Python測試之道——筆記1

　　引言

　　若是利用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. 塊註釋和行註釋，使用#號來註釋。

　　語法規範總結：

　　規範有不少，平時使用注意如下幾點就行：

　　一、換行和縮進

　　二、模塊導入

　　三、註釋

　　更多瞭解，能夠參考官方文檔：https://www.python.org/dev/peps/pep-0008/

　　變量與變量類型

　　變量定義：你們知道程序是用來處理數據的，而變量是用來存儲數據的。python中變量不須要聲明類型，能夠存儲任何值，每一個變量在內存中被建立，

　　變量賦值之後該變量纔會被建立。基於變量的數據類型，解釋器會分配指定內存，並決定什麼數據能夠被存儲在內存中。

　　等號（=）用來給變量賦值。

　　python五種標準的數據類型：

　　一、Numbers（數字）

　　二、String（字符串）

　　三、List（列表）

　　四、Tuple（元組）

　　五、Dictionary（字典）

　　六、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中運算符主要有:

　　一、算術運算符

　　二、比較(關係)運算符

　　三、賦值運算符

　　四、邏輯運算符

　　五、位運算符

　　六、成員運算符

　　七、身份運算符

　　常用的是賦值、算術，比較這三種，固然在斷言的時候，會使用成員運算符。判斷兩個變量是不是相同的標識(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位）。

　　函數

　　一、函數的定義：什麼是函數呢？ 

　　其實函數就是一段代碼的集合，裏面是有不少方法和內容，能夠重複調用的。主要是內置函數和自定義函數。

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

　　python主要的內置函數以下：

　　

 

　　二、函數的返回值。

　　這主要是咱們本身定義的函數，如：

#!/usr/bin/python3
 
# 可寫函數說明
def sum( arg1, arg2 ):
   # 返回2個參數的和."
   total = arg1 + arg2
   print ("函數內 : ", total)
   return total
 
# 調用sum函數
total = sum( 10, 20 )
print ("函數外 : ", total)

　　三、函數的參數。

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

　　位置參數：

　　調用函數時，傳入實參的值按照位置順序以此賦給形參。下面這個函數中的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")

　　四、函數嵌套

 　　在函數中再定義一個函數，就叫作嵌套函數。嵌套函數能夠訪問包圍範圍內的變量。

　　如圖：

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

　　

　　總結

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