Python运算符与控制语句

 第九章、运算符

一、概述

        在 Python 中，运算符是用于进行各种操作的符号或关键字。Python 支持多种类型的运算符，包括算术运算符、比较运算符、逻辑运算符、位运算符、赋值运算符等。

下面对常用的运算符进行详细介绍：

二、算术运算符：用于进行基本的数学运算。

都是二元运算符

注意：一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升，没有必要去专门记忆运算符的优先级

• +：加法运算，如 a + b。
• -：减法运算，如 a - b。
• *：乘法运算，如 a * b。
• /：除法运算，如 a / b。
• %：取模运算，返回除法的余数，如 a % b。
• **：幂运算，如 a ** b，表示 a 的 b 次方。
• //：整除运算，返回除法的商的整数部分，如 a // b。

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），元祖，集合

1. in：用于检查一个值是否存在于一个容器中。如果值存在于容器中，返回 True；否则返回 False。

2. 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 中的身份运算符包括：

1. is: 用于检查两个对象是否指向同一个内存地址。如果两个对象具有相同的身份，则返回 True，否则返回 False。
2. 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 中常见的运算符优先级（从高到低排列）：

1. 括号：()
2. 幂运算：**
3. 乘法、除法、取模运算：*、/、%
4. 加法、减法：+、-
5. 位运算：<<、>>、&、|、^
6. 比较运算：<、<=、>、>=、==、!=
7. 成员运算符：in、not in
8. 身份运算符：is、is not
9. 逻辑运算符：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代码块就不执行