Python 编程入门宝典：从基础语法到面向对象全攻略

Python 基础语法

一、环境准备

• 工具：Jupyter Notebook（在浏览器中运行，地址通常是 localhost:8888）。
• 内核：Python 3.x，这是目前广泛使用的版本。

二、语句与注释

• 语句：一行可执行代码，例如 print("Hello, World!")。
• 注释：
  • 单行注释：以 # 开头，用于解释代码。例如：

    # 这是一个单行注释
    print("Hello, World!")  # 输出 Hello, World!
    

  • 多行注释：使用三对双引号 """ 或三对单引号 '''。例如：

    """
    这是一个多行注释
    可以用来解释复杂的代码块
    """
    print("Hello, World!")
    

  • 快捷键：Ctrl + /，用于快速切换注释状态。

三、变量与赋值

• 定义：变量是存储数据的容器，首次赋值即创建变量。
• 命名规则：
  • 只能包含字母、数字、下划线，不能以数字开头。
  • 区分大小写，Variable 和 variable 是不同的变量。
  • 不能与关键字同名（如 False、None、if、for 等）。
• 命名风格：
  • 下划线法：hero_name（官方推荐）。
  • 小驼峰：heroName。
  • 大驼峰：HeroName（常用于类名）。
• 示例：

  # 正确的变量命名
  my_name = "Kimi"
  age = 25
  is_student = True
  
  # 错误的变量命名
  # 3name = "Kimi"  # 错误：以数字开头
  # class = "Python"  # 错误：使用关键字
  

四、基本数据类型

• 整型 int：表示整数。

  age = 18
  print(type(age))  # 输出 <class 'int'>
  

• 浮点型 float：表示小数。

  money = 99999.99
  print(type(money))  # 输出 <class 'float'>
  

• 字符串 str：表示文本，可以用单引号或双引号。

  name = "Kimi"
  greeting = 'Hello, World!'
  print(type(name))  # 输出 <class 'str'>
  

• 布尔型 bool：表示真或假。

  is_ok = True
  is_not_ok = False
  print(type(is_ok))  # 输出 <class 'bool'>
  

• 查看类型：使用 type() 函数。

  print(type(age))  # 输出 <class 'int'>
  print(type(money))  # 输出 <class 'float'>
  print(type(name))  # 输出 <class 'str'>
  print(type(is_ok))  # 输出 <class 'bool'>
  

五、输入与输出

• 输出：使用 print() 函数。

  print("Hello, World!")
  print("Age:", age)
  print("Name:", name)
  

• 输入：使用 input() 函数，返回字符串。

  user_name = input("请输入你的名字：")
  user_age = input("请输入你的年龄：")
  print("你好，", user_name, "，你今年", user_age, "岁了。")
  

  • 如果需要进行数值运算，需要将输入的字符串转换为数值类型：

    user_age = int(input("请输入你的年龄："))
    print("你明年将会是", user_age + 1, "岁。")
    

六、类型转换

• 整数转换：int(x) 将 x 转换为整数。

  num_str = "123"
  num_int = int(num_str)
  print(num_int)  # 输出 123
  

• 浮点数转换：float(x) 将 x 转换为浮点数。

  num_float = float(num_str)
  print(num_float)  # 输出 123.0
  

• 字符串转换：str(x) 将 x 转换为字符串。

  num_int = 123
  num_str = str(num_int)
  print(num_str)  # 输出 "123"
  

• 错误示例：

  my_number = "200"
  # 下面的代码会抛出 TypeError，因为字符串不能直接与整数相加
  # result = my_number + 100
  # 正确的做法是先将字符串转换为整数
  result = int(my_number) + 100
  print(result)  # 输出 300
  

七、易错点小结

• 变量名不能以数字开头：3name 是错误的。
• 不能使用关键字作为变量名：pass = 5 是错误的。
• 中英文符号混用：引号、括号需统一使用英文半角符号。
• 字符串拼接数字前需转换类型："100" + 200 会抛出 TypeError，需要先将字符串转换为整数。

八、课后练习

1. 用 input() 获取姓名、年龄、身高，格式化输出自我介绍：

   name = input("请输入你的姓名：")
   age = input("请输入你的年龄：")
   height = input("请输入你的身高：")
   print(f"你好，我叫{name}，今年{age}岁，身高{height}厘米。")
   

2. 创建变量保存今天日期，命名为 today_date，并用下划线法重命名所有旧变量：

   today_date = "2025-08-15"
   user_name = "Kimi"
   user_age = 25
   user_height = 175
   print(f"今天是{today_date}，我叫{user_name}，今年{user_age}岁，身高{user_height}厘米。")
   

3. 尝试故意触发一次 TypeError，并写出原因与修正方法：

   # 故意触发 TypeError
   # result = "100" + 200  # 会抛出 TypeError
   
   # 修正方法：将字符串转换为整数
   result = int("100") + 200
   print(result)  # 输出 300
   

Python 流程控制与循环

一、流程控制回顾

• 条件语句 if：

  user_age = 20
  if user_age >= 18:
      print("成年")
      print("你就可以干你想干的事情了")
  

• 比较 / 逻辑运算符：
  • 比较：==、!=、>、<、>=、<=
  • 逻辑：and、or、not

二、循环总览

Python 提供两种基本循环：while 和 for，均可用 break 和 continue 控制流程。

• break：立即终止整个循环。
• continue：提前结束本轮，直接进入下一轮。

三、while 循环

• 语法：

  while 条件:
      语句块
  

• 示例：打印 19 中的奇数：

  n = 0
  while n < 10:
      n += 1
      if n % 2 == 0:  # 偶数
          continue    # 跳过本轮
      print(n)        # 输出 1 3 5 7 9
  

• 示例：使用 break 提前结束：

  i = 0
  while i < 10:
      if i == 5:
          break
      print(i)        # 输出 0 1 2 3 4
      i += 1
  

四、for 循环

• 语法：

  for 变量 in 可迭代对象:
      语句块
  

  可迭代对象包括字符串、列表、range 等。
• 示例：遍历列表：

  names = ['Mike', 'HuaHua', 'Jay']
  for name in names:
      print(name)  # 输出 Mike HuaHua Jay
  

• range() 生成整数序列：
  • range(n)：生成从 0 到 n-1 的整数序列。
  • range(a, b)：生成从 a 到 b-1 的整数序列。
  • range(a, b, step)：生成从 a 到 b-1 的整数序列，步长为 step。

  for i in range(5):  # 生成 0 到 4
      print(i)        # 输出 0 1 2 3 4
  

• 示例：累加 110：

  s = 0
  for x in range(1, 11):  # 生成 1 到 10
      s += x
  print(s)  # 输出 55
  

五、break vs continue 小结

• break：循环的“紧急出口”，一旦执行，循环立刻结束。
• continue：循环的“快进键”，跳过剩余语句，直接开始下一轮。

六、易错点提醒

1. 忘记缩进：会导致 IndentationError。
2. 误把 = 写成 == 或反之：= 是赋值运算符，== 是比较运算符。
3. continue / break 写到循环外：会导致 SyntaxError。
4. range 右开区间：容易多写或少写 1。

七、练习任务

1. 用 while 打印 100 以内的所有偶数：

   n = 0
   while n < 100:
       n += 1
       if n % 2 != 0:  # 奇数
           continue
       print(n)        # 输出 2 4 6 ... 100
   

2. 用 for + range 计算 1100 的和：

   s = 0
   for x in range(1, 101):  # 生成 1 到 100
       s += x
   print(s)  # 输出 5050
   

3. 在 1100 的循环中，遇到能被 7 整除的数字时跳过，遇到 42 时立刻停止，统计实际打印了多少个数字：

   count = 0
   for x in range(1, 101):
       if x == 42:
           break
       if x % 7 == 0:
           continue
       print(x)
       count += 1
   print("实际打印了", count, "个数字")
   

八、一句话总结

基础语法是地基，循环控制是骨架；多敲代码、多调试，肌肉记忆自然来。

Python 字符串操作

一、字符串的四大类常用操作

1. 查（find / index）：
   • find(sub[, start, end])：找到返回索引，找不到返回 -1。
   • index(sub[, start, end])：同上，但找不到抛异常。

   my_str = "hello world kkb"
   print(my_str.find("kkb"))  # 输出 12
   print(my_str.find("kkb", 9, 10))  # 输出 -1
   print(my_str.index("kkb"))  # 输出 12
   # print(my_str.index("kkb", 9, 10))  # 抛出 ValueError
   

2. 增（join）：
   • sep.join(iterable)：用 sep 把可迭代对象里的每个元素串成一个新字符串。

   my_str2 = 'ILoveKKB'
   print('-'.join(my_str2))  # 输出 I-L-o-v-e-K-K-B
   

3. 删（strip 系列）：
   • strip()：去首尾空白（或指定字符）。
   • lstrip()：去左侧空白。
   • rstrip()：去右侧空白。

   my_str3 = '  k k b  '
   print(my_str3.strip())  # 输出 'k k b'
   print(my_str3.lstrip())  # 输出 'k k b  '
   print(my_str3.rstrip())  # 输出 '  k k b'
   

4. 改（replace / 大小写转换 / 对齐填充）：
   • replace(old, new[, count])：替换指定次数，缺省 count 则全部替换。
   • lower() / upper()：全小写 / 全大写。
   • capitalize()：首字母大写，其余小写。
   • title()：每个单词首字母大写。
   • center(width) / ljust(width) / rjust(width)：居中对齐 / 左对齐 / 右对齐，用空格填充到指定宽度。
   • partition(sep) / rpartition(sep)：把字符串分成 (head, sep, tail) 三元组，区别在于方向。

   my_str = 'hello world kkb'
   print(my_str.replace('kkb', 'KKB'))  # 输出 hello world KKB
   print(my_str.lower())  # 输出 hello world kkb
   print(my_str.upper())  # 输出 HELLO WORLD KKB
   print(my_str.capitalize())  # 输出 Hello world kkb
   print(my_str.title())  # 输出 Hello World Kkb
   print(my_str.center(20))  # 输出 '   hello world kkb   '
   print(my_str.ljust(20))  # 输出 'hello world kkb       '
   print(my_str.rjust(20))  # 输出 '       hello world kkb'
   print(my_str.partition(' '))  # 输出 ('hello', ' ', 'world kkb')
   print(my_str.rpartition(' '))  # 输出 ('hello world', ' ', 'kkb')
   

二、下标与切片

• 下标：从 0 开始，负下标从 -1 开始（倒数）。
• 切片语法：s[start:stop:step]。

  my_str = 'welcomekkb'
  print(my_str[0:3])  # 输出 'wel'
  print(my_str[::2])  # 输出 'wlcek'
  print(my_str[::-1])  # 输出 'bkkemoclew'（逆序）
  

三、易错 & 面试点

1. replace 不会修改原字符串：字符串是不可变对象，replace 返回新字符串。
2. find 与 index 的区别：find 找不到返回 -1，index 找不到抛 ValueError。
3. join 的对象必须是字符串组成的可迭代对象：如果列表中有数字，需要先用 map(str, iterable) 转换。
4. 切片区间为左闭右开：[start, stop)。

四、一句话总结

字符串在 Python 中是不可变对象，所有“修改”操作都只是生成新的字符串；牢记“增删改查”四类方法名和返回值，面试手写代码不丢分。

Python 数据容器

一、列表（list）

• 特点：有序、可变、可重复。
• 创建：

  lst = [1, 'a', True]  # 字面量
  lst2 = list('abc')    # ['a', 'b', 'c']
  

• 增：
  • append(obj)：尾部追加。
  • extend(iterable)：批量追加。
  • insert(idx, obj)：在指定索引处插入。

  lst = [1, 2, 3]
  lst.append(4)  # [1, 2, 3, 4]
  lst.extend([5, 6])  # [1, 2, 3, 4, 5, 6]
  lst.insert(0, 0)  # [0, 1, 2, 3, 4, 5, 6]
  

• 删：
  • del lst[idx]：按索引删除。
  • lst.remove(value)：按值删除（删除第一个匹配项）。
  • lst.pop([idx])：弹出指定索引的元素（缺省为尾部）。
  • lst.clear()：清空列表。

  lst = [0, 1, 2, 3, 4, 5, 6]
  del lst[0]  # [1, 2, 3, 4, 5, 6]
  lst.remove(3)  # [1, 2, 4, 5, 6]
  lst.pop()  # [1, 2, 4, 5]，返回 6
  lst.clear()  # []
  

• 改：

  lst = [1, 2, 3]
  lst[1] = 10  # [1, 10, 3]
  

• 查：
  • value in lst：布尔判断。
  • lst.index(value[, start, end])：返回值的索引。
  • lst.count(value)：返回值的出现次数。

  lst = [1, 2, 3, 2, 4]
  print(2 in lst)  # True
  print(lst.index(2))  # 1
  print(lst.count(2))  # 2
  

• 排序：
  • lst.sort(key=..., reverse=bool)：原地排序。
  • sorted(iterable)：返回新列表。
  • lst.reverse()：原地逆置。

  lst = [3, 1, 2]
  lst.sort()  # [1, 2, 3]
  lst.reverse()  # [3, 2, 1]
  new_lst = sorted(lst)  # [1, 2, 3]
  

二、元组（tuple）

• 特点：有序、不可变、可重复。
• 创建：

  t = (1, 'a')  # 逗号是关键
  t = 1,  # 单元素必须尾随逗号
  empty = ()  # 空元组
  

• 只读操作：与列表类似，但不能修改。

  t = (1, 2, 3)
  print(t[1])  # 2
  print(t.index(2))  # 1
  print(t.count(2))  # 1
  

• 注意：元组里的可变对象（如列表）可以修改其内容，但整体地址不变。

  t = ('a', 'b', ['x', 'y'])
  t[2][0] = 'X'  # 合法，元组内容变为 ('a', 'b', ['X', 'y'])
  

三、字典（dict）

• 特点：键唯一、无序（3.7 起插入序）、可变。
• 创建：

  d = {'name': 'Alice', 'age': 18}
  d = dict(name='Alice', age=18)
  

• 增 / 改：
  • d[key] = value：键存在则改，不存在则增。
  • d.setdefault(k, default)：若键不存在则设默认值并返回。
  • d.update(iterable_or_dict)：更新字典。

  d = {'name': 'Alice', 'age': 18}
  d['gender'] = 'Female'  # 增加键值对
  d['age'] = 20  # 修改键值
  d.setdefault('height', 165)  # 增加键值对，返回 165
  d.update({'weight': 50})  # 更新字典
  

• 删：
  • del d[key]：删除键值对。
  • d.pop(key[, default])：弹出键值对并返回值。
  • d.clear()：清空字典。

  d = {'name': 'Alice', 'age': 18}
  del d['age']  # 删除键值对
  print(d.pop('name'))  # 返回 'Alice'，字典变为 {}
  d.clear()  # 清空字典
  

• 查：
  • d[key]：直接访问，键不存在抛异常。
  • d.get(key[, default])：安全取值，键不存在返回默认值。
  • key in d：布尔判断。
  • d.keys() / d.values() / d.items()：返回键、值、键值对。

  d = {'name': 'Alice', 'age': 18}
  print(d['name'])  # Alice
  print(d.get('age'))  # 18
  print(d.get('height', 'Unknown'))  # Unknown
  print('name' in d)  # True
  print(list(d.keys()))  # ['name', 'age']
  print(list(d.values()))  # ['Alice', 18]
  print(list(d.items()))  # [('name', 'Alice'), ('age', 18)]
  

四、集合（set）

• 特点：无序、不重复、可变。
• 创建：

  s = {1, 2, 3}  # 字面量
  s = set([1, 2, 3])  # 去重
  empty = set()  # 注意不是 {}
  

• 增：
  • s.add(elem)：添加单个元素。
  • s.update(iterable)：批量添加。

  s = {1, 2, 3}
  s.add(4)  # {1, 2, 3, 4}
  s.update([5, 6])  # {1, 2, 3, 4, 5, 6}
  

• 删：
  • s.remove(elem)：删除元素，元素不存在抛异常。
  • s.discard(elem)：安全删除，元素不存在不抛异常。
  • s.pop()：随机弹出一个元素。
  • s.clear()：清空集合。

  s = {1, 2, 3}
  s.remove(2)  # {1, 3}
  s.discard(4)  # 不抛异常
  print(s.pop())  # 随机弹出一个元素，例如 1，集合变为 {3}
  s.clear()  # 清空集合
  

• 集合运算：
  • &：交集。
  • |：并集。
  • -：差集。
  • ^：对称差集。

  set1 = {1, 2, 3}
  set2 = {2, 3, 4}
  print(set1 & set2)  # {2, 3}
  print(set1 | set2)  # {1, 2, 3, 4}
  print(set1 - set2)  # {1}
  print(set1 ^ set2)  # {1, 4}
  

五、典型面试 3 连问

1. list 与 tuple 区别？
   • 可不可变：list 可变，tuple 不可变。
   • 内存开销：tuple 通常比 list 更节省内存。
   • 能否做 dict 键：tuple 可以作为字典的键，list 不可以。
2. dict 为什么查找快？
   • 哈希表，平均时间复杂度为 O(1)。
3. set 和 list 去重哪个更快？
   • set 直接哈希去重，时间复杂度 O(n)。

六、一句话总结

数据容器是 Python 编程中的重要组成部分，掌握它们的创建、增删改查操作以及各自的特性，能够帮助你更高效地处理数据。

Python 面向对象与模块

一、核心概念速记

1. 类（Class）：模具。
2. 对象（Instance）：用模具生产出的实体。
3. 三大特性：
   • 封装：将属性和方法打包，访问控制靠 _ 或 __ 约定。
   • 继承：单继承 class Child(Parent):，多继承 class Child(P1, P2):，同名方法按 MRO（Method Resolution Order，方法解析顺序）查找。
   • 多态：不同子类重写同一方法，外部统一接口调用，结果不同。

二、语法模板

class Hero(object):
    # 类属性（所有对象共享）
    family = "HERO"

    # 初始化属性
    def __init__(self, name, hp):
        self.name = name  # 实例属性
        self.hp = hp

    # 实例方法（隐式 self）
    def move(self):
        print("正在前往事发地点...")

    # 魔术方法示例
    def __str__(self):
        return f"{self.name}({self.hp})"

三、对象使用技巧

1. 创建对象：

   gailun = Hero("盖伦", 2600)
   

2. 动态增删属性：

   gailun.sex = "男"  # 添加属性
   del gailun.sex  # 删除属性
   

3. 方法共享、属性独立：

   print(id(gailun.move) == id(blind.move))  # True，方法同地址
   print(id(gailun.name) == id(blind.name))  # False，属性各不同
   

四、模块与包

1. 自定义模块：
   • 文件 first_module.py：

     __all__ = ["g_num", "show"]
     g_num = 10
     def show():
         print("我是一个函数")
     

   • 使用：

     from first_module import *
     print(g_num)  # 10
     show()  # 输出 我是一个函数
     

2. 第三方模块：

   import math, time, random
   print(math.pi)  # 3.141592653589793
   print(time.time())  # 当前时间戳
   print(random.randint(1, 10))  # 随机整数
   

五、易错点提醒

• 双下划线方法（如 __init__、__str__）不要写错成单下划线。
• 多继承时若出现同名方法，记住“左优先”+ MRO 规则，可用 ClassName.__mro__ 查看顺序。
• 模块的 if __name__ == "__main__": 用作测试入口，避免被导入时执行。

六、思维导图快照

• 类 → 对象 → 属性（独立）/ 方法（共享）
• 继承 → 单继承 → 多继承 → MRO
• 多态 → 重写 → 统一接口调用
• 模块 → 自定义（__all__）→ 第三方（import）

七、一句话总结

面向对象和模块化是 Python 编程中的高级概念，掌握它们可以帮助你更好地组织代码，提高代码的可读性和可维护性。

Python 基础语法 & 标准库速记

一、环境一句话

Jupyter Notebook（localhost:8888）➕ Typora 做双屏：左边跑代码，右边写 Markdown 笔记，效率翻倍。

二、语法三件套

• 语句：print("hello")
• 单行注释：# 注释
• 多行注释：""" 注释 """ 或 ''' 注释 '''
• 快捷键：选中行后 Ctrl + / 快速开关注释。

三、变量踩坑提示

• 只能字母/数字/下划线，且不能数字开头。
• Python 是动态类型，随时 type(x) 查看真实身份。

四、模块 & 文件形态

• .ipynb：Jupyter 交互笔记本。
• .py：纯模块文件，可被 import。
• 包（package）：带 __init__.py 的文件夹，层级化管理模块。

五、必会标准库两兄弟

1. math：数学运算

   import math
   print(math.pi)  # 3.141592653589793
   print(math.ceil(2.1))  # 3
   print(math.floor(2.8))  # 2
   print(math.fsum([0.1] * 10))  # 1.0，精度高于 sum
   

2. time：时间戳 & 格式化

   import time
   ticks = time.time()  # 当前时间戳
   lt = time.localtime()  # 当前时间元组
   print(time.strftime("%Y-%m-%d %H:%M:%S", lt))  # 格式化时间
   time.sleep(5)  # 阻塞 5 秒
   

六、今日金句

“不要贪多，所有代码都手敲三遍，运行三遍，改错三遍。”

七、一句话总结

这些笔记内容系统地介绍了 Python 编程的基础知识，通过实际操作和练习，可以更好地掌握这些知识点。希望这份笔记能帮助你快速入门 Python 编程！