【每日一记3.16】python学习记录

6.Python的列表

   Python列表是python内置的数据对象之一

   列表用【】包含，内有数据对象，每个数据对象以‘，’分隔，每个数据对象称为元素

   python是一个有序的序列，支持嵌套

   【】空列表，同时用list(‘strings’)函数也可以生成列表

       列表方法：

           - append(object):将新的元素追加到列表后面，只能追加一个

           In [52]: l=list('TCQ')

           In [53]: l

           Out[53]: ['T', 'C', 'Q']

           In [54]: l.append('ws')

           In [55]: l

           Out[55]: ['T', 'C', 'Q', 'ws']

       - count(value):统计每个对象在列表中出现的次数，返回值为number

           In [56]: l=list('1223334445555')

           In [56]: l.count('4')

           Out[56]: 3

           In [57]: type(l.count('4'))

           Out[57]: int

       - extend(iterable)将可迭代的对象拆分，追加到列表后面

           In [58]: l=list('TCQ')

           In [59]: l.extend('ws')

           In [60]: l

           Out[60]: ['T', 'C', 'Q', 'w', 's']

       - index(value[,start[,stop]])

       根据列表内的元素查找对应的索引，返回值为number

           In [61]: l.index('T',0,len(l)-1)

           Out[61]: 0

       - insert(index,object)

       在指定索引位插入对象，相当于list[n]=object

           In [62]: l.insert(3,'D')

           In [63]: l

           Out[63]: ['T', 'C', 'Q', 'D', 'w', 's']

       - pop(index)

       弹出指定索引对应的元素

           In [64]: l.pop(3)

           Out[64]: 'D'

           In [65]: l

           Out[65]: ['T', 'C', 'Q', 'w', 's']

       - remove(value)

       删除指定的元素，若不存在返回ValuerError

           In [66]: l.remove('w')

           In [67]: l

           Out[67]: ['T', 'C', 'Q', 's']

           In [68]: type(l.remove('T'))

           Out[68]: NoneType

       - reverse()

       将列表内的元素顺序前后对掉，不是反排序

           In [69]: l.reverse()

           In [70]: l

           Out[70]: ['s', 'w', 'Q', 'C', 'T']

       - sort()

       将列表内的元素进行排序，顺序为0-9，A-Z，a-z

       reverse=True反排序

           In [71]: l

           Out[71]: ['a', 'A', '1', 'B', '2', 'b', '3', 'C', 'c']

           In [72]: l.sort()

           In [73]: l

           Out[73]: ['1', '2', '3', 'A', 'B', 'C', 'a', 'b', 'c']

           In [74]: l.sort(reverse=True)

           In [75]: l

           Out[75]: ['c', 'b', 'a', 'C', 'B', 'A', '3', '2', '1']

       - list[index]=value

       根据索引查元素

           In [87]: l[2]

           Out[87]: 'Q'

       - del list[index]

       删除索引对应的值

           In [88]: del l[2]

           In [89]: l

           Out[89]: ['T', 'C', 'w', 's']

7.Python字典

       用{}包裹，每个键值对由：分隔，键与值用冒号相连

       字典是无序的，键必须唯一

       字典是python中的映射数据类型

       {'name':'tcq','age':24,'address':'Beijing'}

           In [90]: {}.fromkeys(['key1','key2','key3'])

           Out[90]: {'key1': None, 'key2': None, 'key3': None}

       使用字典函数创建字典：

           In [91]: dict((['x',1],['y',2]))

           Out[91]: {'x': 1, 'y': 2}

       访问字典:

           In [92]:d={'name':'tcq','age':24,'address':'Beijing'}

           In [93]: d['name']

           Out[93]: 'tcq'

       字典更新：键值有则更新，无则添加

           In [94]: d['new_key']='new_key'

           In [95]: d

           Out[95]: {'address': 'Beijing', 'age': 24, 'name': 'tcq', 'new_key': 'new_key'}

       字典删除：

           In [96]: del d['new_key']

       字典方法：

       - values()获取键对应的值

       In [97]: d.values()

           Out[97]: [24, 'tcq', 'Beijing']

       - keys()获取键

           In [98]: d.keys()

           Out[98]: ['age', 'name', 'address']

       - pop(k,[d])弹出指定键对应的值，如果没找到返回d

           In [99]: d.pop('name')

           Out[99]: 'tcq'

           In [100]: d.pop('name','no')

           Out[100]: 'no'

       - update()更新字典内键与值，键名即使是字符串也不加引号

           In [1]: d.update(name='tcqws')

           In [2]: d

           Out[2]: {'address': 'Beijing', 'age': 24, 'name': 'tcqws'}

       - get()获取字典中键对应的值，与dict['keyname']相同

           In [3]: d.get('name')

           Out[3]: 'tcqws'

       - items()将字典的每一个键和值放在一个元组中，多个元组存放在列表中

           In [4]: d.items()

           Out[4]: [('age', 24), ('name', 'tcqws'), ('address', 'Beijing')]

           In [5]: type(d.items())

           Out[5]: list

       - popitem()随机删除字典中的一个键值对，并以元组方式返回

           In [6]: d.popitem()

           Out[6]: ('age', 24)

       - viewitems()返回字典元素视图

       - keyitems()返回字典键视图

       - valueitems()返回字典值视图

       - iteritems()返回字典dict的迭代对象

       - iterkeys()返回字典dict的键的迭代对象

       - itervalues()返回字典dict的值的迭代对象

       - setfault(k,[d])如果键在字典中，则返回键对应的值，如果不在，则创建该键，值为默认的None或者是d

           In [7]: d.setdefault('name')

           Out[7]: 'tcqws'

           In [8]: d.setdefault('name1')

           In [9]: d

           Out[9]: {'address': 'Beijing', 'age': 24, 'name': 'tcqws', 'name1': None}

       - copy()产生字典副本

           In [10]: d1=d.copy()

           In [11]: id(d)

           Out[11]: 27333328

           In [12]: id(d1)

           Out[12]: 27661392

           In [13]: d is d1

           Out[13]: False

       - clear()清除字典内的所有键和值

           In [14]: d1.clear()

           In [15]: d1

           Out[15]: {}

       - has_key()判断字典中是否由指定的键

           In [16]: d.has_key('name')

           Out[16]: True

       Python 中被in替代

       字典视图：

       在2.7版本以后，Python引入了字典视图。字典视图是字典的动态视图：会与字典保持同步，实时反映出字典的变化。

       迭代对象:

       就是一个迭代器，会返回当前的数据，然后自动的调用内置的next()方法来读取，自动的移动到下一个元素，准备下次的读取，直到对象末尾

8.Python元组

       元组多数情况下，用于系统的输入或者系统的返回，元组的特性是不可修改，但支持迭代

       元组只有count与index两种方法

       元组以()来定义，以‘，’分隔，源所可以是任何数据对象

           In [17]: t=('name','age','name','address')

           In [18]: t.count('name')

           Out[18]: 2

           In [19]: t.index('name')

           Out[19]: 0