python中的for语句和列表list的用法以及深拷贝与浅拷贝

python基础
1.for语句：
作用：
用来遍历可迭代对象的数据元素（）
  可迭代对象是指能依次获取数据元素的对象
语法：
for  变量列表 in 可迭代对象：
语句块1
else：（只有在可迭代对象不能提供数时才会执行）
语句块2
变量列表：自己定义的变量
示例：
s="ABCD"    #只能对可迭代对象进行遍历
for ch in s:
print("ch--->>",ch)
输出结果：
ch--->> A
ch--->> B
ch--->> C
ch--->> D

for 语句说明：
else子句部分可以省略
当在循环内部用break终止循环时，else子句部分不会执行

2、range 函数：
range(stop)用来生成0~stop区间内的整数，直到stop为止（不包含stop）
range(start,stop[,step])用来生成start~stop区间内的整数，直到stop为止（不包含stop）
每次生成整数后移动stop
格式：
>>>help(range)
作用：
用来创建一个生成一系列整数的可迭代对象（也叫整数序列生成器）
说明：
range返回的对象可以有for语句来进行依次迭代访问取出其中的整数
示意：
	range(4)  #生成0，1，2，3
	range(3,6)  #生成3，4，5
	range(1,10,2)   #生成1，3，5，7，9
	range(5,0,-2)   #生成5，3，1
	range(4,0)      #空

**for语句变量可能不被创建的问题：
for x in range(4,0):
    print(x)
    print('x绑定',x)#报错

**for语句的注意事项：
range只调用一次
i=6
for x in range(1,i): #for x in range(1,6)
 	print('x=',x,'i=',i)
	i-=1

for语句嵌套：
   for x in "ABC":
	for y in "123":
		print(x+y)

3、continue语句：
作用：
用于循环语句（while，for）中，不再执行本次循环
continue之后的语句，重新开始一次新的循环
语法：
continue
说明：
1.在while语句中执行continue，将会跳转到while语句的真值表达式
处重新判断循环条件
2.在for语句中执行continue语句，将会从可迭代对象中取
下一个元素，绑定变量后再次进行循环
示例：
continue只能让之后的语句不再执行
for x in range(10):
    if x % 2 == 0:#是偶数，跳过
        continue
    print(x)

while中使用continue
示例：
x=0
while x<5:
    if x==2:
        x+=1
        continue
    print(x)
    x+=1	
-------------------------------------------
循环总结：
四条语句：（只能用在循环里）
while语句
for 语句
break语句
continue语句
------------------------------------------
=========================================
一、列表 list
问题：
如何将计算机运算的数据临时保存在一个地方，同时又方便
添加删除和修改等操作
容器
1.列表的定义：
    列表是一种容器
    列表是可以被改变的序列
    列表是由一系列特定元素组成的，元素与元素之间可能没有任何
    的关联关系，但他们之间有先后顺序关系

python3中的序列类型：
字符串 str
列表 list
元组 tuple
字节串 bytes
字节数组 bytearray

2.创建空列表的字面值表达式：
[]  #创建一个空列表
L=[]   变量绑定一个新创建的空列表

3.创建非空的列表的字面值：
L=[1,2,3,4]  #L绑定一个新创建且含有四个元素的列表
L=['Beijing','Shanghai','Shenzhen']
L=[1,'Two',3.14,'四']
L=[1,2,[3.1,3.2,3.2],4]

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

二、列表的运算：
算术运算：
+ += * *=（运算规则与字符串的运算规则相同）
+ 用于拼接列表，生成新的列表
 x=[1,2,3]
 y=[4,5,6]
 z=x+y   #z=[1,2,3,4,5,6]

+= 用原列表与右侧可迭代对象追加起来修改原列表
   语法：
	列表变量 += 可迭代对象
   示例：
	x=[1,2,3]
	y=[4,5,6]
	x +=y   #x=[1,2,3,4,5,6]
	x+="ABC"  #x=[1,2,3,4,5,6,'A','B','C']
	x += range(4,6)  #x=[1,2,3,4,5]
	# += 是改变原来的列表对象，并不会创建新的列表
	x = [1,2,3]
	print(id(x))
	x += [4,5,6]
	print(id(x))  #字符串+= 会变

字符串是不可改变的对象 +=是创建新的对象，让变量绑定新对象
sx+= "123" 等同于sx = sx +'123'
sx="ABC"
print(id(sx))
sx += '123'
print(id(sx))

* 生成重复的列表
    x=[1,2]*3  # x=[1,2,1,2,1,2]

*=生成重复的列表，并改变对变量的绑定
    x=[1,2,3]
    x*=4   #x=[1,2,3,1,2,3,1,2,3,1,2,3]

三、列表的比较运算：
    运算符：
	<  <= > >= == !=
	    比较规则与字符串的比较规则相同
    示例：
	[1,2,3] < [1,2,4]   #True
	[1,2,3] < [3,2,1]   #True
	[1,2,3] == [3,2,1]  #False
	[2,3] >= [1,2,3]    #True

	[1,"2"] > ['2',1]   #报错
	["ABC",1,2,3] < ["123",3,2]   #True

列表是可迭代对象
    L=[1,3,5,7]
    for x in L:
	print(x)   #1 3 5 7

三、列表的in /not in 运算符
判断一个值是否存在于列表中，如果存在返回True，否则返回False
同字符串的in 运算符
用于检查一个值是否存在于列表中，如果存在返回True，否则返回False
示例:
    x = [1 ,'Two', 3, '四' ]
    3 in x   #返回True
    '3' in x  #返回False
    10 in x  #False
    10 not in x #True

四、列表的索引操作：
    语法：
	列表[整数表达式]
    用法：
	与字符串索引的用法相同（分为正向索引和反向索引）
    示例：
	x=[1,3,5,7]
	print(x[1]) #3
	print(x[-1])#7

五、列表的索引赋值：
    列表是可变的，可以通过索引赋值改变列表中的元素
    语法：
	列表[整数表达式]=表达式
    作用：
	改变列表中索引对应的绑定关系
    示例：
	x=[1,2,3,4]
	x[2]=3.14 #改变了第三个元素的值

六、列表的切片：
    列表[:]
    列表[::]
    列表切片取值返回一个新的列表，规则等同于字符串切片规则
    示例：
	x=[1,2,3,4,5,6,7,8]
	x=[::2]   #[1,3,5,7]
	x=[1::3]  #[2,5,8]

七、列表的切片赋值：
    作用：
	可以改变原列表的数据排列，可以插入和修改数据
	可以用切片改变列表的对应元素的值
	增加或减少原来的列表数据
    语法：
	列表[切片]=可迭代对象
    说明：
	切片赋值的赋值运算符（=）的右侧必须是一个可迭代对象
    示例：
	L =[2,3,4]
	L[0:1] = [1.1,2.2]   #L=[1.1,2.2,3,4]
	L[2:]=[1.1,2.2,3.3,4.4,5.5] #L=[1.1,2.2,3.3,4.4,5.5]
	L=[:]=[3,4]  #L=[3,4]
	L[0:0]=[1,2]    #L=[1,2,3,4]
	L[1:1=[3.14]    #L=[3,3.14,4]
	L[2:2]=[5,6]   #L=[3,4,5,6](越界)
	L[::]=[]	#可以当作清空操作
	L[1:2]="ABC"    #L=[2,'A','B','C',4]
	L=[2,-1,7]
	L[1:2]=range(3,7)   #L=[2,3,4,5,6,7]
        
	切片的注意事项：
	    对于步长不等于1的切片赋值，赋值运算符的右侧的可迭代对象提供元素
	    的个数一定要等于切片切出的段数
	    示例：
		L=[1,2,3,4,5,6,7,8]
		L[1::2]="ABCD"   #对的  L=[]
		L[1::2]="ABCDEF" #错的

八、del语句 用于删除列表的元素
    语法：
	del 列表[索引]
	如：del L[0]
	del 列表[切片]
	如：del L[1::2]


	python3 中常用于序列的函数
	   len(s)  返回序列的长度
	   max(x)  返回序列的最大值元素
	   min(x)  返回序列的最小值元素
	   sum(x)  返回列中所有元素的和（元素必须是数值类型）
	   any(x)  真值测试，如果列表中其中一个值为真值则返回True
	   all(x)  真值测试，如果列表中所有值为真值返回True	
	示例：
	    L=[3,1,9,7,5]
	    print(len(L))    #5
	    print(max(L))    #9
	    print(min(L))    #1
	    print(sum(L))    #25
注：列表里有字符串不能使用sum
列表里有字符串和数字是不能用max比较
python3中常见的列表方法（method）
   详见：>>>help(list)
L.pop(index)不等同于del L[index]	
L.index(v [, begin[, end]]) 返回对应元素的索引下标, begin为开始索引，
		   end为结束索引,当 value 不存在时触发ValueError错误

九、列表和字符串比较：
    1.都是序列，有先后顺序关系，有相同的运算操作
    2.列表是可变的，字符串是不可变的
    3.列表可以存任意类型的数据，字符串只能存字符

	字符串的文本解析方法
	    S.split（sep=None） 将字符串，使用sep作用分隔符分割S字符串，返回
	    分割后的字符串列表，当不给定参数时，用空白字符作用为分隔符分割
	
	    S.join(iterable)
	    用可迭代对象中的字符串，返回一个中间用S进行分隔的字符串
	
十、列表推导式 list comprehension
    列表推导式是用可迭代对象创建列表的表达式
    作用：
	用简易方法生成列表
    语法：
	[表达式 for 变量 in可迭代对象]
	或
	[表达式 for 变量 in 可迭代对象 if 真值表达式]
    示例：
	#生成一个数值为1~9的平方的列表
	#[1,4,9,16,...81]
	不用推导式：
	L = []
	for x in range(1,10):
	    L.append(x**2)
	print(L)
	推导式实现：
	L=[i**2 for i in range(1,10)]
	print(L)
例：
	用列表推导式生成1~100以内奇数的列表
	L = [i for i in range(1,100,2)]
	print(L)
	或
	[i for i in range(1,100) if i%2==1]

十一、列表推导式的嵌套：
    语法：
	[表达式 for 变量1 in可迭代对象1 if真值表达式1
	    for 变量2 in 可迭代对象2 if 真值表达式2...]
    示例：
	#将列表[10,20,30]中的元素与列表[1,2,3]
	元素分别相加，将得到的元素放于一个列表中
	L =[ x + y
		for x in [10,20,30]
		    for y in [1,2,3]]
	print(L)  #[11,12,13,21,22,23,31,32,33] 
--------------------------------------------------------------	
深拷贝和浅拷贝

浅拷贝 shallow copy
    浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑
    定的对象的复制过程
示意：
    L=[3.1,3.2]
    L1=[1,2,L]
    L2=L1.copy()   #浅拷贝
    print(L1)
    print(L2)
    L2[2][0]=3.14
    print(L1)      #[1,2,[3.14,3.2]]
    print(L2)      #[1,2,[3.14,3.2]]

L2=L1  #不是复制，是赋值

深拷贝 deep copy
    复制对象及对象关联的对象一起复制过程叫深拷贝

示意：
    import copy   #导入复制模块
    L=[3.1,3.2]
    L1=[1,2,L]
    L2=copy.deepcopy(L)   #深拷贝
    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]]   <<<L1不变
    print(L2)      #[1,2,[3.14,3.2]]