數據類型：
變量能夠處理不一樣類型的值，基本的類型是數和字符串。使用變量時只須要給它們賦一個值。不須要聲明或定義數據類型。
Python3 中有六個標準的數據類型：
Number（數字），String（字符串），List（列表），Tuple（元組），Sets（集合），Dictionary（字典）html
1. 布爾值bool
布爾值類型: True，False
布爾運算類型: 與and、或or、非notjava
False： None，""，{}，()，[]， 0python
a = True print a and 'a=T' or 'a=F' #計算結果不是布爾類型，而是字符串 'a=T'。由於Python的False只有幾種，其餘數值和非空字符串都當作 True，因此，計算結果是 'a=T'，繼續計算 'a=T' or 'a=F' 計算結果仍是 'a=T'，
2. 字符串
1）定義
是由零個或多個字符組成的有限串行。通常記爲s=a[1]a[2]...a[n]。（通常引號引發來）git
2） 基本操做
str.index() # 索引字符 str[N] # 索引，可爲負值 str[n:m] # 切片，可爲負值 len() # 求序列長度 str1 + str2 # 加法：「+」鏈接字符串鏈接2個序列 str1 * n # 乘法：「*」 重複序列元素，就是重複那個字符串的含義。 in # 判斷元素是否存在於序列中 max() # 返回最大值--ASCII編碼 min() #返回最小值--ASCII編碼 cmp(str1,str2) #比較2個序列值是否相同，首先將字符串中的符號轉化爲對應編碼的數字，而後比較。若是返回的數值小於零，說明第一個小於第二個，等於0，則兩個相等，大於0，第一個大於第二個。
3）擴展操做
● 字符串的拆分和拼接github
str2 = str1.split("sep") #將字符串根據某個sep（分割符）分割成多個字符串組成的列表，默認爲空格。 str2 = "sep".join(interable) #將序列中的元素以指定的字符sep鏈接生成一個新的字符串。列表、元組和字符串都是序列。
● 默認去掉字符串空格：原來的值沒有變化，而是新返回了一個結果。也能夠指定去除內容（序列或者字符），或者指定內容的子序列web
S.strip() #去掉字符串的左右空格、\t、\n，也能夠指定去除內容（序列或者字符），或者指定內容的子序列 S.lstrip() #去掉字符串的左邊空格、\t、\n， 也能夠指定去除內容（序列或者字符），或者指定內容的子序列 S.rstrip() #去掉字符串的右邊空格、\t、\n，也能夠指定去除內容（序列或者字符），或者指定內容的子序列
str = '12a2b12c212' print(str.strip('12')) #a2b12c 刪除頭尾的1和2 print(str.lstrip('12')) #a2b12c212 刪除開頭的1和2 print(str.rstrip('12')) #12a2b12c 刪除結尾的1和2
● 字符大小寫的轉換：用來實現各類類型的大小寫轉化api
S.upper() #將S中的字母轉換爲大寫 S.lower() #將S中的字母轉換爲小寫 S.casefood #將S中的字母轉換爲小寫，更強大 S.swapcase() #將S中的字母的大小寫全轉換 S.title() #將S中字符串中全部的單詞轉換成首字母都是大寫 S.capitalize() #首字母大寫 S.isupper() #S中的字母是否全是大寫 S.islower() #S中的字母是否全是小寫 S.istitle() #S中字符串中全部的單詞拼寫首字母是否爲大寫，且其餘字母爲小寫
● 字符串填充/寬度設置安全
S.center(width[, fillchar]) #設置S的寬度，字符串內容在中間，以第二個參數爲填充字符，填充字符只能指定一個，可不填，默認爲空格 S.ljust(width[, fillchar]) #指定寬度和填充字符，內容放左邊，右邊填充指定字符，默認填充字符爲空格 S.rjust(width[, fillchar]) #指定寬度和填充字符，內容放右邊，左邊填充指定字符，默認填充字符爲空格 S.zfill(width) #指定寬度，不可指定字符，內容放右邊，左邊填充0
● 字符串分割app
S.partition(sep) # 從左邊起，找到第一個指定的字符sep，將左右兩邊進行切割，分割爲3份。第二份爲指定字符sep S.rpartition(sep) # 從右邊起，找到第一個指定的字符sep，將左右兩邊進行切割，分割爲3份。第二份爲指定字符sep S.split(sep=None, maxsplit=-1) # 從左邊起，找到全部指定的字符sep，將左右兩邊抽離，分割爲n份。指定maxsplit=1則只找一個，左右兩邊分割一次，匹配的sep不會出現。 S.lstrip([chars]) # 從右邊起，找到全部指定的字符sep，將左右兩邊抽離，分割爲n份。指定maxsplit=1則只找一個，左右兩邊分割一次，匹配的sep不會出現。 S.splitlines([keepends]) #只能以\n符號分割，若是（）內爲True，保留換行符，爲False爲不保留換行符。
● 字符串內容替換ide
S.maketrans(self, *args, **kwargs) #給定替換規則（「m」，「n」）e.g. x=S.maketrans("abc","123") S.translate(table) #按照給給定的替換規則進行替換，相似翻譯。e.g. y = S.translate(x) ,if S=abcda, print(y)爲123d1 S.replace(old, new[, count]) #字符串替換，把old 替換成new，默認全體替換，可指定替換個數，即替換前面n個數
● 字符串內容判斷
S.isalnum() # 判斷字符串是否只包含數字和字母，是返回True，包含其餘的字符返回False S.isalpha() # 判斷字符串是否只包含字母，是返回True，包含其餘的字符返回False S.isdecimal() # 判斷是否爲數字 S.isdigit() # 判斷是否爲數字，對特殊數字也適用。例如② S.isnumeric() # 判斷是否都是數字，對中文數字也適用。最牛 S.isidentifier() # 判斷是否爲標識符 S.isprintable() # 判斷是否存在不可顯示的字符，如\t、\n S.isspace() # 判斷是否都是空格 S.endswith(suffix[, start[, end]]) #判斷字符串是否以指定字符爲結尾，可指定範圍 S.startswith(prefix[, start[, end]]) #判斷字符串是否以指定字符爲開頭，可指定範圍
● 字符串其它魔法
S.count(sub[, start[, end]]) #計算指定子序列在字符串的個數，可指定計算範圍 S.expandtabs(tabsize=8) #把字符串中的 tab 符號('\t')轉爲空格，tabsize用來斷句，默認8個字符，即以8個字符爲一個斷句標準，不足以空格補全。 S.find(sub [,start [,end]]) #查找給定子序列的第一個位置，返回索引值，可指定範圍，未找到時返回-1 S.format(*args, **kwargs) #格式化，將字符串中的佔位符替換成指定值 S.format_map({*args： m, **kwargs： n}) #格式化，將字符串中的佔位符替換成指定值,必須提供鍵值對 S.index(sub [,start [,end]]) #查找給定子序列的第一個位置，返回索引值，可指定範圍，未找到時返回出錯
4） 格式化字符串
待續。。。
3. 列表
1） 定義
在python中，用方括號 [ ] 表示一個list。在方括號裏面，能夠是int，也能夠是str類型的數據，甚至也可以是True/False這種布爾值，或者嵌套一個列表。list中的元素是任意類型的。
2） 判斷
bool()是一個布爾函數，做用就是來判斷一個對象是「真」仍是「空」（假）。若是list中什麼也沒有，就是空的，用bool()函數來判斷，獲得False，從而顯示它是空的。
3） 生成
生成list：range（）函數和for循環的引用 # e.g. print [ x * y for x, y in zip(range(1,100,2),range(2,101,2))]
4） 修改
這種修改，不是複製一個新的，而是在原地進行修改。內存地址不變。其存儲爲鏈式存儲。
5）切片和索引
list和str兩種類型的數據，有共同的地方，它們都屬於序列（都是一些對象按照某個次序排列起來，這就是序列的最大特徵）。
索引都是從左邊開始編。第一個是0，而後依次增長1。此外，還有一種編號方式，對於list，既然Python支持L[-1]取倒數第一個元素就是從右邊開始，右邊第一個能夠編號爲-1，而後向左依次是：-2,-3,...，依次類推下來。這對字符串、列表等各類序列類型都是用。
序列的切片，左邊的數字必定要小於右邊的數字。不包括右邊的數據。切片結果爲新的list。 一樣支持倒數切片取倒數。切片操做還能夠指定第三個參數：第三個參數表示每N個取一個，上面的 L[::2] 會每兩個元素取出一個來，也就是隔一個取一個。把list換成tuple，切片操做徹底相同，只是切片的結果也變成了tuple。
list[:] #複製出了一個新list。 list[::-1] #反轉，不是在「原地」把原來的值倒過來，而是新生成了一個值，那個值跟原來的值相比，是倒過來了。等同於list(reversed(list0)) list[1:3] = [x, y] #切片賦值
6） 基本操做
len(L) # 求列表長度 e.g. lst = [1,2,3] len(lst) = 3 L[i]=() # 替換第i個元素 e.g. lst[2]=(4) = [1,2,4] L1+ L2 # 鏈接2個序列，鏈接列表 e.g. alst = [5, 6] lst + alst = [1, 2, 3, 4, 5, 6] L*n # 重複序列元 素「*」 字符串中的「乘法」，就是重複那個列表的含義。blst = st * 2 = [1,2,3,1,2,3] x in list # 判斷元素是否存在於序列中 e.g. x in lst : False L.append(object) # 即將新的元素x追加到list的尾部，等效於：a[len(a):]=[x] e.g. lst.append("like") = [1,2,3,like] cmp(L1,L2) # 比較2個序列值 e.g.cmp(lst,alst) == False L.extend(iterable) # append是整建制地追加，extend是個體化擴編。 # e.g. lst.append(["qiwsir","github"]) = [1, 2, 3, ['qiwsir', 'github']]; lst2.extend(["qiwsir","github"]) = [1, 2, 3, 'qiwsir', 'github'] L.count(value) # 計算元素個數 e.g.deblst.count(2) = 2 L.index(value, [start, [stop]]) # 得到索引位置 e.g.lst.index(2) = 1 L.insert(index, object) # L.insert(i,x) 在i位置插入元素x e.g. lst.insert(2,"x") = [1,2,x,3] del L[n:m] # 刪除元素
L.remove(value) # 移除元素 lst.remove(1) = [2,x,3] L.pop([index]) # 移除索引值位置的元素，L.pop([i]) e.g. list.pop([1]) = [1,x,3] L.reverse() # 列表反轉 e.g. lst.reverse () = [3,2,1] L.sort(key=None, reverse=False) # lst.sort(reverse=True) = [3,2,1] L.sort(cmp=None, key=None, reverse=False) -- stable sort IN PLACE; cmp(x, y) -> -1, 0, 1 # lst = ["python","java","c","pascal","basic"]; lst.sort(key=len) =['c', 'java', 'basic', 'python', 'pascal'] L.clear() # 清空列表，參數爲空：None 表示 remove all items from L L.copy() # 拷貝列表，淺拷貝
7） list和str轉化
str.split() # S.split([sep [,maxsplit]]) -> list of strings 這個內置函數實現的是將str轉化爲list。其中str=""是分隔符。返回字符串S中的單詞列表，使用sep做爲分隔符字符串。 若是給出maxsplit，則最多能夠完成maxsplit拆分。 若是未指定sep或無，則空格字符串爲分隔符，並從結果中刪除空字符串。 "[sep]".join(list) or list（str） # 字符串轉換成列表
4. 元組
1）特色
用圓括號()括起來的，其中的元素之間用逗號隔開。（都是英文半角）元組只有一個元素的時候（特別是數或者字符串），記得添加「,」纔是元組
* 元組中的元素類型是任意的python數據。
* tuple是一種序列類型的數據，這點上跟list/str相似。它的特色就是其中的元素不能更改，這點上跟list不一樣，卻是跟str相似；它的元素又能夠是任何類型的數據，這點上跟list相同，但不一樣於str。元素不能被增長或刪除。tuple指向的list，list可變，因此，tuple所謂的「不變」是說，tuple的每一個元素，指向永遠不變。即指向'a'，就不能改爲指向'b'，「可變」是指向一個list，就不能改爲指向其餘對象，但指向的這個list自己是可變的！要建立一個內容也不變的tuple，那就必須保證tuple的每個元素自己也不能變。即一級元素不可變。
* 若是一個元組中只有一個元素的時候，應該在該元素後面加一個半角的英文逗號：由於()既能夠表示tuple，又能夠做爲括號表示運算時的優先級，結果 (1) 被Python解釋器計算出結果 1，致使咱們獲得的不是tuple，而是整數 1。因此 Python 規定，單元素 tuple 要多加一個逗號「,」，這樣就避免了歧義。
2） 索引和切片
能夠正常使用 t[0]，t[-1]等索引方式訪問元素，可是不能賦值成別的元素。
3） tuple使用的情景:
A. Tuple 比 list 操做速度快。若是您定義了一個值的常量集，而且惟一要用它作的是不斷地遍歷它，請使用 tuple 代替 list。
B. 若是對不須要修改的數據進行 「寫保護」，可使代碼更安全。使用 tuple 而不是 list 如同擁有一個隱含的 assert 語句，說明這一數據是常量。若是必需要改變這些值，則須要執行 tuple 到 list 的轉換 (須要使用一個特殊的函數)。
C. Tuples 能夠在 dictionary（字典，後面要講述） 中被用作 key，可是 list 不行。Dictionary key 必須是不可變的。Tuple 自己是不可改變的，可是若是您有一個 list 的 tuple，那就認爲是可變的了，用作 dictionary key 就是不安全的。只有字符串、整數或其它對 dictionary 安全的 tuple 才能夠用做 dictionary key。
D. Tuples 能夠用在字符串格式化中。
4） 列表和元組：用list()和tuple()可以實現二者的轉化
5） 基本用法
T.count(value) #計算某個值的出現個數 T.index(value, [start, [stop]]) #返回索引位置
5. 字典
1） 特色
* 查找速度快：不管dict有10個元素仍是10萬個元素，* 查找速度都同樣。而list的查找速度隨着元素增長而逐漸降低。不過dict的查找速度快不是沒有代價的，dict的缺點是佔用內存大，還會浪費不少內容，list正好相反，佔用內存小，可是查找速度慢。因爲dict是按 key 查找，因此，在一個dict中，key不能重複。
* 存儲的key-value序對是沒有順序，無序
* 做爲 key 的元素必須不可變：Python的基本類型如字符串、整數、浮點數都是不可變的，均可以做爲 key。可是list是可變的，就不能做爲 key。
* 可遍歷：for
2） 建立
* 花括號 {} 表示, key: value,最後一個 key: value 的逗號能夠省略。
* 在字典中的「鍵」，必須是不可變的數據類型；「值」能夠是任意數據類型。列表能夠修改，因此列表是可變的；字符串和元組都不行，因此它們是不可變的。字典能夠原地修改，即它是可變的。列表，字典不能做爲key。布爾值True=1， False=0，當與其餘key值重複的時候，會出現衝突，其能夠當成key的。
* 直接建立：
a. 建立一個空的dict，這個空dict，能夠在之後向裏面加東西用。
mydict = {}
b. 建立有內容的dict。
person = {"name":"qiwsir","site":"qiwsir.github.io"}
"name":"qiwsir"：鍵值對。前面的name叫作鍵（key），後面的qiwsir是前面的鍵所對應的值(value)。在一個dict中，鍵是惟一的，不能重複。值則是對應於鍵，值能夠重複。鍵值之間用(:)英文的冒號，每一對鍵值之間用英文的逗號(,)隔開。
* 利用元組建構字典
name = (["first","Google"],["second","Yahoo"]) website = dict(name) #website = {'second': 'Yahoo', 'first': 'Google'} ad = dict(name = "qiwsir", age = 42) #ad = {'age': 42, 'name': 'qiwsir'}
* 使用fromkeys，這種方法是從新創建一個dict。
website = {}.fromkeys(("third","forth"),"facebook") #website = {'forth': 'facebook', 'third': 'facebook'}
3） 訪問dict的值
dict數據類型是以鍵值對的形式存儲數據的，因此，只要知道鍵，就能獲得值。這本質上就是一種映射關係。經過字典的「鍵」找到相應的「值」。經過「鍵」可以增長dict中的「值」，經過「鍵」可以改變dict中的「值」，經過「鍵」也可以訪問dict中的「值」。字典沒有索引。
person = {'name2': 'qiwsir', 'name': 'qiwsir', 'language': 'python', 'site': 'qiwsir.github.io'} person['name'] #'qiwsir'
person['language'] #'python'
4）基本操做
len(d) # 返回字典(d)中的鍵值對的數量 d[key] # 返回字典(d)中的鍵(key)的值 d[key]=value # 將值(value)賦給字典(d)中的鍵(key) del d[key] # 刪除字典(d)的鍵(key)項（將該鍵值對刪除） key in d # 檢查字典(d)中是否含有鍵爲key的項
5）要避免 KeyError 的兩個辦法：
key in d
先判斷一下 key 是否存在，用 in 操做符：
dict.get()
使用dict自己提供的一個 get 方法，在Key不存在的時候，返回None。
6） 其餘操做
D.clear() #Remove all items from D D.copy() #淺拷貝 D.get(k[,d]) #-> D[k] 獲取key的value值，獲取不到返回None D.items() #D.iteritems(...) D.keys() #獲取字典的key集合 D.values() #D. itervalues() D.pop(k[,d]) #刪除指定鍵的鍵值對。 D.popitem() #隨機刪除字典的鍵值對。 D.setdefault(k[,d]) #設置鍵值對，若存在不設置，獲取當前的key對應得值，不存在的話，添加。 D.update([E, ]**F) #更新鍵值對。存在的覆蓋，不存在的更新上去。e.g. dic.update({'k1':'111','k2':'123'}) or dic.update({k1=111,k2=123}) dict.fromkeys(*args, **kwargs) #根據序列建立字典，指定的值統一。參數只能兩個，靜態方法 e.g. v=dict.fromkeys(["k1",123]，123); v={"k1":123, 123:123}
6. 集合set
1）定義
由不一樣元素組成的集合，集合中是一組無序排列的可hash值，能夠做爲字典的key。即列表，字典不能夠，數字，字符串，元組能夠。
2）特色
不一樣的集合間用來作關係運算，無需糾結於集合中單個值.list和dict的雜合。set擁有相似dict的特色:能夠用{}花括號來定義；其中的元素沒有序列，也就是是非序列類型的數據；並且，set中的元素不可重複,這就相似dict的鍵。
3）建立
用set()來建立集合，即建立的集合可變。
s2 = set([123,"google","face","book","facebook","book"]) #set(['facebook', 123, 'google', 'book', 'face'])
使用{}的方式建立集合，但沒法建立含有list/dict元素的set。這種方式不提倡使用，由於在某些狀況下，python搞不清楚是字典仍是集合。建立的集合可變。
>>> s3 = {"facebook",[1,2,'a'],{"name":"python","lang":"english"},123} Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'dict'
>>> s3 = {"facebook",[1,2],123} Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'list'
集合另外一個建立方法是用frozenset()，hashable類型，不能在原處修改。即建立的集合不可變。
f_set = frozenset("qiwsir") # frozenset(['q', 'i', 's', 'r', 'w']) f_set.add("python") #報錯，不能修改，則無此方法 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'frozenset' object has no attribute 'add' a_set = set("github") #對比看一看，這是一個能夠原處修改的set, set(['b', 'g', 'i', 'h', 'u', 't']) a_set.add("python") #set(['b', 'g', 'i', 'h', 'python', 'u', 't'])
4) 關係運算
in #屬於 not in #不屬於 A==B # A等於B，即兩個集合的元素徹底同樣或使用A!=B A<B #A是B的子集，或者反過來，B是不是A的超集。即A的元素也都是B的元素，可是B的元素比A的元素數量多。判斷集合A是不是集合B的子集，可使用A<B，返回true則是子集，不然不是。另外，還可使用函數A.issubset(B)判斷。 A<=B A>B A>=B A|B. #A、B的並集，即A、B全部元素。可使用的符號是「|」，是一個半角狀態寫的豎線，輸入方法是在英文狀態下，按下"shift"加上右方括號右邊的那個鍵。找找吧。表達式是A | B.也可以使用函數A.union(B)，獲得的結果就是兩個集合並集，注意，這個結果是新生成的一個對象，不是將結合A擴充。 A|=B #合集 A & B #交集，A、B的交集，即A、B全部的元素：A & B 或A.intersection(B) A&=B A - B #A相對B的差（補），即A相對B不一樣的部分元素： A - B或A.difference(B) ^,^= #對稱差分 (A-B)|(B-A) # A、B的對稱差集：（A-B）| （B-A）或A.symmetric_difference(B)
5） 其餘操做
S.add(self, *args, **kwargs) #添加元素 S.clear(self, *args, **kwargs): #清空元素 S0=S.copy(self, *args, **kwargs): #拷貝集合 S.pop(self, *args, **kwargs): #隨機刪除一個元素 S.remove(self, *args, **kwargs): #刪除某個指定元素，若是元素不存在，會報錯。 e.g. S.remove('sb') S.discard(self, *args, **kwargs): # 與remove功能相同，刪除元素不存在時不會拋出異常 S.union(self, *args, **kwargs): # 求並集，至關於s1Us2 S.difference(self, *args, **kwargs): #求差集，至關於s1-s2 S.difference_update(self, *args, **kwargs): #求完交集求補集，至關於s1=s1-（s1&s2） S.intersection(self, *args, **kwargs): #求交集，至關於s1&s2 e.g. s1.intersection(s2) S.intersection_update(self, *args, **kwargs): # 求交集以後將結果賦值給S，至關於s1=s1&s2 S.symmetric_difference(self, *args, **kwargs): # 求交叉集的補集，至關於s1^s2 ((s1-(s1&s2))U((s2-(s1&s2)) S.symmetric_difference_update(self, *args, **kwargs): #求交叉集的補集,並賦值給S。至關於：s1=((s1-(s1&s2))U((s2-(s1&s2)) S.update(self, *args, **kwargs): #把新的可迭代的值更新到S S.isdisjoint(self, *args, **kwargs): # 判斷是否有交集 S.issubset(self, *args, **kwargs): # 判斷s1是否包含於s2，即s1是否爲s2的子集，至關於s1<=s2 S.issuperset(self, *args, **kwargs): #判斷s2是否包含於s1，即s2是否爲s1的子集，至關於s1>=s2
《參考文獻》
https://www.cnblogs.com/wupeiqi/articles/5433893.html
http://www.cnblogs.com/linhaifeng/articles/5935801.html
http://www.cnblogs.com/wupeiqi/articles/5444685.html
https://www.cnblogs.com/nulige/p/6102645.html
http://www.cnblogs.com/alexzp/p/3377921.html