• 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)
    2.
      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
      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)
    2

    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
      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 
    2
      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 
    3

    练习:
       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

    练习:
       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 
    3

  • 相关阅读:
    logback.xml
    logback:RollingFileAppender
    logback :<include>
    logback:参数化日志打印
    logback:fileAppender输出到文件
    logback:root和logger
    logback console控制台输出
    logback encoder详细设置
    logback关闭日志
    IDEA+testng,输出没有test-output目录
  • 原文地址:https://www.cnblogs.com/shengjia/p/10305839.html
Copyright © 2020-2023  润新知