day2_运算符与分支结构

python_day2

运算符与分支结构

运算符

• python中支持的运算符：数学运算符、比较运算符、逻辑运算符、赋值运算符、位运算（了解用法）。

1. 数学运算符：+(加法运算)、-(减法运算)、(乘法运算)、/(除法运算)、%(取模/取余)、//(整除)、*****(幂运算)

   1. +、-、、/和数学中的+、-*、✖、÷的功能一模一样。

   print(5+2)  # 7
   print(5-2)  # 3
   print(5*2)  # 10
   print(5/2)  # 2.5
   

   2. % - 取余、取模（数学中的求余数）

   #  x % y  -  求 x 除以 y 的余数。
   print(10 % 3)  # 1
   

   ​ 应用1：判断一个数是否能被另一个数整除。

   #  x % y 的值为0说明 x 能被 y 整除。
   num = 6
   print(num % 3)  # 0
   

   ​ 应用2：取整数的低位数。

   #  x % 10 - 获取x的个位数； x % 100 - 获取x的后两位数；...以此类推
   print(168 % 10)  # 8
   print(1738 % 100)  # 38
   

   3. // - 整除（商数取整数）

   #  x // y  -  x 除以 y 的商向下取整。
   print(5 // 2)  # 2
   print(-5 // 2)  # -3
   

   ​ 应用：去掉低位数，获取高位数。

   #  x // 10 - 去掉x的最后一位数； x // 100 - 去掉x的最后两位数；...
   print(23563 // 100)  # 235
   

   4. ****** - 幂运算（求次方）

   #  x ** y  -  求 x 的 y 次方
   print(2 ** 3)  # 8
   print(3 ** 3)  # 27
   #  如果次方数是 1/N，表示开 N 次方，开方结果均为浮点型。（float）
   print(8 ** (1/3))  # 2.0
   print(27 ** (1/3))  # 3.0
   

2. 比较运算符：>(大于)、<(小于)、>=(大于等于)、<=(小于等于)、==(等于)、!=(不等于)

   ​ 比较运算符中比较的数据必须为同类型（整型和浮点型可相互比较），并且所有比较运算符的运算结果均为布尔值。

   ​ 注意：python中的比较运算符支持连写的方式表示取值范围。

   print(10 > 20)  # False
   print(10 < 20)  # True
   print(10 >= 10)  # True
   print(10 == 10)  # True
   print(10 != 10)  # False
   

3. 逻辑运算符：and（逻辑与）、or（逻辑或）、not（逻辑非）

   • and - 逻辑与
     应用场景：相当于生活中的"并且"，当需要多个条件同时满足的时候使用。
     运算规则：当条件结果均为True时，结果就为True。只要有一个是False结果就是False。
     True and True - True
     True and False - False
     False and True - False
     False and False - False
   • or - 逻辑或
     应用场景：相当于生活着的"或者"，当多个条件中只要有一个条件满足使用。
     运算规则：当条件结果均为False时，结果就为False。只要有一个是True结果就是True。
     True or True - True
     True or False - True
     False or True - True
     False or False - False
   • not - 逻辑非
     应用场景：对某一个条件进行否定。
     运算规则：True变False，False变True
     not True - False
     not False - True
     什么时候用not：如果一个条件正向写很麻烦，但是反向写很简单，就反向写条件然后加not。
   • 短路操作
     and 的短路操作：条件1 and 条件2 - 如果条件1是False，那么条件2对应的代码不会执行。
     or 的短路操作：条件1 or 条件2 - 如果条件1是True，那么条件2对应的代码不会执行。
   • 运算对象不为布尔值
     实际开发时逻辑运算符的运算对象和运算结果一般都是布尔，如果表达式的值不是布尔，就转换成布尔再判断。
     ​ 注意：python中任何类型的数据都可以转换成布尔值，0值和空值为False，其余全为True。
     ​ 表达式1 and 表达式2 - 如果表达式1的结果是True，那么整个运算结果就是表达式2的值；
     ​ 如果表达式1的结果是False，那么整个运算结果就是表达式1的值；
     ​ 表达式1 or 表达式2 - 如果表达式1的结果是False，那么整个运算结果就是表达式2的值；
     ​ 如果表达式1的结果是True，那么整个运算结果就是表达式1的值；

4. 赋值运算符：=、+=、-=、=、/=、%=、//=、*=

   ​ 所有的赋值运算符都是用来给变量赋值的，所以赋值运算符的左边必须是变量，并且复合的赋值运算符左边的变量必须是已经赋值过的变量。

   1. 普通赋值运算符：=

   a = 10
   

   2. 复合的赋值运算符：先将变量的数据取出来，再进行相应的复合赋值符的运算，将运算结果重新赋值回变量。

   a += 3  # a = a + 3
   a -= 2  # a = a - 2
   a *= 4  # a = a * 4
   

5. 运算符的优先级

   • 数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符（最低）
   • 数学运算符中的优先级：****** > 、/、%、//* > +、-
   • 逻辑运算符中的优先级：and > or
   • 如果有括号，先算括号里的内容

6. 位运算：&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、>>（右移）、<<（左移）

   位运算的运算效率比一般的运算符都要高

   1. 应用1：判断整数的奇偶性 - 数字对1进行按位与运算，如果结果是1就是奇数，结果是0就是偶数

   print(4 & 1, 273 & 1, -832 & 1, 48 & 1)  # 0 1 0 0
   

   2. 应用2：数字 << N - 快速乘2的N次方

   ​ 数字 >> N - 快速整除2的N次方

   print(4 << 1, 5 << 1, 5 << 2)  # 8 10 20
   print(4 >> 1, 5 >> 1, -5 >> 1)  # 2 2 -3
   

分支结构

1. 流程控制

   1. 顺序结构 - 从上往下依次执行每一条语句。（默认）
   2. 分支结构 - 根据条件选择性的执行代码。（if语句）
   3. 循环结构 - 让代码重复执行。（for循环、while循环）

2. 分支结构

   1. if 单分支结构 - 满足条件执行某个操作，不满足就不执行。

      语法：

      if 条件语句：
          代码块
      

      说明：

      1. if - 关键字，固定写法。
      2. 条件语句 - 任何有结果的表达式：任何类型的数据、除赋值语句以外的运算表达式、函数调用表达式。
      3. 冒号 - 固定写法。（python中冒号后面一般都需要换行后产生缩进来表示代码块）
      4. 代码块 - 和if保持一个缩进（按TAB）的一条或多条语句；在满足条件的时候才会执行的代码,不满足不执行。

      执行过程：先判断条件语句是否为True（如果不是布尔值就转换成布尔再判断），如果是True就执行代码块，否则代码块不执行。

      注意：if语句中的代码块至少要有一条语句，在不确定的时候可以先用pass占位。

      age = 28
      if num >= 18:
        print('成年')
      # 成年
      

   2. if 双分支结构 - 满足条件执行某个操作，不满足就执行另一个操作。

      语法：

      if 条件语句：
          代码块1（满足条件要执行的代码）
      else:
          代码块2（不满足条件要执行的代码）
      

      执行过程：先判断条件语句是否为True，如果是True就执行代码块1，否则执行代码块2。

      num = 37
      if not num & 1:
          print('偶数')
      else:
          print('奇数')
      # 奇数
      

   3. if多分支结构 - 根据不同的条件执行不同的操作。

      语法：

      if 条件语句1：
          代码块1
      elif 条件语句2：
          代码块2
      elif 条件语句3：
          代码块3
      ...
      else:
          代码块N
      

      执行过程： 先判断条件语句1是为True，如果是直接执行代码块1，然后整个if结构直接结束；
      如果不为True，就判断条件语句2是否为True,如果是就执行代码块2，然后整个if结构结束；
      如果不为True，就判断条件语句3是否为True，如果是就执行代码块3，然后整个if结构结束；
      …
      以此类推，如果前面的条件语句都不满足就执行else后面的代码块。

      grade = 3.2
      if grade > 4:
          print('获得一等奖学金。')
      elif 3.5 <= grade:
          print('获得二等奖学金。')
      elif 3 <= grade:
          print('获得三等奖学金。')
      elif 2.5 <= grade:
          print('获得四等奖学金。')
      else:
          print('未获得奖学金。')
      # 获得三等奖学金