参考 ：http://www.cnblogs.com/nulige/archive/2016/12/06/6037752.html

在很多时候，你会想要让你的程序与用户（可能是你自己）交互。你会从用户那里得到输入，然后打印一些结果。我们可以分别使用 raw_input 和 print 语句来完成这些功能。对于输出，你也可以使用多种多样的 str（字符串）类。例如，你能够使用 rjust 方法来得到一个按一定宽度右对齐的字符串。利用 help(str) 获得更多详情。

另一个常用的 输入/输出 类型是处理文件。创建、读和写文件的能力是许多程序所必需的

文件

• 你可以通过创建一个 file类 的对象来打开一个文件，分别使用 file类 的 read、readline 或 write 方法来恰当地读写文件。
• 对文件的读写能力依赖于你在打开文件时指定的模式。
• 最后，当你完成对文件的操作的时候，你调用 close 方法来告诉 Python 我们完成了对文件的使用。

使用文件

poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
use Python!
''''''
Python2 中 file 是内建函数
Python3 中 移除了 file 函数，使用 open 函数替代
'''# f = file('poem.txt', 'w')  f = open('poem.txt', 'w')  # open for 'w'riting
f.write(poem)  # write text to file
f.close()  # close the filef = open('poem.txt')
# if no mode is specified, 'r'ead mode is assumed by default
while True:line = f.readline()if len(line) == 0:  # Zero length indicates EOFbreakprint(line, end='')# Notice comma to avoid automatic newline added by Python
f.close()  # close the file

首先，我们通过指明我们希望打开的文件和模式来创建一个 file 类的实例。模式可以为读模式（'r'）、写模式（'w'）或追加模式（'a'）。事实上还有多得多的模式可以使用，你可以使用 help(file) 来了解它们的详情。

我们首先用写模式打开文件，然后使用 file 类的 write 方法来写文件，最后我们用 close 关闭这个文件。

接下来，我们再一次打开同一个文件来读文件。如果我们没有指定模式，读模式会作为默认的模式。在一个循环中，我们使用 readline 方法读文件的每一行。这个方法返回包括行末换行符的一个完整行。所以，当一个空的 字符串被返回的时候，即表示文件末已经到达了，于是我们停止循环。

注意，因为从文件读到的内容已经以换行符结尾，所以我们在 print 语句上使用逗号来消除自动换行。最后，我们用 close 关闭这个文件。

序列化

python3 的 _pickle 模块详解：https://www.cnblogs.com/ranxf/p/7800179.html

python3 中 cPickle 模块已经更名为 _pickle，所以在 python3 中导入时可以使用：import _pickle as cPickle

或者使用 pandas 里面的 cPickle：https://blog.csdn.net/sinat_36458870/article/details/73551210

Python 提供一个标准的模块，称为 pickle。使用它你可以在一个文件中储存 任何Python对象，之后你又可以把它完整无缺地取出来。这被称为 持久的储存对象。

还有另一个模块称为 cPickle，它的功能和 pickle 模块完全相同，只不过它是用C语言编写的，因此要快得多（ 比 pickle 快 1000 倍）。你可以使用它们中的任一个，而我们在这里将使用 cPickle 模块。记住，我们把这两个模块都简称为 pickle 模块。

存储与存取

#!/usr/bin/python
# Filename: pickling.py# import cPickle as p  # python2 使用 cPickle 方法# python3中cPickle模块已经更名为_pickle,所以在python3中导入时可以使用：
import _pickle as p    # python3 使用 cPickle 方法# import pickle as pshop_list_file = 'shop_list.data'
# the name of the file where we will store the objectshop_list = ['apple', 'mango', 'carrot']# Write to the file
f = open(shop_list_file, 'w')
p.dump(shop_list, f)  # dump the object to a file
f.close()del shop_list  # remove the shop_list# Read back from the storage
f = open(shop_list_file)
stored_list = p.load(f)
print(stored_list)# 输出
# $ python
# pickling.py
# ['apple', 'mango', 'carrot']

首先，请注意我们使用了 import..as 语法。这是一种便利方法，以便于我们可以使用更短的模块名称。在这个例子中，它还让我们能够通过简单地改变一行就切换到另一个模块（cPickle或者pickle）！在程序的其余部分的时候，我们简单地把这个模块称为p。为了在文件里储存一个对象，首先以写模式打开一个file对象，然后调用储存器模块的dump函数，把对象储存到打开的文件中。这个过程称为储存 。接下来，我们使用pickle模块的load函数的返回来取回对象。这个过程称为 取储存 。

pathlib --- 面向对象的文件系统路径

pathlib 官方文档：https://docs.python.org/zh-cn/3/library/pathlib.html

你应该使用 pathlib 替代 os.path：https://zhuanlan.zhihu.com/p/87940289

Python 文件 和 目录 操作方法大全（含实例）

Python 获取当前路径：https://www.cnblogs.com/strongYaYa/p/5860401.html

import os, sys

使用 sys.path[0]、sys.argv[0]、os.getcwd()、os.path.abspath(__file__)、os.path.realpath(__file__)

sys.path 是 Python 会去寻找模块的搜索路径列表。

sys.path[0] 和 sys.argv[0] 是一回事，因为 Python 会自动把 sys.argv[0] 加入sys.path。

如果你在 C:\test 目录下执行 python getpath\getpath.py，那么 os.getcwd() 会输出 "C:\test" ，sys.path[0] 会输出 "C:\test\getpath" 。

如果你用 py2exe 模块把 Python 脚本编译为可执行文件，那么 sys.path[0] 的输出还会变化：
如果把依赖库用默认的方式打包为 zip 文件，那么 sys.path[0] 会输出 "C:\test\getpath\libarary.zip"；
如果在 setup.py 里面指定 zipfile=None 参数，依赖库就会被打包到 exe 文件里面，那么 sys.path[0] 会输出 "C:\test\getpath\getpath.exe"。

示例代码：

#!/bin/env python
# -*- encoding=utf8 -*-import os
import sysif __name__ == "__main__":print("__file__=%s" % __file__)print("os.path.realpath(__file__)=%s" % os.path.realpath(__file__))print(f"os.path.dirname(os.path.realpath(__file__))={os.path.dirname(os.path.realpath(__file__))}")print(f"os.path.split(os.path.realpath(__file__))={os.path.split(os.path.realpath(__file__))[0]}")print("os.path.abspath(__file__)=%s" % os.path.abspath(__file__))print("os.getcwd()=%s" % os.getcwd())print("sys.path[0]=%s" % sys.path[0])print("sys.argv[0]=%s" % sys.argv[0])# 输出结果:
# D:\>python ./python_test/test_path.py
# __file__=./python_test/test_path.py
# os.path.realpath(__file__)=D:\python_test\test_path.py
# os.path.dirname(os.path.realpath(__file__))=D:\python_test
# os.path.split(os.path.realpath(__file__))=D:\python_test
# os.path.abspath(__file__)=D:\python_test\test_path.py
# os.getcwd()=D:\
# sys.path[0]=D:\python_test
# sys.argv[0]=./python_test/test_path.py

获取当前的路径：

import os
import sysif __name__ == "__main__":# __file__ 是当前执行的文件# 获取当前文件__file__的路径print(f"os.path.realpath(__file__)= {os.path.realpath(__file__)}")# 获取当前文件__file__的所在目录print(f"os.path.dirname(os.path.realpath(__file__))= {os.path.dirname(os.path.realpath(__file__))}")# 获取当前文件__file__的所在目录print(f"os.path.split(os.path.realpath(__file__))= {os.path.split(os.path.realpath(__file__))[0]}")

Python判断文件是否存在的三种方法

：https://www.cnblogs.com/jhao/p/7243043.html

一、Python中对文件、文件夹操作（os 和 shutil 常用方法）

# os 模块

os.sep 可以取代操作系统特定的路径分隔符。windows下为 '\\'
os.name 字符串指示你正在使用的平台。比如对于Windows，它是'nt'，而对于Linux/Unix用户，它是 'posix'
os.getcwd() 函数得到当前工作目录，即当前Python脚本工作的目录路径
os.getenv() 获取一个环境变量，如果没有返回none
os.putenv(key, value) 设置一个环境变量值
os.listdir(path) 返回指定目录下的所有文件和目录名
os.remove(path) 函数用来删除一个文件
os.system(command) 函数用来运行shell命令
os.linesep 字符串给出当前平台使用的行终止符。例如，Windows使用 '\r\n'，Linux使用 '\n' 而Mac使用 '\r'
os.path.split(path)  函数返回一个路径的目录名和文件名
os.path.isfile() 和os.path.isdir()函数分别检验给出的路径是一个文件还是目录
os.path.exists() 函数用来检验给出的路径是否真地存在
os.curdir  返回当前目录 ('.')
os.mkdir(path) 创建一个目录
os.makedirs(path) 递归的创建目录
os.chdir(dirname) 改变工作目录到dirname
os.path.getsize(name) 获得文件大小，如果name是目录返回0L
os.path.abspath(name) 获得绝对路径
os.path.normpath(path) 规范path字符串形式
os.path.splitext()  分离文件名与扩展名
os.path.join(path,name) 连接目录与文件名或目录
os.path.basename(path) 返回文件名
os.path.dirname(path) 返回文件路径
os.walk(top,topdown=True,οnerrοr=None)  遍历迭代目录os.rename(src, dst)  重命名file或者directory src到dst
如果dst是一个存在的directory, 将抛出OSError. 在Unix, 如果dst存在且是一个file, 如果用户
有权限的话，它将被安静的替换. 操作将会失败在某些Unix 中如果src和dst在不同的文件系统中.
如果成功, 这命名操作将会是一个原子操作 (这是POSIX 需要).
在 Windows上, 如果dst已经存在, 将抛出OSError，即使它是一个文件. 在unix，Windows中有效。os.renames(old, new) 递归重命名文件夹或者文件。像rename()

# shutil 模块

1.得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()
2.返回指定目录下的所有文件和目录名:                 os.listdir()
3.函数用来删除一个文件:                   os.remove()
4.删除多个目录：                          os.removedirs（r“c：\python”）
5.检验给出的路径是否是一个文件：          os.path.isfile()
6.检验给出的路径是否是一个目录：          os.path.isdir()
7.判断是否是绝对路径：                    os.path.isabs()
8.检验给出的路径是否真地存:               os.path.exists()
9.返回一个路径的目录名和文件名: os.path.split()     eg os.path.split('/home/swaroop/byte/code/poem.txt') 结果：('/home/swaroop/byte/code', 'poem.txt')
10.分离扩展名：       os.path.splitext()
11.获取路径名：       os.path.dirname()
12.获取文件名：       os.path.basename()
13.运行shell命令:     os.system()
14.读取和设置环境变量:os.getenv() 与os.putenv()
15.给出当前平台使用的行终止符:    os.linesep    Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'
16.指示你正在使用的平台：         os.name       对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'
17.重命名：          os.rename（old， new）
18.创建多级目录：    os.makedirs（r“c：\python\test”）
19.创建单个目录：    os.mkdir（“test”）
20.获取文件属性：    os.stat（file）
21.修改文件权限与时间戳：os.chmod（file）
22.终止当前进程：        os.exit（）
23.获取文件大小：        os.path.getsize（filename）shutil.copyfile( src, dst) 从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为IOException. 如果当前的dst已存在的话就会被覆盖掉
shutil.move( src, dst)  移动文件或重命名
shutil.copymode( src, dst) 只是会复制其权限其他的东西是不会被复制的
shutil.copystat( src, dst) 复制权限、最后访问时间、最后修改时间
shutil.copy( src, dst)  复制一个文件到一个文件或一个目录
shutil.copy2( src, dst)  在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了，类似于cp –p的东西
shutil.copy2( src, dst)  如果两个位置的文件系统是一样的话相当于是rename操作，只是改名；如果是不在相同的文件系统的话就是做move操作
shutil.copytree( olddir, newdir, True/Flase)把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接
shutil.rmtree( src ) 递归删除一个目录以及目录内的所有内容

二、文件操作方法大全：

关于 open 模式：

r： 只读模式，文件必须存在
w： 以写方式打开，
a： 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+：以读写模式打开。            读写模式，光标默认在起始位置，当需要写入的时候，光标自动移到最后
w+：以读写模式打开 (参见 w )    写读模式，先清空原内容，再写入，也能够读取
a+：以读写模式打开 (参见 a )    追加读模式，光标默认在最后位置，直接写入，也能够读取。
rb：以二进制读模式打开
wb：以二进制写模式打开 (参见 w )
ab：以二进制追加模式打开 (参见 a )
rb+：以二进制读写模式打开 (参见 r+ )
wb+：以二进制读写模式打开 (参见 w+ )
ab+：以二进制读写模式打开 (参见 a+ )

文件操作：

os.mknod("test.txt")        # 创建空文件
fp = open("test.txt", 'w')  # 直接打开一个文件，如果文件不存在则创建文件fp.read([size])             # size为读取的长度，以byte为单位
fp.readline([size])         # 读一行，如果定义了size，有可能返回的只是一行的一部分
fp.readlines([size])        # 把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。
fp.write(str)               # 把str写到文件中，write()并不会在str后加上一个换行符
fp.writelines(seq)          # 把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
fp.close()                  # 关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。  # 如果一个文件在关闭后还对其进行操作会产生ValueError
fp.flush()                  # 把缓冲区的内容写入硬盘
fp.fileno()                 # 返回一个长整型的”文件标签“
fp.isatty()                 # 文件是否是一个终端设备文件（unix系统中的）
fp.tell()                   # 返回文件操作标记的当前位置，以文件的开头为原点
fp.next()                   # 返回下一行，并将文件指针移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。
fp.seek(offset[,whence])    # 将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。如果提供whence参数就不一定了，whence为 0 表示从头开始计算，1 表示以当前位置为原点计算。2 表示以文件末尾为原点进行计算。注意：如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。
fp.truncate([size])         # 把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是随机内容加上去。

注意：   把两个路径合成一个时，不要直接拼字符串，而要通过 os.path.join(part1,part2)函数，这样可以正确处理不同操作系统的路径分隔符。在linux/Unix/Mac下，os.path.join()返回这样的字符串： part1/part2。而Windows下会返回这样的字符串： part1\part2

import os
import shutilfile_dir = "D:\\Python_os\\os"                          # 注意 \\ ；windows 下是这么表示的；Linux 和 Mac 是 /
file_name = "test.txt"
file_abs = os.path.join(file_dir, file_name)            # os.path.join(...) 表示路径链接'''判断路径或文件'''
print (1,os.path.isabs(file_dir))                       # 判断是否绝对路径
print (2,os.path.isabs(file_name))
print (3,os.path.isabs(file_abs))
print (4,os.path.exists(file_abs))                      # 判断是否真实存在
print (5,os.path.exists(os.path.join(file_dir,"xxx")))
print (6,os.path.isdir(file_dir))                       # 判断是否是个目录
print (7,os.path.isdir(file_abs))
print (8,os.path.isfile(file_dir))                      # 判断是否是个文件
print (9,os.path.isfile(file_abs))   

复制、移动文件夹/文件。须使用 shutil 模块，引入 import shutil shutil.copyfile("old","new")  # 复制文件，都只能是文件
shutil.copytree("old","new")　# 复制文件夹，都只能是目录，且new必须不存在
shutil.copy("old","new")　　　# 复制文件/文件夹，复制 old 为 new（new是文件，若不存在，即新建），# 复制 old 为至 new 文件夹（文件夹已存在）
shutil.move("old","new")  　　# 移动文件/文件夹至 new 文件夹中import os
import shutilfile_dir = "D:\\Python_shutil"
os.chdir(file_dir)
shutil.copyfile("test_org.txt","test_copy.txt")        # copy test_org.txt 为 test_copy.txt 若存在，则覆盖
shutil.copyfile("test_org.txt","test1.txt")            # 存在，覆盖
shutil.copytree("test_org","test_copytree")            # copy test_org 为 test_copytree（不存在的新目录）
shutil.copy("test_org.txt","test_copy1.txt")           # 同 copyfile
shutil.copy("test_org.txt","test_copy")                # 将文件 copy 至 目标文件夹中（须存在）
shutil.copy("test_org.txt","test_xxx")                 # 将文件 copy 至 目标文件（该文件可不存在，注意类型！）
print os.listdir(os.getcwd())
shutil.move("test_org.txt","test_move")                # 将文件 move 至 目标文件夹中
shutil.move("test_org","test_move")                    # 将文件夹 move 至 目标文件夹中
print os.listdir(os.getcwd())

三、目录操作方法大全

1.创建目录os.mkdir("file")
2.复制文件：shutil.copyfile("oldfile","newfile")    #oldfile和newfile都只能是文件
shutil.copy("oldfile","newfile")            #oldfile只能是文件夹，newfile可以是文件，也可以是目标目录
3.复制文件夹：
4.shutil.copytree("olddir","newdir")        #olddir和newdir都只能是目录，且newdir必须不存在
5.重命名文件（目录）
os.rename("oldname","newname")              #文件或目录都是使用这条命令
6.移动文件（目录）
shutil.move("oldpos","newpos")
7.删除文件
os.remove("file")
8.删除目录
os.rmdir("dir")                             #只能删除空目录
shutil.rmtree("dir")                        #空目录、有内容的目录都可以删
9.转换目录
os.chdir("path")                            #换路径os.getcwd() 　　　　# 获取当前工作目录
os.chdir(...)　　　 # 改变工作目录
os.listdir(...)　　 # 列出目录下的文件
os.mkdir(...)　　   # 创建单个目录    　　　　注意：创建多级用 os.makedirs()
os.makedirs(...)　  # 创建多级目录  

四、文件综合操作实例

将文件夹下所有图片名称加上 '_fc'

# -*- coding:utf-8 -*-
import re
import os
import time
#str.split(string)分割字符串
#'连接符'.join(list) 将列表组成字符串
def change_name(path):global iif not os.path.isdir(path) and not os.path.isfile(path):return Falseif os.path.isfile(path):file_path = os.path.split(path) #分割出目录与文件lists = file_path[1].split('.') #分割出文件与文件扩展名file_ext = lists[-1] #取出后缀名(列表切片操作)img_ext = ['bmp','jpeg','gif','psd','png','jpg']if file_ext in img_ext:os.rename(path,file_path[0]+'/'+lists[0]+'_fc.'+file_ext)i+=1 #注意这里的i是一个陷阱#或者#img_ext = 'bmp|jpeg|gif|psd|png|jpg'#if file_ext in img_ext:#    print('ok---'+file_ext)elif os.path.isdir(path):for x in os.listdir(path):change_name(os.path.join(path,x)) #os.path.join()在路径处理上很有用
img_dir = 'D:\\xx\\xx\\images'
img_dir = img_dir.replace('\\','/')
start = time.time()
i = 0
change_name(img_dir)
c = time.time() - start
print('程序运行耗时:%0.2f'%(c))
print('总共处理了 %s 张图片'%(i))输出结果：
程序运行耗时:0.11
总共处理了 109 张图片

文件操作_读写函数详解

file() 函数用于创建一个file对象，它有一个别名叫open()，可能更形象一些，它们是内置函数。

file(name[, mode[, buffering]]) -> file object Open a file. The mode can be ‘r’, ‘w’ or ‘a’ for reading (default),writing or appending.
The file will be created if it doesn’t exist when opened for writing or appending;
it will be truncated when opened for writing.
Add a ‘b’ to the mode for binary files.
Add a ‘+’ to the mode to allow simultaneous reading and writing.
If the buffering argument is given, 0 means unbuffered, 1 means line buffered, and larger numbers specify the buffer size.
The preferred way to open a file is with the builtin open() function.
Add a ‘U’ to mode to open the file for input with universal newline support.
Any line ending in the input file will be seen as a ‘\n’ in Python.
Also, a file so opened gains the attribute ‘newlines’;
the value for this attribute is one of None (no newline read yet),
‘\r’, ‘\n’, ‘\r\n’ or a tuple containing all the newline types seen.
‘U’ cannot be combined with ‘w’ or ‘+’ mode. file()与open()的功能一致，打开文件或创建文件。都属于内建函数。

file的属性和方法：

In [1]: dir(file)
Out[1]:
['__class__','__delattr__','__doc__','__enter__','__exit__','__format__','__getattribute__','__hash__','__init__','__iter__','__new__','__reduce__','__reduce_ex__','__repr__','__setattr__','__sizeof__','__str__','__subclasshook__','close','closed','encoding','errors','fileno','flush','isatty','mode','name','newlines','next','read','readinto','readline','readlines','seek','softspace','tell','truncate','write','writelines','xreadlines']

在 Python 中一切皆对象，file 也不例外，file 也有方法和属性。

下面先来看如何创建一个file对象：file(name[, mode[, buffering]])

buffering 如果为 0 表示不进行缓冲，如果为 1 表示进行 "行缓冲"，如果是一个大于 1 的数表示缓冲区的大小，应该是以字节为单位的。

file 对象的属性和方法。

file的属性:closed    # 标记文件是否已经关闭，由close()改写 encoding  # 文件编码 mode      # 打开模式 name      # 文件名 newlines  # 文件中用到的换行模式，是一个tuple softspace # boolean型，一般为0，据说用于printfile的读写方法：F.read([size])        # size为读取的长度，以byte为单位 F.readline([size])    # 读一行，如果定义了size，有可能返回的只是一行的一部分 F.readlines([size])   # 把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用 readline() 来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。 F.write(str)          # 把str写到文件中，write()并不会在str后加上一个换行符 F.writelines(seq)     # 把seq的内容全部写到文件中。这个函数也只是忠实地写入，不会在每行后面加上任何东西。 F.close()             # 关闭文件。如果一个文件在关闭后还对其进行操作会产生ValueErrorF.flush()     # 把缓冲区的内容写入硬盘 F.fileno()    # 返回一个长整型的 "文件描述符"，即 "文件句柄" 或者 id F.isatty()    # 文件是否是一个终端设备文件（unix系统中的） F.tell()      # 返回文件操作标记的当前位置，以文件的开头为原点 F.next()      # 返回下一行，并将文件操作标记位移到下一行。把一个file用于for ... in file这样的语句时，就是调用next()函数来实现遍历的。 F.seek(offset[,whence])   # 将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。# 但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。# 需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。 F.truncate([size])  # 把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。# 如果size比文件的大小还要大，依据系统的不同可能是不改变文件，# 也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。

open()文件操作

open(…)
open(name[, mode[, buffering]]) -> file object Open a file using the file() type, returns a file object. This is the
preferred way to open a file. See file.__doc__ for further information. open()函数是file()函数的别名函数，能够打开文件并返回一个文件对象而非文件的内容。
(应该理解为一个存储着文件的内容的对象，如果想获取内容便需要对文件对象进行操作)。
可以指定不同的打开mode(rw)，在调用open()函数后一定要调用文件对象内建的close()函数来关闭文件。
一般结合try..finally语句来确定会关闭文件对象。 注意：当你open()一个文件，实质上是将该文件的内容加载到缓存中，所以当你open()文件之后，对文件做了修改也不会影响到open()返回的对象的value。 

常用mode ( 6 种mode可以组合使用)： 

r(read缺省参数)： 以读的方式打开文件，不能调用write方法，当文件不存在时报错。
w(write)：        以写方式打开文件，能够写入内容并覆盖，不能调用read方法，      如果文件不存在，则创建新同名文件。
a(append)：       以追加模式打开文件，可以进行写操作，                          如果文件不存在，则创建新同名文件。
+：               使用+允许同时进行读写操作。
U：               支持所有类型的换行符(\n、\r、\r\n) 。由于历史的原因，换行符在不同的系统中有不同模式，比如在 unix中是一个\n，而在windows中是‘\r\n’，用U模式打开文件，就是支持所有的换行模式，也就说‘\r’ '\n' '\r\n'都可表示换行，会有一个tuple用来存贮这个文件中用到过的换行符。b：               表示对二进制文件进行操作(图片、视频)。
t：               对文本文件进行操作。

1.open使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。file_object = open('thefile.txt')try:all_the_text = file_object.read( )finally:file_object.close( )注：不能把open语句放在try块里，因为当打开文件出现异常时，文件对象file_object无法执行close()方法。2.读文件读文本文件input = open('data', 'r')#第二个参数默认为rinput = open('data')读二进制文件input = open('data', 'rb')读取所有内容file_object = open('thefile.txt')try:all_the_text = file_object.read( )finally:file_object.close( )读固定字节file_object = open('abinfile', 'rb')try:while True:chunk = file_object.read(100)if not chunk:breakdo_something_with(chunk)finally:file_object.close( )读每行list_of_all_the_lines = file_object.readlines( )如果文件是文本文件，还可以直接遍历文件对象获取每行：for line in file_object:process line3.写文件写文本文件output = open('data', 'w')写二进制文件output = open('data', 'wb')追加写文件output = open('data', 'w+')写数据file_object = open('thefile.txt', 'w')file_object.write(all_the_text)file_object.close( )写入多行file_object.writelines(list_of_text_strings)注意，调用writelines写入多行在性能上会比使用write一次性写入要高。

读文件

以读方式打开文件后可以调用这三个函数：read() \ readline() \ readlines()
他们都可以传递一个int来指定需要读取的总Size(Bytes)。
注意：因为读取的文件会缓存到内存中，所以当需要读取的文件Size大于内存时，需要指定每次读入的Size。

In [15]: !tail /etc/passwd > fileOperation.txt
In [20]: pswd = open('/usr/local/src/pyScript/fileOperation.txt','r')
In [21]: type(pswd)
Out[21]: file
In [32]: pswd
Out[32]: <open file '/usr/local/src/pyScript/fileOperation.txt', mode 'r' at 0x7f048314a420>

read()读取文件内容

read(…)
read([size]) -> read at most size bytes, returned as a string.
If the size argument is negative or omitted, read until EOF is reached.
Notice that when in non-blocking mode, less data than what was requested
may be returned, even if no size parameter was given. 读取指定Size的内容，缺省参数为全部内容，返回一个String类型对象。

readline() 获取文件一行的内容

readline(…)
readline([size]) -> next line from the file, as a string.
Retain newline. A non-negative size argument limits the maximum
number of bytes to return (an incomplete line may be returned then).
Return an empty string at EOF. 读取文件中的一行含有行结束符的内容，每执行一次会自动获取往下一行的内容，返回一个String。
当读取到最后一行再执行此函数时，会返回一个空String，不会报错。

一个综合例子：

open() + fileObject.readline() + try..finally + String.split() + os.path.exists()
因为readline()函数返回的是String类型对象，所以我们可以使用循环来遍历这一行中所有的元素。

import os
def ergodicIndex(fileName):pwd = open('fileOperation.txt','r')try:content  = pwd.readline()index = content.split(':')for i in index:print i,finally:pwd.close()
if __name__ == '__main__':fileName='/usr/local/src/pyScript/fileOperation.txt'if os.path.exists(fileName):ergodicIndex(fileName)else:print "The file not exist"

readlines() 读取文件所有行的内容

readlines(…)
readlines([size]) -> list of strings, each a line from the file.
Call readline() repeatedly and return a list of the lines so read.
The optional size argument, if given, is an approximate bound on the
total number of bytes in the lines returned. 获取文件所有的内容，并返回一个以每行内容作为一个String元素的List类型对象，本质是通过循环调用readline()实现的。

pwd = open('fileOperation.txt','r')
content = pwd.readlines()
print content
print content[0]
print content[0][0]

修改指定行的内容：

cfg = open(cfgUrl,'r+')
cfgFile = cfg.readlines()
cfgFile[lineNum] = cfgStrcfg = open(cfgUrl,'w+')
cfg.writelines(cfgFile)
cfg.flush()   #刷新内存的缓存区，即将缓存区中的内容写入到磁盘，但不会关闭文件。
cfg.close()

将文件以r+的方式打开，并返回一个对象。对对象的内容进行修改后，再将文件以w+的方式打开，将对象的内容写入到文件中。实现对文件指定行的内容修改。

read()、readline()、readlines()的区别

read()和readlines()默认都是获取文件的所有内容。但是read()返回一个String类型对象，元素是一个Char。readlines()返回一个List类型对象，元素是一个Sting。而readline()获取文件的一行内容，返回是一个String。

写文件

注意：调用write()、writeline()时，文件原有的内容会被清空，因为文件指针初始指向文件的首行首个字母，而进行写操作实质就是在文件指针指向的位置开始写入内容。

write()

write(…)
write(str) -> None. Write string str to file.
Note that due to buffering, flush() or close() may be needed before
the file on disk reflects the data written. 将传递的String参数写入并覆盖文件内容，返回None。需要执行close()或flush()后才会将内存的数据写入到文件中。 注意：当你在没有调用close()函数之前，你是可以调用多次write()函数来实现追加额效果，即后来的write()函数的写入的内容并不会覆盖前一次使用write()函数写入的内容，但是不会自动添加换行符。

pwd = open('fileOperation.txt','w')
pwd.write('My name is JMilk')
pwd.flush()
pwd.write('My name is chocolate')
pwd.flush()
pwd.write('123')
pwd.write('456')
pwd.close()结果：My name is JMilkMy name is chocolate123456

一个综合例子：

open() + fileObject.write() + os.path.exists() + ergodicDictionary

import os
def write_test(fileName,content_iterable):try:pwd = open(fileName,'w')for key,value in content_iterable.items():pwd.write(key+'\t'+value+'\n')  #传入String类型参数同时加入换行符finally:pwd.close()if __name__ == '__main__':fileName = '/usr/local/src/pyScript/fileOperation.txt'dic = {'name':'Jmilk','age':'23','city':'BJ'}if os.path.exists(fileName):write_test(fileName,dic)else:print 'File not exist!'结果：
city    BJ
age     23
name    Jmilk

writelines() 写入多行内容

writelines(…)
writelines(sequence_of_strings) -> None. Write the strings to the file.
Note that newlines are not added. The sequence can be any iterable object
producing strings. This is equivalent to calling write() for each string. 将传递的迭代对象的String元素逐个写入文件，相当于每一行都调用write()函数，但是不会自动添加换行符。

import os
def write_lines(fileName,content_iterable):try:pwd = open(fileName,'w')pwd.writelines(content_iterable) #传递List类型参数finally:pwd.close()if __name__ == '__main__':fileName = '/usr/local/src/pyScript/fileOperation.txt'li = ['my name is Jmilk'+'\n','My name is chocolate'+'\n']  #定义List时加入换行符if os.path.exists(fileName):write_lines(fileName,li)else:print 'File not exist!'结果：
my name is Jmilk
My name is chocolate 

write()和writelines()的区别

从上面两个例子中可以看出，write()接受的是String类型参数，所以可以在()中对实参进行修改加入’\n’。而writelines()接受的是iterable类型参数，并且iteraber对象的元素需要为String类型，只能在定义iterable的时候加入’\n’。在写入多行内容时writelines()会比write()更有效率。再一次反映 数据结构决定了对象操作这一句话，所以对数据结构的理解是非常重要的。python数据结构，请参考：http://blog.csdn.net/jmilk/article/details/48391283

将标准输出重定向写入到指定文件

系统标准输入、输出、Err本质是一个类文件对象。重定向即：

sys.stdout = fileObject_write 

#!/usr/bin/env python
#Filename:stdoTest.py
#coding=utf8
import sysfristOut = sys.stdout  #备份初始的输出文件对象
print type(fristOut)logOut = open('/usr/local/src/pyScript/out.log','w')
sys.stdout = logOut  #重定向输出到新的文件对象
print 'Test stdout.'  #重定向后，不会打印到屏幕logOut.close()   #关闭open()打开的文件对象
sys.stdout = fristOut  #还原输出文件对象

文件指针

文件指针：当使用open()函数打开一个文件并返回一个文件对象后，在文件对象中会存放着当前”光标”在文件中的位置，对文件进行的读、写、截断操作都是基于文件指针，并从文件指针+1开始进行的操作。。这个位置称为文件指针(从文件头部开始计算的字节数)，与C语言额指针概念相似，实质是文件中位置的标识。大部分的文件操作都是基于文件指针来实现的。注意：当对文件进行了读、写操作后都会改变文件指针的值。

tell()：查询文件中光标位置
seek()：光标定位

tell()获取当前文件指针(位置)

tell(…)
tell() -> current file position, an integer (may be a long integer).

pwd = open('fileOperation.txt','rw+')
pwd.tell()结果：
0        // 因为新打开的文件，文件指针指向文件开头位置

seek()转移文件指针

seek(…)
seek(offset[, whence]) -> None. Move to new file position. 可以接收偏移量和选项作为参数，返回None。
当whence==0时，将文件指针从文件头部转移到”偏移量”指定的字符处。
当whence==1时，将文件指针从文件的当前位置往后转移”偏移量”指定的字符数。
当whence==2时，将文件指针从文件尾部向前移动”偏移量”指定的字符数。 

使用示例：

f = open('file','r')
print(f.tell())  #光标默认在起始位置
f.seek(10)    #把光标定位到第10个字符之后
print(f.tell())  #输出10
f.close()
----------------------
f = open('file','w')
print(f.tell())  #先清空内容，光标回到0位置
f.seek(10)
print(f.tell())
f.close()
----------------------
f = open('file','a')
print(f.tell())  #光标默认在最后位置
f.write（'你好 世界'）
print(f.tell())  #光标向后9个字符，仍在最后位置
f.close()

flush() 同步将数据从缓存转移到磁盘

示例，实现进度条功能

import sys,time
for i in range(40):sys.stdout.write('*')sys.stdout.flush()  time.sleep(0.2)if __name__ == '__main__':pass# 下面代码也能够实现相同的功能
import time
for i in range(40):print('*',end='',flush=True) #print中的flush参数time.sleep(0.2)

truncate()截断文件

不能在r模式下执行。w模式下，已经清空所有数据，使用truncate没有任何意义。a模式下，截断指定位置后的内容。

truncate(…)
truncate([size]) -> None. Truncate the file to at most size bytes.
Size defaults to the current file position, as returned by tell(). 默认从文件指针指向的位置开始截断文件内容，也可以通过传递int参数n来指定截断的起始位置，即改变文件指针的位置。
从文件指针指向的位置n开始，之后的文件内容(不包含n)全部删除，以可修改mode打开的文件可以使用此方法。

f = open('file','a')
f.truncate(6) #只显示6个字节的内容（6个英文字符或三个汉字），后面的内容被清空。

光标位置总结

一个汉字两个字节，涉及光标位置的方法有4个：read、tell、seek、truncate。

#--------------------------光标总结head-----------------------------------
f = open('file','r')
print(f.read(6)) #6个字符
print(f.tell())  #位置12字节，一个汉字两个字节
f.close()f = open('file','r')
f.seek(6)      #6个字节
print(f.tell())
f.close()f = open('file','a')
print(f.tell())  #光标默认在最后位置
f.write('你好 世界')
print(f.tell())  #光标向后9个字节，一个汉字两个字节，仍在最后位置 182-->191
f.close()f = open('file','a',encoding='utf-8')
print(f.truncate(6)) #由于需要光标定位位置，所以也是字节。只显示6个字节的内容（6个英文字母或三个汉字,一个汉字两个字节），后面的内容被清空。
f.close()
#-----------------------------光标总结end---------------------------------

一个综合例子：

truncate()+tell()+seek()

In [8]: %cat fileOperation.txt
0123456789In [9]: pwd = open('fileOperation.txt','rw+')In [10]: pwd.tell()
Out[10]: 0In [11]: pwd.seek(5)In [12]: pwd.tell()
Out[12]: 5In [13]: pwd.truncate()In [14]: pwd.close()In [15]: %cat fileOperation.txt
01234

with语句

可以同时对多个文件同时操作，当with代码块执行完毕时，会自动关闭文件释放内存资源，不用特意加f.close() 。

num = 0
with open('file','r') as f1,open('file2','w',encoding='utf8') as f2:for line in f1:num += 1if num == 5:line = ''.join([line.strip(),'羊小羚'])f2.write(line)

遍历文件

from __future__ import print_function
import osroot_dir = "d:/"  # 指明被遍历的文件夹# 三个参数：分别返回1.父目录 2.所有文件夹名字（不含路径） 3.所有文件名字
for parent, dir_names, file_names in os.walk(root_dir):for dir_name in dir_names:  # 输出文件夹信息print "parent is:" + parentprint "dirname is" + dir_namefor file_name in file_names:  # 输出文件信息print "parent is:" + parentprint "filename is:" + file_nameprint "the full name of the file is:" + os.path.join(parent, file_name)  # 输出文件路径信息

基于字符read & write

最基本的文件操作当然就是在文件中读写数据。这也是很容易掌握的。现在打开一个文件以进行写操作：1. fileHandle = open ( 'test.txt', 'w' )fileHandle = open ( 'test.txt', 'w' )‘w'是指文件将被写入数据，语句的其它部分很好理解。下一步就是将数据写入文件：1. fileHandle.write ( 'This is a test.\nReally, it is.' )fileHandle.write ( 'This is a test.\nReally, it is.' )这个语句将“This is a test.”写入文件的第一行，“Really, it is.”写入文件的第二行。最后，我们需要做清理工作，并且关闭文件：1. fileHandle.close()fileHandle.close()正如你所见，在Python的面向对象机制下，这确实非常简单。需要注意的是，当你再次使用“w”方式在文件中写数据，所有原来的内容都会被删除。如果想保留原来的内容，可以使用“a”方式在文件中结尾附加数据：1. fileHandle = open ( 'test.txt', 'a' )
2. fileHandle.write ( '\n\nBottom line.' )
3. fileHandle.close()fileHandle = open ( 'test.txt', 'a' )
fileHandle.write ( '\n\nBottom line.' )
fileHandle.close()然后，我们读取test.txt，并将内容显示出来：1. fileHandle = open ( 'test.txt' )
2. print fileHandle.read()
3. fileHandle.close()fileHandle = open ( 'test.txt' )
print fileHandle.read()
fileHandle.close()以上语句将读取整个文件并显示其中的数据。

基于行的读写 line

1. fileHandle = open ( 'test.txt' )
2. print fileHandle.readline() # "This is a test."
3. fileHandle.close()  fileHandle = open ( 'test.txt' )
print fileHandle.readline() # "This is a test."
fileHandle.close() 同时，也可以将文件内容保存到一个list中： 1. fileHandle = open ( 'test.txt' )
2. fileList = fileHandle.readlines()
3. for fileLine in fileList:
4.     print '>>', fileLine
5. fileHandle.close()  fileHandle = open ( 'test.txt' )
fileList = fileHandle.readlines()
for fileLine in fileList:
print '>>', fileLine
fileHandle.close() 或者在文件中一次读取几个字节的内容：1. fileHandle = open ( 'test.txt' )
2. print fileHandle.read ( 1 ) # "T"
3. fileHandle.seek ( 4 )
4. print FileHandle.read ( 1 ) # " "(原文有错)fileHandle = open ( 'test.txt' )
print fileHandle.read ( 1 ) # "T"
fileHandle.seek ( 4 )
print FileHandle.read ( 1 ) # " "(原文有错)

随机访问文件中的位置 seek

Python在读取一个文件时，会记住其在文件中的位置，如下所示：1. fileHandle = open ( 'test.txt' )
2. garbage = fileHandle.readline()
3. fileHandle.readline() # "Really, it is."fileHandle.close()fileHandle = open ( 'test.txt' )
garbage = fileHandle.readline()
fileHandle.readline() # "Really, it is."fileHandle.close()可以看到，只有第二行显示出来。然而，我们可以让Python从头开始读来解决这个问题：1. fileHandle = open ( 'test.txt' )
2. garbage = fileHandle.readline()
3. fileHandle.seek ( 0 )
4. print fileHandle.readline() # "This is a test."
5. fileHandle.close()fileHandle = open ( 'test.txt' )
garbage = fileHandle.readline()
fileHandle.seek ( 0 )
print fileHandle.readline() # "This is a test."
fileHandle.close()在上面这个例子中，我们让Python从文件第一个字节开始读取数据。所以，第一行文字显示了出来。当然，我们也可以获取Python在文件中的位置：1. fileHandle = open ( 'test.txt' )
2. print fileHandle.readline() # "This is a test."
3. print fileHandle.tell() # "17"
4. print fileHandle.readline() # "Really, it is."fileHandle = open ( 'test.txt' )
print fileHandle.readline() # "This is a test."
print fileHandle.tell() # "17"
print fileHandle.readline() # "Really, it is."

二进制方式读写

在Windows和Macintosh环境下，有时可能需要以二进制方式读写文件，比如图片和可执行文件。此时，只要在打开文件的方式参数中增加一个“b”即可：1. fileHandle = open ( 'testBinary.txt', 'wb' )
2. fileHandle.write ( 'There is no spoon.' )
3. fileHandle.close()fileHandle = open ( 'testBinary.txt', 'wb' )
fileHandle.write ( 'There is no spoon.' )
fileHandle.close()1. fileHandle = open ( 'testBinary.txt', 'rb' )
2. print fileHandle.read()
3. fileHandle.close()fileHandle = open ( 'testBinary.txt', 'rb' )
print fileHandle.read()
fileHandle.close()

python本身并没有对二进制进行支持，不过提供了一个模块来弥补，就是struct模块。

# python没有二进制类型，但可以存储二进制类型的数据，就是用string字符串类型来存储二进制数据，
# 这也没关系，因为string是以1个字节为单位的。import struct
a=12.34#将a变为二进制
bytes=struct.pack('i',a)    #此时bytes就是一个string字符串，字符串按字节同a的二进制存储内容相同。#再进行反操作。现有二进制数据bytes，（其实就是字符串），将它反过来转换成python的数据类型：a,=struct.unpack('i',bytes)    #注意，unpack返回的是tuple# 所以如果只有一个变量的话：
bytes=struct.pack('i',a)# 那么，解码的时候需要这样
a,=struct.unpack('i',bytes) 或者 (a,)=struct.unpack('i',bytes)#如果直接用a=struct.unpack('i',bytes)，那么 a=(12.34,) ，是一个tuple而不是原来的浮点数了。
#如果是由多个数据构成的，可以这样：
a='hello'
b='world!'
c=2
d=45.123
bytes=struct.pack('5s6sif',a,b,c,d)# 此时的bytes就是二进制形式的数据了，可以直接写入文件比如 binfile.write(bytes)
# 然后，当我们需要时可以再读出来，bytes=binfile.read()
# 再通过struct.unpack()解码成python变量
a,b,c,d=struct.unpack('5s6sif',bytes)'5s6sif'这个叫做fmt，就是格式化字符串，由数字加字符构成，5s表示占5个字符的字符串，2i，表示2个整数等等，
下面是可用的字符及类型，ctype表示可以与python中的类型一一对应。

存储对象（序列化存储）

使用上面的模块，可以实现在文件中对字符串的读写。 然而，有的时候，你可能需要传递其它类型的数据，如list、tuple、dictionary和其它对象。在Python中，你可以使用Pickling来完成。你可以使用Python标准库中的“pickle”模块完成数据转储。
下面，我们来编组一个包含字符串和数字的list：

import picklefileHandle = open('pickleFile.txt', 'w')
testList = ['This', 2, 'is', 1, 'a', 0, 'test.']
pickle.dump(testList, fileHandle)
fileHandle.close()fileHandle = open('pickleFile.txt')
testList = pickle.load(fileHandle)
fileHandle.close()
print testList

存储更加复杂的数据：

import picklefileHandle = open('pickleFile.txt', 'w')
testList = [123, {'Calories': 190}, 'Mr. Anderson', [1, 2, 7]]
pickle.dump(testList, fileHandle)
fileHandle.close()fileHandle = open('pickleFile.txt')
testList = pickle.load(fileHandle)
fileHandle.close()

使用Python的“pickle”模块编组确实很简单。众多对象可以通过它来存储到文件中。如果可以的话，“cPickle”同样胜任这个工作。它和“pickle”模块一样，但是速度更快：

import cPicklefileHandle = open('pickleFile.txt', 'w')
cPickle.dump(1776, fileHandle)
fileHandle.close()

简明 Python 教程学习笔记_7_文件操作（os、shutil、pathlib ）相关推荐

1. 简明 Python 教程学习笔记_2_函数

   1. Python 内建函数 Python 内建函数:https://docs.python.org/zh-cn/3.9/library/functions.html#classmethod Pyth ...

2. 简明Python教程学习笔记_3_模块

   模块 如果你想要在其他程序中重用很多函数,那么你该如何编写程序呢?你可能已经猜到了,答案是使用模块.模块基本上就是一个包含了所有你定义的函数和变量的文件.为了在其他程序中重用模块,模块的文件名必须以. ...

3. Python入门学习笔记——12.文件操作

   ##################################################### # 1.文件写入 # 写入操作 ''' 1.打开文件 open()参数1:文件路径路径 ur ...

4. 简明Python教程学习笔记_1_基本

   参考:http://www.kuqin.com/abyteofpython_cn/index.html Learn Python in Y minutes:http://www.jianshu.com ...

5. 简明Python教程学习笔记_8_异常

   菜鸟教程 之 Python 异常处理:http://www.runoob.com/python/python-exceptions.html Python 一篇搞定所有的异常处理:https://ww ...

6. 简明Python教程学习笔记_6_面向对象编程

   面向对象编程:https://www.liaoxuefeng.com/wiki/897692888725344/923030496738368 面向对象高级编程:https://www.liaoxue ...

7. 简明Python教程学习笔记_5_解决问题

   问题 我提出的问题是: 我想要一个可以为我的所有重要文件创建备份的程序. 尽管这是一个简单的问题,但是问题本身并没有给我们足够的信息来解决它.进一步的分析是必需的.例如,我们如何确定该备份哪些文件?备 ...

8. 简明Python教程学习笔记_4_数据结构

   在Python中有三种内建的数据结构--列表.元组和字典. 列表 list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个 序列 的项目.假想你有一个购物列表,上面记载着你要买的东西,你就容 ...

9. 简明Python教程学习笔记_2_函数

   函数 为什么要有函数?因为在平时写代码时,如果没有函数的话,那么将会出现很多重复的代码,这样代码重用率就比较低...并且这样的代码维护起来也是很有难度的,为了解决这些问题,就出现了函数,用来将一些经常 ...

最新文章

1. rman备份后为什么要同时备份归档日志
2. 机器学习-贝叶斯分类器
3. 什么是CPython
4. UA MATH567 高维统计专题3 含L1-norm的凸优化4 Nesterov方法与Accelerate Proximal Gradient
5. Explain：解决MUI 软键盘弹起挤压页面问题
6. 关于javascript中私有作用域的预解释
7. 基于python的视频监控系统_Python实现微信监控报警系统
8. 《明日方舟》Python版公开招募工具
9. CVPR 2019 | 旷视提出新型目标检测损失函数：定位更精准
10. 金额大小写转换(2)
11. 亲爱的，别把上帝缩小了 ---- 读书笔记4
12. java游戏毕业论文参考文献全面论文100个
13. JavaScript — json文件的读取与写入
14. 360篡改html文件打开方式,Chrome浏览器被360导航篡改怎么办
15. 小清新版js扫雷（使用原生js）
16. Python3修改电脑mac地址
17. 网页游戏行业真的火爆吗？该如何选择？
18. 《快递查询-您身边的快递助手-隐私协议》
19. css中filter:alpha透明度总结
20. 游戏本电脑性价比排行2020新品竟如此给力？

热门文章

1. python库Camelot从pdf抽取表格数据以及python库camelot安装及使用中的一些注意事项
2. 安装paddlepaddle-GPU 报libcudnn.so和libcublas.so找不到的解决方案
3. 玩转算法之面试第九章-动态规划
4. 笔记：seafile 7.x 安装和部署摘要
5. Nature发布第一张人类造血干细胞发育的全面路线图
6. 7 计算机组成原理第五章 中央处理器 数据通路
7. 8万行的insert数据，Ctrl+c、Ctrl+v后心态崩了（如何在Linux下对MySQL数据库执行sql文件）...
8. 如何给网页标题添加icon小图标
9. 你所不知道的SQL Server数据库启动过程（用户数据库加载过程的疑难杂症）
10. Atitit 通过调用gui接口杀掉360杀毒 360卫士  qq保镖等难以结束的进程(javac# php )...