Python学习笔记day07,list方法函数，深浅拷贝，字符串文本解析，列表推导式

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

列表的索引操作

语法:

列表[整数表达式]

用法:

1. 与字符串索引的用法相同(分为正向索引和反向索引)

• 示例:

x = [1,3,5,7]
print(x[1])     # 3　　
print(x[-1])    # 7

2. 列表的索引赋值:

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

3. 列表的 切片

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

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

4. 列表的切片赋值

• 作用:
  可以改变原列表的数据排列，可以插入和修改数据
  可以用切片改变列表的对应元素的值
• 语法:
  列表[切片]　= 可迭代对象

• 说明:
  切片赋值的赋值运算符(=) 的右侧必须是一个可迭代对象

• 示例:

  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]

切片的注意事项:

对于步长不等于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]

• 练习:
  已知有列表:L = [3, 5]\
  用索引和切片操作,将原列表改变为:
  L = [1, 2, 3, 4, 5, 6]\
  将列表反转,删除最后一个元素后打印此列表….\
  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

python3中常用的列表方法(method)

方法(函数)	说明
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入列表
list.pop(obj=list[-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort([func])	对原列表进行排序
list.extend(list2)	用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表)

练习：

• 写一个程序，让用户输入很多个正整数，当输入的数小于零时候结束
  
  1. 打印出最大的一个数
  2. 打印出第二大的数
  3. 删除最小的数
  4. 按照原来的顺序打印出剩余的数

  L=[ ]
  L2=[ ]
  A=int(input("请输入数字："))
  while A >= 0:
      L.append(A)
      if A not in L2:
          L2.append(A)
      A=int(input("请输入数字："))
  L2.sort(reverse=True)
  print("原来输入的",L)
  print("L2的",L2)
  print("最大的数是%d   第二大的数是%d   最小的数是%d"%(L2[0],L2[1],L2[len(L2)-1]))
  L.remove(L2[len(L2)-1])
  print("最后的：",L)

浅拷贝和深拷贝：

浅拷贝(Shallow Copy):

• 浅拷贝是指在复制过程中，只赋值了一层变量，不会赋值深层变量绑定的对象的复制过程
  

L1 = [3.1, 3.2]
L2 = [1, 2, L1]
L3 = copy(L2)        #浅拷贝
print(L2)            # [1, 2, [3.1, 3.2]]
print(L3)            # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.111
print(L1)            # [3.111, 3.2]    <<--变了
print(L2)            # [1, 2, [3.111, 3.2]]     <<--变了
print(L3)            # [1, 2, [3.111, 3.2]]

深拷贝(Deep Copy):

• 深拷贝过程是 复制对象以及对象关联的对象
  
• 需要引入 copy 模块

L1 = [3.1, 3.2]
L2 = [1, 2, L1]
L3 = copy.deepcopy(L2)        #浅拷贝
print(L2)            # [1, 2, [3.1, 3.2]]
print(L3)            # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.111
print(L1)            # [3.1, 3.2]     <<--变了
print(L2)            # [1, 2, [3.1, 3.2]]    <<--不变
print(L3)            # [1, 2, [3.111, 3.2]]

字符串文本解析

字符串和列表的相同和不同之处：

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

字符串的文本解析方法

• str.split(sep=none)
  
  • 将字符串使用 sep作用分隔符分割 str 字符串，分割后的字符串以列表形式返回
  • 当不给sep参数时，默认以空白符号分割
• str.join(inerable)
  
  • 用于可迭代对象，返回一个用str进行连接的字符串

列表推导式(list comperehension)

列表推导式是用可迭代对象创建列表的表达式
* 作用
用简易的方法生成列表
* 语法
[表达式 if 变量 in 可迭代对象]或者[表达式 if 变量 in 可迭代对象 if 真值表达式]
* 示例

# 生成一个数值为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. 用列表推导式生成1~100之间的奇数列表

  
  # 1
  
  L = [i for i in range(1,100,2)]
  
  # 2 使用if表达式
  
  L = [i for i in range(1,100) if i%2!=0]

  1. *输入一个开始的整数用begin绑定
     输入一个结束的整数用end绑定
     将从begin开始到end结束的所有偶数存到列表，并打印

     begin=int(input("输入一个开始的整数："))
     end=int(input("输入一个结束的整数："))
     L=[i for i in range(begin,end) if i%2==0]

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

     L=[a+b for a in "ABC" for b in "123"]

  3. 一直有一个字符串:
     s = “100,200,300,500,800”
     将其转换成列表，列表内是整数

     [int(i) for i in s.split(",")]