交互IO的行使形式,集团级开采进阶1

  写的MPI程序须要采取并行IO来操作文件,不过搜遍了度娘都未曾找到多少有关互相IO函数的运用方法。最终在知网搜到了一部分得力的故事集,看了一下,认为一语中的。

  写的MPI程序需求选拔并行IO来操作文件,不过搜遍了度娘都未曾找到多少有关互相IO函数的行使方法。最终在知网搜到了有的卓有效用的舆论,看了①晃,感到出现转机。

MPI-二 并行IO的选取情势,mpi-二并行io

  写的MPI程序需求运用并行IO来操作文件,可是搜遍了度娘都未曾找到多少有关互相IO函数的应用情势。最终在知网搜到了一部分卓有效用的故事集,看了一下,感到出现转机。

  MPI-一对文件的操作是利用绑定语言的函数调用来开始展览的,日常使用的是串行IO的读写格局,壹般意况下是用一个主进度展开文件和读取数据,然后分发给此外进程来拍卖,那种串行IO数据的通讯量非常的大、作用好低。MPI-二实现了并行IO,允许多个经过同时对文件举办操作,从而幸免了文本数量在差别进度间的传递,对于需求凑数文件操作的先后来讲,大致是一大幸福!

  并行IO可分为三种方法:钦点显式偏移量、独立文件指针和共享文件指针,各样格局又可分为阻塞和非阻塞三种处境。

  上边以读写三个二进制文件数组为例,阐述那三种方式的函数调用。上面包车型大巴四个mian函数分别对应二种方法,读取“data”2进制文件数组(文件内容:行数、列数、数组成分),读取完整后由进度0输出其读取的数码以表达读取是不是科学,最后全部进程将其读取的多少写入三个叫“data二”的二进制文件。怎么来查看二进制文件的剧情以验证是不是读写正确吧,或然说2进制文件和可读内容的公文文件之间怎么转换呢?下边也提交轻巧代码。

  

  code:

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 #include"mpi.h"
  5 
  6 #define BLOCK_LOW(rank,size,n)    ((rank)*(n)/(size))
  7 #define BLOCK_HIGH(rank,size,n)    (BLOCK_LOW((rank)+1,size,n)-1)
  8 #define BLOCK_SIZE(rank,size,n)    (BLOCK_HIGH(rank,size,n)-BLOCK_LOW(rank,size,n)+1)
  9 
 10 //并行IO:指定显式偏移的文件操作
 11 int main(int argc, char *argv[])
 12 {
 13     int size,rank,i;
 14     int n,m;
 15     float *array;
 16     MPI_File fh;
 17     MPI_Status status;
 18     MPI_Init(&argc,&argv);
 19     MPI_Comm_rank(MPI_COMM_WORLD,&rank);
 20     MPI_Comm_size(MPI_COMM_WORLD,&size);
 21 
 22     MPI_File_open(MPI_COMM_WORLD,"data",MPI_MODE_RDONLY,MPI_INFO_NULL,&fh);
 23     MPI_File_read_at_all(fh,0,&n,1,MPI_INT,&status);    //从偏移量0处读取
 24     MPI_File_read_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);    //从偏移量1个int处读取
 25     array=(float *)malloc(BLOCK_SIZE(rank,size,n)*m*sizeof(float));
 26     MPI_File_read_at_all(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);
 27     MPI_File_close(&fh);
 28 
 29     if(rank==0){
 30         printf("rank=%d: %d %d\n",rank,n,m);
 31         for(i=0;i<BLOCK_SIZE(rank,size,n)*m;i++){
 32             printf("% .0f",array[i]);
 33             if((i+1)%m==0)    putchar('\n');
 34         }
 35     }
 36 
 37     MPI_File_open(MPI_COMM_WORLD,"data2",MPI_MODE_CREATE|MPI_MODE_WRONLY,MPI_INFO_NULL,&fh);
 38     MPI_File_write_at_all(fh,0,&n,1,MPI_INT,&status);
 39     MPI_File_write_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);
 40     MPI_File_write_at_all(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);
 41     MPI_File_close(&fh);
 42 
 43     MPI_Finalize();
 44     return 0;
 45 }
 46  
 47 /*
 48 //并行IO:独立文件指针
 49 int main(int argc,char *argv[])
 50 {
 51     int size,rank,i;
 52     int n,m;
 53     float *array;
 54     MPI_File fh;
 55     MPI_Status status;
 56     MPI_Init(&argc,&argv);
 57     MPI_Comm_rank(MPI_COMM_WORLD,&rank);
 58     MPI_Comm_size(MPI_COMM_WORLD,&size);
 59 
 60     MPI_File_open(MPI_COMM_WORLD,"data",MPI_MODE_RDONLY,MPI_INFO_NULL,&fh);
 61     MPI_File_set_view(fh,0,MPI_INT,MPI_INT,"internal",MPI_INFO_NULL);    //设置绝对偏移量为0
 62     MPI_File_read_all(fh,&n,1,MPI_INT,&status);    //读取后偏移量自动加1
 63     MPI_File_read_all(fh,&m,1,MPI_INT,&status);
 64     array=(float *)malloc(BLOCK_SIZE(rank,size,n)*m*sizeof(float));
 65     MPI_File_set_view(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),MPI_FLOAT,MPI_FLOAT,"internal",MPI_INFO_NULL);//重置偏移量
 66     MPI_File_read_all(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_INT,&status);
 67     MPI_File_close(&fh);
 68 
 69     if(rank==0){
 70         printf("rank=%d: %d %d\n",rank,n,m);
 71         for(i=0;i<BLOCK_SIZE(rank,size,n)*m;i++){
 72             printf("% .0f",array[i]);
 73             if((i+1)%m==0)    putchar('\n');
 74     
 75         }
 76     }
 77     
 78     MPI_File_open(MPI_COMM_WORLD,"data2",MPI_MODE_CREATE|MPI_MODE_WRONLY,MPI_INFO_NULL,&fh);
 79     MPI_File_set_view(fh,0,MPI_INT,MPI_INT,"internal",MPI_INFO_NULL);
 80     MPI_File_write_all(fh,&n,1,MPI_INT,&status);
 81     MPI_File_write_all(fh,&m,1,MPI_INT,&status);
 82     MPI_File_set_view(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),MPI_FLOAT,MPI_FLOAT,"internal",MPI_INFO_NULL); 
 83     MPI_File_write_all(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);
 84     MPI_File_close(&fh);
 85 
 86     MPI_Finalize();
 87 }
 88 */
 89 
 90 /*
 91 //并行IO:共享文件指针
 92 int main(int argc,char *argv[])
 93 {
 94     int size,rank,i;
 95     int n,m;
 96     float *array;
 97     MPI_File fh;
 98     MPI_Status status;
 99     MPI_Init(&argc,&argv);
100     MPI_Comm_rank(MPI_COMM_WORLD,&rank);
101     MPI_Comm_size(MPI_COMM_WORLD,&size);
102 
103     MPI_File_open(MPI_COMM_WORLD,"data",MPI_MODE_RDONLY,MPI_INFO_NULL,&fh);
104     MPI_File_read_at_all(fh,0,&n,1,MPI_INT,&status);    //指定显式偏移的读取
105     MPI_File_read_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);
106     array=(float *)malloc(BLOCK_SIZE(rank,size,n)*m*sizeof(float));
107     MPI_File_seek_shared(fh,2*sizeof(int),MPI_SEEK_SET);    //共享文件指针,偏移量是2个int
108     MPI_File_read_ordered(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);    //按序读取
109     MPI_File_close(&fh);
110 
111     if(rank==0){
112         printf("rank=%d: %d %d\n",rank,n,m);
113         for(i=0;i<BLOCK_SIZE(rank,size,n)*m;i++){
114             printf("% .0f",array[i]);
115             if((i+1)%m==0)    putchar('\n');
116     
117         }
118     }
119  
120     MPI_File_open(MPI_COMM_WORLD,"data2",MPI_MODE_CREATE|MPI_MODE_WRONLY,MPI_INFO_NULL,&fh);
121     MPI_File_write_at_all(fh,0,&n,1,MPI_INT,&status);    //指定显式偏移的写入
122     MPI_File_write_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);
123     MPI_File_seek_shared(fh,2*sizeof(int),MPI_SEEK_SET);    //共享文件指针,偏移量是2个int
124     MPI_File_write_ordered(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);    //按序写入
125     MPI_File_close(&fh);
126 
127     MPI_Finalize();
128 }
129 */

 

 1 //将二进制数组文件转换为文本文件。要求二进制文件的内容:行数 列数 数组元素
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 
 5 typedef float type;
 6 
 7 int main()
 8 {
 9     int i,j;
10     int n,m;
11     type **array;
12     FILE *fp;
13     fp=fopen("data","rb");
14     fread(&n,sizeof(int),1,fp);
15     fread(&m,sizeof(int),1,fp);
16 
17     array=(type **)malloc(n*sizeof(type *));
18     *array=(type *)malloc(n*m*sizeof(type));
19     for(i=1;i<n;i++)    array[i]=array[i-1]+m;
20 
21     fread(&array[0][0],n*m*sizeof(type),1,fp);  //注意不能是地址 array
22     fclose(fp);
23 
24     fp=fopen("data.txt","w");
25     fprintf(fp," %d %d\n",n,m);
26     for(i=0;i<n;i++){
27         for(j=0;j<m;j++)
28             fprintf(fp,"% f ",array[i][j]);
29         putc('\n',fp);
30     }
31     fprintf(stdout,"Successfully!\n");
32 }

 

 1 //将数组文本文件转换为二进制文件。要求文本文件的内容:行数 列数 数组元素
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 
 5 typedef float type;
 6 
 7 int main()
 8 {
 9     int i,j;
10     int n,m;
11     type **array;
12     FILE *fp;
13     fp=fopen("data.txt","r");
14     fscanf(fp,"%d",&n);
15     fscanf(fp,"%d",&m);
16 
17     array=(type **)malloc(n*sizeof(type *));
18     *array=(type *)malloc(n*m*sizeof(type));
19     for(i=1;i<n;i++)    array[i]=array[i-1]+m;
20 
21     for(i=0;i<n;i++)
22         for(j=0;j<m;j++)
23             fscanf(fp,"%f",&array[i][j]);
24     fclose(fp);
25 
26     fp=fopen("data","wb");
27     fwrite(&n,sizeof(int),1,fp);
28     fwrite(&m,sizeof(int),1,fp);
29     fwrite(&array[0][0],n*m*sizeof(type),1,fp);  //注意不能是地址 &array
30     fclose(fp);
31     fprintf(stdout,"Successfully!\n");
32 }

 

  八个示范的文件文件数组data.txt:

  8 8
  1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000
1.000000
  2.000000 2.000000 2.000000 2.000000 2.000000 2.000000 2.000000
2.000000
  3.000000 3.000000 3.000000 3.000000 3.000000 3.000000 3.000000
3.000000
  4.000000 4.000000 4.000000 4.000000 4.000000 4.000000 4.000000
4.000000
  5.000000 5.000000 5.000000 5.000000 5.000000 5.000000 5.000000
5.000000
  6.000000 6.000000 6.000000 6.000000 6.000000 6.000000 6.000000
6.000000
  7.000000 7.000000 7.000000 7.000000 7.000000 7.000000 7.000000
7.000000
  8.000000 8.000000 8.000000 8.000000 8.000000 8.000000 8.000000
8.000000

并行IO的施用形式,mpi-2并行io
写的MPI程序供给运用并行IO来操作文件,可是搜遍了度娘都未有找到多少有关互相IO函数的接纳情势。最…

本节内容如下:

  MPI-一对文本的操作是使用绑定语言的函数调用来进行的,日常使用的是串行IO的读写情势,1般情状下是用三个主进程展开文件和读取数据,然后分发给任何进度来处理,那种串行IO数据的通讯量不小、作用十分低。MPI-二达成了并行IO,允许多少个经过同时对文本举办操作,从而防止了文件数量在区别进度间的传递,对于急需凝聚文件操作的顺序来说,简直是第一次全国代表大会幸福!

  MPI-一对文件的操作是利用绑定语言的函数调用来开始展览的,经常选拔的是串行IO的读写方式,1般景色下是用叁个主过程展开文件和读取数据,然后分发给任何进度来拍卖,那种串行IO数据的通讯量比十分的大、效用十分低。MPI-贰达成了并行IO,允许四个经过同时对文件进行操作,从而防止了文件数量在分化进程间的传递,对于需求凑数文件操作的程序来讲,简直是第一次全国代表大会幸福!

  • 什么是IO
  • 文件内容操作
    交互IO的行使形式,集团级开采进阶1。操作文本文件
    操作2进制文件
  • 内存IO
    起来认识io模块
  • 目录和文书的操作
    初始认识os模块
    文件的始建、重命名、删除
    目录的创立、重命名、删除
  • 连串化操作

  并行IO可分为三种办法:钦点显式偏移量、独立文件指针和共享文件指针,每种格局又可分为阻塞和非阻塞三种意况。

  并行IO可分为三种方式:内定显式偏移量、独立文件指针和共享文件指针,每个格局又可分为阻塞和非阻塞三种状态。

1. 什么是IO

IO:Input/Output~输入/输出的意味

别的编制程序语言,主题都以对数据的处理,对数码的拍卖1般景观下就是指代数据的输入和出口
符合规律状态下,大家在程序运转的进度中,将数据频仍的输入或然输出到计算机的内部存储器中,让程序经常的运作;
出于程序中的数据并不是能持之以恒保存的,所以在某个情景下,大家将数据输入或然输出到计算机中的文件中来打开恒久保存;
从而各类编制程序语言中,都提供了丰富而且周到的输入输出流的API接口调整数据的输入和输出(读/写)~

运行中的程序,可以将数据暂且保存在内部存款和储蓄器中【向内部存款和储蓄器中输出数据】,也足以将内部存款和储蓄器中的数量读抽出来在先后中央银行使【向程序中输入数据】

num = 12 # 将一个数据12,赋值给变量num,num和对象12被输出保存到计算机内存中了
print (num) # 将内存中num对应的数据12读取到程序中进行答应,num和对应的对象数据12被输入到程序中了

内部存款和储蓄器中的多少读取

如出一辙,运营中的程序,能够将数据永世保存到文件中【向文件中输出数据】,也足以从文件中读取数据到程序中动用【读取文件数量输入到程序中】

从文件中读写多少

  上边以读写一个2进制文件数组为例,解说那三种办法的函数调用。下边包车型大巴八个mian函数分别对应二种艺术,读取“data”2进制文件数组(文件内容:行数、列数、数组成分),读取完整后由进度0输出其读取的多少以证实读取是或不是科学,最终全体进度将其读取的多寡写入1个叫“data二”的二进制文件。怎么来查阅二进制文件的内容以评释是还是不是读写正确吧,也许说二进制文件和可读内容的文书文件之间怎么转换呢?上边也付出轻便代码。

  下边以读写1个2进制文件数组为例,演讲那两种办法的函数调用。上边包车型客车七个mian函数分别对应二种艺术,读取“data”2进制文件数组(文件内容:行数、列数、数组元素),读取完整后由进度0输出其读取的数码以评释读取是还是不是科学,最终全体进度将其读取的多少写入贰个叫“data二”的二进制文件。怎么来查看二进制文件的剧情以表明是还是不是读写正确吧,只怕说二进制文件和可读内容的文书文件之间怎么转移呢?下边也付出不难代码。

二. python中的输入/输出

python中提供了正式的输入/输出的语法结构,在头里的章节中早已开展过介绍,大家那里大致回看一下就可以
标准输入:input()函数操效用于吸收接纳用户数量,保存数据的历程就能够将数据写入到内部存储器中
规范输出:print()函数用于将钦命的数据输出到调节台实行显示

msg = input("请输入个人介绍:")
print("个人介绍:" + msg)

  

  

三. python中对文件内容的操作

澳门葡京备用网址 ,文本内容也是壹种多少,对数据的操作1般处境下可总结为增加和删除改查多样办法
对文本内容的操作,能够归咎为读取、覆盖、追加的操作。

python中对文本内容的操作首如若通过open()函数实行拍卖的,open()函数的简练语法结构如下:

open(file, mode="r", buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

# file:是要操作的文件,这里是完整的问文件路径+文件名称,如:d:/test.txt

# mode:是操作默认,默认是r,表示可读的
####  常规选项如下:
#### r     #### 表示文件以可读的方式打开,打开的文件只能读取文件数据,不能修改
#### w     #### 表示文件以可写的方式打开,可以操作文件中的数据,不能做其他操作
#### x     #### 表示文件以执行的方式打开,主要用于进行文件创建等操作
#### a     #### 表示文件内容以追加的方式打开,向文件写入数据不会覆盖原来的数据
#### b     #### 表示文件以二进制的方式进行处理,可以操作二进制数据
#### t     #### 表示文件以文本的方式进行处理,也是默认的方式
#### +     #### 表示文件以读写的方式进行处理,是rw结合起来的用法
#### U     #### 表示使用通用的内容换行的方式进行处理

# buffering:表示读写内容的缓冲区,如果设置为0表示关闭缓冲区,通常情况下我们会使用io.DEFAULT_BUFFER_SIZE这个默认值,在不同的操作系统中是4096/8192字节的长度

# encoding:打开文件的编码,这个选项只能用于操作文本文件的情况下,这个选项的默认值跟文件所在的操作系统有关

# errors:这个选项主要用于在encoding选项进行编码和解码出现错误时的操作,值是一个字符串,python已经封装了字符串对应的处理功能;常规的选项如下:
#### strict    #### 使用严格模式进行处理,如果出现错误就抛出ValueError异常信息
#### ignore    #### 忽略出现的错误,这里需要注意,忽略编码错误会导致数据丢失的!
#### replace   #### 如果出现编码错误,使用特殊符号替换错误的编码,如符号?

# newline:选项用于控制mode为U时自动换行的处理,可以是如下选项中的一种
#### "None"、""、"\n"、"\r"、"\r\n"

  code:

  code:

三.一. 操作文本文件

  • 读取文本文件中的数据,能够行使read()函数读取全体数据依然read(size)读取内定长度的数码依然readlines()读取整行数据

# 以只读的方式打开系统中d:/test.txt文本文件,读取其中的数据
f = open("d:/test.txt", "r")

# 读取数据到程序中
content = f.read()

# 使用读取到的数据
print(content)

# 操作结果,记得关闭文件哦
f.close()

# 执行结果:d:/test.txt中的数据被完整的读取出来了
~hello python!
~输入输出流测试数据!

上述代码在施行时,假若操作的文本不存在就会现出如下错误,请依据事先的不当调节和测试章节的内容分析一下错误

Traceback (most recent call last):
  File "D:/resp_work/PY_WORK/备课/模块化开发/demo06/demo01文件操作.py", line 3, in <module>
    f = open("d:/testtxt", "r")
FileNotFoundError: [Errno 2] No such file or directory: 'd:/test.txt'

此外,在读取文件数量时,一定要专注文件的编码格式,常常境况下都以应用当前操作系统默许的编码,相当于在函数处理时忽略encoding选项;就好像上边的动静就会并发难点:

本身眼下系统的暗中同意编码是gbk编码,在d:盘下创制了叁个test二.txt文书,文件编码修改成了utf-8编码,此时试行如下代码:

f = open("d:/test2.txt", "r")
content = f.read()
print(content)
f.close()

大家得以看看和目前的代码没有其他分歧,不过进行出现如下难点:

Traceback (most recent call last):
  File "D:/resp_work/PY_WORK/备课/模块化开发/demo06/demo01文件操作.py", line 26, in <module>
    content = f.read()
UnicodeDecodeError: 'gbk' codec can't decode byte 0xaf in position 8: illegal multibyte sequence

那是1个怎么着的主题素材吧:报错提醒UnicodeDecodeError也正是编码错误,大家修改程序代码

f = open("d:/test2.txt", "r", encoding="utf-8")
content = f.read()
print(content)
f.close()

重新奉行顺序,数据平常读取了

这是新的文件内容
  • 向文本文件中写入数据,一般景色下,能够透过write()函数可能writelines()函数向文件中写入数据

# 以可写的方式打开d:/test.txt文件
# 这里请注意,open()函数的mode是w模式,如果目标文件不存在就会自动创建这个文件
f = open("d:/test.txt", "w")

# 通过write()函数向文件中写入数据
f.write("这是Python从程序中写入到文件的数据")

# 操作完成,一定记得关闭文件哦
f.close()

python程序写入文件的数码

  • 向文本文件中追加写入数据,地点的代码实践的结果,会将文件中本来的数码覆盖掉

# 以追加内容的方式打开文件
f = open("d:/test.txt", "a")

# 向文件中追加内容
f.write("这是新的内容")

# 操作完成,记得关闭文件哦
f.close()

大家开采文件能够看看,原来的多寡还在,新的数据被追加到了后头

增添写入数据

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 #include"mpi.h"
  5 
  6 #define BLOCK_LOW(rank,size,n)    ((rank)*(n)/(size))
  7 #define BLOCK_HIGH(rank,size,n)    (BLOCK_LOW((rank)+1,size,n)-1)
  8 #define BLOCK_SIZE(rank,size,n)    (BLOCK_HIGH(rank,size,n)-BLOCK_LOW(rank,size,n)+1)
  9 
 10 //并行IO:指定显式偏移的文件操作
 11 int main(int argc, char *argv[])
 12 {
 13     int size,rank,i;
 14     int n,m;
 15     float *array;
 16     MPI_File fh;
 17     MPI_Status status;
 18     MPI_Init(&argc,&argv);
 19     MPI_Comm_rank(MPI_COMM_WORLD,&rank);
 20     MPI_Comm_size(MPI_COMM_WORLD,&size);
 21 
 22     MPI_File_open(MPI_COMM_WORLD,"data",MPI_MODE_RDONLY,MPI_INFO_NULL,&fh);
 23     MPI_File_read_at_all(fh,0,&n,1,MPI_INT,&status);    //从偏移量0处读取
 24     MPI_File_read_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);    //从偏移量1个int处读取
 25     array=(float *)malloc(BLOCK_SIZE(rank,size,n)*m*sizeof(float));
 26     MPI_File_read_at_all(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);
 27     MPI_File_close(&fh);
 28 
 29     if(rank==0){
 30         printf("rank=%d: %d %d\n",rank,n,m);
 31         for(i=0;i<BLOCK_SIZE(rank,size,n)*m;i++){
 32             printf("% .0f",array[i]);
 33             if((i+1)%m==0)    putchar('\n');
 34         }
 35     }
 36 
 37     MPI_File_open(MPI_COMM_WORLD,"data2",MPI_MODE_CREATE|MPI_MODE_WRONLY,MPI_INFO_NULL,&fh);
 38     MPI_File_write_at_all(fh,0,&n,1,MPI_INT,&status);
 39     MPI_File_write_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);
 40     MPI_File_write_at_all(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);
 41     MPI_File_close(&fh);
 42 
 43     MPI_Finalize();
 44     return 0;
 45 }
 46  
 47 /*
 48 //并行IO:独立文件指针
 49 int main(int argc,char *argv[])
 50 {
 51     int size,rank,i;
 52     int n,m;
 53     float *array;
 54     MPI_File fh;
 55     MPI_Status status;
 56     MPI_Init(&argc,&argv);
 57     MPI_Comm_rank(MPI_COMM_WORLD,&rank);
 58     MPI_Comm_size(MPI_COMM_WORLD,&size);
 59 
 60     MPI_File_open(MPI_COMM_WORLD,"data",MPI_MODE_RDONLY,MPI_INFO_NULL,&fh);
 61     MPI_File_set_view(fh,0,MPI_INT,MPI_INT,"internal",MPI_INFO_NULL);    //设置绝对偏移量为0
 62     MPI_File_read_all(fh,&n,1,MPI_INT,&status);    //读取后偏移量自动加1
 63     MPI_File_read_all(fh,&m,1,MPI_INT,&status);
 64     array=(float *)malloc(BLOCK_SIZE(rank,size,n)*m*sizeof(float));
 65     MPI_File_set_view(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),MPI_FLOAT,MPI_FLOAT,"internal",MPI_INFO_NULL);//重置偏移量
 66     MPI_File_read_all(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_INT,&status);
 67     MPI_File_close(&fh);
 68 
 69     if(rank==0){
 70         printf("rank=%d: %d %d\n",rank,n,m);
 71         for(i=0;i<BLOCK_SIZE(rank,size,n)*m;i++){
 72             printf("% .0f",array[i]);
 73             if((i+1)%m==0)    putchar('\n');
 75         }
 76     }
 77     
 78     MPI_File_open(MPI_COMM_WORLD,"data2",MPI_MODE_CREATE|MPI_MODE_WRONLY,MPI_INFO_NULL,&fh);
 79     MPI_File_set_view(fh,0,MPI_INT,MPI_INT,"internal",MPI_INFO_NULL);
 80     MPI_File_write_all(fh,&n,1,MPI_INT,&status);
 81     MPI_File_write_all(fh,&m,1,MPI_INT,&status);
 82     MPI_File_set_view(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),MPI_FLOAT,MPI_FLOAT,"internal",MPI_INFO_NULL); 
 83     MPI_File_write_all(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);
 84     MPI_File_close(&fh);
 85 
 86     MPI_Finalize();
 87 }
 88 */
 89 
 90 /*
 91 //并行IO:共享文件指针
 92 int main(int argc,char *argv[])
 93 {
 94     int size,rank,i;
 95     int n,m;
 96     float *array;
 97     MPI_File fh;
 98     MPI_Status status;
 99     MPI_Init(&argc,&argv);
100     MPI_Comm_rank(MPI_COMM_WORLD,&rank);
101     MPI_Comm_size(MPI_COMM_WORLD,&size);
102 
103     MPI_File_open(MPI_COMM_WORLD,"data",MPI_MODE_RDONLY,MPI_INFO_NULL,&fh);
104     MPI_File_read_at_all(fh,0,&n,1,MPI_INT,&status);    //指定显式偏移的读取
105     MPI_File_read_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);
106     array=(float *)malloc(BLOCK_SIZE(rank,size,n)*m*sizeof(float));
107     MPI_File_seek_shared(fh,2*sizeof(int),MPI_SEEK_SET);    //共享文件指针,偏移量是2个int
108     MPI_File_read_ordered(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);    //按序读取
109     MPI_File_close(&fh);
110 
111     if(rank==0){
112         printf("rank=%d: %d %d\n",rank,n,m);
113         for(i=0;i<BLOCK_SIZE(rank,size,n)*m;i++){
114             printf("% .0f",array[i]);
115             if((i+1)%m==0)    putchar('\n');
117         }
118     }
119  
120     MPI_File_open(MPI_COMM_WORLD,"data2",MPI_MODE_CREATE|MPI_MODE_WRONLY,MPI_INFO_NULL,&fh);
121     MPI_File_write_at_all(fh,0,&n,1,MPI_INT,&status);    //指定显式偏移的写入
122     MPI_File_write_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);
123     MPI_File_seek_shared(fh,2*sizeof(int),MPI_SEEK_SET);    //共享文件指针,偏移量是2个int
124     MPI_File_write_ordered(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);    //按序写入
125     MPI_File_close(&fh);
126 
127     MPI_Finalize();
128 }
129 */
  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 #include"mpi.h"
  5 
  6 #define BLOCK_LOW(rank,size,n)    ((rank)*(n)/(size))
  7 #define BLOCK_HIGH(rank,size,n)    (BLOCK_LOW((rank)+1,size,n)-1)
  8 #define BLOCK_SIZE(rank,size,n)    (BLOCK_HIGH(rank,size,n)-BLOCK_LOW(rank,size,n)+1)
  9 
 10 //并行IO:指定显式偏移的文件操作
 11 int main(int argc, char *argv[])
 12 {
 13     int size,rank,i;
 14     int n,m;
 15     float *array;
 16     MPI_File fh;
 17     MPI_Status status;
 18     MPI_Init(&argc,&argv);
 19     MPI_Comm_rank(MPI_COMM_WORLD,&rank);
 20     MPI_Comm_size(MPI_COMM_WORLD,&size);
 21 
 22     MPI_File_open(MPI_COMM_WORLD,"data",MPI_MODE_RDONLY,MPI_INFO_NULL,&fh);
 23     MPI_File_read_at_all(fh,0,&n,1,MPI_INT,&status);    //从偏移量0处读取
 24     MPI_File_read_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);    //从偏移量1个int处读取
 25     array=(float *)malloc(BLOCK_SIZE(rank,size,n)*m*sizeof(float));
 26     MPI_File_read_at_all(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);
 27     MPI_File_close(&fh);
 28 
 29     if(rank==0){
 30         printf("rank=%d: %d %d\n",rank,n,m);
 31         for(i=0;i<BLOCK_SIZE(rank,size,n)*m;i++){
 32             printf("% .0f",array[i]);
 33             if((i+1)%m==0)    putchar('\n');
 34         }
 35     }
 36 
 37     MPI_File_open(MPI_COMM_WORLD,"data2",MPI_MODE_CREATE|MPI_MODE_WRONLY,MPI_INFO_NULL,&fh);
 38     MPI_File_write_at_all(fh,0,&n,1,MPI_INT,&status);
 39     MPI_File_write_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);
 40     MPI_File_write_at_all(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);
 41     MPI_File_close(&fh);
 42 
 43     MPI_Finalize();
 44     return 0;
 45 }
 46  
 47 /*
 48 //并行IO:独立文件指针
 49 int main(int argc,char *argv[])
 50 {
 51     int size,rank,i;
 52     int n,m;
 53     float *array;
 54     MPI_File fh;
 55     MPI_Status status;
 56     MPI_Init(&argc,&argv);
 57     MPI_Comm_rank(MPI_COMM_WORLD,&rank);
 58     MPI_Comm_size(MPI_COMM_WORLD,&size);
 59 
 60     MPI_File_open(MPI_COMM_WORLD,"data",MPI_MODE_RDONLY,MPI_INFO_NULL,&fh);
 61     MPI_File_set_view(fh,0,MPI_INT,MPI_INT,"internal",MPI_INFO_NULL);    //设置绝对偏移量为0
 62     MPI_File_read_all(fh,&n,1,MPI_INT,&status);    //读取后偏移量自动加1
 63     MPI_File_read_all(fh,&m,1,MPI_INT,&status);
 64     array=(float *)malloc(BLOCK_SIZE(rank,size,n)*m*sizeof(float));
 65     MPI_File_set_view(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),MPI_FLOAT,MPI_FLOAT,"internal",MPI_INFO_NULL);//重置偏移量
 66     MPI_File_read_all(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_INT,&status);
 67     MPI_File_close(&fh);
 68 
 69     if(rank==0){
 70         printf("rank=%d: %d %d\n",rank,n,m);
 71         for(i=0;i<BLOCK_SIZE(rank,size,n)*m;i++){
 72             printf("% .0f",array[i]);
 73             if((i+1)%m==0)    putchar('\n');
 75         }
 76     }
 77     
 78     MPI_File_open(MPI_COMM_WORLD,"data2",MPI_MODE_CREATE|MPI_MODE_WRONLY,MPI_INFO_NULL,&fh);
 79     MPI_File_set_view(fh,0,MPI_INT,MPI_INT,"internal",MPI_INFO_NULL);
 80     MPI_File_write_all(fh,&n,1,MPI_INT,&status);
 81     MPI_File_write_all(fh,&m,1,MPI_INT,&status);
 82     MPI_File_set_view(fh,2*sizeof(int)+BLOCK_LOW(rank,size,n)*m*sizeof(float),MPI_FLOAT,MPI_FLOAT,"internal",MPI_INFO_NULL); 
 83     MPI_File_write_all(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);
 84     MPI_File_close(&fh);
 85 
 86     MPI_Finalize();
 87 }
 88 */
 89 
 90 /*
 91 //并行IO:共享文件指针
 92 int main(int argc,char *argv[])
 93 {
 94     int size,rank,i;
 95     int n,m;
 96     float *array;
 97     MPI_File fh;
 98     MPI_Status status;
 99     MPI_Init(&argc,&argv);
100     MPI_Comm_rank(MPI_COMM_WORLD,&rank);
101     MPI_Comm_size(MPI_COMM_WORLD,&size);
102 
103     MPI_File_open(MPI_COMM_WORLD,"data",MPI_MODE_RDONLY,MPI_INFO_NULL,&fh);
104     MPI_File_read_at_all(fh,0,&n,1,MPI_INT,&status);    //指定显式偏移的读取
105     MPI_File_read_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);
106     array=(float *)malloc(BLOCK_SIZE(rank,size,n)*m*sizeof(float));
107     MPI_File_seek_shared(fh,2*sizeof(int),MPI_SEEK_SET);    //共享文件指针,偏移量是2个int
108     MPI_File_read_ordered(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);    //按序读取
109     MPI_File_close(&fh);
110 
111     if(rank==0){
112         printf("rank=%d: %d %d\n",rank,n,m);
113         for(i=0;i<BLOCK_SIZE(rank,size,n)*m;i++){
114             printf("% .0f",array[i]);
115             if((i+1)%m==0)    putchar('\n');
117         }
118     }
119  
120     MPI_File_open(MPI_COMM_WORLD,"data2",MPI_MODE_CREATE|MPI_MODE_WRONLY,MPI_INFO_NULL,&fh);
121     MPI_File_write_at_all(fh,0,&n,1,MPI_INT,&status);    //指定显式偏移的写入
122     MPI_File_write_at_all(fh,sizeof(int),&m,1,MPI_INT,&status);
123     MPI_File_seek_shared(fh,2*sizeof(int),MPI_SEEK_SET);    //共享文件指针,偏移量是2个int
124     MPI_File_write_ordered(fh,array,BLOCK_SIZE(rank,size,n)*m,MPI_FLOAT,&status);    //按序写入
125     MPI_File_close(&fh);
126 
127     MPI_Finalize();
128 }
129 */

3.二. 操作二进制文件

  • 以贰进制的方法张开文件读取文件中的数据【文本文件也足以依据贰进制文件的办法读取】

# 按照二进制的方式读取文件,mode可以设置为rb两个选项配合
f = open("d:/test.txt", "rb")

# 读取文件数据
content = f.read()

# 使用文件中的数据
print(content)

# 操作完毕,记得关闭文件哦
f.close()

# 执行结果如下:
~b'\xd5\xe2\xca\xc7Python\xb3\xcc\xd0\xf2\xd0\xb4\xc8\xeb\xce\xc4\xbc\xfe\xb5\xc4\xca\xfd\xbe\xdd\xd5\xe2\xca\xc7\xd0\xc2\xb5\xc4\xc4\xda\xc8\xdd'
  • 以二进制的秘籍,向文件中写入数据

# 定义要写入文件中的内容
s = "这是python按照二进制写入的数据"

# 按照二进制的方式打开文件追加内容,mode可以设置为ab两个选项配合
f = open("d:/test.txt", "ab")

# 向文件中写入数据
f.write(bytes(s, encoding="utf-8"))

# 使用文件中的数据
print(content)

# 操作完毕,记得关闭文件哦
f.close()

bytes(str,
encoding=””)那是二个将字符串转换到字节数组的函数,写入落成后翻看文件内容如下:

革命部分是写入的2进制数据

输入输出流扩张:当我们先河操作文件的历程中,不可防止的出于文件是或不是存在,文件内部存款和储蓄器是还是不是可写等等为让程序出现非凡处境,所以大家要对文件操作进行卓殊处理,常规的处理格局有二种,如下:

  • try-except-finally处理情势
  • with语句处理情势
    第三种格局:try-except-finally包涵,完毕文件操作进度

try:
   f = open("d:/test.txt", "+")
   f.write("写入文件中的内容")
   f.flush()

 

 

4. python中对内部存款和储蓄器IO

python程序对数码的输入输出,不必然都以针对性文件的,也得以是指向内部存款和储蓄器的处理
常规状态下,python提供了StringIOBytesIO四个内置类来拓展内存中数据的拍卖
留神:要求引进python中的io模块

  • StringIO:在内存中读写字符串的内置类
  • BytesIO:在内部存款和储蓄器中读写2进制数据的内置类
 1 //将二进制数组文件转换为文本文件。要求二进制文件的内容:行数 列数 数组元素
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 
 5 typedef float type;
 6 
 7 int main()
 8 {
 9     int i,j;
10     int n,m;
11     type **array;
12     FILE *fp;
13     fp=fopen("data","rb");
14     fread(&n,sizeof(int),1,fp);
15     fread(&m,sizeof(int),1,fp);
16 
17     array=(type **)malloc(n*sizeof(type *));
18     *array=(type *)malloc(n*m*sizeof(type));
19     for(i=1;i<n;i++)    array[i]=array[i-1]+m;
20 
21     fread(&array[0][0],n*m*sizeof(type),1,fp);  //注意不能是地址 array
22     fclose(fp);
23 
24     fp=fopen("data.txt","w");
25     fprintf(fp," %d %d\n",n,m);
26     for(i=0;i<n;i++){
27         for(j=0;j<m;j++)
28             fprintf(fp,"% f ",array[i][j]);
29         putc('\n',fp);
30     }
31     fprintf(stdout,"Successfully!\n");
32 }
 1 //将二进制数组文件转换为文本文件。要求二进制文件的内容:行数 列数 数组元素
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 
 5 typedef float type;
 6 
 7 int main()
 8 {
 9     int i,j;
10     int n,m;
11     type **array;
12     FILE *fp;
13     fp=fopen("data","rb");
14     fread(&n,sizeof(int),1,fp);
15     fread(&m,sizeof(int),1,fp);
16 
17     array=(type **)malloc(n*sizeof(type *));
18     *array=(type *)malloc(n*m*sizeof(type));
19     for(i=1;i<n;i++)    array[i]=array[i-1]+m;
20 
21     fread(&array[0][0],n*m*sizeof(type),1,fp);  //注意不能是地址 array
22     fclose(fp);
23 
24     fp=fopen("data.txt","w");
25     fprintf(fp," %d %d\n",n,m);
26     for(i=0;i<n;i++){
27         for(j=0;j<m;j++)
28             fprintf(fp,"% f ",array[i][j]);
29         putc('\n',fp);
30     }
31     fprintf(stdout,"Successfully!\n");
32 }

4.1 内部存款和储蓄器中读写字符串

  • 内部存储器中读写字符串
    健康状态下就是创制三个StringIO对象,然后遵照正规的文本读写的方法张开内容的读写就能够

# 引入需要的模块
from io import StringIO

# 创建StringIO对象
s = StringIO()

# 向内存中写入数据
s.write("保存在内存中的数据:用户名")
s.write("内容默认是追加的")

# 从内存中读取数据
content = s.getvalue()
print(content)

# 操作完成,适当的时刻关闭对象
s.close()
  • 内部存款和储蓄器中操作二进制数据:和StringIO基本1致

# 引入需要的模块
from io import BytesIO

# 定义要写入的数据,使用bytes()函数转换成二进制数据
s = "这是要写入的数据"
sc = bytes(s, encoding="utf-8")

# 创建BytesIO对象
b = BytesIO()

# 向内存中写入数据
b.write(sc)

# 从内存中读取数据
content = b.getvalue()
print(content)

# 操作完成,适当的时刻关闭对象
s.close()

# 执行结果
~b'\xe8\xbf\x99\xe6\x98\xaf\xe8\xa6\x81\xe4\xbf\x9d\xe5\xad\x98\xe7\x9a\x84\xe6\x95\xb0\xe6\x8d\xae'

 

 

伍. python中对目录/路线/文件夹的操作

本节内容具备的操作,其实都以和Computer交互的操作~操作计算机的内部存款和储蓄器、文件等等,python程序本人是做不了这个工作的,只是python在底层举行了和操作系统交互的成效封装,将操作系统能够实施的诸如创制文件、文件内容操作、内部存款和储蓄器操作等等封装成了函数

轻巧领会os模块,os模块重尽管对准操作系统的API的卷入

# 引入os模块
import os

# 查看操作系统类型
# nt表示windows操作系统;posix表示Unix/Linux或者MacOS系统
os.name
~ 执行结果:nt

# 查看操作系统中的环境变量
os.environ
~执行结果:environ({'ALLUSERSPROFILE': 'C:\\ProgramData', 'APPDATA': 'C:\\Users\\mouwe\\AppData\\Roaming',.................'CLASSPATH': 'D:\\resp_application\\Java\\jdk1.8.0_121\\lib;.;',})
 1 //将数组文本文件转换为二进制文件。要求文本文件的内容:行数 列数 数组元素
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 
 5 typedef float type;
 6 
 7 int main()
 8 {
 9     int i,j;
10     int n,m;
11     type **array;
12     FILE *fp;
13     fp=fopen("data.txt","r");
14     fscanf(fp,"%d",&n);
15     fscanf(fp,"%d",&m);
16 
17     array=(type **)malloc(n*sizeof(type *));
18     *array=(type *)malloc(n*m*sizeof(type));
19     for(i=1;i<n;i++)    array[i]=array[i-1]+m;
20 
21     for(i=0;i<n;i++)
22         for(j=0;j<m;j++)
23             fscanf(fp,"%f",&array[i][j]);
24     fclose(fp);
25 
26     fp=fopen("data","wb");
27     fwrite(&n,sizeof(int),1,fp);
28     fwrite(&m,sizeof(int),1,fp);
29     fwrite(&array[0][0],n*m*sizeof(type),1,fp);  //注意不能是地址 &array
30     fclose(fp);
31     fprintf(stdout,"Successfully!\n");
32 }
 1 //将数组文本文件转换为二进制文件。要求文本文件的内容:行数 列数 数组元素
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 
 5 typedef float type;
 6 
 7 int main()
 8 {
 9     int i,j;
10     int n,m;
11     type **array;
12     FILE *fp;
13     fp=fopen("data.txt","r");
14     fscanf(fp,"%d",&n);
15     fscanf(fp,"%d",&m);
16 
17     array=(type **)malloc(n*sizeof(type *));
18     *array=(type *)malloc(n*m*sizeof(type));
19     for(i=1;i<n;i++)    array[i]=array[i-1]+m;
20 
21     for(i=0;i<n;i++)
22         for(j=0;j<m;j++)
23             fscanf(fp,"%f",&array[i][j]);
24     fclose(fp);
25 
26     fp=fopen("data","wb");
27     fwrite(&n,sizeof(int),1,fp);
28     fwrite(&m,sizeof(int),1,fp);
29     fwrite(&array[0][0],n*m*sizeof(type),1,fp);  //注意不能是地址 &array
30     fclose(fp);
31     fprintf(stdout,"Successfully!\n");
32 }

5.一. 操作文件目录

# 查看当前操作系统的绝对路径
os.path.abspath(".")
~ 执行结果:D:\resp_work\PY_WORK\demo
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 创建指定单级目录
# 语法结构:os.mkdir(path, mode=, dir_fd=None)
# 描述:mkdir()函数用于使用指定的mode选项来创建一个文件夹目录
# 参数path:用于创建文件夹的路径
# 参数mode:用于设置的权限数字,默认777(所有权限:读写执行[rwx])
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 在d盘中创建一个目录,目录名称为test
os.mkdir("d:/test") 

# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 创建指定多级目录
# 语法结构:os.mkdirs(path, mode=, exist_ok=False)
# 描述:makedirs()函数用于使用指定的mode选项来创建一系列文件夹目录
# 参数path:用于创建文件夹的路径
# 参数mode:用于设置的权限数字,默认777(所有权限:读写执行[rwx])
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 在d盘中创建test文件夹,文件夹中包含test2文件夹,test2中包含test3文件夹
os.mkdirs("d:/test/test2/test3")

# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 重命名
# 语法结构:os.rename(old, new)
# 描述:rename()函数用于使用新名称重命名文件夹或者文件
# 参数old:要重命名的文件
# 参数new:文件的新名称
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
os.rename("d:/test", "d:/new")

# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 删除文件或者目录
# 语法结构:os.rmdir(path)
# 描述:rmdir()函数用于删除指定路径的文件夹或者文件
# 参数path:要删除的文件夹或者文件的路径
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
os.rm("d:/test")

# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 删除多级文件夹
# 语法结构:os.removedirs(path)
# 描述:removedirs(path)
# 参数path:要删除的多级文件夹路径
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
os.removedirs("d:/test/test2/test3")

# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 同样在进行文件夹或者文件删除的时候,首先要进行数据验证
# 也就是首先判断是文件夹/文件,才去执行删除操作
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# os.path.exists(path)函数用于判断指定的路径是否存在,存在返回True
res = os.path.exists("d:/test")

# os.path.isdir(path)函数用于判断指定的路径是否文件夹,是则返回True
res = os.path.isdir("d:/test")

# os.path.isfile(path)函数用于判断指定的路径是否文件,是则返回True
res = os.path.isfile("d:/test")

小说来源:http://www.jianshu.com/p/4001cbc518b7

 

 

  3个演示的文书文件数组data.txt:

  八个演示的公文文件数组data.txt:

  8 8
  1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000
1.000000
  2.000000 2.000000 2.000000 2.000000 2.000000 2.000000 2.000000
2.000000
  3.000000 3.000000 3.000000 3.000000 3.000000 3.000000 3.000000
3.000000
  4.000000 4.000000 4.000000 4.000000 4.000000 4.000000 4.000000
4.000000
  5.000000 5.000000 5.000000 5.000000 5.000000 5.000000 5.000000
5.000000
  6.000000 6.000000 6.000000 6.000000 6.000000 6.000000 6.000000
6.000000
  7.000000 7.000000 7.000000 7.000000 7.000000 7.000000 7.000000
7.000000
  8.000000 8.000000 8.000000 8.000000 8.000000 8.000000 8.000000
8.000000

  8 8
  1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000
1.000000
  2.000000 2.000000 2.000000 2.000000 2.000000 2.000000 2.000000
2.000000
  3.000000 3.000000 3.000000 3.000000 3.000000 3.000000 3.000000
3.000000
  4.000000 4.000000 4.000000 4.000000 4.000000 4.000000 4.000000
4.000000
  5.000000 5.000000 5.000000 5.000000 5.000000 5.000000 5.000000
5.000000
  6.000000 6.000000 6.000000 6.000000 6.000000 6.000000 6.000000
6.000000
  7.000000 7.000000 7.000000 7.000000 7.000000 7.000000 7.000000
7.000000
  8.000000 8.000000 8.000000 8.000000 8.000000 8.000000 8.000000
8.000000

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website