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

0:Python的强大之处在于数据操作的方便和大类的第三方module,本文主要是学习收集数据操作相关的内容

1:Tuple相关内容

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

2:List相关内容

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]

3:Dict相关内容

#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 "<ipython-input-3-8ead9275fd02>", 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'}

3：Set相关内容

#由于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)
<ipython-input-45-69dc95d9d8eb> in <module>()
----> 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)
<ipython-input-62-bea8936f69a1> in <module>()
----> 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，做 “-”运算， 返回一个新的集合 

4：常用 实用built-in函数

#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

5：通过id函数，思考shadow copy and deep copy

#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后面再整理

6：几个常用的数据取整函数 round,ceil,floor

#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