Python

关于文件的操作

文件操作

上下文语法：使用完后自动回收流通道

代码示例：

'''
1. 路径
    · file
2. 操作方式
    · r（默认读，可省略）
    · w（写）
    · rb（二进制读）
    · wb（二进制写）
    · a（追加内容，不会全部覆盖）
3. r/w的应用
    · 纯文本等文件
4. rb/wb的应用
    · 纯文本、图片、音乐、视频等文件
5. 缓存
    · buffering
6. 编码
    · encoding
7. 格式
    · open(路径, 操作方式, 缓存, 编码)
'''

# open、read：
foo = open(r'c:\foo.txt')  # r（禁止路径特殊字符转义）
bar = foo.read()  # 读取文件流的内容（纯文本内容）
print(bar)  # To Be or Not to Be

# name：
foo = open(r'c:\foo.txt')
bar = foo.name
print(bar)  # c:\foo.txt

# readable：
foo = open(r'c:\foo.txt')
bar = foo.readable()  # 返回值：bool
print(bar)  # True

# readline：
foo = open(r'c:\foo.txt')
bar = foo.readline()  # 只读一行（默认加换行符）
print(bar)  # 第一行

# readlines：
foo = open(r'c:\foo.txt')
bar = foo.readlines()  # 默认加换行符
print(bar)  # ['第一行\n','第二行\n','第三行\n']

# __file__：
print(__file__)  # 获取当前py文件的路径

# find或rfind等进行文件操作时：
foo = r'c:\foo\foo.txt'
bar = foo[foo.rfind('\\') + 1:]  # \\等同于\

# 每次写入（从生成流通道到回收为一次）时，都会清除旧内容，写入新内容（全部覆盖），\n等转义符不会被原文输出，而是换行

# write：
foo = open(r'c:\foo.txt','w')
n = '''
    awsl
'''  # 原样输出
bar = foo.write(n)  # 返回值：字节数
print(bar)  # 23

# writable：
foo = open(r'c:\foo.txt','w')
bar = foo.writable()  # 返回值：bool
print(bar)  # True

# writelines：
foo = open(r'c:\foo.txt','w')
n = ['foo\n','bar\n']  # 本身无换行效果，需要自己添加\n换行
foo.writelies(n)

# close：
foo.close()  # 作用：有利于运行速度、内存占用（回收后流通道不再可用）

# 上下文语法：
with open(r'c:\foo.txt') as foo: # foo为别名
    bar = foo.read()
    print(bar)  # Hell is other people
    with open(r'c:\bar.txt','w') as bar:
        bar.write(bar)  # 文件内容复制粘贴

相对路径与绝对路径

代码示例：

'''
1. 相对路径
    · foo\foo.txt
2. 绝对路径
    · c:\foo\foo.txt
3. 用..返回上级路径
    · ..\foo\foo.txt
'''

'''
├── foo
│   └── foo.txt
├── bar
│   └── bar.txt
'''

os

代码示例：

import os

# path.dirname：
print(os.path.dirname(r'c:\foo\foo.txt'))  # c:\foo

# path.join：
print(os.path.join(r'c:\foo',r'bar',r'foo.txt'))  # c:\foo\bar\foo.txt

# path.isabs：
foo = os.path.isabs(r'c:\foo\foo.txt')  # 返回值：bool
print(foo)  # True

# path.abspath：
foo = os.path.abspath(r'foo.txt')
print(foo)  # c:\foo\foo.txt

# getcwd：
foo = os.getcwd()
print(foo)  # c:\foo

# path.split：
foo = os.path.split(r'c:\foo\foo.txt')
print(foo)  # ('c:\foo','foo.txt')

# path.splitext：
foo = os.path.splitext(r'c:\foo\foo.txt')
print(foo)  # ('c:\foo\foo','.txt')

# path.getsize：
foo = os.path.getsize(r'c:\foo\foo.txt')
print(foo)  # 1024

# path.isfile：
foo = os.path.isfile(r'c:\foo\foo.txt')  # 返回值：bool
print(foo)  # True

# path.isdir：
foo = os.path.isdir(r'c:\foo\foo.txt')  # 返回值：bool
print(foo)  # False

# listdir：
foo = os.listdir(r'c:\foo')
print(foo)  # ['bar','foo.txt']

# mkdir：
foo = os.mkdir(r'c:\foo')
print(foo)  # None

# rmdir：
os.rmdir(r'c:\foo')

# path.exists：
if not os.path.exists(r'c:\foo'):  # 返回值：bool
    os.mkdir(r'c:\foo')  # 当路径中不存在文件夹或文件时，则创建foo文件夹

# removedirs：
os.removedirs(r'c:\foo\bar')

# remove：
os.remove(r'c:\foo\bar.txt')

# chdir：
foo = os.chdir(r'c:\foo')
print(r)  # None
print(os.getcwd())  # c:\foo

# 复制文件夹：
import os
def foo(args,kwargs):
    listdir = os.listdir(args)  # 遍历args的文件夹与文件，并将其名字加到列表
    for i in listdir:  # 遍历列表
        pathjoin01 = os.path.join(args,i)  # 拼接args与其路径下的文件夹或文件
        if os.path.isdir(pathjoin01):  # 当拼接的路径是文件夹时
            pathjoin02 = os.path.join(kwargs,i)  # 拼接粘贴的路径与复制路径对应的文件夹
            os.mkdir(pathjoin02)  # 创建空文件夹
            foo(pathjoin01,pathjoin02)  # 递归
        else:  # 当拼接的路径是文件时
            with open(pathjoin01,'rb') as flow01:  # 获取复制路径下的文件流
                file = flow01.read()  # 读取文件流的内容
                with open(os.path.join(kwargs,i),'wb') as flow02:  # 拼接粘贴路径与复制路径对应的文件并获取流
                    flow02.write(file)  # 写入内容

foo(r'c:\foo',r'c:\bar')  # 对应复制的路径与粘贴的路径

'''
递归：

1. 每次递归后其实已经执行完一次for循环了（只不过值返不出去）
2. 直到最后一次递归时值才被全部返出去(准确来说是等最后一层递归里的内容结束才会返回给上一层的递归内容，如再遇到递归则再执行一次递归再返回，如此循环直到结束)
3. 每次递归剩余的for循环次数都在等返回值才能继续执行下一次循环
'''