Python筑基之旅-文件(夹)和流

目录

一、文件操作

1、文件打开与关闭

2、文件读写

3、文件操作模式

4、文件编码

二、文件夹操作

1、创建文件夹

2、删除文件夹

3、改变当前工作目录

4、获取当前工作目录

5、检查文件/文件夹是否存在

6、遍历文件夹

三、文件路径操作

1、获取绝对路径

2、构建完整路径

3、检查路径是否存在

4、判断是否为目录

5、获取路径的目录部分和文件名部分

6、获取文件名(不含扩展名)和扩展名

四、流

1、流的理解

2、流的特性

2-1、顺序性

2-2、连续性

2-3、抽象性

3、流的分类

3-1、根据读写操作

3-1-1、输入流

3-1-2、输出流

3-2、根据数据类型

3-2-1、字节流

3-2-2、字符流

3-3、根据环境

3-3-1、文件流

3-3-2、网络流

3-3-3、内存流

3-3-4、数据库流

4、流的操作

4-1、打开流(如打开文件或建立网络连接)

4-2、读取数据(从输入流中)

4-3、写入数据(到输出流中)

4-4、关闭流(释放资源)

五、推荐阅读

1、Python函数之旅

2、Python算法之旅

3、博客个人主页

一、文件操作

1、文件打开与关闭

  1. # 1、文件打开和关闭
  2. # 1-1、读取文件
  3. with open('test.txt', 'r') as file:
  4.     # 读取文件内容
  5.     content = file.read()
  6.     print(content)
  7.     # with语句块结束时，文件会自动关闭
  8. # 1-2、写入文件
  9. # 打开文件以写入，如果文件不存在则创建它
  10. with open('test.txt', 'w') as file:
  11.     # 写入内容到文件
  12.     file.write('Hello, World!')
  13.     # with语句块结束时，文件会自动关闭
  14. # 1-3、追加到文件
  15. with open('test.txt', 'a') as file:
  16.     # 追加内容到文件
  17.     file.write('\nAnother line of text.')
  18.     # with语句块结束时，文件会自动关闭
  19. # 1-4、读取文件行
  20. with open('test.txt', 'r') as file:
  21.     # 逐行读取文件内容
  22.     for line in file:
  23.         print(line, end='')  # 使用 end='' 避免打印额外的换行符
  24.     # with语句块结束时，文件会自动关闭

2、文件读写

  1. # 2、文件读写
  2. # 2-1、读取整个文件
  3. # 打开文件并读取整个内容
  4. with open('test.txt', 'r', encoding='utf-8') as file:
  5.     content = file.read()
  6.     print(content)
  7.     # 文件会在with语句块结束时自动关闭
  8. # 2-2、逐行读取文件
  9. # 打开文件并逐行读取内容
  10. with open('test.txt', 'r', encoding='utf-8') as file:
  11.     for line in file:
  12.         print(line, end='')  # 如果不想在每行后都打印换行符，可以使用end=''
  13. # 文件会在with语句块结束时自动关闭
  14. # 2-3、读取并修改文件内容(不推荐在原文件修改)
  15. # 读取文件内容
  16. with open('test.txt', 'r', encoding='utf-8') as file:
  17.     content = file.read()
  18. modified_content = content.replace('World', 'Python')
  19. # 将修改后的内容写回到文件
  20. with open('test.txt', 'w', encoding='utf-8') as file:
  21.     file.write(modified_content)
  22. with open('test.txt', 'r', encoding='utf-8') as file:
  23.     content = file.read()
  24.     print(content)
  25.     # 文件会在with语句块结束时自动关闭
  26. # 2-4、读取和写入二进制文件
  27. # 读取二进制文件
  28. with open('example.bin', 'rb') as file:
  29.     binary_content = file.read()
  30. # 处理二进制内容（这里只是简单打印长度）
  31. print(len(binary_content))
  32. # 写入二进制内容到文件(这里只是一个示例，你需要有有效的二进制数据)
  33. with open('output.bin', 'wb') as file:
  34.     file.write(b'\x00\x01\x02\x03')  # 写入四个字节的二进制数据
  35. # 文件会在with语句块结束时自动关闭

3、文件操作模式

  1. # 3、文件操作模式
  2. # 3-1、读取模式(r)
  3. # 读取文件内容，文件必须存在，否则会引发FileNotFoundError
  4. with open('test.txt', 'r', encoding='utf-8') as file:
  5.     content = file.read()
  6.     print(content)
  7. # 3-2、写入模式(w)
  8. # 写入文件内容，如果文件不存在则创建它，如果文件已存在则覆盖它
  9. with open('test.txt', 'w', encoding='utf-8') as file:
  10.     file.write('Hello, World!\n')
  11. # 3-3、追加模式(a)
  12. # 将内容追加到文件末尾，如果文件不存在则创建它
  13. with open('test.txt', 'a', encoding='utf-8') as file:
  14.     file.write('This is appended content.\n')
  15. # 3-4、读写模式(r+)
  16. # 打开文件进行读写，文件指针会放在文件的开头
  17. with open('test.txt', 'r+', encoding='utf-8') as file:
  18.     content = file.read()
  19.     print(content)
  20.     file.seek(0)  # 将文件指针重置到文件开头
  21.     file.write('This will replace the first line if it\'s short enough.\n')
  22. # 3-5、写入并读取模式(w+)
  23. # 打开文件进行读写，如果文件已存在则覆盖它，如果文件不存在则创建它
  24. with open('test.txt', 'w+', encoding='utf-8') as file:
  25.     file.write('Hello, World!\n')
  26.     file.seek(0)  # 将文件指针重置到文件开头
  27.     content = file.read()
  28.     print(content)
  29. # 3-6、追加并读取模式(a+)
  30. # 打开文件进行读写。如果文件已存在，文件指针会放在文件的末尾(即追加模式)；如果文件不存在，创建文件
  31. with open('test.txt', 'a+', encoding='utf-8') as file:
  32.     file.write('Appending content...\n')
  33.     file.seek(0)  # 将文件指针重置到文件开头
  34.     content = file.read()
  35.     print(content)  # 注意：这里会先打印出原有内容，然后是新追加的内容
  36. # 3-7、二进制读取模式(rb)
  37. # 读取二进制文件内容
  38. with open('example.bin', 'rb') as file:
  39.     binary_content = file.read()
  40.     # 处理二进制内容...
  41. # 3-8、二进制写入模式(wb)
  42. # 写入二进制文件内容
  43. with open('example.bin', 'wb') as file:
  44.     file.write(b'\x00\x01\x02\x03')
  45. # 3-9、二进制追加模式(ab)
  46. # 将二进制内容追加到文件末尾
  47. with open('example.bin', 'ab') as file:
  48.     file.write(b'\x04\x05\x06\x07')

4、文件编码

  1. # 4、文件编码
  2. # 4-1、读取不同编码的文件
  3. # 读取UTF-8编码的文件
  4. with open('utf8_file.txt', 'r', encoding='utf-8') as file:
  5.     content = file.read()
  6.     print(content)
  7. # 读取ISO-8859-1(Latin-1)编码的文件
  8. with open('latin1_file.txt', 'r', encoding='iso-8859-1') as file:
  9.     content = file.read()
  10.     print(content)
  11.     # 注意：如果文件编码与指定的编码不匹配，可能会出现乱码
  12. # 4-2、将文本写入文件并指定编码
  13. # 将文本写入UTF-8编码的文件
  14. with open('output_utf8.txt', 'w', encoding='utf-8') as file:
  15.     file.write('你好，世界！')
  16. # 将文本写入ISO-8859-1编码的文件（注意：非ASCII字符可能会被编码为替代字符）
  17. with open('output_latin1.txt', 'w', encoding='iso-8859-1', errors='replace') as file:
  18.     file.write('你好，世界！')  # 这将写入替代字符，因为Latin-1不支持中文字符
  19. # 使用二进制模式写入，并手动编码为UTF-8
  20. with open('output_binary_utf8.txt', 'wb') as file:
  21.     file.write('你好，世界！'.encode('utf-8'))
  22. # 4-3、转换文件编码
  23. # 将UTF-8编码的文件转换为GBK编码的文件
  24. with open('input_utf8.txt', 'r', encoding='utf-8') as file_utf8, \
  25.         open('output_gbk.txt', 'w', encoding='gbk') as file_gbk:
  26.     content = file_utf8.read()
  27.     file_gbk.write(content)
  28.     # 注意：如果原始文件包含GBK不支持的字符，这可能会导致错误，你可能需要处理这种情况
  29. # 4-4、检测文件编码
  30. # 首先，你需要安装chardet库
  31. import chardet
  32. # 检测文件的编码
  33. with open('test.txt', 'rb') as file:
  34.     raw_data = file.read()
  35.     result = chardet.detect(raw_data)
  36.     print(result)  # 输出类似{'encoding': 'ascii', 'confidence': 1.0, 'language': ''}的字典
  37. # 使用检测到的编码读取文件
  38. encoding = chardet.detect(raw_data)['encoding']
  39. with open('test.txt', 'r', encoding=encoding) as file:
  40.     content = file.read()
  41.     print(content)

二、文件夹操作

1、创建文件夹

  1. # 5-1、创建单个文件夹
  2. import os
  3. # 定义要创建的文件夹路径，根据实际情况，自行修改即可
  4. folder_path = 'E:\测试代码\my_new_folder'
  5. # 使用os.makedirs创建文件夹
  6. # 如果文件夹已存在并且没有设置exist_ok=True，则会抛出FileExistsError异常
  7. try:
  8.     os.makedirs(folder_path)
  9.     print(f"文件夹 '{folder_path}' 已成功创建！")
  10. except FileExistsError:
  11.     print(f"文件夹 '{folder_path}' 已存在！")
  12. # 如果你想避免异常，并允许文件夹已存在，可以这样做：
  13. try:
  14.     os.makedirs(folder_path, exist_ok=True)
  15.     print(f"文件夹 '{folder_path}' 已创建或已存在！")
  16. except Exception as e:
  17.     print(f"创建文件夹时发生错误：{e}")
  18. # 5-2、创建嵌套的文件夹
  19. import os
  20. # 定义要创建的嵌套文件夹路径
  21. nested_folder_path = 'E:\测试代码\Myelsa'
  22. # 使用os.makedirs创建嵌套的文件夹
  23. try:
  24.     os.makedirs(nested_folder_path)
  25.     print(f"嵌套文件夹 '{nested_folder_path}' 已成功创建！")
  26. except FileExistsError:
  27.     print(f"嵌套文件夹 '{nested_folder_path}' 已存在！")
  28. # 如果你想避免异常，并允许文件夹已存在，可以这样做：
  29. try:
  30.     os.makedirs(nested_folder_path, exist_ok=True)
  31.     print(f"嵌套文件夹 '{nested_folder_path}' 已创建或已存在！")
  32. except Exception as e:
  33.     print(f"创建嵌套文件夹时发生错误：{e}")

2、删除文件夹

  1. # 6、删除文件夹
  2. # 6-1、使用os.rmdir()删除空文件夹
  3. import os
  4. # 定义要删除的文件夹路径(注意：这个文件夹必须是空的)
  5. folder_path = 'E:\测试代码\Myelsa'
  6. # 使用os.rmdir删除文件夹
  7. try:
  8.     os.rmdir(folder_path)
  9.     print(f"文件夹 '{folder_path}' 已成功删除!")
  10. except OSError as e:
  11.     print(f"删除文件夹时发生错误：{e}") # 输出：删除文件夹时发生错误：[WinError 145] 目录不是空的。: 'E:\\测试代码\\Myelsa'
  12.     # 注意：如果文件夹不为空，os.rmdir()会抛出OSError异常
  13. # 6-2、使用shutil.rmtree()删除文件夹及其内容
  14. import shutil
  15. # 定义要删除的文件夹路径(可以包含文件和其他文件夹)
  16. folder_path = 'E:\测试代码\Myelsa'
  17. # 使用shutil.rmtree删除文件夹及其内容
  18. try:
  19.     shutil.rmtree(folder_path)
  20.     print(f"文件夹 '{folder_path}' 及其内容已成功删除!")
  21. except OSError as e:
  22.     print(f"删除文件夹时发生错误：{e}")
  23.     # shutil.rmtree()会递归地删除指定目录及其所有内容

3、改变当前工作目录

  1. # 7、改变当前工作目录
  2. # 7-1、改变当前工作目录
  3. import os
  4. # 打印当前工作目录
  5. print(f"当前工作目录是：{os.getcwd()}")
  6. # 定义新的工作目录路径
  7. new_dir = 'E:\测试代码/directory'  # 替换成你想要的工作目录路径
  8. # 改变当前工作目录
  9. try:
  10.     os.chdir(new_dir)
  11.     print(f"已成功改变工作目录到：{os.getcwd()}")
  12. except FileNotFoundError:
  13.     print(f"目录 '{new_dir}' 不存在！")
  14. except PermissionError:
  15.     print(f"你没有权限访问目录 '{new_dir}'！")
  16. except Exception as e:
  17.     print(f"改变工作目录时发生错误：{e}")
  18. # 7-2、使用相对路径改变工作目录
  19. import os
  20. # 假设你的脚本位于 /home/user/scripts 目录下  
  21. # 并且你想要改变到它的上一级目录 /home/user  
  22. # 打印当前工作目录  
  23. print(f"当前工作目录是：{os.getcwd()}")
  24. # 定义新的工作目录(这里使用相对路径 ".." 表示上一级目录)  
  25. new_dir = '..'
  26. # 改变当前工作目录  
  27. try:
  28.     os.chdir(new_dir)
  29.     print(f"已成功改变工作目录到：{os.getcwd()}")
  30. except Exception as e:
  31.     print(f"改变工作目录时发生错误：{e}")

4、获取当前工作目录

  1. # 8、获取当前工作目录
  2. import os
  3. # 使用os.getcwd()获取当前工作目录
  4. current_working_directory = os.getcwd()
  5. # 打印当前工作目录
  6. print(f"当前工作目录是：{current_working_directory}")

5、检查文件/文件夹是否存在

  1. # 9、检查文件/文件夹是否存在
  2. # 9-1、检查文件是否存在
  3. import os
  4. # 定义文件路径
  5. file_path = 'E:\测试代码\Myelsa/file.txt'
  6. # 使用os.path.exists()检查文件是否存在
  7. if os.path.exists(file_path):
  8.     print(f"文件 '{file_path}' 存在！")
  9. else:
  10.     print(f"文件 '{file_path}' 不存在！")
  11. # 如果你还想检查它是否是一个文件(而不是文件夹)，可以使用os.path.isfile()
  12. if os.path.isfile(file_path):
  13.     print(f"'{file_path}' 是一个文件！")
  14. elif os.path.isdir(file_path):
  15.     print(f"'{file_path}' 是一个文件夹！")
  16. # 9-2、检查文件夹是否存在
  17. import os
  18. # 定义文件夹路径
  19. folder_path = 'E:\测试代码\Myelsa'
  20. # 使用os.path.exists()检查文件夹是否存在
  21. if os.path.exists(folder_path):
  22.     print(f"文件夹 '{folder_path}' 存在！")
  23. else:
  24.     print(f"文件夹 '{folder_path}' 不存在！")
  25. # 如果你只想检查它是否是一个文件夹(而不是文件)，可以使用os.path.isdir()
  26. if os.path.isdir(folder_path):
  27.     print(f"'{folder_path}' 是一个文件夹！")

6、遍历文件夹

  1. # 10、遍历文件夹
  2. # 10-1、遍历指定文件夹中的所有文件和子文件夹
  3. import os
  4. # 定义要遍历的文件夹路径
  5. folder_path = 'E:\测试代码\Myelsa'
  6. # 遍历文件夹
  7. for root, dirs, files in os.walk(folder_path):
  8.     for name in files:
  9.         # 构建文件的完整路径
  10.         file_path = os.path.join(root, name)
  11.         print(file_path)  # 打印文件路径
  12.     for name in dirs:
  13.         # 构建子文件夹的完整路径
  14.         subfolder_path = os.path.join(root, name)
  15.         print(subfolder_path)  # 打印子文件夹路径
  16.         # 如果你想递归遍历子文件夹，你可以在这里递归调用你的遍历函数
  17. # 注意：os.walk()默认就是递归遍历的，所以你不需要额外写递归代码
  18. # 10-2、仅遍历当前文件夹(不包括子文件夹)
  19. import os
  20. # 定义要遍历的文件夹路径
  21. folder_path = 'E:\测试代码\Myelsa'
  22. # 遍历文件夹中的文件和子文件夹
  23. for name in os.listdir(folder_path):
  24.     # 构建文件的完整路径（如果是文件）  
  25.     full_path = os.path.join(folder_path, name)
  26.     # 判断是文件还是文件夹
  27.     if os.path.isfile(full_path):
  28.         print(f"文件: {full_path}")
  29.     elif os.path.isdir(full_path):
  30.         print(f"文件夹: {full_path}")

三、文件路径操作

1、获取绝对路径

  1. # 11、获取绝对路径
  2. # 11-1、获取当前工作目录的绝对路径
  3. import os
  4. # 获取当前工作目录的绝对路径
  5. current_working_directory = os.path.abspath('.')
  6. print(f"当前工作目录的绝对路径是：{current_working_directory}")
  7. # 11-2、获取文件或文件夹的绝对路径
  8. import os
  9. # 定义文件或文件夹的相对路径
  10. relative_path = 'E:\测试代码\Myelsa'
  11. # 获取文件或文件夹的绝对路径
  12. absolute_path = os.path.abspath(relative_path)
  13. print(f"文件或文件夹的绝对路径是：{absolute_path}")
  14. # 11-3、获取脚本文件的绝对路径
  15. import os
  16. # 获取脚本文件的绝对路径
  17. script_dir = os.path.dirname(os.path.abspath(__file__))
  18. print(f"脚本文件的绝对路径是：{script_dir}")
  19. # 如果你想要获取脚本文件所在目录下的某个文件的绝对路径
  20. file_in_same_dir = os.path.join(script_dir, 'file.txt')
  21. print(f"同一目录下的某个文件的绝对路径是：{file_in_same_dir}")

2、构建完整路径

  1. # 12、构建完整路径
  2. # 12-1、使用os.path.join()构建相对路径
  3. import os
  4. # 定义路径组件
  5. directory = 'path'
  6. subdirectory = 'to'
  7. filename = 'your_file.txt'
  8. # 使用os.path.join()构建相对路径
  9. relative_path = os.path.join(directory, subdirectory, filename)
  10. print(f"相对路径是：{relative_path}")
  11. # 12-2、使用os.path.join()和os.getcwd()构建绝对路径
  12. import os
  13. # 定义路径组件
  14. relative_directory = 'path'
  15. relative_filename = 'your_file.txt'
  16. # 获取当前工作目录的绝对路径
  17. current_directory = os.getcwd()
  18. # 使用os.path.join()将当前工作目录和相对路径组件合并成绝对路径
  19. absolute_path = os.path.join(current_directory, relative_directory, relative_filename)
  20. print(f"绝对路径是：{absolute_path}")
  21. # 12-3、构建具有特定根目录的完整路径
  22. import os
  23. # 定义根目录和路径组件
  24. root_directory = '/home/user'
  25. directory = 'data'
  26. filename = 'important_data.csv'
  27. # 使用os.path.join()构建完整路径
  28. full_path = os.path.join(root_directory, directory, filename)
  29. print(f"完整路径是：{full_path}")

3、检查路径是否存在

  1. # 13、检查路径是否存在
  2. # 13-1、检查文件是否存在
  3. import os
  4. # 定义文件路径
  5. file_path = '/path/to/your/file.txt'
  6. # 检查文件是否存在
  7. if os.path.exists(file_path):
  8.     print(f"文件 {file_path} 存在！")
  9. else:
  10.     print(f"文件 {file_path} 不存在！")
  11. # 13-2、检查文件夹是否存在
  12. import os
  13. # 定义文件夹路径
  14. folder_path = 'E:\测试代码\Myelsa'
  15. # 检查文件夹是否存在
  16. if os.path.exists(folder_path):
  17.     print(f"文件夹 {folder_path} 存在！")
  18.     # 如果需要，还可以检查它是否真的是一个文件夹
  19.     if os.path.isdir(folder_path):
  20.         print(f"并且它是一个文件夹！")
  21.     else:
  22.         print(f"但它不是一个文件夹！")
  23. else:
  24.     print(f"文件夹 {folder_path} 不存在！")
  25. # 13-3、检查路径是否存在，并根据情况创建文件夹
  26. import os
  27. # 定义文件夹路径
  28. folder_path = 'E:\测试代码\Myelsa'
  29. # 检查文件夹是否存在
  30. if not os.path.exists(folder_path):
  31.     # 如果文件夹不存在，则创建它
  32.     os.makedirs(folder_path)
  33.     print(f"文件夹 {folder_path} 已创建！")
  34. else:
  35.     print(f"文件夹 {folder_path} 已经存在！")

4、判断是否为目录

  1. # 14、判断是否为目录
  2. # 14-1、判断一个路径是否为目录
  3. import os
  4. # 定义路径
  5. path = 'E:\测试代码\Myelsa'
  6. # 判断是否为目录
  7. if os.path.isdir(path):
  8.     print(f"路径 {path} 是一个目录！")
  9. else:
  10.     print(f"路径 {path} 不是一个目录或不存在！")
  11. # 14-2、结合os.path.exists()和os.path.isdir()
  12. # 如果你想先检查路径是否存在，然后再判断它是否是一个目录
  13. import os
  14. # 定义路径
  15. path = 'E:\测试代码\Myelsa'
  16. # 检查路径是否存在
  17. if os.path.exists(path):
  18.     # 如果存在，再判断是否为目录
  19.     if os.path.isdir(path):
  20.         print(f"路径 {path} 是一个存在的目录！")
  21.     else:
  22.         print(f"路径 {path} 存在，但它不是一个目录，可能是一个文件！")
  23. else:
  24.     print(f"路径 {path} 不存在！")
  25. # 14-3、处理多个路径
  26. # 如果你想检查多个路径，并将它们是否为目录的信息打印出来
  27. import os
  28. # 定义多个路径
  29. paths = [
  30.     'E:\测试代码\Myelsa',
  31.     'E:\测试代码\Myelsa/folder1',
  32.     'E:\测试代码\Myelsa/file.txt'
  33. ]
  34. # 遍历路径并判断
  35. for path in paths:
  36.     if os.path.isdir(path):
  37.         print(f"路径 {path} 是一个目录!")
  38.     else:
  39.         print(f"路径 {path} 不是一个目录或不存在!")

5、获取路径的目录部分和文件名部分

  1. # 15、获取路径的目录部分和文件名部分
  2. # 15-1、获取目录部分和文件名部分
  3. import os
  4. # 定义文件路径
  5. path = 'E:\测试代码\Myelsa/file.txt'
  6. # 获取目录部分
  7. dir_path = os.path.dirname(path)
  8. print(f"目录部分是：{dir_path}")
  9. # 获取文件名部分
  10. file_name = os.path.basename(path)
  11. print(f"文件名部分是：{file_name}")
  12. # 15-2、处理多个文件路径
  13. import os
  14. # 定义多个文件路径
  15. paths = [
  16.     'E:\测试代码\Myelsa/file.txt',
  17.     'E:\测试代码\Myelsa/folder1/file.txt',
  18.     'E:\测试代码\Myelsa/folder2/file.txt'
  19. ]
  20. # 遍历路径并获取目录部分和文件名部分
  21. for path in paths:
  22.     dir_path = os.path.dirname(path)
  23.     file_name = os.path.basename(path)
  24.     print(f"路径 {path} 的目录部分是：{dir_path}")
  25.     print(f"路径 {path} 的文件名部分是：{file_name}")
  26.     print()  # 打印一个空行分隔不同的路径信息

6、获取文件名(不含扩展名)和扩展名

  1. # 16、获取文件名(不含扩展名)和扩展名
  2. # 16-1、获取文件名(不含扩展名)和扩展名
  3. import os
  4. # 定义文件路径
  5. path = 'E:\测试代码\Myelsa/file.txt'
  6. # 获取文件名和扩展名
  7. filename, extension = os.path.splitext(os.path.basename(path))
  8. # 打印结果
  9. print(f"文件名(不含扩展名)是：{filename}")
  10. print(f"扩展名是：{extension}")
  11. # 16-2、处理多个文件路径
  12. import os
  13. # 定义多个文件路径
  14. paths = [
  15.     'E:\测试代码\Myelsa/file.txt',
  16.     'E:\测试代码\Myelsa/folder1/file.txt',
  17.     'E:\测试代码\Myelsa/folder2/file.txt'
  18. ]
  19. # 遍历路径并获取文件名(不含扩展名)和扩展名
  20. for path in paths:
  21.     filename, extension = os.path.splitext(os.path.basename(path))
  22.     print(f"路径 {path} 的文件名(不含扩展名)是：{filename}")
  23.     print(f"路径 {path} 的扩展名是：{extension}")
  24.     print()  # 打印一个空行分隔不同的路径信息

四、流

1、流的理解

        在Python中，"流"(stream)这个概念通常与文件I/O(输入/输出)或网络通信等场景相关，它指的是一种数据传输的抽象，允许数据以连续的方式从一个位置移动到另一个位置，流可以是输入流(从源读取数据)，也可以是输出流(将数据写入目标)。

2、流的特性

2-1、顺序性

        数据在流中是按顺序传输的。

2-2、连续性

        数据在流中是连续不断的，直到整个数据传输完成。

2-3、抽象性

        流提供了一个对数据传输的抽象层，使得我们不必关心底层的实现细节。

3、流的分类

3-1、根据读写操作
3-1-1、输入流

        用于从数据源读取数据。

3-1-2、输出流

        用于将数据写入到目标位置。

3-2、根据数据类型
3-2-1、字节流

        用于处理二进制数据，如图像、音频、视频等。

3-2-2、字符流

        用于处理文本数据，即字符序列。

流的分类数据类型处理对象
字符流处理文本数据，遵循字符编码规则以字符为单位进行读写，需要考虑字符编码
字节流处理二进制数据，不遵循字符编码规则以字节为单位进行读写，不关心字符编码
3-3、根据环境
3-3-1、文件流

        用于文件的读写操作。

3-3-2、网络流

        用于网络通信中的数据传输。

3-3-3、内存流

        在内存中处理数据，如缓存、临时存储等。

3-3-4、数据库流

        与数据库交互时使用的数据流。

4、流的操作

        对于流，我们通常可以执行以下操作：

4-1、打开流(如打开文件或建立网络连接)
4-2、读取数据(从输入流中)
4-3、写入数据(到输出流中)
4-4、关闭流(释放资源)

五、推荐阅读

1、Python函数之旅

2、Python算法之旅

3、博客个人主页

文章知识点与官方知识档案匹配，可进一步学习相关知识
Python入门技能树首页概览422306 人正在系统学习中
遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/139215108"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！