其实，刚拿到这个题目时，我真的没有思路，随后我就对着老师的课设指导书进行研究，对二级文件系统的演示这个课题的每个要求进行分析，总算是有了思路。下面给出我的分析。

文件系统演示

一、课程设计目的

使学生熟悉文件管理系统的设计方法；加深对所学各种文件操作的了解及其操作方法的特点。

//既然是基于控制台的，我们可以更改颜色玩玩

二、课程设计内容

设计一个简单的多用户文件系统。即 //和后面一样，用结构体数组实现

①在系统中用一个文件来模拟一个磁盘； //switch语句或者if-else语句实现，既然这里说到了 用一个文件去模拟一个磁盘，换句话说，在你的课设里，必须要有磁盘空间分配的思路在里面，不然就不是模拟磁盘了。

②此系统至少有：Create、delete、open、close、read、write等和部分文件属性的功能。

③实现这个文件系统。 //文件系统要实现

④能实际演示这个文件系统。//cmd演示即可

基本上是进入一个界面（此界面就是该文件系统的界面）后，可以实现设计的操作要求。


三、课程设计指导

1）设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件。 //三个数组的大小分别为 10、10、5

//一次运行用户最多可以打开5个文件如何实现？ 在用户文件里面加变量判断，用户每打开一个就+1，

//每次用户最多可保存10个文件如何实现？ 很明显，同时保存我们是无法做到的，无论是谁，都无法做到，也就是说还是一个个保存的，那么同样可以设置变量判断。如果保存的较多，那么只好请用户单独关闭某些指定的文件。


2）程序采用二级文件目录（即设置主目录MFD）和用户文件目录（UFD）。另外，为打开文件设置了运行文件目录（AFD）。 //存放各个用户目录的文件夹、用户目录

//是说运行的所有文件用一个目录层次表示吗

3）为了便于实现，对文件的读写作了简化，在执行读写命令时，只需改读写指针，并不进行实际的读写操作。 //整型的变量判断是否读写完成了 下面的pointer

4）因系统小，文件目录的检索使用了简单的线性搜索。 //链表的顺序查找

5）文件保护简单使用了三位保护码：允许读写执行、对应位为 1，对应位为0，则表示不允许读写、执行。 //标记变量即可实现

6）程序中使用的主要设计结构如下：主文件目录和用户文件目录（MFD、UFD），打开文件目录（AFD）即运行文件目录，如图5.1所示。//主要的结构体设计


还有MFD、UFD、AFD最好全部存到文件里面去，不然每次都要输入，十分麻烦，而且不能通过看文件 查看到自己的实验现象，着实不便。

参考的数据结构设计如下

struct TYPE_UFD //用户文件目录

{

string File_Name; //文件名

bool Read; //读保护码，true为可读

bool Write; //写保护码，true为可写

bool Execute; //执行保护码，true为可执行

int Length_File; //文件长度

}; //用户文件目录和用户打开的文件目录是不是都各有自己的属性

struct TYPE_MFD //主文件目录

{

string User_Name; //用户名

TYPE_UFD *Pointer; //用户文件目录指针

};

//很明显，第三个结构体没有指针域，但我们是需要指针域的，还有下面红色部分可以合在一个整型变量里面的

struct TYPE_AFD //打开文件目录

{

int File_ID; //打开的文件号

boolRead;//读保护码，true为可读

boolWrite;//写保护码，true为可写

boolExecute;//执行保护码，true为可执行

int Pointer; //读写指针

};

7）文件系统结构如图5.2所示

//很明显，这里要用到的数据结构是 链表
    

8）文件系统算法的流程图如图5.3所示。

                             

图5.3文件系统算法的流程图

//这里告诉了你 main函数的主要调用的函数顺序 

9）注意对于物理块的访问（包括访问指针，空闲位）需要经过输入输出，相当于通过定位对文件进行读写。打开文件目录（AFD）是在内存中，由打开文件时创建。

好了，分析完了，就要开始编写代码了，下面附上我小小的代码，还有很多需要修改的地方，做的不好的地方，大神就请原谅，也希望多多指点我。

先附上效果图：
                

头文件部分：
#include<cmath>
#include<ctime>
#include<string>
#include<conio.h>
#include<fstream>
#include<cstdlib>
#include<iostream>
#include<windows.h>
using namespace std;

typedef struct UFD
{
	string File_name;         //文件名
	int Start;                //文件在磁盘存储空间的起始地址
	int Protect;              //文件的属性
	int File_length;           //文件的长度
	int Max_File_length;         //文件的最大长度
	struct UFD *next;
}UFD,*UFD_ptr;

typedef struct MFD
{
	string User_name;
	string User_passwd;
	UFD *Ufd_next;
	int End;
	struct MFD *next;
}MFD,*MFD_ptr;

typedef struct AFD
{
	string File_name;
	int File_length;
	int Start;
	int Protect;
	int Pointer;    //根据这个指针的值去完成用户的要求  读写指针
	int Max_File_length;
	struct AFD *next;
}AFD,*AFD_ptr;
源文件部分：
#include"os_fss.h"

#define MaxDisk 512*1024   //一个扇区512字节,假设有1024个扇区,模拟磁盘的大小
int Max_User=10;
int Max_Open=5;
int Max_End=0;
UFD_ptr pufd=NULL;
MFD_ptr pmfd=NULL;
AFD_ptr pafd=NULL;
char User_name[30];   //存放当前用户的用户名
char flag='n';
char Disk_Size[MaxDisk];    //最后在打印输出的时候，用RWX表示即可

typedef struct Disk_Table
{
	int Max_length;      //最大长度
	int Start;          //开始位置
}Disk_Node;
Disk_Node Disk_Head;

void Init_Disk()
{
	Disk_Head.Max_length=MaxDisk;
	Disk_Head.Start=0;
}

bool Init_MFD()
{
	pmfd=(MFD *)new MFD;   //带头节点的单向链表
	MFD *p=pmfd;
	ifstream ifs("MFD.txt");  //文件的输入流对象
	if(!ifs)
	{
		cerr<<"错误：无法打开文件"<<endl;
		p->next=NULL;
		p->Ufd_next=NULL;
		return false;
	}
	while(!ifs.eof())
	{
		p->next=(MFD *)new MFD;
		ifs>>p->next->User_name>>p->next->User_passwd>>p->next->End;  
		if(p->next->End>Max_End)
			Max_End=p->next->End;
		p=p->next;
		p->Ufd_next=NULL;
		p->next=NULL;
	}
	ifs.close();
	return true;
}

void Print_UFD()
{
	UFD *p=pufd->next;  
	if(!p)
	{
		cout<<"抱歉,该用户没有创建任何文件,请先创建!!!"<<endl;
		return ;
	}
	cout<<"文件名\t\t最大文件长度\t文件权限\t起始位置\t文件长度"<<endl;
	while(p)
	{
		cout<<p->File_name<<"\t\t"<<p->Max_File_length;
		if(p->Protect==0)
			cout<<"\t\t"<<"---";
		else if(p->Protect==1)
			cout<<"\t\t"<<"r-x";
		else if(p->Protect==2)
			cout<<"\t\t"<<"rwx";
		cout<<"\t\t"<<p->Start;
		cout<<"\t\t"<<p->File_length<<endl;
		p=p->next;
	}
}

bool Init_UFD(char *name)
{
	ifstream ifs(name); 
	pufd=(UFD *)new UFD;
	UFD *p=pufd;
	char temp[MaxDisk];
	bool Index=false;
	if(!ifs)
	{
		cerr<<"错误：无法打开文件"<<endl;
		p->next=NULL;
		return false;
	}
	while(!ifs.eof())
	{
		memset(temp,'\0',sizeof(temp));
		p->next=(UFD *)new UFD;
		if(!Index)
		{	
			pmfd->Ufd_next=p->next;
			Index=true;
		}
		ifs>>p->next->File_name>>p->next->Max_File_length>>p->next->Protect>>p->next->Start>>p->next->File_length;
		ifs>>temp;
		if(temp[0]=='#')
			temp[0]='\0';
		for(int i=p->next->Start,j=1;j<=p->next->Max_File_length-1;i++,j++)
		{
			Disk_Size[i]=temp[j-1];
			if(!Disk_Size[i])
				break;
		}
		Disk_Head.Max_length-=p->next->Max_File_length;
	//	Disk_Head.Start+=p->next->Max_File_length;
		p=p->next;
		p->next=NULL;
	}
	ifs.close();	
	return true;
}

void Rename_File()
{
	string File_name;
	UFD *temp=pufd;
	char Index;
SD:
	cout<<"请输入文件的名字："<<endl;
	cin>>File_name;
	while(temp)
	{
		if(temp->File_name==File_name)
		{
			cout<<"请输入新的文件名："<<endl;
			cin>>File_name;
			temp->File_name=File_name;
			break;
		}
		temp=temp->next;
	}
	if(!temp)
	{
		cout<<"抱歉,输入的文件不存在,无法完成重命名文件操作,是否继续操作<y/n>?"<<endl;
		cin>>Index;
		if(Index=='y')
			goto SD;
		else
			return ;
	}
	else
		cout<<"修改成功!!!"<<endl;
}

bool User_Check()
{
	string User_passwd;
	int Count=0;
	while(1)
	{
		cout<<"请输入用户名：";
		cin>>User_name;
INIT:
		cout<<"请输入密码：";
		cin>>User_passwd;
		MFD *p=pmfd->next;
		char temp[30];
		memset(temp,'\0',sizeof(temp));
		strcpy(temp,User_name);
		Count++;
		while(p)
		{
			if(User_name==p->User_name)
			{
				if(User_passwd==p->User_passwd)
					cout<<"登入成功."<<endl;
				else
				{
					cout<<"抱歉,密码错误,登陆失败,请重新输入!!!"<<endl;
					if(Count==3)
					{
						cout<<"密码错误次数过多,系统运行结束!!!"<<endl;
						return false;
					}
					goto INIT;
				}
				strcat(temp,".txt"); 
				Init_UFD(temp);
	//			Print_UFD();
				Disk_Head.Start=Max_End;
				return true;
			}
			p=p->next;
		}
		cout<<"用户名不存在,请重新输入!!!"<<endl;
	}
//	return false;
}			

void Init_AFD()
{
	pafd=(AFD *)new AFD;
	pafd->next=NULL;
}

bool Create_MFD()//创建文件命令
{
	string User_name;
	char User_passwd[30];
	MFD *p = pmfd;
	cout<<"请输入要创建的用户名: ";
	cin>>User_name;
	cout<<"请输入"<<User_name<<"用户的密码：(默认为:admin)";
	getchar();
	cin.getline(User_passwd,30);
	if(User_passwd[0]=='\0')
		strcpy(User_passwd,"admin");
	while(p)
	{
		if(User_name==p->User_name)
		{
			cout<<"此用户名已存在!!!"<<endl;
			return false;
		}
		if(!p->next)
			break;
		p= p->next;
	}
	p->next = (MFD *)new MFD;  //尾插法
	p=p->next;
	p->User_name=User_name;
	p->User_passwd=User_passwd;
	p->End=0;
	p->next = NULL;
	p->Ufd_next = NULL;
	Max_User--;
	return true;
}  //应该是 不同的用户下的UFD文件名是不一样的啊，怎么出问题了

bool Create_UFD()//创建文件命令
{
	string File_name;
	UFD *p = pufd;
	unsigned int Protect;
	int Max_File_length;
//	AFD *pa = pafd;
	cout<<"请输入要创建的文件名: ";
	cin>>File_name;
	cout<<"请输入要创建的文件保护类型：";
	cin>>Protect;
	cout<<"请输入文件的最大容量："<<endl;
	cin>>Max_File_length;
	while(p)
	{
		if(File_name==p->File_name)
		{
			cout<<"此文件名已存在!!!"<<endl;
			return false;
		}
		if(!p->next)
			break;
		p= p->next;
	}
	p->next = (UFD *)new UFD;  //尾插法
	p=p->next;
	p->File_name=File_name;
	p->Max_File_length=Max_File_length;
	p->Start=Disk_Head.Start;
	p->Protect = Protect;
//	p->Time_info=      //暂定
	p->File_length = 0;     //刚创建文件时，文件是空的
	Disk_Head.Start+=Max_File_length;
	p->next = NULL;      //我觉得这部分代码有问题；用户创建了一个文件并不代表该文件就被打开了
	return true;
}

bool Delete_UFD()  //关于主目录的用户文件夹的文件删除-->先这样写，好吧    //如果文件已经打开了，是不能删除的
{
	string File_name;
	cout<<"请输入要删除的文件名：";
	cin>>File_name;
	UFD *p=pufd,*temp;
	AFD *pa=pafd;
	while(pa->next)
	{
		if(File_name==pa->next->File_name)
		{
			cout<<"抱歉,该文件已被打开,请先关闭,再进行删除操作!!!"<<endl;
			return false;
		}
	}
	while(p->next)
	{
		if(File_name==p->next->File_name)
		{
			temp=p->next;
			p->next=p->next->next;  //如果说要回收模拟的磁盘空间的话，应该是回收最大长度
		//	Disk_Head.Max_length+=temp->Max_File_length;    //链表中删除了，其他的文件内容的起始位置不变即可，又没事，还是照样可以访问数据的嘛
			delete temp;
			cout<<"文件删除成功!!!"<<endl;
			return true;
		}
		p=p->next;
	}
	cout<<"抱歉,要删除的文件不存在!!!"<<endl;
	return false;
}

bool Open()
{
    string File_name;
	unsigned int Protect;
	cout<<"请输入要打开的文件名：";
    cin>>File_name;
    UFD *p=pufd->next;
	AFD *pa=pafd->next;
	while(pa)
	{
		if(File_name==pa->File_name)
		{
			cout<<"文件"<<File_name<<"已经打开!!!"<<endl;
			return true;
		}
		if(!pa->next)
			break;
		pa=pa->next;
	}
	if(!pa)     //如果找不到，或者打开的文件目录链表为空表
		pa=pafd;
	while(p)
	{
        if(File_name==p->File_name)
		{
			if(!Max_Open)
			{
				cout<<"抱歉，最多只能打开5个文件,请先关闭其他打开的文件再操作!!!"<<endl;
				return false;
			}
			if(p->Protect==0)
			{
				cout<<"抱歉，此文件不可执行任何操作!!!"<<endl;
				return false;
			}
			cout<<"请选择以什么样的方式打开文件<1-只读,2-可读可写>：";
			cin>>Protect;
			pa->next=(AFD *)new AFD;
			pa=pa->next;
			pa->File_name=p->File_name;
			pa->Start=p->Start;
			pa->File_length=p->File_length;
			pa->Max_File_length=p->Max_File_length;
			pa->Protect=Protect;
			if(Protect==1)
				pa->Pointer=0;   //Poniter取0表示此时用户无法写数据(没有空间的含义)
			else
				pa->Pointer=p->File_length;
			pa->next=NULL;
			Max_Open--;
			cout<<"文件"<<File_name<<"已经打开!!!"<<endl;
			return true;
		}
		p=p->next;
	}
	cout<<"抱歉,要打开的文件不存在!!!"<<endl;
	return false;
}

void Close()
{
	string file_name;
	UFD *pu=pufd->next;
	cout<<"请输入要关闭的文件名：";
	cin>>file_name;
	AFD *p=pafd,*temp;
	while(p&&p->next)
	{
		if(file_name==p->next->File_name)
		{
			temp=p->next;
			p->next=p->next->next;
			if(temp->Protect==2)      //可写的文件才有权把新写入的数据也保存起来嘛
			{
				while(pu)
				{
					if(temp->File_name==pu->File_name)
					{
						pu->File_length=temp->Pointer;
						break;
					}
					pu=pu->next;
				}
			}
			delete temp;
			cout<<"文件"<<file_name<<"关闭成功!!!"<<endl;
			return ;
		}
		p=p->next;
	}
	cout<<"抱歉,要关闭的文件没有被打开!!!"<<endl;
}

bool Read_File()  //因为读写都是通过修改运行文件目录的Pointer去模拟的嘛
{
	string File_name;       //你要读文件的话，你这文件肯定得在运行/打开文件目录里面，是吧
	unsigned int length;
	AFD *p=pafd->next;
	cout<<"请输入要读的文件名：";
	cin>>File_name;
	cout<<"请输入要读取的长度：";  //读取的话，实际中文件的长度并不会改变
	cin>>length;          //即读取的长度并不能保存回去,为了方便（如果用户是读数据的话，pointer始终不变）
	while(p)
	{
		if(File_name==p->File_name)
		{
			for(int i=p->Start,j=1;j<=length;i++,j++)
				cout<<Disk_Size[i];
			cout<<endl;
			cout<<"文件"<<File_name<<"读取成功!!!"<<endl;
			return true;
		}
		p=p->next;
	}
	cout<<"读取失败,文件没有打开过!!!"<<endl;
	return false;
}

bool Write_File()  //写的话，自然是运行文件目录
{
	string File_name;
	unsigned int length;
	AFD *p=pafd->next;
	char temp[MaxDisk]={'\0'};
	cout<<"请输入要写的文件名：";
	cin>>File_name;
	while(p)
	{
		if(File_name==p->File_name)
		{
			if(p->Protect!=2)
			{
				cout<<"文件"<<File_name<<"不可写"<<endl;
				return false;
			}
			cout<<"请输入要写入的长度："<<endl;
			cin>>length;
			if(p->Pointer+length<=p->Max_File_length)
			{
				cout<<"请写入指定长度的内容：<以回车作为结束符>"<<endl;
				getchar();
				gets(temp);
				for(int i=p->Start+p->File_length,j=1;j<=strlen(temp);i++,j++)
					Disk_Size[i]=temp[j-1];
				p->Pointer += length;
				cout<<"文件"<<File_name<<"写入成功!!!"<<endl;
			}
			else
			{
				cout<<"欲写入的数据大小发生溢出,已超过文件的分配容量,写入失败!!!"<<endl;
				return false;
			}
			return true;
		}
		p=p->next;
	}
	cout<<"写入失败,文件没有打开过!!!"<<endl;
	return false;
}

void Destroy_Space()
{
	MFD *pm=pmfd;
	while(pm)
	{
		pmfd=pmfd->next;
		delete pm;
		pm=pmfd;
	}
	AFD *pa=pafd;
	while(pa)
	{
		pafd=pafd->next;
		delete pa;
		pa=pafd;
	}
	UFD *pu=pufd;
	while(pu)
	{
		pufd=pufd->next;
		delete pu;
		pu=pufd;
	}
}

void Save_MFD()
{
	ofstream ofs;        //文件的输出流对象
	ofs.open("MFD.txt");
	if(!ofs.is_open())
	{
		cout<<"The MFD can't open!!!"<<endl;
		if(flag=='y')
			cout<<"正在保存主目录用户名信息..."<<endl;
		else
			ofs.close();  //该语句待定
	}
	MFD *p=pmfd->next;
	while(p)
	{
		if(p->User_name==User_name)
			p->End=Disk_Head.Start;
		ofs<<p->User_name<<" "<<p->User_passwd<<" "<<p->End;
		if(p->next)
			ofs<<"\n";	
		p=p->next;
	}
	ofs.close();
}

void Save_UFD(char *name)
{
	ofstream ofs;        //文件的输出流对象
	char temp[MaxDisk]={'\0'};
	ofs.open(name);
	if(!ofs.is_open())
	{
		cout<<"The "<<name<<"文件 can't open!!!"<<endl;
		ofs.close();  //该语句待定，这语句真的用的很妙，因为我并没有马上退出这次函数调用了
	}
	UFD *p=pufd->next;
	while(p)
	{
		memset(temp,'\0',sizeof(temp));
		for(int i=p->Start,j=1;j<=p->Max_File_length;i++,j++)
		{
			if(Disk_Size[i])
				temp[j-1]=Disk_Size[i];
			else
				break;
		}
		if(!temp[0])        //如果文件没有数据的话，就用空格表示此文件没有任何内容
			temp[0]='#'; 
		ofs<<p->File_name<<" "<<p->Max_File_length<<" "<<p->Protect<<" "<<p->Start<<" "<<p->File_length<<" "<<temp;
		if(p->next)
			ofs<<"\n";
		p=p->next;
	}
	ofs.close();
}

void Quit_System()
{
	AFD *pa=pafd->next;
	UFD *pu=pufd->next;
	while(pa)
	{
		if(pa->Protect==2)  //2表示可写   //1表示只读  //0表示不可操作
		{
			while(pu)
			{
				if(pa->File_name==pu->File_name)
				{
					pu->File_length=pa->Pointer;
					break;
				}
				pu=pu->next;
			}
		}
		pa=pa->next;
	}
	char temp[30];
	strcpy(temp,User_name);
	strcat(temp,".txt");
	Save_MFD();
	Save_UFD(temp);
	Print_UFD();
	Destroy_Space();
}

void Print_Help()
{
	system("color 0b");
	cout<<"************************二级文件系统演示*************************"<<endl;
	cout<<"*\t\t命令			  说明			*"<<endl; 
	cout<<"*\t\tlogin			登录系统		*"<<endl; 
	cout<<"*\t\tcreate			创建文件		*"<<endl; 
	cout<<"*\t\tdelete			删除文件		*"<<endl; 
	cout<<"*\t\topen			打开文件		*"<<endl; 
	cout<<"*\t\tclose			关闭文件		*"<<endl; 
	cout<<"*\t\tread			读取文件		*"<<endl; 
	cout<<"*\t\twrite			写入文件		*"<<endl;
	cout<<"*\t\tls		        显示目录		*"<<endl;
	cout<<"*\t\trename			重命文件		*"<<endl;
	cout<<"*\t\thelp			帮助菜单		*"<<endl;
	cout<<"*\t\tcls 			清除屏幕		*"<<endl;
	cout<<"*\t\tlogout 			切换用户		*"<<endl;
	cout<<"*\t\tquit			退出系统		*"<<endl; 
	cout<<"*****************************************************************"<<endl; 
}

void System_Init()
{
Start:
	Print_Help();
	Init_Disk();
	if(!Init_MFD())
	{
		int num;
		cout<<"主目录还未创建，是否创建<y/n>!!!"<<endl;
		cin>>flag;
		cout<<"请输入欲创建的用户文件夹的个数(1-10)："<<endl;
		cin>>num;
		if(flag=='y')
		{
			while(num--)
			{
				Create_MFD();
				if(!Max_User)
				{	
					cout<<"本系统,最多支持10个用户,创建多余用户失败,请删除其他用户,再做尝试!!!"<<endl;
					return ;
				}
			}
			Save_MFD();
			cout<<"主目录已经创建完成,用户各自目录已得到保存,是否继续<y/n>!!!"<<endl;
			cin>>flag;
			if(flag=='y')
				goto Start;
		}
	}
	return ;
}


void File_System()
{
	while(1)
	{
		string Command;
		cout<<"请输入命令：";
		cin>>Command;
		if(Command=="create")
			Create_UFD();
		else if(Command=="delete")
			Delete_UFD();
		else if(Command=="open")
			Open();
		else if(Command=="close")
			Close();
		else if(Command=="read")
			Read_File();
		else if(Command=="write")
			Write_File();
		else if(Command=="quit")
		{ 
			Quit_System();
			break;
		}
		else if(Command=="ls")
			Print_UFD();
		else if(Command=="cls")
			system("cls");
		else if(Command=="login")
		{
			if(!User_Check())
				break;
			Init_AFD();
		}
		else if(Command=="rename")
			Rename_File();
		else if(Command=="logout")
		{
			cout<<"用户登出成功!!!"<<endl;
			Quit_System();
			System_Init();
			File_System();
		}
		else
			Print_Help();
	}
}

int main()   //我保存，我不能连我的指针域也保存啊，这是不对的吧
{
	System_Init();
	File_System();
	return 0;
}

目录

 

一、文件操作

1、文件操作流程

2、文件打开模式

3、文件循环

4、文件的修改

5、flush方法

6、whit语句

7、其它操作

二、文件夹 /

1、提要

2、判断路径或文件

3、路径名、文件名分割

4、工作目录及创建文件夹操作

5、删除文件夹、文件

6、重命名文件夹/文件

7、复制移动文件夹/文件

 

不要努力成为一个成功者，要努力成为一个有价值的人。

一、文件操作

1、文件操作流程

1.打开文件，得到文件句柄并赋值给一个变量

2.通过文件句柄对文件进行操作

3.关闭文件

2、文件打开模式

f = open("file_test","r",encoding = "utf-8")    #打开文件，“读模式”，只能读，得到文件句柄并赋值给一个变量
print(f.read())                     #读文件所有内容，读完之后文件光标跳到最后,文件大时慎用
f.close()

f1 = open("file_test","w",encoding="utf-8")     #写模式，会新建一个file_test文件，再往里写入
f1.write("-------------")
f1.close()

f2 = open("file_test","a",encoding="utf-8")     #追加模式，在原文件内容最后追加，无原文件则新建
f2.write("-------------")
f2.close()

f3  = open("file_test","r+",encoding="utf-8")    #读写模式，写在原文件内容最后追加，无原文件则新建
print(f3.readline())                  #按行读
print(f3.readline())
print(f3.readline())                  #打印前三行，这个时候光标移动到第三行位置
print(f3.tell())                    #打印光标位置
f3.write("--------------")               #但是写入还是文件内容最后写入
f3.close()

f4  = open("file_test","w+",encoding="utf-8")    #写读模式,，只要是“写在前”都会建一个新文件，在写入
f4.write("----------------------\n")
f4.write("----------------------\n")
f4.write("----------------------\n")
f4.seek(10)                       #光标移动到10的位置
f4.write("test4")                    #再写入会将原内容覆盖
f4.seek(0)                        #将光标移动到开头的位置
print(f4.read())
f4.close()
#输出
#----------ni hao -----
#----------------------
#----------------------

f5  = open("file_test","a+",encoding="utf-8")    #追加读模式，在原文件内容最后追加，无原文件新建
f5.write("----------------------\n")
f5.write("----------------------\n")
f5.write("----------------------\n")
f5.seek(10)                       #光标移动到10的位置
f5.write("test5")                    #再写入会在文件内容最后写入
f5.seek(0)
print(f5.read())
f5.close()

f6  = open("file_test","rb")                 #以二进制文件格式读这个文件
print(f6.readline())
print(f6.readline())
print(f6.readline())
f6.close()

f7  = open("file_test","ab")                 #以二进制文件格式追加这个文件
f7.write("-------------------\n".encode())       #encode 将str字符转换为bytes
f7.write("-------------------\n".encode())
f7.write("-------------------\n".encode())
f7.close()

f8  = open("file_test","wb")                 #以二进制文件格式写这个文件
f8.write("-------------------\n".encode())       #encode 将str字符转换为bytes
f8.write("-------------------\n".encode())
f8.write("-------------------\n".encode())
f8.close()


#注：还有rU或r+U模式，"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

3、文件循环

#按行循环，并且将第五行替换
f = open("file_test","r",encoding="utf-8")
count = 0
for line in f:
    count += 1
    if count == 5:
        print("----分割线----")
        continue
    print(line.strip())                           #strip是去除行首行尾的空格符和换行符
f.close()

#f.readlines()                                    #切记用f.readlines是先将文件转换为列表，如果文件太大时对内存消耗太大

4、文件的修改

#打开一个文件，修改完了写到一个新文件
f = open("file_test","r",encoding="utf-8")
f_new = open("file_new","w",encoding="utf-8")
for line in f:                               #按行取出，每行都是一串字符串
    if "fengxiaoli" in line:
        line = line.replace("fengxiaoli","FENGXIAOLI")       #对字符串进行操作,J
    f_new.write(line)
f.close()
f_new.close()

5、flush方法

f = open("file_test","w",encoding="utf-8")
f.write("hello\n")
f.write("hello\n")
f.write("hello\n")
f.flush()       #当往文件写内容的时候，会有一个缓存，达到一个时间，一次往文件写入。如果这时候断电可能内容并没有写入成功，flush刷新会立即执行

6、whit语句

#with语句作用，为了避免打开文件后忘记关闭

with open("file_test","r",encoding="utf-8") as f:          #类似于f = open("file_test","r",encoding="utf-8")

with open("file_test","r",encoding="utf-8") as f, \        #还可以同时打开多个文件
        open("file_test2","r",encoding="utf-8") as f2:


7、其它操作

f = open("file_test","r",encoding="utf-8")
print(f.tell())              #打印光标位置,按字符计数
print(f.readline())          #按行读
print(f.read(10))            #按字符读
print(f.tell())
f.seek(0)                   #把光标回到开头
f.seek(12)                  #把光标移动到12个字符的位置
print(f.readline())
print(f.encoding)           #打印文件编码

print(f.isatty())           #判断文件是否是终端设备，返回Ture or false
print(f.seekable())         #判断是否能移动文件光标，返回Ture or false
print(f.readable())         #判断文件是否可读
print(f.writable())         #判断文件是否可写


# f  = open("file_test","a",encoding="utf-8")
# f.truncate(12)      #从头开始截取多少字符

二、文件夹 /

           文件

1、提要

我们经常会与文件和目录打交道，对于这些操作，python可以使用 os 及 shutill 模块，其中包含了很多操作文件和目录的函数。

os 可以执行简单的文件夹及文件操作，引入用  import os，可用  help(os)  或是  dir(os)  查看其用法。注意有些函数在os模块中，有的是在os.path模块中。

shutil 模块提供了大量的文件的高级操作，特别针对文件拷贝和删除。主要功能为目录和文件操作以及压缩操作。须引入 import shutil  ，具体 help。本文仅介绍移动、复制及删除。

 

可先在 D:\ 下创建文件夹 Python_os ， 再在其下创建文件夹 os， 再在其下创建 test.txt；之后的示例会在该文件夹下操作



2、判断路径或文件

       os.path.isabs(...) 　　　　 # 判断是否绝对路径

　　　　os.path.exists(...)　　　　 # 判断是否真实存在

　　　　os.path.isdir(...)　　　　   # 判断是否是个目录

　　　　os.path.isfile(...)　　　　   # 判断是否是个文件

注意：   把两个路径合成一个时，不要直接拼字符串，而要通过 os.path.join(part1,part2) 函数，这样可以正确处理不同操作系统的路径分隔符。在Linux/Unix/Mac下，os.path.join()返回这样的字符串：    part1/part2，而Windows下会返回这样的字符串：  part1\part2

import os
import shutil

file_dir = "D:\\Python_os\\os"                          # 注意 \\ ；windows 下是这么表示的；Linux 和 Mac 是 /
file_name = "test.txt"
file_abs = os.path.join(file_dir, file_name)            # os.path.join(...) 表示路径链接


'''判断路径或文件'''
print (1,os.path.isabs(file_dir))        1. True               # 判断是否绝对路径
print (2,os.path.isabs(file_name))       2. False                 
print (3,os.path.isabs(file_abs))        3. True                
print (4,os.path.exists(file_abs))       4. True              # 判断是否真实存在
print (5,os.path.exists(os.path.join(file_dir,"xxx")))           5. False     
print (6,os.path.isdir(file_dir))        6. True               # 判断是否是个目录
print (7,os.path.isdir(file_abs))        7. False
print (8,os.path.isfile(file_dir))       8. False               # 判断是否是个文件
print (9,os.path.isfile(file_abs))       9. True

3、路径名、文件名分割

　　　　os.path.split(...)         　　 # 分隔目录和文件名/文件夹名         

　　　　os.path.splitdrive(...)        # 分隔盘符(windows系统)     

　　　　os.path.splitext(...)           # 分隔文件和扩展名

这些合并、拆分路径的函数并不要求目录和文件要真实存在，它们只对字符串进行操作。

4、工作目录及创建文件夹操作

　　　　os.getcwd() 　　　　  # 获取当前工作目录

　　　　os.chdir(...)　　　　   # 改变工作目录

　　　　os.listdir(...)　　　　  # 列出目录下的文件

　　　　os.mkdir(...)　　　　  # 创建单个目录    　　　　注意：创建多级用 os.makedirs()

　　　　os.makedirs(...)　　  # 创建多级目录

import os

file_dir = "D:\\Python_os\\os"    

print (os.getcwd())                                # 获取当前工作目录
os.chdir(file_dir)                                 # 改变工作目录
print (os.getcwd())    
print (os.listdir(file_dir))                       # 列出当前工作目录的所有文件 Python2 不支持 os.listdir()    Python3 会列出当前工作目录下的所有文件      
os.mkdir("test_mkdir")                             # 在当前工作目录下创建文件夹 test_mkdir；注意不可存在相同文件夹，不然会报错
os.makedirs("test_mkdir\\test1")
os.chdir(".\\test_mkdir")                          # . 表示本级目录； .. 表示上级目录
print (os.getcwd())    
for i in range(2,6):                               # 使用for循环等，可方便的创建多个文件夹
    dir_name = "test" + str(i)
    os.mkdir(dir_name)

在执行了上述实例代码后，os 文件夹中新建了空的 test_mkdir 文件夹，而 test_dir 文件夹下也新建出了 test1 至 test5 的空文件夹

创建文件夹可能会出错，原因具体有：(1) path 已存在时(不管是文件还是文件夹)  (2) 驱动器不存在  (3) 磁盘已满  (4) 磁盘是只读的或没有写权限

5、删除文件夹、文件

　　　　os.rmdir(...) 　　　　 　　    # 删除空文件夹  注意：必须为空文件夹  如需删除文件夹及其下 
                                                          所有文件，需用 shutil

　　　　os.remove(...)                   # 删除单一文件

　　　　shutil.rmtree(...)               # 删除文件夹及其下所有文件

在上方示例的文件夹基础上，操作删除 test1 文件夹 （空文件夹可用 os.rmdir() ），删除 test_mkdir 及其下所有文件（）；示例代码如下

import os
import shutil

file_dir = "D:\\Python_os\\os"                    

''' 删除文件/文件夹 '''
os.chdir(file_dir+"\\test_mkdir")                    
print(os.getcwd())                                    # 确保当前工作目录
print(os.listdir(os.getcwd()))                        # 查看当前文件夹下所有文件    
os.rmdir("test1")                                     # 删除 test1 文件夹（空文件夹）
print(os.listdir(os.getcwd()))    
os.chdir("..\\")
print(os.getcwd())                                    # 切换到上级目录
print(os.listdir(os.getcwd()))
shutil.rmtree("test_mkdir")                           # 删除 test_mkdir 及其下所有文件

可见运行结果如下；产生异常的可能原因:  (1) 路径不存在 (2) 路径子目录中有文件或下级子目录（os.rmdir） (3) 没有操作权限或只读



只是删除单一文件，则用   os.remove("test.txt")   即可；产生异常的可能原因:  (1) 文件不存在   (2) 对该文件没有操作权限或只读。

6、重命名文件夹/文件

可对某一文件或文件夹重命名   os.rename(oldfileName, newFilename)  

在os文件夹中新建文件夹 test，文件 test.txt

''' 重命名文件夹/文件 '''
os.chdir(file_dir)
print(os.listdir(os.getcwd()))
os.rename("test","test1")    
os.rename("test.txt","test1.txt")                # 重命名，注意需要带扩展名
print(os.listdir(os.getcwd()))

可见运行结果如下；产生异常的可能原因:  (1) oldfilename 旧文件名不存在（文件须带扩展名）   (2)newFilename 新文件已经存在



注意：新文件的扩展名不能遗漏，理论上需要保持类型一致；但这也不失为改文件类型的一种方式（相当于直接改文件的扩展名）

7、复制移动文件夹/文件

须使用 shutil 模块，引入 import shutil 

　　　　shutil.copyfile("old","new") 　　　　  # 复制文件，都只能是文件

　　　　shutil.copytree("old","new")　　　　 # 复制文件夹，都只能是目录，且new必须不存在

　　　　shutil.copy("old","new")　　　　       # 复制文件/文件夹，复制 old 为 new（new是文件， 
                                                若不存在，即新建），复制 old 为至 new 文件夹 
                                               （文件夹已存在）

　　　　shutil.move("old","new")  　　　　    # 移动文件/文件夹至 new 文件夹中

我们现在 D:\ 下创建新文件夹 Python_shutil ，然后工作目录切到该目录，直接使用 Python 来操作吧，参考代码如下：

import os
import shutil

os.chdir("D:\\")
os.mkdir("Python_shutil")
file_dir = "D:\\Python_shutil"
os.chdir(file_dir)

为演示复制、移动操作，我们在该文件夹下手动操作 新建文件夹 test_org、 test_copy 及 test_move； 新建文件 test.txt  test1.txt , 两者内容不同



Python 复制、移动的操作示例代码如下：

import os
import shutil

file_dir = "D:\\Python_shutil"
os.chdir(file_dir)
shutil.copyfile("test_org.txt","test_copy.txt")        # copy test_org.txt 为 test_copy.txt 若存在，则覆盖
shutil.copyfile("test_org.txt","test1.txt")            # 存在，覆盖
shutil.copytree("test_org","test_copytree")            # copy test_org 为 test_copytree（不存在的新目录）
shutil.copy("test_org.txt","test_copy1.txt")           # 同 copyfile
shutil.copy("test_org.txt","test_copy")                # 将文件 copy 至 目标文件夹中（须存在）
shutil.copy("test_org.txt","test_xxx")                 # 将文件 copy 至 目标文件（该文件可不存在，注意类型！）
print os.listdir(os.getcwd())
shutil.move("test_org.txt","test_move")                # 将文件 move 至 目标文件夹中
shutil.move("test_org","test_move")                    # 将文件夹 move 至 目标文件夹中
print os.listdir(os.getcwd())



 

不要努力成为一个成功者，要努力成为一个有价值的人。

情景：

例我现在有一级目录chaochao，

二级目录有text文件夹，

三级目录有music文件夹、photo文件夹、txt1.txt文件、txt2.txt文件

music文件夹下有music1.txt文件、music2.txt文件

photo文件夹下有photo1.txt文件、photo2.txt文件

如图：



需求：（当前我处于chaochao目录，ls 的结果只有 text文件夹）

压缩 text 文件夹下所有文件：


zip -r text.zip text


压缩 text 文件夹下除 txt1.txt 以外所有文件：


zip -r text.zip text -x='text/txt1.txt'


压缩 text 文件夹下除 music文件夹 与 txt1.txt 以外所有文件：


zip -r text.zip text -x='text/music/*' -x='text/txt1.txt'


 

注意：-r后第一个参数为压缩后的文件夹，第二个参数为想要压缩的文件夹。

           -x排除文件夹下所有文件时后面要加 *

           -x的路径是根据当前所在地址的相对路径

 

 

 

 

 

 

 

亲身试验出来的结果，可供大家参考：

例如：我的主域名是www.aabb.com（对应的是我公司官网页面），我需要解析一个新的二级域名join.aabb.com(用作添加公司招聘宣传页面所用)

一、先登录阿里云账户，到主域页面，然后选择你所需要解析的主域名，点击“解析”进入下一个页面：



二、进入域名解析页面，进行二级域名解析 。点击添加记录，跳出以下模态框，进行添加选择，并确定完成；



然后返回查看二级域名解析状态；

 三、新创建一个.htaccess文件，添加所需的二级目录文件指向：

可先暂时创建一个txt文档，添加下面的代码，进行内容修改，替换你所需要绑定的二级域名和二级目录，然后传到网站根目录下再将txt格式改成为后缀为.htaccess的文件。

（这里以之前的例子说明：主域名为www.aabb.com，解析的二级域名为join.aabb.com→即网站的前缀改变为join，我的二级目录文件夹为join，目录下面的首页为index.html）

#开启伪静态功能
RewriteEngine On

#绑定所需的二级域名
RewriteCond %{HTTP_HOST} ^(www.)?join.aabb.com$

#绑定需指向的二级目录
RewriteCond %{REQUEST_URI} !^/join/

#下面两行不动
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d

#改为要绑定的二级目录
RewriteRule ^(.*)$ /join/$1

#绑定二级域名
RewriteCond %{HTTP_HOST} ^(www.)?join.aabb.com$

# join二级目录 后面是首页文件demo.html,join.html, index.html,index.php……(根据你的实际情况而定)
RewriteRule ^(/)?$ join/index.html [L]



(注意：文件类型是.htaccess文件→把txt文件的后缀改掉就可以转换格式) 

四、把二级域名绑定的文件（这里是名为join的文件夹）和.htaccess上传到服务器的根目录下

（我这里是通过ftp的方式上传文件，上传到htcdocs文件夹下）



上传成功（红色框内是刚上传的二级目录join文件夹和.htaccess文件，这里其余的是主域名下的文件）

 五、最后在浏览器上输入二级域名，就可以访问到其对应的页面了。