精华内容
下载资源
问答
  • 因为外部资源不由JVM管理,无法享用JVM垃圾回收机制,如果我们不在编程时确保在正确的时机关闭外部资源,就会导致外部资源泄露,紧接着就会出现文件被异常占用,数据库连接过多导致连接池溢出等诸多很严重问题。...

    在Java编程过程中,如果打开了外部资源(文件、数据库连接、网络连接等),我们必须在这些外部资源使用完毕后,手动关闭它们。因为外部资源不由JVM管理,无法享用JVM的垃圾回收机制,如果我们不在编程时确保在正确的时机关闭外部资源,就会导致外部资源泄露,紧接着就会出现文件被异常占用,数据库连接过多导致连接池溢出等诸多很严重的问题。

    在java1.7以前,我们关闭资源的方式如下:

    public class CloseTest {
        public static void main(String[] args){
    
            FileInputStream fileInputStream = null;
            try {
                fileInputStream = new FileInputStream("file.txt");
                fileInputStream.read();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if (fileInputStream != null){
                    try {
                        fileInputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    为了确保外部资源一定要被关闭,通常关闭代码被写入finally代码块中,关闭资源时可能抛出的异常,于是经典代码就诞生了。

    但是,在java1.7版本之后,新增加了一个语法糖,就是try-with-resources语句,我们先直接上一个demo,方便理解:

    public class CloseTest {
        public static void main(String[] args) {
            try (FileInputStream fileInputStream1 = new FileInputStream("file1.txt");
                 FileInputStream fileInputStream2 = new FileInputStream("file2.txt")) {
                fileInputStream1.read();
                fileInputStream2.read();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    将外部资源的句柄对象的创建放在try关键字后面的括号中,当这个try-catch代码块执行完毕后,Java会确保外部资源的close方法被调用。多个语句使用分号断开。

    反编译之后我们可以看见:

    public static void main(String[] args) {
      try {
        FileInputStream inputStream = new FileInputStream(new File("test"));
        Throwable var2 = null;
    
        try {
          System.out.println(inputStream.read());
        } catch (Throwable var12) {
          var2 = var12;
          throw var12;
        } finally {
          if (inputStream != null) {
            if (var2 != null) {
              try {
                inputStream.close();
              } catch (Throwable var11) {
                var2.addSuppressed(var11);
              }
            } else {
              inputStream.close();
            }
          }
    
        }
    
      } catch (IOException var14) {
        throw new RuntimeException(var14.getMessage(), var14);
      }
    }

    通过反编译的代码,大家可能注意到代码中有一处对异常的特殊处理: 

    var2.addSuppressed(var11);

    这是try-with-resource语法涉及的另外一个知识点,叫做异常抑制。当对外部资源进行处理(例如读或写)时,如果遭遇了异常,且在随后的关闭外部资源过程中,又遭遇了异常,那么你catch到的将会是对外部资源进行处理时遭遇的异常,关闭资源时遭遇的异常将被“抑制”但不是丢弃,通过异常的getSuppressed方法,可以提取出被抑制的异常。

    源码里面有解释:

     /**
         * Returns an array containing all of the exceptions that were
         * suppressed, typically by the {@code try}-with-resources
         * statement, in order to deliver this exception.
         *
         * If no exceptions were suppressed or {@linkplain
         * #Throwable(String, Throwable, boolean, boolean) suppression is
         * disabled}, an empty array is returned.  This method is
         * thread-safe.  Writes to the returned array do not affect future
         * calls to this method.
         *
         * @return an array containing all of the exceptions that were
         *         suppressed to deliver this exception.
         * @since 1.7
         */
        public final synchronized Throwable[] getSuppressed() {
            if (suppressedExceptions == SUPPRESSED_SENTINEL ||
                suppressedExceptions == null)
                return EMPTY_THROWABLE_ARRAY;
            else
                return suppressedExceptions.toArray(EMPTY_THROWABLE_ARRAY);
        }

    总结

    因为不管什么情况下(异常或者非异常)资源都必须关闭,在jdk1.6之前,应该把close()放在finally块中,以确保资源的正确释放。如果使用jdk1.7以上的版本,推荐使用try-with-resources语句。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 文章目录Python学习with语句文本文件的读取_enumerate()函数和推导式生成列表二进制文件的读取和写入文件对象的常用属性和方法使用pickle序列化CSV文件的操作os和os.path模块OS模块文件和目录操作OS.path模块列出...

    Python学习

    with语句

    with关键字(上下文管理器)可以自动管理上下文资源,不论什么原因跳出with块,都能确保文件正确关闭,并且可以在代码块执行完毕后自动还原进入该代码块时的现场

    下面是Demo

    with open(r'd.txt','a') as f:
        f.writelines('gaoqi,i love u!')
    
    gaoqi,i love u!
    

    文本文件的读取

    文件的读取一般使用有三个方法
    1.read([size]):从文件中读取size,并作为结果返回,如果没有size参数,则读取整个文件,读取到文件末尾,会返回空字符串
    2.readline():读取一行内容作为结果返回,读取到文件末尾,回返回空字符串
    3.readlines()文本文件中,每一行作为一个字符串存入列表中,返回该列表

    下面是Demo

    with open(r'e.txt',encoding='utf-8') as f:
        str = f.read()
        print(str)
    E:\python\python37\python.exe E:/python/PycharmProjects/pythonProject4/文本文件的读取.py
    我 love u
    百战程序员
    尚学堂
    
    Process finished with exit code 0
    
    with open('e.txt','r',encoding='utf-8') as f:
        for a in f:
            print(a,end='')
    E:\python\python37\python.exe E:/python/PycharmProjects/pythonProject4/文本文件的读取.py
    我 love u
    百战程序员
    尚学堂
    Process finished with exit code 0
    
    with open(r'e.txt','r',encoding='utf-8') as f:
        while True:
            fragement = f.readline()
            if not fragement:
                break
            else:
                print(fragement,end='')
    E:\python\python37\python.exe E:/python/PycharmProjects/pythonProject4/文本文件的读取.py
    我 love u
    百战程序员
    尚学堂
    Process finished with exit code 0
    

    _enumerate()函数和推导式生成列表

    练习。

    下面是Demo

    a =['我 love u!\n','尚学堂\n','百战程序员\n']
    b = enumerate(a)
    print(a)
    print(list(b))
    
    with open('e.txt','r',encoding='utf-8') as f:
        lines = f.readlines()
        #推导式生成列表
        lines = [line.rstrip()+'#'+str(index+1)+'\n' for index,line in enumerate(lines)]
    with open('e.txt','w',encoding='utf-8') as f:
        f.writelines(lines)
    E:\python\python37\python.exe E:/python/PycharmProjects/pythonProject4/10.1练习.py
    ['我 love u!\n', '尚学堂\n', '百战程序员\n']
    [(0, '我 love u!\n'), (1, '尚学堂\n'), (2, '百战程序员\n')]
    
    Process finished with exit code 0
    
    with open('e.txt','r',encoding='utf-8') as f:
        lines = f.readlines()
        #推导式生成列表
        lines = [line.rstrip()+'#'+str(index+1)+'\n' for index,line in enumerate(lines)]
    with open('e.txt','w',encoding='utf-8') as f:
        f.writelines(lines)
    
    我 love u#1#1
    百战程序员#2#2
    尚学堂#3#3
    

    二进制文件的读取和写入

    下面是Demo

    with open('aa.gif','rb') as f :
        with open('aa_copy.gif','wb') as w:
            for line in f.readlines():
                w.write(line)
    
    
    print('图片拷贝完成!,,,,')
    
    
    E:\python\python37\python.exe E:/python/PycharmProjects/pythonProject4/二进制文件的读写.py
    图片拷贝完成!,,,,
    
    Process finished with exit code 0
    

    文件对象的常用属性和方法

    文件对象常用方法:
    read([size]):从文件中读取size个字节或者字符的内容返回,若省略[size],则读取到文件末尾,即一次读取文件所有内容
    readline():从文本文件中读取一行内容
    readlines():把文本文件中每一行都作为独立的字符串对象,并将这些对象放入列表返回
    write(str):将字符串str内容写入文件
    writelines(s):将字符串列表S写入文件,不添加换行符
    seek(offset [,whence]:把文件指针移动到新的位置,offset表示相对于whence的多少个字节的偏移量
    offset:off为正往结束方向移动,为负往开始方向移动
    whence不同的值代表不同含义:
    0:从文件头开始计算(默认值)
    1:从当前位置开始计算
    2:从文件尾开始计算
    tell():返回文件指针的当前位置
    truncate([size]):不论指针在什么位置,只留下指针前size个字节的内容,其余全部删除:如果没有传入size,则当指针当前位置到文件末尾内容全部删除
    flush():把缓冲区的内容写入文件,但不关闭文件
    close():把缓冲区内容写入文件,同时关闭文件,释放文件对象相关资源
    下面是Demo

    with open('e.txt','r',encoding='utf-8') as f:
        print('文件名是:{0}'.format(f.name))
        print(f.tell())
        print('读取的内容:{0}'.format(str(f.readline())))
        print(f.tell())
        f.seek(3)
        print('读取的内容:{0}'.format(str(f.readline())))
    E:\python\python37\python.exe E:/python/PycharmProjects/pythonProject4/文件对象常用方法和属性.py
    文件名是:e.txt
    0
    读取的内容:我 love u#1#1
    
    16
    读取的内容: love u#1#1
    
    
    Process finished with exit code 0
    

    使用pickle序列化

    python中,一切都是对象,对象本质上就是一个存储数据的内存块
    我们可以使用pickle模块中的函数,实现序列化和反序列操作
    序列化我们使用:pickle.dump(obj,file) obj就是要被序列化的对象,file指的是存储文件 pickle.load(file) 从file读取数据,反序列化成对象
    下面是Demo

    import pickle
    
    a1 = '袁少旭'
    a2 = 234
    a3 = [10,20,30,40]
    
    with open('data.dat','wb') as f:
        pickle.dump(a1,f)
        pickle.dump(a2,f)
        pickle.dump(a3,f)
    
    
    with open('data.dat','rb') as f:
        b1 = pickle.load(f)
        b2 = pickle.load(f)
        b3 = pickle.load(f)
    
        print(b1);print(b2);print(b3)
    
    
        print(id(a1));print(id(b1))
    
    E:\python\python37\python.exe E:/python/PycharmProjects/pythonProject4/pickle实现序列化和反序列画.py
    袁少旭
    234
    [10, 20, 30, 40]
    2494939062608
    2494940618064
    
    Process finished with exit code 0
    

    CSV文件的操作

    CSV是逗号分隔符文本格式,常用于数据交换,Excel文件和数据库数据的导入和导出

    下面是Demo

    import csv
    
    with open('dd.csv','r') as f:
        a_csv =csv.reader(f)
     #   print(list(a_csv))
        for row in a_csv:
            print(row)
    
    
    with open('ee.csv','w') as f:
        b_csv = csv.writer(f)
        b_csv.writerow(['id','姓名','年龄'])
        b_csv.writerow(['1001','袁少旭','18'])
    
        c = [['1002','xixi','3'],['1003','苏晓红','26']]
        b_csv.writerows(c)
    
    E:\python\python37\python.exe E:/python/PycharmProjects/pythonProject4/csv文件.py
    ['银行卡密码', '', '']
    ['移动号码服务密码', '', '']
    ['电话密码', '', '']
    ['社交账号密码', '', '']
    ['苹果手机下载密码', '', '']
    ['建设银行网盾', '3', '']
    ['QQ飞车二级密码', '156', '']
    ['无线密码', 'yu88', 'yn123']
    ['', '', '']
    ['新手机15118585', '苹果ID密码', 'Li314']
    ['网易邮箱laolig1@163.com', 'n8188', '']
    
    Process finished with exit code 0
    
    
    id,姓名,年龄
    
    1001,袁少旭,18
    
    1002,xixi,3
    
    1003,苏晓红,26
    

    os和os.path模块

    os模块可以帮助我们直接对操作系统进行操作,我们可以直接调用操作系统的可执行文件,命令,直接操作文件,目录等,在系统运维的核心基础
    OS

    下面是Demo

    import os
    
    #os.system('notepad.exe')
    
    #os.system('ping www.baidu.com')
    #os.system('cmd')
    
    #直接调用可执行的文件
    os.startfile(r'"E:\Program Files (x86)\Tencent\QQ\Bin\QQScLauncher.exe"')
    

    OS模块文件和目录操作

    我们可以通过前面讲的文件对象实现对于文件内容的读写操作,如果还需要对文件和目录做其他操作,我们可以使用os和os.path模块
    remove(path):删除指定的文件
    rename(src,dest):重命名文件或目录
    stat(path):返回文件的所有属性
    listdir(path):返回path目录下的文件和目录列表
    mkdir(path):创建目录
    makedirs(path1/path2/path3/…):创建多级目录
    rmdir(path):删除目录
    removedirs(path1/path2/…):删除多级目录
    getcwd():返回当前工作目录:current work dir
    chdir(path):把PATH设为当前目录
    walk():遍历目录树
    sep:当前操作系统所使用的路径分隔符

    下面是Demo

    #coding=utf-8
    #测试OS模块中,关于文件和目录的操作
    
    import os
    ##获取文件和文件夹的信息
    
    print(os.name)#windows返回nt linux和unix返回posix
    print(os.sep)#windows返回\   linux和unix返回/
    print(repr(os.linesep))#windows返回\r\n  linux返回\n\
    print(os.stat('with上下文管理.py'))
    
    
    ###关于工作目录的操作
    # print(os.getcwd())
    # os.chdir('d:')#改变当前工作目录为D盘
    # os.mkdir('书籍')
    ###创建目录,创建多级目录,删除
    # os.mkdir('书籍')
    # os.rmdir('书籍')#相对路径都是相对于当前的工作目录
    # os.makedirs('电影/港台/周星星')
    # os.removedirs('电影/港台/周星星')#只能删除空的目录
    
    # os.makedirs('../音乐/香港/刘德华')#。。/指的是上一级目录
    # os.rename('电影','movie')
    dirs = os.listdir('movie')
    print(dirs)
    

    OS.path模块

    OS.path模块提供了目录相关(路径判断,路径切分,路径链接,文件夹遍历)的操作
    下面是Demo

    #coding=utf-8
    #测试关于os.path关于目录,路径的操作
    import os
    import os.path
    
    ######判断:绝对路径,是否目录,是否文件,文件是否存在######
    print(os.path.isabs('d:/a.txt'))#True
    print(os.path.isdir('d:/a.txt'))#False
    print(os.path.isfile('d:/a.txt'))#True
    print(os.path.exists('d:/a.txt'))
    ######获得文件基本信息######
    print(os.path.getsize('b.txt'))
    print(os.path.basename('b.txt'))
    print(os.path.dirname('d:/a.txt'))
    
    
    print(os.path.getctime('b.txt'))
    print(os.path.getatime('b.txt'))
    print(os.path.getmtime('b.txt'))
    ######路径的操作######
    path = os.path.abspath('b.txt')
    print(os.path.split(path))
    print(os.path.splitext(path))
    
    
    print(os.path.join('aa','bb','cc'))
    
    
    E:\python\python37\python.exe E:/python/PycharmProjects/pythonProject4/os.path.py
    True
    False
    True
    True
    6
    b.txt
    d:/
    1601521483.3649137
    1601521505.011052
    1601521505.011052
    ('E:\\python\\PycharmProjects\\pythonProject4', 'b.txt')
    ('E:\\python\\PycharmProjects\\pythonProject4\\b', '.txt')
    aa\bb\cc
    
    Process finished with exit code 0
    

    列出指定目录下所有的.py文件,并输出文件名

    python中,一切都是对象,实际上,执行def定义函数后,系统就创建了相应的函数对象。

    下面是Demo

    #coding=utf-8
    #列出工作目录下所有的文件,并输出文件名
    import os
    path = os.getcwd()
    file_list = os.listdir(path)#列出子目录,子文件
    for filename in file_list:
        if filename.endswith('py'):
            print(filename,end='\t')
    print('##################')
    file_list2 = [filename for filename in os.listdir(path) if filename.endswith('py')]
    for f in file_list2:
        print(f)
    
    E:\python\python37\python.exe E:/python/PycharmProjects/pythonProject4/1001练习2.py
    10.1练习.py	1001练习2.py	9.29测试.py	csv文件.py	finally测试.py	main.py	os.path.py	os模块.py	os模块文件和目录操作.py	pickle实现序列化和反序列画.py	trackback模块.py	with上下文管理.py	with语句.py	_try_excep基本结构.py	二进制文件的读写.py	异常.py	文件对象常用方法和属性.py	文件的写入.py	文本文件的读取.py	自定义异常.py	##################
    10.1练习.py
    1001练习2.py
    9.29测试.py
    csv文件.py
    finally测试.py
    main.py
    os.path.py
    os模块.py
    os模块文件和目录操作.py
    pickle实现序列化和反序列画.py
    trackback模块.py
    with上下文管理.py
    with语句.py
    _try_excep基本结构.py
    二进制文件的读写.py
    异常.py
    文件对象常用方法和属性.py
    文件的写入.py
    文本文件的读取.py
    自定义异常.py
    
    Process finished with exit code 0
    
    展开全文
  •  首先,连库语句关闭连接部分都应该单独提取出来放在一个类里,有可能话,连库语句还能以输入或从文件中读取形式做出来,这是因为连库的语句有可能会出现变化,比如:今天连MySQL,明天可能因

    原:http://blog.csdn.net/mql0825123/article/details/40430697  

    近期看到在某贴里有一个小程序,内涉到连库的技术,所以发个帖子讨论一下。
        首先,连库语句和关闭连接的部分都应该单独提取出来放在一个类里,有可能的话,连库语句还能以输入或从文件中读取的形式做出来,这是因为连库的语句有可能会出现变化,比如:今天连MySQL,明天可能因为升级或其他原因换成了Oracle,如果你有50个类都涉及到连库那你就要改50个地方,而把连库语句放在一个类中,由其他类去调用它,那么改的时候则只需要改这一个地方,而对关闭连接语句的改动情况可能不会很多但是,由于连一次库就需要有一次关闭连接,连50次库就需要写50遍几乎一模一样的关闭连接语句,写代码即麻烦又不够漂亮。像这样以让结果不发生改变为前提,通过修改代码结构来减少以后修改的麻烦,让代码写的更漂亮的技术就是“重构”,关于重构问题参与过项目的人其实都很清楚其重要性,我在这里就不多说了,为那些还在受到大学里连命名都用a,b,c的无良教育的兄弟们推荐“重构--改善既有代码的设计”这本书,马丁大师的杰作,建议这本书要买下来,而不是去图书馆借。

        由于我重点想说的是关闭连接,所以对连库方面就说这么多,下面重点说说关闭连接的写法,以下是我看到的那个帖子里写的关闭连接方法(命名可能不同),
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    conn = XXX;
    ps = conn.XXX;
    rs = ps.XXX;
        下面是重点
    rs.close();
    ps.close();
    conn.close();
        看到上面的关闭语句了吗?只有3行,但看到这里的人不知道有多少看出这3行中的问题?至少我认为,那些正在接受大学过时教育的学生们都不会看出这里有什么样的问题。那么下面我们就分析一下:

        首先conn,ps,rs的初值为null,就是说还没有连接的情况,那么如果在你的程序中,这3个中有1个,2个甚至3个都没有用到或在之前被置空怎么半?比如你有可能没有用到rs,那么就会出现这种情况:
    rs = null;
    rs.close();
        很明显,没有打开的东西为什么还要关闭?所以只在这个问题上正确的写法如下:
    if(ps != null){
    ps.close();
    ps = null;
    }

        上面的写法就比最开始那个3行关闭要好的多,但这个的写法依然存在问题,每个人都知道在写数据库的操作时会用到下面这个语法:
    try{
    ...
    }catch(SQLException e){
    e.printStackTrace();
    }finally{
    ...
    }
        每个人还都知道这是为了应付中途出现数据库错误而调用的一段错误处理,然后try剩余的部分会终止并从finally开始运行。所以,关闭连接的语句的问题就出现在了这里,我知道肯定有人把关闭语句写在try里因而省掉了finally的部分,但这么做的话,中途出现错误就会导致关闭语句没有被执行,所以关闭语句必须要写在finally里,另外,万一rs,ps中有一个出错,那么conn怎么办?比如说:rs.close()出错,ps和conn的close怎么办?这点也必须考虑进去,因而关闭语句的正确的写法应该是下面这个样子:

    try{
        if(result != null){
            result.close();
            result = null;
        }  
    }catch(SQLException e){
        e.printStackTrace();
    }finally{
        try{
            if(ps != null){
                ps.close();
         ps = null;
       }
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            try{
         if(conn != null){
       conn.close();
       conn = null;
         }
    }catch(SQLException e){
         e.printStackTrace();
    }finally{
         return "数据库连接已关闭";
    }
        }
    }

        然后把上面那段代码放在下面这个总的finally中就行了,由于还要对格式我就不写了

    try{
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        conn = XXX;
        ps = conn.XXX;
        ...
        rs = ps.XXX;
    }catch(SQLException e){
    e.printStackTrace();
    }finally{
        //这里放那段关闭代码
    }

        不要觉得这段关闭代码多余,如果你去应聘公司,面试官让你写出关闭连接的代码,写成3行的那种和写成最后这种明显是不同的,虽然相比多出很多代码,不过你把这些关闭代码提取到一个类中去,通过参数传递conn,ps,rs,只需要写这一遍就可以用一辈子了。如果谁还知道我这种写法还存在什么漏洞也请指教。

        最后还是忍不住再说两句,根据重构法则,要尽量消除重复的代码,所以如果conn,ps和rs在你的一个类中出现了不只一次(比如2个方法都用到了它们),则可以考虑把他们变成类的私有属性提出来,如下:
    private Connection conn = null;
    private PreparedStatement ps = null;
    private ResultSet rs = null;

        另外还有一点,上次看到的那个小程序中把存取函数(set和get方法)单独提了出来,这种做法很不错,但是如果不需要外界调用的话,则可以不用写,因为多加一个存取函数就相当于对外多开放了一个接口,有的时候你多写一个存取函数无所谓,但有时候则会出现安全性的问题哦。

    展开全文
  • C# using 语句的妙用

    2012-07-08 14:46:49
    finally 工作,常用于确保文件、数据库连接正确关闭。 虽然在 C# 中我们可以使用 try ... finally 语句做相同事,但有时做起来会很冗长,不方便。 另一方面 C++ 中 RAII 确实是个非常合适替代方式。 ...

    Common Lisp 中有一种“with-”语句风格,它们可以以方便的方式做 try ... finally 的工作,常用于确保文件、数据库连接正确关闭。

    虽然在 C# 中我们可以使用 try ... finally 语句做相同的事,但有时做起来会很冗长,不方便。

    另一方面 C++ 中的 RAII 确实是个非常合适的替代方式。

    由此想到了使用 C# 中的 using 语句来模拟这种风格,示例代码见“cs-with”,其实很简单,一学就会。

    注意,尽管原理很简单,但由此带来的代码简化却是很明显的,使用这种“伪with”语句比直接的多个赋值语句要简洁得多。

    熊怀东
    shoulea@163.com
    1:41 2012/7/8

    using System;
    
    namespace CSharpWith
    {
        public struct WithColor : IDisposable
        {
            // Fields
            private ConsoleColor color;
    
            // Methods
            public WithColor(ConsoleColor color)
            {
                this.color = Console.ForegroundColor;
                Console.ForegroundColor = color;
            }
    
            void IDisposable.Dispose()
            {
                Console.ForegroundColor = color;
            }
        }
    
        public static class Input
        {
            public static string ReadLine()
            {
                using (new WithColor(ConsoleColor.Cyan))
                    Console.Write(">>> ");
                using (new WithColor(ConsoleColor.Green))
                    return Console.ReadLine();
            }
        }
    
        public static class Output
        {
            public static void WriteLine(string format, params object[] arg)
            {
                using (new WithColor(ConsoleColor.White))
                    Console.WriteLine(format, arg);
            }
        }
    
        class Program
        {
            static void Main()
            {
                while (true)
                {
                    string line = Input.ReadLine();
                    if (line == null)
                        break;
                    if (!string.IsNullOrWhiteSpace(line))
                        Output.WriteLine("{0}", line);
                }
            }
        }
    }
    


    展开全文
  • MFC文本文件的读写

    2017-08-10 13:28:04
    5.关闭文件 1、定义文件变量 定义文件变量格式:CStdioFile文件变量; 例如,定义一个名称为f1文件变量,语句如下:CStdioFile f1; 2、打开指定文件 可以直接通过CStdioFile构造函数来打开磁盘文件,同时...
  • 5.关闭文件 1、定义文件变量 定义文件变量格式:CStdioFile 文件变量; 例如,定义一个名称为f1文件变量,语句如下:CStdioFile f1; 2、打开指定文件 可以直接通过CStdioFile构造函数来
  • 错误日志(error log):对mysql启动、运行、关闭过程中产生错误、警告或者甚至正确信息 二进制文件(binlog):记录所有对mysql写操作语句,有statements和row模式 慢查询日志 (slow query log):记录运行...
  • MFC --txt文本文件的读写

    千次阅读 2013-11-25 10:42:53
    5.关闭文件 1、定义文件变量 定义文件变量格式:CStdioFile 文件变量; 例如,定义一个名称为f1文件变量,语句如下:CStdioFile f1; 2、打开指定文件 可以直接通过CStdioFile构造函数来打开磁盘文件,
  • with语句 上下文管理器 contextlib模块 参考引用 with语句 with语句时在Python2.6...如要实现文件在操作出现异常时也能正确关闭,则需要像如下实现: f = open("test.txt") try: for line in f.readline...
  • Python 2.7.10文件操作一般文件操作可以通过open方式获取一个文件对象fp,比如:fp = open('test.txt', 'r')然后我们可以通过fp对文件进行读操作,操作完成后,我们需要通过调用fp对象close方法显示的关闭资源,...
  • with语句 上下文管理器 contextlib模块 参考 with语句 with语句时在Python2.6中出现新...如要实现文件在操作出现异常时也能正确关闭,则需要像如下实现: f = open("test.txt") try: for line in f.readlines(...
  • 对于系统资源如文件、数据库连接、socket 而言,应用程序打开这些资源并执行完业务逻辑之后,必须做一件事就是要关闭(断开)该资源。 比如 Python 程序打开一个文件,往文件中写内容,写完之后,就要关闭文件,...
  • 实例是保存在硬盘上的文件,它不会随着数据库启动/关闭而存在或消失。 B.实例是内存中结构,是一种访问数据库方式。 C.可以用语句Select instance_name FROM v$instance获得实例名。 D.一个实例可以访问多...
  • 各章链接如下填空1、 对文件进行写入操作之后,()方法用来在不关闭文件对象情况下将缓冲区内容写入文件。flush()2、 Python内置函数()用来打开或创建文件并返回文件对象。open()3、 使用上下文管理关键字()可以...
  • MFC中TXT文件读写

    万次阅读 多人点赞 2017-05-02 18:28:09
    5.关闭文件 1、定义文件变量 定义文件变量格式:CStdioFile 文件变量; 例如,定义一个名称为f1文件变量,语句如下:CStdioFile f1; 2、打开指定文件 可以直接通过CStdioFile构造函数来
  • 文件读写

    2019-05-17 10:21:04
    打开一个文件用open()方法...所以,为了保证无论是否出错都能正确关闭文件,我们可以使用try … finally来实现 但是每次都这么写实在太繁琐,所以,Python引入了with语句来自动帮我们调用close()方法 python文...
  • 另外一个功能,当我关闭当前窗口时,弹出警告框,我在js文件中是这样写, $(window).unload(function(){alert("感谢您访问!");});这条语句我写在 $(function(){});函数外,运行此HTML文件,但是没效果。 如何...
  • 刚刚接手服务器系统运维工作时,如果整个服务器很乱情况,如何理清整个服务器web运行环境 ...2、找到nginx位置,如果修改了nginx,需要先检查nginx配置文件是否正确,运行语句/usr/local/nginx-1.10.
  • python程序设计第七章文件操作 题库

    千次阅读 2020-06-26 20:44:29
    1、 对文件进行写入操作之后,()方法用来在不关闭文件对象情况下将缓冲区内容写入文件。 flush() 2、 Python内置函数()用来打开或创建文件并返回文件对象。 open() 3、 使用上下文管理关键字()可以自动管理文件...
  • 前言如果你有阅读源码习惯,可能会看到一些优秀代码经常出现带有 “with” 关键字的语句,它通常用在什么场景呢?今天就来说说 with 和 上下文管理器。对于系统资源如文件、数据库连接、socket 而言,应用程序...
  • 在命令提示下键入批处理文件的名称,或者双击该批处理文件,系统就会调用Cmd.exe按照该文件中各个命令出现的顺序来逐个运行它们。使用批处理文件(也被称为批处理程序或脚本),可以简化日常或重复性任务。当然我们...
  • with= open('文件路径','打开模式') as f:#PS:python3提供了with语句来帮我们自动调用close方法,所以说无论打开文件是否出错都能自动正确关闭文件 Python打开文件的模式 基本模式 带'+'的模式 带'b'的...
  • 因为外部资源不由JVM管理,无法享用JVM垃圾回收机制,如果我们不在编程时确保在正确的时机关闭外部资源,就会导致外部资源泄露,紧接着就会出现文件被异常占用,数据库连接过多导致连接池溢出等诸多很严重问题。...
  • 没有正确的打开、关闭文件,只使用了open,没有使用close; 或者虽然程序中写了close,但有时会在open阶段发生异常,异常抛出后或者在异常处理中最终并没有执行close,导致文件内容为空。 解决 使用with open as f:...
  • with 关键字(上下文管理器)可以自动管理上下文资源,不论什么原因跳出 with 块,都能确保文件正确关闭,且可以在代码块执行完毕后自动还原进入该代码块时现场。 【例】使用 with 管理文件写入操作 s = ['学习...
  • with 关键字(上下文管理器)可以自动管理上下文资源,不论什么原因跳出with 块,都能 确保文件正确的关闭,并且可以在代码块执行完毕后自动还原进入该代码块时现场。 相当于一个还原点,还原到文件关闭状态。 ...
  • 如果你有阅读源码习惯,可能会看到一些优秀代码经常出现带有 “with” 关键字的语句,它通常用在什么场景呢?今天就来说说 with 和 上下文管理器。  对于系统资源如文件、数据库连接、socket 而言,应用程序...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 212
精华内容 84
关键字:

关闭文件的正确语句