2020_9_23_运算符和分支结构

运算符和分支结构

运算符

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 = int(input(‘请输入一个整数:’))
num = 23
print(num % 3)

应用2：取整数的低位数
x % 10 - 获取x的个位数； x % 100 - 获取x后两位数; …

获取任意整数的个位数
print(123 % 10) # 3
print(92831 % 10) # 1

3）// - 整除(商取整)
x // y - x除以y的商向小取整
向小取整：1.9 -> 1 -1.9 -> -2 3.4 -> 3
print(5 // 2) # 2
print(-5 //2) # -3

应用：去掉低位数
678 // 10 -> 67 678 // 100 -> 6
num = 23562
print(num // 100) # 235

练习：获取任意大于100的数的百位数
234 -> 2 1345 -> 3 78623 -> 6
“”"
234 // 100 -> 2 % 10 -> 2
1345 // 100 -> 13 % 10 -> 3
78623 // 100 -> 786 % 10 -> 6

234 % 1000 -> 234 // 100 -> 2
1345 % 1000 -> 345 // 100 -> 3
78623 % 1000 -> 623 // 100 -> 6
“”"
num = 23232
num = int(input(‘请输入一个大于100的整数:’))
方法一
print(num // 100 % 10)

方法二
print(num % 1000 // 100)

4）** - 幂运算
x ** y -> 求 x 的 y 次方
print(2 ** 3) # 8
print(3 ** 3) # 27

如果次方数是 1/N 表示开 N 次方
print(4 ** 0.5) # 2.0
print(8 ** (1/3)) # 2.0

2.比较运算符: >、<、>=、<=、==、!=
所有的比较运算符的运算结果都是布尔值
print(10 > 20) # False
print(10 < 20) # True
print(10 >= 10) # True
print(10 == 10) # True
print(10 != 10) # False

注意：Python中的比较运算符支持连写的方式表示取值范围
age = 32
print(18 <= age <= 28)

3.逻辑运算符：and(逻辑与)、or(逻辑或)、not(逻辑非)

1. and - 逻辑与
   “”"
   应用场景：相当于生活中的 ‘并且’， 当需要多个条件同时满足的时候使用
   运算规则：都是True结果就是True，只要有一个是False结果就是False
   True and True -> True
   True and False -> False
   False and True -> False
   False and False -> False
   “”"
   获得奖学金的条件：绩点大于3.5并且操评分不低于90
   grade = 3.9
   score = 98
   print(‘是否能拿奖学金：’, grade > 3.5 and score >= 90)

练习：写出一个数是否能同时被3和7整除的条件
num = 67
方法一：
print(‘是否能同时被3和7整除：’, num % 3 == 0 and num % 7 == 0)

方法二：
print(‘是否能同时被3和7整除：’, num % 21 == 0)

2）or - 逻辑或运算
“”"
应用场景：相当于生活中的 ‘或者’，需要多个条件中只要有一个条件满足的时候使用
运算规则：都是False结果才是False，只要有一个是True结果就是True
True or True -> True
True or False -> True
False or True -> True
False or False -> False
“”"
练习：写出判断闰年的条件
闰年 - 能被4整除但是不能被100整除， 或者能被400整除
year = 2012
能被4整除: year % 4 == 0
不能被100整除: year % 100 != 0
能被400整除：year % 400 == 0
print(‘是否是闰年：’, (year % 4 == 0 and year % 100 != 0) or year % 400 == 0)

3）not - 逻辑非运算
“”"
应用场景：对某一个条件进行否定
运算规则：True 变 False, False 变 True
not True -> False
not False -> True
“”"
age = 18
print(not age > 18) # True

什么时候用not： 如果一个条件正向写很麻烦，但是反向写很简单，就反向写条件然后加not
练习：写出不能同时被3和7整除的条件
num = 12
方法一：
print((num % 3 != 0 and num % 7 != 0) or (num % 3 == 0 and num % 7 != 0) or (num % 3 != 0 and num % 7 == 0))
方法二：
print(not num % 21 == 0)

4）*短路操作
and 的短路操作： 条件1 and 条件2 - 如果条件1是False，那么条件2对应的代码不会执行
or 的短路操作： 条件1 or 条件2 - 如果条件1是True，那么条件2对应的代码不会执行
False and print(’=====’)
True or print(’+++++’)

5）*运算对象不是布尔值
“”"
实际开发的时候逻辑运算符的运算对象和运算结果一般都是布尔，但是面试的时候喜欢考运算对象不是布尔的情况

表达式1 and 表达式2 - 如果表达式1的结果是True,那么运算结果就是表达式2的值；
如果表达式1的结果是False,那么运算结果是表达式1的值。
表达式1 or 表达式2 - 如果表达式1的结果是False,那么运算结果就是表达式2的值；
如果表达式1的结果是True,那么运算结果是表达式1的值。

注意：如果表达式的值不是布尔，就转换成布尔再判断
怎么转：python任何类型的数据都可以转换成布尔值，所有为0为空的值都会转换成False，
其他的值都是True
“”"
a.布尔值转换
print(bool(0), bool(0.0)) # False False
print(bool(100), bool(-1000)) # True True
print(bool(’’), bool("")) # False False
print(bool(‘False’), bool(’ ')) # True True

print(5 and 3) # 3
print(0 and 3) # 0

print(5 or 3) # 5
print(0 or 3) # 3

print(‘abc’ and ‘123’)
print(False or ‘123’)

4.赋值运算符：=、+=、-=、*=、/=、%=、//=、**=
所有的赋值运算都是用来给变量赋值，赋值运算符的左边必须是变量;
复合的赋值运算左边的变量必须是已经赋值过的变量。

1. =
   a = 10

2. 复合的赋值运算符
   a += 3 # a = a+3
   print(a) # 13

a = 2 # a = a2 = 13*2
print(a) # 26

a %= 3 # a = a%3 = 26%3
print(a) # 2

5.运算符的优先级
数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符(最低)
数学运算符：** > *、/、%、// > +、-
逻辑运算符：and > or
如果有括号先算括号里面的内容
print(2 * 3 ** 2) # 18

6.*位运算：&(按位与)、|(按位或)、^(按位异或)、~(按位取反)、>>(右移)、<<(左移)
位运算的运算效率比一般的运算符都要高（高出几十倍到几百倍）

应用1：判断整数的奇偶性 - 数字对1进行按位与运算，如果结果是1就是奇数，结果是0就是偶数
print(28 & 1, 10 & 1, 102 & 1, -20 & 1) # 0 0 0 0
print(11 & 1, 9 & 1, -23 & 1, 1005 & 1) # 1 1 1 1

应用2：
数字 << N - 快速乘 2N
数字 >> N - 快速整除 2
数字 << 1 - 快速乘2：数字*2
数字 >> 1 - 快速整除2：数字//2
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 100:
pass

if ‘abc’:
pass

if 10+20:
pass

a = 100
if a % 2 + 3:
pass

注意：if后面不能是赋值语句
if a = 20:
pass

if后面的代码段满足条件的时候才会执行
print(’=======’)
if 20 > 10:
print(’+++++++’)
print(’-------’)

练习：输入一个整数，如果是偶数就打印"这个数能够被2整除"
num = int(input(‘请输入一个整数:’))
num = 25
if num & 1 == 0:
print(num, ‘这个数能够被2整除’)

if num & 1:
print(‘这个数是奇数’)

if语句代码段至少要有一条语句，在不确定的时候可以先用pass占位
if num % 5 == 0:
pass

2）if双分支结构 - 满足条件执行某个操作，条件不满足执行另外的一个操作
“”"
语法：
if 条件语句:
代码块1（满足条件要执行的代码）
else:
代码块2（不满足条件要执行的代码）

执行过程：
先判断条件语句是否为True，如果是就执行代码块1否则执行代码块2
“”"
练习1：如果输入的数字是偶数就打印’偶数’，否则打印’奇数’
num = 25
if num & 1 == 1:
print(‘奇数’)
else:
print(‘偶数’)

练习2：根据输入的年龄值打印 ‘成年’ 或者 ‘未成年’
age = 14
if age >= 18:
print(‘成年’)
else:
print(‘未成年’)

练习3：输入年份，根据年份值打印 ‘闰年’ 或者 ‘非闰年’
year = 2012
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
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, …
以此类推，如果前面的条件语句都不满足就执行else后面的代码段
“”"
练习：输入学生的绩点，判断该学生能获取讲学金的等级
一等：绩点 > 4
二等：3.5 <= 绩点 <= 4
三等：3 <= 绩点 < 3.5
四等：2.5 <= 绩点 < 3
没有：绩点 < 2.5
grade = 4.1
if grade > 4:
print(‘一等奖学金’)
elif grade >= 3.5:
print(‘二等奖学金’)
elif grade >= 3:
print(‘三等奖学金’)
elif grade >= 2.5:
print(‘四等奖学金’)
else:
print(‘没有奖学金’)