Python基础保姆级讲解（3）

条件语句

1.if

if condition:

# 当条件为真时执行这里的代码,否则不执行这里

year=1993
if year%4==0:
    print("year能被4整除")

2.if-else

if condition:

# 当条件为真时执行这里的代码

else:

# 如果前面的条件都为假，执行这里的代码

year=1993
if year%4==0:
    print("year能被4整除")
else:
    print("year不能被4,400整除")

3.if-elif-else

if condition:

# 当条件为真时执行这里的代码

elif another_condition:

# 当上面条件为假，而这个条件为真时执行这里的代码

else:

# 如果前面的条件都为假，执行这里的代码

year=1992
if year%4==0:
    print("year能被4整除")
elif year%400==0:
    print("year能被400整除")
else:
    print("year不能被4,400整除")

4.整体

• 语法

  if 条件表达式1:
      语句块1
  elif 条件表达式2:
      语句块2
  elif 条件表达式3:
      语句块3
  ...
  elif 条件表达式n:
      语句块n
  else:
      语句块(其他)
      

  • 说明
    • elif 子句可以有0个，1个或多个,
    • else 子句可以有0个或1个且只能放在最后
    • 它通过对表达式逐个求值直至找到一个真值在子句体中选择唯一匹配的一个；然后执行该子句体（而且 if 语句的其他部分不会被执行或求值）。 如果所有表达式均为假值，则如果 else 子句体如果存在就会被执行。

• 课后练习1

  写一个程序，输入一个整数，用程序判断这个整数是正数，负数，还是零

  参考答案

  number = int(input('请输入整数: '))
  if number < 0:
      print(number, '是负数')
  elif number > 0:
      print(number, '是正数')
  else:
      print(number, '是零')

• 课后练习2

  写一个程序， 06_input_score.py, 输入一个学生的成绩，如果成绩在 60~100 之间提示"及格", 否则提示不及格
  

  参考答案

  score = int(input('请输入学生成绩: '))
  if 60 <= score <= 100:
      print('及格')
  else:
      print('不及格')

• 课后练习3

  写一个程序， 07_input_score.py, 输入一个学生的成绩，
  如果成绩在 [0,60)  提示"不及格"
  如果成绩在 [60,80)  提示"及格"
  如果成绩在 [80,90)  提示"良好"
  如果成绩在 [90,100]  提示"优秀"
  如果是其他值，则提示"您的输入有误"
  

  [ ] 表示包含 () 表示不包含

  参考答案

  score = int(input('请输入学生成绩: '))
  if 0 <= score < 60:
      print('不及格')
  elif 60 <= score < 80:
      print('及格')
  elif 80 <= score < 90:
      print('良好')
  elif 90 <= score <= 100:
      print('优秀')
  else:
      print('您的输入有误')

• if 语句也是语句，他可以嵌套到其他的复合语句中

  if xxxx:
       if yyyy > 0:
            print('.....')
       else:
            print("fjdsfdf")
  else:
      print("hello")
  

5. 条件表达式

Python 中的三元表达式（或称条件表达式）的语法规则如下：

<表达式1> if <条件> else <表达式2>

语法解释：

• <条件> ：要判断的条件表达式，通常是一个布尔表达式（例如 a > b）。
• <表达式1> ：当条件为 True 时返回的值或执行的表达式。
• <表达式2> ：当条件为 False 时返回的值或执行的表达式。

示例：

x = 5
y = 10

# 使用三元表达式判断并赋值
result = "x is greater" if x > y else "y is greater"
print(result)  # 输出: "y is greater"


if x > y:
    result = "x is greater"
else:
    result = "y is greater"

循环语句

while 语句

• 作用

  根据一定的条件，重复的执行某个语句块

• 语法

  while 真值表达式:
      语句块1  (*此部分可能会重复执行)
  else:
      语句块2

• 说明

  • else 子句可以省略
  • else 子句 当且仅当 真值表达式为假Flase的时候 会执行 else 里的语句块2
  • 如果 此 while 是因为 调用 break 语句而终止循环。则 else 子句里的语句不会执行

• 示例1

  while 1 < 2:
      print("hello world")

  再终端界面下 ctrl + c 可以终止正在执行的程序(进程)

• 示例2

  # 打印 5 行 "hello world"
  i = 0
  while i < 5:
      print("hello world")
      i = i + 1  # 也可写成 i += 1
  else:
      print("while 语句已经结束!")

• 课后练习1

  写一个程序,输入一个整数，写程序打印如下 n 行文字
  如:
     请输入: 10
     这是第 1 行
     这是第 2 行
     这是第 3 行
     ...
     这是第 10 行
  

  参考答案

  total_lines = int(input('请输入：'))
  i = 1
  while i <= total_lines:
      print('这是第', i, '行')
      i = i + 1  # i += 1

• 课后练习2

  写一个程序 打印1~20 的整数, 打印在 1 行内 每个数字之间用一个空格分隔开
  1 2 3 4 5 ... 19 20
  提示: print(x, end=' ')
  

  参考答案

  x = 1
  while x <= 20:
      print(x, end=' ')
      x += 1  # 等同于 x = x + 1
  
  print()  # 打印一个换行 '\n'

语句嵌套

• while 语句也是语句, 和其他的语句一样，可以嵌套到其他的任何复合语句中。外层控制行，内层控制列。

• while 语句嵌套示意:

  while 真值表达式:
      ...
      while 真值表达式2:
          ...
      else:
          ...
      ......
  else:
      ...
  

  示例

  写一个程序 打印1~20 的整数, 打印在 1 行内 每个数字之间用一个空格分隔开
  1 2 3 4 5 ... 19 20
  
  打印 10 行
  1 2 3 4 5 ... 19 20
  1 2 3 4 5 ... 19 20
  1 2 3 4 5 ... 19 20
  1 2 3 4 5 ... 19 20
  1 2 3 4 5 ... 19 20
  ....
  1 2 3 4 5 ... 19 20

• 课后练习:

  写一个程序 打印1~20 的整数, 打印在 1 行内 每个数字之间用一个空格分隔开
  1 2 3 4 5 ... 19 20
  
  以上输出打印 10 行
  

  参考答案

  i = 0
  while i < 10:
      # print('1 2 3 4 5 6 7.... 20')
      x = 1
      while x <= 20:
          print(x, end=' ')
          x += 1  # 等同于 x = x + 1
  
      print()  # 打印一个换行 '\n'
  
      i += 1

• 课后练习1

  写程序，输入一个整数n , 代表结束的整数， 计算
          1 + 2 + 3 + 4 + ..... + n 的和
  请输入: 100
  5050
  # 提示： 
  he = 0  # 用一个变量来记录这个和
  

  参考答案

  n = int(input('请输入一个整数： '))
  
  he = 0
  
  i = 1
  while i <= n:
      # print(i)  # 1 2 3 4 5 .... n
      he += i
      i += 1
  
  print(he)

• 课后练习2

  打印 1~ 20 的整数, 每行打印 5 个， 打印 四行, 如:
  1 2 3 4 5
  6 7 8 9 10
  ...
  16 17 18 19 20  
  # 提示: print()  换行
  

  参考答案

  x = 1
  while x <= 20:
      print('%2d' % x, end=' ')
      if x % 5 == 0:
          print()  # 换行
      x += 1
  print()

• 课后练习3

  已知, 局域网的IP 都是: 192.168.0.xxx
  写程序，生成 从 192.168.0.1 ~ 192.168.0.254 区间的 254 个 IP 地址
  

  参考答案

  ip_fmt = '192.168.0.%d'
  x = 1
  while x <= 254:
      # print(x)  # 1 2 3 4 .... 254
      ip = ip_fmt % x
      print(ip)
      x += 1

• 课后练习4

  写一个程序，输入三行文字， 按最长的一行， 打印如下图形方框
  请输入: hello
  请输入: welcome to beijing 
  请输入: aaaaaaa
  打印:
  +--------------------+
  |       hello        |
  | welcome to beijing |
  |       aaaaaaa      |
  +--------------------+
  提示: str.center(width)
  

  参考答案

  # 写一个程序，输入三行文字， 按最长的一行， 打印如下图形方框
  # 请输入: hello
  # 请输入: welcome to beijing
  # 请输入: aaaaaaa
  # 打印:
  # +--------------------+
  # |       hello        |
  # | welcome to beijing |
  # |       aaaaaaa      |
  # +--------------------+
  # 提示: str.center(width)
  
  s1 = input("请输入：")   # ctrl + d 可以复制当前行
  s2 = input("请输入：")
  s3 = input("请输入：")
  
  len1 = len(s1)  # 求取字符串的长度
  len2 = len(s2)
  len3 = len(s3)
  # 从上面三个数中，找出最大的一个， 用 mymax 变量绑定
  # 方法2， 通用的算法
  mymax = len1
  
  if len2 > mymax:
      mymax = len2
  
  if len3 > mymax:
      mymax = len3
  
  # 方法1
  # if len1 > len2:
  #     # 让 len1 和 len3 再比较
  #     if len1 > len3:
  #         mymax = len1
  #     else:
  #         mymax = len3
  # else:
  #     # 让 len2 和 len3 再比较
  #     if len2 > len3:
  #         mymax = len2
  #     else:
  #         mymax = len3
  print('最大长度是：', mymax)
  
  # 计算第一行
  line1 = '+' + '-' * (mymax +2) + '+'
  print(line1)
  # 文字的第一行
  # 方法1 ， 用 str.center 居中文字的第一行
  # center_s1 = '| ' + s1.center(mymax) + ' |'
  
  # 方法2 ， 用 自己的方法 居中文字的第一行
  left_blanks = (mymax - len1) // 2   # 计算左侧的空格数
  right_blanks = mymax - len1 - left_blanks   # 计算右侧的空格数
  center_s1 = '| ' + ' ' * left_blanks + s1 + ' ' * right_blanks + ' |'
  print(center_s1)
  
  # 文字的第二行
  center_s2= '| ' + s2.center(mymax) + ' |'
  print(center_s2)
  # 文字的第三行
  center_s3 = '| ' + s3.center(mymax) + ' |'
  print(center_s3)
  
  # 打印最后一行
  print(line1)

break 语句

• 作用

  用于循环语句(while, for语句)中, 当break 执行是，她会终止包含他的当前循环。

• 语法

  break

• 说明

  • break 语句只能用在 while 语句或for语句的内部。
  • break 语句通常和 if 语句组合使用。
  • 当break 语句执行后，此循环语句break 之后的所有语句都不会执行（else 子句里的语句也不执行）
  • break 语句只能终止包含他的当前循环，当有循环嵌套时，只能跳出离他最近的一个循环

• 示例

  i = 1
  while i <= 5:
  	print('i=', i)
      if i == 2
          break
  	i += 1
  else:
      print('循环结束: i=', i)

死循环

death loop

• 死循环是指循环条件一直成立的循环
• 死循环通常使用 break 语句来终止循环
• 死循环的 else 子句中的语句永远不会执行

写法

while True:
    语句块

死循环通常用户循环次数无法确定的循环

• 课后练习1:

  写程序， 任意输入一些正整数, 当输入负数时结束输入，当输入完成后，打印您输入的这些正整数的和
  如:
     请输入: 1
     请输入: 2
     请输入: 3
     请输入: 4
     请输入: -1
     您刚才输入的正整数之和是: 10
  

  参考答案

  # 1. 定义一个变量 total 用来累加 用户输入的整数
  total = 0
  # 2. 用死循环， 循环输入正整数，当输入负数时结束输入。
  while True:
      s = input('请输入正整数: ')
      if s == '':  # 用户没有输入文字，结束输入
          break
      number = int(s)
      if number < 0:
          break
      total += number
  
  # 3. 打印输入的结果
  print(total)

for 语句

• 作用

  • 用来遍历可迭代对象的数据元素

  遍历是指经历且只经历一遍

  可迭代对象是指能够依次获取数据元素的对象

  可迭代对象

  1. 字符串
  2. ---- 以下后面才讲----
  3. 列表 list
  4. 字典 dict
  5. ...

• 语法

  for 变量列表 in 可迭代对象:
      语句块1
  else:
      语句块2

• 语法说明

  • else 子句可以省略
  • else 子句的语句块2 只有在 可迭代对象不再能提供数据的时候才会执行
  • 因为 语句块1 部分调用break 而终止循环式，else 子句部分不会执行。

• 示例

  s = 'ABCDE'
  for ch in s:
      print('ch=', ch)
  else:
      print("遍历结束")

• 课后练习1

  写一个程序，输入一个任意长度的字符串，用for 语句找出这个字符串中有几个英文的等号(=)
  注： 不允许使用 str.count 方法
  如:
     请输入: a = b = c = 100
     结果: 3
  

  参考答案

  string = input('请输入:')
  count = 0   #
  for ch in string:
      if ch == '=':
          count += 1
  
  print('= 的个数是：', count)

range 函数

• 作用

  用来生成一个能够得到一系列整数的可迭代对象（也叫整数序列生成器）

• 调用格式

  range(stop)                 # stop 停止整数
  range(start, stop)          # start 开始整数
  range(start, stop, step)    # step 步长

  range 函数调用会生成从 start 开始，到 stop 结束(不包含stop) 的一系列整数，整数的间隔 step

  start 默认值为0, step 默认值为1

• 示意

  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

• 示例

  >>> for x in range(4):
  ...     print(x)
  ... 
  0
  1
  2
  3
  >>> for x in range(3, 6):
  ...     print(x)
  ... 
  3
  4
  5
  >>> for x in range(1, 10, 2):
  ...      print(x)
  ... 
  1
  3
  5
  7
  9
  >>> for x in range(5, 0, -2):
  ...     print(x)
  ... 
  5
  3
  1

• 课后练习1

  用 for 语句 打印 1~20 的整数，打印在一行内
  1 2 3 4 .... 19 20

  参考答案

  for x in range(1, 21):
      print(x, end=' ')
  print()  # 换行

• 课后练习2

  写程序，计算 1 + 3 + 5 + 7 + ..... + 97 + 99 的和
  分别用 for 循环和 while 实现。
  

  参考答案

  # 用 while 语句实现
  total = 0
  x = 1
  while x < 100:
      # print(x, end=' ')
      total += x
      x += 2
  print('1 + 3 + 5 + 7 + .... + 99=', total)
  
  # 用 for 语句实现
  total = 0
  for x in range(1, 100, 2):
      # print(x, end=' ')
      total += x
  print('1 + 3 + 5 + 7 + .... + 99=', total)

continue 语句

• 作用

  用于循环语句(while 语句和for语句)中， 不再执行本次循环内 continue 之后的语句，开始一次新的循环

• 语法

  continue

• 说明

  • 在for 语句中, 执行continue 语句，for语句将会从可迭代对象向中获取下一个元素绑定变量后再次进行循环
  • 在while 中,执行continue 语句, 将会直接跳转到while 语句的真值表达式处，重新判断循环条件。

• 示例1

  for x in range(5):
      if x % 2 == 0:
          continue
      print(x)    # 1 3 

• 示例2

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

• 课后练习3

  假设一个用户信息如下:
   用户名是:root
   密码是: 123456
  写一个身份验证的程序，让用户输入用户名和密码登录, 用户名和密码全部匹配，提示登录成功。
  否则继续，最多尝试3次。3次不匹配以后提示登录失败.
  

  参考答案

  USERNAME = 'root'
  PASSWORD = '123456'
  
  times = 1  # 比变量由于记录循环次数
  while True:
      user = input('请输入用户名: ')
      passwd = input('请输入密码: ')
      if user == USERNAME and passwd == PASSWORD:
          print('登陆成功')
          break
      if times == 3:
          print('登陆失败')
          break
      times +=1

pass 语句

pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句

for x in  range(10):
    if x == 7:
        pass
    else:
        print(x)

容器

python 中默认有4种容器

1. 列表list
2. 字典 dict
3. 集合 set
4. 元组 tuple

容器都是可迭代对象, 可以用for 语句来遍历容器

for x in [1, 2, 3]:
    print(x)
    
for y in (1, 2, 3):
    print(y)