Python：list列表

列表 list

列表 list
	列表是一种容器
	列表是可以被改变的序列容器

创建空列表的字面值
	L = []  # L 绑定一个新创建的空列表

创建非空列表的字面值:
	L = [1, 2, 3, 4]
	L = ["北京", "上海", "深圳"]
	L = [1, "二", 3.14, "Four"]
	L = [1, 2, [3.1, 3.2, 3.3], 4]

列表的构造(创建)函数 list
	list()         创建一个空的列表，等同于[]
	list(iterable)  用可迭代对象创建一个列表
示例:
	L = list()  # L绑定空列表
	L = list("hello")  #L绑定['h','e','l','l','o']
	L = list(range(10))  # L绑定[0,1,2,3...9]

**列表的运算:**
	算术运算符
	+  +=  *   *= 
示例:
	+ 加号用于拼接列表
  	x = [1, 2, 3]
  	y = [4, 5, 6]
  	z = x + y  # z = [1, 2, 3, 4, 5, 6]
	+= 用于原列表与右侧可迭代对象进行拼接,用变量绑定列表
语法:
    x += 可迭代对象
如:
    x = [1, 2, 3]
    y = [4, 5, 6]
    x += y  # x绑定[1, 2, 3, 4, 5, 6]
    x = 
* 生成重复的列表
*=  让原列表重复n次再用原变量绑定
 	 x = [1, 2] * 3  # x =[1, 2, 1, 2, 1, 2]
 	 x = [1, 2]
  	x *= 2  # x = [1, 2, 1, 2]
  	列表的比较运算:
运算符:
  <  <=  >  >=  ==  != 
说明:
  列表的比较规则与字符串的比较规则相同
  列表要求每两个元素能依次进行比较,否则会出现类型错误
示例:
  [1, 2, 3]  < [1, 2, 4]  # True
  [1, 2, 3] != [1, 2, 4]  # True
  ["One", "Two"] < ["1", "2"]  # False
  [1, 'Two'] > ['Two', 1]  # TypeError
  [1, "二", 3.14] < [2, "2", 1]  # True

列表的in / not in 运算符

判断一个值是否存在于列表中，如果存在则返回True,
否则返回False
同字符串的 in 运算符类似

示例:
	x = [1, 'Two', 3, "四"]
	3 in x       # True
	"3" in x     # False
	10 not in x  # True

列表的索引操作:

	索引取值
语法:
	x = 列表[整数表达式]
用法:
 	等同于字符串的索引(同样分为正向索引和反向索引)

索引赋值
	列表是可变的序列,可以通过索引赋值改变列表中的元素

语法:
	列表[整数表达式] = 表达式
示例:
	x = [1, 2, 3, 4]
	x[2] = 1 + 2.14  # 改变了第三个元素的值
	print(x)  

列表的切片操作

切片取值
列表[起始索引:终止索引:步长]
列表的切片取值是从原列表中取出想要的元素再次组成一个
新的列表
示例:
	 L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 	 y = L[1:10:2]  # y = [1, 3, 5, 7, 9]

**切片的赋值操作**
作用:
	可以改变原列表的排列,可以插入,和修改数据
语法:
	列表[切片] = 可迭代对象
说明:
	切片赋值的赋值运算符(=)的右侧必须是一个可迭代对象
示例:
	L = [2, 3, 4]
	L[0:1] = [1.1, 2.2]  # L=[1.1, 2.2, 3, 4]
	L[0:2] = [2]  # L = [2, 3, 4]
	L[1:2] = [3.1, 3.2]  # L = [2, 3.1, 3.2, 4]

	L = [2, 3, 4]
	L[1:1] = [2.1, 2.2]  # L = [2, 2.1, 2.2, 3, 4]
	L[0:0] = [0, 1]  # L = [0, 1, 2, 2.1 ....]
	L = [2, 3, 4]
	L[3:3] = [5, 6]  # L = [2, 3, 4, 5, 6]

	L = [2, 3, 4]
	L[1:2] = "AB" # L = [2, 'A', 'B', 4]
	L[1:3] = range(7, 10)  # L = [2, 7, 8, 9, 4]

**切片的注意事项:**
	对于步长不等于1的切片赋值,赋值运算符的右侧的可迭代对象
提供的元素的个数,一定要等于切片切出的段数

L = [1, 2, 3, 4, 5, 6] 
L[::2] = "ABC"  # 对的
L[::2] = "abcd"  # 错的

del 语句

可以用于删除列表的元素
语法:
	del 列表[整数表达式]
	del 列表[切片]
示例:
	L = [1, 2, 3, 4, 5, 6, 7, 8]
	del L[-1]  # L = [1, 2, 3, 4, 5, 6, 7]
	del L[1::2] # L = [1, 3, 5, 7]

python中常用于的序列的函数

len(x)  返回序列的长度
max(x)  返回序列的最大值元素
min(x)  返回序列中最小值元素
sum(x)  返回序列中所有元素的和(元素必须是数字类型)
any(x)  真值测试.如果列表中的一个值为真值则返回True
all(x)  真值测试.如果列表中所有的值为真值则返回True

示例:
	L = ["Beijing", 1, 123]
	print(len(L))  # 3
	L = [8, 3, 6, 2]
	print(max(L))  # 8
	print(min(L))  # 2
	print(sum(L))  # 19

列表常用的方法:

L.append(x)  追加
L.insert(索引, 数据对象)
L.extend(可迭代对象)
L.remove(数据对象)
L.pop([整数索引])
L.clear() 
L.count(数据对象) 
L.index(数据对象) 返回第一次出现的位置
L.sort(reverse=False)  排序
L.reverse()   反转

列表与字符串比较:

1. 列表和字符串都是序列,元素之间有先后顺序关系
2. 列表和字符串有相同的操作: + += * *= <　> in ...
3. 字符串是不可变化的序列，列表是可变的序列
4. 字符串的每个元素只能存储字符，而列表可以存储任意类型
	的元素
5. 列表和字符串都是可迭代对象

字符串的文本解析方法 split 和join

S.split(sep=None)  将字符串使用sep作为分隔符分割s
       字符串，返回分割后的字符串列表;当不给定参
       数时，用空白字符作为分隔符
S.join(iterable)  用可迭代对象中的字符串生成一个中
       间用S进行分隔的字符串
示例:
	s = 'Beijing is Capital'
	L = s.split(' ')   # L = ['Beijing', 'is', 'Capital']
	s2 = "##".join(L)  # s2 = "Beijing##is##Capital"

列表推导式 list comprehesion

列表推导式是用可迭代对象创建列表的表达式
作用：
	创建列表
	语法：
		[ 表达式 for 变量 in 可迭代对象]
或
		[ 表达式 for 变量 in 可迭代对象 if 真值表达式]
示例:
	生成一个数值为1~9的平方的列表
  	L = [x**2 for x in range(1, 10)]
	# L = [1, 4, 9, 16 .... 64, 81]
	# 生成一个数值1~9的平方的列表(只要其中奇数的平方)
	L = [x**2 for x in range(1, 10) if x % 2 = = 1]
	# L = [1, 9, 25, 49, 81]
	以上列表推导式可以改写为:
	L = []
	for x in range(1, 10):
    	if x % 2 == 1:
        	L.append(x**2)

列表推导式的嵌套语法:

[ 表达式
    for 变量1 in 可迭代对象1 if 真值表达式1
        for 变量2 in 可迭代对象2 if 真值表达式2
            .....]
如:
L = [x + y for x in "ABC" for y in "123"]
# L = ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 
        'C1', 'C2', 'C3']