Python3基础(列表list)

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

创建空列表的字面值
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[]
list(iterable) 用可迭代对象创建一个列表

示例：
L = list() 　　　　　　　　#L绑定空列表
L = list(“hello”) 　　　　　　#L绑定[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]
L = list(rannge(10)) 　　　　　#L绑定[0,1,2,3,4,5,6,7,8,9]

列表的运算：
算数运算符：+ += * *=
+= 运算符等同于在原列表的末尾添加数据　
示例：
x = [1, 2, 3]
y = [4, 5, 6]
z = x + y # z = [1, 2, 3, 4, 5, 6]

列表的比较运算：
运算符:
< <= > >= == !=
说明：
列表的比较规则与字符串的比较规则相同
列表要求每两个元素能依次进行比较，否则会出现类型错误
示例：
[1, 2, 3] < [1, 2, 4] #True
[1, 2, 3] != [1, 2, 4] #True
[‘one’, ‘two’] < [‘1’, ‘2’] #False
[1, ‘two’] > [‘two’, 1] #TypeError

列表的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] #[1,3,5,7,9]

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

切片的注意事项：
对于步长不等于１的切片赋值，赋值运算符的右侧的可迭代对象提供的元素的个数，
一定要等于切片切出的段数
示例：
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]

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

python3中常用于的序列的函数

len(x)　		返回序列的长度
max(x)		返回序列的最大值元素
min(x)		返回序列中最小值元素
sun(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(sun(L)) #19

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

python3中常用的列表方法(method)
文档参见：
>>>help(list)
/
L.index(v [, begin[, end]]) 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误
L.insert(index, obj) 将某个元素插放到列表中指定的位置
L.count(x) 返回列表中元素的个数
L.remove(x) 从列表中删除第一次出现在列表中的值
L.copy() 复制此列表（只复制一层，不会复制深层对象)

／
深拷贝 deep copy
如：
import 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.1,3.2]]××××××
print(L2) #[1, 2, [3.14,3.2]]
/
浅拷贝 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]]

L.append(x) 	向列表中追加单个元素
L.extend(lst) 	向列表追加另一个列表
L.clear() 	清空列表,等同于 L[:] = []
L.sort(reverse=False) 	将列表中的元素进行排序，默认顺序按值的小到大的顺序排列
L.reverse() 	列表的反转，用来改变原列表的先后顺序
L.pop([index]) 	删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系 

例：创建一个列表，并往里添加数个正整数．
１）打印出这个列表中的最大数和第二大的数．
２）删除最后一个元素并打印目前的列表
３）删除最大数和第二大的数并打印列表

l1 = []
while True:
    n = int(input('请输入正整数：'))
    if n < 0:
        break
    l1 += [n]

l1.sort()
print('最大的数是：', l1[-1])
print('第二大的数是：', l1[-2])
l1.reverse()
l1.pop()
print('l1 =', l1)

#先排序，找第二个元素
l1.sort()   #排序后最后一个最大

zuida = max(l1)
#把最大的全删除
l2 = l1.copy()  #复制一份
while zuida in l2:      #   l1内有最大数时就删除最大数
    l2.remove(zuida)
dierda = max(l2)
print('第二大是：', dierda)

#删除最小的一个数
zuixiao = min(l1)
l1.remove(zuixiao)  #只删除一个
print('最后的列表为：', l1)

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

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

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

字符串的文本解析方法　split 和　join
/
S.split(sep=None) 将字符串使用sep作用分隔符分割字符串，返回分割后的字符串列表，
当不给定参数时，用空白字符作为分割符
/
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 真值表达式]
示例：
生成一个数值为１～９的平方的列表
　　L = [x**2 for x in range(1, 10)]
#L = [1, 4, 9, 16, …64, 81]

生成一个数值为１～９的平方的列表(只要其中奇数的平方)
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 真值表达式
　　　　…]

如：
　　L = [x + y for x in ‘ABC’ for y in ‘123’]
#L = [‘A1’,‘A2’, …‘C3’]

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
练习：
１．有一些数存于列表中，如：
L = [1,3,2,1,6,4,2,…98,82]
1)将列表中出现的数字存入到另一个列表L2中
要求：
重复出现多次的数字只能在L2中保留一份（去重）
2)将列表中出现两次的数字存于L3列表中，在L3列表中只保留一份

L = [1,4,3,5,7,8,10,98,57,65,85,8,7,5,3,10,3,8]
L1 = []
L2 = []
L3 = []

for x in L:             #用x遍历L列表
    if x not in L2:     #如果x不在L2列表中：就将这个x添加到L２列表中，循环回来时如果发现x在L2列表中已经存在（重复），就进入else语句  
        L2.append(x)
    else:               #否则如果x在L２列表中：就将这个x添加到L1列表中，这个下面的Ｌ１列表中存放的是那些重复出现多次的数字，并不是只保留一份，而是都保存下了
        L1.append(x)
        
print('L1 =', L1)

for y in L2:            #用y遍历L2列表(L去重后的列表)
    if y in L1 and L.count(y)==2:         #如果y在L1列表(重复数字列表)中：就将这个y添加到L3列表中。也就是说在L1列表(存放那些重复数字的列表）中只要发现和y相同的数字，就意味着这个数字在原列表L中出现了两次(或者多次),然后同时排除那些出现不是两次而是更多次的数
        L3.append(y)
        
print('L2 =', L2)

print('L3 =', L3)

２，生成一个列表，求x的平方+1的列表，跳过结果能被5整除的数（注：0 <= x <= 100)

l = [x**2+1 for x in range(0,101) if x % 5 != 0]
print('l =', l)

３．把0~100之间的所有素数存于一个列表中
　　即：L = [2,3,5,7,11,…97]

L = []
a = 0   #用于累加，随着s的遍历,提高除数s的范围
for x in range(2,101):  #用x遍历2~100之间，                           
    for s in range(2,a+1):      #再用s遍历2到s最大值之间
        if x % s == 0:  #如果x除以s余数为０则跳出当前循环
            break
    else:               #否则的话将这个x添加到L列表中
        L.append(x)
        a += 1       #for s循环遍历一遍，累加一次，提高除数s的范围
print('L =', L)

print('--------方法二-------')
L = []
for x in range(101):
    if x < 2:
        continue
    #走到此，x的值一定大于２
    #判断ｘ能否被２，３，４，５....x-1整除
    for i in range(2, x):
        if x % i == 0:
            #x一定不是素数
            break
    else:
        L.append(x)
print(L)