Unit II

File Handling
File handling in Python is a powerful and versatile tool that can be used to perform a wide
range of operations.

Python too supports file handling and allows users to handle files i.e., to read and write files,
along with many other file handling options, to operate on files.

Python treats files differently as text or binary and this is important. Each line of code includes
a sequence of characters and they form a text file. Each line of a file is terminated with a
special character, called the EOL or End of Line characters like comma {,} or newline
character. It ends the current line and tells the interpreter a new one has begun.

Advantages of File Handling

 Versatility: File handling in Python allows you to perform a wide range of operations, such
as creating, reading, writing, appending, renaming, and deleting files.
 Flexibility: File handling in Python is highly flexible, as it allows you to work with
different file types (e.g. text files, binary files, CSV files, etc.), and to perform different
operations on files (e.g. read, write, append, etc.).
 User–friendly: Python provides a user-friendly interface for file handling, making it easy
to create, read, and manipulate files.
 Cross-platform: Python file-handling functions work across different platforms (e.g.
Windows, Mac, Linux), allowing for seamless integration and compatibility.

Disadvantages of File Handling

 Error-prone: File handling operations in Python can be prone to errors, especially if the
code is not carefully written or if there are issues with the file system (e.g. file permissions,
file locks, etc.).
 Security risks: File handling in Python can also pose security risks, especially if the
program accepts user input that can be used to access or modify sensitive files on the
system.
 Complexity: File handling in Python can be complex, especially when working with more
advanced file formats or operations. Careful attention must be paid to the code to ensure
that files are handled properly and securely.
 Performance: File handling operations in Python can be slower than other programming
languages, especially when dealing with large files or performing complex operations.
Let us consider the following “abc.txt” file as an example shown below

Eg: abc.txt

Hello World
Good Morning
123456789

Working of open() Function in Python

Before performing any operation on the file like reading or writing, first, we have to open that
file. For this, we should use Python’s inbuilt function open() but at the time of opening, we
have to specify the mode, which represents the purpose of the opening file.

Syntax: f=open(filename, mode)

Below are the following modes are supported:

1. r: open an existing file for a read operation.
2. w: open an existing file for a write operation. If the file already contains some data then it
will be overridden but if the file is not present then it creates the file as well.
3. a: open an existing file for append operation. It won’t override existing data.
4. r+: To read and write data into the file. The previous data in the file will be overridden.
5. w+: To write and read data. It will override existing data.
6. a+: To append and read data from the file. It won’t override existing data.

Working in Read mode

There is more than one way to read a file in Python. Let us see how we can read the content of
a file in read mode.

Example 1: The open command will open the file in the read mode and the for loop will print
each line present in the file.

# a file named "abc.txt", will be opened with the reading mode.

file = open('abc.txt', 'r')

# This will print every line one by one in the file

for each in file:
print (each)

Output
Hello World
Good Morning
123456789
Example 2: In this example, we will extract a string that contains all characters in the file then
we can use file.read().

# Python code to illustrate read() mode

file = open("abc.txt", "r")
print (file.read())

Example 3: In this example, we will see how we can read a file using the with statement.

# Python code to illustrate with()

with open("abc.txt") as file:
data = file.read()

print(data)

Example 4: Another way to read a file is to call a certain number of characters like in the
following code the interpreter will read the first five characters of stored data and return it as a
string:

# Python code to illustrate read() mode character wise

file = open("abc.txt", "r")
print (file.read(5))

Output
Hello

Example 5:
We can also split lines while reading files in Python. The split() function splits the variable
when space is encountered. You can also split using any characters as you wish.

# Python code to illustrate split() function

with open("abc.txt", "r") as file:
data = file.readlines()
for line in data:
word = line.split()
print (word)

Output
['Hello', 'world']
['Good' , ‘Morning’]
['123456789']
 Creating a File using the write() Function
Just like reading a file in Python, there are a number of ways to write in a file in Python .
Let us see how we can write the content of a file using the write() function in Python.

Working in Write Mode

Let’s see how to create a file and how the write mode works.

Example 1: In this example, we will see how the write mode and the write() function is used
to write in a file. The close() command terminates all the resources in use and frees the system
of this particular program.

# Python code to create a file

file = open('abc.txt','w')
file.write("This is the write command")
file.write("It allows us to write in a particular file")
file.close()

Output:
This is the write commandIt allows us to write in a particular file

Example 2: We can also use the written statement along with the with() function.

# Python code to illustrate with() alongwith write()

with open("abc.txt", "w") as f:
f.write("Hello World!!!")

Working of Append Mode

Eg:
# Python code to illustrate append() mode
file = open('abc.txt', 'a')
file.write("This will add this line")
file.close()

Open a File in Python

Python provides inbuilt functions for creating, writing, and reading files. There are two types
of files that can be handled in Python, normal text files and binary files (written in binary
language, 0s, and 1s).
 Text files: In this type of file, each line of text is terminated with a special character
called EOL (End of Line), which is the new line character (‘\n’) in Python by default. In
the case of CSV(Comma Separated Files, the EOF is a comma by default).
 Binary files: In this type of file, there is no terminator for a line, and the data is stored after
converting it into machine-understandable binary language, i.e., 0 and 1 format.
Opening a File in Python

Opening a file refers to getting the file ready either for reading or for writing. This can be done
using the open() function. This function returns a file object and takes two arguments, one that
accepts the file name and another that accepts the mode (Access Mode). Now, the question
arises what is the access mode? Access modes govern the type of operations possible in the
opened file. It refers to how the file will be used once it’s opened. These modes also define the
location of the File Handle in the file. The file handle is like a cursor, which defines where
the data has to be read or written in the file. There are 6 access modes in Python.

Mode Description

‘r’ Open text file for reading. Raises an I/O error if the file does not exist.

‘r+’ Open the file for reading and writing. Raises an I/O error if the file does not exist.

Open the file for writing. Truncates the file if it already exists. Creates a new file if it
‘w’
does not exist.

Open the file for reading and writing. Truncates the file if it already exists. Creates a
‘w+’
new file if it does not exist.

Open the file for writing. The data being written will be inserted at the end of the
‘a’
file. Creates a new file if it does not exist.

Open the file for reading and writing. The data being written will be inserted at the
‘a+’
end of the file. Creates a new file if it does not exist.

Open the file for reading in binary format. Raises an I/O error if the file does not
‘rb’
exist.

Open the file for reading and writing in binary format. Raises an I/O error if the file
‘rb+’
does not exist.

Open the file for writing in binary format. Truncates the file if it already exists.
‘wb’
Creates a new file if it does not exist.

Open the file for reading and writing in binary format. Truncates the file if it already
‘wb+’
exists. Creates a new file if it does not exist.
Mode Description

Open the file for appending in binary format. Inserts data at the end of the file.
‘ab’
Creates a new file if it does not exist.

Open the file for reading and appending in binary format. Inserts data at the end of
‘ab+’
the file. Creates a new file if it does not exist.

Syntax: File_object = open(r"File_Name", "Access_Mode")

Note: The file should exist in the same directory as the Python script, otherwise full address of
the file should be written. If the file is not exist, then an error is generated, that the file does not
exist.

Opening a file in read mode in Python

In this example, we are reading data from a Txt file (myfile.txt). We have used read() to read
the data.

# Python program to demonstrate

# opening a file

# Open function to open the file "myfile.txt"

# (same directory) in read mode and store
# it's reference in the variable file1

File1 = open("myfile.txt")

# Reading from file

print(file1.read())

file1.close()

Output
Welcome to my class
Note: In the above example, we haven’t provided the access mode. By default, the open()
function will open the file in read mode, if no parameter is provided.
Adding data to the existing file in Python

If you want to add more data to an already created file, then the access mode should be ‘a’
which is append mode, if we select ‘w’ mode then the existing text will be overwritten by the
new data.

# Python program to demonstrate

# opening a file

# Open function to open the file "myfile.txt"

# (same directory) in append mode and store
# it's reference in the variable file1
file1 = open("myfile.txt" , "a" )

# Writing to file
file1.write("\nWriting to file:)" )

# Closing file
file1.close()

Output
Welcome to my class
Writing to file

Opening a file with write mode in Python

In this example, we are using ‘w+’ which deleted the content from the file, writes some data,
and moves the file pointer to the beginning.

# Open a file for writing and reading

file = open('test.txt', 'w+')

# Write some data to the file

file.write('Hello, world!')

# Move the file pointer back to the beginning of the file

file.seek(0)

# Read the data from the file

data = file.read()

# Print the data to the console

print(data)

# Close the file when you're done

file.close()

Output
Hello, world!

Reading Data from File Using Line By Line Using readline()

The readline() method in Python is used to read a single line from a file that has been opened
for reading. When readline() is used in the code, it reads the next line of the file and returns it
as a string.
In this example, we are reading data line by line from a file named test.txt and printing it into
the terminal.
# Open a file for reading
file = open('test.txt', 'r')

# Read the first line of the file

line = file.readline()

# Loop through the rest of the file and print each line
while line:
print(line)
line = file.readline()

# Close the file when you're done

file.close()

Output
Welcome to class 1
Welcome to class 2
Welcome to class 3

How to read from a file in Python

Different access modes for reading a file are –
1. Read Only (‘r’) : Open text file for reading. The handle is positioned at the beginning of
the file. If the file does not exists, raises I/O error. This is also the default mode in which
file is opened.
2. Read and Write (‘r+’) : Open the file for reading and writing. The handle is positioned at
the beginning of the file. Raises I/O error if the file does not exists.
3. Append and Read (‘a+’) : Open the file for reading and writing. The file is created if it
does not exist. The handle is positioned at the end of the file. The data being written will be
inserted at the end, after the existing data.
 Opening a File
It is done using the open() function. No module is required to be imported for this function.
Syntax: File_object = open(r"File_Name", "Access_Mode")
The file should exist in the same directory as the python program file else, full address of the
file should be written on place of filename.
Note: The r is placed before filename to prevent the characters in filename string to be treated
as special character. For example, if there is \temp in the file address, then \t is treated as the
tab character and error is raised of invalid address. The r makes the string raw, that is, it tells
that the string is without any special characters. The r can be ignored if the file is in same
directory and address is not being placed.

# Open function to open the file "MyFile1.txt"

# (same directory) in read mode and
file1 = open("MyFile.txt", "r")

# store its reference in the variable file1

# and "MyFile2.txt" in D:\Text in file2
file2 = open(r"D:\Text\MyFile2.txt", "r+")

Here, file1 is created as object for MyFile1 and file2 as object for MyFile2.

Closing a file
close() function closes the file and frees the memory space acquired by that file. It is used at
the time when the file is no longer needed or if it is to be opened in a different file mode.
Syntax: File_object.close()

# Opening and Closing a file "MyFile.txt"

# for object name file1.
file1 = open("MyFile.txt", "r")
file1.close()

Reading from a file

There are three ways to read data from a text file.
 read() : Returns the read bytes in form of a string. Reads n bytes, if no n specified, reads
the entire file.
File_object.read([n])
 readline() : Reads a line of the file and returns in form of a string. For specified n, reads at
most n bytes. However, does not reads more than one line, even if n exceeds the length of
the line.
File_object.readline([n])
 readlines() : Reads all the lines and return them as each line a string element in a list.
File_object.readlines()

Note: ‘\n’ is treated as a special character of two bytes.

With statement
with statement in Python is used in exception handling to make the code cleaner and much
more readable. It simplifies the management of common resources like file streams. Unlike the
above implementations, there is no need to call file.close() when using with statement. The
with statement itself ensures proper acquisition and release of resources.
Syntax: with open filename as file:
# Program to show various ways to
# read data from a file.

L = ["This is Delhi \n", "This is Paris \n", "This is London \

n"]

# Creating a file
with open("myfile.txt", "w") as file1:
# Writing data to a file
file1.write("Hello \n")
file1.writelines(L)
file1.close() # to change file access modes

with open("myfile.txt", "r+") as file1:

# Reading from a file
print(file1.read())

Output:
Hello
This is Delhi
This is Paris
This is London

Writing to file in Python

Python provides inbuilt functions for creating, writing and reading files. There are two types of
files that can be handled in python, normal text files and binary files (written in binary
language, 0s and 1s).
 Text files: In this type of file, Each line of text is terminated with a special character called
EOL (End of Line), which is the new line character (‘\n’) in python by default.
 Binary files: In this type of file, there is no terminator for a line and the data is stored after
converting it into machine-understandable binary language.
Access mode
Access modes govern the type of operations possible in the opened file. It refers to how the file
will be used once it’s opened. These modes also define the location of the File Handle in the
file. File handle is like a cursor, which defines from where the data has to be read or written in
the file. Different access modes for reading a file are –
1. Write Only (‘w’) : Open the file for writing. For an existing file, the data is truncated and
over-written. The handle is positioned at the beginning of the file. Creates the file if the file
does not exist.
2. Write and Read (‘w+’) : Open the file for reading and writing. For an existing file, data is
truncated and over-written. The handle is positioned at the beginning of the file.
3. Append Only (‘a’) : Open the file for writing. The file is created if it does not exist. The
handle is positioned at the end of the file. The data being written will be inserted at the end,
after the existing data.

Opening a File
It is done using the open() function. No module is required to be imported for this function.

Syntax: File_object = open(r"File_Name", "Access_Mode")

The file should exist in the same directory as the python program file else, full address of the
file should be written on place of filename.
Note: The r is placed before filename to prevent the characters in filename string to be treated
as special character. For example, if there is \temp in the file address, then \t is treated as the
tab character and error is raised of invalid address. The r makes the string raw, that is, it tells
that the string is without any special characters. The r can be ignored if the file is in same
directory and address is not being placed.

# Open function to open the file "MyFile1.txt"

# (same directory) in read mode and
file1 = open("MyFile.txt", "w")

# store its reference in the variable file1

# and "MyFile2.txt" in D:\Text in file2
file2 = open(r"D:\Text\MyFile2.txt", "w+")

Here, file1 is created as object for MyFile1 and file2 as object for MyFile2.

Closing a file
close() function closes the file and frees the memory space acquired by that file. It is used at
the time when the file is no longer needed or if it is to be opened in a different file mode.

Syntax: File_object.close()
# Opening and Closing a file "MyFile.txt"
# for object name file1.
file1 = open("MyFile.txt", "w")
file1.close()

Writing to file
There are two ways to write in a file.
1. write() : Inserts the string str1 in a single line in the text file.
File_object.write(str1)
1. writelines() : For a list of string elements, each string is inserted in the text file. Used to
insert multiple strings at a single time.
File_object.writelines(L) for L = [str1, str2, str3]
Note: ‘\n’ is treated as a special character of two bytes.

Example
# Python program to demonstrate
# writing to file

# Opening a file
file1 = open('myfile.txt', 'w')
L = ["This is Delhi \n", "This is Paris \n", "This is London \
n"]
s = "Hello\n"

# Writing a string to file

file1.write(s)

# Writing multiple strings

# at a time
file1.writelines(L)

# Closing file
file1.close()

# Checking if the data is

# written to file or not
file1 = open('myfile.txt', 'r')
print(file1.read())
file1.close()

Output
Hello
This is Delhi
This is Paris
This is London

Appending to a file
When the file is opened in append mode, the handle is positioned at the end of the file. The
data being written will be inserted at the end, after the existing data. Let’s see the below
example to clarify the difference between write mode and append mode.
# Python program to illustrate
# Append vs write mode
file1 = open("myfile.txt", "w")
L = ["This is Delhi \n", "This is Paris \n", "This is London \
n"]
file1.writelines(L)
file1.close()

# Append-adds at last
file1 = open("myfile.txt", "a") # append mode
file1.write("Today \n")
file1.close()

file1 = open("myfile.txt", "r")

print("Output of Readlines after appending")
print(file1.read())
print()
file1.close()

# Write-Overwrites
file1 = open("myfile.txt", "w") # write mode
file1.write("Tomorrow \n")
file1.close()

file1 = open("myfile.txt", "r")

print("Output of Readlines after writing")
print(file1.read())
print()
file1.close()

Output
Output of Readlines after appending
This is Delhi
This is Paris
This is London
Today
With statement
with statement in Python is used in exception handling to make the code cleaner and much
more readable. It simplifies the management of common resources like file streams. Unlike the
above implementations, there is no need to call file.close() when using with statement. The
with statement itself ensures proper acquisition and release of resources.

Syntax: with open filename as file:

# Program to show various ways to

# write data to a file using with statement

L = ["This is Delhi \n", "This is Paris \n", "This is London \

n"]

# Writing to file
with open("myfile.txt", "w") as file1:
# Writing data to a file
file1.write("Hello \n")
file1.writelines(L)

# Reading from file

with open("myfile.txt", "r+") as file1:
# Reading form a file
print(file1.read())

Output
Hello
This is Delhi
This is Paris
This is London

using for statement:

steps:
To write to a file in Python using a for statement, you can follow these steps:
Open the file using the open() function with the appropriate mode (‘w’ for writing).
Use the for statement to loop over the data you want to write to the file.
Use the file object’s write() method to write the data to the file.
Close the file using the file object’s close() method.
In this example, the file is opened for writing using the with open(‘file.txt’, ‘w’) as f statement.
The data to be written is stored in a list called data. The for statement is used to loop over each
line of data in the list. The f.write(line + ‘\n’) statement writes each line of data to the file with
a newline character (\n) at the end. Finally, the file is automatically closed when the with block
ends.
# Open the file for writing
with open('file.txt', 'w') as f:
# Define the data to be written
data = ['This is the first line', 'This is the second line',
'This is the third line']
# Use a for loop to write each line of data to the file
for line in data:
f.write(line + '\n')
# Optionally, print the data as it is written to the
file
print(line)
# The file is automatically closed when the 'with' block ends

Output
This is the first line
This is the second line
This is the third line

Approach:
The code opens a file called file.txt in write mode using a with block to ensure the file is
properly closed when the block ends. It defines a list of strings called data that represents the
lines to be written to the file. The code then uses a for loop to iterate through each string in
data, and writes each string to the file using the write() method. The code appends a newline
character to each string to ensure that each string is written on a new line in the file. The code
optionally prints each string as it is written to the file.
 Functions
Collection of several statements with a given name for some specific task.

Why do we need functions?

Reusability: We can call functions many number of times.

Flexibility: Can call functions in any order whwnever required.

Arguments & Returns: can take input as arguments & returns the result as values.

This is what the simplest function definition looks like:

def function_name():
function_body

 It always starts with the keyword def (for define)

 Next after def goes the name of the function (the rules for naming functions are exactly
the same as for naming variables)
 After the function name, there's a place for a pair of parentheses (they contain nothing
here, but that will change soon)
 The line has to be ended with a colon;
 The line directly after def begins the function body ‒ a couple (at least one) of
necessarily nested instructions, which will be executed every time the function is
invoked; note: the function ends where the nesting ends, so you have to be careful.

Eg:
def message():
print("Enter a value: ")

Eg:
def message():
print("Enter a value: ")

print("We start here.")

print("We end here.")

Output
We start here.
We end here.
This means that Python reads the function's definitions and remembers them, but won't launch
any of them without your permission.

Eg: we've inserted the function's invocation between the start and end messages:
def message():
print("Enter a value: ")

print("We start here.")

message()
print("We end here.")

Output
We start here.
Enter a value:
We end here.

How functions work

 when you invoke a function, Python remembers the place where it happened
and jumps into the invoked function;
 the body of the function is then executed;
 reaching the end of the function forces Python to return to the place directly after the
point of invocation.

There are two, very important, catches. Here's the first of them:

1. You mustn't invoke a function which is not known at the moment of

invocation.

Remember - Python reads your code from top to bottom. It's not going to look ahead in
order to find a function you forgot to put in the right place ("right" means "before
invocation".)

We've inserted an error into this code ‒ can you see the difference?

Eg:

print("We start here.")

message()
print("We end here.")

def message():
print("Enter a value: ")
Output

message()
NameError: name 'message' is not defined

Note; Don't try to force Python to look for functions you didn't deliver at the right time.

The second catch sounds a little simpler:

2. You mustn't have a function and a variable of the same name.

The following snippet is erroneous:

Eg:
def message():
print("Enter a value: ")
message=1

Output

Assigning a value to the name message causes Python to forget its previous role. The function
named message becomes unavailable.

Eg:

def message():
print("Enter a value: ")

message()
a = int(input())
message()
b = int(input())
message()
c = int(input())

Output

Enter a value:
10
Enter a value:
20
Enter a value:
23
How functions communicate with their environment
Parameterized functions

A parameter is actually a variable, but there are two important factors that make parameters
different and special:

 parameters exist only inside functions in which they have been defined, and the only
place where the parameter can be defined is a space between a pair of parentheses in
the def statement;
 assigning a value to the parameter is done at the time of the function's invocation, by
specifying the corresponding argument.

Syntax:

def function(parameter):

###

Eg:
def message(number):
print("Enter a number:", number)

message() # message(1)

Output
TypeError: message() missing 1 required positional argument:
'number'

It's legal, and possible, to have a variable named the same as a function's parameter.

The snippet illustrates the phenomenon:

def message(number)
print("Enter a number:", number)
number=1234

message(1)
print(number)

A situation like this activates a mechanism called shadowing:

 parameter x shadows any variable of the same name, but...

 ... only inside the function defining the parameter.
The parameter named number is a completely different entity from the variable named number.

Output
1
1234

A function can have as many parameters as you want, but the more parameters you have, the
harder it is to memorize their roles and purposes.

Let's modify the function ‒ it has two parameters now:

Eg:
def message(what, number):
print("Enter", what, "number", number)

message("telephone", 11)
message("price", 5)
message("number", "number")

Output
Enter telephone number 11
Enter price number 5
Enter number number number

Positional parameter passing

A technique which assigns the i th (first, second, and so on) argument to the i th (first, second, and
so on) function parameter is called positional parameter passing, while arguments passed in this
way are named positional arguments.

Eg:
def my_function(a, b, c):
print(a, b, c)

my_function(1, 2, 3)

Output
1 2 3

Eg:
def introduction(first_name, last_name):
print("Hello, my name is", first_name, last_name)
introduction("Luke", "Skywalker")
introduction("Jesse", "Quick")
introduction("Clark", "Kent")

Output
Hello, my name is Luke Skywalker
Hello, my name is Jesse Quick
Hello, my name is Clark Kent

Keyword argument passing

Python offers another convention for passing arguments, where the meaning of the argument is
dictated by its name, not by its position ‒ it's called keyword argument passing.

Eg:

def introduction(first_name, last_name):

print("Hello, my name is", first_name, last_name)

introduction(first_name = "James", last_name = "Bond")

introduction(last_name = "Skywalker", first_name = "Luke")

Output
Hello, my name is James Bond
Hello, my name is Luke Skywalker
Note: But you shouldn’t use non-existant parameter name.

Eg:
def introduction(first_name, last_name):
print("Hello, my name is", first_name, last_name)

introduction(surname="Skywalker", first_name="Luke")

Output
TypeError: introduction() got an unexpected keyword
argument 'surname'
Mixing positional and keyword arguments
You can mix both styles if you want ‒ there is only one unbreakable rule: you have to
put positional arguments before keyword arguments.

Eg:
def adding(a, b, c):
print(a, "+", b, "+", c, "=", a + b + c)
adding(1, 2, 3)

Output
1 + 2 + 3 = 6

It was ‒ as you may suspect ‒ a pure example of positional argument passing.

You can replace such an invocation with a purely keyword variant, like this:
adding(c = 1, a = 2, b = 3)
Our program will output a line like this:
2+3+1=6

Let's try to mix both styles now.

Look at the function invocation below:
adding(3, c = 1, b = 2)

Let's analyze it:

the argument (3) for the a parameter is passed using the positional way;
the arguments for c and b are specified as keyword ones.
This is what you'll see in the console: 3 + 2 + 1 = 6

Be careful, and beware of mistakes. If you try to pass more than one value to one argument, all
you'll get is a runtime error.

Look at the invocation below - it seems that we've tried to set a twice:

adding(3, a = 1, b = 2)

Python's response: TypeError: adding() got multiple values for argument 'a'
Parametrized functions – more details

It happens at times that a particular parameter's values are in use more often than others. Such
arguments may have their default (predefined) values taken into consideration when their
corresponding arguments have been omitted.

Eg:

def introduction(first_name, last_name="Smith"):

print("Hello, my name is", first_name, last_name)
introduction("James", "Doe")
introduction("Henry")
introduction(first_name="William")

Output
Hello, my name is James Doe
Hello, my name is Henry Smith
Hello, my name is William Smith

Eg;
def introduction(first_name="John", last_name="Smith"):
print("Hello, my name is", first_name, last_name)
introduction()
introduction(last_name="Hopkins")

Output
John Smith
John Hopkins
 Returning a result from a function
Effects and results: the return instruction

To get functions to return a value (but not only for this purpose) you use the return instruction.

Note: it's a Python keyword.

The return instruction has two different variants ‒ let's consider them separately.

return without an expression

Eg:

def happy_new_year(wishes = True):

print("Three...")
print("Two...")
print("One...")
if not wishes:
return
print("Happy New Year!")
happy_new_year()

Output

Three...
Two...
One...
Happy New Year!

Providing False as an argument:

happy_new_year(False)

the return instruction will cause its termination just before the wishes ‒ this is the updated output:

Three...
Two...
One...
return with an expression

The second return variant is extended with an expression:

def function():
return expression

There are two consequences of using it:

 it causes the immediate termination of the function's execution (nothing new

compared to the first variant)
 moreover, the function will evaluate the expression's value and will return it (hence
the name once again) as the function's result.

Eg:

def boring_function():
return 123

x = boring_function()

print("The boring_function has returned its result. It's:", x)

Output

The boring_function has returned its result. It's: 123

The return instruction, enriched with the expression (the expression is very simple here),
"transports" the expression's value to the place where the function has been invoked.

The result may be freely used here, e.g., to be assigned to a variable.

If the function returns a value, and we ignore it

Eg:

def boring_function():
print("'Boredom Mode' ON.")
return 123

print("This lesson is interesting!")

boring_function()
print("This lesson is boring...")
Output

This lesson is interesting!

'Boredom Mode' ON.
This lesson is boring...

A few words about None

Its data doesn't represent any reasonable value ‒ actually, it's not a value at all; hence, it mustn't
take part in any expressions.

For example, a snippet like this:

print(None + 2)

will cause a runtime error, described by the following

TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
Note: None is a keyword.
There are only two kinds of circumstances when None can be safely used:
when you assign it to a variable (or return it as a function's result)
when you compare it with a variable to diagnose its internal state.

Just like here:

value = None
if value is None:
print("Sorry, you don't carry any value")

Don't forget this: if a function doesn't return a certain value using a return expression clause, it is
assumed that it implicitly returns None.

Let's test it.

Take a look at the code in the editor.

def strange_function(n):
if(n%2==0):
return True
print(strange_function(2))
print(strange_function(1))

Output

True
None
 Scopes in Python
Here you will learn about scopes in Python, and the global keyword. By the end of the section
you will be able to distinguish between local and global variables, and know how to utilize the
mechanism of namespaces in your programs.

Functions and scopes

The scope of a name (e.g., a variable name) is the part of a code where the name is properly
recognizable.

For example, the scope of a function's parameter is the function itself. The parameter is
inaccessible outside the function.

Eg:
def scope_test():
x = 123
scope_test()
print(x)

Output
Traceback (most recent call last):
File "main.py", line 6, in <module>
print(x)
NameError: name 'x' is not defined

Let's start by checking whether or not a variable created outside any function is visible inside the
functions. In other words, does a variable's name propagate into a function's body?

Eg:
def my_function():
print("Do I know that variable?", var)

var = 1
my_function()
print(var)

Output
Do I know that variable? 1
1

The answer is: a variable existing outside a function has scope inside the function's body.

This rule has a very important exception.

Let's make a small change to the code:
def my_function():
var=2
print("Do I know that variable?", var)

var=1
my_function()
print(var)

Output

Do I know that variable? 2

1

What's happened?
the var variable created inside the function is not the same as when defined outside it ‒ it seems
that there two different variables of the same name;

moreover, the function's variable shadows the variable coming from the outside world.

Note: A variable existing outside a function has scope inside the function's body, excluding
those which define a variable of the same name.

It also means that the scope of a variable existing outside a function is supported only when
getting its value (reading). Assigning a value forces the creation of the function's own variable.

Functions and scopes: the global keyword

You should now have arrived at the following question: does this mean that a function is not able
to modify a variable defined outside it? This would create a lot of discomfort.

Fortunately, the answer is no.

There's a special Python method which can extend a variable's scope in a way which includes the
function's body (even if you want not only to read the values, but also to modify them).

Such an effect is caused by a keyword named global:

global name
global name1, name2, ...

Using this keyword inside a function with the name (or names separated with commas) of a
variable (or variables), forces Python to refrain from creating a new variable inside the function ‒
the one accessible from outside will be used instead.
In other words, this name becomes global (it has global scope, and it doesn't matter whether it's
the subject of read or assign).

Eg:
def my_function():
global var
var = 2
print("Do I know that variable?", var)

var = 1
my_function()
print(var)

Output
Do I know that variable? 2
2

How the function interacts with its arguments

Now let's find out how the function interacts with its arguments.
As you can see, the function changes the value of its parameter. Does the change affect the
argument?

Eg:
def my_function(n):
print("I got", n)
n += 1
print("I have", n)

var = 1
my_function(var)
print(var)

Output
I got 1
I have 2
1

The conclusion is obvious ‒ changing the parameter's value doesn't propagate outside the
function (in any case, not when the variable is a scalar, like in the example).
This also means that a function receives the argument's value, not the argument itself. This is
true for scalars.
Eg:
def my_function(my_list_1):
print("Print #1:", my_list_1)
printprint("Print #2:", my_list_2)
my_list_1 = [0, 1]
print("Print #3:", my_list_1)
print("Print #4:", my_list_2)

my_list_2 = [2, 3]
my_function(my_list_2)
print("Print #5:", my_list_2)

Output
Print #1: [2, 3]
Print #2: [2, 3]
Print #3: [0, 1]
Print #4: [2, 3]
Print #5: [2, 3]

Note : 1. A variable that exists outside a function has scope inside the function body unless the
function defines a variable of the same name .

2. A variable that exists inside a function has scope inside the function body.

Exceptions
Errors in data vs. errors in code

Dealing with programming errors has (at least) two sides. The one appears when you get into
trouble because your – apparently correct – code is fed with bad data. For example, you expect
the code will input an integer value, but your careless user enters some random letters instead.

The other side of dealing with programming errors reveals itself when undesirable code behavior
is caused by mistakes you made when you were writing your program. This kind of error is
commonly called a “bug”, which is a manifestation of a well-established belief that if a program
works badly, it must be caused by malicious bugs which live inside the computer hardware and
cause short circuits or other interference.

When data is not what it should be

Let's write a piece code – it will read a natural number (a non-negative integer) and print its
reciprocal. In this way, 2 will turn into 0.5 (1/2) and 4 into 0.25 (1/4). Here’s the program:

value = int(input('Enter a natural number: '))

print('The reciprocal of', value, 'is', 1/value)

Output
Enter a natural number: 4
The reciprocal of 4 is 0.25

Entering data that is not an integer (which also includes entering nothing at all) will completely
ruin the program execution. This is what the user will see:

Enter a natural number: e

Traceback (most recent call last):
value = int(input('Enter a natural number: '))
ValueError: invalid literal for int() with base 10: 'e'

The first word in the line is the name of the exception which causes your code to stop.
It's ValueError here. The rest of the line is just a brief explanation which more precisely specifies
the cause of the occurred exception.

The try-except branch

"It's better to handle an error when it happens than to try to avoid it". This is where
the exception comes on the scene.

try:
# It's a place where
# you can do something
# without asking for permission.

except:
# It's a spot dedicated to
# solemnly begging for forgiveness.

 first, starting with the try keyword – this is the place where you put the code you suspect
is risky and may be terminated in case of error;
Note: this kind of error is called an exception, while the exception occurrence is
called raising – we can say that an exception is (or was) raised;
 second, the part of the code starting with the except keyword is designed to handle the
exception; it's up to you what you want to do here: you can clean up the mess or you can
just sweep the problem under the carpet.

Let's rewrite the above code :

try:
value = int(input('Enter a natural number: '))
print('The reciprocal of', value, 'is', 1/value)
except:
print('I do not know what to do.')

Output
Enter a natural number: r
I do not know what to do.

Let us summarize what we talked about:

 any part of the code placed between try and except is executed in a very special way –
any error which occurs here won't terminate program execution. Instead, the control will
immediately jump to the first line situated after the except keyword, and no other part of
the try branch is executed;
 the code in the except branch is activated only when an exception has been encountered
inside the try block. There is no way to get there by any other means;
  when either the try block or the except block is executed successfully, the control returns
to the normal path of execution, and any code located beyond in the source file is
executed as if nothing happened.

How to deal with more than one exception

Two exceptions after one try

As you can see, we've just introduced the second except branch. This is not the only difference –
note that both branches have exception names specified. In this variant, each of the expected
exceptions has its own way of handling the error, but it must be emphasized that only one of all
branches can intercept the control – if one of the branches is executed, all the other branches
remain idle.

Eg:

try:
value = int(input('Enter a natural number: '))
print('The reciprocal of', value, 'is', 1/value)

except ValueError:
print('I do not know what to do.')

except ZeroDivisionError:
print('Division by zero is not allowed in our Universe.')

Output
Enter a natural number: 0
Division by zero is not allowed in our Universe.

Enter a natural number: y

I do not know what to do.

Additionally, the number of except branches is not limited – you can specify as many or as few
of them as you need, but don't forget that none of the exceptions can be specified more than
once.
The default exception and how to use it

Eg:

try:
value = int(input('Enter a natural number: '))
print('The reciprocal of', value, 'is', 1/value)

except ValueError:
print('I do not know what to do.')

except ZeroDivisionError:
print('Division by zero is not allowed in our Universe.')

except:
print('Something strange has happened here... Sorry!')

We've added a third except branch, but this time it has no exception name specified – we can say
it's anonymous or (what is closer to its actual role) it's the default. You can expect that when an
exception is raised and there is no except branch dedicated to this exception, it will be handled
by the default branch.

Note: The default except branch must be the last except branch. Always!

Some useful exceptions

Let’s discuss in more detail some useful (or rather, the most common) exceptions you may
experience.

ZeroDivisionError

This appears when you try to force Python to perform any operation which provokes division in
which the divider is zero, or is indistinguishable from zero.

Note that there is more than one Python operator which may cause this exception to raise.

Yes, they are: /, //, and %.

ValueError

Expect this exception when you're dealing with values which may be inappropriately used in
some context. In general, this exception is raised when a function (like int() or float()) receives
an argument of a proper type, but its value is unacceptable.
TypeError

This exception shows up when you try to apply a data whose type cannot be accepted in the
current context. Look at the example:

short_list = [1]
one_value = short_list[0.5]

You're not allowed to use a float value as a list index (the same rule applies to tuples,
too). TypeError is an adequate name to describe the problem, and an adequate exception to raise.

AttributeError

This exception arrives – among other occasions – when you try to activate a method which
doesn't exist in an item you're dealing with. For example:

short_list = [1]
short_list.append(2)
short_list.depend(3)

The third line of our example attempts to make use of a method which isn’t contained in the lists.
This is the place where AttributeError is raised.
 Introduction to modules in Python
What is a module?

Computer code has a tendency to grow. We can say that code that doesn't grow is probably
completely unusable or abandoned. A real, wanted, and widely used code develops continuously,
as both users' demands and users' expectations develop in their own rhythms.

A code which is not able to respond to users' needs will be forgotten quickly, and instantly
replaced with a new, better, and more flexible code. Be prepared for this, and never think that
any of your programs is eventually completed. The completion is a transition state and usually
passes quickly, after the first bug report. Python itself is a good example how the rule acts.

Growing code is in fact a growing problem. A larger code always means tougher maintenance.
Searching for bugs is always easier where the code is smaller (just as finding a mechanical
breakage is simpler when the machinery is simpler and smaller).

Moreover, when the code being created is expected to be really big (you can use a total number
of source lines as a useful, but not very accurate, measure of a code's size) you may want (or
rather, you will be forced) to divide it into many parts, implemented in parallel by a few, a
dozen, several dozen, or even several hundred individual developers.

Of course, this cannot be done using one large source file, which is edited by all programmers at
the same time. This will surely lead to a spectacular disaster.

If you want such a software project to be completed successfully, you have to have the means
allowing you to:

 divide all the tasks among the developers;

 join all the created parts into one working whole.

For example, a certain project can be divided into two main parts:

 the user interface (the part that communicates with the user using widgets and a graphical
screen)
 the logic (the part processing data and producing results)

Each of these parts can be (most likely) divided into smaller ones, and so on. Such a process is
often called decomposition.

For example, if you were asked to arrange a wedding, you wouldn't do everything yourself - you
would find a number of professionals and split the task between them all.

How do you divide a piece of software into separate but cooperating parts? This is the
question. Modules are the answer.
How to make use of a module?
So what is a module? The Python Tutorial defines it as a file containing Python definitions and
statements, which can be later imported and used when necessary.

The handling of modules consists of two different issues:

the first (probably the most common) happens when you want to use an already existing module,
written by someone else, or created by yourself during your work on some complex project - in
this case you are the module's user;

the second occurs when you want to create a brand new module, either for your own use, or to
make other programmers' lives easier - you are the module's supplier.

Let's discuss them separately.

First of all, a module is identified by its name. If you want to use any module, you need to know
the name. A (rather large) number of modules is delivered together with Python itself. You can
think of them as a kind of "Python extra equipment".

All these modules, along with the built-in functions, form the Python standard library - a special
sort of library where modules play the roles of books (we can even say that folders play the roles
of shelves)

Each module consists of entities (like a book consists of chapters). These entities can be
functions, variables, constants, classes, and objects. If you know how to access a particular
module, you can make use of any of the entities it stores.

Let's start the discussion with one of the most frequently used modules, named math. Its name
speaks for itself - the module contains a rich collection of entities (not only functions) which
enable a programmer to effectively implement calculations demanding the use of mathematical
functions, like sin() or log().

Importing a module
To make a module usable, you must import it (think of it like of taking a book off the shelf).
Importing a module is done by an instruction named import. Note: import is also a keyword
(with all the consequences of this fact).

Let's assume that you want to use two entities provided by the math module:

a symbol (constant) representing a precise (as precise as possible using double floating-point
arithmetic) value of π (although using a Greek letter to name a variable is fully possible in
Python, the symbol is named pi - it's a more convenient solution, especially for that part of the
world which neither has nor is going to use a Greek keyboard)
a function named sin() (the computer equivalent of the mathematical sine function).

Both these entities are available through the math module, but the way in which you can use
them strongly depends on how the import has been done.

The simplest way to import a particular module is to use the import instruction as follows:

import math
The clause contains:

the import keyword;

the name of the module which is subject to import.

The instruction may be located anywhere in your code, but it must be placed before the first use
of any of the module's entities.

If you want to (or have to) import more than one module, you can do it by repeating
the import clause (preferred):

import math import sys

or by listing the modules after the import keyword, like here:

import math, sys

The instruction imports two modules, first the one named math and then the second named sys.
The modules' list may be arbitrarily long.

Namespace
A namespace is a space (understood in a non-physical context) in which some names exist and
the names don't conflict with each other (i.e., there are not two different objects of the same
name). We can say that each social group is a namespace - the group tends to name each of its
members in a unique way (e.g., parents won't give their children the same first names).

Inside a certain namespace, each name must remain unique. This may mean that some names
may disappear when any other entity of an already known name enters the namespace. We'll
show you how it works and how to control it, but first, let's return to imports.

If the module of a specified name exists and is accessible (a module is in fact a Python source
file), Python imports its contents, i.e., all the names defined in the module become known, but
they don't enter your code's namespace.
This means that you can have your own entities named sin or pi and they won't be affected by the
import in any way.

At this point, you may be wondering how to access the pi coming from the math module.

To do this, you have to qualify the pi with the name of its original module.

Importing a module: continued

This first example won't be very advanced - we just want to print the value of sin(½π).

Look at the code in the editor. This is how we test it.

import math
print(math.sin(math.pi/2))

It's simple, you put:

the name of the module (e.g., math)
a dot (i.e., .)
the name of the entity (e.g., pi)

Output

1.0

In the second method, the import's syntax precisely points out which module's entity (or entities)
are acceptable in the code:

from math import pi

The instruction consists of the following elements:

the from keyword;

the name of the module to be (selectively) imported;
the import keyword;
the name or list of names of the entity/entities which are being imported into the namespace.

The instruction has this effect:

the listed entities (and only those ones) are imported from the indicated module;

the names of the imported entities are accessible without qualification.

Note: no other entities are imported. Moreover, you cannot import additional entities using a
qualification - a line like this one:

print(math.e)

will cause an error (e is Euler's number: 2.71828...)

Let's rewrite the previous script to incorporate the new technique.

Here it is:

from math import sin, pi

print(sin(pi/2))

Importing a module: *
In the third method, the import's syntax is a more aggressive form of the previously presented
one:

from module import *

As you can see, the name of an entity (or the list of entities' names) is replaced with a single
asterisk (*).

Such an instruction imports all entities from the indicated module.

Is it convenient? Yes, it is, as it relieves you of the duty of enumerating all the names you need.

Is it unsafe? Yes, it is - unless you know all the names provided by the module, you may not be
able to avoid name conflicts. Treat this as a temporary solution, and try not to use it in regular
code.

The as keyword
If you use the import module variant and you don't like a particular module's name (e.g., it's the
same as one of your already defined entities, so qualification becomes troublesome) you can give
it any name you like - this is called aliasing.

Aliasing causes the module to be identified under a different name than the original. This may
shorten the qualified names, too.

Creating an alias is done together with importing the module, and demands the following form of
the import instruction:

import module as alias

Note: as is a keyword.

Aliasing
If you need to change the word math, you can introduce your own name, just like in the example:

import math as m

print(m.sin(m.pi/2))

Note: after successful execution of an aliased import, the original module name becomes
inaccessible and must not be used.

In turn, when you use the from module import name variant and you need to change the entity's
name, you make an alias for the entity. This will cause the name to be replaced by the alias you
choose.

This is how it can be done:

from module import name as alias

The phrase name as alias can be repeated - use commas to separate the multiplied phrases, like
this:

from module import n as a, m as b, o as c

Selected Python modules (math, random, platform)
Working with standard modules
Before we start going through some standard Python modules, we want to introduce
the dir() function to you. It has nothing to do with the dir command you know from Windows
and Unix consoles, as dir() doesn't show the contents of a disk directory/folder, but there is no
denying that it does something really similar - it is able to reveal all the names provided through
a particular module.

There is one condition: the module has to have been previously imported as a whole (i.e., using
the import module instruction - from module is not enough).

The function returns an alphabetically sorted list containing all entities' names available in the
module identified by a name passed to the function as an argument:

dir(module)

Note: if the module's name has been aliased, you must use the alias, not the original name.

Using the function inside a regular script doesn't make much sense, but it is still possible.

For example, you can run the following code to print the names of all entities within the math
module:

import math

for name in dir(math):

print(name, end="∖t")

Output

__doc__∖t__loader__∖t__name__∖t__package__∖t__spec__∖tacos∖tacosh
∖tasin∖tasinh∖tatan∖tatan2∖tatanh∖tcbrt∖tceil∖tcomb∖tcopysign∖tcos
∖tcosh∖tdegrees∖tdist∖te∖terf∖terfc∖texp∖texp2∖texpm1∖tfabs∖tfacto
rial∖tfloor∖tfmod∖tfrexp∖tfsum∖tgamma∖tgcd∖thypot∖tinf∖tisclose∖ti
sfinite∖tisinf∖tisnan∖tisqrt∖tlcm∖tldexp∖tlgamma∖tlog∖tlog10∖tlog1
p∖tlog2∖tmodf∖tnan∖tnextafter∖tperm∖tpi∖tpow∖tprod∖tradians∖tremai
nder∖tsin∖tsinh∖tsqrt∖ttan∖ttanh∖ttau∖ttrunc∖tulp∖t.

Have you noticed these strange names beginning with __ at the top of the list? We'll tell you
more about them when we talk about the issues related to writing your own modules.
Some of the names might bring back memories from math lessons, and you probably won't have
any problems guessing their meanings.

Using the dir() function inside a code may not seem very useful - usually you want to know a
particular module's contents before you write and run the code.

Fortunately, you can execute the function directly in the Python console (IDLE), without needing
to write and run a separate script.

Selected functions from the math module

Let's start with a quick preview of some of the functions provided by the math module.

We've chosen them arbitrarily, but that doesn't mean that the functions we haven't mentioned
here are any less significant. Dive into the modules' depths yourself - we don't have the space or
the time to talk about everything in detail here.

The first group of the math's functions are connected with trigonometry:

 sin(x) → the sine of x;

 cos(x) → the cosine of x;
 tan(x) → the tangent of x.

All these functions take one argument (an angle measurement expressed in radians) and return
the appropriate result (be careful with tan() - not all arguments are accepted).

Of course, there are also their inversed versions:

 asin(x) → the arcsine of x;

 acos(x) → the arccosine of x;
 atan(x) → the arctangent of x.

These functions take one argument (mind the domains) and return a measure of an angle in
radians.

To effectively operate on angle measurements, the math module provides you with the following
entities:

 pi → a constant with a value that is an approximation of π;

 radians(x) → a function that converts x from degrees to radians;
 degrees(x) → acting in the other direction (from radians to degrees)
Example:

from math import pi, radians, degrees, sin, cos, tan, asin

ad = 90
ar = radians(ad)
ad = degrees(ar)

print(ad == 90.)
print(ar == pi / 2.)
print(sin(ar) / cos(ar) == tan(ar))
print(asin(sin(ar)) == ar)

Output

True
True
True
True

Apart from the circular functions (listed above) the math module also contains a set of
their hyperbolic analogues:

sinh(x) → the hyperbolic sine;

cosh(x) → the hyperbolic cosine;

tanh(x) → the hyperbolic tangent;

asinh(x) → the hyperbolic arcsine;

acosh(x) → the hyperbolic arccosine;

atanh(x) → the hyperbolic arctangent.

Another group of the math's functions is formed by functions which are connected
with exponentiation:

e → a constant with a value that is an approximation of Euler's number (e)

exp(x) → finding the value of ex;

log(x) → the natural logarithm of x

log(x, b) → the logarithm of x to base b

log10(x) → the decimal logarithm of x (more precise than log(x, 10))

log2(x) → the binary logarithm of x (more precise than log(x, 2))

Note: the pow() function:

pow(x, y) → finding the value of xy (mind the domains)

This is a built-in function, and doesn't have to be imported.

Look at the code in the editor. Can you predict its output?

Example:

from math import e, exp, log

print(pow(e, 1) == exp(log(e)))
print(pow(2, 2) == exp(2 * log(2)))
print(log(e, e) == exp(0))

Output

False
True
True

The last group consists of some general-purpose functions like:

 ceil(x) → the ceiling of x (the smallest integer greater than or equal to x)

 floor(x) → the floor of x (the largest integer less than or equal to x)
 trunc(x) → the value of x truncated to an integer (be careful - it's not an equivalent either
of ceil or floor)
 factorial(x) → returns x! (x has to be an integral and not a negative)
 hypot(x, y) → returns the length of the hypotenuse of a right-angle triangle with the leg
lengths equal to x and y (the same as sqrt(pow(x, 2) + pow(y, 2)) but more precise)

Look at the code in the editor. Analyze the program carefully.

It demonstrates the fundamental differences between ceil(), floor() and trunc().

Example:

from math import ceil, floor, trunc

x = 1.4
y = 2.6

print(floor(x), floor(y))
print(floor(-x), floor(-y))
print(ceil(x), ceil(y))
print(ceil(-x), ceil(-y))
print(trunc(x), trunc(y))
print(trunc(-x), trunc(-y))

Output
1 2
-2 -3
2 3
-1 -2
1 2
-1 -2

Selected functions from the random module

The random function

The most general function named random() (not to be confused with the module's
name) produces a float number x coming from the range (0.0, 1.0) - in other words: (0.0 <= x
< 1.0).

The example program below will produce five pseudorandom values - as their values are
determined by the current (rather unpredictable) seed value, you can't guess them:

from random import random

for i in range(5):
print(random())

The randrange and randint functions

If you want integer random values, one of the following functions would fit better:

 randrange(end)
 randrange(beg, end)
 randrange(beg, end, step)
 randint(left, right)
The first three invocations will generate an integer taken (pseudorandomly) from the range
(respectively):

 range(end)
 range(beg, end)
 range(beg, end, step)

Note the implicit right-sided exclusion!

The last function is an equivalent of randrange(left, right+1) - it generates the integer value i,
which falls in the range [left, right] (no exclusion on the right side).

Look at the code in the editor. This sample program will consequently output a line consisting of
three zeros and either a zero or one at the fourth place.

from random import randrange, randint

print(randrange(1), end=' ')
print(randrange(0, 1), end=' ')
print(randrange(0, 1, 1), end=' ')
print(randint(0, 1))

Output
0 0 0 1

The previous functions have one important disadvantage - they may produce repeating values
even if the number of subsequent invocations is not greater than the width of the specified range.

Look at the code below - the program very likely outputs a set of numbers in which some
elements are not unique:

from random import randint

for i in range(10):
print(randint(1, 10), end=',')

Output
9,5,8,9,3,8,10,2,4,2,
The choice and sample functions

As you can see, this is not a good tool for generating numbers in a lottery. Fortunately, there is a
better solution than writing your own code to check the uniqueness of the "drawn" numbers.

It's a function named in a very suggestive way - choice:

 choice(sequence)
 sample(sequence, elements_to_choose)

The first variant chooses a "random" element from the input sequence and returns it.

The second one builds a list (a sample) consisting of the elements_to_choose element "drawn"
from the input sequence.

In other words, the function chooses some of the input elements, returning a list with the choice.
The elements in the sample are placed in random order. Note: the elements_to_choose must not
be greater than the length of the input sequence.

Look at the code below:

from random import choice, sample

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(choice(my_list))
print(sample(my_list, 5))
print(sample(my_list, 10))

Output
7
[3, 8, 9, 10, 4]
[7, 5, 10, 6, 2, 9, 3, 8, 4, 1]

Again, the output of the program is not predictable.

Selected functions from the platform module

The platform function

The platform module lets you access the underlying platform's data, i.e., hardware, operating
system, and interpreter version information.
There is a function that can show you all the underlying layers in one glance, named platform,
too. It just returns a string describing the environment; thus, its output is rather addressed to
humans than to automated processing (you'll see it soon).

This is how you can invoke it:

platform(aliased = False, terse = False)

And now:

 aliased → when set to True (or any non-zero value) it may cause the function to present
the alternative underlying layer names instead of the common ones;
 terse → when set to True (or any non-zero value) it may convince the function to present
a briefer form of the result (if possible)

from platform import platform

print(platform())
print(platform(1))
print(platform(0, 1))

Output

Windows-10-10.0.19045-SP0
Windows-10-10.0.19045-SP0
Windows-10

The machine function

Sometimes, you may just want to know the generic name of the processor which runs your OS
together with Python and your code - a function named machine() will tell you that. As
previously, the function returns a string.

Again, we ran the sample program:

from platform import machine

print(machine())

The processor function

The processor() function returns a string filled with the real processor name (if possible).

Once again, we ran the sample program:

from platform import processor

print(processor())

The system function

A function named system() returns the generic OS name as a string.

from platform import system

print(system())

The version function

The OS version is provided as a string by the version() function.

from platform import version

print(version())

What is a package?

Python modules may contain several classes, functions, variables, etc. whereas Python
packages contain several modules. In simpler terms, Package in Python is a folder that contains
various modules as files.

Creating Package

Let’s create a package in Python named mypckg that will contain two modules mod1 and
mod2. To create this module follow the below steps:
 Create a folder named mypckg.
 Inside this folder create an empty Python file i.e. __init__.py
 Then create two modules mod1 and mod2 in this folder.

Mod1.py
def gfg():

print("Welcome to GFG")
Mod2.py
def sum(a, b):

return a+b

Understanding __init__.py

__init__.py helps the Python interpreter recognize the folder as a package. It also specifies the
resources to be imported from the modules. If the __init__.py is empty this means that all the
functions of the modules will be imported. We can also specify the functions from each
module to be made available.
For example, we can also create the __init__.py file for the above module as:
__init__.py

Import Modules from a Package

We can import these Python modules using the from…import statement and the dot(.)
operator.

Syntax:
import package_name.module_name
Example 1:
We will import the modules from the above-created package and will use the functions inside
those modules.

packageDemo.py

from mypckg import mod1

from mypckg import mod2

mod1.gfg()
res = mod2.sum(1, 2)
print(res)

Output

Welcome to GFG
3
We can also import the specific function also using the same syntax.
from mypckg.mod1 import gfg
from mypckg.mod2 import sum

gfg()
res = sum(1, 2)
print(res)

Output

Welcome to GFG
3