print( "Hello, world!

" )
5 + 7
print( "I", "own", "two", "apples", "and", "one", "banana" )
print( ' I can \ ' t stand it ' )
print( ' I can \\\ ' t stand it ' )
print( 1,000,000,000 )
print( (431 / 100) * 100 )
print( 15+4 )
print( 15-4 )
print( 15*4 )
print( 15/4 )
print( 15//4 )
print( 15* *4 )
print( 15%4 )
print( 5*2 -3+4/2 )
print( "hello"+"world" )
print( 3* "hello" )
print( "goodbye" *3 )
print( 15/4 )
print( int( 15/4 ) )
print( "I own " + str( 15 ) + " apples." )
# All equivalent statements
print( 2 + 3 )
print(2+3)
print( 2+3)
print ( 2 + 3 )
Exercise 3.1 The cover price of a book is $24.95, but bookstores get a 40 percent
discount.
Shipping costs $3 for the first copy and 75 cents for each additional copy.
Calculate the total
wholesale costs for 60 copies.
Exercise 3.2 Can you identify and explain the errors in the following lines of
code?
Correct them.
exercise0302.py
print( "A message" ).
print( "A message ' )
print( ' A messagef" ' )
Exercise 3.3 When something is wrong with your code, Python will raise errors.
Often
these will be �syntax errors� that signal that something is wrong with the form of
your
code (e.g., the code in the previous exercise raised a SyntaxError). There are also
�runtime
errors,� which signal that your code was in itself formally correct, but that
something went
wrong during the code�s execution. A good example is the ZeroDivisionError, which
indicates
that you tried to divide a number by zero (which, as you may know, is not allowed).
Try to make Python raise such a ZeroDivisionError.
Exercises 23
Exercise 3.4 Here is another illustrative example of a runtime error. Run the
follow code
and study the error that it generates. Can you locate the problem?
exercise0304.py
print( ((2*3) /4 + (5-6/7) *8 )
print( ((12*13) /14 + (15-16)/17) *18 )
Exercise 3.5 You look at the clock and see that it is currently 14.00h. You set an
alarm to
go off 535 hours later. At what time will the alarm go off? Write a program that
prints the
answer. Hint: for the best solution, you will need the modulo operator.

--------------------------------

x = 5
print( x )
x = 2
y = 3
print( "x =", x )
print( "y =", y )
print( "x * y =", x * y )
print( "x + y =", x + y )
a = 3.14159265
b = 7.5
c = 8.25
d = a * b * b * c / 3
print( d )
pi = 3.14159265
radius = 7.5
height = 8.25
volume_of_cone = pi * radius * radius * height / 3
print( volume_of_cone )
classification = 1 # 1
Classification = 1 # 2
cl@ssification = 1 # 3
class1f1cat10n = 1 # 4
1classification = 1 # 5
_classification = 1 # 6
class = 1 # 7
Class = 1 # 8

SERVICE_CHARGE = 1.15
CENTS = 100
total = 24.95
final_total = int( CENTS * total * SERVICE_CHARGE ) / CENTS
print( final_total )

nr1 = 5
nr2 = 4
nr3 = 5
print( nr3 / (nr1 % nr2) )
nr1 = nr1 + 1
print( nr3 / (nr1 % nr2) )
nr1 = nr1 + 1
print( nr3 / (nr1 % nr2) )
nr1 = nr1 + 1
print( nr3 / (nr1 % nr2) )

a = 3
print( type( a ) )
a = 3.0
print( type( a ) )
a = "3.0"
print( type( a ) )
a = 1
b = 4
c = "1"
d = "4"
print( a + b )
print( c + d )

Exercise 4.1 Define three variables var1, var2 and var3. Calculate the average of
these
variables and assign it to average. Print the average. Add three comments.
Exercise 4.2 Write code that can compute the surface of circle, using the variables
radius
and pi = 3.14159. The formula, in case you do not know, is radius times radius
times pi.
Print the outcome of your program as follows: �The surface area of a circle with
radius ...
is ...�
Exercise 4.3 Write code that classifies a given amount of money (which you store in
a
variable named amount), specified in cents, as greater monetary units. Your code
lists the
monetary equivalent in dollars (100 ct), quarters (25 ct), dimes (10 ct), nickels
(5 ct), and
pennies (1 ct). Your program should report the maximum number of dollars that fit
in the
amount, then the maximum number of quarters that fit in the remainder after you
subtract
the dollars, then the maximum number of dimes that fit in the remainder after you
subtract
the dollars and quarters, and so on for nickels and pennies. The result is that you
express
the amount as the minimum number of coins needed.
Exercise 4.4 Can you think of a way to swap the values of two variables that does
not
need a third variable as a temporary storage? In the code block below, try to
implement
the swapping of the values of a and b without using a third variable. To help you
out, the
first step to do this is already given. You just need to add two more lines of
code.
exercise0404.py
a = 17
b = 23
print( "a =", a, "and b =", b )
a += b
# add two more lines of code here to cause swapping of a and b
print( "a =", a, "and b =", b )

----------------------------------------

Elements of a function
� The name of the function
� The parameters it needs (if any)
� The return value of the function (if any)

base = 2
exponent = 3
print( pow( base , exponent ) )
x = pow( 3, "2" )
y = int( "two-and-a-half" )

x = 2.1
y = ' 3 '
z = int( x )
print( z )
print( int( y ) )

print( 10 * int( "100,000,000" ) )

abs() has one numerical parameter (an integer or a float). If the value is
positive, it
will return the value. If the value is negative, it will return the value
multiplied by -1.
� max() has two or more numerical parameters, and returns the largest.
� min() has two or more numerical parameters, and returns the smallest.
� pow() has two numerical parameters, and returns the first to the power of the
second.
Optionally, it has a third numerical parameter. If that third parameter is
supplied, it
will return the value modulo that third parameter.
� round() has a numerical parameter and rounds it,

x = -2
y = 3
z = 1.27
print( abs( x ) )
print( max( x, y, z ) )
print( min( x, y, z ) )
print( pow( x, y ) )
print( round( z, 1 ) )

print( len( ' cannot ' ) )

print( len( "" ) ) # "" is an empty string
number = input( "Please enter a number: " )
number = float( number )
print( "Your number squared is", number * number )

print( "X", "X", "X", sep="x" )

print( "{:.3f}".format( 7/11 ) )
print( "The first 3 numbers are {}, {} and {}.".format(
"one", "two", "three" ) )
print( "{:5d} divided by {:5d} is {:5f}".format( 1, 2, 1/2 ) )
print( "{:<5f} divided by {:^5f} is {:>5f}".format( 1, 2, 1/2 ) )

Modules

import math
print( math.sqrt( 4 ) )
from math import sqrt
print( sqrt( 4 ) )
from math import sqrt as squareroot
print( squareroot( 4 ) )

math

exp() gets one numerical parameter and returns e to the power of that parameter. If
you do not remember e from math class: e is a special value that has many
interesting
properties, which have applications in physics, maths, and statistics.
� log() gets one numerical parameter and returns the natural logarithm of that
parameter.
The natural logarithm is the value which, when e is raised to the power of
that value, gives the requested parameter. Just like e, the natural logarithm has
many
applications in physics, maths, and statistics.
� log10() gets one numerical parameter and returns the base-10 logarithm of that
parameter.
� sqrt() gets one numerical parameter and returns the square root of that
parameter.

random

random() gets no parameters, and returns a random float in the range [0, 1), i.e.,
a
range that includes 0.0, but excludes 1.0.
� randint() gets two parameters, both integers, and the first should be smaller
than
or equal to the second. It returns a random integer in the range for which the two
parameters are boundaries, e.g., randint(2,5) returns 2, 3, 4, or 5, with an equal
chance for each of them.
seed() initializes the random number generator of Python. If you want a sequence of
random numbers that are always the same, start by calling seed() with a fixed value
as parameter, for instance, 0. This can be useful for testing purposes. If you want
to re-initialize the random number generator so that it starts behaving completely
randomly again, call seed() without parameter.

from random import random , randint , seed

seed()
print( "A random number between 1 and 10 is", randint( 1, 10 ) )
print( "Another is", randint( 1, 10 ) )
seed( 0 )
print( "3 random numbers are:", random(), random(), random() )
seed( 0 )
print( "The same 3 numbers are:", random(), random(), random() )

pcinput

getInteger() gets one string parameter, the prompt, and asks the user to supply an
integer using that prompt. If the user enters something that is not an integer, the
user
is asked to enter a new input. The function will continue asking the user for
inputs
until a legal integer is entered, and then it will return that value, as an
integer.
� getFloat() gets one string parameter, the prompt, and asks the user to supply a
float
using that prompt. If the user enters something that is not a float or an integer,
the
user is asked to enter a new input. The function will continue asking the user for
inputs until a legal float or integer is entered, and then it will return that
value, as a
float.
� getString() gets one string parameter, the prompt, and asks the user to supply a
string using that prompt. Any value that the user enters is accepted. The function
will return the string that was entered, with leading and trailing spaces removed.
� getLetter() gets one string parameter, the prompt, and asks the user to supply a
letter using that prompt. The user�s input must be a single letter, in the range A
to
Z. Both capitals and lower case letters are accepted. The function returns the
letter
entered, converted to a capital.

from pcinput import getInteger

num1 = getInteger( "Please enter an integer: " )
num2 = getInteger( "Please enter another integer: " )
print( "The sum of", num1 , "and", num2 , "is", num1 + num2 )

Exercise 5.1 Ask the user to enter a string. Then print the length of that string.
Use the
input() function rather that the getString() function from pcinput, as the
getString()
function removes leading and trailing spaces.
Exercise 5.2 The Pythagorean theorem states that of a right triangle, the square of
the
length of the diagonal side is equal to the sum of the squares of the lengths of
the other two
sides (or a2 + b2 = c2). Write a program that asks the user for the lengths of the
two sides
that meet at a right angle, then calculate the length of the third side (in other
words: take
the square root of the sum of the squares of the two sides that you asked for), and
display
it in a nicely formatted way. You may ignore the fact that the user can enter
negative or
zero lengths for the sides.
Exercise 5.3 Ask the user to enter three numbers. Then print the largest, the
smallest,
and their average, rounded to 2 decimals.
Exercise 5.4 Calculate the value of e to the power of -1, 0, 1, 2, and 3, and
display the
results, with 5 decimals, in a nicely formatted manner.
Exercise 5.5 Suppose you want to generate a random integer between 1 and 10 (1 and
10 both included), but from the random module you only have the random() function
available (you can use functions from other modules, though). How do you do that?

---------------------------------------------------

print( "1.", 2 < 5 )

print( "2.", 2 <= 5 )
print( "3.", 3 > 3 )
print( "4.", 3 >= 3 )
print( "5.", 3 == 3.0 )
print( "6.", 3 == "3" )
print( "7.", "syntax" == "syntax" )
print( "8.", "syntax" == "semantics" )
print( "9.", "syntax" == " syntax" )
print( "10.", "Python" != "rubbish" )
print( "11.", "Python" > "Perl" )
print( "12.", "banana" < "orange" )
print( "13.", "banana" < "Orange" )

print( "y" in "Python" )

print( "x" in "Python" )
print( "p" in "Python" )
print( "th" in "Python" )
print( "to" in "Python" )
print( "y" not in "Python" )

t = True
f = False
print( t and t )
print( t and f )
print( f and t )
print( f and f )
print( t or t )
print( t or f )
print( f or t )
print( f or f )
print( not t )
print( not f )

a = # True or False?
b = # True or False?
c = # True or False?
print( (a and b) or c )
print( a and (b or c) )

x = 7
if x < 10:
print( "This line is only executed if x < 10." )
print( "And the same holds for this line." )
print( "This line , however , is always executed." )

# This code contains indentation errors!

x = 3
y = 4
if x == 3 and y == 4:
print( "x is 3" )
print( "y is 4" )
if x > 2 and y < 5:
print( "x > 2" )
print( "y < 5" )
if x < 4 and y > 3:
print( "x < 4" )
print( "y > 3" )

x = 4
if x > 2:
print( "x is bigger than 2" )
else:
print( "x is smaller than or equal to 2" )

# Example of syntactically correct but ugly indenting.

x = 1
if x > 2:
print( "x is bigger than 2" )
else:
print( "x is smaller than or equal to 2" )

from pcinput import getInteger

num = getInteger( "Please enter a positive integer: " )
if num < 0:
print( "You should have entered a positive integer!" )
else:
print( "Now I am processing your integer", num )
print( "Lots and lots of processing" )
print( "Hundreds of lines of code here" )
from pcinput import getInteger
from sys import exit
num = getInteger( "Please enter a positive integer: " )
if num < 0:
print( "You should have entered a positive integer!" )
exit()
print( "Now I am processing your integer", num )
print( "Lots and lots of processing" )
print( "Hundreds of lines of code here" )

Exercise 6.1 Grades are values between zero and 10 (both zero and 10 included), and
are always rounded to the nearest half point. To translate grades to the American
style, 8.5
to 10 become an �A,� 7.5 and 8 become a �B,� 6.5 and 7 become a �C,� 5.5 and 6
become
a �D,� and other grades become an �F.� Implement this translation, whereby you ask
the
user for a grade, and then give the American translation. If the user enters a
grade lower
than zero or higher than 10, just give an error message. You do not need to handle
the user
entering grades that do not end in .0 or .5, though you may do that if you like �
in that case,
if the user enters such an illegal grade, give an appropriate error message.
score = 98.0
if score >= 60.0:
grade = ' D '
elif score >= 70.0:
grade = ' C '
elif score >= 80.0:
grade = ' B '
elif score >= 90.0:
grade = ' A '
else:
grade = ' F '
print( grade )
Exercise 6.3 Ask the user to supply a string. Print how many different vowels there
are in the string. The capital version of a lower case vowel is considered to be
the same
vowel. y is not considered a vowel. Try to print nice output (e.g., printing �There
are 1
different vowels in the string� is ugly). Example: When the user enters the string
�It�s Owl
Stretching Time,� the program should say that there are 3 different vowels in the
string.
Exercise 6.4 You can solve quadratic equations using the quadratic formula.
Quadratic
equations are of the form Ax2 + Bx + C = 0. Such equations have zero, one or two
solutions. The first solution is (??B + sqrt(B2 ?? 4AC))/(2A). The second solution
is
(??B ?? sqrt(B2 ?? 4AC))/(2A). There are no solutions if the value under the square
root
is negative. There is one solution if the value under the square root is zero.
Write a program
that asks the user for the values of A, B, and C, then reports whether there are
zero,
one, or two solutions, then prints those solutions. Note: Make sure that you also
take into
account the case that A is zero (there is only one solution then, namely ??C/B),
and the
case that both A and B are zero.

-----------------------------------

num = 1
while num <= 5:
print( num )
num += 1
print( "Done" )

from pcinput import getInteger

total = 0
count = 0
while count < 5:
total += getInteger( "Please give a number: " )
count += 1
print( "Total is", total )
Exercise Change the code block above so that it not only prints the total, but also
the
average of the five numbers.
Exercise The first code block of this chapter also asks the user for five numbers,
and
prints the total. However, that code block uses �Enter number x: � as a prompt,
whereby x
is a digit. Can you change the code block above so that it also uses such a
changing prompt
to ask for each number?

from pcinput import getInteger

num = -1
total = 0
while num != 0:
num = getInteger( "Enter a number: " )
total += num
print( "Total is", total )

from pcinput import getInteger

num = getInteger( "Enter a number: " )
total = 0
while num != 0:
total += num
num = getInteger( "Enter a number: " )
print( "Total is", total )

for letter in "banana":

print( letter )
print( "Done" )
fruit = "banana"
for letter in fruit:
print( letter )
print( "Done" )
fruit = "banana"
for letter in fruit:
print( letter )
if letter == "n":
fruit = "orange"
print( "Done" )
for x in range( 10 ):
print( x )
for x in range( 1, 11, 2 ):
print( x )
for x in ( 10, 100, 1000, 10000 ):
print( x )
for x in ("apple", "pear", "orange", "banana", "mango", "cherry"):
print( x )

Exercise You already created code with a while loop that asked the user for five
numbers,
and displayed their total. Create code for this task, but now use a for loop.
Exercise Create a countdown function that starts at a certain count, and counts
down to
zero. Instead of zero, print �Blast off!� Use a for loop.
Exercise I am not going to ask you to build a for loop that asks the user to enter
numbers
until the user enters zero. Why not?

i = 0
while i < 5:
print( i )
i += 1
else:
print( "The loop ends , i is now", i )
print( "Done" )

for fruit in ( "apple", "orange", "strawberry" ):

print( fruit )
else:
print( "The loop ends , fruit is now", fruit )
print( "Done" )

i = 1
while i <= 1000000:
num1 = int( "1" + str( i ) )
num2 = int( str( i ) + "1" )
if num2 == 3 * num1:
print( num2 , "is three times", num1 )
break
i += 1
else:
print( "No answer found" )

for grade in ( 8, 7.5, 9, 6, 6, 6, 5.5, 7, 5, 8, 7, 7.5 ):

if grade < 5.5:
print( "The student fails!" )
break
else:
print( "The student passes!" )

num = 0
while num < 100:
num += 1
if num%2 == 0:
continue
if num%3 == 0:
continue
if num%10 == 7:
continue
if num%10 == 9:
continue
print( num )

i = 0
while i < 10:
if i == 5:
continue
i += 1

for i in range( 4 ):
for j in range( i+1, 4 ):
print( "({},{})".format( i, j ) )
Exercise Write code that prints all pairs (i,j) where i and j can take on the
values 0 to
3, but they cannot be equal.

from pcinput import getInteger

from sys import exit
while True:
x = getInteger( "Enter number 1: " )
if x == 0:
break
y = getInteger( "Enter number 2: " )
if y == 0:
break
if (x < 0 or x > 1000) or (y < 0 or y > 1000):
print( "The numbers should be between 0 and 1000" )
continue
if x%y == 0 or y%x == 0:
print( "Error: the numbers cannot be dividers" )
exit()
print( "Multiplication of", x, "and", y, "gives", x * y )
print( "Goodbye!" )

wordcount = 0
bookcount = 0
for shelf in library:
for book in shelf:
for word in book:
wordcount += 1
bookcount += 1
print( wordcount / bookcount )
---------------------------------------

def multiply( x, y ):
result = x * y
print( result )
multiply( 2020, 5278238 )
multiply( 2, 3 )

a = "Hello"
if isinstance( a, int ):
print( "integer" )
elif isinstance( a, float ):
print( "float" )
elif isinstance( a, str ):
print( "string" )
else:
print( "other" )

from math import sqrt

def pythagoras( a, b ):
return sqrt( a * a + b * b )
c = pythagoras( 3, 4 )
print( c )

from math import sqrt

def pythagoras( a, b ):
if a <= 0 or b <= 0:
return
return sqrt( a * a + b * b )
print( pythagoras( 3, 4 ) )
print( pythagoras( -3, 4 ) )

from math import sqrt

def pythagoras( a, b ):
if a > 0 and b > 0:
return sqrt( a * a + b * b )
print( pythagoras( 3, 4 ) )
print( pythagoras( -3, 4 ) )

from math import sqrt

def pythagoras( a, b ):
if a <= 0 or b <= 0:
return -1
print( "This line will never be printed" )
return sqrt( a * a + b * b )

def return3():
return 3
print( return3() )

def return3():
return 3
x = 2 * * return3()
print( x )

import datetime
def addDays( year , month , day , dayincrement ):
startdate = datetime.datetime( year , month , day )
enddate = startdate + datetime.timedelta( days=dayincrement )
return enddate.year , enddate.month , enddate.day
y, m, d = addDays( 2015, 11, 13, 55 )
print( "{}/{}/{}".format( y, m, d ) )

from math import sqrt

def pythagoras( a, b ):
if a <= 0 or b <= 0:
return -1
return sqrt( a * a + b * b )
def euclideanDistance ( x1, y1, x2, y2 ):
return pythagoras( abs( x1 - x2 ), abs( y1 - y2 ) )
print( euclideanDistance ( 1, 1, 4, 5 ) )

from math import sqrt

def euclideanDistance ( x1, y1, x2, y2 ):
def pythagoras_inside ( a, b ):
if a <= 0 or b <= 0:
return -1
return sqrt( a * a + b * b )
return pythagoras_inside ( abs( x1 - x2 ), abs( y1 - y2 ) )
print( euclideanDistance ( 1, 1, 4, 5 ) )
# print( pythagoras_inside( 3, 4 ) )

hello = "Hi!"
bye = "Goodbye!"
for i in range( 3 ):
for j in range( 2 ):
afternoon = "Good afternoon"
print( bye )
print( j )
print( hello )
print( afternoon )
print( i )
print( j )
print( afternoon )

dozen = 12
def dimeAdozen ():
print( "There are", dozen/dime , "dimes in a dozen" )
dime = 10
dimeAdozen ()
print( "dime =", dime , "and dozen =", dozen )

apple = "apple"
banana = "banana"
cherry = "cherry"
durian = "durian"
def printfruits_1 ():
print( apple , banana )
def printfruits_2( apple ):
banana = cherry
print( apple , banana )
def printfruits_3( apple , banana ):
cherry = "mango"
banana = cherry
print( apple , banana )
printfruits_1 ()
printfruits_2( cherry )
printfruits_3( cherry , durian )
print( "apple =", apple )
print( "banana =", banana )
print( "cherry =", cherry )
print( "durian =", durian )

fruit = "apple"
def changeFruit ():
global fruit
fruit = "banana"
print( fruit )
changeFruit ()
print( fruit )

8.5.1 main()
When examining other people�s Python programs, in particular those that contain
functions
that you might want to import, you often see a construct like shown below:
def main():
# code...
if __name__ == '__main__':
main()
The function main() contains the core of the program, and may call other functions.
There is no need to understand this exactly, but what happens here is the
following: the
Python file that contains the code can run as a program, or the functions that it
contains
can be imported into other programs. The construction shown here ensures that the
program
only executes main() (which is the core program) if the program is run as a
separate
program, rather than being loaded as a module. If, instead, the program is loaded
as a
module into another program, only its functions can be accessed, and the code for
main()
is ignored.
If the Python file that contains such a construct is predominantly used as a
module, the
main() function usually contains some code that tests the functions in the module.
This is
useful during development time.

def isEven( num ):

return num%2 == 0
if __name__ == ' __main__ ' :
for i in range( 10 ):
if isEven( i ):
print( i, "is even" )

f = lambda x: x * x
print( f(12) )

def f( x ):
return x * x
print( f(12) )

from pcinput import getInteger

from sys import exit
while True:
x = getInteger( "Enter number 1: " )
if x == 0:
break
y = getInteger( "Enter number 2: " )
if y == 0:
break
if (x < 0 or x > 1000) or (y < 0 or y > 1000):
print( "The numbers should be between 0 and 1000" )
continue
if x%y == 0 or y%x == 0:
print( "Error: the numbers cannot be dividers" )
exit()
print( "Multiplication of", x, "and", y, "gives", x * y )
print( "Goodbye!" )

# What is wrong?
def area_of_triangle ( bottom , height ):
area = 0.5 * bottom * height
print( "The area of a triangle with a bottom of", bottom ,
"and a height of", height , "is", area )
print( area_of_triangle ( 4.5, 1.0 ) )

def factorial( n ):
if n <= 1:
return 1
return n * factorial( n-1 )
print( factorial( 5 ) )

function leads_to_exit( currentcell ):

if (currentcell is the exit):
return (path consisting of only the exit)
for (every connnectedcell that was not yet explored):
path = leads_to_exit( connectedcell )
if (path is not empty):
add currentcell to path
return path
return (empty path)

from pcmaze import entrance , exit , connected

def leads_to_exit( comingfrom , cell ):
if cell == exit():
return True
for i in range( entrance(), exit()+1 ):
if i == comingfrom:
continue
if not connected( cell , i ):
continue
if leads_to_exit( cell , i ):
print( cell , "->", i )
return True
return False
if leads_to_exit( 0, entrance() ):
print( "Path found!" )
else:
print( "Path not found" )

from pcmaze import entrance , exit , connected

def leads_to_exit( comingfrom , cell , depth ):
indent = depth * 4 * " "
if cell == exit():
return True
for i in range( entrance(), exit()+1 ):
if i == comingfrom:
continue
if not connected( cell , i ):
continue
print( indent + "Check connection", cell , "->", i )
if leads_to_exit( cell , i, depth + 1 ):
print( indent + "Path found:", cell , "->", i )
return True
return False
if leads_to_exit( 0, entrance(), 0 ):
print( "Path found!" )
else:
print( "Path not found" )
----------------------------------------

15.4.1 getcwd()
getcwd() returns the current working directory as a string.
from os import getcwd
print( getcwd() )

15.4.2 chdir()
chdir() changes the current working directory. The new directory is provided as a
string
argument.
from os import getcwd , chdir
home = getcwd()
print( home )
chdir( ".." )
print( getcwd() )
chdir( home )
print( getcwd() )

15.4.3 listdir()
listdir() returns a list of all the files and directories in the directory that is
given as
argument. The names are given in arbitrary order. Notice that they do not include
the full
path name.
from os import listdir
flist = listdir( "." )
for name in flist:
print( name )

15.4.4 system()
system() gets a string argument that is a command, that Python executes on the
command
line. You can use it to do anything that the operating system supports, including
running
other programs. There are better ways to execute other programs, though (look for
functions
that start with �exec�).

---------------------------------

fp = open( "pc_rose.txt" )
print( fp.read() )
fp.close()

with open( "pc_rose.txt" ) as fp:

buffer = fp.read()
print( buffer )

Reading lines using readline()

fp = open( "pc_rose.txt" )
while True:
buffer = fp.readline()
if buffer == "":
break
print( buffer )
fp.close()
fp = open( "pc_rose.txt" )
buffer = fp.readlines ()
for line in buffer:
print( line , end="" )
fp.close()

fp = open( "pc_jabberwocky.txt" )
count = 0
while count < 5:
buffer = fp.readline()
if buffer == "":
break
print( buffer , end="" )
count += 1
fp.close()

fp = open( "pc_writetest.tmp", "w" )

while True:
text = input( "Please enter a line of text: " )
if text == "":
break
fp.write( text )
fp.close()
fp = open( "pc_writetest.tmp" )
buffer = fp.read()
fp.close()
print( buffer )

FILENAME = "pc_writetest.tmp"
def displaycontents ( filename ):
fp = open( filename )
print( fp.read() )
fp.close()
displaycontents ( FILENAME )
fp = open( FILENAME , "a" )
while True:
text = input( "Please enter a line of text: " )
if text == "":
break
fp.write( text+"\n" )
fp.close()
displaycontents ( FILENAME )

from os.path import exists

if exists( "pc_rose.txt" ):
print( "Rose exists" )
else:
print( "Rose does not exist" )
if exists( "pc_tulip.txt" ):
print( "Tulip exists" )
else:
print( "Tulip does not exist" )

from os.path import isfile

if isfile( "pc_rose.txt" ):
print( "Rose is a file" )
else:
print( "Rose is not a file" )
from os.path import isdir
if isdir( "pc_rose.txt" ):
print( "Rose is a directory" )
else:
print( "Rose is not a directory" )

from os import listdir , getcwd

from os.path import join
filelist = listdir( "." )
for name in filelist:
pathname = join( getcwd(), name )
print( pathname )

from os.path import basename

print( basename( "/System/Home/readme.txt" ) )

from os.path import dirname

print( dirname( "/System/Home/readme.txt" ) )

from os.path import getsize

numbytes = getsize( "pc_rose.txt" )
print( numbytes )

from sys import getfilesystemencoding

print( getfilesystemencoding () )

for i in range(16):
if i < 10:
print( ' ' +chr( ord( ' 0 ' )+i ), end= ' ' )
else:
print( ' ' +chr( ord( ' A ' )+i-10 ), end= ' ' )
print()
for i in range( 10, 16 ):
print( chr( ord( ' A ' )+i-10 ), end= ' ' )
for j in range( 16 ):
c = i*16+j
print( ' ' +chr( c ), end= ' ' )
print()

------------------------------------------
from pcinput import getInteger
num = getInteger( "Please enter a number: " )
print( "3 divided by {} is {}".format( num , 3/num ) )
print( "Goodbye!" )

from pcinput import getInteger

num = getInteger( "Please enter a number: " )
if num == 0:
print( "Dividing by zero is not allowed" )
else:
print( "3 divided by {} is {}".format( num , 3/num ) )
print( "Goodbye!" )

from pcinput import getInteger

num = getInteger( "Please enter a number: " )
try:
print( "3 divided by {} is {}".format( num , 3/num ) )
except:
print( "Division by zero is not allowed" )
print( "Goodbye!" )

from pcinput import getInteger

num = getInteger( "Please enter a number: " )
try:
print( "3 divided by {} is {}".format( num , 3/num ) )
print( "3 divided by {}-3 is {}".format( num , 3/(num -3) ) )
except:
print( "Division by zero is not allowed" )
print( "Goodbye!" )

fruitlist = ["apple", "banana", "cherry"]

try:
num = input( "Please enter a number: " )
if "." in num:
num = float( num )
else:
num = int( num )
print( fruitlist[num] )
except:
print( "Something went wrong" )

try:
num = 3 / int( input( "Please enter a number: " ) )
except ZeroDivisionError :
print( "Dividing by zero is not allowed" )
except ValueError:
print( "You have not entered an integer" )
except:
print( "Something unforeseen went wrong" )
else:
print( num )
print( "Goodbye" )

try:
fp = open( "pc_rose.txt" )
print( "File opened" )
print( fp.read() )
finally:
fp.close()
print( "File closed" )

try:
print( int( "NotAnInteger" ) )
except ValueError as ex:
print( ex.args )

try:
fp = open( "NotAFile" )
fp.close()
except IOError as ex:
print( ex.args )

import errno
try:
fp = open( "NotAFile" )
fp.close()
except IOError as ex:
if ex.args[0] == errno.ENOENT:
print( "File not found!" )
else:
print( ex.args[0], ex.args[1] )

def getStringLenMax10 ( prompt ):

s = input( prompt )
if len( s ) > 10:
raise ValueError( "Length exceeds 10", len( s ) )
return s
print( getStringLenMax10 ( "Use 10 characters or less: " ) )

fp = open( "pc_rose.txt ")

try:
buffer = fp.read()
print( buffer )
except IOError:
fp.close()
raise
fp.close()

----------------------------------
class Point:
pass
p = Point()
print( type( p ) )

class Point:
def __init__( self ):
self.x = 0.0
self.y = 0.0
p = Point()
print( "({}, {})".format( p.x, p.y ) )

class Point:
def __init__( self ):
self.x = 0.0
self.y = 0.0
p = Point()
p.z = 0.0
print( "({}, {}, {})".format( p.x, p.y, p.z ) )

class Point:
def __init__( self , x, y ):
self.x = x
self.y = y
p = Point( 3.5, 5.0 )
print( "({}, {})".format( p.x, p.y ) )

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
p1 = Point()
print( "({}, {})".format( p1.x, p1.y ) )
p2 = Point( 3.5, 5.0 )
print( "({}, {})".format( p2.x, p2.y ) )

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
p = Point( 3.5, 5.0 )
print( p )

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
def __repr__( self ):
return "({}, {})".format( self.x, self.y )
p = Point( 3.5, 5.0 )
print( p )

from math import sqrt

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
def __repr__( self ):
return "({}, {})".format( self.x, self.y )
def distance_from_origin ( self ):
return sqrt( self.x * self.x + self.y * self.y )
p = Point( 3.5, 5.0 )
print( p.distance_from_origin () )

from math import sqrt

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
def __repr__( self ):
return "({}, {})".format( self.x, self.y )
def translate( self , shift_x , shift_y ):
self.x += shift_x
self.y += shift_y
p = Point( 3.5, 5.0 )
p.translate( -3, 7 )
print( p )

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
def __repr__( self ):
return "({}, {})".format( self.x, self.y )
class Rectangle:
def __init__( self , point , width , height ):
self.point = point
self.width = width
self.height = height
def __repr__( self ):
return "[{},w={},h={}]".format( self.point , self.width ,
self.height )
p = Point( 3.5, 5.0 )
r = Rectangle( p, 4.0, 2.0 )
print( r )

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
def __repr__( self ):
return "({}, {})".format( self.x, self.y )
class Rectangle:
def __init__( self , point , width , height ):
self.point = point
self.width = width
self.height = height
def __repr__( self ):
return "[{},w={},h={}]".format( self.point , self.width ,
self.height )
p = Point( 3.5, 5.0 )
r = Rectangle( p, 4.0, 2.0 )
print( r )
p.x = 1.0
p.y = 1.0
print( r )

from copy import copy

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
def __repr__( self ):
return "({}, {})".format( self.x, self.y )
class Rectangle:
def __init__( self , point , width , height ):
self.point = copy( point )
self.width = width
self.height = height
def __repr__( self ):
return "[{},w={},h={}]".format( self.point , self.width ,
self.height )
p = Point( 3.5, 5.0 )
r = Rectangle( p, 4.0, 2.0 )
print( r )
p.x = 1.0
p.y = 1.0
print( r )

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
pointlist = []
for i in range( 100 ):
for j in range( 100 ):
p = Point( i, j )
pointlist.append( p )
print( "There are", len( pointlist ), "points in the list" )

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
totalx = 0
totaly = 0
for i in range( 1000 ):
for j in range( 1000 ):
p = Point( i, j )
totalx += p.x
totaly += p.y
print( "The totals of x and y are", totalx , "and", totaly )

---------------------Overloading---------------------
class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
def __repr__( self ):
return "({}, {})".format( self.x, self.y )
p1 = Point( 3, 4 )
p2 = Point( 3, 4 )
p3 = p1
print( p1 is p2 )
print( p1 is p3 )
print( p1 == p2 )
print( p1 == p3 )

class Point:
def __init__( self , x=0.0, y=0.0 ):
self.x = x
self.y = y
def __repr__( self ):
return "({}, {})".format( self.x, self.y )
def __eq__( self , p ):
return self.x == p.x and self.y == p.y
p1 = Point( 3, 4 )
p2 = Point( 3, 4 )
p3 = p1
print( p1 is p2 )
print( p1 is p3 )
print( p1 == p2 )
print( p1 == p3 )

class Quaternion:
def __init__( self , a, b, c, d ):
self.a = a
self.b = b
self.c = c
self.d = d
def __repr__( self ):
return "({},{}i,{}j,{}k)".format( self.a, self.b,
self.c, self.d )
def __eq__( self , n ):
if isinstance( n, int ) or isinstance( n, float ):
if self.a == n and self.b == 0 and \
self.c == 0 and self.d == 0:
return True
else:
return False
elif isinstance( n, Quaternion ):
if self.a == n.a and self.b == n.b and \
self.c == n.c and self.d == n.d:
return True
else:
return False
return NotImplemented
c1 = Quaternion( 1, 2, 3, 4 )
c2 = Quaternion( 1, 2, 3, 4 )
c3 = Quaternion( 3, 0, 0, 0 )

buffer = []
if buffer:
print( buffer )
else:
print( "buffer is empty" )

class Quaternion:
def __init__( self , a, b, c, d ):
self.a, self.b, self.c, self.d = a, b, c, d
def __repr__( self ):
return "({},{}i,{}j,{}k)".format( self.a, self.b,
self.c, self.d )
def __add__( self , n ):
if isinstance( n, int ) or isinstance( n, float ):
return Quaternion( n+self.a, self.b, self.c, self.d )
elif isinstance( n, Quaternion ):
return Quaternion( n.a + self.a, n.b + self.b, \
n.c + self.c, n.d + self.d )
return NotImplemented
c1 = Quaternion( 3, 4, 5, 6 )
c2 = Quaternion( 1, 2, 3, 4 )
print( c1 + c2 )
print( c1 + 10 )

class Quaternion:
def __init__( self , a, b, c, d ):
self.a, self.b, self.c, self.d = a, b, c, d
def __repr__( self ):
return "({},{}i,{}j,{}k)".format( self.a, self.b,
self.c, self.d )
def __add__( self , n ):
if isinstance( n, int ) or isinstance( n, float ):
return Quaternion( n+self.a, self.b, self.c, self.d )
elif isinstance( n, Quaternion ):
return Quaternion( n.a + self.a, n.b + self.b, \
n.c + self.c, n.d + self.d )
return NotImplemented
def __radd__( self , n ):
return self.__add__( n )
c1 = Quaternion( 3, 4, 5, 6 )
print( 10 + c1 )

class Quaternion:
def __init__( self , a, b, c, d ):
self.a, self.b, self.c, self.d = a, b, c, d
def __repr__( self ):
return "({},{}i,{}j,{}k)".format( self.a, self.b,
self.c, self.d )
def __neg__( self ):
return Quaternion( -self.a, -self.b, -self.c, -self.d)
def __abs__( self ):
return Quaternion( abs( self.a ), abs( self.b ),
abs( self.c ), abs( self.d ) )
def __bytes__( self ):
return self.__str__().encode( "utf -8" )
c1 = Quaternion( 3, -4, 5, -6 )
print( c1 )
print( -c1 )
print( abs( c1 ) )
print( bytes( c1 ) )

class Sentence:
def __init__( self , words ):
self.words = words
def __repr__( self ):
return " ".join( self.words )
s = Sentence( [ "There", "is", "only", "one", "thing", "worse",
"than", "being", "talked", "about",
"and", "that", "is", "not", "being", "talked", "about" ] )
print( s )
print( len( s ) )
print( s[5] )
s[5] = "better"
print( "being" in s )

--------------------------------------------
class Person:
def __init__( self , firstname , lastname , age ):
self.firstname = firstname
self.lastname = lastname
self.age = age
def __repr__( self ):
return "{} {}".format( self.firstname , self.lastname )
def underage( self ):
return self.age < 18
class Student( Person ):
pass
albert = Student( "Albert", "Applebaum", 19 )
print( albert )
print( albert.underage() )

class Person:
def __init__( self , firstname , lastname , age ):
self.firstname = firstname
self.lastname = lastname
self.age = age
def __repr__( self ):
return "{} {}".format( self.firstname , self.lastname )
def underage( self ):
return self.age < 18
class Student( Person ):
def __init__( self , firstname , lastname , age , program ):
super().__init__( firstname , lastname , age )
self.courselist = []
self.program = program
def underage( self ):
return self.age < 21
def enroll( self , course ):
self.courselist.append( course )
albert = Student( "Albert", "Applebaum", 19, "CSAI" )
print( albert )
print( albert.underage() )
print( albert.program )
albert.enroll( "Methods of Rationality" )
albert.enroll( "Defense Against the Dark Arts" )
print( albert.courselist )

class Vehicle:
def __init__( self ):
self.startpoint = []
self.endpoints = []
self.verb = ""
self.name = ""
def __str__( self ):
return self.name
def isStartpoint( self , p ):
return NotImplemented
def isEndpoint( self , p ):
return NotImplemented
def travel_speed( self , p1, p2 ):
return NotImplemented
def travelVerb( self ):
return NotImplemented

class Rectangle:
def __init__( self , x, y, w, h ):
self.x = x
self.y = y
self.w = w
self.h = h
def __repr__( self ):
return "[({},{}),w={},h={}]".format( self.x, self.y,
self.w, self.h )
def area( self ):
return self.w * self.h
def circumference( self ):
return 2*( self.w + self.h)

--------------------Iterators---------------------

for i in [1,2,3,4]:
print( i, end=" " )
print()
for i in ( "pi", 3.14, 22/7 ):
print( i, end=" ")
print()
for i in range( 3, 11, 2 ):
print( i, end=" ")
print()
for c in "Hello":
print( c, end=" " )
print()
for key in { "apple":1, "banana":3 }:
print( key , end=" " )

iterator = iter( ["apple", "banana", "cherry"] )

print( next( iterator , "END" ) )
print( next( iterator , "END" ) )
print( next( iterator , "END" ) )
print( next( iterator , "END" ) )
iterator = iter( ["apple", "banana", "cherry"] )
for fruit in iterator:
print( fruit )

class Fibo:
def __init__( self ):
self.seq = [1,1,2,3,5,8,13,21,34,55]
def __iter__( self ):
return self
def __next__( self ):
if len( self.seq ) > 0:
return self.seq.pop(0)
raise StopIteration ()
fseq = Fibo()
for n in fseq:
print( n, end=" " )

class Fibo:
def __init__( self ):
self.seq = [1,1,2,3,5,8,13,21,34,55]
self.index = -1
def __iter__( self ):
return self
def __next__( self ):
if self.index < len( self.seq )-1:
self.index += 1
return self.seq[self.index]
raise StopIteration ()
def reset( self ):
self.index = -1
fseq = Fibo()
for n in fseq:
print( n, end=" " )
print()
fseq.reset()
for n in fseq:
print( n, end=" " )

class Fibo:
def reset( self ):
self.nr1 = 0
self.nr2 = 1
def __init__( self , maxnum =1000 ):
self.maxnum = maxnum
self.reset()
def __iter__( self ):
return self
def __next__( self ):
if self.nr2 > self.maxnum:
raise StopIteration ()
nr3 = self.nr1 + self.nr2
self.nr1 = self.nr2
self.nr2 = nr3
return self.nr1
fseq = Fibo()
for n in fseq:
print( n, end=" " )
print()
fseq.reset()
for n in fseq:
print( n, end=" " )

class FiboIterable:
def __init__( self , seq ):
self.seq = seq
def __next__( self ):
if len( self.seq ) > 0:
return self.seq.pop(0)
raise StopIteration ()
class Fibo:
def __init__( self , maxnum =1000 ):
self.maxnum = maxnum
def __iter__( self ):
nr1 = 0
nr2 = 1
seq = []
while nr2 <= self.maxnum:
nr3 = nr1 + nr2
nr1 = nr2
nr2 = nr3
seq.append( nr1 )
return FiboIterable( seq )

fseq = Fibo()
for n in fseq:
print( n, end=" " )
print()
for n in fseq:
print( n, end=" " )

z = zip( [1,2,3], [4,5,6], [7,8,9] )

for x in z:
print( x )

class Doubles:
def __init__( self ):
self.seq = [2*x for x in range( 1, 11 )]
def __iter__( self ):
return self
def __next__( self ):
return self.seq.pop(0)
seq = zip( range( 1, 11 ), Doubles(), [3*x for x in range(1,11)])
for x in seq:
print( x )

fruitlist = ["apple", "orange", "cherry", "banana"]

for fruit in reversed( fruitlist ):
print( fruit )

fruitlist = ["apple", "orange", "cherry", "banana"]

for fruit in sorted( fruitlist ):
print( fruit )

--------------------Generators----------------
def fibo( maxnum ):
nr1 = 0
nr2 = 1
while nr2 <= maxnum:
nr3 = nr1 + nr2
nr1 = nr2
nr2 = nr3
yield nr1
fseq = fibo( 1000 )
for n in fseq:
print( n, end=" " )
print()
for n in fseq:
print( n, end=" " )

seq = (x * x for x in range( 11 ))

for x in seq:
print( x, end=" " )

from itertools import chain

seq = chain( [1,2,3], [11,12,13,14], [x * x for x in range(1,6)] )
for item in seq:
print( item , end=" ")

from itertools import zip_longest

seq = zip_longest( "apple", "coconut", "banana", fillvalue=" ")
for item in seq:
print( item )

from itertools import product

seq = product( [1,2,3], "ABC", ["apple","banana"] )
for item in seq:
print( item )

from itertools import permutations

seq = permutations( [1,2,3], 2 )
for item in seq:
print( item )

from itertools import combinations

seq = combinations( [1,2,3], 2 )
for item in seq:
print( item )

from itertools import combinations_with_replacement

seq = combinations_with_replacement ( [1,2,3], 2 )
for item in seq:
print( item )
---------------------------
import sys
# 3 variables for holding the command line parameters
inputfile = "input.txt"
outputfile = "output.txt"
shift = 3
# Processing the command line parameters
# (works with 0, 1, 2, or 3 parameters)
if len( sys.argv ) > 1:
inputfile = sys.argv[1]
if len( sys.argv ) > 2:
outputfile = sys.argv[2]
if len( sys.argv ) > 3:
try:
shift = int( sys.argv[3] )
except TypeError:
print( sys.argv[3], "is not an integer." )
sys.exit(1)

import re
pAplus = re.compile( r"a+" )
lAplus = pAplus.findall( "aardvark" )
print( lAplus )

import re
lAplus = re.findall( r"a+", "aardvark" )
print( lAplus )

import re
m = re.match( r"a+", "Look out for the aardvark!" )
if m:
print( "{} starts the string".format( m.group() ) )
else:
print( "The pattern is not found at the start of the string")

import re
mlist = re.finditer( r"a+",
"Look out! A dangerous aardvark is on the loose!" )
for m in mlist:
print( "{} starts at index {} and ends at index {}.".format(
m.group(), m.start(), m.end() ) )

import re
slist = re.findall( r"b[aeiou]ll", "Bill Gates and Uwe Boll \
drank Red Bull at a football match in Campbell." )
print( slist )

import re
mlist = re.finditer(r"ba+","A sheep says ' baaaaah ' to Ali Baba.")
for m in mlist:
print( "{} is found at {}.".format(m.group(), m.start()))

import re
mlist = re.finditer(r"a+","A sheep says ' baaaaah ' to Ali Baba.")
for m in mlist:
print( "{} is found at {}.".format(m.group(), m.start()))

import re
s = re.sub( r"([iy])se", "\g<1>ze", "Whether you categorise , \
emphasise , or analyse , you should use American spelling!" )
print( s )
--------------------------------------------
fp = open( "pc_inventory.csv" )
print( fp.read().strip() )
fp.close()

from csv import reader

fp = open( "pc_inventory.csv", newline= ' ' )
csvreader = reader( fp )
for line in csvreader:
print( line )
fp.close()

from csv import writer

fp = open( "pc_writetest.csv", "w", newline= ' ' )
csvwriter = writer( fp )
csvwriter.writerow( ["MOVIE", "RATING"] )
csvwriter.writerow( ["Monty Python and the Holy Grail", 8] )
csvwriter.writerow( ["Monty Python ' s Life of Brian", 8.5] )
csvwriter.writerow( ["Monty Python ' s Meaning of Life", 7] )
fp.close()

-----------------------

from pickle import dump

cheeseshop = [ ("Roquefort", 12, 15.23),
("White Stilton", 25, 19.02), ("Cheddar", 5, 0.67) ]
fp = open( "pc_cheese.pck", "wb" )
dump( cheeseshop , fp )
fp.close()
print( "Cheeseshop was pickled" )

from pickle import load

fp = open( "pc_cheese.pck", "rb" )
buffer = load( fp )
fp.close()
print( type( buffer ) )
print( buffer )

from pickle import dump , load

class Point:
def __init__( self , x, y ):
self.x = x
self.y = y
def __repr__( self ):
return "({},{})".format( self.x, self.y )
p = Point( 2, 5 )
fp = open( "pc_point.pck", "wb" )
dump( p, fp )
fp.close()
fp = open( "pc_point.pck", "rb" )
q = load( fp )
fp.close()
print( type( q ) )
print( q )
--------------------------------
from datetime import datetime
print( datetime.now() )

from datetime import datetime , timedelta

thisyear = datetime.now().year
xmasthisyear = datetime( thisyear , 12, 25, 23, 59, 59 )
thisday = datetime.now()
days = xmasthisyear - thisday
if days.days < 0:
print( "Christmas will come again next year." )
elif days.days == 0:
print( "It ' s Christmas!" )
else:
print( "Only", days.days , "days to Christmas!" )

from collections import Counter

data = [ "apple", "banana", "apple", "banana", "apple", "cherry" ]
c = Counter( data )
print( c )
print( c.most_common( 1 ) )
data2 = [ "orange", "cherry", "cherry", "cherry", "cherry" ]
c.update( data2 )
print( c )
print( c.most_common () )

from collections import deque

dq = deque( [ 1, 2, 3 ] )
dq.appendleft( 4 )
dq.extendleft( [ 5, 6 ] )
print( dq )

from glob import glob

glist = glob( " *. pdf" )
for name in glist:
print( name )

from statistics import mean , median , mode , stdev , variance , \

StatisticsError
data = [ 4, 5, 1, 1, 2, 2, 2, 3, 3, 3 ]
print( "mean:", mean( data ) )
print( "median:", median( data ) )
try:
print( "mode:", mode( data ) )
except StatisticsError as e:
print( e )
print( "st.dev.: {:.3f}".format( stdev( data ) ) )
print( "variance: {:.3f}".format( variance( data ) ) )