第一章、运算符
一、概述
在 Python 中,运算符是用于进行各种操作的符号或关键字。Python 支持多种类型的运算符,包括算术运算符、比较运算符、逻辑运算符、位运算符、赋值运算符等。
下面对常用的运算符进行详细介绍:
二、算术运算符:用于进行基本的数学运算。
都是二元运算符
注意:一个表达式当中有多个运算符,运算符有优先级,不确定的加小括号,优先级得到提升,没有必要去专门记忆运算符的优先级
1、+:对应__add__()方法
+
:加法运算,如a + b
。只有int,float,complex,bool,str,tuple,list 这7中类型有__add__方法,可以使用+运算符
my_int1: int = 1
my_int2: int = 2
print(my_int1 + my_int2) # 3
print(my_int1.__add__(my_int2)) # 3
my_float1: float = 1.2
my_float2: float = 3.4
print(my_float1 + my_float2) # 4.6
print(my_float1.__add__(my_float2)) # 4.6
my_complex1: complex = 1 + 2j
my_complex2: complex = 3 + 4j
print(my_complex1 + my_complex2) # (4+6j)
print(my_complex1.__add__(my_complex2)) # (4+6j)
my_bool1: bool = True
my_bool2: bool = True
print(my_bool1 + my_bool2) # 2
print(my_bool1.__add__(my_bool2)) # 2
my_str1: str = "jzq"
my_str2: str = "666"
print(my_str1 + my_str2) # jzq666
print(my_str1.__add__(my_str2)) # jzq666
my_tuple1: tuple[int, ...] = (1, 2)
my_tuple2: tuple[int, ...] = (3, 4)
print(my_tuple1 + my_tuple2) # (1, 2, 3, 4)
print(my_tuple1.__add__(my_tuple2)) # (1, 2, 3, 4)
my_list1: list[int] = [1, 2]
my_list2: list[int] = [3, 4]
print(my_list1 + my_list2) # [1, 2, 3, 4]
print(my_list1.__add__(my_list2)) # [1, 2, 3, 4]
2、-:对应__sub__()方法
-
:减法运算,如a - b
。只有int,float,complex,bool,set 这5种类型有__sub__方法,可以使用-运算符
my_int1: int = 1
my_int2: int = 2
print(my_int1 - my_int2) # -1
print(my_int1.__sub__(my_int2)) # -1
my_float1: float = 1.2
my_float2: float = 3.4
print(my_float1 - my_float2) # -2.2
print(my_float1.__sub__(my_float2)) # -2.2
my_complex1: complex = 1 + 2j
my_complex2: complex = 3 + 4j
print(my_complex1 - my_complex2) # (-2-2j)
print(my_complex1.__sub__(my_complex2)) # (-2-2j)
my_bool1: bool = True
my_bool2: bool = False
print(my_bool1 - my_bool2) # 1
print(my_bool1.__sub__(my_bool2)) # 1
my_set1: Set[int] = {1, 2, 3}
my_set2: Set[int] = {3, 4, 5}
print(my_set1 - my_set2) # {1, 2}
print(my_set1.__sub__(my_set2)) # {1, 2}
print(my_set2 - my_set1) # {4, 5}
print(my_set2.__sub__(my_set1)) # {4, 5}
# print([1, 2] - [2, 3]) # TypeError: unsupported operand type(s) for -: 'list' and 'list'
3、*:对应__mul__()方法
*
:乘法运算,如a * b
。只有int,float,complex,bool,str,tuple,list 这7中类型有__mul__方法,可以使用*运算符
my_int1: int = 1
my_int2: int = 2
print(my_int1 * my_int2) # 2
print(my_int1.__mul__(my_int2)) # 2
my_float1: float = 1.2
my_float2: float = 3.4
print(my_float1 * my_float2) # 4.08
print(my_float1.__mul__(my_float2)) # 4.08
my_complex1: complex = 1 + 2j
my_complex2: complex = 3 + 4j
print(my_complex1 * my_complex2) # (-5+10j)
print(my_complex1.__mul__(my_complex2)) # (-5+10j)
my_bool1: bool = True
my_bool2: bool = True
print(my_bool1 * my_bool2) # 1
print(my_bool1.__mul__(my_bool2)) # 1
my_str1: str = "jzq"
my_str2: str = "666"
# print(my_str1 * my_str2) # TypeError: can't multiply sequence by non-int of type 'str'
print(my_str1 * 2) # jzqjzq
print(my_str1.__mul__(2)) # jzqjzq
my_tuple1: Tuple[int, ...] = (1, 2)
my_tuple2: Tuple[int, ...] = (3, 4)
# print(my_tuple1 * my_tuple2) # TypeError: can't multiply sequence by non-int of type 'tuple'
print(my_tuple1.__mul__(2)) # (1, 2, 1, 2)
print(my_tuple2 * 2) # (3, 4, 3, 4)
my_list1: List[int] = [1, 2]
my_list2: List[int] = [3, 4]
# print(my_list1 * my_list2) # TypeError: can't multiply sequence by non-int of type 'list'
print(my_list1.__mul__(2)) # [1, 2, 1, 2]
print(my_list2 * 2) # [3, 4, 3, 4]
4、/:对应__truediv__()方法
/
:真除除法运算,如a / b,得到浮点数结果
。只有int,float,complex,bool 这4中类型有__truediv__方法,可以使用 / 运算符
my_int1: int = 10
my_int2: int = 4
print(my_int1 / my_int2) # 2.5
print(my_int1.__truediv__(my_int2)) # 2.5
my_float1: float = 1.2
my_float2: float = 0.5
print(my_float1 / my_float2) # 2.4
print(my_float1.__truediv__(my_float2)) # 2.4
my_complex1: complex = 1 + 2j
my_complex2: complex = 3 + 4j
print(my_complex1 / my_complex2) # (0.44+0.08j)
print(my_complex1.__truediv__(my_complex2)) # (0.44+0.08j)
my_bool1: bool = True
my_bool2: bool = True
print(my_bool1 / my_bool2) # 1.0
print(my_bool1.__truediv__(my_bool2)) # 1.0
5、%:对应__mod__()方法
%
:取模运算,返回除法的余数,如a % b
。只有int,float,bool 这3种类型有__mod__方法,可以使用 % 运算符
my_int1: int = 1
my_int2: int = 2
print(my_int1 % my_int2) # 1
print(my_int1.__mod__(my_int2)) # 1
my_float1: float = 3.6
my_float2: float = 1.5
print(my_float1 % my_float2) # 0.6
print(my_float1.__mod__(my_float2)) # 0.6
my_bool1: bool = True
my_bool2: bool = True
print(my_bool1 % my_bool2) # 0
print(my_bool1.__mod__(my_bool2)) # 0
6、**:对应__pow__()方法
**
:幂运算,如a ** b
,表示 a 的 b 次方。只有int,float,complex,bool 这4种类型有__pow__方法,可以使用 ** 运算符
my_int1: int = 2
my_int2: int = 3
print(my_int1 ** my_int2) # 8
print(my_int1.__pow__(my_int2)) # 8
my_float1: float = 2.0
my_float2: float = 2.0
print(my_float1 ** my_float2) # 4.0
print(my_float1.__pow__(my_float2)) # 4.0
my_complex1: complex = 1 + 2j
my_complex2: complex = 3 + 4j
print(my_complex1 ** my_complex2) # (0.12900959407446697+0.03392409290517014j)
print(my_complex1.__pow__(my_complex2)) # (0.12900959407446697+0.03392409290517014j)
my_bool1: bool = True
my_bool2: bool = True
print(my_bool1 ** my_bool2) # 1
print(my_bool1.__pow__(my_bool2)) # 1
7、//:对应__floordiv__()方法
//
:取整除法运算,返回除法的商的整数部分,如a // b
。只有int,float,bool 这3中类型有__floordiv__方法,可以使用 // 运算符
my_int1: int = 10
my_int2: int = 4
print(my_int1 // my_int2) # 2
print(my_int1.__floordiv__(my_int2)) # 2
my_float1: float = 1.6
my_float2: float = 0.5
print(my_float1 // my_float2) # 3.0
print(my_float1.__floordiv__(my_float2)) # 3.0
my_bool1: bool = True
my_bool2: bool = True
print(my_bool1 // my_bool2) # 1
print(my_bool1.__floordiv__(my_bool2)) # 1
a = 10
b = 3
print(a + b) #13
print(a - b) # 7
print(a * b) #30
print(a / b) #3.3333333333333335
print(a % b) #1
print(a // b) #3
print(a ** b) #1000
三、比较运算符:用于比较两个值是否相等或大小关系。
==
:等于,如a == b
。- 三个连续为链式比较中,True==False==False 等价于 (True==False) and (False==False)
- 是对于值的比较,而非内存地址,底层调用__eq__()方法
!=
:不等于,如a != b
。- 不能连续三个比较
>
:大于,如a > b
。<
:小于,如a < b
。>=
:大于等于,如a >= b
。<=
:小于等于,如a <= b
。
二元运算符
关系运算符的运算结果一定是boolean类型:True/False
比较运算符的运算原理:
int a = 10; 10为字面值,字面值自动装箱为int类型对象,返回对象的引用赋值给a
int b = 10; 10为字面值,字面值自动装箱为int类型对象,返回对象的引用赋值给b
a和b都是变量,指向字面值为10的int对象,也有内存地址(堆内存)
Python中对象都重写了类似于java中的equals方法,因此比较的是对象的值,而非内存地址,因此a>b 比较的是a指向对象中保存的10这个值和b指向对象中保存的10这个值之间的大小比较,和内存地址无关,a==b 也是如此。
a = 10
b = 10
print(a == b) #True
print(a != b) #False
print(a > b) #False
print(a < b) #False
print(a >= b) #True
print(a <= b) #True
四、逻辑运算符:用于进行逻辑运算。
and和or是 二元运算符,not是一元运算符
1、and和or 要求两边的算子都是bool类型或者可以转换为bool类型的数据类型,并且and和or最终的运算结果也是一个bool类型或者可以转换为bool类型的数据类型
2、not要求 算子都是bool类型或者可以转换为bool类型的数据类型,并且not最终的运算结果一定是个bool类型(True或False)
and
:逻辑与(短路与),如果所有操作数都为 True,则结果为 True,否则为 False。- 两个值中只要有一个值为false,就返回false,只有两个值都为true时,才会返回true
- 如果第一个值为false,则不会检查第二个值
- 非布尔值时:如果两个都为true,则返回第二个值,如果两个值中有false,则返回靠前的false的值
- 第一个表达式执行结果为false,会发生短路与
#测试短路与
#两边算子都是False
print(None and 0) #None
#左边算子是False,右边为True
print(False and True) #False
#左边算子是True,右边为False
print("jzq" and {}) #{}
#两边算子都是True
print(True and "888") #888
or
:逻辑或(短路或),如果任一操作数为 True,则结果为 True,否则为 False。- 两个值中只要有一个true,就返回true,只有两个值都为false,才会返回false
- 短路的或,如果第一个值为true,则不会检查第二个值
- 非布尔值时:如果两个都为false ,则返回第二个值,如果两个值中有true,则返回靠前的true的值
- 第一个表达式执行结果为true,会发生短路或
#测试短路或
#两边算子都False
print(None or 0) #0
#左边算子是False,右边为True
print(False or True) #True
#左边算子是True,右边为False
print("jzq" or {}) #jzq
#两边算子都是True
print(True or "888") #True
not
:逻辑非,用于取反操作,如果操作数为 True,则结果为 False,反之亦然。- 取反,not false就是true,not true就是false,这是一个单目运算符
#测试not非
print(not 1) #False
print(not ()) #True
Python 中也存在类似于 Java 中的短路与(Short-circuit AND)和短路或(Short-circuit OR)的概念。
短路与(Short-circuit AND): 在 Python 中,短路与用 and
表示。当使用 and
运算符连接多个条件时,如果其中一个条件为 False,则后面的条件不会再进行求值,整个表达式的结果为 False。只有当所有条件都为 True 时,整个表达式的结果才为 True。
例如:
a = 5
b = 10
c = 0
if a > 0 and b > 0 and c > 0:
print("All conditions are True")
else:
print("At least one condition is False") # 输出:"At least one condition is False"
在上面的例子中,由于 c
的值为 0,第三个条件为 False,因此后面的条件不再求值,整个表达式的结果为 False。
短路或(Short-circuit OR): 在 Python 中,短路或用 or
表示。当使用 or
运算符连接多个条件时,如果其中一个条件为 True,则后面的条件不会再进行求值,整个表达式的结果为 True。只有当所有条件都为 False 时,整个表达式的结果才为 False。
例如:
a = 5
b = 10
c = 0
if a > 0 or b > 0 or c > 0:
print("At least one condition is True") # 输出:"At least one condition is True"
else:
print("All conditions are False")
在上面的例子中,由于 a
的值为 5,第一个条件为 True,因此后面的条件不再求值,整个表达式的结果为 True。
短路与和短路或在 Python 中的使用和 Java 中类似,可以有效地简化条件判断和逻辑处理。
五、位运算符:用于对二进制数进行位级操作。
&
:按位与,将两个数的二进制表示按位进行与操作。|
:按位或,将两个数的二进制表示按位进行或操作。^
:按位异或,将两个数的二进制表示按位进行异或操作。~
:按位取反,对一个数的二进制表示按位进行取反操作。<<
:左移,将一个数的二进制表示向左移动指定的位数。>>
:右移,将一个数的二进制表示向右移动指定的位数。
二进制位的运算
比如:如何将2快速变成8
2的二进制位为:10
8的二进制位为:1000
只需要将2的二进制位的1向左移动2位即可
右移运算符:原数据 >> n // n为移动位数
左移运算符:原数据 << n // n为移动位数
右移运算:即原数据除以 (2 * n)
左移运算:即原数据乘以 (2 * n)
#测试位运算符
"""
>> 1 二进制右移一位
10的二进制位:00001010 【10】
10的二进制右移一位是:00000101 【5】
"""
print(10 >> 1) #5 右移一位就是除以2
print(20 >> 2) #5 右移两位就是除以4
print(10 >> 2) #2 右移两位就是除以4
"""
<< 1 二进制左移一位
10的二进制位:00001010 【10】
10的二进制左移一位是:00010100 【20】
"""
print(10 << 1) #20 左移一位就是乘2
print(10 << 2) #40 左移一位就是乘4
六、赋值运算符:用于给变量赋值。
赋值类的运算符优先级:先执行等号右边的表达式,将执行结果赋值给左边的变量
=
:简单赋值,将右边的值赋给左边的变量。+=
、-=
、*=
、/=
、%=
、**=
、//=
:复合赋值,将右边的值和左边的变量进行相应的运算后再赋值。
a = 10
print(10) #10
a = a + 5
print(a) #15
#扩展的赋值运算符
a += 5 #运行结果等同于:a = a + 5
print(a) #20
a -= 5 #运行结果等同于:a = a - 5
print(a) #15
a *= 2 #运行结果等同于:a = a * 2
print(a) #30
a /= 4 #运行结果等同于:a = a / 4
print(a) #7.5
a //= 2 #运行结果等同于:a = a // 2
print(a) #3.0
a %= 2 #运行结果等同于:a = a % 2
print(a) #1.0
在Python中,没有像C++或其他编程语言中那样的自增(++)和自减(--)运算符。在Python中,自增和自减操作可以通过常规的加法(+)和减法(-)运算符完成。
自增示例:
# 通过加法运算符实现自增
x = 5
x = x + 1
print(x) # 输出: 6
自减示例:
# 通过减法运算符实现自减
y = 10
y = y - 1
print(y) # 输出: 9
虽然Python没有直接的自增和自减运算符,但它支持增量赋值运算符,比如+=
和-=
,可以在一条语句中实现自增和自减操作。
自增(增量赋值运算符)示例:
# 使用增量赋值运算符实现自增
x = 5
x += 1
print(x) # 输出: 6
自减(增量赋值运算符)示例:
# 使用增量赋值运算符实现自减
y = 10
y -= 1
print(y) # 输出: 9
所以,虽然Python没有独立的自增和自减运算符,但通过使用适当的加法和减法运算符,或者增量赋值运算符,你可以完成类似的操作。
1、简单赋值和复合赋值的区别
简单赋值方式:凡是c=c+a等都会改变内存地址
复合赋值方式:c+=a赋值方式,如果是可变对象,则不会改变内存地址,如果是不可变对象,则会改变内存地址
#简单赋值方式
#不可变对象,不可变数据类型
str1 = "jzq"
print(id(str1))
str2 = "666"
print(id(str2))
str1 = str1 + str2
print(id(str1))
print(str1)
"""
1308387556272
1308387556400
1308387887792
jzq666
"""
#可变对象,可变数据类型
list1 = [1,2]
print(id(list1))
list2 = [3,4]
print(id(list2))
list1 = list1 + list2
print(id(list1))
print(list1)
"""
2193636512256
2193636748160
2193637046976
[1, 2, 3, 4]
"""
#复合赋值方式
#不可变对象,不可变数据类型
tuple1 = (1,2)
print(id(tuple1))
tuple2 = (3,4)
print(id(tuple2))
tuple1 += tuple2
print(id(tuple1))
print(tuple1)
"""
2384251807040
2384251835328
2384252113424
(1, 2, 3, 4)
"""
#可变对象,可变数据类型
list3 = [5,6]
print(id(list3))
list4 = [7,8]
print(id(list4))
list3 += list4
print(id(list3))
print(list3)
"""
1513777755008
1513778051712
1513777755008
[5, 6, 7, 8]
"""
七、字符串连接运算符
关于Python中的“+”运算符
1、“+”运算符在Python中有两个作用
加法运算,求和
字符串的连接运算
2、当“+”运算符两边的数据都是数字的话,一定是进行加法运算
3、当“+”运算符两边的数据只要有一个数据是字符串,一定会进行字符串连接运算,并且,连接运算之后的结果返回一个字符串类型
数字 + 数字 ---> 数字(求和)
str(数字) + 字符串 ---> 字符串 (字符串连接)
4、在一个表达式中可以出现多个加号,在没有添加小括号的前提下,遵循自左向右的顺序依次运算
在 Python 中,字符串连接可以通过加号 +
运算符来实现。当你用加号 +
来连接两个字符串时,它们会被合并成一个新的字符串。
例如:
str1 = "Hello"
str2 = " World"
result = str1 + str2
print(result) # 输出 "Hello World"
print(str1,str2,sep="") # 输出 "Hello World"
你还可以将多个字符串连续使用 +
运算符连接在一起:
str1 = "Hello"
str2 = ", "
str3 = "World"
result = str1 + str2 + str3
print(result) # 输出 "Hello, World"
print(str1,str3,sep=", ") # 输出 "Hello, World"
需要注意的是,字符串连接只能用于连接字符串类型的对象。如果你尝试将其他数据类型与字符串进行连接,将会引发错误。在连接非字符串类型时,你需要先将其转换为字符串,例如通过 str()
函数。
num = 42
result = "The answer is: " + str(num)
print(result) # 输出 "The answer is: 42"
此外,Python 还支持使用 +=
运算符来实现原地修改字符串的连接。这意味着你可以在原有字符串的基础上继续追加内容
str1 = "Hello"
str2 = " World"
str1 += str2
print(str1) # 输出 "Hello World"
八、三元运算符/三目运算符/条件运算符
Python 中的三元运算符是一种简洁的条件表达式,它允许你在一行中根据条件选择不同的值。三元运算符的语法如下:
语法: 表达式1 if 布尔表达式 else 表达式2
执行原理:
当布尔表达式的结果true的时候,选择表达式1作为整个表达式的执行结果,并返回
当布尔表达式的结果false的时候,选择表达式2作为整个表达式的执行结果,并返回
例如,假设我们要根据一个数值变量 x
的正负来选择不同的输出:
x = 10
result = "Positive" if x > 0 else "Non-positive"
print(result) # 输出 "Positive"
在这个例子中,如果 x > 0
条件为真,则返回字符串 "Positive";否则,返回字符串 "Non-positive"。
你也可以在输出中使用表达式而不仅仅是简单的字符串:
x = 5
result = "Even" if x % 2 == 0 else "Odd"
print(result) # 输出 "Odd"
在这个例子中,如果 x
是偶数,则返回 "Even",否则返回 "Odd"。
三元运算符可以在一些简单的条件判断场景中提供简洁的解决方案,但在复杂的情况下,使用常规的 if...else
语句可能更易于阅读和理解。
九、成员运算符
在 Python 中,成员运算符用于检查一个值是否属于一个集合或容器(例如列表、元组、字符串、字典等)。Python 中的成员运算符有两个:in
和 not in
。
序列可为 字符串,列表,字典(key),元祖,集合
-
in
:用于检查一个值是否存在于一个容器中。如果值存在于容器中,返回True
;否则返回False
。 -
not in
:用于检查一个值是否不存在于一个容器中。如果值不存在于容器中,返回True
;否则返回False
。
下面是成员运算符的使用示例:
# 使用 in 运算符
numbers = [1, 2, 3, 4, 5]
if 3 in numbers:
print("3 is in the list.") # 输出:3 is in the list.
# 使用 not in 运算符
fruits = ['apple', 'banana', 'orange']
if 'kiwi' not in fruits:
print("Kiwi is not in the list.") # 输出:Kiwi is not in the list.
# 字符串中的成员运算符
text = "Hello, World!"
if 'o' in text:
print("'o' is present in the string.") # 输出:'o' is present in the string.
# 字典中的成员运算符
person = {'name': 'John', 'age': 30, 'city': 'New York'}
if 'age' in person:
print("Age is a key in the dictionary.") # 输出:Age is a key in the dictionary.
成员运算符是 Python 中用于检查元素是否存在于容器中的重要工具,可以帮助我们在处理集合数据时进行快速而方便的检查和操作。
十、身份运算符(主要针对可变对象比较内存地址)
现在优化了:
Python中对于不可变对象,相同的值在堆内存中只创建一份;对于可变对象,相同的值在堆内存中创建多份
在 Python 中,身份运算符用于比较对象的身份(内存地址),而不是比较它们的值。Python 中的身份运算符包括:
is
: 用于检查两个对象是否指向同一个内存地址。如果两个对象具有相同的身份,则返回True
,否则返回False
。is not
: 用于检查两个对象是否指向不同的内存地址。如果两个对象具有不同的身份,则返回True
,否则返回False
。
示例:
a = [1, 2, 3]
b = a # b指向a所指向的内存地址
print(a is b) # True,a和b指向同一个内存地址
print(a is not b) # False,a和b指向同一个内存地址
c = [1, 2, 3]
print(a is c) # False,a和c指向不同的内存地址
print(a is not c) # True,a和c指向不同的内存地址
身份运算符对于比较可变对象的时候很有用,可以判断两个变量是否指向同一个可变对象。需要注意的是,对于不可变对象(例如整数、字符串等),身份运算符的行为可能是不符合预期的,因为 Python 会对一些不可变对象进行内存优化,使得相同的不可变对象在内存中只有一个实例。因此,对于不可变对象,最好使用比较运算符(==
、!=
)来比较它们的值。
对于不可变对象,Python 中的 is
运算符用于比较对象的身份标识,即是否是同一个对象,而不是比较对象的值。不可变对象的值可能相同,但它们仍然可以是不同的对象,具有不同的身份标识。
因此,尽管不可变对象的值相同,它们在内存中仍然可以有不同的实例。is
运算符检查两个对象是否是同一个内存地址的引用,而不考虑对象的值。
以下是一个示例来说明这一点:
a = "hello"
b = "hello"
c = "world"
print(a is b) # 输出: True,a 和 b 引用同一个字符串对象
print(a is c) # 输出: False,a 和 c 引用不同的字符串对象
在这个示例中,虽然 a
和 b
的值相同,但它们是两个不同的字符串对象,因此 a is b
返回 True
。而 a
和 c
是不同的字符串对象,因此 a is c
返回 False
。
如果你想比较不可变对象的值是否相等,应该使用 ==
运算符,而不是 is
运算符。==
运算符会比较对象的值,而不关心它们的身份标识。
a = "hello"
b = "hello"
print(a == b) # 输出: True,a 和 b 的值相等
总之,is
运算符用于比较对象的身份标识,而对于不可变对象,即使值相同,它们仍然可以是不同的对象,因此 is
运算符可能返回 False
。如果想比较不可变对象的值是否相等,应该使用 ==
运算符。
十一、运算符优先级
优先级不确定直接加括号提升优先级,不用记
在 Python 中,运算符的优先级是指在一个表达式中,哪些运算符会先执行,哪些会后执行。当表达式中包含多个运算符时,Python 根据运算符的优先级来确定执行的顺序。如果运算符具有相同的优先级,那么它们的执行顺序将根据结合性来决定。
以下是 Python 中常见的运算符优先级(从高到低排列):
- 括号:
()
- 幂运算:
**
- 乘法、除法、取模运算:
*
、/
、%
- 加法、减法:
+
、-
- 位运算:
<<
、>>
、&
、|
、^
- 比较运算:
<
、<=
、>
、>=
、==
、!=
- 成员运算符:
in
、not in
- 身份运算符:
is
、is not
- 逻辑运算符:
not
、and
、or
优先级:()>not>and>or
需要注意的是,Python 中的优先级规则和数学中的运算优先级类似,但有一些特殊情况需要注意。如果在复杂的表达式中使用多个运算符,建议使用括号来明确优先级,以免出现意料之外的结果。
第十章、控制语句
所有的控制语句都是可以嵌套使用的,只要合理嵌套就行,嵌套使用的时候,代码格式要保证完美,该缩进的时候必须缩进
一、条件语句
关于Python中的if语句,属于选择结构,if语句又称为分支语句/条件控制语句
- if语句中只要有一个分支执行,整个if语句全部结束(if语句最多只有一个分支会执行)
- if语句的分支中只有一条Python语句的话,大括号可以省略不写
- 只要带有else,至少会保证一条分支会执行
1、if单分支
语法:
If 表达式:
缩进代码
如果只有一条Python语句
if bool表达式:
一条Python语句
等同于:
if bool表达式:一条Python语句
if True:
print("一条Python语句")
if True: print("888")
2、if else 双分支
If 表达式:
缩进代码
else:
缩进代码
if和else平级,else配离它最近的平齐的if;else不能单独出现,必须有和它配对的if才可以
3、if嵌套
If 表达式:
缩进代码
If 表达式:
缩进代码
else:
缩进代码
else:
缩进代码
If 表达式:
缩进代码
else:
缩进代码
4、if elif 多分支
if 表达式:
缩进代码
if 表达式:
缩进代码
elif 表达式:
缩进代码
......
else:
缩进代码
else:
缩进代码
注意:多分支有一个if,且第一个必须为if,一个或者多个elif 和一个else组成(else可省略),最多只能有一个else,elif可以有多个,但是elif不能单独出现,必须有对应的程序才可以
二、循环语句
既可以使用循环中的值,也可以用来记次数
1、while循环
if是判断一次,当条件为True时执行一次; while是判断n+1次,条件为True时执行n次
定义变量
while 条件选择:
循环体
改变变量
1、死循环
死循环:循环一直执行,没结束循环
while True:
缩进代码
2、break continue语句
一般都是在小循环里面的,不能在大循环里,一般认为while else组合中,else也循环中的一部分
- break语句
- 用于结束循环与循环相关的(while else等),只要有一个break就影响循环及相关
- break下方不直接写代码,没有 意义
- continue语句
- 跳过循环中while循环中continue后面所有的语句,并不是紧邻的,与和while平齐的else等其他无关,continue正下面不直接跟代码
3、while else双分支
定义变量
while 条件选择:
循环体
改变变量
else:
缩进代码注意:当循环结束时,可执行else缩进的代码块,但如果循环是以break结束的,else的缩进代码块不执行
4、嵌套循环
定义变量
while 条件表达式:
......
while 条件表达式:
缩进代码
......
2、for循环
for循环遍历数据有字符串,列表,字典,元祖,集合,range整数序列;for else组合中,一般认为else也是循环中的一部分
语法:for 变量 in 序列:
缩进代码(循环体)执行过程:把序列的第一个值赋给变量,执行一次缩进代码,接着第二个值赋给变量,再执行一次缩进代码,......直到最后一个值赋给变量,执行一次缩进代码,循环结束
与while循环相比没有变量定义和改变变量
1、for循环嵌套
for 变量 in 序列:
......
for 变量 in 序列:
缩进代码
......
2、break continue语句
- break语句
- break只有在最外层for中时,待会终止所有循环及相关(for else组合),否则只能终止最近层for循环,其他继续
- break正下面不直接写代码,没有意义
- continue语句
- 跳过循环中for循环中continue后面所有的语句,并不是紧邻的,与和while平齐的else等其他无关,continue正下面不直接跟代码
3、for else循环
for 变量 in 序列:
缩进代码
else:
缩进代码块注意:当for循环结束后,则执行else,如果最外部循环以break结束,则else代码块就不执行