Python学习（七）：基础运算符与表达式【详解】

文章目录

• python基础运算符与表达式
• • 运算符与表达式的优先级
  • 算术运算符（四则运算）
  • 算术运算符（取余/模、乘方）
  • 关系比较运算符
  • 位运算符
  • 逻辑运算符
  • 赋值运算符、复合赋值运算符
  • 条件表达式
  • await序列切片表达式
  • 星号表达式
  • yield表达式
  • lambda表达式

python基础运算符与表达式

运算符与表达式的优先级

算术运算符（四则运算）

算术运算符用于执行基本的算术操作，如加法、减法、乘法和除法。
【注意】 Python不支持 ++ 和 - - 运算符，虽然有些地方在形式上是相同的，但是意义完全不同，比如，2++1 和 3–1 实际表示为2+1 和 2-(-1)，结果均为3。
以下是Python的算术运算符：

注意： 在Python中，整数除法（/）会得到浮点数结果，整除运算符（//）得到整数结果。

算术运算符（取余/模、乘方）

算术运算符用于执行基本的算术操作，如加法、减法、乘法和除法。以下是Python的算术运算符：

注意： 在Python中，整数除法（/）会得到浮点数结果，整除运算符（//）得到整数结果。

关系比较运算符

比较运算符用于比较两个值，并返回一个布尔值（True或False）。以下是Python的比较运算符：

位运算符

逻辑运算符

逻辑运算符用于组合多个条件，并返回一个布尔值。以下是Python的逻辑运算符：

赋值运算符、复合赋值运算符

赋值运算符用于将值赋给变量。以下是Python的赋值运算符：

条件表达式

await序列切片表达式

切片就是在序列对象（字符串、元组或列表）以及range对象中选择某个范围内的项，其中的start、stop、step的含义和range函数中的同名形式参数的含义完全相同，且皆表示元素下标。

星号表达式

格式：*标识符 、**标识符、*序列，星号表达式必须为列表或者元组中的元素，否则会抛出异常

• 位于赋值表达式左侧，用于【打包】，同时形成一个列表对象，对传入函数的多个实参进行打包、并作为函数的形式参数传递
  • *是将对应传入的多个位置参数打包为一个【元组类型】对象
  • **是将对应传入的多个关键字参数打包为一个【字典类型】对象
• 位于一个赋值表达式的右侧，用于【解包】，对传入函数的一个可迭代对象进行解包，并作为函数的实参传递
  • * 会在可迭代对象的每一个元素的相对位置保持不变的情况下，将可迭代对象的所有元素对应转化为多个位置参数（对于字典，仅取出键）
  • **会在字典的每一个键值对的相对位置保持不变的情况下，将字典的所有键值对对应转化为多个关键字参数，转化以后原先字典的键即为函数形参变量名

# 打包----------------------------------------------------------------------
def pack(a, *b, **c):
    print(a, b, c)

pack(1, 2, 3, 4, 5, x=5, y=10)
# pack输出结果：1 (2, 3, 4, 5) {'x': 5, 'y': 10}
# 【"*"、"**"各只能出现一次】
# "*b"对其所在索引位置及后面的元素打包为元组对象
# "**c"对其所在索引位置及后面的元素打包为字典组对象（已被"*b"打包过的元素不再打入）

*a = range(5)  # 打包
print(a)       # 异常"SyntaxError: starred assignment target must be in a list or tuple"

*a, = range(5) # 打包
print(a)       # 输出结果：[0, 1, 2, 3, 4]

# 解包----------------------------------------------------------------------
def unpack(a, b, c):
    print(a, b, c)

unpack(*[1, 2, 3])                  # 输出结果：1 2 3
unpack(**{'a':1,'b':2,'c':3})       # 输出结果：1 2 3

a, *b, c = [*[1, 2, 3], 4, 5]       # 【同时打包、解包】
print(a, b, c)                      # 输出结果：1 [2, 3, 4] 5  打包的同时会兼顾参数c赋值

yield表达式

函数体内含有yield关键字，会将此函数变成一个生成器，那该函数的执行结果是生成器对象：a = yield表示把yield的接收值赋值给a。生成器对象的本质就是迭代器。
生成器它不会直接执行函数代码，而需要调用__next__()（在 for 循环中会自动调用 next()）才开始执行。每执行到一个 yield 语句就会中断，并返回一个迭代值，下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。
可以返回多次值，而return只能返回一次值。

def my_generator(n):    # 自定义生成器函数
    for i in range(n):
        temp = yield i
        print(f'temp={temp}')

g = my_generator(3)     # 初始化生成器，g是一个可以
type(g)                                           # 输出<class 'generator'>
print(g.__next__())                               # 输出0
print(g.__next__())                               # 输出temp=None、1
print(g.__next__())                               # 输出temp=None、2

#------------------------------------------------------------------------
g = ( i for i in range(10) if i > 3)              # 定义迭代器

for i in range(1000): # range生成一个1000个元素的List，占用内存空间大
    print(i)

for i in xrange(1000): # xrange不会生成一个1000个元素的List，而是返回iterable对象，占用内存空间很小 
    print(i)


def my_generator(n):
    for i in range(n):
        temp = yield i
        print(f'我是{temp}')

# 迭代器对象.send(None) 等同于next(迭代器对象)
# 迭代器对象.send（值）相当于值传给yield yield再赋值给变量，碰到下一个yield又会将函数挂起
# 迭代器对象.close()关闭后无法传值
g = my_generator(5)
print(next(g))  # 输出0
print(next(g))  # 输出1
g.send(100)     # 【本来输出2，但是传入新的值100，改为输出100，可以保证传入新的值且原值也不会弄丢】
print(next(g))  # 输出3
print(next(g))  # 输出4

运行结果：
0
我是None
1
我是100
我是None
3
我是None
4

lambda表达式

lambda是一个表达式，而不是一个语句，用来写一些小体量的一次性函数，避免污染环境，同时也能简化代码。
lambda表达式和def定义函数的区别：lambda为编写简单的函数而设计的，而def用来处理复杂的任务。
lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的参数。

# lambda表达式的语法格式如下：
func = lambda [arg1[, arg2, ... argN]] : expression

# lambda表达式转换成普通函数的形式，如下所示：
def func([arg1[, arg2, ... argN]]):
return expression

# ---------------------------------------------------------------
# 举例如下定义一个内部仅包含 1 行表达式的函数add
def add(x, y):
    return x+ y
    
print(add(5, 10))    # 输出15
# ---------------------------------------------------------------
# 将函数add转换成lambda表达式
add = lambda x,y:x+y

print(add(5, 10))    # 输出15