精华内容
下载资源
问答
  • 我打开XML的方法是通过打开一个索引XML文件(Index)然后获得子XML文件的路径,然后在根据这些路径用循环的方式打开子XML文件获取里面的信息。但是,我的程序不知道为什么出错,当子XML是只有一个时,程序就可以...
  • 读文件内容 第二次循环文件指针为NULL 请问这是为什么? 代码大致如下 FILE* fIn = NULL; fIn = fopen (p_infilename, "rb"); if (fIn == NULL) { printf("\nError: Unable to open %s for input\n", p_...
  • 我打开XML的方法是通过打开一个索引XML文件(Index)然后获得子XML文件的路径,然后在根据这些路径用循环的方式打开子XML文件获取里面的信息。但是,我的程序不知道为什么出错,当子XML是只有一个时,程序就可以...
  • void main(int argc, char *argv[]) { FILE *fp; char str[100] = { 0 }; ...//使用for循环第一个打开正常 (fclose关闭时就关闭失败) 命令行的参数无误!请问这是为什么啊?表示不明白啊!
  • 我正在进行文本处理并使用“readline()”函数,如下所示:ifd = open(...)for line in ifd:...当条件变为false时,我需要倒带指针,以便“for”循环再次读取同一行。在在ifd.fseek公司()后面跟readline是给我一个...

    我正在进行文本处理并使用“readline()”函数,如下所示:ifd = open(...)

    for line in ifd:

    while (condition)

    do something...

    line = ifd.readline()

    condition = ....

    当条件变为false时,我需要倒带指针,以便“for”循环再次读取同一行。在

    在ifd.fseek公司()后面跟readline是给我一个'\n'字符。如何倒带指针,以便重新读取整行。在

    ^{pr2}$

    这是我的代码labtestnames = sorted(tmp)

    #Now read each line in the inFile and write into outFile

    ifd = open(inFile, "r")

    ofd = open(outFile, "w")

    #read the header

    header = ifd.readline() #Do nothing with this line. Skip

    #Write header into the output file

    nl = "mrn\tspecimen_id\tlab_number\tlogin_dt\tfluid"

    offset = len(nl.split("\t"))

    nl = nl + "\t" + "\t".join(labtestnames)

    ofd.write(nl+"\n")

    lenFields = len(nl.split("\t"))

    print "Reading the input file and converting into modified file for further processing (correlation analysis etc..)"

    prevTup = (0,0,0)

    rowComplete = 0

    k=0

    for line in ifd:

    k=k+1

    if (k==200): break

    items = line.rstrip("\n").split("\t")

    if((items[0] =='')):

    continue

    newline= list('' for i in range(lenFields))

    newline[0],newline[1],newline[3],newline[2],newline[4] = items[0], items[1], items[3], items[2], items[4]

    ltests = []

    ltvals = []

    while(cmp(prevTup, (items[0], items[1], items[3])) == 0): # If the same mrn, lab_number and specimen_id then fill the same row. else create a new row.

    ltests.append(items[6])

    ltvals.append(items[7])

    pos = ifd.tell()

    line = ifd.readline()

    prevTup = (items[0], items[1], items[3])

    items = line.rstrip("\n").split("\t")

    rowComplete = 1

    if (rowComplete == 1): #If the row is completed, prepare newline and write into outfile

    indices = [labtestnames.index(x) for x in ltests]

    j=0

    ifd.seek(pos)

    for i in indices:

    newline[i+offset] = ltvals[j]

    j=j+1

    if (rowComplete == 0): #

    currTup = (items[0], items[1], items[3])

    ltests = items[6]

    ltvals = items[7]

    pos = ifd.tell()

    line = ifd.readline()

    items = line.rstrip("\n").split("\t")

    newTup = (items[0], items[1], items[3])

    if(cmp(currTup, newTup) == 0):

    prevTup = currTup

    ifd.seek(pos)

    continue

    else:

    indices = labtestnames.index(ltests)

    newline[indices+offset] = ltvals

    ofd.write(newline+"\n")

    展开全文
  • 我这里用的是CFile的getposition和getlength,它和CArchive对象操作的文件指针是一个指针么?还是这样并不能获得CArchive在文件内读写时的指针呢?如果是一个指针,为什么只能循环一次呢? 还有就是hi,上面我在最后...
  • 一次性读入正确版本,循环读取文件文件操作的其他方法读相关操作1、readline:一次读一行2、readlines:读取所有行写相关操作writelinesflush:了解的方法控制文件指针的移动移动单位,模式示范作业 每日测验(默写上...

    每日测验(默写上节课课堂代码)

    1、注册功能
        用户输入账号密码,按照"egon:18"的格式存入文件
    2、基于上述注册信息,完成验证功能
        即用户验证的账号密码来源于文件
        验证成功打印login sucessful
        验证错误输出账号or密码错误
    
    3、编写文本文件copy程序
        with open(r'源文件',mode='rt',encoding='utf-8') as f1,\
            open(r'目标文件',mode='wt',encoding='utf-8') as f2:
    
            # data=f1.read()
            # f2.write(data)
    
            for line in f1:
                f2.write(line)
    

    昨日内容回顾

    1、什么是文件
        用户/应用程序(f=open(),获得文件对象/文件句柄)
        操作系统(文件)
        计算机硬件(硬盘)
    2、为何要用文件
        用于应用程序操作硬盘,永久保存数据,或者从硬盘读数据
    
    3、如何用
        f=open(r'C:\new_dir\a.txt',mode='r+t',encoding='gbk')
        res=f.read() # 读出硬盘的二进制(gbk)->t控制将二进制转换unicode->字符
        print(res)
        # f.write()
        f.close()
        print(f)
        f.read() # 抛出异常
    
        with open(...) as f,open(...) as f1:
            code1
            code2
            code3
    

    今日内容概要

    1、文件模式
        x模式(控制文件操作的模式)-》了解
            x, 只写模式【不可读;不存在则创建,存在则报错】
    
        b模式补充(控制文件读写内容的模式)
                bytes类型转换
                    x=10 # int(10)
                    '你'.encode('gbk') # bytes()
    
    2、文件的操作的其他方法
    
    3、文件的高级操作:控制文件指针的移动
    

    今日内容详细

    x模式

    x模式(控制文件操作的模式)-》了解
    x, 只写模式【不可读;不存在则创建,存在则报错】

    
    with open('a.txt', mode='x', encoding='utf-8') as f:
        pass
    
    with open('c.txt', mode='x', encoding='utf-8') as f:
        f.read()
    
    with open('d.txt', mode='x', encoding='utf-8') as f:
        f.write('哈哈哈\n')
    
    

    b模式

    控制文件读写内容的模式

    t:
    	1、读写都是以字符串(unicode)为单位
    	2、只能针对文本文件
    	3、必须指定字符编码,即必须指定encoding参数
    b:binary模式
    	1、读写都是以bytes为单位
    	2、可以针对所有文件
    	3、一定不能指定字符编码,即一定不能指定encoding参数
    
    总结:
    1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节,b模式则需要手动编码与解码,所以此时t模式更为方便
    2、针对非文本文件(如图片、视频、音频等)只能使用b模式
    

    错误演示:t模式只能读文本文件

    
    with open(r'爱nmlgb的爱情.mp4', mode='rt') as f:
        f.read()  # 硬盘的二进制读入内存-》t模式会将读入内存的内容进行decode解码操作
    

    b模式演示

    with open(r'test.jpg', mode='rb', encoding='utf-8') as f:
        res = f.read()  # 硬盘的二进制读入内存—>b模式下,不做任何转换,直接读入内存
        print(res)  # bytes类型
        print(type(res))
    
    with open(r'd.txt', mode='rb') as f:
        res = f.read()  # utf-8的二进制
        print(res, type(res))
    
        print(res.decode('utf-8'))
    
    
    with open(r'd.txt', mode='rt', encoding='utf-8') as f:
        res = f.read()  # utf-8的二进制->unicode
        print(res)
    
    
    with open(r'e.txt', mode='wb') as f:
        f.write('你好hello'.encode('gbk'))
    
    with open(r'f.txt', mode='wb') as f:
        f.write('你好hello'.encode('utf-8'))
        f.write('哈哈哈'.encode('gbk'))
    
    

    文件拷贝工具(b模式的运用)

    反面教材版,一次性读入

    src_file = input('源文件路径>>: ').strip()
    dst_file = input('源文件路径>>: ').strip()
    with open(r'{}'.format(src_file), mode='rb') as f1,\
            open(r'{}'.format(dst_file), mode='wb') as f2:
        # res=f1.read() # 内存占用过大
        # f2.write(res)
    
        for line in f1:
            f2.write(line)
    

    正确版本,循环读取文件

    方式一:自己控制每次读取的数据的数据量
    with open(r'test.jpg', mode='rb') as f:
        while True:
            res = f.read(1024)  
            if len(res) == 0:
                break
            print(len(res))
    
    
    方式二:以行为单位读,当一行内容过长时会导致一次性读入内容的数据量过大
    with open(r'g.txt', mode='rt', encoding='utf-8') as f:
        for line in f:
            print(len(line), line)
    
    with open(r'g.txt', mode='rb') as f:
        for line in f:
            print(line)
    
    with open(r'test.jpg', mode='rb') as f:
        for line in f:
            print(line)
    

    文件操作的其他方法

    读相关操作

    1、readline:一次读一行

    with open(r'g.txt', mode='rt', encoding='utf-8') as f:
        # res1=f.readline()
        # res2=f.readline()
        # print(res2)
    
        while True:
            line = f.readline()
            if len(line) == 0:
                break
            print(line)
    

    2、readlines:读取所有行

    with open(r'g.txt', mode='rt', encoding='utf-8') as f:
        res = f.readlines()
        print(res)	
    
    强调:
    f.read()与f.readlines()都是将内容一次性读入内存,如果内容过大会导致内存溢出,若还想将内容全读入内存,
    

    写相关操作

    writelines

    方法用于向文件中写入一序列的字符串。
    这一序列字符串可以是由迭代对象产生的,如一个字符串列表。
    换行需要制定换行符 \n。
    
    with open('h.txt', mode='wt', encoding='utf-8') as f:
        # f.write('1111\n222\n3333\n')
    
        # l=['11111\n','2222','3333',4444]
        l = ['11111\n', '2222', '3333']
        # for line in l:
        #     f.write(line)
        f.writelines(l)
    
    with open('h.txt', mode='wb') as f:
        # l = [
        #     '1111aaa1\n'.encode('utf-8'),
        #     '222bb2'.encode('utf-8'),
        #     '33eee33'.encode('utf-8')
        # ]
    
        # 补充1:如果是纯英文字符,可以直接加前缀b得到bytes类型
        # l = [
        #     b'1111aaa1\n',
        #     b'222bb2',
        #     b'33eee33'
        # ]
    
        # 补充2:'上'.encode('utf-8') 等同于bytes('上',encoding='utf-8')
        l = [
            bytes('上啊', encoding='utf-8'),
            bytes('冲呀', encoding='utf-8'),
            bytes('小垃圾们', encoding='utf-8'),
        ]
        f.writelines(l)
    

    flush:

    用来刷新缓冲区的,即将缓冲区中的数据立刻写入文件,同时清空缓冲区,不需要是被动的等待输出缓冲区写入。
    
    一般情况下,文件关闭后会自动刷新缓冲区,但有时你需要在关闭前刷新它,这时就可以使用 flush() 方法。
    
    with open('h.txt', mode='wt', encoding='utf-8') as f:
        f.write('哈')
        f.flush()
    
    

    了解的方法

    with open('h.txt', mode='wt', encoding='utf-8') as f:
        print(f.readable()) # False
        print(f.writable()) # True
        print(f.encoding) # utf-8
        print(f.name) # h.txt
    
    print(f.closed) # True
    

    控制文件指针的移动

    移动单位,模式

    指针移动的单位都是以bytes/字节为单位
    只有一种情况特殊:
    t模式下的read(n), n代表的是字符个数
    
    with open('aaa.txt', mode='rt', encoding='utf-8') as f:
        res = f.read(4)
        print(res)
    
    f.seek(n, 模式): n指的是移动的字节个数
    模式:
    模式0:参照物是文件开头位置
    f.seek(9, 0)
    f.seek(3, 0)  # 3
    
    模式1:参照物是当前指针所在位置
    f.seek(9, 1)
    f.seek(3, 1)  # 12
    
    模式2:参照物是文件末尾位置,应该倒着移动
    f.seek(-9, 2)  # 3
    f.seek(-3, 2)  # 9
    
    强调:只有0模式可以在t下使用,1、2必须在b模式下用
    
    f.tell()  # 获取文件指针当前位置
    

    示范

    with open('aaa.txt', mode='rb') as f:
        f.seek(9, 0)
        f.seek(3, 0)  # 3
        # print(f.tell())
        f.seek(4, 0)
        res = f.read()
        print(res.decode('utf-8'))
    
    
    with open('aaa.txt', mode='rb') as f:
        f.seek(9, 1)
        f.seek(3, 1)  # 12
        print(f.tell())
    
    
    with open('aaa.txt', mode='rb') as f:
        f.seek(-9, 2)
        # print(f.tell())
        f.seek(-3, 2)
        # print(f.tell())
        print(f.read().decode('utf-8'))
    
    

    作业

    1、通用文件copy工具实现
    
    2、基于seek控制指针移动,测试r+、w+、a+模式下的读写内容
    
    3、tail -f access.log程序实现
    
    4、周末作业参考在老师讲解完毕后(下午17:30开始讲解),练习熟练,明早日考就靠他俩
      4.1:编写用户登录接口
      4.2:编写程序实现用户注册后(注册到文件中),可以登录(登录信息来自于文件)
    
    展开全文
  • 智能指针在 标头文件的 std 命名空间中定义。 它们对 RAII 或 获取资源即初始化 编程惯用法至关重要。 RAII 的主要原则是为所有堆分配资源提供所有权,例如动态分配内存或系统对象句柄、析构函数包含要删除或释放...
  • c++智能指针介绍 由于 C++ 语言没有自动内存回收机制,程序员每次 new 出来的内存都要手动 delete,比如流程太复杂,最终导致没有 delete,异常导致程序过早退出,没有... 智能指针在 标头文件的 std 命名空间中

    c++智能指针介绍

    由于 C++ 语言没有自动内存回收机制,程序员每次 new 出来的内存都要手动 delete,比如流程太复杂,最终导致没有 delete,异常导致程序过早退出,没有执行 delete 的情况并不罕见,并造成内存泄露。如此c++引入 智能指针 ,智能指针即是C++ RAII的一种应用,可用于动态资源管理,资源即对象的管理策略。 智能指针在 <memory>标头文件的 std 命名空间中定义。 它们对 RAII 或 获取资源即初始化 编程惯用法至关重要。 RAII 的主要原则是为所有堆分配资源提供所有权,例如动态分配内存或系统对象句柄、析构函数包含要删除或释放资源的代码的堆栈分配对象,以及任何相关清理代码。

    c++智能指针类别

    c++ 智能指针主要包括:unique_ptr,shared_ptr, weak_ptr, 这三种,其中auto_ptr 已被遗弃。 

    unique_ptr 
    只允许基础指针的一个所有者。 可以移到新所有者(具有移动语义),但不会复制或共享(即我们无法得到指向同一个对象的两个unique_ptr)。 替换已弃用的 auto_ptr。 相较于 boost::scoped_ptr。 unique_ptr 小巧高效;大小等同于一个指针,支持 rvalue 引用,从而可实现快速插入和对 STL 集合的检索。 头文件:<memory>。

    使用unique_ptr,可以实现以下功能:

    1、为动态申请的内存提供异常安全。 
    2、将动态申请内存的所有权传递给某个函数。 
    3、从某个函数返回动态申请内存的所有权。

    4、在容器中保存指针。 
    5、所有auto_ptr应该具有的(但无法在C++ 03中实现的)功能。 

    如下代码所示:

    class A;
    // 如果程序执行过程中抛出了异常,unique_ptr就会释放它所指向的对象
    // 传统的new 则不行
    unique_ptr<A> fun1()
    {
    	unique_ptr p(new A);
    	//do something
    	return p;
    }
    
    void fun2()
    {   //  unique_ptr具有移动语义
    	unique_ptr<A> p = f();// 使用移动构造函数
    	// do something
    }// 在函数退出的时候,p以及它所指向的对象都被删除释放
     shared_ptr 
    采用引用计数的智能指针。 shared_ptr基于“引用计数”模型实现,多个shared_ptr可指向同一个动态对象,并维护了一个共享的引用计数器,记录了引用同一对象的shared_ptr实例的数量。当最后一个指向动态对象的shared_ptr销毁时,会自动销毁其所指对象(通过delete操作符)。shared_ptr的默认能力是管理动态内存,但支持自定义的Deleter以实现个性化的资源释放动作。头文件:<memory>。 

    基本操作:shared_ptr的创建、拷贝、绑定对象的变更(reset)、shared_ptr的销毁(手动赋值为nullptr或离开作用域)、指定deleter等操作。

     shared_ptr的创建,有两种方式,一,使用函数make_shared(会根据传递的参数调用动态对象的构造函数);二,使用构造函数(可从原生指针、unique_ptr、另一个shared_ptr创建) 

    shared_ptr<int> p1 = make_shared<int>(1);// 通过make_shared函数
        shared_ptr<int> p2(new int(2));// 通过原生指针构造
    此外智能指针若为“空“,即不指向任何对象,则为false,否则为true,可作为条件判断。可以通过两种方式指定deleter,一是构造shared_ptr时,二是使用reset方法时。可以重载的operator->, operator *,以及其他辅助操作如unique()、use_count(), get()等成员方法。 

     weak_ptr 
    结合 shared_ptr 使用的特例智能指针。 weak_ptr 提供对一个或多个 shared_ptr 实例所属对象的访问,但是,不参与引用计数。 如果您想要观察对象但不需要其保持活动状态,请使用该实例。 在某些情况下需要断开 shared_ptr 实例间的循环引用。 头文件:<memory>。 

    weak_ptr的用法如下:

    weak_ptr用于配合shared_ptr使用,并不影响动态对象的生命周期,即其存在与否并不影响对象的引用计数器。weak_ptr并没有重载operator->和operator *操作符,因此不可直接通过weak_ptr使用对象。提供了expired()与lock()成员函数,前者用于判断weak_ptr指向的对象是否已被销毁,后者返回其所指对象的shared_ptr智能指针(对象销毁时返回”空“shared_ptr)。循环引用的场景:如二叉树中父节点与子节点的循环引用,容器与元素之间的循环引用等。 

    智能指针的循环引用

    循环引用问题可以参考 这个链接 上的问题理解,“循环引用”简单来说就是:两个对象互相使用一个shared_ptr成员变量指向对方的会造成循环引用。导致引用计数失效。下面给段代码来说明循环引用:

    #include <iostream>
    #include <memory>
    using namespace std;
    
    class B;
    class A
    {
    public:// 为了省去一些步骤这里 数据成员也声明为public
    	//weak_ptr<B> pb;
    	shared_ptr<B> pb;
    	void doSomthing()
    	{
    //		if(pb.lock())
    //		{
    //
    //		}
    	}
    
    	~A()
    	{
    		cout << "kill A\n";
    	}
    };
    
    class B
    {
    public:
    	//weak_ptr<A> pa;
    	shared_ptr<A> pa;
    	~B()
    	{
    		cout <<"kill B\n";
    	}
    };
    
    int main(int argc, char** argv)
    {
    	shared_ptr<A> sa(new A());
    	shared_ptr<B> sb(new B());
    	if(sa && sb)
    	{
    		sa->pb=sb;
    		sb->pa=sa;
    	}
    	cout<<"sa use count:"<<sa.use_count()<<endl;
    	return 0;
    }
    上面的代码运行结果为:sa use count:2, 注意此时sa,sb都没有释放,产生了内存泄露问题!!!

    即A内部有指向B,B内部有指向A,这样对于A,B必定是在A析构后B才析构,对于B,A必定是在B析构后才析构A,这就是循环引用问题,违反常规,导致内存泄露。

    一般来讲,解除这种循环引用有下面有三种可行的方法( 参考 ): 
    1 . 当只剩下最后一个引用的时候需要手动打破循环引用释放对象。 
    2 . 当A的生存期超过B的生存期的时候,B改为使用一个普通指针指向A。 
    3 . 使用弱引用的智能指针打破这种循环引用。 
    虽然这三种方法都可行,但方法1和方法2都需要程序员手动控制,麻烦且容易出错。我们一般使用第三种方法:弱引用的智能指针weak_ptr。 

    强引用和弱引用 
    一个强引用当被引用的对象活着的话,这个引用也存在(就是说,当至少有一个强引用,那么这个对象就不能被释放)。share_ptr就是强引用。相对而言,弱引用当引用的对象活着的时候不一定存在。仅仅是当它存在的时候的一个引用。弱引用并不修改该对象的引用计数,这意味这弱引用它并不对对象的内存进行管理,在功能上类似于普通指针,然而一个比较大的区别是,弱引用能检测到所管理的对象是否已经被释放,从而避免访问非法内存。 

    使用weak_ptr来打破循环引用 

    代码如下:

    #include <iostream>
    #include <memory>
    using namespace std;
    
    class B;
    class A
    {
    public:// 为了省去一些步骤这里 数据成员也声明为public
    	weak_ptr<B> pb;
    	//shared_ptr<B> pb;
    	void doSomthing()
    	{
    		if(pb.lock())
    		{
    
    		}
    	}
    
    	~A()
    	{
    		cout << "kill A\n";
    	}
    };
    
    class B
    {
    public:
    	//weak_ptr<A> pa;
    	shared_ptr<A> pa;
    	~B()
    	{
    		cout <<"kill B\n";
    	}
    };
    
    int main(int argc, char** argv)
    {
    	shared_ptr<A> sa(new A());
    	shared_ptr<B> sb(new B());
    	if(sa && sb)
    	{
    		sa->pb=sb;
    		sb->pa=sa;
    	}
    	cout<<"sb use count:"<<sb.use_count()<<endl;
    	return 0;
    }

    参考:

    http://msdn.microsoft.com/zh-cn/library/hh279674.aspx

    http://www.dewen.org/q/8560/%E5%85%B3%E4%BA%8E%E9%81%BF%E5%85%8D%E5%BE%AA%E7%8E%AF%E5%BC%95%E7%94%A8 

    展开全文
  • ''' open_demos.py (open()/获取File文件对象; File文件对象相关属性及方法...File文件指针:File.tell()、File.seek(offse,whence); File文件对象迭代器:可迭代/循环/list/序列解包等; 上下文管理器:实现__...
    '''
    open_demos.py
    
    (open()/获取File文件对象;
    File文件对象相关属性及方法:File.read()/readline()/readlines()/write()/writelines();
    File文件指针:File.tell()、File.seek(offse,whence);
    File文件对象迭代器:可迭代/循环/list/序列解包等;
    上下文管理器:实现__enter__() 和 __exit__() 两个魔法方法)
    
    
    
    使用:
    
    ####################
    #打开文件 获取 文件对象File
    
    #####
    #使用:open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
    #来打开 参数file文件 并返回一个流stream即_io.TextIOWrapper类对象。失败时提出OSError。
    
    #参数file        : 要创建或打开文件的文件名称,该名称要用引号(单引号或双引号都可以)括起来。
    #参数mode='r'    : 可选参数,用于指定文件的打开模式。默认以只读(r)模式打开文件。
    #注意:参数mode='r'文件打开模式,直接决定了后续可以对文件做哪些操作。
    #例如,使用 r 模式打开的文件,后续编写的代码只能读取文件,而无法改动文件内容。
    
    
    ####################
    #File文件对象 相关属性、方法
    
    #####
    #使用:File.encoding 来获取对象的编码方式
    #使用:File.mode     来获取对象的打开模式
    #使用:File.closed   来获取对象是否处于关闭状态,返回布尔值
    #使用:File.name     来获取对象打开的文件名
    
    #####
    #使用:File.read([size]) 来读取文件对象File的内容。
    #参数size: 用于指定要读取的字符/字节的数量。默认一次性读取所有内容字符/字节
    #注意:(File文件对象打开模式为 b 二进制则按字节读取,其他模式则按字符读取)
    
    #####
    #使用:File.readline([size]) 来读取File文件对象的一行。
    #参数size: 用于指定读取一行时最多读取的字符/字节 的数量。
    #注意:(File文件对象打开模式为 B 二进制则按字节读取,其他模式则按字符读取)
    #注意:File.readline()会连行尾的换行符一块读取。
    
    #####
    #使用:File.readlines([size]) 来读取File文件对象中的所有行。
    #参数size: 用于指定返回 size行 的列表,默认返回全部所有行。
    
    #注意:File.readlines([size]) 和调用不指定 size 参数的 File.read() 函数类似,只是返回类型不同,一个是列表,一个是str
    #注意:File.readlines([size]) 返回是一个字符串列表,其中每个元素为文件中的一行内容。
    #注意:readline() 函数一样,readlines() 函数在读取每一行时,会连同行尾的换行符一块读取。
    
    #####
    #使用:File.write(string) 来在File文件对象中写入 参数string 内容。
    #参数string: 表示要写入文件的字符串,也可以是二进制数据。
    #注意:File是一个已经打开的文件对象。
    
    #####
    #使用:File.writelines([str]) 来将 字符串列表/序列 写入到File文件对象中。
    #参数str: 表示要写入文件的字符串序列。
    
    #####
    #使用:File.close() 来将open()已经打开的File文件对象关闭。
    #注意:如果打开的文件对象File不进行close()操作的话,会影响 譬如 os.remove('b.txt') 删除文件等的操作
    
    
    ####################
    #File文件指针File.tell()/File.seek(offse,whence)  
    
    ##### 
    #使用:File.tell() 来判断文件指针当前所处的位置。
    
    #使用:File.seek(offset,whence) 来移动文件指针到指定位置。
    #参数offset: 表示偏移量,+正数表示向后偏移,-负数表示向前偏移。
    #参数whence: 可选参数0/1/2,指定文件指针的放置位置。三个选择:0 代表文件头(默认值)、1 代表当前位置、2 代表文件尾。
    
    #注意:File文件对象以 b 模式打开,每个数据就是一个字节;以普通模式打开,每个数据就是一个字符。
    
    
    ####################
    #File文件对象迭代器
    #open()读取后的File文件对象 可以被当做 迭代器 来使用,可循环,可操作,可list、序列解包、多重赋值等
    
    #####
    #使用:list 或 for循环等迭代 可作用于File文件对象
    #来将文件转换成字符串列表,效果等同于 File.readlines()
    
    #####
    #使用:print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    #参数file:实现将 参数value 写入输出到 参数file文件中 的操作
    
    #####
    #使用:多重赋值 可作用于File文件对象
    
    
    ####################
    #使用:上下文管理器,即:同时包含__enter__() 和 __exit__() 两个魔法方法的对象就是上下文管理器,
    #上下文管理器 可以通过使用 with as 语句来管理。
    #参考链接:http://c.biancheng.net/view/5319.html
    
    #__enter__(self)
    #__exit__(self, exc_type, exc_value, exc_traceback)
    #参数exc_traceback:判断其是否为None,即可判断出 with 代码块执行时是否遇到了异常。
    '''
    
    
    
    # =============================================================================
    # #open()
    # #open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
    # #open() 函数位于自动导入的模块_io中
    # =============================================================================
    
    help(open)
    ####################
    #打开文件 获取 文件对象
    
    #####
    #使用:open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
    #来打开 参数file文件 并返回一个流stream即_io.TextIOWrapper类对象。失败时提出OSError。
    
    #参数file        : 要创建或打开文件的文件名称,该名称要用引号(单引号或双引号都可以)括起来。
    #参数mode='r'    : 可选参数,用于指定文件的打开模式。默认以只读(r)模式打开文件。
    #注意:参数mode='r'文件打开模式,直接决定了后续可以对文件做哪些操作。
    #例如,使用 r 模式打开的文件,后续编写的代码只能读取文件,而无法改动文件内容。
    """
    #注意:open(file, mode='r') 函数中 参数mode='r'支持的打开模式有如下类型:
    #------------------------------------------------------------------------------
    模式	    意义	                                                    注意事项
    r	    只读模式打开文件,读文件内容的指针会放在文件的开头。	    注意:操作的文件必须存在。
    rb	    以二进制格式、采用只读模式打开文件,读文件内容的指针位于文件的开头,一般用于非文本文件,如图片文件、音频文件等。
    r+	    打开文件后,既可以从头读取文件内容,也可以从开头向文件中写入新的内容,写入的新内容会覆盖文件中等长度的原有内容。
    rb+	    以二进制格式、采用读写模式打开文件,读写文件的指针会放在文件的开头,通常针对非文本文件(如音频文件)。
    w	    以只写模式打开文件,若该文件存在,打开时会清空文件中原有的内容。	若文件存在,会清空其原有内容(覆盖文件);反之,则创建新文件。
    wb	    以二进制格式、只写模式打开文件,一般用于非文本文件(如音频文件)
    w+	    打开文件后,会对原有内容进行清空,并对该文件有读写权限。
    wb+	    以二进制格式、读写模式打开文件,一般用于非文本文件
    a	    以追加模式打开一个文件,对文件只有写入权限,如果文件已经存在,文件指针将放在文件的末尾(即新写入内容会位于已有内容之后);反之,则会创建新文件。	 
    ab	    以二进制格式打开文件,并采用追加模式,对文件只有写权限。如果该文件已存在,文件指针位于文件末尾(新写入文件会位于已有内容之后);反之,则创建新文件。	 
    a+	    以读写模式打开文件;如果文件存在,文件指针放在文件的末尾(新写入文件会位于已有内容之后);反之,则创建新文件。	 
    ab+	    以二进制模式打开文件,并采用追加模式,对文件具有读写权限,如果文件存在,则文件指针位于文件的末尾(新写入文件会位于已有内容之后);反之,则创建新文件。
    #------------------------------------------------------------------------------
    """
    #参数buffing=-1  : 可选参数,用于指定对文件做读写操作时,是否使用缓冲区。
    #如果 buffering 的值被设为 0,就不会有寄存。
    #如果 buffering 的值取 1,访问文件时会寄存行。
    #如果将 buffering 的值设为大于 1 的整数,表明了这就是的寄存区的缓冲大小。
    #如果取负值,寄存区的缓冲大小则为系统默认。
    
    #参数encoding=None: 指定打开文件的编码格式,默认为GBK编码。
    file=open(r'open_cases\open_case1_testOpen_A.txt','w+',-1,encoding='utf-8')   #指定打开模式 w+ 为新建读写模式,若无则创建,若存在则替换覆盖
    type(file)
    file.write('这里是第一次写入内容')            #write()方法按行写入内容
    #print(file)                                 #通过file.reade()等读取方法才能输出内容
    file.close()
    
    
    ####################
    #文件对象 相关属性、方法
    
    #####
    #使用:File.encoding 来获取对象的编码方式
    #使用:File.mode     来获取对象的打开模式
    #使用:File.closed   来获取对象是否处于关闭状态,返回布尔值
    #使用:File.name     来获取对象打开的文件名
    
    
    #####
    #使用:File.read([size]) 来读取文件对象File的内容。
    #参数size: 用于指定要读取的字符/字节的数量。默认一次性读取所有内容字符/字节
    #注意:(File文件对象打开模式为 b 二进制则按字节读取,其他模式则按字符读取)
    help(open)
    help(print)
    
    f=open(r'open_cases\open_case1_testOpen_A.txt','r',True,encoding='utf-8')
    while True:
        ch=f.read(1)                #读取一个字符/字节,循环一直读取。#注意:(File文件对象打开模式为 B 二进制则按字节读取,其他模式则按字符读取)
        if not ch:                  #如果读取不到内容,则退出;否则输出读取的内容。
            break
        print(ch,end='')            #自定义结束字符串为 空  以此输出原文原样。默认为换行符
    f.close()
    
    f=open(r'open_cases\open_case1_testOpen_A.txt','r',True,encoding='utf-8')
    print(f.read())                 #File.read()参数size为空则默认读取所有字符/字节。
    f.close()
    
    f=open(r'open_cases\open_case1_testOpen_A.txt','rb',True)#用二进制模式打开文件,获取得到bytes文件对象
    print(f.read().decode('GBK'))   #open()的默认encoding='GBK',注意需要一致编解码。
    f.close()
    
    #####
    #使用:File.readline([size]) 来读取File文件对象的一行。
    #参数size: 用于指定读取一行时最多读取的字符/字节 的数量。
    #注意:(File文件对象打开模式为 B 二进制则按字节读取,其他模式则按字符读取)
    #注意:File.readline()会连行尾的换行符一块读取。
    f=open(r'open_cases\open_case1_testOpen_A.txt','r',encoding='utf-8')
    print(f.readline(1))
    f.close()
    
    #####
    #使用:File.readlines([size]) 来读取File文件对象中的所有行。
    #参数size: 用于指定返回 size行 的列表,默认返回全部所有行。
    
    #注意:File.readlines([size]) 和调用不指定 size 参数的 File.read() 函数类似,只是返回类型不同,一个是列表,一个是str
    #注意:File.readlines([size]) 返回是一个字符串列表,其中每个元素为文件中的一行内容。
    #注意:readline() 函数一样,readlines() 函数在读取每一行时,会连同行尾的换行符一块读取。
    f=open(r'open_cases\open_case1_testOpen_A.txt','r',encoding='utf-8')
    print(f.readlines())
    f.close()
    
    
    #####
    #使用:File.write(string) 来在File文件对象中写入 参数string 内容。
    #参数string: 表示要写入文件的字符串,也可以是二进制数据。
    #注意:File是一个已经打开的文件对象。
    f=open(r'open_cases\open_case1_testOpen_A.txt','a+',encoding='utf-8')
    f.write('\n这是第二次写入数据内容  追加写入')              #注意 a+为追加读写模式在末尾,注意内容自行添加换行符\n
    f.close()
    
    f=open(r'open_cases\open_case1_testOpen_A.txt','r',encoding='utf-8')
    print(f.read())
    f.close()
    
    #####
    #使用:File.writelines([str]) 来将 字符串列表/序列 写入到File文件对象中。
    #参数str: 表示要写入文件的字符串序列。
    f=open(r'open_cases\open_case1_testOpen_A.txt','r',encoding='utf-8')
    n=open(r'open_cases\open_case2_testOpen_B.txt','w+',encoding='utf-8')     
    n.writelines(f.readlines())                      #readlines()读取文件中的所有行,返回列表结构。  writelines()写入列表结构
    n.close()
    f.close()
    
    
    #美化输出
    import pprint
    pprint.pprint(open(r'open_cases\open_case1_testOpen_A.txt',encoding='utf-8').readlines())
    
    
    #####
    #使用:File.close() 来将open()已经打开的File文件对象关闭。
    #注意:如果打开的文件对象File不进行close()操作的话,会影响 譬如 os.remove('b.txt') 删除文件等的操作
    
    
    
    ####################
    #File文件指针File.tell()/File.seek(offse,whence)  
    
    ##### 
    #使用:File.tell() 来判断文件指针当前所处的位置。
    
    #使用:File.seek(offset,whence) 来移动文件指针到指定位置。
    #参数offset: 表示偏移量,+正数表示向后偏移,-负数表示向前偏移。
    #参数whence: 可选参数0/1/2,指定文件指针的放置位置。三个选择:0 代表文件头(默认值)、1 代表当前位置、2 代表文件尾。
    
    #注意:File文件对象以 b 模式打开,每个数据就是一个字节;以普通模式打开,每个数据就是一个字符。
    
    f=open(r'open_cases\open_case4_testOpen_D.txt','r',encoding='utf-8')
    print(f.tell())            #输出当前文件指针位置
    print(f.read(3))           #按行读取字符3个字符
    print(f.tell())            #输出当前文件指针位置
    f.close() 
    
    
    f=open(r'open_cases\open_case4_testOpen_D.txt','r',encoding='utf-8')
    print(f.tell())            #输出当前文件指针位置
    print(f.read(1))           #按行读取1个字节,现文件指针位置在1
    print(f.tell())            #输出当前文件指针位置
    
    f.seek(5)                  #设置文件指针位置至 5   
    print(f.tell())            #输出当前文件指针位置
    print(f.read(1))           #按行读取1个字节
    print(f.tell())
    
    f.seek(5,1)                #设置文件指针至 当前指针向后移动5个字节 的位置
    print(f.tell())
    print(f.read(1))
    print(f.tell())
    
    f.seek(-1,2)               #设置文件指针至 文件结尾向前移动1个字节 的位置
    print(f.tell())
    print(f.read(1))
    print(f.tell())
    f.close()
    
    
    
    ####################
    #File文件对象迭代器
    #open()读取后的File文件对象 可以被当做 迭代器 来使用,可循环,可操作,可list、序列解包、多重赋值等
    
    #####
    #使用:list 或 for循环等迭代 可作用于File文件对象
    #来将文件转换成字符串列表,效果等同于 File.readlines()
    list(open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8'))
    
    with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
        for line in f:
            print(line)
    
    for line in open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8'):
        print(line)
    
    #####
    #使用:print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    #参数file:实现将 参数value 写入输出到 参数file文件中 的操作
    help(print)
    f=open(r'open_cases\open_case4_testOpen_D.txt','w',encoding='utf-8')
    print('First','line',file=f)                            #输出内容到指定文件
    print('Second','line',file=f)
    print('Third','and final','line',file=f)
    f.close()
    
    #####
    #使用:多重赋值 可作用于File文件对象
    first,second,third=open(r'open_cases\open_case4_testOpen_D.txt','r',encoding='utf-8')     #给文件内容的每行进行赋值操作
    print(first)
    print(second)
    print(third)
    
    
    
    ####################
    #使用:上下文管理器,即:同时包含__enter__() 和 __exit__() 两个魔法方法的对象就是上下文管理器,
    #上下文管理器 可以通过使用 with as 语句来管理。
    #参考链接:http://c.biancheng.net/view/5319.html
    
    #__enter__(self)
    #__exit__(self, exc_type, exc_value, exc_traceback)
    #参数exc_traceback:判断其是否为None,即可判断出 with 代码块执行时是否遇到了异常。
    
    with open(r'open_cases\open_case5_testOpen_E.txt','a+',encoding='utf-8')  as f:
        f.write('\nPython大法')
    
    
    #####示例:
    #自定义类   实现上下文管理协议的类,并尝试用 with as 语句来管理它:
    class FkResource:
        """
        自定义一个实现上下文管理协议的类,并尝试用 with as 语句来管理它.
        只要一个类实现了 __enter__() 和 __exit__() 这 2 个方法,程序就可以使用 with as 语句来管理它,
        
        通过 __exit__() 方法的参数exc_traceback是否为None,即可判断出 with 代码块执行时是否遇到了异常。
        """
        def __init__(self,tag):                                       #初始化构造器方法
            self.tag=tag
            print('构造器,初始化资源:{}'.format(tag))
        def __enter__(self):                                          #定义__enter__魔法方法,即with体之前执行的方法
            print('[__enter__方法: {}]'.format(self.tag))
            return 'fkit'                                             #可以返回任何类型来测试该自建类方法
        def __exit__(self, exc_type, exc_value, exc_traceback):       #定义__exit__魔法方法,即with体之后执行的方法
            print('[__exit__方法: {}]'.format(self.tag))
            """参数exc_traceback    为None,代表没有异常"""
            if exc_traceback is None:                                          
                print('没有异常,关闭资源')
            else:
                print('遇到异常,关闭资源')
                return False                                          #可以省略,默认返回None也被看成是False
    with FkResource('孙悟空') as dr:
        print(dr)
    
    #测试异常
    with FkResource('白骨精'):
        print('[with代码块]异常之前的代码')
        raise Exception
        print('[with代码块]异常之后的代码----------------不会再显示,因为已经异常')
        
    
    
    
    
    
    ##########
    #示例:
    #通过readlines()读取全部内容成列表后,修改列表元素,然后添加该列表,形成修改后的新的文本文件
    
    f=open(r'open_cases\open_case1_testOpen_A.txt',encoding='utf-8')
    lines=f.readlines()      #读取文件所有行,返回列表结构
    f.close()
    print(lines)
    
    lines[-1]="通过提取f.readlines()的列表,然后对列表进行赋值操作。所以这里进行了添加和新的修改。"
    print(lines)
    
    f=open(r'open_cases\open_case3_testOpen_C.txt','w+',encoding='utf-8')
    f.writelines(lines)      #注意 a+为追加读写模式在末尾,添加换行符\n
    f.close()
    
    
    ##########
    #示例:
    #迭代文件内容的多重方式(read,readline,readlines)
    
    #自建虚构的 内容处理函数
    def process(string):
        """此函数用作展示,即处理字符或行,可换做其他处理方法"""
        print('Processing: ',string)
        
    #通过read方式读取 单个字符 来循环迭代
    with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
        char=f.read(1)        
        while char:
            process(char)
            char=f.read(1)
            
    with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
        while True:
            char=f.read(1)
            if not char:
                break
            print(char,end='')                      #去除输出结尾的默认换行符,从而达到连续输出的目的。
    
    #通过readline读取 单行 来进行循环迭代 
    with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
        while True:
            char=f.readline()
            if not char:
                break
            process(char)
            
    #通过read 和 readlines 读取全部内容,来进行循环迭代
    with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
        for char in f.read():
            process(char)
            
    with open(r'open_cases\open_case3_testOpen_C.txt',encoding='utf-8') as f:
        for char in f.readlines():
            process(char)
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 2. 文件指针 1. 文件描述符 文件描述符就是内核当中 fd_array 数组的下标,是一个正整数 我们写出如下代码,并在代码最后加上一个循环,让代码不要退出 运行程序,后查看当前进程 如下图所示: 文件描述符:...
  • //打开文件指针,创建文件 if (!is_writable($filename)) { die("文件:" . $filename . "不可写,请检查!"); } else { fwrite($fp1, $filename); } fclose($fp1); mkdir('./test/test1'); $file
  • Ⅰ 文件的打开模式 控制文件读写操作的模式r 只读操作只读(默认的):在文件不存在时报错,文件存在时文件指针跳到文件开头f = open('a.txt', mode = 'rt', encoding = 'utf-8').read() 将文件读出来并赋值.readable() ...
  • 使用for循环遍历文件 1、打开文件读打开文件,从头到尾读完后,再执行read()就没有了 关闭后就不能读 readlines()和readline()区别:readline() :一行一行读取,返回字符串,当指针文件末尾后,返回空readlines...
  • C语言全套资料 C语言程序设计 C语言算法 C语言课件 C语言顺序程序设计,C语言数组,C语言循环控制,C语言预处理命令,C语言文件操作指针,C语言选择结构程序设计,C语言结构体与共用体,C语言文件操作,C语言函数
  • 实现流程 打开文件 按照行的方式 循环文件 解析每一行,若匹配key关键字,在进行value值的提取 提取value值需要 1去除前后空格 1级指针典型应用
  • Object-C在MRC文件中使用弱指针 背景: 在ARC文件中,我们通常会在block中使用__weak生成对象的弱引用,解决block中对象循环引用的问题。 新项目建议完全使用ARC,不过有一些老项目和老文件还在使用MRC,并且...
  • with open(filename, "r") as f: 的形式进行文件操作,如果忘记关闭文件指针的话,他会帮你自己关闭文件, 如果使用原来的方式 f = open(filename, "w") 打开文件,在程序终止的时候,Python虽然说会帮你自动关闭...
  • 使用python写入文件,每次写入的时候,都追加在后面。 但是,程序开始运行时,先进行清空,再追加写入。...这一行代码写在循环外面,循环结束之后文件才会关闭,所以每次写入的时候,文件指针都在末尾。 ...
  • inputFile = open('xiao.csv','r') line = inputFile.readline() #先初始化,指向文件头 while line: name = line.split(',')[6] ...#while循环结束后,指针文件末尾 inputFile.seek(0) #返回文件头 line
  • 文件遍历在实际业务中,Creo对文件操作时需要对制定的文件夹中的文件进行循环遍历,查找到符合要求的文件,以便进行操作ProPath *file_list, *dir_list; //文件名和路径名称保存指针 ProName w_nm; //路径 ...
  • Info`缓存表对象`Table`创建函数增删改查增insert删delete改update查select效率分析debug与其他思考函数指针与代码优化中途退出的特判问题多向量结构与标志位函数与封装文件流的再思考 源码已经全部更新到我的GitHub...
  • c++循环读取多行文本文件

    千次阅读 2013-11-08 16:41:39
    其实主要的思路就是每次调用fgets,文件指针都会跳到下一行。  自己写的代码  #include  #include  #define Line 1024  int main()  {  //读取多行文件,存多行文件  FILE *fp;  char filename...
  • printf("自文件中读入数据为:\n"); if ((fp=fopen("Data.txt","r"))==NULL) { printf("打开失败\n"); exit(0); } for (i=0; !feof(fp); i++) { fscanf(fp,"%10d ",&Student_ReadFromFile [i] . num); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,009
精华内容 403
关键字:

文件指针循环