Python3 学习笔记6-os 模块、错误和异常、面向对象编程、类的专有方法、命名空间和作用域、Python 3的标准库

最新推荐文章于 2025-08-21 14:39:36 发布

原创最新推荐文章于 2025-08-21 14:39:36 发布 · 1.6k 阅读

15 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

python

（1）__init__(self, ...):

（2）__del__(self):

（3）__repr__(self):

（4）__setitem__(self, key, value):

（5）__getitem__(self, key):

（6）__len__(self):

（7）__cmp__(self, other):

（8）__call__(self, ...):

（9）__add__(self, other):

（6）global和nonlocal关键字：

xml.etree.ElementTree模块：

一、`os` 模块：

os 模块是 Python 的标准库之一，它提供了丰富的方法来处理文件和目录，以及执行与操作系统相关的操作。

常用方法：

os.access(path, mode)：检查指定路径的文件权限。
os.chdir(path)：改变当前工作目录到指定路径。
os.chflags(path, flags)：更改文件的标记（仅限于Unix）。
os.chmod(path, mode)：更改文件的权限。
os.chown(path, uid, gid)：更改文件的所有者和组。
os.chroot(path)：更改当前进程的根目录（仅限于Unix）。
os.close(fd)：关闭文件描述符。
os.closerange(fd_low, fd_high)：关闭指定范围内的所有文件描述符。
os.dup(fd)：复制文件描述符。
os.dup2(fd, fd2)：将文件描述符复制到另一个。
os.fchdir(fd)：通过文件描述符改变当前工作目录（仅限于Unix）。
os.fchmod(fd, mode)：更改文件描述符指定的文件权限。
os.fchown(fd, uid, gid)：更改文件描述符指定的文件的所有者。
os.fdatasync(fd)：将文件描述符指定的文件数据同步写入磁盘。
os.fdopen(fd[, mode[, bufsize]])：通过文件描述符创建文件对象。
os.fpathconf(fd, name)：返回打开文件的系统配置信息。
os.fstat(fd)：返回文件描述符的状态。
os.fstatvfs(fd)：返回文件描述符的文件系统信息。
os.fsync(fd)：将文件描述符指定的文件同步写入硬盘。
os.ftruncate(fd, length)：裁剪文件描述符指定的文件。
os.getcwd()：返回当前工作目录。
os.getcwdb()：返回当前工作目录的字节字符串形式。
os.isatty(fd)：检查文件描述符是否与tty设备相连。
os.lchflags(path, flags)：类似于chflags，但不追踪软链接。
os.lchmod(path, mode)：修改链接文件的权限。
os.lchown(path, uid, gid)：类似于chown，但不追踪软链接。
os.link(src, dst)：创建硬链接。
os.listdir(path)：列出指定路径下的文件和目录。
os.lseek(fd, pos, how)：设置文件描述符的当前位置。
os.lstat(path)：类似于stat，但解析软链接。
os.major(device)：从设备号中提取主设备号。
os.makedev(major, minor)：创建设备号。
os.makedirs(path[, mode])：递归创建目录。
os.minor(device)：从设备号中提取次设备号。
os.mkdir(path[, mode])：创建目录。
os.mkfifo(path[, mode])：创建命名管道。
os.mknod(filename[, mode=0600, device])：创建文件系统节点。
os.open(file, flags[, mode])：打开文件。
os.openpty()：打开伪终端。
os.pathconf(path, name)：返回文件的系统配置信息。
os.pipe()：创建管道。
os.popen(command[, mode[, bufsize]])：执行命令并打开管道。
os.read(fd, n)：从文件描述符读取数据。
os.readlink(path)：读取软链接的路径。
os.remove(path)：删除文件。
os.removedirs(path)：递归删除目录。
os.rename(src, dst)：重命名文件或目录。
os.renames(old, new)：递归重命名目录。
os.rmdir(path)：删除空目录。
os.stat(path)：获取文件状态。
os.stat_float_times([newvalue])：控制stat_result是否以浮点数显示时间戳。
os.statvfs(path)：获取文件系统的统计信息。
os.symlink(src, dst)：创建软链接。
os.tcgetpgrp(fd)：获取与终端关联的进程组。
os.tcsetpgrp(fd, pg)：设置与终端关联的进程组。
os.tempnam([dir[, prefix]])：已在Python 3中删除，用于创建临时文件。
os.tmpfile()：已在Python 3中删除，用于创建临时文件。
os.tmpnam()：已在Python 3中删除，用于获取临时文件名。
os.ttyname(fd)：获取与文件描述符关联的终端名。
os.unlink(path)：删除文件。
os.utime(path, times)：设置文件的访问和修改时间。
os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])：遍历目录树。
os.write(fd, str)：写入数据到文件描述符。
os.path 模块：用于处理文件路径。
os.pardir：表示父目录。
os.replace()：重命名文件或目录。
os.startfile()：在Windows上打开文件或文件夹。

二、错误和异常：

在Python中，错误和异常是程序运行时可能出现的问题。理解它们的区别和如何处理它们是编写健壮Python程序的关键。

（1）语法错误：

语法错误（SyntaxError）是在代码编写时犯的错误，通常是由于不符合Python的语法规则造成的。例如，缺少括号、冒号、逗号或其他语法元素。

# 错误的代码示例
while True print('Hello world')  # 缺少冒号

（2）异常：

异常（Exception）是程序运行时发生的错误，它们通常是由不正确的操作或外部因素引起的。Python中的异常是Exception类或其子类的实例。

# 异常示例
try:
    # 这将触发除以零的异常
    result = 10 / 0
except ZeroDivisionError:
    print("不能除以零")

（3）异常处理：

Python使用try和except关键字来处理异常。try块中的代码是潜在会抛出异常的代码，而except块则是用来捕获并处理特定类型的异常。

# 异常处理示例
try:
    # 尝试将用户输入转换为整数
    x = int(input("请输入一个数字: "))
except ValueError:
    print("输入错误，请确保你输入的是一个整数！")

（4）抛出异常：

在Python中，可以使用raise关键字主动抛出一个异常。

# 抛出异常的示例
x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

（5）用户自定义异常：

用户可以创建自己的异常类型，通常是通过继承内置的Exception类来实现。

# 用户自定义异常示例
class MyError(Exception):
    def __init__(self, value):
        self.value = value

try:
    raise MyError(2 * 2)
except MyError as e:
    print('我的异常发生了，值:', e.value)

（6）清理行为：

finally子句是try语句的一部分，无论是否发生异常，都会执行finally块中的代码。这常用于执行清理操作，如关闭文件。

# 清理行为示例
try:
    f = open('myfile.txt', 'r')
    data = f.read()
except IOError:
    print("文件读取错误")
finally:
    print("执行清理操作")
    f.close()

（7）with语句：

with语句是Python中的上下文管理器，它确保代码块执行完毕后，会自动调用资源的清理代码（如文件的关闭）。

# with语句示例
with open('myfile.txt', 'r') as f:
    for line in f:
        print(line, end="")
# 文件会在with语句块结束时自动关闭

三、面向对象编程：

面向对象编程（OOP）是一种编程范式，它使用类和对象来设计应用程序和操作系统。在Python中，OOP的核心概念包括类、对象、继承、封装和多态。

（1）类和对象：

类是创建对象的蓝图，它定义了一组属性（变量）和方法（函数）。对象是类的实例，每个对象都可以拥有不同的属性值。

# 定义一个类
class Dog:
    def __init__(self, name, age):  # 构造函数
        self.name = name  # 实例变量
        self.age = age

    def bark(self):  # 方法
        print("Woof!")

# 创建对象
my_dog = Dog("Buddy", 3)
my_dog.bark()  # 调用方法
print(f"My dog's name is {my_dog.name} and he is {my_dog.age} years old.")

（2）继承：

继承允许创建基于现有类的新的类。新的类（子类）可以继承现有类（基类）的属性和方法。

# 定义基类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass  # 基类中的占位方法

# 定义子类，继承自Animal
class Dog(Animal):
    def speak(self):  # 重写方法
        print(f"{self.name} says Woof!")

# 创建子类的对象
my_dog = Dog("Buddy")
my_dog.speak()  # 调用重写的方法

（3）封装：

封装是将数据（属性）和行为（方法）捆绑在一起，并隐藏内部实现的细节。在Python中，通过在属性名前加双下划线来实现私有属性。

class BankAccount:
    def __init__(self, owner, balance=0):
        self.__owner = owner  # 私有属性
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return amount
        else:
            print("Insufficient funds")

    def get_balance(self):
        return self.__balance

# 创建对象
account = BankAccount("John", 1000)
account.deposit(500)
print(account.get_balance())  # 正确的方式访问私有属性
# print(account.__balance)  # 错误的方式，会引发属性错误

（4）多态：

多态是指对象可以采用多种形态的能力。在Python中，多态是通过方法重写实现的。

# 定义基类
class Animal:
    def speak(self):
        pass

# 定义子类
class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

# 创建对象
animals = [Dog(), Cat()]

# 多态的体现
for animal in animals:
    animal.speak()

（5）运算符重载：

Python允许重载特殊的方法名来实现运算符的自定义行为。

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(3, 4)
v3 = v1 + v2
print(v3)  # 输出: (5, 7)

四、类的专有方法：

在Python中，类的专有方法（也称为魔术方法或双下方法）是一些有特殊意义的内置方法，它们在特定的操作或内置函数被调用时自动执行。

`（1）init(self, ...)`:

构造函数，当一个实例被创建时调用，用于初始化对象。

class MyClass:
    def __init__(self, value):
        self.value = value

`（2）del(self)`:

析构函数，当一个实例被销毁时调用。

class MyClass:
    def __del__(self):
        print("对象已被销毁")

`（3）repr(self)`:

返回对象的官方字符串表示，通常用于调试。

class MyClass:
    def __repr__(self):
        return "MyClass({})".format(self.value)

`（4）setitem(self, key, value)`:

定义当对象使用下标赋值时的行为。

class MyClass:
    def __init__(self):
        self.data = {}
    def __setitem__(self, key, value):
        self.data[key] = value

`（5）getitem(self, key)`:

定义当对象使用下标访问时的行为。

class MyClass:
    def __init__(self):
        self.data = {1: 'one', 2: 'two'}
    def __getitem__(self, key):
        return self.data[key]

`（6）len(self)`:

定义当使用len()函数时的行为。

class MyClass:
    def __init__(self, contents):
        self.contents = contents
    def __len__(self):
        return len(self.contents)

`（7）cmp(self, other)`:

在Python 2中用于比较操作。在Python 3中已被移除，应使用__lt__, __le__, __eq__, __ne__, __gt__, __ge__等方法。

`（8）call(self, ...)`:

定义当对象被调用时的行为，允许实例像函数那样被调用。

class MyClass:
    def __call__(self, arg):
        return "Called with: " + str(arg)

`（9）add(self, other)`:

定义加法操作的行为。

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

（10）补充：

__sub__(self, other): 定义减法操作的行为。
__mul__(self, other): 定义乘法操作的行为。
__truediv__(self, other): 定义真除法（除以非零数）操作的行为。
__mod__(self, other): 定义求余操作的行为。
__pow__(self, other[, modulo]): 定义幂运算的行为。

五、命名空间和作用域：

在Python中，命名空间和作用域是两个核心概念，它们决定了如何查找和访问变量。

（1）命名空间：

命名空间是存储变量的区域，Python中的每个作用域都有自己的命名空间。命名空间可以避免命名冲突，因为不同命名空间中的同名变量不会相互影响。

（2）作用域：

作用域是指变量可见的区域。Python中有几种作用域：

局部作用域（Local）：在函数内部定义的变量，只能在该函数内部访问。
嵌套作用域（Enclosing）：在嵌套函数中访问外层函数的变量。
全局作用域（Global）：在模块级别定义的变量，在整个模块中都可以访问。
内置作用域（Built-in）：包含Python内建的变量和函数。

（3）命名空间查找顺序：

当访问一个变量时，Python会按照以下顺序查找命名空间：

局部命名空间
嵌套命名空间
全局命名空间
内置命名空间

如果变量在这些命名空间中都未找到，Python会抛出NameError。

（4）作用域的生命周期：

作用域的生命周期通常与定义它的代码块的执行有关。例如，函数内的局部变量在函数执行完毕后就不再存在。

（5）示例代码：

命名空间和作用域的示例代码：

# 全局变量
global_var = "I am global"

def function():
    # 局部变量
    local_var = "I am local"
    
    def inner_function():
        # 嵌套局部变量
        nested_local_var = "I am nested local"
        print(nested_local_var)
        print(local_var)
        # print(global_var)  # 这会引发错误，因为 global_var 在这个作用域不可见

    inner_function()
    print(local_var)
    # print(nested_local_var)  # 这会引发错误，因为 nested_local_var 在这个作用域不可见

function()
print(global_var)
# print(local_var)  # 这会引发错误，因为 local_var 在这个作用域不可见

（6）global和nonlocal关键字：

当需要在函数内部修改全局变量或嵌套作用域中的变量时，可以使用global和nonlocal关键字。

# 修改全局变量
global_var = "I am global"

def function():
    global global_var
    global_var = "I am now global and modified"

function()
print(global_var)

# 修改嵌套作用域中的变量
def outer():
    var = "I am outer"
    def inner():
        nonlocal var
        var = "I am inner and modified"
    inner()
    print(var)

outer()

（7）作用域和命名空间的规则：

变量查找始终从最内层的作用域开始，向外层作用域进行。
global关键字用于在函数内部声明全局变量。
nonlocal关键字用于在嵌套函数中声明非局部变量。
在函数内部赋值给一个变量，默认情况下会创建一个局部变量，除非使用了global或nonlocal关键字。
Python中的if、for、while等语句块不会创建新的作用域。

六、Python 3的标准库：

Python 3的标准库非常庞大，提供了广泛的功能，从基本的文件操作到复杂的网络编程，几乎涵盖了所有常见的编程任务。

os模块：

提供了与操作系统交互的功能，如文件和目录操作、环境变量访问等。

import os
print(os.getcwd())  # 获取当前工作目录

sys模块：

提供了与Python解释器和系统相关的功能，如命令行参数访问、标准输入输出错误等。

import sys
print(sys.argv)  # 打印命令行参数列表

time模块：

提供了时间相关的函数，如获取当前时间、睡眠等。

import time
print(time.time())  # 获取当前时间戳

datetime模块：

提供了日期和时间的类，支持时区处理、日期时间计算等。

from datetime import datetime
print(datetime.now())  # 获取当前日期和时间

random模块：

提供了生成随机数的功能，包括随机整数、浮点数、随机选择等。

import random
print(random.randint(1, 10))  # 生成1到10之间的随机整数

math模块：

提供了数学相关的函数，如三角函数、对数、指数等。

import math
print(math.sqrt(16))  # 计算16的平方根

re模块：

提供了正则表达式的支持，用于字符串搜索、替换等。

import re
print(re.findall(r'\d+', 'foo 123 bar 456'))  # 查找所有数字

json模块：

提供了JSON数据的编码和解码功能。

import json
data = '{"name": "John", "age": 30}'
print(json.loads(data))  # 将JSON字符串解码为Python字典

urllib模块：

提供了URL处理和网页访问的功能。

from urllib.request import urlopen
response = urlopen('http://example.com')
print(response.read())  # 读取网页内容

shutil模块：

提供了高级文件操作，如文件复制、移动等。

import shutil
shutil.copyfile('source.txt', 'destination.txt')  # 复制文件

glob模块：

提供了文件通配符搜索的功能。

import glob
print(glob.glob('*.py'))  # 获取所有Python文件列表

gzip模块：
提供了gzip文件压缩和解压缩的功能。

import gzip
with gzip.open('file.gz', 'wb') as f:
    f.write(b'Some data')  # 写入压缩数据

collections模块：

提供了许多有用的容器类型，如deque、Counter、OrderedDict、defaultdict和namedtuple等。

from collections import defaultdict, namedtuple
my_data = defaultdict(int)
my_tuple = namedtuple('Point', 'x y')(1, 2)

itertools模块：

提供了用于迭代器的函数式编程工具，如map、filter、reduce、takewhile、dropwhile等。

from itertools import count, islice
for num in islice(count(1), 10):  # 生成从1开始的10个数字
    print(num)

heapq模块：

提供了一个基于列表的最小堆实现，允许进行堆队列操作，如heappush、heappop等。

import heapq
my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
heapq.heapify(my_list)  # 将列表转换为堆
print(heapq.heappop(my_list))  # 弹出最小元素

logging模块：

提供了灵活的方式来记录错误、调试信息、警告等。

import logging
logging.basicConfig(level=logging.INFO)
logging.info('This is an info message')

multiprocessing模块：

允许并行地执行多个操作，提供了创建进程、管理进程间通信的工具。

from multiprocessing import Process, Queue
def worker(name, queue):
    print(f'Launch process with ID: {name}')
    queue.put(name)

queue = Queue()
p = Process(target=worker, args=('123', queue))
p.start()
p.join()
print(queue.get())

threading模块：

提供了线程相关的操作，允许程序中执行多线程操作。

from threading import Thread
def print_numbers():
    for i in range(5):
        print(i)

thread = Thread(target=print_numbers)
thread.start()
thread.join()

socket模块：

提供了访问网络接口的功能，可以进行基本的网络通信。

import socket
s = socket.socket()
host = socket.gethostname()
print(f'The hostname is {host}')

sqlite3模块：

提供了轻量级的磁盘基数据库，使用SQLite数据库。

import sqlite3
conn = sqlite3.connect('example.db')
c = conn.cursor()
c.execute('CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, name TEXT)')

csv模块：

提供了读写CSV文件的功能。

import csv
with open('example.csv', 'w', newline='') as f:
    writer = csv.writer(f)
    writer.writerow(['Name', 'Age'])
    writer.writerow(['Alice', 24])

xml.etree.ElementTree模块：

提供了解析和创建XML数据的工具。

import xml.etree.ElementTree as ET
tree = ET.parse('example.xml')
root = tree.getroot()
print(root.find('tag').text)

标签

#学习 #笔记 #python #开发语言 #github

Python3 学习笔记6-os 模块、错误和异常、面向对象编程、类的专有方法、命名空间和作用域、Python 3的标准库

一、os 模块：

常用方法：

二、错误和异常：

（1）语法错误：

（2）异常：

（3）异常处理：

（4）抛出异常：

（5）用户自定义异常：

（6）清理行为：

（7）with语句：

三、面向对象编程：

（1）类和对象：

（2）继承：

（3）封装：

（4）多态：

（5）运算符重载：

四、类的专有方法：

（1）__init__(self, ...):

（2）__del__(self):

（3）__repr__(self):

（4）__setitem__(self, key, value):

（5）__getitem__(self, key):

（6）__len__(self):

（7）__cmp__(self, other):

（8）__call__(self, ...):

（9）__add__(self, other):

（10）补充：

五、 命名空间和作用域：

（1）命名空间：

（2）作用域：

（3）命名空间查找顺序：

（4）作用域的生命周期：

（5）示例代码：

（6）global和nonlocal关键字：

（7）作用域和命名空间的规则：

六、Python 3的标准库：

os模块：

sys模块：

time模块：

datetime模块：

random模块：

math模块：

re模块：

json模块：

urllib模块：

shutil模块：

glob模块：

gzip模块：

collections模块：

itertools模块：

heapq模块：

logging模块：

multiprocessing模块：

threading模块：

socket模块：

sqlite3模块：

csv模块：

xml.etree.ElementTree模块：

一、`os` 模块：

`（1）init(self, ...)`:

`（2）del(self)`:

`（3）repr(self)`:

`（4）setitem(self, key, value)`:

`（5）getitem(self, key)`:

`（6）len(self)`:

`（7）cmp(self, other)`:

`（8）call(self, ...)`:

`（9）add(self, other)`:

五、命名空间和作用域：