发表文章

[最新] Python学习day7

sinat42311311 3月前 5

列表的索引操作:
  语法:
    列表[整数表达式]
  用法:
    等同于字符串的索引
    索引分正向索引和反向索引,规则与字符串规则完全相同
  示例:
    L = list("ABCD")
    print(L[1])  # B


列表的索引赋值
  列表是可变的,可以通过索引赋值改变列表中的元素
示例 
  L = [1, 2, 3, 4]
  L[2] = 3.1
  print(L) # L=[1, 2, 3.1, 4]


列表的切片
  语法:
    列表[:]
    列表[::]
  说明:
    列表的切片取值返回一个列表,规则等同于字符串切片规则
  示例:
    x = list(range(10))
    y = x[1:9:2]  # 奇数
    y = x[::]     # 复制x列表 


列表的切片赋值
  语法:
    列表[切片slice] = 可迭代对象
  作用:
    可以改变原列表的排列,可以插入数据和修改数据
    可以用切片改变列表对应的元素的值
  说明:
    切片的赋值运算符(=)的右侧必须是一个"可迭代对象"


  示例:
    L = [2, 3, 4]
    L[1:2] = [3.1, 3.2]  # L = [2, 3.1, 3.2, 4]
    L[:1] = [1.1, 2.2]  # L=[1.1, 2.2, 3.1, 3.2, 4]
    L = [2, 3, 4]
    L[2:] = []
    L = [2, 3, 4]
    L[:0] = [0, 1]
    L = [2, 3, 4]
    L[3:] = [5, 6, 7]

    L = [2, 3, 4]
    L[1:2] = "ABC"  # L = [2, 'A', 'B', 'C', 4]
    L = [1, 2]
    L[2:] = range(3, 10)  # L = [1,2,3,4....9]

切片注意事项:
  对于步长不等1的切片赋值,赋值运算符的右侧的可迭代对象提供的数据元素的个数一定要等于切片切出的段数
  例如:
    L = [1, 2, 3, 4, 5, 6]
    L[::2] = 'ABC'  # 正确
    L[::2] = 'ABCDE' # 错误
del 语句:
  del 可以用来删除列表元素
  语法:
    del 列表[索引]
    del 列表[切片]
  示例:
    L = [1, 2, 3, 4, 5, 6]
    del L[1]
    del L[2]
    del L[-1]
    L = [1, 2, 3, 4, 5, 6]
    del L[::2]


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




python3中常用的序列函数
  len(x)  返回序列的长度
  max(x)  返回序列的最大值元素
  min(x)  返回序列中最小值元素
  ------以上是以前学过的------
  sum(x)  返回序列中所有元素的和(元素必须是数字)
  any(x)  真值测试, 如果列表中的其中一个元素 为真值,则返回True
  all(x)  真值测试, 如果列表中的所有元素都为真值, 则返回True,否则返回False


  示例:
    L = [1, 7, 0, 3, 2]
    print(len(L))  # 5
    print(max(L))  # 7
    print(min(L))  # 0
    print(sum(L))  # 13
    print(any(L))  # True
    print(all(L))  # False

python3中常用的列表方法(method)
详见:
   >>> help(list)




sorted 函数:
   用于生成一个排序后的列表
   格式:
     sorted(iterable, reverse=False)


reversed(seq)  返回原序列反序的可迭代对象
示例:
  L = [7, 9, 5, 1, 3]
  L2 = sorted(L)  # L2 = [1, 3, 5, 7, 9]
  L3 = sorted(L, reverse=True)  # L3 = [9, 7, 5, 3, 1]
  for x in reversed(L):
      print(x)  # 3 1 5 9 7

字符串的文本解析方法 split 和 join方法
  S.split(sep=None)  将字符串使用sep作为分隔符分割S字符串,返回分割后的字符串列表,当不给定参数时默认用空白字符作为分隔符分割


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


  示例:
    s = 'Beijing is capital'
    L = s.split(' ')  # L = ['Beijing', 'is', 'capital']


    L = ["C:", "Windows", "System32"]
    s = '\\'.join(L)  #s=r"C:\Windows\System32"


深拷贝 deep copy 和浅拷贝 shallow copy


浅拷贝 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]]
  L[0] = 3.14
  print(L1)  # [1, 2, [3.14, 3.2]]
  print(L2)  # [1, 2, [3.14, 3.2]]


  说明:
    浅拷贝是指在复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程


深拷贝
  对所有可变对象进行层层复制,实现对象的各自独立
  例:


  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]]
  L[0] = 3.14
  print(L1)  # [1, 2, [3.14, 3.2]]
  print(L2)  # [1, 2, [3.1, 3.2]] #此列表不受影响


列表推导式 list comprehesion
  列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式


  作用:
    用简易方法生成列表
  语法:
    [表达式 for 变量 in 可迭代对象]
    或
    [表达式 for 变量 in 可迭代对象 if 真值表达式]
  示例:
    # 生成一个列表,此列表内的数值是1~9的方平
    L = [x ** 2 for x in range(1, 10)]


    # 以前的方法:
    L = []
    for x in range(1, 10):
        L.append(x ** 2)


练习:
   用列表推导式生成 1 ~ 100 内奇数的列表
   答:
     1. [x * 2 + 1 for x in range(50)]
     2. [x for x in range(1, 100, 2)]
     # 用带有if的列表推导式
       [x for x in range(100) if x % 2 ==1]
列表推导式的嵌套:
  语法:
    [表达式
      for 变量1 in 可迭代对象1 if 真值表达式1
         for 变量2 in 可迭代对象2 if 真值表达式2
            ...]
  示例:
    用字符串"ABC" 和 "123" 生成如下列表:
      ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
    L = [x + y for x in "ABC" for y in "123"]
相关推荐
最新评论 (0)
返回
发表文章
sinat42311311
文章数
29
评论数
0
注册排名
1311234