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子句部分的语句
     不会执行
   示例见:
    

# for.py

# 此示例示意for语句的语法和用法

s = "ABCDE"

for ch in s:
    print("ch绑定---->", ch)
else:
    print("for语句迭代访问结束")

print("程序退出")

    

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

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

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


s = input("请输入一段字符串: ")
blanks_count = 0
# 遍历输入的字符串,当有字符为' '时,将blanks_count做加1操作
for ch in s:
    if ch == ' ':
        blanks_count += 1
print("空格的个数是:", blanks_count)

# 2) 计算出字符串中全部英文字母(A-Z和a-z)的个数,
#    并打印打印这个个数
alpha_count = 0
for ch in s:
    # if 65 <= ord(ch) < 65+26 or 97 <= ord(ch) < 97+26:
    if 'A' <= ch <= 'Z' or 'a' <= ch <= 'z':
        alpha_count += 1
print("英文字母的个数是:", alpha_count)

#   完成上题后思考:
#     能否用while语句实现上述功能

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


s = input("请输入一段字符串: ")

blanks_count = 0
alpha_count = 0
i = 0  # i 代表字符串的索引
while i < len(s):  # 索引不允许大于等于len(s)
    ch = s[i]  # ch绑定每次遍历的字符
    # 统计个数
    if ch == ' ':
        blanks_count += 1
    if 'A' <= ch <= 'Z' or 'a' <= ch <= 'z':
        alpha_count += 1
    i += 1  # 索引增加1,

print("空格的个数是:", blanks_count)
print("英文字母的个数是:", alpha_count)

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


s = input('请输入字符串: ')
# s2 = s[::-1]  # 反转字符串
# for c in s2:
#     print(c)

# for c in s[::-1]:
#     print(c)

# 用while循环实现
i = len(s)-1  # 代表索引
while i >= 0:
    print(s[i])
    i -= 1  # 索引向前走一步

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)      # 空
   示例见:
    

# myrange.py

for x in range(4):
    print(x)  # 打印0 1 2 3
print('-----------')

for x in range(3, 6):
    print(x)   # 3 4 5
print('-----------')

for x in range(1, 10, 3):
    print(x)  # 1 4 7
print('-----------')

for x in range(5, 0, -1):
    print(x)  # 5 4 3 2 1

练习:
   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. 用for语句打印 1~20的整数,打印在一行内
#     1 2 3 4 5 6 .... 19 20

for i in range(1, 21):
    print(i, end=' ')
else:
    print()

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

for x in range(101):
    if x * (x + 1) % 11 == 8:
        print(x)

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

# 用for循环实现
# s = 0  # 用来累加和
# for x in range(1, 100, 2):
#     s += x
# print("和是:", s)

# 用while循环实现
s = 0
x = 1
while x < 100:
    s += x  # 累加
    x += 2  # 向后移2

print("用while计算后的的是", s)

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

# for_range.py

i = 6
for x in range(1, i):
    print('x =', x, 'i =', i)
    i -= 1
print("====================")
i = 6
r = range(1, i)
for x in r:
    print('x =', x, 'i =', i)
    i -= 1

#请问执行结果是什么？

  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 . 输入一个整数，代表正方形的宽和高，打印相应的正方形
#       用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

w = int(input('请输入: '))
for _ in range(w):  #  外重循环控制行数
    # 内重循环打印一行
    for x in range(1, w + 1):
        print(x, end=' ')
    print()  # 换行

#   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

w = int(input("请输入: "))
for line in range(1, w + 1):
    # 打印一行从 line 号开始的 w个数字
    for x in range(line, line + w):
        print('%2d' % x, end=' ')
    print()
    # print(line)

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

# continue.py

for x in range(5):
    if x == 2:
        continue
    print(x)

# continue2.py


# 打印10以内的偶数 0 2 4 6 8
for x in range(10):
    # 如果x是奇数，则跳过本次循环
    if x % 2 == 1:
        continue
    print(x)

# continue3.py

x = 0
while x < 5:
    if x == 2:
        x += 1
        continue
    print(x)
    x += 1

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

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

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

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

print("最终的和是:", s)

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

print("最终的和是:", s)

循环小结:
   四条语句:
     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的末尾

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

L = []  # 创建一个列表，　准备存放数字
while True:
    # 每次输入一个数，如果此数小于0，则退出循环，否则把
    # 这个数放在列表中
    x = int(input("请输入: "))
    if x < 0:
        break
    L += [x]

print('列表的内容是:', L)

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

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

h = int(input("请输入树干的高度: "))

# 打印树冠 部分
w = 2 * h - 1  # w 代表树冠最大下层叶子的星号个数
for line in range(1, h + 1): # line 代表行号
    stars = 2 * line - 1  # 算出星号个数
    s = '*' * stars
    print(s.center(w))

# 打印树干部分
for _ in range(h):
    print(' ' * (h-1) + '*')

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

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

x = int(input("请输入一个整数: "))
if x < 2:
    print(x,'不是素数')
else:
    flag = True  # 标志
    # 判断x不是素数
    for i in range(2, x):
        if x % i == 0:  # 整除
            print(x, '不是素数')
            flag = False
            break
    # 能不能在此知道x是否为素数?
    if flag:
        print(x, '是素数')

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

x = int(input("请输入一个整数: "))
if x < 2:
    print(x,'不是素数')
else:
    # 判断x不是素数
    for i in range(2, x):
        if x % i == 0:  # 整除
            print(x, '不是素数')
            break
    else:
        print(x, '是素数')

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

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

a = input("请输入第1行: ")
b = input("请输入第2行: ")
c = input("请输入第3行: ")
# 方法1
# L = [a, b, c]
# 方法2
L = []
L += [a]
L += [b]
L += [c]
print(L)