1.同时定义多个变量
1）同时定义多个变量赋相同的值
变量名1 = 变量名2 = 变量名3 = … = 数据
a = b = c = 100
print(a, b, c)
2）同时定义多个变量赋不同的值
变量名1, 变量名2, 变量名3,… = 数据1, 数据2, 数据3,…
x, y = 100, 200
print(x, y)
应用：已知两个变量，写代码交换这两个变量的值
方法一：引入其他变量：将a、b看作两杯不同饮料，通过加入一个空杯来腾出操作空间
m = 10
n = 20
t = m # t = 10
m = n # m = 20
n = t # n = 10
print(m, n)
方法二：直接同时赋值
m = 10
n = 20
m, n = n, m # m, n = 20, 10
print(m, n)
2.Python与C,Java定义变量和重新赋值的底层逻辑的不同点
C,Java定义变量时申请内存大小不是根据数据大小而是数据类型,重新赋值时不会自动释放旧内存并重新申请内存,当申请的内存和数据大小不匹配时会导致内存浪费或溢出,并且数据类型固定,不能赋其他类型数值(挖一次坑就不管*)
Python定义变量的是先申请内存，内存申请多大看需要保存的数据需要多大内存，然后将数据存储到对应的内存中，最后再让变量和这块内存进行关联。
重新赋值，是重新申请新的内存，新的内存多大看新的数据需要多个，新数据存储到新的内存中，最后将原来的变量和新的内存关联。
宏观表现:Python根据数据大小,更合理,更智能,但加重了计算机的任务,降低了运行效率(随着需求不断挖坑填坑)
当Python中某部分运算量很大,可以嵌入C来互补
"""
bytes(位)
1字节 = 8位
1bit = 1024字节 # 1024=2**10
1mb = 1024bit
1Gb = 1024mb
1Tb = 1024Gb
...
"""
运算符
1.数学运算符
数学运算符：+、-、*、/、%、//、**
1) +、-、*、/ 和数学中的+、-、×、÷的功能一模一样
如果运算对象中有一个是浮点数，结果就是浮点数。(除法运算的结果都是浮点数)
print(2 + 5)
print(2 - 5)
print(2 * 5)
print(2 / 5)
print(4.0 / 2)
2) % - 取余（取模）
x % y - 求x除以y的余数
print(5 % 2) # 1
print(8 % 3) # 2
取余在程序中的作用：
1）判断一个数是否能够被另外一个数据整除（判断余数是否为0）
num = 9
print(num % 2) # 1
2）取整数的低位数(对10的次方数取余)
print(234 % 10, 23 % 10, 129 % 10)
print(234 % 100, 9012 % 100)
获取输入的数字的个位数
num = int(input('请输入一个正整数:'))
print(num % 10)
3) // - 整除(求商，商向小取整)
x // y - x除以y的商向小取整(结果为负数时要注意)
print(5 // 2) # (2) 2.5 3
print(-5 // 2) # (-3) -2.5 -2
print(6 // 2) # 3
print(10.6 // 2) # (5.0) 5.3 6
应用：去掉低位数，保留高位
num = 1232291
print(num // 10) # 123229
print(num // 100) # 12322
print(num // 1000) # 1232
练习：输入任意一个正整数，获取这个数的十位数
234 -> 3 9087 -> 8
num = 2341
print(num // 10 % 10) # 4
print(num % 100 // 10) # 4
4) ** - 幂运算
x ** y - 求x的y次方
print(2 ** 3)
print(4 ** 2)
# 部分浮点数存储时只能近似 浮(意为浮动不定)
print(3.3 ** 2) # 10.889999999999999
print(16 ** 0.5) # 4.0
print(8 ** (1/3)) # 2.0
print(2 ** -2) # 0.25
2.比较运算符：>、<、>=、<=、==、!=
所有比较运算符的运算结果都是布尔值
print(10 > 20)
print(10 < 20)
print(10 >= 10)
print(10 >= 5)
print(10 <= 5)
print(10 == 10)
print(10 == 11)
print(10 != 11)
age = 8
print(10 <= age <= 20)
3.逻辑运算符：and、or、not
1) and - 逻辑与
应用场景：需要多个条件同时满足，就用and将条件连接，相当于生活中的并且
运算规则: 条件1 and 条件2 - 两个条件只有一个是False结果就是False, 两个都是True结果才是True
True and True -> True
True and False -> False
False and Ture -> False
False and False -> False
练习1：写出num是否是能被3整除的偶数：
num = 29
print(num % 3 == 0 and num % 2 == 0)
练习2：写出num是否是大于100的奇数
条件1：是否大于100 - num > 100
条件2：是奇数 - num % 2 == 1 num % 2 != 0
num = 120
print(num > 100 and num % 2 == 1)
练习3：写出num是否能同时被3和7整除的条件
# 条件1：能被3整除 - num % 3 == 0
# 条件2：能被7整除 - num % 7 == 0
num = 21
print(num % 3 == 0 and num % 7 == 0)
print(num % 21 == 0)
判断年龄是否在[10, 20]之间
age = 1
print(10 <= age <= 20)
2) or - 逻辑或
应用场景：需要多个条件有一个条件满足就可以，使用or，相当于生活中的或者
运算规则：条件1 or 条件2 - 两个条件中只要有一个是True，结果就是True，两个都是False结果才是False
'''
True or True -> True
True or False -> True
False or Ture -> True
False or False -> False
'''
练习1：判断num是否能够被3或者5整除
num = 23
print(num % 3 == 0 or num % 5 == 0)
练习2：判断指定的年是否是闰年
闰年分为普通闰年和世纪闰年两种，普通闰年-能被4整除但是不能被100整除 世纪闰年 - 能被400整除
# 普通闰年：year % 4 == 0 and year % 100 != 0
# 世纪闰年：year % 400 == 0
year = 2004
print((year % 4 == 0 and year % 100 != 0) or (year % 400 == 0))
3) not - 逻辑非
应用场景：如果一个条件正向写情况很多很复杂，反向却很简单，条件就反向写再加not
运算符规则：not 条件 - True变False，False变True
"""
not True - False
not False - True
"""
age = 28
# 年龄不大于18
print(not age > 18)
print(age <= 18)
练习：判断一个数是否不能同时被3、7整除
方法一：
# 1)能被3整除不能被7整除 num % 3 == 0 and num % 7 != 0
# 2)能被7整除不能被3整除 num % 3 != 0 and num % 7 == 0
# 3)既不能被3整除又不能被7整除 num % 3 != 0 and num % 7 != 0
num = 21
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)
方法三：
print(num % 3 != 0 or num % 7 != 0)
| 1 - 1 | and or |
| 1 - 0 | or |
| 0 - 1 | or |
| 0 - 0 | not |
4.赋值运算符
=、+=、-=、*=、/=、%=、//=、**=
注意：
-
所有的赋值运算符的最终目的都是将数据保存到变量中，所以赋值运算符的前面必须是变量名，后面必须是数据
-
所有的赋值运算符表达式是没有结果的（非常重要） - 赋值语法无法提供数据
print(10)
print(10 + 23)
print(10 > 20)
print(10 > 20 and 5 != 4)
# print(a = 10) # 报错！
1 ) 简单的赋值运算: =
定义变量和给变量赋值的时候的使用
a = 10
print(a)
2) 复合的赋值运算符
+=、-=、*=、/=、%=、//=、**=
变量 += 数据 - 将变量中保存的数据取出来和后面的数据进行加法运算，将运算结果再保存到变量中
注意：复合的赋值运算符前面的变量必须是已经定义过的变量
# b += 10 # 报错！
a += 2 # a = a + 2
print(a) # 12
a -= 5 # a = a - 5 = 12 - 5
print(a) # 7
a *= 2 # a = a * 2 = 7 * 2
print(a) # 14
a %= 3 # a = a % 3 = 14 % 3
print(a) # 2
# print(a //= 2) # 报错
a = 14
a /= 7
print(a)
print(14 / 7)
print(10 + 23)
print(10 > 20)
# print(a = 20)
# print(a /= 10)
a = 20
print(a)
a /= 10
print(a)
5.运算符优先级
结论
1：数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符(最低)
2：** > *、/、%、// > +、-
3：有括号先算括号里面 - ()
补充：布尔值参数数学运算的时候True就是1，False就是0
print(True + 23) # 24
print(False * 34) # 0
流程控制 - 程序执行方式
- 顺序结构(默认) - 代码从上往下一条一条的执行，每条语句执行一遍
- 分支结构(if) - 根据条件选择执行代码
- 循环结构(for、while) - 代码重复执行（写一遍，执行多表）
print('==========')
print('++++++++')
print('----------')
# print('网络连接成功！')
# print('网络连接失败！')
if分支结构
1）if单分支结构 - 满足条件执行某个操作，条件不满足的时候就不执行
语法：
'''
if 条件语句:
代码段
'''
说明：
if - 关键字；固定写法
条件语句 - 任何有结果的表达式，包括：具体的数据、已经赋值过的变量、运算表达式(除了赋值语句)
: - 固定写法(容易忘记)
代码段 - 从结构上是和if保持一个缩进(一般是一个制表符/tab)的一条或者多条语句(至少一条)；
从逻辑上就是在满足条件才会执行的代码
执行过程：先判断条件语句是否成立，如果成立就执行代码段，条件不成立代码段就不执行。
注：如果条件语句的结果不是布尔，就将数据转换成布尔看结果是True还是False（所有的零值和空值是False,其他的都是True）。
age = 18
if age >= 18:
print('成年！')
print('可以进网吧！')
if 19: # 这里19即是True
print('xxx')
练习：根据指定的分数值，打印 ‘及格’
score = 93
if score >= 60:
print('及格')
if双分支结构（if-else）
满足条件执行某个操作，条件不满足的时候执行另外的操作
'''
语法：
if 条件语句:
代码段1(满足条件时执行)
else:
代码段2(不满足条件时执行)
'''
练习：根据num的值打印’奇数’或者’偶数’
方法一：
num = 23
if num % 2 != 0:
print('奇数')
else:
print('偶数')
方法二：
num = 23
if num % 2: # 因为结果只有1或0,直接当作布尔值
print('奇数')
else:
print('偶数')
练习：根据year的值打印’闰年’或者’平年’
year = 2000
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
print('闰年')
else:
print('平年')
补充：布尔转换
print(bool(0), bool(0.0), bool(''), bool(None),bool(False)) # False False False False False
print(bool(12), bool(-100), bool('a'), bool('False')) # True True True True
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
