{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Python语法基础" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. 变量与基本数据类型" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.1 变量定义与内存管理\n", "\n", "Python变量的本质：\n", "- 变量是对象的引用（类似于指针）\n", "- 变量本身没有类型，类型属于对象\n", "- 赋值操作实际上是建立引用关系\n", "\n", "内存管理机制：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 示例：变量引用\n", "a = 10 # 创建整数对象10，变量a引用它\n", "b = a # 变量b也引用同一个对象\n", "a = 20 # 创建新对象20，a改为引用它，b仍引用10\n", "print(f\"a: {a}, b: {b}\")\n", "\n", "# 查看对象内存地址\n", "print(f\"a的id: {id(a)}, b的id: {id(b)}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2 数据类型详解\n", "\n", "#### 数字类型\n", "- 整数(int)：不限大小（仅受内存限制）\n", "- 浮点数(float)：双精度浮点，注意精度问题\n", "- 复数(complex)：包含实部和虚部\n", "\n", "#### 字符串(str)\n", "- 不可变序列\n", "- 三种表示方式：单引号、双引号、三引号\n", "- 原始字符串（忽略转义）：r'...'\n", "\n", "#### 布尔(bool)\n", "- True和False\n", "- 实际上是整数子类：True==1，False==0\n", "- 假值包括：False, None, 0, \"\", [], {}, ()等" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 数字类型示例\n", "big_num = 999999999999999999999999999999999999999999999999999999999999\n", "print(0.1 + 0.2 == 0.3) # 浮点精度问题\n", "c = 3 + 4j\n", "print(f\"复数: {c}, 实部: {c.real}, 虚部: {c.imag}\")\n", "\n", "# 字符串示例\n", "s1 = '单引号'\n", "s2 = \"双引号\"\n", "s3 = \"\"\"多行\n", "字符串\"\"\"\n", "path = r'C:\\new_folder' # 原始字符串\n", "\n", "# 布尔类型示例\n", "print(bool(\"\")) # 空字符串为False\n", "print(bool([])) # 空列表为False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. 运算符全面解析" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.1 算术运算符\n", "\n", "| 运算符 | 名称 | 描述 | 示例 | 结果 |\n", "|--------|--------|-----------------------|------------|-------|\n", "| `+` | 加 | 数值相加/字符串拼接 | `3 + 2` | `5` |\n", "| `-` | 减 | 数值相减 | `5 - 3` | `2` |\n", "| `*` | 乘 | 数值相乘/字符串重复 | `3 * 2` | `6` |\n", "| `/` | 除 | 总是返回浮点数 | `6 / 3` | `2.0` |\n", "| `//` | 整除 | 向下取整 | `7 // 3` | `2` |\n", "| `%` | 取模 | 返回除法余数 | `7 % 3` | `1` |\n", "| `**` | 幂运算 | 计算次方 | `2 ** 3` | `8` |" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 特殊行为示例\n", "print(\"Hello\" + \"World\") # HelloWorld\n", "print(\"Hi\" * 3) # HiHiHi\n", "print(5 + 3.14) # 8.14" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.2 比较运算符\n", "\n", "| 运算符 | 描述 | 示例 | 结果 |\n", "|--------|------------|--------------|-------|\n", "| `==` | 等于 | `3 == '3'` | False |\n", "| `!=` | 不等于 | `5 != 3` | True |\n", "| `>` | 大于 | `5 > 3.5` | True |\n", "| `<` | 小于 | `'a' < 'b'` | True |\n", "| `>=` | 大于等于 | `5 >= 5` | True |\n", "| `<=` | 小于等于 | `3.0 <= 3` | True |" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 链式比较特性\n", "x = 5\n", "print(1 < x < 10) # True\n", "print(3 <= x*2 <= 12) # True" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.3 逻辑运算符\n", "\n", "| 运算符 | 描述 | 示例 | 结果 |\n", "|--------|--------|------------------------|-------|\n", "| `and` | 逻辑与 | `True and False` | False |\n", "| `or` | 逻辑或 | `False or 3` | 3 |\n", "| `not` | 逻辑非 | `not 0` | True |" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 短路特性验证\n", "def check():\n", " print(\"函数被调用\")\n", " return True\n", "\n", "False and check() # 无输出\n", "True or check() # 无输出" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.4 位运算符\n", "\n", "| 运算符 | 描述 | 示例 | 结果（十进制） |\n", "|--------|------------|----------------|---------------|\n", "| `&` | 按位与 | `0b1100 & 0b1010` | 8 |\n", "| `|` | 按位或 | `0b1100 | 0b1010` | 14 |\n", "| `^` | 按位异或 | `0b1100 ^ 0b1010` | 6 |\n", "| `~` | 按位取反 | `~0b0011` | -4 |\n", "| `<<` | 左移 | `5 << 2` | 20 |\n", "| `>>` | 右移 | `16 >> 2` | 4 |" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 位操作应用\n", "print(1 << 4) # 16\n", "num = 7\n", "print(num & 1) # 1（奇数）" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.5 赋值运算符\n", "\n", "| 运算符 | 等价表达式 | 示例 | 效果 |\n", "|--------|------------|-------------|----------------|\n", "| `=` | - | `x = 5` | 基本赋值 |\n", "| `+=` | `x = x + y`| `x += 3` | 增量赋值 |\n", "| `-=` | `x = x - y`| `x -= 2` | 减量赋值 |\n", "| `*=` | `x = x * y`| `x *= 1.5` | 乘量赋值 |\n", "| `/=` | `x = x / y`| `x /= 2` | 浮点除赋值 |\n", "| `//=` | `x = x // y`| `x //= 2` | 整除赋值 |\n", "| `%=` | `x = x % y`| `x %= 3` | 取模赋值 |\n", "| `**=` | `x = x ** y`| `x **= 2` | 幂运算赋值 |" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 可变对象陷阱\n", "lst1 = [1,2]\n", "lst2 = lst1\n", "lst1 += [3]\n", "print(\"lst2:\", lst2) # [1,2,3]\n", "\n", "lst1 = lst1 + [4]\n", "print(\"lst2:\", lst2) # [1,2,3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.6 成员与身份运算符\n", "\n", "| 类型 | 运算符 | 描述 | 示例 | 结果 |\n", "|------------|--------|-----------------------|-------------------|-------|\n", "| 成员运算符 | `in` | 元素存在性 | `3 in [1,2,3]` | True |\n", "| | `not in` | 元素不存在性 | `'a' not in 'xyz'`| True |\n", "| 身份运算符 | `is` | 对象标识相同 | `x = [1]; y = [1]; x is y` | False |\n", "| | `is not` | 对象标识不同 | `3 is not None` | True |" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 256\n", "b = 256\n", "print(a is b) # True\n", "\n", "x = 257\n", "y = 257\n", "print(x is y) # False\n", "\n", "lst = [1,2,3]\n", "print([2] in lst) # False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.7 运算符优先级\n", "\n", "| 优先级 | 运算符 |\n", "|--------|-------------------------------------|\n", "| 1 | `()` |\n", "| 2 | `**` |\n", "| 3 | `~` `+` `-` |\n", "| 4 | `*` `/` `%` `//` |\n", "| 5 | `+` `-` |\n", "| 6 | `<<` `>>` |\n", "| 7 | `&` |\n", "| 8 | `^` |\n", "| 9 | `|` |\n", "| 10 | `==` `!=` `>` `<` `>=` `<=` |\n", "| 11 | `is` `is not` |\n", "| 12 | `in` `not in` |\n", "| 13 | `not` |\n", "| 14 | `and` |\n", "| 15 | `or` |" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "result = 3 + 4 * 2 ** 2 // (1 + 1)\n", "print(result) # 11" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 综合练习\n", "**练习1**：使用位运算交换两个变量\n", "**练习2**：判断闰年（能被4整除但不能被100整除，或能被400整除）\n", "**练习3**：计算 `(True or False) and (not (5 <= 3))`" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 练习1答案\n", "a = 5\n", "b = 3\n", "a ^= b\n", "b ^= a\n", "a ^= b\n", "print(f\"a={a}, b={b}\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 练习2答案\n", "year = 2024\n", "is_leap = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)\n", "print(f\"{year}是闰年: {is_leap}\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 练习3答案\n", "print((True or False) and (not (5 <= 3))) # True" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. 控制流程深度解析" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.1 条件表达式详解\n", "\n", "#### 条件语句的本质\n", "Python中的条件控制结构基于布尔逻辑进行分支判断，其核心特点是：\n", "- **缩进定义代码块**：Python使用严格的缩进（通常4个空格）来界定代码块\n", "- **灵活的表达式**：条件表达式可以是比较运算、成员测试、身份测试或布尔组合\n", "\n", "#### 多分支决策模式\n", "```python\n", "if condition1:\n", " # 当condition1为True时执行\n", "elif condition2:\n", " # 当condition1为False且condition2为True时执行\n", "else:\n", " # 当所有条件都为False时执行\n", "```\n", "\n", "#### 模式匹配（Python 3.10+）\n", "结构化模式匹配比传统的if-elif-else更清晰，适用于：\n", "- 处理复杂数据结构\n", "- 实现状态机\n", "- 解析命令行参数" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 模式匹配示例\n", "def handle_http_status(status):\n", " match status:\n", " case 200:\n", " return \"成功\"\n", " case 404:\n", " return \"未找到\"\n", " case 500 | 502 | 503: # 多值匹配\n", " return \"服务器错误\"\n", " case _ if 400 <= status < 500: # 带条件的匹配\n", " return \"客户端错误\"\n", " case _:\n", " return \"未知状态码\"\n", "\n", "print(handle_http_status(404)) # 输出\"未找到\"\n", "print(handle_http_status(403)) # 输出\"客户端错误\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2 循环控制进阶\n", "\n", "#### 循环结构类型\n", "Python提供两种循环结构：\n", "1. **while循环**：基于条件重复执行\n", "2. **for循环**：迭代序列或可迭代对象\n", "\n", "#### 循环控制语句\n", "| 语句 | 作用 |\n", "|-----------|------------------------------|\n", "| `break` | 立即退出整个循环 |\n", "| `continue`| 跳过当前迭代，进入下一次循环 |\n", "| `else` | 循环正常结束（非break退出）时执行 |\n", "\n", "#### 高效迭代技巧\n", "- `enumerate`：同时获取索引和值\n", "- `zip`：并行迭代多个序列\n", "- `itertools`模块：提供高级迭代工具" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 循环高级用法示例\n", "names = ['Alice', 'Bob', 'Charlie']\n", "scores = [85, 92, 78]\n", "\n", "# 使用enumerate和zip\n", "for idx, (name, score) in enumerate(zip(names, scores), start=1):\n", " print(f\"{idx}. {name}: {score}\")\n", "else:\n", " print(\"成绩统计结束\")\n", "\n", "# 自定义可迭代对象\n", "class CountDown:\n", " def __init__(self, start):\n", " self.current = start\n", " \n", " def __iter__(self):\n", " return self\n", " \n", " def __next__(self):\n", " if self.current <= 0:\n", " raise StopIteration\n", " num = self.current\n", " self.current -= 1\n", " return num\n", "\n", "print(\"倒计时:\")\n", "for num in CountDown(3):\n", " print(num)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 循环性能优化\n", "1. 避免在循环内进行不必要的计算\n", "2. 使用生成器表达式替代列表推导式（大数据量时）\n", "3. 考虑使用内置函数如`map()`, `filter()`\n", "\n", "#### 循环中的异常处理\n", "正确处理循环中的异常保证程序健壮性：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 循环异常处理示例\n", "urls = ['https://example.com', 'invalid_url', 'https://example.org']\n", "\n", "for url in urls:\n", " try:\n", " print(f\"正在处理: {url}\")\n", " if 'invalid' in url:\n", " raise ValueError(\"无效URL\")\n", " # 模拟成功处理\n", " print(f\"成功处理 {url}\")\n", " except ValueError as e:\n", " print(f\"跳过 {url}, 错误: {e}\")\n", " continue\n", " except Exception as e:\n", " print(f\"严重错误: {e}\")\n", " break\n", " else:\n", " print(f\"{url} 处理完成\")\n", " finally:\n", " print(\"清理临时资源\\n\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 循环与函数式编程\n", "Python支持部分函数式编程风格：\n", "- `map()`: 对可迭代对象应用函数\n", "- `filter()`: 过滤元素\n", "- `functools.reduce()`: 累积计算" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from functools import reduce\n", "\n", "# 函数式编程示例\n", "numbers = [1, 2, 3, 4, 5]\n", "\n", "# map示例\n", "squared = list(map(lambda x: x**2, numbers))\n", "print(f\"平方: {squared}\")\n", "\n", "# filter示例\n", "evens = list(filter(lambda x: x%2==0, numbers))\n", "print(f\"偶数: {evens}\")\n", "\n", "# reduce示例\n", "product = reduce(lambda x,y: x*y, numbers)\n", "print(f\"乘积: {product}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 控制流程最佳实践\n", "1. 避免过深的嵌套（一般不超过3层）\n", "2. 复杂条件提取为变量或函数\n", "3. 使用生成器处理大数据集\n", "4. 优先使用for循环而非while循环（当迭代次数明确时）\n", "5. 适当使用`itertools`模块提高效率" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 控制流程综合示例\n", "import itertools\n", "\n", "def process_data(data):\n", " \"\"\"处理数据的最佳实践示例\"\"\"\n", " # 条件判断\n", " if not data:\n", " print(\"警告: 空数据集\")\n", " return []\n", " \n", " # 使用生成器表达式\n", " filtered = (x for x in data if x > 0)\n", " \n", " # 使用itertools.islice限制处理数量\n", " results = []\n", " for idx, value in enumerate(itertools.islice(filtered, 100)):\n", " try:\n", " # 复杂处理逻辑\n", " result = value ** 0.5\n", " if result > 10:\n", " continue # 跳过过大值\n", " results.append(result)\n", " except Exception as e:\n", " print(f\"处理错误: {e}\")\n", " \n", " return results\n", "\n", "data = [1, 4, -5, 9, 16, 0, 25, -1, 36]\n", "print(\"处理结果:\", process_data(data))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 控制流程练习\n", "\n", "**练习1**：使用模式匹配实现一个简单的命令行解析器\n", "\n", "**练习2**：使用生成器实现斐波那契数列\n", "\n", "**练习3**：使用itertools.groupby对数据进行分组统计" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 练习1：命令行解析器\n", "def parse_command(command):\n", " match command.split():\n", " case [\"exit\"]:\n", " print(\"退出程序\")\n", " case [\"load\", filename]:\n", " print(f\"加载文件: {filename}\")\n", " case [\"save\", filename] if '.' in filename:\n", " print(f\"保存文件: {filename}\")\n", " case _:\n", " print(\"未知命令\")\n", "\n", "# 在此测试您的代码\n", "parse_command(\"load data.txt\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 练习2：斐波那契生成器\n", "def fibonacci(limit):\n", " a, b = 0, 1\n", " while a < limit:\n", " yield a\n", " a, b = b, a + b\n", "\n", "# 在此测试您的代码\n", "print(\"斐波那契数列:\", list(fibonacci(100)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 练习3：数据分组\n", "from itertools import groupby\n", "\n", "data = [('A', 85), ('B', 92), ('A', 78), ('C', 90), ('B', 88)]\n", "\n", "# 按字母分组计算平均分\n", "# 提示：需要先排序再分组\n", "# 在此编写您的代码" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. 数据结构高级特性" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.1 列表推导式与生成器\n", "\n", "列表推导式：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "squares = [x**2 for x in range(10) if x % 2 == 0]\n", "print(squares)\n", "\n", "# 生成器表达式\n", "sum_of_squares = sum(x**2 for x in range(1000000))\n", "print(f\"前1000000个数的平方和: {sum_of_squares}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.2 字典高级操作\n", "\n", "字典推导式：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "square_dict = {x: x**2 for x in range(5)}\n", "print(square_dict)\n", "\n", "# setdefault()方法\n", "d = {}\n", "for k, v in [('a', 1), ('b', 2), ('a', 3)]:\n", " d.setdefault(k, []).append(v)\n", "print(d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. 数据结构" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.1 列表操作\n", "\n", "列表是Python中最常用的数据结构，特点：\n", "- **有序的集合**：元素按插入顺序存储\n", "- **可变性**：可以修改内容\n", "- **异构元素**：可以包含不同类型的元素\n", "- **索引支持**：支持正负索引（-1表示最后一个元素）\n", "\n", "#### 常用列表方法：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 列表基础操作示例\n", "fruits = ['apple', 'banana']\n", "\n", "# 添加元素\n", "fruits.append('orange') # 末尾添加\n", "fruits.insert(1, 'pear') # 索引1处插入\n", "print(\"添加后:\", fruits) # ['apple', 'pear', 'banana', 'orange']\n", "\n", "# 删除元素\n", "fruits.remove('banana') # 删除第一个匹配项\n", "popped = fruits.pop(2) # 移除并返回索引2的元素\n", "print(f\"删除后: {fruits}, 弹出元素: {popped}\")\n", "\n", "# 排序与反转\n", "nums = [3, 1, 4, 2]\n", "nums.sort() # 原地排序\n", "nums.reverse() # 原地反转\n", "print(\"排序结果:\", nums) # [4, 3, 2, 1]\n", "\n", "# 负索引访问\n", "print(\"最后一个元素:\", fruits[-1]) # orange" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 列表切片操作\n", "**语法规则**：\n", "```python\n", "list[start:end:step]\n", "```\n", "- start：起始索引（包含），默认0\n", "- end：结束索引（不包含），默认到末尾\n", "- step：步长，默认1\n", "\n", "**重要特性**：\n", "- 返回新列表\n", "- 支持负数索引\n", "- 不会修改原列表" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 切片操作示例\n", "letters = ['a', 'b', 'c', 'd', 'e', 'f']\n", "\n", "print(\"前三个元素:\", letters[0:3]) # ['a', 'b', 'c']\n", "print(\"每隔一个取元素:\", letters[::2]) # ['a', 'c', 'e']\n", "print(\"反向切片:\", letters[-3:-1]) # ['d', 'e']\n", "print(\"反转列表:\", letters[::-1]) # ['f', 'e', 'd', 'c', 'b', 'a']\n", "\n", "# 修改原列表的切片\n", "letters[1:3] = ['x', 'y']\n", "print(\"修改后:\", letters) # ['a', 'x', 'y', 'd', 'e', 'f']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.2 字典操作\n", "\n", "字典是键值对的集合，特点：\n", "- **无序性**（Python 3.7+保持插入顺序）\n", "- **键不可变**：键必须是字符串、数字或元组等不可变类型\n", "- **值任意类型**：值可以是任意Python对象\n", "- **高效查找**：基于哈希表实现，查找时间复杂度O(1)\n", "\n", "#### 常用字典方法：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 字典基础操作示例\n", "student = {\"name\": \"Alice\", \"age\": 20}\n", "\n", "# 增删改查\n", "student[\"score\"] = 85 # 添加新键值对\n", "student[\"age\"] = 21 # 修改已有键\n", "del student[\"score\"] # 删除键\n", "print(\"当前字典:\", student) # {'name': 'Alice', 'age': 21}\n", "\n", "# 常用方法\n", "print(\"所有键:\", student.keys()) # dict_keys(['name', 'age'])\n", "print(\"所有值:\", student.values()) # dict_values(['Alice', 21])\n", "print(\"键值对:\", student.items()) # dict_items([('name', 'Alice'), ('age', 21)])\n", "\n", "# 安全访问\n", "print(\"获取成绩:\", student.get(\"score\", \"N/A\")) # N/A\n", "\n", "# 合并字典\n", "extra_info = {\"gender\": \"female\", \"age\": 22}\n", "student.update(extra_info)\n", "print(\"合并后:\", student) # {'name': 'Alice', 'age': 22, 'gender': 'female'}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 字典视图对象\n", "Python 3中的特殊特性：\n", "- `keys()`, `values()`, `items()`返回视图对象\n", "- 视图对象动态反映字典变化\n", "- 支持集合操作（交集、并集等）" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 视图对象示例\n", "d = {'a': 1, 'b': 2}\n", "keys = d.keys()\n", "values = d.values()\n", "\n", "# 动态变化演示\n", "d['c'] = 3\n", "print(\"更新后的键视图:\", list(keys)) # ['a', 'b', 'c']\n", "print(\"更新后的值视图:\", list(values)) # [1, 2, 3]\n", "\n", "# 集合操作\n", "d2 = {'b': 3, 'c': 4}\n", "common_keys = d.keys() & d2.keys()\n", "print(\"共有键:\", common_keys) # {'b', 'c'}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.3 列表推导式与生成器\n", "\n", "#### 列表推导式（List Comprehension）\n", "**语法结构**：\n", "```python\n", "[expression for item in iterable if condition]\n", "```\n", "\n", "**核心特性**：\n", "1. 快速创建新列表的简洁语法\n", "2. 可包含条件过滤（if子句）\n", "3. 支持多层嵌套循环\n", "\n", "**应用场景**：\n", "- 数据转换（如类型转换、数值计算）\n", "- 数据过滤（如筛选满足条件的元素）\n", "- 矩阵操作（如二维列表处理）\n", "\n", "**注意事项**：\n", "- 避免过度复杂的嵌套（超过2层建议改用常规循环）\n", "- 处理大数据时注意内存消耗\n", "- 无法处理异常（需在外部处理）" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 列表推导式示例\n", "# 基本形式\n", "squares = [x**2 for x in range(10)]\n", "print(\"平方列表:\", squares)\n", "\n", "# 带条件过滤\n", "even_squares = [x**2 for x in range(10) if x % 2 == 0]\n", "print(\"偶数平方:\", even_squares)\n", "\n", "# 多层嵌套\n", "matrix = [[1,2,3], [4,5,6], [7,8,9]]\n", "flatten = [num for row in matrix for num in row]\n", "print(\"扁平化矩阵:\", flatten)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 生成器表达式（Generator Expression）\n", "**语法结构**：\n", "```python\n", "(expression for item in iterable if condition)\n", "```\n", "\n", "**核心特性**：\n", "1. 惰性求值：按需生成元素，节省内存\n", "2. 单向迭代：只能迭代一次\n", "3. 可与多数内置函数配合使用（sum、max等）\n", "\n", "**最佳实践**：\n", "- 处理大型数据集时优先使用\n", "- 管道式数据处理（多个生成器串联）\n", "- 需要多次使用时转换为其他数据结构" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 生成器示例\n", "# 基本生成器\n", "gen = (x**3 for x in range(5))\n", "print(\"生成器类型:\", type(gen))\n", "print(\"生成器内容:\", list(gen))\n", "\n", "# 管道处理\n", "data = range(1000000)\n", "sum_squares = sum(x**2 for x in data if x % 3 == 0)\n", "print(\"能被3整除的平方和:\", sum_squares)\n", "\n", "# 生成器与列表对比\n", "import sys\n", "list_size = sys.getsizeof([x for x in range(1000000)])\n", "gen_size = sys.getsizeof((x for x in range(1000000)))\n", "print(f\"列表内存: {list_size} bytes\")\n", "print(f\"生成器内存: {gen_size} bytes\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.4 字典高级操作\n", "\n", "#### 字典推导式（Dict Comprehension）\n", "**语法结构**：\n", "```python\n", "{key_expr: value_expr for item in iterable if condition}\n", "```\n", "\n", "**典型应用**：\n", "- 转换现有字典（键值变换）\n", "- 从其他数据结构构建字典\n", "- 数据分组预处理\n", "\n", "**特殊方法**：\n", "- `setdefault(key, default)`：安全获取并设置默认值\n", "- `update()`：合并字典（原地修改）\n", "- `get(key, default)`：安全获取值" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 字典操作示例\n", "# 字典推导式\n", "square_dict = {x: x**2 for x in range(5)}\n", "print(\"平方字典:\", square_dict)\n", "\n", "# 键值转换\n", "original = {'a': 1, 'b': 2}\n", "inverted = {v: k for k, v in original.items()}\n", "print(\"反转字典:\", inverted)\n", "\n", "# setdefault应用\n", "word_counts = {}\n", "words = ['apple', 'banana', 'apple', 'cherry']\n", "for word in words:\n", " word_counts.setdefault(word, 0)\n", " word_counts[word] += 1\n", "print(\"词频统计:\", word_counts)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 字典合并方法\n", "1. **update()方法**：\n", "```python\n", "dict1.update(dict2) # 原地修改dict1\n", "```\n", "\n", "2. **解包操作符（Python 3.5+）**：\n", "```python\n", "merged = {**dict1, **dict2}\n", "```\n", "\n", "3. **collections.ChainMap**：\n", "```python\n", "from collections import ChainMap\n", "combined = ChainMap(dict1, dict2)\n", "```\n", "\n", "**选择建议**：\n", "- 需要新字典时使用解包操作符\n", "- 需要动态更新时用ChainMap\n", "- 需要原地修改时用update()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 字典合并示例\n", "d1 = {'a': 1, 'b': 2}\n", "d2 = {'b': 3, 'c': 4}\n", "\n", "# 方法1：解包操作符（优先）\n", "merged = {**d1, **d2}\n", "print(\"解包合并:\", merged) # {'a':1, 'b':3, 'c':4}\n", "\n", "# 方法2：update()\n", "d1.update(d2)\n", "print(\"update合并:\", d1) # 原地修改d1\n", "\n", "# 方法3：ChainMap\n", "from collections import ChainMap\n", "combined = ChainMap(d1, d2)\n", "print(\"ChainMap获取b:\", combined['b']) # 显示第一个字典中的值" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.5 集合操作（Set Operations）\n", "\n", "**核心特性**：\n", "- 无序的唯一元素集合\n", "- 支持数学集合运算\n", "- 基于哈希表实现，查找效率O(1)\n", "\n", "**运算类型**：\n", "| 运算符 | 方法 | 描述 |\n", "|--------|---------------|--------------------|\n", "| `|` | union() | 并集 |\n", "| `&` | intersection()| 交集 |\n", "| `-` | difference() | 差集 |\n", "| `^` | symmetric_diff() | 对称差集 |\n", "\n", "**特殊类型**：\n", "- `frozenset`：不可变集合（可哈希，可用作字典键）\n", "- `collections.Counter`：带计数器的多重集合" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 集合操作示例\n", "A = {1, 2, 3, 4}\n", "B = {3, 4, 5, 6}\n", "\n", "print(\"并集:\", A | B) # {1,2,3,4,5,6}\n", "print(\"交集:\", A & B) # {3,4}\n", "print(\"差集:\", A - B) # {1,2}\n", "print(\"对称差集:\", A ^ B) # {1,2,5,6}\n", "\n", "# 集合推导式\n", "words = ['apple', 'banana', 'cherry']\n", "unique_lengths = {len(word) for word in words}\n", "print(\"唯一长度集合:\", unique_lengths)\n", "\n", "# 冻结集合\n", "fs = frozenset([1,2,3])\n", "try:\n", " fs.add(4) # 会抛出AttributeError\n", "except AttributeError as e:\n", " print(\"错误:\", e)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 集合应用场景\n", "1. **快速去重**：\n", "```python\n", "unique_items = list(set(duplicate_list))\n", "```\n", "\n", "2. **成员检测优化**：\n", "```python\n", "if item in large_set: # 比列表快得多\n", " ...\n", "```\n", "\n", "3. **数据关系分析**：\n", "- 共同好友（交集）\n", "- 独特特征（差集）\n", "- 组合特征（并集）\n", "\n", "**性能对比**：\n", "| 操作 | 列表 | 集合 |\n", "|------------|---------|---------|\n", "| 成员检测 | O(n) | O(1) |\n", "| 去重 | O(n²) | O(n) |\n", "| 交/并/差集 | O(n*m) | O(len(s)) |" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 性能对比示例\n", "import timeit\n", "\n", "# 成员检测\n", "list_time = timeit.timeit('\"99999\" in lst', \n", " setup='lst = list(map(str, range(100000)))', \n", " number=1000)\n", "\n", "set_time = timeit.timeit('\"99999\" in s', \n", " setup='s = set(map(str, range(100000)))', \n", " number=1000)\n", "\n", "print(f\"列表检测耗时: {list_time:.4f}s\")\n", "print(f\"集合检测耗时: {set_time:.4f}s\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 综合练习" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 练习：实现一个支持加减乘除的计算器类\n", "class Calculator:\n", " def __init__(self, initial_value=0):\n", " self.value = initial_value\n", " \n", " def add(self, x):\n", " self.value += x\n", " return self\n", " \n", " def subtract(self, x):\n", " self.value -= x\n", " return self\n", " \n", " def multiply(self, x):\n", " self.value *= x\n", " return self\n", " \n", " def divide(self, x):\n", " try:\n", " self.value /= x\n", " except ZeroDivisionError:\n", " print(\"错误：除数不能为零\")\n", " return self\n", " \n", " def __str__(self):\n", " return str(self.value)\n", "\n", "# 链式调用\n", "calc = Calculator(10)\n", "calc.add(5).multiply(3).subtract(2).divide(4)\n", "print(f\"计算结果: {calc}\")" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.5" } }, "nbformat": 4, "nbformat_minor": 4 }