day3

1. 函數基本語法及特性

2. 參數與局部變量

3. 返回值

嵌套函數

4.遞歸

5.匿名函數

6.高階函數

7.內置函數

 

集合

a = {1,2,3,4}
b = {3,4,5,6}
print(a.symmetric_difference(b))#去掉相同的數據，保留不一樣的數據
print(a.difference(b))#a有，b沒有
print(a.union(b))#a並b
print(a.intersection(b))#a交b

字典

key-value對

1. 特性：
2. 無順序
3. 去重
4. 查詢速度快，比列表快多了
5. 比list佔用內存多

hash類型，查詢速度很快

先說python2

1. py2裏默認編碼是ascii
2. 文件開頭那個編碼聲明是告訴解釋這個代碼的程序 以什麼編碼格式 把這段代碼讀入到內存，由於到了內存裏，這段代碼實際上是以bytes二進制格式存的，不過即便是2進制流，也能夠按不一樣的編碼格式轉成2進制流，你懂麼？
3. 若是在文件頭聲明瞭#_*_coding:utf-8*_，就能夠寫中文了， 不聲明的話，python在處理這段代碼時按ascii，顯然會出錯， 加了這個聲明後，裏面的代碼就全是utf-8格式了
4. 在有#_*_coding:utf-8*_的狀況下，你在聲明變量若是寫成name=u"大保健"，那這個字符就是unicode格式，不加這個u,那你聲明的字符串就是utf-8格式
5. utf-8 to gbk怎麼轉，utf8先decode成unicode,再encode成gbk

再說python3

1. py3裏默認文件編碼就是utf-8,因此能夠直接寫中文，也不須要文件頭聲明編碼了，乾的漂亮
2. 你聲明的變量默認是unicode編碼，不是utf-8, 由於默認便是unicode了（不像在py2裏，你想直接聲明成unicode還得在變量前加個u）, 此時你想轉成gbk的話，直接your_str.encode("gbk")便可以
3. 但py3裏，你在your_str.encode("gbk")時，感受好像還加了一個動做，就是就是encode的數據變成了bytes裏，我擦，這是怎麼個狀況，由於在py3裏，str and bytes作了明確的區分，你能夠理解爲bytes就是2進制流，你會說，我看到的不是010101這樣的2進制呀， 那是由於python爲了讓你能對數據進行操做而在內存級別又幫你作了一層封裝，不然讓你直接看到一堆2進制，你能看出哪一個字符對應哪段2進制麼？什麼？本身換算，得了吧，你連超過2位數的數字加減運算都費勁，還仍是省省心吧。　　
4. 那你說，在py2裏好像也有bytes呀，是的，不過py2裏的bytes只是對str作了個別名(python2裏的str就是bytes, py3裏的str是unicode)，沒有像py3同樣給你顯示的多出來一層封裝，但其實其內部仍是封裝了的。 這麼講吧， 不管是2仍是三， 從硬盤到內存，數據格式都是 010101二進制到-->b'\xe4\xbd\xa0\xe5\xa5\xbd' bytes類型－－>按照指定編碼轉成你能看懂的文字

編碼應用比較多的場景應該是爬蟲了，互聯網上不少網站用的編碼格式很雜，雖然總體趨向都變成utf-8，但如今仍是很雜，因此爬網頁時就須要你進行各類編碼的轉換，不過生活正在變美好，期待一個不須要轉碼的世界。

最後，編碼is a piece of fucking shit, noboby likes it.

 

函數是什麼?

函數一詞來源於數學，但編程中的「函數」概念，與數學中的函數是有很大不一樣的，具體區別，咱們後面會講，編程中的函數在英文中也有不少不一樣的叫法。在BASIC中叫作subroutine(子過程或子程序)，在Pascal中叫作procedure(過程)和function，在C中只有function，在Java裏面叫作method。

定義: 函數是指將一組語句的集合經過一個名字(函數名)封裝起來，要想執行這個函數，只需調用其函數名便可

特性:

1. 減小重複代碼
2. 使程序變的可擴展
3. 使程序變得易維護

 

def sayhi(): #函數名

     print ( "Hello, I'm nobody!" )

 

sayhi() #調用函數

 

帶參數

def sayhi(a,b):
    print('hello %s %s'%(a,b))

sayhi('ronghui','jiangyijing')

2.函數參數與局部變量　　

形參變量只有在被調用時才分配內存單元，在調用結束時，即刻釋放所分配的內存單元。所以，形參只在函數內部有效。函數調用結束返回主調用函數後則不能再使用該形參變量

實參能夠是常量、變量、表達式、函數等，不管實參是何種類型的量，在進行函數調用時，它們都必須有肯定的值，以便把這些值傳送給形參。所以應預先用賦值，輸入等辦法使參數得到肯定值

 

默認參數

 

def stu(age,name,city='sh'):
 print('%s %s %s' %(name,age,city))

stu(25,'rh')

關鍵參數

正常狀況下，給函數傳參數要按順序，不想按順序就能夠用關鍵參數，只需指定參數名便可，但記住一個要求就是，關鍵參數必須放在位置參數以後。

 

stu(age = 22 ,name = 'rh' ,city = "python" ,)

非固定參數

def stu_register(name,age, * args): # *args 會把多傳入的參數變成一個元組形式

     print (name,age,args)

 

stu ( "Alex" , 22 )

#輸出

#Alex 22 () #後面這個()就是args,只是由於沒傳值,因此爲空

 

stu( "Jack" , 32 , "CN" , "Python" )

#輸出

# Jack 32 ('CN', 'Python')

 

 

 

還能夠有一個**kwargs

def stu(name,age, * args, * * kwargs): # *kwargs 會把多傳入的參數變成一個dict形式

     print (name,age,args,kwargs)

 

stu( "Alex" , 22 )

#輸出

#Alex 22 () {}#後面這個{}就是kwargs,只是由於沒傳值,因此爲空

 

stu( "Jack" , 32 , "CN" , "Python" ,sex = "Male" ,province = "ShanDong" )

#輸出

# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

name = "Alex Li"

 

def change_name(name):

     print ( "before change:" ,name)

     name = "金角大王,一個有Tesla的男人"

     print ( "after change" , name)

 

 

change_name(name)

 

print ( "在外面看看name改了麼?" ,name)

 

before change: Alex Li

after change 金角大王,一個有Tesla的男人

在外面看看name改了麼? Alex Li

 

全局與局部變量

在子程序中定義的變量稱爲局部變量，在程序的一開始定義的變量稱爲全局變量。

全局變量做用域是整個程序，局部變量做用域是定義該變量的子程序。

當全局變量與局部變量同名時：

在定義局部變量的子程序內，局部變量起做用；在其它地方全局變量起做用。

 

3.返回值　

要想獲取函數的執行結果，就能夠用return語句把結果返回

注意:

1. 函數在執行過程當中只要遇到return語句，就會中止執行並返回結果，so 也能夠理解爲 return 語句表明着函數的結束
2. 若是未在函數中指定return,那這個函數的返回值爲None

 

嵌套函數　

list_qiantao = [1,13,25,21,41,16,28,999,321]
print(list_qiantao)
def test(x):
 for i in range(len(x)):
 temp=0
 for i in range(len(x)-1):
 if x[i]>x[i+1]:#當前一個比後一個大時，互換位置
 temp=x[i]
 x[i]=x[i+1]
 x[i+1]=temp

 print(i,'---',x)

test(list_qiantao)

遞歸

遞歸特性:

1. 必須有一個明確的結束條件

2. 每次進入更深一層遞歸時，問題規模相比上次遞歸都應有所減小

3. 遞歸效率不高，遞歸層次過多會致使棧溢出（在計算機中，函數調用是經過棧（stack）這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。因爲棧的大小不是無限的，因此，遞歸調用的次數過多，會致使棧溢出）

 

遞歸函數實際應用案例，二分查找

list_qiantao = [1,13,25,21,41,16,28,999,321,2]
def two_half(datalist,num):

 datalist=sorted(datalist)
 print(datalist)
 if len(datalist) > 1:
 mid = int(len(datalist)/2)
 if datalist[mid] == num:
 print('find it')
 print(datalist[mid])
 elif datalist[mid] > num:
 print("zai zuo bian")
 print(datalist[0:mid])
 return two_half(datalist[0:mid],num)
 else:
 print("zai you bian")
 print(datalist[mid+1:])
 return two_half(datalist[mid+1:],num)
 else:
 if datalist[0] == num:
 print("find it")
 else:
 print('mei you zhe ge shu zi')

two_half(list_qiantao,25)

匿名函數

#這段代碼

def calc(n):

     return n * * n

print (calc( 10 ))

 

#換成匿名函數

calc = lambda n:n * * n

print (calc( 10 ))

 

 

res = map ( lambda x:x * * 2 ,[ 1 , 5 , 7 , 4 , 8 ])

for i in res:

     print (i)

 

高階函數

def add(x,y,f):

     return f(x) + f(y)

 

 

res = add( 3 , - 6 , abs )

print (res)

 

8. 內置參數　　

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:rh
 user = 'rh'
 passwd = 'abc'
 def auth(auth_type):
 def out_wrapper(func):
 def wrapper(*args,**kwargs):
 if auth_type == 'local':
 username = input('username:')
 password = input('password:')
 if username == user and password == passwd:
 print('\033[32;1mWelcome to your home\033[0m')
 res = func(*args,**kwargs)
 print('after authentication!')
 return res
 else:
 print('\033[31;1mIvalid username or password\033[0m')
 elif auth_type == 'ldap':
 username = input('username:')
 password = input('password:')
 if username == user and password == passwd:
 print('\033[31;1mlao zi buhui ladp\033[0m')
 else:
 print('invalid username or password')

 return wrapper
 return out_wrapper



 def index():
 print('in then index')

 @auth(auth_type='local')
 def home():
 print('in the home')
 return 'from home'

 @auth(auth_type='ldap')
 def bbs():
 print('in the bbs')
 return 'from bbs'

 index()
 print(home())
 bbs()

 print(all([1,-2]))#可迭代對象，若是有0返回false
 print(any([0,1,2,3]))#有一個真，就就是真
 print(type(ascii([1,2])))#str將列表變成字符串
 print(bin(4))#吧數字轉成二進制
 print(bool(0))
 a = bytes('abc',encoding='utf-8')
 print(a)
 def sayhi():
 pass
 print(callable(sayhi))#是否可調用

 print(chr(98))#吧數字轉成ASCII碼錶示成英文
 print(ord('A'))#吧英文字母轉成數字
 code = 'for i in range(10):print(i)'
 exec(code)

 print(dir(sayhi))#返回方法
 print(divmod(5,3))#5/3=1餘2
 x=1
 print(eval('x+1'))#執行字符串中的內容

 calc = lambda x:print(x)
 calc(5)

 c = map(lambda x:x*x,range(10))#對全部的數據處理，並返回
 print(type(c))
 for i in c:
 print(i)

 d = filter(lambda n:n>5,range(10))#過濾符合條件的值
 print(type(d))
 for i in d:
 print(i)

 res = [i*2 for i in range(10)]
 for i in res:
 print(i)
 x=2
 e = '3 if x>5 else 2'
 print(eval(e))

 import functools
 res = functools.reduce(lambda x,y:x*y,range(1,10))
 print(res)

 a = frozenset([1,2,3,4])#不可變列表 至關於元組 print(globals())#判斷變量是否存在 a = globals() b = list(a) print(b) if 'res' in b: print('ok') print(hash('a')) def test(): local_var = 333 print(locals()) test() print(globals()) print(globals().get('local_var')) print(max([1,2,3,4])) #next()=__next__() print(hex(15)) print(oct(15)) print(pow(3,3))#3的3次方 print(repr(c))#字符串 for i in reversed([1,2,3]): print(i) print(round(1.3232,2))#保留兩位小數 d=range(20) d=d[slice(2,5)] print(d) a = {6:2,8:0,1:4,-5:6,99:11,4:22}#字典 無序 print(a) print(sorted(a.items())) print(sorted(a)) print(sorted(a.items(),key=lambda x:x[0])) print(sum([1,2,3])) a=[1,2,3,4] b=['a','b','c','d'] for i in zip(a,b): print(i) ls = [1,2,3] rs = map(str, ls) for i in rs: print(type(i)) lt = [1, 2, 3, 4, 5, 6] def add(num): return num + 1 rs = map(add, lt) for i in rs: print(i)import decorator__import__('decorator')