python基础（2）

循环代码优化：

• 尽量减少循环中不必要的计算
• 嵌套循环中，尽量减少内层循环的计算次数，尽量往外提
• 局部变量查询较快，尽量使用局部变量

函数

def print_star(n): 
	print("*"*n) 
	
print(print_star) 
print(id(print_star)) 

c = print_star 
c(3)

执行结果： <function print_star at 0x0000000002BB8620>
45844000

---

参数的传递

1. 可变对象进行写操作，直接在原对象上进行修改
2. 不可变对象进行写操作时，先引用原对象，而后创建一个新对象存储操作后的值。 java等语言与python不同，java在写操作时直接拷贝一个原对象。

可变对象：字典、列表、集合、自定义的对象等
不可变对象：int、float、字符串、元组、布尔值、字符串、元组、function 等

浅拷贝与深拷贝

深拷贝

def testDeepCopy(): 
'''测试深拷贝''' 
	a = [10, 20, [5, 6]] 
	b = copy.deepcopy(a) 
	print("a", a) 
	print("b", b) 
	b.append(30) 
	b[2].append(7) 
	print("深拷贝......") 
	print("a", a) print("b", b) 

testCopy() 
print("*************") 
testDeepCopy()

输出：
a [10, 20, [5, 6]]
b [10, 20, [5, 6]]
深拷贝…
a [10, 20, [5, 6]]
b [10, 20, [5, 6, 7], 30]

浅拷贝

传递不可变对象时，不可变对象里包含的子对象是可变的，则方法内修改了这个可变对象，原对象也发生了改变

可变参数

可变参数指的是“可变数量的参数”。分两种情况：

1. 1.*param（一个星号），将多个参数收集到一个“元组”对象中

2. **param（两个星号），将多个参数收集到一个“字典”对象中。

def f1(a,b,*c): 
	print(a,b,c) 
f1(8,9,19,20) 


def f2(a,b,**c): 
	print(a,b,c)
f2(8,9,name='gaoqi',age=18) 


def f3(a,b,*c,**d): 
	print(a,b,c,d) 
f3(8,9,20,30,name='gaoqi',age=18)

执行结果：
8 9 (19, 20)
8 9 {‘name’: ‘gaoqi’, ‘age’: 18}
8 9 (20, 30) {‘name’: ‘gaoqi’, ‘age’: 18}

强制命名参数

在带星号的“可变参数”后面增加新的参数，必须在调用的时候“强制命名参数”。

def f1(*a,b,c): 
	print(a,b,c) 

#f1(2,3,4) #会报错。由于 a 是可变参数，将 2,3,4 全部收集。造成 b 和 c 没有赋值。 

f1(2,b=3,c=4)

输出结果：
(2,) 3 4

lambda 表达式和匿名函数

f = lambda a,b,c:a+b+c 
print(f) 
print(f(2,3,4)) 

g = [lambda a:a*2,lambda b:b*3,lambda c:c*4] 
print(g[0](6),g[1](7),g[2](8))

执行结果：
<function at 0x0000000002BB8620>
9
12 21 32