第一章 python语言概述

1．多选题：下面哪些属于 Python 语言的特点？（ABCD）

A．跨平台 B．开源 C．解释执行 D．支持函数式编程

2．多选题：下面能够支持 Python 开发的环境有哪些？（ABCD）

A．IDLE B．Anaconda3 C．PyCharm D．Eclipse

3．多选题：下面哪些是正确的 Python 标准库对象导入方式？（BD）

A．import math.sin B．from math import sin

C．import math. D．from math import

4.解释导入标准库与扩展库中对象的几种方法之间的区别。

import 库名

优点：不会重名，清晰安全

缺点：每次都要写 库名。函数

import 库名 as 别名

优点：名字短，写起来快

from 库名 import 对象

优点：直接用函数名，不用写库名

缺点：只能用指定对象

from 库名 import *

优点：一次性导入所有函数 / 变量

缺点：容易重名、代码可读性差

第2章 运算符、表达式与内置对象

• 理解变量类型的动态性
• 掌握运算符的用法
• 掌握内置函数的用法
• 理解函数式编程模式

1．Python 运算符中用来计算整商的是//。

2．Python 运算符中用来计算集合并集的是|。

3．Python 运算符中用来计算集合差集的是–。

4．Python 运算符中用来计算集合交集的是&。

5．使用运算符测试集合 A 是否为集合 B 的真子集的表达式为A<B。

6．Python 3.x 语句 print(1, 2, 3, sep=’:’)的输出结果为1:2:3。

7．Python 内置函数len()可以返回列表、元组、字典、集合、字符串以及 range 对象 • 中的元素个数。

8．表达式 sum(map(int, str(123456)))的值为__21__。

9．表达式 eval(‘3+2’+’*2’)的值为_7__。

10．表达式-17 // 4 的值为-5。

11．表达式’3′ > ‘111’的值为True。

12．表达式{1, 2, 3} < {1, 2, 4}的值为_False___。

13．表达式 max([{1}, {2}, {3}])的值为_{3}__。

14．表达式 sorted([1,2,3], reverse=True) == reversed([1,2,3])的值为False。

15．表达式 list(filter(None, [-3, 0, 3]))的值为__[-3,3]__。

16．判断对错：表达式 len(zip([1,2,3], ‘abcdefg’))的值为 3。（ 对）

17．判断对错：已知 x = 3，那么赋值语句 x = ‘abcedfg’是无法正 常执行的。（ 错）

18．判断对错：0o12f 是合法的八进制数字。（ 错）

19．判断对错：x = 9999**9999 这样的语句在 Python 中无法运行， 因为数字太大了超出了整型变量的表示范围。（ 错）

20．判断对错：Python 变量使用前必须先声明，并且一旦声明就 不能在当前作用域内改变其类型了。（ 错）

21．已知 x = {1, 2, 3}，那么可以计算 3*x 的值吗？如果可以，值 是什么？如果不可以，请解释原因。

*不可以，集合不支持乘法运算符，列表，元组，字符串支持重复乘法，集合无该运算规则，会报错**

22．已知 x = zip(‘abc’, ‘1234’)，那么连续两次执行 list(x)会得到同 样的结果吗？如果能，结果是什么？如果不能，请解释原因。

不会得到同样结果，因为zip（）返回的是迭代器，迭代器只能遍历一次；第一次list(x)遍历完后迭代器耗尽，第二次再list（x）得到空列表

第3章 Python序列结构

• 掌握列表、元组、字典、集合的类型特点和自身提供的方法
• 掌握运算符和内置函数对列表、元组、字典、集合的操作
• 理解列表推导式、生成器表达式的工作原理 • 掌握切片操作
• 掌握序列解包的用法

编写程序，生成包含20 个随机数的列表，然后将前10 个元 素升序排列，后10 个元素降序排列，并输出结果。

import random

# 生成20个1~100的随机整数
nums = [random.randint(1, 100) for _ in range(20)]
print("原始列表：", nums)

# 切分前10、后10个元素
first = nums[:10]
last = nums[10:]

# 前10升序，后10降序
first.sort()
last.sort(reverse=True)

# 合并
res = first + last
print("处理后列表：", res)

编写程序，让用户在键盘上输入一个包含若干整数的列表， 输出翻转后的列表。

# 输入示例：1 2 3 4 5
s = input("请输入若干整数，以空格分隔：")
# 转为整数列表
lst = list(map(int, s.split()))

# 列表翻转
lst_rev = lst[::-1]
print("翻转后的列表：", lst_rev)

第 4 章 选择结构与循环结构

• 理解条件表达式与 True/False 的等价关系
• 熟练运用常见选择结构
• 熟练运用 for 循环和 while 循环
• 理解带 else 理解 break 子句的循环结构执行过程
• 理解 break 和 continue 语句在循环中的作用

编写程序，实现人机对战的尼姆游戏。 问题描述：尼姆游戏是这样一个游戏：假设有一堆物品，计算机和人类玩家轮流从其中拿走 一部分。在每一步中，人或计算机可以自由选择拿走多少物品，但是必须至少拿走一个并且 最多只能拿走一半物品，然后轮到下一个玩家。拿走最后一个物品的玩家输掉游戏。

from random import randint
n=int(input('请输入一个正整数:'))
while n> 1:
    # 人类玩家先走
    print("该你拿了，现在剩余物品数为:{0}".format(n))
    #确保人类玩家输入合法整数值
    while True:
        try:
            num=int(input('输入你要拿走的物品数量:'))
            #确保你拿走的物品数量不超过一半
            assert 1 <= num <= n//2
            break #作用:输入合法则终止whi1e循环
        except:
            print('最少必须拿走一个，最多可以拿走{0}个'.format(n//2))
     n -= num
     if n == 1:
         print('恭喜，你赢了!')
         break
         #计算机玩家随机拿走一些，randint用来生成指定范围内的一个随机数
         n -= randint(1, n//2)
     else:
        print('哈哈，你输了。')

第 5 章 函数

• 掌握函数定义和调用的用法
• 理解递归函数的执行过程
• 掌握位置参数、关键参数、默认值参数和不定长度参数的用法
• 理解函数调用时参数传递的序列解包用法
• 理解变量作用域
• 掌握 lambda 表达式的定义与用法
• 理解生成器函数工作原理

1.编写函数，模拟内置函数 all()的功能

def my_all(iterable):
    # 遍历每一个元素
    for item in iterable:
        # 只要有一个元素为假，立即返回 False
        if not item:
            return False
    # 全部为真 或 空迭代器 → 返回 True
    return True

2.编写函数，模拟内置函数 any()的功能

def my_any(iterable):
    # 遍历每一个元素
    for item in iterable:
        # 只要有一个元素为真，立即返回 True
        if item:
            return True
    # 全部为假 或 空迭代器 → 返回 False
    return False

3.写出下面程序的运行结果

def Sum(a, b=3, c=5):
    return sum([a, b, c])
print(Sum(a=8, c=2))
print(Sum(8))
print(Sum(8,2))

13 16 15

4.编写函数，模拟标准库 itertools 中 cycle() 函数的功能（无限循环迭代给定的可迭代对象。）

def myCycle(iterable):
    temp = tuple(iterable)  # 1.将输入转换为元组（存储副本）
    while True:             # 2.无限循环
        for item in temp:   # 3.每次循环遍历元组
            yield item      # 4.逐个生成元素

c = myCycle('Python小屋')
for i in range(20):
    print(next(c))

第 6 章 面向对象程序设计

• 掌握定义类的语法
• 掌握创建对象的语法
• 理解数据成员与成员方法的区别
• 理解私有成员与公有成员的区别
• 理解属性的工作原理
• 了解继承的基本概念
• 了解特殊方法的概念与工作原理

1.判断对错： Python 语言中定义类的属性时只能定义只读属性，无法定义可以 修改和删除 的属性。（错）

2.判断对错：定义类时一般把数据成员定义为私有的，成员方法定义为公有的， 不能把成 员方法定义为私有的。（错）

3.解释面向对象程序设计中封装、继承、多态的概念。

封装

将数据（属性）和**操作数据的方法**捆绑在类中，隐藏内部实现细节，只对外提供必要访问接口；同时可控制访问权限（公有 / 私有），保证数据安全。

继承

允许定义一个新类（子类），复用已有类（父类）的属性和方法，还可以扩展新功能或重写原有方法，实现代码复用。

多态

不同子类继承同一个父类，重写同名方法；调用同一个方法时，会根据对象实际类型执行对应子类的实现，一个接口多种表现形式。

4.设计并实现一个数组类，要求能够把包含数字的列表、元组或 为数组， 并能够修改数组中指定位置上的元素值。

class MyArray:
    # 初始化：接收列表/元组
    def __init__(self, data):
        # 转为内部列表，方便修改
        self._arr = list(data)

    # 修改指定位置元素
    def set_item(self, index, value):
        # 简单下标合法性判断
        if 0 <= index < len(self._arr):
            self._arr[index] = value
        else:
            print("下标越界")

    # 获取指定位置元素
    def get_item(self, index):
        if 0 <= index < len(self._arr):
            return self._arr[index]
        else:
            return "下标越界"

    # 打印数组
    def show(self):
        print(self._arr)

# 测试代码
if __name__ == "__main__":
    # 用元组创建数组
    a1 = MyArray((1,2,3,4,5))
    a1.show()
    # 修改下标2的元素
    a1.set_item(2, 99)
    a1.show()

    # 用列表创建数组
    a2 = MyArray([10,20,30])
    a2.show()

第 7 章 字符串

• 了解 ASCII 、 UTF-8 、 GBK 、 CP936 等常见字符编码格式
• 了解转义字符和原始字符串的概念和用法
• 熟练运用字符串常用方法
• 熟练运用运算符和内置函数对字符串的操作
• 了解中文分词和拼音处理的扩展库基本用法

1.表达式len(‘::’.join([‘a’,’b’,’c’])) 的值为__7___。

2.表达式’123abc’.islower()的值为____True。

3.表达式’abc’ in ‘abdc’的值为__False___。

4.编写函数，接收一个字符串，返回其中最长的数字子串。

def longest_digit_substring(s):
    max_sub = ""    # 存储最长数字子串
    current = ""    # 存储当前正在拼接的数字子串

    for ch in s:
        if ch.isdigit():  # 如果是数字
            current += ch
            # 如果当前更长，更新最长
            if len(current) > len(max_sub):
                max_sub = current
        else:             # 不是数字，重置当前
            current = ""

    return max_sub

5.编写函数，接收一句英文，把其中的单词倒置，标点符号不倒置，例如 I like Beijing. 经过函数后变为： Beijing. like I

def reverse_words(sentence):
    words = sentence.split()    # 按空格分割成单词列表
    words_reversed = words[::-1] # 反转列表
    return ' '.join(words_reversed) # 用空格连接

Python 字符串方法

1. 大小写转换

• s.upper()：全部转大写
• s.lower()：全部转小写
• s.title()：每个单词首字母大写
• s.capitalize()：首字母大写，其余小写
• s.swapcase()：大小写互换

2. 判断类（返回布尔值）

• s.isdigit()：是否全为数字
• s.isalpha()：是否全为字母
• s.isalnum()：是否字母 + 数字组成
• s.islower()：字母是否全小写
• s.isupper()：字母是否全大写
• s.isspace()：是否全为空白字符
• s.startswith(x)：是否以 x 开头
• s.endswith(x)：是否以 x 结尾

3. 查找与统计

• s.find(x)：从左找子串，找不到返回 – 1
• s.rfind(x)：从右找子串，找不到返回 – 1
• s.index(x)：从左找，找不到报错
• s.rindex(x)：从右找，找不到报错
• s.count(x)：统计子串出现次数

4. 分割与拼接

• s.split()：按空白分割成列表
• s.split(sep)：按指定分隔符分割
• s.rsplit(sep)：从右分割
• s.join(iter)：用当前字符串连接可迭代对象

5. 替换与删除

• s.replace(old,new)：替换子串
• s.strip()：首尾空白去除
• s.lstrip()：去除左侧空白
• s.rstrip()：去除右侧空白

6. 对齐填充

• s.center(n)：居中对齐，总长度 n
• s.ljust(n)：左对齐
• s.rjust(n)：右对齐
• s.zfill(n)：左侧补 0 到指定长度

7. 其他常用

• len(s)：返回字符串长度
• s.format()：格式化字符串
• s.eval()：执行字符串表达式

find /rfind/index /sort 用法

一、字符串：find、rfind、index

1. s.find(sub)

• 功能：从左向右查找子串下标
• 找到：返回起始索引
• 找不到：返回 -1
• 语法：s.find(子串, 起始位置, 结束位置)

2. s.rfind(sub)

• 功能：从右向左查找子串最后一次出现位置
• 找到：返回最后一次起始索引
• 找不到：返回 -1

3. s.index(sub)

• 和 find 几乎一样，从左找
• 区别：找不到直接报错，不返回 – 1
• rindex：从右找，找不到也报错

s = "abcab"
print(s.find("ab"))    # 0
print(s.rfind("ab"))   # 3
print(s.index("ab"))   # 0

二、列表：sort

lst.sort()

• 原地排序，直接修改原列表，无返回值
• 默认：升序
• lst.sort(reverse=True) 降序
• 支持 key= 自定义排序规则

lst = [3,1,2]
lst.sort()          # 升序 [1,2,3]
lst.sort(reverse=True)  # 降序 [3,2,1]

字符串 split () 切割结果

1. 基础形态

split() 切割完永远返回：列表（list），里面每个元素是子字符串。

2. 三种常用用法

① 不带参数：s.split()

按任意空白（空格、多个空格、制表符、换行）切割，自动忽略首尾空白，连续空白当一个分隔。

s = "I  love Python"
print(s.split())
# 结果：['I', 'love', 'Python']

② 指定分隔符：s.split(',')

按指定字符切割，不忽略首尾、连续分隔会出空字符串。

s = "a,b,c"
print(s.split(','))
# 结果：['a', 'b', 'c']

③ 带最大分割次数：s.split(' ', 2)

只切前 2 次，后面整体当成一个元素。

3. 总结长相

• 返回类型：列表 list
• 列表里的每一项：字符串 str
• 无参 split：干净拆分，无空元素
• 有参 split：严格按字符切，可能产生空串

生成器函数 vs 普通函数（return）的区别

---

1. 普通函数（用 return）

• 关键字：return
• 执行：运行 → 返回值 → 函数结束
• 特点：一次性返回所有结果
• 返回类型：普通数据（数字、列表、字符串…）

def func():
    return [1,2,3]

---

2. 生成器函数（用 yield）

• 关键字：yield
• 执行：暂停 → 返回一个值 → 下次继续从暂停处运行
• 特点：一次返回一个值，不占内存，可无限迭代
• 返回类型：生成器（迭代器）

def gen():
    yield 1
    yield 2
    yield 3

---

3. 核心区别（必背）

1. return 直接结束函数；yield 暂停函数，下次还能继续
2. return 返回一个值；yield 返回一个生成器，能不断产出值
3. return 占内存；yield 几乎不占内存（适合大数据 / 无限循环）
4. 普通函数调用就执行；生成器函数调用不执行，只返回生成器对象
5. 生成器只能迭代一次；普通函数可无限调用

---

4. 省流

return = 一次性交差

yield = 分批交货，随用随取

面向对象：类、对象、成员、私有成员 访问规则

1. 基本概念

• 类：模板、图纸，定义属性和方法
• 对象：根据类创建出来的实例，具体个体
• 成员：类里的属性（变量）+ 方法（函数）
• 私有成员：以双下划线 __ 开头的属性 / 方法

2. 普通公有成员（无下划线 / 单下划线）

在哪都能访问

1. 类内部：可以直接访问
2. 本类对象：外部 对象.成员 可直接访问
3. 子类：可以继承、访问
4. 其他地方：也能直接访问

3. 私有成员 __xxx 访问规则（重点必背）

能访问的情况

• 只能在【本类的内部方法】中访问

不能访问的情况

1. 类外部：对象。私有成员 直接报错
2. 子类内部：不能直接访问父类私有成员
3. 其他任何外部代码：都不能访问

4. 单下划线 _xxx 说明

语法上仍可外部访问，只是编程约定：视为私有，建议不要外部直接调用

5. 总结

• 公有成员：内外、子类随便访问
• 私有成员__：仅本类内部能用，外面、子类都不许直接碰

class Person:
    name = "张三"       # 公有成员
    __age = 18         # 私有成员

    def get_age(self):
        return self.__age  # 本类内部：可以访问私有

p = Person()
print(p.name)       # 可以
# print(p.__age)   # 外部：报错，不能访问

Python 类中 4 种方法：实例方法、类方法、静态方法、__main__

一、成员方法（实例方法）

特征

• 第一个参数必须是 self
• 必须通过对象调用
• 可以访问、修改实例属性和类属性

考点

1. 隐含参数 self，调用时不用传
2. 只能对象。方法 () 调用
3. 能操作自己的实例属性

class A:
    def fun(self):
        pass
a = A()
a.fun()

---

二、类方法

特征

• 装饰器 @classmethod
• 第一个参数 cls 代表当前类
• 可用类名 / 对象都能调用
• 只能访问类属性，不能直接用实例属性

考点

1. 必须加 @classmethod
2. 参数固定 cls
3. 不依赖实例，跟类绑定

class A:
    @classmethod
    def cm(cls):
        pass
A.cm()

---

三、静态方法

特征

• 装饰器 @staticmethod
• 无默认参数（不用 self、cls）
• 跟类、对象都弱绑定，就是放在类里的普通函数
• 类名、对象都可调用

考点

1. @staticmethod，无默认参数
2. 不能直接访问实例属性、类属性
3. 只是逻辑归类放在类里

class A:
    @staticmethod
    def sm():
        pass
A.sm()

---

四、if __name__ == '__main__': 入口

不是 Java 的 main 方法，是程序入口判断

考点

1. 当前文件直接运行：__name__ 等于 __main__，里面代码执行
2. 当前文件被当作模块导入：不执行里面代码
3. 用来隔离测试代码，防止导入时自动运行

if __name__ == '__main__':
    # 只当前文件直接运行才执行
    pass

---

五、必考对比一句话

1. 实例方法：带 self，对象调用，操作实例
2. 类方法：@classmethod 带 cls，类 / 对象都能调，操作类属性
3. 静态方法：@staticmethod 无默认参数，纯工具函数
4. *main*：区分直接运行 vs 被导入，程序入口

六、考试常考题

• 谁有默认参数？

  实例 (self)、类方法 (cls) 有；

  静态方法没有

• 谁能访问实例属性？只有实例方法
• 类方法、静态方法可以用类名直接调用
• __main__ 作用：防止导入模块时执行测试代码

Python 字典

1. 定义

键值对：{键:值, 键:值}

键不可变（字符串、数字、元组），值任意类型。

d = {"name":"张三", "age":18}

2. 取值

• d["name"] 按键取值，不存在报错
• d.get("age") 取值，不存在返回 None，不报错

3. 增 / 改

• 键存在：修改值
• 键不存在：新增键值对

d["age"] = 20   # 修改
d["sex"] = "男" # 新增

4. 删除

• del d["键"] 删除指定键
• d.pop("键") 删除并返回对应值
• d.clear() 清空所有

5. 常用遍历

• d.keys() 所有键
• d.values() 所有值
• d.items() 所有键值对 (k,v)

for k,v in d.items():
    print(k,v)

6. 考试必背特点

1. 字典无序（Python3.7 + 插入有序，但考试按无序记）
2. 键唯一，重复键会覆盖
3. 键不能是列表、集合；可以是字符串、数字、元组
4. 查找速度极快，靠键映射取值

字典就是按键存、按键取，增删改查全靠键，遍历用 items ()。

列表推导式

1. 作用

一行代码快速生成列表，代替普通 for 循环。

2. 基础语法

[表达式 for 变量 in 可迭代对象]

示例：生成 1~10 列表

lst = [x for x in range(1,11)]

3. 带条件筛选

[表达式 for 变量 in 可迭代对象 if 条件]

示例：只保留偶数

even = [x for x in range(1,11) if x % 2 == 0]

4. 带运算

每个元素先计算再存入

sq = [x**2 for x in range(1,6)]
# 1,4,9,16,25

5. 考试核心考点

1. 格式：[x for x in ...] 中括号
2. 能遍历 + 筛选 + 运算一步到位
3. 比普通 for 循环简洁、速度快
4. 可嵌套循环（简单了解）

中括号里：先写结果，再循环，最后加条件。

生成器 特点 + 使用场景

一、核心特点

1. 用 yield 定义，不是 return
2. 惰性求值：不用不生成，用一个生成一个
3. 节省内存：不一次性把所有数据装进内存
4. 只能遍历一次，遍历完就空了
5. 函数调用后返回生成器对象，不立刻执行

二、使用场景

1. 数据量超大（几万 / 百万条数据），不想占满内存
2. 无限序列（无限自然数、循环迭代）
3. 逐行读取大文件，一行一行处理
4. 流程分步暂停、分步产出结果

一句话总结

生成器就是边用边生成、不占内存、只能用一次，适合大数据和无限循环场景。

Python 面向对象继承示例

包含：父类 Person、子类 Teacher/Student、公有属性、私有属性、继承、方法重写、子类独有方法。

# 父类：人类
class Person:
    # 公有属性
    name = ""
    age = ""
    # 私有属性（双下划线开头）
    __id_card = "110123456"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 父类公有方法
    def show_info(self):
        print(f"姓名：{self.name}，年龄：{self.age}")

    # 提供方法访问私有属性
    def get_id(self):
        return self.__id_card

# 子类：学生 继承 Person
class Student(Person):
    def __init__(self, name, age, stu_id):
        # 调用父类构造方法
        super().__init__(name, age)
        # 学生独有属性
        self.stu_id = stu_id

    # 学生独有方法：自我介绍
    def introduce(self):
        print(f"我是学生{self.name}，今年{self.age}岁，学号：{self.stu_id}")

# 子类：老师 继承 Person
class Teacher(Person):
    def __init__(self, name, age, subject):
        super().__init__(name, age)
        # 老师独有属性
        self.subject = subject

    # 重写父类方法
    def show_info(self):
        print(f"老师：{self.name}，年龄：{self.age}，任教科目：{self.subject}")

# 测试运行
if __name__ == "__main__":
    # 创建学生对象
    s = Student("李明", 20, "2026001")
    s.introduce()       # 子类独有自我介绍
    s.show_info()       # 继承父类方法
    print("身份证号：", s.get_id())  # 访问父类私有属性

    print("-" * 30)

    # 创建老师对象
    t = Teacher("王芳", 38, "Python编程")
    t.show_info()       # 重写后的方法

核心知识点标注

1. 继承：Student(Person)、Teacher(Person) 子类继承父类
2. 公有属性：name、age 内外都能直接访问
3. 私有属性：__id_card 双下划线，外部不能直接访问，只能类内部 / 通过公有方法访问
4. super()：调用父类构造方法，继承父类初始化逻辑
5. 方法重写：老师类重写了父类 show_info
6. 子类独有方法：学生类 introduce() 自我介绍，父类没有

运行效果

我是学生李明，今年20岁，学号：2026001
姓名：李明，年龄：20
身份证号： 110123456
------------------------------
老师：王芳，年龄：38，任教科目：Python编程

四个经典递归

1. 阶乘递归

# 求 n 的阶乘
def fact(n):
    # 递归出口
    if n == 1 or n == 0:
        return 1
    # 递归公式
    return n * fact(n - 1)

# 测试
if __name__ == "__main__":
    print(fact(5))   # 5! = 120
    print(fact(6))   # 720

2. 爬楼梯问题

规则：每次只能走 1 阶或 2 阶，求上 n 阶台阶总走法

def climb(n):
    # 递归出口
    if n == 1:
        return 1
    if n == 2:
        return 2
    # 当前 = 少1阶走法 + 少2阶走法
    return climb(n-1) + climb(n-2)

# 测试
if __name__ == "__main__":
    print(climb(3))  # 3
    print(climb(4))  # 5

3. 汉诺塔递归

# n个盘子，从a借助b，移到c
def hanoi(n, a, b, c):
    if n == 1:
        print(f"盘子 1 ：{a} → {c}")
    else:
        # 先把n-1个从a移到b
        hanoi(n-1, a, c, b)
        # 移动最底下盘子
        print(f"盘子 {n} ：{a} → {c}")
        # 再把n-1个从b移到c
        hanoi(n-1, b, a, c)

# 测试 3个盘子
if __name__ == "__main__":
    hanoi(3, "A柱", "B柱", "C柱")

4.斐波那契

# 递归求第n个斐波那契数
def fib(n):
    if n == 1 or n == 2:
        return 1
    return fib(n-1) + fib(n-2)

# 测试：输出第1~10项
for i in range(1, 11):
    print(fib(i), end=" ")