【笔记】2022.4.13 变量和运算符

1. 变量

1.1 变量的必要性

（1）简洁
（2）易修改
（3）赋予数据意义

1.2 认识变量和定义（创建）变量

1.2.1 变量的概念：变量是用来保存数据的容器

（建议：在程序中使用数据时，不要直接用，而是先用变量把数据存起来，然后通过使用变量来使用数据）

1.2.2 定义变量（创建变量）：将数据保存到变量中

1.2.2.1 语法：变量名 = 数据

1.2.2.2 对语法的说明：

（1）变量名：由程序员自己命名
要求：是标识符不是关键字（由字母、数字、下划线组成，且不能数字开头）
规范：

①见名知义（看到变量名就大概知道变量中保存的是什么数据）
RIGHT Example：

age = 18
name = 18

②不使用系统的函数名、类名和模块名（如果使用系统的函数名、类名给变量命名，会导致他们本身的功能消失）
WRONG Example：

print = 100             # print函数无法使用
int = 20                # int做类型转换无法使用

③所有的字母都小写，多个单词之间用下划线隔开（也可以使用驼峰式命名）
RIGHT Example：

dog_name = '溪溪'       #PEP8命名规范
dogName = '溪溪'        #驼峰式命名

（2）=：赋值符号，固定写法
（3）数据：可以是任何有结果的表达式（例如具体的某个类型的数据、运算表达式）
RIGHT Example：

a = 19
b = 'abc'
c = 10 + 20
d = a

1.3 使用变量

使用变量就是使用变量中保存的数据
RIGHT Example：

x = 100
y = 200

print(x, y)                  # 100 200
print(x + 10)                # 110

1.4 重新给变量赋值

xx = 100
print(xx)                      # 100

xx = 200                       # 重新赋值为200
print(xx)                      # 200

xx = 'abc'                     # 重新赋值的时候可以赋不同类型的值
print(xx)                      # abc

注意：重新赋值会覆盖先前的值

1.5 同时定义多个变量

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

x1 = x2 = x3 = 100
print(x1, x2, x3)              # 100 100 100

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

WRONG Example：

y1, y2, y3 = 10, 20
print(y1, y2, y3)              # 报错ValueError

RIGHT Example：

y1, y2, y3 = 10, 20, 30
print(y1, y2, y3)              # 10 20 30

APPLICATION 交换变量的值：

# 方法1
m = 100
n = 20
t = m
m = n
n = t
print(m, n)

# 方法2
m = 10
n = 20
m, n = n, m
print(m, n)

方法1通用，但python里更推荐方法2

1.6 定义变量和重新给变量赋值的底层逻辑

1.6.1 C语言与python的存储方式

1.6.1.1 C语言的存储方式

（1）存储方式：根据数据类型申请内存空间。相当于根据要储存的内容物先选择一个现有的容器。

（2）赋新值时的运作方式：内存空间不变，删除原有数据，放入新数据。相当于容器不变，只换掉内容物。

图示：（3）优缺点：运行速度快，但容易造成数据溢出、内存浪费，同时还必须考虑数据成长的问题。

1.6.1.2 python的存储方式

（1）存储方式：数据需要多大内存，就申请多大内存。相当于根据要储存的内容物量身定制一个容器。

（2）赋新值时的运作方式：根据新的数据申请新内存，放入新数据，再与原来的变量名关联，并释放掉原来的内存。相当于直接选择新的容器并放入内容物。

图示：

（3）优缺点：数据不会溢出、内存无浪费或极少，但运行速度慢。

1.6.2 python对比C语言的一些不同点

（1）python定义变量不需要写类型

原理：python定义变量申请内存的时候，内存申请多大看数据需要多大，不看类型

RIGHT Example：

a = 10            

（2）python中变量重新赋值的时候可以赋不同类型的值

原理：重新赋值的时候会重新申请新的内存，相当于重新选容器

RIGHT Example：

b = 20
b = 'abc'
b = [10, 20, 30]

（3）python可以直接计算9999**9999

原理：申请内存的时候会先提前计算存储这个数据需要多大的内存，需要多大就申请多大

RIGHT Example：

a = 9999**9999
print(a)                         #成功打印出结果，但结果太大不予展示

1.6.3 获取内存的工具id()函数

语法：id(变量)

RIGHT Example：

x = 100
print(id(x))                     # 140736121738000

x = 2000
print(id(x))                     # 539446831440（每运行一次变一次）

说明python中每次重新赋值都在申请新的内存空间

2. 运算符

2.1 数学运算符

包括：+（加）、-（减）、*（乘）、/（除）、%（取余、取模）、//（整除，先算除法再取整）、**（幂运算）

2.2.1 +（加）、-（减）、*（乘）、/（除）

含义：+、 -、 *、 /的功能和数学中的+、-、×、÷的功能一模一样

2.1.2 %：取余、取模（求余数）

含义： x % y ：求x除以y的余数

RIGHT Example：

print(10 % 3)                 # 1
print(15 % 4)                 # 3

APPLICATION 1 判断整除关系（判断一个数是否能够被另外一个数整除）：

原理：如果两个数存在整除关系，那么它们相除的余数是0

num = 214
print(num % 2)                # 0，说明是偶数
print(20 % 2)                 # 0，说明是偶数
print(231312 % 2)             # 0，说明是偶数

APPLICATION 2 取整数的低位数：对10或者10的N次幂取余（N代表要取的是后几位）：

num = 3249
print(num % 10)               # 1，说明个位是9
print(num % 100)              # 49，说明后两位是49

2.1.3 //：整除

含义：x // y：求x除以y的商，商向小取整

RIGHT Example：

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

APPLICATION 1 （在知道两个数能整除的情况下）获取整型的商：

nums = [28, 89, 23, 45, 56, 90, 23, 80]
# print(nums[len(nums) / 2])  # 报错，因为除法运算结果不是整型
# 修改后：
print(nums[int(len(nums) / 2)])
print(nums[len(nums) // 2])

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

APPLICATION 2 整数去掉低位数，保留高位数。对10或者10的N次幂进行整除操作：

num = 324
# 324 → 32
print(num // 10)              # 32
# 324 → 3
print(num // 100)             # 3

# 补充：取整数中间的某几位。例如取7647997中间的479
num = 7647997
print(num // 100 % 1000)      # 479
# 或者
print(num % 100000 // 100)    # 479

2.1.4 **：幂运算

含义：x ** y：求x的y次方

RIGHT Example：

print(2 ** 3)
print(4 ** 5)
print(4 ** 2)
print(4 ** 0.5)               # 2.0
print(8 ** (1/3))             # 2.0
print(2 ** -2)                # 0.25
print(1 ** -1)                # 1.0

补充：为什么-10 % 3运算结果是2？

基本原理：被除数 = 商 × 除数 + 余数，余数 = 被除数 - 除数 × 商

具体过程：

①先计算-10 // 3，-10 ÷ 3 ≈ -3.3，向小取整得到-4

②再计算余数，-10 - 3 × (-4) = 2

2.2 比较运算符

包括：>（大于）、<（小于）、>=（大于等于）、<=（小于等于）、==（等于）、!=（不等于）

说明：所有的比较运算符的运算结果都是布尔

RIGHT Example：

print(10 > 30)                # False
print(10 >= 10)               # True
print(10 == 20)               # False

# 判断num是否能被4整除
num = 23
print(num % 4 == 0)           # False

# 判断num是否是浮点数
num = 2.34
print(type(num) == float)     # True

# 判断指定的年龄是否成年
age = 33
print('是否成年：', age >= 18)  # 是否成年：True

补充说明：python的比较运算符支持连写表示范围

RIGHT Example：

# 判断num是否在0到1的范围内
num = 2
print(0 <= num <= 3)          # True
print(0 <= num and num <= 3)  # True。警告：不是最简洁的写法

2.3 逻辑运算符

包括：and（逻辑与运算）、or（逻辑或运算）、not（逻辑非运算）

说明：用来连接条件

2.3.1 and：逻辑与运算

（1）应用场景：用于连接要求同时满足的多个条件
（2）运算规则：条件1 and 条件2。两个条件都是True，结果就是True，只要有一个False结果就是False。类似串联电路。详见下表：

条件	结果
True and True	True
True and False	False
False and True	False
False and False	False

APPLICATION 1 判断是否能获取奖学金：

# 获得奖学金的条件是：绩点不低于3.5，并且操评分大于90
# 条件1：绩点不低于3.5：gpa >= 3.5
# 条件2：操评分大于90：score > 90
gpa = 3.5
score = 95
print('是否能获取奖学金：', gpa >= 3.5 and score > 90)  # 是否能获取奖学金：True

APPLICATION 2 判断num是否能够同时被3和7整除：

# 条件1：能被3整除：num % 3 == 0
# 条件2：能被7整除：num % 7 == 0
num = 23
print('num是否能够同时被3和7整除：', num % 3 == 0 and num % 7 == 0)
# 或者：被3和7的公倍数整除
print('num是否能够同时被3和7整除：', num % 21 == 0)

2.3.2 or：逻辑或运算

（1）应用场景：如果两个或者多个条件中只要有一个满足就行，就用or来对这些条件进行连接

（2）运算规则：条件1 or 条件2。两个条件中只要有一个是True，结果就是True，两个都是False，结果才是False。相当于并联电路。详见下表：

条件	结果
True or True	True
True or False	True
False or True	True
False or False	False

APPLICATION 1 判断num是否能够被3或者7整除：

# 条件1：能被3整除：num % 3 == 0
# 条件2：能被7整除：num % 7 == 0
num = 24
print('num是否能够被3或者7整除：', num % 3 == 0 or num % 7 == 0)

APPLICATION 2 判断指定年份是否是闰年（闰年分为普通闰年和世纪闰年两种。普通闰年：能被4整除但不能被100整除，世纪闰年：能被400整除）：

# 普通闰年：条件1：能被4整除
#         条件2：不能被100整除
#         综合：year % 4 == 0 and year % 100 != 0
# 世纪闰年：year % 400 == 0
year = int(input('请输入年份：'))
print('是否是闰年：', (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0))

2.3.3 not：逻辑非运算

（1）应用场景：如果一个条件正向写情况很多很复杂，反向写却很简单的时候，我们就将条件反向写，再写not
（2）运算规则：not 条件：对指定条件进行否定

RIGHT Example：

age = 23
# 年龄大于等于18
print(age >= 18)

# 年龄不大于等于18
print(not age >= 18, age < 18)

# num能被3整除
num = 23
print(num % 3 == 0)

# num不能被3整除
print(not num % 3 == 0, num % 3 != 0)

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

# 方法1：正向写条件
# 不能同时被3和7整除：能被3整除但不能被7整除、能被7整除但不能被3整除、既不能被3整除也不能被7整除
# 条件1：能被3整除但不能被7整除：num % 3 ==0 and num % 7 !=0
# 条件2：不能被3整除但能被7整除：num % 3 !=0 and num % 7 ==0
# 条件3：既不能被3整除也不能被7整除：num % 3 !=0 and num % 7 !=0
print((num % 3 ==0 and num % 7 !=0) or (num % 3 !=0 and num % 7 ==0) or (num % 3 !=0 and num % 7 !=0))

# 方法2：反向写条件
# 反向写条件：num能同时被3和7整除
print(not (num % 3 == 0 and num % 7 == 0))

2.4 赋值运算符

包括：=、+=、-=、*=、/=、%=、//=、**=

注意1：所有赋值运算符的作用都是将某个数据保存到某个变量中
注意2：所有的赋值运算都没有结果

WRONG Example：

print(a = 10)            # 报错，TypeError

RIGHT Example：

a = 10
print(a)

2.4.1 =：简单赋值运算符

格式：变量 = 数据：将右边的数据保存到左边的变量中

RIGHT Example：

a = 10

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

以+=为例

格式：变量 += 数据：将变量中保存的数据和+=后面的数据进行加法运算，然后将运算结果再赋值给变量

WRONG Example：

b += 10                  # 报错，NameError

RIGHT Example：

a = 2.5
a += 2                   # 相当于：a = 2.5 + 2
print(a)                 # 4.5

2.5 运算符优先级

（1）数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符（最低）
（2）数学运算符：** > * 、 / 、 % 、 // > + 、 -
（3）有括号先算括号里面的

附：计算机内存单位（按从小到大排列）

单位名	与上一级之间的进率
位（bit）	None
字节（byte）	1字节=8位
Kb	1Kb=1024字节
Mb	1Mb=1024Kb
Gb	1Gb=1024Mb
T	1T=1024Gb