一篇文章带你掌握测试基础语言——Python
生活随笔
收集整理的這篇文章主要介紹了
一篇文章带你掌握测试基础语言——Python
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
一篇文章帶你掌握測試基礎語言——Python
本篇文章針對將Python作為第二語言的用戶觀看（已有Java或C基礎的用戶）
因為之前學習過Java語言，所以本篇文章主要針對Python的特征和一些基本語法來展開介紹
下面我們將從以下角度來介紹：
- Python基本介紹
- Python語法基礎
- Python流程控制
- Python數據結構
- Python函數信息
- Python類與對象
- Python文件操作
- Python異常處理
Python基本介紹
首先我們需要了解一下Python的基本信息
Python基本信息
首先我們要了解為什么要學習Python：
- Python屬于一種腳本語言
- 它本身具有簡單, 易學, 免費, 開源, 適??群?泛的特點
- Python是我們在測試及測試自動化中所必須掌握的基本語言并從中展開學習框架來實現自動化
Python在計算機領域上被稱為解釋性語言：
- 解釋性語言：解釋型語言編寫的程序不進行預先編譯，以文本方式存儲程序代碼，會將代碼一句一句直接運行
- 解釋性語言優點：程序執行效率高，跨平臺性較差
- 編譯性語言：程序執行之前有一個專門的編譯過程，把程序編譯成為機器語言的文件，運行時不需要重新翻譯，直接使用編譯的結果
- 編譯性語言優點：程序執行效率低，跨平臺性較好
Python在使用中有以下優點：
- 完全面向對象的語言：萬物皆對象，針對對象就可以去做處理；支持繼承、重載、多重繼承；支持重載運算符，也支持泛型設計
- 有著強大的標準庫：Python 標準庫提供了 系統管理、網絡通信、文本處理、數據庫接口、圖形系統、XML 處理 等額外的功能
- 有大量的第三方模塊：例如我們測試自動化后期要使用到的unittest框架和pytest框架
Python使用方法
首先我們需要下載最近穩定版本的Python，這里給出一個鏈接，直接下載即可：
Python下載 | Python中文網 官網 (p2hp.com)
我們通常書寫代碼是在PyCharm，社區版功能基本夠用，網上也有破解版，這里給出社區版的下載地址：
Download PyCharm: Python IDE for Professional Developers by JetBrains
Python語法基礎
下面我們來介紹Python的基本語法信息
Python基本語法信息
首先我們需要知道Python的注釋信息標注方法：
# 用#來表示注釋信息
# 在#后面所書寫的內容不會被注入Python執行器中
第二步我們需要了解怎么去書寫一個Python代碼：
# python中是不存在主函數的概念的，當然你也可以通過書寫一個main方法來當作主函數
# 我的意思是：你可以直接在編譯器中輸入對應語法并右鍵run執行，就可以執行最基本的python語言
# 例如我們只需要在編譯器中書寫print("hello,python!"),我們就可以run執行在信息欄收到該輸出信息
print("hello,python!")
# 當然你也可以選擇使用main方法進行輸出,在if左側會有對應的執行按鈕，相當于一個方法的執行
if __name__ == '__main__':
print("hello,python!")
# 在pyCharm編譯器中，你只需要輸入main，點下Tab鍵就會自動補全main方法語法內容：
main+Tab:
if __name__ == '__main__':
第三步我們來學習Python標識符的命名規則：
# 標識符可以包括英文、數字以及下劃線
# 1.開頭必須是字母或下劃線,不能以數字開頭開頭
# 2.標識符是會區分大小寫的，例如myList和MyList是不同的兩個變量
# 3.不能出現分隔符、標點符號或者運算符
# 4.不能使用關鍵字：def if for while class等
Python基本變量信息
首先我們需要了解變量的基本概念：
- 變量用于儲存計算結果或數值
- 可以通過變量名訪問，變量值通常是可變的
- Python中沒有常量，但人們通常以全大寫來表示常量，提示程序員之間不要去修改
然后我們需要了解Python的變量生效方法：
# Python中對于基本類型沒有固定的類型概念
# 也就是說我們的Python變量不需要初始化或者說初始化時不需要指定類型
my_intSum = 1
my_Str = "你好"
剛好我們順便來了解一下python的基本數據類型：
# Python僅僅是不需要去指定類型，但是不代表它沒有數據類型
# Python的數據是沒有上限值的，因此我們不需要擔心Python的數據會因為長度過長導致錯誤
# int整型：
# 整數：沒有小數部分的數值，分為正整數、0和負整數
my_int1 = 100
my_int2 = -100
my_int3 = 0
# float浮點數：
# 浮點數：包含小數點的數
my_float1 = 100.123
my_float2 = 2.3e2 # 科學計數法
# complex復數：
# 復數由兩部分組成：實部和虛部。復數的形式為：實部+虛部j
my_complex1 = 2+3j
my_complex2 = 0.5-0.9j
# bool布爾：
# 布爾類型是用來表示邏輯“是”、“非”的一種類型，它只有兩個值，True和False （首字母T和F是大寫的）
# Python將布爾值True實現為1（int類型），False實現為0，所以可以參與整型運算
my_bool1 = True
my_bool2 = False
# str字符串:
# Python語言中的字符串是一種序列，字符串用單引號、雙引號、三引號作為定界符
my_str1 = "hello,python"
# list列表:
# 列表采用"[]"進行數據包裝，并且采用","來進行數據隔離，可以存儲不同類型
my_list1 = ［1,2,3,True］
my_list2 = ［“one”,“two”,“three”,“four”］
# tuple元組:
# 元組屬于一種另類的List列表，元組采用"()"進行數據包裝并且采用","來進行數據隔離，但是元組的數據不能修改
my_tuple1 = (1,2,3,True)
my_tuple2 = (“one”,“two”,“three”,“four”)
# dict字典:
# 字典類似于Java中的Map，屬于鍵值對類型，采用"{}"進行數據包裝并且采用","來進行數據隔離，內部采用":"進行數據賦值
my_dict1 = {"胡桃"："火屬性","鐘離":"巖屬性"}
my_dict2 = {"胡桃"：158,"鐘離":"老爺子"}
# set集合:
# 集合是由各種不可變類型的元素組成，但元素之間無序，并且元素都不重復,采用"{}"進行數據包裝
my_set1 = {‘car’, ‘ship’, ‘train’, ‘bus’}
my_set2 = {"我的快樂"，"不想上班"}
Python基本操作語句
我們首先需要知道Python的賦值語句格式：
# Python基本賦值語句和Java沒有區別
x = 1
y = x
a = b = 1
# 但是Python可以快速實現數據交換（python的數據不會實時更新，它是在語句執行結束后才會更新）
# 例如下述交換語句效果相同
x,y = y,x
tmp = x
x = y
y =tmp
此外我們簡單了解一下Python的運算符：
# Python運算符和Java也基本一致
# +運算符
# 同類型+有效
1+2
"hello"+"Python"
# 不同類型”+“無效（下面是無法生效的）
3+"ab"
# *運算符
# *運算符可以用于數值相乘
1*2
20*30
# "*"運算符可以用于列表、元組或字符串和整數相乘，相當于多個數據相加；但是dict和set不可以，因為兩者不允許同樣的數據出現！
[1,3,5] * 2
('a','b','c') * 2
'Hello' * 2
# ** 運算符
# 冪運算，與內置函數pow()相同
2 ** 3 = 8
# / 真除法 與 //整數除法
# / 真除法獲得全部值，但是//只會獲得保留整數的數值
5/2 = 2.5
5//2 = 2
# 關系運算符：<（小于）、<=（小于等于）、>（大于）、>=（大于等于）、==（等于）、!=（不等于）；運算結果：布爾值True或False
# 列表比較大小：從左到右逐個元素的依次比較，類似字符串之間的比較，但是需要注意字符串和數字屬于不可比較大小的！
# 測試運算符：in、not in、is、is not；運算結果：布爾值True或False
# in（判斷屬性是否存在）
2 in [2,3,4]
# is（判斷是否是同一對象）
str1 = "abc"
str2 = "abc"
str1 is str2 # False
str1 == str2 # True
# 邏輯運算符:and（與）、or（或）、not（非）;通過邏輯運算符可以將任意表達式連接在一起
# 需要注意：當可以判斷結果時，后面的語句將不再執行
# Python沒有自加++與自減--
Python基本交互語句
我們簡單了解一下Python的輸入輸出語句：
# 首先我們了解一下輸入語句
# input("提示信息")
x = input("請輸入x的值：")
# 然后我們再了解一下輸出語句
# print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
# value：輸出內容
# sep：對象之間的間隔符，默認用一個空格分隔
# end：以什么字符結尾，默認值是換行符
# file：表示輸出位置，可將輸出到文件，默認是控制臺
# flush：將緩存里面的內容是否強制刷新輸出，默認值是False
print('hello','python','!',sep=',', end='!')
# 最后再來了解一個運算語句
# 因為我們在實際使用過程中可能出現數據類型不符合條件的狀況，我們可以采用eval來進行計算獲取值
# eval(source, globals=None, locals=None, /)
# source：字符串，這個字符串能表示成Python表達式，或者是能夠通過編譯的代碼
# globals：可選的參數，默認為None，如果設置屬性不為None的話，就必須是dictionary對象
# locals：可選的參數，默認為None，如果設置屬性不為None的話，可以是任何map對象
# 字符串中是表達式：返回表達式的值
# 字符串中是列表、元組或字典：得到真正的列表、元組或字典
# 字符串中是能夠通過編譯的代碼：執行代碼
eval('x+1') # 表達式：x+1
eval('3+5') #8
eval('[1,2,3]') # 返回列表[1,2,3]
eval("__import__('os').getcwd()") # 執行語句：獲取當前目錄
# 我們通常將input和eval合并使用，因為我們單獨使用input輸入列表等信息時可能出現報錯信息：
x=eval(input("請輸入x值：")) #輸入列表格式：[1,2,3]
x=eval(input("請輸入x值：")) #輸入字典格式：{'a':1,'b':2}
Python內置函數信息
下面我們以表格形式列出內置函數庫：
| 函數 | 功能 |
|---|---|
| abs(x) | 返回數字x的絕對值，如果給出復數，返回值就是該復數的模 |
| eval(s[,globals[,locals]]) | 計算字符串中表達式的值并返回 |
| input(prompt=None, /) | 接受鍵盤輸入，顯示提示信息，返回字符串 |
| len(obj) | 返回對象obj（列表、元組、字典、字符串、集合、range對象）的元素個數 |
| map(func, *iterables) | 包含若干函數值的map對象，其中func表示函數，iterables表示迭代對象，將函數作用于迭代對象 |
| max(x[,y,z…])、min(x[,y,z…]) | 返回給定參數的最大值、最小值，參數可以為可迭代對象 |
| pow(x,y[,z]) | pow()函數返回以x為底，y為指數的冪。如果給出z值，該函數就計算x的y次冪值被z取模的值 |
| print(value, …, sep=’ ‘, end=’\n’) | 輸出對象，默認輸出到屏幕，相鄰數據之間使用空格分隔，結尾以換行符結束 |
| range([start,]end[,step]) | 返回range對象，該對象包含按參數（[start,end)范圍內，step為步長）生成的整數 |
| round(x[,n]) | 返回浮點數x的四舍五入值，若不給出n值，則返回整數；給出n值，則代表舍入到小數點后的位數 |
| sorted(iterable, /, *, key=None, reverse=False) | 返回排序后的列表，其中iterable表示要排序的序列或迭代對象，key表示排序規則，reverse表示升序或降序，默認升序 |
| sum(iterable, start=0, /) | 返回序列iterable中所有元素之和，如果指定起始值start，則返回start+sum(iterable);如果iterable為空，則返回start |
| float(x=0, /) | 把一個數字或字符串轉換成浮點數 |
| int(x[,base]) | 把數字和字符串轉換成一個整數，或把base進制的字符串x轉換為十進制，base為可選的基數，默認為十進制 |
| list([x])、tuple([x])、dict([x])、set([x]) | 將對象x轉換成列表、元組、字典、集合，或生成空列表、空元組、空字典、空集合 |
| chr(i) | 返回Unicode編碼為i所對應的字符，0 <= i <= 0x10ffff |
| ord(x) | 返回一個字符的Unicode編碼 |
Python流程控制
下面我們來介紹Python的流程控制語法
分支流程
我們的分支流程一般采用IF進行分支劃分
下面我們來介紹一下python的基本IF使用方法：
# Python的IF語句和Java完全相同
# 單IF判斷
if x > 5:
print("x>5,符合條件")
# 多IF判斷：
if x < 3:
print("x<3")
elif x > 5:
print("x>5")
# 多IF且ELSE判斷：
if x < 3:
print("x<3")
elif x > 5:
print("x>5")
else:
print("x不滿足條件")
# 注意：Python中不存在switch流程控制
循環流程
我們的循環流程一般采用for或者while進行循環
下面我們來介紹一下python的基本for和while循環使用方法：
# for循環
# for 變量 in 序列或迭代器等可迭代對象:
# 循環體
my_list = [20,30,40]
for i in my_list:
print("i")
# 這里我們補充一個range方法，我們在上面的內置函數信息中也提到了
# range(start, stop[, step])
# 其中start表示起始值，例如0，則說明該數組從0開始
# 其中stop表示停止值，但不能包含stop，例如10，則我們的數組到10之前結束，也就是到9結束
# 其中step表示步數，也就是我們之間相隔的個數，默認為1，即數組從1，2，3...9，但若我們賦值為2，即數組從1，3，5...9
for i in range(0,10):
print("i")
# 此外break和continue在Python中同樣適用
for i in range(0,10):
if i/2==0:
continue # 當i為偶數時，跳過當前循環執行
print("i")
for i in range(0,10):
if i/2==0:
break # 當i為偶數時，直接跳出該循環
print("i")
# while循環
# while循環和Java最基礎的while循環是相同的
# python的while循環是可以添加else語句的
# while 條件表達式:
# 循環體
# else：
# else語句塊
while(i>5):
i = i-1
else:
print("i已經不再大于5") # 但當while是通過break跳出循環時，else不再執行
# 同理，針對for也存在else情況
# for 變量 in 序列或迭代器等可迭代對象:
# 循環體
# else:
# else語句塊
for i in range(0,10):
print("i")
else:
print("range的循環輸出語句已經執行完畢")
Python數據結構
下面我們來介紹Python中使用到的數據結構
序列List
我們首先來介紹序列中的List：
- 列表將由若干數據作為元素的序列放置在一對"[]"中，元素之間以","分隔
- 列表元素可以由任意類型的數據構成。同一列表中各元素的類型可以各不相同
- 列表是可以進行修改的并且允許元素重復
下面我們來介紹序列List的各種操作方法：
# List的創建大致分為兩種
# 直接進行賦值創建或者采用構造方法進行創建
my_list0 = []
my_list1 = [1,"小米手機",10.15]
my_list2 = list()
my_list3 = list([1,3,5])
list_sample=[['I','LOVE','YOU'],['I','HATE','YOU']]
# List的元素獲取
# List的索引和Java數組相同，從0開始，從左到右依次遞增
my_list1[0]
# List的索引存在負數，例如-1就是最后一個元素，可以采用負數進行數據獲取
my_list1[-1]
# Python存在一種特性叫做切片，即從第i個元素到第j個元素
# my_list1[start:stop:step],同理從start開始到stop前面結束，以step為步數進行獲取
my_list[0:1] # 表示第一個元素
my_list[0:3] # 表示第一個元素到第三個元素
my_list[0:3:2] # 表示第一個元素和第三個元素
my_list[-3:-1:2] # 表示倒數第三個元素和倒數第一個元素
# List元素修改
my_list1[0] = 2
my_list1[1] = 123
# List元素修改也可以采用切片形式，當數量不夠時元素被刪除掉
my_list1[0:3] = [1,2,3]
my_list1[0:3] = [1,2]
# del命令
# del屬于命令，用于刪除元素或本體
del my_list0
del my_list1[2]
# List相加
# List相加只會創建新的list，不會影響原有的list
my_list4 = my_list1 + my_list2
my_list4 += ["bike"]
# List相乘
# List只能和整數相乘，相當于n份相同的list相加，創建新的list，不會影響原有數據
my_list5 = my_list4 * 2
# index方法
# index(value[,start=0[,stop]])
# 尋找在start和stop之間的第一個value的下標位置
# start沒指定：則從索引為0的位置開始查找，否則從索引為strat的位置開始查找
# stop沒指定：可以查找到列表最后元素，否則在位于[start, stop)內的索引區間查找。
# 如果找不到匹配項，就會引發異常
res = my_list3.index(3)
# count方法
# 統計某個元素在列表中出現的次數
res = my_list3.count(3)
# append方法
# 追加單個元素到列表的尾部，只接受一個元素
my_list.append(1)
my_list.append(my_list1[0:2]) # 這里添加的是一個list類型，相當于嵌套的list
# extend方法
# 在列表的末尾一次性追加另一個列表中的多個值（只能有一個參數）
my_list.extend(my_list1[0:2]) # 這里添加的是多個數據，相當于添加多個數據
# insert方法
# 將一個元素插入到指定位置
# 兩個參數：第一個參數是索引點，即插入的位置，第二個參數是插入的元素
my_list.insert(0,"第一個數")
# remove方法
# 用于移除列表中與某值匹配的第一個元素；如果找不到匹配項，就會引發異常
my_list.remove("第一個數")
# pop方法
# 移除列表中的一個元素（默認為最后一個元素），并且返回該元素的值（出棧）；可以指定索引位置
# 當不在索引范圍內或者是空列表中，均會觸發異常
my_list.pop()
my_list.pop(0) # 第0個位置的數
# clear方法
# 刪除列表中所有元素，但保留列表對象
my_list.clear()
# reverse方法
# 用于將列表中的元素位置反向存放
my_list.reverse()
# sort方法
# reverse參數：默認為False（升序），若等于True表示降序排序
my_list.sort()
序列Tuple
然后我們來介紹序列中的Tuple：
- 元組是用一對圓括號（）括起、用逗號分隔的多個元素的組合；屬于序列：有順序，可以重復
- 元組是不可更改的，是不可變對象：元組創建之后就不能修改、添加、刪除成員
下面我們來介紹序列Tuple的各種操作方法：
# Tuple的方法和List基本相同，下面有些重復內容不再做注釋解釋
# Tuple的創建方法
# 直接進行賦值創建或者采用構造方法進行創建
tuple4=()
tuple1 = ('a',200,'b',150, 'c',100)
tuple5 = tuple()
# Tuple的訪問方法
tuple1=('train', 'bus', 'car', 'ship', 'subway', 'bicycle')
tuple1[3]
tuple1[-3]
tuple1[0:3:2]
tuple1[-3:-1:2]
# Tuple相加
tuple3 = tuple1 + tuple2
tuple3 += ("新數據")
# Tuple相乘
tuple4 = tuple3 * 2
# 列表–>元組
# tuple()函數：接受一個列表，并返回一個包含同樣元素的元組
my_tuple1 = tuple(my_list1)
# 元組–>列表
# list()函數：接受一個元組，并返回一個包含同樣元素的列表
my_list1 = list(my_tuple1)
字典dict
然后我們來介紹字段dict：
- dict是Python中唯一內建的映射類型；用一對花括號“{”和“}”作為邊界，元素之間以逗號分隔
- 每個元素是一對鍵（key）和值（value），鍵和值之間用英文冒號分隔
- 字典類似于Java的Map，屬于無序且不可出現重復鍵
下面我們來介紹字典dict的各種操作方法：
# 創建字典
# 字典創建分為直接創建，構造方法創建，序列方法創建
# 注意：字典是無序集合，字典的顯示次序由字典在內部的存儲結構決定
my_dict1 = {}
my_dict1 = {"胡桃":10,"鐘離":20,"刻晴":30}
my_dict2 = dict()
my_dict2 = dict({"胡桃":10,"鐘離":20,"刻晴":30})
keys = ["胡桃","鐘離","刻晴"]
values = [10,20,30]
my_dict3 = dict(zip(keys,values))
# 查看字典元素
# 通過key來查找value
my_dict1["胡桃"]
# 修改字典元素
# 通過key來修改value
my_dict1["胡桃"] = 100
# len方法
# 獲得字典的元素個數
my_dict1.len()
# del命令
# 刪除字典元素或者字典本身
del my_dict1
del my_dict1["胡桃"]
# in方法
# 判斷該字段是否是字典的key值
res = "胡桃" in my_dict2
# keys方法 values方法
# 獲得字典的key集合和value集合
my_dict1.keys
my_dict1.values
# items方法
# 獲得字典的items集合（key和value組合的集合）,需要轉換成list或者tuple才能查看
list(my_dict1.items())
tuple(my_dict1.items())
# setdefault方法
# 如果字典中包含參數key對應的鍵，則返回該鍵對應的值
# 否則以參數key的值為鍵，以參數default的值為該鍵對應的值，在字典中插入鍵-值對元素，并返回該元素的值部
my_dict1.setdefault("胡桃") # 返回對應value值
my_dict1.setdefault("胡桃"，20) # default值和value值不同，返回value值
my_dict1.setdefault("小草神") # 不存在這個值，創建該key，由于無value值，該value為None（Java的null）
my_dict1.setdefault("巴爾"，50) # 不存在這個值，創建該key，且value為50
# update方法
# 將另一個字典中的所有鍵值對一次性地添加到當前字典中
# 如果兩個字典中存在有相同的鍵，則以另一個字典中的值更新當前字典
my_dict1 = dict({"胡桃":20,"鐘離":20,"刻晴":30,"wuhu":90})
my_dict2 = dict({"胡桃":10,"鐘離":20,"刻晴":30})
my_dict2.update(my_dict1) # 則胡桃變為20，且新添wuhu字段value為90
# clear方法
# clear()方法將字典中的所有條目刪除，變成空字典
my_dict1.clear()
# pop，popitem方法
# pop()方法能夠彈出并刪除字典中的鍵值對；popitem()方法能夠彈出字典的一個元素，如果字典為空則觸發異常
my_dict1.pop()
my_dict1.popitem()
# get方法
# 返回指定鍵所對應的值，如果鍵不存在則返回默認值。默認值為None，也可以自己指定
my_dict1.get("胡桃")
# 列表與字典之間的轉化：字典–>列表
# 如果直接轉化，則默認是鍵轉化為列表
list(abbreviation)
list(abbreviation.keys())
list(abbreviation.values())
list(abbreviation.items())
# 元組與字典之間的轉化：字典–>元組
# 如果直接轉化，則默認是鍵轉化為列表
tuple(abbreviation)
tuple(abbreviation.keys())
tuple(abbreviation.values())
tuple(abbreviation.items())
集合Set
然后我們來介紹集合Set：
- 集合是一組用{ }括起來的無序,不重復元素，元素之間用逗號分隔
- 元素可以是各種類型的不可變對象
下面我們來介紹集合Set的各種操作方法：
# 集合的創建
# 集合創建分為直接創建，構造方法創建
my_set1 = {1,2,3}
my_set1 = set() # 注意：空集合只能用構造方法創建
my_set1 = set({1,2,3})
# len() 、max()、min()、sum()方法
# 分別對應長度，最大值，最小值，總值
nums = {4,3,8,9,0,-5,7}
len(nums)
max(nums)
min(nums)
sum(nums)
# in
# 判斷某元素是否存在于集合之中，判斷結果用布爾值True或False表示
res = 1 in my_set1
# 并集，交集，差集
# 并集：創建一個新的集合，該集合包含兩個集合中的所有元素
my_set1|my_set2
# 交集：創建一個新的集合，該集合為兩個集合中的公共部分
my_set1&my_set2
# 差集：A-B表示集合A與B的差集，返回由出現在集合A中但不出現在集合B中的元素所構成的集合
my_set1-my_set2
# 并集，交集，差集運算
# union()：相當于并集運算，產生新集合，不對原有集合產生影響
# intersection()：相當于交集運算，產生新集合，不對原有集合產生影響
# difference()：相當于差集運算，產生新集合，不對原有集合產生影響
# update():相當于集合元素合并運算，注意與union()方法的區別,直接將set2的數據放入set1
new_set = my_set1.union(my_set2)
new_set = my_set1.intersection(my_set2)
new_set = my_set1.difference(my_set2)
new_set = my_set1.update(my_set2)
# add方法
# 向集合中添加元素
new_set.add("新數據")
# remove方法
# 從集合中刪除元素，如果集合中沒有該元素，則出錯
new_set.remove("舊數據")
# discard方法
# 從集合中刪除元素，如果集合中沒有該元素，也不提示出錯
new_set.discard("舊數據")
# pop方法
# 從集合中刪除任一元素，并返回該元素；如果集合為空，則拋出KeyError異常
new_set.pop()
# clear方法
# 從集合中刪除所有元素，變成一個空集合
new_set.clear()
字符串Str
我們首先講解一下Str字符串，這里僅講解最基本的內容：
# Str的三種構造方法
# Str可以由構造函數構造，可以直接采用成對的單引號，雙引號，三引號來構造
# 注意：若Str中存在單引號則不可以采用單引號構造，否則會出現字符串提前結束問題，當然也可以采用轉義字符"\"來解決
my_str1 = str("第一個字符串")
my_str2 = '第二個字符串'
my_str3 = "第三個字符串"
my_str4 = "Let's Go!"
my_str4 = 'Let\'s Go!'
# 特殊構造
# 當我們在Str的構造前加一個r，我們就默認內部元素都是原始數據不會被轉義
print(r"c:\test\net")
下面我們去講解一下字符串格式化：
# 字符串格式化：指字符串在編程過程中，允許編碼人員通過特殊的占位符，將相關對應的信息整合或提取的規則字符串
# 1.用 % 符號格式化字符串
# 我們采用%進行占位，常用的包含有%c字符，%s字符串，%d整數，%f浮點數
# 我們首先采用%占位，在字符串末尾采用%+元組的形式進行數據輸入，最后產生對應的數據結果
name='Lily'
age=18
print('我叫%s，今年%d歲'%(name,age))
# 2.format()方法格式化字符串
# format()方法是通過{}和:來代替傳統%方式
# 我們采用{}進行占位，可以采用{}，也可以采用{index}，也可以采用{name}來進行占位
# 然后我們采用format(數據)進行數據輸出，最后產生對應的數據結果
information=['胡桃',18]
'我叫{},今年{}歲'.format('胡桃',18)
'我叫{1},今年{0}歲'.format(18,'胡桃')
'我叫{},今年{}歲'.format(*information)
'我叫{name},今年{age}歲'.format(name='胡桃',age=18)
然后我們去介紹Str字符串的一些常用方法：
# 字符串截取
# 字符串截取采用[]或者切片方法
my_str[0]
my_str[0:5:2]
# len,max,min方法
# 分別獲取長度，最大值，最小值（以Unicode碼為校驗值）
len(s) #字符串長度
max(s) #最大字符
min(s) #最小字符：本處為空格
# ord，chr方法
# 進行Unicode和字符之間的轉換
ord('M') #獲取該字符的Unicode碼 77
chr(77) #把編碼轉換為對應的字符 'M'
# center()、ljust()、rjust()
# 意義：將字符串填充至合適長度，并以中間/左側/右側對齊
# 格式：center(width, fillchar=’ ')
# width:指定寬度
# fillchar:填充的字符，默認為空格
'胡桃'.center(10)
'胡桃'.center(12，"?")
# lower()、upper()
# 意義：將字符串所有字符轉化為小寫字符/大寫字符，并返回新字符串
new_str1 = old_str1.lower()
new_str2 = old_str2.upper()
# capitalize()、title()、swapcase()
# capitalize():將整個字符串首字母轉換為大寫形式，其他字母轉換為小寫形式,返回新字符串
# title():將每個單詞的首字母轉換為大寫形式，其他部分的字母轉換為小寫形式,返回新字符串
# swapcase():將大小寫互換，返回新字符串
new_str1 = old_str1.capitalize()
new_str2 = old_str2.title()
new_str3 = old_str3.swapcase()
# islower()、isupper()、isdigit()
# islower()：測試字符串是否為全小寫,返回True或False
# isupper()：測試字符串是否為全大寫,返回True或False
# isdigit()：測試字符串是否為全數字,返回True或False
res1 = old_str1.islower()
res2 = old_str2.isupper()
res3 = old_str3.isdigit()
# find()、rfind()
# 格式：S.find(sub[, start[, end]])
# 意義：從左側/右側開始尋找第一個對應的字串，從start開始，到end前面結束，尋找sub字符串，默認整個字符串，如果沒有找到則返回-1
res_index = =str1.find("abc")
res_index = =str1.rfind("abc",-5,-1)
# index()、rindex()
# 格式：S.index(sub[, start[, end]])
# 意義：同find完全一樣，但是找不到時會直接拋出異常
res_index = =str1.index("abc")
res_index = =str1.rindex("abc",-5,-1)
# count()
# 格式:S.count(sub[, start[, end]])
# 意義；在字符串S中，查找并返回[start,end)范圍內子串sub出現的次數
res_count = str1.count("ab")
# split()，rsplit()
# 意義：以指定字符為分隔符，從左往右/從右往左將字符串分割開來，并將分割后的結果組成列表返回
# 如果不指定分隔符，實際上表示以任何空白字符（包括連續出現的）作為分隔符,可以添加第二參數指定劃分的最大次數
new_str = "i am apple"
new_list = new_str.split(" ")
# join()
# 意義：join()方法可用來連接序列（list或tuple）中的元素，并在兩個元素之間插入指定字符，返回一個字符串
old_str = 'i am apple'
my_list = s.split()
new_str = " ".join(my_list) # 創建一個空字符進行原字符串的拼接
# replace()
# 格式：replace(old,new,count=-1)
# 意義：查找字符串中old子串并用new子串來替換
# 參數count默認值為-1，表示替換所有匹配項，否則(count為其他值時）最多替換count次；返回替換后的新字符串（原字符串不變）
old_str = "hutao zhongli hutao hutao zhongli"
new_str = old_str.replace("hutao","keqing",2)
# strip()
# 意義：去除字符串兩側的空白字符(空格、回車、制表符等）或指定字符，并返回新字符串
old_str = " i love you "
new_str = old_str.strip()
最后我們介紹一下正則表達式：
# 正則表達式：正則表達式(Regular Expression)是一種文本模式，包括普通字符（例如，a 到 z 之間的字母）和特殊字符（稱為"元字符"），可以用來描述和匹配字符串的特定模式
# 在模式串中常常有特殊字符，為了書寫方便，在字符串前加r前綴，不對其進行轉義
# “.”：表示任意單個字符 (除換行符以外)
# 下述案例中匹配i后面跟除換行符以外的任意字符的形式：必須是兩個字符：第一個是i，第2個是換行符以外的任意字符，可以是空白符
s='hi,i am a student.my name is Hilton.'
re.findall(r'i.',s)
# “[]”：指定字符集
# 用來指定一個字符集合，從字符集合中必須選一個，也只能選一個字符（即單個字符）
# 下述案例中匹配mit或者mwt
s='mat mit mee mwt meqwt'
re.findall(r'm[iw]t',s)
# “^”：匹配行首，匹配每行中以^后面的字符開頭的字符串
# ^ 表示一個字符串的開頭，但它用在一個方括號的開頭的時候，它表示這個字符集是否定的
# 下述案例中匹配所有開頭非a的字符+it的字符串
s='mat mit mee mwt meqwt'
re.findall(r'[^a]it',s)
# “\”：反斜杠后面可以加不同的字符以表示不同的特殊意義（四對）
# \b匹配單詞頭或單詞尾；\B與\b相反，匹配非單詞頭或單詞尾
# \d匹配任何數字字符；相當于[0-9]；\D與\d相反，匹配任何非數字字符，相當于[^0-9]
# \s匹配任何空白字符，相當于[\t\n\r\f\v]；\S與\s相反，匹配任何非空白字符，相當于[^\t\n\r\f\v]
# \w匹配任何字母、數字或下畫線字符，相當于[a-zA-Z0-9_]；\W與\w相反，匹配任何非字母、數字和下畫線字符，相當于[^a-zA-Z0-9_]
迭代器Iterator
我們首先需要了解一個概念：
- 可迭代對象：存放元素的容器，可以被遍歷其中的元素
- 迭代器:可迭代對象（容器）提供的,用于遍歷容器元素的一個工具
我們需要了解可迭代對象：
- 如果一個對象實現了_iter_()方法，那么這個對象就是可迭代(Iterable)對象
對于迭代器其實也是同理：
- 實現了__iter__方法和__next__方法，并且可以通過__next__方法不斷返回下一個值的對象
我們只需要了解對應的內置函數即可：
# enumerate方法
# 格式：enumerate(iterable, start=0)
# 功能：返回下標和值的enumerate對象。
# 參數：第1個參數表示可迭代(Iterable)對象，第2個參數表示下標的開始值，默認從0開始
# 解釋：將容器的每個元素取出來，搭配一個下標
my_list = ["劉備"，"關羽","張飛"]
res = enumerate(my_list)
for i in res:
print(i," ") # 這里輸出的是列表(0,"劉備")...
# zip方法
# 格式：zip(iter1 [,iter2 […]])
# 功能：將多個迭代器(Iterator)對象（或者可迭代(Iterable)對象）中的元素壓縮到一起，返回一個zip對象
# 解釋：將多個容器的逐個對應元素拼合在一起（我們之前在dict章節使用過將keys和values壓縮在一起）
keys = ["胡桃","鐘離","刻晴"]
values = [10,20,30]
my_dict3 = dict(zip(keys,values))
# map方法
# 格式：map(func, *iterables)
# 功能：把一個函數func依次映射到可迭代(Iterable)對象的每個元素上，返回一個map對象。
# 解釋：將每個元素傳入func函數，把結果放入map里
my_list1 = ['1','5.6','7.8','9']
my_list2 = map(float,aa) #將每個元素變為float類型
# filter方法
# 格式：filter(函數名 or None, 可迭代對象)
# 功能：把一個帶有一個參數的函數function作用到一個可迭代(Iterable)對象上，返回一個filter對象。
# 通俗：將容器中的元素用函數過濾一下
my_list1=[5,6,-9,-56,-309,206]
def func(x):
return x%2!=0
over_list=filter(func,my_list1)
Python函數信息
這一章我們來介紹Python的函數
Python函數基本信息
首先我們需要知道函數的定義方法：
def 函數名(形式參數):
函數體
我們對函數需要保證以下條件：
- 函數名必須符合Python標識符的規定
- 形式參數，簡稱為形參，寫在一對圓括號里面，多個形參之間用逗號隔開
- 該行以 冒號結束
- 沒有 返回值 類型
- 函數體是語句序列，左端必須縮進空格
針對于函數的返回的定義方法如下：
# 如果一個函數的定義中沒有return語句，運行時，系統將自動在函數體的末尾插入return None語句
def 函數名(形式參數):
函數體
return 返回數據
當我們需要執行該函數時，我們只需要直接調用該函數并給出參數即可：
def add(x,y):
res = x + y
return res
if __name__ == '__main__':
n = 1
m = 2
res = add(n,m)
print(res)
然后我們再來講解一下函數的位置參數和關鍵字參數:
# 參數傳遞時有兩種方式：位置參數和關鍵字參數
# 我們之前所使用的就是位置參數，而關鍵字參數就是在我們調用時直接采用name進行賦值
def add(x,y):
res = x*2 + y
return res
if __name__ == '__main__':
n = 1
m = 2
res = add(y=m,x=n) # 結果為4，這里是關鍵字傳參
print(res)
下面我們介紹一下函數的默認值：
# 函數的形參可以設置默認值。這種形參通常稱為默認參數
# 若調用時沒有為這些參數提供值：這些參數就使用默認值
# 若調用時有實參：則將實參的值傳遞給形參，形參定義的默認值將被忽略
def 函數名(非默認參數, 形參名=默認值, ……):
函數體
# 我們給出一個例子
def sayHello(s="Hello!",n=2,m=1): #3個都是默認參數
for i in range(1,n+1):
print(s*m)
if __name__ == '__main__':
sayHello(m=2) # 例如這里我們只給m賦值了，那么s就是Hello，n就是2，m是我們賦值的2，然后去執行操作
# 函數定義時，非默認參數與默認參數可以并存，但非默認參數之前不能有默認參數
# 即：非默認參數在前，默認參數在后（下述def就是錯誤示例）
def sayHello(s="Hello!",n,m): # s應該放在n和m的后面
for i in range(1,n+1):
print(s*m)
下面我們繼續介紹Python的可變長度參數：
# 在Python的函數的末尾，我們可以去添加一個可變長度參數
# 函數可以接收不定個數的參數：通過在形參前面使用標識符“*”來實現
def all_1(*args):
print(args) #收集為一個元組
if __name__ == '__main__':
all_1("a") #1個參數
all_1("a"，True，[1,"胡桃"]) #3個參數
# 可變長度參數必須要放在最末尾值，順序如：非默認參數，默認參數，可變長度參數（下面是正確實例）
def all_3(s,*args):
print(s)
print(args)
# Python還提供了一種形參名前面加標識符“**”的方式，用來引用一個字典
def all_4(**args):
print(args) # 收集為一個字典
if __name__ == '__main__':
all_4(x="a",y="b",z=2) #實參：關鍵字參數
# 可變長度字典參數必須要放在最末尾值，順序如：非默認參數，默認參數，可變長度參數，可變長度字典參數（下面是正確實例）
def all_6(a,*my_list,**my_dict):
print(a)
print(my_list)
print(my_dict)
我們還需要注意我們的序列和字典都可以作為參數進行函數傳參：
# 如果使用序列作為實參，則要滿足下列兩個條件之一
# 函數中形參也是序列
# 如果函數中形參是n個單變量，則在實參的序列變量名前加“*”，要求實參序列中的元素個數與單變量形參個數相同
def sum1(args): #形參：序列
print(args)
s=0
for i in args:
s+=i
return s
def sum2(args): #形參：字典
print(args)
s=0
for i in args.keys():
s+=args[i]
return s
if __name__ == '__main__':
aa=[1,2,3] #列表（序列）作實參
print(sum1(aa))
cc={'x': 1, 'y': 2, 'c': 3} #字典變量 作實參
print(sum2(cc))
# 針對于正常的單個數據參數，我們仍舊可以采用序列進行傳參，但是我們需要注意進行解體：
def sum3(x,y,z): #形參：多個單變量
return x+y+z
if __name__ == '__main__':
aa=[1,2,3] #列表
print(sum3(*aa)) #實參為列表變量，加前綴"*"，自動解包，和形參個數相同 6
Python函數進階內容
首先我們先來了解一下生成器函數：
-
生成器其實是一種特殊的迭代器
-
該方法不需要寫iter()和next()方法，只需要在函數中使用一個yield關鍵字以惰性方式逐一返回元素
我們來講解一下生成器的運行：
- 每次遇到yield語句時，函數會暫停執行，并保存當前所有的運行狀態信息
- 返回yield后面的值（相當于return），并在下一次執行next()方法時從當前位置繼續運行
我們給出一個簡單示例：
def fib(n):
i, a, b = 0, 1, 1
while i < n:
yield a #表示：返回a的值，然后暫停在這兒，等著下一次next(繼續從這一行運行)。
a, b = b, a + b
i += 1
#沒有return L語句了,因為已經用yield返回值了
if __name__ == '__main__':
n=int(input('請輸入個數：'))
L=fib(n)
for x in L:
print(x) #1 1 2..
在Python中也存在Lambda表達式，我們也來簡單介紹一下：
- lambda函數是一個匿名函數，有時也被稱為lambda表達式，比def格式的函數定義簡單很多
- Lambda函數可以接收任意多個參數，但只返回一個表達式的值;
- lambda中不能包含多個表達式;
我們給出Lambda表達式的書寫方法：
- 形式參數可以有多個，它們之間用逗號隔開，但是表達式只有一個
- 返回表達式的計算結果
我們同樣給出一個簡單的例子：
f=lambda x,y : x+y #f是lamda函數的名字
f(5,10)
y=list(filter(lambda i : i%2==0, x))
y
Python類與對象
這一章節我們來介紹python中的類和對象
類與對象基本信息
首先我們先介紹一下Python中的對象：
- 在Python中，所有的數據（包括數字和字符串）實際上都是對象，每個對象都屬于某個類型
然后我們延伸到類的概念：
-
在Python中，使用類來定義同一種類型的對象
-
類（class）是廣義的數據類型，能夠定義復雜數據的特性，包括靜態特性和動態特性
-
靜態特性主要指類的屬性，動態特性主要指類的方法，而我們所謂的類其實就是對象的抽象化概念
在目前Python3.0之后的版本中，類都被稱為新式類：
- 新式類都有一個共同的父類——object類
- 所有的類都有父類，并且都直接或間接地繼承自object
我們來講解一下Python中類的基本語法：
# Python中使用class保留字來定義類，類名的首字母一般要大寫
# 類的主要成員包括兩種類型，即描述狀態的數據成員（屬性）和描述操作的函數成員（方法）
class <類名>：
類屬性1
……
類屬性n
<方法定義1>
……
<方法定義n>
# 創建類的對象就需要使用到該類
class Person:
name = "胡桃"
age = 18
if __name__ = '__main__':
new_person = person()
# 類中的屬性可以直接被類中的方法調用，也可以使用對象直接調用public屬性
class Person:
name = "胡桃"
age = 18
def information_self(self):
print(self.name)
if __name__ = '__main__':
new_person = Person()
print(new_person.name)
# 類的屬性被劃分為對象屬性和類屬性
# 類屬性針對整個類都是共享的存儲，在初始化方法__init__()之外定義
# 對象屬性針對每個單獨的對象有單獨的存儲，在初始化方法__init__()之中定義
# 我們給出一個簡單示例
class Teacher:
school = "光明高中" # 這里是類屬性，類屬性在init方法外定義且賦值
def __init__(self,nameSide,ageSide): # 類的所有方法的第一個參數都是self，但是不需要傳值
self.name = nameSide # 這里的name和age就是對象屬性，在init方法中通過外界傳值來進行賦值
self.age = ageSide
def printInformation(self):
print("名稱：{}，年齡：{}"format(self.name,self.age))
if __name__ = '__main__':
new_person = Teacher("胡桃崽崽"，18) # 創建類對象
print(Teacher.school) # 調用類屬性
print(new_person.name) # 調用類對象屬性
new_person.age = 20 # 修改類對象屬性
new_person.printInformation() # 調用類對象方法
# 當然Python和Java一樣是劃分為public，protect和private的
# 沒有以任何下畫線開頭的屬性是public
# “單下畫線” 開始的屬性是protect
# “雙下畫線” 開始的屬性是private
class Person:
def __init__(self,n,y,w,h): #構造方法
self.name=n #定義公有屬性：姓名name和出生年份year
self.year=y
self.__weight=w #定義私有屬性：以千克為單位的體重weight、以米為單位的身高height
self.__height=h
def getWeight(self):
print(self.name,"的體重為",self.weight)
if __name__ = '__main__':
person1 = Person("胡桃崽崽",18,90,160)
# 你可以直接訪問共有屬性
person1.name
# 你訪問不到私有屬性（下述操作會報錯）
person1.__weight
# 但是你可以通過方法獲取
person1.getWeight()
# 上面針對屬性設置的劃分對于方法來說也是有效的
class Book:
def __init__( self,name, author, price):
self.name = name
self.author = author
self.price = price
# 這里以雙下劃線，為private
def __check_name(self):
if self.name == '' : return False
else: return True
def get_name(self):
if self.__check_name():print(self.name,self.author) #本類中，調用私有方法
else:print('No value')
# 然后我們來介紹一下del析構方法
# del()析構方法用于銷毀類的實例，如釋放對象占用的資源
if __name__ = '__main__':
person1 = Person("胡桃崽崽",18,90,160)
person2 = Person("胡桃寶寶",20,80,161)
person3 = person1
# 我們直接去刪除person2是可以刪除成功的，因為person2所指向的對象只有它一個人占有
del person1
# 但當我們去刪除person1是無法將對象進行刪除的，它只會將這個對象的count--，當且僅當count=0時才會真正刪除該對象
# 靜態方法（和Java的靜態方法完全相同）
# 靜態方法的定義之前需要添加“@staticmethod”并且不需要表示訪問對象的self參數
# 靜態方法只能訪問屬于類的成員(類屬性、類方法），一個類的所有實例對象共享靜態方法
# 可以通過“類名.靜態方法名()”來訪問，也可以通過“對象名.靜態方法名()”來訪問
@staticmethod
def 靜態方法名([形參列表])
函數體
類名.靜態方法名([實參列表])
class Person:
number = 0
def __init__(self,n,y,w,h): #構造方法
self.name=n #定義公有屬性：姓名name和出生年份year
self.year=y
self.__weight=w #定義私有屬性：以千克為單位的體重weight、以米為單位的身高height
self.__height=h
number += 1
@staticmethod
def getNumber():
print(number)
if __name__ = '__main__':
person1 = Person("胡桃崽崽",18,90,160)
person2 = Person("胡桃寶寶",20,80,161)
print(Person.getNumber())
# 類方法
# 允許聲明屬于類本身的方法，即類方法
# 類方法中，一般對類本身進行操作,不能對特定實例進行操作，在類方法中訪問對象實例屬性會導致錯誤
# 可以通過“類名.類方法名()”來訪問，也可以通過“對象名.類方法名()”來訪問
@classmethod
def 靜態方法名(cls,[形參列表])
函數體
類名.類方法名([實參列表])
class Foo:
classname = "Foo" #類屬性
def __init__(self, name): #初始化方法
self.name = name
print("init:",self.name)
def f1(self): #實例方法
print("f1():",self.name)
@staticmethod
def f2(): #靜態方法
print("static")
@classmethod
def f3(cls): #類方法：cls實際是Foo類名
print("classmethod",cls.classname) #訪問的是類屬性classname。不能訪問實例屬性。
#self.name
if __name__ = '__main__':
f = Foo("李四") #會調用 初始化方法__init__()
f.f1() #用 對象名.實例方法()
Foo.f2() #用 類名.靜態方法()
Foo.f3() #用 類名.類方法()
類與對象繼承組合
我們通常復用已有的代碼來進行開發，用官方語言來講就是重用
針對Python類主要包含“繼承”和“組合”兩種重用方式
我們首先需要知道Python繼承的一些知識點：
- 繼承是在父類（或稱為基類）的基礎上擴展新的屬性和方法
- Python支持多重繼承，即，一個類可以有多個父類，同時從多個父類中繼承所有特性
下面我們直接去講解Python的繼承語法：
# 首先我們需要知道繼承的基本語法
class ChildClassName(父類名1[, 父類名2[,父類名3, …]]):
類體或pass語句
# 我們還需要注意這些特點：
# 小括號()內為父類，可以有多個父類；
# 如果圓括號中沒有父類，則表示從object類派生；
# 如果只是給出一個定義，尚沒有定義類體時，可以使用pass語句（空語句）代替類體。
# 由于我們這篇文章是基于Java基礎的，所以一些類似的定理我們下面就不再給出示例了
# 子類可以繼承父類的非私有屬性（公有、保護）；針對私有屬性不能繼承也不能訪問
# 子類如果定義了和父類中名稱相同的屬性，父類中的屬性在子類中將被覆蓋
# Python中同樣可以實現方法繼承和方法覆蓋
# 如果需要在子類中調用父類中同名的方法，可以采用如下格式：super(子類類名, self).方法名稱(參數)
然后我們也簡單介紹一下組合：
- 一個類可以包含其他類的對象作為屬性，這就是類的組合
- 在Java的體現其實就是在類中去使用另外一個類
Python文件操作
這一章節我們簡單介紹一下Python的文件操作
Python文件基本操作
我們直接介紹Python中有關文件的對應指令：
# 打開一個文件
# 格式：open(name[, mode [, buffering]])
# name：唯一必須提供的參數，即為文件的路徑
# mode:可選參數，指定讀寫模式,包含w，w+，r，r+等
# buffering：可選參數，緩存大小
# 調用open函數之后，將得到一個文件對象
# Python打開文件常用格式
f = open(r'd:\test.txt') #r前綴
f = open('d:\\test.txt') #反斜杠轉義
f = open('d:/test.txt') #正斜杠
# file.closed屬性
# 用于判斷文件是否關閉，若關閉為True，若未關閉為False
# file.mode屬性
# 返回讀寫類型，就是我們前面的mode參數
# file.name屬性
# 返回文件的名稱信息
# 我們通常采用read()方法讀取，采用write()方法寫入數據
f = open(r'd:\test.txt',r)
f.read()
f.close()
f = open(r'd:\test.txt',w)
f.write('abc')
f.close()
# 在打開文件open時，可以時用with語句，系統會自動關閉打開的流
with open(r'd:\test.txt') as f:
f.read()
接下來我們需要去了解Python文件的mode模式參數：
- r：讀取權限
- w：書寫權限
- a：追寫權限
- b：支持二進制
此外我們需要注意一些特殊組合：
- r+，w+：滿足讀寫權限
- rb，wb：以二進制進行讀取/書寫
- rb+，wb+：以二進制進行讀取和書寫
我們下面再給出一些具體的文件操作：
# write()：寫入部分數據
# w:會新建文件或刪除原有數據，以覆蓋的方式寫入(不能讀取)
f=open('d:\\test.txt','w')
f.write('abc')
f.close()
# a:會以追加的形式寫入文件，不刪除之前的數據(不能讀取)
f=open('d:\\test.txt','a')
f.write('abc')
f.close()
# writelines()可實現逐行寫入給定列表中的所有字符串元素
f = open('d:\\test.txt','a')
a_list = ['胡桃老婆','胡桃貼貼']
f.writelines(a_list)
f.close()
# read():讀取部分數據
# 若括號中無數字，則直接讀取文件中所有的字符
f = open('d:\\test.txt')
f.read()
# 若提供數字，則一次讀取指定數量字節的字符
# 注意：文件內部會有一個指針，每次讀取后該指針都會對應移動
# 例如下述先讀取3個字符，相當于指針移動三位，然后在讀取兩位，相當于讀取第4~5位，以此來達到逐漸讀取所有數據
f = open('d:\\test.txt')
f.read(3)
f.read(2)
# f.readline()可實現逐行讀取字符
# 若括號中無數字，則默認讀取一行
f = open('d:\\test.txt')
f.readline()
# 若括號中有數字，則讀取這一行中對應數量的字符（如果該數字大于這一行的字符數，則讀取這一行所有字符）
# 注意：當讀取該行的部分數據后該行尚未被讀取完畢，則下一個readline仍舊讀取該行
f = open('d:\\test.txt')
f.readline()
f.readline(2)
f.readline()
# f.readlines()可實現讀取一個文件中的所有行，并將其作為一個列表返回
# 但是readlines會將文件數據存放在內存中，若過大可能會導致計算機運行緩慢或其他異常
f = open('d:\\test.txt')
my_lsit = f.readlines()
# 因此我們可以采用其他方法來代替readlines
#方法1：常規循環
f = open('d:\\test.txt')
line = f.readline()
while line:
print(line,end='')
line = f.readline()
f.close()
#方法2：迭代器next
f = open('d:\\test.txt')
for line in iter(f):
print(line,end='')
f.close()
#方法3：直接迭代文件
f = open('d:\\test.txt')
for line in f:
print(line,end='')
f.close()
Python文件進階內容
首先我們先來介紹文件指針：
- 針對每個文件對象都會有一個特定的參數指針來記錄執行到該文件的哪個字符
我們是可以去操作這個指針的：
# seek()
# 格式：f.seek(offset[,where])
# 意義：該方法可以用來指定指針的移動，但是注意不能移動到文件前面的字節
# offset：移動的偏移量，如果offset取正值，則往文件尾方向移動；如果offset取負值，則往文件頭方向移動
# where：定義了指針位置的參照點，若where缺省，其默認值為0，即文件頭位置；取值為1，即為當前指針位置；取值為2，即為文件末尾
f = open('d:\\test.txt','rb')
f.seek(3) #從頭前移3個字節：返回值是目前的指針的位置3
f.read(3) #讀取3個字節，讀取指針會后移
f.read(2) #讀取2個字節
f.seek(-3,1) #從當前位置后退3個字節：返回移動后指針所在的位置5
f.read() #讀取剩余全部字節
接下來我們去講解一下Object對象和JSON在Python中的轉換方法：
- JSON和Python的各種組合數據結構的格式是一樣的，因此轉換方法也非常簡單
我們給出對應代碼展示：
# dumps(obj)：把obj對象序列化為JSON字符串
# dump(obj, fp)：把obj對象序列化為JSON字符串，再寫入到文件fp
# loads(s)：把JSON字符串s反序列化后的對象
# load(fp)：從文件fp中讀取JSON字符串反序列化后的對象
#【例】對象JSON格式系列化示例
import json
#列表
data = [{'a': 'A', 'b': (2, 4), 'c': 3.0}]
str_json = json.dumps(data)
#輸出：'[{"a": "A", "c": 3.0, "b": [2, 4]}]'
str_json
data1 = json.loads(str_json)
#輸出：[{'a': 'A', 'c': 3.0, 'b': [2, 4]}]
data1
Python異常處理
最后我們來介紹Python的異常處理機制
Python異常基本信息
首先我們需要知道什么是異常：
- 異常是在程序執行過程中發生的影響程序正常執行的一個事件
而針對異常，Python給出了一套處理機制：
- 將出現的錯誤信息封裝為對應的異常對象
- 將該異常對象拋出去（目的：正常流程代碼和異常處理代碼分離開，不干擾正常處理流程）
- 匹配（捕獲）拋出的異常對象，由能處理該異常的代碼來處理
- 若本方法不能處理，則繼續拋給調用方，直到能夠處理，或者，到最后，拋到操作系統（停止該程序）
下面我們來講解Python處理異常的具體代碼：
# 下述代碼針對輸入的價格來做判斷
# 若為數字順利執行，若非數字產生ValueError異常，進入except運行欄中,處理完異常后，繼續執行下面的語句
try:
price=float(input("請輸入價格："))
print('價格為:%5.2f' % price)
except ValueError:
print('您輸入的不是數字。')
print("接下來的代碼...")
# 我們給出一個簡單的模板
try:
<可能出現異常的語句塊> # 自動拋出標準異常類的對象
raise 自定義的異常類名字() # 或者 主動創建并拋出 自定義異常類的對象
except <異常類名字name1>:
<異常處理語句塊1> #如果在try部份引發了'name1'異常，執行這部分語句塊
except <異常類名字name2> as e1： #將拋出的異常對象傳給e1（處理語句需要其中的信息）
<異常處理語句塊2> #如果在try部份引發了'name2'異常，執行這部分語句塊
except < (異常類名字name3, 異常類名字name4, …)> as e2: #本塊可以處理多種異常類對象
<異常處理語句塊3> #如果引發了'name3'、'name4'、…中任何一個異常，執行該語句塊
…
except:
<異常處理語句塊n> #如果引發了異常，但與上述異常都不匹配，執行此語句塊
else: #如果沒有上述所列的異常發生，執行else語句塊
<else語句塊>
finally: #無論有無異常，都需要執行的語句塊
<任何情況下都要執行的語句塊>
Python特有機制斷言
首先我們來簡單了解一下斷言：
-
斷言是一種除錯機制，用于驗證代碼是否符合編碼人員的預期
-
斷言如果是正確的則無任何響應，但若是錯誤的就會拋出異常
我們給出斷言的語法：
# 格式：assert expression [, arguments]
# expression：運算公式
# arguments：異常提示信息
# 表達式正確，--> 斷言成功 --> 不采取任何措施
assert 2==1+1
# 表達式錯誤, -->斷言失敗 --> 拋出異常信息
assert 2==1*1，"運算結果錯誤"
結束語
這篇文章中詳細介紹了Python的基本語法和一些特征 ，希望能為你學習第二語言帶來幫助
附錄
下面給出我學習和書寫該篇文章的一些參考文章，大家也可以去查閱：
- CSDN筆記：【精選】Python復習筆記———超詳細_python復習筆記我是娜托_我是哪托的博客-CSDN博客
- CSDN筆記：【精選】Python基礎筆記（全）_python速成筆記_Noria 107的博客-CSDN博客
- 黑馬課程：黑馬程序員Python自動測試教程，python從基礎到UnitTest框架管理測試用例_嗶哩嗶哩_bilibili
總結
以上是生活随笔為你收集整理的一篇文章带你掌握测试基础语言——Python的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Go 接口-契约介绍
- 下一篇： Python 机器学习入门：数据集、数据