python 文件操作

2019.5.24
1.目录操作
```shell
import os
```
查看当前所在路径。
```shell
os.getcwd()
```
列举目录下的所有文件。返回的是列表类型。
```shell
os.listdir(path)
```
返回path的绝对路径。
```shell
os.path.abspath(path)
```
:文件或文件夹是否存在，返回True 或 False。
```shell
os.path.exists(path)
```
函数：连接两个或更多的路径名组件
```shell
os.path.join()
```
:文件或文件夹的最后修改时间，从新纪元到访问时的秒数。
```shell
os.path.getmtime(path)
```
:文件或文件夹的最后访问时间，从新纪元到访问时的秒数。
```shell
os.path.getatime(path)
```
判断是否是目录
```shell
os.path.isdir
```
:文件或文件夹的创建时间，从新纪元到访问时的秒数。
```shell
os.path.getctime(path)
```
改变当前工作目录
```shell
os.chdir(path)
```
更改权限
```shell
os.chmod(path, mode)
```
更改文件所有者
```shell
os.chown(path, uid, gid)
```
新建目录
```shell
os.mkdir()
```
重命名
```shell
os.rename(current_file_name,new_file_name)
```
删除一个空目录
```shell
os.rmdir()
```
删除文件
```shell
os.remove(file_name)
```
方法用于通过在目录树中游走输出在目录中的文件名，向上或者向下
方法是一个简单易用的文件、目录遍历器，可以帮助我们高效的处理文件、目录方面的事情。
语法
```shell
os.walk(top)

```
walk()方法语法格式如下：

```shell
os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
参数
top -- 是你所要遍历的目录的地址, 返回的是一个三元组(root,dirs,files)。

root 所指的是当前正在遍历的这个文件夹的本身的地址
dirs 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)
files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)
topdown --可选，为 True，则优先遍历 top 目录，否则优先遍历 top 的子目录(默认为开启)。如果 topdown 参数为 True，walk 会遍历top文件夹，与top 文件夹中每一个子目录。

onerror -- 可选，需要一个 callable 对象，当 walk 需要异常时，会调用。

followlinks -- 可选，如果为 True，则会遍历目录下的快捷方式(linux 下是软连接 symbolic link )实际所指的目录(默认关闭)，如果为 False，则优先遍历 top 的子目录。
```
例子：
```shell
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import os
for root, dirs, files in os.walk(".", topdown=False):
for name in files:
print(os.path.join(root, name))
for name in dirs:
print(os.path.join(root, name))
```
执行以上程序输出结果为：
```shell
./.bash_logout
./amrood.tar.gz
./.emacs
./httpd.conf
./www.tar.gz
./mysql.tar.gz
./test.py
./.bashrc
./.bash_history
./.bash_profile
./tmp
./tmp/test.py

```
os.path 模块主要用于获取文件的属性
```shell
os.path.abspath(path) # 返回绝对路径
os.path.basename(path) #返回文件名
os.path.dirname(path) #返回文件路径
os.path.exists(path) #路径存在则返回True,路径损坏返回False
os.path.getatime(path) #返回最近访问时间（浮点型秒数）
os.path.getmtime(path) #返回最近文件修改时间
os.path.getctime(path) #返回文件 path 创建时间
os.path.getsize(path) #返回文件大小，如果文件不存在就返回错误
os.path.isabs(path) #判断是否为绝对路径
os.path.isfile(path) #判断路径是否为文件
os.path.isdir(path) #判断路径是否为目录
os.path.join(path1[, path2[, ...]]) #把目录和文件名合成一个路径
os.path.samefile(path1, path2) #判断目录或文件是否相同
```
文件的操作：
文件打开：
open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
不同模式打开文件的完全列表：

模式 描述
```shell
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
```
文件读取
```shell
read() 每次读取整个文件，它通常用于将文件内容放到一个字符串变量中。如果文件大于可用内存，为了保险起见，可以反复调用read(size)方法，每次最多读取size个字节的内容。
readlines() 之间的差异是后者一次读取整个文件，象 .read() 一样。.readlines() 自动将文件内容分析成一个行的列表，该列表可以由 Python 的 for ... in ... 结构进行处理。
readline() 每次只读取一行，通常比readlines() 慢得多。仅当没有足够内存可以一次读取整个文件时，才应该使用 readline()。
```
注意：这三种方法是把每行末尾的'\n'也读进来了，它并不会默认的把'\n'去掉，需要我们手动去掉。
例子：
```shell
with open（"test.txt","r"） as f1:
list1 = f1.readlines()
Out[3]: ['111\n', '222\n', '333\n', '444\n', '555\n', '666\n']
```
去掉'\n'
```shell
list1[i] = list1[i].rstrip('\n')
```

write()来写入文件
```shell
with open('test.txt', 'w') as f:
f.write('Hello, world!')
```
python文件对象提供了两个“写”方法： write() 和 writelines()。

```shell
write()方法和read()、readline()方法对应，是将字符串写入到文件中。
writelines()方法和readlines()方法对应，也是针对列表的操作。它接收一个字符串列表作为参数，将他们写入到文件中，换行符不会自动的加入，因此，需要显式的加入换行符。
```
例子
```shell
f1 = open('test1.txt', 'w')
f1.writelines(["1", "2", "3"])
# 此时test1.txt的内容为:123

f1 = open('test1.txt', 'w')
f1.writelines(["1\n", "2\n", "3\n"])
# 此时test1.txt的内容为:
# 1
# 2
# 3
```
tell() 方法返回文件的当前位置，即文件指针当前位置。
```shell
fileObject.tell() 返回文件的当前位置。
```
例子：
```shell
#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 打开文件
fo = open("runoob.txt", "rw+")
print "文件名为: ", fo.name

line = fo.readline()
print "读取的数据为: %s" % (line)

# 获取当前文件位置
pos = fo.tell()
print "当前位置: %d" % (pos)

# 关闭文件
fo.close()
```
seek() 方法用于移动文件读取指针到指定位置。
```shell
fileObject.seek(offset[, whence])

```
参数
```shell
offset -- 开始的偏移量，也就是代表需要移动偏移的字节数

whence：可选，默认值为 0。给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。
```

返回值
```shell
如果操作成功，则返回新的文件位置，如果操作失败，则函数返回 -1。
```

读取文件名
```shell
file.name
```
##### with 关键字，系统会自动关闭文件

字典是另一种可变容器模型，且可存储任意类型对象。键必须是唯一的，但值则不必。
```shell
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
len(dict) #计算字典元素个数，即键的总数。
str(dict) #输出字典，以可打印的字符串表示。
type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型。
dict.copy() #复制一个字典
pop(key[,default]) #删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
```

join
```shell
#!/usr/bin/python
# -*- coding: UTF-8 -*-

str = "-";
seq = ("a", "b", "c"); # 字符串序列
print str.join( seq );
```
例子一：替换文件file.txt中所有的“北京”为“江苏”
```shell
f=open('file.txt','r')
f1=open('file1.txt','w')
for line in f:
if "北京" in line:
line = line.replace("北京","江苏")
f1.write(line)
f.close()
f1.close()

with open("file.txt","w") as f:
f.write(open("file1.txt").read())
```
例子二：合并两个文件的内容

```shell
'''
输入：电话簿、邮箱地址簿文件
处理：将两个文件内容进行合并
输出：合并后包含电话和邮箱地址簿的文件
--------------------------------
程序的步骤
一：打开文件、读取文件
二：分别获取文件中的信息，到两个字典1和2
三：建立合并用的空列表，完成字典1和2中的信息合并操作到列表中
四：将列表中的信息写入到新文件
五：关闭所有打开的文件
'''

file1_read = open("file11.txt", 'r')
file1_read.readline()
lines1 = file1_read.readlines()

file2_read = open("file12.txt", 'r')
file2_read.readline()
lines2 = file2_read.readlines()

dict1 = {}
dict2 = {}

for line in lines1:
element = line.split() #split() 通过指定分隔符对字符串进行切片
dict1[element[0]] = element[1]
# print(dict1)

for line in lines2:
element = line.split()
dict2[element[0]] = element[1]
# print(dict2)
file1_read.close()
file2_read.close()

lines = []
s = "姓名\t电话\t\t\t邮箱\n"
lines.append(s)
#print(s)

for key in dict1.keys():
if key in dict2.keys():
s = "\t".join([key, dict1[key], dict2[key]]) + '\n' #str.join(元组、列表、字典、字符串) 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
else:
s = "\t".join([key, dict1[key], '----------']) + '\n'
lines.append(s)
# print(lines)

for key in dict2.keys():
if key not in dict1.keys():
s = "\t".join([key, '----------', dict2[key]]) + '\n'
lines.append(s)
# print(lines)
with open("file13.txt", 'w') as file3_write:
file3_write.writelines(lines)