• Python高级二

    一、异常

            1、定义

            异常是在程序执行过程中出现的错误或意外情况。当程序遇到异常时，它会中断当前的执行流程，并尝试找到相应的异常处理机制来解决问题。

            2、常见异常类型

            SyntaxError：语法错误，通常是代码书写不符合Python语法规则。

            NameError：名称错误，当引用一个未定义的变量或函数时抛出。

            TypeError：类型错误，当对不支持的操作数类型进行操作时抛出。

            ValueError：值错误，当传入的参数类型正确但取值范围不正确时抛出。

            IndexError：索引错误，当访问列表、元组或字符串等序列类型时使用了无效的索引值时抛出。

            KeyError：键错误，当访问字典中不存在的键时抛出。

            FileNotFoundError：文件未找到错误，当尝试打开不存在的文件时抛出。

            3、示例

    1. def func(x, y):
    2.      if y != 0:
    3.         return x/y
    4.  
    5. if __name__ == '__main__':
    6.     try:  #包含所有可能抛出异常的代码
    7.         a = int(input("x:"))
    8.         b = int(input("y:"))
    9.         res = func(a, b)
    10.         print("res:", res)
    11.  
    12.         fd = open("file.txt", mode="r+")  # opend 打开文件
    13.         print(fd)
    14.     except ZeroDivisionError as err:   #as  保存异常信息
    15.         print("*********************", err)
    16.     except (IOError, NameError) as err:  #如果捕获多种异常  则使用元组
    17.         print("error:11111111111111", err)

    二、目录操作

               要进行目录操作，可以使用Python中的os模块或pathlib模块。这些模块提供了许多用于处理文件和目录的函数和方法。     

             1、创建目录

    1. import os.path
    2.  
    3. #检查目录 12 是否存在或者是否是一个目录   存在：True 不存在：False
    4. dir = "12"
    5. if os.path.exists("12") is False:
    6.     os.mkdir(dir)    #创建该目录
    7.     print("目录创建成功")
    8. else:
    9.     print("目录已存在，创建失败")

            2、查看目录下的文件并分类

    1. import os.path
    2.  
    3. # listdir(dir) :列举出dir 目录中的所有文件名
    4. files = os.listdir("../day2")
    5. print(files)
    6. dir = []
    7. fi = []
    8. for file in files:
    9.     path = "../day2/" + file  #"path" 通常指代文件系统中文件或目录的路径
    10.     if os.path.isdir(path):
    11.         dir.append(file)
    12.     else:
    13.         fi.append(file)
    14. print("目录：", dir)
    15. print("文件", fi)

    三、文件操作

            open函数       

       open()函数是Python内置函数之一，用于打开文件并返回一个文件对象，以便对文件进行读取、写入或其他操作。

           file: 文件路径（包括文件名）

      mode: 打开文件的模式，常见的包括：

            "r": 只读模式，文件必须存在。

            "w": 只写模式，清空文件内容，若文件不存在则创建新文件。

            "a": 追加模式，在文件末尾添加内容，若文件不存在则创建新文件。

            "r+": 读写模式，允许读取和写入文件内容。

            其他参数：如buffering（缓冲大小）、encoding（文件编码）、errors（编解码错误处理方式）等

            返回值：open()函数返回一个文件对象，可以通过该文件对象执行文件的读取、写入等操作。

            1、权限

            "r"：只读模式，文件必须存在，如果文件不存在则会引发错误。

            "w"：只写模式，文件不存在则创建，文件存在则清空内容。

             "a"：追加模式，文件不存在则创建，文件存在则在末尾追加内容。

             "r+"：读写模式，文件必须存在，从文件头开始读写。

             "w+"：读写模式，文件不存在则创建，文件存在则清空内容并从头开始读写。

             "a+"：读写模式，文件不存在则创建，文件存在则在末尾追加内容并可以读取。

            2、打开文件

                       fd = open("file.txt", mode="w+")   #以读写模式打开文件file.txt

            3、读取文件内容

            res = fd.read(32)        #read(n)读取前n 字节的数据 返回str类型

            res = fd.readlines()     #readlines() :读取文件所有行数据， 返回list类型

            4、向文件写入内容

            fd.write("hello world")    #write（）写入数据hello world

            5、示例

    1. fd = open("file.txt", mode="w+")
    2. with open("file.txt", mode="r+") as fd:
    3.     l1 = ["123444\n", "45644\n", "789565\n", "goodbye\n"]
    4.     fd.writelines(l1)   #按行写入数据  用于将一个字符串列表写入文件。每个字符串元素都作为一行写入文件。
    5.     fd.close()

            6、with语句

            with语句是用于简化资源管理的一种方式，确保在代码块执行完成后自动关闭文件、释放锁或者执行其他清理操作。

    四、多线程 

            示例

    1. from threading import Thread
    2. from time import sleep, ctime
    3.  
    4.  
    5. def study(book):
    6.     for i in range(5):
    7.         print("I'm study 《{}》 {}".format(book, ctime))
    8.         sleep(1)
    9. def music(music):
    10.     for i in range(5):
    11.         print("I'm listening 《{}》".format(music))
    12.         sleep(2)
    13.  
    14. if __name__ == '__main__':
    15.     #Thread() : 创建线程  target ： 用指定线程执行函数  args：传递数据到线程中
    16.     t1 = Thread(target = study, args = ("模电",))
    17.     #start(): 启动线程
    18.     t1.start()
    19.  
    20.     t2 = Thread(target=music, args=("蓝莲花",))
    21.     # start(): 启动线程
    22.     t2.start()
    23.  
    24.     t1.join()
    25.     t2.join()

    五、多进程

            示例

    1. from multiprocessing import Process
    2. from time import sleep, ctime
    3.  
    4.  
    5. def study(book):
    6.     for i in range(5):
    7.         print("I'm study 《{}》 {}".format(book, ctime()))
    8.         sleep(1)
    9.  
    10. def music(music):
    11.     for i in range(5):
    12.         print("I'm listening 《{}》".format(music))
    13.         sleep(2)
    14.  
    15. if __name__ == '__main__':
    16.     #Process() : 创建进程  target ： 用指定进程执行函数  args：传递数据到线程中
    17.     t1 = Process(target=study, args=("模电",))
    18.     #start(): 启动进程
    19.     t1.start()
    20.  
    21.     t2 = Process(target=music, args=("蓝莲花",))
    22.     # start(): 启动进程
    23.     t2.start()
    24.  
    25.     t1.join()
    26.     t2.join()

    六、锁

            在多线程编程中，锁是一种同步机制，用于控制多个线程对共享资源的访问。使用锁可以确保在任意时刻只有一个线程可以访问共享资源，从而避免多个线程同时修改共享数据导致的数据不一致或竞态条件等问题。

    1. from threading import Thread, Lock
    2.  
    3. # 共享资源
    4. counter = 0
    5. l = Lock()
    6. # 定义一个函数，用于增加计数器的值
    7. def increase_counter():
    8.     global counter
    9.     for _ in range(1000):
    10.         with l:
    11.             counter += 1
    12.  
    13.  
    14. # 创建两个线程分别增加计数器的值
    15.  #Thread() : 创建线程  target ： 用指定线程执行函数  args：传递数据到线程中
    16. thread1 = Thread(target=increase_counter)
    17. thread2 = Thread(target=increase_counter)
    18.  
    19. thread1.start()
    20. thread2.start()
    21.  
    22. thread1.join()
    23. thread2.join()
    24.  
    25. print("Final value of counter:", counter)
    26.  
    27.  
    28.

    七、管道

            管道（Pipe）是一种进程间通信机制，通常用于在父进程和子进程之间传递数据。在Python中，可以使用multiprocessing模块中的Pipe类来创建管道。

            示例

    1. from multiprocessing import Process, Pipe, freeze_support
    2.  
    3. # 子进程的函数，接收父进程发送的消息并回复
    4. def child_process(conn):
    5.     while True:
    6.         msg = conn.recv()  # 接收消息
    7.         print("Received message from parent:", msg)
    8.         if msg == "exit":
    9.             break
    10.         reply_msg = "Message received: " + msg
    11.         conn.send(reply_msg)  # 回复消息
    12.     conn.close()
    13.  
    14. if __name__ == '__main__':
    15.     freeze_support()  # 添加这一行
    16.     # 创建管道
    17.     parent_conn, child_conn = Pipe()
    18.  
    19.     # 启动子进程
    20.     p = Process(target=child_process, args=(child_conn,))
    21.     p.start()
    22.  
    23.     # 父进程向子进程发送消息并接收回复
    24.     messages = ["Hello", "How are you?", "exit"]
    25.     for msg in messages:
    26.         parent_conn.send(msg)  # 发送消息
    27.         if msg == "exit":
    28.             break
    29.         reply = parent_conn.recv()  # 接收回复
    30.         print("Received reply from child:", reply)
    31.  
    32.     p.join()

  • 相关阅读:
    视觉SLAM十四讲_4李群与李代数
    grep基础正则使用
    Anaconda3安装部署(二) 百篇文章学PyQT
    跑通Kaldi中的例子LibriSpeech
    GBASE 8s 高可用RSS集群搭建
    数学建模学习笔记（7）：相关系数
    51单片机应用从零开始（五）·加减乘除运算
    神经网络rnn是什么意思,RNN神经网络基本原理
    C++(string 类模拟实现）
    进程和线程
  • 原文地址：https://blog.csdn.net/only_write_bug/article/details/136629957