函數

函數是實現特定功能的代碼段的封裝，在需要的時候可以多次調用函數來實現該功能。

內置函數函數的使用

python內置了許多非常有用的函數，可以直接調用，下面是部分展示。

查看函數的幫助信息

help(名稱)

數學相關

1、絕對值：abs(-1)
2、最大最小值：max([1,2,3])、min([1,2,3])
3、序列長度：len('abc')、len([1,2,3])、len((1,2,3))
4、取模：divmod(5,2)
5、乘方：pow(2,3,4)
6、浮點數：round(1)

類型轉換

1、int(x)
2、str(x)
3、float(x)
4、bool()# 布爾值判斷
5、list(x)
6、tuple(x) #元組
7、hex(x)
8、ord(x)#返回字符對應的ASC碼數字編號，如ord(‘A’)返回65
9、chr(x)#返回x對應的字符，如chr(65)返回‘A’

功能相關

1、函數是否可調用：callable(funcname)，注意，funcname變量要定義過（類和類內…)，且像整數，字符串，列表，元組，字典等等，都是不可調用的!
2、類型判斷：isinstance(x,list/int)

3、快速生成序列：它的語法：range(start, stop [,step]) ；start 指的是計數起始值，默認是 0；stop 指的是計數結束值，但不包括 stop ；step 是步長，默認爲 1，不可以爲 0 。range() 方法生成一段左閉右開的整數範圍。
必須是整數，可以是負數，但不能是浮點數等其它類型；（3）它是不可變的序列類型，可以進行判斷元素、查找元素、切片等操作，但不能修改元素；（4）它是可迭代對象，卻不是迭代器。

print(range(5,10))

for x in range(5,10) : # 默認取值
    print(x,end=' ')
print()

for y in range(5,10,2) : # 每隔2個取一次值
    print(y,end=' ')

自定義函數，參數類型檢查

適用於需要多次重複使用相當功能的情況下定義函數並調用函數。
定義函數語法：
def 函數名(形參1，形參2，…) :
函數體（需實現代碼）
調用函數：calc
注意：

函數名可以包含數字、字幕、下劃線，但不能以數字開頭。
如果函數有返回值，使用 return 關鍵字
定義函數後函數中的代碼並不會執行，需要調用函數纔會執行

自定義函數

# 定義參數 使用def關鍵字
def name(num1,num2) : # 其中num值是必選參數，也成爲位置參數，調用的時候必須要有，否則報錯
    num = num1 + num2
    return num

#調用
print(name(3,5))

參數類型檢查

# 參數類型檢查
def my_abs(x):
    #可以爲函數添加文檔註釋，也稱爲文檔字符串doc string
    # 三個雙引號，回車即可自動出現param和return
    """
    計算絕對值
    :param x: 參數
    :return: 返回x的絕對值
    """
    # 對參數類型進行檢查
    if not isinstance(x,(int,float)):
        #拋出自定義異常
        raise TypeError('參數類型不正確，只能爲數值類型')

    if x>=0:
        return x
    else:
        return -x #絕對值，負負爲正
print(my_abs('str'))
print(help(my_abs))
print(my_abs(666))
print(my_abs(-666))

默認、可變、關鍵，命名參數

默認參數

默認參數就是帶有默認參數的變量！！
如果我們定義2個值沒有定義默認值的話如果不賦2個值，就會報錯，如果設置默認值以後，那個值即使不定義也不會報錯，定義以後就會用你定義的值。
方法：變量=n 即可

# 默認參數
# 計算一個值的n次方
def my_pow(x,y=2): #設置y的默認值爲2
    if y==0:
        return 1 #如果輸入0，則默認1次方 避免結果爲0
    res = x # 定義一個x
    for i in range(y - 1): # 循環次數,因爲上面已經定義一個x了，所以這需要-1
        res *= x # 開平方
    return res
print(my_pow(2,3))
print(my_pow(2))

可選參數

就是說參數可以想傳多少傳多少，也就是參數數量是可變的。
方法：變量名(*可選參數）或變量名(固定參數，*可選參數) 注：可選參數是以數組的形式展現，如果要獲取裏面的值，需要通過遍歷獲取！

def my_sus(*x): #單獨定義一個 可變參數
    print(x)

my_sus(1,2,3,4,5,6) # 以數組方式打印

print('*' * 50)

def my_usu(x,*y): #x是必選參數，y是可選參數
    print(x)
    print(y)
my_usu(1,4,4,4,5,6,7)

# 也可以調用數組()和[]都可以，方法 *變量名
def my_usu(x,*y): #x是必選參數，y是可選參數
    print(x)
    print(y)
nums=(1,4,4,4,5,6,7)
my_usu(66,*nums) #*nums等同於，nums[0],nums[1],....
print('*' * 50)
my_usu(66,nums)

如果有必選參數，和可選參數，建議把必選參數放前面，如果必須參數放後面，需要指定必須變量名再賦值，否則報錯

def test(*x,y):
    print(x)
    print(y)
# test(5,4,5,6,412) 這樣賦值會報錯，會默認爲全部是賦值給x的
test(5,13,3,11,y=66)

關鍵字參數

使用 ** ，也表示參數個數是可變的，但傳遞的是帶名稱的參數。

#關鍵字參數
def f1(x,**y):
    print(x)
    print(y)

f1(666,a=6,b=66,c='牛牛牛')

也可以調用字典dict內容，方法和可變參數一樣 **變量名

#關鍵字參數
def f1(x,**y):
    print(x)
    print(y)
# f1(666,a=6,b=66,c='牛牛牛')
user = {'age':23,'name':'ccx','add':'china'}
f1(666,**user)
# 等同於
f1(555,age=user['age'],name=user['name'],add='china')

命名關鍵字參數

限制關鍵字參數的名字，使用* 分割，*號後面的參數表示命名關鍵字參數。

def f2(x,*,name,age,add): #  *沒有任何意義，單純用來分割而已
    print(name)
    print(age)
    print(add)

f2(666,name='ccx',age=23,add='china')

接受任意參數

*args：接受任意參數
**kwargs：接受任意命名參數

# 任意參數
def f3(*args,**kwargs):
    print(args)  # 任意參數
    print(kwargs)#任意命名參數

f3(666,555,'ccx','....',age=23,name='ccx',add='china',wa='...')

自定義函數

空函數

表示先定義一個空函數，以後實現自定義功能。

def kong() :
    pass  # 表示 是空函數，暫不賦值


# 定義函數的返回值，可以定義多個返回值
def f1():
    name = 'ccx'
    age = 23
    sex = 'man'
    return name,age,sex
print(f1())  # 返回值是一個tuple(數組）
# 獲取數組裏面的值
a, b, c = f1()  # 任意定義3個參數，按順序分別對應f1()中的三個參數
print(a, b, c)

函數的返回值，返回一個函數

簡單來說就是調用一個已定義的函數
方法：直接函數名() 即可
注：如果用print輸出變量名，會多一個None

def test(x) :
    print('你調用了該函數，並輸入了參數'+x)

def kong():
    print('你調用了一個空函數')
    pass

test(str(666)) # 調用函數
print(test(str(777)),type(test(str(888)))) #輸出函數！！！

print('$' * 50)

kong() #調用函數
print(kong())  # 使用輸出結果都會多一個None，而調用卻不會！

也可以嵌套使用，調用的參數或局部變量成爲：閉包

def f1(x):
    print('調用了f1')
    y = 6 #定義 局部變量

    def f2(z): #內部函數（這裏屬於函數f1）
        print(x * y + z) #內部函數使用了外部(f1)函數的參數或局部變量，成爲閉包

    return f2 #這裏返回屬於 內部函數(f2)

fn = f1(3) # 定義變量，並給x賦值3
print('....')
fn(5) # 使用函數，這裏定義的其實是z，因爲調用f1 返回的是內置函數f2的return

遞歸函數

一個函數在內部調用自身，這個函數就叫做遞歸函數。
demo:計算x的y次方
普通方法

#普通寫法
def f1(x,y):
    if y == 0:
        return 1   # 平方次數 最少一次，避免報錯
    i = 1
    sum = x
    while i<y : # 因爲上面定義了一個sum，所以這需要-1
        sum *= x
        i += 1 #先當於y的+1
    return sum
print(f1(2,0)) #直接調用

ff = f1(2,3) #先定義再返回結果
print(ff)

遞歸函數方法

#遞歸函數方式

def f2(x,y):
    if y==0:  #這裏是停止條件，如果不定義這個，就會進入死循環
        return 1
    else:
        #遞歸條件
        #2x2x2x2x2=2x(2x2x2x2)=2x(2x(2x2x2))=2x(2x(2x(2x2)))=2x(2x(2x(2x(2x1))))) # 這裏的1就是停止條件
        return x * f2(x,y - 1) # 不停的調用自己，直到滿足y=0停止


print(f2(2,5))

當然，不能太作死的遞歸自己，否則會棧溢出！

變量作用域和命名空間

變量作用域

變量作用域 scope：指的是變量生效的區域
有兩種作用域：
1，全局作用域：函數意外的區域都是全局作用域，在全局作用域中定義的變量，都是全局變量。
2，函數作用域，也稱爲局部作用域：函數內的區域，每調用一次函數就會創建一個新的函數作用域，在函數作用域中定義的變量，都是局部變量。
變量的查找順序：先在當前作用域中查找，如果沒有則向上一級作用域中查找，直到查找全局作用域，如果還是沒有，則報錯。

#作用域介紹
a = 666 #全局變量

if True:
    b = 777 #全局變量（不在函數內！！！）
    # 在python中沒有塊級作用域（在java中 這裏面定義的外面是用不了的）

def f1():
    c = 999 #局部變量
    print('函數內部：a=',a)
    print('函數內部：b=', b)
    print('函數內部：c=',c)

f1()
print('——' * 20)
print('函數外部：a=', a)
print('函數外部：b=', b)
# print('函數外部：c=', c)

默認全局變量中的變量名與局部(函數內）變量名沒有關係。

a = 10 #全局a
def fn():
    a=20 #局部a
    print('內部a',a)
print('外部a',a)
fn()
print('——' * 20)

global關鍵字(局部中讓外部生效）

b = 10
def fn2():
    #如果想在內部函數中修改全局變量的值，需要使用參數 global關鍵字來聲音變量
    global b # 聲明這裏面的b是全局變量b
    b = 20
    print('內部b',b)
    return b
fn2()
print('外部b',b)

#變量查找介紹
#先在當前作用域中查找，如果沒有則向上一級作用域中查找，直到查找全局作用域，如果還是沒有，則報錯。
x = 1#全局作用域
def f2():
    x = 2#上一級作用域
    print(x)
    def f3():
        x = 3#當前作用域
        print(x)

命名空間

命名空間namespace：指的是變量存儲的位置，每一個變量都要存儲在指定的命名空間中；
每個作用域都有一個對應的命名空間；
全局命名空間，用來存儲全局變量；
函數命名空間，用來存儲函數中的變量；
命名空間實際上就是一個字典(dict)，是一個專門用來存儲變量的字典。

獲取命名（locals）

使用方法： locals() 獲取當前作用域的命名空間
注：在全局中使用就是調用全局命名，在函數中使用並調用函數，就是獲取該函數中的命名。

# 命名空間
a = 6
b = 66

scp = locals()
print('全局變量:',scp)
print('參數類型:',type(scp)) # 在全局作用域中調用locals，獲取的就是全局命名空間

def f1():
    c = 666
    print('調用函數:',locals())
f1()

def f2(name) : #設置返回值
    age = 23
    sc = locals()
    print('調用參數函數命名:',sc) #返回一個名字/值對的字典
f2('ccx') #調用並輸入返回值

修改命名參數

a = 6
b = 7
print('修改前的總變量：',a,b)
scp = locals()
scp['a'] = 666 # 修改變量a
scp['b'] = 777
print(scp)
print('修改後的總變量：',a,b)

z = 456
def f1():
    c = 123
    sc = locals()
    sc['c'] = 321
    sc['z'] = 654 #修改總變量z ，因爲查找規則就是先函數後總變量，但僅對當前函數生效
    print(sc)
    print('函數中修改總變量：',z) # 函數中修改的總變量，不能直接用print打印！
f1()
print('總變量z:',z)

獲取命名（globals）

可以在任意位置獲取全局命名空間
方法：globals()

a = 6
def f1():
    b = 7
    scp = globals()
    print(scp)
    print(scp['a'])
f1()

高級特性（迭代和列表生成式）

迭代

迭代：迭代的意思是重複做一些事很多次，就像在循環中做的那樣,也稱爲遍歷，循環獲取每一個元素；

回憶一下普通遍歷：

for i in ('tom','alk','ccx') :
    print(i,end=',')
print()
for j in {'name':'ccx' , 'age':'2','ccx':'最帥'}.keys():
    print('1:',j,end=',')
print()
for j in {'name':'ccx' , 'age':'2','ccx':'最帥'}.items():
    print('2:',j,end=',')
print()
for k,l in {'name':'ccx','age':22,'ccx':'超級cool'}.items() :
    print('3:',k,l,end=',')
print()
print('4:',end=' ')
for n in 'good evening' :
    print(n,end=',')

判斷是否可迭代
需要判斷對象是否是可迭代的，判斷方法：isinstance(file,Collections,Iterable) ——返回布爾類型

print(isinstance('good evening',Collections,Iterable))

使用enumerate()函數，轉換爲索引-元素對

name = {'ccx':'is a hero','age':22}
print(enumerate(name))
print('enumetate函數：',end=' ')
for k,v in enumerate(name):
    print(k,v,end=',')
print()
print('普通遍歷:',end=' ')
name1 = {'ccx':'is a hero','age':22}
for n,m in name1.items() :
    print(n,m,end=',')

迭代使用
迭代器是一個可以記住遍歷的位置的對象。
迭代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。迭代器只能往前不會後退。
迭代器有兩個基本的方法：iter() 和 next()。
迭代器iterator：用來訪問集合元素的一種方式，可以記住迭代的位置。
字符串，列表或元組對象都可用於創建迭代器

迭代的普通用法

# 普通迭代 一次一個值
list = [1,2,3,4]
i = iter(list) #調用iter()函數創建迭代器
print(next(i))# 調用next()函數獲取迭代器的下一個元素
print(next(i))
print(next(i))
print(next(i))

迭代器對象可以使用常規for語句進行遍歷：
和普通遍歷比起來，區別最大的可能就是逼格更高把？？？或許迭代器只能往前不會後退。雖然知道怎麼體現，但看不見的好處或許就是這個把！！！

next使用：因爲的我會報錯，所以我加了個try機制。沒找到原因。

list = [1,2,3,4]
i = iter(list)
while True:
    try:
        print(next(i))
    except StopIteration:
        exit()

列表生成式

列表生成式：簡單來說，用來創建list的生成式
如: 生成0-99的list

# 普通for循環的方法
for i in range(0,100):
    print(i,end=',')
print()

#生成式方法
nums = range(0,100)# 如果轉換格式 其實就是個range模式。
print(nums)
print()

nums1 = list(range(0,100)) # 需要轉換爲list格式，可以直接打印!!!!
print(nums1,end=',')

如：打印1，100之間所有的偶數

如:生成一個包含1-100之間所有3的倍數的list

# 方式一
print('方法一：',end=' ')
lst = range(1,101)
for i in lst:
    if i % 3 == 0:
        print(i,end=',')
print()

# 方式二
print('方法二：',end=' ')
lst1 = []
for i in range(1,101):
    if i%3 == 0 :
        print(i,end=',')
print()

#方式三
print('方法三：',end=' ')
lst2 = [i for i in range(1,101) if i%3==0]
print(lst2)

生成器

生成器generator：在循環過程中一次計算獲取值的對象；
創建生成器的方式：
方式一：把一個列表生成式的[]改成()

#方式一：把一個列表生成式的[]改成()
generator = (i for i in range(0,100))
print('generator類型爲:',type(generator))
# 注意，上面的generator並沒有生成值，只有獲取時纔會生成值

# 獲取生成器的下一個值
print(next(generator))
print(next(generator))
print(next(generator))
print(next(generator))
print('*' * 50)

# 遍歷generator的值
for i in generator:
    print(i,end=',') # 因爲0-3上面已經用next獲取了，所以這兒不會有0-3

知道迭代特性會記錄獲取的值，所以如果提取超過值便會拋異常

方式二：在函數中使用yield關鍵字，此時該函數就變成一個生成器函數

#方式二：在函數中使用yield關鍵字，此時該函數就變成一個生成器函數
def gen():
    print('one')
    yield 13
    print('two')
    yield 8
    print('three')
    yield 25
    print('four')
    yield 38

#生成器函數與普通函數的執行流程不一樣；
#普通函數是順序執行，執行到最後一行或者遇到return時結束
#生成器函數是在每次嗲用next時執行,遇到yield語句就返回，下一次調用next()時會從上一次返回的yield語句處繼續執行
g = gen()
print(type(g))
print(next(g))
print(next(g))
print(next(g))

print('*' * 50)

#使用for循環遍歷生成器
for i in g:
    print(i) #從上一個next()返回結果的下一處繼續執行！

高階函數

自定義高階函數

高階函數：一個函數接收另一個函數作爲參數，這種函數成爲高階函數。

# 定義一個函數，用來檢查數字是否大於5
list = [4,5,6,7,8,18, 19, 20, 21, 22, 23, 24,111,112]
def f1(x):
    if x > 5:
        return True #沒有實際作用，只是測試滿足x>5就會輸出True而已
    return False
print('f1條件函數:',f1(6))
print('*' * 59)

#自定義高階函數，用來過濾列表中的函數
def f2(fun,list):
    """
    將列表中所有符合條件的元素篩選出來，返回一個新列表
    :param fun: 條件函數
    :param list: 要進行篩選的列表
    :return: 返回新列表
    """
    new_list=[] # 創建一個新列表
    for i in list:
        if fun(i):
            new_list.append(i) #滿足條件的添加到列表中
    return new_list # 返回新列表
num = f2(f1,list) # 調用f1函數，傳入list列表內容
print('f2條件函數:',num)
print('*' * 50)

定義這種高階函數的好處在於條件可以隨時變更，然後調用高階函數的時候再調用新的條件函數即可，如：上面創建了一個>5的條件函數(f1)，一個高階函數(f2),現在創建一個新的條件(f3)

#自定義高階函數，用來過濾列表中的函數
def f2(fun,list):
    """
    將列表中所有符合條件的元素篩選出來，返回一個新列表
    :param fun: 條件函數
    :param list: 要進行篩選的列表
    :return: 返回新列表
    """
    new_list=[] # 創建一個新列表
    for i in list:
        if fun(i):
            new_list.append(i) #滿足條件的添加到列表中
    return new_list # 返回新列表
num = f2(f1,list) # 調用f1函數，傳入list列表內容
print('f2條件函數:',num)
print('*' * 50)

def f3(x):
    if x % 2 == 0: # 只要偶數
        return True
print('f3條件函數:',f2(f3,list)) #輸出並調用 f2高階函數，傳入 函數f3和list列表

內置高階函數

內置高階函數 filter()，用於過濾序列
使用方法：filter(條件函數,列表)

lst = [4,5,6,7,8,18, 19, 20, 21, 22, 23, 24,111,112]
def f3(x):
    if x % 2 == 0: # 只要偶數
        return True

num = filter(f3,lst)
print(list(num))

內置高階函數 map()，用於處理序列
使用方法：map(條件函數,列表)

lst = [4,5,6,7,8,18, 19, 20, 21, 22, 23, 24,111,112]
def f4(n):
    return n+1
def f5(n):
    return n*n

print('原列表:',lst)
print('所有數值+1：',list(map(f4,lst)))
print('所有數值開平方：',list(map(f5,lst)))

內置高階函數 sorted()，用於排序
使用方法：sorted(列表) # 默認排序小到大
sorted(列表，reverse=True)# 大到小排序
sorted(列表，key=)#key= 是自定義條件，後面也可以加reverse=True

lst = [1,2,3,-55,-100,66] #普通列表
lst1 = [{'a':1,'b':2,'c':3,'d':4}] #多維列表
a = sorted(lst) # 默認排序 從小到大
b = sorted(lst,reverse=True) #從大到小，因爲reverse默認爲false。
c = sorted(lst,key=abs,reverse=True) #最簡單的條件，絕對值排序
d = sorted(lst1,key=lambda n:n,reverse=True)
# d是多維列表的使用方法，按理說 n:n[0]是單獨提取不排序，n:n[1]是排序，但我這會報錯，不知道爲啥。n是自定義的。
print('小到大：',a)
print('大到小：',b)
print('絕對值(大到小)：',c)
print(d)

匿名函數和裝飾器

匿名函數

匿名函數：沒有名字的函數，只能使用一次。 
方法：lambda關鍵字

nums = [3,55,6,22,8]

# 以map爲例，讓nums列表中值 x2+1
def f1(x):
    return x*2+1
a = list(map(f1,nums))
print('f1函數返回結果:',a)

# 假設f1函數只用一次，這麼定義一個f1 就顯得有點麻煩了，所以可以定義一個 匿名函數
b = list(map(lambda x:x*2+1,nums))

	print('匿名函數返回值：',b)

匿名函數除了可以調用列表以外，也可以定義一個匿名函數，然後賦值並調用匿名函數

abc = lambda x:x+5
print(abc(1))
print(abc(555))

裝飾器

裝飾器：裝飾器本質上是一個函數，該函數用來處理其他函數，它可以讓其他函數在不需要修改代碼的前提下增加額外的功能（稱爲裝飾器Decoration，類似於AOP），裝飾器的返回值也是一個函數對象。它經常用於有切面需求的場景，比如：插入日誌、性能測試、事務處理、緩存、權限校驗等應用場景。裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量與函數功能本身無關的雷同代碼並繼續重用。概括的講，裝飾器的作用就是爲已經存在的對象添加額外的功能。
方法：先定義一個裝飾器（其實就是一個 def函數）

def name():
    def new_name():
        #功能塊
    return new_name()

使用：在需要增加功能的函數上面 @裝飾器函數name即可

如：

# 定義一個裝飾器，爲該函數添加打印日誌功能
def log(fn):
    def wrapper(*args,**kwargs):
        print('開始執行%s()函數。。。'% fn.__name__) # __name__ 內置屬性，獲取名字
        res = fn(*args,**kwargs)
        print('執行%s()函數結束。。。' % fn.__name__)
    return wrapper()  #返回裝飾函數
# 隨便定義了一個裝飾器
。
def abc(a):
    def c():
        print('this is ...')
    return c()

lst = [ 2,3,4,5,6,66,555]

@log
def f1(lst):
    for i in lst: #遍歷
        if i % 2 ==0 : #只要偶數
            print(i)

@abc
def f2(num1,num2):
    sum = num1+num2 # 計算
    return sum # 返回sum

f1(lst)
print('*' * 50)
print(f2(3,5))

注：上面代碼運行有報錯，方法就是這樣使用的，至於爲什麼運行報錯，現在的我並無法解決，報錯如下。

那時的我無法解決，不代表現在的我無法解決（我的博客都是累計到一定數量，然後一併發佈）。既然不會那麼就多查資料多總結多實驗嘛，單獨說下修飾器，參見：https://blog.csdn.net/cuichongxin/article/details/106563876

python函數“超2萬字”的介紹——（帶圖超詳細）

文章目錄

函數

內置函數函數的使用

查看函數的幫助信息

數學相關

類型轉換

功能相關

自定義函數，參數類型檢查

自定義函數

參數類型檢查

默認、可變、關鍵，命名參數

默認參數

可選參數

關鍵字參數

命名關鍵字參數

接受任意參數

自定義函數

空函數

函數的返回值，返回一個函數

遞歸函數

變量作用域和命名空間

變量作用域

global關鍵字(局部中讓外部生效）

命名空間

獲取命名（locals）

獲取命名（globals）

高級特性（迭代和列表生成式）

迭代

列表生成式

生成器

高階函數

自定義高階函數

內置高階函數

匿名函數和裝飾器

匿名函數

裝飾器