精华内容
下载资源
问答
  • C语言文件读写操作(详解)
    万次阅读 多人点赞
    2020-07-21 23:02:51

    数据流和缓冲区是什么?文件类型和文件存取方式都有啥?

    • 数据流
      就C程序而言,从程序移进,移出字节,这种字节流就叫做流。程序与数据的交互是以流的形式进行的。进行C语言文件的读写时,都会先进行“打开文件”操作,这个操作就是在打开数据流,而“关闭文件”操作就是关闭数据流。
    • 缓冲区
      在程序执行时,所提供的额外内存,可用来暂时存放准备执行的数据。它的设置是为了提高存取效率,因为内存的存取速度比磁盘驱动器快得多。
      当使用标准I/O函数(包含在头文件stdio.h中)时,系统会自动设置缓冲区,并通过数据流来读写文件。当进行文件读取时,是先打开数据流,将磁盘上的文件信息拷贝到缓冲区内,然后程序再从缓冲区中读取所需数据。事实上,当写入文件时,并不会马上写入磁盘中,而是先写入缓冲区,只有在缓冲区已满或“关闭文件”时,才会将数据写入磁盘。
    • 文件类型
      文本文件和二进制文件:
      文本文件是以字符编码的方式进行保存的。
      二进制文件将内存中的数据原封不动的进行保存,适用于非字符为主的数据。其实,所有的数据都可以算是二进制文件。二进制文件的优点在于存取速度快,占用空间小。
    • 文件存取方式
      顺序存取方式和随机存取方式:
      顺序存取就是从上往下,一笔一笔读取文件的内容。写入数据时,将数据附加在文件的末尾。这种存取方式常用于文本文件。
      随机存取方式多半以二进制文件为主。它会以一个完整的单位来进行数据的读取和写入,通常以结构为单位。

    什么是文件呢?

    文件是一段数据的集合,这些数据可以是有规则的,也可以是无序的集合。在stdio.h有一个非常重要的东西,文件指针,每个文件都会在内存中开辟一块空间,用于存放文件的相关信息,这些信息保存在一个结构体中:
    struct _iobuf {
    char *_ptr; //指向buffer中第一个未读的字节
    int _cnt; //记录剩余的未读字节的个数
    char *_base;//文件的缓冲
    int _flag;//打开文件的属性
    int _file;//获取文件描述
    int _charbuf;//单字节的缓冲,即缓冲大小仅为1个字节
    int _bufsiz;//记录这个缓冲大小
    char *_tmpfname;//临时文件名
    };
    typedef struct _iobuf FILE;
    FILE是一个数据结构,用于访问一个流。每个流都会对应一个FILE结构体。

    C语言文件操作函数详解

    C语言中没有输入输出语句,所有的输入输出功能都用 ANSI C提供的一组标准库函数来实现。文件操作标准库函数有:

    • 文件的打开
      fopen():打开文件
    • 文件的关闭
      fclose():关闭文件
    • 文件的读写
      fgetc():读取一个字符
      fputc():写入一个字符
      fgets():读取一个字符串
      fputs():写入一个字符串
      fprintf():写入格式化数据
      fscanf():格式化读取数据
      fread():读取数据
      fwrite():写入数据
    • 文件状态检查
      feof():文件是否结束
      ferror():文件读/写是否出错
      clearerr():清除文件错误标志
      ftell():文件指针的当前位置
    • 文件指针定位
      rewind():把文件指针移到开始处
      fseek():重定位文件指针

    参数解释:
    “r”:以只读的形式打开文本文件(不存在则出错)
    “w”:以只写的形式打开文本文件(若不存在则新建,反之,则从文件起始位置写,覆盖原内容)
    “a”:以追加的形式打开文本文件(若不存在,则新建;反之,在原文件后追加)
    “r+”:以读写的形式打开文本文件(读时,从头开始;写时,新数据只覆盖所占的空间)
    “wb”:以只写的形式打开二进制文件
    “rb”:以只读的形式打开二进制文件
    “ab”:以追加的形式打开一个二进制文件
    “rb+”:以读写的形式打开二进制文件。
    “w+”:首先建立一个新文件,进行写操作,然后从头开始读(若文件存在,原内容将全部消失)
    “a+”:功能与”a”相同。只是在文件尾部追加数据后,可以从头开始读
    “wb+”:功能与”w+”相同。只是在读写时,可以由位置函数设置读和写的起始位置
    “ab+”:功能与”a+”相同。只是在文件尾部追加数据之后,可以由位置函数设置开始读的起始位置

    打开文件
    FILE *fopen( const char *filename, const char *mode );

    • filename:文件的路径
    • mode:打开模式

    例:

    int main()
    {
        FILE* f;
        f = fopen("file.txt", "w");
        if (f != NULL)
        {
            fputs("fopen example", f);
            fclose(f);
            f=NULL;
        }
        return 0;
    }
    

    注意:

    • 文件是否打开成功
    • 关闭文件
    • 文件指针置空

    关闭文件
    函数原型:int fclose( FILE *stream );

    • stream:流

    例:

    if(fclose(f)!=0) 
    {
    	printf("File cannot be closed/n"); 
    	exit(1); 
    } 
    else
    {
        printf("File is now closed/n"); 
    }
    

    读取字符
    int fgetc ( FILE * stream );

    • stream:流

    例:

    #include <stdio.h>
    int main ()
    {
      FILE * pFile;
      int c;
      int n = 0;
      pFile = fopen ("D:\\myfile.txt", "r");
      if (pFile == NULL) perror ("Error opening file"); // 打开失败
      else
      {
        while (c != EOF)
        {
          c = fgetc (pFile); // 获取一个字符
          if (c == '$') n++; // 统计美元符号 '$' 在文件中出现的次数
        }
        fclose (pFile); // 一定记得要关闭文件
        printf ("The file contains %d dollar sign characters ($).\n",n);
      }
      return 0;
    }
    

    写入字符
    int fputc( int c, FILE *stream );

    • c:要写入的字符
    • stream:流

    例:

        char ch;
        FILE* pf = fopen("file.txt", "w");
        if (pf == NULL)
        {
            perror("error opening file");
            exit(0);
        }
        ch = getchar();
        while (ch != '$')
        {
            fputc(ch, pf);
            ch = getchar();
        }
        fclose(pf);
    

    读取字符串
    char * fgets ( char * str, int num, FILE * stream );

    • str:将读取到的内容复制到的目标字符串
    • num:一次读取的大小
    • stream:流

    例:

        char buf[10] = { 0 };
        FILE *pf = fopen("file.txt", "r");
        if (pf == NULL)
        {
            perror("open file for reading");
            exit(0);
        }
        fgets(buf, 9, stdin);
        printf("%s", buf);
        fclose(pf);
    

    写入字符串
    int fputs( const char *string, FILE *stream );

    • string:要写入的字符串
    • stream:一次读取的大小

    例:

        char buf[10] = { 0 };
        FILE *pf = fopen("file.txt", "r");
        if (pf == NULL)
        {
            perror("open file for reading");
            exit(0);
        }
        fgets(buf, 9, stdin);
        fputs(buf, stdout);
        fclose(pf);
    

    读取数据块
    size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );

    • ptr:目标内存块
    • size:一次读取的字节大小
    • count:一次读取多少个 size
    • stream:流

    例:

    #include <stdio.h>
    #include <string.h>
     
    int main()
    {
        FILE *pFile = fopen("file.txt", "rb");
        if (pFile == NULL) 
        {
            perror ("Error opening file");
            return 0;
        }
        char buf[100] = { 0 };
        while (!feof(pFile)) //没有到文件末尾
        {
            memset(buf, 0, sizeof(buf));
            size_t len = fread(buf, sizeof(char), sizeof(buf), pFile);
            printf("buf: %s, len: %d\n", buf, len);
        }
        fclose(pFile);
    }
    

    写入数据块
    size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
    同理,简单好理解,就不详细阐述了。

    文件指针重定位
    int fseek ( FILE * stream, long int offset, int origin );

    • stream:流
    • offset:相对应 origin 位置处的偏移量,单位为字节
    • origin:指针的位置
      #define SEEK_CUR 1 // 当前位置
      #define SEEK_END 2 // 末尾
      #define SEEK_SET 0 // 开头

    获取指针位置
    long int ftell ( FILE * stream );

    • stream:流

    获取文件大小
    例:

    long n;
    fseek(pf,0,SEEK_END);
    n=ftell(pf);
    

    文件指针移到开始处
    void rewind( FILE *stream );

    • stream:流

    清除文件错误标志
    void clearerr( FILE *stream );

    • stream:流

    文件流是否读到了文件尾
    int feof( FILE *stream );

    • stream:流

    重命名文件
    int rename ( const char * oldname, const char * newname );

    • oldname:原名
    • newname:新名

    删除文件
    int remove ( const char * filename );

    • filename:文件的路径
    更多相关内容
  • DWG文件读写开发库

    2018-12-22 14:04:08
    DWG文件读写开发库,支持c++,C#开发读写DWG文件的相关功能。
  • 基于QT实现XML文件读写,解析操作
  • android文件读写权限

    2013-11-04 14:57:09
    在android开发中,我们经常用到文件读写权限
  • C++文件读写操作C++文件读写操作 C++文件读写操作C++文件读写操作
  • 200行代码实现PCM格式的WAV文件读写,使用标准C++库实现,不依赖于其他库。 // Write WAv文件 Wave_header header(1, 48000, 16); uint32_t length = header.fmt_data->sample_per_sec * 10 * header.fmt_data...
  • linux C文件读写

    热门讨论 2012-12-27 10:41:40
    linux C文件读写 初学练手代码 内容很简单,就实现简单的文件读写功能
  • C语言文件读写操作

    千次阅读 多人点赞 2020-10-25 15:58:33
    c语言文件读写操作 介绍了文件指针FILE的使用,文件读写操作的一般函数

    c语言文件读写操作

    一、文件指针File

    1.定义

    1. FILE类型是系统预先设定的一种结构体指针
    2. FILE* 指针作为文件句柄,是文件访问的唯一标识,它由fopen函数创建,fopen打开文件成功,则返回一个有效的FILE*指针,否则返回空指针NULL
    3. 定义方式
      FILE *fp=fopen(char *filename,char *mode);

      FILE *fp;
      fp=fopen(char *filename,char *mode);

      FILE * fopen(char* filename,char* mode)
      filename:文件名,如“students.txt”。 相对路径
      mode:打开方式(读写方式,文件类型)

    2.文件类型分类

    1. 文本文件:这类文件以文本的ASCII、UNICODE(万国码)等编码形式存储在计算机中。它是以"行"为基本结构的一种信息组织和存储方式。
    2. 二进制文件:这类文件以文本的二进制形式存储在计算机中,用户一般不能直接读懂它们,只有通过相应的软件才能将其显示出来。二进制文件一般是可执行程序、图形、图像、声音等等。

    3.文件打开方式

    1. "r"正文文件只读方式打开。文件不存在,则打开失败
    2. "w"正文文件只写方式打开。若文件不存在,则建立文件;若文件存在,则删除文件内容,重建空文件
    3. "a"正文文件添加方式。文件不存在,则建立文件
    4. "r+ ":正文文件读写打开,文件不存在,则打开失败
    5. "w+ " :正文文件读写方式打开,文件不存在,则建立文件

    4.文件打开

    #include <stdio.h>
    int main()
    {
        FILE *fp; /*文件指针*/
        fp=fopen("member.txt","rb");
        if(fp==NULL)
            printf("提示:文件未能成功打开");
        else
            printf("提示:文件已经打开");
        return 0;
    } 
    

    Warning!
    使用fopen时,但凡含r字母的打开方式,一定要加判断,文件是否打开成功,否则程序不会报告错误,会运行下去。如:

    FILE *fr; 
    fr=fopen("abc.txt","r"); 
    if(fr==NULL){
    printf("File not open!/n"); 
    

    5.文件关闭

    fclose(FILE *fp)
    一般地,fclose(fp)应与fopen配对使用,特别是含有写方式的文件,若不关闭,可能会造成文件数据丢失。

    二、一般读写函数

    字符的读写函数:fgetc()函数和fputc()函数
    字符串的读写函数:fgets()函数和fputs()函数
    数据块的读写函数,主要针对二进制文件:fread()函数和fwrite()函数
    格式化的读写函数,主要针对文本文件:fscanf()函数和fprintf()函数

    字符串读写

    1、fputs()函数

    格式:fputs(s,fp);
    功能:用来将一个字符串写入指定的文本文件。
    其中,fp为文件指针,s可以是字符数组名,字符型指针变量或字符串常量。该函数的功能是将字符串s写入由fp指向的文件中,字符串末尾的‘\0’字符不允写入。
    返回值:执行成功,返回所写的最后一个字符;否则,返回EOF。

    //fputs
    
    #include <stdio.h>
    #include <stdlib.h>
    void main(){
        FILE *fp;
        char s[][15]={"BeiJing","ShangHai","GuangZhou","NanJing","HangZhou"};
        if((fp=fopen("c:\\1\\wenjiu3.txt","w"))==NULL)
        /*只能相应文件,创建不了文件夹,fopen()函数会寻找相应位置文件夹然后在其中创建所需文件。
        当没有所需文件夹的时候,系统会自动跳转到NULL!*/
        {
            printf("Cannot open the file,strike any key to exit!\n");
            getchar();
            exit(0);
        }
        for(int i=0;i<6;i++){
            fputs(s[i],fp);
            fputs("\n",fp);
        }
        fclose(fp);
    }//输出在文件中的第六行,会出现“'jb”这个字符串
    

    2、fgets()函数

    格式:fgets(s,n,fp);

    功能:用于从指定的文件中读一个字符串到字符数组中。

    其中,s可以是字符型数组名或字符串指针,n是指定读入的字符个数;fp为文件指针。n是一个正整数,表示从文件中最多读取n-1个字符,并将字符串指针s定位在读入的字符串首地址。fgets()函数从文件中读取字符直到遇到回车符或EOF为止,函数会在最后一个字符后加上字符串结束标志’\0’;若有EOF,则不予保留。

    返回值:该函数如果执行成功,返回读取字符串;如果失败,则返回空指针NULL,这时,s中的内容不确定。

    //fgets()函数
    
    #include <stdio.h>
    #include <stdlib.h>
    void main(){
        FILE *fp;
        char s[6][15];
        if((fp=fopen("c:\\1\\wenjiu3.txt","r"))==NULL){
            printf("Cannot open the file,strike any key to exit!\n");
            getchar();
            exit(0);
        }
        for(int i=0;i<6;i++){
            fgets(s[i],15,fp);
            if(i%2==0)
                printf("%s",s[i]);
        }
        fclose(fp);
    }
    

    格式化读写

    1.fprintf()函数

    格式:fprintf(fp, format, arg1, arg2,….,argn);

    功能:fprintf()用来将输出项按指定的格式写入指定的文本文件中,其中格式化规定与printf()函数功能相似,所不同的只是fprintf()函数是将输出的内容写入文件中,而printf()函数则是在屏幕输出。

    其中,fp为文件指针,format为指定的格式控制字符串;arg1~argn为输出项,可以是字符、 字符串或各种类型的数值。该函数的功能是按格式控制字符串format给定的格式,将输出项arg1,arg2,……,argn的值写入fp所指向的文件中。

    返回值:如果函数执行成功,返回实际写入文件的字符个数;若出现错误,返回负数。

    fprintf()中格式控制的使用与printf()相同。
    例如:fprintf(fp,”r=%f,area=%f\n”,r,area);

    //fprintf()函数
    
    #include <stdio.h>
    #include <stdlib.h>
    void main(){
        FILE *fp;
        int data[1000];
        for(int i=0;i<1000;i++)
            data[i]=(rand()%1000);//产生0~999的随机整数
        if((fp=fopen("c:\\1\\wenjiu5.txt","w"))==NULL){
            printf("Cannot open the file,strike any key to exit!\n");
            getchar();
            exit(0);
        }
        for(i=0;i<1000;i++){
            if(i%20==0)
                fprintf(fp,"\n%5d",data[i]);
            else
                fprintf(fp,",%5d",data[i]);
            if((i+1)%20==0)
                fprintf(fp,"\n");
        }
        fclose(fp);
    
    }
    

    2、fscanf()函数

    格式:fscanf(fp,format,arg1,arg2,……,argn);

    功能:fscanf()用来按规定的格式从指定的文本文件中读取数据。它与scanf()函数的功能相似,都是按规定的格式读数据的函数,只是fscanf()函数读的对象不是键盘区,而是文件。

    其中,fp为文件指针,format为指定的格式控制字符串;arg1~argn为输入项的地址。该函数的功能是从文件指针fp所指的文本文件中读取数据,按格式控制字符串format给定的格式赋予输入项arg1,arg2,……,argn中。

    返回值:如果该函数执行成功,返回读取项目个数;如果遇到文件末尾,返回EOF;如果赋值失败,返回0.

    fscanf()中格式控制的使用与scanf()相同。
    例如:fprintf(fp,”%d,%d\n”,&a,&b);

    //fscanf()函数
    
    #include <stdio.h>
    #include <stdlib.h>
    void main(){
        FILE *fp;
        int data[1000];
        if((fp=fopen("c:\\1\\wenjiu5.txt","r+"))==NULL){
            printf("Cannot open the file,strike any key to exit!\n");
            getchar();
            exit(0);
        }
        for(int i=0;i<1000;i++){
            if(i%20==0)
                fscanf(fp,"\n%5d",&data[i]);
            else
                fscanf(fp,",%5d",&data[i]);
        }
        fseek(fp,0,SEEK_END);
        fprintf(fp,"\n\n");
        int j=0;
        for(i=0;i<1000;i++){
            {
                if(data[i]%7==0)
                {
                    if(j%20==0)
                        fprintf(fp,"%5d",data[i]);
                    if((j+1)%20==0) fprintf(fp,"\n");
                    j++;
                }
            }
            fclose(fp);
        }
    }
    

    结语

    第一次发表博客,还有点小激动,虽然不是原创,从网上几篇文章整理的,就是复习了一下c语言文字文件读写操作,也供自己以后回顾。

    展开全文
  • 多线程对文件读写操作(java),提高对文件读写效率。
  • nc文件读写 java版本

    热门讨论 2013-12-16 16:27:23
    netcdf即nc文件读写实例,java版本的,不懂的地方可以问我,lishirongtech@126.com
  • 文件读写监控工具文件读写监控工具文件读写监控工具文件读写监控工具文件读写监控工具文件读写监控工具文件读写监控工具
  • 最好懂的python文件读写(详解)

    万次阅读 多人点赞 2020-02-23 17:13:12
      1、文件读写的流程   2、文件读写的几种常见模式   3、read、readline、readlines的区别   4、对于一个10G的大文件,怎么高效的查看文件中的内容呢? 1、文件读写的流程 1)类比windows中手动操作txt文档...

    目录

      1、文件读写的流程
      2、文件读写的几种常见模式(你不清楚的知识点)
      3、read、readline、readlines的区别
      4、对于一个10G的大文件,怎么高效的查看文件中的内容呢?

    1、文件读写的流程

    1)类比windows中手动操作txt文档,说明python中如何操作txt文件?
    ① windows中手动操作txt文件的步骤
    • 找到word文档
    • 打开word文档
    • 查看(或操作)word文档中的内容
    • 关闭word文档
    ② python操作txt文件的步骤
    • 获取被打开的文件的内存对象,该内存对象又叫做“文件句柄”。
    • 通过这个内存对象(文件句柄),来对文件进行操作(读取,写入等操作)。
    • 关闭文件
    2)什么是文件的内存对象(文件句柄)?

      使用python读取一个txt文件的时候,相当于把这个文件从硬盘上,读取到了内存中。我们如果想要操作这个文件,是不是先要获取这个文件对象?只有获取这个文件对象后,才能够真正的去操作这个文件,不管是读取文件中的内容,还是向文件中写入内容。
      这个“文件句柄”包含了文件的文件名、文件的字符集、文件的大小、文件在硬盘上的起始位置。

    3)演示怎么读取文件
    ① 演示如下
    f = open(r"G:\6Tipdm\file_read_write\yesterday.txt","r",encoding="utf-8")
    data  = f.read()
    print(data[:245])
    f.close()
    

    结果如下:
    在这里插入图片描述

    ② 一个很奇怪的现象?
    f = open(r"G:\6Tipdm\file_read_write\yesterday.txt","r",encoding="utf-8")
    data  = f.read()
    data1 = f.read()
    print(data[:245])
    print("-------------------------------------")
    print(data1[:245])
    f.close()
    

    结果如下:
    在这里插入图片描述
    问题:我们读取了2遍内容,为什么只显示了一次读取的结果呢?对于上述问题,我们用一张图回答上述问题。
    在这里插入图片描述
      通过上图我们可以发现,当我们操作这个“文件句柄”的read()方法去读取文件的时候,这个句柄会从文件的开头位置1,移动到文件的结束位置2。如果不做任何操作,读取完毕之后,句柄就会停止在2这个位置。因此当我们再次读取文件的时候,该句柄是从2这个位置,往后面读取内容。由于后面没有任何内容,因此第二次读取为空。
      那么,如果我们想要第二次同样能够读取到文件中的内容,应该怎么办呢?那么接着往下看。

    4)演示怎么写文件
    f = open(r"G:\6Tipdm\file_read_write\yesterday2.txt","w",encoding="utf-8")
    f.write("我爱北京天安门")
    f.close()
    

    结果如下:
    在这里插入图片描述
    假如我们在写一句“天安门上太阳升”,会出现啥情况呢?

    f = open(r"G:\6Tipdm\file_read_write\yesterday2.txt","w",encoding="utf-8")
    f.write("天安门上太阳升")
    f.write("很好,很好")
    f.close()
    

    结果如下:
    在这里插入图片描述
      意外发生。当我们再次写入新的内容的时候,发现之前写的内容不见了,这是为啥呢?这就是我们下面要讲述的“文件读写的几种常见模式”。
      

    2、文件读写的几种常见模式(你不清楚的知识点)

    在这里插入图片描述

    1)关于r+、w+、a+使用说明(易错点)

      当我们读取某个文件,向文件中写入某些内容(覆盖写),向文件中追加写入某写内容时,最好的方式就是分别使用r、w、a这三种模式。对于这三种模式,要么读,要么写,读模式就不能写,写模式就不能读。
      对于r+、w+、a+这三种模式,如果你不是特别清楚python文件读写的原理,就不要轻易使用,因为会出现很多问题,下面我们仅演示r+、w+、a+这三种模式。

    2)r+模式:可读可写

      对于这种模式,不管是读取文件中的内容,还是朝文件中写入内容。前提条件:文件存在。

    # 只读取文件中的内容
    f = open(r"G:\6Tipdm\file_read_write\yesterday1.txt","r+",encoding="utf-8")
    data = f.read()
    print(data)
    f.close()
    
    # 朝文件中写入内容后,立即读取,会出现啥问题?
    f = open(r"G:\6Tipdm\file_read_write\yesterday1.txt","r+",encoding="utf-8")
    f.write("丽丽姑娘")
    
    data = f.read()
    print(data)
    f.close()
    
    # 朝文件中写入内容后,调整句柄位置后,再读取,会出现啥问题?
    f = open(r"G:\6Tipdm\file_read_write\yesterday1.txt","r+",encoding="utf-8")
    f.write("丽丽姑娘")
    f.seek(0)
    data = f.read()
    print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述
    结果分析:
      使用r+模式,当只读文件的时候,可以读取到其中的内容。
      当写入内容后,立即读取文件内容,发现什么也读取不到。这是由于当你写入内容后,文件句柄会放在写入内容的最后面,因此当你立即读取的时候,句柄会从上次内容最后的位置,朝后面读,因此读取为空。
      当朝文件中写入内容后,调整句柄位置后,再读取文件中的内容,发现就有了内容。这是由于我们使用了f.seek(0)方法,将句柄由内容末尾调整到了内容开头,因此就又有了内容。

    3)w+:可读可写
    # 直接往文件中写入内容
    f = open(r"G:\6Tipdm\file_read_write\yesterday3.txt","w+",encoding="utf-8")
    f.write("bbbbbb")
    f.close()
    
    # 直接读取上述文件,看看会发生啥问题?(特别注意这一步)
    f = open(r"G:\6Tipdm\file_read_write\yesterday3.txt","w+",encoding="utf-8")
    data = f.read()
    print(data)
    f.close()
    
    # 朝文件中写入内容后,立即读取,又会发生什么?
    f = open(r"G:\6Tipdm\file_read_write\yesterday3.txt","w+",encoding="utf-8")
    f.write("哈哈哈哈哈")
    data = f.read()
    print(data)
    f.close()
    
    # 朝文件中写入内容后,调整句柄位置后,再读取,会发生什么?
    f = open(r"G:\6Tipdm\file_read_write\yesterday3.txt","w+",encoding="utf-8")
    f.write("嘿嘿嘿嘿嘿")
    f.seek(0)
    data = f.read()
    print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述
    结果分析:
      使用w+模式,当我们直接朝文件中写入bbbbbb,毋庸置疑,肯定是可以的。
      接着,我们直接读取这个文件中的内容,奇怪的现象发生了,什么都读取不到。这是因为w+模式,在进行文件读取的时候,默认是先写再读。但是我们确实没有写入任何东西呀?这是由于系统默认帮我们写入了一个空值,因此把原有内容覆盖了。所以再当我们读取文件中的内容的时候,发现读取为空。
      再接着,我们朝文件中,写入内容后再立即读取,这下仍然读取不到任何内容,这又是为什么呢?这是由于我们第一次写入“哈哈哈哈哈哈”的时候,句柄移动到了内容最后。当我们立即读取的时候,句柄从内容最后的位置,继续朝后面读,因此啥也没有。
      最后,当朝文件中写入内容后,调整句柄位置后,再读取文件中的内容,发现就有了内容。这是由于我们使用了f.seek(0)方法,将句柄由内容末尾调整到了内容开头,因此就又有了内容。

    4)a+:可读可写
    # 直接朝文件中写入内容
    f = open(r"G:\6Tipdm\file_read_write\yesterday4.txt","a+",encoding="utf-8")
    f.write("哈哈")
    f.close()
    
    # 直接读取文件中的内容
    f = open(r"G:\6Tipdm\file_read_write\yesterday4.txt","a+",encoding="utf-8")
    data = f.read()
    print(data)
    f.close()
    
    # 调整句柄位置后,再读取文件中的内容
    f = open(r"G:\6Tipdm\file_read_write\yesterday4.txt","a+",encoding="utf-8")
    f.seek(0)
    data = f.read()
    print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述
    结果分析:
      使用a+模式,朝文件中写入内容,毋庸置疑,肯定是没问题的。
      接着,当我们读取上述文件中的内容,会发现什么也读取不到。这是由于,使用r+模式打开文件,文件句柄默认放在内容的最后面,因此你直接读取其中的内容,什么也没有。
      最后,在读取文件中内容之前,我们使用了f.seek(0)方法,将句柄由内容末尾调整到了内容开头,再次读取文件中的内容,发现就有了内容。

    3、read、readline、readlines的区别

    在这里插入图片描述

    1)read()方法的使用说明
    f = open(r"G:\6Tipdm\file_read_write\test.txt","r",encoding="utf-8")
    data = f.read()
    print(type(data))
    print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述

    2)readline()方法的使用说明
    f = open(r"G:\6Tipdm\file_read_write\test.txt","r",encoding="utf-8")
    data = f.readline()
    print(type(data))
    print(data)
    f.close()
    
    f = open(r"G:\6Tipdm\file_read_write\test.txt","r",encoding="utf-8")
    for i in range(3):
        data = f.readline()
        print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述
    去掉每一行末尾的换行符:

    f = open(r"G:\6Tipdm\file_read_write\test.txt","r",encoding="utf-8")
    for i in range(3):
        data = f.readline().strip()
        print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述

    3)readlines()方法的使用说明
    f = open(r"G:\6Tipdm\file_read_write\test.txt","r",encoding="utf-8")
    data = f.readlines()
    print(type(data))
    print(data)
    f.close()
    

    结果如下:
    在这里插入图片描述

    4、对于一个10G的大文件,怎么高效的查看文件中的内容呢?

    1)相关说明

      当我们读取文件中的内容,相当于是把写在硬盘上的东西,读取到内存中。不管你是使用read()或者readlines()一次性读取到到内存中,还是使用readline()一行行的将整个内容读取到内存中,如果文件很大,都将会耗用很大的内存。同时,从硬盘读取文件内容到内存中,也会很慢。
      因此,有没有一种高效的方式?既让我们看到了文件中的内容,又不会占用内存呢?下面我们将进行说明。

    2)操作说明
    f = open(r"G:\6Tipdm\file_read_write\yesterday.txt","r",encoding="utf-8")
    for line in f:
        print(line.strip())
    

    部分截图如下:
    在这里插入图片描述
    结果说明:
      上述方式中,f相当于一个迭代器,我们使用for循环迭代f中元素。每循环一次,就相当于读取一行到内存中,并记住这一次读取到的位置。当进行下次迭代的时候,上一次读取到内存中的内容,就会被销毁了,当前内存中读取的就是第二行的内容。当进行第三次循环的时候,内存中第二行的内容也会被销毁,此时内存中只会保存第三行的内容,这样依次进行下去。直到最后一次循环,读取最后一行的内容,此时,内存中保留的也只是最后一行的内容。
      迭代器有一个特性:每次进行迭代的时候,就会记住当前读取的位置。当进行下一次迭代的时候,前面的内容会被销毁掉,在内存中只会保留当前循环得到的内容。

    展开全文
  • Android 文件读写最全解析

    万次阅读 多人点赞 2020-04-21 18:08:19
    本文目录文件读写概述读取raw目录文件读取assets目录文件data/data/(包名) 目录文件读写写数据读数据sdcard文件读写申请动态权限写数据读数据完整代码 文件读写概述 raw下的和assert下的文件可以以资源文件的形式...

    推荐阅读:
    Android 通过HttpURLConnection访问Http协议网络
    Android SQlite数据库使用详解
    Android xUtils框架最全使用详解
    Android 动态权限最全解析

    Android文件读写概述

    在这里插入图片描述
    在Androi中文件读写一共有以下目录

    • raw目录
    • asserts目录
    • data/data/包名
    • sdcard目录

    其中raw下的和asserts下的文件可以以资源文件的形式读取,这些目录的数据只能读取,不能写入,两者目录下的文件在打包后会原封不动的保存在apk包中,不会被编译成二进制。
    data/data/包名sdcard目录文件可读可写。其中data/data/包名目录不需要申请权限,sdcard目录需要申请权限

    读取raw目录文件

    Android工程默认是没有raw文件夹的在读文件前我们先把raw 文件夹以及文件建好

    • 点中工程的res目录 右键New -> Directory -> 弹窗中输入raw
    • 点中刚刚新建的raw目录 右键New -> File -> 弹窗中输入test.txt
    • 点开刚刚新建的test.txt文件 ,往里面输入hello world
      在这里插入图片描述
      读数据方法
       InputStream inputStream = null;
       Reader reader = null;
        BufferedReader bufferedReader = null;
        try {
            //得到资源中的Raw数据流
            inputStream = getResources().openRawResource(R.raw.test);
            reader = new InputStreamReader(inputStream);// 字符流
            bufferedReader = new BufferedReader(reader); //缓冲流
            StringBuilder result = new StringBuilder();
            String temp;
            while ((temp = bufferedReader.readLine()) != null) {
                result.append(temp);
            }
            Log.i("MainActivity", "result:" + result);
    
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
        }
    

    从打印的结果中我们可以看出数据读取成功
    在这里插入图片描述

    读取assets目录文件

    Android工程默认是没有assets文件夹的,在读文件前我们先把assets 文件夹以及文件建好

    • 点中工程 右键New -> Folder -> Assets Folder
    • 点中刚刚新建的Assets Folde目录 右键New -> File -> 弹窗中输入test.txt
    • 点开刚刚新建的test.txt文件 ,往里面输入hello world
    • 在这里插入图片描述
      读去assets文件中的数据方法
    		InputStream inputStream = null;
            Reader reader = null;
            BufferedReader bufferedReader = null;
            try {
                //得到资源中的asset数据流
                inputStream = getResources().getAssets().open("test.txt");
                reader = new InputStreamReader(inputStream);// 字符流
                bufferedReader = new BufferedReader(reader); //缓冲流
                StringBuilder result = new StringBuilder();
                String temp;
                while ((temp = bufferedReader.readLine()) != null) {
                    result.append(temp);
                }
                Log.i("MainActivity", "result:" + result);
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
            }
    
    

    从打印的结果中我们可以看出数据读取成功
    在这里插入图片描述

    data/data/(包名) 目录文件读写

    将数据以普通文件的形式保存在 /data/data/包名中,该方法不需要申请权限。
    存放在数据区(/data/data/包名)的文件可以使用openFileOutputopenFileInput进行操作。
    也可以直接指定文件/data/data/包名路径读写。

    该目录存放文件类型规则如下:

    路径功能
    data/data/包名/shared_prefs存放SharedPreferences数据
    data/data/包名/databases存放数据库数据
    data/data/包名/files存放普通数据
    data/data/包名/cache存放缓存文件

    写数据

    方法1:openFileOutput

            FileOutputStream fileOutputStream = null;
            try {
                String text = "hello world";
                fileOutputStream = openFileOutput("test.txt", MODE_PRIVATE);
                fileOutputStream.write(text.getBytes());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (fileOutputStream != null) {
                    try {
                        fileOutputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    

    openFileOutput方法参数详解

    	@Override
        public FileOutputStream openFileOutput(String name, int mode)
            throws FileNotFoundException {
            
        }
    
    • name 存储文件名字
    • mode 存储方式 其值的含义如下
    参数值参数含义
    Context.MODE_PRIVATE指定该文件数据只能被本应用程序读、写
    Context.MODE_WORLD_READABLE指定该文件数据能被其他应用程序读,但不能写
    Context.MODE_WORLD_WRITEABLE指定该文件数据能被其他应用程序读
    Context.MODE_APPEND该模式会检查文件是否存在,存在就往文件追加内容,否则就创建新文件;

    方法2:传统方法读写

       String text = "hello world";
       File file1=new File("/data/data/com.lucashu.file/","test.txt");
          FileOutputStream fileOutputStream = null;
         try {
             fileOutputStream = new FileOutputStream(file1);
             fileOutputStream.write(text.getBytes());
         } catch (Exception e) {
             e.printStackTrace();
         }finally {
             if (fileOutputStream != null) {
                 try {
                     fileOutputStream.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
    

    执行以后我们可以看到添加了一个文件
    在这里插入图片描述

    读数据

    方法1:openFileInput

    		FileInputStream fileInputStream = null;
            Reader reader = null;
            BufferedReader bufferedReader = null;
            try {
                fileInputStream = openFileInput("test.txt");
                reader = new InputStreamReader(fileInputStream);// 字符流
                bufferedReader = new BufferedReader(reader); //缓冲流
                StringBuilder result = new StringBuilder();
                String temp;
                while ((temp = bufferedReader.readLine()) != null) {
                    result.append(temp);
                }
                Log.i("MainActivity", "result:" + result);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fileInputStream != null) {
                    try {
                        fileInputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    

    方法2:openFileInput

    		InputStream inputStream = null;
            Reader reader = null;
            BufferedReader bufferedReader = null;
            try {
    
                File file=new File("/data/data/com.lucashu.file/", "test.txt");
                inputStream = new FileInputStream(file);
                reader = new InputStreamReader(inputStream);
                bufferedReader = new BufferedReader(reader);
                StringBuilder result = new StringBuilder();
                String temp;
                while ((temp = bufferedReader.readLine()) != null) {
                    result.append(temp);
                }
                Log.i("MainActivity", "result:" + result);
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
            }
    

    从打印的结果中我们可以看出数据读取成功

    在这里插入图片描述
    我们也可以用一下方法来获取改文件的路径

    getFilesDir();// data/data/包名/files 目录
    getFilesDir().getParent(),;// data/data/包名/ 目录
    

    sdcard文件读写

    sdcard读写的数据将数据保存在 /mnt/sdcard目录,该目录读写需要先申请动态权限,动态权限申请方法如下

    申请动态权限

    Android 动态权限最全解析
    在这里插入图片描述

    首先需要在manifest.xml中添加权限

    <!--文件读写权限-->
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    

    如果是AndroidQ 或者更高的版本还需要在manifest.xml文件中的application节点下加入
    android:requestLegacyExternalStorage="true"
    申请动态权限方法:

    private static final int REQUEST_EXTERNAL_STORAGE = 1;
    private static String[] PERMISSIONS_STORAGE = {"android.permission.READ_EXTERNAL_STORAGE",
                "android.permission.WRITE_EXTERNAL_STORAGE"};
    
    private void checkPermission() {
    //检查权限(NEED_PERMISSION)是否被授权 PackageManager.PERMISSION_GRANTED表示同意授权
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                != PackageManager.PERMISSION_GRANTED) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission
                    .WRITE_EXTERNAL_STORAGE)) {
                Toast.makeText(this, "请开通相关权限,否则无法正常使用本应用!", Toast.LENGTH_SHORT).show();
            }
            //申请权限
            ActivityCompat.requestPermissions(this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
    
        } else {
            Toast.makeText(this, "已授权成功!", Toast.LENGTH_SHORT).show();
            writeSdcard();
    
        }
    }
    

    Activity中动态权限的回调方法

    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           String permissions[], int[] grantResults) {
        switch (requestCode) {
            case REQUEST_EXTERNAL_STORAGE: {
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(this, "授权成功!", Toast.LENGTH_SHORT).show();
                    writeSdcard();
                } else {
                    Toast.makeText(this, "授权被拒绝!", Toast.LENGTH_SHORT).show();
    
    
                }
                return;
            }
    
        }
    }
    
    

    写数据

    private void writeSdcard()  {
            String text = "hello world";
            if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    File storage = Environment.getExternalStorageDirectory();
                    File tmepfile = new File(storage.getPath());
                    if (! tmepfile.exists()) {
                        tmepfile.mkdirs();
                    }
                    File file1=new File(tmepfile,"test.txt");
                    if (!file1.exists()){
                        try {
                            file1.createNewFile();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    FileOutputStream fileOutputStream = null;
                    try {
                        fileOutputStream = new FileOutputStream(file1);
                        fileOutputStream.write(text.getBytes());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }finally {
                        if (fileOutputStream != null) {
                            try {
                                fileOutputStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    

    执行以后我们可以看到添加了一个文件
    在这里插入图片描述

    读数据

    private void readSdcard() {
            if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    InputStream inputStream = null;
                    Reader reader = null;
                    BufferedReader bufferedReader = null;
                    try {
                        File storage = Environment.getExternalStorageDirectory();
                        File tmepfile = new File(storage.getPath());
                        File file=new File(tmepfile, "test.txt");
                        inputStream = new FileInputStream(file);
                        reader = new InputStreamReader(inputStream);
                        bufferedReader = new BufferedReader(reader);
                        StringBuilder result = new StringBuilder();
                        String temp;
                        while ((temp = bufferedReader.readLine()) != null) {
                            result.append(temp);
                        }
                        Log.i("MainActivity", "result:" + result);
    
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        if (reader != null) {
                            try {
                                reader.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        if (inputStream != null) {
                            try {
                                inputStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        if (bufferedReader != null) {
                            try {
                                bufferedReader.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
    
                    }
                }
            }
        }
    

    在这里插入图片描述

    sdcard文件读写完整代码

    package com.lucashu.file;
    
    import androidx.appcompat.app.AppCompatActivity;
    import androidx.core.app.ActivityCompat;
    
    import android.Manifest;
    import android.content.pm.PackageManager;
    import android.os.Bundle;
    import android.os.Environment;
    import android.util.Log;
    import android.widget.Toast;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.Reader;
    import java.io.Writer;
    
    public class MainActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            checkPermission();
        }
    
    
        private void writeSdcard()  {
            String text = "hello world";
            if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    File storage = Environment.getExternalStorageDirectory();
                    File tmepfile = new File(storage.getPath());
                    if (! tmepfile.exists()) {
                        tmepfile.mkdirs();
                    }
                    File file1=new File(tmepfile,"test.txt");
                    if (!file1.exists()){
                        try {
                            file1.createNewFile();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    FileOutputStream fileOutputStream = null;
                    try {
                        fileOutputStream = new FileOutputStream(file1);
                        fileOutputStream.write(text.getBytes());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }finally {
                        if (fileOutputStream != null) {
                            try {
                                fileOutputStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    
    
        private void readSdcard() {
            if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    InputStream inputStream = null;
                    Reader reader = null;
                    BufferedReader bufferedReader = null;
                    try {
                        File storage = Environment.getExternalStorageDirectory();
                        File tmepfile = new File(storage.getPath());
                        File file=new File(tmepfile, "test.txt");
                        inputStream = new FileInputStream(file);
                        reader = new InputStreamReader(inputStream);
                        bufferedReader = new BufferedReader(reader);
                        StringBuilder result = new StringBuilder();
                        String temp;
                        while ((temp = bufferedReader.readLine()) != null) {
                            result.append(temp);
                        }
                        Log.i("MainActivity", "result:" + result);
    
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        if (reader != null) {
                            try {
                                reader.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        if (inputStream != null) {
                            try {
                                inputStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        if (bufferedReader != null) {
                            try {
                                bufferedReader.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
    
                    }
                }
            }
        }
        private static final int REQUEST_EXTERNAL_STORAGE = 1;
        private static String[] PERMISSIONS_STORAGE = {"android.permission.READ_EXTERNAL_STORAGE",
                "android.permission.WRITE_EXTERNAL_STORAGE"};
    
        private void checkPermission() {
            //检查权限(NEED_PERMISSION)是否被授权 PackageManager.PERMISSION_GRANTED表示同意授权
            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    != PackageManager.PERMISSION_GRANTED) {
                if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission
                        .WRITE_EXTERNAL_STORAGE)) {
                    Toast.makeText(this, "请开通相关权限,否则无法正常使用本应用!", Toast.LENGTH_SHORT).show();
                }
                //申请权限
                ActivityCompat.requestPermissions(this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
    
            } else {
                Toast.makeText(this, "已授权成功!", Toast.LENGTH_SHORT).show();
                readSdcard();
    
            }
        }
    
        @Override
        public void onRequestPermissionsResult(int requestCode,
                                               String permissions[], int[] grantResults) {
            switch (requestCode) {
                case REQUEST_EXTERNAL_STORAGE: {
                    if (grantResults.length > 0
                            && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                        Toast.makeText(this, "授权成功!", Toast.LENGTH_SHORT).show();
                        readSdcard();
                    } else {
                        Toast.makeText(this, "授权被拒绝!", Toast.LENGTH_SHORT).show();
    
                    }
                    return;
                }
    
            }
        }
    
    }
    
    

    作者:lucashu
    出处:https://blog.csdn.net/huweiliyi/category_8913738.html
    原创不易,欢迎转载,但未经作者同意请保留此段声明,并在文章页面明显位置给出原文链接。

    展开全文
  • ;文本文件读写 二进制文件读写 文件的定位与随机读取;定义文件指针 打开文件 读写文件 关闭文件;读写文件;读写文件;读写文件;读写文件;读写文件;读写文件;读写文件;
  • C语言 文件读写的实现

    万次阅读 多人点赞 2019-04-26 11:55:33
    关于C语言的文件读写,我将介绍下面这几种方式: 字符的读写:使用 fgetc() 函数 和 fputc() 函数; 字符串的读写:使用 fgets() 函数和 fputs() 函数; 格式化的读写(主要用于文本文件):使用 ...
  • python的文件读写操作

    万次阅读 多人点赞 2019-04-28 08:30:49
    文件读写实现原理与操作步骤 文件打开模式 Python文件操作步骤示例 Python文件读取相关方法 文件读写与字符编码 一、I/O操作概述 I/O在计算机中是指Input/Output,也就是Stream(流)的输入和输出。这里的输入和...
  • linux下文件读写

    万次阅读 2019-06-23 10:25:26
    linux 下一切皆文件 文件读写 文件的打开open函数 涉及头文件: ubuntu 头文件所在目录:/usr/include/x86_64-linux-gnu/sys #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> ...
  • codesys工程ST语言读写EXCEL的cvs文件!!!内附代码、源工程文件
  • 1、python文件缓冲区 f = open('test', 'w', 1) # 第三个参数为1表示行缓冲,默认值为-1 while True: data = input('>>>') if not data: break f.write(data) f.flush() # 立即刷新缓冲,写入磁盘 f....
  • Linux下的文件读写

    千次阅读 2019-04-01 10:07:40
    应用程序(打开文件)-》各种库(标准库fopen)-》系统调用(open)-》内核(驱动)-》硬件(磁盘)。 系统调用:内核提供给外界访问的接口函数,调用这些函数将使进程进入内核态。 1、UNIX、Linux大部的系统...
  • C++对文本文件读写方法

    千次阅读 2021-11-13 17:38:05
    1、创建流对象,打开文件 void open( const char *filename ); void open( const char *filename, openmode mode ); filename 文件名 mode:打开模式 ios::app 添加输出 ios::ate 当已打开时寻找到EOF ...
  • C++文件读写操作

    千次阅读 2021-02-05 10:34:07
    C++文件操作C++文件操作C++文件操作 60.C++文件操作-文本文件-写文件 61.C++文件操作-文本文件-读文件 62.C++文件操作-二进制文件-写文件 63.C++文件操作-二进制文件-读文件 60.C++文件操作-文本文件-写文件 61....
  • C语言-文件读写操作

    千次阅读 2019-04-19 11:35:01
    即当读写一个文件时,可以不必关心文件的格式或结构。 2、文本文件和二进制文件: 计算机文件的存储,物理上都是二进制,所以文本文件与二进制文件的区别并不是物理上的, 而是逻辑上的。这两者只是在编码层次上有...
  • Qt 二进制文件读写

    千次阅读 2021-02-25 21:39:28
    Qt 使用 QFile 和 QDataStream 进行二进制数据文件读写: QFile 负责文件的 IO 设备接口,即与文件的物理交互; QDataStream 以数据流的方式读取文件内容或写入文件内容。 QDataStream 保存文件时使用的数据编码...
  • Android R(11)文件读写适配

    千次阅读 2021-03-17 14:42:47
    INT >= Build.VERSION_CODES.R) { if (Environment.isExternalStorageManager()) { //已获取android读写权限 } else { //存储权限获取失败 } } } 创建文件:亲测可以如下方式在文件管理器根目录正常创建和读写。...
  • python多线程同步之文件读写控制

    千次阅读 2020-11-21 01:28:16
    本文实例为大家分享了python多线程同步之文件读写控制的具体代码,供大家参考,具体内容如下1、实现文件读写的文件ltz_schedule_times.py#! /usr/bin/env python#coding=utf-8import osdef ReadTimes():res = []if ...
  • Linux监控文件读写

    千次阅读 2019-07-25 17:18:34
    如何去监测目标文件, 我思考了很久仍没有头绪,翻了翻开发大赛入围名单, 发现马艺诚同学使用了hook方法来监测进程操作目标文件。于是下午试了试, 确实可行(毕竟人家已经做出来了嘛)。下面讲解一下我下午尝试的...
  • 查看文件权限的语句:  在终端输入:ls -l xxx.xxx (xxx.xxx是文件名)  那么就会出现相类似的信息,主要都是这些:-rw-rw-r--  一共有10位数
  • C++ 文件读写相关函数

    千次阅读 2019-03-13 14:19:49
    几个C/C++语言文件读写函数 1、打开和关闭文件  (1)打开文件:FILE * fopen(const char *filename, const char *mode)  在使用打开文件函数时,我们要提供一个要打开的文件名,这里要提供一个当前用户有...
  • rust 文件读写操作

    千次阅读 2020-11-23 18:13:24
    文章目录一、读取文件二、写入文件 一、读取文件 use std::fs::File; fn main() { let f = File::open("hello.txt").unwrap(); } 1、按字节读取 use std::fs::File; use std::io::prelude::*; fn main() { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,061,156
精华内容 424,462
关键字:

文件的读写

友情链接: LSD4RF-2F717N30.rar