### 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()并行迭代
### 循环代码的优化
原则：
1.尽量减少不必要的计算
2.尽可能把东西往循环外面放
3.尽量使用局部变量
```python
import time
start=time.time()
for i in range(3000):
result=[]
for m in range(10000):
result.append(i*1000+m*100)
end=time.time()
print("耗时：{0}".format(end-start))
start2=time.time()
for i in range(3000):
result=[]
c=i*1000
for m in range(10000):
result.append(c+m*100)
end2=time.time()
print("耗时：{0}".format(end2-start2))
```
### 其他优化手段
1.连接多个字符，使用join（）而不使用+
2.列表进行元素插入和删除，尽量在列表尾部操作
3.zip（）
degree：默认为2，输入的整数越大，升入的维度越高
ordinal：会返回一列特征
几何概率：与构成事件的长、面积、体积 成比例；
几何概率特点：基本事件 的无限性（抽象）、等可能性；
古典概型特点：基本事件 的有限性（具象）、等可能性；