小甲魚python視訊的筆記【斜槓派】
我就不設定導航了，要是直接看某一節的筆記，按ctrl+F，搜號碼吧。
這個是斜槓達人的微信公眾號：
斜槓達人→→→
001 我和Python的第一次接觸
使用的Python版本：3.3.2
IDLE是一個Python shell
print("I love fishc.com") #列印雙引號裡的字串
print（5+3） #列印括號中四則運算的結果
print("well water"+"river") #把前後兩個字串連起來，中間不自動新增任何字元
print("I love fishc.com"+8) #報錯，不相關的資料型別無法進行合併
002 用Python設計第一個遊戲
Python是使用縮排來控制條件分支的作用域
temp = input("xxx") #向螢幕輸出引號中的字串，提示使用者輸入操作，將輸入的東西存到temp裡
guess = int(temp) #將temp轉化為整形變數賦值給guess
if guess == 8 : #判斷使用者輸入的值是否為8，這裡有個冒號
print("xxx")
else: #注意這裡也有個冒號
print("xxx")
print("xxx")Python提供了很多BIF(built in functions)
dir(__builtins__) #輸出所有BIF
help(函式名) #返回函式功能說明
003 小插曲之變數和字串
myteather = '小甲魚'
yourteather = '老甲魚'
print(myteather +yourteather ) #輸出為兩個字串拼接到一起Python對大小寫敏感，fish_c和fish_C是不一樣的
在字串裡面打'或"，需要使用轉義字元，或使用原生字串，即字串前面新增r關鍵字標識
列印多行的長字串，需要使用"""xxx"""，要保證成對使用
004 小插曲之變數和字串
> >= < <= == !=
六個比較操作符，返回的結果是True或False
if 條件:
條件為真（True）執行的操作
else:
條件為假（False）執行的操作while 條件:
條件為真（True）執行的操作and運算子的使用，功能是執行邏輯與運算
內建模組random，包含的格式是
import random #包含random模組
value = random.randint(1,10) #使用random內的函式randint()生成一個隨機的int型常量005 閒聊之Python的資料型別
一些數值型別：整型、布林型別、浮點型、科學技術法
型別轉換：int( )、str( )、float( )
函式的引數要適當，不是任意轉。
type( x )函式返回變數x的型別、isinstance( x,y )函式返回變數x是否為y型別
006 算術操作符
+ - * / % ** //
加、減、乘、除（精確除）、取餘、冪次、除（取整除，捨棄小數部分）
and or not
邏輯與、邏輯或、取反
運算子優先順序：
** #冪運算
+ - #一元=和一元-
* / // + - #算術運算子
< <= > >= == != #比較運算子
not and or #邏輯運算子007 了不起的分支和迴圈1
載入背景音樂
播放背景音樂（單曲迴圈）
我方飛機誕生
interval = 0
while True:
if 使用者點選了關閉按鈕:
結束
interval +=1
if interval == 50:
interval = 0
小飛機誕生
else:
小飛機移動一個位置
螢幕重新整理
if 滑鼠移動了位置:
我方飛機中心位置 = 滑鼠位置
螢幕重新整理
if 我方飛機與小飛機相撞:
我方飛機掛，播放撞機音樂
修改我方飛機圖案
列印“Game Over”
停止背景音樂，淡出
跳出迴圈008 了不起的分支和迴圈2
遇到需要分類的條件判斷使用if...elif結構
if 條件:
執行的程式碼
elif 條件：
執行的程式碼
else：
執行的程式碼Python通過縮排來匹配if和else，四個空格
三元操作符：
value = a if x<y else b #看x<y的結果，如果為True則返回a；如果為False則返回bassert關鍵字的使用格式是：
assert 表示式 #如果表示式返回True，則繼續往下執行；
#若表示式返回False，則程式自動崩潰，丟擲AssertionError的異常009 了不起的分支和迴圈3
while 條件:
迴圈體
for 目標 in 表示式:
迴圈體fav = 'fishC'
for i in fav:
print( i , end=' ')member = ['小甲魚','小布丁','黑夜','迷途','怡靜']
for each in menber
print(each,len(each))range( )函式功能是生成數列，用法是：range( a,b,x )
其中a是數列的起始值，b是數列包含數字的個數，x是步長。
a和x可以省略，a的預設值是0，x的預設值是1
break關鍵字：終止迴圈，向下執行迴圈塊後面的程式碼。【作用範圍：一層迴圈】
continue關鍵字：跳過迴圈塊中的剩餘程式碼，立即執行下一輪迴圈。【作用範圍：一層迴圈】
010 一個打了激素的陣列1
列表：
menber = ["小甲魚"，“小布丁”,"迷途","怡靜"]
number = [ 1, 2, 3, 4, 5]
mix = [ 1, "小甲魚", 3.14, [1, 2, 3]]
empty = []menber = ["小甲魚"，“小布丁”,"迷途","怡靜"]
member.append("福祿娃娃")
#將“福祿娃娃”新增到member末尾
menber = ["小甲魚"，“小布丁”,"迷途","怡靜","福祿娃娃"]還有一種新增方式，extend()
menber = ["小甲魚"，“小布丁”,"迷途","怡靜"]
member.extend(["竹林小溪","Crazy迷戀"])
#在列表末尾一次性追加另一個序列中的多個值insert()函式，可以指定插入的位置
menber = ["小甲魚"，“小布丁”,"迷途","怡靜"]
member.insert(x, "y")
#將“y”插入到列表menber的x的位置，原列表x的位置的元素依次向後移位011 一個打了激素的陣列2
menber = ["小甲魚"，“小布丁”,"迷途","怡靜"]
member.remove("小甲魚")
#從member列表裡刪掉“小甲魚”這個元素，刪完後面的元素向前移動
#如果member.remove("大笨豬")，就會報錯，因為目標列表裡沒有這個元素
menber = ["小甲魚"，“小布丁”,"迷途","怡靜"]
del member(1)
#刪掉“小布丁”這個元素，後面元素一次向前補上
del member
#del後加列表名，就會刪掉整個列表
menber = ["小甲魚"，“小布丁”,"迷途","怡靜"]
member.pop()
#刪除列表中最後一個元素，並返回該元素
member.pop(1)
#跟上面del一樣，指定pop出哪個位置的元素，並返回該元素
切片：
menber = ["小甲魚"，“小布丁”,"迷途","怡靜"]
member[1:3]
#會返回從1到3位置的元素，不包括3
member[:3]
#第一個數的預設值為0，不寫就表示從0開始
member[1:]
#第二個數的預設值為列表的最後，不寫就表示一直到列表的最後一個元素
member[:]
#兩個數都不寫，得到的就是列表的拷貝【資料的拷貝，非地址的拷貝】012 一個打了激素的陣列3
list1 = [123,456]
list2 = [234,123]
print(list1 > list2)
#返回falsa，比較的是第0位。比較是從第0為開始，若相等則依次往後比較
list4 = list1 + list2
#list4返回[123，456，234，123]，就是list2接到list1後面，拼起來
list2 * 3
#執行結果就是list2為[234,123,234,123,234,123]
#就是list2被複制三次，和list2 *=3是一樣的效果
list2 = [234,123]
123 in list2 #返回True
123 not in list2 #返回False
'小甲魚' not in list2 #返回True
list5 = [123,['小甲魚','牡丹'],456]
'小甲魚' in list5 #返回False 【只能查詢一層】
'小甲魚' in list5[1] #返回rue 【指定到這一層就能查到了】
#要列印'小甲魚'，就要使用類似二維陣列的寫法，list5[1][1]就是'小甲魚'了
#1列表的新增：
#append()是新增單個元素、
#extend()是新增列表、
#insert()是想指定位置插入
#2列表的修改：
#列表名 * N ：用列表名乘以N，則把當前列表複製N次，覆蓋原列表
#sort()，對目標列表排序，預設從小到大排序，通過修改輸入引數，可調整功能。
#比如，sort(reverse = True)，則從大到小排序。引數還可指定使用哪個排序演算法。
#sort()預設使用堆排序
#reverse()反轉列表
#3列表的刪除：remove()、del()、pop()
#remove()輸入引數是具體元素、del()輸入引數是位置、
# pop()預設刪最後意思元素，若指定山某個元素，同del()
#4列表的查詢：count()、index()
#count()是統計輸入引數在目標列表中出現的次數
#index()是查詢輸入引數第一次出現在目標列表中的位置
#indec()還可在某個位置區間搜尋，member.index('小甲魚'，3，7)
#則從下標位置3到7這些元素中搜索，返回第一次出現'小甲魚'的下標，不包括7的位置。013 元組：戴上了枷鎖的列表
元組和列表的區別：
1. 建立和訪問
建立使用的是( )，訪問和使用元組還是使用[ ]
元組被規定不可以被修改，比如：（但後面會講修改的辦法）
tuple1 = (1,2,3,4,5,6,7,8)
tuple1[1] = 0 #這樣會報錯，元組是不可以被修改的temp = (1) #以為建立了一個元素的元組
type(temp) #這句返回的是'int'，實際上建立的是int型變數
temp2 = 2,3,4
type(temp2) #這句返回的是'tuple'，及時不加括號，只要有逗號也是元組
temp = []
type(temp) #這裡建立的就是'list'
temp = ()
type(temp) #這裡建立的是'tuple'
temp = (1,)
type(temp) #這樣建立的就是'tuple'，因為有逗號了
temp = 1,
type(temp) #和上面帶括號的一樣，這裡也是'tuple'
8 * (8) #這個結果是一個數值
8 * (8,) #這樣返回的結果就是(8,8,8,8,8,8,8,8)，因為這個時候，*就是複製功能了2. 更新和刪除
temp = ('小甲魚','黑夜','迷途','小布丁')
temp = temp[:2] + ('怡靜') + temp[2:]
#通過使用切片的方法，來造一個新元組，再覆蓋掉原來的temp
#新的temp就是('小甲魚','黑夜','怡靜','迷途','小布丁')
del temp #刪除temp元組3. 元組相關的操作符
跟列表類似，只要不涉及到直接修改元組的，都可以用。
014 字串：各種奇葩的內建方法
str1 = 'I love fishc.com'
str1[:6] #（切片）返回：'I love'
str1[5] #返回'e'
#字串和元組一樣，不能修改，所以要向字串中插入字串就還是要用切片的方法
str1[:6] + '要插入的字串' + str1[6:]
#返回：'I love要插入的字串 fishc.com'| 2 |
返回一個指定的寬度 width 居中的字串，fillchar 為填充的字元，預設為空格。 |
| 3 |
返回 str 在 string 裡面出現的次數，如果 beg 或者 end 指定則返回指定範圍內 str 出現的次數 |
| 4 |
Python3 中沒有 decode 方法，但我們可以使用 bytes 物件的 decode() 方法來解碼給定的 bytes 物件，這個 bytes 物件可以由 str.encode() 來編碼返回。 |
| 5 |
以 encoding 指定的編碼格式編碼字串，如果出錯預設報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace' |
| 6 |
endswith(suffix, beg=0, end=len(string)) |
| 7 |
把字串 string 中的 tab 符號轉為空格，tab 符號預設的空格數是 8 。 |
| 8 |
檢測 str 是否包含在字串中，如果指定範圍 beg 和 end ，則檢查是否包含在指定範圍內，如果包含返回開始的索引值，否則返回-1 |
| 10 |
如果字串至少有一個字元並且所有字元都是字母或數字則返 回 True,否則返回 False |
| 11 |
如果字串至少有一個字元並且所有字元都是字母則返回 True, 否則返回 False |
| 12 |
如果字串只包含數字則返回 True 否則返回 False.. |
| 13 |
如果字串中包含至少一個區分大小寫的字元，並且所有這些(區分大小寫的)字元都是小寫，則返回 True，否則返回 False |
| 14 |
如果字串中只包含數字字元，則返回 True，否則返回 False |
| 15 |
如果字串中只包含空白，則返回 True，否則返回 False. |
| 16 |
如果字串是標題化的(見 title())則返回 True，否則返回 False |
| 17 |
如果字串中包含至少一個區分大小寫的字元，並且所有這些(區分大小寫的)字元都是大寫，則返回 True，否則返回 False |
| 18 |
以指定字串作為分隔符，將 seq 中所有的元素(的字串表示)合併為一個新的字串 |
| 20 |
返回一個原字串左對齊,並使用 fillchar 填充至長度 width 的新字串，fillchar 預設為空格。 |
| 21 |
轉換字串中所有大寫字元為小寫. |
| 22 |
截掉字串左邊的空格或指定字元。 |
| 23 |
建立字元對映的轉換表，對於接受兩個引數的最簡單的呼叫方式，第一個引數是字串，表示需要轉換的字元，第二個引數也是字串表示轉換的目標。 |
| 24 |
返回字串 str 中最大的字母。 |
| 25 |
返回字串 str 中最小的字母。 |
| 26 |
把 將字串中的 str1 替換成 str2,如果 max 指定，則替換不超過 max 次。 |
| 29 |
返回一個原字串右對齊,並使用fillchar(預設空格）填充至長度 width 的新字串 |
| 30 |
刪除字串字串末尾的空格. |
| 31 |
num=string.count(str)) 以 str 為分隔符擷取字串，如果 num 有指定值，則僅擷取 num 個子字串 |
| 32 |
按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果引數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。 |
| 33 |
檢查字串是否是以 obj 開頭，是則返回 True，否則返回 False。如果beg 和 end 指定值，則在指定範圍內檢查。 |
| 34 |
在字串上執行 lstrip()和 rstrip() |
| 35 |
將字串中大寫轉換為小寫，小寫轉換為大寫 |
| 36 |
返回"標題化"的字串,就是說所有單詞都是以大寫開始，其餘字母均為小寫(見 istitle()) |
| 37 |
根據 str 給出的表(包含 256 個字元)轉換 string 的字元, 要過濾掉的字元放到 deletechars 引數中 |
| 38 |
轉換字串中的小寫字母為大寫 |
| 39 |
返回長度為 width 的字串，原字串右對齊，前面填充0 |
| 40 |
檢查字串是否只包含十進位制字元，如果是返回 true，否則返回 false。 |
015 字串：格式化
replacement欄位：
#位置引數
"{0} love {1}.{2}".format("I","FishC","com")
#這句返回'I love FishC.com'
#關鍵字引數
"{a} love {b}.{c}".format(a="I",b="FishC",c="com")
#關鍵字引數需要指定一下，這句返回'I love FishC.com'
#位置&關鍵字引數混合使用
"{0} love {b}.{c}".format("I",b="FishC",c="com")
#要保證位置引數在關鍵字引數前
#如果下面這樣，就報錯了
"{a} love {b}.{0}".format(a="I",b="FishC","com")
#這樣就報錯了，提示"com"需要指定關鍵字
"{{0}}".format("不列印")
#前面已經不算位置引數了，所以返回：'{0}'
#如果把{0}當作關鍵字引數，在後面寫上{0}=‘不列印’，會報錯
'{0:.1f}{1}'.format(27.658,'GB')
#第一個位置引數後面多了:.1f，這個冒號表示後面是格式化符號的開始
#這個.1f是列印四捨五入到小數點後一位轉義字元的使用：【類似C語言的printf()】
'%c' % 97 #返回的就是97對應的字元'a'
'%c' '%c' '%c' % (97, 98, 99) #返回'a b c'
'%d + %d = %d' % (4, 5, 4+5) #返回'4 + 5 = 9'
'%5.1f' % 27.658 #返回' 27.1'，5指示返回的字串最少佔5個位置，1表示精確到小數點後一位
'%.2e' % 27.658 #返回'2.77e+01'，2指示返回的字串精確到小數點後兩位，e指示用e的表示法
'%3d' % 5 #返回：' 5'，3表示返回的字串至少佔3位
'%-3d' % 5 #返回：'5 '，加負號表示左對齊
'%#o' % 100 #返回100的八進位制數
'%#x' % 100 #返回100的十六進位制數
'%#d' % 100 #返回100的十進位制數
'%010d' % 5 #返回的還是最少佔10位，但改成了用0填充
'%-010d' % 5 #返回的還是用空格佔位，因為如果用0佔位，內容本身就變了，5就變成了5000000000016 序列！序列！
列表、元組和字串的共同點：
1. 都可以通過索引得到每一個元素
2. 預設索引值從0開始
3. 可是使用切片
4. 都可以使用：重複操作符、拼接操作符、成員關係操作符（in、not in）
list()把一個可迭代物件轉換為列表
有兩個引數組合：
1. 無引數，返回空列表。
2. 引數為迭代器，從一個可迭代物件初始化一個新列表
b = 'I love FishC.com'
b = list(b)
#b現在就變成了['I',' ','l','o','v','e','F','i','s','h','C','.','c','o','m']
c = (1, 1, 2, 3, 5, 8, 13, 21, 34)
c = list(c)
#b現在變成了[1, 1, 2, 3, 5, 8, 13, 21, 34]
tuple() #是把物件轉換成元組，用法和list()類似
str() #是把物件轉換成字串，用法和list()類似
len() #是返回物件的元素個數
max() #返回物件的最大值，按ASCⅡ來排列
min() #返回物件的最小值，一樣是按ASCⅡ來排列
#如果輸入為字串，因為字串也是可迭代物件，所以返回字串中ASCⅡ值最小的那個字元
sum() #返回物件的相加總和
sum(list,8) #返回值是，把list的加和計算完再加上8
sorted() #把物件從小到大排序
reversed() #返回的是一個迭代器
#要返回翻轉的值，需要使用其它的序列函式再轉一下，比如：
list(reversed(c))
enumerate() #生成由每個元素的index值和item值組成的元組
#用法類似reversed()
numbers = [1, 18, 76]
list(enumerate(numbers))
#返回：[(0,1),(1,18),(2,76)]
zip() #返回由各個引數的序列組成的元組
a = [7, 6, 5, 4]
b = [2, 3, 4]
list(zip(a,b))
#返回：[(7,2),(6,3),(5,4)]017 函式：python的樂高積木
# 函式的格式：
def function(para_1,para_2):
result = para_1 + para_2
return result018 函式：靈活即強大
__doc__屬性
def fnc():
'''函式語句中，如果第一個表示式是一個string，這個函式的__doc__就是這個string，否則__doc__是None'''
print(fnc.__doc__)def saysome(name,words):
print(name + '->' +words)
saysome('小甲魚','xxx')
saysome('xxx','小甲魚')
saysome(words='xxx',name='小甲魚')
#通過關鍵字索引，使函式接收引數不受位置影響預設引數：
def saysome(name='小甲魚',words='xxx'):
print(name + '->' +words)
#函式可以設定引數的預設值，但帶預設值的引數只能放在沒有預設值引數的後面def test(*para):
print('引數長度：',len(para))
print('第一個引數：',para[0])
#不確定引數數量時使用可變引數這個語法
test(4,5,6,22,51,7)
def func_1(*para,env=250):
print('引數長度：',len(para))
print('第一個引數：',para[0])
func_1(4,5,6,22,51,7,env=100)
#可變引數後面的值需要使用關鍵字索引，否則就被當作可變引數
#通常會把可變引數後面的引數設定預設值，防止沒用關鍵字索引時函式報錯019 函式：我的地盤聽我的
def hello():
print('hello')
print(type(hello())) #函式沒有返回值時，返回值型別就是'NoneType'
def back():
return 1,'小甲魚',3.14
back() #呼叫該函式，返回的是元組(1,'小甲魚',3.14)，因為帶逗號的表示式預設是元組def discounts(price,rate):
final_price = price * rate
old_price = 50 #此處是區域性的old_price，在該函式的作用域下，使用區域性的old_price
print('修改後的old_price值：',old_price)
return final_price
old_price = float(input('請輸入原價：')) #輸入100
rate = float(input('請輸入折扣：')) #輸入0.6
new_price = discounts(old_price,rate) #函式返回計算後的值：60
print('修改後的old_price的值是：',old_price) #列印的是全域性的old_price
print('打折後的價格是',new_price) #列印經函式計算的結果：new_price這時區域性的這個變數和全域性的那個變數，名字雖然相同，
但不是同一個變數，類似C++中的程式碼塊內的變數，當出現與全域性變數一樣名的變數時，
在當前區域性程式碼塊兒中，全域性變數失效，使用的是區域性變數。
如果想在區域性改全域性的變數，用global修飾變數，就ok啦。
020 內嵌函式和閉包
內嵌函式：
def fun1():
print('fun1()正在被呼叫...')
def fun2():
print('fun2()正在被呼叫...')
fun2()
fun1()
#執行結果是：
#fun1()正在被呼叫...
#fun2()正在被呼叫...閉包：
def FunX(x):
def FunY(y):
return x*y
return FunY
i = FunX(8) #返回的是函式
type(i) #返回結果為'function'
i(5) #返回40
FunX(8)(5) #返回40
FunY(5) #這行會報錯，不能直接使用FunY()
def Fun1():
x = 5
def Fun2():
x *= x
return x
return Fun2()
Fun1() #這行會報錯，因為在Fun2()中的x屬於區域性變數，
# 並不是Fun1()中的那個x，所以會提示x不能在被分配值前使用
#修改1：
def Fun1():
x = [5]
def Fun2():
x[0] *= x[0]
return x[0]
return Fun2()
Fun1() #這樣就不會報錯了，列表不是存放在棧中
# 因此這裡返回25
#修改1：
def Fun1():
x = 5
def Fun2():
nonlocal x
x *= x
return x
return Fun2()
Fun1() #使用nonlocal關鍵字，表示此處使用的不是區域性的變數
# 這樣就能在此處使用Fun1()裡的x了，因此這裡返回25021 函式：lambda表示式
#1
def ds(x):
return 2 * x + 1
#2
ds = lambda x : 2 * x + 1
#1和#2等價#1
def add(x,y):
return x+y
#2
add = lambda x,y: x+y
add(3,4) #返回7結合filter()和map()使用
filter(lambda x:x%2 ,range(10)) #篩選出0~9中的奇數
#range(10)裡的值代入到第一個引數中，第一個引數返回為真的留下
map(lambda x:x*2 ,range(10)) #所有數都乘以2
#range(10)裡的值代入到第一個引數中，按第一個引數的計算方式計算022 函式：遞迴是神馬
非遞迴求階乘：
def factorial(n):
result = n
for i in range(1,n):
result *=i
return result遞迴求階乘：
def factorial(n):
if n==1:
return 1
else:
return n*factorial(n-1)#2 有終止條件
023 遞迴：這幫小兔崽子
實現斐波那契數列：
#迭代：
def fab(n):
n1 = 1
n2 = 1
n3 = 1
if n<1:
print('輸入有誤！')
return -1
while (n-2)>0:
n3 = n2+n1
n1 = n2
n2 = n3
n -= 1
return n3實現2：
def fibonacci_iteration(n):
a = 0
b = 1
list = []
for i in range(n):
next_value = a+b
a,b = b,next_value
list.append(a)
return list#遞迴：
def fab(n):
if n<1:
print('輸入有誤！')
return -1
if n==1 or n==2:
return 1
else:
return fab(n-1)+fab(n-2)024 遞迴：漢諾塔
將64個盤子從x上移動到z上，中間藉助y
拆分過程：
1. 將前63個盤子從x上移動到y上（多步驟操作）
2. 將x上的第64個盤子從x移動到z上（單步操作）
3. 將y上的63個盤子移動到z上（多步驟操作）
將兩個多步驟操作繼續分：
1. 可以描述成新問題，將63個盤子從x上移動到y上，中間藉助z
3. 可以描述成新問題，將63個盤子從y上移動到z上，中間藉助x
程式碼如下：
def hanoi(n,x,y,z):
if n==1:
print(x,'-->',z)
else:
hanoi(n-1,x,z,y) #將前n-1個盤子從x移動到y上
print(x,'-->',z) #將最底下的最後一個盤子從x移動到z上
hanoi(n-1,y,x,z) #將y上的n-1個盤子移動到z上025 字典：當索引不好用時1
dict1 = {'李寧':'一切皆有可能','耐克':'Just do it','阿迪達斯':'Impossible is nothing','魚C工作室':'讓程式設計改變世界'}
print('魚C工作室的口號是：',dict1['魚C工作室'])
#返回的是'魚C工作室'冒號後面對應的鍵值：'讓程式設計改變世界'
dict3 = dict((('F',70),('h',104),('C',67)))
#dict3變成了字典{'F':70,'C':67,'h':104}
dict4 = dict(小甲魚='讓程式設計改變世界',蒼井空='讓AV征服所有宅男')
#dict4變成了字典{'蒼井空':'讓AV征服所有宅男','小甲魚':'讓程式設計改變世界'}
dict4['蒼井空'] = '替換內容'
dict4['愛迪生'] = '測試新增項'
#原字典裡有的鍵，會修改對應的鍵值；若沒有的，則新增鍵和鍵值。1、用{}建立字典
2、用內建函式dict()
1)、入參為類似a="1"的鍵值對
2)、入參為一個元組，元組內部是一系列包含兩個值的元組，例如(("a", "1"), ("b", "2"))
3)、入參為一個元組，元組內部是一系列包含兩個值的列表，例如(["a", "1"], ["b", "2"])
4)、入參為一個列表，列表內部是一系列包含兩個值的元組，例如[("a", "1"),("b", "2")]
5)、入參為一個列表，列表內部是一系列包含兩個值的列表，例如[["a", "1"],["b", "2"]]
3、使用者fromkeys方法建立字典，第一個
026 字典：當索引不好用時2
字典的BIF：
027 集合：在我的世界裡，你就是唯一
集合（set）是一個無序不重複元素的序列。
基本功能是進行成員關係測試和刪除重複元素。
可以使用大括號 { } 或者 set() 函式建立集合，注意：建立一個空集合必須用 set() 而不是 { }，因為 { } 是用來建立一個空字典。
num ={}
type(num) #返回'dict'
num2 = {1,2,3,4,5}
type(num2) #返回'set'建立集合的兩種方法：
一種是上面的num2，直接用花括號括起來的方法；另一種是使用set()工廠函式建立集合
num = set([1,2,3,4,56,56])
print(num) #返回{1, 2, 3, 4, 56}set可以進行集合元算：交、並、差、補
集合可以使用in 操作符，常用的BIF有add()和remove()，用於新增和刪除元素。
不可變的集合：
num = frozenset([1,2,3,4,56,56])028 檔案：因為懂你，所以永恆
open()函式：讀寫檔案，返回一個file物件，這個file物件可直接作為序列進行迭代。
open(filename, mode)
- filename：filename 變數是一個包含了你要訪問的檔名稱的字串值。
- mode：mode決定了開啟檔案的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個引數是非強制的，預設檔案訪問模式為只讀(r)。
常用的有read()、close()、readline()、readlines()、wrtite()、tell()、seek()等。
029 檔案：一個任務
把open()返回的物件直接當序列用時，每次迭代返回一行的內容。
030 檔案系統：介紹一個高大上的東西
OS模組：
常用的函式有：getcwd()、chdir()、listdir()、mkdir()、rmdir()、remove()、system()、curdir()、、、、、、、、、、、、、、、
主要是對檔案路徑的各種拆分操作和對檔案屬性的獲取。
031 永久儲存：醃製一缸美味的泡菜
主要就兩個函式，一個是dump()、一個是load()
我個人的理解是類似C++裡輸入輸出流的操作。
032 異常處理：你不可能總是對的1
033 異常處理：你不可能總是對的2
try:
可能出現異常的程式碼
except 標準異常的巨集 as arr:
出現異常後要執行的程式碼其中，arr用於儲存異常原因的描述。
finally關鍵字
finally存在的意義是如果try沒捕獲到的異常導致程式崩潰，finally後面的語句會在程式掛掉的時候，臨死前呻吟一下。
與其他語言相同，在python中，try/except語句主要是用於處理程式正常執行過程中出現的一些異常情況，如語法錯誤（python作為指令碼語言沒有編譯的環節，在執行過程中對語法進行檢測，出錯後發出異常訊息）、資料除零錯誤、從未定義的變數上取值等；而try/finally語句則主要用於在無論是否發生異常情況，都需要執行一些清理工作的場合，如在通訊過程中，無論通訊是否發生錯誤，都需要在通訊完成或者發生錯誤時關閉網路連線。儘管try/except和try/finally的作用不同，但是在程式設計實踐中通常可以把它們組合在一起使用try/except/else/finally的形式來實現穩定性和靈活性更好的設計。
預設情況下，在程式段的執行過程中，如果沒有提供try/except的處理，指令碼檔案執行過程中所產生的異常訊息會自動傳送給程式呼叫端，如python shell，而python shell對異常訊息的預設處理則是終止程式的執行並列印具體的出錯資訊。這也是在python shell中執行程式錯誤後所出現的出錯列印資訊的由來。
python中try/except/else/finally語句的完整格式如下所示：
try:
Normal execution block
except A:
Exception A handle
except B:
Exception B handle
except:
Other exception handle
else:
if no exception,get here
finally:
print("finally") 說明：
正常執行的程式在try下面的Normal execution block執行塊中執行，在執行過程中如果發生了異常，則中斷當前在Normal execution block中的執行跳轉到對應的異常處理塊中開始執行；
python從第一個except X處開始查詢，如果找到了對應的exception型別則進入其提供的exception handle中進行處理，如果沒有找到則直接進入except塊處進行處理。except塊是可選項，如果沒有提供，該exception將會被提交給python進行預設處理，處理方式則是終止應用程式並列印提示資訊；
如果在Normal execution block執行塊中執行過程中沒有發生任何異常，則在執行完Normal execution block後會進入else執行塊中（如果存在的話）執行。
無論是否發生了異常，只要提供了finally語句，以上try/except/else/finally程式碼塊執行的最後一步總是執行finally所對應的程式碼塊。
需要注意的是：
1.在上面所示的完整語句中try/except/else/finally所出現的順序必須是try-->except X-->except-->else-->finally，即所有的except必須在else和finally之前，else（如果有的話）必須在finally之前，而except X必須在except之前。否則會出現語法錯誤。
2.對於上面所展示的try/except完整格式而言，else和finally都是可選的，而不是必須的，但是如果存在的話else必須在finally之前，finally（如果存在的話）必須在整個語句的最後位置。
3.在上面的完整語句中，else語句的存在必須以except X或者except語句為前提，如果在沒有except語句的try block中使用else語句會引發語法錯誤。也就是說else不能與try/finally配合使用。
4.except的使用要非常小心，慎用。
class AError(Exception):
"""AError---exception"""
print('AError')
try:
#raise AError
asdas('123')
except AError:
print("Get AError")
except:
print("exception")
else:
print("else")
finally:
print("finally")
print("hello wolrd")在上面的程式碼中，Normal execution block中出現了語法錯誤，但是由於使用了except語句，該語法錯誤就被掩蓋掉了。因此在使用try/except是最好還是要非常清楚的知道Normal execution block中有可能出現的異常型別以進行鍼對性的處理。