1.數據類型
Python3 中有六個標準的數據類型：
1.1、Number（數字）
int、float、bool、complex（複數）。
注意：不同類型的數混合運算時會將整數轉換爲浮點數
1.2、String（字符串）
Python中的字符串用單引號(')或雙引號(")括起來，同時使用反斜槓(\)轉義特殊字符。
Python 字符串不能被改變。向一個索引位置賦值，比如word[0] = 'm'會導致錯誤。
注意：
反斜槓可以用來轉義，使用r可以讓反斜槓不發生轉義，r'\temp' 。
字符串可以用+運算符連接在一起，用*運算符重複。
Python中的字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始。
Python中的字符串不能改變。
| str.upper() | 全部大寫 |
| str.lower() | 全部小寫 |
| str.swapcase() | 大小寫轉換 |
| str.capitalize() | 首字母大寫 |
| str.title() | 每個單詞的首字母大寫 |
| str.find('t',start,end) | 查找字符串，可以指定起始及結束位置搜索,沒有返回-1 |
| str.rfind('t') | 從右邊開始查找字符串 |
| str.replace('old','new') | 替換函數，替換old爲new，參數中可以指定maxReplaceTimes，即替換指定次數的old爲new |
| str.strip() | 去兩邊空格 |
| str.lstrip() | 去左空格 |
| str.rstrip() | 去右空格 |
| str.startswith('start') | 是否以start開頭 |
| str.endswith('end') | 是否以end結尾 |
| str.isalnum() | 是否全爲字母或數字 |
| str.isalpha() | 是否全字母 |
| str.isdigit() | 是否全數字 |
| str.islower() | 是否全小寫 |
| str.isupper() | 是否全大寫 |
#print字符串拼接:
>>> print("hello"+"andy")
helloandy
>>> print("hello","andy")
hello andy <,號會有一個空格>
>>> print("hello"*2)
hellohello
#join(seq) 以指定字符串作爲分隔符，將 seq 中所有的元素(的字符串表示)合併爲一個新的字符串
>>> list=['I','love','you']
>>> ''.join(list)
'Iloveyou'
>>> ' '.join(list)
'I love you'
>>> ','.join(list)
'I,love,you'
>>> love = 'I love you'
>>> love.split() #默認是以空格爲分隔符分割
['I', 'love', 'you']
>>> love.split(' ',2) #以空格爲分隔符，最大分割次數爲2
['I', 'love', 'you']
>>> love.split(' ',1) #以空格爲分隔符，最大分割次數爲1
['I', 'love you']| 轉義字符 | 描述 |
| \(在行尾時) | 續行符 |
| \\ | 反斜槓符號 |
| \' | 單引號 |
| \" | 雙引號 |
| \a | 響鈴 |
| \b | 退格(Backspace) |
| \e | 轉義 |
| \000 | 空 |
| \n | 換行 |
| \v | 縱向製表符 |
| \t | 橫向製表符 |
| \r | 回車 |
| \f | 換頁 |
| \oyy | 八進制數，yy代表的字符，例如：\o12代表換行 |
| \xyy | 十六進制數，yy代表的字符，例如：\x0a代表換行 |
| \other | 其它的字符以普通格式輸出 |
#python字符串格式化:
"this is %d %s bird" % (1, 'dead') # 一般的格式化表達式
"%s---%s---%s" % (42, 3.14, [1, 2, 3]) # 字符串輸出：'42---3.14---[1, 2, 3]'
"%d...%6d...%-6d...%06d" % (1234, 1234, 1234, 1234) # 對齊方式及填充："1234... 1234...1234 ...001234"
x = 1.23456789
"%e | %f | %g" % (x, x, x) # 對齊方式："1.234568e+00 | 1.234568 | 1.23457"
"%6.2f*%-6.2f*%06.2f*%+6.2f" % (x, x, x, x) # 對齊方式：' 1.23*1.23 *001.23* +1.23'
"%(name1)d---%(name2)s" % {"name1":23, "name2":"value2"} # 基於字典的格式化表達式
"%(name)s is %(age)d" % vars() # vars()函數調用返回一個字典，包含了所有本函數調用時存在的變量
"{0}, {1} and {2}".format('spam', 'ham', 'eggs') # 基於位置的調用
"{motto} and {pork}".format(motto = 'spam', pork = 'ham') # 基於Key的調用
"{motto} and {0}".format(ham, motto = 'spam') # 混合調用
# 添加鍵 屬性 偏移量 (import sys)
"my {1[spam]} runs {0.platform}".format(sys, {'spam':'laptop'}) # 基於位置的鍵和屬性
"{config[spam]} {sys.platform}".format(sys = sys, config = {'spam':'laptop'}) # 基於Key的鍵和屬性
"first = {0[0]}, second = {0[1]}".format(['A', 'B', 'C']) # 基於位置的偏移量
# 具體格式化
"{0:e}, {1:.3e}, {2:g}".format(3.14159, 3.14159, 3.14159) # 輸出'3.141590e+00, 3.142e+00, 3.14159'
"{fieldname:format_spec}".format(......)
# 說明:
"""
fieldname是指定參數的一個數字或關鍵字, 後邊可跟可選的".name"或"[index]"成分引用
format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]
fill ::= <any character> #填充字符
align ::= "<" | ">" | "=" | "^" #對齊方式
sign ::= "+" | "-" | " " #符號說明
width ::= integer #字符串寬度
precision ::= integer #浮點數精度
type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
"""
# 例子:
'={0:10} = {1:10}'.format('spam', 123.456) # 輸出'=spam = 123.456'
'={0:>10}='.format('test') # 輸出'= test='
'={0:<10}='.format('test') # 輸出'=test ='
'={0:^10}='.format('test') # 輸出'= test ='
'{0:X}, {1:o}, {2:b}'.format(255, 255, 255) # 輸出'FF, 377, 11111111'
'My name is {0:{1}}.'.format('Fred', 8) # 輸出'My name is Fred .' 動態指定參數| 符 號 | 描述 |
| %c | 格式化字符及其ASCII碼 |
| %s | 格式化字符串： 'a %s parrot' % 'kind' |
| %d | 格式化整數 |
| %u | 格式化無符號整型 |
| %o | 格式化無符號八進制數 |
| %x | 格式化無符號十六進制數 |
| %X | 格式化無符號十六進制數（大寫） |
| %f | 格式化浮點數字，可指定小數點後的精度 |
| %e | 用科學計數法格式化浮點數 |
| %E | 作用同%e，用科學計數法格式化浮點數 |
| %g | %f和%e的簡寫 |
| %G | %f 和 %E 的簡寫 |
| %p | 用十六進制數格式化變量的地址 |
1.3、List（列表）
注意：
1、List寫在方括號之間，元素用逗號隔開。
2、和字符串一樣，list可以被索引和切片。
3、List可以使用+操作符進行拼接，星號（*）是重複操作。
4、List中的元素是可以改變的。
| list=[] | 創建一個空列表 |
| list.append('zengjia') | 在列表末尾添加一個元素，返回值爲none |
| list.extend([7,8,9]) | extend() 函數用於在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表）。 |
| list.insert(6,'six') | 指定位置插入 |
| del list[6] | 刪除指定位置元素 del a[2:4] del a[:] |
| list.pop() | 刪除指定位置的值並返回刪除的值 默認最後一個 |
| list.clear() | 清空列表 |
| list.sort() | 排序 |
| list.reverse() | 原地反轉列表 |
| list.remove(1) | 刪除首次出現的指定元素 1 |
| list.index(22) | 查看元素第一次出現的位置 |
| list.count(1) | 指定元素1出現的次數 |
| list.copy() | 返回列表的淺複製，等於a[:]。 |
| len(list) | 列表長度 |
| 切片：用切片查看元素不會因爲越界拋出異常，代碼具有更強的健壯性 | |
| cc=[0,1,2,3,4,5,6,7,8,9,10] | |
| cc[::] | [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |
| cc[0:11:1] | [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |
| cc[::-1] | [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] |
| cc[::2] | [0, 2, 4, 6, 8, 10] |
| cc[len(cc):]='a' #切片增加元素 | [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a'] |
| cc[:3]=['a','b','c'] #切片修改元素 | ['a', 'b', 'c', 3, 4, 5, 6, 7, 8, 9, 10] |
| collections.deque | 它爲在首尾兩端快速插入和刪除而設計。 |
| for i, v in enumerate(['tic', 'tac', 'toe']): ... print(i, v) | 在序列中循環時，索引位置和對應值可以使用 enumerate() 函數同時得到: |
| >>> questions = ['name', 'quest', 'favorite color'] >>> answers = ['lancelot', 'the holy grail', 'blue'] >>> for q, a in zip(questions, answers): ... print('What is your {0}? It is {1}.'.format(q, a)) | 時循環兩個或更多的序列，可以使用 zip() 整體打包: |
Python的List功能已經足夠完成隊列的功能, 可以用 append() 來向隊尾添加元素, 可以用類似數組的方式來獲取隊首元素, 可以用 pop(0) 來彈出隊首元素. 但是List用來完成隊列功能其實是低效率的, 因爲List在隊首使用 pop(0) 和 insert() 都是效率比較低的, Python官方建議使用collection.deque來高效的完成隊列任務.
from collections import deque
queue = deque(["Eric", "John", "Michael"])
queue.append("Terry") # Terry 入隊
queue.append("Graham") # Graham 入隊
queue.popleft() # 隊首元素出隊 #輸出: 'Eric'
queue.popleft() # 隊首元素出隊 #輸出: 'John'
queue # 隊列中剩下的元素 #輸出: deque(['Michael', 'Terry', 'Graham'])列表生成式
Python內置的非常簡單卻強大的可以用來創建list的生成式。
>>> list(range(1,21)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] >>> L = [] >>> for x in range(1,11): ... L.append(x*x) >>> L [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] >>> [x * x for x in range(1,11)] #一行的高級寫法 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] >>> [x * x for x in range(1,11) if x %2 == 0] #加上if判斷，篩選出偶數的平方 [4, 16, 36, 64, 100] >>> [(x,y) for x in [1,2,3] for y in [3,1,4] if x != y] [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
1.4、Tuple（元組）
元組（tuple）與列表類似，不同之處在於元組的元素不能修改，所以沒有增刪改操作。元組寫在小括號(())裏，元素之間用逗號隔開。
#元組是不可變的，所以初始化後元組內的元素不可改變。
雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表。
| 1 2 3 4 | t = tuple() # 構造一個空元組 t = () 也是構造一個空元組 t = (1,) 初始化一個元素的元組，一個元素必須要加逗號 t = (1, 2, 3) # 初始化三個元素的元組 |
注意：
1、與字符串一樣，元組的元素不能修改。
2、元組也可以被索引和切片，方法一樣。
3、注意構造包含0或1個元素的元組的特殊語法規則。
4、元組也可以使用+操作符進行拼接。
string、list和tuple都屬於sequence（序列）。
1.5、Sets（集合）
集合（set）是一個無序不重複元素的序列。
基本功能是進行成員關係測試和刪除重複元素。
可以使用大括號({})或者 set()函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因爲 { } 是用來創建一個空字典。
s = set() # 用set函數定義空集合
s = {} ！！！這是字典
1.6、Dictionary（字典）
列表是有序的對象結合，字典是無序的對象集合。兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
字典是一種映射類型，字典用"{ }"標識，它是一個無序的鍵(key) : 值(value)對集合。
鍵(key)必須使用不可變類型。
在同一個字典中，鍵(key)必須是唯一的。
注意：
1、字典是一種映射類型，它的元素是鍵值對。
2、字典的關鍵字必須爲不可變類型，且不能重複。
3、創建空字典使用 { }。
常用字典常量和操作
D = {}
D = {'spam':2, 'tol':{'ham':1}} # 嵌套字典
D = dict.fromkeys(['s', 'd'], 8) # {'d': 8, 's': 8}
D = dict(name = 'tom', age = 12) # {'age': 12, 'name': 'tom'}
D = dict([('name', 'tom'), ('age', 12)]) # {'age': 12, 'name': 'tom'}
D = dict(zip(['name', 'age'], ['tom', 12])) # {'age': 12, 'name': 'tom'}
D.keys() D.values() D.items() # 字典鍵、值以及鍵值對
D.get(key, default) # get函數,指定鍵的值
D.update(D_other) # 合併字典，如果存在相同的鍵值，D_other的數據會覆蓋掉D的數據
D.pop(key, [D]) # 刪除字典中鍵值爲key的項，返回鍵值爲key的值，如果不存在，返回默認值D，否則異常
D.popitem() # pop字典中的一項（一個鍵值對）
D.setdefault(k[, d]) # 設置D中某一項的默認值。如果k存在，則返回D[k]，否則設置D[k]=d，同時返回D[k]。
del D # 刪除字典
del D['key'] # 刪除字典的某一項
if key in D: if key not in D: # 測試字典鍵是否存在
# 字典注意事項：（1）對新索引賦值會添加一項（2）字典鍵不一定非得是字符串，也可以爲任何的不可變對象| 一些寫法： | |
| {x:x**2 for x in (2,4,6)} | {2: 4, 4: 16, 6: 36} |
| {k:8 for k in ['s','d']} | {'s': 8, 'd': 8} |
| {k:v for (k,v) in zip(['name','age'],['tom',12])} | {'age': 12, 'name': 'tom'} |
| dict(sape=4139, guido=4127, jack=4098) | {'jack': 4098, 'guido': 4127, 'sape': 4139} |
| 字典遍歷： | |
| >>> knights = {'gallahad': 'the pure', 'robin': 'the brave'} >>> for k, v in knights.items(): ... print(k, v) | 在字典中循環時，關鍵字和對應的值可以使用 items() 方法同時解讀出來: |
| import collections | collections.OrderedDict() | 這個模塊可以記錄字典的輸入順序，遍歷按輸入順序輸出。 |
附：
迭代：如果給定一個list或tuple，我們可以通過for循環來遍歷這個list或tuple，這種遍歷我們稱爲迭代（Iteration）。
Python中的索引，從前往後，索引是從0開始，從後往前，索引是從-1開始。
如果索引超出範圍，將引發IndexError異常。
2.數據類型轉換
| 函數 | 描述 |
| int(x [,base]) | 將x轉換爲一個整數 |
| float(x) | 將x轉換到一個浮點數 |
| complex(real [,imag]) | 創建一個複數 |
| str(x) | 將對象 x 轉換爲字符串 |
| repr(x) | 將對象 x 轉換爲表達式字符串 |
| eval(str) | 用來計算在字符串中的有效Python表達式,並返回一個對象 |
| tuple(s) | 將序列 s 轉換爲一個元組 |
| list(s) | 將序列 s 轉換爲一個列表 |
| set(s) | 轉換爲可變集合 |
| dict(d) | 創建一個字典。d 必須是一個序列 (key,value)元組。 |
| frozenset(s) | 轉換爲不可變集合 |
| chr(x) | 將一個整數轉換爲一個字符 |
| unichr(x) | 將一個整數轉換爲Unicode字符 |
| ord(x) | 將一個字符轉換爲它的整數值 |
| hex(x) | 將一個整數轉換爲一個十六進制字符串 |
| oct(x) | 將一個整數轉換爲一個八進制字符串 |