Python Learning - Three
1. Set
Set is a collection which is unordered and unindexed. No duplicate members
In Python sets are written with curly brackets { }
set1 = {'apple', 'banana', 'cherry'}
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
print(set1)
print(list_set, type(list_set))
The set( ) constructor
# Note the double round-brackets
set_constructor = set(('apple', 'cherry', 'mango')) print(set_constructor, type(set_constructor))
(1) .intersection( )
set1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
print(set1, set2)
print(set1.intersection(set2))
(2) .union( )
set1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
print(set1, set2)
print(set1.intersection(set2))
print(set1.union(set2))
(3) .difference( )
A.difference(B) means those values that are in A and not in B
# Author: Alan FUNG # A&F TECH HK Co,LTD. set1 = {'apple', 'banana', 'cherry'} ''' list1 = [1, 2, 3, 4, 5] list_set = set(list1) ''' set2 = set(['mango', 'cherry', 'apple', 'orange']) print(set1.difference(set2)) print(set2.difference(set1))
(4) .issubset( ) and .issuperset( )
set1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
print(set1.issubset(set2))
print(set1.issuperset(set2))
set3 = set(['apple', 'cherry'])
print(set3.issubset(set1))
print(set1.issuperset(set3))
(5) .symmetric_difference( )
set1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
print(set1.issubset(set2))
print(set1.issuperset(set2))
set3 = set(['apple', 'cherry'])
print(set3.issubset(set1))
print(set1.issuperset(set3))
print(set1.symmetric_difference(set3))
(6) .isdisjoint( )
# Return True if two sets have a null intersection
set1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
set3 = set(['apple', 'cherry'])
set4 = set(('mango', 'pineapple','orange' ))
print(set3.isdisjoint(set4))
(7) & and .intersection( )
et1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
set3 = set(['apple', 'cherry'])
set4 = set(('mango', 'pineapple','orange' ))
print(set1 & set2)
print(set1.intersection(set2))
print(set2.intersection(set1))
(8) | and .union( )
set1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
set3 = set(['apple', 'cherry'])
set4 = set(('mango', 'pineapple','orange' ))
print(set1 | set2)
print(set1.union(set2))
print(set2.union(set1))
(9) - and .difference( )
set1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
set3 = set(['apple', 'cherry'])
set4 = set(('mango', 'pineapple','orange' ))
print(set1 - set2)
print(set1.difference(set2))
print(set2-set1)
print(set2.difference(set1))
(10) ^ and .symmetric_difference( )
set1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
set3 = set(['apple', 'cherry'])
set4 = set(('mango', 'pineapple','orange' ))
print(set1 ^ set2)
print(set1.symmetric_difference(set2))
print(set2 ^ set1)
(11) .add ( )
set1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
set3 = set(['apple', 'cherry'])
set4 = set(('mango', 'pineapple','orange' ))
print(set3.add('mango'))
print(set3)
(12) .update( )
Add more than one item to the set
set1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
set3 = set(['apple', 'cherry'])
set4 = set(('mango', 'pineapple','orange' ))
print(set3.add('mango'))
print(set3)
set3.update(['pineapple', 'banana', 'orange'])
print(set3)
(13) .remove( )
et1 = {'apple', 'banana', 'cherry'}
'''
list1 = [1, 2, 3, 4, 5]
list_set = set(list1)
'''
set2 = set(['mango', 'cherry', 'apple', 'orange'])
set3 = set(['apple', 'cherry'])
set4 = set(('mango', 'pineapple','orange' ))
set4.remove('orange')
print(set4)
2. Files
The key function for working with files in Python is the open() function.
The open() function takes two parameters; filename, and mode.
There are four different methods (modes) for opening a file:
"r" - Read - Default value. Opens a file for reading, error if the file does not exist.
"a" - Append - Opens a file for appending, creates the file if it does not exist.
"w" - Write - Opens a file for writing, creates the file if it does not exist.
"x"- Create - Creates the specified file, returns an error if the file exists.
In addition, you can specify if the file should be handled as binary or text mode
"t" - Text - Default value. Text mode
"b"- Binary - Binary mode (e.g. images)
(1) "w"
file_w = open('testing_file', 'w', encoding='utf-8')
file_w = open('testing_file', 'w', encoding='utf-8') file_w.write('Hello World! \n') print(file_w)
(2) "a"
''' file_w = open('testing_file', 'w', encoding='utf-8') file_w.write('Hello World! \n') print(file_w) ''' file_a = open('testing_file', 'a', encoding='utf-8') file_a.write('Hi, this is Alan \n') print(file_a)
(3) "x"
file_x = open('testing_file', 'x', encoding='utf-8')
file_x = open('testing_file_for_create', 'x', encoding='utf-8')
file_x = open('testing_file_for_create_2', 'x', encoding='utf-8') file_x.write('Hi, this is a new file') print(file_x)
(4) .read( ) and .readline( )
1) .read( ) print all the content
file_read = open('testing_file', 'r', encoding='utf-8') content = file_read.read() print(content)
2) .readline( ) only return one line
file_read = open('testing_file', 'r', encoding='utf-8') content = file_read.readline() print(content)
3) Use the for loop
file_read = open('testing_file', 'r', encoding='utf-8') for i in range(5): print(file_read.readline())
(5) .readline( ) and .readlines( )
1) .readlines( )
file_read = open('testing_file', 'r', encoding='utf-8') for line in file_read.readlines(): print(line)
2) .readlines( ) with enumerate( )
file_read = open('testing_file', 'r', encoding='utf-8') for index, line in enumerate(file_read.readlines()): if index == 3: print('-----------------------This is a dashline ----------------------------') continue print(line.strip())
(6) .tell( )
file_read = open('testing_file', 'r', encoding='utf-8') print(file_read.tell()) print(file_read.readline()) print(file_read.tell()) file_read.seek(0) print(file_read.readline())
(7) .encoding( )
ile_read = open('testing_file', 'r', encoding='utf-8') print(file_read.encoding)
(8) .flush( )
import sys, time for i in range(20): sys.stdout.write('#') sys.stdout.flush() time.sleep(0.5)
(9) read and write -- r+
ile_rwrite = open('testing_file', 'r+', encoding='utf-8') print(file_rwrite.readline()) print(file_rwrite.readline()) print(file_rwrite.readline()) file_rwrite.write('--------------------- This is a dash line ----------------------') print(file_rwrite.readline())
(10) Write and read -- w+
file_wread = open('testing_file', 'r+', encoding='utf-8') file_wread.write('----------------------- This is a dash line -------------------------- \n') file_wread.write('----------------------- This is a dash line -------------------------- \n') file_wread.write('----------------------- This is a dash line -------------------------- \n') file_wread.write('----------------------- This is a dash line -------------------------- \n') print(file_wread.tell()) file_wread.seek(0) print(file_wread.readline())
(11) file modification
file_mod = open('yesterday', 'r', encoding='utf-8') file_new = open('yesterday_new.bak', 'w', encoding='utf-8') for line in file_mod: if 'Alan' in line: line = line.replace('Alan','FUNG') file_new.write(line) else: file_new.write(line) file_mod.close() file_new.close()
(12) with statement
with open('yesterday', 'r', encoding='utf-8') as file_read : print(file_read.readline())
with open('yesterday', 'r', encoding='utf-8') as file_read : for line in file_read: print(line)
3. Python Functions
A function is a block of code which only runs when it is called.
You can pass data, known as parameters, into a function.
A function can return data as a result.
(1) Function Basics
(2) Creating a Function
In Python a function is defined using the def keyword:
(3) Calling a Function
To call a function, use the function name followed by parenthesis:
(4) Parameters
Information can be passed to functions as parameter.
Parameters are specified after the function name, inside the parentheses. You can add as many parameters as you want, just separate them with a comma.
The following example has a function with one parameter (fname). When the function is called, we pass along a first name, which is used inside the function to print the full name:
(5) Default Parameter Value
The following example shows how to use a default parameter value.
If we call the function without parameter, it uses the default value:
Default Value:
def my_function(country = "Norway"): print("I am from " + country) my_function() my_function("Hong Kong")
(6) Multiple Arguments
Asterisk ['æstərɪsk] 星號, 星號鍵 Multiple Arguments
The asterisk * means multiple arguments. Receive positional parameters (位置參數), and convert into tuples. Positional parameters must be placed before the keyword parameters.
def test(*args): print(args) test(1,2,3,4,5,6) test(*[1,2,3,4,5,6])
1) ** == > dictionay
Receive keyword parameters (關鍵字參數) and Convert into dictionary.
def test2(**kwargs): print(kwargs) test2(name = "alan", age = 28, gender = 'male') test2(**{'name':'alan', 'age':28, 'gender': 'male'})
def test2(**kwargs): print(kwargs) print(kwargs['name']) test2(name = "alan", age = 28, gender = 'male') test2(**{'name':'alan', 'age':28, 'gender': 'male'})
def test3(name, **kwargs): print(name) print(kwargs) test3('alan') test3("alan", age = 28, gender = 'male')
def test4(name, age = 18, *args, **kwargs): print(name) print(age) print(args) print(kwargs) test4('Alan', 27, gender = 'malre', jod = 'analyst')
def test4(name, age = 18, *args, **kwargs): print(name) print(age) print(args) print(kwargs) test4('Alan', 27, 23,4,54, 76, gender = 'malre', jod = 'analyst')
def logger(source): print('From {}'.format(source)) print("From %s" %(source)) def test4(name, age = 18, *args, **kwargs): print(name) print(age) print(args) print(kwargs) logger('TEST-4') test4('Alan', 28, gender = 'male', job = 'analyst')
(7) Return Values (返回值)
To let a function to return a value, use the return statement:
def my_function(x): return x * 5 print(my_function(3)) print(my_function(5)) print(my_function(9))
def my_function(x): print(x * 5) my_function(3) print(my_function(3))
VS 
def func1(): print("This is a function!") def func2(): print('This is another function!') return 0 def func3(): print('This is also a function!') return 1, 'function', ['alan', 'fung'], {'Name': 'AlanFUNG'} func1() print(func1()) func2() print(func2()) func3() print(func3())
(8) Scopes
1) Python Scope Basics
Besides packaging code for reuse, functions add an extra namespace layer to your programs to minimize the potential for collisions among variables of the same name—by default, all names assigned inside a function are associated with that function’s namespace, and no other. This rule means that:
- Names assigned inside a def can only be seen by the code within that def. You cannot even refer to such names from outside the function.
- Names assigned inside a def do not *** with variables outside the def, even if the same names are used elsewhere. A name X assigned outside a given def (i.e., in a different def or at the top level of a module file) is a completely different variable from a name X assigned inside that def.
Variables may be assigned in three different places, corresponding to three different scopes:
- If a variable is assigned inside a def, it is local to that function.
- If a variable is assigned in an enclosing def, it is nonlocal to nested functions.
- If a variable is assigned outside all defs, it is global to the entire file.
Scope Example
# global scope X = 99 # X and func assigned in module: global def func(Y): #Y and Z assigned in function: locals # local scope Z = X + Y # X is a global return Z print(func(1))
The Built-in Scope
import builtins print(dir(builtins)) print(zip) print(zip is builtins.zip)
2) The global Statement
We’ve talked about global in passing already. Here’s a summary:
- Global names are variables assigned at the top level of the enclosing module file.
- Global names must be declared only if they are assigned within a function.
- Global names may be referenced within a function without being declared
X = 88 def func(): global X X = 99 print(func()) print(X)
Program Design: Minimize Global Variables
X = 99 def func1(): global X X = 88 def func2(): global X X = 77 print(func1()) print(X) print(func2()) print(X)
(9) Recursion
Python also accepts function recursion, which means a defined function can call itself.
Recursion is a common mathematical and programming concept. It means that a function calls itself. This has the benefit of meaning that you can loop through data to reach a result.
The developer should be very careful with recursion as it can be quite easy to slip into writing a function which never terminates, or one that uses excess amounts of memory or processor power. However, when written correctly recursion can be a very efficient and mathematically-elegant approach to programming.
In this example, tri_recursion() is a function that we have defined to call itself ("recurse"). We use the k variable as the data, which decrements (-1) every time we recurse. The recursion ends when the condition is not greater than 0 (i.e. when it is 0).
To a new developer it can take some time to work out how exactly this works, best way to find out is by testing and modifying it.
def tri_recursion(k): if (k > 0): result = k + tri_recursion(k-1) print(result) else: result = 0 return result print("\n\n Recursion Example Results") tri_recursion(6)
1) Recursive Functions
Summation with Recursion
def mysum(L): if not L: return 0 else: return L[0] + mysum(L[1:]) # Call myself recursively print(mysum([1,2,3,4,5]))
def mysum(L): print(L) if not L: return 0 else: return L[0] + mysum(L[1:]) # Call myself recursively print(mysum([1,2,3,4,5]))
Coding Alternatives
def mysum(L): return 0 if not L else L[0] + mysum(L[1:]) print(mysum([1])) print(mysum([1,2,3,4,5]))
def mysum(L): if not L: return 0 return nonempty(L) def nonempty(L): return L[0] + mysum(L[1:]) print(mysum([1,2,3,4,5]))
Loop Statements Versus Recursion
L = [1,2,3,4,5] sum = 0 while L: sum += L[0] L = L[1:] print(sum)
L = [1,2,3,4,5] sum = 0 for x in L: sum += x # sum += x print(sum)
Handling Arbitrary Structures
def sumtree(L): tot = 0 for x in L: if not isinstance(x,list): tot += x else: tot += sumtree(x) return tot L = [1, [2, [3,4], 5], 6, [7, 8]] print(sumtree(L))
Recursion versus queues and stacks
def sumtree(L): tot = 0 items = list(L) while items: front = items.pop(0) if not isinstance(front, list): tot += front else: items.extend(front) return tot L = [1, [2, [3,4], 5], 6, [7, 8]] print(sumtree(L))
4 Function Objects: Attributes and Annotations
(1) Indirect Function Calls: “First Class” Objects
def echo(message): print(message) echo("Direct Call")
def echo(message): print(message) x = echo x("Indirect Call")
def echo(message): print(message) def indirect(func, arg): func(arg) indirect(echo, 'Argument Calls!')
def echo(message): print(message) schedule = [(echo, 'Spam!'), (echo, 'Ham!')] for (func, arg) in schedule: func(arg)
def make(label): def echo(message): print(label + " :" + message) print(label, ":", message) return echo F = make("Spam") F("Ham!") F("Eggs!")
(2) Function Introspection
def func(a): b = "spam" return b * a print(func(8))
def func(a): b = "spam" return b * a print(func.__name__) print(dir(func)) print(func.__code__) print(dir(func.__code__)) print(func.__code__.co_varnames) print(func.__code__.co_argcount)
(3) Function Attributes
def func(a): b = "spam" return b * a print(func)
def func(a): b = "spam" return b * a print(func) func.count = 0 func.count += 1 print(func.count) func.handles = "Button-press" print(func.handles) print(dir(func))
def f(): pass print(dir(f)) print(len(dir(f)))
(4) Function Annotations in 3.X
def func(a, b, c): return a + b + c print(func(1, 2, 3))
def func(a:'spam', b:(1,10), c:float) ->int: return a + b + c print(func(1, 2, 3))
5. Anonymous Functions: lambda
(1) lambda Basics
Besides the def statement, Python also provides an expression form that generates function objects. Because of its similarity to a tool in the Lisp language, it’s called lambda.
The lambda’s general form is the keyword lambda, followed by one or more arguments (exactly like the arguments list you enclose in parentheses in a def header), followed by an expression after a colon:
lambda argument1, argument2, ... argumentN : expression using arguments
- lambda is an expression, not a statement.
- lambda’s body is a single expression, not a block of statements.
def func(x, y, z): return x + y + z print(func(2, 3, 4)) f = lambda x, y, z : x + y + z print(f(2,3,4))
x = lambda a = "fee", b = "fie", c = "foe": a + b + c y = (lambda a = "fee", b = "fie", c = "foe": a + b + c) print(x("wee")) print(y(b ="wee"))
def knights(): title = "sir" action = (lambda x : title + ' ' + x) return action act = knights() msg = act('robin') print(msg)
(2) Scopes: lambdas Can Be Nested Too
def action(x): return (lambda y: x + y) act = action(99) print(act) print(act(2))
action = (lambda x: (lambda y: x + y)) act = action(99) print(act(3)) print((lambda x: (lambda y: x + y))(99)(4))
6. Functional Programming Tools
(1) Mapping Functions over Iterables: map
counters = [1, 2, 3, 4] updated = [] for x in counters: updated.append(x + 10) print(updated)
counters = [1, 2, 3, 4] def inc(x): return x + 10 print(list(map(inc, counters)))
counters = [1, 2, 3, 4] print(list(map((lambda x: x + 3), counters)))
def inc(x): return x + 10 def mymap(func, seq): res = [] for x in seq: res.append(func(x)) return res print(list(map(inc, [1, 2, 3]))) print(mymap(inc, [1, 2, 3]))
print(pow(3,4)) print(list(map(pow,[1,2,3], [2,3, 4])))
def inc(x): return x + 10 print(list(map(inc, [1, 2, 3, 4]))) print([inc(x) for x in [1, 2, 3, 4]]) print(list(inc(x) for x in [1, 2, 3, 4]))
(2) Selecting Items in Iterables: filter
print(list(range(-5, 5))) print(list(filter((lambda x: x > 0), range(-5, 5))))
res = [] for x in range(-5, 5): if x > 0: res.append(x) print(res) print([x for x in range(-5, 5) if x > 0])
(3) Combining Items in Iterables: reduce
from functools import reduce # import in 3.x, not in 2.x print(reduce((lambda x, y: x + y), [1,2,3,4])) print(reduce((lambda x, y: x * y), [2,3,4,5])) L = [1, 2, 3, 4] res = L[0] for x in L[1:]: res = res + x print(res)
Coding your own version of reduce is actually fairly straightforward. The following function emulates most of the built-in’s behavior and helps demystify its operation in general:
def myreduce (function, sequence): tally = sequence[0] for next in sequence[1:]: tally = function(tally, next) return tally print(myreduce((lambda x, y : x + y), [1,2,3,4,5])) print(myreduce((lambda x, y : x * y), [1,2,3,4,5]))
import operator, functools print(functools.reduce(operator.add,[2,4,6])) print(functools.reduce((lambda x, y: x + y), [2,4,6]))
浙公网安备 33010602011771号