Python基础——Ch07~Ch0提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
- 7. 运算符、优先级
- 7.1 算数运算符
- 7.2 比较运算符
- 7.3 赋值运算符
- 7.3.1 增强赋值
- 7.3.2 序列赋值
- 7.3.3 多目标赋值
- 7.4 逻辑运算符
- 7.5 成员运算符
- 7.6 身份运算符
- 7.7 位运算符
- 7.8 运算符优先级
- 7.9 +、+=、* 的连接操作
- 8. 条件语句
- 8.1 三元表达式
- 8.2 if 语句嵌套
- 8.3 条件语句特点
- 8.4 实现：石头剪刀布游戏
- 9. 循环语句
- 9.1 while 循环
- 9.2 for 循环
- 9.3 循环控制语句
- 9.4 优化：石头剪刀布游戏
- 9.5 pass 语句
- 10. 推导式
- 10.1 列表推导式
7. 运算符、优先级 7.1 算数运算符
a = 3 b = 2 d = a + b print(d) # 5 d = a - b print(d) # 1 d = a * b print(d) # 6 d = a / b print(d) # 1.5 # 取模(除法的余数) d = a % b print(d) # 1 # 相当于 / 再向下取整 d = a // b print(d) # 1 # 10**8 还可以用科学计数法写成 1e8 d = a ** b print(d) # 9 d = 10 ** 8 print(d) # int f = 1e8 print(f) # float
负数取整，取模
print(15 // 4) # 15 / 4等于3点几，然后再向下取整，取更小的最接近的整数3 print(-15 // 4) # -15 / 4等于负3点几，然后再向下取整，取更小的最接近的整数-4 print(15 % 4) # 余数 = 15 - (3*4) = 3 print(-15 % 4) # 余数 = -15 - (-4*4) = 1 # 规律： (a % b) + (-a % b) = b或0 (当a为0时，为0)7.2 比较运算符
返回布尔值：True，False
a = 20 b = 9 c = a == b print(c) # False c = a != b print(c) # True c = a > b print(c) # True c = a < b print(c) # False c = a >= b print(c) # True c = a <= b print(c) # False7.3 赋值运算符
a = 3 c = a + 2 print(c) # 5 c += a print(c) # 8 结果等于 c = c + a c -= a print(c) # 5 结果等于 c = c - a c *= a print(c) # 15 结果等于 c = c * a c /= a print(c) # 5.0 结果等于 c = c / a c %= a print(c) # 2.0 结果等于 c = c % a c **= a print(c) # 8.0 结果等于 c = c ** a c //= a print(c) # 2.0 结果等于 c = c // a
:= 海象运算符
# 写法一：
string = "hello world"
length = len(string)
print(length + 5)
print(f"string的长度为{length}")
# 写法二：
string = "hello world"
print(len(string) + 5)
print(f"string的长度为{len(string)}")
# 写法三：
# 海象运算符，可在表达式内部为变量赋值，记得加括号，不然就是赋值len(string) + 5的返回值了
# 相对写法一：避免了一次赋值给中间变量的步骤
# 相对写法二：避免使用两次len方法
string = "hello world"
print((length := len(string)) + 5)
print(f"string的长度为{length}")
7.3.1 增强赋值
增强赋值在条件符合的情况下（例如：操作数是一个可变类型对
象）会以追加的方式来进行处理，而普通赋值则会以新建的方式进
行处理，此时增强赋值语句比普通赋值语句的效率是更高的，但是
也要注意因此产生的问题
""" 增强的赋值运算符 += -= *= /= %= **= //= """ lis1 = [1, 2] lis2 = lis1 lis1 = lis1 + [3, 4] print(lis1) # [1, 2, 3, 4] print(lis2) # [1, 2] lis1 = [1, 2] lis2 = lis1 lis1 += [3, 4] print(lis1) # [1, 2, 3, 4] print(lis2) # [1, 2, 3, 4] # a = 12 # b = a # a = a + 1 # print(a) # 13 # print(b) # 12 # a += b # 等效于 a = a + b # a = 12 # b = a # a += 1 # 等效于 a = a + 1 # print(a) # 13 # print(b) # 127.3.2 序列赋值
a, b = 3, 4 # 等同于 (a,b) = (3,4) print(a, b) [a, b] = [3, 4] print(a, b) [a, b] = [3, 4] print(a, b) a, b, c = [3, 4, 5] print(a, b, c) a, b, c = "你好吗" print(a, b, c)7.3.3 多目标赋值
a = b = c = 999 d = 999 print(id(a)) print(id(b)) print(id(c)) print(id(d)) b = d print(id(b)) a = b = c = [1, 2, 3] b.append(4) print(a, b, c)7.4 逻辑运算符
# None, False, 0, 空列表/空元组/空字典/空集合都会被认定为 False a = 2 b = "hello world" c = [] d = 0 # 左边为假，返回左边；否则返回右边 print(c and a) # [] print(c and d) # [] print(d and c) # 0 print(a and c) # [] print(a and b) # "hello world" print(b and a) # 2 # 左边为真，返回左边；否则返回右边 print(a or c) # 2 print(a or b) # 2 print(b or a) # "hello world" print(c or a) # 2 print(c or d) # 0 print(d or c) # [] # 假，返回真；真，返回假 print(not a) # False print(not b) # False print(not c) # True print(not (a and c)) # True # 优先级：not > and > or print(not a or c) # []
规律：
and 只要有其中一边为 False，最后结果一定为 False；只有两边都为 True 的情况下，最后结果才为 True。
or 只要有其中一边为 True，最后结果就为 True；只有两边都为 False 的情况下，最后结果才为 False。
短路原则： 如果前面的部分已经计算出整个表达式的结果，则后面的部分不再计算（考虑优先级）。
a = 0 b = 1 print(a == 0 or b / a > a) print(a > 0 and b / a > a) print(a > 0 or b / a > a)7.5 成员运算符
返回布尔值：True，False（判断对象中是否存在某个元素）
str1 = "hello world"
list1 = [1, 2, 3, 4, 5]
tuple1 = (1, 2, 3, 4, 5)
set1 = {1, 2, 3, 4, 5}
a = "hel" in str1
b = 4 in list1
c = 4 in tuple1
d = 4 in set1
print(a,b,c,d) # True True True True
a = "hel" not in str1
b = 4 not in list1
c = 4 not in tuple1
d = 4 not in set1
print(a,b,c,d) # False False False False
7.6 身份运算符
返回布尔值：True，False
a = 257 b = 257 print(a == b) print(a is b) print(id(a)) print(id(b)) a = 256 b = 256 print(a == b) print(a is b) print(id(a)) print(id(b))
is 和 == 的区别
is 是身份运算符，判断对象的地址是否相同；而 == 是比较运算符，判断对象的值是否相等
判断两个变量是否相等，实际上式需要判断两个条件：
- 变量的值是否相等；
- 变量的内存地址是否相同。
位运算符是把数字看作二进制来进行计算的
进制转换函数
bin(x)
将一个整数转变为一个前缀为“0b”的二进制字符串。
print(bin(3)) # 0b11 print(bin(-100)) # -0b1100100
hex(x)
将一个整数转变为一个前缀为“0x”的十六进制字符串。
print(hex(255)) # 0xff print(hex(-42)) # -0x2a
oct(x)
将一个整数转变为一个前缀为“0o”的八进制字符串。
print(oct(255)) # 0o377 print(oct(-42)) # -0o52
a = 60 # 二进制 60 = 0011 1100 b = 13 # 二进制 13 = 0000 1101 c = a & b # 12 = 0000 1100 同都为真(1和1), 才为真 print(c) c = a | b # 61 = 0011 1101 一个真(至少一个1), 就为真 print(c) c = a ^ b # 49 = 0011 0001 不同(01或者10), 就为真 print(c) c = a ^ b ^ a # 一个数异或于同一个数两次，结果还是它本身 print(c) # 13
在计算机中，负数以原码的补码形式表达
负数的反码：对该数的原码除符号位外各位取反
负数的补码：对该数的原码除符号位外各位取反，然后在最后一位加1 （即反码+1）
正数的反码和补码都与原码相同
# 23的原码：0,0010111 右移两位舍弃右边的两位，最高位使用符号位填充：000,00101 还原成十进制就是5 # 右移三位舍弃右边的三位：0000,0010 还原成十进制就是2 print(23 >> 2, 23 >> 3) # 23的原码：0,0010111 左移两位后面补两个0：0,001011100 换算成十进制就是92 # 左移三位后面补三个0：0,0010111000 换算成十进制就是184 print(23 << 2, 23 << 3) # 因为在计算机中，负数以原码的补码形式表达，所以先算出补码，再来移位(符号位1代表负数) # -23原码：1,0010111 -23反码：1,1101000 -23补码： 1,1101001 # 补码向右移两位得到：111,11010 这个还是补码形式，需要先转成原码再换算成十进制 # 补码转成原码就是逆过程：111,11010减一再取反码就是原码了，得到：111,00110 换算成十进制就是-6 # 补码向右移三位得到：1111,1101 这个还是补码形式，需要先转成原码再换算成十进制 # 补码转成原码就是逆过程：1111,1101减一再取反码就是原码了，得到：1111,0011 换算成十进制就是-3 # 补码向左移两位得到：1,110100100 这个还是补码形式，需要先转成原码再换算成十进制 # 补码转成原码就是逆过程：1,110100100减一再取反码就是原码了，得到：1,001011100 换算成十进制就是-92 # 补码向左移三位得到：1,1101001000 这个还是补码形式，需要先转 成原码再换算成十进制 # 补码转成原码就是逆过程：1,1101001000减一再取反码就是原码了，得到：1,0010111000 换算成十进制就是-184 print(-23 >> 2, -23 >> 3) print(-23 << 2, -23 << 3)
按位取反运算符，对数据的每个二进制位取反（包括符号位）
# 23的原码：0,0010111 按位取反：1,1101000 # 按位取反之后变成了负数, 负数在计算机中以原码的补码形式表达,所以需要先转成原码再换算成十进制 # 补码转成原码就是逆过程：1,1101000减一再取反码就是原码了，得到：1,0011000 换算成十进制就是-24 print(~23) # 负数在计算机中以原码的补码形式表达,所以先算出补码，再来按位取反 # -23原码：1,0010111 -23反码：1,1101000 -23补码： 1,1101001 # 再来按位取反得到：0,0010110 按位取反之后变成了正数，正数直接换算成十进制就是22 print(~-23)7.8 运算符优先级
以下表格列出了从高到低优先级的常用运算符：
+、+=、* 还可以对字符串、列表、元组进行连接操作（要保证连接对象的类型一致）
a = "1"
b = "2"
c = a + b
print(c) # '12'
a = ["1"]
b = [2, 3]
c = a + b
print(c) # ['1', 2, 3]
a = ("1",)
b = (2, 3)
c = a + b
print(c) # ('1', 2, 3)
a = "1"
b = "2"
a += b # a = a + b
print(a) # '12'
a = ["1"]
b = [2, 3]
a += b
print(a) # ['1', 2, 3]
a = ("1",)
b = (2, 3)
a += b
print(a) # ('1', 2, 3)
a = "1"
b = a * 3
print(b) # "111"
a = ["1"]
b = a * 3
print(b) # ['1', '1', '1']
a = ("1",)
b = a * 3
print(b) # ('1', '1', '1')
8. 条件语句
格式一：
if 判断条件:
执行语句…
sex = '男'
if sex == '男':
print("男士请进")
print("这是男士专用卫生间...")
sex = "女"
if sex == '女':
print("女士请进");
print("这是女士专用卫生间...")
格式二 ：
if 判断条件:
执行语句…
else:
执行语句…
sex = '男'
if sex == '男':
print('男士请进')
else:
print('女士请进')
格式三：
if 判断条件1:
执行语句1…
elif 判断条件2:
执行语句2…
elif 判断条件3:
执行语句3…
else:
执行语句4…
sex = input("请输入你的性别 (男/女): ")
if sex == "男":
print("男士请进")
elif sex == "女":
print("女士请进")
else:
print("输入错误!")
print("程序结束")
8.1 三元表达式
它是一个表达式，而不是一个结构化的代码块
score = float(input("请在下方输入你的考试分数:n"))
if score >= 90:
print("牛逼")
elif score >= 80:
print("优秀")
elif score >= 60:
print("可以")
# elif score < 60:
# print("同志仍需努力")
else:
print("同志仍需努力")
# 三元表达式
result = print("牛逼") if score >= 90 else print("优秀") if score >= 80 else print("可以") if score >= 60 else print("同志仍需努力")
print(result) # None
if score >= 90:
result = "牛逼"
elif score >= 80:
result = "优秀"
elif score >= 60:
result = "可以"
else:
result = "同志仍需努力"
print(result)
# 三元表达式 result = "牛逼" if score >= 90 else "优秀" if score >= 80 else "可以" if score >= 60 else "同志仍需努力"
print(result)
print("老师说我" + ("牛逼" if score >= 90 else "优秀" if score >= 80 else "可以" if score >= 60 else "同志仍需努力"))
8.2 if 语句嵌套
print("敲门声: 咣咣咣~")
sex = input("请输入你的性别 (男/女): ")
if sex == "男":
print("滚犊子...")
else:
answer = input("请问是不是包租婆? (是/不是): ")
if answer == '是':
print("屋里没人...")
else:
answer2 = input("请问是不是小姐姐? (是/不是): ")
if answer2 == '是':
print("请进, 你是找我的吗?")
else:
print("不好意思, 您找错人了...")
# 三元表达式嵌套（了解一下）
print("不好意思, 我今天不能见男的, 您请回吧") if input("请问你是男是女 (男/女): ") == "男" else (print("不好意思, 今天我不在家, 房租下次给你") if input("请问是包租婆吗? (是/不是): ") == "是" else (print("小姐姐, 您好, 请进...") if input("请问你是小姐姐吗? (是/不是): ") == "是" else print("不好意思, 我今天不宜面圣, 您请回吧")))
8.3 条件语句特点
每个条件语句只会满足一次结果
num = 5
if num > 0: # 满足条件, 输出a, 后面就不会执行了
print("a")
elif num > 1:
print("b")
elif num > 2:
print("c")
elif num > 3:
print("d")
else:
print("e")
if num > 4: # 然后又跳到这个条件语句中执行
print("f")
else:
print("g")
进行 bool 判断时，任何非零 / 非None / 非空值为 True，反之为False
if 123456:
print("123456为True")
if []:
print("[]为True")
else:
print("[]为False")
8.4 实现：石头剪刀布游戏
import random
INFO = {0: "石头", 1: "剪刀", 2: "布"} # ["石头", "剪 刀", "布"]
computer = random.randint(0, 2)
player = int(input("请出拳! 输入0代表石头、1代表剪刀、2代表 布: "))
# 展示电脑和玩家的出拳结果
print(f"电脑出拳: {INFO[computer]}n玩家出拳: {INFO[player]}")
# 判断谁输谁赢
if computer == player:
print("平局!")
elif player-computer == -1 or player-computer == 2:
print("玩家胜利!")
else:
print("电脑胜利!")
random 模块常用函数
random.random() 返回 [0.0, 1.0) 范围内的随机浮点数
random.randint(a, b) 返回 [a, b] 范围内的随机整数
random.uniform(a, b) 返回 [a, b] / [b, a] 范围内的随机浮点数
random.choice(seq) 从非空序列 seq 返回一个随机元素。 如果seq 为空，则引发 IndexError
random.sample(population, k) 从序列或者集合中随机获取k个元素，以列表形式返回（Python3.9 版本, 集合中采样已弃用）
random.shuffle(x) 将可变序列 x 随机打乱位置
random.randrange ([start,] stop [,step]) 等效于从 range(start, stop, step) 里随机返回一个元素
random.seed ([x]) 起固定随机数的作用，x 可以是任意数字（x可以理解为种子的名字）
import random
# 返回 [0.0, 1.0) 范围内的随机浮点数
a = random.random()
print(a)
# 返回 [2, 4] 范围内的随机整数
a = random.randint(2, 4)
print(a)
# 返回 [2.5, 3.5] 范围内的随机浮点数
a = random.uniform(2.5, 3.5)
a = random.uniform(3.5, 2.5)
print(a)
# 从序列返回一个随机元素
a = random.choice(range(10))
print(a)
# 从序列中随机获取k个元素，以列表形式返回
a = random.sample(("a", 1, 2, 3, "b"), 2)
print(a)
# 从集合中随机获取k个元素，以列表形式返回
a = random.sample({"a", 1, 2, 3, "b"}, 2)
print(a)
# 将可变序列随机打乱位置
a = [1, 2, 3, 4, 5]
random.shuffle(a)
print(a)
# 从[star, stop)范围按照step步长组成的数据范围里返回一个随机数
a = random.randrange(start=2, stop=100, step=2)
print(a)
# 设定好种子之后，每次执行程序随机数将是固定的
# 使用相同的随机数种子，生成的随机数值是一样的
print(random.random())
random.seed(10)
print("seed10:", random.random())
random.seed(7)
print("seed7:", random.random())
random.seed(10)
print("seed10:", random.random())
9. 循环语句
9.1 while 循环
格式：
while 判断条件:
执行语句…
a = 1 while a < 4: print(a) # 1 2 3 a += 1
while True:
a = 0
while True:
print("hello")
a += 1
if a == 3:
break
while … else
count = 0 while count < 5: print(count, "小于5") count = count + 1 else: print(count, "大于或等于 5") count = 0 while count < 5: print(count, "小于5") count = count + 1 print(count, "大于或等于 5") count = 0 while True: print(count, "小于5") count = count + 1 if count >= 5: break else: print(count, "大于或等于 5") count = 0 while True: print(count, "小于5") count = count + 1 if count >= 5: break print(count, "大于或等于 5")
while 循环嵌套
# 实现九九乘法表
right = 1
while right <= 9:
left = 1
while left <= right:
print(f"{left}x{right}={left*right}", end="t")
left += 1
print()
right += 1
9.2 for 循环
for 变量 in 可迭代对象:
执行语句…
str1 = "123ab"
lis1 = [1, 2, 3, "a", "b"]
tup1 = (1, 2, 3, "a", "b")
dic1 = {"one": 1, "two": 2}
set1 = {3, 2, 4, "a"}
for i in str1:
print(i)
for i in lis1:
print(i)
for i in tup1:
print(i)
for i in dic1:
print(i)
for i in set1:
print(i)
当循环变量不用时可以使用“_”代替
for … in … else
for i in [1, 2, 3, 4]: print(i) if i > 2: break else: print(5) for i in [1, 2, 3, 4]: print(i) if i > 2: break print(5)
for 循环嵌套
# 实现九九乘法表
for right in range(1, 10):
for left in range(1, right+1):
print(f"{left}x{right}={left*right}", end="t")
print()
range(stop) / range(start, stop[, step])
返回一个按步骤生成的从start(包括)到stop(不包括)的整数序列，它是不可变的序列
start：计数从 start 开始，默认是从 0 开始
stop：计数到 stop 结束，但不包括 stop
step：步长，默认为1
range 类型相比常规 list 或 tuple 的优势在于一个 range 对象总是占用固定数量的（较小）内存，不论其所表示的范围有多大（因为它只保存了 start, stop 和 step 值）
print(list(range(4))) # [0, 1, 2, 3] print(list(range(1, 5))) # [1, 2, 3, 4] print(list(range(1, 8, 2))) # [1, 3, 5, 7] print(list(range(8, 1, -2))) # [8, 6, 4, 2]
enumerate(iterable, start=0)
返回一个enumerate对象（迭代器）。迭代它会得到一个个的元组，每个元组是索引（从start开始，默认为 0）和索引对应iterable的值组成的
seasons = ['Spring', 'Summer', 'Fall', 'Winter'] object1 = enumerate(seasons) #9.3 循环控制语句print(list(object1)) # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] object2 = enumerate(seasons, start=1) # 设置开始迭代的索引 print(list(object2)) # [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
break
终止所在的循环
for i in range(3):
for j in range(3):
print("hello")
break # 只终止所在的循环, 所以输出3个 hello
continue
跳过当前，继续到循环位置
a = 0 while a <= 5: if a == 3: a += 1 continue print(a) a += 19.4 优化：石头剪刀布游戏
import random
INFO = {0: "石头", 1: "剪刀", 2: "布"} # ["石头", "剪 刀", "布"]
while True:
computer = random.randint(0, 2)
while True:
player = int(input("请出拳! 输入0代表石头、1代表剪 刀、2代表布: "))
# 判断输入是否有误
if player in [0, 1, 2]:
# 展示电脑和玩家的出拳结果
print(f"电脑出拳: {INFO[computer]}n玩家出拳: {INFO[player]}")
# 判断谁输谁赢
if computer == player:
print("平局!")
elif player-computer == -1 or player- computer == 2:
print("玩家胜利!")
else:
print("电脑胜利!")
break
print("输入有误, 输入0代表石头、1代表剪刀、2代表布")
# 判断输入是否有误
while True:
rec = input("是否继续游戏?(y/n): ")
if rec in ["y", "n", "Y", "N"]:
break
else:
print("输入有误, 请输入y或者n")
# 判断游戏是否要继续玩
if rec in ("n", "N"):
print("游戏结束!")
break
9.5 pass 语句
pass 是一个空操作, 当它被执行时, 什么都不发生。它适合当语法上需要一
条语句但并不需要执行任何代码时用来临时占位
num = int(input("请输入一个数字: "))
if num < 100:
pass
else:
pass
10. 推导式
10.1 列表推导式
结构由一对方括号里面包含一个表达式，后面跟一个 for 子句，然后是零个或多个 for 或 if 子句组成
其结果将是一个新列表，由表达式依据后面的 for 和 if 子句的内容进行求值计算而得出
squares = [] for x in range(10): squares.append(x**2) squares = [x**2 for x in range(10)] result = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y] result = [] for x in [1,2,3]: for y in [3,1,4]: if x != y: result.append((x, y))
嵌套的列表推导式
列表推导式中的初始表达式可以是任何表达式，包括另一个列表推导式
