1、前面第三章有說過了Python有的資料型別，在開始介紹各種資料型別之前，我們先要知道Python的一個內建函式 type() ，用以查詢變數所賦值的資料型別。

>>> a=1
>>> type(a)
<type 'int'>
>>> b='abc'
>>> type(b)
<type 'str'>

2、整型（int 型）

整型就是整數的意思，在數學裡整數包括有正整數、0 、負整數，Python中同樣如此。

>>> a,b,c=-1,0,1
>>> type(a)
 
<type 'int'>
>>> type(b)
<type 'int'>
>>> type(c)
<type 'int'>

3、浮點型 （float 型）

浮點型通俗的說就是小數點型，Python 中的小數有兩種書寫形式：1.3， 1.3e4(等價於1.4*10⁴)

>>> a,b=1.3,1.3e4
>>> type(a)
<type 'float'>
>>> type(b)
<type 'float'>

4、布林型（bool型）

布林型表示真假值，Python中用兩個常量 True 和 False 表示真假。通常用於條件判斷和迴圈語句中

>>> 3>2
True
>>> 3<2
False

注：

1) True 和 False 是 Python 中的關鍵字，當作為 Python 程式碼輸入時，一定要注意字母的大小寫，否則直譯器會報錯。

>>> true
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined
>>> True
True

2) 布林型別可以當做整數來對待，即 True 相當於整數值 1，False 相當於整數值 0

>>> True+1
2
>>> False+1
1

3)布林值可以用and、or和not運算

and是與運算，只有所有都為True，結果才是True；

or 是或運算，只要其中有一個為True，結果就是True；

not 是非運算，結果取反。

5、字元型 （str 型)

字串是以單引號 '' 或雙引號 "" 括起來的任意字符集，字元的內容可以包含字母、數字、標點、特殊符號、中文、日文等全世界的所有文字。

1） Python 字串中的雙引號和單引號沒有任何區別。當字串中需要出現 ’或者“ 時需要使用轉義字元 \

>>> a,b='123',"123"
>>> type(a)
<type 'str'>
>>> type(b)
<type 'str'>

2）字串拼接

兩個字串相加，就相當於把兩個字串拼接起來，用+號實現連線。

>>> "py" + "thon"
'python'

3）索引和切片

字串是由多個字元組成的集合，通過索引找到對應的字元，由左往右的第一個字元對應的索引值是 0 ，依次加 1 位。

>>> a='hello world'
>>> a[0]
'h'
>>> a[4]
'o'

如何通過字元得到對應索引值？這時候就使用到 index() 函式

>>> a.index('e')
1

通過索引得到字元的過程，稱之為切片。

>>> a='hello world'  
>>> a[1:]                   #得到從索引值1開始到最末尾的字元
'ello world'  
>>> a[1:4]             #得到從索引值1開始到索引值4之前的字元，不含4的值
'ell'                                    #即1<=x<4
>>> a[:4]                 #得到從索引值4之前的字元，不含4的值
'hell'
>>> a[:]                  #得到從所有的字元
'hello world'

4）字串的一些基本操作>>> a,b='qw','qwe'

>>> a+b          #字串拼接
'qwqwe'
>>> 'a' in a   #判斷某個字串是否存在於另一個字串內，存在為真，否為假
False
>>> 'q' in a
True

#每個字元在計算機內都是有編碼的，也就是對應著一個數字,即在ASCII中的值。根據數字大小進行比較
>>> max(a)   #提取字串中的最大值，
'w'
>>> min(a)     #提取字串中的最小值
'q'
>>> cmp(a,b)   #兩個字串進行比較，也是首先將字串中的符號轉化為對一個的數字，然後比較。如果返回的數值小於零，說明第一個小於第二個，等於0，則兩個相等，大於0，第一個大於第二個。
 -1                 #在字串的比較中，是兩個字串的第一個字元先比較，如果相等，就比較下一個，如果不相等，就返回結果。直到最後，如果還相等，就返回0。位數不夠時，按照沒有處理  
>>> ord('a')   #ord()函式，返回某個字元（注意，是一個字元，不是多個字元組成的串）所對一個的ASCII值（是十進位制的），字元a在ASCII中的值是97，空格在ASCII中的值是32。
97
>>> chr(97)        #chhr()函式，根據ASCII值得到對應字元
'a'

>>> len(a)       #得到字串的長度
2
>>> type(a)            查詢變數型別
<type 'str'>

6、列表（List）

python中用方括號 [ ] 表示一個list，方括號裡面可以是各種資料型別。

>>> a=[1,'q',True]
>>> type(a)
<type 'list'>

1）列表也有類似字串一樣的索引和切片，方法一樣

>>> a=[1,23,2]
>>> a[0]
1
>>> a.index(1)
0

2）反轉：字串倒過來。

反轉，不是在“原地”把原來的值倒過來，而是新生成了一個值，那個值跟原來的值相比，是倒過來了，原來的值還存在於變數中

反轉有兩種方式：

>>> a=[1,23,2]
>>> a[::-1]          #方式一
[2, 23, 1]
>>>a
[1,23,2]
>>> list(reversed(a))   #方式二
[2, 23, 1]

3）基礎操作

>>> a.append("like")       #增加列表元素，追加到尾部
>>> a
[1, 23, 2, 'like']
>>> b=['q', 'w']
>>> a.extend(b)   #b中的所有元素加入到a中
>>> a
[1, 2, 3, 'q', 'w']
>>> b
['q', 'w']

>>> a = "python"
>>> hasattr(a,'__iter__')  
False
>>>b = [1,2]
>>> hasattr(b,'__iter__')  
True
#hasattr()判斷一個字串是否是可迭代的，是返回True,否返回False。其判斷本質就是看該型別中是否有__iter__函式。用dir()查詢整型、字串、列表中，誰有__iter__。
>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

#id()函式檢視變數在記憶體的位置編碼
>>> id(a)
140571421973464
>>> id(b)
140571377764352

4）insert(i, x)函式，含義是將元素 x 插入到索引值是 i 的元素前面。索引值是從0開始的。

>>> a=['a','b','c','d']
>>> a.insert(2,'q')
>>> a
['a', 'b', 'q', 'c', 'd']
>>> a.insert(9,'w')
>>> a
['a', 'b', 'q', 'c', 'd', 'w']

注：當 i 的值大於 list 中的最大索引值時，元素 x 自動插入 list 末尾。

5）remove(x)函式，刪除列表中的x元素。注：當列表中含有多個不緊鄰的x元素時，只刪除第一個x元素，若相鄰的就一起刪除

>>> a=['a', "a",'b', 'c', 'd', 'w']
>>> a.remove('a')
>>> a
['a', 'b', 'c', 'd', 'w']
>>> a=['a','b','a', 'c', 'd', 'w']
>>> a.remove('a')
>>> a
['b', 'a', 'c', 'd', 'w']

6）pop(i)函式，刪除指定索引值 i 對應的元素，並將刪除結果返回，若不寫 i , 預設刪除最後一個元素。

>>> a=['b', 'a', 'c', 'd', 'w']
>>> a.pop()
'w'
>>> a
['b', 'a', 'c', 'd']
>>> a.pop(2)
'c'

7）reverse()函式，將列表反轉，等同於 list[ : :-1]

>>> a=['a','b','c']
>>> a.reverse()
>>> a
['c', 'b', 'a']
>>> a[::-1]
['a', 'b', 'c']

8）sort()函式，對原列表進行排序，語法：

list.sort(cmp=None,key=None,reverse=False)   #python 2.x

list.sort( key=None, reverse=False)     #python 3.x

key -- 主要是用來進行比較的元素，只有一個引數，具體的函式的引數就是取自於可迭代物件中，指定可迭代物件中的一個元素來進行排序。預設值None

reverse -- 排序規則，reverse = True降序，reverse = False升序（預設）。

>>> a=['qwe','rty','uiop']
>>> a.sort()
>>> a
['qwe', 'rty', 'uiop']
>>> a.sort(key=len)
>>> a
['qwe', 'rty', 'uiop']
>>> a.sort(key=len,reverse=True)
>>> a
['uiop', 'qwe', 'rty']
>>> b=[45,5,7,3]
>>> b.sort()
>>> b
[3, 5, 7, 45]

此外，還有一個內建函式sorted()用於排序

sorted(iterable,cmp=None,key=None,reverse=False)#python 2.x

注：兩函式的的區別是， sort( )函式時是在原列表上進行排序，無返回值；而sorted( )函式是返回一個新的list,不在原來的list上進行操作，呼叫其返回一個排好序的list。

>>> b
[3, 5, 7, 45]
>>> c=sorted(b)
>>> c
[3, 5, 7, 45]

9）split()函式，指定分隔符對字串進行分割，分割後的字串以逗號“，”隔開。

語法：str.split(str="", num=string.count(str))

• str -- 分隔符，預設為所有的空字元，包括空格、換行(\n)、製表符(\t)等。
• num -- 分割次數。分隔出 num+1 個子字串，預設為 -1, 即分隔所有。

>>> a="hello world to you"
>>> a.split()
['hello', 'world', 'to', 'you']
>>> a
'hello world to you'
>>> a.split(" ",1)
['hello', 'world to you']
>>> a.split(" ",2)
['hello', 'world', 'to you']

10）join() 函式用於將序列中的元素以指定的字元連線生成一個新的字串。

語法：str.join(sequence)

str：指定字元 sequence:序列名

>>> a,b=(1,2,3,4,5),['a','b','c','d']
>>> "".join(b)
'abcd'
>>> "".join(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected string, int found
>>> print(" ".join('%s' %id for id in a))
1 2 3 4 5
>>> " ".join('%s' %id for id in a)
'1 2 3 4 5'

注：若序列中元素包含數字，則join()會報錯。需遍歷序列中元素，將之轉化成字串。這樣就能成功輸出數字結果。

11）remove()函式，刪除列表中的某個元素

>>> b=[1,2,3]
>>> b.remove(2)
>>> b
[1, 3]

Python的序列型別：字串、列表、元組

7、元組（tuple）

Python 中元組用圓括號 () 括起來的，其中的元素之間用逗號隔開。

1)元組的建立

>>> a=()                 #建立空元組
>>> type(a)
<type 'tuple'>
>>> b=(1)
>>> type(b)     
<type 'int'>
>>> b=(1,)       #建立元組時，元素的數量必須大於1，只有1個元素是整型int,不是元組型
>>> type(b)
<type 'tuple'>
>>> c=1,'q',[1,2]   #多種資料型別組合在一起，是元組型
>>> type(c)
<type 'tuple'>

2）元組也是序列型別，也存在索引和切片操作

>>> c=1,'q',[1,2]
>>> type(c)
<type 'tuple'>
>>> c[1]
'q'
>>> c[2]
[1, 2]
>>> c[2][0]   #單獨提取元素中的小元素
1
>>> c[2][1]
2

3) 元組操作

元組中的元素不允許修改和刪除，可以對元組進行拼接（+），也使用del語句來刪除整個元組

>>> tup1 = (12, 34.56)
>>> tup2 = ('abc', 'xyz')
>>> tup1+tup2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate tuple (not "list") to tuple
>>> tup1+tup2
(12, 34.56, 'abc', 'xyz')
>>> tup3=tup1+tup2
>>> tup3
(12, 34.56, 'abc', 'xyz')
>>> del tup3
>>> tup3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'tup3' is not defined

注：元組拼接的資料型別必須相同，否則拼接不成功。

>> tup1,tup2=(1,2,3),[2,'qw','c']
>>> tup3=list(tup1)       #資料型別強制轉換，轉換成列表
>>> tup3+tup2
[1, 2, 3, 2, 'qw', 'c']

8、字典（dict）

Python中字典由花括號{} 加鍵值對組成，每個鍵值對(key：value) 用冒號: 隔開，每個對之間用逗號(,)分割，格式如下所示：

dict = {key1 : value1, key2 : value2, key3 : value3 }
鍵是唯一的不能重複，所以可以用數字，字串或元組充當，而用列表就不行。值不唯一。

1）字典建立

>>> a={}            #建立空字典
>>> a["key1"]=12        #給字典中新增鍵值對
>>> a
{'key1': 12}
>>> b=dict(key1=32,key2=43)          #利用dict()函式建立字典
>>> b
{'key2': 43, 'key1': 32}
>>> c=(['q','w'],[1,2])           
>>> c=dict(c)                  #dict()函式加元組構成字典
>>> c
{'q': 'w', 1: 2}
以上方法得到的還是原來的字典，即在字典上操作

Python 字典 fromkeys() 函式，建立一個新字典
語法： dict.fromkeys(seq, value)
以序列 seq 中元素做字典的鍵，value 為字典所有鍵對應的初始值。
引數
seq -- 字典鍵值列表。
value -- 可選引數, 設定鍵序列（seq）的值。
返回值
該方法返回一個新字典。

>>> d= {}.fromkeys(("q","w"),(1,2)) #
>>> c
{'q': 'w', 1: 2}
>>> d
{'q': (1, 2), 'w': (1, 2)}

2）基本操作：

• len(d)，返回字典(d)中的鍵值對的數量
• d[key]，返回字典(d)中的鍵(key)的值,若鍵不存在，則報錯
• d.get(key)，得到鍵key的值，若鍵不存在，則返回None
• d[key]=value，將值(value)賦給字典(d)中的鍵(key)
• del d[key]，刪除字典(d)的鍵(key)項（將該鍵值對刪除）
• d.clear() 函式，清空字典
• key in d，檢查字典(d)中是否含有鍵為key的項
• str(d),輸出字典，以可列印的字串表示。

>>> a={1:12,2:13,3:14}
>>> a.[4]
  File "<stdin>", line 1
    a.[4]
      ^
SyntaxError: invalid syntax     #dict[key]與dict.get(key)的區別
>>> a.get(4)
>>> 
>>> print(a.get(4))
None

copy()函式，複製新的變數 dict.copy()

>>> q=d.copy()         #copy後在新變數上操作不影響原來的變數
>>> q
{'q': (1, 2), 'w': (1, 2)}
>>> id(d)
139753898228264
>>> id(q)
139753942536832
>>> w=d             #在原來變數上操作
>>> id(w)
139753898228264

3）setdefault() 函式和 get()類似, 得到鍵的值，如果鍵不存在於，則新增鍵並將值設為預設值None。

語法：dict.setdefault(key, default=None)

>>> a
{1: 12, 2: 13, 3: 14}
>>> a.setdefault(4)
>>> a
{1: 12, 2: 13, 3: 14, 4: None}
>>> a.setdefault(5,16)
16
>>> a
{1: 12, 2: 13, 3: 14, 4: None, 5: 16}

4）items()和iteritems()函式

items()函式，將字典以列表形式返回，列表中的元素是由字典中的鍵和值組成的元組

>>> b={1: 12, 2: 13, 3: 14, 4: None, 5: 16}
>>> b.items()
[(1, 12), (2, 13), (3, 14), (4, None), (5, 16)]
>>> b={1: 12, 7: 13, 3: 14, 4: None, 5: 16}
>>> b.items()
[(1, 12), (3, 14), (4, None), (5, 16), (7, 13)]

iteritems()函式，將字典返回成迭代器，是一個'dictionary-itemiterator'型別，不過這種迭代器型別的資料不能直接輸出，必須用list()轉換一下，才能看到裡面的真面目。

>>> b={1: 12, 7: 13, 3: 14, 4: None, 5: 16}
>>> b.items()
[(1, 12), (3, 14), (4, None), (5, 16), (7, 13)]
>>> c=b.iteritems()
>>> c
<dictionary-itemiterator object at 0x7f743743efc8>
>>> list(c)
[(1, 12), (3, 14), (4, None), (5, 16), (7, 13)]

5）keys()和values()函式

>>> b={1: 12, 7: 13, 3: 14, 4: None, 5: 16}
>>> b.keys()           #提取字典中的鍵
[1, 3, 4, 5, 7]
>>> b.values()                #提取字典的值
[12, 14, None, 16, 13]

6）pop()和popitem()函式

pop(key[,default])函式 ，刪除字典給定鍵 key 及對應的值，返回值為被刪除的值，key必須寫

key: 要刪除的鍵值

default: 如果沒有對應key值，返回default值，[]內為可選

popitem() 函式，隨機刪除字典中一對鍵和值。並返回該鍵值對。若字典為空，就報出 KeyError 異常。

>>> b={1: 12, 7: 13, 3: 14, 4: None, 5: 16}
>>> b.popitem()
(1, 12)
>>> b.pop(7)
13

7)has_key()函式，判斷字典中是否存在某個鍵，等同於 "key in dict"

>>> b={1: 12, 7: 13, 3: 14, 4: None, 5: 16}
>>> b.has_key(1)
True
>>> 1 in b
True

9、集合（set）

集合建立用花括號{ }或者set()函式。

注意：

建立一個空集合必須用set()而不是{ }，因為{ }是用來建立一個空字典。

集合中的元素無序，不可重複。

不推薦使用花括號{}建立集合，因為Python難以分辨是字典還是集合

set()函式可以建立一個無序不重複的元素集，這個函式至多可以傳一個引數，否則會報錯；可以傳比如串一個字串或者一個列表，只含有一個引數

>>> a=set("A",12)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: set expected at most 1 arguments, got 2
#例項中傳了2個引數，所以會報錯
>>> a=set("Asdad")

>>> a=set(["["a","b"]","q","w","e"])
File "<stdin>", line 1
a=set(["["a","b"]","q","w","e"])
^
SyntaxError: invalid syntax
>>> a=set(['["a","b"]',"q","w","e"]) #單引號和雙引號配合使用，不能單引號巢狀單引號，或者雙引號巢狀雙引號

1）list()和set()能夠實現兩種資料型別之間的轉化。

2）基本操作

set.add(元素) 向set集合中新增元素

set1.update(set2) 將集合set2更新到集合set1中

>>> a.add("q")
>>> a
set(['A', 1, 2, 'q'])
>>> b=set()
>>> b.update(a)
>>> b
set(['A', 1, 2, 'q'])
>>> c.update(a)            
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'dictionary-itemiterator' object has no attribute 'update'
# 注得先建立集合才能使用update，否則會報錯，字典也是一樣，得先創建出存在的字典

set.pop()函式，任意選一個元素刪除並將這個值返回。pop()不能有引數，否則報錯。此外,如果set是空的了,也報錯。

set.remove(obj)函式，刪除指定元素obj,該元素必須是set中的元素,否則就報錯。

set.discard(obj)函式，刪除指定元素obj，obj如果是set中的元素,就刪除,如果不是,就什麼也不做。

set.clear()函式，清空集合中的所有元素，得到空集合。

3) set()創立的集合都是可原處修改的集合，即裡面的元素可變；frozenset()創立的集合不能在原處修改，裡面的元素不可變。

>>> a=frozenset()
>>> type(a)
<type 'frozenset'>

4）判斷集合A與集合B的關係

>>> a=set(['q', 'w', 'e', 'r'])
>>> b=set(['q', 'w'])
>>> b<a     #c是a的子集
True
>>>b.issubset(a)   #或者用這種方法，判斷c是否是a的子集
True
>>> a.issuperset(c) #判斷a是否是c的超集
True
>>> a | b                       #並集，可以有兩種方式，結果一樣
set(['q', 'w', 'e', 'r'])
>>> a.union(b)
set(['q', 'w', 'e', 'r'])
>>> a & b       #交集，兩種方式，等價
set(['q', 'w'])
>>> a.intersection(b)
set(['q', 'w'])
>>> a - b                #A相對B的差（補）
set('e', 'r'])
>>> a.difference(b)
set(['e', 'r'])
>>> c=set(['q', 'w','s'])    #A、B的對稱差集
>>> a.symmetric_difference(c)
set(['s', 'r', 'e'])