第2章Python序列

第2章 Python序列

列表与列表推导式

在Python中，同一个列表中元素的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，也可以是列表、元组、字典、集合以及其他自定义类型的对象。
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

一、列表的创建与删除

1.使用“=”直接将一个列表赋值给变量即可创建列表对象
eg: a_list=[‘a’,‘b’,1]

可以将其他类型转换为列表，使用list()函数。如果把字典转换为列表时默认为将字典的“键”转换为列表，使用items()方法可把字典的元素转换为列表。

• eg:>>>list({‘a’:3,‘b’:9,‘c’:78})
  [‘a’,‘c’,‘b’]
• eg:>>>list({‘a’:3,‘b’:9,‘c’:78}.items())
  [(‘b’,9),（‘c’,78),(‘a’,3)]

2.创建列表之后，可以使用整数作为下标来访问其中的元素，其中0表示第1个元素，1表示第2个元素，以此类推。-1表示最后一个元素，-2表示倒数第2个，以此类推。
3. 当一个列表不再使用时，可以使用del命令将其删除。这一点适用于所有类型的Python对象。也可以使用del命令删除列表、字典等可变序列中的部分元素，而不能删除元组、字符串等不可变序列中的部分元素。
eg:>>>x=[1,2,3]
>>>del x[1]
>>>x
[1,3]

二、列表常用方法

1. append()、insert()、extend()—添加元素

• append()用于向列表尾部追加一个元素

• insert()用于向列表任意指定位置插入一个元素

• extend()用于将另一个列表中的所有元素追加至当前列表的尾部。

  这3个方法都属于原地操作，不影响列表对象在内存中的起始地址。
  运算符+和*也可以实现增加元素的目的，但这两个运算符不属于原地操作，而是返回新列表。
  

2. pop()、remove()、clear()—删除元素

• pop(）用于删除并返回指定位置（默认是最后一个）上的元素.

• remove()用于删除列表中第一个值与指定值相等的元素。

• clear()用于清空列表。

  这3个方法属于原地操作，不影响列表对象的内存地址。
  

3. count()、index()

• count()用于返回指定元素出现的次数。
• index()用于返回指定元素在列表中首次出现的位置，如果该元素不在列表中则抛出异常。

4. sort()、reverse()—排序

• sort(）方法用于按照指定的规则对所有元素进行排序，默认规则是直接比较元素大小。
• reverse()方法用于将列表所有元素逆序排列。

扩展知识：

• Python列表支持与整数的乘法运算，表示列表元素进行重复并生成新列表，不对原列表进行任何修改。
  eg:>>>[1,2,3]*3
  [1,2,3,1,2,3,1,2,3]
• Python列表不支持与整数的加、减、除运算，也不支持列表之间的减、乘、除操作。列表之间的加法运算表示列表元素的合并，生成新列表，而不是向量意义的加法。
  eg:>>>[1,2,3]+[4,5,6]
  [1,2,3,4,5,6]

三、列表推导式

列表推导式语法形式为：[表达式 for 变量 in 序列或迭代对象]
列表推导式在逻辑上相当于一个循环，只是形式更加简洁。

• eg:>>>aList=[x*x for i in range(10)]

        相当于
         >>>aList=[]
        >>>for x in range(10)
        aList.append(x*x)

1. 使用列表推导式实现嵌套列表的平铺

• eg:>>>vec=[[1,2,3],[4,5,6],[7,8,9]]
  >>>[num for elem in vec for num in elem]
  [1,2,3,4,5,6,7,8,9]
  在这个列表推导式中有2个循环，其中一个循环可以看作是外循环，执行得慢；而第二个循环可以看作是内循环，执行得快。上面代码执行过程等价于下面的写法：
  >>>vec=[[1,2,3],[4,5,6],[7,8,9]]
  >>>result=[]
  >>>for elem in vec:
  >>>for num in elem:
        result.append(num)
  >>>result
  [1,2,3,4,5,6,7,8,9]

2. 过滤不符合条件的元素

下面的代码用于从列表中选择符合条件的元素组成新的列表：

• eg:>>>aList=[-1,-4,6,7.5,-2.3,9,-11]
  [i for i in aList if i>0]
  [6,7.5,9]

3. 在列表推导式中使用多个循环，实现多序列元素的任意组合，并且可以结合条件语句过滤特定元素

• eg:>>>[(x,y)for x in [1,2,3] for y in [3,1,4] if x != y]
  [(1,3),(1,4),(2,3),(2,1),(2,4),(3,1),(3,4)]

  对于包含多个循环的列表推导式，一定要弄清楚多个循环的执行顺序或“嵌套关系”。
  上面的例子等价于：
  >>>result=[]
  >>>for x in [1,2,3]:
  for y in [3,1,4]:
       if x != y:
        result.append((x,y))
  >>>result
  [(1,3),(1,4),(2,3),(2,1),(2,4),(3,1),(3,4)]

4. 使用列表推导式实现矩阵转置

eg:>>>matrix=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]
>>>[[row[i] for row in matrix] for i in range(4)
[[1,5,9],[2,6,10],[3,7,11],[4,8,11,12]]

5. 列表推导式中可以使用函数或复杂表达式

• eg:>>>def f(v):
       if v%2==0:
         v=v2
       else:
         v=v+1
        return v
  >>>print([f(v) for v in [2,3,4,-1] if v>0])
  [4,4,16]
  >>>print([v2 if v%2 = =0 else v+1 for v in [2,3,4,-1] if v>0])
  [4,4,16]

6. 列表推导式支持文件对象迭代

• eg:>>> fp=open(‘C:\install.log’, ’ r ')
  >>>print([line for line in fp])
  >>>fp.close()

7. 使用列表推导式生成100以内的所有素数

• eg:>>>[ p for p in range (2,100) if 0 not in [p%d for d in range (2, int(sqrt § )+1] ]

  四、切片

       在形式上，切片使用2个冒号分割的3个数字来完成，第一个数字表示切片的开始位置（默认为0），第二个数字表示切片的截止(但不包含)位置（默认为列表长度），第三个数字表示切片的步长（默认为1），步长省略时，可省略最后一个冒号。

  1.使用切片获取列表中的部分元素

  使用切片可以返回列表原有元素的一个“子集”。与使用下标访问列表元素的方法不同，切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强地健壮性。

  • eg:>>>aList=[3,4,5,6,7,9,11,13,15,17]
    >>>aList[::]            #返回包含原列表中所有元素的逆序列表
    [3,4,5,6,7,9,11,13,15,17]

• eg:>>>aList[: : -1]            #返回包含原列表中所有元素的逆序列
  [17,15,13,11,9,7,6,5,4,3]

• eg:>>>aList=[1 : : 2]            #隔一个元素取一个元素，获取偶数位置的元素
  [4,6,9,13,17]

2.使用切片对列表元素进行增、删、改

1.列表元素的增、删、改以及元素替换等操作都可以通过切片来实现，并且不影响列表对象的内存地址。

• eg:>>>aList=[3,5,7]
  >>>aList[ len (aList) :]
  []

• eg:>>>aList=[ len (aList) :]=[9]          #在列表尾部增加元素
  >>>aList
  [3,5,7,9]

• eg:>>>aList [ : 3 ]=[1,2,3]          #替换元素
  >>>aList
  [ 1,2,3,9]

  也可以结合使用del命令与切片结合来删除列表中的部分元素
  >>>aList=[3,5,7,9,11]
  >>>del aList [ : 3 ]
  >>>aList
  [9,11]

   1. 切片返回的是列表元素的浅复制，与列表对象的直接赋值并不一样。
    浅复制不是同一个对象，两个列表对象的地址不相等
   2. 直接把一个列表变量赋值给另一个变量指向同一个内存地址，但是一个列表
   分别赋值给2个变量时不是这样的情况。
  

元组与生成器推导式

元组(tuple)

创建元组的方法：
>>>x=(1,2,3)
>>>x=(3,)     #如果元组中只有一个元素，必须在后面多写一个逗号

     元组属于不可变序列，一旦创建，没有任何地方可以修改元组中元素的值，也无法
 为元组增加或删除元素。
     元组支持切片操作，但只能通过切片来访问元组中的元素，而不支持使用切片来修
 改元组中元素的值也不支持使用切片操作为元组增加或删除元素。
     调用函数时使用元组传递参数可以防止在函数中修改元组，而使用列表则很难做到
 这一点。
     虽然元组属于不可变序列，其元素的值时不可变的，但是如果元组中包含不可变序
 列，情况就变得复杂。
     eg:>>>x=([1,2], 3)
        >>>x[0][0]=5
        ([5,2], 3)

来看一个“可变的”tuple：

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
t
('a', 'b', ['X', 'Y'])

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

生成器推导式

1.从形式上看，生成期推导式与列表推导式非常接近，只是生成器推导式使用圆括号而不是方括号。
2. 与列表推导式不同的是，生成器推导式的结果是一个生成器对象，而不是列表，也不是元组。
3. 使用生成器对象的元素时，可以根据需要将其转化为列表或元组，可以使用生成器对象的_ next() _方法或内置函数next()进行遍历。
4. 当所有元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。

• eg:>>>g=( (i+2) **2 for i in range(10) )  #创建生成器对象
  >>>tuple(g)   #将生成器对象转换为元组
  (4, 9, 16, 25,36, 49, 64, 81, 100, 121)
  >>> list(g)      #生成器对象已遍历结束，没有元素了
  []
  >>>g=( (i+2) **2 for i in range(10) )  #重新创建生成器对象
  >>>g._ next _()  #使用生成器对象的 _ _ next() _ _方法获取元素

字典

   字典是包含若干“键：值”元素的无序可变序列，字典中的每个元素包含“键”和“值”两部分，表示一种映射或对应关系，也成为关联数组。
   字典中的“键”可以是Python中任意不可变数据，如整数、实数、复数、元组等，但不能使用列表、集合、字典或其他可变类型作为字典的“键”。"键“不允许重复，而”值“是可以重复的。

一、字典的创建和元素添加、修改与删除

1.使用赋值运算符”=”将一个字典赋值给一个变量即可创建一个字典变量。
2.使用内置函数dict()通过已有数据快速创建字典

• eg:>>>keys=[‘a’, ‘b’, ‘c’, ‘d’]
  >>>values=[1,2,3,4]
  >>>dictionary=dict( zip(keys,values) )
  >>>print(dictionary)
  {‘a’ :1, ‘c’ ：3，‘b’：2， ’d’: 4}

3.还可以使用内置函数dict()根据给定的“键：值“来创建字典：

• eg: >>>d=dict(name=‘dong’,age=18)
  >>>d
  {‘age’:18,‘name’:dong}

4.当以指定”键“为下标为字典元素赋值，有两种含义：

• 若该”键“存在，则表示修改该”键“对应的值；
• 若该键不存在，则表示添加一个新的’键:值”，也就是添加一个新元素。

5.使用字典对象的update()方法可以将另一个字典的“键：值”一次性全部添加到当前字典对象，如果两个字典中存在相同的：键”，则以另一个字典中的“值”为准对当前字典进行更新。
6.使用del命令可以删除整个字典，也可以删除字典中指定的元素。
7.也可以使用字典对象的pop()和popitem()方法弹出并删除指定的元素。

二、访问字典对象的数据

1.字典对象提供了一个get()方法用来返回指定“键”对应的“值”，这方法允许指定该键不存在时返回特定的“值”。

• eg:>>>aDict.get(‘address’, ‘Not Exists .’)  #指定的“键”不存在时返回指定的默认值

2.字典对象的setdefault()方法用于返回指定“键”对应的“值”，如果字典不存在该“键”，就添加一个新元素并设置该“键”对应的“值”

+eg：>>>aDict.setdefault(‘address’, ‘SDIBT’) #增加新元素

3.对字典对象进行迭代时，默认是遍历字典的"键“。可以使用items()方法返回字典中的元素，即所有“键：值”，字典对象的keys()方法返回所有”键“，values()方法返回所有”值“。

集合(set)

一、集合基础知识

同一个集合内的每个元素都是唯一的，元素之间不允许重复。
可以使用set()函数将列表、元组等其他可迭代对象转换为集合，如果原来的数据中存在重复元素，则在转换为集合的时候只保留一个。

    集合中只能包括数字、字符串、元组等不可变类型(或者说可哈希)的数据，而不能
包含列表、字典、集合等可变类型的数据。

二、集合操作与运算

1.集合元素增加与删除

• 使用集合对象的add()方法可以为其增加新元素，如果该元素已存在于集合则忽略该操作；update()方法用于合并另外一个集合中得到元素到当前集合中。
• pop()方法用于随机删除并返回集合中的一个元素。
• remove()方法用于删除集合中的元素，如果指定元素不存在则抛出异常
• discard()用于从集合中删除一个特定元素，如果元素不存在集合中则忽略该操作。

2.集合运算

Python集合支持并集、交集、差集等运

3.集合可快速提取序列中单一元素

eg:>>>newSet=set(listRandom)

序列解包