python是解釋型語言

變量定義的規(guī)則：

• 變量名只能是字母、數(shù)字或下劃線的任意組合
• 變量名的第一個字符不能是數(shù)字
• 以下關(guān)鍵字不能聲明為變量名
  【‘a(chǎn)nd’，‘a(chǎn)s’,‘a(chǎn)ssert’，‘break’，‘class’，‘continue’，‘def’，‘elif’，‘else’，‘except’，‘exec’，‘finally’，‘for’，‘from’，‘global’，‘if’，‘import’，‘in’，‘is’，‘lambda’，‘not’，‘or’，‘pass’，‘print’，‘raise’，‘return’，‘try’，‘while’，‘with’，‘yield’】

字符編碼

python解釋器加載.py文件中的代碼時，會對內(nèi)容進(jìn)行編碼（默認(rèn)ASCII），ASCII碼最多只能表示255個符號，一個字符占一個字節(jié)，8位bits

image.png

顯然ASCII碼無法將世界上的各種文字和符號全部表示，所以，就需要新出一種可以代表所有字符和符號的編碼，即：Unicode，一個字符占兩個字節(jié)，16位bits
UTF-8,，又進(jìn)步為可變存儲字節(jié)數(shù)，en:1bytes，zh:3bytes

image.png

注釋

當(dāng)行注釋：#被注釋內(nèi)容
多行注釋：'''被注釋內(nèi)容'''
注：多行注釋也可以多行輸出

image.png

用戶交互程序

image.png

image.png

image.png

image.png

密碼密文顯示

image.png

循環(huán)

while循環(huán)

image.png

次數(shù)達(dá)到限制，詢問是否繼續(xù)：

image.png

for循環(huán)

image.png

image.png

image.png

庫

python的強(qiáng)大之處在于有非常豐富和強(qiáng)大的標(biāo)準(zhǔn)庫和第三方庫，幾乎你想實現(xiàn)的任何功能都有相應(yīng)的python庫支持

sys庫

打印環(huán)境變量
print(sys.path)

打印文件路徑
print(sys.argv)

第三方庫的安裝位置

image.png

標(biāo)準(zhǔn)庫的安裝位置

image.png

OS庫

import os
cmd_system=os.system('dir')#執(zhí)行命令，不保存結(jié)果
print('cmd_system--',cmd_system)
cmd_popen=os.popen('dir').read()#通過read方法讀取存在內(nèi)存的信息
print('cmd_popen---',cmd_popen)
os.mkdir('new_dir')#在當(dāng)前位置創(chuàng)建一個目錄

image.png

數(shù)據(jù)類型

數(shù)字

int（整型）
在32位機(jī)器上，整數(shù)的位數(shù)為32位，取值范圍為-2^31~ 2^31-1
在64位機(jī)器上，整數(shù)的位數(shù)為32位，取值范圍為-2^63~ 2^63-1

long（長整型）
python的長整數(shù)沒有指定位寬

float（浮點型）
浮點數(shù)用來處理實數(shù)，即帶有小數(shù)的數(shù)字，類似于C語言中的double類型，占8個字節(jié)（64位），其中52位表示底，11位表示指數(shù)，剩下的一位表示符號

修改浮點數(shù)的精度：

a=1.3455465457647
a=float('%0.2f'%a)#a=1.35

bytes類型

bytes-》string：decode
string-》bytes：encode

image.png

布爾值

對象的三個特征：id（is）、value（==）、type（isinstance）
真或假（1或0）
三元運算

result=值1 if 條件 else 值2

image.png

字符串

name='ha\tha'
print('name:',name)
print('len(name):',len(name))
print('name.capitalize():',name.capitalize())#首部大寫
print("name.count('h'):",name.count('h'))#指定字母出現(xiàn)的次數(shù)
print("name.center(10,'-'):",name.center(10,'-'))#指定字符串的長度，將原本的字符串?dāng)?shù)據(jù)放在中間，不夠的數(shù)據(jù)用‘-’補(bǔ)全
print("name.ljust(10,'-'):",name.ljust(10,'-'))#指定字符串的長度，將原本的字符串?dāng)?shù)據(jù)放在左邊，不夠的數(shù)據(jù)用‘-’補(bǔ)全
print("name.rjust(10,'-'):",name.rjust(10,'-'))#指定字符串的長度，將原本的字符串?dāng)?shù)據(jù)放在右邊，不夠的數(shù)據(jù)用‘-’補(bǔ)全
print("name.endswith('a'):",name.endswith('a'))#判斷字符串是否是指定字母結(jié)尾
print('name.expandtabs(tabsize=6):',name.expandtabs(tabsize=6))#將tab鍵轉(zhuǎn)換為指定個數(shù)的空格
print("name.find('a'):",name.find('a'))#找出指定字母的指針
print("name[name.find('a'):]:",name[name.find('a'):])#切片
name2='hello {haha} world'
print('name2:',name2)
print("name2.format(haha='enen'):",name2.format(haha='enen'))
print("name2.format_map({'haha':'enen'}):",name2.format_map({'haha':'enen'}))#通過字典傳參
print("'---'.join(['1','2','3']):",'---'.join(['1','2','3']))#將列表轉(zhuǎn)換為字符串并用制動數(shù)據(jù)隔開
print("'HINIjijhijHI'.lower():",'HINIjijhijHI'.lower())#將大寫變小寫
print("'HINIjijhijHI'.lower():",'HINIjijhijHI'.lower())
print(r'\nHINIjijhijHI','\nHINIjijhijHI')
print(r"'   \nHINIjijhijHI   '.lstrip():",'   \nHINIjijhijHI   '.lstrip())#去掉最左邊的回車鍵
print(r"'  HINIjijhijHI\n   '.rstrip():",'  HINIjijhijHI\n   '.rstrip())#去掉最右邊的回車鍵
print(r"'   \nHINIjijhijHI   \n'.strip():",'   \nHINIjijhijHI   \n'.strip())#去掉左右的的回車鍵和空格鍵

p=str.maketrans('nbyaneuf','09754216')#通過對應(yīng)數(shù)據(jù)對字符串進(jìn)行替換
print('yuan'.translate(p))

print("'HINIjijhijHI'.replace('H','8',1):",'HINIjijhijHI'.replace('H','8',1))#替換指定個數(shù)的字符串內(nèi)數(shù)據(jù)
print("'1+2+3+4'.split('+'):",'1+2+3+4'.split('+'))#通過字符串內(nèi)指定數(shù)據(jù)對字符串進(jìn)行分割，分割成列表
print("'Haha'.swapcase():",'Haha'.swapcase())#交換字符串大小寫
print("'aha yoy'.title():",'aha yoy'.title())#將字符串換成標(biāo)題格式，每個單詞首字母大寫

輸出內(nèi)容：

image.png

列表

name=['haha','enen','lala','yoyo','hengheng','lala']
print(name[0])
print(name[2:4])#切片：顧頭不顧尾，包含開頭，不包含結(jié)束位置
print(name[-1])#取最后一個
print(name[-3:-1])
print(name[-2:])#取最后兩個
print(name[:2])#取前面兩個

name.append('qq')#插入數(shù)據(jù)到最后面
print(name)
name.insert(1,'pp')#插入數(shù)據(jù)到指定位置
print(name)

name[1]='KK'#修改指定位置的數(shù)據(jù)
print(name)

name.remove('KK')#刪除指定數(shù)據(jù)
print(name)
del name[-1]#刪除指定位置數(shù)據(jù)
print(name)
name.pop(1)#刪除指定位置的數(shù)據(jù)，沒有輸入下標(biāo)，默認(rèn)刪除最后一個數(shù)據(jù)

print(name.index('yoyo'))#查找指定數(shù)據(jù)的坐標(biāo)

print(name.count('hengheng'))#查看指定數(shù)據(jù)的個數(shù)
name.reverse()#翻轉(zhuǎn)列表
print(name)
name.sort()#排序（特殊符號，數(shù)字，大寫字母，小寫字母）
print(name)
name_num=[1,2,3,4]
name.extend(name_num)#合并2個列表
print(name,name_num)

name.clear()#清空列表
print(name)

輸出內(nèi)容：

import copy
name=['haha','enen','lala','yoyo',['yuan','jojo'],'hengheng','lala']
print(name[0:-1:2])#切片隔一個打印一個
#print(name[::2])#同上
name2=name.copy()#淺copy，復(fù)制第一層，其他的多層數(shù)據(jù)都是copy的內(nèi)存地址
name3=copy.deepcopy(name)#深copy，全部復(fù)制，復(fù)制的就是數(shù)據(jù)
print(name3)
print(name2)
name[2]='啦啦'
print(name)
print(name2)
print(name3)
name[4][0]='YUAN'
print(name)
print(name2)
print(name3)

輸出內(nèi)容：

image.png

元組

元組和列表差不多，也是存一組數(shù)，不過它一旦創(chuàng)建，便不能修改，所以又叫只讀列表
它只有2個方法，一個是count，一個是index；

name=('haha','enen','lala')

集合

集合是一個無序的，不重復(fù)的數(shù)據(jù)組合，他的主要作用如下：

• 去重，把一個列表變成集合，就自動去去重了
• 關(guān)系測試，測試兩組數(shù)據(jù)之間的交集、差集、并集等關(guān)系

# Author:haha

list_1=[1,4,2,6,7,9,0,7,4,3,0]
list_1=set(list_1)
print('list1',list_1)
list_2=set([2,3,4,55,7,332])
print('list2',list_2)
list_3=set([0,1])
print('list_3',list_3)
#關(guān)系測試
print(list_1.intersection(list_2))#取交集
print('&交集',list_1&list_2)

print(list_1.union(list_2))#并集
print('|并集',list_1|list_2)

print(list_1.difference(list_2))#差集，list_1有，list_2沒有的數(shù)據(jù)
print('1-2:-差集',list_1-list_2)

print(list_2.difference(list_1))#差集，list_2有，list_1沒有的數(shù)據(jù)
print('2-1:-差集',list_2-list_1)

print(list_3.issubset(list_1))#判斷l(xiāng)ist_3是否是list_1的子集
print(list_1.issuperset(list_3))#判斷l(xiāng)ist_1是否是list_3的父集

print(list_1.symmetric_difference(list_2))#對稱差集，將list_1、list_2中都互相沒有的取都出來
print('^對稱差集',list_1^list_2)

#其他遺漏關(guān)系
print('----------')
list_4=set([0,3])
print(list_3.isdisjoint(list_4))#判斷l(xiāng)ist3是否和list4有交集，如果有，返回FALSE

list_3.add(999)
print('add 1項',list_3)
list_3.update([5,6,7])
print('update 多項',list_3)
#如果該元素不存在于集合中，則會拋出KeyError；如果存在集合中，則會移除該元素并返回None。
print('remove指定刪除元素',list_3.remove(7))
#如果該元素不存在于集合中，則不會拋出KeyError；如果存在集合中，則會移除該元素并返回None。
print('discard指定刪除元素',list_3.discard(5))

print('pop隨機(jī)刪除元素，并返回被刪除的元素',list_3.pop())
print('len',len(list_3))
print(list_3)

輸出結(jié)果：

image.png

字典

字典的特性：
·dict是無序的
·key必須是唯一的，所以天生去重

info={
   'name':'haha',
   'age':12,
   'sex':'female'
     }
info['name']='enen'#修改現(xiàn)有數(shù)據(jù)
print(info)
info['ID']='1'#添加數(shù)據(jù)
print(info)
print(info.keys())#打印所有的key
print(info.values())#打印所有的values
info.setdefault('pp','yoyo')#字典中取key值，能取到就返回value值，沒取到，就創(chuàng)建key值，及新value值
print(info)
print('name' in info)#判斷指定key是否在字典中
print(info.get('name'))#查找指定key值value，存在打印，不存在，打印none
print(info.get('oo'))
del info['ID']#刪除指定key數(shù)據(jù)
print(info)
info.pop('name')#刪除指定key數(shù)據(jù)
print(info)

輸出內(nèi)容：

image.png

a={'a':'aa','b':'bb','c':'cc'}
b={'a':'haha',1:11,2:22}
a.update(b)#將b合并大a中，如果有相同key值，b的value替換a中value值
print(a)
print(a.items())
c=dict.fromkeys([6,7,8],'test')#初始化字典
print(c)

#字典的循環(huán)
for i in a:#效率更高
    print(i,a[i])
for i,j in a.items():
    print(i,j)

輸出內(nèi)容：

image.png

進(jìn)制轉(zhuǎn)換

二進(jìn)制數(shù)與十六進(jìn)制數(shù)之間如何互相轉(zhuǎn)換
16位表示方法：

二進(jìn)制轉(zhuǎn)換成十六進(jìn)制方法：取四合一，如

image.png

16進(jìn)制的表示法：比BH表示16進(jìn)制數(shù)11；0x53表示16進(jìn)制53

image.png

image.png

十六進(jìn)制轉(zhuǎn)二進(jìn)制：一分四

image.png

進(jìn)制表示

二進(jìn)制：0b(二進(jìn)制數(shù))  如：0b10=2(十進(jìn)制數(shù))
八進(jìn)制：0o(八進(jìn)制數(shù))  如：0o10=8(十進(jìn)制數(shù))
十六進(jìn)制：0x(十六進(jìn)制數(shù))  如：0x10=16(十進(jìn)制數(shù))
十進(jìn)制：(十進(jìn)制數(shù))  如：10=10(十進(jìn)制數(shù))

轉(zhuǎn)換

bin(除二進(jìn)制數(shù))->二進(jìn)制
int(除十進(jìn)制數(shù))->十進(jìn)制
hex(除十六進(jìn)制數(shù))->十六進(jìn)制
oct(除八進(jìn)制數(shù))->八進(jìn)制
ord(除ascll碼)->ascll碼

運算符

'hello'+'world'
#helloworld
[1,2,3]*3
#[1, 2, 3, 1, 2, 3, 1, 2, 3]
3-1
#2
3/2
#1.5
3//2(整除)
#1
5%2(求余)
#1
5**2(平法)
#25
5**5(次方)
#3125

賦值運算符（先計算再賦值）

=、-=、+=、=、/=、//=、%=、*=

邏輯運算符

優(yōu)先級：
高：not（反）
中：and（且） 遇假為假
低：or（或） 遇真為真

位運算符（把數(shù)字當(dāng)做二進(jìn)制進(jìn)行計算）

&（按位與）->10&11->10 見0是0
|（按位或）->10|11->11 見1是1
^（按位異或）
~（按位取反）
<<（左移動）
>>（右移動）

文件操作

對文件操作流程
1、打開文件，得到文件句柄并復(fù)制給一個變量
2、通過句柄對文件進(jìn)行操作
3、關(guān)閉文件

#讀文件
file=open('buweixia','r',encoding='utf-8')#文件句柄,默認(rèn)讀模式
data=file.read()#執(zhí)行后文件指針已經(jīng)知道文件末尾
data2=file.read()#所以data2為空
print(data)
print('---data2---',data2)
file.close()

file6=open('buweixia2','rb')#以二進(jìn)制模式讀取文件
print(file6.readline().strip())
print(file6.readline().strip())
file6.close()

#寫文件
file2=open('buweixia2','w',encoding='utf-8')#使用寫模式，是創(chuàng)建，如果文件存在，就會覆蓋之前內(nèi)容，如果文件不存在，就會創(chuàng)建文件
file2.write('不謂俠\n')
file2.write('歌詞\n')
file2.close()

file7=open('buweixia2','wb')#以二進(jìn)制模式寫文件
file7.write('編曲：潮汐-tide\n')
file7.close()

#可讀可寫
file5=open('buweixia2','r+',encoding='utf-8')#使用讀寫模式，是創(chuàng)建，如果文件不存在，就會創(chuàng)建文件
print(file5.readline().strip())
print(file5.readline().strip())
file5.write('不謂俠\n')
file5.write('歌詞\n')
file5.close()

#追加文件
file3=open('buweixia2','a',encoding='utf-8')#使用追加模式，是創(chuàng)建，如果文件不存在，就會創(chuàng)建文件
file3.write('詞：遲意 ')
file3.write('曲：潮汐-tide\n')
file3.close()

file4=open('buweixia','r',encoding='utf-8')#文件句柄,默認(rèn)讀模式
#打印前5行內(nèi)容
print('------打印前5行內(nèi)容------')
for i in range(5):
    print(file4.readline().strip())
#循環(huán)文件,大文件的話，占內(nèi)存
print('--------循環(huán)文件，操作第10行---------')
for index,line in enumerate(file4.readlines()):
    if index==9:
        print('-----分割線-------')
        continue
    print(line.strip())

#高效循環(huán)文件，不占內(nèi)存
file4=open('buweixia','r',encoding='utf-8')#文件句柄,默認(rèn)讀模式
count=0
for line in file4:
    if count==9:
        print('-----分割線-------')
        count += 1
        continue
    count+=1
    print(line.strip())
 

file=open('buweixia','r',encoding='utf-8')#文件句柄,默認(rèn)讀模式
print(file.tell())#打印當(dāng)前指針的位置
print(file.read(5))#指定讀取文件字符個數(shù)
print(file.tell())
file.seek(22)#移動指針到文件開頭位置
print(file.readline())
print(file.encoding)#打印文件的編碼格式
print(file.name)#打印文件名

print(file.flush())#實時更新硬盤數(shù)據(jù)
#例：
import sys,time
for i in range(10):
    sys.stdout.write('#')
    sys.stdout.flush()
    time.sleep(0.1)

file.truncate(10)#沒有參數(shù)，就清空文件；有參數(shù)，就從指定指針位置截斷文件

#修改文件
f1=open('buweixia','r',encoding='utf-8')
f_new=open('buweixia_update','w',encoding='utf-8')
for line in f1:
    if '潮汐-tide' in line:
        line=line.replace('潮汐-tide','haha')
    f_new.write(line)
f1.close()
f_new.close()

with:為了避免文件打開后忘記關(guān)閉，就通過with管理上下文

#可以同時打開多個文件
with open('buweixia','r',encoding='utf-8') as f,\
        open('buweixia','r',encoding='utf-8') as f2:
    for line in f:
        print(line)
    print(f2.readline())

函數(shù)

編程語言中的函數(shù)定義：函數(shù)是邏輯結(jié)構(gòu)化和過程化的一種編程方法。

#python中函數(shù)定義方法
def test(x):
    'The function definitions'
    x+=1
    return
'''
def:定義函數(shù)的關(guān)鍵字
test：函數(shù)名
（）：內(nèi)可定義形參
'':函數(shù)描述（非必要，但是強(qiáng)烈建議為你的函數(shù)添加描述信息）
x+=1：泛指代碼塊或程序處理邏輯
return:定義返回值
'''

使用函數(shù)的三大優(yōu)點：
1、代碼重用
2、保持一致
3、可擴(kuò)展性

函數(shù)的返回值：

• 返回值數(shù)=0；返回None
• 返回值數(shù)=1；返回object
• 返回值數(shù)>0；返回tuple

傳參

#默認(rèn)參數(shù)特點：調(diào)用函數(shù)的時候，默認(rèn)參數(shù)非必須傳遞
def test1(x=1):
    print('test1',x)
test1()
#輸出：1

#接收N個位置參數(shù)，轉(zhuǎn)換成元組形式
def test2(*args):
    print(args)
    print(type(args))

test2(1,2,3,4)
test2(*[1,2,3,4,5])
#輸出：(1, 2, 3, 4)
#      <class 'tuple'>
    # (1, 2, 3, 4, 5)
    # <class 'tuple'>

#**kwargs:把N個關(guān)鍵字參數(shù)，轉(zhuǎn)換成字典的方式
def test3(name,age=18,**kwargs):
    print(name)
    print(age)
    print(kwargs)

test3('haha',sex= 'm',hobby='testing')
#輸出：
# haha
# 18
# {'sex': 'm', 'hobby': 'testing'}

def test4(**kwargs):
    print(kwargs)
test4(**{'name':'haha','sex':'m'})
#輸出：{'name': 'haha', 'sex': 'm'}

局部變量和全局變量

• 在子程序中定義的變量為局部變量，在程序的一開始定義的變量為全局變量
• 全局變量的作用域是整個程序，局部變量作用域是定義該變量的子程序
• 當(dāng)全局變量與局部變量同名時，在定義局部變量的子程序內(nèi)，局部變量起作用，在其他地方全局變量起作用

#局部變量，所在函數(shù)就是這個變量的作用域
def test1(name):
    print('before change %s'%name)
    name='HAHA'
    print('after change %s'%name)

name='haha'
test1(name)
print(name)
#輸出：
# before change haha
# after change HAHA
# haha

#全局變量
def test2():
    global name #申明變量的類型
    print('before change %s'%name)
    name='HAHA'
    print('after change %s'%name)

name='haha'#全局變量
test2()
print(name)
#輸出：
# before change haha
# after change HAHA
# HAHA

遞歸

在函數(shù)內(nèi)部，可以調(diào)用其他函數(shù)，如果一個函數(shù)在內(nèi)部調(diào)用自己本身，這個函數(shù)就是遞歸函數(shù)
遞歸特性：

• 必須有一個明確的結(jié)束條件
• 每次進(jìn)入更深一層遞歸時，問題規(guī)模相比上次遞歸都應(yīng)有所減少
• 遞歸效率不高，遞歸層次過高會導(dǎo)致棧溢出

def test(n):
    print(n)
    if int(n/2)>0:
        return test(int(n/2))
    print("->",n)
test(10)
#輸出：
# 10
# 5
# 2
# 1
# -> 1

高階函數(shù)

變量可以指向函數(shù)，函數(shù)的參數(shù)能接收變量，那么一個函數(shù)就可以接收另外一個函數(shù)作為參數(shù)，這種函數(shù)就叫高階函數(shù)

def add(a,b,f):
    return f(a)+f(b)

res=add(2,-6,abs)#abs為取絕對值
print(res)
#輸出：8

裝飾器

定義：本質(zhì)是函數(shù)，裝飾其他函數(shù)就是為其他函數(shù)添加附加功能
原則：

• 不能修改被裝飾的函數(shù)的源代碼
• 不能修改被裝飾的函數(shù)的調(diào)用方式
  簡單裝飾器：

import time
def timer(func):
    def wrapper():
        print('before time',time.time())
        func()
        print('after time',time.time())
    return wrapper

@timer
def test():
    time.sleep(1)
    print('haha')

test()

復(fù)雜裝飾器：

username='haha'
passwd='123'
def login(type):
    def outwrapper(func):
        def wrapper(*args,**kwargs):
            if type=='qq':
                name=input('your username:')
                psd=input('your password:')
                if name==username and passwd==psd:
                    print('welcome...')
                    return func(*args, **kwargs)
                else:print('username or passwd error')
            else:
                print('還不支持此登錄方式！')

        return wrapper
    return outwrapper


@login(type='qq')
def first_page(name):
    print('this is first page ',name)

@login(type='weixin')
def second_page():
    print('this is second page ')

first_page('haha')
second_page()

生成器

• 只有在調(diào)用時才會生成相應(yīng)的數(shù)據(jù)
• 只記錄當(dāng)前位置
• 只有一個next（）方法

>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9

復(fù)雜生成器：

def cals(max):
    n=0
    a=0
    b=1
    while n<max:
        yield b
        a,b=b,a+b
        n+=1
    return 'done'

print(cals(10))

輸出結(jié)果：

<generator object cals at 0x0000000001E1CA20>

捕獲錯誤信息：

def cals(max):
    n=0
    a=0
    b=1
    while n<max:
        yield b
        a,b=b,a+b
        n+=1
    return 'done'
c=cals(6)
while True:
    try:
        print(next(c))
    except StopIteration as s:
        print('StopIteration',s.value)
        break

輸出結(jié)果：

1
1
2
3
5
8
StopIteration done

還可通過yield實現(xiàn)在單線程的情況下實現(xiàn)并發(fā)運算的效果：

import time
def eat(name):
    print('%s,來了，點了包子'%name)
    while True:
        num=yield
        print('%s正在吃了第%s個包子'%(name,num))


def make():
    c=eat('A')
    c2=eat('B')
    c.__next__()
    c2.__next__()
    print('包子拿來了')
    time.sleep(1)
    for i in range(8):
        time.sleep(1)
        print('上了第%s個包子'%i)
        c.send(i)
        c2.send(i)

make()

輸出結(jié)果：

A,來了，點了包子
B,來了，點了包子
包子拿來了
上了第0個包子
A正在吃了第0個包子
B正在吃了第0個包子
上了第1個包子
A正在吃了第1個包子
B正在吃了第1個包子
上了第2個包子
A正在吃了第2個包子
B正在吃了第2個包子
上了第3個包子
A正在吃了第3個包子
B正在吃了第3個包子
上了第4個包子
A正在吃了第4個包子
B正在吃了第4個包子
上了第5個包子
A正在吃了第5個包子
B正在吃了第5個包子
上了第6個包子
A正在吃了第6個包子
B正在吃了第6個包子
上了第7個包子
A正在吃了第7個包子
B正在吃了第7個包子

迭代器

• 可以直接作用于for循環(huán)的對象統(tǒng)稱為可迭代對象：Iterable
• 可以被next()函數(shù)調(diào)用并不斷返回下一個值的對象稱為迭代器：Iterator。
• 生成器都是Iterator對象，但list、dict、str雖然是Iterable，卻不是Iterator。

把list、dict、str等Iterable變成Iterator可以使用iter()函數(shù)：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

內(nèi)置方法

print('all:',all([2,0,6]))#數(shù)據(jù)內(nèi)，有假，就為假
print('any:',any([2,0,6]))#數(shù)據(jù)內(nèi)，有真，就為真
print('bin:',bin(8))#將十進(jìn)制轉(zhuǎn)為二進(jìn)制
print('hex:',hex(8))#將十進(jìn)制轉(zhuǎn)成十六進(jìn)制
print('oct:',oct(8))#將十進(jìn)制轉(zhuǎn)成八進(jìn)制
def test():pass
print('callable:',callable(test))#判斷數(shù)據(jù)是否可以調(diào)用
print('chr:',chr(77))#輸入ASCII碼，找出對應(yīng)字符
print('ord:',ord('m'))#輸入字符，找出對用ASCII碼
print('dir:',dir([]))#取出數(shù)據(jù)有哪些方法
print('eval:',eval("{'name':'haha'}"))#將字符串轉(zhuǎn)成表達(dá)式
print('pow:',pow(2,8))#取出指定數(shù)據(jù)的指定次冪
print('round:',round(2.445,2))#保留幾位小數(shù)
print('frozenset:',frozenset([1,23,4,3,5,7,1]))#凍結(jié)集合，使集合不能更改

輸出結(jié)果：

all: False
any: True
bin: 0b1000
hex: 0x8
oct: 0o10
callable: True
chr: M
ord: 109
dir: ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
ecal: {'name': 'haha'}
pow: 256
round: 2.44
frozenset: frozenset({1, 3, 4, 5, 7, 23})

a=bytearray('456778',encoding='utf-8')
print(a)
print(a[0])
a[0]=99
print(a)#修改字符串
#輸出：
# bytearray(b'456778')
# 52
# bytearray(b'c56778')

res=filter(lambda n:n>5,range(10))#
for i in res:
    print(i)
#輸出：
# 6
# 7
# 8
# 9

res2 = map(lambda n: n > 5, range(10))#
for i in res2:
    print(i)
#輸出：
# False
# False
# False
# False
# False
# False
# True
# True
# True
# True

from functools import reduce
res3=reduce(lambda x,y:x+y,range(100))
print(res3)
#輸出：
# 4950

a={3:4,-6:3,2:7}
print(sorted(a.items()))#使字典變?yōu)榱斜戆磌ey值排序
print(sorted(a.items(),key=lambda x:x[1]))#使字典變?yōu)榱斜戆磛alue值排序
#輸出：
# [(-6, 3), (2, 7), (3, 4)]
# # [(-6, 3), (3, 4), (2, 7)]

a=[1,2,3,4,5,6]
b=['a','b','c','d']
for i in zip(a,b):
    print(i)
#輸出：
# (1, 'a')
# (2, 'b')
# (3, 'c')
# (4, 'd')

序列化和反序列化（json、pickle）

用于序列化的兩個模塊

• json，用于字符串 和 python數(shù)據(jù)類型間進(jìn)行轉(zhuǎn)換
• pickle，用于python特有的類型 和 python的數(shù)據(jù)類型間進(jìn)行轉(zhuǎn)換
• Json模塊提供了四個功能：dumps、dump、loads、load
• pickle模塊提供了四個功能：dumps、dump、loads、load

import json
data={'a':1,'b':2}
j_str=json.dumps(data)
print(j_str)
j_json=json.loads(j_str)
print(j_json['a'])

with open('./test.txt','w') as f:
    json.dump(data,f)
with open('./test.txt','r') as f1:
    data_j=json.load(f1)
print(data_j['b'])
#輸出結(jié)果：
{"a": 1, "b": 2}
1
2

import pickle
data={'a':1,'b':2}
p_str=pickle.dumps(data)
print(p_str)
p_json=pickle.loads(p_str)
print(p_json['a'])

with open('./test.txt','wb') as f:#以二進(jìn)制形式存入文件
    pickle.dump(data,f)
with open('./test.txt','rb') as f1:
    data_j=pickle.load(f1)
print(data_j['b'])
#輸出結(jié)果：
b'\x80\x03}q\x00(X\x01\x00\x00\x00aq\x01K\x01X\x01\x00\x00\x00bq\x02K\x02u.'
1
2