[Python]容器类变量的使用学习

摘要：的强大之处在于数据操作的方便和大类的第三方本文主要是学习收集数据操作相关的内容相关内容通过代码对基本内容进行学习这是一个空的注意这不是一个变量，而是一个类型的变量注意与上面的例子对比，这里在括号内加了一个逗号，变量类型为变量包含多个元素，元

#通过代码对基本内容进行学习
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