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

 Python运算符与控制语句_第1张图片

六、赋值运算符:用于给变量赋值。

赋值类的运算符优先级:先执行等号右边的表达式,将执行结果赋值给左边的变量

  • =:简单赋值,将右边的值赋给左边的变量。
  • +=-=*=/=%=**=//=:复合赋值,将右边的值和左边的变量进行相应的运算后再赋值。
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 中的成员运算符有两个:innot 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 引用不同的字符串对象

        在这个示例中,虽然 ab 的值相同,但它们是两个不同的字符串对象,因此 a is b 返回 True。而 ac 是不同的字符串对象,因此 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. 成员运算符:innot in
  8. 身份运算符:isis not
  9. 逻辑运算符:notandor  优先级:()>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")

Python运算符与控制语句_第2张图片

2、if else 双分支

If 表达式:
     缩进代码
else:
     缩进代码

Python运算符与控制语句_第3张图片

 if和else平级,else配离它最近的平齐的if;else不能单独出现,必须有和它配对的if才可以

Python运算符与控制语句_第4张图片

3、if嵌套

If 表达式:
     缩进代码
     If 表达式:
         缩进代码
     else:
         缩进代码
else:
     缩进代码
     If 表达式:
         缩进代码
     else:
         缩进代码

Python运算符与控制语句_第5张图片

4、if  elif  多分支

if  表达式:

        缩进代码

        if  表达式:

                缩进代码

        elif  表达式:

                缩进代码

        ......

        else:

                缩进代码

else:

        缩进代码

注意:多分支有一个if,且第一个必须为if,一个或者多个elif 和一个else组成(else可省略),最多只能有一个else,elif可以有多个,但是elif不能单独出现,必须有对应的程序才可以

Python运算符与控制语句_第6张图片

二、循环语句

既可以使用循环中的值,也可以用来记次数

1、while循环

if是判断一次,当条件为True时执行一次; while是判断n+1次,条件为True时执行n次

定义变量

while  条件选择:

        循环体

        改变变量

Python运算符与控制语句_第7张图片

1、死循环

死循环:循环一直执行,没结束循环

while True:

        缩进代码

2、break continue语句

一般都是在小循环里面的,不能在大循环里,一般认为while else组合中,else也循环中的一部分

  • break语句
    • 用于结束循环与循环相关的(while  else等),只要有一个break就影响循环及相关
    • break下方不直接写代码,没有 意义
  • continue语句
    • 跳过循环中while循环中continue后面所有的语句,并不是紧邻的,与和while平齐的else等其他无关,continue正下面不直接跟代码

Python运算符与控制语句_第8张图片

Python运算符与控制语句_第9张图片

3、while else双分支

定义变量
while 条件选择:
     循环体
     改变变量
else:
     缩进代码

注意:当循环结束时,可执行else缩进的代码块,但如果循环是以break结束的,else的缩进代码块不执行

Python运算符与控制语句_第10张图片

 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正下面不直接跟代码

Python运算符与控制语句_第11张图片

3、for else循环

for 变量 in 序列:
     缩进代码
else:
     缩进代码块

注意:当for循环结束后,则执行else,如果最外部循环以break结束,则else代码块就不执行

你可能感兴趣的:(Python,python,网络,开发语言)