Python 复习笔记(三)

1. 列表操作——改变元素值：
x = [1, 2, 3]
x[1] = 0

2. 列表操作——删除元素(del)：
names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
del name[2]

3. 列表操作——切片赋值：
name = list['Perl']
name[1:] = list['ython']
name # ['P', 'y', 't', 'h', 'o', 'n']

numbers = [1, 5]
numbers[1:1] = [2, 3, 4] # 不需要替换任何原有元素的情况下插入新的元素
numbers # [1, 2, 3, 4, 5]

numbers = [1, 2, 4, 5]
numbers[1:4] = [] # 从第２个元素到第４个元素都是空值
numbers # [1, 5]

4. 列表的方法
　　1) append, 在列表尾部添加新的元素
lst = [1, 2, 3]
lst.append(4)

2) cout, 统计某个元素在列表中出现的次数，并返回值
x = [[1,2], 1, 1,[2,1,[1, 2]]]
x.count(1) # 结果是2,　因为它统计x列表中单个元素的次数

3) extend, 在列表尾部追加一个列表的值
　　a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
a # [1, 2, 3, 4, 5, 6]
此方法看上去像连接，两者主要的区别是extend将列表扩展了，并返回一个新的列表，　而连接不会扩展原来的列表。　

　　4) index, 查找元素在列表中的第一次出现的索引位置，如果找不到引发一个异常
a = [5, 3, 7, 3, 9]
a.index(3) # 1

5) insert, 在列表指定位置插入元素，且一次只能插入一个元素
numbers = [1, 2, 3, 5, 6, 7]
numbers.insert(3, 'four')

6) pop, 移除列表最后一个元素，并返回被移除的元素值
　　 x = [1, 2, 3]
x.pop() # 3
pop 在操作一个空的列表时，将引发一个异常
pop(出栈) 与 append(入栈) 可实现一种数据结构"栈"

7) remove, 移除列表中第一个满足条件值的元素
x = ['to', 'be', 'or', 'not', 'to', 'be']
x.remove('be') # 移除x列表中的第２个元素

8) reverse, 将列表元素反向存储(倒序存储)，但不返回值
x = [1, 2, 3]
x.reverse()

9) sort, 对列表按照升序进行排序，返回一个空值
　　x = [3, 6, 2, 1, 7, 9]
x.sort()
x # [1, 2, 3, 6, 7, 9]
排序后，原来的列表已被修改，如果要保留原来的副本，可以：
x = [3, 6, 2, 1, 7, 9]
y = x[:] # 将原列表赋值给另外一个列表，这里不能 y = x，因为这样操作后，x, y都会指向同一个地址
　　y.sort() # 对被赋值的列表排序
x #　原列表不变
当然还有个函数(它不是列表的方法)较为直接，它返回排序后的值，且不修改原列表
x = [3, 6, 2, 1, 7, 9]
y = sorted(x) # 原列表不变，返回排序后的结果

　　当然，如果你的按降序排序，需要配合上面的 reverse 方法。

10) 高级排序
　　以cmp 函数为参数排序，如：
　　numbers = [3, 6, 2, 1, 7, 9]
numbers.sort(cmp) # 以升序排序，这个看来和sort()方法一样；
sort方法还有另外两个可选参数：key和reverse, 使用key参数排序必须提供一个在排序过程中使用的函数，如：
x = ['aardeark', 'abalone', 'acme', 'add', 'aerate']
x.sort(key = len) # 以字符长度为排序依据
　　reverse是简单的布尔值排序，reverse = True时，按降序排序，reverse = False时，按升序排序：
x = [3, 6, 2, 1, 7, 9]
x.sort(reverse = True)

5.　元组
元组与列表一样，唯一不同是元组不能修改，它是用圆括号括起来的.
空元组是：()
只有一个元组：(3, ) # 如果没有一个逗号，会认为是一个常量
()内可以做运算，如：
(5-2, 6) # (3, 6)
(5 > 3, 6) # (True, 6)
如果在()用*号，则：
3 * (2, ) # (2, 2, 2)
(2, ) * 3 # (2, 2, 2),(2, )如果没有逗号，则是 2 * 3 = 6

6. 将列表转换为元组: tuple()
a = [12, 3, 8]
tuple(a)
如果a是一个元组，则还是返回元组。