1. 程式人生 > >小甲魚python視訊的筆記【斜槓派】

小甲魚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))
檢查字串是否以 obj 結束,如果beg 或者 end 指定則檢查指定的範圍內是否以 obj 結束,如果是,返回 True,否則返回 False.

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:

get()

in 操作符

pop()

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中有可能出現的異常型別以進行鍼對性的處理。