迭代器

1.迭代器
"""
什麼是迭代器
迭代:更新換代(重複)的過程,每次的迭代都必須基於上一次的結果
迭代器:迭代取值的工具

爲何要用
迭代器給你提供了一種不依賴於索引取值的方式

如何用
"""
n = 1
f = 1.1
s = 'hello'
l = [1, 2, 34, ]
t = (1, 2, 34)
s1 = {1, 2, 3, 4}
d = {'name': 'jason'}
f1 = open('xxx.txt', 'w', encoding='utf-8')

#
# res = s.__iter__() # 等價於res = iter(s)
#
# print(s.__len__()) # 簡化成了len(s)
# res1 = l.__iter__() # res1 = iter(l)
# res2 = f1.__iter__() # res2 = iter(f1)
# print(res,res1,res2)
# print(f1)

# 可迭代對象執行內置的__iter__方法獲得就是該對象的迭代器對象

2.迭代器取值
"""
迭代器對象
1.內置有__iter__方法
2.內置有__next__方法 # 只有做爲迭代器對象時才能用第二種方法
ps:迭代器必定是可迭代對象
而可迭代對象不必定是迭代器對象
"""

# l = [1,2,3,]
# # 生成一個迭代器對象
# iter_l = l.__iter__() 記住這個
#
# # 迭代器取值 調用__next__
# print(iter_l.__next__())
# print(iter_l.__next__())
# print(iter_l.__next__()) # 若是取完了 直接報錯

# d = {'name':'jason','password':'123','hobby':'泡m'}
# # 將可迭代對象d轉換成迭代器對象
# iter_d = d.__iter__()
# # 迭代器對象的取值 必須用__next__
# print(iter_d.__next__())
# print(iter_d.__next__())
# print(iter_d.__next__())
# print(iter_d.__next__()) # 取完了 報錯StopIteration

f1 = open('xxx.txt','r',encoding='utf-8')
# 調用f1內置的__iter__方法
# iter_f = f1.__iter__()
# print(iter_f is f1)
"""
迭代器對象不管執行多少次__iter__方法獲得的仍是迭代器對象自己(******)
"""
# print(f1 is f1.__iter__()
"""
問:__iter__方法就是用來幫咱們生成迭代器對象
而文件對象自己就是迭代器對象,爲何還內置有__iter__方法???
"""

 

 

d = {'name':'jason','password':'123','hobby':'泡m'}
# iter_d = d.__iter__()

# print(d.__iter__().__next__())
# print(d.__iter__().__next__())
# print(d.__iter__().__next__()) # 不斷地生成的迭代器，致使結果重複

# print(iter_d.__next__())
# print(iter_d.__next__())
# print(iter_d.__next__())
# print(iter_d.__next__())

# 異常處理
# while True:
# try:
# print(iter_d.__next__())
# except StopIteration:
# # print('老母豬生不動了')
# break

"""
迭代器取值的特色
1.只能日後依次取 不能後退
"""

3.for循環的本質
d = {'name':'jason','password':'123','hobby':'泡m'}
# for i in d:
# print(i)
# for循環後面的in關鍵 跟的是一個可迭代對象
"""
for循環內部的本質
1.將in後面的可迭代對象調用__iter__轉換成迭代器對象
2.調用__next__迭代取值
3.內部有異常捕獲StopIteration,當__next__報這個錯 自動結束循環
"""

"""
可迭代對象:內置有__iter__方法的
迭代器對象:既內置有__iter__也內置有__next__方法

迭代取值:
優勢
1.不依賴於索引取值
2.內存中永遠只佔一份空間,不會致使內存溢出

缺點
1.不可以獲取指定的元素
2.取完以後會報StopIteration錯

"""
# l = [1,2,3,4]
# res = map(lambda x:x+1,l) # 內置for循環
# print(map(lambda x:x+1,l)) # 這是一個迭代器的內存地址
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())

l1 = [1,2,3,4,5]
l2 = ['a','b','c']
print(zip(l1,l2))

4.生成器(定義函數的形式)
"""
生成器:用戶自定義的迭代器,本質就是迭代器
"""

# def func():
# print('first')
# yield 666 # 注意 函數內若是有yield關鍵字,那麼加括號執行函數的時候並不會觸發函數體代碼的運行
# print('second')
# yield 777
# print('third')
# yield 888
# print('forth')
# yield
# yield
# # yield後面跟的值就是調用迭代器__next__方法你能獲得的值
# # yield既能夠返回一個值也能夠返回多個值 而且多個值也是按照元組的形式返回
# g = func() # 生成器初始化:將函數變成迭代器
# print(g)
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())
# print(g.__next__()) # yield後沒有值時結果爲None

# print(range(1,10))

# for i in range(1,10,2):
# print(i)

def my_range(start, end, step=1):
while start < end:
yield start
start += step

5.yield 與return
# yield支持外界爲其傳參
def dog(name):
print('%s 準備開吃' % name)
while True:
food = yield
print('%s 吃了 %s' % (name, food))

# def index():
# pass

#dog() # 這個不會運行可是print（'dog'）仍然是函數的的內存地址
# 就是說當函數內有yield關鍵字的時候,調用該函數不會執行函數體代碼 這是於自定義函數的區別
# 將函數變成生成器即迭代器
# g = dog('egon')
# g.__next__() # 必須先將代碼運行至yield 纔可以爲其傳值
# g.send('狗不理包子') # 給yield左邊的變量傳參 觸發了__next__方法
# g.send('餃子')

"""

yield
1.幫你提供了一種自定義生成器方式
2.會幫你將函數的運行狀態暫停住
3.能夠返回值

與return之間異同點
相同點:均可以返回值,而且均可以返回多個
不一樣點:
yield能夠返回屢次值,而return只能返回一次函數當即結束
yield還能夠接受外部傳入的值
"""

6.生成器表達式
# 列表生成式
# res = [i for i in range(1,10) if i != 4]
# print(res)

# res = (i for i in range(1,100) if i != 4) # 注意這個不是元組的表達式，而是生成器表達式
# print(res)
# """
# 生成器不會主動執行任何一行代碼
# 必須經過__next__觸發代碼的運行
# """
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())

# 佔內存由於要一次性讀取
# f = open('xxx.txt','r',encoding='utf-8')
# data = f.read()
# print(len(data))
# f.close() # 下面的with open 格式會自動幫你close文件

# with open('xxx.txt','r',encoding='utf-8') as f:
# # n = 0
# # for line in f:
# # n += len(line)
# # print(n)
# g = (len(line) for line in f)
# # print(g.__next__())
# # print(g.__next__())
# # print(g.__next__())
# # print(g.__next__())
# print(sum(g)) # 由於逐行讀取因此節省了內存提升了效率 記住sum逐行方法

7.經常使用的一些內置方法
# print(abs(-11.11)) # 求絕對值
# l = [0,1,0]
# print(all(l)) # 只要有一個爲False就返回False
# print(any(l)) # 只要有一個位True就返回True
def index():

username = '我是局部名稱空間裏面的username'
# print(locals()) # 當前語句在哪一個位置 就會返回哪一個位置所存儲的全部的名字
print(globals()) # 不管在哪 查看的都是全局名稱空間
# index()
# print(bin(10))
# print(oct(10))
# print(hex(10))
# print(int('0b1010',2))

# print(bool(1))
# print(bool(0))

# s = 'hello'
# print(s.encode('utf-8'))
# print(bytes(s,encoding='utf-8'))

# 可調用的(能夠加括號執行相應功能的)
# l = [1,2,3]
# def index():
# pass
# print(callable(l))
# print(callable(index))

 

 

# print(chr(97)) # 將數字轉換成ascii碼錶對應的字符
# print(ord('a')) # 將字符按照ascii錶轉成對應的數字

"""
面向對象須要學習的方法
classmethod
delattr
getattr
hasattr
issubclass
property
repr
setattr
super
staticmethod
"""
# dir獲取當前對象名稱空間裏面的名字
"""
迭代器對象
1.內置有__iter__方法
2.內置有__next__方法
ps:迭代器必定是可迭代對象
而可迭代對象不必定是迭代器對象
"""

8.面向對象
"""
面向過程編程:就相似於設計一條流水線
好處:
將複雜的問題流程化 從而簡單化
壞處:
可擴展性較差 一旦須要修改 總體都會受到影響
"""
# 註冊功能
# 1.獲取用戶輸入
def get_info():
while True:
username = input(">>>:").strip()
if not username.isalpha(): # 判斷字符串不能包含數字
print('不能包含數字')
continue
password = input('>>>:').strip()
confirm_password = input("confirm>>>:").strip()
if password == confirm_password:
d = {
'1':'user',
'2':'admin'
}
while True:
print("""
1 普通用戶
2 管理員
""")
choice = input('please choice user type to register>>>:').strip()
if choice not in d:continue
user_type = d.get(choice)
operate_data(username,password,user_type)
break
else:
print('兩次密碼不一致')

# 2.處理用戶信息
def operate_data(username,password,user_type):
# jason|123
res = '%s|%s|%s\n'%(username,password,user_type)
save_data(res,'userinfo.txt')

# 3.存儲到文件中
def save_data(res,file_name):
with open(file_name,'a',encoding='utf-8') as f:
f.write(res)

def register():
get_info()

register()