Python 基础语法笔记.1

一、基础语法

1. 变量和数据类型

• 变量：

  • 定义：通过赋值创建，如 name = "Alice"（动态类型，无需声明类型）。
  • 命名规则：字母 / 数字 / 下划线，不能数字开头（如 age1 合法，1age 非法），区分大小写（Name ≠ name），避免关键字（如 if、else）。
  • 赋值技巧：
    • 多变量赋值：a, b = 1, 2（解包）；交换变量 a, b = b, a。
    • 可变对象陷阱：默认参数用 None 初始化（如 def func(lst=None): if lst is None: lst = []）。
  • 类型转换：int("123")（字符串转整数）、float(3)（整数转浮点）、str(1.5)（浮点转字符串）、bool(0)（0 转 False，非 0 转 True）。

• 数据类型：

  • 数字：int（整数，无长度限制）、float（浮点，如 3.14）、complex（复数，如 1+2j）。
  • 字符串：不可变序列，用 '、" 或 """/'''（多行）定义，支持索引（s[0]）和切片（s[1:3]）。
  • 布尔：True/False，隐式转换（空字符串、0、空列表等为 False，非空为 True）。

2. 运算符

• 算术运算符：

  • +（加）、-（减）、*（乘）、/（浮点除，10/3=3.333…）、%（取余，10%3=1）、**（幂，2**3=8）、//（取整，10//3=3，负数向下取整）。

• 比较运算符：

  • ==（值相等）、!=（值不等）、>/</>=/<=（大小比较），返回布尔值。注意：不同类型（如 1 和 '1'）不可直接比较（Python 3 报错）。

• 赋值运算符：

  • =（赋值）、+=（a += 1 等价 a = a + 1）、*=/%= 等复合赋值，支持链式赋值（a = b = 1）。

• 逻辑运算符：

  • and（短路，全为真才真，返回实际值）、or（短路，有真则真，返回实际值）、not（取反）。
    示例：1 and 2 → 2，0 or 3 → 3。

• 位运算符：

  • 处理整数二进制位：&（按位与）、|（按位或）、^（异或）、~（取反）、<<（左移）、>>（右移）。
    示例：6 (0b110) << 1 → 12 (0b1100)。

• 成员运算符：

  • in（判断元素是否在容器中，如 'a' in "abc"）、not in（相反）。字典判断键是否存在（如 'k' in {'k':1}）。

3. 字符串操作

• 创建：

  • 单 / 双引号：s = 'Hello' 或 "Hello"（嵌套时切换引号，如 "I'm OK"）。
  • 三引号：s = """多行文本"""（保留换行和缩进）。

• 访问：

  • 索引：s[0]（首字符）、s[-1]（末字符）。
  • 切片：s[1:3]（左闭右开，取索引 1、2），s[::2]（步长 2，隔字符取），s[::-1]（反转）。

• 运算：

  • 连接："Hello" + "World"（低效，大量连接用 ''.join()）。
  • 重复："Hi" * 3 → "HiHiHi"。
  • 比较：按字符 ASCII 码比较（如 "A" < "B" 为 True）。

• 方法（常用）：

  • find(sub, start, end)：找子串索引，无则返回 -1。
  • replace(old, new)：替换子串。
  • split(sep, maxsplit)：按分隔符分割（默认空格），返回列表。
  • join(iterable)：用字符串连接可迭代对象（高效）。
  • strip(chars)：去除首尾空白（或指定字符，如 s.strip('@') 去除首尾 @）。
  • lower()/upper()：转小写 / 大写。
  • startswith(prefix)/endswith(suffix)：判断开头 / 结尾。

4. 列表、元组、字典

• 列表（list，可变序列）：

  • 定义：lst = [1, 2, 3] 或 list()。
  • 操作：
    • 访问：索引、切片（同字符串）。
    • 添加：append(4)（末尾，高效）、insert(1, 5)（位置 1 插入 5，低效）、extend([6,7])（扩展列表）。
    • 删除：del lst[0]（按索引删）、pop(1)（删索引 1 并返回，默认末位）、remove(2)（删第一个 2）。
    • 方法：sort()（排序，key=len 按长度排）、reverse()（反转）、count(2)（元素 2 的次数）、index(2)（元素 2 的索引）。

• 元组（tuple，不可变序列）：

  • 定义：tup = (1, 2, 3) 或 tuple()，单元素需加逗号（tup = (1,)）。
  • 操作：
    • 访问：索引、切片（同字符串，但不可修改）。
    • 方法：count(2)（次数）、index(2)（索引）。
  • 特性：可作为字典键（列表不行，因可变），解包方便（a, b, c = tup）。

• 字典（dict，键值对，可变）：

  • 定义：d = {'k1':1, 'k2':2} 或 dict()。
  • 操作：
    • 访问：d['k1']（键存在则返回，否则报错）、d.get('k3', 0)（键不存在返回 0，避免报错）。
    • 添加 / 修改：d['k3'] = 3（新增）、d['k1'] = 10（修改）。
    • 删除：del d['k1']（删键）、d.pop('k2')（删键并返回值）、d.clear()（清空）。
    • 方法：keys()（键列表）、values()（值列表）、items()（键值对元组列表，如 for k, v in d.items()）、update({'k4':4})（合并字典）。

二、控制结构

1. 条件语句（if/elif/else）

• 语法：

  if 条件1:  
      代码块1  
  elif 条件2:  
      代码块2  
  else:  
      代码块3  
  

• 要点：条件可嵌套，elif 可多个；条件为布尔表达式（或隐式转换为布尔）。

2. 循环语句

• for 循环：

  • 遍历可迭代对象（列表、字符串、range 等）：

    for i in range(5):  # 0-4  
        print(i)  
    for k, v in d.items():  # 遍历字典键值对  
        print(k, v)  
    

  • else 子句：循环正常结束（未被 break 打断）时执行。

• while 循环：

  • 语法：

    while 条件:  
        代码块  
        if 终止条件:  
            break  # 跳出循环  
        continue  # 跳过当前迭代  
    else:  
        循环正常结束时执行  
    

  • 要点：需确保条件最终为 False，避免死循环。

3. 异常处理（try/except/else/finally）

• 语法：

  try:  
      可能出错的代码  
  except 异常类型1 as e:  # 捕获特定异常  
      处理逻辑1  
  except (异常类型2, 异常类型3) as e:  # 捕获多个异常  
      处理逻辑2  
  else:  
      无异常时执行  
  finally:  
      无论是否异常都执行（如释放资源）  
  

• 示例：除零异常

  python

  try:  
      result = 1 / 0  
  except ZeroDivisionError as e:  
      print("除零错误：", e)  
  finally:  
      print("程序结束")  
  

三、函数

1. 定义和调用

• 语法：

  def 函数名(参数):  
      """文档字符串（可选，解释功能）"""  
      代码块  
      return 返回值  # 可返回多个值（元组解包，如 return 1, 2）  
  

• 调用：result = 函数名(参数)，支持嵌套调用。

2. 参数传递

• 位置参数：按顺序传参（如 func(1, 2)）。
• 关键字参数：按名称传参（如 func(a=1, b=2)），可混合位置参数（位置参数在前）。
• 默认参数：def func(a, b=10)（默认参数放末尾，避免可变对象陷阱）。
• 可变参数：
  • *args：接收任意位置参数为元组（如 def func(*args): print(args)）。
  • **kwargs：接收任意关键字参数为字典（如 def func(**kwargs): print(kwargs)）。

3. 返回值

• 无显式 return 则返回 None。
• 多返回值通过元组解包实现（如 a, b = func()，实际返回 (a, b)）。

四、面向对象编程

1. 类和对象

• 定义类：

  class Person:  
      # 类变量（所有实例共享）  
      species = "Human"  
      def __init__(self, name, age):  # 构造方法，初始化实例变量  
          self.name = name  # 实例变量  
          self.age = age  
      def speak(self):  # 实例方法，第一个参数为 self（当前实例）  
          print(f"I'm {self.name}, {self.age} years old.")  
  

• 创建对象：p = Person("Alice", 25)，调用方法 p.speak()。

2. 继承和多态

• 继承：

  class Student(Person):  # 继承 Person  
      def __init__(self, name, age, grade):  
          super().__init__(name, age)  # 调用父类构造方法  
          self.grade = grade  
      def speak(self):  # 重写父类方法，体现多态  
          print(f"I'm {self.name}, a {self.grade} student.")  
  

• 多态：不同子类实例调用同一方法（如 speak），行为不同（Person 和 Student 的 speak 输出不同）。

3. 封装和抽象

• 封装：
  • 私有属性：双下划线开头（如 __name），实际为名字修饰（_类名__name），外部不可直接访问，需通过方法操作（如 get_name()/set_name()）。
  • 约定私有：单下划线开头（如 _name），仅为提示，外部仍可访问。
• 抽象：
  • 抽象类：通过 abc 模块定义，含抽象方法（@abstractmethod 装饰），子类必须实现抽象方法，否则无法实例化。

五、模块和包

1. 导入和使用

• 导入模块：
  • import 模块名（如 import os），调用 os.listdir()。
  • from 模块 import 函数/类（如 from os import path），直接调用 path.exists()。
  • import 模块 as 别名（如 import numpy as np）。
• 避免循环导入：拆分模块功能，或用延迟导入。

2. 自定义模块

• 新建 .py 文件（如 mymodule.py），定义函数 / 类，通过 import mymodule 导入。

3. 包的结构

• 包是含 __init__.py 的目录（Python 3.3+ 可选，但建议保留），用于组织模块。
• 导入包内模块：from mypackage.module import func，__init__.py 可初始化包（如导入子模块）。

六、文件操作

1. 打开和关闭

• 语法：

  # 方式1：手动关闭  
  f = open("file.txt", "r", encoding="utf-8")  
  f.close()  
  # 方式2：自动关闭（推荐）  
  with open("file.txt", "w") as f:  
      f.write("Hello")  
  

• 模式：r（读，默认）、w（写，覆盖）、a（追加）、rb/wb（二进制）、r+（读写）等。

2. 读写文件

• 读操作：
  • f.read()：读全部内容。
  • f.readline()：读一行。
  • f.readlines()：读所有行到列表（大文件建议逐行读：for line in f:）。
• 写操作：
  • f.write("内容")：写字符串。
  • f.writelines(["行1", "行2"])：写多行。

3. 文件指针

• f.tell()：返回当前指针位置（字节数）。
• f.seek(offset, whence)：移动指针，whence=0（开头，默认）、1（当前）、2（末尾）。

七、常用库

1. OS 库（操作文件 / 目录）

• 常用函数：
  • os.listdir()：列目录。
  • os.mkdir()：建目录（单级），os.makedirs()：建多级目录。
  • os.remove()：删文件，os.rmdir()：删空目录。
  • os.path.exists(path)：判断路径是否存在。
  • os.path.join(dir, file)：跨平台拼接路径。

2. 时间库（time/datetime）

• time 模块：
  • time.sleep(1)：休眠 1 秒。
  • time.time()：返回时间戳（秒数）。
• datetime 模块：
  • datetime.datetime.now()：获取当前时间。
  • datetime.timedelta(days=1)：时间间隔，支持加减（如 now + timedelta）。
  • 格式化：now.strftime("%Y-%m-%d %H:%M:%S")。

3. 随机数库（random）

• 常用函数：
  • random.randint(1, 10)：生成 1-10 随机整数。
  • random.random()：生成 0-1 随机浮点数。
  • random.shuffle(lst)：打乱列表。
  • random.seed(0)：设置随机种子（复现结果）。

4. 正则表达式库（re）

• 常用函数：
  • re.match(pattern, s)：从开头匹配，re.search(pattern, s)：任意位置匹配。
  • re.findall(pattern, s)：找所有匹配项。
  • 正则语法：
    • 元字符：\d（数字）、\w（字母 / 数字 / 下划线）、.（任意字符）。
    • 量词：+（至少 1 次）、*（任意次）、?（非贪婪匹配）。
  • 示例：re.findall(r"\d+", "age: 25") → ["25"]。