一，基本類型
類型一
檢視資料類型的方法
type :檢視資料類型 type(變量名)
ctrl+滑鼠左鍵：放在需要檢視的變量上可知詳細内容–源碼
help(type(變量名))： --目前的控制台
dir:檢視類下方法名字
數字類型
int(整型)
float(浮點型)
相同類型下整數要比浮點數快
complex(複數)
int float complex 都不可以修改
數字類型的互相轉化
a=2
b=3.14
c='2'
print("a的類型為",type(a))
print("b的類型為",type(b))
print("c的類型為",type(c))
#轉換為整數
d=int(b)
#轉換為浮點數
f=float(a)
#轉化為複數
e=complex(a) 注意：若傳入兩個參數，前後都不允許是字元串類型的數字
其他類型
布爾值(bool)： True和False
——字元串——
單引号，雙引号構成的
雙引号包含單引号 例如：c="a’b’c"包含了：a ’ b ’ c 多種字元
索引（下标） 反向索引
長度（len）
切片：a[頭：尾：步長] 切片時下标標頭不包尾，切片時是從前向後，反向時也一樣
——字元串的功能集——
| capitalize() | str | 首字母變大寫 | S.capitalize() |
|---|---|---|---|
| casefold() | str | 小寫 | S.casefold() |
| center(width[, fillchar]) | str | 内容居中，width：總長度；fillchar：空白處填充内容 | S.center(20,’*’) |
| count(sub[, start[, end]]) | int | 子序列個數 | s.count(‘a’) or s.count(‘a’,0,10) |
| endswith(suffix[, start[, end]]) | bool | (字元串中大于等于start小于end的位置)是否以 xxx 結束 | s.endswith(‘e’) or s.endswith(‘e’,0,6) |
| expandtabs(tabsize=8) | str | 将tab轉換成空格，預設一個tab轉換成8個空格 | s.expandtabs() or s.expandstabs(20) |
| find(sub[, start[, end]]) | int | 尋找子序列位置，如果沒找到，傳回 -1 | s.find(‘e’) |
| format(*args, **kwargs) | str | 字元串格式化，動态參數,講函數式程式設計時細說 | “hello{0},age(1)".format(‘china’, 69) |
| index(sub[, start[, end]]) | int | 子序列位置，如果沒找到，報錯，參考find |
| 方法名 | 傳回值 | 含義 | 案例 |
|---|---|---|---|
| isalnum() | bool | 是否是字母和數字 | |
| isalpha() | bool | 是否是字母 | |
| isdigit() | bool | 是否是數字 | |
| islower() | bool | 是否小寫 | |
| isspace() | bool | 是否空格 | |
| istitle() | bool | 是否标題 | |
| isupper() | bool | 是否大寫 | |
| join(iterable) | str | 清單拼接為字元串 | li = [“hello”,“world”] s ="-".join(li) |
| ljust(width[, fillchar]) | str | 内容左對齊，右側填充，參考center | |
| lower() | str | 變小寫 | |
| lstrip([chars]) | str | 移除左側空白 | |
| rstrip([chars]) | str | 移除右側空白 | |
| strip([chars]) | str | 移除兩側空白 |
| 方法名 | 傳回值 | 含義 | 案例 |
|---|---|---|---|
| partition(sep) | tuple | 将字元串分割為前，中（sep），後三部分 | “hello-world”.partition("-") 傳回;(‘hello’, ‘-’, ‘world’) |
| replace(old, new[, count]) | str | 替換 | “hello-world”.replace(’-’, '/’) 傳回：'hello/world’ |
| split(sep=None, maxsplit=-1) | list | 分割， maxsplit最多分割幾次 | “hello-world”.split("-") 傳回;[‘hello’, ‘world’] |
類型二
一，清單 (list)
清單是有序的可變的元素集合 。
像字元串值用引号來标記字元串的起止一樣，清單用左方括号開始，右方括号結束，即 [ ]。清單中的值也稱為“表項”。
索引，切片，長度，循環與字元串一緻
添加：append(object) extend(iterable) insert(index, object) 單純的 + 号
删除：pop([index]) remove(value) clear()
循環：for
| 方法名 | 傳回值 | 含義 | 案例 |
|---|---|---|---|
| append(object) | None | 追加 | L.append(“d”)print(L) |
| clear() | None | 清除 | L.clear() |
| copy() | list | 拷貝 | L.copy() |
| count(value) | int | 子元素個數,同字元串 | |
| extend(iterable) | None | 批量添加 | L1.extend(L2)print(L1) |
| index(value, [start, [stop]]) | int | 子元素位置 同字元串 | |
| insert(index, object) | None | 插入 | L.insert(1, “d”)print(L) |
| pop([index]) | item | 移除清單最後一個元素，并可将該元素指派給新的變量 | a = L.pop()print(L)print(a) |
| remove(value) | None | 移除左邊開始第一個指定元素 | L.remove(“b”)print(L) |
| reverse() | 倒置(不是排順序，僅反轉) | ||
| sort(key=None,reverse=False) | None | 排序 |
二，字典（dict）
字典是由鍵值對構成（key、value）的無序集合（不像字元串、清單和元祖那樣有固定的位置）
鍵（key）的資料類型一般為數字或字元串，且必須是唯一的，不能重複。值（value）可以是任意資料類型。
字典使用大括号{ }。
——特性——
-
鍵(key)唯一性 ：字典中的鍵(key)具有唯一性，不存在兩個相同的鍵(key)
無序性：字典中的鍵也是無序的，是以不能通過索引取值
可變性：字典是可變對象，但是字典的鍵(key)必須是不可變對象
長度：len()
鍵、值、鍵值對：
# 鍵、值、鍵值對
D = {
'k1': 'v1',
'k2': 'v2',
'k3': 'v3',
}
# items
# keys
# values
print(D.items()) # dict_items([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
print(D.keys()) # dict_keys(['k1', 'k2', 'k3'])
print(D.values()) # dict_values(['v1', 'v2', 'v3'])
擷取值：
# 通過key取value
print(D['k2'])
# get
print(D.get('k3'))
print(D.get("k4")) # None
print(D.get("k4", 'false')) # false
# setdefault()：key有則取，無則增
print(D.setdefault('k3'))
print(D.setdefault("k4")) # None
print(D) # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': None}
print(D.setdefault("k5", "v5")) # v5
print(D) # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': None, 'k5': 'v5'}
新增：
# 同上setdefault：如果key不存在，則建立，如果存在，則傳回已存在的值且不修改，類似get（）
print(D.setdefault("k5", "v8"))
print(D) # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': None, 'k5': 'v5'}
# 通過key修改
D['k2'] = 'v8'
print(D)
D['k6'] = "v6"
print(D) # {'k1': 'v1', 'k2': 'v8', 'k3': 'v3', 'k4': None, 'k5': 'v5', 'k6': 'v6'}
删除：popitem() clear() pop(k[,d])
循環：for k,v in x.items(): 注意鍵值對
print(k,v)
| 方法名 | 傳回值 | 含義 | 案例 |
|---|---|---|---|
| clear() | None | 清除内容 | D.clear() |
| copy() | dict | 拷貝 | D.copy() |
| fromkeys() | dict | 建立字典的一種方法 | L = [1, 2, 3] print(D.fromkeys(L)) print(D.fromkeys(L, ‘v’)) |
| pop(k[,d]) | dict | 擷取并在字典中移除指定key值項 | a = D.pop(‘k2’) print(a) print(D) |
| popitem() | dict | 擷取并在字典中移除最後一項 | a = D.popitem() print(a) print(D) |
| get(k[,d]) | 根據k擷取值，d是預設值，k不存在傳回預設 | print(D.get(‘k4’, ‘false’)) | |
| items() | 所有項的鍵值對形式（非真正意義上的list） | print(D.items()) | |
| keys() | 所有的key清單形式 | print(D.keys()) | |
| values() | 所有的值 | print(D.values()) | |
| setdefault(k[,d]) | 如果key不存在，則建立，如果存在，則傳回已存在的值且不修改，類似get（） | print(D.setdefault(‘k4’, ‘v4’)) print(D) | |
| update([E, ]**F) | None | 把字典E的鍵/值對更新(添加）到dict裡（key值相同更新，不同則添加） | F.update(D) print(F) |
三，元祖（tuple)
注意：單元組元素帶逗号 t=(1,)
元組的索引，切片，長度，循環，包含以上方法使用同清單一緻
元組是有序的不可變的元素集合 。
元組與清單幾乎一樣，元組使用小括号，清單使用方括号。
但清單可以修改（追加，移除，删除），元組不能修改!
元組是不可變對象，如果需要改變，轉化成清單即可元組中隻有 count 和 index 方法，友善查找元組中的資料
循環：for
| 方法名 | 傳回值 | 含義 | 案例 |
|---|---|---|---|
| count(value) | int | 子元素個數,同清單 | print(T.count(“a”)) |
| index(value, [start, [stop]]) | int | 子元素位置 同清單 | print(T.index(“b”)) |
四，集合（set）
s=set()------空集合定義
集合自動去重
集合變量初始化：元素類型同清單，元素可以使用任何資料類型
一個包含唯一進制素的不可變和無序的集合資料類型。
集合的一個用途是快速删除清單中的重複項。
集合中的元素是不可變的類型
集合使用大括号{ }。
同數學上的集合類似，也有交集、并集、子集的數學運算
——特性——
-
唯一性：集合中的元素具有唯一性，不存在兩個相同的元素
無序性：集合中的元素是無序的，是以沒有存在索引
可變性：集合是可變對象
添加：add() uodate()
删除：remove() pop() discard()
交集：兩個set的共同的部分 使用 s1 & s2
并集：由所有屬于set A 或屬于set B 的元素所組成的 set ,叫做AB的并集 使用 s1 | s2
補集：屬于前set，不屬于後面set的元素組成的set 使用 s1 - s2
去重：集合自動去重
| 數學符号 | python運算符 | 含義 | 定義 |
|---|---|---|---|
| ∩ | & | 交集 | 一般地,由所有屬于A且屬于B的元素所組成的集合叫做AB的交集. |
| ∪ | | | 并集 | 一般地,由所有屬于集合A或屬于集合B的元素所組成的集合,叫做AB的并集 |
| -或\ | - | 相對補集/差集 | A-B，取在A集合但不在B集合的項 |
| ^ | 對稱差集/反交集 | A^B，取隻在A集合和隻在B集合的項，去掉兩者交集項 |
功能表
| 方法名 | 傳回值 | 含義 | 案例 |
|---|---|---|---|
| add() | set | 增加 | S.add(11) print(S) |
| clear() | set | 清空成為空集合 | S.clear() print(S) |
| copy() | set | 複制 | S1 = S.copy() print(S1) |
| difference() | set | 找出S1中有的，但S2中不存在的集合并指派給新的變量 | S3 = S1.difference(S2) |
| difference_update() | set | 找出s1中有的，但s2中不存在的集合 ，更新自身 | S1.difference_update(S2) |
| discard() | None | 在集合中移除指定元素，不存在不報錯 | S.discard(5) print(S) |
| remove() | None | 在集合中移除指定元素，不存在會報錯 | S.remove(6) print(S) |
| intersection() | set | 取s1、s2集合的交集并指派給新的變量 | s3 = s1.intersection(s2) |
| intersection_update() | set | 取s1、s2集合的交集,更新自身 | s1.intersection_update(s2) |
| isdisjoint() | bool | 判斷s1、s2集合是否無交集，有False；無True | ret = s1.isdisjoint(s2) |
| issubset() | bool | 判斷s1是否是s2的子集，是 True；否False | ret = s1.issubset(s2) |
| issuperset() | bool | 判斷s1是否是s2的父集，是 True；否False | ret = s1.issuperset(s2) |
| pop() | set | 随機删除集合中元素 | a = S.pop() print(a) print(S) |
| symmetric_difference() | set | 把s1存在但s2不存在的和s2存在但s1不存在的元素組成一個新的集合s3 | s3 = s1.symmetric_difference(s2) |
| symmetric_difference_update() | set | 把s1存在但s2不存在的和s2存在但s1不存在的元素組成一個新的集合并更新給s1 | s1.symmetric_difference_update(s2) |
| union() | set | 取s1和s2的并集 | s3 = s1.union(s2) |
| update() | set | 同上，更新為s1 | s1.update(s2) |
類型三
1.運算符：
算術運算符：+，-，*，/，%（取餘），**（幂），//（整除）
比較運算符：==，!=，>，<，>=，<=
指派運算符：=，+=，-=，*=，/=，%=， **=，//=
邏輯運算符：and(與)，or（或），not（非）
成員運算符：in，not in
2.嵌套：
T=(11, 12, [ 'wold', {'k1': 'dd', 'k2': 's'} ] )
print(T[2][1]['k1']) #類型為tuple 輸出為dd
3.清單 元祖 字典 set 特點總結：
a. 清單list：有序，可修改，允許重複的集合
b. 元祖tuple：有序，不可修改，允許重複的集合 （元素是可變烈性的元素，可以修改元素内部）
c. 字典dict：無序，可修改，允許重複的集合
d. set：無序，不可變，不允許重複的集合（元素不能是清單，字典等類型）
4.字元串總結：
1、反斜杠可以用來轉義，使用r可以讓反斜杠不發生轉義。兩種讓\不發生轉義的方法
a:print（r‘Ru\nood')
b:print（‘Ru\nood’)
2、字元串可以用+運算符連接配接在一起（該方法效率比較低，不建議使用），用*運算符重複。
3、Python中的字元串有兩種索引方式，從左往右以0開始，從右往左以-1開始。
4、Python中的字元串中字元不能改變。
5、print(l[::2]):第三個參數表示步長step
6.字元串的轉義：
* ： print("=" * 30) 輸出30個等号
\n： 換行
\t： 水準制表符
\b： 倒退
\r： 回車，目前位置移到本行開頭
\\： 代表反斜杠 \
'： 代表一個單引号，同樣的 “ ? 等符号也可以這麼輸出
\0： 代表一個空字元
\a： 系統提示音如果去掉字元串的轉義，隻需要在字元串前面加上 rr’abc\tabc’
7.字元串的格式化：
format (python特有的) 方法 ”{}-{}-{}“.format()
s = "name %s, age %d" % ("符華", 50000) # %方法 必須一一對應否則會報錯
print '{:.2f}'.format(321.33345) #321.33 保留兩位小數
s = "name {}, age {},".format("Bronya", 17) #無序一一對應
s = "name {0}, age {1}".format("Bronya", 17) #無序一一對應
L=["Bronya", 17]
s = "name {0}, age {1}".format(*L) # name Bronya, age 17
s = "name {name}, age {age}".format(age=17, name=Bronya) #已和下标沒有太大關系
| 格式 | 描述 | 例子 | 格式 | 描述 |
|---|---|---|---|---|
| %% | 百分号标記 | “%d-%d-%d” %() | %e | 浮點數字(科學計數法) |
| %c | 字元及其ASCII碼 | %E | 浮點數字(科學計數法，用E代替e) | |
| %s | 字元串 | %f | 浮點數字(用小數點符号) | |
| %d | 有符号整數(十進制) | %g | 浮點數字(根據值的大小采用%e或%f) | |
| %u | 無符号整數(十進制) | %G | 浮點數字(類似于%g) | |
| %o | 無符号整數(八進制) | %p | 指針(用十六進制列印值的記憶體位址) | |
| %x | 無符号整數(十六進制) | %n | 存儲輸出字元的數量放進參數清單的下一個變量中 | |
| %X | 無符号整數(十六進制大寫字元) |
格式化得到的結果都是字元串，通過把位置預先留出來，後期再往其中填入内容可以讓輸出内容更加整潔美觀，而又具有良好的可讀性，同時讓代碼更簡潔精練字元串的轉義可以友善我們表示我們不太友善表示的字元，同時轉義有些情況下又會帶來麻煩，特别是在表示路徑的時候，這種情況下可以在字元串前面加上 r 來去掉字元串的轉義
類型四
1.字元串編碼：
編碼（encode） unicode編為指定的其他編碼
解碼（decode） 其他編碼轉成unicode
s="有基佬開我褲鍊“
utf8 = s.encode("utf-8")
printf(utf8)
utf8_gbk = utf8.decode("gbk")
print(utf8_gbk)
2.深淺複制：
字元串 數字 指派 深淺拷貝無意義都是記憶體
淺複制：在記憶體裡隻額外建立了第一層
方法 copy
深複制：隻是建立一個變量 ，該變量複制原來的記憶體位址但與原來互不影響
方法 deepcopy
3.bytes和bytearray：
bytes
基本用法：
print(type(b"fffff")) #類型為 bytes不為str
b=bytes("守望先鋒", encoding="utf-8")
bytearray
s="守望先鋒“
b=bytearray(s.encode("utf-8")) #類型為 bytearray
二，控制流程
1.條件判斷
文法結構：
if 判斷語句1:
執行語句1
elif 判斷語句2:
執行語句2…
else:
執行語句
2.三目運算
if b>5:
print(Ture)
else:
print(False)
三目運算
print(Ture) if b> 5 else print(False) #隻能用在if else 的簡單判斷情況
3.條件循環
while：條件滿足才執行語句 注意不要死循環了
break和else：break終止循環 else循環全部結束後執行，并且要求循環不是被break掉的
continue：跳出目前循環繼續下一次循環
注意要點：
-
循環可以被終止： 通過break終止循環 通過continue跳過當此循環
else的執行條件： 隻有在循環不是被break終止的情況下才會執行else中的内容
4.疊代循環
for疊代：
文法規則： for x in y: #x為元素 Y必須為可疊代對象
循環體 注意縮進
判斷是否為可疊代對象：能不能for 有iter對象
range：與切片類似 有 頭 尾 步長+
注意要點：
-
for 後面需要接上可疊代對象
for會依次取出可疊代對象中的元素
continue的用法:
continue和break類似，但是continue不會終止循環，而是結束本次循環，跳到下次循環
三，函數基礎和函數參數
函數基礎
函數定義
def 函數名(參數)：函數頭
pass 函數體（表達式）
return 傳回值
函數名命名規則： 字母、數字和下劃線組成，和變量命名規則一緻return 後面可以傳回任意表達式，但不能是指派語句
函數參數
1.必須參數
def func(x):
print(x)
func(1)
x稱為形參(必須參數) 1稱為實參（位置參數）
實參與形參一一對應
2.預設參數
def func(x, y=None):
print(x)
print(y)
func(1)
func(1, 2)
調用的時候如果沒有傳入實參，就用預設值，有實參就覆寫，必須寫在必須參數後面
3.關鍵字參數
def fun(a, b, c)
print(a)
print(b)
print(c)
fun(b=2, c=3, a=1) #1 2 3
函數的參數會按照關鍵字去找對應的值
4.動态函數
def func(*args, **kwargs):
print(args)
print(kwargs)
func(1, 2, 3, a=4, b=5, c=6)
func(*(1, 2, 3), **{'a': 4, 'b': 5, 'c': 6})
*args： 傳入的位置參數都會被接受生成一個元組
**kwargs： 傳入的關鍵字參數都會被接受生成一個字典
拓展：為動态參數傳入 清單（使用*） 字典（使用**）
常見内置參數
1.簡單内置函數
内置對象檢視： dir(builtins)
常見函數：
-
len 求長度 reversed 反向
min 求最小值 sum 求和
max 求最大值 sorted 排序
進制轉換函數：
-
bin( ) 轉換為二進制
oct( ) 轉換為八進制
hex( ) 轉換為十六進制
ord( ) 字元轉ASCII碼
chr( ) ASCII碼轉字元
2.進階内置函數
enumerate 傳回一個可以枚舉(周遊)的對象
eval： 取出字元串中的内容将字元串str當成有效的表達式來求指并傳回計算結果（識别是表達式，并有傳回值）
exec： 執行字元串沒有傳回值
filter：（函數，可疊代對象） 過濾器，取出每一個可疊代對象去執行函數，符合條件的留下不符合的删除
map：取出每一個可疊代對象去執行函數，并将結果進行處理作為清單輸出
zip： 将對象逐一配對，并将結果進行處理然後輸出
![TestLink導出用例轉換工具(XML2Excel)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)