day05回顾
   循环语句
     for 语句
       for 变量列表 in 可迭代对象:
           语句块1
       else:
           语句块2
     可迭代对象:
       字符串str, range()返回的对象, 列表list
     range(停止)
     range(开始, 停止)
     range(开始, 停止, 步长)
     for语句嵌套
    
     continue语句
    
   列表 list
   创建列表:
        字面值
          L = [1, 2, 3, 4]
          []
        构造函数
          list()
          list(range(10))
          list("ABC")
          L2 = list(L) # 复制列表  L2 = L
   列表的运算:
     +  +=  *  *=
     <  <=  >  >=  ==  !=
     in / not in 运算符
       判断一个元素是否存在于列表

day06 笔记
列表的索引操作
　语法:
     列表[整数表达式]
   用法:
     等同于字符串的索引
     索引分为正向索引和反向索引，规则与字符串索引规则完全相同
   示例:
     L = [1, 2, 3, 4]
     print(L[1])  # 2
     print(L[-1])  # 4

列表是可变的序列，列表支持索引赋值，列表可以通过索引赋值改变
列表中的元素
   语法:
     列表[整数表达式] = 表达式
   示例:
     L = [1, 2, 3, 4]
     L[2] = 3.14  # 改变了第三个元素的值

列表的切片操作
   取值:
     列表[起始值:终止值]
     列表[起始值:终止值:步长]
     列表的切片取值返回一个列表，规则等同于字符串切片规则
   示例:
     L = list(range(10))
     L2 = L[::2]  # L2 = [0, 2, 4, 6, 8]

列表的切片赋值
     作用:
       可以改变源列表的排列，可以插入，修改和删除数据
     语法:
       列表[切片] = 可迭代对象
     说明:
       切片赋值的赋值运算符(=)的右侧必须是一个可迭代对象
     示例:
       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[1:4] = []  # 切出2.2, 3.3, 4.4, 没加入新数据 L = [1.1, 5.5]
       L[1:] = range(5, 9)  # L = [1.1, 5, 6, 7, 8]
       L = [2, 5]
       L[1:1] = [3, 4]  # L = [2, 3, 4, 5]
       L[0:0] = range(2) # L = [0, 1, 2, 3, 4, 5]
       L[6:] = [6, 7] # L = [0, 1, 2, 3, 4, 5, 6, 7]

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

del 语句用于删除列表的元素
   语法:
     del 列表[索引]  # 删除索引
     del 列表[切片]  # 删除切片
　示例:
     L = [1, 2, 3, 4, 5, 6, 7]
     del L[-1]  # L = [1, 2, 3, 4, 5, 6]
     del L[::2]  # L = [2, 4, 6]

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

  1 # 练习:
  2 #   已知有列表:
  3 #     L = [3, 5]
  4 #   1) 用索引和切片操作，将原列表改变为:
  5 #     L = [1, 2, 3, 4, 5, 6]
  6 #   2) 将列表反转，删除最后一个元素后，打印此列表:
  7 #     ...
  8 #     print(L)  # [6, 5, 4, 3, 2]
  9
 10 L = [3, 5]
 11
 12 print("id(L)", id(L))  # ??????
 13 L[1:1] = [4]  # L = [3, 4, 5]
 14 L[len(L):] = [6]
 15 L[0:0] = [1, 2]
 16 print('L=', L)
 17
 18 # 将列表反转，删除最后一个元素后，打印此列表:
 19 # L = L[::-1]  # <<<<------ L绑定新的列表ID会变化
 20 L[::] = L[::-1]  # ID不变
 21 del L[-1]
 22 print("L=", L)
 23 print("id(L):", id(L))
 24
 25
 26 

list

Python3 中常用于序列的函数:
   len(x)   返回序列的长度
   max(x)   返回序列的最大值元素
   min(x)   返回序列的最小值元素
   sum(x)   返回序列中所有元素的和(元素必须是数值类型)
   any(x)   真值测试,如果列表中其中一个值为真值则返回True
   all(x)   真值测试,如果列表中所有值为真值才返回True,否则
            返回False

示例:
     L = [8, 3, 6, 2, 7]
     print(len(L))  # 5
     print(max(L))  # 8
     print(min(L))  # 2
     print(sum(L))  # 26
     print(any(x))  # True
     print(all(x))  # True

序列函数2
   reversed(seq)  返回原序列反向顺序的可迭代对象
   sorted(iterable, reverse=False)   返回已排序的列表

示例:
     L = [1, 2, 3, 4]
     for x in L:
         print(x)  # 1 2 3 4
     for x in reversed(L):
         print(x)  # 4 3 2 1
     L2 = [5, 8, 3, 7, 1]
     L3 = sorted(L2)  # L3 = [1, 3, 5, 7, 8]
     L4 = sorted(L2, reverse=True)  # 降序排序 L4=[8,7,5,3,1]

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

2. 写一个程序,让用户输入两个或以上的正整数,当输入小于零的数
      时结束输入(不允许输入重复的数)
      1) 打印这些数的和
      2) 打印这些数的最大数
      3) 打印这些数的最二大的数
      4) 删除最小的一个数,并打印原来的列表

  1 #   2. 写一个程序,让用户输入两个或以上的正整数,当输入小于零的数
  2 #      时结束输入(不允许输入重复的数)
  3 #      1) 打印这些数的和
  4 #      2) 打印这些数的最大数
  5 #      3) 打印这些数的最二大的数
  6 #      4) 删除最小的一个数,并打印原来的列表
  7
  8 numbers = []  # 创建一个容器,用变量numbers绑定
  9 while True:
 10     x = int(input("请输入正整数: "))
 11     if x < 0:
 12         if len(numbers) < 2:
 13             print('您输入的数字太少')
 14             continue
 15         break
 16     if x not in numbers:
 17         numbers += [x]
 18
 19 print("这些数的和是:", sum(numbers))
 20 L = sorted(numbers)
 21 print("最大数是:", L[-1])
 22 print("第二大数是:", L[-2])
 23 min_number = L[0]
 24 for i in range(len(numbers)):
 25     if numbers[i] == min_number:
 26         del numbers[i]
 27         break
 28
 29 print("删除最小数后的列表是: ", numbers)
 30 

1,2

python3 中常用的列表方法
   文档参见:
     python_base_docs_html/list.py

练习:
   输入多行文字,存入列表中
   每次输入后回车算作一行,任意输入多行文字.
   当直接输入回车(即空行时算作输入结束)
     要求:
       1) 按原输入的内容在屏幕上输出内容
       2) 打印出您共输入了多少行文字
       3) 打印出您共输入了多少个字符
     如:
       请输入: ABC
       请输入: abc
       请输入: 123
       请输入: <回车>
     您输入的内容是:
       ABC
       abc
       123
     您输入了3行文字
     您输入了9个字符

  1 # 练习:
  2 #   输入多行文字,存入列表中
  3 #   每次输入后回车算作一行,任意输入多行文字.
  4 #   当直接输入回车(即空行时算作输入结束)
  5 #     要求:
  6 #       1) 按原输入的内容在屏幕上输出内容
  7 #       2) 打印出您共输入了多少行文字
  8 #       3) 打印出您共输入了多少个字符
  9 #     如:
 10 #       请输入: ABC
 11 #       请输入: abc
 12 #       请输入: 123
 13 #       请输入: <回车>
 14 #     您输入的内容是:
 15 #       ABC
 16 #       abc
 17 #       123
 18 #     您输入了3行文字
 19 #     您输入了9个字符
 20
 21
 22 L = []
 23
 24 while True:
 25     s = input("请输入: ")
 26     if not s:  #  当输用户直接输入回车时,得到空字符串
 27         break
 28     L.append(s)  # 将字符串s追加到L列表末尾
 29 print("L=", L)
 30 print("您输入的内容是:")
 31 for text in L:
 32     print(text)
 33
 34 print("您输入了", len(L), '行文字')
 35
 36 count = 0
 37 for text in L:
 38     count += len(text)  # 把每一行字符串长度累加到count中
 39 print("您输入了", count, '个字符')
 40 

深拷贝 和 浅拷贝
浅拷贝 shallow copy
   浅拷贝是指在复制过程中,只复制一层变量,不会复制深层变量绑定的
   对象的复制过程
   如:
     L1 = [1, 2, [3.1, 3.2]]
     L2 = L1.copy()
     L2[2][0] = 3.14
     print(L1)  # [1, 2, [3.14, 3.2]]
     print(L2)  # [1, 2, [3.14, 3.2]]

深拷贝 deep copy
   深拷贝会在复制过程中,逐层复制深层对象,实现两个对象的完全独立
   如:
     import copy  # 导入考拷贝模块
     L1 = [1, 2, [3.1, 3.2]]
     L2 = copy.deepcopy(L1)
     L2[2][0] = 3.14
     print(L1)  # [1, 2, [3.1, 3.2]]
     print(L2)  # [1, 2, [3.14, 3.2]]

小结:
   L1 = [1, 2, [3.1, 3.2]]
   L2 = L1  # 不拷贝
   L3 = L1.copy()  # 浅拷贝
   import copy
   L4 = copy.deepcopy(L1)  # 深拷贝

列表与字符串比较:
   列表和字符串都是序列,元素之间有先后关系
   字符串中每个元素只能存储字符,而列表可以存储任意类型的元素
   字符串是不可变的序列,而列表是可变的序列
   列表和字符串都是可迭代对象

字符串的文本解析方法
   方法名     说明
  S.split(sep=None)  将字符串,使用sep作用分隔符分割S字符串
            返回分割后的字符串列表,当不给定参数时,用空白字符
            作为分隔符
  S.splitlines()  将字符串接换行符'\n' 分为分隔符进行分割
            返回分割后的列表
  S.join(iterable)  用可迭代对象中的字符串,返回一个是中间
            用S进行分隔的字符串
   示例:
     s = 'Beijing is capital'
     L = s.split()  # L = ['Beijing', 'is', 'capital']
     s2 = '-'.join(L)  # s2 = 'Beijing-is-capital'

练习:
   有字符串'hello' 生成字符串'h e l l o'  和 'h-e-l-l-o'
    答案:
      s = 'hello'
      s2 = ' '.join(s)
      s3 = '-'.join(s)

创建列表的方法有几种:
   字面值:
     [1, 2, 3]
   构造函数:
     list(range(1, 4))
   列表推导式方式

列表推导式 list comprehension
   列表推导式是用可迭代对象创建列表的表达式
   作用:
     用简易方法生成列表
   语法:
     [表达式 for 变量 in 可迭代对象]
     或
     [表达式 for 变量 in 可迭代对象 if 真值表达式]
   示例:
     生成一个数值为1~9的整数的平方的列表,如:
       L = [1, 4, 9, 16, 25, 36, 49, 64, 81]
     用循环语句:
       L = []
       for x in range(1, 10):
           L.append(x ** 2)
       L = [x ** 2 for x in range(1, 10)]

练习 :
   用列表推导式生成 1~100 内所有奇数组成的列表
   结果是:[1, 3, 5, 7, ....., 99]

  1 # 练习 :
  2 #   用列表推导式生成 1~100 内所有奇数组成的列表
  3 #   结果是:[1, 3, 5, 7, ....., 99]
  4
  5 # L = [x for x in range(1, 100, 2)]
  6 L = [x for x in range(1, 100) if x % 2 == 1]
  7 print(L)
  8
  9 L = []
 10 for x in range(1, 100):
 11     if x % 2 == 1:
 12         L.append(x)
 13 print("L=", L)

1~100

示例:
     生成一个数值为1~9的奇数的平方的列表,如:
       L = [1, 9, 25, 49, 81]
     L = [x**2 for x in range(1, 10) if x % 2 == 1]

列表推导式的嵌套:
   语法:
     [表达式 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']

2. 生成一个列表,此列表为x的平方加1不能被5整数的数的列表
    条件: (x ** 2 + 1) % 5 != 0
    x的取值范围是: 0 <= x < 100
    L = [x for x in range(100) if (x ** 2 + 1) % 5 != 0]

  1 # 练习 :
  2 #   用列表推导式生成 1~100 内所有奇数组成的列表
  3 #   结果是:[1, 3, 5, 7, ....., 99]
  4
  5 # L = [x for x in range(1, 100, 2)]
  6 L = [x for x in range(1, 100) if x % 2 == 1]
  7 print(L)
  8
  9 L = []
 10 for x in range(1, 100):
 11     if x % 2 == 1:
 12         L.append(x)
 13 print("L=", L)

ABC123

练习:
   1. 已知有一个字符串:
       s= '100,200,300,500,800'
     将其转化为列表,列表内都为整数,即:
       L = [100,200,300,500,800]

2. 有一些数存于列表中,如:
     L = [1, 3, 2, 1, 6, 4, 2, ....., 98, 82]
     1) 将列表中出现数字存入到另一个列表L2中
        要求:
          重复出现多次的数只在L2列表中保留一份(去重)
     2) 将列表中出现两次的数字存于L3列表中,在L3列表中只保留一份
   3. 生成前40个斐波那契数(Fibonacci)
       1  1  2  3  5  8  13  21
     要求:  将这些数保存在列表中,最后打印这些数
       注: 斐波那契数的前2个数为1 和 1, 从第二个数起为前两个
       数相加之和

  1 #   3. 生成前40个斐波那契数(Fibonacci)
  2 #       1  1  2  3  5  8  13  21
  3 #     要求:  将这些数保存在列表中,最后打印这些数
  4 #       注: 斐波那契数的前2个数为1 和 1, 从第二个数起为前两个
  5 #       数相加之和
  6
  7 # 方法1:
  8 # L = []
  9 # a = 0  # a表示第一个数的前一个数
 10 # b = 1  # b表示第一个数
 11 # while len(L) < 40:
 12 #     # 每次把b加入到列表中
 13 #     L.append(b)
 14 #     # 再算出下一个fibonacci数，存于b中
 15 #     c = a + b  # 算出下一个数
 16 #     a = b  # 把当前作为前一个数
 17 #     b = c  # 把新算出来的c交给b
 18
 19 # 方法2
 20 # L = []
 21 # a = 0  # a表示第一个数的前一个数
 22 # b = 1  # b表示第一个数
 23 # while len(L) < 40:
 24 #     # 每次把b加入到列表中
 25 #     L.append(b)
 26 #     # 再算出下一个fibonacci数，存于b中
 27 #     a, b = b, a + b  # 序列赋值
 28 #     # c = a + b  # 算出下一个数
 29 #     # a = b  # 把当前作为前一个数
 30 #     # b = c  # 把新算出来的c交给b
 31
 32 # 方法3
 33 L = [1, 1]
 34 while len(L) < 40:
 35     # 每次生成一个数，加到列表里
 36     L.append(L[-1] + L[-2])
 37
 38
 39 print("L=", L)
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53 

3

  1 #   1. 已知有一个字符串:
  2 #       s= '100,200,300,500,800'
  3 #     将其转化为列表,列表内都为整数,即:
  4 #       L = [100,200,300,500,800]
  5
  6
  7 s= '100,200,300,500,800'
  8 L2 = s.split(',')  # L2=['100','200','300','500','800']
  9 L = [int(x) for x in L2]
 10
 11 print("L=", L)  # print("L=", str(L))
 12 

1

  1 #   2. 有一些数存于列表中,如:
  2 #     L = [1, 3, 2, 1, 6, 4, 2, ....., 98, 82]
  3 #     1) 将列表中出现数字存入到另一个列表L2中
  4 #        要求:
  5 #          重复出现多次的数只在L2列表中保留一份(去重)
  6 #     2) 将列表中出现两次的数字存于L3列表中,在L3列表中只保留一份
  7
  8
  9 L = [1, 3, 2, 1, 6, 4, 2, 98, 82]
 10 L2 = []
 11 for x in L:
 12     if x not in L2:  # 说明L2里不存在，这是第一次出现
 13         L2.append(x)
 14 print('L2 =', L2)
 15
 16 # 2) 将列表中出现两次的数字存于L3列表中,在L3列表中只保留一份
 17 L3 = []
 18 for x in L:
 19     if L.count(x) == 2 and x not in L3:
 20         L3.append(x)
 21 print("L3=", L3)
 22
 23
 24
 25 

2