Python基础教程常考内容有哪些？

分为几个模块，每个模块下都包含核心概念、常见考点、示例代码和易错点,方便你系统性地复习。

Python 基础语法

这是所有 Python 学习的起点,也是必考内容。

变量与数据类型

• 核心概念：

  • 变量是内存中用来存储数据的容器，Python 是动态类型语言,不需要声明类型。
  • 基本数据类型：int (整数), float (浮点数), str (字符串), bool (布尔值)。
  • 复合数据类型：list (列表), tuple (元组), dict (字典), set (集合)。

• 常见考点：

  1. 类型判断：使用 type() 或 isinstance() 函数。
  2. 类型转换：int(), str(), float(), bool() 的使用场景和规则（bool([]) 是 False）。
  3. 不可变类型 vs 可变类型：int, str, tuple 是不可变的；list, dict, set 是可变的。

• 示例代码：

  
  （图片来源网络，侵删）

  # 类型判断
  a = 10
  print(type(a) is int)  # True
  print(isinstance(a, int)) # True (推荐，可以判断继承关系)
  # 类型转换
  b = "123"
  c = int(b)  # c 是整数 123
  d = str(456) # d 是字符串 "456"
  # 不可变与可变
  my_list = [1, 2, 3]
  my_list.append(4)  # 可以修改
  # my_tuple = (1, 2, 3)
  # my_tuple.append(4)  # 会报错 AttributeError

• 易错点：

  • 混淆 (值相等) 和 is (对象身份/内存地址相等)，对于小整数和字符串，Python 会缓存，导致 a = 256; b = 256; a is b 可能为 True,但这不是可靠的规律。
  • 字符串和数字直接相加会报错 TypeError,必须先转换类型。

数据结构

这是 Python 的精髓,几乎必考。

列表

• 核心概念：有序、可变、允许重复元素的序列。

• 常见考点：

  1. 增删改查：append(), insert(), pop(), remove(), del 语句，索引 [] 和切片 [:]。
  2. 常用方法：len(), sort(), sorted(), reverse(), count(), index()。
  3. 列表推导式：简洁地创建列表,是高频考点。

• 示例代码：

  my_list = [3, 1, 2]
  my_list.append(4)      # [3, 1, 2, 4]
  my_list.pop()          # 返回 4, 列表变为 [3, 1, 2]
  my_list.sort()         # 列表变为 [1, 2, 3]
  new_list = [x**2 for x in my_list if x > 1]  # 列表推导式: [4, 9]

字典

• 核心概念：无序（Python 3.7+ 后按插入顺序）、键值对集合,键必须是不可变类型且唯一。

• 常见考点：

  1. 增删改查：dict['key'], dict.get(key, default), dict[key] = value, del dict[key], pop(key)。
  2. 常用方法：keys(), values(), items(), update()。
  3. 字典推导式：类似列表推导式,用于创建字典。

• 示例代码：

  my_dict = {'name': 'Alice', 'age': 25}
  print(my_dict.get('age'))       # 25
  print(my_dict.get('city', 'Unknown')) # Unknown (避免KeyError)
  my_dict['age'] = 26             # 修改
  my_dict['city'] = 'New York'    # 增加
  new_dict = {k: v for k, v in my_dict.items() if k != 'age'} # 字典推导式

元组

• 核心概念：有序、不可变的序列。

• 常见考点：

  1. 为什么需要元组？：作为字典的键、函数返回多个值时使用。
  2. “陷阱”：当元组中只有一个元素时，必须加逗号，否则类型会变成该元素的类型。t = (1,) 是元组，而 t = (1) 是整数。

• 示例代码：

  t = (1, 2, 'hello')
  # t[0] = 100 # 会报 TypeError
  # 单元素元组
  single_tuple = (1,) 
  print(type(single_tuple)) # <class 'tuple'>
  not_a_tuple = (1)
  print(type(not_a_tuple)) # <class 'int'>

集合

• 核心概念：无序、不可变（元素本身不可变）、唯一的元素集合。

• 常见考点：

  1. 常用操作：add(), remove(), discard(), union() (), intersection() (&), difference() ()。
  2. 去重：list(set(my_list)) 是快速去除列表重复元素的方法。

• 示例代码：

  set_a = {1, 2, 3}
  set_b = {3, 4, 5}
  print(set_a | set_b) # {1, 2, 3, 4, 5} 并集
  print(set_a & set_b) # {3} 交集

流程控制

条件语句

• 核心概念：if-elif-else。
• 常见考点：
  1. if 条件的真值：在 if 语句中，0, 0, (空字符串), [] (空列表), (空元组), (空字典), None 都被视为 False，其他视为 True。
  2. is vs ：判断 None 时用 if my_var is None:，而不是 if my_var == None:。

循环语句

• 核心概念：for 循环, while 循环, break, continue。

• 常见考点：

  1. for 循环与 range()：for i in range(5): 和 for i in range(2, 5): 的区别。
  2. for 循环与可迭代对象：for item in my_list:。
  3. while 循环与死循环：确保循环有明确的终止条件。
  4. break 和 continue 的区别：break 跳出整个循环，continue 跳过本次循环。

• 示例代码：

  # for 循环
  for i in range(3): # 0, 1, 2
      print(i)
  # 遍历列表索引和值
  for index, value in enumerate(['a', 'b', 'c']):
      print(f"Index: {index}, Value: {value}")

函数

函数定义与调用

• 核心概念：def 关键字，return 语句。

• 常见考点：

  1. 参数传递：Python 中一切皆对象，传递不可变对象（如整数、字符串）相当于值传递（实际是传递对象的引用，但对象内容不可改）；传递可变对象（如列表、字典）相当于引用传递,函数内部可以修改原对象。
  2. 返回值：没有 return 语句的函数默认返回 None。
  3. 作用域：LEGB 规则（Local, Enclosing, Global, Built-in）。

• 示例代码：

  # 参数传递示例
  def modify_list(my_list):
      my_list.append(4) # 修改了传入的列表
  my_list = [1, 2, 3]
  modify_list(my_list)
  print(my_list) # 输出 [1, 2, 3, 4]
  def modify_int(x):
      x = x + 1 # x 是一个局部变量，不影响外部的 x
  x = 10
  modify_int(x)
  print(x) # 输出 10

高阶函数

• 核心概念：函数作为参数或返回值。

• 常见考点：

  1. 匿名函数 lambda：语法 lambda arguments: expression。
  2. 内置高阶函数：map(), filter(), sorted()。列表推导式通常比 map 和 filter 更 Pythonic 且易读。

• 示例代码：

  # lambda
  add = lambda x, y: x + y
  print(add(2, 3)) # 5
  # map
  numbers = [1, 2, 3]
  squared = list(map(lambda x: x**2, numbers)) # [1, 4, 9]
  # 等价的列表推导式
  squared_comp = [x**2 for x in numbers] # [1, 4, 9]
  # filter
  evens = list(filter(lambda x: x % 2 == 0, numbers)) # [2]
  # 等价的列表推导式
  evens_comp = [x for x in numbers if x % 2 == 0] # [2]

面向对象编程

• 核心概念：类 (class)，对象 (object)，实例化，属性,方法。

• 常见考点：

  1. __init__ 构造方法：在创建对象时自动调用,用于初始化对象的属性。
  2. self 参数：代表类的实例本身,必须作为实例方法的第一参数。
  3. 类属性 vs 实例属性：类属性由所有实例共享,实例属性只属于当前实例。
  4. 继承：class Child(Parent):,子类继承父类的属性和方法。
  5. 方法重写：子类可以重新定义父类的方法。
  6. super() 函数：在子类中调用父类的方法。

• 示例代码：

  class Dog:
      # 类属性
      species = "Canis familiaris"
      def __init__(self, name, age):
          # 实例属性
          self.name = name
          self.age = age
      def bark(self):
          return f"{self.name} says Woof!"
  # 继承
  class JackRussellTerrier(Dog):
      def speak(self, sound="Arf"):
          return f"{self.name} says {sound}"
  buddy = Dog("Buddy", 9)
  miles = JackRussellTerrier("Miles", 4)
  print(miles.speak())      # Miles says Arf
  print(miles.speak("Grrr"))# Miles says Grrr
  print(isinstance(miles, Dog)) # True

文件操作与异常处理

文件操作

• 核心概念：使用 with open(...) 语句,它会自动处理文件的关闭。

• 常见考点：

  1. 打开模式：'r' (读), 'w' (写，覆盖), 'a' (追加), 'b' (二进制模式)。
  2. 读取方法：read(), readline(), readlines()。
  3. 写入方法：write()。

• 示例代码：

  # 写入文件
  with open('test.txt', 'w') as f:
      f.write("Hello, Python!\n")
      f.write("This is a test file.")
  # 读取文件
  with open('test.txt', 'r') as f:
      content = f.read()
      print(content)

异常处理

• 核心概念：使用 try-except-else-finally 结构来优雅地处理程序可能出现的错误。

• 常见考点：

  1. 捕获特定异常：try...except ValueError as e:。
  2. finally 块：无论是否发生异常都会执行，通常用于清理资源（如关闭文件）。
  3. raise 语句：主动抛出异常。

• 示例代码：

  try:
      num = int(input("请输入一个数字: "))
      result = 10 / num
  except ValueError:
      print("输入无效，请输入一个整数！")
  except ZeroDivisionError:
      print("错误：不能除以零！")
  else:
      print(f"计算结果是: {result}")
  finally:
      print("程序执行完毕。")

模块与包

• 核心概念：
  • 模块：一个 .py 文件。
  • 包：一个包含 __init__.py 文件的目录。
• 常见考点：
  1. 导入方式：import module, from module import func, from module import * (不推荐)。
  2. if __name__ == "__main__": 的作用：确保该部分代码只在作为主程序运行时执行,而不是被导入时执行。
  3. pip：Python 的包管理工具，用于安装第三方库（如 pip install requests）。

常用内置函数与“魔法方法”

常用内置函数

• len(), max(), min(), sum(), sorted(), enumerate(), zip(), range(), type(), isinstance(), open()。

“魔法方法” (Magic Methods / Dunder Methods)

• 核心概念：以双下划线 __ 开头和结尾的方法,用于自定义类的行为。
• 常见考点：
  1. __str__(self)：print(obj) 或 str(obj) 时调用,返回对用户的友好字符串。
  2. __repr__(self)：调试时调用，返回对开发者明确且无歧义的字符串，理想情况下 eval(repr(obj)) == obj。
  3. __len__(self)：len(obj) 时调用。
  4. __getitem__(self, key)：obj[key] 时调用,使对象支持索引。
  5. __init__ 和 __call__ 也是非常重要的魔法方法。

复习建议

1. 动手敲代码：不要只看不练，每个知识点都亲手写一遍示例，并尝试修改、扩展。
2. 理解原理：不仅要知其然，更要知其所以然，为什么列表推导式比 map 快？is 和 的根本区别是什么？
3. 做练习题：在 LeetCode、HackerRank、牛客网等平台上找一些 Python 基础题来做,巩固知识点。
4. 总结归纳：用自己的话总结每个模块的核心考点,形成知识体系。

祝你考试顺利,学习愉快！