Python3从零基础到入门（2）—— 运算符-3

Python3从零基础到入门（2）—— 运算符-2

https://developer.aliyun.com/article/1507990

五、成员运算符

       成员运算符用于识别某一元素是否包含在变量中，这个变量可以是字符串、列表、元组，因为是判断在或者不在，所以有两个运算符 in 和 not in，得到的结果为 bool 变量：true 和 false

1.in

判断变量是否包含某元素，包含返回true，不包含返回false，例如：

a = 1
b = 10
 
list = [1, 2, 3, 4, 5];
 
if (a in list):
    print("变量a在list中")
else:
    print("变量a不在list中")
 
 
if (b in list):
    print("变量b在list中")
else:
    print("变量b不在list中")

运行结果：

变量a在list中

变量b不在list中

in的用途不仅仅局限于找单个元素哦，字符串的匹配也可以哦，例如:

s = "hello"
s1 = "ll"
s2 = "lll"
 
if (s1 in s):
    print("变量s1在s中")
else:
    print("变量s1不在s中")
 
if (s2 in s):
    print("变量s2在s中")
else:
    print("变量s2不在s中")

运行结果：

变量s1在s中

变量s2不在s中

2.not in

not in和in恰恰相反，判断变量是否不包含某元素，不包含包含返回true，包含返回false，例如：

a = 1
b = 10
 
list = [1, 2, 3, 4, 5];
 
if (a not in list):
    print("变量a不在list中")
else:
    print("变量a在list中")
 
if (b not in list):
    print("变量b不在list中")
else:
    print("变量b在list中")

运行结果：

变量a在list中

变量b不在list中

我们再试试字符串，例如：

s = "hello"
s1 = "ll"
s2 = "lll"
 
if (s1 not in s):
    print("变量s1不在s中")
else:
    print("变量s1在s中")
 
if (s2 not in s):
    print("变量s2不在s中")
else:
    print("变量s2在s中")

运行结果：

变量s1在s中

变量s2不在s中

最后我们再做个总结

• in：如果在指定的变量中找到元素返回 true，否则返回 false
• not in：如果在指定的变量中没有找到元素返回 true，否则返回 false

六、身份运算符

身份运算符是用来比较两个对象的存储单元，主要包括 is 、is not两个运算符。

1.is与is not 运算符

is，是判断两个标识符是不是引用自一个对象，比如x is y，类似于id(x)==id(y),如果引用的是同一个对象则返回True，否则返回False。（注:id().函数用于获取对象的内存地址。）

is not，是判断两个标识符是不是引用自不同对象，比如x is not y，类似于id(x)！=id(y),如果引用的不是同一个对象则返回True，否则返回False。

例如：

a = 20
b = 20
 
if (a is b):
    print("1 - a 和b有相同的标识")
else：
    print("1 - a和b没有相同的标识"）
 
if ( id(a) == id(b)):
    print("2-a和b有相同的标识")
else:
    print("2-a和b没有相同的标识")
 
# 修改变量b的值
 
b = 30
 
if ( a is b ):
    print ("3-a和b有相同的标识")
else:
    print ("3-a和b没有相同的标识")
 
if ( a is not b ):
    print ("4 - a 和 b 没有相同的标识")
else:
    print ("4 - a 和 b 有相同的标识")

示例输出结果：

1 - a和b有相同的标识

2 - a和b有相同的标识

3 - a和b没有有相同的标识

4 - a和b没有相同的标识

2.is 与 ==区别

is 用于判断两个变量引用对象是否为同一个也就是比较引用对象的地址，==用于判断引用变量的值是否相等。

例如：

>>>a = [1,2,3]
>>>b = a #b=a将两者指向同一个对象
>>>b is a #判断引用对象是否为同一个
True
>>>b == a #判断引用变量的是否相等
True
>>>b = a[:] #b=a[:]会创建一个新的与a完全相同的对象，但是与a并不指向同一对象
>>>b is a
False
>>>b == a
True

七、运算符优先级

       在python中，运算符优先级是指在python解释器在进行多个运算时，根据运算符的优先级规则先计算这个后再计算另一个。如小学时数学中所学的先算括号里面的再算乘除，最后算加减，同理，python在进行运算时根据规则也是如此运算。

以下是从最高到最低优先级的所有运算符：

1.圆括号的表达式

一般使用括号()、中括号[]及大括号{}表示，例如：

a = (1 + 2) * 3
 
# a 的值为 9

其中小括号 (1+2) 用于强制对 1 和 2 的和进行计算，使得计算结果乘以 3。由于乘法操作符 * 的优先级高于加法操作符 +，因此不使用小括号进行强制运算优先级时，计算的顺序可能会与期望不同。因此，在这个例子中使用小括号能够确保计算顺序正确。

2.读取，切片，调用，属性引用

分别为：x[index], x[index:index], x(arguments...), x.attribute，按运算符优先级从高到低如下：

• x(arguments...)：函数调用运算符 () 优先级最高，总是首先执行。在一个表达式中，由于小括号可以改变运算符优先级关系，因此这个运算符是最强的分组运算符。
• x[index] 和 x[index:index]：它们的优先级相同，都比点运算符低。这两个运算符都是序列类型（如字符串、列表和元组）中的索引和切片操作符，用于获取序列中的元素或子序列。
• x.attribute：点运算符 . 是访问对象属性的运算符，在运算符优先级中优先级最低。在一个表达式中，点运算符总是最后执行，并且可以链接多个点运算符形成一个长链，例如 ：obj.attr1.attr2.attr3。例如：

my_list = ["apple", "banana", "cherry"]
index = 1
result = my_list[index].upper()
 
print(result)

输出结果为：

BANANA

这里定义了一个列表 my_list 和一个整数变量 index。接着，我们使用索引操作 my_list[index] 访问了列表的第二个元素 "banana"，得到了一个字符串对象。然后，再使用点运算符 .upper() 访问字符串对象的内置方法 upper()，将其字母全部转换为大写形式，然后打印结果。其中可以看到先是进行了切片操作再进行的点运算。

3.await 表达式

await是用来等待协程完成的，像await x则是表示一个暂停当前协程的语法。

4.乘方(指数)

用符号**表示，操作如下：

a = 2 + 3 * 5**2
 
# a的值为77

在python中还能使用内置函数pow()来表示：

1. pow(2, 3)
2. 
3. ＃　值为８

与 ** 运算符不同的是，pow() 函数还可以指定第三个参数表示模数，即将结果对某个值取模的结果。如下：

pow(2, 3, 5)
 
＃　值为3

5.正，负，按位非 NOT

其符号分别为：+x、-x、 ~x，操作如下：

a = 10
b = -a         # 负运算符，优先级最高
c = ~a         # 按位非 NOT 运算符，优先级第二高
d = a + b * c
 
print(d)

输出结果为：

1010

1010

120

可以看到的是以上代码先是运算完ａ、ｂ、ｃ的值再进行的加减乘除，而ｃ的值为-11，怎么得到的？这里是将变量 a 的二进制表示中的每一位取反（0 变成 1，1 变成 0），得到补码 c=-11

6.乘，矩阵乘，除，整除，取余

使用的表示符号分别是：*,  @，  /,  //,  %。它们的预算优先级相同，运算时按照从左往右运算，例如：

a = 10
b = 3
 
# 乘法
c = a * b
 
print("乘法：%d" % c)
 
# 矩阵乘法
import numpy as np
 
x = np.array([[1, 2], [3, 4]])
y = np.array([[5, 6], [7, 8]])
z = np.dot(x, y)
 
print("矩阵乘法：\n", z)
 
# 除法
d = a / b
 
print("除法：%.2f" % d)
 
# 整除
e = a // b
 
print("整除：%d" % e)
 
# 取余
f = a % b
 
print("取余：%d" % f)

输出结果为：

乘法：30

矩阵乘法：

[[19 22]

[43 50]]

除法：3.33

整除：3

取余：1

7.加和减

加和减的使用和在数学上的使用基本一致，不过在python的表达中可以这样使用：

a = 2
a += 2
a -= 2
 
print(a)

结果为：

２

在python中，可以使用＋＝、－＝这样来进行加减的运算。

8.移位

在 Python 中，移位（Shift）是一种按比特位对数值进行位移的运算。移位操作分为左移和右移两种。

（1）左移<<

将数字的所有二进制位向左移动指定数量的位置，并在低位设置零值。例如，在整数 6（二进制表示：110）执行 6 << 2 时，将其向左移动两个位置，变成 11000，其十进制值为 24。

（2）右移>>

将数字的所有二进制位向右移动指定数量的位置，对于正数，高位设置为 0；对于负数，则高位设置为 1。例如，在整数 -6（二进制表示：11111111111111111111111111111010）执行 -6 >> 2 时，将其向右移动两个位置，变成 11111111111111111111111111111110，其十进制值为 -2。这里的－６二进制表示是使用了补码所以有点长，在python中－６的表示为：0b11111111111111111111111111111010。

9.按位与 AND

& 符号代表按位与 AND 运算符。将两个数字的每个对应二进制位进行比较，如果两个位置上的二进制位都为 1，则该位结果为 1，否则为 0。如下是12 和 25（二进制表示分别为 1100 和 11001）的按位与的运算表示：

  1100
& 11001
-------
  10000

所以，Python 中的 12 & 25 的结果为 16。

10.按位异或 XOR

使用符号 ^ 表示，如果两个位置上的二进制位不相同，则该位结果为 1，否则为 0。如下是12 和 25（二进制表示分别为 1100 和 11001）的按位异或的运算表示：

  1100
^ 11001
-------
  11101

因此，Python 中的 12 ^ 25 的结果为 29。

11.按位或 OR

使用符号 | 表示，在二进制位上对比，有一个为１，则为１，反之则为０。如下是12 和 25（二进制表示分别为 1100 和 11001）的按位或的运算表示：

  1100
| 11001
-------
  11101

结果为：29。

12.比较运算，包括成员检测和标识号检测

一般使用 in,not in, is,is not, <, <=, >, >=, !=, == 来表达。从左往右分别为判断在不在一个集合里用 in 或 not in ；判断属不属于一个集合用 is 或 is not ，属于返回 True，反之返回 Flase；顺着的四个这是小于、小于等于和大于、大于等于；在python中不等于用 != 这个表示，而等号 = 则表示的是赋值，双等号 == 才表示等于。

13.逻辑非 NOT

逻辑非 NOT 运算符使用符号 not 表示。逻辑非是一个布尔运算符，用于将某个布尔表达式的值取反，即如果表达式的值为 True，则逻辑非返回 False，否则返回 True。以下是逻辑非 NOT 运算符的示例代码：

x = True
y = not x
 
print(y) # 输出 False

14.逻辑与 AND

逻辑与 AND 运算符使用符号 and 表示。逻辑与也是一个布尔运算符，用于将多个布尔表达式连接起来进行逻辑与运算，即只有当所有表达式的值均为 True 时，逻辑与才返回 True，否则返回 False。以下是逻辑与 AND 运算符的示例代码：

x = True
y = False
z = x and y
 
print(z) # 输出 False

15.逻辑或 OR

使用符号 or 表示。用于将多个布尔表达式连接起来进行逻辑或运算，即只有当其中至少一个表达式的值为 True 时，逻辑或才返回 True，否则返回 False。以下是逻辑或 OR 运算符的示例代码：

x = True
y = False
z = x or y
 
print(z) # 输出 True

需要注意的，按位和逻辑是俩种不同的运算方式：

 1）按位运算是指对二进制数进行的运算，以二进制位为单位进行处理。按位与（&）和按位或（|）是其中常见的运算符。按位与表示两个二进制数对应位上都为1时结果为1，否则为0；按位或表示两个二进制数对应位上都为0时结果为0，否则为1。

 2）逻辑运算是指对逻辑变量进行的运算，逻辑变量只有两个取值：真（true）和假（false）。逻辑与（&&）和逻辑或（||）是其中常见的运算符。逻辑与表示两个逻辑变量都为真时结果为真，否则为假；逻辑或表示两个逻辑变量有一个为真时结果为真，否则为假。

16.条件表达式

条件表达式（也称为三元表达式）可以用来简洁地表示一个条件语句，使用 if-else 语句的形式进行赋值。当条件表达式的值为 True，则将变量赋值为表达式1的值；否则将变量赋值为表达式2的值。以下是一个条件表达式的示例代码：

x = 5
y = 10
z = x if x > y else y
 
print(z)
 
# 输出 10，因为 x < y 的值为 False，所以将 z 赋值为 y

条件表达式可以替代常见的 if-else 语句，使代码更加简洁、清晰，但同时也容易造成代码可读性较低，所以还是要根据具体场景选择使用哪个方式。

17.lambda 表达式

lambda 表达式是一种用于创建匿名函数的语法结构，以下是一个使用 lambda 表达式实现简单的加法运算的示例代码：

add = lambda x, y: x + y
print(add(3, 5))
 
# 输出 8

lambda 表达式通常用于简化代码、增强可读性，在一些函数式编程的场景中具有重要的作用。但也需要注意不要过度依赖 lambda 表达式，以免影响代码的可维护性和可读性。

18.赋值表达式

赋值表达式（也称为海象运算符），是 Python 3.8 新增的一个语法结构。它可以在一行代码中同时进行变量赋值和表达式运算，以简化代码并提高可读性。但是需要注意，赋值表达式并不是一种通用的语法结构，在一些特殊的情况下可能会导致代码难以理解，因此需要谨慎使用。以下是基本形式：

变量名 := 表达式
 
＃:= 就是赋值表达式的运算符，左侧是要被赋值的变量名，右侧是要进行的表达式运算。