Golang文件读写操作详情

目录
  • 一、概念
  • 二、读取文件操作
    • 2.1 打开和关闭文件
      • defer 语句
    • 2.2 file.Read() 读取文件
      • Read 方法定义
      • ReadAt方法定义
      • 一次性读取
      • 循环读取
    • 2.3 bufio 读取文件
    • 2.4 ioutil 读取文件
    • 效率比较
  • 三、写入文件操作
    • 3.1 os.OpenFile()函数
    • 3.2 Write和WriteString 方式写入
    • 3.3 bufio.NewWriter
    • 3.4 ioutil.WriteFile
  • 四、复制文件
    • 4.1 通过ioutil进行复制
    • 4.2 以文件流的方式复制文件
  • 五、其他操作

一、概念

文件是数据源(保存数据的地方)的一种,文件最主要的作用就是保存数据。

文件在程序中是以流的形式来操作的。

  • 输入流和输出流

  • :数据在数据源(文件)和程序(内存)之间经历的路径
  • 输入流:数据从数据源(文件)到程序(内存)的路径
  • 输出流:数据从程序(内存)到数据源(文件)的路径

二、读取文件操作

2.1 打开和关闭文件

打开文件:

func Open(filename string) (file *File, err error)

Open打开一个文件用于读取。如果操作成功,返回的文件对象的方法可用于读取数据;对应的文件描述符具有O_RDONLY模式。如果出错,错误底层类型是*PathError

关闭文件:

func (f *File) Close() error

Close关闭文件f,使文件不能用于读写。它返回可能出现的错误。

示例:

package main
import (
	"fmt"
	"os"
)
func main() {
	//只读方式打开当前目录下的test.txt
	file, err := os.Open("test.txt")
	if err != nil {
		fmt.Println("open file failed!,err:",err)
	}
	//返回的是一个指针
	fmt.Println(&file)

	//关闭文件
	//err = file.Close()
	//if err != nil{
	//	fmt.Println("close file failed!,err:",err)
	//}
	//为了防止文件忘记关闭,通常使用defer注册文件关闭语句。
	defer file.Close() // 关闭文件
}

运行结果:

0xc0000ce018

defer 语句

  • defer—般用于资源的释放和异常的捕捉。
  • defer语句会将其后面跟随的语句进行延迟处理;跟在defer后面的语言将会在程序进行最后的return之后再执行。
  • defer归属的函数即将返回时,将延迟处理的语句按defer的逆序进行执行,也就是说,先被defer的语句最后被执行,最后被 defer的语句,最先被执行。

2.2 file.Read() 读取文件

Read 方法定义

func (f *File) Read(b []byte) (n int, err error)

从文件对象中读取长度为b的字节,返回当前读到的字节数以及错误信息。因此使用该方法需要先初始化一个符合内容大小的空的字节列表。读取到文件的末尾时,该方法返回0,io.EOF

ReadAt方法定义

func (file *File) ReadAt(b []byte, off int64) (n int, err Error)

从文件的off偏移量开始读取长度为b的字节。返回读取到字节数以及错误信息。当读取到的字节数n小于想要读取字节的长度len(b)的时候,该方法将返回非空的error。当读到文件末尾时,err返回io.EOF。

  • b:是指定字节长度的缓冲区
  • off:int64类型的偏移量,从此位置开始读取。

注意:ReadAt 绝对不允许出现,没有读满 buffer,又非 EOF,又没有 err 的情况发生,这个是接口语义明确规定的,这是一个非常细节的区别。

一次性读取

适用于读取较小文件使用:

package main
import (
	"fmt"
	"io"
	"os"
)
func main() {
	//1、只读方式打开当前目录下的test2.txt
	file, err := os.Open("test2.txt")
	if err != nil {
		fmt.Println("open file failed!,err:",err)
		return
	}
	//3、当函数退出时,及时关闭file
	//使用 defer 内置函数 当函数退出时才会调用,要及时关闭否则会内存泄露
	defer file.Close()
	//2、使用Read方法读取数据,注意一次只会读取128个字节
	tmp := make([]byte, 128)
	n, err := file.Read(tmp)
	//使用ReadAt方法读取数据,注意一次只会读取6个字节
	//tmp := make([]byte, 6)
	//n, err := file.ReadAt(tmp,6)

	//io.EOF 表示文件的末尾
	if err == io.EOF {
		fmt.Println("文件读取完毕")
		return
	}
	if err != nil {
		fmt.Println("read file failed,err:",err)
		return
	}
	fmt.Printf("读取了 %d 字节数据\n", n)
	fmt.Println(string(tmp[:n]))
}

运行结果:

读取了 13 字节数据
Hello Golang!

循环读取

使用 for 循环读取文件中的所有数据:

package main
import (
	"fmt"
	"io"
	"os"
)
//循环读取文件
func main() {
	//只读方式打开当前目录下的test.txt
	file, err := os.Open("test.txt")
	if err != nil {
		fmt.Println("open file failed!,err:",err)
		return
	}
	//关闭文件
	defer file.Close()
	//循环读取文件
	var content []byte
	//使用Read方法读取数据,注意一次只会读取128个字节
	tmp := make([]byte, 128)

	for {
		n, err := file.Read(tmp)	//每次读取128个字节
		if err == io.EOF {
			fmt.Println("文件读取完毕")
			break
		}
		if err != nil {
			fmt.Println("read file failed,err:",err)
			return
		}
		//每次读取的内容都追加到已知的byte切片中
		content = append(content,tmp[:n]...)
	}
	//将byte类型转换结果,打印结果
	fmt.Println(string(content))
}

运行结果:

文件读取完毕
水陆草木之花,可爱者甚蕃。晋陶渊明独爱菊。自李唐来,世人甚爱牡丹。
予独爱莲之出淤泥而不染,濯清涟而不妖,中通外直,不蔓不枝,香远益清,亭亭净植,可远观而不可亵玩焉。

予谓菊,花之隐逸者也;牡丹,花之富贵者也;莲,花之君子者也。
噫!菊之爱,陶后鲜有闻。莲之爱,同予者何人?牡丹之爱,宜乎众矣!

说明:

这里的循环读取文件其实就是一个不断追加的过程,将每次读取的128个字节追加到预先定义好的content切片中,最后将切片转换成string类型,进行打印显示。

2.3 bufio 读取文件

语法:

//bufio.NewReader(rd io.Reader) *Reader
r := bufio.NewReader(file)

//func (b *Reader) ReadString(delim byte) (string, error)
n, err := r.Read(buf)

参数

返回值:

使用 NewReader 读取文件时,首先,需要打开文件,接着, 使用打开的文件返回的文件句柄当作 函数参数 传入 NewReader。

最后,使用 NewReader 返回的 reader 对象调用 Read 来读取文件。文件读取结束的标志是返回的 n 等于 0,因此,如果需要读取整个文件内容,那么我们需要使用 for 循环 不停的读取文件,直到 n 等于 0。

  • file:要读取的文件句柄;
  • buf:读取的数据存放的缓冲区。
  • n:读取到的长度
  • err:读取失败,则返回错误信息。

示例:

package main
import (
	"bufio"
	"fmt"
	"io"
	"os"
)
//bufio读取文件
func main() {

	//只读方式打开当前目录下的test.txt
	file, err := os.Open("test.txt")
	if err != nil {
		fmt.Println("open file failed!,err:",err)
		return
	}
	//关闭文件,避免内存泄露
	defer file.Close()
	//通过bufio缓冲区读取文件
	reader := bufio.NewReader(file)	//建立缓冲区,将文件内容放入到缓冲区
	//循环读取文件信息
	for {
		line, err := reader.ReadString('\n')	//读到一个换行就结束

		if err == io.EOF {	 //io.EOF 表示文件的末尾
			//输出最后的内容
			if len(line) != 0 {
				fmt.Println(line)
			}
			fmt.Println("文件读取完毕")
			break
		}
		if err != nil {
			fmt.Println("read file failed,err:",err)
			return
		}
		fmt.Println(line)
	}
}

运行结果:

水陆草木之花,可爱者甚蕃。晋陶渊明独爱菊。自李唐来,世人甚爱牡丹。
予独爱莲之出淤泥而不染,濯清涟而不妖,中通外直,不蔓不枝,香远益清,亭亭净植,可远观而不可亵玩焉。
予谓菊,花之隐逸者也;牡丹,花之富贵者也;莲,花之君子者也。
噫!菊之爱,陶后鲜有闻。莲之爱,同予者何人?牡丹之爱,宜乎众矣!
文件读取完毕

2.4 ioutil 读取文件

语法:

func ReadFile(name string) ([]byte, error)
  • name:文件路径地址

使用 io/ioutil.ReadFile 方法一次性将文件读取到内存中,只需要将文件名作为参数传入。

示例:

package main
import (
	"fmt"
	"io/ioutil"
)
//ioutil 读取整个文件
func main() {
	content, err := ioutil.ReadFile("test.txt")
	if err != nil {
		fmt.Println("read failed,err:",err)
		return
	}
	fmt.Println(string(content))
}

运行结果:

水陆草木之花,可爱者甚蕃。晋陶渊明独爱菊。自李唐来,世人甚爱牡丹。
予独爱莲之出淤泥而不染,濯清涟而不妖,中通外直,不蔓不枝,香远益清,亭亭净植,可远观而不可亵玩焉。
予谓菊,花之隐逸者也;牡丹,花之富贵者也;莲,花之君子者也。
噫!菊之爱,陶后鲜有闻。莲之爱,同予者何人?牡丹之爱,宜乎众矣!

注意:如果文件比较大,一次性读取整个文件会占用很大的内存,影响执行效率。

建议读取小文件时使用,不太适用于大文件的读取。

效率比较

  • 当文件较小(KB 级别)时,ioutil > bufio > file.Read()。
  • 当文件大小比较常规(MB 级别)时,三者差别不大,但 bufio 优势已经显现出来。
  • 当文件较大(GB 级别)时,bufio > file.Read()> ioutil。

当读取小文件时,使用ioutil效率明显优于file.Read()bufio,但如果是大文件,bufio读取会更快,效率更高。

三、写入文件操作

3.1 os.OpenFile()函数

语法:

func OpenFile(name string, flag int, perm uint32) (file *File, err Error)

参数

os.OpenFile()函数能够以指定模式打开文件,从而实现文件写入相关功能。

  • name:要文件路径+文件名;
  • flag:打开文件的模式,只读、读写等;
  • perm:文件权限,一个八进制数。r(读)04,W(写)02,x(执行)01。

模式flag种类:

模式 含义
os.O_WRONLY 只写
os.O_CREATE 如果不存在文件,创建文件
os.O_RDONLY 只读
os.O_RDWR 可读可写
os.O_TRUNC 打开时清空文件原先内容
os.O_APPEND 追加

若同时想用多种可用|拼接不同模式。

文件权限perm:

使用4位8进制数来表示三种类型用户的权限,首位取0,形式即0XXX

  • 第一个X表示的是文件所有者的权限;
  • 第二个X表示的是组用户的权限;
  • 第三个X表示的是其他用户的权限。

每位数字所代表的权限:读r=4,写w=2,可执行x=1

数字 r w x 权限
0 - - - 所有权限均无
1 - - x 可执行
2 - w - 可写
3 - w x 可写,可执行
4 r - - 可读
5 r - x 可读,可执行
6 r w - 可读,可写
7 r w x 可读,可写,可执行

常使用的0644-rw-r--r--),表示文件所有者可读写,同组用户及其他用户只可读。

3.2 Write和WriteString 方式写入

Write语法:

func (file *File) Write(b []byte) (n int, err Error)

参数

返回值:

使用 Write 方法写文件,接受的 参数 是一个要写入的文件内容的 字节 数组。如果写入成功,返回成功写入的字节数,如果写入失败,返回 error 信息。

WriteString语法:

func (f *File) WriteString(s string) (n int, err error)

参数

返回值:

使用 WriteString 方法写文件,接受的参数是一个要写入的文件内容的 字符串。如果写入成功,返回成功写入的字节数,如果写入失败,返回 error 信息。

  • file:文件对象
  • b:要写入的文件内容
  • n: 成功写入的字节数
  • err:写入失败,则返回错误信息
  • f:文件对象
  • s:要写入的文件内容
  • n:成功写入的字节数
  • err:写入失败,则返回错误信息

示例:

package main
import (
	"fmt"
	"os"
)
//创建并写入数据
//Write 和 WriteString
func main() {
	//os.O_CREATE|os.O_RDWR:如果不存在文件,创建文件,可读可写
	//0666对应:-rw-rw-rw-
	file, err := os.OpenFile("D:/bb.txt", os.O_CREATE|os.O_RDWR, 0666)
	if err != nil {
		fmt.Println("open file failed,err:",err)
		return
	}
	defer file.Close()
	str := "Hello Golang\r\n"
	file.Write([]byte(str))	//写入字节切片数据
	file.WriteString("直接写入的字符串数据") //直接写入字符串数据
}

3.3 bufio.NewWriter

语法:

func NewWriter(w io.Writer) *Writer
func (b *Writer) WriteString(s string) (int, error)
func (b *Writer) Flush() error

将要写入的内容写入缓存中,在执行flush的时候才会被写到磁盘。

  • 创建writer实例
  • 将信息写入缓存
  • 将缓冲写入文件

示例:

package main
import (
	"bufio"
	"fmt"
	"os"
)
//bufio.NewWriter
func main() {
	//1、打开文件
	file,err := os.OpenFile("D:/cc.txt",os.O_CREATE|os.O_TRUNC|os.O_WRONLY,0666)
	if err != nil {
		fmt.Println("open file failed,err:",err)
		return
	}
	//5、关闭文件流
	defer file.Close()

	//2、创建writer对象
	writer := bufio.NewWriter(file)

	for i := 0; i < 10; i++ {
		writer.WriteString("Hello Golang\r\n")	//3、将数据先写入缓存
	}
	writer.Flush()	//4、将缓存中的内容写入文件
}

3.4 ioutil.WriteFile

语法:

func WriteFile(filename string, data []byte, perm os.FileMode) error

参数

返回值

使用 WriteFile 方法写文件,接受的第一个 参数 是一个 string 类型 的文件名,第二个参数是一个要写入的文件内容的 byte 数组,最后一个参数是文件的权限。如果写入成功,返回空的 error 信息,如果写入失败,返回 error 信息。

  • filename:文件路径+文件名称
  • data:要写入的文件内容
  • perm:文件权限
  • err:写入失败,则返回错误信息

示例:

package main
import (
	"fmt"
	"io/ioutil"
)
//ioutil.WriteFile
func main() {
	str := "Hello Golang"
	err := ioutil.WriteFile("D:/dd.txt", []byte(str), 0666)
	if err != nil {
		fmt.Println("write file failed,err:",err)
		return
	}
}

四、复制文件

4.1 通过ioutil进行复制

package main

import (
	"fmt"
	"io/ioutil"
)
//复制文件
//ioutil 进行复制
//编写一个函数,接收两个文件路径 srcFileName dstFileName
func CopyFile(srcFileName string,dstFileName string)(err error){
	input, err := ioutil.ReadFile(srcFileName)
	if err != nil {
		fmt.Println(err)
		return err
	}
	err = ioutil.WriteFile(dstFileName, input, 0644)
	if err != nil {
		fmt.Println("Error creating",dstFileName)
		fmt.Println(err)
		return err
	}
	return nil
}
func main() {
	srcFile := "D:/aa.zip"
	dstFile := "D:/bb.zip"
	err := CopyFile(srcFile, dstFile)
	if err == nil {
		fmt.Printf("拷贝完成\n")
	}else {
		fmt.Printf("拷贝错误 err=%v\n",err)
	}
}

4.2 以文件流的方式复制文件

package main
import (
	"fmt"
	"io"
	"os"
)
//复制数据
func CopyFile(srcFileName string,dstFileName string)(err error){
	source, _ := os.Open(srcFileName)
	destination, _ := os.OpenFile(dstFileName, os.O_CREATE|os.O_WRONLY, 0666)
	buf := make([]byte, 128)
	for {
		n, err := source.Read(buf)
		if err != nil && err != io.EOF {
			return err
		}
		if n == 0 {
			break
		}
		if _,err := destination.Write(buf[:n]); err != nil {
			return err
		}
	}
	return nil
}
func main() {
	srcFile := "D:/aa.zip"
	dstFile := "D:/bb.zip"
	err := CopyFile(srcFile, dstFile)
	if err == nil {
		fmt.Printf("拷贝完成\n")
	}else {
		fmt.Printf("拷贝错误 err=%v\n",err)
	}
}

五、其他操作

package main
import (
	"fmt"
	"os"
)
func main() {
	//文件重命名
	err01 := os.Rename("D:/aa.txt","D:/ee.txt")	//只能同盘操作
	if err01 != nil {
		fmt.Println(err01)
	}
	//创建目录
	err02 := os.Mkdir("D:/aa", 0666)
	if err02 != nil {
		fmt.Println(err02)
	}
	//一次创建多个目录
	err03 := os.MkdirAll("D:/aa/bb/cc",0666)	//创建多级目录
	if err03 != nil {
		fmt.Println(err03)
	}
	//删除目录和文件
	err04 := os.Remove("D:/ee.txt")
	if err04 != nil {
		fmt.Println(err04)
	}
	//一次删除多个目录或者文件
	err05 := os.RemoveAll("D:/aa")
	if err05 != nil {
		fmt.Println(err05)
	}
}

到此这篇关于Golang文件读写操作详情的文章就介绍到这了,更多相关Go文件操作内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • golang解析yaml文件操作

    首先安装解析的第三方包: go get gopkg.in/yaml.v2 示例: package main import ( "os" "log" "fmt" "encoding/json" "gopkg.in/yaml.v2" ) type Config struct { Test Test `yaml:"test"` } type Test struct { User []strin

  • Golang 文件操作:删除指定的文件方式

    我就废话不多说了,大家还是直接看代码吧~ package main import "os" func main () { err := os.Remove(logFile) if err != nil { // 删除失败 } else { // 删除成功 } } 补充:[Golang]文件/文件夹一般操作:判断.复制.删除.遍历 1. 检查指定路径是否为文件夹 func IsDir(name string) bool { if info, err := os.Stat(name); e

  • Golang获取目录下的文件及目录信息操作

    一.获取当前目录下的文件或目录信息(不包含多级子目录) func main() { pwd,_ := os.Getwd() //获取文件或目录相关信息 fileInfoList,err := ioutil.ReadDir(pwd) if err != nil { log.Fatal(err) } fmt.Println(len(fileInfoList)) for i := range fileInfoList { fmt.Println(fileInfoList[i].Name()) //打印

  • Golang 编译成DLL文件的操作

    首先撰写golang程序exportgo.go: package main import "C" import "fmt" //export PrintBye func PrintBye() { fmt.Println("From DLL: Bye!") } //export Sum func Sum(a int, b int) int { return a + b; } func main() { // Need a main function

  • golang逐行读取文件的操作

    我就废话不多说了,大家还是直接看代码吧~ func ReadLine(fileName string) ([]string,error){ f, err := os.Open(fileName) if err != nil { return nil,err } buf := bufio.NewReader(f) var result []string for { line, err := buf.ReadString('\n') line = strings.TrimSpace(line) if

  • golang如何操作csv文件详解

    目录 练习要求: 考察点: 编码: README.md 附:使用Golang导出CSV数据并解决数据乱码问题 CSV 格式 实现方式 golang实现csv数据写文件 golang实现web导出csv数据 总结 练习要求: 写一个小程序解析data.csv,要求实现如下功能: 接收姓名作为参数. 根据姓名查找出对应员工的工时信息,并将 日期.上班.下班.工时 打印到标准输出. 将上一条输出的内容保存到json文件,使用姓名.json作为文件名 根据上条中生成的json文件,计算出该员工的月总工时

  • Golang文件读写操作详情

    目录 一.概念 二.读取文件操作 2.1 打开和关闭文件 defer 语句 2.2 file.Read() 读取文件 Read 方法定义 ReadAt方法定义 一次性读取 循环读取 2.3 bufio 读取文件 2.4 ioutil 读取文件 效率比较 三.写入文件操作 3.1 os.OpenFile()函数 3.2 Write和WriteString 方式写入 3.3 bufio.NewWriter 3.4 ioutil.WriteFile 四.复制文件 4.1 通过ioutil进行复制 4.

  • Go语言文件读写操作案例详解

    目录 基本介绍 文件基本操作 读操作 写操作 写操作案例 查看文件或目录是否存在 拷贝文件 基本介绍 文件,对我们并不陌生,文件是数据源(保存数据的地方)的 一种 输入流和输出流 文件在程序中是以流的形式来操作的 流:数据在数据源(文件)和程序(内存)之间经历的路径 输入流:数据从文件到内存的路径 输出流:数据从内存到文件的路径 os.File封装所有文件相关操作,File是一个结构体 文件基本操作 读操作 package main import ( "bufio" "fmt

  • python文件读写操作与linux shell变量命令交互执行的方法

    本文实例讲述了python文件读写操作与linux shell变量命令交互执行的方法.分享给大家供大家参考.具体如下: python对文件的读写还是挺方便的,与linux shell的交互变量需要转换一下才能用,这比较头疼. 代码如下: 复制代码 代码如下: #coding=utf-8 #!/usr/bin/python import os import time #python执行linux命令 os.system(':>./aa.py') #人机交互输入 S = raw_input("

  • IOS 文件读写操作详解及简单实例

    iPhone 文件读写操作 1,写文件操作 - (IBAction)btnWrite:(id)sender { //创建文件管理器 NSFileManager *fileManager = [NSFileManager defaultManager]; //获取路径 //参数 要获取的哪种路径 NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES); NSSt

  • Android编程之文件读写操作与技巧总结【经典收藏】

    本文实例总结了Android文件读写操作.分享给大家供大家参考,具体如下: 在Android中的文件放在不同位置,它们的读取方式也有一些不同. 本文对android中对资源文件的读取.数据区文件的读取.SD卡文件的读取及RandomAccessFile的方式和方法进行了整理.供参考. 一.资源文件的读取: 1) 从resource的raw中读取文件数据: String res = ""; try{ //得到资源中的Raw数据流 InputStream in = getResources

  • PHP文件读写操作之文件写入代码

    在PHP网站开发中,存储数据通常有两种方式,一种以文本文件方式存储,比如txt文件,一种是以数据库方式存储,比如Mysql,相对于数据库存储,文件存储并没有什么优势,但是文件读写操作在基本的PHP开发中还是时有使用,今天和大家分享如何利用PHP技术实现文件读写之文件写入操作教程,也算是对PHP文件读写操作的入门学习. 将数据写入文件的操作主要涉及三个步骤及部分文件操作函数如下: 1.打开文件(文件操作函数:fopen) 2.写入文件(文件操作函数:fwrite等) 3.关闭文件(文件操作函数:f

  • PHP文件读写操作之文件读取方法详解

    PHP文件读取操作相对于文件写入操作涉及更多的PHP文件操作函数,在代码实例中会详细介绍这些函数. 读取文本文件中存储数据的方式主要涉及的三个步骤及部分文件操作函数如下: 1.打开文件(文件操作函数:fopen) 2.文件数据读取(文件操作函数:fgets.file.readfile.feof等) 3.关闭文件(文件操作函数:fclose) 下面仍然以PHP文件读写操作代码实例讲解文件读取方法的具体应用,在实例中,通过调用不同的PHP文件读取操作函数读取文本文件中的数据,你可以加深PHP文件读取

  • Android编程之在SD卡上进行文件读写操作实例详解

    本文实例讲述了Android编程之在SD卡上进行文件读写操作的方法.分享给大家供大家参考,具体如下: 很多知识只有真正理解掌握之后才能运用自如,举一反三.对Java中的文件操作和android系统SD卡里面的文件操作,你觉得有区别吗,显然没有本质区别,如果勉强说有,那也是不足为道滴,但我们在实际运用中却要注意如下几点,不然问题会缠上你. 1.首先想要对android系统SD卡里文件操作需要添加使用权限: android系统是不会让外来程序随意动自己内存的,如果没有许可证,不好意思,不准你动我地盘

  • 详解C++文件读写操作

    在看C++编程思想中,每个练习基本都是使用ofstream,ifstream,fstream,以前粗略知道其用法和含义,在看了几位大牛的博文后,进行整理和总结: 这里主要是讨论fstream的内容: #include <fstream> ofstream //文件写操作 内存写入存储设备 ifstream //文件读操作,存储设备读区到内存中 fstream //读写操作,对打开的文件可进行读写操作 1.打开文件 在fstream类中,成员函数open()实现打开文件的操作,从而将数据流和文件

  • Python3之文件读写操作的实例讲解

    文件操作的步骤: 打开文件 -> 操作文件 -> 关闭文件 切记:最后要关闭文件(否则可能会有意想不到的结果) 打开文件 文件句柄 = open('文件路径', '模式') 指定文件编码 文件句柄= open('文件路径','模式',encoding='utf-8') 为了防止忘记关闭文件,可以使用上下文管理器来打开文件 with open('文件路径','模式') as 文件句柄: 打开文件的模式有: r,只读模式(默认). w,只写模式.[不可读:不存在则创建:存在则删除内容:] a,追加

随机推荐