小甲魚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則返回b
assert關鍵字的使用格式是:
assert 表示式 #如果表示式返回True,則繼續往下執行;
#若表示式返回False,則程式自動崩潰,丟擲AssertionError的異常
用於要確保程式中某個位置的條件為真才能讓程式繼續工作。009 了不起的分支和迴圈3
while 條件:
迴圈體
for 目標 in 表示式:
迴圈體
fav = 'fishC'
for i in fav:
print( i , end=' ')
每次迴圈都列印一個fav字串裡的一個字元member = ['小甲魚','小布丁','黑夜','迷途','怡靜']
for each in menber
print(each,len(each))
每次迴圈都列印一個member中的元素,並輸出每個元素的長度(字元個數)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就變成了5000000000
016 序列!序列!
列表、元組和字串的共同點:
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 result
018 函式:靈活即強大
__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了,因此這裡返回25
021 函式:lambda表示式
#1
def ds(x):
return 2 * x + 1
#2
ds = lambda x : 2 * x + 1
#1和#2等價
可以將lambda表示式返回的物件賦給其它物件,其他物件就可以按照函式的用法使用
#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)
#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])
這個frozenset就不允許之後對這個集合進行修改。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中有可能出現的異常型別以進行鍼對性的處理。