深浅拷贝：

.copy()方法，浅拷贝值拷贝一层。

列表中的列表和字典会深拷贝，其他类型会浅拷贝。

列表中的列表和字典会随着副本的修改而改变，其他类型不会随着副本的改变为改变。

a=b不是复制，是两个变量共享同一内存空间，一个改变另一个也改变。

a=[[1,2],3,4] b=copy.copy(a)：浅拷贝，c=copy.deepcopy(a)：深拷贝

集合：（重点）

作用：把不同的元素集合在一起,去除重复的内容，是无序的，集合里的元素是可哈希的。

set是可变集合，本身是非可哈希的，不能作为字典的键，

frozenset不可变集合。

集合创建：

s=set('alex li')

访问集合：

由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。

for i in s:

print(i)

集合操作：

s.add（'uu'）：添加一个元素

s.update（'ops'）：当成多个元素添加

s.remove（）：删除元素

s.pop（）：随机删除

s.clear（）：清空集合

del s：删除集合

集合操作符：

intersection（）：交集 {&}

union（）：并集 {|}

difference（）：差集 {-}

symmetric_difference（）对称差集，反向交集 {^}

a.issuperset（b）：a>b 父集

a.issubset（b）：a<b 子集

函数：

作用：减少重复代码；方便修改，更易扩展；保持代码一致性

函数创建：define定义

def 函数名称（）：

函数代码

函数命名规则：

--函数名必须以下划线或字母开头，可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号；

--函数名是区分大小写的。

--函数名不能是保留字。

函数调用一定要加括号。

函数参数：

----必需的参数：

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

def f(name,age):

print('I am %s,I am %d'%(name,age))

f('alex',18)

f('alvin',16)

----关键字参数：

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def f(name,age):

print('I am %s,I am %d'%(name,age))

# f(16,'alvin') #报错

f(age=16,name='alvin')

----缺省参数（默认参数）：默认参数要跟在其他参数后面

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

def print_info(name,age,sex='male'):

print('Name:%s'%name)

print('age:%s'%age)

print('Sex:%s'%sex)

return

print_info('alex',18)

print_info('铁锤',40,'female')

----不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。

加了星号（*）的变量名会存放所有未命名的变量参数。而加(**)的变量名会存放命名的变量参数

不定长参数的位置：

*args无命名参数要放在命名参数的左边；**kargs参数放在右边；默认参数，放最左边

def print_info(*args,**kwargs):

print(args)

#for i in kwargs:

# print('%s:%s'%(i,kwargs[i]))

print(kwargs)

for i in kwargs:

print('%s:%s'%(i,kwargs[i]))

print_info('j','hj',[1,2,3],name='alex',age=12,job='it',hobby='grils')

函数返回值：

return None:默认

return作用：结束函数；返回某个对象

注意：函数没有写return，默认返回None；如果return多个对象，那么会把多个对象封装成一个元祖返回。

=============================================================================

作用域（重要）：L（local） E（enclosing） G（global） B（built_in）

局部作用域不能修改全局作用域。

count=10

def outer():

print(count)

count=5

会出错

局部变量要修改全局变量要加关键字global

count=10

def outer():

global count

print(count)

count=5

print(count)

local作用域要想修改enclosing作用域必须加上nonlocal count

def outer():

count=10

def inner():

nonlocal count

count=20

print(count)

inner()

print(count)

outer()

LEGB

x = int(2.9) # int built-in

g_count = 0 # global

def outer():

o_count = 1 # enclosing

def inner():

i_count = 2 # local

print(o_count)

# print(i_count) 找不到

inner()

outer()

# print(o_count) #找不到

小结：

1、变量查找顺序：LEGB，作用域局部>外层作用域>当前模块中的作用域>Python内置作用域；

2、只有模块、类及函数才能引入新的作用域；

3、对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量；

4、内部作用域要修改外部作用域变量时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字，nonlocal是Python3新增的关键字，有了这个关键字，就能完美的实现闭包了

高阶函数：

函数名可以进行赋值，函数名可以作为参数，还可以函数的返回值

def f(n):

return n*n

print(f(4))

def foo(a,b,func):

return func(a)+func(b)

print(foo(1,2,f))

结果：5

====================

def f():

print('ok')

def bar(a,b,func):

func()

return 1

print(bar(1,2,f))

结果：

ok

1

==================

def foo3():

def inner():

return 8

return inner

foo3()

print(foo3())#返回inner的内存地址

print(foo3()())#返回8

递归函数：

特点：调用自身函数；有一个结束条件

能用递归写的程序循环都可以解决，递归效率在很多时候非常低，不推荐使用

阶乘：

def f(n):

if n==1:

return 1

return n*f(n-1)

print(f(4))

斐波那契数列：

def fibo(n):

before=0

after=1

for i in range(n-1):

ret=before+after

before=after

after=ret

return ret

print(fibo(3))

#**************递归*********************

def fibo_new(n):#n可以为零，数列有［0］

if n <= 1:

return n

return(fibo_new(n-1) + fibo_new(n-2))

print(fibo_new(3))

print(fibo_new(30000))#maximum recursion depth exceeded in comparison

内置函数：

（1）filter:过滤器掉相同的字符

str=['a','b','c','d']

def fun1(s):

if s!='a':

return s

ret=filter(fun1,str)

print(ret) #<filter object at 0x000001A0AF55B940>

print(list(ret)) #['b','c','d']

结果为迭代器（过滤器）对象

（2）map:

str = ['d','a', 'b']

def fun2(s):

return s + "alvin"

ret = map(fun2, str)

print(ret) #<map object at 0x000001D4F52972B0> map object迭代器

print(list(ret)) #['dalvin', 'aalvin', 'balvin']

（3）reduce:叠加

from functools import reduce #Python3使用reduce要加这句话

def add1(x,y):

return x + y

print (reduce(add1, range(1, 10)))## 4950 （注：1+2+...+99）

print (reduce(add1, range(1, 101), 20))

#阶乘

def mul(x,y):

return x*y

print(reduce(mul,range(1,10)))

（4）lambda：

def add(a,b):

return a + b

print add(2,3)

#匿名函数

add = lambda a,b : a + b

print(add(2,3))