### LEGB规则
local指的就是函数的方法内部
Enclosed 指嵌套函数(闭包)
Global指的是模块中的全局变量
Bulit in指的是PYTOHN为自己保留的特殊名称
### LEGB规则
local指的就是函数的方法内部
Enclosed 指嵌套函数(闭包)
Global指的是模块中的全局变量
Bulit in指的是PYTOHN为自己保留的特殊名称
### 嵌套函数
#测试嵌套函数的定义 ```python def outer(): print("outer running") def inner01(): print("inner01 running") inner01() outer()
```
nonlocal 用了声明外层的局部变量
global 用了声明全局变量
def outer(): b=10 def inner(): nonlocal b print("inner b",b) b=20 inner() print("outer b:",b) outer()
### 递归函数的使用
阶乘计算案列
```python
def test01(n): if n == 1: return 1 else: return n * test01(n - 1) result = test01(5) print(result)
```
### 递归函数
自己调用自己的函数
### eval()函数
功能将字符串str当成有效表达式来求职并返回计算结果
语法:
eval(source[,globals[,locals]])-->value
source:一个Python表达式或者函数compile()返回的代码对象
globals:可选,必须是dictionary
locals:可选,任意映射对象
```python
b=2 c=eval("a+b") print(c) dict1=dict(a=100,b=200)#创建一个新的字典 d=eval("a+b",dict1) print(d)
```
时间复杂度
### lambda表达式和匿名函数
语法:lambda arg1,arg2,arg3...:<表达式>
```python
f=(lambda a,b,c:a+b+c) print(f(2,3,4)) g=[lambda a:a*2,lambda b:b**2,lambda c:c/3] print(g[0](5),g[0](3),g[1](3),g[2](7))
```
### 可变参数
1.一个星号,将多个参数放入元组
2.两个星号,多个参数放入字典
### 强制命名参数
```python
def f1(*a,b,c): print(a,b,c) f1(2,b=3,c=4) f1(2,3,4)#会报错,因为,*a把2,3,4,都收入里面,导致b.c没有赋值
```
### 参数的几种类型
1.位置参数
2.默认值参数
3.命名参数
```python
def f1(a,b,c=10): print(a,b,c) f1(8,9,19)#位置参数(同时有默认值参数,19优先与C原本的10) f1(c=10,a=12,b=61)#命名参数,位置可以不同 运行结果:
8 9 19
12 61 10
```
传递不可变对象的时候是浅拷贝
#传递不可变对象时,如果发生拷贝,是浅拷贝 a=10 print("a:",id(a)) def test01(m): print("m:",id(m)) m=20 print(m) print("m:",id(m)) test01(a)
### 浅拷贝和深拷贝
浅拷贝:不拷贝对象的内容,只拷贝子对象的引用
深拷贝:会连子对象的内容也全部拷贝一份,对子对象的修改不会影响源对象
#测试浅拷贝和深拷贝 import copy a=[10,20,[5,6]] b=copy.copy(a) print("a:",a) print("b:",b) b.append(30) b[2].append(7) print("浅拷贝。。。") print("a:",a) print("b:",b)
运行结果:
a: [10, 20, [5, 6]]
b: [10, 20, [5, 6]]
浅拷贝。。。
a: [10, 20, [5, 6, 7]]
b: [10, 20, [5, 6, 7], 30]
2.传递把不可变对象
不可变对象有字符串,数字,元组,function
传递不可变对象时,发生的运行逻辑,由于原对象不可变,会产生一个新的对象
### 参数的传递
1.对可变对象进行写操作
a=[10,20] print(id(a)) print(a) def test01(m): print(id(m)) m.append(300) print(id(m)) test01(a) print(a)
1.全局变量应尽量避免使用
2.局部比全局变量快
3.局部变量和全局变量一样是,系统自动使用局部变量
4.局部变量通过产生栈帧临时保存地址
5.在函数中用golbal声明,则局部变量变为全局变量
返回值
1.默认返回None
2.结束函数运行
printMax(a,b):
形参,在定义时使用
实参,在调用时会用
1.括号内是形参列表,有多个参数要用逗号隔开
2.形参不需要声明类型,也不需要指定函数返回值类型
3.无参数,也必须保留空的圆括号
4.实参列表必须与形参列表一一对应
import turtle t=turtle.Pen() t.circle(50) t.penup() t.goto(0,-50) t.pendown() t.circle(100) t.penup() t.goto(0,-100) t.pendown() t.circle(150) turtle.done()
### 推导式创建序列
#### 列表推导式
[表达式 for item in 可迭代对象]
或者:{表达式 for item in 可迭代对象 if 条件判断}
也可以两个循环
```python
例子1:
y=[x*2 for x in range(1,50) if x%5==0] print(y)
例子2:
cells=[(a,b) for a in range(1,10) for b in range(1,10)] print(cells)
```
#### 字典推导式
{key_expression : value_expression for 表达式 in 可迭代对象}
```python
my_text="i love you,i love sxt,i love gaoqi" char_count={c:my_text.count(c) for c in my_text}#count()表示字符出现的次数 print(char_count)
```
#### 集合推导式
```python
b={x for x in range(1,100) if x%9==0} print(b)
```
#### 生成器推导式
一个生成器只能运行一次,迭代第一次后,再迭代就没有数据了
```python
a=(x for x in range(4)) print(tuple(a))#tuple是生成元组的意思
```
用zip()并行迭代