当前位置：
  1. 首页
  2. python
  3. 正文
本文介绍: Python3从零基础到入门（2）—— 运算符算术运算符关系运算符赋值运算符逻辑运算符位运算符成员运算符身份运算符运算符优先级

目录

一、算术运算符

1.四则运算符

（1）加

（2）减

（3）乘

加法运算符用 + 表示，代表对两个数据进行相加操作，如下：

a = 10

b = 8

print(a + b)

输出的结果是：

18

那么如果两个变量不是整数，会怎么样呢？我们来看下：

a = 10.6

b = 8.41

print(a + b)

输出结果如下：

如果你对 C语言中浮点数的存储方式比较熟悉，那么就应该知道，浮点数的计算是会产生误差的的，所以明明在数学上 10.6 + 8.41 的结果是 19.001，但是输出来竟然是 19.009999999999998。这就是浮点数的精度误差。

减法运算符用 – 表示，代表对两个数据进行相减操作，如下：

a = 10

b = 8

print(a - b)

输出的结果是：

2

对于浮点数的相减，同样会产生精度问题，不再累述。

乘法运算符用 * 表示，代表对两个数据进行相乘操作，如下：

a = 10

b = 8

print(a * b)

输出的结果是：

80

对于浮点数的相乘，同样会产生精度问题，不再累述。

除法运算符用 / 表示，代表对两个数据进行相除操作，如下：

a = 10

b = 3

print(a / b)

输出的结果是：

3.3333333333333335

由于并非整除，所以产生了一定的精度误差，符合预期。

取模运算符用 % 表示，代表两数相除的到的余数，如下：

a = 10

b = 3

print(a % b)

输出的结果是：

1

那么，如果除数是负数，或者被除数是负数，结果又是多少呢？如下：

print(-10 % 3)

print(-10 % -3)

print(10 % -3)

输出结果如下：

在 Python 中，取模结果的符号和除数相同；在 C语言 中，取模结果的符号和被除数相同。

幂用 ** 表示。

其中 a**b 代表 a 的 b 次幂。如下：

a = 3

b = 4

print(3**4)

输出的结果如下：

81

当然，幂运算的右操作数，也支持负数。

取整除就是数学上的取下整的意思。用 // 表示，如下：

a = 10

b = 6

print(10 // 6)

输出的结果是：

1

关系运算符主要包括 ==、!=、>、<、>=、<=  这六个关系运算符。

等于关系运算符在Python中用 == 表示，用于比较两个值是否相等。

a = 6

b = 6

print(a == b)

若相等则返回True，否则返回False。我们可以使用 print 语句输出其返回值。

输出结果如下：

True

这里的 == 就是最简单的等于运算符了。

不等于关系运算符在Python中用 != 表示，用于比较两个对象是否不相等。

 a = 10

 b = 11

 print(a != b)

若不相等，返回True；否则，返回False。

输出结果如下：

True

大于关系运算符在Python中用 > 表示，用于比较两个值的大小。其基本语法如下：

 x > y

若 x 的值比 y 的值大，则返回True；否则返回False。

例如：

 a = 10

 b = 9

 print(a > b)

若大于则返回True；否则返回False。

输出结果如下：

True

小于关系运算符在Python中用 < 表示，用于比较两个值的大小。其基本语法如下：

 x < y

若 x 的值比 y 的值小，则返回True；否则返回False。

例如：

a = 10

b = 11

print(a < b)

若小于则返回True；否则返回False。

输出结果如下：

True

大于等于关系运算符在Python中用 >= 表示，用于比较两个值的大小。其基本语法如下：

x >= y

若 x 的值大于等于 y 的值，则返回True；否则返回False。

例如：

a = 10

b = 9

print("a >= b :", (a >= b))


c = 5

d = 5

print("c >= d :", (c >= d))

以上代码，a 的值是 10，b 的值是 11，c 的值是 5 ，d 的值是 5 ，使用 >= 关系运算符判断 a 是否大于等于 b 以及 c 是否大于等于 d，并输出其返回值。

输出结果如下：

小于等于关系运算符在Python中用 <= 表示，用于比较两个值的大小。其基本语法如下：

x <= y

若 x 的值小于等于 y 的值，则返回True；否则返回False。

例如：

a = 10

b = 10

print(a <= b)

若a <= b则返回True；否则返回False。

输出结果如下：

True

上述关系运算符的使用都是整数与整数进行比较。若是不同的数据类型进行比较，Python会先尝试进行类型转换，然后再进行比较。

  • 如果两个对象都是整数或浮点数，则直接进行比较
  • 如果一个对象是整数，另一个对象是浮点数，则将整数转换为浮点数再进行比较
  • 如果一个对象是复数，则不支持比较，会抛出异常。

例如：

# 复数与整数进行比较

c = 1 + 2j

d = 10

print(c < d)

以上代码，a 是一个复数，值为 1 + 2i ，b 是一个整数，值为 10，使用 < 关系运算符比较这两个数的大小时，会抛出TypeError异常：

  • 如果两个字符串不为空，则按照字母表顺序进行比较；
  • 如果一个字符串为空，则认为它比非空字符串小；
  • 如果两个字符串都为空，则认为它们相等。

例如：

# 不为空的字符串比较

str1 = "aaa"

str2 = "aba"

print(str1 <= str2)


# 空串与非空字符串比较

str3 = "hello"

str4 = ""

print(str3 <= str4)

以上代码，定义了4个字符串。

str1与str2都是非空字符串，它们进行比较时，会按照字典序来比较，str1中第2个字母是a，str2的第2个字母是b，在字母表中b排在a后面，因此在比较时，str1小于str2。​

str3为非空字符串，str4为空字符串，空字符串在Python中认为比非空字符串小，因此str4小于str3。​

输出结果如下：

  • 如果两个列表（元组）长度相等，则按照元素顺序依次进行比较；
  • 如果两个列表（元组）长度不相等，则先比较相同位置上的元素，如果都相等则长度更长的列表（元组）更大，否则比较第一个不同的元素的大小；
  • 如果列表（元组）中包含不同类型的元素，则会尝试对它们进行类型转换，然后再进行比较。

例如：

# 列表与列表比较

list1 = [1, 2, 3]

list2 = [1, 2, 3, 4]

print(list1 == list2) # False



# 元组与元组比较

tu1 = (1, 2, 3)

tu2 = (1, 2, 3)

print(tu1 == tu2) # True



# 列表与元组比较

print(list1 == tu1) # True

print(list2 <= tu2) # TypeError!!!

以上代码，分别定义了两个列表和两个元组。

需要注意的是，列表与元组进行比较时，如果是==或!=的比较，Python通常会将元组转换为一个列表，再进行比较；而若是使用 >、<、>=、<= 进行大小比较，则会抛出TypeError类型错误。

输出结果如下：

在Python中，字符串与数字是不同类型的对象，不能直接进行大小比较，会抛出一个类型错误（TypeError）。经过测试，如果使用 == 或 != 进行比较，则不会报错，而是会判断字符串与数字不相等。

例如：

a = 1

b = "abc"

print(a == b) # 等于比较

print(a < b) # 大小比较

以上代码，a 是一个整数，而 b 是一个字符串，若是使用 == 来进行比较，则会直接返回False；若是进行大小比较，则会抛出类型错误。

输出结果如下：

False

Traceback (most recent call last) :

File “compare.py”, line 4, in <module>

print(a < b) # 大小比较

TypeError: ‘<‘ not supported between instances of ‘int’ and ‘str’

虽然使用 == 或 != 来比较字符串与数字不会报错，但是不建议这样子使用。

        赋值运算符主要包括 简单赋值运算符、加法赋值运算符、减法赋值运算符、乘法赋值运算符、除法赋值运算符、取模赋值运算符、幂赋值运算符、取整除赋值运算符。

赋值运算符就是将某个数值赋值给某个变量的运算符。在Python中用 = 表示，如下：

a = 10
b = 5.1

print(a)
print(b)

以上两句话，代表的就是将 10 赋值给变量 a，将 5.1 赋值给变量 b；

我们可以用 print 语句进行打印输出，确认它们的值，输出结果如下：

10

5.1

这里的 = 就是最简单的赋值运算符。

加法赋值运算符用 += 表示，a += c 和 a = a + c 是等价的。

含义就是 a 加上 c 的结果，赋值给 a，我们来看个例子：

a = 6
a += 7

print(a)

以上代码，a 最终的值等价于 a + 7，而 a 的初始值是 6，所以最后打印的 a 的值就是：

13

减法赋值运算符用 -= 表示，a -= c 和 a = a – c 是等价的。

含义就是 a 减去 c 的结果，赋值给 a，例如：

a = 6
a -= 7

print(a)

以上代码，a 最终的值等价于 a – 7，而 a 的初始值是 6，所以最后打印的 a 的值就是：

-1

乘法赋值运算符用 *= 表示， a *= c 和 a = a * c 是等价的。

含义就是 a 乘上 c 的结果，赋值给 a，例如：

a = 10
a *= 0.1

print(a)

以上代码，a 最终的值等价于 a * 0.1，而 a 的初始值是 10，所以最后打印的 a 值就是：

1.0

因为乘法的结果就是看乘号两边的运算数的类型，如果都是整数，那么结果就是整数；如果有一个是浮点数，那么结果就是浮点数。

除法赋值运算符用 /= 表示，a /= c 和 a = a / c 是等价的。

含义就是 a 除上 c 的结果，赋值给 a，例如：

a = 7
a /= 3

print(a)

以上代码，a 最终的值等价于 a / 3，而 a 的初始值是 7，所以最后打印的 a 值就是：

2.3333333333333335

为什么最后有个 5 呢？

由于浮点数精度问题，这个 5 已经在小数点的第 16 位了，已经不再属于它的精度范围，所以才会出现这样的偏差，实际运算过程中，我们不会用到这么后面的小数点。

取模赋值运算符用 %= 表示，a %= c 和 a = a % c 是等价的。

含义就是 a 模上 c 的结果，赋值给 a，例如：

a = 7
a %= 3

print(a)

以上代码，a 最终的值等价于 a % 3，而 a 的初始值是 7，所以最后打印的 a 值就是：

1

幂赋值运算符用 **= 表示，a **= c 和 a = a**c 等价。

含义就是 a 的 c 次幂的结果，赋值给 a，例如：

a = 5
a **= 4

print(a)

以上代码，a 最终的值等价于 a 的 4 次，而 a 的初始值是 5，所以最后打印的 a 值就是：

625

取整除赋值运算符用 //= 表示，a //= c 和 a = a // c 等价。

例如：

a = 15
a //= 2

print(a)

输出结果：

7

        位运算可以理解成对二进制数字上的每一个位进行操作的运算，位运算分为 布尔位运算符 和 移位位运算符

定义描述：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0。

两个数 按位与 操作如下：

a = 60     # 60 = 0011 1100
b = 13     # 13 = 0000 1101
c = 0

c = a & b  # 12 = 0000 1100

print("1 - c 的值为：", c)

输出结果如下：

1 – c 的值为： 12

定义描述：只要对应的二个二进位有一个为1时，结果位就为1。

两个数 按位或 操作如下：

a = 60     # 60 = 0011 1100
b = 13     # 13 = 0000 1101
c = 0

c = a | b  # 61 = 0011 1101

print ("2 - c 的值为：", c)

输出结果如下：

2 – c 的值为： 61

定义描述：当两对应的二进位相异时，结果为1。

两个数 按位异或 操作如下：

a = 60     # 60 = 0011 1100
b = 13     # 13 = 0000 1101
c = 0

c = a ^ b  # 49 = 0011 0001 

print ("3 - c 的值为：", c)

输出结果如下：

3 – c 的值为： 49

定义描述：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1

两个数 按位取反 操作如下：

a = 60     # 60 = 0011 1100
c = 0

c = ~a     # -61 = 1100 0011 

print ("4 - c 的值为：", c)

输出结果如下：

4 – c 的值为： -61

注意：这里 ~a 代表是对二进制数 00111100 取反，直观感受应该是  11000011 ，即  -67。但实际输出的却是 -61, 这是为什么呢？是因为计算机中，二进制编码是采用补码的形式表示的，补码定义如下：

正数的补码是它本身，符号位为 0；负数的补码为正数数值二进制位取反后加一，符号位为一；

我们对 a求反的过程如下：

  0011 1100     # a的初始值

—————

  0011 1100     # a初始值的补码，正数的补码是它本身

~1100 0011     # 对a的每一位取反

—————

  1011 1100     # a取反后的数值的补码表示 11 1100  = 60， 符号位为1，即 -60。

—————

  1011 1101     # 负数的补码为正数数值二进制位取反后加一，所以11 1101= 61,符号位为1，即 -61。

  所以我们的-61就是这么来的。

定义描述：运算数的各二进位全部左移若干位，由”<<“右边的数指定移动的位数，高位丢弃，低位补0。

一个数 左移动运算 操作如下：

a = 60       # 60 = 0011 1100
c = 0

c = a << 2    # 240 = 1111 0000 
print ("5 - c 的值为：", c)

输出结果如下：

5 – c 的值为： 240

定义描述：把”>>”左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数。低位丢弃，高位补0。

一个数 右移动运算 操作如下：

a = 60       # 60 = 0011 1100
c = 0

c = a >> 2    # 15 = 0000 1111 
print ("6 - c 的值为：", c)

输出结果如下：

6 – c 的值为： 15

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

判断变量是否包含某元素，包含返回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中

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两个运算符。

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没有相同的标识

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在进行运算时根据规则也是如此运算。

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

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

a = (1 + 2) * 3

# a 的值为 9

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

分别为：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()，将其字母全部转换为大写形式，然后打印结果。其中可以看到先是进行了切片操作再进行的点运算。

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

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

a = 2 + 3 * 5**2

# a的值为77

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

pow(2, 3)

＃　值为８

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

pow(2, 3, 5)

＃　值为3

其符号分别为：+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

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

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

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

a = 2
a += 2
a -= 2

print(a)

结果为：

２

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

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

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

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

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

  1100
& 11001
-------
  10000

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

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

  1100
^ 11001
-------
  11101

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

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

  1100
| 11001
-------
  11101

结果为：29。

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

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

x = True
y = not x

print(y) # 输出 False

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

x = True
y = False
z = x and y

print(z) # 输出 False

使用符号 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）。逻辑与（&&）和逻辑或（||）是其中常见的运算符。逻辑与表示两个逻辑变量都为真时结果为真，否则为假；逻辑或表示两个逻辑变量有一个为真时结果为真，否则为假。

条件表达式（也称为三元表达式）可以用来简洁地表示一个条件语句，使用 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 语句，使代码更加简洁、清晰，但同时也容易造成代码可读性较低，所以还是要根据具体场景选择使用哪个方式。

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

add = lambda x, y: x + y
print(add(3, 5))

# 输出 8

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

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

变量名 := 表达式

＃:= 就是赋值表达式的运算符，左侧是要被赋值的变量名，右侧是要进行的表达式运算。
显示所有内容
上一篇 资产信息管理系统-前后端开发
下一篇 STM32-创建工程模板

相关文章

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

插入图片
浏览器会保存昵称、邮箱和网站cookies信息，下次评论时使用。