PYTHON1.day05

day04回顾
   字符串的格式化表达式
     "姓名: %s, 年龄:%d" % ('小张', 20)
     生成具有一定格式的字符串
        格字化字符串 % 参数
        格字化字符串 % (参数1, 参数2,....)
      %s %d %x %X %f %% ...
      '%7.2f' % 3.1415926
      ....

循环语句
     while 语句
     for 语句
   语法:
     while 真值表达式:
         语句块1
     else:
         语句块2

while语句可以嵌套
     i = 0
     while i < 5:
         ...
         while j < 10:
             ....
         i += 1

break语句
     终止当前循环
     break终止的循环语句 else子句部分不会执行
   死循环
     while True:
         pass
   死循环通过用于不确定次数的循环

day05 笔记
for 语句
   作用:
     用来遍历可迭代对象的数据元素
     (可迭代对象是指能依次获取数据元素的对象)

可迭代对象包括:
     字符串 str
     ------ 以下是后面会学到的----------
     列表 list
     元组 tuple
     字典 dict
     ....

for 语句语法:
     for 变量列表 in 可迭代对象:
         语句块1
     else:
         语句块2
   说明:
     else子句部分可以省略(同while语句类似)
     当在循环语句内部用break终止循环时,else子句部分的语句
     不会执行
   示例见:

  1 # for.py
  2 
  3 # 此示例示意for语句的语法和用法
  4 
  5 s = "ABCDE"
  6 
  7 for ch in s:
  8     print("ch绑定---->", ch)
  9 else:
 10     print("for语句迭代访问结束")
 11 
 12 print("程序退出")
 13 
 14

练习:
   任意输入一段字符串
     1) 计算出这个字符串中空格的个数,并打印这个个数
        (要求用for 语句,不允许使用S.count方法)
     2) 计算出字符串中全部英文字母(A-Z和a-z)的个数,
        并打印打印这个个数
   完成上题后思考:
     能否用while语句实现上述功能

练习:
   输入一个字符串, 从尾向头输出这个字符串的字符
   如:
     请输入: hello
   打印:
     o
     l
     l
     e
     h

  1 # 练习:
  2 #   任意输入一段字符串
  3 #     1) 计算出这个字符串中空格的个数,并打印这个个数
  4 #        (要求用for 语句,不允许使用S.count方法)
  5 #     2) 计算出字符串中全部英文字母(A-Z和a-z)的个数,
  6 #        并打印打印这个个数
  7 #   完成上题后思考:
  8 #     能否用while语句实现上述功能
  9 
 10 
 11 s = input("请输入一段字符串: ")
 12 blanks_count = 0
 13 # 遍历输入的字符串,当有字符为' '时,将blanks_count做加1操作
 14 for ch in s:
 15     if ch == ' ':
 16         blanks_count += 1
 17 print("空格的个数是:", blanks_count)
 18 
 19 # 2) 计算出字符串中全部英文字母(A-Z和a-z)的个数,
 20 #    并打印打印这个个数
 21 alpha_count = 0
 22 for ch in s:
 23     # if 65 <= ord(ch) < 65+26 or 97 <= ord(ch) < 97+26:
 24     if 'A' <= ch <= 'Z' or 'a' <= ch <= 'z':
 25         alpha_count += 1
 26 print("英文字母的个数是:", alpha_count)
 27 
 28 #   完成上题后思考:
 29 #     能否用while语句实现上述功能

  1 # 练习:
  2 #   任意输入一段字符串
  3 #     1) 计算出这个字符串中空格的个数,并打印这个个数
  4 #        (要求用for 语句,不允许使用S.count方法)
  5 #     2) 计算出字符串中全部英文字母(A-Z和a-z)的个数,
  6 #        并打印打印这个个数
  7 #   完成上题后思考:
  8 #     能否用while语句实现上述功能
  9 
 10 
 11 s = input("请输入一段字符串: ")
 12 
 13 blanks_count = 0
 14 alpha_count = 0
 15 i = 0  # i 代表字符串的索引
 16 while i < len(s):  # 索引不允许大于等于len(s)
 17     ch = s[i]  # ch绑定每次遍历的字符
 18     # 统计个数
 19     if ch == ' ':
 20         blanks_count += 1
 21     if 'A' <= ch <= 'Z' or 'a' <= ch <= 'z':
 22         alpha_count += 1
 23     i += 1  # 索引增加1,
 24 
 25 print("空格的个数是:", blanks_count)
 26 print("英文字母的个数是:", alpha_count)
 27

  1 # 练习:
  2 #   输入一个字符串, 从尾向头输出这个字符串的字符
  3 #   如:
  4 #     请输入: hello
  5 #   打印:
  6 #     o
  7 #     l
  8 #     l
  9 #     e
 10 #     h
 11 
 12 
 13 s = input('请输入字符串: ')
 14 # s2 = s[::-1]  # 反转字符串
 15 # for c in s2:
 16 #     print(c)
 17 
 18 # for c in s[::-1]:
 19 #     print(c)
 20 
 21 # 用while循环实现
 22 i = len(s)-1  # 代表索引
 23 while i >= 0:
 24     print(s[i])
 25     i -= 1  # 索引向前走一步
 26 
 27

range函数
   range(stop) 用来生成0~stop区间内的整数,直到stop为止(不
               包含stop)
   range(start, stop[, step]) 用来生成start~stop区间内
               的整数,直到stop为止(不包含stop),每个整数间
               隔step(且step可以是负数 )
   作用:
     用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)
   说明:
     此函数调用后返回的对象是可迭代对象,可以用于for语句中
   示例:
     range(4)         # 生成 0 1 2 3
     range(3, 6)      # 生成 3 4 5
     range(1, 10, 2) # 生成 1 3 5 7 9
     range(5, 0, -2) # 生成 5 3 1
     range(4, 0)      # 空
   示例见:

  1 # myrange.py
  2 
  3 for x in range(4):
  4     print(x)  # 打印0 1 2 3
  5 print('-----------')
  6 
  7 for x in range(3, 6):
  8     print(x)   # 3 4 5
  9 print('-----------')
 10 
 11 for x in range(1, 10, 3):
 12     print(x)  # 1 4 7
 13 print('-----------')
 14 
 15 for x in range(5, 0, -1):
 16     print(x)  # 5 4 3 2 1
 17

练习:
1. 用for语句打印 1~20的整数,打印在一行内
1 2 3 4 5 6 .... 19 20

2. 求 100以内有哪儿些整数与自身+1的乘积再对11求余的结果
      等于8?
         即: x * (x + 1) % 11 == 8
     打印出这些数

3. 计算 1 + 3 + 5 + 7 + .... + 99 的和
分别用for循环语句和while循环语句实现

  1 # 练习:
  2 #   1. 用for语句打印 1~20的整数,打印在一行内
  3 #     1 2 3 4 5 6 .... 19 20
  4 
  5 for i in range(1, 21):
  6     print(i, end=' ')
  7 else:
  8     print()
  9 
 10 
 11 
 12

1~20

  1 #   2. 求 100以内有哪儿些整数与 自身+1的乘积再对11求余的结果
  2 #      等于8?
  3 #         即: x * (x + 1) % 11 == 8
  4 #     打印出这些数
  5 
  6 for x in range(101):
  7     if x * (x + 1) % 11 == 8:
  8         print(x)

  1 
  2 #   3. 计算 1 + 3 + 5 + 7 + .... + 99 的和
  3 #      分别用for循环语句和while循环语句实现
  4 
  5 # 用for循环实现
  6 # s = 0  # 用来累加和
  7 # for x in range(1, 100, 2):
  8 #     s += x
  9 # print("和是:", s)
 10 
 11 # 用while循环实现
 12 s = 0
 13 x = 1
 14 while x < 100:
 15     s += x  # 累加
 16     x += 2  # 向后移2
 17 
 18 print("用while计算后的的是", s)

1~99的和

for 语句的注意事项
1. for range的调用顺序见:
for_range.py

  1 # for_range.py
  2 
  3 i = 6
  4 for x in range(1, i):
  5     print('x =', x, 'i =', i)
  6     i -= 1
  7 print("====================")
  8 i = 6
  9 r = range(1, i)
 10 for x in r:
 11     print('x =', x, 'i =', i)
 12     i -= 1
 13 
 14 #请问执行结果是什么？
 15 
 16

for_range.py

2. 变量可能不被创建的问题:
     如:
         for x in range(4, 0):
             print(x)
         else:
             print('循环结束后的x=', x) # 出错
         print(x) # 出错

for 语句嵌套:
   示例:
     for x in "ABC":
         for y in '123':
             print(x + y) # 请问此语句打印几次?

练习:
   1 . 输入一个整数，代表正方形的宽和高，打印相应的正方形
       用for语句实现
     如:
       请输入: 5
     打印:
       1 2 3 4 5
       1 2 3 4 5
       1 2 3 4 5
       1 2 3 4 5
       1 2 3 4 5

2. 输入一个整数，代表正方形的宽和高，打印相应的正方形
     如：
       请输入: 5
     打印:
       1 2 3 4 5
       2 3 4 5 6
       3 4 5 6 7
       4 5 6 7 8
       5 6 7 8 9

  1 #   1 . 输入一个整数，代表正方形的宽和高，打印相应的正方形
  2 #       用for语句实现
  3 #     如:
  4 #       请输入: 5
  5 #     打印:
  6 #       1 2 3 4 5
  7 #       1 2 3 4 5
  8 #       1 2 3 4 5
  9 #       1 2 3 4 5
 10 #       1 2 3 4 5
 11 
 12 w = int(input('请输入: '))
 13 for _ in range(w):  #  外重循环控制行数
 14     # 内重循环打印一行
 15     for x in range(1, w + 1):
 16         print(x, end=' ')
 17     print()  # 换行
 18 
 19 
 20

  1 #   2. 输入一个整数，代表正方形的宽和高，打印相应的正方形
  2 #     如 ：
  3 #       请输入: 5
  4 #     打印:
  5 #       1 2 3 4 5
  6 #       2 3 4 5 6
  7 #       3 4 5 6 7
  8 #       4 5 6 7 8
  9 #       5 6 7 8 9
 10 
 11 w = int(input("请输入: "))
 12 for line in range(1, w + 1):
 13     # 打印一行从 line 号开始的 w个数字
 14     for x in range(line, line + w):
 15         print('%2d' % x, end=' ')
 16     print()
 17     # print(line)

continue 语句
   问题:
     如何让程序不再向下执行，重新开始一次新的循环

   作用:
     用于循环语句(while,for语句), 不再执行本次循环内continue
     之后的语句，重新开始一次新的循环
   语法:
     continue
   说明:
     1. 在while语句中执行continue语句，将会直接跳转到while语
        句的真值表达式处，重新判断循环条件。
     2. 在for语句中执行continue语句，将会从可迭代对象中取下一
       一个元素绑定变量后再次进行循环。
   示例见:
     continue.py
     continue2.py
     continue3.py

  1 # continue.py
  2 
  3 for x in range(5):
  4     if x == 2:
  5         continue
  6     print(x)
  7 
  8

  1 # continue2.py
  2 
  3 
  4 # 打印10以内的偶数 0 2 4 6 8
  5 for x in range(10):
  6     # 如果x是奇数，则跳过本次循环
  7     if x % 2 == 1:
  8         continue
  9     print(x)
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17

  1 # continue3.py
  2 
  3 x = 0
  4 while x < 5:
  5     if x == 2:
  6         x += 1
  7         continue
  8     print(x)
  9     x += 1
 10 
 11 
 12

练习:
1. 打印10以内的偶数(要求试用while语句+ continue)
采用跳过奇数的方式实现

2. 求 1 ~ 100 之间所有不能被2, 3, 5 和 7 中任意一个数
整除的数的和(用continue实现)

  1 # 练习:
  2 #   打印10以内的偶数(要求试用while语句+  continue)
  3 #     采用跳过奇数的方式实现
  4 x = 0
  5 while x < 10:
  6     if x % 2 == 1:
  7         x += 1
  8         continue
  9     print(x)
 10     x += 1
 11

10以内偶数

  1 #   2. 求 1 ~ 100 之间所有不能被2, 3, 5 和 7 中任意一个数
  2 #      整除的数的和(用continue实现)
  3 s = 0  # 用于累加和
  4 for x in range(1, 101):
  5     if x % 2 == 0:
  6         continue
  7     if x % 3 == 0:
  8         continue
  9     if x % 5 == 0:
 10         continue
 11     if x % 7 == 0:
 12         continue
 13     # print(x)
 14     s += x
 15 
 16 print("最终的和是:", s)

2.方法1

  1 #   2. 求 1 ~ 100 之间所有不能被2, 3, 5 和 7 中任意一个数
  2 #      整除的数的和(用continue实现)
  3 s = 0  # 用于累加和
  4 for x in range(1, 101):
  5     if x % 2 == 0 or x % 3 == 0 or 
  6        x % 5 == 0 or x % 7 == 0:
  7         continue
  8     # print(x)
  9     s += x
 10 
 11 print("最终的和是:", s)

2.方法2

循环小结:
   四条语句:
     while 语句
     for 语句
         字符串str
         range函数调用后返回的对象
     break 语句
     continue 语句

列表 list
   问题:
     容器
       如何将计算运算的数据临时存在一个地方，同时又方便添加,
       删除，修改等操作?

什么是列表:
   列表是一种容器
   列表是可以被改变的序列
   列表是由一系列特定元素组成的，元素与元素之间可能没有任何的关
      联关系，但他们之间有先后顺序关系

python3中序列类型简介:
    字符串 str
    列表 list
    元组 tuple (以下后面会学)
    字节串 bytes
    字节数组 bytearray

创始空列表的字面值
L = [] # L绑定空列表
注: 表达式 [] 会创建一个空的列表

创建非空列表的字面值:
   L = [1, 2, 3, 4]
   L = ['北京', '上海', '深圳']
   L = [1, 'Two', 3.14, '四']
   L = [1, 2, [3.1, 3.2], 4]

列表的构造(创建) 函数 list
list() 创建一个空的列表,等同于 []
list(iterable) 用可迭代对象创建一个列表

示例:
   L = list() # L 绑定空列表等同于 L = []
   L = list('hello') # L=['h', 'e', 'l', 'l', 'o']
   L = list(range(1, 10, 2)) # L = [1, 3, 5, 7, 9]

列表的运算:
   算术运算:
     +   +=    *    *=
   + 用于拼接列表
     x = [1, 2, 3]
     y = [4, 5, 6]
     z = x + y # z = [1, 2, 3, 4, 5, 6]

+= 将原列表与右侧的可迭代对象的数据追加,得到新的列表
     语法:
       x += 可迭代对象
     如:
       x = [1, 2, 3]
       x += [4, 5, 6]
       x += "ABC"
       x += range(1, 10, 3)
     注:
       += 运算符是用原可迭代对象的数据进行追加,原列表的ID不变
     如:
       s = "ABC"
       print(id(s)) # ???
       s += '123'
       print(id(s)) # 和上面的???不相同

    L = [1, 2, 3]
       print(id(L)) # ???
       L += '123'
       print(id(L)) # ???

* 生成重复的列表
x = [1, 2] * 3 # x = [1, 2, 1, 2, 1, 2]

*= 生成重复的列表，用原变量绑定更新后的列表
     x = [1, 2, 3]
     x *= 2 # [1, 2, 3, 1, 2, 3]


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

列表是可迭代对象
   L = [1, 3, 5, 7]
   for x in L:
       print(x) # 打印 1 3 5 7

列表的 in / not in 运算符
   判断一个值是否存在于列表中．如果存在返回True,否则返回False
     (同字符串的in和not in 用法相同)
   not in 返回值与in 相反

示例:
     x = [1, 'Two', 3, '四']
     3 in x   # True
     '3' in x   # False
     10 in x    # False
     10 not in x # True

练习:
   写一个程序，让用户输入很多个正整数，当输入负数时结束输入
   将用户输入的数存于列表L中,打印这个列表
   如:
     请输入: 1
     请输入: 2
     请输入: 3
     请输入: 4
     请输入: -1
   打印如下:
     [1, 2, 3, 4]
   提示:
     L = []
     x = int(input('请输入: '))
     L += [x] # 把x放在列表中，追加到L的末尾

  1 # 练习:
  2 #   写一个程序，让用户输入很多个正整数，当输入负数时结束输入
  3 #   　将用户输入的数存于列表L中,打印这个列表
  4 #   如:
  5 #     请输入: 1
  6 #     请输入: 2
  7 #     请输入: 3
  8 #     请输入: 4
  9 #     请输入: -1
 10 #   打印如下:
 11 #     [1, 2, 3, 4]
 12 #   提示:
 13 #     L = []
 14 #     x = int(input('请输入: '))
 15 #     L += [x]  # 把x放在列表中，追加到L的末尾
 16 
 17 L = []  # 创建一个列表，　准备存放数字
 18 while True:
 19     # 每次输入一个数，如果此数小于0，则退出循环，否则把
 20     # 这个数放在列表中
 21     x = int(input("请输入: "))
 22     if x < 0:
 23         break
 24     L += [x]
 25 
 26 print('列表的内容是:', L)
 27

练习:
   1. 输入一个整数，代表树干的高度,打印如下一棵＂圣诞树"
     如:
       请输入: 2
     打印
      *
     ***
      *
      *
     如:
       请输入: 3
     打印:
       *
      ***
     *****
       *
       *
       *

  1 # 练习:
  2 #   1. 输入一个整数，代表树干的高度,打印如下一棵＂圣诞树"
  3 #     如:
  4 #       请输入: 2
  5 #     打印
  6 #      *
  7 #     ***
  8 #      *
  9 #      *
 10 #     如:
 11 #       请输入: 3
 12 #     打印:
 13 #       *
 14 #      ***
 15 #     *****
 16 #       *
 17 #       *
 18 #       *
 19 
 20 h = int(input("请输入树干的高度: "))
 21 
 22 # 打印树冠 部分
 23 w = 2 * h - 1  # w 代表树冠最大下层叶子的星号个数
 24 for line in range(1, h + 1): # line 代表行号
 25     stars = 2 * line - 1  # 算出星号个数
 26     s = '*' * stars
 27     print(s.center(w))
 28 
 29 # 打印树干部分
 30 for _ in range(h):
 31     print(' ' * (h-1) + '*')
 32 
 33 
 34 
 35 
 36 
 37

tree

2. 写一个，任意输入一个整数，判断这个数是否是素数(prime)
     打印结果
     素数(也叫质数),只能被1和自身整除的正整数
       如: 2 3 5 7 11 13 17 19 .....
     提示:
       用排除法,当判断x是否是素数时，只要让x分别除
         以2, 3, 4, 5,... x-1,只要有一个能被整除，则x不是素数
       否则x为素数

  1 #   2. 写一个，任意输入一个整数，判断这个数是否是素数(prime)
  2 #     打印结果
  3 #     　素数(也叫质数),只能被1和自身整除的正整数
  4 #       如:  2 3 5 7 11 13 17 19 .....
  5 #     提示:
  6 #       用排除法,当判断x是否是素数时，只要让x分别除
  7 #         以2, 3, 4, 5,... x-1,只要有一个能被整除，则x不是素数
  8 #       否则x为素数
  9 
 10 x = int(input("请输入一个整数: "))
 11 if x < 2:
 12     print(x,'不是素数')
 13 else:
 14     flag = True  # 标志
 15     # 判断x不是素数
 16     for i in range(2, x):
 17         if x % i == 0:  # 整除
 18             print(x, '不是素数')
 19             flag = False
 20             break
 21     # 能不能在此知道x是否为素数?
 22     if flag:
 23         print(x, '是素数')

素数

  1 #   2. 写一个，任意输入一个整数，判断这个数是否是素数(prime)
  2 #     打印结果
  3 #     　素数(也叫质数),只能被1和自身整除的正整数
  4 #       如:  2 3 5 7 11 13 17 19 .....
  5 #     提示:
  6 #       用排除法,当判断x是否是素数时，只要让x分别除
  7 #         以2, 3, 4, 5,... x-1,只要有一个能被整除，则x不是素数
  8 #       否则x为素数
  9 
 10 x = int(input("请输入一个整数: "))
 11 if x < 2:
 12     print(x,'不是素数')
 13 else:
 14     # 判断x不是素数
 15     for i in range(2, x):
 16         if x % i == 0:  # 整除
 17             print(x, '不是素数')
 18             break
 19     else:
 20         print(x, '是素数')

素数2

3. 输入三行，将这三行文字保存于一个列表L中,并打印
     如:
       请输入: ABC
       请输入: 123
       请输入: 你好
     生成如下列表并打印:
       print(L) # ['ABC', '123', '你好']

  1 #   3. 输入三行，将这三行文字保存于一个列表L中,并打印
  2 #     如:
  3 #       请输入: ABC
  4 #       请输入: 123
  5 #       请输入: 你好
  6 #     生成如下列表并打印:
  7 #       print(L)  # ['ABC', '123', '你好']
  8 
  9 a = input("请输入第1行: ")
 10 b = input("请输入第2行: ")
 11 c = input("请输入第3行: ")
 12 # 方法1
 13 # L = [a, b, c]
 14 # 方法2
 15 L = []
 16 L += [a]
 17 L += [b]
 18 L += [c]
 19 print(L)
 20