引言

如果利用python做自動化測試的話，一些python相關的基礎知識是必須要掌握的。常用的比如：python代碼規范、變量與數據類型、運算、函數和字符串處理等。

語法規范

這里只介紹重點和常用的一些注意事項。

在使用python編碼的時候，我們應該嚴格按照pep8的規范來要求自己，這樣不僅僅提高代碼的可讀性，同時也提高了自己編碼的整體水平。

重點關注：

1. python不像java一樣，代碼以分號結束，python一條命令一行代碼，沒有分號。

2.每行的長度不超過80個字符。這里是除導入較長的模塊和注釋里的內容。

3.python的隱式連接是使用()、[]和{}。 切記不要使用反斜杠來連接行。

不推薦這種：

a = "這是一個超長的字符串" \

"這是一個很長的字符串"

print(a)

我們使用這種：

b = ("這是一個超長的字符串"

"這是一個很長的字符串")

print(b)

4.使用4個空格作為縮進代碼，不要使用tab鍵。

5.類與方法之間需要空一行，定級定義之間空兩行，其他保持一行就可以了。

6.括號內不要有空格。

7.如果一個類不繼承其他的類，就顯示的從object繼承，嵌套也一樣。

推薦使用:

class TestClass01(object):

pass

不要使用這種:

class TestClass01:

pass

8.字符串合并使用+，不要使用%s%s，字符串打印使用format格式化，不要使用+

如：

# 推薦

a = "a" + "b"

b = "{},{}".format(1,2)

c = "key1: %s, key2: %d"%("aa",2)

d = "key1: {}, key2: {}".format("python",1)

print(a)

print(b)

print(c)

print(d)

# 不推薦

a = "%s%s" % ("a","b")

b = "{}{}".format(1,2)

c = "key1: aa" + ", " + "key2: 2"

d = "key1: " + "python" + ", " + "key2: " + str(1)

print(a)

print(b)

print(c)

print(d)

執行結果：

ab

1,2

key1: aa, key2: 2

key1: python, key2: 1

ab

12

key1: aa, key2: 2

key1: python, key2: 1

Process finished with exit code 0

9.導入的格式，每個導入應該單獨占一行，

# 推薦

import os

import sys

# 不推薦

import os,sys

10.?塊注釋和行注釋，使用#號來注釋。

語法規范總結：

規范有很多，平時使用注意以下幾點就行：

1、換行和縮進

2、模塊導入

3、注釋

更多了解，可以參考官方文檔：https://www.python.org/dev/peps/pep-0008/

變量與變量類型

變量定義：大家知道程序是用來處理數據的，而變量是用來存儲數據的。python中變量不需要聲明類型，可以存儲任何值，每個變量在內存中被創建，

變量賦值以后該變量才會被創建。基于變量的數據類型，解釋器會分配指定內存，并決定什么數據可以被存儲在內存中。

等號(=)用來給變量賦值。

python五種標準的數據類型：

1、Numbers(數字)

2、String(字符串)

3、List(列表)

4、Tuple(元組)

5、Dictionary(字典)

6、Set(集合)

Python3 的六個標準數據類型中：

不可變數據(3 個)：Number(數字)、String(字符串)、Tuple(元組)；

可變數據(3 個)：List(列表)、Dictionary(字典)、Set(集合)。

Python 數字

當指定一個值(數字)，數字對象就被創建：

var = 1

print(var)

python有四種不同的數字類型：

int(有符號整型)

long(長整型[也可以代表八進制和十六進制])

float(浮點型)

complex(復數)

Python字符串

字符串轉換

# 字符轉換

str(x) # x為任意數據類型

# 字符串合并

a = 123

b = "123"

print(str(a) + b)

# 字符串截取

a = "a=abc,b=123,abcd,(1,2,3)"

print(a.split(','))

print(a.split(',', 2))

print(a.split(',')[1].split('=')[1])

#字符串替換

a = "a=abc,b=123,abcd,(1,2,3)"

print(a.replace(',', ':'))

print(a.replace(',', ':', 2))

print(a.replace(',', ':', 3))

b = a.replace(',', ':', 3)

print(b)

Python 列表

List(列表)是python中使用最頻繁的數據類型

列表可以完成大多數集合類的數據結構實現，它支持字符，數字，字符串甚至可以包含列表(即嵌套)。

列表用?[ ]?標識，是 python 最通用的復合數據類型。列表中值的切割也可以用到變量?[頭下標:尾下標]

一個完整的切片表達式包含兩個“:”，用于分隔三個參數(start_index、end_index、step)。當只有一個“:”時，默認第三個參數step=1；當一個“:”也沒有時，start_index=end_index，表示切取start_index指定的那個元素。

切片操作基本表達式：object[start_index:end_index:step]

step：正負數均可，其絕對值大小決定了切取數據時的‘‘步長”，而正負號決定了“切取方向”，正表示“從左往右”取值，負表示“從右往左”取值。當step省略時，默認為1，即從左往右以步長1取值。“切取方向非常重要！”“切取方向非常重要！”“切取方向非常重要！”，重要的事情說三遍！

start_index：表示起始索引(包含該索引對應值)；該參數省略時，表示從對象“端點”開始取值，至于是從“起點”還是從“終點”開始，則由step參數的正負決定，step為正從“起點”開始，為負從“終點”開始。

end_index：表示終止索引(不包含該索引對應值)；該參數省略時，表示一直取到數據“端點”，至于是到“起點”還是到“終點”，同樣由step參數的正負決定，step為正時直到“終點”，為負時直到“起點”

"""列表"""

a = [1,2,"python",(3,"aa")]

# 刪除

a.remove("python")

print(a)

# 新增

a.append(4)

print(a)

a.insert(1,"java")

print(a)

# 修改

a[2] = "python"

print(a)

# 合并

b = [5,6,7]

a.extend(b)

print(a)

b = b + a

print(b)

Python 元組

元組不可修改，使用小括號()存儲數據，元素之間使用逗號分隔。

a = (1, "a", (3, "python"))

print(a[0])

print(a[1])

print(a[2])

print(a[-1])

print(a[2][-1])

print(a[-1][0])

print(a[1:-1])

Python 字典

列表是有序集合，而字典是無序集合。兩者區別，字典表現形式是{},并且通過鍵來存取的，而列表是通過偏移存取。

字典是一種映射類型，字典用?{ }?標識，它是一個無序的?鍵(key) : 值(value)?的集合。鍵(key)必須使用不可變類型。

在同一個字典中，鍵(key)必須是唯一的。

"""字典"""

a = {'a':1,'b':2,'c':3}

print(a)

# 刪除

del(a['a'])

print(a)

b = {'a':4,'d':5}

# 更新

a.update(b)

print(a)

Python 集合

使用大括號?{ }?或者?set()?函數創建集合，注意：創建一個空集合必須用set()?而不是?{ }，因為?{ }?是用來創建一個空字典。

# 集合

test = {1,2,3,"python","java","python"}

# 輸出元素，重復的自動去掉

print(test)

# 增加元素

test.add("php")

print(test)

# 增加多個

test.update([4,5,6])

print(test)

# 刪除元素

test.remove(6)

print(test)

a = set('abc')

b = set('abcde')

print(a)

print(a - b) # 差集

print(b - a)

print(a | b) # 并集

print(a & b) # 交集

print(a ^ b) # a與b不同時存在的元素

# 成員關系判斷

member = {"python","php","java","c#"}

if "python" in member:

print("python在集合中")

else:

print("不在集合中")

運算符

自動化測試中，經常使用運算符，對數據進行處理。

python中運算符主要有:

1、算術運算符

2、比較(關系)運算符

3、賦值運算符

4、邏輯運算符

5、位運算符

6、成員運算符

7、身份運算符

經常使用的是賦值、算術，比較這三種，當然在斷言的時候，會使用成員運算符。判斷兩個變量是否是相同的標識(id)，可以使用身份運算符。

當然，條件判斷的時候，還會使用邏輯運算符。

# and和or 左右兩邊不一定是布爾類型，有可能是表達式，and左邊為真時，才會去算右邊的值，or左邊為真時，就不會去算右邊的值，not右邊值為假才會返回真。

# 0為False , 1為True

a = 1

b = 2

c = 0

print(a and b)

print(a or b)

print(not a)

print(bool(a))

print(a and c)

print(bool(c))

print(c or b)

print(a and b and c)

if a > 0 and b:

print(a)

字符串

python使用時，字符串是非常頻繁的一個數據類型。

創建方式：使用''或""，即可。

訪問方式：通過[]來截取。

# 字符串合并

a = 123

b = "123"

print(str(a) + b)

# 字符串截取

a = "a=abc,b=123,abcd,(1,2,3)"

print(a.split(','))

print(a.split(',', 2))

print(a.split(',')[1].split('=')[1])

# 字符串替換

a = "a=abc,b=123,abcd,(1,2,3)"

print(a.replace(',', ':'))

print(a.replace(',', ':', 2))

print(a.replace(',', ':', 3))

b = a.replace(',', ':', 3)

print(b)

# 訪問

a = "adfa_2323"

print(a[:-2])

在需要在字符中使用特殊字符時，python 用反斜杠?\?轉義字符，使用最頻繁的是：

# 續行符

print("test \

test")

# 反斜杠

print("\\")

# 換行

print("test\ntest")

# 響鈴

print("\a")

# 單引號

print('\'')

# 雙引號

print("\"")

字符串前面使用r，是顯示原始字符串，不是轉義

字符串前面使用u，一般是中文使用u，進行unicode編碼時，防止中文亂碼。

字符串前面使用b，是bytes字節串類型。

a = u"中國"

print(a)

b = r"fadfa\\"

print(b)

c = bytes("中國",encoding='utf8')

print(c)

d = c.decode()

print(d)

輸出結果：

中國

fadfa\\

b'\xe4\xb8\xad\xe5\x9b\xbd'

中國

在Python3中，所有的字符串都是Unicode字符串(16位)。

函數

1、函數的定義：什么是函數呢？

其實函數就是一段代碼的集合，里面是有很多方法和內容，可以重復調用的。主要是內置函數和自定義函數。

平時我們使用print，其實就是python的內置函數。

python主要的內置函數如下：

2、函數的返回值。

這主要是我們自己定義的函數，如：

#!/usr/bin/python3

# 可寫函數說明

def sum( arg1, arg2 ):

# 返回2個參數的和."

total = arg1 + arg2

print ("函數內 : ", total)

return total

# 調用sum函數

total = sum( 10, 20 )

print ("函數外 : ", total)

3、函數的參數。

主要分為四種：位置參數，默認參數，不定長參數(可變和關鍵字參數)

位置參數：

調用函數時，傳入實參的值按照位置順序以此賦給形參。下面這個函數中的x和n就是位置參數。

def power(x, n):

s = 1

while( n ):

n = n - 1

s = s * x

return s

默認參數：

python的函數同時還允許你給函數的參數設置默認值，當調用者沒有給出參數的值時自動使用默認值。設置默認參數時要注意，必選參數必須在默認參數之前。

def power(x, n = 2):

s = 1

while( n ):

n = n - 1

s = s * x

return s

注意：默認參數必須指向不可變對象，否則會發生不可預知的錯誤。

可變參數：

在Python函數中還可以定義可變的參數，參數的個數可以是任意個，定義參數時，只需要在參數的前面加一個 * 符號即可。

def N(×num):

s = 1

for n in num:

s = s * n

return s

A = N(1,2,3,4,5,6,7,8,9,10) #A = 3628800

關鍵字參數(keyword argument)：

python的關鍵字參數允許你傳入任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝為一個dict。傳入關鍵字參數的時候必須指定參數的名稱(參數名由調用者自行取定)，否則該參數會被認為是位置參數從而報錯。

def keyword_params(**kwargs):

return kwargs

keyword_params(key1="values1",key2="values2")

可變和關鍵字參數混搭：

def test_fuc(*args,**kwargs):

print(args,111)

print(kwargs,222)

test_fuc(1,2,3,key1="values")

注意事項:

*args與**kwargs的區別，兩者都是python中的可變參數。

*args表示任何多個無名參數，它本質是一個tuple；

**kwargs表示關鍵字參數，它本質上是一個dict；

如果同時使用*args和**kwargs時，必須*args參數列要在**kwargs前。

在這個場景下使用這兩個關鍵字。其實并不是必須寫成*args 和**kwargs。??*(星號)才是必須的. 你也可以寫成*ar 和**k. 而寫成*args 和**kwargs只是一個通俗的命名約定。

關鍵字和位置參數混搭：

def person(name, age, **kw):

print('name:', name, 'age:', age, 'other:', kw)

preson("J",33,city = "Beaijing",job = "Engineer")

4、函數嵌套

在函數中再定義一個函數，就叫做嵌套函數。嵌套函數可以訪問包圍范圍內的變量。

如圖：

def add_test(a,b):

c = a + b

def ride_test(x):

x = x*x

print(c)

return x

return ride_test(c)

print(add_test(1, 2))

這里嵌套會涉及一個閉包概念，閉包就是把內部函數作為一個變量來使用。

我們可以將閉包理解為一種特殊的函數，這種函數由兩個函數的嵌套組成，且稱之為外函數和內函數，外函數返回值是內函數的引用，此時就構成了閉包。

格式如下：

def 外層函數(參數):

def 內層函數():

print("內層函數執行", 參數)

return 內層函數

內層函數的引用 = 外層函數("傳入參數")

內層函數的引用()

簡單的一個閉包案例：

def outter(x):

def inner(y):

return x + y

return inner

test = outter(2)

print(test(3))

閉包也叫工廠函數，它的作用如下：

a：記憶外層作用域中的值；

b：可以保護變量不被修改；

c：可以讓一個變量常駐內存；

內函數中修改外函數的值：

def outter(x):

a = 100

def inner(y):

nonlocal a

a = 200

return x + y + a

return inner

test = outter(2)

print(test(3))

這個結果是205，而不是105。

一般在函數結束時，會釋放臨時變量，但在閉包中，由于外函數的臨時變量在內函數中用到，此時外函數會把臨時變量與內函數綁定到一起，這樣雖然外函數結束了，但調用內函數時依舊能夠使用臨時變量，即閉包外層的參數可以在內存中進行保留

如果想要在內函數中修改外函數的值，需要使用 nonlocal 關鍵字聲明變量。

在看一個典型的裝飾器原型：

import time

def showtime(func):

def wrapper(x):

s_time = time.time()

func()

e_time = time.time()

print('speed is {}'.format(e_time - s_time))

return x

return wrapper

def wait():

print('waiting...')

time.sleep(3)

foo = showtime(wait)

print(foo(3))

運行結果：

waiting...

speed is 3.000234603881836

3

總結

有興趣加入測試交流群，歡迎測開愛好者加入我們~

總結

以上是生活随笔為你收集整理的python测试之道pdf百度云_Python测试之道——笔记1的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。