day3运算符

变量

重新赋值

a = 10      # 创建变量a，并且赋值为10
print(a)    # 10

a = 100     # 重新给a赋值为100
print(a)    # 100

a = 'abc'   # 重新赋一个其他类型的数据
print(a)    # abc

同时定义多个变量

1. 同时定义多个变量赋相同的值：变量名1 = 变量名2 = 变量名3 = … = 数据

   x = y = z = 100
   print(x,y,z)     # 100 100 100
   

2. 同时定义多个变量赋不同的值：变量名1,变量名2,变量名3,… = 数据1,数据2,数据3,…

   m,n = 10,20
   print(m,n)    # 10 20
   

   注意： =后面数据的个数必须和前面变量的个数保持一致

   练习：交换两个变量的值

   a = 100
   b = 200
   a, b = b, a
   print(a, b)    # 200 100
   

变量保存数据的底层逻辑

定义变量的时候会自动在内存中申请空间保存数据

原理：定义变量的时候会自动申请内存，内存的大小由数据的大小决定；重新给变量赋值，会重新根据新的数据申请新的内存。

补充：内存单位
位(bit)
1字节(byte) = 8位
1kb = 1024字节
1Mb = 1024KB
1Gb = 1024Mb
1Tb = 1024Gb

数学运算符

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

1. +(加)、-(减)、*(乘)、/(除)

   Python中的+、-、*、/和数学中的+、-、×、÷的功能一样

   print(5 + 2)
   print(5 - 2)
   print(5 * 2)
   print(5 / 2)
   

2. //(整除)

   x // y - 求x除以y的商，商向小取整(找和小数相邻的两个整数中较小的那个)

   print(5 // 2)       # 2; 2 2.5 3
   print(-5 // 2)      # -3; -2 -2.5 -3
   

   应用1：希望能整除的情况下商是整型

   print(4 / 2)        # 2.0
   print(int(4 / 2))     # 2
   print(4 // 2)       # 2
   

   应用2：去掉(砍掉)一个整数的低位数，保留高位数

   num = 2342
   print(num // 10)        # 234
   print(num // 100)       # 23
   

3. % - 取余、取模

   x % y - 求x除以y的余数

   print(5 % 2)    # 1
   print(15 % 4)   # 3
   

   应用1：判断两个数字之间的整除关系 - 判断余数是否为0

   print(71 % 2)    # True
   

   应用2：去掉高位数，保留低位数

   num = 27283
   print(num % 10)     # 3
   print(num % 100)    # 83
   

   练习：获取任意一个正整数的十位数

   num = 82967
   # 方法1：
   print(num // 10 % 10)
   
   # 方法2：
   print(num % 100 // 10)
   

4. ** - 幂运算

   x ** y - 求x的y次方

   print(2 ** 3)      # 8
   print(5 ** 4)      # 625
   print(16 ** 0.5)   # 4.0
   print(2**-3)       # 0.125
   

注意：/的结果一定是浮点数；其他运算符的运算结果的类型和运算对象有关

print(10 + 3.0)    # 13.0
print(2.5 * 2)     # 5.0
print(5 / 1)       # 5.0

比较运算符

比较运算符：>、<、==（等于）、!=（不等于）、>=、<=

注意1：所有的比较运算符的运算结果都是布尔值

print(10 > 30)
print(10 < 30)
print(10 == 30)
print(10 == 10)
print(10 != 10)
print(10 >= 10)

age = 13
print('是否成年：',age >= 18)

判断num对2取余的结果是否为0

num = 89
print('是否是偶数：',num % 2 == 0)

注意2：Python的比较运算符直接连写表示范围

x = 2
print('x是否在0-1之间：',0 <= x <= 2)

逻辑运算符

逻辑运算符：and（逻辑与预算）、or（逻辑或运算）、not（逻辑非运算）
单一条件：如果下雨；如果温度高于35度
复合条件：并且（要求多个条件同时成立）、或者（要求多个条件中只要有一个条件成立就行）

1. and - 逻辑与运算

应用场景：如果需要多个条件同时满足，就用and连接。相当于生活中的“并且”
运算规则：条件1 and 条件2 - 如果两个条件都成立结果是True,只要有一个不成立结果就是False

True and True - True
False and True - False
True and False - False
False and False - False

练习1：写条件判断num是否是大于10的偶数

num = 31
# 分析条件的类型：看是单一条件还是复合条件
# 所有的条件：大于10(num > 10)、是偶数(num % 2 == 0)
# 分析连接方式：num>10 and num % 2 == 0
print('num是否是大于10的偶数：',num > 10 and num % 2 == 0)

练习2：写条件判断num是否能同时被3和7整除

# 方法1：
print('num是否能同时被3和7整除：',num % 3 == 0 and num % 7 == 0)

# 方法2：
print('num是否能同时被3和7整除：',num % 21 == 0)

2. or - 逻辑或运算

   应用场景：如果要求多个条件中有一个条件成立就行，就用or连接；相当于生活中的或者
   运算规则：条件1 or 条件2 - 如果两个条件都不成立结果就是False，只要有一个条件成立结果就是True

   True or False - True
   False or True - True
   True or False - True
   False or False - False

   练习1：判断num是否能被3或者5整除

   num = 23
   print('num是否能被3或者5整除：', num % 3  == 0 or num % 5 == 0)
   

   练习2：判断year是否是闰年

   闰年分为世纪闰年和普通闰年两种：
   世纪闰年：能被400整除的年 （year % 400 == 0）

   普通闰年：能被4整除但是不能被100整除 （ year % 4 == 0 and year % 100 != 0）
   能被4整除: year % 4 == 0
   不能被100整除: year % 100 != 0

   year = 2000
   print('year是否是闰年：', (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0))
   

3. not - 逻辑非运算

   应用场景：对指定的条件进行否定（如果一个条件正向写情况很多很复杂，反向却非常简单，就可以将条件反向写再加not)
   运算规则：not 条件

   not True - False
   not False - True

   练习1：年龄不大于18

   age = 19
   print(not age > 18)
   print(age <= 18)
   

   练习2：判断num不是偶数

   num = 89
   print('num是否不是偶数：', not num % 2 == 0)
   print('num是否不是偶数：', num % 2 != 0)
   

   练习3：判断num是否不能同时被3和7整除

   num = 23
   print('num是否不能同时被3和7整除:',not num % 21 == 0)
   print('num是否不能同时被3和7整除:',num % 21 != 0)
   

赋值运算符

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

注意：所有赋值运算都是用来给变量赋值的,所以赋值运算表达式没有结果（不能提供一个数据）

1. = - 直接赋值

   变量 = 数据 - 将数据保存到变量中，变量既可以是已经定义过的变量，也可以是没有定义过的变量

2. 复合赋值运算符

   变量 += 数据 - 先将变量中的数据取出来，然后和后面的数据进行加法运算，然后将计算结果再赋值给变量
   （变量必须是已经定义过的变量，并且里面保存的数据，可以和后面的数据进行加法运算）

   a = 20
   a += 10   # a = a + 10 -> a = 20 + 10 -> a = 30
   print(a)  # 30
   
   a -= 5    # a = 30 - 5 = 25
   a *= 2    # a = 25 * 2 = 50
   a %= 3    # a = 50 % 3 = 2
   
   print(a)   # a = 2
   

   所有的赋值数据都是没有结果，无法提供数据

   # print(a = 10)       报错
   # print(age += 20)    报错
   # a = (b = 1)         报错
   

运算符优先级

如果一个表达式中有多种运算符，谁的优先级高就算谁：

1. 数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符(最低的)
2. 不同的数学运算符的优先级数学一样。（** > *、/、%、// > +、-）
3. 有括号先算括号里面的 - ()

分支结构

程序执行过程(顺序结构)

print(10)
print(20)
print(30)

分支结构(if)

让程序根据条件执行代码

1. if单分支结构 - 如果xxx就xxx(满足条件执行某个操作，条件不满足的时候这个操作就不执行)

   语法：
   if 条件语句:
   代码段

   说明：

   a. if - 关键字；固定写法
   b. 条件语句 - 可以是任何有结果的表达式(比如：具体的数据、运算表达式、已经定义过的变量等，只有赋值语句不行)；
   一般将结果是布尔的表达式作为条件
   c. : - 固定写法(注意输入法问题)
   d. 代码段 - 结构上，就是和if保持一个缩进的一条或者多条语句(至少一条!!!);
   逻辑上，就是满足条件才会执行代码。

   执行过程：先判断条件语句是否成立(如果条件语句的结果不是布尔，就转换成布尔看是否是True)，如果成立就执行代码段；条件不成立，代码段就不执行。

   age = 18
   if age >= 18:
       print('成年!')
   
   num = 230
   if num % 2 == 0:
       print('偶数')
   

2. if双分支结构 - 如果xxx就xxx否则就xxx（条件成立执行某个操作，不成立就执行另外一个操作）

   语法：
   if 条件语句:
   代码段1(满足条件执行的代码)
   else:
   代码段2(不满足条件执行的代码)

   练习1：根据age的值打印成年或者未成年

   year = 2004
   if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
       print('闰年')
   else:
       print('平年')
   

   练习2：根据year的值打印’闰年’或者’平年’

   year = 2004
   if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
       print('闰年')
   else:
       print('平年')
   

3. if多分支结构