深浅拷贝：
.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))