總結：從基本資料型別到執行緒
阿新 • • 發佈：2020-12-10
技術標籤：python
可迭代物件
1.我們已經知道可以對list,tuple,dict,set,str等型別的資料使用for....in...的迴圈語法，從其中依次拿到資料進行使用，我們把這樣的的過程稱為遍歷，也叫迭代。
2.把可以通過for....in...這類語句迭代讀取一條資料供我們使用的物件稱之為可迭代物件（Iterator）。
推導式
推導式
1.推導式分為 列表推導式、字典推導式、集合推導式等。在這⾥我們主要說其中 ⼀種也是⽤的Y多列表推導式 列表推導式是Python構建列表（list）的⼀種快捷⽅式,可以使⽤簡潔的程式碼就 創建出⼀個列表簡單理解就是由⼀箇舊的列表來構建出⼀個新的列表
語法
1 [表示式 for 變數 in 舊列表]
2 [表示式 for 變數 in 舊列表 if 條件]
⽣成器*
⽣成器
背景
通過列表推導式我們可以直接創建出⼀個列表，但是受到記憶體的限制，我們不 可能創造出⼀個⽆限⼤的列表。⽽且建立⼀個有200萬個元素的列表，會佔⽤很 ⼤的記憶體空間，⽽這個時候我們僅僅需要訪問列表中⼏個元素，那麼後⾯的元
素就佔⽤著空間就是⼀種浪費的⾏為。那麼我們可不可以⽤⼏個元素就創建出 ⼏個元素。這樣在⼀定程度上就優化了記憶體。那麼在Python中有⼀種⼀邊迴圈 ⼀邊計算的機制就是⽣成器
建立⽣成器的⽅式
通過列表推導式的⽅式
1 g = (x * 3 for 通過函式的⽅式
1 def fu():
2 n = 0
3 while True:
4 n += 1
5 yield n
只要在函式中出現yield關鍵字它就是⼀個⽣成器函式
迭代器
關係對應圖
迭代器
1.迭代器是訪問集合元素的⼀種⽅式。迭代器是⼀個 可以記住遍歷位置的對 象。
2.迭代器物件從集合的第⼀個元素開始訪問，指導所有元素被訪問完結束。
3.可以被next()函式調⽤並不斷返回下⼀個值的物件稱為迭代器Iterator
4.⽣成器是可迭代的，也是迭代器
5.列表是可迭代的，但不是迭代器
6 閉包
# 閉包構成的三大條件
# 1. 函式巢狀
# 2. 內部函式使用外部函式的引數或者變數
# 3. 外部函式返回內部函式的函式物件
# 函式需要執行程式碼，呼叫函式
# fun_out 函式物件 fun_out()呼叫函式
# def fun_out(num1):
# def fun_inner(num2):
# res = num1 + num2
# print(res)
#
# return fun_inner
# f = fun_out(1) # f = fun_inner
# f(2)
# fun_out(1)(2) # 函式 的呼叫等於函式的返回值 fun_out()() = fun_inner()
# f = fun_out(1) # f = fun_inner
# f(2)
# 閉包的特性：保持外部函式的變數不被銷燬
# python關鍵是使用，python是類似與指令碼型語言，用起來舒服，但是底層實現的就很複雜
# 裝飾器
def fun_out(fn):
def fun_inner(*args, **kwargs):
print('函式開始執行')
r = fn(*args, **kwargs) # r = add1()
print(r)
print('函式執行結束')
return fun_inner
def fun(fn):
def wrapper(*args, **kwargs):
print('我是第二個裝飾器')
r = fn(*args, **kwargs)
print(r)
return wrapper
@fun
@fun_out # @fun_out == fun_out(add1) # 語法糖的寫法
def add1(a, b):
return a + b
# f = fun_out(add1)
# f(1, 2)
add1(1, 2)
# def qiuji():
# print(111)
#
# # 裝飾函式
# def fun(fn):
# print('函式開始執行')
# fn()
# print('函式執行結束')
#
# fun(qiuji)
列表推導式
# 找到長度大於3的名字
# 中文是佔兩個字元
# def fun(lis):
# new_list = []
# for i in list1:
# if len(i) > 3:
# new_list.append(i)
#
# return new_list
#
#
# r = fun(list1)
# print(r)
# 列表推導式語法
# [表示式 for 變數 in 舊列表]
# list3 = [i for i in range(10)]
# print(list3)
# # [表示式 for 變數 in 舊列表 if 條件]
# list1 = ['cheney', 'jerry', '居然', 'amy']
# list2 = [i*2 for i in list1 if len(i) > 3] # list2 = [i1, i2, i3, i4]
# print(list2)
# 1-100之間能被4整除的資料放到新列表中 還要能被6整除的數
# list4 = [i for i in range(1, 101) if i % 4 == 0]
# list5 = [i for i in list4 if i % 6 == 0]
# 對於某某某在某某某中間，然後我們幹嘛
list4 = [name+1 for name in range(1, 101) if name % 4 == 0 and name % 6 == 0]
print(list4)
迭代器
# 通過不同得可迭代物件可以轉換為迭代器，但是物件本質不同
# 可迭代物件 實現了iter()這個方法
# 迭代器物件 實現了 next()、iter()方法
list1 = [1, 2, 3, 4, 5]
tuple1 = (1, 2, 3, 4, 5)
iterate = iter(list1) # list_iterator
iterate = iter(tuple1) # tuple_iterator
# print(itra)
# print(itra1)
list2 = [i for i in itra]
print(list2)
print(next(itra))
# list3 = [i for i in itra]
# print(list3)
# print(next(itra))
# 迭代器可以完成得事情，生成器都可以完成，而且生成器更加得靈活
print('ssssss%s' % 'ha')
class A(object):
def __init__(self):
self.a = 1
def __iter__(self):
return self
def next(self):
pass
生成器
# 方法一：推導式的方式獲得
# 得到從1-100之間得到能整除4的列表
# list1 = [i for i in range(1, 101) if i % 4 == 0]
# print(list1)
# gen = (i for i in range(1, 101) if i % 4 == 0)
# print(gen, type(gen)) # generator 生成器
# 生成器是一個特殊的迭代器， 是一種容器, 資料取完了就沒了， 如果沒取完，生成器會記住上次取資料的位置，下次你在取得時候，就會從這個位置開始取資料
print(next(gen))
# print(next(gen))
# print(next(gen))
# print(next(gen))
# list1 = [i for i in gen]
# print(list1)
# print(next(gen))
# print(len(gen))
# list1 = [i for i in gen]
# print(list1)
# 使用函式得方式來得到生成器 yield
# 函式只要有呼叫，就會進入到函式內部執行程式 沒有return列印一個None
# 但是，此時，這個函式已經不是一個函數了，它變成了一個生成器
def fun():
def fun1():
pass
i = 0
while True:
i += 1
yield i # yield和return有同樣得返回得效果, yield有阻塞程式得效果
print(i)
r = fun()
# print(r)
print(next(r))
print(next(r))
print(next(r))
list()
作業
# 請使用裝飾器實現已存在的函式的執行所花費的時間。
import time
def get_time(fn):
def fun_inner():
begin = time.time()
fn()
end = time.time()
print('函式得執行時間為%s' % (end - begin))
return fun_inner
@get_time
def fun():
for i in range(20000000):
pass
fun()