Python核心基础DAY3--Python表达式及常见语句

前面相关文章：

Python核心基础DAY1--Python的基础变量类型之字符串和数字类型

Python核心基础DAY2--复合类型之序列类型、映射类型和集合类型

---

一、表达式

表达式是由一个或多个操作数和运算符组成的。简单来说，表达式可以是任何会产生一个值的代码片段。

1.算术表达式

算术表达式用于执行基础数学运算，例如加法、减法、乘法和除法。

a = 5
b = 3
result = a + b  # 加法
result = a / b  # 除法
result = a // b  # 地板除
result = a % b  # 取余
result = a ** b  # 幂运算

2.比较表达式

用于比较两个值，通常返回布尔值 True 或 False。

a = 5
b = 3
result = a > b  # 大于
result = a <= b  # 小于等于

3.逻辑表达式

逻辑表达式用于组合布尔逻辑，包括 and、or 和 not。

a = True
b = False
result = a and b  # 逻辑与
result = a or b  # 逻辑或
result = not a  # 逻辑非

4.赋值表达式

赋值表达式用于将值绑定到变量，最常用的是 = 运算符。

a = 5  # 赋值表达式
b = a + 3  # 计算并赋值

Python 3.8+ 引入 海象运算符（:=），允许在表达式中直接给变量赋值： 

if (n := len(data)) > 10:  # 给n赋值并使用
    print(f"列表长度大于10，长度为{n}")

5.成员表达式

成员表达式用于检查元素是否存在于容器（如列表、集合、字典）。

a = [1, 2, 3]
result = 2 in a  # 检查2是否在列表a中
result = 4 not in a  # 检查4是否不在列表a中

6.身份表达式

身份表达式用于判断两个变量是否引用同一对象（is 或 is not）。

a = [1, 2]
b = a
result = a is b  # 判断a和b是否是同一个对象
result = a is not b  # 判断a和b是否不是同一个对象

7.三元表达式

三元表达式提供简洁的条件赋值方式。

a = 5
b = 3
result = a if a > b else b  # 如果a > b，result为a，否则为b

8.函数调用表达式

函数调用表达式通过函数名和参数执行函数逻辑。

def add(x, y):
    return x + y
result = add(5, 3)  # 函数调用表达式

9.推导式 — 用更简洁的方式创建列表、字典和集合

推导式提供高效的容器生成方式，包括列表、字典和集合。

9.1.列表推导式

a = [1, 2, 3, 4]
result = [x * 2 for x in a]  # 创建一个新列表，元素是原列表每个元素的两倍

9.2.字典推导式 

a = ['a', 'b', 'c']
result = {x: ord(x) for x in a}  # 创建一个字典，将字母映射到对应的ASCII值

9.3.集合推导式 

a = [1, 2, 3, 4]
result = {x * 2 for x in a}  # 创建一个集合，元素是原列表每个元素的两倍

9.4.练习：生成1—10之间的数字：将其平方存入list01中。将list01中所有偶数存入list02中。将list01中所有大于5的奇数增加1后存入list03中。要求都用列表推导式 

list01 = [pow(i,2)for i in range(1,11)]
print(list01)
list02 = [n for n in list01 if n%2 == 0]
print(list02)
list03 = [m+1 for m in list01 if m>5 and m%2]
print(list03)

8.Lambda表达式

Lambda 表达式（又称匿名函数）是一种轻量级、单行定义的函数，无需使用 def 关键字命名，主要用于快速创建简单函数，通常作为参数传递给高阶函数（如 map()、filter()）或在需要临时函数的场景中使用

lambda  参数列表 : 表达式

参数列表：函数的输入参数，多个参数用逗号分隔       表达式：函数的返回值，无需return关键字

f = lambda x, y: x + y  # 创建一个匿名函数
result = f(2, 3)  # 调用匿名函数

9.生成器表达式

生成器表达式按需生成值，节省内存。

a = [1, 2, 3, 4]
result = (x * 2 for x in a)  # 创建一个生成器，元素是原列表每个元素的两倍

---

二、语句

语句是计算机执行程序的最小单位

1.赋值语句：赋值语句将一个值赋给变量

2.条件语句：条件语句用于根据不同的条件来执行不同的代码块

if-elif-else：

x = 10
if x > 0:
    print("x 是正数")
elif x == 0:
    print("x 是零")
else:
    print("x 是负数")

match-case： 

在Python3.10版本后更新了match-case语句：

1. 当存在多个判断环境时，if-elif-else语句会比较臃肿
2. 在判断条件较为简单的前提下，可使用match case来进行多条件判断
3. 当x与对应的case匹配后，立刻结束判断，无论后续的case是否匹配

x = 20
match x:
    case 10:
        print("x is 10")
    case 20:
        print("x is 20")
    case _:
        print("x is not 10 ether 20")
# case条件判断并不要求为单一条件，可以进行多条件判断
x = 20
match x:
    case 10 | 20 | 30:
        print("x为10、20、30中的一个")
    case _:
        print("x不为10、20、30中的任何一个")
# match case支持在判断条件中套用if判断
x=20
match x:
    case x if x>10:
        print("x大于10")
    case x if x<30:
        print("x大于10小于30")

3.循环语句：

for循环：遍历可迭代对象（如列表、元组、字典等）

# 遍历是指经历且只经历一遍
# 可迭代对象是指能够依次获取数据元素的对象
for i in range(5):
    print(i)  # 输出 0, 1, 2, 3, 4

while循环：当条件为 True 时重复执行 

while循环是可以嵌套的

count = 0
while count < 5:
    print(count)
    count += 1  # 输出 0, 1, 2, 3, 4

【拓展】range：用来生成一个能够得到一系列整数的可迭代对象（也叫整数序列生成器） 

1. range(stop) # stop 停止整数，start 默认值为0, step 默认值为1
2. range(start, stop) # start 开始整数
3. range(start, stop, step) # step 步长

range(4)          # 生成 0 1 2 3
range(3, 6)       # 生成 3 4 5
range(1, 10, 2)   # 生成 1 3 5 7 9
range(5, 0, -2)   # 生成 5 3 1

4.死循环：

1. 死循环是指循环条件一直成立的循环
2. 死循环通常使用 break 语句来终止循环

while True:  # 条件永远为真，形成死循环
    user_input = input("输入 'q' 退出: ")
    if user_input == 'q':
        break  # 满足条件时跳出循环
    print(f"你输入的是: {user_input}")
print("循环已终止")

5.循环控制语句：跳转语句用于控制程序的执行流程

break：跳出整个循环

continue：跳过当前循环，继续下一次循环

for i in range(5):
    if i == 3:
        continue  # 跳过打印 3
    print(i)
# 输出：0, 1, 2, 4

pass：占位符，什么也不做，通常用于占据语法上必须有代码的地方 

def empty_function():
    pass  # 这里不做任何事情

6.字典遍历 — 可以使用 for 循环来遍历字典的键和值

1.字典常规遍历：

d = {'name': 'tarena', 'age': 19}
for k in d:
  print(k)
for k in d:
    print("key=", k, 'value=', d[k])

2.遍历字典的键 ：

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict.keys():
    print(f"Key: {key}")

3.遍历字典的值 :

my_dict = {'a': 1, 'b': 2, 'c': 3}
for value in my_dict.values():
    print(f"Value: {value}")

4.同时遍历字典的键和值 :

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")

练习：正向最大匹配分词算法

dict1 = {"北京市长", "喜欢", "南京市", "长江大桥", "和", "南京烤鸭"}  
MAX_LEN = 5  # 假设最大词长度为 5，可根据词典中最长词调整
sentence = "北京市长喜欢南京市长江大桥和南京烤鸭"
results = []
# 完成分词：正向最大匹配
while len(sentence) > 0:
    print('sentence: ', sentence)
    # 从最大可能的词长度开始尝试匹配
    for i in range(MAX_LEN, 0, -1):  
        if i > len(sentence):
            continue  # 当 i 超过当前 sentence 长度时，跳过本次循环
        word = sentence[:i]
        if word in dict1:
            results.append(word)
            sentence = sentence[i:]  # 截取剩余未分词的部分
            break
print('分词结果：', results)

 

7.异常处理语句 — 用于捕获和处理可能出现的错误

try-except-finally 

fenzi = float(input("请输入分子："))
fenmu = float(input("请输入分母："))
try:
    r = fenzi / fenmu
    print("结果为：", r)
except ZeroDivisionError:
    print("分母不能为0")
finally:
    print('后续业务处理中...')

raise 

raise关键字用于显式地抛出异常，通常用于自定义异常或在代码中手动触发错误。

fenzi = float(input("请输入分子："))
fenmu = float(input("请输入分母："))
**# 直接抛出异常，代码不再往下执行**
if fenmu == 0:
    raise ZeroDivisionError('分母不能为0')
try:
    r = fenzi / fenmu
    print("结果为：", r)
except ZeroDivisionError:
    print("分母不能为0")
finally:
    print('后续业务处理中...')

 

assert 

assert 主要用于开发和调试时检查某个条件是否成立。

x = 10
assert x > 5  # 通过，不会报错
assert x < 5, "x 必须小于 5"  # 失败，抛出 AssertionError: x 必须小于 5

 

错误类型	说明
ZeroDivisionError	除(或取模)零 (所有数据类型)
ValueError	传入无效的参数
AssertionError	断言语句失败
StopIteration	迭代器没有更多的值
IndexError	序列中没有此索引(index)
IndentationError	缩进错误
OSError	输入/输出操作失败
ImportError	导入模块/对象失败
NameError	未声明/初始化对象 (没有属性)
AttributeError	对象没有这个属性

8.类定义语句 — 用于定义一个类，类中包含属性和方法

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")
p = Person("Alice", 30)
p.greet()  # 调用类的方法

9.with语句

with open("file.txt", "r") as file:
    content = file.read()
    print(content)

---

三、总结

表达式与语句概述

1. 表达式是由操作数和运算符组成的代码片段，能够产生值。主要包括算术、比较、逻辑、赋值、成员、身份、三元、函数调用、推导式、Lambda和生成器表达式。表达式通常用于计算或条件判断。
2. 语句是程序执行的最小单位，包括赋值、条件、循环、异常处理等。语句控制程序流程，实现逻辑分支、重复执行和错误处理。

表达式分类

1. 算术表达式执行基础数学运算，如加减乘除、地板除、取余和幂运算。比较表达式用于值的大小比较，返回布尔结果。逻辑表达式组合布尔逻辑，包括与或非操作。
2. 赋值表达式将值绑定到变量，Python 3.8+引入海象运算符允许在表达式中赋值。成员表达式检查元素是否存在于容器。身份表达式判断变量是否引用同一对象。
3. 三元表达式提供简洁的条件赋值方式。函数调用表达式通过函数名和参数执行逻辑。推导式高效生成列表、字典和集合。Lambda表达式创建匿名函数。生成器表达式按需生成值，节省内存。

语句类型

1. 赋值语句将值赋给变量。条件语句根据条件执行不同代码块，包括if-elif-else和Python 3.10引入的match-case结构。循环语句重复执行代码，包括for和while循环，支持嵌套和range生成整数序列。
2. 循环控制语句包括break跳出循环、continue跳过当前循环、pass占位符。字典遍历使用for循环访问键值对，支持keys、values和items方法。异常处理语句捕获和处理错误，包括try-except-finally和raise主动引发异常。