摘要：的強(qiáng)大之處在于數(shù)據(jù)操作的方便和大類的第三方本文主要是學(xué)習(xí)收集數(shù)據(jù)操作相關(guān)的內(nèi)容相關(guān)內(nèi)容通過代碼對(duì)基本內(nèi)容進(jìn)行學(xué)習(xí)這是一個(gè)空的注意這不是一個(gè)變量，而是一個(gè)類型的變量注意與上面的例子對(duì)比，這里在括號(hào)內(nèi)加了一個(gè)逗號(hào)，變量類型為變量包含多個(gè)元素，元

#通過代碼對(duì)基本內(nèi)容進(jìn)行學(xué)習(xí)
empty=() #這是一個(gè)空的tuple

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

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

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

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


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

#由于tuple內(nèi)部的數(shù)據(jù)是可嵌套的，所以內(nèi)部的數(shù)據(jù)是什么類型，也很重要

#看一個(gè)tuple不怎么用的功能，把world分解成每一個(gè)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]  #前三個(gè)元素 
name[-3:] #最后三個(gè)元素 
name[3:6] #位置3,4,5 這三個(gè)元素 ，注意不包含位置6的元素

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

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

#改變某一個(gè)位置的元素 
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容器的擴(kuò)展
# 直接做+產(chǎn)生新的擴(kuò)展list,不會(huì)影響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函數(shù)，如下，a的內(nèi)容被 擴(kuò)展了

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中的某個(gè)item,如下，可以看到remove是從左往右查找，找到第一需要?jiǎng)h除的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()追加函數(shù)和pop()函數(shù)，實(shí)現(xiàn)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()方法也是經(jīng)常會(huì)使用到的


# 關(guān)于list的shadow copy和 deep copy
# 下面是shadow copy的例子，b的值改變了會(huì)影響a的值
# 所以shadow copy中，b變量只是a變量的別名，操作的是同一塊內(nèi)存空間
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的方法 ，賦值時(shí)使用b=a[:] 這處形式即可，a,b的操作互不影響對(duì)方
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是相當(dāng)重要的一類容器
#注意dict的key不能是數(shù)字
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這個(gè)key就對(duì)應(yīng)著多個(gè)值，所以 1個(gè) key 對(duì)應(yīng)多個(gè)值，這種情況，在python中就不是問題，
#因?yàn)樵赑ython中，容器是可嵌套的


#在vardict字典變量中插入一對(duì)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變量中彈出一個(gè)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()函數(shù)返回的是一個(gè)可迭代的對(duì)象list對(duì)象
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對(duì)象
In [27]: vardict
Out[27]: {"height": 1.75, "name": "Tome", "test": (3, 4)}

In [28]: vardict.clear()

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



#直接把dcit對(duì)象賦值給另一個(gè)對(duì)象，使用的是shadow copy方式，相當(dāng)于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"}


#當(dāng)我們使用了copy操作，對(duì)一個(gè)對(duì)象進(jìn)行復(fù)制后，兩個(gè)對(duì)象是相互不影響的，如下例子
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"

#如下又一個(gè)例子，可見dict對(duì)象的copy方法復(fù)制對(duì)象還是非常徹底的
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()只是對(duì) 對(duì)象進(jìn)行一層copy,第二層沒有進(jìn)行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變量中可以進(jìn)行迭代的一些量
d.keys() ,d.values(),d.items()
for key,value in d.items():

#返回 key對(duì)應(yīng)的value
d.get(key)     #如果沒有這個(gè)key,則返回None
d.get(key,x)   #如果沒有這個(gè)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"這個(gè)key,所以會(huì)返加"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}  # 并且這個(gè)"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",并且將這個(gè)一對(duì)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 鍵 ，則返回對(duì)應(yīng)value,否則返回None
d.pop(k,x) #如果存在k 鍵，則返回對(duì)應(yīng)的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, 所以返回對(duì)應(yīng)的value
Out[41]: 1

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

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

In [43]: a=set()

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

In [45]: a=set(3,4,5,"hellO") #這樣是不對(duì)的哦
---------------------------------------------------------------------------
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"))  #這樣才對(duì)，兩個(gè)括號(hào)

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

In [47]: a.add(3)  #因?yàn)樯厦嬉呀?jīng)存在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中,所以報(bào)錯(cuò)了 
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in ()
----> 1 a.remove(0)

KeyError: 0

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

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

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

#all(q)函數(shù)，q中所有元素都是true時(shí)，返回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)函數(shù)，只要q中有一個(gè)item是true,則返回ture
Out[80]: True

#常用小函數(shù)，不解釋
 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) #這個(gè)很重要，后面需要特別研究
id(x) #相當(dāng)于變量x的內(nèi)存地址，如果id(x),id(y)相同，那么x與y互為別名

isinstance(x, C) #如果變量x是 類C的一個(gè)實(shí)例，返回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) 就下面這點(diǎn)用？？
In [138]: a
Out[138]: 3
In [139]: s="a+2"
In [142]: a=eval(s)
In [143]: a
Out[143]: 5

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

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

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

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


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

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

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

#float函數(shù)，注意傳入?yún)?shù)可以是str，也可以是數(shù)字
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()函數(shù)的使用
In [164]: int("33")
Out[164]: 33

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

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

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


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

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

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

In [171]: long(float("333.3")) #內(nèi)部嵌套一個(gè)float轉(zhuǎn)換即可
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入，精確到幾位小數(shù)
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的別名，下面可以看到，都是指向同一塊內(nèi)存地址 

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

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

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

In [109]: b[0]=33 #當(dāng)b[0]的內(nèi)容發(fā)生變化時(shí)，就會(huì)分配一塊新的內(nèi)存給b[0]

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

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

#demo 3 這個(gè)更難了，所以書中說的shadow copy實(shí)際就是說只復(fù)制了一層
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函數(shù)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函數(shù)，向上取整
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函數(shù)，向下取整
In [12]: math.floor(1.2)
Out[12]: 1.0

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