深淺拷貝：
.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))
?
)
