1.函數(shù)的概念
函數(shù)是實現(xiàn)某一特定功能的代碼段的封裝
2.函數(shù)的聲明/定義
def 函數(shù)名(形參列表):
函數(shù)體
形參: 可以看成是聲明在函數(shù)中的變量; 作用是將函數(shù)外部的數(shù)據(jù)傳遞到函數(shù)內(nèi)部
函數(shù)體: 函數(shù)說明文檔, 實現(xiàn)函數(shù)功能的代碼段, return 語句
(重點!)聲明函數(shù)的時候不會執(zhí)行函數(shù)體
3.函數(shù)的調(diào)用
函數(shù)名(實參列表)
(重點!)函數(shù)調(diào)用過程:
回到函數(shù)聲明的位置
傳參(用實參給形參賦值) - 保證每個參數(shù)都值
執(zhí)行函數(shù)體
結(jié)束后，確定返回值 - 自然死亡/遇到return
返回函數(shù)調(diào)用的位置 - 這個時候函數(shù)調(diào)用表達式的值才是之前確定返回值
4.函數(shù)的參數(shù)
位置參數(shù)和關(guān)鍵字參數(shù)
參數(shù)默認值
參數(shù)類型說明
不定長參數(shù): 形參前加* -> 將形參變成元祖, 形參前加** -> 將形參變成字典
5.函數(shù)的返回值 - 將函數(shù)內(nèi)部傳遞到函數(shù)的外面
a.怎么確定函數(shù)的返回值
看執(zhí)行函數(shù)的時候會不會遇到return, 遇到了return 后面的值就是返回值。沒有遇到返回值就是None
b.怎么獲取函數(shù)的返回值
通過獲取函數(shù)調(diào)用表達式的值來獲取返回值
普通數(shù)據(jù)能做的事情返回值都可以做
注意：每次調(diào)用函數(shù)，都會重新獲取返回值
"""
``
def func(num: int):
return [1, 2] * num
list1 = [func(3), 100]
list1[0].append(100)
print(list1)
``
print(func(3))
result = func(2)
print(func(3)[0])
print(func(3)[:3])
for x in func(2):
print(x)
func(3).append(10)
print(func(3))
result = func(3)
result.append(10)
print(result)
print('=======================')
def func1(x):
print(x)
def func2(n):
# n=4
return n * 2
def func3(x):
# x = 3
# return func2(4)
return func2(x+1)
func1(func2(2))
print(func3(3))
"""
1.什么是匿名函數(shù)
匿名函數(shù)還是函數(shù)，只是聲明的格式和普通函數(shù)不一樣。只適用于函數(shù)功能比較簡單的函數(shù)
def 函數(shù)名(形參列表):
函數(shù)體
2.匿名函數(shù)的聲明
a.語法
變量名 = lambda 形參列表:返回值
b.說明
變量名 - 相當于函數(shù)名
lambda - 聲明匿名函數(shù)的關(guān)鍵字
形參列表 - 和普通函數(shù)的形參列表一樣
: - 固定寫法
返回值 - 就相當于普通函數(shù)中只有一天return語句的函數(shù)體
- 匿名函數(shù)的調(diào)用
和普通函數(shù)一樣
"""
1.匿名函數(shù)的參數(shù)也可以設(shè)置默認值(不會有類型提示)
2.匿名函數(shù)不通過添加:類型名來說明參數(shù)類型
func1 = lambda x, y=0: x+y
print(func1(10))
print(func1(y=11,x=20))
這個函數(shù)和上面的匿名函數(shù)一模一樣！
def func1(x, y):
return x+y
print(func1(10, 20))
3.匿名函數(shù)可以設(shè)置不定長參數(shù)
func2 = lambda *nums: sum(nums)
print(func2(1, 2, 3, 4, 5))
func3 = lambda x: print(x)
# x = 100 return print(100)
print(func3(100)) # None
def func3(x):
return print(x)
"""
1.什么是變量的作用域
就是變量能夠使用的范圍
2.全局變量和局部變量
a.全局變量 - 沒有聲明在函數(shù)或者類中的變量都是全局變量
全局變量的作用域是從聲明開始，到整個文件結(jié)束
b.局部變量 - 聲明在函數(shù)或者類中的變量就是局部變量
局部變量的作用域是從聲明開始，到函數(shù)結(jié)束
總結(jié)：當我們調(diào)用函數(shù)的時候，系統(tǒng)會自動在棧區(qū)間專門為這個函數(shù)開辟一塊獨立的內(nèi)容空間，
用來保存在函數(shù)中聲明的變量(形參也是屬于聲明在函數(shù)中的變量)。當函數(shù)調(diào)用結(jié)束后，
這個函數(shù)對應(yīng)的棧區(qū)間會自動銷毀 --- (函數(shù)調(diào)用過程是一個壓棧的過程)
"""
1.全局變量1
變量a是全局變量
a = 100
print('外面:', a)
for x in range(5):
print('循環(huán)里:',a)
def func1():
print('函數(shù)中:', a)
func1()
2.全局變量
這兒的y也是全局變量
for y in range(3):
print(y)
print('外面:', y)
def func2():
print('函數(shù)里面:', y)
func2()
3.局部變量
a.函數(shù)的形參就相當于聲明在函數(shù)中的變量，所以是局部變量
num1是局部
def func3(num1):
print(num1)
for x in range(3):
print(num1)
func3(10)
print(num1) # 局部變量不能在函數(shù)外面使用
函數(shù)中的nums，max1和item都是局部變量
def func4(*nums):
# nums = (1, 89, 9, 887, 0)
max1 = nums[0]
for item in nums:
if item > max1:
max1 = item
print(max1)
func4(1, 89, 9, 887, 0)
# print(item)
4.如果全局變量和局部變量同名，那么在局部變量的作用域中使用的是局部變量；外部使用的是全局變量
全局變量
aa = 100
def func5():
# 局部變量aa
aa = 200
print('函數(shù)里', aa)
func5()
print('外部:', aa)
"""
3.global - 在函數(shù)中聲明一個全局變量(只能在函數(shù)中使用)
在函數(shù)中:
global 變量名
變量名 = 值
bb = 111
def func6():
global bb
bb = 222
print('函數(shù)里:',bb)
global aaa
aaa = 100
print(aaa) # 100
func6()
print(bb)
print(aaa) # 100
"""
- nonlocal - 想要在局部的局部中去修改布局變量的值，就使用nonlocal對變量進行說明
nonlocal 局部變量
局部變量 = 值
"""
def func11():
abc = 123
def func22():
nonlocal abc
abc = 333
print('func22', abc)
func22()
print('func11', abc)
func11()
# func22 333
# func11 123
"""
list1 = []
i = 0 [lambda x: x*i]
i = 1 [lambda x: x*i, lambda x: x*i]
i = 2 [lambda x: x*i, lambda x: x*i, lambda x: x*i]
i = 3 [lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i]
i = 4 [lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i]
"""
list1 = []
for i in range(5):
list1.append(lambda x: x*i)
print(list1[0](3))
# lambda x: x* i x = 3 return 3*4
print(list1[3](3))
# lambda x: x* i x = 3 return 3*4
print(list1)
# list1 = [lambda x: x*2]
# print(list1[0](100))
def func1():
a = [1, 2]
print(a[10])
# func1()
a = 10
func1 = lambda x: x*a
a = 20
print(func1(2)) # 40
"""
python中聲明函數(shù)其實就是聲明一個類型是function的變量, 函數(shù)名就是變量名
a = 10
str1 = 'abc'
list1 = [1, 34, 'ahjs']
dict1 = {'a': 10, 'b': 100}
func1 = lambda x: x
def func2():
print('asbc')
print(type(dict1), id(dict1))
print(type(func1), id(func1))
print(type(func2), id(func2))
print(dict1)
print(func1, func2)
"""
函數(shù)名 -- 類型是function的變量
函數(shù)名() -- 調(diào)用函數(shù)并且獲取函數(shù)的返回值
普通變量能做的事情函數(shù)變量都能做!
1.給別的變量賦值
"""
聲明了一個列表變量list1
list1 = [1, 2, 3]
聲明一個函數(shù)變量func1
def func1():
print('我是一個函數(shù)!')
return 10
使用列表變量給另外一個變量list2賦值,
list2 = list1
# 賦值后list2就可以當成列表來用
print(list2[0])
print(list2[::-1])
list2.append(100)
print(list2)
# 使用函數(shù)變量給另外一個變量func2賦值
func2 = func1
# 賦值后func2就可以當成函數(shù)來使用
func2()
print(func2())
"""
2.變量作為容器類數(shù)據(jù)的元素
"""
a = 10
nums = [a, 100, 1000]
print(nums)
print(nums[0] - 10)
def func3(x):
print('abc', x)
return 10
list2 = [func3, func3(10), 100]
print(list2)
print(list2[0](1))
"""
3.變量作為函數(shù)的實參
函數(shù)1作為函數(shù)2的實參 -- 函數(shù)2就是一個高階函數(shù)
a = 10
def func4(n: int):
print(n + n - 1)
func4(a)
func4(10)
def func5(x):
print(x)
x(111)
func5(func4)
func5(lambda x: x*2)
"""
函數(shù)作為參數(shù)的應(yīng)用: sort函數(shù)
列表.sort(key=None, reverse=False)
參數(shù)key - 要求是一個帶有一個參數(shù)，并且返回值是布爾的函數(shù)。這兒的參數(shù)指向的是列表中元素。
確定按照元素的什么值進行排序
list1 = [1, 23, 9, 90]
list1.sort(reverse=True)
print(list1)
all_student = [
{'name': '張三', 'age': 19, 'score': 90},
{'name': 'stu1', 'age': 30, 'score': 79},
{'name': 'xiaoming', 'age': 12, 'score': 87},
{'name': 'stu22', 'age': 29, 'score': 99}
]
這兒的item是需要排序的列表的元素
# def func(item):
# return item['score']
# all_student.sort(key=func, reverse=True)
all_student.sort(key=lambda item: item['score']) # 按成績從小到大排序
all_student.sort(key=lambda item: item['age'], reverse=True) # 按年齡從大到小排序
print(all_student)
tuple1 = (
(10, 20),
(5, 80),
(30, 90)
)
new_tuple = sorted(tuple1, key=lambda item: sum(item))
print(new_tuple)
print('=============')
練習(xí): 按學(xué)生的平均分排序
all_student = [
{'name': '張三', 'age': 19, 'score': {'c': 78, 'm': 90, 'e': 40}},
{'name': 'stu1', 'age': 30, 'score': {'c': 89, 'm': 60, 'e': 98}},
{'name': 'xiaoming', 'age': 12, 'score': {'c': 78, 'm': 67, 'e': 86}},
{'name': 'stu22', 'age': 29, 'score': {'c': 34, 'm': 99, 'e': 50}}
]
def average(student):
scores = student['score']
sum1 = 0
for key in scores:
sum1 += scores[key]
return sum1/3
all_student.sort(key=average)
print('~~~~~~~~~~~')
print(all_student)
=============排序原理(了解)=============
def yt_sorted(iterable, key=None, reverse=False):
list1 = list(iterable)
if key:
for x in range(len(iterable) - 1):
for y in range(x + 1, len(iterable)):
item1 = list1[x]
item2 = list1[y]
if key(item1) > key(item2):
list1[x], list1[y] = list1[y], list1[x]
else:
# 快速排序
for x in range(len(iterable) - 1):
for y in range(x + 1, len(iterable)):
if list1[y] < list1[x]:
list1[x], list1[y] = list1[y], list1[x]
if not reverse:
# 從小到大
return list1
else:
# 從大到小
return list1[::-1]
print(yt_sorted([1, 20, 9, 10]))
# print(sorted(all_student, key=lambda x: x['age']))
print(yt_sorted(all_student, key=lambda x: x['age'], reverse=True))
"""
4.變量作為函數(shù)的返回值
函數(shù)1作為函數(shù)2的返回值 - 函數(shù)2是返回值高階函數(shù)
"""
def operation(char):
# char = '-'
if char == '+':
def func1(*nums):
return sum(nums)
# 將函數(shù)作為函數(shù)的返回值
return func1
elif char == '-':
def func2(*nums):
# (10, 3, 4)
# 如果沒有傳參
if not nums:
return 0
sum1 = nums[0]
for index in range(1, len(nums)):
sum1 -= nums[index]
return sum1
return func2
print(operation('+')(1, 2, 3, 4))
print(operation('-')(10, 3, 4))
