一、pycharm的使用和python基本語法
（一）、pycharm的使用和python環境
1、python以及pycharm的安裝
- python 的版本選擇：3.x 版本，不要安裝2.x 版本，有很多語法不一樣
- 如何確定自己 python 版本： cmd: python
- 不是內部命令：python沒有正確安裝，原因大概率是因為沒有配置環境變數(配置環境變數後重啟電腦生效)
- 指定 python 的安裝目錄：一般來說是安裝在 d:\python37
- 測試python是否安裝成功
- cmd: python
- cmd: pip ，或者 pip3 , 有任何一個出現命令不存在，
- 額外注意：loadrunner 中也有pip，這個pip配置環境變數了之後，python中的pip也需要配置環境變數
- prcharm 的版本選擇：社群版夠用
- pycharm 只是一個工具，python 才是關鍵
2、pycharm 新建專案
- 新建專案
- file ---> New Project
- 退出專案
- file ---> Close Project
- 切換專案
- file ---> Open
- file ---> Open Recent
3、檔案、目錄、包的建立和管理
- Project ---> 右鍵 ，可以新建檔案、目錄和包
4、pycharm 的基礎使用
- python 程式碼是儲存到以 .py 結尾的檔案當中
- .py 檔案又是放到各個資料夾（目錄）下面的
5、如何執行程式碼：
- 右鍵，點選 run
- 命令列執行：點選底下的 Terminal
- 進入專案路徑
- python 拼接好的路徑/python檔案.py
6、安裝第三方庫
-
第三方庫：是別人已經寫好的 python 程式碼
-
第一種方法：
- 安裝：pip install 庫名
- 解除安裝：pip uninstall 庫名
-
第二種方法：pycharm ：不要勾選 user's site package
-
第三種方法：庫放在國外的伺服器上，需要用到國內安裝源，python國內源
- pip install 庫名 -i 源地址
- pip install openpyxl -i https://pypi.tuna.tsinghua.edu.cn/simple
python國內源：
清華：https://pypi.tuna.tsinghua.edu.cn/simple
阿里雲：http://mirrors.aliyun.com/pypi/simple/
中國科技大學 https://pypi.mirrors.ustc.edu.cn/simple/
華中理工大學：http://pypi.hustunique.com/
山東理工大學：http://pypi.sdutlinux.org/
豆瓣：http://pypi.douban.com/simple/
（二）、python基本語法
1、基本語法
-
print 輸出
- 表示在螢幕上列印出（顯示出）
- 使用的任何的程式碼，雙引號是半形，英文
- print 預設輸出是換行的，不同的資料之間用逗號隔開
-
python註釋: 表示在 python 當中不會執行的文字（不會當成程式碼）, 是說明下面的程式碼是什麼？
- # 表示單行註釋 , Ctrl + /
- """ """ 表示多行註釋
- ''' ''' 表示多行註釋
-
縮排：
- 現在這個階段，所有的程式碼全部頂格寫，不要進行縮排。
-
數值
- 和數學中的數值表示是一樣的（注意點：數值不用加引號）
-
字串
- python 使用引號來表示字串（一串文字）
-
變數
- 什麼是變數：是用來儲存資料
- a = 100
- b = 200
- c = “ hello world”
- 變數名的命名規範：
- 只能包含數字、字母、下劃線，
- 不能以數字開頭，
- 不能有關鍵字( 注意點 )
- python 中所有的關鍵字: keyword.kwlist
- 儘量做到見名知意
- 儘量不要用拼音
- 什麼是變數：是用來儲存資料
-
識別符號：（凡是我們自己取的名字，都是識別符號。）
- 規範：識別符號由字母、數字、下劃線組成，不能使用關鍵字
- 識別符號包括：變數名、函式名、類名、模組名、專案名
- 在python中，所有識別符號可以包括英文，數字以及下劃線（_），但不能以數字開頭。
- python 中的識別符號是區分大小寫的，大寫的 A 和小寫的 a 不一樣
-
識別符號的命名風格：
- 下劃線命名法：
- 規範：單詞字母小寫，單詞之間使用下劃線連線
- 如：max_number ，test_data
- 大駝峰命名法：
- 規範：每個單詞的第一個字母大寫
- 如：MaxNumber , TestData
- 小駝峰命名法：
- 規範：第一個單詞以小寫字母開始，第二個單詞的首字母大寫
- 如：maxNumber , testData
- 下劃線命名法：
-
input 使用者輸入
- 從控制檯裡面獲取一個資料，獲取到的型別是字串型別
二、python中常見資料型別
（一）、數值型別 & 運算子
1、數值型別資料
- 數值型別
- 整數（int）：整數
- 浮點數（float）：小數
- 布林值（bool）：只有兩個值 True 和 False
2、python 常見運算子
-
算術運算子：
- +
- -
- *
- /
- 除法運算一定要注意：除數不能為0
- 除數如果為0，就會報錯：ZeroDivisionError: division by zero
- //
- 整除
- %
- 餘數：模運算
# + print(5 + 6) # - print(7 - 8) # * print(2 * 3) # / # 只要是進行除法運算，得到的是一個 float print(4 / 3) print(4 / 2) # 除法運算一定要注意，除數不能為 0 # 除數如果為0，就會報錯：ZeroDivisionError: division by zero # 程式報錯以後，就無法繼續執行 # print(2/0) # print('hello world') # // 得到的是一個整數。 整除 print(4 // 3) # % 取餘數 : 模運算 print(4 % 3) # ** 冪運算 4的3次方 print(4 ** 3) -
賦值運算子
- =
- +=
- -=
- *=
- /=
- //=
- %=
- **=
name = 'yuze' age = 18 #漲一歲 age = age + 1 print(age) #縮寫 age += 1 ==> age = age + 1 age += 2 print(age) age /= 3 print(age)
-
比較運算子: 比較運算得到的結果是一個 bool 值， True 或 False
- <
- >
- <=
- >=
- !=
> 大於 print(5 > 4) # True < 小於 print(6 < 3) # False >= 大於等於 print(6 >= 3) # True <= 小於等於 print(6 <= 3) # False != 不等於 print(6 != 3) # True TODO: == 才是比較運算， 一個 = 是賦值運算 print(6 == 6)
-
邏輯運算 : 可以使用()提高優先順序
- and
- or
- not
a = 3 > 4 print(a) b = 4 != 5 print(b) # 運算 and # 每一個都為 True print(a and b) # False # 運算 or # 只要有一個為 True print(a or b) # True # 練習 a = True b = 5 == 4 # False c = 5 != 3 # True print(a and b or c) # True print(a or b and c) # True # python 的運算有沒有優先順序，如何設定優先順序 # 使用 () 設定優先順序 print(((a and b) or c) and b) # not 取反 print(not(b)) # True -
身份運算
- is
- is not
-
成員運算
- in
- not in
# in name = 'yuz' print('u' in name) # True print('uz' in name) # True print('uai' in name) # False # TODO: in 一定是連著的， yz 是一個整體 print('yz' in name) # False print('Y' in name) # False
3、隨機數模組： random （python 官方庫）
-
隨機生成 0-1 之間的浮點數：random.random()
-
隨機生成 0-100 之間的浮點數：random.randint(1, 100)
import random f_num = random.random() print(f_num) num = random.randint(0, 100) print(num)
（二）、字串
本節問題：
問題一：python中如何表示字母，比如要將一個人的名字儲存下來？
問題二：字串如何定義?
問題三：字串如果要換行怎麼辦？
問題四：數值型別的資料可以轉換成字串嗎？
問題五：可以把兩個字串組成一個嗎？
問題六；如何獲取字串中某個具體的字元？
1、字串的定義：
-
單引號、雙引號：定義單行字串
-
三引號、三雙引號： 多行字串定義
-
空字串： s=''
-
str():
-
注意點：字串中有單引號時，外面用雙引號注意區分
"""字串的定義 如何表示字串： - 引號表示字串 - 單引號 '' - 雙引號 "" - 三引號 ''' ''' - 三雙引號 """ """ """ name1 = "yuze" print(name1) name2 = 'yuze' print(name2) name3 = '''yuze''' print(name3) name4 = """yuze""" print(name4) print(name1 == name2 == name3 == name4) # True print(name1 == name2) # True print(name1 == name3) # True print(name1 == name4) # True
2、字串的切片和下標取值
-
1、下標索引取值
- 下標取值：可以正向取，也可以反向取
- 注意點：正向從 0 開始，反向從 -1 開始
name = 'yuzwang' print(name[1]) # u print(name[0]) # y # 獲取第3個字元 print(name[2]) # z # 獲取 g print(name[6]) print(name[-1])
-
2、切片： [:][::]
- 問題：下標取值只能獲取單個元素，現有字串 str1='hello python' ，如果要獲取出來 python 應該怎麼做？
- 切片的語法： 和下標取值一樣使用中括號進行切片，有兩種用法：
- [a:b] :a代表起始位置下標， b 代表終止位置下標（左閉右開）；
- [a: b: c] : a代表起始位置下標， b 代表終止位置下標（左閉右開），c 代表步長。
"""字串的切片 slice 獲取多個字元 索引獲取的公式： m_str[start:end:step] 注意：end - start 的符號 必須和 step 的符號相同才可以獲取到索引 step 的值不能為0 """ name = 'yuzwang' # 要 1 和 2 print(name[1:2]) # u print(name[0:1]) # y # TODO: 這個才是對的 # TODO: 顧頭不顧腚，取頭不取尾，取左不取右 print(name[0:2]) # yu print(name[3:6]) # wan # 什麼是 step , 取完第一個索引，把索引 + 多少 # step = 2 print(name[3:6:2]) # wn print(name[1:5:3]) # ua # step 可以為負數 print(name[5:1:-3]) # nz print(name[5:1:3]) # 取不到值 None print(name[1:4:-2]) # 取不到值 None # TODO: end - start 的符號 必須和 step 的符號相同才可以獲取到索引 # TODO:step 的值不能為0，否則會報錯：ValueError: slice step cannot be zero print(name[1:5:0]) # TODO: IndexError print(name[1000000]) # IndexError: string index out of range print(name[1:1000000]) # uzwang 不會報錯，會取到所有值 name = "yuzewang" # 省略 end ,表示取到最後 print(name[1:]) # 省略 start ，表示從 0 開始 print(name[:5]) # 複製，copy 從頭到尾， # TODO: 面試題：複製字串 print(name[:]) name_copy = name[:] print(name_copy) # 倒序 '123456' ==> '654321' # TODO：面試題：倒序一個字串 print(name[::-1]) # gnawezuy
3、字串拼接和轉義
-
+ 號：'hello' + 'python'
-
字串轉義：
- \n: 換行符
- \t: 水平製表符
- 關閉轉義：r'hello \n python'
name = 'yuz' family_name = 'wang' print(name + family_name) print(name + ' ' + family_name) 字串和數字能不能相加 print('yuz' + 7) # 字串和數字不能直接相加，會報錯：TypeError: must be str, not int print('yuz' + str(7)) # yuz7 資料型別的轉化 print(int(name)) # 報錯：ValueError: invalid literal for int() with base 10: 'yuz' print(int('12')) # 12 print(bool(34)) # True bool 轉化，只要是非0，非空的就是True 字串換行 '\' 不會分開成兩行 name = "yuze ooasfjojo" \ "wefwllfjlj" print(name) # yuze ooasfjojowefwllfjlj # 三引號換行，得到多行資料 name = """yuze flaljlkfjlajl lsajllakj fjk sjljjfljladf aljfl """ print(name) # 單引號中 \n 表示換行 name = 'kaixina lajj\nlfljajljssfjdlk\njljajs' print(name)
4、字串常用方法
- join : 字串拼接
name = "qin er cai"
# 字串拼接
print(name + 'wang')
# 使用 join 拼接
print(name.join(['a','b','c'])) # aqin er caibqin er caic
# 時間 ['2020', '08', '03'] 用 / 連線起來
print('/'.join(['2020', '08', '03'])) # 2020/08/03
print('2020' + '/' + '08' + '/' + '03') # 2020/08/03
- find : 查詢元素的位置
# find：在字串當中查詢某個字元或者字串的位置
# 會得到索引
a = "wangyuze is coming"
print(a.find('e')) # 7
index = a.find('e')
print(index) # 7
# 如果找的有兩個呢？ i，會得到第一個
print(a.find('i')) # 9
# 如果是一個子串呢？ ng
print(a.find('ng')) # 2
# 如果找不到怎麼辦？會得到 -1 ，這是規定
print(a.find('isnot')) # -1
# 如果子串不在一起，也是找不到，返回 -1
print(a.find('wn')) # -1
# index 約等於 find
# 區別：index 找不到元素的時候，會報錯，find 找不到的時候返回-1
print(a.index('ng')) # 2
print(a.index('wn')) # ValueError: substring not found
- count : 查詢元素的個數
# count 統計某個字元出現的次數
m_str = 'foweofpweef'
print(m_str.count('o')) # 2
song = "我愛你，我喜歡你，我..."
print(song.count('我')) # 3
- replace : 替換字元
# replace 替換
song = "我愛你，我喜歡你，我..."
print(song.replace('你', 'ta')) # 我愛ta，我喜歡ta，我...
- split : 字串分割
# split 切分、切割 ==》 和 join 相反
time_string = '2020/08/03'
print(time_string.split('/')) # ['2020', '08', '03']
-
format : 格式化輸出
-
upper : 將字母大寫
# upper 所有字母都大寫
name = 'yuze'
print(name.upper()) # YUZE
- lower : 將字母小寫
# lower 所有字母都小寫
name = 'JECK'
print(name.lower()) # jeck
- strip : 去掉兩邊的特殊字元，如果什麼都不傳，就是去掉空格或者換行符
# strip 去掉兩邊的特殊字元，如果什麼都不傳，就是去掉空格或者換行符
name = ' yuze wang '
print(name.strip()) # yuze wang
print(name)
cp = "&雨澤&哈哈&"
print(cp.strip('&')) # 雨澤&哈哈
- len : 計算字串長度
# len 計算字串的長度
name = 'yuzewang '
print(len(name)) # 9
5、字串格式化輸出
-
format 格式化輸出
- format() 功能強大，該函式把字串當成一個模板，通過傳入的引數進行格式化，並且使用 {} 作為特殊字元代替 %
資料 格式 結果 描述 5.11111 {:.2f} 5.11 保留小數點後兩位 0.25 {:.2%} 25.00% 百分比格式 aa {:<10} aa 左對齊（寬度為10） aa {:^10} aa 中間對齊（寬度為10） - format 字串的格式化
``` # 現在需要列印下面的格式： ------------------- 借條 借款人：yuz 債權人：double king 金額：500 ------------------- loan_name = 'yuz' rich_man = 'double king' money = 500 # # 方法一： # print("---------------------") # print('借條') # print('借款人：' + loan_name) # print('債權人：' + rich_man) # print('金額：' + str(money)) # print('---------------------') # # # 方法二： # {} 表示佔坑符，佔位符 # 位置一定要匹配，不能亂填順序 # print(""" # ------------------- # 借條 # 借款人：{} # 債權人：{} # 金額：{:.2f} 萬 # ------------------- # """.format(loan_name, rich_man, money)) # # # # 方法三： # # f-string : python3.6 以後才支援 # print(f""" # ------------------- # 借條 # 借款人：{loan_name} # 債權人：{rich_man} # 金額：{money} 萬 # ------------------- # """) -
傳統的格式化輸出 %
符號 描述 %s 格式化字串 %d 格式化整數 %f 格式化浮點數字，可指定小數點後的精度
（三）、列表和元組
1、列表
-
列表的定義
- 是一種資料型別，可以用來儲存多個資料
- 列表用 [ ] 來標識
- 列表內部的元素可以是任意型別的
- 列表是使用最頻繁的資料型別之一
-
列表的常見操作
-
下標取值（索引取值）：獲取某一個元素
-
切片操作：獲取多個元素
- 有步長的切片過程：先根據起始位置和終止位置，將內容切出來，然後再根據步長分為若干部分，然後將每部分的第一個元素拿出來，得出結果。
-
修改元素的值：可以通過下標修改指定位置的元素。
# 5 個人，5個大佬 ， 使用列表 big_boss = ['Demons', 'Go', 'EE', '上善若水', 'summer'] print(big_boss) # 元素可以是任意的資料型別 big_boss = ['Demons', 11, True, 33.33, 'summer'] print(big_boss) big_boss = ['Demons', 11, True, 33.33, ['a','b','c']] print(big_boss) big_boss = ['Demons', 11, True, 33.33, ['a','b',['yuz',True]]] print(big_boss) # 索引： 獲取索引為 0 的元素 print(big_boss[0]) # Demons print(big_boss[-1]) # ['a', 'b', ['yuz', True]] print(big_boss[-2]) # 33.33 print(big_boss[2]) # True # 獲取 a print(big_boss[-1][0]) # a last_one = big_boss[-1] print(last_one[0]) # a # 獲取 'yuz' print(big_boss[-1][-1][0]) # yuz # 切片 print(big_boss[:3]) # ['Demons', 11, True]
-
-
列表巢狀
-
列表中如果有多層巢狀，取值時需要一層一層的取值
lst = [ 'a', 'b', [1,2,3] ] print(lst[0]) # a print(lst[-1][1]) # 2
-
-
列表的方法
- 增：append 、insert 、 extend
- 刪：pop 、 remove
- 改：通過下標修改值
- 查：index 、 count
- 其他：reverse 、 sort
方法 描述 append 在列表的尾部加入一個元素 insert 在指定位置插入一個元素 extend 插入多個元素 pop 刪除一個元素（預設從列表尾部刪除，也可以指定下標進行刪除） remove 刪除指定的元素（從前往後找） index 查詢元素的位置，找到第一個就返回結果 count 統計元素的個數 sort 將列表的元素進行排序 reverse 將列表內元素反序（頭變為尾，尾變頭） # TODO：坑 dalaos = ['隨風'] new_dalao = dalaos.append('利己') print(dalaos) # ['隨風', '利己'] # append() 返回 None print(new_dalao) # None # 再新增多個，['一罐','本本','可愛','美雪'] 新增到最後 dalaos.extend(['一罐','本本','可愛','美雪']) print(dalaos) # TODO: 坑2 報錯：AttributeError: 'NoneType' object has no attribute 'append' new_dalao = dalaos.append('sfo').append('hello').append('sof') print(new_dalao) # 增加某個元素，修改的是原來的變數 lst lst = ['yuz', 'shanshan', 'rita'] lst.append('裴綸') print(lst) # ['yuz', 'shanshan', 'rita', '裴綸'] # insert 指定索引位置新增元素，不是獲取索引，不用[] lst.insert(1, '仙人球') print(lst) # ['yuz', '仙人球', 'shanshan', 'rita', '裴綸'] # extend 新增多個，可以合併 2 個列表 lst.extend(['tiger', 'f2']) print(lst) # ['yuz', '仙人球', 'shanshan', 'rita', '裴綸', 'tiger', 'f2'] lst = [1,2,3] lst.append(3) print(f"第一次嘗試{lst}") # 第一次嘗試[1, 2, 3, 3] # lst.extend(3) # print(f"第二次嘗試{lst}") # 報錯：TypeError: 'int' object is not iterable lst.extend([3]) print(f"第三次嘗試{lst}") # 第三次嘗試[1, 2, 3, 3, 3] a = [1,2,3] b = [4,5,6] # b 是作為一個整體，一個元素，新增到 a 當中 # a.append(b) # print(a) # [1, 2, 3, [4, 5, 6]] # b 是拆開裡面元素，作為多個元素，新增到 a 當中 a.extend(b) print(a) # [1, 2, 3, 4, 5, 6]"""列表的刪除 - remove - delete - pop """ # remove: 在列表當中刪除指定的值 big_boss = ['糖', '木易', '均價'] big_boss.remove('木易') print(big_boss) # ['糖', '均價'] # delete 異類：儘量不要用 # del big_boss[0] # print(big_boss) # ['均價'] # pop 0 代表索引為 0 big_boss.pop(0) print(big_boss) # ['均價'] # 獲取索引為 0 的值 print(big_boss[0]) big_boss.append('木易') print(big_boss) # ['均價', '木易']"""列表的修改 lst[0] = 1 """ lst = [1,2,3] lst[1] = 'a' print(lst) # [1, 'a', 3] lst[1],lst[2] = 'c', 'd' print(lst) # [1, 'c', 'd'] lst[1:] = 5,6 print(lst) # [1, 5, 6]"""列表的方法 - index - count - sort - reverse - clear """ lst = [4,5,6,5] # # 統計 # print(lst.count(5)) # 2 # # # index 查詢得到第一次出現的索引值 # print(lst.index(5)) # 1 # # # sort 排序 # print(lst.sort()) # None # # lst.sort() # print(lst) # [4, 5, 5, 6] # # # # reverse 反向，倒序 , 相當於 [::-1] # lst.reverse() # print(lst) # [6, 5, 5, 4] # 反向排序 lst.sort(reverse=True) print(lst) # [6, 5, 5, 4] # clera 清除一個列表 lst.clear() print(lst) # []
2、元組
-
元組的定義：
- 元組定義在小括號中，元組內部的資料：它支援數字，字串甚至可以包含元組（即巢狀）
-
元組的常見操作
- 下標取值：元組內部的資料是有序的，可以通過下標獲取對應的元素
-
注意點
- t = () 空元組
- t = (1,) 只有一個資料的時候要注意加逗號
- 元組的值不可以修改，是屬於不可變資料
-
元組的方法
- count ： 查詢元素的個數
- index ：查詢元素下標
tuple_yuz = ('yuz','一罐',['閒人','七七','小驕傲']) # 修改的是元組的元素，元組的元素是列表 # tuple_yuz[2] = ['新列表'] # print(tuple_yuz) # 不能修改元組的元素 # 為什麼這裡可以改?? # 元組的不可變是相對的，不是說裡面所有的內容都完全不能變 # 只要看索引的前面是不是一個可變的型別 tuple_yuz[2][0] = ['新列表'] print(tuple_yuz) tuple_yuz = ('yuz','一罐',{'tuple':'yuze'}) # 索引前面是元組，代表我們要修改的是元組的元素，不可以 # tuple_yuz[2] = 'hello world' # tuple_yuz[2] 是字典，可變型別，可以直接修改 tuple_yuz[2]['name'] = 'hello world' print(tuple_yuz) # 索引前yuz是列表，可以改變 yuz = ['yuz','一罐',('四葉草','曉峰')] yuz[2] = 'hello' print(yuz) # yuz[2]是元組，不可變 yuz[2][1] = 'youxi'tuple_demo = () print(tuple_demo) # TODO:坑 ，一個元素的元組表示，不是一個元組，而是去掉括號後的原始資料型別 # tuple_demo_2 = (1) # print(tuple_demo_2) # 如果想表示一個元素的元組，記得務必在元素後面加一個逗號 # tuple_demo_3 = (1,) # print(len(tuple_demo_3)) tuple_demo_4 = (1,3,4,5,5,) print(len(tuple_demo_4)) tuple_demo_5 = 1 print(tuple_demo_5) # 元組解包 family_name,name = ('wang','yuze') # family_name,name = ('wang','yuze','hello') # 值要一一對應，否則會報錯 print(family_name) print(name) a,b = 3,4 print(a) print(b) family_name,name,*other = ('wang','yuze','hello','world') print(family_name) print(name) print(*other)
3、字串、列表、元組總結
- 序列型別：
- 字串、列表、元組，統稱為序列型別資料（內部的元素是有順序的）
- 通用操作：
- 下標取值：
- 切片：
- 獲取元素總數： len()
（四）、字典和集合
- 問題：
- 使用一個列表儲存了一個學生資訊，姓名，年齡，電話號碼，stu = ['小明', '18', '13812341234']
- 問題一：當前如果電話號碼寫錯了，怎麼修改
- 問題二：當前列表中有10個設定100個元素，不知道電話號碼具體的下標，怎麼修改電話號碼
1、字典
-
字典的定義：
-
也是用來儲存多個資料的
-
字典：字典用 {} 來標識
-
字典能夠表示元素更具體的意思，每個元素表示的意義是什麼，可以通過 key 命名
-
字典的結構：就是將它看做是一個 {key:value} 鍵:值 對的集合，鍵必須是唯一的（在一個字典中）
-
空字典 ： {}
-
字典定義的方式：
# 方式一： dic = {'name':'musen', 'age':18} # 方式二： dic = {name = 'musen', age = 18}
-
-
注意點：
- 字典中的鍵必須是唯一的
- key 不能出現重名，在一個字典當中，key 之間是不一樣的
- key 不能變的，列表是不能作為 key 的
- 可變型別資料：字典定義後可以修改內部元素
- 注意點：字典的鍵必須是不可變型別的（一般情況下都是字串），值可以是任意型別的資料（字典，元組，列表等等都可以）
-
字典的增刪改查
-
增
-
通過指定鍵去新增相應的值
dic[key] = value -
update() : 將一個字典的所有元素更新到另一個字典中
# 簡單理解 dic.update({'a':1, 'b':2}) -
-
改：通過指定鍵去修改對應的值
dic[key] = value -
刪
-
pop() : 刪除指定的鍵，刪除的鍵不存在會報錯（避免錯誤可以新增預設值）
dic.pop(key) -
popitem() : 刪除一個鍵值對，刪除最後一個新增的元素
- 之前版本是隨機刪除一個元素，python3.7新特性，刪除最後新增的元素
-
關鍵字 del : 通過鍵刪除
del dic[key]
-
-
-
查
- get() : 獲取鍵對應的值
- keys() : 獲取所有的鍵，可以用 list 將結果轉換成列表
- values() : 獲取所有的值，可以用 list 將結果轉換成列表
- items() : 獲取所有的鍵值對，可以用 list 將結果轉換成列表，列表中每個鍵值對組成一個元組。
# 列表：當每個元素有具體的意義，你又想去單獨獲取的時候，可讀性不強 beisheng = ['星際穿越', '蜘蛛俠', '上海堡壘', '分手大師', '前任3'] print(beisheng[2]) # 字典：key: 元素的名稱， value: 元素的值 ， 鍵值對：成對 # 用 {} 在最外面 # key: value, key1: value1 beisheng = {'favor':'星際穿越','hate':'蜘蛛俠','first':'上海堡壘','last':'分手大師','twice':'前任3'} print(beisheng['hate']) # 蜘蛛俠 # 重名的key beisheng = {'favor':'星際穿越', 'hate':'蜘蛛俠', 'first':'上海堡壘', 'favor':'分手大師', 'twice':'前任3'} # favor 後面的值會覆蓋前面的值 print(beisheng['favor']) # 分手大師 print(beisheng) # {'favor': '分手大師', 'hate': '蜘蛛俠', 'first': '上海堡壘', 'twice': '前任3'} # key 不能是列表 # beisheng = {'favor':'星際穿越', # ['hate']:'蜘蛛俠', # 'first':'上海堡壘', # 'favor':'分手大師', # 'twice':'前任3'} # print(beisheng) # 報錯：TypeError: unhashable type: 'list' # 鍵為數字: 沒有意義，不建議使用 beisheng = {1:'星際穿越', 3:'蜘蛛俠', 2:'上海堡壘', 5:'分手大師', 4:'前任3'} print(beisheng) # {1: '星際穿越', 3: '蜘蛛俠', 2: '上海堡壘', 5: '分手大師', 4: '前任3'}beisheng = {'favor':'星際穿越', 'hate':'蜘蛛俠', 'first':'上海堡壘', 'last':'分手大師', 'twice':'前任3'} # 獲取，查 print(beisheng['hate']) # 字典沒有索引和切片 # 修改 beisheng['hate'] = '蝙蝠俠' print(beisheng) # {'favor': '星際穿越', 'hate': '蝙蝠俠', 'first': '上海堡壘', 'last': '分手大師', 'twice': '前任3'} # 新增, 和修改是一樣的 # 什麼時候是修改，什麼時候又是新增？ # 看 key：當 key 已經存在的時候，是修改，當之前沒有這個key，就是新增。 beisheng['scared'] = '貞子' print(beisheng) beisheng['scared'] = '午夜凶鈴' print(beisheng)
2、集合
-
定義：
- 集合中的元素不能重複
- 花括號 或 set() 函式可以用來建立集合
-
注意：
- 要建立一個空集合你只能用 set() 而不能用 {} ，因為後者是建立一個空字典
-
集合的方法：
- 增加元素 : add
- 刪除元素 ：pop , remove
- 自動化測試中很少用集合來存放資料，更多內容請自行擴充套件
-
集合的重要應用場景：去重
-
集合的交集、並集、差集
- a & b : 集合 a 和 b 中都包含了的元素
- a | b : 集合 a 或 b 中包含的所有元素
- a - b : 集合 a 中包含而集合 b 中不包含的元素
# 集合不是鍵值對 # 集合是無序的 # 不能通過索引獲取 # 重複的元素直接丟掉，集合目前我們使用的最多的功能就是去重 set_yuz = {'yuz','魯西西','閒人','yiguan'} print(set_yuz) # print(set_yuz[1]) # 會報錯 print(len(set_yuz)) # 去重 set_yuz = list(set(['yuz','魯西西','閒人','yuz'])) print(set_yuz) # split 分割 # a = 'hello world' # b = a.split('w') # print(b) a = 'hello/world/sofo/sooof' b = a.split('/',1) # 數字1代表分割一次 print(a) # a 是字串，不會變 print(b)
（五）、資料型別相互轉換
1、字串的轉化
-
字串轉換成列表
- 字串轉換成list 的時候，str可以作為迭代物件，直接放入；也可以使用split對字串進行切割。然後返回list
s = '1ab1cd' print(list(s)) # ['1', 'a', 'b', '1', 'c', 'd'] print(s.split('1')) # ['', 'ab', 'cd']
-
字串轉換成元組
s = '1ab1cd' print(tuple(s)) # ('1', 'a', 'b', '1', 'c', 'd')
-
字串轉換成字典
a='1ab1cd' b='123456' print(zip(a,b)) # <zip object at 0x00000000022952C8> print(dict(zip(a,b))) # {'1': '4', 'a': '2', 'b': '3', 'c': '5', 'd': '6'} a='1ab1cdd4e5' b='123456' print(zip(a,b)) # <zip object at 0x00000000022952C8> print(dict(zip(a,b))) # {'1': '4', 'a': '2', 'b': '3', 'c': '5', 'd': '6'}
-
字串轉換成集合
a='1ab1cd1d' print(set(a)) # {'1', 'a', 'c', 'b', 'd'}
2、列表的轉化
-
列表轉換成字串
- 列表裡如果有int型別，字典，元祖，列表，則join方法不可用
list = ["3","d","aaa"] print("".join(list)) # 3daaa print(" ".join(list)) # 3 d aaa print("!".join(list)) # 3!d!aaa
-
列表轉換成元組
list = ['1','2','3','a',(1,2,3),1,[1,2],{"a":1}] print(tuple(list)) # ('1', '2', '3', 'a', (1, 2, 3), 1, [1, 2], {'a': 1})
-
列表轉換成字典
list1 = ['1','2','3','4','a',(1,2,3),5,6] list2 = ['a','b','c','d','e','f',[1,2],{"g":"h"}] dict1 = dict(zip(list1,list2)) print(dict1) # {'1': 'a', '2': 'b', '3': 'c', '4': 'd', 'a': 'e', (1, 2, 3): 'f', 5: [1, 2], 6: {'g': 'h'}}
-
列表轉換成集合
list = ['1','2','3','3'] print(set(list)) #{'3', '1', '2'}
3、元組的轉化
-
元組轉換成字串
- 元組裡如果有int型別，字典，元祖，列表，則join方法不可用
tuple = ('1','2','3','4','2','a') print(''.join(tuple)) # 12342a -
元組轉換成列表
tuple = (1,2,3,4,5,'2','a') print(list(tuple)) # [1, 2, 3, 4, 5, '2', 'a'] -
元組轉換成字典
tuple1 = ('1', '2', '3', '4',111,(11,22,33),"") tuple2 = ('a', 'b', 'c', 'd','e','f','h','g','i','j','k') dict1 = dict(zip(tuple1, tuple2)) print(dict1) # {'1': 'a', '2': 'b', '3': 'c', '4': 'd', 111: 'e', (11, 22, 33): 'f', '': 'h'} -
元組轉換成集合
tuple1 = ('1','2','3','4',4,'4',4,1) print(set(tuple1)) # {1, 4, '3', '1', '2', '4'}
4、字典的轉化
-
字典轉換成字串
- 對於生成字串，需要先生成list和tuple，然後再由list和tuple生成str
dict1 = {1:'a',2:'b',3:'c'} list1 = list(dict1.values()) print("".join(list1)) # abc tuple1 = tuple(dict1.values()) print("".join(tuple1)) # abc -
字典轉換成列表/元組/集合
- 字典可以使用 dict.keys() 和 dict.values() 返回迭代器，通過list和tuple直接生成列表和元祖
dict1 = {1:'a',2:'b',3:'c'} print(list(dict1.keys())) # [1, 2, 3] print(list(dict1.values())) # ['a', 'b', 'c'] print(tuple(dict1.keys())) # (1, 2, 3) print(tuple(dict1.values())) # ('a', 'b', 'c') print(set(dict1.keys())) # {1, 2, 3} print(set(dict1.values())) # {'a', 'b', 'c'} print(tuple(dict1.items())) #生成元祖為單位的元祖 # ((1, 'a'), (2, 'b'), (3, 'c')) print(list(dict1.items())) #生成元祖為單位的列表 # [(1, 'a'), (2, 'b'), (3, 'c')] print(set(dict1.items())) #生成元祖為單位的集合 # {(2, 'b'), (3, 'c'), (1, 'a')}
5、集合的轉化
-
集合轉換成字串
- 集合是無序的，每次轉換成的字串值都不一定一樣，也可以先轉為列表或者元祖，再轉換成字串
set1 = {"1","2","ac"} print("".join(set1)) # 2ac1 print(type("".join(set1))) # <class 'str'> -
集合轉換成列表/元組
set1 = {1,2,3,4,5,6} print(list(set1)) # [1, 2, 3, 4, 5, 6] print(tuple(set1)) # (1, 2, 3, 4, 5, 6) -
集合轉換成字典
- 無意義的對映，不推薦
set1 = {1,2,3,4,5,6} set2 = {'a','b','c','d'} print(dict(zip(set1,set2))) # {1: 'd', 2: 'a', 3: 'b', 4: 'c'}
三、控制流程
（一）、條件語句
-
if條件判斷
- 分支結構，常用的表現方式：
- if（條件表示式）:......
- if(條件表示式):......else:......
- if(條件表示式):......elif(條件表示式):......elif(條件表示式):......else:
- 分支結構，常用的表現方式：
# if的寫法（else可以省略）
if (條件表示式):
pass
else:
pass
if (條件表示式):
pass
elif (條件表示式):
pass
else:
pass
# 例如：
username = "yuze"
if username == "yuze" or username == "yuzewang":
#縮排表示條件滿足以後需要執行的子程式碼，是一個分支
print("登入成功")
elif username == ""
print("請輸入使用者名稱")
elif username == "Demo"
print("沒有該使用者")
else
print("登入失敗")
-
if語句用於驗證某個條件
- 當條件為真時，執行if下面的程式碼塊，否則執行else下面的程式碼塊
- 條件當中，只要執行了一個分支，其它分支就不會繼續執行了
- 條件表示式:要得到的值是一個bool型別，True, False
-
使用if需要注意的點
- 所有分支流必須以if開頭
- 語句中的else可以省略
- if與elif後面必須加條件表示式，else後面不能加條件表示式
- 一個判斷分支下只有一個if，一個else，可以有多個elif
- 分支下按順序執行程式碼，只要執行了一個分支下的程式碼，其他的分支則都不會執行
（二）、程式debug除錯
- 是暫停程式碼的執行去獲取現在的資料狀態
- pycharm中的debug
- 先打斷點
- 再執行debug
- 下一步按鈕
- 檢視資料
- 打斷點，是告訴程式我應該在哪裡暫停
（三）、while迴圈
-
迴圈控制流
- 迴圈語句，用於驗證某個條件
- 當條件為真時，執行迴圈下的程式碼塊，否則結束迴圈
- 分類：
- while 迴圈
- for 迴圈
-
while迴圈作用：用來重複執行某個操作
-
while 語法
while 判斷條件：
執行程式碼
# 例如：
times = 0
while times < 999:
print("我說了{times}次")
times = times + 1
continue: 表示手工進入下一個迴圈體，進入下次迴圈
break：表示手工強制退出整個while迴圈
（四）、for迴圈
-
作用：
- 用來遍歷物件
- 從物件的第一個元素到最後一個元素，依次訪問
- for迴圈會自動+1
-
語法
- for 元素 in 資料集合：執行程式碼
- 資料集合可以是：列表，元組，字典，字串，也可以是指定的資料範圍
- for迴圈巢狀，子迴圈執行完，才會回到母迴圈執行
for 迭代變數 in 字串|列表|元組|字典|集合：
程式碼塊
# 例如：
add = "http://c.biancheng.net/python/"
#for迴圈，遍歷 add 字串
for ch in add:
print(ch,end="")
continue：手工進入下一個迴圈體，進入下次迴圈
break：手工強制退出整個while迴圈
-
break
- 常用在迴圈結構中
- 在迴圈中遇到break,就跳出迴圈
-
continue
-
常用在迴圈結構中
-
在迴圈中遇到continue,就跳出本次迴圈，繼續下一次迴圈
（五）總結知識點
- for經常用到的場景：如果有一個現成的列表，字串，字典，就用for
- while經常用到的場景：不知道什麼時候結束迴圈
- 同時獲取列表的索引和值
for i,value in enumerate(list):
print(i, value)
- 同時獲取字典的鍵和值(常用)
for k,v in mdict.items():
print(k, v)
- 獲取所有的value
for value in mdict.values():
print(value)
- 獲取所有的key
for key in mdict.keys():
print(key)
for k in mdict:
print(k)
-
range() 函式
- 表示迴圈某一個資料段
- range(start,end,step),與切片類似，包前不包後
- 列印100遍
for i in range(100): print(i)
四、函式和函式引數
（一）、函式定義和呼叫
1、函式的定義
-
函式的概念：以數學函式來理解
-
作用：傳入一個自變數，會得到一個另外的變數，這個變數會根據自變數變化而變化
-
用於儲存一段程式碼。 是封裝
-
定義函式關鍵字：def
-
為什麼要寫函式：方便好用、複用性高
-
函式名：屬於識別符號，遵循識別符號的命名規則：
- 函式的名稱是一個識別符號：數字、字母、下劃線，不能是內建關鍵字
- 函式名遵循蛇形命名：下劃線命名
- 函式名稱要見名知義
- 函式命名的重要性：函式的名稱會告訴讀程式碼的人：這個函式的作用是什麼
-
語法：
def 函式名(引數): 函式內部功能程式碼一 函式內部功能程式碼二 函式內部功能程式碼三 函式內部功能程式碼四 def add(a,b): print(a+b) -
函式中的程式碼如何執行？
- 函式定義時，函式的程式碼不會被執行，只有當函式被呼叫時，函式中的程式碼才會被執行
-
不要在一個檔案中定義兩個同名函式，後面的會覆蓋前面的
def add (a,b):
print(a+b)
def add (a,b):
print(a-b)
add(1,2) # -1
2、函式的呼叫
-
使用函式的過程叫做呼叫函式；呼叫的時候會給變數賦值，即變數 = 值
-
呼叫方法：
函式名()
-
函式的相互呼叫
- 在函式中呼叫另外一個函式
- 函式呼叫是去執行函式體內部邏輯
- 避免兩個函式相互呼叫
- 不要呼叫自己
（二）、函式的返回值
- return 的作用：
- 返回值數目 = 0；返回 None
- 返回值數目 = 1：返回object
- 返回值數目 > 1：返回tuple
- 疑問：為什麼要用return？什麼時候用return？
- 根據需求，當需要返回的時候就返回，不需要返回的時候就不返回。
- 注意點：
- 1、return 是用來給函式返回結果的。
- 2、當函式執行到return 時函式執行結束。
- 3、函式沒有定義return，預設的返回值為None
- 現在有兩件事，寫成兩個函式
（三）、函式引數
-
1、引數的定義
- 函式名後面的括號彙總定義引數
-
2、形參與實參
- 在函式定義的時候出現，是變數名，是自己定義的
- 呼叫時實際傳遞的引數為：實參，是函式呼叫時出現的，實際引數是將要賦給變數名（形參）的值
- 實參和形參要配對，成對出現的，下面情況都是不行的
- 只有實參，沒有形參
- 只有形參，沒有實參
def add (a,b): print(a+b) return(a+b) add(1,2) # a,b是形參， 1,2 是實參 -
位置引數
- 函式的形參和實參是成對出現的，一一對應的
- 函式呼叫的時候一定要檢查好引數的個數
- 位置引數概念
- 形參和實參的這種位置關係叫位置引數
def add (a,b): print(a+b) return(a+b) add(1,2) # 1對應a， 2對應b -
關鍵字引數
- 關鍵字引數,函式呼叫的時候，給實際引數貼標記，標記是形參的變數名
- 通過關鍵字引數，可以不按順序配對
- 關鍵字引數要放在位置引數的後面
- 關鍵字引數的作用：當引數很多時，可以使用
def add (a,b): print(a+b) return(a+b) add(b=3,a=2) -
預設引數
- 在函式定義的時候，給形式引數一個預設的值
- 呼叫函式的時候，可以不用賦值給預設引數
- 使用預設引數：可以少些實際引數
- 放在位置引數後面
def add (a,b=8): print(a+b) return(a+b) -
不定長引數
- 不定長參數列示方式： * **
- * 當在一個形參前加*，他會收集所有剩下沒有配對的實際引數（位置引數），把剩下的資料組成一個元組
- *args 存放很多位置引數
def add (a,*b): print(a) print(b) add(1,2,3,4) # 1,(2,3,4) def add (a,*b): print(a) print(b) add(1,2,3,4,c=1) #報錯：預設引數要放到位置引數後面，不定長引數放到位置引數後面 -
**只能收集關鍵字引數
-
**kwargs 存放很多關鍵字引數
-
將資料轉換為字典的形式
def add (a,**b):
print(a)
print(b)
add(1,c=1,d=2) # 1 {'c': 1, 'd': 2}
-
不定長引數的作用
- 在引數定義的時候，不知道有多少個實際引數（關鍵字引數）
-
拆包：
- 列表、元組拆包
- 會拆成位置引數
- 函式定義當中args 表示不定長的位置引數，在呼叫的時候，叫做拆包、解包
- 呼叫的時候，把 一個列表或元素變數傳入函式，在前面加，就可以比那成多個值
def marry(male,female): print(male) print(female) couple = ("老王","小星星") marry(*couple)- 字典拆包
- 會拆成關鍵字引數
couple = {"male":"小王","female":"老劉"} marry(**couple)
- 列表、元組拆包
（四）、函式作用域
- 是區域性作用域
- 在定義函式時，設定的變數為區域性變數
- 區域性變數不能在全域性作用域獲取
- 函式內部區域性作用域可以用全域性變數
- 在函式外部不能修改函式內部的變數
- 在函式內部可以修改全域性變數，不過需要用global宣告是全域性變數 例如：global c
（五）、內建函式
-
print ：輸出
-
input ：輸入
-
type ：檢視資料型別
-
range ：生成資料
-
id ：獲取資料記憶體地址
-
int、float、str、bool、list、dict、tuple、set ：代表對應的資料型別，轉換資料型別
-
max ：獲取最大的值，可以傳多個引數，可以傳列表
-
min ：獲取最小的值，可以傳多個引數，可以傳列表
-
sum ：求和
-
enumetate:
# enumerate() 將列表中的元素及其位置轉換為成對的元組 m_list = ['aa', 'bb', 'cc', 'dd'] print(list(enumerate(m_list))) # [(0, 'aa'), (1, 'bb'), (2, 'cc'), (3, 'dd')] print(list(enumerate(m_list, start = 1))) # [(1, 'aa'), (2, 'bb'), (3, 'cc'), (4, 'dd')] -
eval ：可以去掉一個字串的引號
m_str = "6>7" print(m_str) print(eval(m_str)) # False m_str = '{"username":"yuz","age":18}' print(m_str) # {"username":"yuz","age":18} print(type(m_str)) # <class 'str'> print(eval(m_str)) # {'username': 'yuz', 'age': 18} print(type(eval(m_str))) # <class 'dict'> -
filter ：過濾某些資料 filter（呼叫函式，列表）
li = [2,3,4,5,6,7]
def get_odd(value):
if value % 2 == 0:
return True
return False
res = filter(get_odd, li)
print(list(res)) # [2, 4, 6]
- map ：
li = [2,3,4,5,6,7]
def square(value):
return value ** 2
res = map(square, li)
print(list(res)) # [4, 9, 16, 25, 36, 49]
- zip ：
li_1 = ["yuz","hello","world"]
li_2 = [43,12,15]
print(list(zip(li1,li2))) # [('yuz', 43), ('hello', 12), ('world', 15)]
a = zip(li1, li2)
print(dict(a)) # {'yuz': 43, 'hello': 12, 'world': 15}
（六）、模組和包
-
模組
- 模組，就是一個帶 .py 字尾的python 檔案，一個模組裡面會有很多的函式，類
- 模組名稱：是一個識別符號，符號識別符號命名規則
- 數字、字母、下劃線，不能以數字開頭，不能是關鍵字
- 模組名稱命名一般是使用下劃線的形式命名，駝峰， d1_review.py
- 模組名稱不能和 python 內建的模組名稱重合
- 模組作用：
- 有邏輯的組織python程式碼
- 把相關功能的程式碼寫到一個模組裡能讓程式碼更好用，更易懂
-
包
- 包，package，就是一個python檔案的資料夾，裡面會有一個或多個模組
- 包含一個_init_.py 模組的資料夾，這個模組可以什麼都不定義，可以只是一個空資料夾
- 標準庫，第三方庫，實現特定功能的程式碼集合，一個模組，也可以是一個包
- python3 新版本，不帶_init_.py 同樣可以作為包使用
-
模組匯入
-
是模組間變數和函式的互相使用 ，需要使用 import 的關鍵字
-
import ... 後面只能跟 模組，不能跟函式，變數
-
from .. import ... 後面可以跟模組，函式，類，變數
-
匯入自己的模組，別人的第三方模組，一般使用from import ,不用import..
-
google內部約定，匯入模組只匯入模組這一層，然後使用 模組名.函式名() 來呼叫函式
from class_9_file import demo01 demo01.test01_fun() -
import .. 呼叫函式的時候需要些很長的字首，比較麻煩
-
-
不建議使用：from... import *
- 匯入模組或者包裡面，所有的類、函式、變數
- 匯入所有，如果重命沒有解決方法
-
as 重新命名 - 避免同名函式衝突
-
匯入時匯入到模組這一層，使用時使用模組名.函式名
-
使用別名
- 別名就是重新命名，就是原函式名很長，為了方便使用函式
from class_9_file import demo01 as d d.test01_fun()
-
-
不要用相對匯入，要絕對匯入，就是從根目錄開始匯入
-
五、檔案及路徑
（一）、檔案
1、開啟檔案和關閉檔案
-
開啟檔案，使用內建函式 open()
- open(" path/檔名.字尾 “)
-
特別注意：開啟檔案不管進行什麼操作後，一定要關閉檔案，否則會出現資料不對，或者寫入內容不生效，檔案無法再次被開啟等情況
f = open("python32.txt") f.close() -
為了避免忘記關閉檔案，可以使用with語句，操作完成後會自動關閉檔案
with open('python32.txt','r',encoding='utf8') as f: print(f.read()) with open('python32.txt','a',encoding='utf8') as f: print(f.write()) -
不在同一路徑下要用絕對路徑，windows要加 r 防止轉義，有反斜槓，mac不用加
with open(r'J:\學習資料\Study\PythonAndSelenium\檸檬班python自動化課程\python32_API\class_09_file\python32.txt') as f: print(f.readline())
2、讀取檔案
-
mode 開啟方式
- r 以只讀方式開啟檔案（預設），一般用於文字檔案，如：txt。檔案指標預設放在檔案開頭
- b 以二進位制格式開啟檔案。一般用於非文字檔案，如：圖片、視訊
- rb 以二進位制的形式開啟並讀取
-
read() 讀取
with open("python32.txt", mode = 'r', encoding = 'utf8') as f: print(f.read()) with open('1.png', mode= 'rb') as f: print(f.read()) -
readline() 讀取一行
with open('python32.txt', encoding = 'utf8') as f: print(f.readline())
-
readlines() 讀取所有行，會以列表的形式展示
with open('log.txt', encoding = 'utf8') as f: print(f.readlines()) # 可以顯示換行符
3、寫入檔案
-
mode 寫入方式
- w 新建寫入
- w比較危險，如果之前已經有同名的檔案，用w會覆蓋之前的內容，w只能用於新建寫入
- a 追加寫入
- 如果檔名不存在，是先新建再寫入；如果檔名存在，則為追加
- wb 以二進位制開啟一個檔案用於只寫
- 如果檔名存在，則覆蓋，不存在，則新建寫入
- ab 以二進位制開啟一個檔案用於追加
- 如果檔案存在，檔案指標會放在檔案結尾處
with open('python32.txt', mode = 'w', encoding = 'utf8') as f: f.write('裴綸') with open('python32.txt', mode = 'a', encoding = 'utf8') as f: f.write('哈哈哈')- + 表示可以同時讀寫某個檔案
- r+ 可讀，可寫
- w+ 可讀，可寫
- a+ 可讀，可寫
- w 新建寫入
（二）、路徑
1、路徑
-
sys . path 包含專案開始根目錄路徑和 python 內建的目錄路徑
- 模組匯入的搜尋路徑: sys.path
- 模組匯入不了時可以用來檢查
- python去查詢包或模組，相當於python裡的地圖
- 返回的是一個列表
- 模組匯入的搜尋路徑: sys.path
-
os 是 python 內建的模組需要用 import 匯入： import os
-
找模組
- 專案開始根目錄
- python內建目錄
- 不建議將寫的模組存放在python的安裝目錄下
- python目錄主要是放外部的庫或第三方的模組
2、路徑處理
-
python中一般不直接寫入絕對路徑， 而是通過程式碼獲取
-
獲取當前檔案的路徑：
abs_path = os.path.abspath(_file_)
_file_ 表示執行的檔案的名稱
-
獲取當前檔案的目錄路徑: 兩種寫法，用第一種絕對路徑
dir_name = os.path.dirname(abs_name)
dir_name = os.path.dirname(_file_)
-
獲取不與當前檔案同一個目錄下的檔案路徑
- 1 ．先獲取當前檔案的絕對路徑
- 2 ．獲取當前檔案的目錄路徑
- 3 ．當前檔案的目錄路徑和該檔案拼接
比如，獲取pac01 下面的 demo.txt: txt_file_path = os.path.join(dirname, 'pac01', 'demo.txt') 讀取圖片檔案（二進位制格式） dir_name = os.path.dirname(os.path.abspath(file)) png_pic = os.path.join(dir_name,'1.png') f = open(png_pic,mode='rb') print(f.read()) f.close()
3、路徑操作
-
os.path.abspath() 獲取絕對路徑
-
os.path.dirname() 獲取檔案/目錄所在路徑
-
os.path.join(a, b) 連線兩個部分的路徑，組成一個完整路徑
-
os.getcwd() 獲取當前工作路徑
-
os.chdir() 切換工作路徑
-
os.mkdir() 在某個目錄下建立一個新目錄
-
os.rmdir() 刪除一個目錄
-
os.listdir() 獲取當前路徑下的目錄，返回列表格式資料
-
os.path.isdir() 判斷當前檔案是否是目錄，返回布林值
-
os.path.isfile() 判斷當前檔案是否是檔案，返回布林值
六、異常
（一）、異常處理
- 異常
- 當程式執行中檢測到一個錯誤時，無法繼續執行，出現一些錯誤提示，這就是異常。
- 程式遇到異常不會再執行，我們要改變程式碰到異常的行為
（二）、異常型別的捕獲
-
語法一：try...except....
-
程式先執行try中的程式碼，一旦try中某個程式碼報錯， 會直接跳到except，try剩下的程式碼不會執行
try: 要執行的可能發生異常的程式碼 except: 程式發生異常後，你希望程式做的事情 try: 1/0 except IndexError as e: print(e) # 其中as e可以在後面用來展示異常資訊，但不能展示異常型別
-
-
語法二：try...except....finally
try: 1/0 except ZeroDivisionError as e: print("不能除以0") finally: print("無論異常與否，都會繼續執行的程式碼") # 執行結果： # 不能除以0 # 無論異常與否，都會繼續執行的程式碼 -
try...except...else
try:
1 / 0
print("正常執行的程式碼")
except ZeroDivisionError as e:
print("不能除以0")
else:
print("程式碼沒有報錯才會執行")
print("正常執行的程式碼的後面部分")
# 執行結果：
# 不能除以0
（三）、多異常型別的捕獲
- 多種異常出現時，可以統一處理的就用下面的方式一，處理方式不一樣的就用方式二
方式一：
try:
{'name':'yez'}['age']
a = 1/0
lst = ['yz','yr']
lst[3]
except(ZeroDivisionError, IndexError, KeyError) as err:
print(err)
print('hello')
except ImportError as e:
print()
方式二：
try:
{'name':'yez'}['age']
a = 1/0
lst = ['yz','yr']
lst[3]
except ZeroDivisionError as err:
print(err)
except IndexError as err:
print('index error')
except KeyError:
print('key error')
（四）、丟擲異常
-
raise 主動丟擲異常
def adult_add(a, b): # 兩個數相加， a, b 一定要大於18， 否則就不能執行 if (a < 18) or (b < 18): raise ValueError('引數必須大於18') c = a + b return c print(adult_add(3, 4)) print('函式執行完成。') # 上面一行報錯，這行不會打 try: adult_add(3, 4) except: print('函式執行完成。') # 結果會列印：函式執行完成。
（五）、斷言 assert
-
斷言: assert
-
斷言的作用：判斷真假
-
斷言的時候，如果斷言成功，程式繼續執行
-
如果斷言失敗，程式終止執行，本質上斷言失敗會觸發一個異常型別：AssertionError
-
斷言，主要用在預期結果和實際結果的比對
height = int(input('輸入身高：')) print(height > 180) # False assert height > 180 print("斷言有結果")
七、物件導向
（一）、類(Class)
-
什麼是類：
- 是指所有符合某種特徵的個體的集合
- 類(Class) 是用來描述具有相同的屬性和方法的物件的集合。它定義了該集合中每個物件所共有的屬性和方法。
-
類的表示：（下面三種寫法作用完全一樣）
class 類名稱: # 類當中的內容 屬性 ==》 特徵 行為 class 類名稱(): pass class 類名稱(object): passclass Dog: # 類內容 tailed = True def say(self): print('汪汪。。。') -
類的命名
- 符合識別符號命名規則
- 字母數字下劃線，不能是關鍵字，要有意義
- 規範：大駝峰，SingleDog
-
使用 類 的好處
- 方便複用（如果你用函式寫，就要複製整塊程式碼，增加了程式碼量，增加了出錯率）
- 方便擴充套件（函式寫段程式碼，若要升級、擴充套件，都十分複雜，容易出錯，用類來擴充套件，則方便清晰）
- 方便維護（因為類是把抽象的東西對映成我們常見的，摸得到的東西，容易理解，維護也方便）
（二）、物件
-
什麼是物件：
- 物件指的是某個類當中的一個成員，一個個體
- 物件是從類當中生成的， ==》 類是一個模型，是一個生產圖紙。
- 物件就是類的具體例項
- 類是函式的定義，物件是函式的呼叫
- 例項、物件、object 都是同一個東西
class Dog: # 類內容 tailed = True def say(self): print('汪汪。。。') zhonghua = Dog() print(zhonghua) # 是物件 <__main__.Dog object at 0x00000000022724A8> print(Dog) # 是類 <class '__main__.Dog'> # Dog 不加括號的時候是類 zhonghua = Dog print(zhonghua) # <class '__main__.Dog'>
（三）、屬性和方法
- 屬性就是指類或者物件的特徵。名詞
- 方法就是指類或者物件的行為。動詞
- 屬性：
- 類屬性（類變數）：類當中每一個成員都具備的特徵，類和物件都可以獲取類屬性
- 例項屬性（例項變數）、物件屬性：類當中的成員不一定都具備的特徵，是物件獨有的，自己具備
- 方法：
-
類方法：每一個成員或者整個類都能呼叫的行為
-
例項方法、物件方法：只能是需要一個單獨的成員呼叫的行為，不能是整個類呼叫
- 不要用整個類去呼叫例項方法
- 例項方法在定義的時候自帶一個引數：self，
- 但是例項方法在呼叫的時候不需要傳 self 這個引數的實際引數
class Dog: # 有尾巴 # 類屬性 tailed = True # 例項方法 def say(self): print('汪汪汪。。。') # 物件 teddy = Dog() # 類屬性的獲取 print(Dog.tailed) # True # 物件獲取屬性 print(teddy.tailed) # True # 屬性可以後天修改 Dog.tailed = False print(Dog.tailed) # False print(teddy.tailed) # False teddy.tailed = '有時候有尾巴，有時候沒有' print(Dog.tailed) # False print(teddy.tailed) # 有時候有尾巴，有時候沒有 # 類方法的呼叫 # Dog.say() # 會報錯 # Dog.say('abc') # 不要用整個類去呼叫例項方法 # teddy.say('abc') # 會報錯 teddy.say() # 汪汪汪。。。
-
（四）、物件的初始化
-
一個物件：除了整個類都具備的屬性，還有自己的特徵。 物件自己的特徵就叫例項屬性或者物件屬性。
-
每個物件都有自己不同的例項屬性，可以在物件生成的時候傳入實際引數，這個實際引數就是例項屬性，傳入實際引數時需要有對應的形式引數，這些形式引數不能在類後面直接定義，這裡就定義了一個特別函式，方法，_init_，在這裡面定義好的形式引數，最終在物件初始化的時候傳入實際引數，這個例項屬性產生的過程就叫物件的初始化。
-
傳入的實際引數是在什麼時候呼叫的？？？
teddy = Dog(name = 'teddy', color = 'blue') 自動呼叫 _init_
不需要寫 Dog._init_()TODO: 一定不要寫成 _int_
class Dog: tailed = True # 定義一個特別函式，方法，定義好的形式引數，最終在物件初始化的時候傳入實際引數 def __init__(self, name, color): """初始化函式，初始化方法""" # 自定義物件產生的過程 # 例項屬性的產生 self.name 定義一個叫做 name 的例項屬性 self.name = name self.color = color def say(self): print('汪汪汪。。。') teddy = Dog(name = 'teddy', color = 'blue') teddy.say() # 獲取例項屬性 print(teddy.color) # 類不能呼叫例項屬性 # print(Dog.color) # AttributeError: type object 'Dog' has no attribute 'color'
-
例項化
-
通過一個類去建立一個物件，就是例項化。
-
例項化是產生物件的過程
-
例項化就是函式的呼叫
-
產生物件，例項化物件的時候，會自動呼叫 _init_ 這個方法
self.name = name
self.name ==> 例項屬性
name ====> 引數， teddy 值。
name 這個name是變數，和類和物件沒有關係
-
-
什麼是 self ：
-
所謂的self，可以理解為自己，就是我們的例項本身，代表例項物件，誰去呼叫代表誰。
Kitty 這個例項物件呼叫，self就代表Kitty
jingel 這個例項物件去呼叫，self就代表jingel
-
某個物件呼叫其方法時，python直譯器會把這個物件作為第一個引數傳遞給 self，只需要傳遞後面的引數即可
-
self 可以改成其他名字，但不建議改，你改了別人就不知道具體的含義了
class Dog: tailed = True # 定義一個特別函式，方法，定義好的形式引數，最終在物件初始化的時候傳入實際引數 def __init__(self, name, color='grey'): """初始化函式，初始化方法""" # 自定義物件產生的過程 # 例項屬性的產生 self.name 定義一個叫做 name 的例項屬性 # dog.name = name # 不能這樣寫，函式裡面不能使用全域性變數，這個時候 dog 這個物件還沒有產生出來 # Dog.name = name # 也不能這麼寫，不能所有的狗都叫同一個名字 self.name = name self.color = color print(self) def say(self): print('汪汪汪。。。') dog = Dog('teddy') print(dog.color) # grey # dog print(dog) # self 和 dog 物件是同一個地址 # ha = Dog('teddy') # print(ha.color) # grey # # dog # print(ha) # self 和 ha 物件是同一個地址
-
（五）、例項方法、類方法、靜態方法
1、例項方法：
- 定義：
- 例項方法直接定義在類中
- 第一個引數是 self （必須要寫），
- 例項方法的訪問
- 只有該類的例項物件都可以訪問，訪問例項方法的時候會自動將物件本身當成引數，傳給self接收
- 在類和物件當中，例項方法是用的最多的。
- 如果不知道該定義成例項方法，類方法還是靜態方法，就定義成例項方法
- 呼叫方法：
- obj.方法名()
- 例項.方法()
2、類方法：
-
定義：
使用裝飾器 @classmethod。第一個引數必須是當前類物件，該引數名一般約定為“cls”，通過它來傳遞類的屬性和方法（不能傳例項的屬性和方法）
-
呼叫：
- 例項物件和類物件都可以呼叫
-
應用場景：
- 需要站在類的角度執行某個行為時，那麼就應該定義為類方法
-
類方法呼叫
- 類.類方法()
3、靜態方法：
-
定義：
- 使用裝飾器 @staticmethod 引數隨意，沒有 self 和 cls 引數，但是方法體中不能使用類或例項的任何屬性和方法
-
呼叫：
- 例項物件和類物件都可以呼叫。
-
應用場景：
- 存放邏輯程式碼，內部不需要引用類屬性和例項屬性
- 當想在一個類當中定義一個方法，和這個類或者物件沒有直接的關係。
- 你在方法當中，沒有使用到類或者是物件。
-
靜態方法呼叫：
- 類和物件，都可以呼叫靜態方法
-
靜態方法存在的理由：
- 放在類裡面方便管理
def say_static(times): # 放在這裡是普通的函式，和放在類裡面效果是一樣的，只是呼叫時這個直接呼叫，呼叫類裡面的需要加字首
print(f'汪汪。。。{times} 聲')
class Dog:
tailed = True
# 定義一個特別函式，方法，定義好的形式引數，最終在物件初始化的時候傳入實際引數
def __init__(self, name, color='grey'):
"""初始化函式，初始化方法"""
self.name = name
self.color = color
print(self)
# 例項方法
def say(self, times):
print(f'{self}汪汪汪。。。{times} 聲')
# 靜態方法
@staticmethod
def say_static(times):
print(f'汪汪汪。。。{times} 聲')
# # 類方法。進化
# def jinhua(self):
# print('狗類正在進化')
# Dog.tailed = False
# 宣告：這是一個類方法
# 固定寫法
@classmethod
def jinhua(cls):
print('狗類正在進化')
Dog.tailed = False
haha = Dog('haha')
yiyi = Dog('yiyi')
# print(haha.tailed) # F
# print(yiyi.tailed) # F
# Dog.jinhua() # jinhua()是例項方法，不能使用類去呼叫
# print(haha.tailed)
# print(yiyi.tailed)
# 類方法的呼叫
# Dog.jinhua() # Dog 加括號表示物件，不加括號表示類
# haha.tailed
# haha.jinhua()
# print(haha.tailed)
#
# haha.say(5)
# 靜態方法的呼叫，類和物件，都可以呼叫靜態方法
haha.say_static(5)
Dog.say_static(6)
# 普通函式版
say_static(7)
（六）、繼承
（1）、類的繼承
-
定義類兩種方式的區別：
# Python2 中稱為經典類，在python3 中預設繼承 object class MyTest: pass # python2 中稱為新式類。 class MyTest(object): pass # 注意點：python3 中上面兩種定義方法沒有區別，都是繼承 object 這個父類 -
在python3 的繼承中，所有的類都預設繼承自 object 這個基類。
-
子類通過繼承可以獲得父類的屬性和方法。
-
被繼承的類叫父類（也叫基類），繼承的類叫子類
-
注意：私有屬性不能繼承
-
作用：
- 子類通過繼承可以獲得父類的屬性和方法，提高開發的效率及程式碼的複用率
# 普通寫法定義手機類和智慧手機類 class Mobile: def __init__(self, model, color='blacd'): self.model = model self.color = color def call(self): """打電話""" print(f"{self} 手機正在打電話。") class SmartPhone: def __init__(self, model, color='blacd'): self.model = model self.color = color def call(self): """打電話""" print(f"{self} 手機正在打電話。") def play_game(self): print("玩遊戲") # 使用繼承 class Mobile(): def __init__(self, brand, model, color='blacd'): self.model = model self.color = color self.brand = brand def call(self): """打電話""" print(f"{self} 手機正在打電話。") class SmartPhone(Mobile): def play_game(self): print("玩遊戲") # iphone = SmartPhone() # iphone.play_game() # 這裡會報錯，初始化的時候需要呼叫__init__方法，自己沒有去找父類，父類的__init__需要傳引數 iphone = SmartPhone('iphone12', 'apple') iphone.play_game()
（2）、超繼承
-
重寫父類方法
- 重寫，就是子類中，有一個和父類相同名字的方法，在子類中的方法會覆蓋掉父類中的同名方法
- 如：同樣是打電話，第一版手機只能大語音電話，最新版手機可以打視訊電話
-
呼叫重名的父類方法
- 子類重寫了父類的方法之後，如何在子類中再呼叫父類的方法：
- 方式一：父類名.方法名(self)
- 方式二：super().方法名()
class Mobile(): def __init__(self, brand, model, color='blacd'): self.model = model self.color = color self.brand = brand def call(self): """打電話""" print(f"{self} 手機正在打電話。") class SmartPhone(Mobile): def __init__(self, model, brand, color='red', pixel = 2000): # self.model = model # self.color = color # self.brand = brand # 這三行程式碼父類中有，可以使用 super() super().__init__(brand, model, color) # 使用 super() 直接呼叫父類的方法 self.fiveG = True self.pixel = pixel def play_game(self): print("玩遊戲") def call(self): """智慧手機打電話""" print('開視訊') super().call() # super 函式的使用 smart = SmartPhone('p40','huawei') print(smart.pixel) smart.call() - 子類重寫了父類的方法之後，如何在子類中再呼叫父類的方法：
（七）、動態獲取屬性
-
獲取物件屬性的時候，如果物件中沒有這個屬性，程式碼就會報錯
-
可以使用 getattr( 物件, 屬性名稱 , 預設值) 動態獲取屬性，並在屬性後面傳入一個預設值，如果物件沒有這個屬性就會顯示預設值，程式碼就不會報錯
-
還可以動態修改屬性，使用 setattr( 物件, 屬性名稱 , 屬性值)
class Mobile: def __init__(self, brand, model): # 先天初始化過程中形成的屬性 self.brand = brand self.model = model def call(self): print('正在打電話。。') iphone = Mobile('apple', 'xr') # 獲取屬性 # print(iphone.brand) # 修改屬性 # iphone.brand = 'aple' # 定義新的例項屬性 # 後天養成的特性 # iphone.video = '美顏' # print(iphone.video) # 獲取一個不存在的屬性 # 如果獲取不存在的屬性，程式碼會報錯 # print(iphone.games) # AttributeError: 'Mobile' object has no attribute 'games' # 動態獲取屬性 # getattr 內建函式 # print(getattr(iphone, 'games')) # 還是報錯：AttributeError: 'Mobile' object has no attribute 'games' # default ，如果獲取不到屬性名，傳入 default 預設值，就不會報錯了 # getattr 不會修改原來的物件的屬性 print(getattr(iphone, 'games', '吃雞')) # print(iphone.games,) # 還是會報錯，因為iphone 沒有games屬性 # 動態修改屬性 setattr(iphone, 'games', '王者榮耀') print(iphone.games) # 王者榮耀