前言回顧

1.容器型數(shù)據(jù)類型：列表、元組、字典、集合

1. 列表：

[元素1,元素2,...]
可變、有序
增刪改查、+、*、>、<、>=、<=、==、!=、is(判斷地址是否相等)、in、not in、len()、list()
多個數(shù)據(jù)的意義相同，并且需要支增刪改操作

2. 元組：

(元素1,元素2,...)、(元素1,)、元素1,，元素2,...
不可變、有序
查、+、*、>、<、>=、<=、==、!=、is(判斷地址是否相等)、in、not in、len()、tuple()
一般選擇容器存儲數(shù)據(jù)的時候不用元組 存儲不可變數(shù)據(jù)的時候才用

3. 字典

{鍵1:值1, 鍵2:值2,...} 鍵 - 不可變，唯一 值 - 任何類型的數(shù)據(jù)
可變、無序
增刪改查、==、!=、is、in、not in、len()、dict()
保存的多個數(shù)據(jù)需要區(qū)分(意義/性質不同)

4. 集合

{元素1, 元素2,...} 元素 - 不可變、唯一
可變、無序
增刪查、==、!=、is、in、not in、len()、set()、數(shù)學集合運算(|, &, -, ^, >=, <=)
注意：集合遍歷的效率高
做數(shù)學集合運算操作、去重、提高程序效率

2.函數(shù)

1. 聲明

def 函數(shù)名(參數(shù)列表):
函數(shù)體
注意：函數(shù)聲明的時候不會執(zhí)行函數(shù)體！

2. 調用

函數(shù)(函數(shù)列表)
注意：函數(shù)調用之前必須已經聲明過
**調用過程：
回到函數(shù)聲明的位置
傳參(傳參要保證每個參數(shù)都有值)
執(zhí)行函數(shù)體
執(zhí)行完函數(shù)體確定返回值
回到函數(shù)調用的位置(這個時候函數(shù)調用表達式的值就是返回值)

3. 參數(shù)

位置參數(shù)、關鍵字參數(shù) - 保證位置參數(shù)在關鍵字參數(shù)的前面
參數(shù)默認值 - 可以不用傳參
類型說明
不定長參數(shù) - args，*kwargs (面試題)

4. 返回值

怎么確定返回值
怎么獲取返回值：獲取函數(shù)調用表達式的值

5. 其他

lambda 參數(shù)列表：返回值

變量的作用域：

全局變量：聲明在函數(shù)/類外部的變量是全局變量
局部變量：聲明在函數(shù)里面的變量就是局部變量

global: 在函數(shù)中聲明全局變量
nonlocal: 在局部的局部中去修改局部變量的值

nums = [12, 3, 89, 90, 8]
nums.sort(reverse=True)
print(nums)

print('=====')
print(print('abc'))

print('=====')
func1 = lambda x: x*2
result = func1(10)
print(result)

list1 = [10, lambda x: x*x]
result = list1[1](10)
print(result)

print('how are you'.split(' '))

1.函數(shù)作為變量

python 中聲明函數(shù)其實就是聲明一個類型是function的變量，函數(shù)名就是變量名
所有普通變量能做的事情函數(shù)都可以做

def func1():
    print('這是一個函數(shù)')
    return 100

2.一個變量可以給另一個變量賦值

a = 10
b = a
print(b/2)
a = 'abc'
print(a)

# c = func1()  # 調用函數(shù)，獲取函數(shù)返回值
c = func1  # 將函數(shù)名作為變量，給另一個變量賦值(獲取函數(shù)變量)
print('===')
print(c())
print('===')
func1 = 12.5
print(func1)

3.一個變量可以作為容器的元素

print('=====')
a = 10
print(type(a))

#聲明一個變量，類型是function
def func2():
    print('這是函數(shù)2')
    return 100

print(type(func2))
list1 = [a, func2, func2()]
print(list1)
print('0:', list1[0]//3)
print('1:', list1[1]())  # 有問題。。。

練習：

list2 = []
for i in range(5):
    def func(n):
        return i * 2
    list2.append(func)
# 請說出list2[0](3), list2[1](3), list[2](3)  分別的值

list2 = []
i = 0 ~ 4
i = 0: func, list2 = [func]
i = 1: func, list2 = [func, func]
i = 4: list2 = [func, func, func, func, func] # 每聲明一次函數(shù)，函數(shù)名相同，但是都會開辟不同的存儲空間
聲明函數(shù)時，函數(shù)都不會執(zhí)行
8 8 8

4.變量可以作為函數(shù)的參數(shù)

# 普通變量
def func4(n):
    return n*2
a = 10
# 將變量作為函數(shù)的參數(shù)
func4(a)

函數(shù)作為函數(shù)的參數(shù)(實參高階函數(shù))

def func1(fn, fn2):
    fn()  # func11()
    print(fn2(3) / 4)  # print(func12(3)/4)

def func11():
    print('這是一個函數(shù)')

def func12(n):
    return n**2

print(func1(func11, func12))  # print None

應用：sort函數(shù)

nums = [1, 34, 45, 9, 20]
nums.sort()
print(nums)

all_students = [
    {'name': '小明', 'age': 19, 'score': 89},
    {'name': '熊大', 'age': 20, 'score': 90},
    {'name': '熊二', 'age': 17, 'score': 70},
    {'name': '光頭強', 'age': 21, 'score': 40}
]
# sort函數(shù)中有個參數(shù)key，這個參數(shù)要求傳一個函數(shù)，并且函數(shù)有一個參數(shù)和一個返回值
# 參數(shù)就是序列中的元素，返回值就是排序比較的對象
# def compare(item):
#     return item['age']
# all_students.sort(key=compare)
all_students.sort(key=lambda item: item['age'])
print(all_students)

練習，將all_message中的元組按照第二個元素從大到小排序，然后按照學號的最后一位從小到大排序

all_message = [
    ('張三', 'python1902004'),
    ('李四', 'python1902049'),
    ('王五', 'python1902032')
]
all_message.sort(key=lambda item: item[1], reverse=True)
print(all_message)
all_message.sort(key=lambda item: item[1][-1])
print(all_message)

5.變量作為返回值

將一個函數(shù)作為函數(shù)的返回值(返回值高階函數(shù))

print('======返回值高階函數(shù)======')
def func1():
    def temp(*nums):
        return sum(nums)
    return temp

print(func1()(1, 3, 5, 9))

迭代器

1.迭代器

迭代器是容器型數(shù)據(jù)類型(可以同時存儲多個數(shù)據(jù)),但是想要獲取/查看迭代器中元素的值，只能將元素取出來
取出來的元素在迭代器中就不存在了，取的時候只能從前往后一個一個的取，不能跳著取

2.迭代器的元素

迭代器的元素只能通過類型轉換，將其他容器轉換成迭代器；或者通過生成器取生成

1. 轉換 - 所有的序列都可以轉換成迭代器 迭代器的元素可以是任何類型的數(shù)據(jù)

iter1 = iter([1, 23, 45, [1, 3]])
print(iter1)

3.獲取元素：迭代器獲取元素，不管以什么樣的方式獲取，獲取后，這個元素在迭代器中就不存在了

1. next(迭代器) - 獲取迭代器頂部數(shù)據(jù)(最上面的數(shù)據(jù))

iter2 = iter('hello')
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2))
# print(next(iter2))  # StopIteration 元素取完之后會報錯

2. 遍歷獲取每個元素

iter2 = iter('hello')
next(iter2)
next(iter2)
for x in iter2:
    print('x:', x)
# print(next(iter2))  # StopIteration

生成器

1.什么是生成器

生成器本質就是迭代器，迭代器不一定是生成器
調用一個帶有yield關鍵字的函數(shù)就能得到一個生成器(yeild只能出現(xiàn)在函數(shù)體中)

def func1():
    print('=====')
    return 100
    yield

gen1 = func1()
gen2 = func1()
print(gen1, gen2)

2.生成器的元素

生成器獲取元素的方式和迭代器一樣：next()和循環(huán)遍歷(只能是for循環(huán))

1. 生成器元素的個數(shù)：看執(zhí)行完生成器對應的函數(shù)會遇到幾次yield
2. 元素的值：看yield后表達式的值

def func2():
    print('函數(shù)體')
    for x in range(10):
        yield x

gen3 = func2()
print('next:', next(gen3))
print('next:', next(gen3))
for x in gen3:
    print('x:', x)

3) 生成器產生數(shù)據(jù)的原理

當獲取生成器的元素的時候，會執(zhí)行生成器對應的函數(shù)，從開始執(zhí)行到y(tǒng)ield為止，將yield后面的數(shù)據(jù)作為元素返回并且記錄結束位置
下次獲取元素的時候，從上次結束的位置接著往后執(zhí)行，直到遇到y(tǒng)ield，將yield后面的數(shù)據(jù)作為元素返回并且記錄結束位置
依次類推
如果從開始執(zhí)行到函數(shù)結束，沒有遇到y(tǒng)ield，那么就獲取不到元素

print('======')
def func3():
    print('第一次')
    yield 1
    print('第二次')
    yield 2
    print('第三次')
    yield 3

gen4 = func3()
print('next1:', next(gen4))
for x in range(10):
    print('+++++')

print('next2:', next(gen4))
print('next3:', next(gen4))

nums = ['001', '002', '003', '004']
def func5():
    for x in range(1, 6):
        yield str(x).rjust(3, '0')
nums2 = func5()
print(next(nums2))
print(next(nums2))

能夠產生無線數(shù)字的生成器

def func6():
    num = 0
    while True:
        yield num
        num += 1

gen5 = func6()