python表达式

1. 基本元素

构成表达式的基本元素。

• 字面值、标识符、操作符
• 括号
• 带圆括号的形式
  • 列表、集合、字典、元组的显示
  • 生成器表达式
  • yield表达式

1.1. 字面值

字面值是表示固定值的基本元素。它们是表达式中最简单的元素，直接表示数据而不需要计算。

1.1.1. 数值字面值

• 整数、浮点数、虚数。
• 虚数字面值语法规则：imagnumber ::= (floatnumber | digitpart) ("j" | "J")
• 没有复数字面值（复数由实数加虚数构成）。
• 数值字面值不含正负号，实际上，-1 等负数是由一元运算符 - 和字面值 1 合成的。

1.1.2. 字符串字面值

1.1.2.1. 定义

字符串是由字符组成的文本数据，可以包含字母、数字、符号以及其他字符。字符串字面值用引号包围，可以使用单引号'...'、双引号"..."，也可以用三重引号'''...'''或"""..."""来定义。

1.1.2.2. 基本用法

• 三重引号 '''...''' 和 """..."""：用于定义多行字符串或包含复杂内容的字符串，如长文本、带有换行的字符串等。
• 单引号 '...' 和双引号 "..."：用于定义单行字符串。两者之间没有区别，主要用于方便嵌套引号。
• 用例：

single_quote_string = 'Hello, World!'  # 使用单引号定义
double_quote_string = "Hello, World!"  # 使用双引号定义

multi_line_string = """This is a
multi-line string
using triple double quotes."""

another_multi_line = '''This is another example
of a multi-line string
using triple single quotes.'''

1.1.2.3. 转义字符

• 在字符串字面值中，可以使用反斜杠\作为转义字符，以插入特殊字符。

"""
\' ：单引号
\" ：双引号
\\ ：反斜杠
\n ：换行符
\t ：制表符（Tab）
\r ：回车符
\b ：退格符
\u 或 \U ：插入Unicode字符（如\u00A9表示©）
\xhh ：插入十六进制字符（如\x41表示A）
"""
escaped_string = "This is a \"quoted\" word with newline:\nNew line here."
print(escaped_string) 

# 输出：
# This is a "quoted" word with newline:
# New line here.

1.1.2.4. 原始字符串

• 在字符串前加r或R，将其定义为原始字符串。原始字符串中的反斜杠会被视为普通字符，不作为转义符。

raw_string = r"C:\Users\Name\Folder"  # 反斜杠不会被转义
print(raw_string)  # 输出 "C:\Users\Name\Folder"

1.1.2.5. Unicode字符串

• 在Python 3中，所有字符串都是Unicode编码的。可以直接包含特殊字符或使用\u、\U表示Unicode字符。

unicode_string = "你好！"  
print(unicode_string) # 你好！

1.1.3. 字节串字面值

1.1.3.1. 定义

字节串用于表示二进制数据。它们不是由字符组成的，而是由字节（8位组成的数值）组成的。字节串字面值用前缀b或B加上引号（单引号或双引号）表示。

1.1.3.2. 基本用法

• 字节串可以使用单引号或双引号，前缀是b或B。字节串中的每个元素都是一个值在0-255之间的字节。
• 字节串字面值中的字符必须是ASCII字符，这些字符在ASCII表中都有唯一的编码，Python会根据这个编码将字符转换为相应的字节。
  • ASCII编码是最早的字符编码标准之一，它定义了128个字符的编码，包括英文字母（大写和小写）、数字、标点符号以及一些控制字符。每个ASCII字符都可以用一个字节（8位）来表示，其值从0到127。
• 字节串主要用于处理二进制数据。如果需要处理非ASCII文本（如Unicode文本），通常需要使用普通的字符串。
• 用例：

byte_string = b'Hello, World!'  # 使用单引号定义字节串
byte_string2 = B"Another byte string."  # 使用双引号定义字节串
type(byte_string) # bytes

byte_string = b'你好世界!'   # SyntaxError: bytes can only contain ASCII literal characters.

1.1.3.3. 字节串中的转义字符

• 字节串字面值也支持转义字符，但只能使用ASCII字符和部分转义序列。
• 用例：

"""
\n：换行符
\t：制表符
\r：回车符
\\：反斜杠
\'：单引号
\"：双引号
\xhh：十六进制值为hh的字节
"""
escaped_byte_string = b"This is a byte string with newline:\nNew line here."
print(escaped_byte_string)

1.1.3.4. 字节串与字符串的区别

• 字符串是Unicode文本，可以包含多语言字符和特殊字符。
• 字节串是二进制数据，只能包含字节（0-255范围内的整数）。
• 字符串与字节串不能直接拼接，需要通过encode()和decode()来相互转换。
• 用例：

# 字符串转字节串
string = "Hello, 世界"
byte_data = string.encode('utf-8')  # 使用UTF-8编码
print(byte_data)  # 输出 b'Hello, \xe4\xb8\x96\xe7\x95\x8c'

# 字节串转字符串
decoded_string = byte_data.decode('utf-8')  # 解码为字符串
print(decoded_string)  # 输出 "Hello, 世界"

1.1.4. 特殊字面值

• None字面量：None，表示空值或无值。
• 布尔字面量：True和False。

1.2. 标识符

标识符是用来命名变量、函数、类、模块和其他对象的名称。它们是用户定义的，并遵循一系列的命名规则和规范。

• 在表达式中，标识符所代表的内容可以看作表达式的基本构成元素。

1.3. 操作符

用于对操作数进行运算的符号。

类别	符号
算术操作符	+、-、*、/、%、**、//
比较操作符	==、!=、<、>、<=、>=
逻辑操作符	and、or、not
赋值操作符	=、+=、-=、*=、/=
位操作符	&、|、^、~、<<、>>
成员运算符	in（成员）、not in（非成员）
身份运算符	is（是）、is not（不是）

1.4. 括号

用于明确优先级和操作。

类别	符号
小括号 ()	用于分组或函数调用。
中括号 []	用于列表、元组索引和切片。
大括号 {}	用于集合和字典。

1.5. 容器

容器是用于存储和组织数据的数据结构。它们可以通过特定的括号形式来创建，支持不同类型的数据操作，如索引、迭代、添加、删除等。

类别	符号	描述	示例
列表（List）	[ ]	可变的有序集合，支持索引、切片、添加、删除等操作。	numbers = [1, 2, 3, 4]
元组（Tuple）	( )	不可变的有序集合，一旦创建就不能修改，适用于需要固定内容的数据。	coordinates = (10.5, 20.3)
集合（Set）	{ }	无序且不重复的元素集合，支持集合运算，如并集、交集、差集。	unique_numbers = {1, 2, 3, 4}
字典（Dictionary）	{key: value}	键值对的无序集合，通过键来访问对应的值。键是唯一的，可以是不可变类型，如字符串或数字。	student_info = {'name': 'Alice', 'age': 22}

2. 基本操作

编程语言中最紧密绑定的操作。
表达式中对数据进行操作的方式。

• 语法规则如下：

primary ::=  atom(基本构成元素) | attributeref(属性引用) | subscription(抽取) | slicing(切片) | call(调用)

2.1. 属性引用

• 定义：属性引用是通过.操作符来访问对象的属性或方法。属性可以是数据属性（变量）或方法。
• object.attribute
• 用例：

class MyClass:
    def __init__(self):
        self.value = 42

    def show(self):
        print("Hello, World!")

my_instance = MyClass()
print(my_instance.value)  # 访问数据属性
my_instance.show()        # 调用方法

2.2. 抽取

• 定义：抽取是通过[]操作符来访问序列（如列表、元组、字符串等）中的单个元素。索引从0开始。
• sequence[index]
• 用例：

my_list = [1, 2, 3, 4, 5]
print(my_list[2])  # 访问列表中的第三个元素，输出: 3

my_string = "Hello, World!"
print(my_string[7])  # 访问字符串中的第八个字符，输出: W

2.3. 切片

• 定义：切片是通过[]操作符和冒号（:）来获取序列的子集。切片可以指定起始索引、结束索引以及步长。
• sequence[start:end:step]
• 用例：

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(my_list[2:5])  # 输出: [2, 3, 4]
print(my_list[::2])  # 输出: [0, 2, 4, 6, 8]，步长为2

2.4. 调用

• 定义：调用是通过()操作符来执行函数或方法。可以传递位置参数、关键字参数、可变参数列表和关键字参数字典。function(arguments)
• 用例：

def greet(name, message="Hello"):
    print(f"{message}, {name}!")

greet("Alice")  # 调用函数，输出: Hello, Alice!
greet("Bob", message="Hi")  # 使用关键字参数调用函数，输出: Hi, Bob!

3. 表达式

3.1. 算术表达式

用于执行数学运算的表达式，包括加法、减法、乘法、除法、取余等操作。

• 用例：

# 基本算术运算
a = 10
b = 3
sum_result = a + b       # 13
diff_result = a - b      # 7
product = a * b          # 30
quotient = a / b         # 3.333...
integer_division = a // b  # 3
modulus = a % b          # 1
power = a ** b           # 1000 (10的3次方)

3.2. 比较表达式

用于比较两个值的关系，返回布尔值True或False。通常用于条件判断和循环中。

• 用例：

x = 5
y = 10

print(x == y)  # False
print(x != y)  # True
print(x < y)   # True
print(x > y)   # False
print(x <= 5)  # True
print(y >= 15) # False

3.3. 逻辑表达式

用于布尔值之间的逻辑运算，可以连接多个条件表达式，常用于复杂条件判断。

• 用例：

a = True
b = False

print(a and b)  # False
print(a or b)   # True
print(not a)    # False

# 复杂条件判断
age = 25
has_ticket = True

# 检查是否可以进入
can_enter = (age >= 18) and has_ticket  # True

3.4. 赋值表达式

用于将表达式的结果赋值给变量。Python支持多种赋值运算符，包括复合赋值运算符（如+=、*=等）。

• 用例：

x = 10
x += 5  # 相当于 x = x + 5，结果为15
x *= 2  # 相当于 x = x * 2，结果为30
x -= 10 # 相当于 x = x - 10，结果为20
x /= 4  # 相当于 x = x / 4，结果为5.0

3.5. 成员表达式

用于检查元素是否存在于某个序列（如列表、元组、字符串）或集合中。

常用操作符

• 用例：

fruits = ['apple', 'banana', 'cherry']

# 成员检查
print('apple' in fruits)   # True
print('grape' in fruits)   # False
print('orange' not in fruits)  # True

3.6. 身份表达式

用于比较两个对象的身份（即内存地址），检查它们是否是同一个对象。

• 用例：

a = [1, 2, 3]
b = a  # b引用了a
c = [1, 2, 3]

print(a is b)   # True，因为b是a的引用
print(a is c)   # False，尽管内容相同，但a和c是不同的对象
print(a is not c)  # True

3.7. 位运算表达式

用于按位处理整数。操作符作用在数字的二进制位上。

• 用例：

a = 0b1010  # 二进制表示10
b = 0b1100  # 二进制表示12

print(bin(a & b))  # 0b1000，按位与
print(bin(a | b))  # 0b1110，按位或
print(bin(a ^ b))  # 0b0110，按位异或
print(bin(~a))     # -0b1011，按位取反
print(bin(a << 2)) # 0b101000，左移两位，相当于乘以4
print(bin(b >> 2)) # 0b11，右移两位，相当于除以4

3.8. 条件表达式

条件表达式（也称三元表达式）用于根据条件选择值。常见于简单的条件选择。

• 语法：value_if_true if condition else value_if_false
• 用例：

age = 20
status = "Adult" if age >= 18 else "Minor"
print(status)  # 输出 "Adult"

3.9. Lambda表达式

用于定义匿名函数，通常用于简洁地表示短小的函数。它们没有名称，可以在需要函数的地方内联使用。

• 语法：lambda arguments: expression
• 用例：

# 简单的lambda表达式
square = lambda x: x ** 2
print(square(5))  # 输出 25

# 在排序中使用lambda
points = [(1, 2), (3, 1), (0, 4)]
sorted_points = sorted(points, key=lambda p: p[1])
print(sorted_points)  # 输出 [(3, 1), (1, 2), (0, 4)]

3.10. 生成器表达式

生成器表达式用于创建一个生成器对象，它是一种惰性求值的迭代器，在需要时才会计算生成的值，而不是一次性生成所有值。因此，它非常适合处理大量数据或需要延迟计算的场景。

• 生成器表达式使用圆括号()包围，与列表推导式的语法类似，但返回的是生成器而不是列表。
• 基本语法：

(expression for item in iterable if condition)

• 用例：

# 生成器表达式：创建一个生成1到10之间所有偶数的生成器
even_numbers = (x for x in range(1, 11) if x % 2 == 0)

# 使用生成器
for num in even_numbers:
    print(num)  # 输出：2 4 6 8 10

3.11. yield表达式

• yield表达式是一种特殊的语法，用于在函数中生成一个生成器。
• 包含yield的函数称为生成器函数，每次调用yield时，函数的执行会暂停，并返回一个值。下一次调用生成器时，函数会从上次暂停的地方继续执行。
• 详细可见[[python-语句]]/语句

3.12. 列表推导式

列表推导式（List Comprehension）是Python中一种简洁且强大的创建列表的方式。它能够在一行内基于已有的列表或其他可迭代对象生成新的列表，支持条件过滤和变换，是编写简洁代码的有力工具。

• 语法：[expression for item in iterable if condition]
• 基本列表推导式：最简单的列表推导式就是从一个已有的可迭代对象创建一个新的列表。

# 从 0 到 9 的整数生成平方列表
squares = [x ** 2 for x in range(10)]
print(squares)  # 输出 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

• 带有条件过滤的列表推导式：可以在列表推导式中使用if条件来过滤元素。

# 生成 0 到 9 的偶数列表
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # 输出 [0, 2, 4, 6, 8]

• 嵌套的列表推导式：

# 生成笛卡尔积，例如 (x, y) 组合，其中 x 来自 [1, 2, 3]，y 来自 [4, 5, 6]
cartesian_product = [(x, y) for x in [1, 2, 3] for y in [4, 5, 6]]
print(cartesian_product)  # 输出 [(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]

• 带有多个条件的列表推导式：

# 生成 0 到 19 的偶数且大于 10 的数字
filtered_numbers = [x for x in range(20) if x % 2 == 0 and x > 10]
print(filtered_numbers)  # 输出 [12, 14, 16, 18]

• 嵌套循环的列表推导式：可以在列表推导式中使用嵌套循环，从而更紧凑地生成复杂的数据结构。

# 生成一个 3x3 的二维矩阵
matrix = [[x * y for y in range(1, 4)] for x in range(1, 4)]
print(matrix)  # 输出 [[1, 2, 3], [2, 4, 6], [3, 6, 9]]