Python 小白学习之：list

	列表的比较运算：
		运算符：
			< <= > >= == !=
		说明：
			列表的比较规则与字符的比较规则相同
			列表要求每两个元素能依次进行比较，否则就会出现类型错误
		示例:
			[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
			[1,2,3,4] > list(range(10)) # True 
	列表的 in/ not in运算符
		判断一个值是否存在于列表中，如果存在则返回True，否则返回False
		同字符串的 in 运算符类似
	运算符一般是用在表达式里的
	示例：
		x = [1,'Two',3,"四"]
		3 in x       # True
		"3" in x     # False
		10 not in x  # True
		
	**序列(有序排列，有排序规则)：字符串，列表，元组，字节串，字节数组
	**序列的（运算（+ -等）和比较（< >等），in/not in，索引和切片）的运算规则是一样的

	列表的索引操作：
		索引取值语法：
			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:9:2]  #  y = [1,3,5,7]
		切片的赋值操作：
			作用：
				可以改变原列表的排列，可以插入和修改数据
			语法格式：
				列表[切片] = 可迭代对象
			说明：
				切片赋值的赋值运算符（=）的右侧必须是一个可迭代对象
			示例：
				L = [2,3,4]
				L[0:1] = [1.1,2.2] # L = [1.1,2.2,3,4]
				L[0:2] = [2]  # L = [2,4]
				L[0:1] = []  # L = [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] = [1]  # L = [1,2,2.1,2.2,3,4]

				L = [2,3,4]
				L = [3:3] = [5,6]  # L = [2,3,4,5,6]
				
				L = [1.1,2.2,3,4]
				L[-1:-1] = [5,6]  # L = [1.1,2.2,3,5,6,4]
				
				L = [2,3,4]
				L[1:2] = "ab" # L = [2,'a','b',3,4]
				L[1:3] = range(7,10)
			切片的注意事项：
				对于步长不等于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]
练习：
	已经有列表：L = [3,5]，用索引和切片的操作，将原列表改变为
	            L = [1,2,3,4,5,6],将列表反转，结果如下：
				L = [6,5,4,3,2,1]，然后删除最后一个元素，结果如下：
				L = [6,5,4,3,2]
练习：
	写一个程序，让用户很多个正整数，当输入负数时结束输入
	将用户输入的数字存储于列表中，
	1，打印存有数字的列表
	2，求出这些数字中的平均数
	3，求出这些数字中的最大数
	如：
		请输入：1
		请输入：2
		请输入：99
		请输入：100
		请输入：-1
	打印如下：
		列表是[1,2,99,100]
		平均值是：50.5
		最大数是：100


Python3当中常用于序列的函数
	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,5,2]
		print(max(L))  #  8
		print(min(L))  #  2
		print(sum(L))  #  19
		
Python3中常用的列表方法（method）
	文档参见：
		python_base_docs_html/list.html
		
练习：
	写一个程序，让用户输入很多个正整数，当小于0时结束输入
	1）打印这些数中的最大的数
	2）打印这些数中的第二大的数
	3）删除最小的一个数
		
深拷贝 deep copy 和浅拷贝 shallow copy
	浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的
		对象的复制过程
	如:
		L = [3.1,3.2]
		L1 = [1,2,L]
		L2 = L1.copy  # 浅拷贝
		print(L1)   #  [1,2,[3.1,3.2]]
		print(L2)   #  [1,2,[3.1,3.2]]
		L2[2][0] = 3.14
		print(L1)   #  [1,2,[3.14,3.2]]
		print(L2)   #  [1,2,[3.14,3.2]]
	深拷贝	
		如：
		import copy  # 导入复制模块
		L = [3.1,3.2]
		L1 = [1,2,L]
		L2 = copy.deepcopyL1		# 深拷贝
		print(L1)   #  [1,2,[3.1,3.2]]
		print(L2)   #  [1,2,[3.1,3.2]]
		L2[2][0] = 3.14
		print(L1)   #  [1,2,[3.1,3.2]]
		
		print(L2)   #  [1,2,[3.14,3.2]]
		
列表与字符串比较：
	1.列表和字符串都是序列，元素之间有先后顺序关系
	2.列表和字符串有相同的操作：+ += * *= < > in ......
	3.字符串是不可变的序列，列表是可变的序列
	4.字符串的每个元素只能存储字符，而列表可以存储任意类型的元素
	5.列表和字符都是可迭代对象
	
字符串的文本解析方法 split 和 join
	S.split(sep=None)  将字符串使用sep作为分隔符分隔s字符串，返回分隔
	                   后的字符串列表；当不给定参数时，用空白字符作为
					   分隔符（sep要求是字符串里面的字符）
	S.join(iterable)   用可迭代对象中的字符串生成一个中间用S进行分隔
	                   的字符串
	示例：
		s = 'Beijing is Capital'
		L = S.split（" "）  # L = ['Beijing','is','Capital']
		L = S.split（"i"）  # L = ['Be','j','ng ','s Cap','tal']
		L = S.split（）  # L = ['Beijing','is','Capital'](不加参数代表以空白字符分隔)
		
		s2 = "##".join(L) # s2 = 'Beijing##is##Capital'
		
练习：
	有字符串“hello”
	生成新的字符串：
		'h e l l o'和'h-e-l-l-o'
		
	s1 = ' '.join('hello')
	s2 = '-'.join('hello')
		
列表推导式 list comprehesion
	列表推导式是用可迭代对象创建列表的表达式
	
	作用：
		创建列表
	语法：
		[表达式 for 变量 in 可迭代对象]
		或
		[表达式 for 变量 in 可迭代对象 if 真值表达式]
	示例：
		生成一个数值为1~9的平方的列表
		L = [x**2 for x in range(0,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 真值表达式
				for 变量2 in 可迭代对象2 if真值表达式
					...]
		如：
			L = [x + y for x in "ABC" for y in "123"]
			# L = ["A1","A2","A3","B1","B2","B3","C1","C2","C3"]
		(先执行X，然后执行X，等Y一轮循环完之后，再执行X一次，然后
		再执行Y一轮...依次类推)

练习：
	1.有一些数存于列表中，如：
		L = [1,3,2,1,6,4,2,......,98,82]
		1)将列表中出现的数字存入到另一个列表L2中
		要求：
			重复出现多次的数字只能在L2中保留一份（去重）
		2）将列表中出现两次的数字存于L3列表中，在L3列表中只保留一份
	2.生成一个列表，求x的平方+1的列表，跳过结果能被5整除的数，
		（注：0 <= x <= 100)
	3.把0~100之间的所有素数存于一个列表中
		即：L = [2,3,5,7,......,97]