【python】运算符及语句

目录

一 运算符

1 算数运算符

2 关系运算符

3 逻辑运算符

4 赋值运算符

(1) = 的使用

(2) 复合赋值运算符

5 其他

二 顺序语句

三 条件语句

1 定义

2 语法格式

四 缩进和代码块

五 空语句pass

六 循环语句

1 while循环

2 for循环

---

上一篇回顾链接：【【python]变量及简单数据类型 - CSDN App】https://blog.csdn.net/zzzsde/article/details/150925681?sharetype=blog&shareId=150925681&sharerefer=APP&sharesource=zzzsde&sharefrom=link

一 运算符

1 算数运算符

像 + - * / % ** // 这种进行算术运算的运算符, 称为 算术运算符 
 
注意1: / 中不能用 0 作为除数. 否则会 抛出异常

注意2: 整数 / 整数 结果可能是小数. 而不会截断

注意3: % 不是 "百分数", 而是求余数.

print(7 % 2)

运行结果为1

注意4: ** 是求乘方. 不光能算整数次方, 还能算小数次方.

print(4**2)
print(4**0.5)

运行结果为：

16
2.0

注意5: // 是取整除法(也叫地板除). 整数除以整数, 结果还是整数(舍弃小数部分, 并向下取整. 不是四舍五入)

print(7//2)
print(-7//2)

运行结果为

3
-4

2 关系运算符

像 < <= > >= == != 这一系列的运算符称为 关系运算符, 它们是在比较操作数之间的关系. 
其中
<= 是 "小于等于"
>= 是 "大于等于"
== 是 "等于"
!= 是 "不等于"

(1) 如果关系符合, 则表达式返回 True. 如果关系不符合, 则表达式返回 False

a = 10
b = 20print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)

运行结果为：

True
True
False
False
False
True

(2) 关系运算符不光针对整数/浮点数进行比较, 还能针对字符串进行比较.

a = 'hello'
b = 'world'print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)

运行结果为：

True
True
False
False
True

注意: 
直接使用 == 或者 != 即可对字符串内容判定相等. (这一点和 C / Java 不同). 
字符串比较大小, 规则是 "字典序"

关于字典序:
想象一个英文词典, 上面的单词都是按照字母顺序排列. 如果首个字母相同, 就比较第二个字母. (就
比如著名单词 abandon). 
我们认为一个单词在词典上越靠前, 就越小. 越靠后, 就越大.

(3) 对于浮点数来说, 不要使用 == 判定相等

print(0.1 + 0.2 == 0.3)

运行结果为：

False

注意: 浮点数在计算机中的表示并不是精确的! 在计算过程中, 就容易出现非常小的误差.

print(0.1)
print(0.2)
print(0.3)
print(0.1 + 0.2)

运行结果为：

0.1
0.2
0.3
0.300000000004

可以看到, 0.1 + 0.2 的结果并非是 0.3 , 而是带了个小尾巴. 虽然这个尾巴非常小了, 但是 == 是锱铢
必较的, 仍然会导致 == 的结果为 False.

正确的比较方式: 不再严格比较相等了, 而是判定差值小于允许的误差范围.

a = 0.1 + 0.2
b = 0.3
print(-0.000001 < (a - b) < 0.000001)

3 逻辑运算符

像 and or not 这一系列的运算符称为 逻辑运算符. 

and 并且. 两侧操作数均为 True, 最终结果为 True. 否则为 False. (一假则假)
or 或者. 两侧操作数均为 False, 最终结果为 False. 否则为 True. (一真则真)
not 逻辑取反. 操作数本身为 True, 则返回 False. 本身为 False, 则返回 True.

a = 10
b = 20
c = 30print(a < b and b < c)
print(a < b and b > c)
print(a > b or b > c)
print(a < b or b > c)
print(not a < b)
print(not a > b)

运行结果为：
 

True
False
False
True
False
True

一种特殊写法
a < b and b < c 这个操作等价于 a < b < c . 这个设定和大部分编程语言都不相同.

关于短路求值
和其他编程语言类似, Python 也存在短路求值的规则. 
对于 and, 如果左侧表达式为 False, 则整体一定为 False, 右侧表达式不再执行. 
对于 or, 如果左侧表达式为 True, 则整体一定为 True, 右侧表达式不再执行.

print(10 > 20 and 10 / 0 == 1)
print(10 < 20 or 10 / 0 == 1)

运行结果为：

False
True

上述代码没有抛出异常, 说明右侧的除以 0 操作没有真正执行.

4 赋值运算符

(1) = 的使用

= 表示赋值. 这个我们已经用过很多次了. 注意和 == 区分. 
= 除了基本的用法之外, 还可以同时针对多个变量进行赋值.

链式赋值

a=b=10

多元赋值

a, b=10,20

例：交换两个变量

基础写法

a = 10
b = 20tmp = a
a = b
b = tmp

基于多元赋值

a = 10
b = 20
a, b = b, a

(2) 复合赋值运算符

Python 还有一些 复合赋值运算符. 例如 += -= *= /= %= 
其中 a += 1 等价于 a = a + 1 . 其他复合赋值运算符也是同理.

a = 10
a = a + 1print(a)
b = 10
b += 1
print(b)

注意: 像 C++ / Java 中, 存在 ++ -- 这样的自增/自减运算符. Python 中则不支持这种运算. 如果需要使用, 则直接使用 += 1 或者 -= 1
++ -- 最大的问题就是容易分不清前置和后置的区别. 这一点 Python 语法在设计的时候就进行了规避, 避免出现这种不直观, 并且容易混淆的语法.

5 其他

除了上述之外, Python 中还有一些运算符, 比如 身份运算符 (is, is not), 成员运算符 (in, not in), 位运算符 ( & | ~ ^ << >>) 等. 
此处咱们暂时不介绍.

二 顺序语句

默认情况下, Python 的代码执行顺序是按照从上到下的顺序, 依次执行的.

print("1")
print("2")
print("3")

执行结果一定为 "123", 而不会出现 "321" 或者 "132" 等. 这种按照顺序执行的代码, 我们称为 顺序语句.

三 条件语句

1 定义

条件语句能够表达 "如果 ... 否则 ..." 这样的语义. 这构成了计算机中基础的 逻辑判定. 
条件语句 也叫做 分支语句, 表示了接下来的逻辑可能有几种走向.

如果 我认真敲代码
   我就很容易找到工作
否则
   我就容易毕业就失业

其中 "我认真敲代码" 称为 条件. 如果条件成立(条件为真), 则会出现 "我就很容易找到工作" 这个情况. 如果条件不成立(条件为假), 则会出现 "我就容易毕业就失业

2 语法格式

Python 中使用 if else 关键字表示条件语句.

（1）if

if expression:do_something1do_something2
next_something

如果 expression 值为 True, 则执行 do_something1, do_something2, next_something
如果 expression 值为 False, 则只执行 next_something, 不执行 do_something1, do_something2

（2） if-else

if expression:do_something1
else:do_something2

如果 expression 值为 True, 则执行 do_something1
如果 expression 值为 False, 则执行 do_something2

(3)if - elif - else

if expression1:do_something1
elif expression2:do_something2
else:do_something3

如果 expression1 值为 False, 并且 expression2 为 True 则执行 do_something2
如果 expression1 值为 False, 并且 expression2 为 False 则执行 do_something3

如果 expression1 值为 True, 则执行 do_something1

注意: Python中的条件语句写法, 和很多编程语言不太一样. 
if 后面的条件表达式, 没有 ( ), 使用 : 作为结尾. 
if / else 命中条件后要执行的 "语句块", 使用 缩进 (通常是 4 个空格或者 1 个 tab)来表示, 而不是 { }
对于多条件分支, 不是写作 else if, 而是 elif (合体了).

四 缩进和代码块

代码块 指的是一组放在一起执行的代码. 
在 Python 中使用缩进表示代码块. 不同级别的缩进, 程序的执行效果是不同的.

# 代码1
a = input("请输入一个整数: ")
if a == "1":print("hello")print("world")

# 代码2
a = input("请输入一个整数: ")
if a == "1":print("hello")
print("world")

注意上述代码的区别. 
在代码1 中, print("world") 有一级缩进, 这个语句属于 if 内的代码块, 意味着条件成立, 才执行, 条件
不成立, 则不执行. 
在代码2 中, print("world") 没有缩进, 这个语句是 if 外部的代码, 不属于 if 内部的代码块. 意味着条件
无论是否成立, 都会执行.

代码块内部还可以嵌套代码块.

a = input("请输入第一个整数: ")
b = input("请输入第二个整数: ")
if a == "1":if b == "2":print("hello")print("world")
print("python")

在这个代码中, 
print("hello") 具有两级缩进, 属于 if b == "2" 条件成立的代码块. 
print("world") 具有一级缩进, 属于 if a == "1" 条件成立的代码块. 
print("python") 没有缩进, 无论上述两个条件是否成立, 该语句都会执行.

基于缩进的方式表示代码块, 带来的好处就是强制要求程序猿要写明确的缩进, 来明确代码之间的相对关系. 如果缩进书写的不对, 则直接报错.像 C++ / Java 这些语言, 即使完全不写缩进, 语法也不会报错. 代码可读性就比较差.

同时, 带来的坏处就是, 如果缩进层次比较多, 就容易分不清楚某个语句属于哪个层级.

if a == 1:if b == 2:if c == 3:if d == 4:if e == 5:if f == 6:if g == 7:print("hello")print("1")print("2")

请问, 上述代码中的 print("1") 和 print("2") 属于哪一级缩进?

1. print("1")
   它与 if g == 7: 处于同一缩进级别。
   因为它的缩进量和 if g == 7: 相同，且位于该 if 语句的下方（属于该 if 语句的同级代码，在 if g == 7: 条件判断之后执行）。

2. print("2")
   它与 if c == 3: 处于同一缩进级别。
   因为它的缩进量和 if c == 3

因此, 就有了 "写 Python 需要自备游标卡尺" 这个梗.

五 空语句pass

代码示例：输入一个数字，如果数字为1，则打印hello

​
​a = int(input{"请输入一个整数：“））
if a==1:print("hello")​​

这个代码也可以等价写成

​
a = int(input("请输入一个整数：”））
if a！=1:pass
elseprint("hello")​

其中 pass 表示 空语句, 并不会对程序的执行有任何影响, 只是占个位置, 保持 Python 语法格式符合要求.

如果代码写作

a = int(input("请输入一个整数:"))
if a != 1:
else:print("hello")

程序是不符合 Python 语法的, 会直接报错.

六 循环语句

有些操作是需要反复执行的. 这种就需要使用循环.

1 while循环

基本语法格式：

while 条件:循环体

条件为真，则执行循环体代码。条件为假，则结束循环

示例：打印1-10的整数

num = 1
while num<= 10:print(num)num+=1

示例：计算1-100的和

sum = 0
num = 1
while num<=100:sum += numnum +=1
print(sum)

示例：计算5的阶乘

result = 1
n = 1
while n<=5:result*=nn+=1
print(result)

代码示例:求1!+2!+3! + 4! + 5!

num = 1
sum = 0
while num <= 5:factorResult = 1i = 1while i <= num:factorResult*=ii+=1sum += factorResultnum += 1
print(sum)

这个程序用到了两重循环. 
也就是在循环语句中也可以套循环.

2 for循环

基本语法格式

for 循环变量 in 可迭代对象:循环体

注意:
  python 的 for 和其他语言不同, 没有 "初始化语句", "循环条件判定语句", "循环变量更新语句", 而是更加简单
  所谓的 "可迭代对象", 指的是 "内部包含多个元素, 能一个一个把元素取出来的特殊变量"

示例：打印1-10

for i in range(1,11):print(i)

使用 range 函数, 能够生成一个可迭代对象. 生成的范围是 [1, 11), 也就是 [1, 10]

range函数：

在 Python 中，range() 是一个内置函数，用于生成一个整数序列，通常在循环（如 for 循环）中使用。它的语法有以下几种形式：

1. range(stop)
   生成从 0 开始，到 stop-1 结束的整数序列（不包含 stop 本身）。

for i in range(5):print(i)  # 输出：0, 1, 2, 3, 4

2 range(start, stop)
生成从 start 开始，到 stop-1 结束的整数序列。

for i in range(2, 7):print(i)  # 输出：2, 3, 4, 5, 6

3 range(start, stop, step)
生成从 start 开始，到 stop-1 结束，且步长为 step 的整数序列（step 不能为 0）。

for i in range(1, 10, 2):print(i)  # 输出：1, 3, 5, 7, 9（步长为 2，即每次加 2）

重要特性：

• range() 生成的序列是惰性计算的，即它不会立即生成所有元素，而是在需要时才计算，因此占用内存少，效率高。
• 若要查看 range 对象的所有元素，可以用 list() 转换：

​print(list(range(3, 10, 2)))  # 输出：[3, 5, 7, 9]

step 可以为负数，实现反向序列（此时需保证 start > stop）：

for i in range(5, 0, -1):print(i)  # 输出：5, 4, 3, 2, 1

示例：求1-100的和

sum 0
for i in range(1,101):sum += i
print(sum)

3  continue

continue 表示结束这次循环, 进入下次循环. 
 
代码示例: 模拟吃包子. 吃第 3 个包子的时候吃出了一只虫.

for i in range(1, 6):if i == 3:continueprint(f"吃完第 {i} 个包子")

运行结果为：

吃完第 1 个包子
吃完第 2 个包子
吃完第 4 个包子
吃完第 5 个包子

4 break

break 表示结束整个循环  

代码示例: 模拟吃包子. 吃第 3 个包子的时候吃出了半只虫.

for i in range(1, 6):if i == 3:breakprint(f"吃完第 {i} 个包子")

运行结果为：

吃完第 1 个包子
吃完第 2 个包子

代码示例: 输入若干个数字, 求平均值. 使用 "分号" 作为结尾.

sum = 0
count = 0
while True:num = input("请输入数字:")if num == ';':breaknum = float(num)sum += numcount += 1
print(sum / count)