1. 序列

1. 序列类型操作符

序列操作符	作用
seq[ind]	获得下标为ind的元素
seq[ind1:ind2]	获得下标从ind1到ind2间的元素集合
seq * expr	序列重复expr次
seq1 + seq2	链接序列seq1和seq2
obj in seq	判断obj元素是否包含在seq中
obj not in seq	判断obj元素是否不包含在seq中

1. 成员关系操作符(in, not in)

    用来判断一个元素是否属于一个序列:

>>> "h" in "hello owrld"True>>> 1 in (2, 3, 4)False

2. 连接操作符

>>> "hello " + "world"'hello world'>>> arr = []>>> arr.append("hello ")>>> arr.append("world")>>> "".join(arr)'hello world'>>> num1 = [1, 2]>>> num2 = [3, 4]>>> num1.extend(num2)>>> num1[1, 2, 3, 4]

3. 切片

>>> ss = "hello world">>> ss[:]'hello world'>>> ss[1:4]'ell'>>> ss[:-1]'hello worl'>>> ss[::2]'hlowrd'

2. 内建函数

1. 类型转换

函数	含义
list(iter)	把可迭代对象转换为列表
str(obj)	把obj对象转换成字符串(对象的字符串表示法)
unicode(obj)	把对象转换成unicode字符串
basestring()	抽象工厂函数,为str和unicode函数提供父类
tuple(iter)	把一个可迭代对象转换成一个元组对象

    这里均使用到浅拷贝.

2. 可操作

函数名	功能
enumerate(iter)	接受一个可迭代对象作为参数,返回一个enumerate对象
len(seq)	返回seq的长度
max(iter,key=None) or max(arg0,...)	返回iter或(arg0,..)的最大值,如果指定key,则key必须是可传给sort()方法,用来比较的回调函数
min(iter,key=None) or min(arg0,...)	返回最小值
reversed(seq)	接受一个序列作为参数,返回一个以逆序访问的迭代器
sorted(iter, func=None,key=None,reverse=False)	接受一个可迭代对象作为参数,返回一个有序的列表
sum(seq, init=0)	返回seq和可选参数init的总和,等同于reduce(operator.add, seq, init)
zip([it0, it1,..])	返回一个列表(具体含义看实例)

实例如下:

>>> num = [1, 2, 3, 4]>>> enumerate(num)
    
     >>> list(enumerate(num))[(0, 1), (1, 2), (2, 3), (3, 4)]>>> len(num)4>>> max(num)4>>> min(num)1>>> reversed(num)
     
      >>> list(reversed(num))[4, 3, 2, 1]>>> sorted(num)[1, 2, 3, 4]>>> sum(num)10>>> zip(num)
      
       >>> list(zip(num))[(1,), (2,), (3,), (4,)]
      
     
    

2. 列表

    列表能保留任意数目的python对象的灵活容器.

1. 列表的一些基础操作(创建,访问,更新,删除)

>>> aList = []>>> aList.append(1)>>> id(aList)65662280>>> aList.append(2)>>> id(aList)65662280>>> aList.extend([3, 4, 5])>>> aList[1, 2, 3, 4, 5]>>> aList.append(["hello", "world"])>>> aList[1, 2, 3, 4, 5, ['hello', 'world']]>>> aList[5][1]'world'>>> aList[2] = "what">>> aList[1, 2, 'what', 4, 5, ['hello', 'world']]>>> del aList[1]>>> aList[1, 'what', 4, 5, ['hello', 'world']]>>> aList.remove("what")>>> aList[1, 4, 5, ['hello', 'world']]>>> del aList>>> aListTraceback (most recent call last):  File "
    
     ", line 1, in 
     
          aListNameError: name 'aList' is not defined
     
    

3. 元组

    元组是不可变类型,所以通常可以用作一个字典的key.

1. 元组的一些基础操作(创建,访问,更新,删除)

    在创建一个元组时要注意一点:只有一个元素的元组需要在元组分隔符里面加一个逗号(,)以防止跟普通的分组操作符混淆.

>>> aTuple = (123, "abc", 3.45, ["inner", "tuple"], 8-9j)>>> aTuple[1:5]('abc', 3.45, ['inner', 'tuple'], (8-9j))>>> id(aTuple)65420808>>> bTuple = aTuple + (1,2,3)>>> bTuple(123, 'abc', 3.45, ['inner', 'tuple'], (8-9j), 1, 2, 3)>>> id(bTuple)65625672>>> del aTuple>>> id(aTuple)Traceback (most recent call last):  File "
    
     ", line 1, in 
     
          id(aTuple)NameError: name 'aTuple' is not defined
     
    

4. 拷贝python对象,浅拷贝和深拷贝

    对象赋值实际上是简单的对象引用,也就是说,当你创建一个对象,然后把它赋给另一个变量的时候,python并没有拷贝这个对象,而是拷贝了这个对象的引用.

实例如下:

>>> person = ["name", ["savings", 100.00]]>>> hubby = person[:]>>> wifey = list(person)>>> [id(x) for x in (person,hubby,wifey)][65794568, 65794440, 65735944]

    假设hubby取走50元,则会影响到wifey的账户:

>>> hubby[0] = "joe">>> wifey[0] = "jane">>> hubby, wifey(['joe', ['savings', 100.0]], ['jane', ['savings', 100.0]])>>> hubby[1][1] = 50.00>>> hubby, wifey(['joe', ['savings', 50.0]], ['jane', ['savings', 50.0]])

    原因是我们仅仅做了一次浅拷贝.对一个对象进行浅拷贝其实是新建了一个类型跟原对象一样,其内容是原来对象的引用,换句话说,这个拷贝的对象本身是新的,但是它的内容不是.序列类型对象的浅拷贝是默认类型拷贝,并可以以下几种方式实施:1.完全切片操作[:],2利用工厂函数(list,dict),3使用copy模块的copy函数.

    我们可以使用深拷贝来实现hubby和wifey的账户独立:

>>> person = ["name", ["savings", 100.00]]>>> hubby = person>>> import copy>>> wifey = copy.deepcopy(person)>>> [id(x) for x in (person, hubby, wifey)][55781320, 55781320, 65735496]>>> hubby[0] = "joe">>> wifey[0] = "jane">>> hubby, wifey(['joe', ['savings', 100.0]], ['jane', ['savings', 100.0]])>>> hubby[1][1] = 50.00>>> hubby, wifey(['joe', ['savings', 50.0]], ['jane', ['savings', 100.0]])

    实际上可以通过id进行查看:

>>> person = ["name", ["savings", 100.00]]>>> hubby = person[:]>>> wifey = list(person)>>> [id(x) for x in (person, hubby, wifey)][50112776, 60091528, 60092104]>>> [id(y) for x in (person, hubby, wifey) for y in x][14821560, 60091208, 14821560, 60091208, 14821560, 60091208]>>> hubby1 = person[:]>>> import copy>>> wifey = copy.deepcopy(person)>>> [id(y) for x in (person, hubby, wifey) for y in x][14821560, 60091208, 14821560, 60091208, 14821560, 60091848]

5. 映射类型:字典

1. 字典的基本操作(创建,访问,更新,删除)

创建:

>>> dict1 = {}>>> dict2 = {"name" : "earth", "port" : 80}>>> dict3 = dict((["x", 1], ["y", 2]))>>> dict4 = {}.fromkeys(("x", "y"), -1)>>> dict1{}>>> dict2{'name': 'earth', 'port': 80}>>> dict3{'y': 2, 'x': 1}>>> dict4{'y': -1, 'x': -1}

    dict()为工厂函数,要求参数为一元组/列表,且元组/列表的元素必须可迭代.而fromkeys()用来创建一个"默认"字典,字典中元素具有相同的值.

访问:

>>> for key in dict2:	print("key=%s,value=%s" % (key, dict2[key]))	key=name,value=earthkey=port,value=80>>> for key, value in dict2.items():	print("key=%s,value=%s" % (key, value))	key=name,value=earthkey=port,value=80

    而我们可以使用in或者has_key()(备注:在最新版本python中,好像没有此方法)来判断是否有其键值:

>>> "name" in dict2True>>> "server" in dict2False

更新和删除:

>>> dict2["name"] = "hello">>> dict2{'name': 'hello', 'port': 80}>>> del dict2["name"]>>> dict2{'port': 80}>>> dict2.clear()>>> dict2{}>>> del dict2>>> dict2Traceback (most recent call last):  File "
    
     ", line 1, in 
     
          dict2NameError: name 'dict2' is not defined
     
    

2. 映射类型的内建函数和工厂函数

1. 映射类型函数

dict():

    dict()工厂函数被用来创建字典,如果不提供参数,会生成空字典.当容器类型对象作为一个参数传递给方法dict()时,如果参数是可以迭代的,即一个序列,或是一个迭代器,或是一个支持迭代的对象,那每个可迭代的元素必须成对出现.在每个值对中,第一个元素是字典的键,第二个元素是字典中的值:

>>> dict(zip(("x", "y"), (1, 2))){'y': 2, 'x': 1}>>> dict([["x", 1], ("y", 2)]){'y': 2, 'x': 1}

    如果输入参数是一个映射对象,对其调用dict()会从存在的字典里复制内容来生成新的字典.新生成的字典是原来字典对象的浅复制版本,与调用copy一样.

>>> import copy>>> dict1 = {"x" : 1, "y" : 2}>>> dict2 = dict1.copy()>>> dict1{'y': 2, 'x': 1}>>> dict2{'x': 1, 'y': 2}>>> id(dict1)65373640>>> id(dict2)65791112

hash():

    hash()可以判断某个对象是否可以做一个字典的键.将一个对象作为参数传递给hash(),会返回这个对象的哈希值.只有这个对象是可哈希的,才可作为字典的键:

>>> hash("hello")5758210612334034391>>> hash([])Traceback (most recent call last):  File "
    
     ", line 1, in 
     
          hash([])TypeError: unhashable type: 'list'
     
    

2. 映射类型内建方法

update():

    将一个字典的内容添加到另一个字典中:

>>> dict2 = {"host" : "earth", "port" : 80}>>> dict3 = {"host" : "venus", "server" : "http"}>>> dict2.update(dict3)>>> dict2{'host': 'venus', 'port': 80, 'server': 'http'}>>> dict3.clear()>>> dict3{}

3. 字典的键

    字典的键,不允许一个键对应多个值:

>>> dict1 = {"foo" : 789, "foo" : "xyz"}>>> dict1{'foo': 'xyz'}

    而且,键必须是可哈希的,所以只能使用数值,字符串和元素值必须为数值/字符串的元组.

6. 集合类型

    集合对象是一组无序排列的可哈希的值,有两种不同类型:可变集合和不可变集合.可变集合不是可哈希,所以既不能用作字典的键也不能做其他集合中的元素.而不可变集合刚好相反.

1. 集合的基本操作(创建,访问,更新,删除)

创建:

>>> s = set("cheeseshop")>>> t = frozenset("bookshop")>>> s{'o', 'h', 'p', 'e', 's', 'c'}>>> tfrozenset({'o', 'h', 'p', 's', 'b', 'k'})

访问

    无法通过索引来访问:

>>> s[1]Traceback (most recent call last):  File "
    
     ", line 1, in 
     
          s[1]TypeError: 'set' object does not support indexing>>> for i in s:	print(i)	ohpesc
     
    

更新:

>>> s.add("z")>>> s.update("pypi")>>> s.remove("o")>>> >>> s{'h', 'p', 'e', 's', 'c', 'y', 'i', 'z'}>>> s -= set("pypi")>>> s{'h', 'e', 's', 'c', 'z'}>>> t.add("z")Traceback (most recent call last):  File "
    
     ", line 1, in 
     
          t.add("z")AttributeError: 'frozenset' object has no attribute 'add'
     
    

删除:

>>> del s>>> sTraceback (most recent call last):  File "
    
     ", line 1, in 
     
          sNameError: name 's' is not defined