摘要：的強大之處在于數據操作的方便和大類的第三方本文主要是學習收集數據操作相關的內容相關內容通過代碼對基本內容進行學習這是一個空的注意這不是一個變量，而是一個類型的變量注意與上面的例子對比，這里在括號內加了一個逗號，變量類型為變量包含多個元素，元

#通過代碼對基本內容進行學習
empty=() #這是一個空的tuple

onestr=("hello world")    #注意這不是一個tuple變量，而是一個str類型的變量 

onetuple=("hello world",) #注意與上面的例子對比，這里在括號內加了一個逗號，變量類型為tuple

multituples=(1,"hellow",3.14) #tuple變量包含多個元素，元素的類型可以不一樣

multituples=1,"hellow",3.14  #這個例子也是tuple類型，與上例效果一樣，只是一種偷懶的寫法


#tuple中，選擇子tuple的方法與list一樣，這里就不多說了，如下
name[:3]  #前三個元素 
name[-3:] #最后三個元素 
name[3:6] #位置3,4,5 這三個元素 ，注意不包含位置6的元素 

#由于tuple內部的數據是可嵌套的，所以內部的數據是什么類型，也很重要

#看一個tuple不怎么用的功能，把world分解成每一個alphabet
In [1]: tuple("hello")
Out[1]: ("h", "e", "l", "l", "o")

In [2]: tuple("hello world")
Out[2]: ("h", "e", "l", "l", "o", " ", "w", "o", "r", "l", "d")

varlist=[] #空的list

#list中，選擇子list的方法,如下
name[:3]  #前三個元素 
name[-3:] #最后三個元素 
name[3:6] #位置3,4,5 這三個元素 ，注意不包含位置6的元素

#list的insert方法
varlist.insert(4,"apple") #在位置4插入"apple"值，原來在位置4的值，往后退一位，變成位置5上的值

#list中刪除一個元素的方法 
del varlist[3]     #這樣會把位置3的元素值給刪掉
del valist[0:2]    #刪除位置 0,1的兩個元素 
del valist[3:5]    #刪除位置 3,4的兩個元素 

#改變某一個位置的元素 
varlist[3]="hello"


#下面是List中常用的一些方法 
if x in List :  #判斷 item是不是在list中存在
if x not in List: #同上，這里的item可以是子List
#如下看例子
In [36]: a
Out[36]: [1, 2, 3, 6, 7, 8, 9, [1, 2, 4]]

In [37]: [1,2,4] in a
Out[37]: True

#List容器的擴展
# 直接做+產生新的擴展list,不會影響a,b的值
In [39]: a=[i  for i in range(1,5)]

In [40]: a
Out[40]: [1, 2, 3, 4]

In [41]: b=[6,7,8]

In [42]: a+b
Out[42]: [1, 2, 3, 4, 6, 7, 8]

In [43]: a
Out[43]: [1, 2, 3, 4]

In [44]: b
Out[44]: [6, 7, 8]

#使用list容器的 extend函數，如下，a的內容被 擴展了

In [45]: a
Out[45]: [1, 2, 3, 4]

In [46]: b
Out[46]: [6, 7, 8]

In [47]: a.extend(b)

In [48]: a
Out[48]: [1, 2, 3, 4, 6, 7, 8]

#刪掉list中的某個item,如下，可以看到remove是從左往右查找，找到第一需要刪除的item就刪除掉 
In [56]: a
Out[56]: [1, 2, 3, 4, 5, 6, 7]
In [57]: a.append(7)

In [58]: a
Out[58]: [1, 2, 3, 4, 5, 6, 7, 7]

In [59]: a.remove(7)
In [60]: a
Out[60]: [1, 2, 3, 4, 5, 6, 7]

#使用append()追加函數和pop()函數，實現stack的效果
In [66]: a
Out[66]: [1, 2, 3, 4, 5, 6, 7]

In [67]: a.append(8)

In [68]: a
Out[68]: [1, 2, 3, 4, 5, 6, 7, 8]

In [69]: cell=a.pop()

In [70]: cell
Out[70]: 8

In [71]: a
Out[71]: [1, 2, 3, 4, 5, 6, 7]

#pop(int)還可以指定彈出某一位置的值，如下
In [72]: a
Out[72]: [1, 2, 3, 4, 5, 6, 7]

In [73]: a.pop(0)
Out[73]: 1

In [74]: a
Out[74]: [2, 3, 4, 5, 6, 7]

#list的reverse()和sort()方法也是經常會使用到的


# 關于list的shadow copy和 deep copy
# 下面是shadow copy的例子，b的值改變了會影響a的值
# 所以shadow copy中，b變量只是a變量的別名，操作的是同一塊內存空間
In [76]: a
Out[76]: [2, 3, 4, 5, 6, 7]

In [77]: b=a

In [78]: b[0]=100

In [79]: a
Out[79]: [100, 3, 4, 5, 6, 7]

In [80]: b
Out[80]: [100, 3, 4, 5, 6, 7]

#使用deep copy的方法 ，賦值時使用b=a[:] 這處形式即可，a,b的操作互不影響對方
In [81]: a
Out[81]: [100, 3, 4, 5, 6, 7]

In [82]: b=a[:]

In [83]: b[0]=200

In [84]: a
Out[84]: [100, 3, 4, 5, 6, 7]

In [85]: b
Out[85]: [200, 3, 4, 5, 6, 7]

#dict是相當重要的一類容器
#注意dict的key不能是數字
In [1]: vardict=dict(name="Tome",age=22,height=1.75)

In [2]: vardict
Out[2]: {"age": 22, "height": 1.75, "name": "Tome"}

In [3]: vardict=dict(name="Tome",age=22,height=1.75,3=5)
  File "", line 1
    vardict=dict(name="Tome",age=22,height=1.75,3=5)
SyntaxError: keyword can"t be an expression


In [4]: vardict=dict(name="Tome",age=22,height=1.75,test=(3,4))

In [5]: vardict
Out[5]: {"age": 22, "height": 1.75, "name": "Tome", "test": (3, 4)}

#如上test這個key就對應著多個值，所以 1個 key 對應多個值，這種情況，在python中就不是問題，
#因為在Python中，容器是可嵌套的


#在vardict字典變量中插入一對key,value
In [9]: vardict["gendar"]="male"

In [10]: vardict
Out[10]: {"age": 22, "gendar": "male", "height": 1.75, "name": "Tome", "test": (3, 4)}

#刪除dict變量中的key,value,只需要知道key值就足夠了
In [10]: vardict
Out[10]: {"age": 22, "gendar": "male", "height": 1.75, "name": "Tome", "test": (3, 4)}

In [11]: del vardict["age"]
   
In [12]: vardict
Out[12]: {"gendar": "male", "height": 1.75, "name": "Tome", "test": (3, 4)}


#dict變量中彈出一個key,value的方法 pop(key)
In [15]: vardict
Out[15]: {"gendar": "male", "height": 1.75, "name": "Tome", "test": (3, 4)}

In [16]: vardict.pop("gendar")
Out[16]: "male"

In [18]: vardict
Out[18]: {"height": 1.75, "name": "Tome", "test": (3, 4)}


# 判斷key,value 在dict變量中是否存在的方法 
# 從下面的例子可知 keys(),values()函數返回的是一個可迭代的對象list對象
In [23]: vardict
Out[23]: {"height": 1.75, "name": "Tome", "test": (3, 4)

In [24]: "height" in vardict.keys()
Out[24]: True

In [25]: 1.75 in vardict.values()
Out[25]: True

# 使用clear()方法，清空dict對象
In [27]: vardict
Out[27]: {"height": 1.75, "name": "Tome", "test": (3, 4)}

In [28]: vardict.clear()

In [29]: vardict
Out[29]: {}



#直接把dcit對象賦值給另一個對象，使用的是shadow copy方式，相當于c++里面的引用，看如下例子
In [32]: vardict
Out[32]: {"age": 22, "height": 1.75, "name": "Tome"}

In [33]: shadowdict=vardict

In [34]: shadowdict
Out[34]: {"age": 22, "height": 1.75, "name": "Tome"}

In [35]: shadowdict["age"]=25

In [36]: shadowdict
Out[36]: {"age": 25, "height": 1.75, "name": "Tome"}

In [37]: vardict
Out[37]: {"age": 25, "height": 1.75, "name": "Tome"}


#當我們使用了copy操作，對一個對象進行復制后，兩個對象是相互不影響的，如下例子
In [50]: vardict
Out[50]: {"age": 25, "height": 1.75, "name": "Tome"}

In [51]: adict=vardict.copy()

In [52]: adict
Out[52]: {"age": 25, "height": 1.75, "name": "Tome"}

In [53]: adict["age"]=888

In [54]: vardict
Out[54]: {"age": 25, "height": 1.75, "name": "Tome"}

In [55]: adict
Out[55]: {"age": 888, "height": 1.75, "name": "Tome"

#如下又一個例子，可見dict對象的copy方法復制對象還是非常徹底的
In [60]: vardict
Out[60]: {"age": 25, "height": 1.75, "name": "Tome", "subdict": {"a": 4, "b": 5}}

In [61]: adict=vardict.copy()

In [62]: adict
Out[62]: {"age": 25, "height": 1.75, "name": "Tome", "subdict": {"a": 4, "b": 5}}

In [63]: adict["subdict"]="hello world"

In [65]: adict
Out[65]: {"age": 25, "height": 1.75, "name": "Tome", "subdict": "hello world"}

In [66]: vardict
Out[66]: {"age": 25, "height": 1.75, "name": "Tome", "subdict": {"a": 4, "b": 5}}

#再看下面的例子可以知道dict的變量的copy()只是對 對象進行一層copy,第二層沒有進行copy,
In [67]: vardict
Out[67]: {"age": 25, "height": 1.75, "name": "Tome", "subdict": {"a": 4, "b": 5}}

In [68]: adict=vardict.copy()

In [69]: adict["subdict"]["a"]=55

In [70]: adict
Out[70]: {"age": 25, "height": 1.75, "name": "Tome", "subdict": {"a": 55, "b": 5}}

In [71]: vardict
Out[71]: {"age": 25, "height": 1.75, "name": "Tome", "subdict": {"a": 55, "b": 5}}

In [72]: vardict["age"]=88

In [73]: adict
Out[73]: {"age": 25, "height": 1.75, "name": "Tome", "subdict": {"a": 55, "b": 5}}

In [74]: vardict
Out[74]: {"age": 88, "height": 1.75, "name": "Tome", "subdict": {"a": 55, "b": 5}}


#dict變量中可以進行迭代的一些量
d.keys() ,d.values(),d.items()
for key,value in d.items():

#返回 key對應的value
d.get(key)     #如果沒有這個key,則返回None
d.get(key,x)   #如果沒有這個key,則返回x

# 下面是get方法的用法
In [6]: vardict.get("a")
Out[6]: 4

In [7]: vardict.get("0")

In [8]: a=vardict.get("0")

In [9]: a

In [10]: print a
None

In [11]: vardict
Out[11]: {"a": 4, "b": 5, "c": 6, "d": "hello"}

In [12]: if a==None:
   ....:     print "yes"
   ....:     
yes

# 由于vardict里面沒有"0"這個key,所以會返加"baby"

In [13]: vardict.get("0","baby")
Out[13]: "baby"

In [14]: vardict
Out[14]: {"a": 4, "b": 5, "c": 6, "d": "hello"}

#下面是setdefault(key)的用法
In [26]: vardict=dict(a=1,b=2)

In [27]: a=vardict.setdefault("aa")  #由于"aa"之前不存在，所以返回None
In [28]: vardict
Out[28]: {"a": 1, "aa": None, "b": 2}  # 并且這個"aa" key也加入到vardict里面了

#下面setdefault(key,value)的用法
In [33]: vardict
Out[33]: {"a": 1, "aa": None, "b": 2}

In [34]: a=vardict.setdefault("bb","baby") #由于"bb" key之前不存在，所以 返回"baby",并且將這個一對key,value加入到vardict中

In [35]: print a
baby

In [36]: vardict
Out[36]: {"a": 1, "aa": None, "b": 2, "bb": "baby"}


#下例，由于"bb"key之前存在，所以返回"bb"的value,
In [37]: a=vardict.setdefault("bb","gaga")

In [38]: print a
baby

In [39]: vardict
Out[39]: {"a": 1, "aa": None, "b": 2, "bb": "baby"}



#下面的例子與上面的d.get,d.setdefault也是一樣的工作原理
d.pop(k)  #如果存在k 鍵 ，則返回對應value,否則返回None
d.pop(k,x) #如果存在k 鍵，則返回對應的value,否則返回x

#下面是pop的用法
In [39]: vardict
Out[39]: {"a": 1, "aa": None, "b": 2, "bb": "baby"}
In [40]: vardict.pop("xx",3)  #沒有"xx" key，所以返回3
Out[40]: 3

In [41]: vardict.pop("a",3)   #存在"a" key, 所以返回對應的value
Out[41]: 1

In [42]: vardict              #并且可以看到，這個key,value已經被彈出
Out[42]: {"aa": None, "b": 2, "bb": "baby"}

#由于Set用的相對較少，所以也不多說
#Set容器的重要特點就是唯一性
#看下面例子就可以了

In [43]: a=set()

In [44]: type(a)
Out[44]: set

In [45]: a=set(3,4,5,"hellO") #這樣是不對的哦
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 1 a=set(3,4,5,"hellO")

TypeError: set expected at most 1 arguments, got 4

In [46]: a=set((3,4,5,"hellO"))  #這樣才對，兩個括號

#set元素的唯 一性
In [46]: a=set((3,4,5,"hellO"))

In [47]: a.add(3)  #因為上面已經存在3了，加了也沒用

In [48]: a
Out[48]: {3, 4, 5, "hellO"}

In [49]: a.add(6)

In [50]: a
Out[50]: {3, 4, 5, 6, "hellO"}

#set的remove
In [57]: a
Out[57]: {3, 4, 5, 6, 9, "hellO"}

In [58]: 9 in a
Out[58]: True

In [59]: 10 in a
Out[59]: False

In [60]: a.remove(3)

In [61]: a
Out[61]: {4, 5, 6, 9, "hellO"}

In [62]: a.remove(0) # 由于0不在set a中,所以報錯了 
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in ()
----> 1 a.remove(0)

KeyError: 0

#set的常用函數
x in set
x not in set
len(set)
set.clear()
set.copy() #只會復制第一層
s.add(x)  #只會加一次
s.remove(x) #把x去掉 ，x不存在會報錯，所以remove 之前，做一下 if x in a:
s.dicard(x) #把x去掉， x不存在也不會報錯

s.issubset(t) #當s是t的子集時，返回true   s <= t
s.issuperset(t) #當s是t的超集時，返回true s >= t

s.union(t)         #不影響s,t，做 “或”運算，返回一個新的集合
s.intersection(t)  #不影響s,t，做 “與”運算，返回一個新的集合
s.difference(t)    #不影響s,t，做 “-”運算， 返回一個新的集合 

#all(q)函數，q中所有元素都是true時，返回true,q是可iterable
In [75]: a
Out[75]: {5, 6, 9, "hellO"}

In [76]: all(a)
Out[76]: True

In [77]: a.add(None)

In [78]: a
Out[78]: {None, 5, 6, 9, "hellO"}

In [79]: all(a)
Out[79]: False

In [80]: any(a)  #any(q)函數，只要q中有一個item是true,則返回ture
Out[80]: True

#常用小函數，不解釋
 x in q , x not in q ,  len(q) ,max(q)

In [84]: max(("tom","jerry","zuangta")) #比較首字母的ascii值
Out[84]: "zuangta"

In [85]: min(("tom","jerry","zuangta")) #比較首字母的ascii值
Out[85]: "jerry"

In [86]: max(3,4,5)
Out[86]: 5

In [87]: min(3,4,5)
Out[87]: 3

In [92]: sum([i for i in range(1,101)]) #一行代碼，求1到100的和
Out[92]: 5050

In [93]: sum((1,2,3))
Out[93]: 6

In [94]: len([i for i in range(1,101)])
Out[94]: 100

chr(int),unichr(int),ord(character)
dir(x) #返回module的method and attributes
hasattr(x,a) #這個很重要，后面需要特別研究
id(x) #相當于變量x的內存地址，如果id(x),id(y)相同，那么x與y互為別名

isinstance(x, C) #如果變量x是 類C的一個實例，返回true,如下例子
In [129]: a=3
In [130]: isinstance(a,int)
Out[130]: True
In [131]: isinstance(a,float)
Out[131]: False
type(x) #查看x的類型，多用于debug

#eval(s) 就下面這點用？？
In [138]: a
Out[138]: 3
In [139]: s="a+2"
In [142]: a=eval(s)
In [143]: a
Out[143]: 5

#文件操作，這個太重要了
open(f, m)

range(i) #產生 0到i-1的list

In [146]: divmod(6,4) #這個函數好用
Out[146]: (1, 2)

#幾個基本的數操作函數 
hex(i)  #注意下面的結果，返回的是str類型
In [147]: hex(16)
Out[147]: "0x10"
In [148]: hex(15)
Out[148]: "0xf"


oct(int) #返回的是8進行的表達式，返回類型為str
In [154]: oct(7)
Out[154]: "07"

In [155]: oct(8)
Out[155]: "010"

In [156]: oct(16)
Out[156]: "020"

#float函數，注意傳入參數可以是str，也可以是數字
In [160]: float("3")
Out[160]: 3.0

In [161]: float(3)
Out[161]: 3.0

In [162]: float("3.4")
Out[162]: 3.4

In [163]: float("3e10") #這樣也是可以的
Out[163]: 30000000000.0

#int()函數的使用
In [164]: int("33")
Out[164]: 33

In [165]: int(44.4)
Out[165]: 44

In [166]: int("44.4") #這樣就報錯了，怎么辦
ValueError: invalid literal for int() with base 10: "44.4"

In [167]: int(float("44.4")) #先轉化為float再int，就可以了
Out[167]: 44


#long()函數的使用
In [168]: long(333)
Out[168]: 333L

In [169]: long("333")
Out[169]: 333L

In [170]: long("333.3") #又報錯了，同上面的解決方法一樣
ValueError: invalid literal for long() with base 10: "333.3"

In [171]: long(float("333.3")) #內部嵌套一個float轉換即可
Out[171]: 333L

#pow(x,y)的使用
In [185]: pow(2,3)
Out[185]: 8

In [186]: pow(2,-3)
Out[186]: 0.125

#round(x,n) 4舍5入，精確到幾位小數
In [187]: round(3.1415926,2)
Out[187]: 3.14

In [188]: round(3.1415926,3)
Out[188]: 3.142

In [189]: round(3.1415926)
Out[189]: 3.0

#demo 1
In [99]: a=[1,3,4]

In [100]: b=a #shadow copy,b是a的別名，下面可以看到，都是指向同一塊內存地址 

In [101]: id(b)
Out[101]: 139824773228304

In [102]: id(a)
Out[102]: 139824773228304

#demo 2
In [103]: a
Out[103]: [1, 3, 4]

In [104]: b=a[:] #id都不同了

In [105]: id(a)
Out[105]: 139824773228304

In [106]: id(b)
Out[106]: 139824773228232

#但是 下面的現象，你可以知道什么 ，呵呵
#下面的情況，還是python為了節約內存的一種做法
#python的解釋器太過智能了
In [107]: id(b[0])
Out[107]: 30560600

In [108]: id(a[0])
Out[108]: 30560600

In [109]: b[0]=33 #當b[0]的內容發生變化時，就會分配一塊新的內存給b[0]

In [110]: id(a[0])
Out[110]: 30560600

In [111]: id(b[0])
Out[111]: 30559832

#demo 3 這個更難了，所以書中說的shadow copy實際就是說只復制了一層
In [115]: a
Out[115]: [1, 2, [3, 4]]

In [116]: b=a[:]

In [117]: id(b)
Out[117]: 139824773228160

In [118]: id(a)
Out[118]: 139824773229240

In [119]: id(b[2])
Out[119]: 139824789304600

In [120]: id(a[2])
Out[120]: 139824789304600

In [121]: b[2].append(88)

In [122]: a
Out[122]: [1, 2, [3, 4, 88]]

In [123]: b
Out[123]: [1, 2, [3, 4, 88]]

In [124]: id(a[2])
Out[124]: 139824789304600

In [125]: id(b[2])
Out[125]: 139824789304600

In [126]: a[0]=33

In [127]: a
Out[127]: [33, 2, [3, 4, 88]]

In [128]: b
Out[128]: [1, 2, [3, 4, 88]]


#deep copy后面再整理

#round函數4舍5入
In [3]: round(1.4999)
Out[3]: 1.0

In [4]: round(1.5000)
Out[4]: 2.0

In [5]: round(1.5)
Out[5]: 2.0

In [6]: round(1.2)
Out[6]: 1.0

#ceil函數，向上取整
In [9]: import math

In [10]: math.ceil(1.2)
Out[10]: 2.0

In [11]: math.ceil(1.8)
Out[11]: 2.0

#foor函數，向下取整
In [12]: math.floor(1.2)
Out[12]: 1.0

In [13]: math.floor(1.8)
Out[13]: 1.0