7，文件操作（done）

路径说明

• 读写文件就是请求操作系统打开一个文件对象，然后，通过操作系统提供的接口从这个文件对象中读取文件，或者把数据写入这个文件对象中；
• 路径分为两种：
  • 绝对路径：’/root/.jupyter/xellgat’ (python的工作目录)
  • 相对路径：../picture/1.png（1.png这张图片以python的工作目录为参考点，所在位置就是相对路径）
• 路径书写的三种方式：
  • ‘\’ 比如：file = open(‘d:\python\test.txt’)
  • r’’ 比如：file = open(r’d:\python\test.txt’)
  • ‘/‘ 比如：file = open(‘d:/python/test.txt’) <——————————-> （推荐的写法） linux的路径写法

    操作模式

打开文件

使用open( )打开

• file：用来指定打开的文件（不是文件的名字，而是文件的路径），如果要写入的文件不存在，函数 open( ) 将自动创建它；
• mode：用来指定打开文件时的模式，默认为r，只读模式，如果省略了模式实参，Python将以默认的只读模式打开文件；
• encoding：用来指定打开文件时的编码方式； ```python f = open(‘a.txt’,’r’)

print(f.read())

f.close()

- 缺点: 使用这样的方式直接打开文件，如果出现异常（如，读取文件过程中文件不存在），则直接出现错误，close命令无法执行，文件无法关闭;
<a name="9efd1e75"></a>
### 使用with open( )打开
优势：用with语句的好处就是到达语句末尾时会自动关闭文件，即使出现异常。
- with 的作用就是调用close( )方法;
- with的方法和前面的try ... finally是一样的，但是代码更佳简洁，并且不必调用f.close( )方法;
```python
with open('a.txt','r') as f:
    print(f.read())

使用try-except-finally打开

由于文件读写时都有可能会产生IOError，一旦出错，后面的f.close()就不会调用，所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try…finally来实现：

f = open('a.txt','r')
try:
    for line in f.readlines():
        print(line)
except:
    print('Ouput Error')
finally:
    f.close()

读取内容

步骤：

• 首先, 使用open( )函数打开一个文件，传入文件名和标示符即可；
• 接着, 调用read( )方法读取文件的全部内容，python把内容读到内存，用一个str对象表示，{注意: 如果读取的是数字, 必须使用int()或float()函数转换成数值型才能进行运算}
  • 调用read( )：{常用于文件很小的情况下}，该方法会一次性读取文件的全部内容, 如果文件有10G，内存就爆了;
  • 调用read(size)：{常用于不能确定文件大小}， 为了保险起见，使用read(size)方法, 可以每次最多读取size个字节的内容, 例如, read(1024) 每次读取1024个字节的数据内容;
  • 调用readline( )：每次读取一行内容;
  • 调用readlines( )：{常用于读取配置文件}， 该方法会一次性读取所有内容保存在一个列表中;

• 最后, 调用close( )方法关闭文件，文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源；

  读取一份文本文件

  with open('a.txt','r',encoding='utf8') as f:                # 使用with open()可以自动释放资源
    if f.readable():                                        # 用于容错，判断该文件是否可读,返回的是布尔值(比如：把模式改成'w')
        for line in f.readlines():
            print(line.strip())                                # 把末尾的’\n’在 strip()函数中可以把目标内容line里面所有的空格，空行等都删除掉，只剩余文字内容
    else:
        print('不可读')

• encoding用于传递编码参数；

• 如果文本中夹杂了一些非法编码的字符，可能会遇到UnicodeDecodeError，解决办法是在open()函数传递一个errors参数，表示遇到编码错误后如何处理，最简单的方式是直接忽略

  with open('file/openfile.txt','r', encoding = 'gbk', errors='ignore' ) as f:

读取多份文本文件

with open('/home/xbwang/Desktop/output_measures.txt','r') as f:
........
with open('/home/xbwang/Desktop/output_measures2.txt','r') as f1:
........
with open('/home/xbwang/Desktop/output_output_bk.txt','r') as f2:
......

读取大文件的正确姿势

# 打开文件
file = open("README")
while True:
    # 读取一行内容
    text = file.readline()
    # 判断是否读到内容
    if not text:
        break
    # 每读取一行的末尾已经有了一个 `\n`
    print(text, end="")
# 关闭文件
file.close()

读取二进制文件

with open('111.jpg','r',encoding='utf8') as f:                # 要读取二进制文件，比如图片、视频等等，则用'rb'模式打开文件即可
    if f.readable():
        print(f.read())
    else:
        print('不可读')

写入内容

• 写文件和读文件是一样的，唯一区别是调用open()函数时，传入标识符’w’或者’wb’表示写文本文件或写二进制文件；
• 以写入（ ‘w’ ）模式打开文件时要小心，因为如果指定的文件已经存在，python将在返回文件对象前会清空该文件；
• python只能将字符串写入文本，如果要将数值存储到文本中，必须先使用函数str( ) 将其转换为字符串格式；
• write() 在写入的文本时, 不会在行末尾添加换行符，所以在写入多行时要指定换行符, 可以使用空格、制表符和空行来设置这些输出的格式;
  • 调用write( )：每次都会将原来的内容清空，然后写入当前的内容.
  • 调用writelines( )：写入可迭代的数据，没有换行的效果，需要手动加\n来表示换行.
• 当我们写文件时，操作系统往往不会立刻把数据写入磁盘，而是放到内存缓存起来，空闲的时候再慢慢写入;
• 只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘；

• 忘记调用close()的后果是数据可能只写了一部分到磁盘，剩下的丢失了，所以，还是用with语句来得比较保险；

  with open('a.txt','w+') as f:                        # 标示符’w’表示只写，’w+’可读可写
    s1 = '3.141592653589793239462643383279'
    if f.writable():                                # 用于判断该文件是否可写,返回的是布尔值  
        f.write(s1)
    f.seek(0,0)                                     # 光标已处在末尾,想要看文本内容,则要重置光标到文本开头处
    print(f.read())

操作内容

• 下面演示操作文件中圆周率的值：
  • 注意：在变量str存储的字符串中，包含原来位于每行左边的空格，为了删除这些空格，可使用strip( ), 而不是rstrip( ). ```python import collections

filename = ‘file/openfile.txt’

with open(filename) as f: # 打开文件，并将其中的所有行都存储在一个列表中 lines = f.readlines()

str=’’ # 创建了一个空变量,用于存储圆周率的值

print(isinstance(lines,collections.Iterator)) # 查看lines是否是迭代器

for line in lines: str += line.strip() # 使用一个循环将各行都加入str中,使用strip()删除每行末尾的换行符及位于每行左边的空格

print(str) # 打印这个字符串及其长度 print(len(str))

- 假如有一个文本文件，其中包含精确到小数点后1000000位的字符串，但是我们只要打印到小数点后50位，避免终端为了显示全部1000000位而不断地翻滚：
```python
filename = 'file/openfile.txt'
with open(filename) as file:
    lines=file.readlines()
str=''
for line in lines:
    str+=line.strip()
print(str[:52]+'....')                            # 打印到小数点后50位
print(len(str))

文件指针

• 指针就相当于我们在word中输入时候的光标，光标在哪文件就从哪开始输入;
• 使用open()方法打开文件时候，指针会默认在文件开始的地方;

  f.read(3)

  表示的是从指针所在的地方往后读取三个字符，也就是说不改变指针的位置的话，f.read(3)就是读取文件开头的三个字符;

f.write()

表示的是将指针放在文件末尾处进行写入，写完之后指针依旧会在文件末尾处;

with open('file/openfile.txt',mode='rt',encoding='utf-8') as f:
    date = f.read(3)                                                # 光标所在的位置往后读取三个字符
    print(date)

f = open('file/openfile.txt',mode='rb')
print(f.read(3).decode('utf-8'))
f.close()

f.seek()

文件内指针的移动是以字节为单位的, 唯独t模式下的read读取内容个数是以字符为单位;
f.seek(指针的偏移量, [0,1,2]): 控制文件指针的移动

f.tell()

查看文件指针当前位置

模式控制

强调：其中0模式可以在t或者b模式使用, 而1跟2模式只能在b模式下用

0 模式
默认的模式，该模式代表指针移动的字节数是以文件的开头为参照的

with open('file/openfile.txt',mode='rt',encoding='utf8',errors='ignore') as f1:
    print(f1.read())
    f1.seek(2,0)
    print(f1.tell())
    print(f1.read())

with open('file/openfile.txt',mode='rb') as f2:
    f2.seek(2,0)
    print(f2.tell())
    print(f2.read().decode('utf8'))

with open('file/openfile.txt',mode='rt',encoding='utf-8',errors='ignore') as f3:
    print(f3.read())
    f3.seek(5,0)
    print(f3.read())

1 模式
该模式代表指针移动的字节数是以当前所在的位置为参照的

with open('file/openfile.txt',mode='rb') as f:
    f.seek(3,1)
    print(f.tell())
    f.seek(4,1)
    print(f.tell())
    print(f.read().decode('utf-8'))

2 模式
该模式代表指针移动的字节数是以文件末尾的位置为参照的

with open('file/openfile.txt',mode='rb') as f:
    f.seek(-9,2)
    data=f.read()
    print(data.decode('utf-8'))

关闭文件

• 为什么要关闭文件？
  • 可以释放系统资源
  • 会立即清空缓冲区的数据内容到磁盘文件 ```python f = open(‘file/openfile_write.txt’,’w+’)

print(f.writable())

s1 = ‘123456789’ f.write(s1)

f.seek(0,0)
print(f.read())

f.flush() # 刷新，可以立即清空缓冲区的数据内容到磁盘文件，比close提前执行

f.close() # 释放资源

<a name="3819bdaa"></a>
## 文件操作（重）
---
<a name="6fc5044a"></a>
### 引用os模块
```python
import os                               # 它是与操作系统交互的一个接口，os提供的方法就是用来调用操作系统的方法
os.environ                              # 获取系统环境变量
os.name                                    # 输出字符串指示当前使用平台,win->'nt'; Linux->'posix'
os.sep                                    # 输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.system("bash command")                 # 运行shell命令，直接显示
os.stat('path/filename')                  # 获取指定的文件/目录信息
os.path.basename('getpassword.py')
os.path.dirname('getpassword.py')        # 返回path的目录，其实就是os.path.split(path)的第一个元素
os.path.abspath('getpassword.py')        # 返回path规范化的绝对路径
os.path.isabs('getpassword.py')            # 如果path是绝对路径，返回True
os.path.split('getpassword.py')         # 将path分割成目录和文件名二元组返回  
os.path.basename('getpassword.py')         # 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值，即os.path.split(path)的第二个元素 
os.path.exists('getpassword.py')         # 如果path存在，返回True；如果path不存在，返回False
os.path.isfile('getpassword.py')          # 如果path是一个存在的文件，返回True，否则返回False
os.path.isdir('getpassword.py')          # 如果path是一个存在的目录，则返回True，否则返回False
os.path.getatime('getpassword.py')         # 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime('getpassword.py')      # 返回path所指向的文件或者目录的最后修改时间
# os.path.join(path1[, path2[, ...]])    # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

获取目录中的文件列表

假设你当前的工作目录有子目录叫 my_directory：

方法1：os.listdir( )方法（旧）

import os
print(os.listdir('./'))                                        # 获取当前目录下的所有文件和子目录，以列表方式返回
print(os.listdir('../'))                                    # 获取当前目录的上级目录下的所有文件和子目录，以列表方式返回
print(os.listdir('my_directory'))                             # 获取指定目录下的所有文件和子目录，包括隐藏文件，以列表方式返回

方法2：os.scandir( )方法（新）

• os.scandir() 和with语句一起使用，因为它支持上下文管理协议，使用上下文管理器关闭迭代器，并在迭代器耗尽后自动释放获取的资源； ```python import os

with os.scandir(‘my_directory’) as entries: # 使用os.scandir()方法，返回的是一个迭代器 for entry in entries: print(entry.name)

<a name="50ce697c"></a>
#### 方法3：from pathlib import Path（牛逼）
- `pathlib.Path()` 返回的是 `PosixPath` 或 `WindowsPath` 对象，这个取决于操作系统；
- `pathlib.Path()` 对象中有一个 `.iterdir()` 方法，用于创建一个迭代器，包含该目录下所有文件和目录信息；
- `pathlib` 提供了一组类，以简单并且面向对象的方式提供了路径上的大多数常见的操作，使用 `pathlib` 比起使用 `os` 中的函数更加有效；
- `pathlib.Path()` 提供了在 `os` 和 `shutil` 中大部分处理文件和路径的功能，并且它的方法比这些模块更加有效；
- 和 `os` 相比，使用 `pathlib` 的另一个好处是减少了操作文件系统路径所导入包或模块的数量；
- 使用 `pathlib.Path()` 或 `os.scandir()` 来替代 `os.listdir()` 是获取目录列表的首选方法，尤其是需要获取文件类型和文件属性信息的时候；
- 在上面的例子中，调用 `pathlib.Path()` 并传入了一个路径参数，然后调用 `.iterdir()` 方法来获取 `my_directory` 下的所有文件和目录列表；
```python
from pathlib import Path
entries = Path('my_directory')
print(entries)
for entry in entries.iterdir():
    print(entry)                    # 显示该目录下的文件路径：my_directory\a.txt
    print(entry.name)                # 只显示文件名

实例演示：列出目录中的文件

需求：

• 分别使用 os.listdir() ，os.scandir() 和 pathlib.Path() 来打印出目录下所有文件的名称；
• 为了过滤目录，并且只列出使用 os.listdir() 方式生成的目录列表的文件，需要使用 os.path ；

使用 os.listdir() 方法，它返回的是指定路径中所有内容的列表，接着使用 os.path.isfile() 来过滤列表，让其只显示文件，不显示目录，代码如下：

import os
mypath = 'my_directory'
for entry in os.listdir(mypath):
    if os.path.isfile(os.path.join(mypath,entry)):          # 使用os.path.isfile判断该路径是否是文件类型
        print(entry)

使用 os.scandir() 或 pathlib.Path() 方法列出一个目录中所有的文件

import os
mypath = 'my_directory'
with os.scandir(mypath) as entries:   
    for entry in entries:
        if entry.is_file():                                 # 对ScandirIterator的每一项调用entry.is_file() ，如果返回True，则表示这一项是一个文件
            print(entry.name)

使用 pathlib.Path() 列出一个目录中的所有文件

from pathlib import Path
mypath = Path('my_directory')
for entry in mypath.iterdir():
    if entry.is_file():                                     # 在.iterdir()产生的每一项调用.is_file()，产生的输出结果和上面相同
        print(entry.name)

将for循环和if语句组合成一个生成器表达式，则上述的代码可以更加简洁

mypath = Path('my_directory')
files = [entry for entry in mypath.iterdir() if entry.is_file()]
for i in files:
    print(i.name)

实例演示：列出目录中的目录

使用 os.listdir() 和 os.path() 列出子目录

import os
mypath = 'my_directory'
for entry in os.listdir(mypath):
    if os.path.isdir(os.path.join(mypath, entry)):
        print(entry)

当多次使用 os.path,join() 时，以这种方式操作文件系统就会变得很笨重，所以可以使用os.scandir( )方法：

import os
mypath = 'my_directory'
with os.scandir(mypath) as entries:
    for entry in entries:
        if entry.is_dir():
            print(entry.name)

使用 pathlib.Path()

from pathlib import Path
mypath = Path('my_directory')
for entry in mypath.iterdir():
    if entry.is_dir():
        print(entry.name)

获取文件的属性

Python可以很轻松的获取文件大小，文件修改时间等文件属性，可以通过使用 os.stat() ， os.scandir() 或 pathlib.Path 来获取；
下面的例子显示了如何获取 my_directory 中文件的最后修改时间，以时间戳的方式输出：

import os
from pathlib import Path
dir = 'my_directory'
with os.scandir(dir) as f:              # os.scandir() 返回一个ScandirIterator 对象
    for i in f:                         # ScandirIterator 对象中的每一项有.stat() 方法，能获取关于它指向文件或目录的信息
        print(i.stat().st_mtime)        # 最后，代码打印了 st_time 属性，该属性是上次修改文件内容的时间  
"""结果:
1599114017.307
1599114019.87
1599126668.4891484
1599114024.14
"""

使用 pathlib 模块可以获取同样的效果

import os
from pathlib import Path
dir = Path('my_directory')
for i in dir.iterdir():                 # 循环.iterdir()，返回迭代器，并通过对其中每一项调用.stat()来获取文件属性
    print(i.stat().st_mtime)            # st_mtime属性是一个浮点类型的值，表示的是时间戳
"""结果:
1599114017.307
1599114019.87
1599126668.4891484
1599114024.14
"""

为了让 st_time 返回的值更容易阅读，可以使用 datatime模块

import datetime                                                                 
from pathlib import Path                                                        
def timers(timestamp, convert_to_local=True, utc=8, is_remove_ms=True):
    """                                                                         
    转换 UNIX 时间戳为 datetime对象                                                     
    :param timestamp: 时间戳                                                       
    :param convert_to_local: 是否转为本地时间                                           
    :param utc: 时区信息，中国为utc+8                                                   
    :param is_remove_ms: 是否去除毫秒                                                 
    :return: datetime 对象                                                        
    """                                                                         
    if is_remove_ms:                                                            
        timestamp = int(timestamp)   
    dt = datetime.datetime.utcfromtimestamp(timestamp) 
    if convert_to_local:                                                        
        dt = dt + datetime.timedelta(hours=utc)   
    return dt                                                                   
def convert_date(timestamp, format='%Y-%m-%d %H:%M:%S'):                        
    dt = timers(timestamp)                                     # 调用 convert_date() 来转换文件最后修改时间让其以一种人类可读的方式显示                 
    return dt.strftime(format)                                # convert_date() 使用 .strftime() 将datetime类型转换为字符串                     
basepath = Path('my_directory')   
for entry in basepath.iterdir():
    if entry.is_file():
        info = entry.stat()                                                       # 首先得到 my_directory 中文件的列表以及它们的属性                
        print('{} 上次修改时间为 {}'.format(entry.name, timers(info.st_mtime)))
"""结果:
a.txt 上次修改时间为 2020-09-03 14:20:17
b.txt 上次修改时间为 2020-09-03 14:20:19
VS操作记录 上次修改时间为 2020-09-03 14:20:24
"""

修改默认目录

import os
os.chdir("dirname")                                  # 改变当前脚本工作目录；相当于shell下cd

重命名目录/文件

import os
os.rename("a.txt","b.txt")                          # 重命名文件
os.rename("shell","python")                            # 重命名目录
os.renames("shell/a.txt","python/b.txt")            # 同时修改目录名和目录下的文件名

创建文件夹

创建单个目录

import os
os.mkdir('shell')                                    # 创建单个目录，如果该目录已经存在，os.mkdir()将抛出FileExistsError异常
os.mkdir('shell',Oo777)                                # 为目录设定访问权限
os.makedirs('shell/tmp')                            # 创建多层递归目录

使用 pathlib 来创建单目录

from pathlib import Path
p = Path('xellgat_test1')
p.mkdir()                                            # 如果路径已经存在，mkdir()会抛出FileExistsError异常

为了避免像这样的错误抛出， 当发生错误时捕获错误并让你的用户知道:

from pathlib import Path
p = Path('xellgat_test1')
try:
    p.mkdir()                
except FileExistsError as e:
    print(e)

from pathlib import Path
p = Path('xellgat_test1')
try:
    p.mkdir(exist_ok=True)        # 可以给.mkdir()传入exist_ok = True参数来忽略FileExistsError异常,如果目录已存在，则不会引起错误
except FileExistsError as e:
    print(e)

创建多层目录

os.makedirs() 和 os.mkdir() 类似，两者之间的区别在于：os.makedirs() 不仅可以创建单独的目录，还可以递归的创建目录树，换句话说，它可以创建任何必要的中间文件夹，来确保存在；

完整的路径，os.makedirs() 和在bash中运行 mkdir -p 类似，例如，要创建一组目录像 2018/10/05，你可以像下面那样操作:

import os
os.makedirs('2018/10/05', mode=0o770)

上述代码创建了 2018/10/05 的目录结构并为所有者和组用户提供读、写和执行权限，默认的模式为 0o777 ，增加了其他用户组的权限；

删除目录/文件

import os
os.remove('a.txt')                                     # 删除一个文件
os.rmdir('shell')                                    # 删除空目录，若目录下有任何文件存在，则无法删除，报错；相当于shell中rmdir dirname 
os.removedirs('shell/tmp')                             # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

文件的复制

输入一个文件的名字, 自动创建一份它的副本 (如:openfile_read.txt ==> openfile_read_bak.txt)

# 使用读写的方式完成
with open('file/openfile_read.txt','rt') as f:
    with open('file/openfile_read_bak.txt','wt') as f1:
        f1.write(f.read())
print('复制完成!')

# 使用os模块完成
import os
# 目录下拼接一个文件
path1 = os.path.dirname(__file__)     # 获取当前文件所在的目录（绝对路径）， 注意：这个__file__必须指向的是一个xx.py的文件才行
print(path1)
print(type(path1))
f = os.path.join(path1,'aa.txt')
print(f)
# 组合生成新文件名的方法:
filename = oldfile.rpartition('.')            # 比如旧文件test.txt, 那么分割后的结果为:('test','.','txt')
newfile = name[0] + '.bak.' + name[2]
filename = os.path.splitext(oldfile)           # 比如旧文件test.txt, 那么分割后的结果为:('test','.txt')
newfile = name[0] + '.bak.' + name[1]

import os
f1 = input('请输入一个文件名字{有路径则带上路径}:')           # 输入一个文件路径,用于表示将要打开一个旧文件
if os.path.isfile(f1):                                  # 使用os.path.isfile来判断输入的是否为文件
    open_oldfile = open(f1,encoding='utf8')             # 如果是,打开旧文件
    file_name = f1.rpartition('.')                      # 根据旧文件名称,自动生成新文件名称,使用分隔符右切分开旧文件名,然后取指定的元素即可
    new_file = file_name[0] + '.bak.' + file_name[2]    # 组合生成新文件名称
    open_newfile = open(new_file,'w',encoding='utf8')   # 打开新文件
    while True: 
        content = open_oldfile.read(1024)               # 把旧文件中读取出来的内容,写入到新的文件中,为了避免大文件,使用循环,一次写入1024个字节
        open_newfile.write(content)   
        if not content:
            break
    open_oldfile.close()
    open_newfile.close()
else:
    print('你输入的文件不存在!')

[推荐使用优化的] 对一个非文本文件进行副本创建

import os
oldfile = input('请输入一个文件名字{有路径则带上路径}:')       # 输入一个文件路径,用于表示将要打开一个旧文件
if os.path.isfile(oldfile):                                    # 使用os.path.isfile来判断输入的是否为文件
    open_oldfile = open(oldfile,'rb')                          # 如果是,打开旧文件,不管是什么文件,都以二进制的形式读取文件
    filename = oldfile.rpartition('.')              
    newfile = filename[0] + '.bak.' + filename[2]   
    open_newfile = open(newfile,'wb')                          # 打开新文件, 不管是什么文件,都以二进制的形式写入文件
    while True: 
        content = open_oldfile.read(1024)                   # 把旧文件中读取出来的内容,写入到新的文件中,为了避免大文件,使用循环,一次写入1024个字节
        open_newfile.write(content)   
        if not content:
            break
    open_oldfile.close()
    open_newfile.close()
else:
    print('你输入的文件不存在!')

CSV文件的读写

csv文件: Comma-Separated Values,中文叫逗号分隔值或者字符分隔值, 其文件以纯文本的形式存储表格数据. 可以把它理解为一个表格, 只不过这个表格是以纯文本的形式现实的, 单元格与单元格之间, 默认使用逗号分开, 每行数据之间, 使用换行进行分隔.

# 读取文件
import csv
file = open('file/opencsv.csv','r',encoding='utf8',newline='')
r = csv.reader(file)
for data in r:
    print(data)
file.close()

# 写入文件
import csv   #系统内置模块
file = open('file/demo.csv','w',encoding='utf8',newline='')  # 打开一个新的文件,如果不存在,则创建(因为是w模式), newline='' 表示不换行
w = csv.writer(file) 
#一行一行的写入   
w.writerow(['name','age','score','city'])       # 对新建的csv文件写入一行数据
w.writerow(['张三',19,90,'武汉'])
w.writerow(['李四',20,90,'上海'])
#多行写入  
w.writerows(
    [
        ['王五',21,88,'广州'],
        ['赵六',25,92,'北京'],
        ['merry',18,92,'纽约'],
    ]
)
file.close()