<> Cyclic structure

Go on .

<>for loop

It is usually used for traversal of iteratable objects .
be careful , When the variables in circulation come out, the extracorporeal circulation will fail
for Circular format :
for variable in Iteratable object : Loop body statement
example :
for x in (1,2,3,4,5): print(x)
For iteratable objects
character string , Output the characters in the string in turn .

Key of dictionary


Dictionary values

Key pair of dictionary

start: Starting value , Do not write default 0;end: End value ;step: step , Default to 1.

<>for Syntactic else

Usage and while Of else equally
for variable in Iteratable object Circulatory body else Statement block
I'm going to do some work :
b=['name','age','type','number'] a=[] for i in range(4): an=input(' Please input {0}:'.
format(b[i])) a.append(an) print(' Input completed ',end='! ') if an=='q': print(' Active exit entry ')
break else: c=dict(zip(b,a)) print(' Input completed , The input result is {0}'.format(c))
normal operation : Will carry out else Statement of

break In this case , Not implemented else Statement in

<>break sentence

Can be used for while and for loop , Used to receive the entire loop , When there are nested loops ,break Statement can only jump out of the nearest layer .

<>continue sentence

End this cycle only , The whole cycle continues .
continue After that, it will be prompted that it will not run .

Here's an example : Pay attention to the output
x=0 while True: x+=1 print(' The third {0} round '.format(x),end='\t') a=input() if a=='q':
print('break,circle is over',end='\t') break else: print('no break','\t') if a
== 'c': print('continue,just jump one circle') continue print('it`s wrong ,
continue isn`t work!') else: print('no break and no continue,a full circle')

<> Nested loop exercise

1. Realize such an array

My way of writing :
for x in range(5): for i in range(5): if i<4: print(x,end='\t') else: print(x,
Writing in class
for x in range(5): for i in range(5): print(x,end='\t') print()
Still young , I didn't expect to go straight print() Empty output for line feed
2. Print the multiplication table below

My way of writing
for x in range(1,10,1): for i in range(1,x+1,1): print(str(x),'*',str(i),'=',x*
i,end='\t') print()

What we talked about in class is used .format To format the output

3. Use lists and dictionaries to store the following information , And print out the salary higher than 15000 Data for

I wrote it :
l1={'name':' Gao Xiaoyi ',' Age ':'18',' salary ':30000,' city ':' Beijing '} l2={'name':' Gao Xiaoer ',' Age ':'19',
' salary ':20000,' city ':' Shanghai '} l3={'name':' Gao Xiaowu ',' Age ':'20',' salary ':10000,' city ':' Shenzhen '} a=[l1,l2,
l3] for x in a: if x.get(' salary ')>=15000: print(x)

The idea is the same this time , Don't write the code in class .

<> Optimization of loop code

1. Minimize unnecessary calculations within the loop ;
2. In nested loop, forgive and reduce the calculation of inner layer , Take the calculation out ;
3. Fast algorithm of local variable query , Try to use local variables .

<> use zip() Do parallel iterations

There are other ways to do it , It's just that zip This effect can be achieved

<> Inferential creation sequence

<> List derivation

Generate list objects
[ expression for item in Iteratable object ] a=[x**2 for x in range(1,5,1)] print(a)

[ expression for item in Iteratable object if Conditional judgment ] a=[x**2 for x in range(1,10,1) if x%2==0] print

The more complicated ones can even be written :
a=[(x,y)for x in range(3) for y in range(3)] print(a)

Whole life
a=['{0}*{1}={2}'.format(x,y,x*y) for x in range(1,10,1) for y in range(1,x+1,1)
] count=0 for i in range(0,9,1): for b in range(0,i+1,1): print(a[count],end=' '
) count+=1 print() print(' multiplication table ')

<> Dictionary derivation

Generate dictionary object
{key_expression : value_expression for expression in Iteratable object } a1=['name','age','type']
a2=['temmie',23,'dog'] a={a1[i]:a2[i] for i in range(2)} print(a)

A more useful example was given in class : Count the number of letters in a sentence :
text='i am temmie!temmie!!temmie!!!' a={c:text.count(c) for c in text} print(a)
Because the key of the dictionary cannot be repeated , So all the characters should have appeared , But each character appears only once .

<> Set derivation
{expression for expression in Iteratable object }
It's like a dictionary , I won't show it here .

<> Generator derivation ( Generating tuples )

be careful : The generator can be run only once . A generator is an iterative object , It can be used as an iterative object .
gnt=(x for x in range(1,100) if x%9==0) for x in gnt: print(x,end=' ')

<> practice : Draw concentric circles of different colors

First, add the grammar of two little turtles :
1. You can assign variables to simplify the input :t=turtle.Pen(), In this way, it can be written directly when called later t.circle To simplify the input code .
2.turtle.done() You can keep the drawn window open ( In the past, my screenshots were all closed debug Here's a screenshot , Gan !)
3.turtle.speed() To set the drawing speed
import turtle as t t.width('5') t.speed(0) co=('red','orange','yellow','green',
'cyan','blue','purple') for i in range(1,7,1): t.color(co[i]) t.penup() t.goto(0
,-50*i) t.pendown() t.circle(50*i) t.done()

<> practice : Draw chessboard
import turtle as t t.width('5') t.speed(0) for f in range(0,2,1): for i in
range(0,5,1): if f==0: t.penup() t.goto(-100,50*i) t.pendown() t.goto(100,50*i)
else: t.penup() t.goto(50*(i-2),0) t.pendown() t.goto(50*(i-2),200) t.done()

<> function

Functions are reusable blocks of program code . It's the encapsulation of the code , Added function call , Transfer parameters , Return calculation results and other contents .
Query function documents can be used :
help( Function name .__doc__)

<>python Classification of functions in

1. Built in functions : All we can use directly are built-in functions
2. Standard library functions : We passed import Import library , And then use the function .
3. Third party library function : Download and install in the community , use import Imported third party functions .
4. User defined function : We create our own functions .

<> How to define function :
def Function name ([ parameter list ]): ''' Document string ( Explanatory notes )''' Function body / Several sentences
For multiple parameters **,** separate . Function should be preserved without parameters .
example :
def temmie(n): for i in range(1,n+1,1): print('temmie','!'*i)

<> Formal parameter and actual parameter

Formal parameters are used when defining functions , Is a local variable , The part beyond the function will be invalid . Formal parameters do not need to specify a type , The actual parameter and the formal parameter should be corresponding one by one .
def Function name ( Formal parameter 1, Formal parameter 2…)
The argument is when the function is called , The parameters passed are called arguments .
Function name ( Actual parameters 1, Actual parameters 2…)

<> The return value of the function

return Statement can be written or not , Do not write default return None.
Use time format :return expression
return The following statement is not executed .
object = Function name ( Actual parameters ), This gives the return value to the object .
A function is also an object , You can also not pass it to other variables , Use directly as an object .
When multiple values are to be returned , You can use the list , Dictionary to return multiple data .

<> Global variable and local variable ( Scope of variable )

The module in which a variable works is called the scope of the variable . The variables with the same name in different scopes have no influence on each other .
global variable ::
 1. Variables declared outside function and class definitions . The scope is the defined module , Start from the defined position until the end of the module ;
 2. Global variables reduce the versatility and readability of functions , The use of global variables should be avoided as far as possible ;
 3. Global variables are generally used as constants ;
 4. Function to change the value of the global variable , Need to use global Make a statement ;
local variable ::
 1. In function body ( Include formal parameters ) Declared variables ;
 2. References to local variables are faster than references to global variables , Priority to use ;
 3. If the local variable has the same name as the global variable , This hides global variables within the function , Use only local variables with the same name . If you want to use it, use it global Let's make a statement .
Output Global , local variable
Use the following statement
print(locals()) print(globals()) a=100 b=200 def temmie_num(): a=1000 print(a)
global b b=400 print(' This is a local variable ',locals()) print(' This is a global variable ',globals()) temmie_num()

<> Transfer of parameters

The parameter passing of function is essentially : Assignment operation from real parameter to formal parameter .
1. For variable objects
Dictionaries , list , aggregate , Custom objects, etc , The delivery operation is actually the address of the delivered content . Is to operate on the same object .
2. For immutable objects
number , character string , tuple ,function etc. , The pass operation creates a new object .
a=100# number , Immutable object b=[200]# list , Variable object print(type(a),type(b)) print('a And b Your address ',id(a),id(b
)) def temmie(m,n): print('m And n Your address ',m,id(m),n,id(n),' Address passed in ') m=m*2 n.append(20)
print('m And n Your address ',m,id(m),n,id(n)) temmie(a,b)#a It's immutable ,b It's a variable object print(a,b)

But I had a little doubt when I tried , If the list operation is changed to n=n*2 In my words , Its address will change .

<> Shallow copy (copy) And deep copy (deepcopy)

Shallow copy : Do not copy the contents of the sub object , It's just a reference to a child object .
Deep copy : Even the memory of the sub object will be copied , Modifications to child objects do not affect the source object .
Need to import when using copy modular
Let's test it with code :
import copy a=[10,20,[30,40]] b=[50,60,[70,80]] a_c=copy.copy(a) b_c=copy.
deepcopy(b) a_c[2][1]=100 print(a,'\n',a_c) b_c[2][1]=100 print(b,'\n',b_c)
print('a Element address of :',a[0],':',id(a[0]),a[1],':',id(a[1]),a[2][0],':',id(a[2][0]),a[2]
[1],':',id(a[2][1])) print('a_c Element address of :',a_c[0],':',id(a_c[0]),a_c[1],':',id(a_c[1
]),a_c[2][0],':',id(a_c[2][0]),a_c[2][1],':',id(a_c[2][1])) print('b Element address of :',b[0]
print('b_C Element address of :',b_c[0],':',id(b_c[0]),b_c[1],':',id(b_c[1]),b_c[2][0],':',id(
result :

Now I'll show my understanding with pictures and pictures :

in other words , If list a There is a small book , This little book remembers how many elements it contains , Where are the elements , Shallow copy is just a list a It's a copy of the same one , And the list a List contained in b My little book is the same as before ; A deep copy copies all the books .

<> Several types of parameters

<> Location parameter

Function call , Arguments are passed in positional order by default , Number and parameter matching is required . Parameters passed by location , be called : Location parameter

<> Default value parameter

for example :def fuction1(a,b,c=1,d=2)
this side c and d This is the default parameter , These values are used by default if they are not given when the function is called , If given, the input value is used . The default parameter must be placed at the end

<> Named parameters

as :def fuction1(a,b,c)
Write on call fuction(c=1,b=2,a=10) Then and write fuction(10,2,1) The effect is the same , But it can be written out of order .

<> Variable parameters

* *param, Collect multiple parameters into a tuple object .
* **param, Collect multiple adoption numbers into a dictionary object . def temmie(a,b,*c): print(a,b,c) def temmie01(a,b,
**c): print(a,b,c) temmie(1,2,3,4,5,6) temmie01(1,2,name='temmie',age=23)
# Pay attention to the way the dictionary says it !!

<> Forcing named parameters

For the above variable parameters , If it comes first , There will be values that do not know from where to which belong to this variable parameter , So if the function is defined as :
*def fuction01(a,b,c)
In this form , Call should write :
Write the name in this way , Everything else is not specified *a Content of .

<>lambda Expressions and anonymous functions

lambda Expressions can be used to declare anonymous functions , It's a simple way , How to define a function on the same line .
lambda Only one expression is allowed , Cannot contain complex statements , The result of the expression is the return value of the function .
lambda arg1,arg2...:< expression >
arg1,arg2… Equivalent to the parameters of a function ,< expression > Equivalent to function body .

<>eval function

String str Evaluates as a valid expression and returns the result of the evaluation .
eval(source[, globals[, locals]]) -> value
Let's do the whole job :
while True: message=input('temmie say:') if message=='q': print('tteemmiiee
say:see ya!!!!',end='') break else: print('tteemmiiee alsooo say:',end='') eval(

<> Recursive function

Recursive functions refer to : Call your own functions , Call yourself directly or indirectly inside the function body .
Each recursive function must contain the following two parts :1. Termination conditions : Indicates when the recursion ends , Generally used for return values , Don't call yourself again ;2. recursive procedure : Put the first n The value of step and step n-1 Step correlation .
Recursive functions take up a lot of resources , Use with care .
example : Calculate factorial
def fuction01(n): if n==1: return 1 else: return n*fuction01(n-1) a=fuction01(5
) print(a)

<> Nested function ( Internal function )

A function defined inside a function
this is it :
def outer_fuction(): Code block def inner_fuction(): Code block inner_fuction()# The outer function calls the inner function
outer_fuction()# Using external functions
be careful , An internal function can only be used by this external function , The inner function cannot be called from another location .
effect : encapsulation : Nested functions cannot be accessed externally .2. Avoid code duplication inside functions .3. closure ( Not for the time being )