精华内容
下载资源
问答
  • python读写、创建文件、文件夹等等

    万次阅读 多人点赞 2019-06-23 17:00:08
    python中对文件、文件夹(文件操作函数)的操作需要涉及到os模块和shutil模块。 得到当前工作目录,即当前Python脚本工作的目录路径:os.getcwd() 返回指定目录下的所有文件和目录名:os.listdir() 函数用来删除一...

    Python中对文件、文件夹(文件操作函数)的操作需要涉及到os模块和shutil模块。

    得到当前工作目录,即当前Python脚本工作的目录路径:os.getcwd()

    返回指定目录下的所有文件和目录名:os.listdir()

    函数用来删除一个文件:os.remove()

    删除多个目录:os.removedirs(r“c:\python”)

    检验给出的路径是否是一个文件:os.path.isfile()

    检验给出的路径是否是一个目录:os.path.isdir()

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

    检验给出的路径是否真地存:os.path.exists()

    返回一个路径的目录名和文件名:os.path.split()  eg os.path.split('/home/swaroop/byte/code/poem.txt') 结果:('/home/swaroop/byte/code', 'poem.txt')

    分离扩展名:os.path.splitext()

    获取路径名:os.path.dirname()

    获取文件名:os.path.basename()

    运行shell命令:os.system()

    读取和设置环境变量:os.getenv() 与os.putenv()

    给出当前平台使用的行终止符:os.linesep    Windows使用'\r\n',Linux使用'\n'而Mac使用'\r'

    指示你正在使用的平台:os.name 对于Windows,它是'nt',而对于Linux/Unix用户,它是'posix'

    重命名:os.rename(old, new)

    创建多级目录:os.makedirs(r“c:\python\test”)

    创建单个目录:os.mkdir(“test”)

    获取文件属性:os.stat(file)

    修改文件权限与时间戳:os.chmod(file)

    终止当前进程:os.exit()

    获取文件大小:os.path.getsize(filename)

    文件操作:

    os.mknod("test.txt") #创建空文件
    
    fp = open("test.txt",w)  #直接打开一个文件,如果文件不存在则创建文件

    关于open 模式:

    • w     以写方式打开
    • a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
    • r+     以读写模式打开
    • w+     以读写模式打开 (参见 w )
    • a+     以读写模式打开 (参见 a )
    • rb     以二进制读模式打开
    • wb     以二进制写模式打开 (参见 w )
    • ab     以二进制追加模式打开 (参见 a )
    • rb+    以二进制读写模式打开 (参见 r+ )
    • wb+    以二进制读写模式打开 (参见 w+ )
    • ab+    以二进制读写模式打开 (参见 a+ )
    fp.read([size])  #size为读取的长度,以byte为单位
    
    fp.readline([size])  #读一行,如果定义了size,有可能返回的只是一行的一部分
    
    fp.readlines([size])   #把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分。
    
    fp.write(str) #把str写到文件中,write()并不会在str后加上一个换行符
    
    fp.writelines(seq)    #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入,不会在每行后面加上任何东西。
    
    fp.close()   #关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。  如果一个文件在关闭后还对其进行操作会产生ValueError
    
    fp.flush()   #把缓冲区的内容写入硬盘
    
    fp.fileno()    #返回一个长整型的”文件标签“
    
    fp.isatty()    #文件是否是一个终端设备文件(unix系统中的)
    
    fp.tell()#返回文件操作标记的当前位置,以文件的开头为原点
    
    fp.next()    #返回下一行,并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时,就是调用next()函数来实现遍历的。
    
    fp.seek(offset[,whence])  #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了,whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以a或a+的模式打开,每次进行写操作时,文件操作标记会自动返回到文件末尾。
    
    fp.truncate([size])   #把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。

    目录操作:

    os.mkdir("file")     #创建目录

    复制文件:

    • shutil.copyfile("oldfile","newfile") oldfile和newfile都只能是文件
    • shutil.copy("oldfile","newfile")   oldfile只能是文件夹,newfile可以是文件,也可以是目标目录

    复制文件夹:

    • shutil.copytree("olddir","newdir") olddir和newdir都只能是目录,且newdir必须不存在

    重命名文件(目录)

    • os.rename("oldname","newname") 文件或目录都是使用这条命令

    移动文件(目录)

    • shutil.move("oldpos","newpos")   

    删除文件

    • os.remove("file")

    删除目录

    • os.rmdir("dir")只能删除空目录
    • shutil.rmtree("dir")  空目录、有内容的目录都可以删

    转换目录

    • os.chdir("path")   换路径

    Python读写文件

    1.open

    使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。

    '''
    学习中遇到问题没人解答?小编创建了一个Python学习交流QQ群:531509025
    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    '''
    file_object = open('thefile.txt')
    try:
        all_the_text = file_object.read()
    finally:
        file_object.close()
    

    注:不能把open语句放在try块里,因为当打开文件出现异常时,文件对象file_object无法执行close()方法。

    2.读文件

    读文本文件

    input = open('data' , 'r')
    #第二个参数黑认为r
    input = open('data')

    读二进制文件

    input = open('data', 'rb')

    读取所有内容

    file_object = open('thefile.txt')
    try:
        all_the_text = file_object.read()
    finally:
        file_object.close()

    读固定字节

    '''
    学习中遇到问题没人解答?小编创建了一个Python学习交流QQ群:531509025
    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    '''
    file_object = open('abinfile', 'rb')
    try:
        while True:
            chunk = file_object.read(100)
            if not chunk:
                break
            do_something_with(chunk)
    finally:
        file_object.close( )

    读每行

    list_of_all_the_lines = file_object.readlines()

    如果文件是文本文件,还可以直接遍历文件对象获取每行:

    for line in file_object:
        process line

    3.写文件

    写文本文件

    output = open('data', 'w')
    

    写二进制文件

    output = open('data', 'wb')
    

    追加写文件

    output = open('data', 'w+')

    z写数据

    file_object = open('thefile.txt', 'w')
    file_object.write(all_the_text)
    file_object.close()

    写入多行

    file_object.writelines(list_of_text_strings)

    注意,调用writelines写入多行在性能上会比使用write一次性写入要高。

    在处理日志文件的时候,常常会遇到这样的情况:日志文件巨大,不可能一次性把整个文件读入到内存中进行处理,例如需要在一台物理内存为 2GB 的机器上处理一个 2GB 的日志文件,我们可能希望每次只处理其中 200MB 的内容。

    在 Python 中,内置的 File 对象直接提供了一个 readlines(sizehint) 函数来完成这样的事情。以下面的代码为例:

    file = open('test.log' , 'r')sizehint = 209715200
    # 20OMposition = olines = file.readlines(sizehint)while not file.tell() - position < 0:
    position = file.tel1()
    lines = file.readlines(sizehint)

    每次调用 readlines(sizehint) 函数,会返回大约 200MB 的数据,而且所返回的必然都是完整的行数据,大多数情况下,返回的数据的字节数会稍微比 sizehint 指定的值大一点(除最后一次调用 readlines(sizehint) 函数的时候)。通常情况下,Python 会自动将用户指定的 sizehint 的值调整成内部缓存大小的整数倍。

    file在python是一个特殊的类型,它用于在python程序中对外部的文件进行操作。在python中一切都是对象,file也不例外,file有file的方法和属性。下面先来看如何创建一个file对象:

    file(name[, mode[, buffering]])

    file()函数用于创建一个file对象,它有一个别名叫open(),可能更形象一些,它们是内置函数。来看看它的参数。它参数都是以字符串的形式传递的。name是文件的名字。

    mode是打开的模式,可选的值为r w a U,分别代表读(默认) 写 添加支持各种换行符的模式。用w或a模式打开文件的话,如果文件不存在,那么就自动创建。此外,用w模式打开一个已经存在的文件时,原有文件的内容会被清空,因为一开始文件的操作的标记是在文件的开头的,这时候进行写操作,无疑会把原有的内容给抹掉。由于历史的原因,换行符在不同的系统中有不同模式,比如在 unix中是一个\n,而在windows中是‘\r\n’,用U模式打开文件,就是支持所有的换行模式,也就说‘\r’ '\n' '\r\n'都可表示换行,会有一个tuple用来存贮这个文件中用到过的换行符。不过,虽说换行有多种模式,读到python中统一用\n代替。在模式字符的后面,还可以加上+ b t这两种标识,分别表示可以对文件同时进行读写操作和用二进制模式、文本模式(默认)打开文件。

    buffering如果为0表示不进行缓冲;如果为1表示进行“行缓冲“;如果是一个大于1的数表示缓冲区的大小,应该是以字节为单位的。

    file对象有自己的属性和方法。先来看看file的属性。

    '''
    学习中遇到问题没人解答?小编创建了一个Python学习交流QQ群:531509025
    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    '''
    closed #标记文件是否已经关闭,由close()改写
    
    encoding #文件编码
    
    mode #打开模式
    
    name #文件名
    
    newlines #文件中用到的换行模式,是一个tuple
    
    softspace #boolean型,一般为0,据说用于print

    file的读写方法:

    F.read([size]) #size为读取的长度,以byte为单位
    
    F.readline([size])
    
    #读一行,如果定义了size,有可能返回的只是一行的一部分
    
    F.readlines([size])
    
    #把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分。
    
    F.write(str)
    
    #把str写到文件中,write()并不会在str后加上一个换行符
    
    F.writelines(seq)
    
    #把seq的内容全部写到文件中。这个函数也只是忠实地写入,不会在每行后面加上任何东西。

    file的其他方法:
     

    F.close()
    
    #关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError
    
    F.flush()
    
    #把缓冲区的内容写入硬盘
    
    F.fileno()
    
    #返回一个长整型的”文件标签“
    
    F.isatty()
    
    #文件是否是一个终端设备文件(unix系统中的)
    
    F.tell()
    
    #返回文件操作标记的当前位置,以文件的开头为原点
    
    F.next()
    
    #返回下一行,并将文件操作标记位移到下一行。把一个file用于for ... in file这样的语句时,就是调用next()函数来实现遍历的。
    
    F.seek(offset[,whence])
    
    #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了,whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以a或a+的模式打开,每次进行写操作时,文件操作标记会自动返回到文件末尾。
    
    F.truncate([size])
    
    #把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。

    结尾给大家推荐一个非常好的学习教程,希望对你学习Python有帮助!

    Python基础入门教程推荐:更多Python视频教程-关注B站:Python学习者
     

    【Python教程】全网最容易听懂的1000集python系统学习教程(答疑在最后四期,满满干货)

    Python爬虫案例教程推荐:更多Python视频教程-关注B站:Python学习者
     

    2021年Python最新最全100个爬虫完整案例教程,数据分析,数据可视化,记得收藏哦

    展开全文
  • Python设计模式1-创建模式

    千次阅读 2015-11-15 21:15:20
    Python设计模式1-创建模式 工作时间一长,需求多而杂,往往难得有时间去仔细思量代码如何的更加优雅,习惯使然。设计模式本身不是一个神秘的东西,也许无意中也会用到,只是没有刻意去思考。正好找个时间,把...

    Python设计模式1-创建型模式

    本文简书地址: http://www.jianshu.com/p/2450b785c329

    工作时间一长,需求多而杂,往往难得有时间去仔细思量代码如何写的更加优雅,习惯使然。设计模式本身不是一个神秘的东西,也许无意中也会用到,只是没有刻意去思考。正好找个时间,把设计模式用python实现一遍,加深印象,为写出优雅的代码努力。

    1 设计模式简介

    设计模式的概念最初来自建筑学,记得以前读过一本《java与模式》,里面用道家思想讲设计模式,颇有新意。不过对于计算机领域的设计模式,大家一致认可的是GoF提出的设计模式,那本《设计模式》一书有点晦涩,不过好在另外有一本《深入浅出设计模式》,讲设计模式十分的通俗易懂,可以参考。设计模式分为创建型,结构型,行为型等几类。这个系列准备分三篇按照设计模式类型来总结,本篇文章里面提到的设计模式都属于创建型模式。

    2 工厂模式

    工厂模式可以分为简单工厂模式,工厂方法模式以及抽象工厂模式,这里以制作披萨作为例子来看看这几种模式的用法。所谓工厂模式其实是体现了设计模式中的依赖倒置原则,即要依赖抽象,而不是具体实现。

    2.1 简单工厂模式

    简单工厂模式实现很简单,我们单独用一个工厂类来创建不同类型的披萨。我们的例子中有三种类型的披萨,分别是cheese,clam,veggie三种口味。简单工厂的优点是实现简单,但是对变化不大友好,如果要增加口味或者新开分店,就要改动create_pizza函数代码。

    #!/usr/bin/env python
    #coding:utf8
    
    class Pizza(object):
      def prepare(self):
        print 'prepare pizza'
    
      def bake(self):
        print 'bake pizza'
    
      def cut(self):
        print 'cut pizza'
    
      def box(self):
        print 'box pizza'
    
    
    class CheesePizza(Pizza):
      def __init__(self):
        self.name = "cheese pizza"
    
    
    class ClamPizza(Pizza):
      def __init__(self):
        self.name = "clam pizza"
    
    
    class VeggiePizza(Pizza):
      def __init__(self):
        self.name = "veggie pizza"
    
    
    class SimplePizzaFactory(object):
      def create_pizza(self, type):
        pizza = None
    
        if type == "cheese":
          pizza = CheesePizza()
        elif type == "clam":
          pizza = ClamPizza()
        elif type == "veggie":
          pizza = VeggiePizza()
    
        return pizza
    
    
    
    class PizzaStore(object):
      def __init__(self, factory):
        self.factory = factory
    
      def order_pizza(self, type):
        pizza = self.factory.create_pizza(type)
        pizza.prepare()
        pizza.bake()
        pizza.cut()
        pizza.box()
        return pizza
    
    
    if __name__ == "__main__":
      store = PizzaStore(SimplePizzaFactory())
      pizza = store.order_pizza('cheese')
      print pizza.name

    2.2 工厂方法模式

    简单工厂模式在一个地方就把所有口味的披萨制作完成了,如果此时我们要在北京上海广州开分店,如果全部代码写在简单工厂里面,如果以后有代码变动,会难以维护,缺少弹性,而且对象依赖太多,设计模式告诉我们要依赖抽象,不要依赖具体类,要针对接口编程,而不是具体实现编程。简单工厂模式里面,PizzaStore是高层的组件,而Pizza是低层组件,PizzaStore过于依赖这些具体的披萨类如CheesePizza,ClamPizza等。工厂方法模式就是针对每一个分店加一个工厂,代码如下,当然在python里面我们也可以改进下create_pizza函数代码,通过globals()[type]()这种方式来创建对象,不需要写那么多的if-else:

    #!/usr/bin/env python
    #coding:utf8
    
    class Pizza(object):
      def prepare(self):
        print 'prepare pizza'
    
      def bake(self):
        print 'bake pizza'
    
      def cut(self):
        print 'cut pizza'
    
      def box(self):
        print 'box pizza'
    
    
    class GZCheesePizza(Pizza):
      def __init__(self):
        self.name = "guangzhou cheese pizza"
    
    
    class GZClamPizza(Pizza):
      def __init__(self):
        self.name = "guangzhou clam pizza"
    
    
    class GZVeggiePizza(Pizza):
      def __init__(self):
        self.name = "guangzhou veggie pizza"
    
    
    class PizzaStore(object):
      def create_pizza(self, item):
        raise NotImplementedError
    
      def order_pizza(self, type):
        pizza = self.create_pizza(type)
        pizza.prepare()
        pizza.bake()
        pizza.cut()
        pizza.box()
        return pizza
    
    
    class GZPizzaStore(PizzaStore):
      def create_pizza(self, type):
        pizza = None
    
        if type == "cheese":
          pizza = GZCheesePizza()
        elif type == "clam":
          pizza = GZClamPizza()
        elif type == "veggie":
          pizza = GZVeggiePizza()
    
        return pizza
    
    
    if __name__ == "__main__":
      gz_store = GZPizzaStore()
      pizza = gz_store.order_pizza('cheese')
      print pizza.name

    2.3 抽象工厂模式

    抽象工厂模式则是针对同一个产品簇来建立抽象工厂和具体工厂角色。所谓产品簇就是位于不同产品等级结构中,功能相关联的产品组成的家族。比如在我们的例子中,北京上海广州几个不同地区的分店都会有cheese,clam,veggie等口味的披萨,不同地区虽然风味和口味有所不同,但使用的原料有许多是一样的,这样原料就可以使用抽象工厂模式,这样不同地区不同口味的披萨可以使用相同的原料工厂。这里代码就不加示例了。

    3 单例模式

    单例模式用于生成特定类型的唯一对象,即全局只能有一个实例。在许多场景中,我们只是需要一个唯一的实例,比如一些工具类对象,我们通常只要一个实例即可,这样可以节约内存。一个实现如下,用一个私有内部类作为唯一单例对象:

    class OnlyOne(object):
        class __OnlyOne(object):
            def __init__(self, arg):
                self.val = arg
            def __str__(self):
                print 'call str'
                return repr(self) + self.val
        instance = None
        def __init__(self, arg):
            if not OnlyOne.instance:
                OnlyOne.instance = OnlyOne.__OnlyOne(arg)
            else:
                OnlyOne.instance.val = arg
    
    x = OnlyOne('sausage')
    y = OnlyOne('eggs')
    z = OnlyOne('spam')
    assert id(x.instance) == id(y.instance) == id(z.instance)```

    另一种感觉更pythonic的方法是复写类的__new__方法,如下:

    #!/usr/bin/env python
    #coding:utf8
    
    class Singleton(object):
      def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)
        return cls._instance
    
    
    class SingletonClass(Singleton):
      pass
    
    if __name__ == "__main__":
      instance1 = SingletonClass()
      instance2 = SingletonClass()
      assert id(instance1) == id(instance2)

    当然还有种称之为borg模式,据说比单例模式实现单例更好。

    class Borg(object):
        _state = {}
        def __new__(cls, *args, **kw):
          obj = super(Borg, cls).__new__(cls, *args, **kw)
          obj.__dict__ = cls._state
          return obj
    
    
    class SingleInstance(Borg):
      pass
    
    
    instance1 = SingleInstance()
    instance2 = SingleInstance()
    assert instance1.__dict__ is instance2.__dict__  #实例不同,但是字典相同
    assert id(instance1) != id(instance2)

    4 建造模式

    建造模式用于将构建复杂对象的过程和组成对象的组件解耦。一般有四个角色:指导者,抽象建造者,具体建造者,产品。首先需要创建一个具体建造者,然后将建造者传入指导者对象进行配置,然后指导者对象调用建造者的方法创建产品对象,最后客户端从指导者那里获取产品。与工厂模式不同的是,建造模式创建产品是在建造者对象中完成,而不像工厂模式产品创建是在产品类中完成的,一个示例如下,代码取自参考资料3:

    #!/usr/bin/python
    # -*- coding : utf-8 -*-
    
    """
    @author: Diogenes Augusto Fernandes Herminio <diofeher@gmail.com>
    https://gist.github.com/420905#file_builder_python.py
    """
    
    
    # Director
    class Director(object):
    
        def __init__(self):
            self.builder = None
    
        def construct_building(self):
            self.builder.new_building()
            self.builder.build_floor()
            self.builder.build_size()
    
        def get_building(self):
            return self.builder.building
    
    
    # Abstract Builder
    class Builder(object):
    
        def __init__(self):
            self.building = None
    
        def new_building(self):
            self.building = Building()
    
    
    # Concrete Builder
    class BuilderHouse(Builder):
    
        def build_floor(self):
            self.building.floor = 'One'
    
        def build_size(self):
            self.building.size = 'Big'
    
    
    class BuilderFlat(Builder):
    
        def build_floor(self):
            self.building.floor = 'More than One'
    
        def build_size(self):
            self.building.size = 'Small'
    
    
    # Product
    class Building(object):
    
        def __init__(self):
            self.floor = None
            self.size = None
    
        def __repr__(self):
            return 'Floor: {0.floor} | Size: {0.size}'.format(self)
    
    
    # Client
    if __name__ == "__main__":
        director = Director()
        director.builder = BuilderHouse()
        director.construct_building()
        building = director.get_building()
        print(building)
        director.builder = BuilderFlat()
        director.construct_building()
        building = director.get_building()
        print(building)
    
    ### OUTPUT ###
    # Floor: One | Size: Big
    # Floor: More than One | Size: Small

    5 原型模式

    原型模式即是通过拷贝原型对象来创建新的对象,python中提供了copy模块来实现原型模式。原型模式里面通常会有一个原型管理器,用于注册管理原型对象。注意原型模式中的copy与创建一个对象是不一样的,创建对象只是得到一个初始化的对象,而拷贝对象则可以保持对象的原有状态并在原来对象基础上进行操作。比如游戏里面创建角色,可以用到原型模式,对同样的属性不用改变,不同的属性可以拷贝对象后再重新设置。示例代码如下,取自参考资料3:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    
    import copy
    
    
    class Prototype(object):
    
        def __init__(self):
            self._objects = {}
    
        def register_object(self, name, obj):
            """Register an object"""
            self._objects[name] = obj
    
        def unregister_object(self, name):
            """Unregister an object"""
            del self._objects[name]
    
        def clone(self, name, **attr):
            """Clone a registered object and update inner attributes dictionary"""
            obj = copy.deepcopy(self._objects.get(name))
            obj.__dict__.update(attr)
            return obj
    
    
    class A(object):
        def __init__(self):
            self.x = 3
            self.y = 8
            self.z = 15
            self.garbage = [38, 11, 19]
    
        def __str__(self):
            return '{} {} {} {}'.format(self.x, self.y, self.z, self.garbage)
    
    
    def main():
        a = A()
        prototype = Prototype()
        prototype.register_object('objecta', a)
        b = prototype.clone('objecta')
        c = prototype.clone('objecta', x=1, y=2, garbage=[88, 1])
        print([str(i) for i in (a, b, c)])
    
    if __name__ == '__main__':
        main()
    
    ### OUTPUT ###
    # ['3 8 15 [38, 11, 19]', '3 8 15 [38, 11, 19]', '1 2 15 [88, 1]']

    6 对象池模式

    开发中总是少不了用到各种池,比如线程池,连接池等。对象池就是将对象用完后先不销毁,而是存起来,后面继续用,节省重新创建对象的开销。示例代码来自参考资料3:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    
    class QueueObject():
    
        def __init__(self, queue, auto_get=False):
            self._queue = queue
            self.object = self._queue.get() if auto_get else None
    
        def __enter__(self):
            if self.object is None:
                self.object = self._queue.get()
            return self.object
    
        def __exit__(self, Type, value, traceback):
            if self.object is not None:
                self._queue.put(self.object)
                self.object = None
    
        def __del__(self):
            if self.object is not None:
                self._queue.put(self.object)
                self.object = None
    
    
    def main():
        try:
            import queue
        except ImportError:  # python 2.x compatibility
            import Queue as queue
    
        def test_object(queue):
            queue_object = QueueObject(queue, True)
            print('Inside func: {}'.format(queue_object.object))
    
        sample_queue = queue.Queue()
    
        sample_queue.put('yam')
        with QueueObject(sample_queue) as obj:
            print('Inside with: {}'.format(obj))
        print('Outside with: {}'.format(sample_queue.get()))
    
        sample_queue.put('sam')
        test_object(sample_queue)
        print('Outside func: {}'.format(sample_queue.get()))
    
        if not sample_queue.empty():
            print(sample_queue.get())
    
    
    if __name__ == '__main__':
        main()
    
    ### OUTPUT ###
    # Inside with: yam
    # Outside with: yam
    # Inside func: sam
    # Outside func: sam

    7 参考资料

    展开全文
  • Python文件读写模式

    千次阅读 2019-05-27 19:57:32
    文件常见的读写模式 ... a 以追加模式打开 (从 EOF 开始, 必要时创建新文件) r+ 以读写模式打开 w+ 以读写模式打开 (参见 w ) a+ 以读写模式打开 (参见 a ) rb 以二进制读模式打开 wb...


    文件常见的读写模式
    w     以写方式打开,
    W     文件若存在,首先要清空,然后(重新)创建
    a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
    r+     以读写模式打开
    w+     以读写模式打开 (参见 w )
    a+     以读写模式打开 (参见 a )
    rb     以二进制读模式打开
    wb     以二进制写模式打开 (参见 w )
    ab     以二进制追加模式打开 (参见 a )
    rb+    以二进制读写模式打开 (参见 r+ )
    wb+    以二进制读写模式打开 (参见 w+ )
    ab+    以二进制读写模式打开 (参见 a+ )

     


    读取文件内容
    open 读取所有内容
    使用open打开文件后一定要记得调用文件对象的close()方法。
    file = open('thefile.txt')
    file.close( )

     

    with open('ecord.txt','a+',encoding = 'utf-8') as f:
         f.write(str+'\n')
    写完成自动关闭

     

    写入数据
    file_object = open('thefile.txt', 'w')
    file_object.write(all_the_text)
    file_object.close( )
    写文本文件
    output = open('data', 'w')

     

    写二进制文件
    output = open('data', 'wb')
    追加写文件
    output = open('data', 'w+')

     

    写入多行
    file.writelines(strings)

     

    注意,调用writelines写入多行在性能上会比使用write一次性写入要高。

     


    文件打开模式 w+ r+ a+ 区别和辨析
    w+ 打开文件并读写:

     

      1. 文件存在,则清空(也即写入空);

     

      2. 文件不存在,则创建文件 ;

     

      3. 文件流定位到开始位置, 所以read() 会得到空。
    r+  打开文件并读写:

     

        1. 文件存在,打开文件,文件指针定位到文件开始位置;

     

      2. 文件不存在, 则报错文件不存在。
    a+  打开文件并读写:

     

        1. 文件存在,打开文件,文件指针定位到文件开始位置,但不清空;

     

      2.  文件不存在,创建文件;

     

      3. 打开后读取时,在文件开头位置,

     

      4. 写入时,添加到文章末尾,并且指针位于添加后的末尾,所以再次读取会乱码。
    另外:
      1. w 打开文件写入,也会清空文件,如果使用read(),则报错;a 打开文件添加,数据流添加到文件末尾,而不是w模式的清空后,添加到文件末尾。
      2. b可以附加到上述的字母后,形成rb, rb+, wb等等模式,针对二进制文件,比如exe, elf, jpeg格式的文件,进行文件操作; 在unix 类型的系统上,text格式与二进制的处理相同,但是非unix类型的系统上,换行格式不同,所以需要用加b模式来在指定是否是二进制。

    展开全文
  • python 创建读写目录,文件

    千次阅读 2017-11-01 14:14:46
    python中对文件、文件夹(文件操作函数)的操作需要涉及到os模块和shutil模块。 得到当前工作目录,即当前Python脚本工作的目录路径: os.getcwd()返回指定目录下的所有文件和目录名:os.listdir()函数用来删除一个...

    python中对文件、文件夹(文件操作函数)的操作需要涉及到os模块和shutil模块。
    得到当前工作目录,即当前Python脚本工作的目录路径: os.getcwd()

    返回指定目录下的所有文件和目录名:os.listdir()

    函数用来删除一个文件:os.remove()

    删除多个目录:os.removedirs (r“c:\python”)

    检验给出的路径是否是一个文件:os.path.isfile()

    检验给出的路径是否是一个目录:os.path.isdir()

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

    检验给出的路径是否真实存在:os.path.exists()

    返回一个路径的目录名和文件名:os.path.split() eg os.path.split(‘/home/swaroop/byte/code/poem.txt’) 结果:(‘/home/swaroop/byte/code’, ‘poem.txt’)

    分离扩展名:os.path.splitext()

    获取路径名:os.path.dirname()

    获取文件名:os.path.basename()

    运行shell命令: os.system()

    读取和设置环境变量:os.getenv() 与os.putenv()

    给出当前平台使用的行终止符:os.linesep Windows使用‘\r\n’,Linux使用‘\n’而Mac使用‘\r’
    指示你正在使用的平台:os.name 对于Windows,它是‘nt’,而对于Linux/Unix用户,它是‘posix’

    重命名:os.rename(old, new)

    创建多级目录:os.makedirs(r“c:\python\test”)

    创建单个目录:os.mkdir(“test”)

    获取文件属性:os.stat(file)

    修改文件权限与时间戳:os.chmod(file)

    终止当前进程:os.exit()

    获取文件大小:os.path.getsize(filename)

    文件操作:
    os.mknod(“test.txt”) 创建空文件

    fp = open(“test.txt”,w) 直接打开一个文件,如果文件不存在则创建文件

    关于open 模式:
    w 以写方式打开,
    a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
    r+ 以读写模式打开
    w+ 以读写模式打开 (参见 w )
    a+ 以读写模式打开 (参见 a )
    rb 以二进制读模式打开
    wb 以二进制写模式打开 (参见 w )
    ab 以二进制追加模式打开 (参见 a )
    rb+ 以二进制读写模式打开 (参见 r+ )
    wb+ 以二进制读写模式打开 (参见 w+ )
    ab+ 以二进制读写模式打开 (参见 a+ )
    fp.read([size]) #size为读取的长度,以byte为单位
    fp.readline([size]) #读一行,如果定义了size,有可能返回的只是一行的一部分
    fp.readlines([size]) #把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分。
    fp.write(str) #把str写到文件中,write()并不会在str后加上一个换行符
    fp.writelines(seq) #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入,不会在每行后面加上任何东西。
    fp.close() #关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。 如果一个文件在关闭后还对其进行操作会产生ValueError
    fp.flush() #把缓冲区的内容写入硬盘
    fp.fileno() #返回一个长整型的”文件标签“
    fp.isatty() #文件是否是一个终端设备文件(unix系统中的)
    fp.tell() #返回文件操作标记的当前位置,以文件的开头为原点
    fp.next() #返回下一行,并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时,就是调用next()函数来实现遍历的。
    fp.seek(offset[,whence]) #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了,whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以a或a+的模式打开,每次进行写操作时,文件操作标记会自动返回到文件末尾。
    fp.truncate([size]) #把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。

    目录操作:
    os.mkdir(“file”) 创建目录
    复制文件:
    shutil.copyfile(“oldfile”,”newfile”) oldfile和newfile都只能是文件
    **shutil.copy(“oldfile”,”newfile”) **oldfile只能是文件夹,newfile可以是文件,也可以是目标目录

    复制文件夹:
    shutil.copytree(“olddir”,”newdir”) olddir和newdir都只能是目录,且newdir必须不存在
    重命名文件(目录)
    os.rename(“oldname”,”newname”) 文件或目录都是使用这条命令
    移动文件(目录)
    shutil.move(“oldpos”,”newpos”)
    删除文件
    os.remove(“file”)
    删除目录
    os.rmdir(“dir”)只能删除空目录
    shutil.rmtree(“dir”) 空目录、有内容的目录都可以删
    转换目录
    os.chdir(“path”) 换路径

    Python读写文件
    1.open
    使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。

    file_object = open('thefile.txt')
    try:
    all_the_text = file_object.read( )
    finally:
    file_object.close( )

    注:不能把open语句放在try块里,因为当打开文件出现异常时,文件对象file_object无法执行close()方法。
    2.读文件
    读文本文件
    input = open(‘data’, ‘r’)
    第二个参数默认为r
    input = open(‘data’)
    读二进制文件
    input = open(‘data’, ‘rb’)
    读取所有内容

    file_object = open('thefile.txt')
    try:
    all_the_text = file_object.read( )
    finally:
    file_object.close( )

    读固定字节

    file_object = open('abinfile', 'rb')
    try:
    while True:
    chunk = file_object.read(100)
    if not chunk:
    break
    do_something_with(chunk)
    finally:
    file_object.close( )

    读每行
    list_of_all_the_lines = file_object.readlines( )
    如果文件是文本文件,还可以直接遍历文件对象获取每行:
    for line in file_object:
    process line
    3.写文件
    写文本文件
    output = open(‘data’, ‘w’)
    写二进制文件
    output = open(‘data’, ‘wb’)
    追加写文件
    output = open(‘data’, ‘w+’)
    写数据

    file_object = open('thefile.txt', 'w')
    file_object.write(all_the_text)
    file_object.close( )

    写入多行
    file_object.writelines(list_of_text_strings)
    注意,调用writelines写入多行在性能上会比使用write一次性写入要高。
    在处理日志文件的时候,常常会遇到这样的情况:日志文件巨大,不可能一次性把整个文件读入到内存中进行处理,例如需要在一台物理内存为 2GB 的机器上处理一个 2GB 的日志文件,我们可能希望每次只处理其中 200MB 的内容。
    在 Python 中,内置的 File 对象直接提供了一个 readlines(sizehint) 函数来完成这样的事情。以下面的代码为例:

    file = open('test.log', 'r')
    sizehint = 209715200 
    # 200Mposition = 0
    lines = file.readlines(sizehint)
        while not file.tell() - position < 0:
                 position = file.tell() lines = file.readlines(sizehint)

    每次调用 readlines(sizehint) 函数,会返回大约 200MB 的数据,而且所返回的必然都是完整的行数据,大多数情况下,返回的数据的字节数会稍微比 sizehint 指定的值大一点(除最后一次调用 readlines(sizehint) 函数的时候)。通常情况下,Python 会自动将用户指定的 sizehint 的值调整成内部缓存大小的整数倍。
    file在python是一个特殊的类型,它用于在python程序中对外部的文件进行操作。在python中一切都是对象,file也不例外,file有file的方法和属性。下面先来看如何创建一个file对象:

    file(name[, mode[, buffering]])
    file()函数用于创建一个file对象,它有一个别名叫open(),可能更形象一些,它们是内置函数。来看看它的参数。它参数都是以字符串的形式传递的。name是文件的名字。
    mode是打开的模式,可选的值为r w a U,分别代表读(默认) 写 添加支持各种换行符的模式。用w或a模式打开文件的话,如果文件不存在,那么就自动创建。此外,用w模式打开一个已经存在的文件时,原有文件的内容会被清空,因为一开始文件的操作的标记是在文件的开头的,这时候进行写操作,无疑会把原有的内容给抹掉。由于历史的原因,换行符在不同的系统中有不同模式,比如在 unix中是一个\n,而在windows中是‘\r\n’,用U模式打开文件,就是支持所有的换行模式,也就说‘\r’ ‘\n’ ‘\r\n’都可表示换行,会有一个tuple用来存贮这个文件中用到过的换行符。不过,虽说换行有多种模式,读到python中统一用\n代替。在模式字符的后面,还可以加上+ b t这两种标识,分别表示可以对文件同时进行读写操作和用二进制模式、文本模式(默认)打开文件。
    buffering如果为0表示不进行缓冲;如果为1表示进行“行缓冲“;如果是一个大于1的数表示缓冲区的大小,应该是以字节为单位的。
    file对象有自己的属性和方法。先来看看file的属性。

    closed #标记文件是否已经关闭,由close()改写
    encoding #文件编码
    mode #打开模式
    name #文件名
    newlines #文件中用到的换行模式,是一个tuple
    softspace #boolean型,一般为0,据说用于print

    file的读写方法:
    F.read([size]) #size为读取的长度,以byte为单位
    F.readline([size])
    读一行,如果定义了size,有可能返回的只是一行的一部分

    F.readlines([size])
    把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分。

    F.write(str)
    把str写到文件中,write()并不会在str后加上一个换行符

    F.writelines(seq)
    把seq的内容全部写到文件中。这个函数也只是忠实地写入,不会在每行后面加上任何东西。

    file的其他方法:
    F.close()
    关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError

    F.flush()
    把缓冲区的内容写入硬盘

    F.fileno()
    返回一个长整型的”文件标签“

    F.isatty()
    文件是否是一个终端设备文件(unix系统中的)

    F.tell()
    返回文件操作标记的当前位置,以文件的开头为原点

    F.next()
    返回下一行,并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时,就是调用next()函数来实现遍历的。

    F.seek(offset[,whence])
    将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了,whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以a或a+的模式打开,每次进行写操作时,文件操作标记会自动返回到文件末尾。

    F.truncate([size])
    把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。

    展开全文
  • 主要介绍了python单例模式原理与创建方法,结合实例形式分析了Python单例模式的概念、原理、定义、使用方法及相关操作注意事项,需要的朋友可以参考下
  • 使用python写的使用但里模式创建的一个日志记录器,具体相关知识可以参阅我的博客。
  • 三、工厂模式:建立创建对象的工厂 工厂模式可以说是最常用的设计模式 本章主要介绍创建型设计模式:工厂模式 本章主题 了解简单工厂设计模式 讨论工厂方法和抽象工厂方法及其差异 利用Python 代码实现真实场景 ...
  • python 读写csv文件(创建,追加,覆盖)

    万次阅读 多人点赞 2018-08-28 14:52:19
    这篇博客讲述python怎样创建,读写,追加csv文件 创建: 利用csv包中的writer函数,如果文件不存在,会自动创建,需要注意的是,文件后缀一定要是.csv,这样才会创建csv文件 这里创建好文件,将csv文件的头信息...
  • python 程序员的 OpenGL 教程

    万次阅读 多人点赞 2019-01-26 08:47:24
    C / C++ / python / java 都可以很好支持 OpengGL,我当然习惯性选择 python 语言。 如果读者是 python 程序员,并且了解 numpy,接下来的阅读应该不会有任何障碍;否则,我建议先花半小时学习一下 python 语言。
  • 01. 单例设计模式 设计模式 设计模式是前人工作的总结和提炼,通常,被人们... 目的—— 让类创建的对象,在系统中只有唯一的一个实例 每一次执行类名()返回的对象,内存地址是相同的 单例设计模式的应用场...
  • Anaconda 创建 32 位 Python 环境

    千次阅读 2020-07-21 13:35:22
    首先进入 32 位模式,set CONDA_FORCE_32BIT=1,然后再创建环境默认就是 32 位的 Python了。使用 conda info 可查看该环境的详细信息。 恢复 64 位模式,使用命令 set CONDA_FORCE_32BIT=0 就可以了。 ...
  • Python读写文件各种模式详解

    千次阅读 2018-07-03 21:08:12
    Python读写文件涉及的问题 # 读写文件最好用 with...open...操作,这样最安全 with open(path,'r') as f: f.read() # 一次读取整个文件,当然可以设置读取大小,如f.read(128) f.readline() # 一次读取一行 f....
  • Python编程实战 运用设计模式、并发和程序库创建高质量程序
  • Python 读写 CSV 文件最简单的方法是使用自带的 csv 库,复杂...其实还是比较简单的,但是看到网上有人给了个错误的示范,还是有必要个正确的。一、Python 对 CSV 文件的读写操作新建文件:import csvdef create_...
  • Python编程实战-运用设计模式、并发和程序库创建高质量程序.Python编程实战-运用设计模式、并发和程序库创建高质量程序.
  • Python文件处理:创建、打开、追加、读、

    万次阅读 多人点赞 2018-08-14 16:16:16
    Python中,不需要导入外部库来读取和写入文件。... Python中的文件模式 如何创建文本文件 使用Python,您可以通过使用代码创建一个.文本文件(古鲁99.txt),我们在这里演示了如何做到这一点 第1步)  ...
  • 本文实例讲述了Python设计模式之原型模式。分享给大家供大家参考,具体如下: 原型模式(Prototype Pattern):用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象 一个原型模式的简单demo: #!/usr/bin/...
  • Python的文件是一个重要的对象,使用open()函数来打开文件,创建文件对象,进行文件的读写操作。当数据用于交换信息时,通常需要把数据保存为有格式的文本数据,可以保存为有特定的行分隔符和列分隔符的数据,这可以...
  • python对excel的操作,只读、只、读写、创建图表。
  • 即open(路径+文件名, 读写模式, 编码)在python对文件进行读写操作的时候,常常涉及到“读写模式”,整理了一下常见的几种模式,如下:读写模式:r :只读 r+ : 读写 w : 新建(会对原有文件进行覆盖) a : 追加...
  • python os模块 读写、创建 文件

    万次阅读 多人点赞 2019-02-20 14:59:31
    python中对文件、文件夹(文件操作函数)的操作需要涉及到os模块和shutil模块。 得到当前工作目录,即当前Python脚本工作的目录路径: os.getcwd() 返回指定目录下的所有文件和目录名:os.listdir() 函数用来...
  • python使用单例模式创建MySQL链接

    千次阅读 2018-03-29 14:01:16
    上一篇文章python通过跳板机连接MySQL中,实现了通过跳板机访问MySQL,在实际项目中,可能会在多个不同的方法中使用MySQL链接,如果每次都新建、关闭连接,当访问量高时可能会造服务器崩溃无法访问等问题,而单例...
  • Python 编程实战 运用设计模式、并发和程序库创建高质量程序高清电子书附加源码
  • 常用设计模式Python实现

    千次阅读 2019-04-24 13:00:27
    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 代码查看:...
  • Python设计模式:原型模式

    万次阅读 2019-12-29 13:39:11
    设计模式四:原型模式 什么是原型模式 创建某个时间点对原有对象的一个完全副本。 使用场景 重新创建原有对象没有意义时, 一个对象过于复杂不适合重新创建时, 希望对对象的某些部分变更但又希望保持原有对象不变时...
  • @概述 通过基本读写模式(只读r,覆写w,追加a,创x)我们可以方便地操作字符流文件的读写; 对于字节流文件(一切非字符型文件,包括媒体文件...字节读写模式与普通读写模式所不同的,仅仅在于读入和出的内容...
  • Python设计模式:工厂模式

    万次阅读 2019-12-26 22:28:03
    设计模式一:工厂模式 什么是工厂模式 根据提供的信息,在工厂的处理下,返回给想要的结果。 比如,甲方给工厂提供一个外形...2.可以通过工厂模式来对相似的对象创建进行分组 3.可以创建多个工厂,每个工厂负责一...
  • 前言第1章Python创建型设计模式 1.1抽象工厂模式 1.1.1经典的抽象工厂模式 1.1.2Python风格的抽象工厂模式 1.2建造者模式 1.3工厂方法模式 1.4原型模式 1.5单例模式第2章Python的结构型设计模式 2.1适配器...
  • python创建一个游戏的模式选项

    千次阅读 2020-05-28 18:31:12
    调用 tkinter 制作一个游戏机的选项: ...如果选择3, 显示“多人模式“ 如果选择Exit 则 退出 代码如下: from tkinter import * class Test(Frame): def printit(self): print("hi") def createWidgets(self)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 279,801
精华内容 111,920
关键字:

创建写模式python

python 订阅