函數

函數式：將某功能代碼封裝到函數中，日後便無需重復編寫，僅調用函數即可

面向對象：對函數進行分類和封裝，讓開發“更快更好更強...”

函數式編程最重要的是增強代碼的重用性和可讀性

def  xx():
    print(‘xx‘)   # 定義函數，放入內存當中，並不立即執行
    
#執行函數
xx()  #調用函數，這時內存中的函數才開始執行，輸出XX

函數的定義主要有如下要點：

• def：表示函數的關鍵字
• 函數名：函數的名稱，日後根據函數名調用函數
• 函數體：函數中進行一系列的邏輯計算，如：發送郵件、計算出 [11,22,38,888,2]中的最大數等...
• 參數：為函數體提供數據
• 返回值：當函數執行完畢後，可以給調用者返回數據。

返回值

函數是一個功能塊，該功能到底執行成功與否，需要通過返回值來告知調用者。

參數

函數的有三中不同的參數：

• 普通參數
• 默認參數:有默認參數一定要放在後面
• 動態參數

形參，實參（默認，按照順序）

指定形參傳入實參，可以不按照順序

動態參數

#動態參數  一個星號
def f1(*a):
    print(a,type(a))
li=[1,2,3,4]
f1(li)   #  輸出  ([1, 2, 3, 4],) <class ‘tuple‘> 輸出元組會將列表當成一個元素
f1(*li)  #  輸出   (1, 2, 3, 4) <class ‘tuple‘>  輸出元組會將列表的每一個元素當成元組的每一個元素
 

f1(123)
f1(123,[4,5,6],{‘k1‘:‘43n‘},(1,2,3),{1,2,3})  #可傳任意多的參數，而且還可以時不同類型的參數
#返回的是元組的類型


#動態參數  兩個星號
def f2(**a):
    print(a,type(a))
f2(k1=123,k2=456)
#輸出 {‘k1‘: 123, ‘k2‘: 456} <class ‘dict‘>
f2(k1=123,k2=456,k3=1212)
#輸出  {‘k1‘: 123, ‘k2‘: 456, ‘k3‘: 1212} <class ‘dict‘>
# 返回的是字典類型，默認輸出以鍵值對的形式
 

dic={‘k1‘:123}  # 也可以將字典直接傳進去
f2(**dic)  # 但需要再在前面加入兩個星號，否則必須要f2(k1=dic) 形式傳入
f2(k1=dic)
#    上面的兩條調用的輸出結果分別為
#   {‘k1‘: 123} <class ‘dict‘>  #  這樣可以避免引入額外的參數  ‘k1=‘
#   {‘k1‘: {‘k1‘: 123}} <class ‘dict‘>

#各種參數組合起來
def f3(p,k1=23,*a,**aa):
    print(p,type(p))
    print(k1,type(k1))
    print(a,type(a))
    print(aa,type(aa))
f3(11,22,33,44,[00,55,66],k2=456,k3=000)

‘‘‘ 輸出結果為：11 <class ‘int‘>  p接收
            22 <class ‘int‘> 給k1傳了值，所以k1的默認值將會被改變
            (33, 44, [0, 55, 66]) <class ‘tuple‘>  *a 接收住
            {‘k2‘: 456, ‘k3‘: 0} <class ‘dict‘>  **a接收
‘‘‘

局部變量和全局變量

在函數內部 修改和找到全局變量 要用關鍵字聲明 global(變量) ,全局變量都大寫，局部變量都小寫

lambda 表達式

f2=lambda : 123 函數的另一種表達方式 ，函數名f2就是個變量

def f3(a1,a2):
    return a1+a2


f3=lambda a1,a2:a1+a2   #  對於簡單的函數，用一個簡單的一句話就能表示

python 內置函數

# all() 循環參數，如果每個參數都為真，那麽all的返回值為真
print(all([True,False,True]))  # 輸出False 
print(all([True,True,True]))   #輸出True
# 0,None,空值都為假的，其他都為真的

# any() 只要一個為真即為真
print(any([True,False,True]))  # 輸出True

#ascii(對象) 對象的類中找__repr__,獲取其返回值

# bin()二進制  hex()十六進制 oct()八進制 int ()十進制
print(int(‘0b11‘,base=2)) # 二進制轉化為十進制
print(int(‘0o11‘,base=8)) # 八進制轉化為十進制
print(int(‘0x11‘,base=16)) # 十六進制轉化為十進制

#bytes 字節 bytearray (字節列表)
#chr(數字)找到數字對應ascii碼  ord(ascii碼) 找到ascii碼所對應的數字
# 例子 隨機驗證碼
import random
temp=‘‘
for i in range(6):
    num1=random.randrange(0,4)
    if num1==3 or num1 == 1:
        red2=random.randrange(0,10)
        temp += str(red2)
    else:
        red1=random.randrange(65,91)
        c=chr(red1)
        temp += c
print(‘驗證碼:‘,temp)
    
# callable(f1) 判斷f1()是不是可執行的 ,是返回True 
#compile() 編譯 complex() 復數  dir() 查看對象的方法
# divmod()
print(divmod(10,3))  #  輸出(3,1)  商和余數
# eval() exec() 
print(eval(‘1+3‘))    #輸出4 
exec(‘for i in range(10):print(i)‘) #將字符串當成python代碼執行，沒有返回值

# filter(函數，可叠代的對象) 篩選元素
def f1(x): #篩選偶數
    if x%2 == 0:
        return True
ret=filter(f1,[11,22,33,44]) #篩選  等同於  filter(lambda x: x%2==0,[11,22,33,44])
for i in ret:
    print(i)   #輸出 22，44

#map() 按照某種規則映射 
ret=map(lambda x: x +100,[1,2,3,4])
for i in ret:
    print(i) # 輸出 101，102，103，104
# globals() #獲取全部的全局變量   locals()獲取全部的局部變量
#hash() 哈希值  幫助快速找到對應的值

#zip()
li1=[11,22,33,44]
li2=[‘a‘,‘b‘,‘c‘,‘d‘]
li3=[‘A‘,‘B‘,‘C‘,‘D‘]
r=zip(li1,li2,li3)
for i in r:
    print(i)(11, ‘a‘, ‘A‘)
‘‘‘ 輸出
(22, ‘b‘, ‘B‘)
(33, ‘c‘, ‘C‘)
(44, ‘d‘, ‘D‘)
‘‘‘

排序

字符串和數字不能混在一起排序 ，字符串排序時，字符串中的排序順序為：數字（正常比較），字母(ascii碼)，中文（轉化為16進制）

文件操作

open(文件名，模式，編碼)

打開文件時，需要指定文件路徑和以何等方式打開文件，打開後，即可獲取該文件句柄，日後通過此文件句柄對該文件操作。

打開文件的模式有：

• r ，只讀模式【默認】
• w，只寫模式【不可讀；不存在則創建；存在則清空內容；】
• x， 只寫模式【不可讀；不存在則創建，存在則報錯】
• a， 追加模式【不可讀； 不存在則創建；存在則只追加內容；】

"+" 表示可以同時讀寫某個文件

• r+， 讀寫【可讀，可寫】 :寫、追加時指針到最後,f.tell() 獲取指針的位置,讀,0開始讀,寫:只要讀過(不管都沒讀完),最後位置追加,如果從特定位置往後寫,需要主動seek尋找位置
• w+，寫讀【可讀，可寫】 ：寫之前先清空，再寫之後就可以讀了,但需要把指針返回到最初位置f.seek(0)
• x+ ，寫讀【可讀，可寫】 :如果文件存在會報錯,這是和W+的區別
• a+， 寫讀【可讀，可寫】 : 打開的同時把指針移到最後，等待追加,f.seek(0)返回到起始位置

"b"表示以字節的方式操作

• rb 或 r+b
• wb 或 w+b
• xb 或 w+b
• ab 或 a+b

註：以b方式打開時，讀取到的內容是字節類型，寫入時也需要提供字節類型

truncate() #截取文件內容，依賴於指針的位置 flush # 將內存的數據刷進硬盤中

f1=open(‘text.txt‘,‘r‘)
for line in f1:  # 一行一行讀直到讀完
    print(line)
f1.close   #  每次打開都要close一次

with open(‘text.txt‘,‘r‘) as f: # 自動幫你close()
    f.read()

#同時打開兩個文件，讀一行寫一行，內存的消耗將會降低    
with open(‘text.txt‘,‘r‘) as f2,open(‘text1.txt‘,‘w‘) as f3:
    for line in f2:
        f3.write(line)

冒泡排序

li=[1,123,43,56,78,90,23,34589,234]
inp=1
while(inp<len(li)):
    for i in range(len(li)-inp):
        if li[i] < li[i+1]:
            temp=li[i]
            li[i]=li[i+1]
            li[i+1]=temp
    inp += 1
print(li)    

例子：用戶登錄

def login(username,password):
    ‘‘‘
    用於用戶名密碼的驗證
    username 用戶名
    password 用戶名密碼
    返回值：True表示登陸成功
    返回值: False 表示登錄失敗
    ‘‘‘
    with open(‘text.txt‘,‘r‘) as f:
        for line in f:
            line=line.strip() #默認strip無參數，移除空格、換行符
            #有參數，移除兩端指定的值
            line_list=line.split(‘$‘)
            if username == line_list[0] and password == line_list[1]:
                return True
    return False    
def register(username,password):
    if user_exist(username):
        return False
    else:
        with open(‘text.txt‘,‘a+‘) as f:
            user_list=‘\n‘+username+‘$‘+password
            f.write(user_list)
        return True
    
    
def user_exist(username):
    with open(‘text.txt‘,‘r‘) as f:
        for line in f:
            line=line.strip()
            line_list=line.split(‘$‘)
            if username == line_list[0]:
                return True
    return False
def user_modif(username,new_password):
    for i in new_password:
        if i == ‘@‘ or i == ‘#‘ or i==‘$‘:
            print(‘[email protected]#、$‘)
            return False
    with open(‘text.txt‘,‘r‘) as f1:
        lines=f1.readlines()
    with open(‘text.txt‘,‘w‘) as f2:
        for line in lines:
            line_list=line.split(‘$‘)
            if username == line_list[0]:
                new_line=line_list[0]+‘$‘+new_password+‘\n‘
                f2.write(new_line)
            else:
                f2.write(line)
    return True
def user_del(username):
    with open(‘text.txt‘,‘r‘) as f1:
        lines=f1.readlines()
    with open(‘text.txt‘,‘w‘) as f2:
        for line in lines:
            line_list=line.split(‘$‘)
            if username == line_list[0]:
                continue
            else:
                f2.write(line)
    return True    
#print(inp)
while(True):
    print(‘歡迎登陸幸福之門系統\n‘)
    inp=input(‘1:登陸，2:註冊,3:修改密碼，4：註銷賬戶,5:退出\n‘)
    if inp == ‘1‘:
        user=input(‘請輸入用戶名：‘)
        pwd=input(‘請輸入密碼：‘)
        if login(user,pwd):
            print(‘登陸成功！‘)
        else:
            print(‘登錄失敗!‘)
    elif inp == ‘2‘:
        user=input(‘請輸入用戶名：‘)
        pwd=input(‘請輸入密碼：‘)
        if register(user,pwd):
            print(‘註冊成功！‘)
        else:
            print(‘註冊失敗！‘)

    elif inp == ‘3‘:
        user=input(‘請輸入你想修改密碼得用戶名：‘)
        password=input(‘請輸入原來賬戶名得密碼‘)
        if login(user,password):
            new_password=input(‘請輸入新的密碼‘)
            if new_password == password:
                print(‘你輸入得密碼和原密碼相同不用修改！‘)
            else:
                if user_modif(user,new_password):
                    print(‘修改成功！‘)
                else:
                    print(‘修改失敗!‘)
        else:
            print(‘輸入密碼錯誤無法修改!‘)
    elif inp == ‘4‘:
        user=input(‘請輸入你想註銷得用戶名：‘)
        password=input(‘請輸入賬戶名密碼‘)
        if login(user,password):
            if user_del(user):
                print(‘註銷成功！‘)
            else:
                print(‘註銷失敗！‘)
        else:
            print(‘輸入密碼錯誤無法註銷!‘)
    elif inp == ‘5‘:
        break

遞歸

#函數當作參數傳遞
def f1():
    return ‘F1‘
    
def f2(arg):
    print(arg()) # 相當於執行f1(),輸出 F1
    return ‘F2‘

f2(f1) # f1代指函數,相當於一個變量,是變量就可以當作參數進行傳遞,f1()執行函數
# 函數名可以當作參數傳遞     函數名 代指函數內容

裝飾器

讓函數在執行之前或執行之後做一些操作,只要函數應用上裝飾器，那麽函數將會被重新定義，重新定義為裝飾器的內層函數。

單層裝飾器不帶參數

# 單層不加參數得裝飾器
def outer(func):
    def inner():
        print(‘Hello‘)
        print(‘Hello‘)
        print(‘Hello‘)
        print(‘Hello‘)
        r=func() # 原來的f1的函數= func,func()=f1(),r=null(沒有返回值)
        print(‘End‘)
        print(‘End‘)
        print(‘End‘)
        print(‘End‘)
        return r
    return inner    
                # 1.執行outer函數，並且將其下面的函數名，當作參數傳進去
@outer            #2. 將outer的返回值重新賦值給新的f1，新的f1=outer的返回值 ,新的f1=inner
def f1():       # 新的f1()=inner()
    print(‘F1‘)
@outer
def f2():
    print(‘F2‘)
@outer
def f3():
    print(‘F3‘)
f1() 
#相當於執行 inner(),原來不加裝飾器得f1()調用時只會輸出F1,加過裝飾器之後得f1()
#輸出得結果為                    
‘‘‘
Hello
Hello
Hello
F1
End
End
End
End
‘‘‘
#就相當於在不改變原函數得情況下，給原函數附加一些功能

帶參數的裝飾器(可傳任意多的參數，適用多層)

# 帶參數的裝飾器(可傳任意多的參數,適用多層)
def outer(func):
    def inner(*args,**kwargs):# 可接受任意多、任意形式的參數
        print(‘Hello‘)        
        #print(args)
        r=func(*args,**kwargs) # 接收上面inner()中的參數
        #print(kwargs)
        print(‘End‘)           #python內部的優化，自動幫你判斷f1函數所需要的參數,無需自己提取
        return r
    return inner    
                # 1.執行outer函數，並且將其下面的函數名，當作參數傳進去
@outer            #2. 將outer的返回值重新賦值給新的f1，新的f1=outer的返回值 ,新的f1=inner
def f1(a):       # 新的f1()=inner()
    print(‘F1‘)
    print(a)     

f1(1) 
                   # 同樣一個裝飾既適用一個參數的，也適用多個參數的
@outer
def f2(a,b,c):
    print(a+b+c)
f2(1,2,3)

多層的裝飾器

# 多層的裝飾器
def outer1(func):
    def inner(*args,**kwargs):
        print(‘Hello1‘)        
        r=func(*args,**kwargs)
        print(‘End1‘)         
        return r
    return inner        #相當於在第一個裝飾上又裝飾了一下
def outer2(func):
    def inner(*args,**kwargs):
        print(‘Hello2‘)
        r=func(*args,**kwargs)
        print(‘End2‘)         
        return r
    return inner
@outer1 #（在第一個裝飾器外面又裝飾了一些東西）  # 1.執行outer1函數，並且將其下面的函數名(outer2中的內層函數inner)，當作參數傳到outer1中
@outer2    #（內部第一個裝飾器）                 #2. 將outer的返回值重新賦值給(outer2中的內層函數inner)
def f1(a,b):           
    print(‘F1‘)
    print(a+b)     


f1(1,1) 
#內部裝飾器裝飾的結果為 
‘‘‘
Hello2
F1            外面多了一層 Hello2 End2
2
End2
‘‘‘
#加上外部裝飾器裝飾的結果為
‘‘‘
Hello1     外面多了一層 Hello1 End1
Hello2
F1
2
End2
End1
‘‘‘

python 全棧開發筆記 2