精华内容
下载资源
问答
  • 文件对象 文件打开方法 open及file内建函数 1.作为打开文件之门钥匙”,内建函数open()以及file()提供了初始化输入/输出( I/O )操作通用接口 2.成功打开文件后时候会返回一个文件对象,否则引发一个错误 ...
  • 通过文件对象的实例方法write/writelines,可以写入字符串到文本文档,通过文件对象的实例方法read/readlines,可以读取文本文件的内容,文件读写完毕后,应该用close的方法关闭文件。 祭上教科书上的代码: ...

    用Python的内置函数open()创建、打开文件对象;通过文件对象的实例方法write/writelines,可以写入字符串到文本文档,通过文件对象的实例方法read/readlines,可以读取文本文件的内容,文件读写完毕后,应该用close的方法关闭文件。
    祭上教科书上的代码:

    import sys
    filename=sys.argv[0]#所读取并输出的就是本程序文件
    f=open(filename,'r',encoding='utf8')#打开文件
    line_no=0#统计行号
    while True:
        line_no +=1#行号计数
        line=f.readline()#读取行信息
        if line 
            print (line_no,":",line)#输出行号和行内容
        else:
            break
    f.close()#关闭打开的文件 
    教科书上的代码就是简单的读取程序本身的文件,先说明几点,sys.argv访问命令行参数,
    而sys.argv[0]为Python脚本名,就是运行的程序名,argv[1]就是第一个参数,往后类推。
    内置函数如何打开或创建文件对象,语法格式:
    f=open(file,mode='r',buffering=-1,encoding=None)
    file是要打开或创建的文件名,如果不在当前路径,需指出具体路径(只要是打开本程序之外的文件都要指明路径,
    这个也是今天第一个碰到的bug)mode是打开文件的模式,buffering表示是否使用缓存(默认为-1,表示使用系统默认的缓存区大小,
    encoding是文件的编码(这个是今日的第二个bug,折腾了好久)
    好了,基本介绍完了,但是作为一名有志之士当然不能满足教科书啦,当然要改动下
    ,来点刺激的读取指定路径文件试试。这里只是列举问题和解决的方法
    1、打开文件属性,找路径,一开始是直接把路径复制到filename那个位置上去,
    结果出BUG,第二次是把路径赋给第二行的filename,结果又出BUG,但是位置是放对了,
    后来查了下发现单纯地复制路径并不准确,要把路径用‘’括起来,
    然后前面加个r (filename=r'C:\Users\guoxang\Documents')但是BUG继续来,
    为什么?原因就是属性显示的路径只是文件所在的文件夹,所以以上路径只是文件所在的文件夹的位置,
    按这种读取的话应该是文件目录,当然有bug,好了继续修改,
    加上文件名filename=r'C:\Users\guoxang\Documents\python代码练习' 还是出bug,
    可能是本人对文件文件名概念不好导致的出bug,添加的文件名没有 加后缀,必须加上.txt filename=r'C:\Users\guoxang\Documents\python代码练习.txt'才是完整的路径。好了,继续走,
    又出bug,是因为记事本的字符编码类型跟要解释的类型utf-8不相同,是中文部分出问题,
    所以要在记事本保存的时候把编码格式改一下,改为utf-8,才能正常解码。
    第一次变更书上的代码就遇到坑,还坑的不浅,但是还是有很大的收获,
    希望各位大佬不要嘲笑我,这次时间有点紧张,就只是简单的说说解决方法,原理什么的,还没完全搞懂,就不写了。
    祭上修改好的代码
    import sys
    filename=r'C:\Users\guoxang\Documents\python代码练习.txt'
    f=open(filename,'r',encoding='utf_8')
    line_no=0
    while True:
        line_no +=1
        line=f.readline()
        if line:
            print(line_no,":",line)
        else:
            break
    f.close()
    运行结果:
    ![运行如下](https://img-blog.csdn.net/20180908115200405?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkyNDY1Ng==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 打开文件并创建文件对象 file = open(filename, mode, buffering) file: 被创建文件对象、 filename: 要创建或者打开文件文件名,需要使用单引号或者双引号括起来。待打开文件在当前位置,不用使用绝对路径,...

    ​​​​在这里插入图片描述

    python进阶篇

    文件与IO

    1.基本文件操作

    在使用文件对象时,首先需要通过内置的open()方法创建一个文件对象,然后 通过该对象提供的方法进行一些基本文件操作。

    • 1.创建和打开文件

      • open()

        打开文件并创建文件对象

        file = open(filename, mode, buffering)
        file: 被创建的文件对象
        filename: 要创建或者打开文件的文件名,需要使用单引号或者双引号括起来。待打开的文件在当前位置,不用使用绝对路径,否则使用。
        mode: 可选参数,用于指定文件的打开模式。具体P203页
        buffering: 可选参数,用于指定读写文件的缓冲模式。0,不缓存;1,缓存;大于1,则表示缓冲区大小。默认为缓存模式。

        • 1.file = open(“status.txt”)

          • 打开一个不存在的文件时先创建该文件,否则会抛出异常

            • 解决方案

              在当前目录下创建一个名为“status.txt”文件。
              在调用open()函数时,指定mode的参数为w、w+、 a、a+。这样,当要打开的文件不存在时,就可以创建新的文件了。

        • 2.以二进制的形式打开文件

          使用open()函数不仅可以以文本的形式打开文本文件,而且可以以二进制形式打开非文本文件,如图片、音频、视频等。

          • file = open(“picture.png”, ‘rb’)
        • 3.打开文件时指定编码方式

          open()函数打开文件时,默认采用GBK编码,当打开的不是GBK编码时将抛出异常。

          • file = open(‘notice.txt’, ‘r’, encoding=‘utf-8’)
    • 2.close()

      打开文件后,需要及时关闭,以免对文件造成不必要的破坏。

      • file.close()

        close()方法先刷新缓冲区中没有写入的信息,然后在关闭文件,这样可以将没有写入到文件的内容写入到文件中。在关闭文件后,便不能再进行写入操作了。

    • 3.打开文件时使用with语句,保证文件执行完操作后正常关闭。

      打开文件后,要及时将其关闭。从而实现在处理文件时,无论是否抛出异常,都能保证with语句执行完毕后关闭已经打开的文件。
      基本语法格式:
      with 表达式 as target:
        with语句体

      例子:
      with open(“message.txt”, ‘w’) as file:
        pass # 可以改成其他操作语句

    • 4.写入文件内容

      • file.write(string)

        file为打开的文件对象;string为要写入的字符串。
        调用write()方法向文件中写入内容的前提是, 打开文件时,指定的打开模式为w(可写)或者a(追加),否则抛出异常。

    • 5.读取文件

      • 1.读取指定字符

        • file.read([size])

          file为打开的文件对象;size为可选参数,用于指定要读取的字符个数,如果省略则一次性读取所有内容。
          在调用read()方法读取文件内容的前提是,打开文件时,指定的打开模式为r(只读)或者r+(读写),否则将抛出异常。

          例子:
          with open(“message.txt”, ‘r’) as file:
           string = file.read(9)
           print(string)
          注:使用read(size)方法读取文件时,是从文件的开头读取文件。
          指定位置读取文件,file.seek(offset[,whence])
          file: 表示已经打开的文件对象。
          offset: 用于指定移动的字符个数,其具体位置与whence有关。
          whence: 用于指定从什么位置开始计算。值为0表示从文件头开始计算,值为1表示从当前位置开始计算,值为2表示从文件尾开始计算,默认值为0。
          例子:
          with open(“message.txt”, ‘r’) as file:
           file.seek(14) # 移动文件指针到新的位置
           string = file.read(8) # 读取8个字符
           print(string)
          具体见 P208页

          • read()方法读取文件时,如果文件很大,一次读取全部内容到内存,容易造成内存不足。
      • 2.读取一行

        • file.readline()

          with open(”message,txt“, ‘r’) as file:
          number = 0 # 记录行号
          while True:
           number +=1
           line = file.readline()
           if line == ’ ':
            break
          print(number, line, end = ‘\n’) # 输出一行内容

      • 3.读取全部行

        • file.readlines()

          读取全部行的作用同调用read()方法时不指定size类似,只不过读取全部行时,返回的是一个字符串列表,列表每个元素为文件的一行内容。
          例子:
          with open(”message,txt“, ‘r’) as file:
           message = file.readlines()
           print(message)

          • 如果文件比较大时,采用该方法输出读取的文件内容会很慢,这时可以将列表的内容逐行输出。

            例子:
            with open(”message,txt“, ‘r’) as file:
             messageall = file.readlines()
             for message in messageall:
              print(message)

    2.目录操作

    在python中,内置了os模块以及其子模块os.path,用于对目录或者文件进行操作。

    • 1.os和os.path模块

      • os.sep:用于获取当前操作系统上的换行符,其他部分参见P211页
    • 2.路径

      • 1.相对路径

        import os
        print(os.getcwd()) # 输出当前目录
        其依赖于当前工作目录

      • 2.绝对路径

        import os
        print(os.path.abspath(r’demo\message.txt’)) # 获取绝对路径
        不依赖于当前工作目录

      • 3.拼接路径

        如果想将两个或者多个路径拼接到一起组成一个新的路径,可以使用os.path模块提供的join()函数实现。
        语法格式:
        os.path.join(‘path1,[,path2[,…]]’)
        路径之间用‘ ,’隔开。
        如果路径中没有一个绝对路径,那么最后拼接出来的将是一个相对路径。
        注:使用os.path.join()函数拼接路径时,并不会检测路径是否真实存在。

        例子:
        import os
        print(os.path.join(“E:\program\Python\Code”, “demo\message.txt”))

        如果存在多个绝对路径,那么以从左到右的顺序最后一次出现为准,并且该路径之前的参数都将被忽略。

        • 两个路径拼接成一个路径时,不要直接使用字符串拼接,而使用os.path.join()函数,这样可以正确的处理不同操作系统的路径分隔符。
    • 3.判断目录是否存在

      • os.path.exists(path)

        其中的path可以采用绝对路径,也可以使用相对路径
        返回值:如果给定的路径存在,返回Ture,否则返回False

    • 4.创建目录

      • 1.创建一级目录

        注:该函数只能创建指定路径中的最后一级路径,如果该路径的上一级不存在,则抛出异常FileNotFoundError。

        • os.mkdir(path, mode = 0o777)

          path: 可以是绝对路径,也可以是相对路径。
          mode: 用于指定数值模式,默认值为0777。该参数在非UNIX系统上无效或者被忽略。
          例子:
          import os
          os.mkdir(“C:\demo”)
          如果路径已经存在,将会抛出FileExistsError异常。
          解决办法:
          import os
          path = ‘C:\demo’
          if not os.path.exists(path):
           os.makedir(path)
           print(“目录创建成功!”)
          else:
           print(“该目录已经存在!”)

      • 2.创建多级目录

        • os.mkdirs(name, mode=0o777)

          import os
          os.makedirs(“C:\demo\test\dir\mr”)
          创建C:\demo\test\dir\mr

    • 5.删除目录

      • 使用rmdir()函数只能删除空的目录

        • os.rmdir(path)

          其中,path为要删除的目录,可以是相对路径,也可以是绝对路径。
          例子:
          import os
          os.rmdir(”C:\demo\test\dir\mr“)

          删除C:\demo\test\dir目录下的mr目录,如果删除的目录不存在将会抛出FileNotFoundError异常。

      • 删除非空目录

        • shutil.rmtree(“C:\demo\test”)

          import shutil
          shutil.rmtree(“C:\demo\test”)

          要删除不为空的”C:\demo\test“目录。

    • 6.遍历目录

      指对 指定目录下 的全部目录(包含子目录)及文件浏览一遍。
      os.walk(top[, topdown][, onerror][, followlinks])
      参数说明:
      top: 用于指定要遍历内容的根目录
      topdown: 可选参数,用于指定遍历的顺序,Ture,表示自上而下遍历(即先遍历根目录);False,表示自下而上遍历(即先遍历最后一级子目录),默认为Ture。
      onerror: 可选参数,用于指定错误处理方式,默认为忽略。
      followlinks: 可选参数,详见P218页
      返回值:返回一个包含三个元素的(dirpath, dirnames, filenames)的元组生成器对象。
      dirpath: 当前遍历的路径,是一个字符串
      dirnames: 当前路径下包含的子目录,是一个列表
      filenames: 当前路径下包含的文件,也是一个列表
      例子:
      import os
      tuples = os.walk(“E:\program\Python\Code\01”)
      for tuple1 in tuples:
       print(tuple,’\n’)

      • os.walk(path)返回(路径,子路径,文件)的元组

    3.高级文件操作P219页

    • 1.删除文件

      • os.remove(path)

        import os
        path = “mrsoft.txt”
        if os.path.exists(path):
         os.remove(path)
         print(“文件删除完毕!”)
        else:
         print(“文件不存在!”)

    • 2.重命名文件和目录

      • os.rename(src, dst)

        src: 用于指定重命名的目录和文件
        dst: 用于指定重命名后的目录或者文件
        例子:
        import os
        src = “C:\demo\test\dir\mr\mrsoft.txt” 换为目录“demo”
        dst = “C:\demo\test\dir\mr\mr.txt” 换为目录“test”
        if os.path.exists(src):
         os.rename(src, dst)
         print(“文件重命名完毕!”)
        else:
         print(“文件不存在!”)

    • 3.获取文件基本信息

      在计算机上创建文件后,该文件本身就会包含一些信息。
      stat()函数可以获取最后一次访问时间、最后一次修改时间、文件大小等基本信息。
      object = os.stat(path),该函数的返回值是一个对象,该对象包含以下属性,
      st_mode:保护模式
      st_dev:设备名
      st_ino:索引号
      st_uid:用户名
      st_nlink:硬链接号
      st_gid:组ID
      st_size:文件大小,单位为字节
      st_atime:最后一次访问时间
      st_mtime:最后一次修改时间
      st_ctime:最后一次状态变化时间

    函数

    函数的定义:
    def functionname([parameterlist1,parameterlist2]):
     [’’’ 注释’’’]
     [函数体]

    函数体:不知道填写什么,可以用pass替代或者“ … ”替代

    1.函数调用

    • functionname([参数])

      • 参数之间用" , "分隔
      • 无参数,不传参

    2.参数传递

    形参和实参:
    (1)形参:
    在函数定义 / 创建时,函数名后面括号中的参数为“形式参数”
    (2)实参
    在调用函数时,函数名后面括号中的参数为"实际参数"

    注:
    (1)当实参为不可变对象时,进行的是值得传递==>值传递后,改变形参的值,实参的值不变
    (2)当实参为可变对象时,进行的是引用传递==>引用传递时,改变形参的值,实参的值也一同变化

    P162页

    • 1.位置参数

      • 参数在调用时的数量和位置必须和定义时一样
    • 2.关键字参数

      • 使用形参的名字来确定输入的参数值

        注:通过该方式指定实参时,不再需要与形参的位置完全一致,只要将参数名写正确即可。

    • 3.为参数设置默认值

      调用函数时,如果没有指定某个参数将抛出异常,即在定义函数时,直接指定形式参数的默认值。
      定义函数时,指定默认的形参必须在所有参数的最后,否则将产生语法错误。
      def functionname(…, [parameter1 = defualtvalue1]):
      [函数体]

      注意:定义函数时,为形式参数设置默认值要牢记一点==>默认参数必须指向不可变对象。

      • 查看当前函数的默认参数值,函数名._defaults_,其结果是一个元组

      • 可变对象最好使用None作为默认值,否则会出现意料之外的值,P166,这时还需要进行代码的检查

        def demo(obj=None):
         if obj == None:
          obj = [ ]
         print(“obj的值:”,obj)
         obj.append(1)

    • 4.可变参数

      • 可变参数也称为不定长参数,即传入函数的实际参数可以是0个、1个、两个到任意个。

          1. *parameter
          • 表示接受任意多个实际参数,并将其放到一个元组中

            def functionname(*name):
             print("\n我们喜欢的球员有:")
             for item in name:
              print(item)

            functionname(‘邓肯’, ‘乔丹’)

            • 扩展:使用一个已存在的列表作为函数的可变参数,可以在列表的名称前加“ * ”.

              param = [‘邓肯’, ‘帕克’, ‘詹姆斯’]
              functionname(*param)

          1. **parameter
          • 表示任意多个显式赋值的实际参数,并将其放到一个字典中

            def functionname(**sign):
             print( ) # 输出一个空行
             for key, value in sign.items():
              print("[" + key +"] 的绰号是:" + value)

            functionname(邓肯=‘石佛’, 罗冰逊 =‘海上将军’)

            • 扩展:使用一个已经存在的字典作为函数的可变参数,可以在字典的名字前面加“ ** ”

              dict1 = {‘邓肯’: ‘石佛’, ‘罗宾逊’: ‘海上将军’, ‘吉诺比利’: ‘妖刀’}
              functionname(** dict1)

    3.返回值: result = return [value]

    4.变量的作用域

    • 1.局部变量

      • 指在函数内部定义并使用的变量
    • 2.全局变量

      • 能够作用于函数内外的变量

      • 两种形式

        • 1.在函数外定义

        • 2.在函数内定义

          • 使用global关键字修饰

            • 可以利用该方法,在函数体内修改全局变量值

    5.匿名函数

    • 利用关键字lambda

      • result = lambda[arg1, [,arg2, …,argn]]:expression

        例子:

    	  import math
    	  r = 10
    	  result = lambda r: math.pi *r*r
    	  print('半径为', r, '的面积为:',result(r))
    

    模块

    • Python 标准库中的模块,标准模块;
    • 第三方模块;
    • 自己开发的自定义模块。

    python中的一个".py"文件就是一个模块。

    1.自定义模块

    • 1.创建模块,创建的模块尽量不要与Python自带的标准模块名形同。
    • 2.导入模块
      import modelname [as 别名]
      import test1, test2, ...			# 导入多个模型,使用","分隔,不推荐该方法 
      from 模块名 import member/* 			# 利用dir()查看具体导入了哪些定义(变量、函数或者类等)
    
    - 模块搜索目录
    
      1、在当前目录(即执行的python脚本文件所在目录)下查找
      2、到PYTHONPATH(环境变量)下的每一个目录中查找
      2、到Python的默认安装目录下查找
      以上各个目录的具体位置保存在标准模块sys的sys.path变量中
      import sys
      print(sys.path) # 输出具体目录
      
      
      我们可以通过以下3种方式添加指定的目录带sys.path中。P193
      1.临时添加
      2.增加.pth文件(推荐)
      3.在PYTHONPATH环境变量中添加
    

    2.python中的包(文件夹)

    • 1.创建包

      (1) 创建一个文件夹(setting)
      (2) 在文件夹中创建一个__init__.py的文件,可以不写任何内容,再导入包是会自动执行。

    • 2.使用包

      (1) import+完整包名+模块名

      import setting.size
      通过这种方式导入的模块后,在使用时需要使用完整的名称。
      例子:
      import seeting.size
      if __name__ =='__main__': #__name__,程序可以检查该变量,以确定它在哪个模块中执行
      	print(‘高度:’,setting.size.width)
      	print('宽度:',setting.size.height)
      

      (2) from+完整包名+import+模块名

      from seeting import size
      if __name__ =='__main__': 
      	print(‘高度:’,size.width)
      	print('宽度:',size.height)
      #无需加包名setting
      

      (3) from+完整包名+模块名+import+定义名:加载指定模块

      # 导入setting包下size模块中的width和height变量
      from seeting.size import width, height (*代替全部定义被加载)
      if __name__ =='__main__': 
      	print(‘高度:’,width)
      	print('宽度:',height)
      

    类和对象

    1.类

    • 1.类的定义

      class ClassName:
       ‘’‘类的帮助信息’’’
       statement

      设计图也就绪,🤭

    • 2.创建类的实例

      • ClassName(parameterlist)
    	  class Geese:
    	  '''大雁类'''
    	  	pass
    		  
    	  wildGoose=Geese()
    	  print(wildGoose)
    
    • 3.魔术方法

      • init()

        P178页

    	  class Geese:
    	  	‘’‘大雁类’‘’
    	  	def __init__(self):  
    	  	# 其中除了self参数外,还可以自定义一些其他参数,例如:def __init__(self, beak, wing, claw):
    	  		print(“大雁类”)
    	  
    	  wildGoose = Geese()  
    
      在创建类后,类通常会自动创建一个__init__()方法。
      每当创建一个类的新实列时,Python都会自动执行它。
      __init__()方法必须包含一个self参数,并且必须是第一个参数。
      self参数是一个指向实列本身的引用,用于访问类中的属性和方法。在方法调用时会自动传递实际参数self。
    
    	- Python中默认的方法
    
    • 4.创建类的成员并访问

    类的成员主要由实例方法和数据成员组成,可以通过类的实例进行访问。

    (1)创建实例方法并访问

    所谓的实例方法(行为)是指在类中定义的函数。同_init_()方法一样,实例方法的第一个参数为self,并且必须包含一个参数self。

    	  def functionname(self, parameterList):
    	  	block # 方法体
    	  
    	  实例名.functionname(parameterValue)
    	  # 其中的参数个数和类中的实例方法个数一致
    

    (2)创建数据成员并访问
     数据成员是指在类中定义的变量,即属性。
     根据定义的位置又可以分为类属性和实例属性。

    	- 类属性
    
    	  类属性是指定义在类中,并且在函数体外的属性。
    	  类属性可以在类的所有实例之间共享值,也就是在所有实例化的对象中公用。
    	  class Geese:
    	  	'''大雁类'''
    	  	neck = "脖子较长"		# 定义类属性
    	  	wing = “振翅频率高”		# 定义类属性
    	  	leg = “腿位于身份的中心支点,行走自如”			# 定义类属性
    	  	def __init__(self):			# 定义类方法(相当于构造方法)
    	  		print("我是大雁类,我具有以下特征")
    	  		print("Geese.neck")
    	  		print("Geese.wing")
    	  		print("Geese.leg")
    	  
    	  geese = Geese() # 实例化过程中运行
    
    	- 实例属性
    
    	  是指定义在类的方法中的属性,只作用与当前实例中。
    	  class Geese:
    	  	'''大雁类'''
    	  	def __init__(self):			# 定义类方法(相当于构造方法)
    	  		neck = "脖子较长"		# 定义实例属性
    	  		wing = “振翅频率高”		# 定义实例属性
    	  		leg = “腿位于身份的中心支点,行走自如”	# 定义实例属性
    	  		print("我是大雁类,我具有以下特征")
    	  		print("self.neck")
    	  		print("self.wing")
    	  		print("self.leg")
    	  
    	  geese = Geese() # 实例化过程中运行
    
    • 5.访问权限

    Python中并没有对属性和方法的访问权限进行限制.

    - (1)尾都有双下划线,__foo__
    
    	- 表示定义特殊方法,一般是系统定义名字,如__init__()
    
    - (2)头一个下划线,_foo
    
    	- 表示protected(保护)类型的成员,只允许类本身和子类进行访问,但是不能使用"from module import *"语句导入
    
    	  class Swan:
    	  	‘’‘天鹅类’‘’
    	  	_neck_swam='天鹅的脖子很长' 		# 定义私有属性
    	    def __init__(self):
    	  		print('__init__():'  Swan.__neck_swan)	# 在实例方法中访问私有属性
    	  
    	  swan = Swam() # 创建Swam类的实例
    	  print("直接访问:", swam._neck_swan) #保护属性可以通过实例名访问
    
    		- 可以通过类名和实例名进行访问
    
    - (3)头两个下划线,__foo
    
    	- 表示private(私有)类型的成员,只允许定义该方法的类本身进行访问,而且不能通过类的实例进行访问,但是可以通过"类的实列名.类名__xxx"方式访问
    
    	  class Swan:
    	  ’‘天鹅类’‘’
    	  __neck_swam='天鹅的脖子很长' 		# 定义私有属性
    	  def __init__(self):
    	  		print('__init__():'  Swan.__neck_swan)	# 在实例方法中访问私有属性
    	  
    	  swan = Swam() # 创建Swam类的实例
    	  print("加入类名:", swam._Swan__neck_swan) # 私有属性,可以通过"实例名.类名__xxx"方式访问
    	  print("直接访问:", swam.__neck_swan) # 私有属性不能通过实例名访问,错误❌
    
    		- 可以 通过类名访问,或者“实例名.类名__xxx”访问,但是不能直接通过“实例名.属性名”方式访问
    

    2.属性

    • (1)创建用于计算的属性

      通过@property(装饰器)将一个方法转化为属性,从而实现用于计算机的属性。
      将方法转换为属性后,可以直接通过方法名来访问,不需要在添加“()”。

      语法格式:
      @property
      def methodname(self):
      	block
      
      例子:
      class Rect:
      	def __init__(self, width, height):
      		self.width = wifth
      		self.height = height
      	@property		# 将方法转化为属性
      	def area(self):
      		return self.width*self.height
      rect = Rect(800,600)
      print(“面积:”,rect.area) # 访问的时候没有添加"()"
    
    • (2)为属性添加安全保护机制
      class TVshow:
      	def __init__(self, show):
      		self.__show = show
      	@property			# 将方法转化为属性
      	def show(self):
      		return self.__show		# 返回私有属性的值
      tvshow=TVshow("正在播放《战狼2》")	
      print("默认:" tvshow.show)
      
      tvshow.show="正在播放《红海行动》"	 #修改属性的值
      print("默认:" tvshow.show) 		# ❌无法修改
    
    	- 实现只读属性
    

    3.继承

    被继承的类称为父类或者基类,新的类称为子类或者派生类。

    语法格式:
    class ClassName(基类1,基类2,...) # 如果不指定,将适用所有python对象的根类object
    		''类的信息'''
    		类体
    
    • 方法重写P186

    • 子类中调用父类的__init__()方法

      • 利用super()函数
    	super().__init__() # 调用基类的__init__()方法
    
    展开全文
  • 在Linux系统中,一切都是文件。...创建文件对象通过Python内置函数open()可以很容易创建一个文件对象。open函数有很多参数,最常用有两个,使用open函数最常用方法是:open(filename, mode)。f = op...

    在Linux系统中,一切都是文件。但我们通常说的文件是保存在磁盘上的图片、文档、数据、程序等等。而在程序的IO操作中,很多时候就是从磁盘读写文件。本节我们讲解Python中的文件对象如何操作文件。

    1460000019217705

    创建文件对象

    通过Python内置函数open()可以很容易的创建一个文件对象。open函数有很多参数,最常用的有两个,使用open函数最常用的方法是:open(filename, mode)。

    f = open('myfile', 'w')

    第一个参数filename是文件名的字符串,比如myfile。第二个参数也是一个字符串,表示文件使用方式。mode的可选项如下:

    mode

    含义

    "r’

    以只读模式打开(默认)

    "w’

    以可写模式打开,并清楚文件内容(如果文件存在的话)

    "x’

    创建一个新文件并以可写模式打开

    "a’

    以可写模式打开,从文件末尾开始写入(如果文件存在的话)

    "b’

    二进制模式

    "t’

    文本模式(默认)

    ’+’

    打开一个已存在文件以便进行更新(读和写)

    其中的'b'和't'是指定文件内容是文本还是二进制,其它都说是关于读写方式的。

    'b'是二进制模式打开文件,读写的数据都是字节对象(bytes),这个模式可以读写一切文件,包括文本文件,但读写文本文件时要注意编码的问题。

    't'是文本模式下读写文件。读取时,默认会把平台特定的行结束符 (Unix 上的 , Windows 上的  )转换为 。写入是,默认会把出现的  转换回平台特定的结束符。这种默认的“幕后修改”对文本文件来说没有问题,但会破坏二进制数据(比如,JPEG或exe)文件中的数据。

    在使用open创建文件对象时,最好使用 with 关键字。其好处是,当字句体结束后文件会正确关闭,即使在某个时刻引发了异常。并且with比等效的try-finally代码块更简短:

    In [102]: with open('myfile') as f:

    ...: data = f.read()

    ...:

    In [103]: f.closed

    Out[103]: True

    如果没使用with关键字,就要调用f.close()来关闭文件并立即释放它使用的系统资源。如果没有显示的关闭文件,Python的垃圾回收器最终将销毁该对象并为你关闭打开的文件,但这个文件可能会保持打开状态一段时间。另外一个风险是不同的Python实现会在不同的时间进行清理。

    通过 with 语句或者调用 f.close() 关闭文件对象后,尝试使用该文件对象将自动失败。

    文件对象的方法

    通过上面的方法创建文件对象f后,,我们就可以通过其对应的方法读写数据了。

    (1)写内容到文件:f.write(string)

    把内容写入文件的方法是write()方法,传递的对象必须是字符串(文本模式下)或字节对象(二进制模式下)。如果要写入其它类型的对象(比如,字典、列表等等),就要先把它们转换成字符串(文本模式下)或字节对象(二进制模式下)。

    In [109]: f = open('myfile', 'w')

    In [110]: f.write('认真学Python,就是文件的全部内容。 ')

    Out[110]: 21

    In [111]: f.close()

    (2)读取文件内容:f.read(size)

    它会读取文件里面的数据并将其返回为字符串(在文本模式下),或者字节对象(二进制模式)。参数size是一个可选的整数参数,当size被省略或为负的时候,读取文件的全部内容;如果文件的大小是机器内存的两倍或更大,那么可能出现错误。读取并返回的size大小的内容。如果已经读完全部内容(到达文件末尾),将返回一个空字符串。

    In [112]: f = open('myfile')

    In [113]: f.read()

    Out[113]: '认真学Python,就是文件的全部内容。 '

    In [114]: f.read()

    Out[114]: ''

    f.readline() 从文件读取一行,换行符 留住字符串末尾;

    f.readlines() 读取文件所有行,返回一个字符串的列表;

    In [118]: f.readline()

    Out[118]: '认真学Python,就是文件的全部内容。 '

    In [119]: f.seek(0)

    Out[119]: 0

    In [120]: f.readlines()

    Out[120]: ['认真学Python,就是文件的全部内容。 ']

    遍历文件的所有行,也可以用遍历文件对象的方式,这是内存高效、快速并简单的方式:

    In [122]: for line in f:

    ...: print(line)

    ...:

    认真学Python,就是文件的全部内容。

    (3)文件对象的位置

    前面的例子中,我们已经读到文件的末尾,如果要再从头读的话就要调用f.seek(0)来设置文件对象的位置到文件开头。这个方法有两个参数:f.seek(cookie, whence=0)

    cookie 是位置偏移量

    whence 是相对位置,它有三种相对位置:

    0 文件开头,偏移量是0或整数;

    1 当前位置,偏移量可以是负数;

    2 文件末尾,偏移量通常是负数;

    如何查看当前位置呢?调用f.tell()方法。

    展开全文
  • Python的文件是一个重要对象,使用open()函数来打开文件,创建文件对象,进行文件读写操作。当数据用于交换信息时,通常需要把数据保存为有格式文本数据,可以保存为有特定行分隔符和列分隔符数据,这可以...

    Python的文件是一个重要的对象,使用open()函数来打开文件,创建文件对象,进行文件的读写操作。当数据用于交换信息时,通常需要把数据保存为有格式的文本数据,可以保存为有特定的行分隔符和列分隔符的数据,这可以使用pandas模块中的函数来读写;也可以保存为json结构的数据,这可以使用json模块中的函数来实现;对于大型的数据交互,通常使用数据库。

    Python基础库中open()函数用于打开文件,创建文件对象:

    open(name, mode, encoding=None)

    参数注释:

    name是文件名,包括路径

    encoding 是编码方式,常用的编码方式是utf-8

    mode是打开文件的模式,最常用的模式是:

    r:只读模式,表示打开文件是为了从文件的开头读取文件中的数据;

    w:只写模式,表示打开文件是为了向文件写入数据。如果该文件已存在,那么打开该文件,删除原有的内容,从文件开头开始写入;如果该文件不存在,那么创建新的文件。

    a:以只追加可写模式打开文件,并将文件指针指向文件尾部;如果文件不存在则创建

    open()函数创建一个file 对象,文件对象的主要方法:

    file.read([size]):size 未指定则返回整个文件,如果文件大小 >2 倍内存则有问题,f.read()读到文件尾时返回""(空字串)。

    file.readline():只读取一行。

    file.readlines([size]) :返回包含size行的列表, size 未指定则返回全部行。

    for line in f: print( line ):通过迭代器访问。

    f.write("hello "):如果要写入字符串以外的数据,先将他转换为字符串。

    f.close() 关闭文件

    1,读取文件

    调用open()函数打开一个文件,设置mode='r',表示打开文件是为了读取文件中的数据,调用文件对象的函数或迭代器来逐行读取数据:

    file = open('test.txt','r',encoding='utf-8')

    lines= [line.strip() for line infile]

    file.close()

    注意:打开文件之后,完成文件的读写之后,必须调用文件对象的close()方法,最终关闭文件。

    2,写入文件

    调用open()函数打开一个文件,如果设置mode='w',那么表示打开文件是为了向文件中写入数据,调用文档对象的write('content')函数向文档中写入内容。

    file = open('test.txt','w',encoding='utf-8')

    file.write('write content to file')

    file.close()

    注意:打开文件之后,完成文件的读写之后,必须调用文件对象的close()方法,最终关闭文件。

    3,文件的关闭

    调用open()函数打开一个文件,是把文件读取到内存中的,如果不及时关闭文件,文件对象就会一直占用系统资源,除了调用文件对象的close()方法关闭文件之外,还可以使用 with open(),由系统自动关闭文件:

    with open('test.txt','r',encoding='utf-8') as file:

    lines= [line.strip() for line in file]

    参考文档:

    展开全文
  • Python-文件对象常用API

    千次阅读 2016-05-25 17:11:21
    文件对象会由一些其它内置的函数和方法返回,如os.popen()和os.fdopen()以及套接字对象的makefile()方法。临时文件可以通过tempfile模块创建,高级的文件操作如复制、移动和删除文件和目录可以通过shutil模块完成。 ...
  • ile 对象使用 open 函数来创建,下表列出了 file 对象常用的函数: 序号 方法及描述 1 file.close() 关闭文件。关闭后文件不能再进行读写操作。 2 file.flush() 刷新文件内部缓冲...
  • file 对象使用 open 函数来创建,下表列出了 file 对象常用的函数:1、file.close()close() 方法用于关闭一个已打开的文件。关闭后的文件不能再进行读写操作, 否则会触发 ValueError 错误。 close() 方法允许调用多...
  • file 对象使用 open 函数来创建,下表列出了 file 对象常用的函数: 1、file.close() close()方法用于关闭一个已打开的文件。关闭后的文件不能再进行读写操作, 否则会触发ValueError错误。 close() 方法允许调用...
  • python_文件对象

    2018-02-05 17:32:46
    一、文件系统和文件 文件系统是OS用于明确磁盘或分区上的文件的方法和数据结构——即在磁盘上组织文件的方法计算机文件,是存储在某种长期储存设备或临时存储设备中...python内置函数open()用于打开文件创建
  • pythonopen()函数用于打开一个文件创建file对象,相关方法才可以调用它进行读写语法:open(name,[,model[,buffering]])模式描述r以只读方式打开文件文件的指针将会放在文件的开头。这是默认模式。rb以二进制...
  • python open() 函数以指定模式打开一个文件创建一个 file 对象,相关方法才可以调用它进行读写。 w 模式表示打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。...
  • 文件系统和文件创建一个文件readline()与readlines()区别查看指针指向位置w+写入模式访问权限文件的权限修改修改文件的属主 属组import pickle 将内存持久存入文件函数匿名函数 lambdafilter过滤器映射器函数闭包...
  • f = open("yesterday","a",encoding="utf-8") #文件句柄 文件的内存对象 #a = append 追加 不覆盖文件 #"r" "w" "a" "r+" 读追加写都行 读写 "w+" 写读 先创建一个文件在写读 "rb" 二进制文件格式读写 "wb" #data ...
  • open  首先open是python内置的一个打开文件创建一个file对象的方法。与之相似的方法有个file。其功能上没有太大的区别。 file object = open(file_name [, access_mode][, buffering])
  • python open() 函数以指定模式打开一个文件创建一个 file 对象,相关方法才可以调用它进行读写。 w 模式表示打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有...
  • Python文件I/O函数基础

    2018-04-18 21:14:11
    首先我们先列出Python的I/O函数有哪些: input():读取键盘输入,程序会假设你输入一个有效...打开一个文件创建一个file对象,要对文件操作都需要用到 close():file对象调用方法,针对文件打开之后关闭,也就...
  • python中有一个内置函数open(),该函数用于打开一个文件创建一个 file 对象,相关方法才可以调用它进行读写。如果以只写模式打开一个文件,那么该函数会在文件不存在时创建一个文件。语法:open(name[, mode[, ...
  • 本章讨论Python的内置功能,这些功能本书会用到很多。虽然扩展库,比如pandas和Numpy,使处理大数据集很方便,但它们是和...最后,会学习Python的文件对象,以及如何与本地硬盘交互。 3.1 数据结构和序列 P...
  • Python文件对象

    2015-12-06 19:52:00
    Python内置函数open()用于打开文件和创建文件对象。 open(name[.mode[.bufsize]]) 接受三个参数:文件名,模式(读,只读。。。),缓冲区参数(0表示无缓冲,1表示使用缓冲只缓冲一行,负数表示使用系统默认,正数...
  • file 对象使用 open 函数来创建,下表列出了 file 对象常用的函数: 1、file.close() close()方法用于关闭一个已打开的文件。关闭后的文件不能再进行读写操作, 否则会触发ValueError错误。 close() 方法允许调用...
  • 向函数内部批量传递数据二,Python面向对象的编程1.声明类2.构造函数和析构函数3.继承三,文件1.读取创建好的mypython.txt并打印里的内容2.with语句3.上下文管理器 一,函数 1.介绍python的函数 实现某种特定...
  • 本章讨论Python的内置功能,这些功能本书会用到很多。虽然扩展库,比如pandas和Numpy,使处理大数据集很方便,但...最后,会学习Python的文件对象,以及如何与本地硬盘交互。 数据结构和序列 Python的数据结构简单而...
  • Python 文件对象和方法

    2018-05-07 23:08:00
    Python文件对象和方法 1.打开和关闭文件 Python提供了必要的函数和方法进行默认情况下的文件基本操作,我们可以用file对象做大部分文件操作。 open()方法 我们必须先用Python内置的open()函数打开一个文件,创建一个...
  • python创建Excel文件及写入保存数据

    千次阅读 2021-02-15 21:24:06
    文章目录python创建Excel文件及写入保存数据一、 创建并保存Excel文档二、工作表创建三、完整代码结果展示 一、 创建并保存Excel文档 首先调用我们openpyxl.Workbook()函数,创建一个新Workbook对象。...
  • 然后会讨论创建你⾃⼰、可重复使⽤的Python函数。最后,会学习Python的⽂件对象,以及如何与本地硬盘交互。 一、数据结构和序列 1、元组() (元组本身是不可变,但当元组存储的对象是可变对象,那就可以对...
  • Python文件对象方法

    2019-08-08 09:57:00
    使用open()函数创建一个文件对象,这里是可以在这个对象上调用的函数的列表 - 编号方法名称描述 1 file.close() 关闭文件,无法读取或写入关闭的文件。 2 file.flush() 清空内部缓冲区,类似于...

空空如也

空空如也

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

python创建文件对象的函数

python 订阅