Python编程语言下使用list和tuple
列表 list
列表由一系列特定元素组成，元素和元素间没有任何关联关系，但有先后顺序关系
列表是一种容器
列表是序列的一种
列表是可以被改变的序列
python中的序列类型简介（sequence）
字符串 str
列表 list
元祖 tuple
字节串 bites
字节数组 bytearray
创建空列表的字面值：
L = [] #L绑定空列表
创建非空列表：
L=[1，2，3，4]
L=['北京'，'上海'，'重庆']
L=[1，'two'，3,'四']
L=[1,2，[3.1，3.2,3.3],4]
列表的构造（创建）函数list
list（） 生成一个空的列表 等同于[]
list（iterable） 用可迭代对象创建一个列表
示例：
L=list（） L为空列表
L=list("ABCD") #L-->['A','B','C','D']
L=list（range（1,10,2））
列表的运算：
算术运算：
+ += * *=
+：用于拼接列表
x=[1,2,3]
y=[4,5,6]
z=x+y # z=[1,2,3,4,5,6]
+=:用于原列表与右侧可迭代对象进行拼接，生成新的列表
x=[1,2,3]
x+=[4,5,6] # x=[1,2,3,4,5,6]
x=[1,2,3]
x+='ABC' # x=[1,2,3,A,B,C] (+=:右侧必须是可迭代对象）
*:生成重复的列表：
x=[1,2,3]*2 # x=[1,2,3,1,2,3]
*=:用于生成重复的列表，同时用变量绑定新列表
x=[1,2]
x*=3 # x=[1,2,1,2,1,2]
比较运算：
运算符：< <= > >= == !=
示例：
x=[1,2,3]
y=[4,5,6]
x!=y #True
x>[1,2] #True
x<y #True
[1,3,2]>[1,2,3] #True
['AB','CD']>['AC','BD'] #True
[1,'two']>['two',1] #TypeError
练习：
1，输入一个整数，代表树干的高度，打印一颗圣诞树
如：输入：2
打印：
*
***
*
*
输入：3
打印：
*
***
*****
*
*
*
2，用循环生成如下字符串：
‘ABC...XYZ’
‘AaBbCc...XxYyZz’
提示：用ord和chr函数结合循环语句实现
3，算出100~999以内的水仙花数（Narcissistic number）
水仙花数指百位的三次方加上十位的三次方加上各位的三次方等于原数的数字
例如：153=1**3 + 5**3 + 3**3
2，not in的返回值与in运算符相反
示例：
x in [1,'two',3.14,四]
1 in x #True
2 in x #False
3 not in x #True
'四' not in x #False
列表的 索引 index / 切片 slice
列表的索引语法：
列表[整数表达式]
用法：
列表的索引取值与字符串的索引取值规则完全相同
列表的索引分为正向索引和反向索引
示例：
L=['A',2，'B',3]
print(L[1]) #2
x = L[2] #x = 'B'
列表的索引赋值
列表是可变的序列，可以通过索引赋值改变列表中的元素
语法：
列表[索引]=表达式
示例：
x = [1,2,3,4]
x[2] = 3.14 #改变了第三个元素的值
id（x）指列表x在计算机中的存储位置（起始位置）
*列表L中元素增删替换，或列表做加减运算，id（L）不变
*字符串s中元素增删替换，或字符串做加减运算，id（s）改变
Python是用引用计数来管理内存的
列表的切片：
列表[:]
列表的[::]
列表的切片取值返回一个列表，规则等同于字符串的切片规则
示例：
x = list(range(9))
y = x[1:9:2] #y= [1,3,5,7]
列表的切片赋值语法：
列表[切片] = 可迭代对象
说明：
切片赋值的赋值运算符的右侧必须是一个可迭代对象
示例：
L = [2，3，4]
L[0：1]=[1.1，2.2]
print（L） #L=[1.1，2.2，3，4]
L = [2，3，4]
L[:]=[7，8]
print（L） #L=[7，8]
L = [2，3，4]
L[1:2]=[3.1，3.2，3.3]
print（L） #L=[2，3.1，3.2，3.3，4]
L = [2，3，4]
L[1：1]=[2.1，2.2]
print（L） #L=[2，2.1，2.2，3，4]
L = [2，3，4]
L[0：0]=[0，1]
print（L） #L=[0，1，2，3，4]
L = [2，3，4]
L[3：3]=[5，6]
print（L） #L=[2，3，4, 5，6]
L = [2，3，4]
L[2：3]=[]
print（L） #L=[2，3]
切片步长不为1的切片规则：
L=list（range（1,9））
L[1：:2]=[2.2，4.4，6.6，8.8]
print（L） #L=[1，2.2，3，4.4，5，6.6，7，8.8]
切片注意事项：
对于步长不等于1的切片赋值，
赋值运算符右侧的可迭代对象提供元素的个数一定要等于切片切出的段数
如：
L = [1，2，3，4，5，6]
L[::2] = 'ABCD’ #错的
L[::2] = 'ABC’ #对的
del 语句用于删除列表元素
语法：
del 列表[索引]
del 列表[切片]
示例：
L = [1，2，3，4，5，6]
del L[0] #L = [2，3，4，5，6]
del L[-1] #L = [2，3，4，5]
L = [1，2，3，4，5，6]
del L[::2] #L = [2，4，6]
☆.python3中常用的序列函数：
len（x） 返回序列的长度
max（x） 返回序列的最大值元素
min（x） 返回序列的最小值元素
sum（x） 返回序列中所有元素的和（元素必须是数值类型）
any（x） 真值测试，若列表中其中一个值为真值则返回True，否则返回False
all（x） 真值测试，若列表中所有值为真值则返回True，
只要有一个为假，则返回False
练习：
1，已知有列表L=[3，5],用索引和切片操作将列表改为：L=[1，2，3，4，5，6]
将列表反转（前后对调），然后删除最后一个元素，print（L） #[6，,4，3，2]
2，写程序，让用户循环输入一些整数，当输入-1时结束，将这些整数存在于列表L中
1）打印一共输入几个有效的数字
2）打印输入的最大数
3）打印输入的最小数
4）打印输入这些数的平均数
python3常见的列表方法：
见：help（list）
L.append()
L.extend(list) ----->相当于L += list
L.pop(index)
练习：
写一个程序，输入多行文字，当输入空行时结束输入，将原输入所有字符串存于列表中：
1）按原输入行的顺序反向打印这些行
例：输入hello world
输入welcome to china
输入I like python
输入<回车>
显示：I like python
welcome to china
hello world
2）打印一共输入了多少字符
深拷贝deep copy和浅拷贝shallow copy：
浅拷贝
是指在复制过程中只复制一层变量，不会复制深层变量绑定的对象的过程
L=[3.1，3.2]
L1=[1，2，L]
L2=L1.copy（）#等同于L1[:] 浅拷贝
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]]
**python：变量赋值是改变变量的绑定关系，并不会复制
L=[1，2，3]
L1=L
L[1]=1
print(L) #L=[1,1,3]
print(L1) #L1=[1,1,3]
L=[1，2，3]
L1=L[:] #等同于L1=L.copy（）
L[1]=1
print(L) #L=[1,1,3]
print(L1) #L1=[1,2,3]
深拷贝：
import copy #导入copy模块
L=[3.1，3.2]
L1=[1，2，L]
L2=copy.deepcopy（L1） #深拷贝
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.1，3.2]]
注：深拷贝通常只对可变对象进行复制，不可变对象通常不变
列表推导式： list conprehension
列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式
作用：
用简易方法生成列表
语法：
[表达式 for 变量 in 可迭代对象]
或：
[表达式 for 变量 in 可迭代对象 if 真值表达式 ]
示例：
#以下生成一个数值为1~9的平方的列表
L=[x*x for x in range（1,10）]
相当于：
L = []
for x in range(1,10):
L.append(x*x)
练习：
用列表推导式生成1~100内所有奇数的列表，结果[1,3,5，..99]
示例：
#以上练习可以改写为：
L=[x for x in range(1,101) if x % 2 == 1]
列表推导式的嵌套：
语法：
[表达式1 for 变量1 in 可迭代对象1 if
真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2...]
示例：
L1=[2，3，5]
L2=[7，11，13]
#将L1中的全部元素与L2中的全部元素相乘后放到列表L3中
L3=[x**y for x in L1 for y in L2]
print(L3)
练习：
1，用字符串s=‘ABC’和s2=‘123’
生成如下列表：
['A1','A2','A3','B1','B2','B3','C1','C2','C3']
2，有一些数存在于列表L中，如：
L=[1,3,2,1,6,4,2...98,82]（数据自己定义）
将列表L中的数存于另一个列表L2中
（要求重复出现多次的数字只在L2列表中保留一份）
3，生成前40个斐波那契数（Fibonacci）
1 1 2 3 5 8 13 ....
(自第三个起，之后的所有数为前两个数之和)
要求：将这些数存于列表中，最后打印列表中这些数
提示：用循环、列表或变量组合可以实现
元组 tuple：
元组是不可改变的序列，同list一样，元组可以存放任意类型的元素，
一旦元组生成，则它不可以改变
元组的表示方式：
用小括号（）括起来，单个元素括起来用逗号（，）区分是单个对象还是元组
创建空元祖的字符值
t = （）
创建非空元组得字面值：
t = 200，
t = (20,)
t = (1,2,3)
t = 100,200,300
元组的错误示例：
t=(20) #t绑定整数
x,y,z=100,200,300 #序列赋值 #x=100 y=200 z=300
x,y,z=a，b，c #x=a y=b z=c
x,y,z=[10,20,30] #x=10 y=20 z=30
元组的构造函数 tuple
tuple（） 生成一个空的元组,等同于（）
tuple（iterable） 用可迭代对象生成一个元组
示例：
t=tuple（）
t=tuple（range（10））
t=tuple（‘hello’）
t=tuple（[1,2,3,4]）
t=tuple（（1,2,3,4））
元组的算术运算：
+ += * *=
算法与列表的用法完全相同
元组的比较运算：
< <= > >= == !=
规则与列表完全相同
in / not in
索引取值
切片取值
规则与列表完全相同
区别：
元组是不可变对象，不支持切片赋值和索引赋值
元组的方法：
见help（tuple）
T.count(value) 用于获取元祖中v的个数
T.index(value[，start[，stop]]) 用于获取元组中v元素的索引位置
可以用于序列的函数：
len， max, min, sum, all, any
三个构造函数：
str(obj)
list(iterable)
tuple(iterable)
用于创建相应的对象
其他函数：
reversed（seq） 返回反向顺序的可迭代对象
sorted(iterable,reversed=False) 返回已排序的列表
示例：
for x in reversed("ABCD")
print(x) # D C B A
L=[8,6,3,5,7]
L2=sorted(L)
print(L2) #[3,5,6,7,8]
L3=sorted(L,reversed=True)
print(L3) #[8,7,6,5,3]
print(L) #保持不变
列表由一系列特定元素组成，元素和元素间没有任何关联关系，但有先后顺序关系
列表是一种容器
列表是序列的一种
列表是可以被改变的序列
python中的序列类型简介（sequence）
字符串 str
列表 list
元祖 tuple
字节串 bites
字节数组 bytearray
创建空列表的字面值：
L = [] #L绑定空列表
创建非空列表：
L=[1，2，3，4]
L=['北京'，'上海'，'重庆']
L=[1，'two'，3,'四']
L=[1,2，[3.1，3.2,3.3],4]
列表的构造（创建）函数list
list（） 生成一个空的列表 等同于[]
list（iterable） 用可迭代对象创建一个列表
示例：
L=list（） L为空列表
L=list("ABCD") #L-->['A','B','C','D']
L=list（range（1,10,2））
列表的运算：
算术运算：
+ += * *=
+：用于拼接列表
x=[1,2,3]
y=[4,5,6]
z=x+y # z=[1,2,3,4,5,6]
+=:用于原列表与右侧可迭代对象进行拼接，生成新的列表
x=[1,2,3]
x+=[4,5,6] # x=[1,2,3,4,5,6]
x=[1,2,3]
x+='ABC' # x=[1,2,3,A,B,C] (+=:右侧必须是可迭代对象）
*:生成重复的列表：
x=[1,2,3]*2 # x=[1,2,3,1,2,3]
*=:用于生成重复的列表，同时用变量绑定新列表
x=[1,2]
x*=3 # x=[1,2,1,2,1,2]
比较运算：
运算符：< <= > >= == !=
示例：
x=[1,2,3]
y=[4,5,6]
x!=y #True
x>[1,2] #True
x<y #True
[1,3,2]>[1,2,3] #True
['AB','CD']>['AC','BD'] #True
[1,'two']>['two',1] #TypeError
练习：
1，输入一个整数，代表树干的高度，打印一颗圣诞树
如：输入：2
打印：
*
***
*
*
输入：3
打印：
*
***
*****
*
*
*
2，用循环生成如下字符串：
‘ABC...XYZ’
‘AaBbCc...XxYyZz’
提示：用ord和chr函数结合循环语句实现
3，算出100~999以内的水仙花数（Narcissistic number）
水仙花数指百位的三次方加上十位的三次方加上各位的三次方等于原数的数字
例如：153=1**3 + 5**3 + 3**3
参考答案：153,370...
列表的 in / not in
1，判断一个数据元素是否存在于容器（列表）内，若存在返回True，否则返回False2，not in的返回值与in运算符相反
示例：
x in [1,'two',3.14,四]
1 in x #True
2 in x #False
3 not in x #True
'四' not in x #False
列表的 索引 index / 切片 slice
列表的索引语法：
列表[整数表达式]
用法：
列表的索引取值与字符串的索引取值规则完全相同
列表的索引分为正向索引和反向索引
示例：
L=['A',2，'B',3]
print(L[1]) #2
x = L[2] #x = 'B'
列表的索引赋值
列表是可变的序列，可以通过索引赋值改变列表中的元素
语法：
列表[索引]=表达式
示例：
x = [1,2,3,4]
x[2] = 3.14 #改变了第三个元素的值
id（x）指列表x在计算机中的存储位置（起始位置）
*列表L中元素增删替换，或列表做加减运算，id（L）不变
*字符串s中元素增删替换，或字符串做加减运算，id（s）改变
Python是用引用计数来管理内存的
列表的切片：
列表[:]
列表的[::]
列表的切片取值返回一个列表，规则等同于字符串的切片规则
示例：
x = list(range(9))
y = x[1:9:2] #y= [1,3,5,7]
列表的切片赋值语法：
列表[切片] = 可迭代对象
说明：
切片赋值的赋值运算符的右侧必须是一个可迭代对象
示例：
L = [2，3，4]
L[0：1]=[1.1，2.2]
print（L） #L=[1.1，2.2，3，4]
L = [2，3，4]
L[:]=[7，8]
print（L） #L=[7，8]
L = [2，3，4]
L[1:2]=[3.1，3.2，3.3]
print（L） #L=[2，3.1，3.2，3.3，4]
L = [2，3，4]
L[1：1]=[2.1，2.2]
print（L） #L=[2，2.1，2.2，3，4]
L = [2，3，4]
L[0：0]=[0，1]
print（L） #L=[0，1，2，3，4]
L = [2，3，4]
L[3：3]=[5，6]
print（L） #L=[2，3，4, 5，6]
L = [2，3，4]
L[2：3]=[]
print（L） #L=[2，3]
切片步长不为1的切片规则：
L=list（range（1,9））
L[1：:2]=[2.2，4.4，6.6，8.8]
print（L） #L=[1，2.2，3，4.4，5，6.6，7，8.8]
切片注意事项：
对于步长不等于1的切片赋值，
赋值运算符右侧的可迭代对象提供元素的个数一定要等于切片切出的段数
如：
L = [1，2，3，4，5，6]
L[::2] = 'ABCD’ #错的
L[::2] = 'ABC’ #对的
del 语句用于删除列表元素
语法：
del 列表[索引]
del 列表[切片]
示例：
L = [1，2，3，4，5，6]
del L[0] #L = [2，3，4，5，6]
del L[-1] #L = [2，3，4，5]
L = [1，2，3，4，5，6]
del L[::2] #L = [2，4，6]
☆.python3中常用的序列函数：
len（x） 返回序列的长度
max（x） 返回序列的最大值元素
min（x） 返回序列的最小值元素
sum（x） 返回序列中所有元素的和（元素必须是数值类型）
any（x） 真值测试，若列表中其中一个值为真值则返回True，否则返回False
all（x） 真值测试，若列表中所有值为真值则返回True，
只要有一个为假，则返回False
练习：
1，已知有列表L=[3，5],用索引和切片操作将列表改为：L=[1，2，3，4，5，6]
将列表反转（前后对调），然后删除最后一个元素，print（L） #[6，,4，3，2]
2，写程序，让用户循环输入一些整数，当输入-1时结束，将这些整数存在于列表L中
1）打印一共输入几个有效的数字
2）打印输入的最大数
3）打印输入的最小数
4）打印输入这些数的平均数
python3常见的列表方法：
见：help（list）
或E:\python-study\python_base_docs_html\list.html
L.append()
L.extend(list) ----->相当于L += list
L.pop(index)
练习：
写一个程序，输入多行文字，当输入空行时结束输入，将原输入所有字符串存于列表中：
1）按原输入行的顺序反向打印这些行
例：输入hello world
输入welcome to china
输入I like python
输入<回车>
显示：I like python
welcome to china
hello world
2）打印一共输入了多少字符
深拷贝deep copy和浅拷贝shallow copy：
浅拷贝
是指在复制过程中只复制一层变量，不会复制深层变量绑定的对象的过程
L=[3.1，3.2]
L1=[1，2，L]
L2=L1.copy（）#等同于L1[:] 浅拷贝
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]]
**python：变量赋值是改变变量的绑定关系，并不会复制
L=[1，2，3]
L1=L
L[1]=1
print(L) #L=[1,1,3]
print(L1) #L1=[1,1,3]
L=[1，2，3]
L1=L[:] #等同于L1=L.copy（）
L[1]=1
print(L) #L=[1,1,3]
print(L1) #L1=[1,2,3]
深拷贝：
import copy #导入copy模块
L=[3.1，3.2]
L1=[1，2，L]
L2=copy.deepcopy（L1） #深拷贝
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.1，3.2]]
注：深拷贝通常只对可变对象进行复制，不可变对象通常不变
列表推导式： list conprehension
列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式
作用：
用简易方法生成列表
语法：
[表达式 for 变量 in 可迭代对象]
或：
[表达式 for 变量 in 可迭代对象 if 真值表达式 ]
示例：
#以下生成一个数值为1~9的平方的列表
L=[x*x for x in range（1,10）]
相当于：
L = []
for x in range(1,10):
L.append(x*x)
练习：
用列表推导式生成1~100内所有奇数的列表，结果[1,3,5，..99]
示例：
#以上练习可以改写为：
L=[x for x in range(1,101) if x % 2 == 1]
列表推导式的嵌套：
语法：
[表达式1 for 变量1 in 可迭代对象1 if
真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2...]
示例：
L1=[2，3，5]
L2=[7，11，13]
#将L1中的全部元素与L2中的全部元素相乘后放到列表L3中
L3=[x**y for x in L1 for y in L2]
print(L3)
练习：
1，用字符串s=‘ABC’和s2=‘123’
生成如下列表：
['A1','A2','A3','B1','B2','B3','C1','C2','C3']
2，有一些数存在于列表L中，如：
L=[1,3,2,1,6,4,2...98,82]（数据自己定义）
将列表L中的数存于另一个列表L2中
（要求重复出现多次的数字只在L2列表中保留一份）
3，生成前40个斐波那契数（Fibonacci）
1 1 2 3 5 8 13 ....
(自第三个起，之后的所有数为前两个数之和)
要求：将这些数存于列表中，最后打印列表中这些数
提示：用循环、列表或变量组合可以实现
元组 tuple：
元组是不可改变的序列，同list一样，元组可以存放任意类型的元素，
一旦元组生成，则它不可以改变
元组的表示方式：
用小括号（）括起来，单个元素括起来用逗号（，）区分是单个对象还是元组
创建空元祖的字符值
t = （）
创建非空元组得字面值：
t = 200，
t = (20,)
t = (1,2,3)
t = 100,200,300
元组的错误示例：
t=(20) #t绑定整数
x,y,z=100,200,300 #序列赋值 #x=100 y=200 z=300
x,y,z=a，b，c #x=a y=b z=c
x,y,z=[10,20,30] #x=10 y=20 z=30
元组的构造函数 tuple
tuple（） 生成一个空的元组,等同于（）
tuple（iterable） 用可迭代对象生成一个元组
示例：
t=tuple（）
t=tuple（range（10））
t=tuple（‘hello’）
t=tuple（[1,2,3,4]）
t=tuple（（1,2,3,4））
元组的算术运算：
+ += * *=
算法与列表的用法完全相同
元组的比较运算：
< <= > >= == !=
规则与列表完全相同
in / not in
索引取值
切片取值
规则与列表完全相同
区别：
元组是不可变对象，不支持切片赋值和索引赋值
元组的方法：
见help（tuple）
T.count(value) 用于获取元祖中v的个数
T.index(value[，start[，stop]]) 用于获取元组中v元素的索引位置
以上方法同list中的count，index方法
可以用于序列的函数：
len， max, min, sum, all, any
三个构造函数：
str(obj)
list(iterable)
tuple(iterable)
用于创建相应的对象
其他函数：
reversed（seq） 返回反向顺序的可迭代对象
sorted(iterable,reversed=False) 返回已排序的列表
示例：
for x in reversed("ABCD")
print(x) # D C B A
L=[8,6,3,5,7]
L2=sorted(L)
print(L2) #[3,5,6,7,8]
L3=sorted(L,reversed=True)
print(L3) #[8,7,6,5,3]
print(L) #保持不变