python基础（6）——列表 & del & 深拷贝和浅拷贝

一、列表的 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

1、列表的索引赋值:

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

2、列表的切片

   列表[:]
   列表[::]
   列表的切片取值返回一个新的列表，规则等同于字符串切片规则

  示例:
     x = [1, 2, 3, 4, 5, 6, 7, 8]
     x[::2]  # [1, 3, 5, 7]
     y = [1::3]  # y = [2, 5, 8]

3、列表的切片赋值:

   作用:
   　　可以改变原列表的数据排列，可以插入和修改数据
      　可以用切片改变列表的对应元素的值
   语法:
      　列表[切片]　= 可迭代对象
　说明:
    　  切片赋值的赋值运算符(=) 的右侧必须是一个可迭代对象
 
   示例:
     L = [2, 3, 4]
     L[0:1] = [1.1, 2.2]  # L = [1.1, 2.2, 3, 4]
     L[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 = [3, 4]
     L[1:1] = [3.14]  # L = [3, 3.14, 4]
     L = [3, 4]
     L[-1:-1] = [5, 6] # L = [3, 4, 5, 6]
     L = [2, 3, 4]
     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]

  向列表头部添加元素的方法：
     L = [1,2,3,4,5]
     x = 2   # x为数字或字符串
     L [0:0] = [x]  （方法1）
     L.insert(0,x)  （方法2）
     print(L)

切片的注意事项:
   对于步长不等于1的切片赋值,赋值运算符的右侧的可迭代对象提供元素的个数一定要等于切片切出的段数
   示例:
     L = [1, 2, 3, 4, 5, 6, 7, 8]
     L[1::2] = "ABCD"  # 对的
     L[1::2] = "ABCDEF"  # 错的

三、del 语句 用于删除列表的元素

语法:
     del 列表[索引]
         如: del L[0]
     del 列表[切片]
         如: del L[1::2]

    列表.pop([索引])
    列表.remomve(对象)

练习:
   已知有列表:
     L = [3, 5]
   用索引和切片操作,将原列表改变为:
     L = [1, 2, 3, 4, 5, 6]
   将列表反转,删除最后一个元素后打印此列表
     ....
     print(L)  # [6, 5, 4, 3, 2]

L = [3, 5]
L[0:0] = [1, 2]  # 把1, 2添加3之前
L[3:3] = [4]
L[len(L):] = [6]
# L[5:] = [6]
L[::] = L[::-1]  # 先将列表反序生成一个新列表,再替代原列表
# 此时ID不变
del L[-1]
print(L)  # [6, 5, 4, 3, 2]

四、python 3中常用于序列的函数

   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

练习:
   写程序,让用户循环输入一些整数,当输入-1时结束输入,将这些整数存于列表L中
     1) 打印您共输入了多少个有效的数
     2) 打印您输入的数的最大数是?
     3) 打印您输入的最小数是多少?
     4) 打印您输入的这些数的平均值是多少?

# 先创建一个列表:
L = []
while True:
    n = float(input("请输入一些数: "))
    if n == -1:
        break
    L += [n]  # L[len(L):] = [n]

print('您共输入了%d个数' % len(L))
print('您刚才输入的最大数是:', max(L))
print('您刚才输入的最小数是:', min(L))
print('平均数是: ', sum(L) / len(L))

五、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()	复制此列表（只复制一层，不会复制深层对象)
L.append(x)	向列表中追加单个元素
L.extend(lst)	向列表追加另一个列表
L.clear()	清空列表,等同于 L[:] = []
L.sort(reverse=False)	将列表中的元素进行排序，默认顺序按值的小到大的顺序排列
L.reverse()	列表的反转，用来改变原列表的先后顺序
L.pop([index])	删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系

练习：
　　写一个程序，让用户输入很多个正整数，当输入小于零的数时结束输入
　　1) 打印这些数中最大的一个数
　　2) 打印这些数中第二大的一个数
  　  3) 删除最小的一个数
  　  4) 按原来顺序打印出剩余的这些数

#方法1
L = []
while True:
    x = int(input("请输入正整数:"))
    if x < 0:
        break
    L.append(x)  # 等同于 L += [x]

print('您刚才输入的是:', L)
print("最大的一个数是:", max(L))
L2 = L.copy()  # 复制一份，然后再排序，
L2.sort(reverse=True)  # 自大至小降序排序
print("最大的一个数是:", L2[0])
print("第二大的一个数是:", L2[1])

L.remove(min(L))  # 删除最小的一个数
print('最后的结果是', L)

#方法2
L = []
while True:
    x = int(input("请输入正整数:"))
    if x < 0:
        break
    L.append(x)  # 等同于 L += [x]
print('您刚才输入的是:', L)
# 先复制列表到L2中，把最大一个一个数找到，
# 打印这个最大的数，然后再删除最大的数，
# 那剩下数是最大的数就是第二大的数

zuida = max(L)
print("最大的一个数是:", max(L))
L2 = L.copy()  # 复制一份
while True:
    if zuida in L2:  # 如果最大数存在则删除，否则跳出循环
        L2.remove(zuida)    
    else:
        break
print("第二大的数是:", max(L2))
# 删除所有最小的数:
zuixiao = min(L)
while zuixiao in L:
    L.remove(zuixiao)
print('最后的结果是', L)

六、深拷贝和浅拷贝

1、浅拷贝 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]]

2、深拷贝 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]]　　<<< L1不变
   print(L2)  # [1, 2, [3.14, 3.2]]

七、列表和字符串比较：

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

字符串的文本解析方法:

   S.split(sep=None) 将字符串，使用 sep作用分隔符分割S字符串，返回分割后的字符串列表，当不给定参数时，用空白字符作为分隔符分割

   S.join(iterable) 用可迭代对象中的字符串，返回一个中间用S进行分隔的字符串

示例:
   s = 'Beijing is capital'
   L = s.split(' ')  # L = ['hello', 'world', 'tarena']
  
   s2 = "hello#world#tarena"
   L = s2.split('#')  # L = ['hello', 'world', 'tarena']
  
   L = ['aaa', 'bbbb', 'ccccc']
   '$'.join(L) # 生成 'aaa$bbbb$ccccc'
练习:
   有字符串'hello'请生成'h e l l o'字符串和'h-e-l-l-o'
   L = list("hello")
   ' '.join(L)  # ' '.join("hello")  # 'h e l l o'
   '-'.join("hello")

L = list("hello")
a=" ".join(L)
b="-".join(L)
print(a,b)

八、列表推导式 list comprehension

1、列表推导式的使用

   列表推导式是用可迭代对象创建列表的表达式

  作用:
     用简易方法生成列表
  语法:
     [表达式 for 变量 in 可迭代对象]
        3         2         1
     或
     [表达式 for 变量 in 可迭代对象 if 真值表达式]
        4         2         1              3
  示例:
     # 生成一个数值为1~9的平方的列表
     # [1, 4, 9, 16, .... 81]
     # 不用推导式:
     L = []
     for i in range(1, 10):
         L.append(i**2)
     # 推导式实现
     L = [i ** 2 for i in range(1, 10)]

用列表推导式生成 1~100以内奇数的列表
   结果是:[1, 3, 5, 7, ...., 99]
   答案:
     [i for i in range(1, 100, 2)]

    或
     [i for i in range(1, 100) if i % 2 == 1]

练习:
   输入一个开始的整数用begin绑定
   输入一个结束的整数用end绑定
   将从begin开始,到end结束(不包含end)的所有偶数存于列表中
   并打印此列表
   (可以使用列表推导式完成,也可以用循环语句来完成)

#方法1:列表推导式
begin = int(input("请输入开始的整数: "))
end = int(input("请输入结束的整数: "))
L = [x for x in range(begin, end) if x % 2 == 0]
print(L)

#方法2:循环语句
L2 = []
for x in range(begin, end):
    if x % 2 == 0:
        L2.append(x)

print("L2=", L2)

2、列表推导式的嵌套

 语法:
     [表达式
       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]

练习:
   1. 用字符串"ABC"和字符串"123" 生成如下列表
    ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3', ]

a=[x+y for x in "ABC" for y in "123"] 
print(a)

  2. 已知有一个字符串:
     s = '100,200,300,500,800'
     将其转化为列表,列表的内部是整数
     L = [100, 200, 300, 500, 800]

s = '100,200,300,500,800'
L=[int(x) for x in s.split(",")]
print(L)

 

3. 已知有列表:
     L = [3, 5]
   用索引和切片操作,将原列表改变为:
     L = [1, 2, 3, 4, 5, 6]
   将列表反转,删除最后一个元素后打印此列表
     ....
     print(L)  # [6, 5, 4, 3, 2]

L = [3, 5]
L[0:0] = [1, 2]  # 把1, 2添加3之前
L[3:3] = [4]
L[len(L):] = [6]
# L[5:] = [6]
L[::] = L[::-1]  # 先将列表反序生成一个新列表,再替代原列表
# 此时ID不变
del L[-1]
print(L)  # [6, 5, 4, 3, 2]

练习:
   1. 有一些数存在列表中, 如:
      L = [1, 3, 2, 1, 6, 4, 2, ...., 98, 82]
     1) 将列表L中出现的数字存于另一个列表L2中
       要求:
          重复出现多次的数字只在L2列表中保留一份(去重)
     2) 将列表中出现两次的数字存于L3列表中(在L3列表中保留一份)

L = [1, 3, 2, 1, 6, 4, 2, 98, 82]
# 1) 将列表L中出现的数字存于另一个列表L2中
# 要求:
#  重复出现多次的数字只在L2列表中保留一份(去重)
L2 = []  # 准备放入不重复的数据
for x in L:
    if x not in L2:  # L2里没有
        L2.append(x)
print("L2= ", L2)

# 2) 将列表中出现两次的数字存于L3列表中(在L3列表中保留一份)
L3 = []
for x in L:
    if x not in L3 and L.count(x) == 2:
        L3.append(x)

print('L3=', L3)

  2. 计算出100以内的素数,将这些素数存于列表中,最后打印出列表中的这些素数

L = []
for x in range(100):
    # 判断如果x是素数就打印,不是素数就跳过判断
    if x < 2:  # 跳过小于2的数
        continue
    for i in range(2, x):
        if x % i == 0:
            break
    else:
        L.append(x)

print(L)

  3. 生成前40个斐波那契数(Fibonacci)
     1 1 2 3 5 8 13 21 ......
     要求将这数整数存于列表L中,最后打印出这些数
     (斐波那契的前两个是1, 1, 之后的数是前两个数的和)

L = []  # 准备放入数据

#方法1
a = 0
b = 1  # 当前已经求出来的数
while len(L) < 40:  # 不够40个
    L.append(b)  # 把已经得到的数加入列表中
    # 再算出下一个数,依旧存于b中,为下次循环做准备
    c = a + b  # 下一次的数
    a = b  # 将当前的数交给a
    b = c  # 再把已经算好的数交给b

#方法2
a = 0
b = 1  # 当前已经求出来的数
while len(L) < 40:  # 不够40个
    L.append(b)  # 把已经得到的数加入列表中
    # 再算出下一个数,依旧存于b中,为下次循环做准备
    a, b = b, a + b

# 方法3
L = [1, 1]
while len(L) < 40:
    L.append(L[-1] + L[-2])

print(L)