zoukankan      html  css  js  c++  java

  • python学习之路-3 初始python数据类型以及文件操作

    本篇涉及内容



    set集合

    set是一个无序的且不重复的元素集合

    1、创建set集合的方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    # 第一种方法
    s = set()
    print(type(s))
                
    # 输出
    <class 'set'>
               
               
    # 第二种方法
    s = {1, 2}
    print(type(s))
               
    # 输出
    <class 'set'>
               
               
    # 第三种方法
    # 将一个可迭代的序列转换成为集合
    l1 = [11, 22, 33, 44, 22, 44]
    s = set(l1)
    print(type(s))
    print(s)
               
               
    # 输出
    <class 'set'>
    {33, 11, 44, 22}
               
    # 注：可以看到输出的set集合里面每一个值都是唯一的，这也体现出了set集合是一个不重复的序列

    2、set集合的一些方法

    • add()  向set集合中添加一个元素
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      # add()  向set集合中添加一个元素
      s = {1, 2}
      print(s)
      s.add(3)
      s.add(3)
      s.add(2)
      print(s)
                
      # 输出
      {1, 2}
      {1, 2, 3}
                
      # 注：set的add方法一次只能够添加一个元素，由于set集合有去重的机制，所以多次添加相同的值，最后输出set集合的时候也只会显示一次

    • clear() 清空set集合中的所有元素 

      1
      2
      3
      4
      5
      6
      7
      8
      s = {1, 2, "a", "b", "c"}
      print(s)
      s.clear()
      print(s)
                 
      # 输出
      {'b', 1, 2, 'a', 'c'}
      set()

    • copy() 浅拷贝

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      x = [11, 22, 33, 11, 44, 22, 55]
      s = set(x)
      print(s)
      print(id(s))    # 输出内存地址
                 
      # 对s进行浅拷贝
      s2 = s.copy()
      print(s2)
      print(id(s2))  # 输出内存地址
                 
                 
      # 输出
      {33, 11, 44, 22, 55}
      5882152   # 内存地址
      {33, 11, 44, 22, 55}
      6091272   # 内存地址
      # 注：可以看到s和s2的内存地址已经发生变化了

    • difference()  将前者存在，后者不存在的值取出来赋值给一个新的变量

      1
      2
      3
      4
      5
      6
      7
      8
      9
      s1 = {11, 22, 33, 44}
      s2 = {22, 33, 44, 55}
      s3 = s1.difference(s2)
      print(s3)
                  
      #　输出
      {11}
                  
      # 注：将s1中存在,s2中不存在的元素放到一个新的set集合中，然后返回给s3

    • difference_update()   将前者存在，后者不存在的元素放到一个新的set集合中，然后将前者直接覆盖掉

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      s1 = {11, 22, 33, 44}
      s2 = {22, 33, 44, 55}
      s3 = s1.difference_update(s2)
      print(s1)
      print(s3)
                 
      #　输出
      {11}
      None
                 
      # 注：将s1中存在的元素，s2中不存在的元素放到一个新的set集合中，然后将前者直接覆盖掉，不返回值

    • discard()  删除set集合中的一个元素

      1
      2
      3
      4
      5
      6
      7
      8
      9
      s1 = {11, 22, 33, 44}
      s1.discard(11)
      s1.discard(111)
      print(s1)
                 
      # 输出
      {33, 44, 22}
                 
      # 注：如果删除的值不存在，也不会出现报错信息

    • intersection()   前者和后者都有的

      1
      2
      3
      4
      5
      6
      7
      8
      9
      s1 = {11, 22, 33, 44}
      s2 = {22, 33, 44, 55}
      s3 = s1.intersection(s2)
      print(s3)
                 
      # 输出
      {33, 44, 22}
                 
      # 注：可以理解为两个集合的并集吧

    • intersection_update()   前者和后者都有的，赋值给前者   没有返回值

      1
      2
      3
      4
      5
      6
      7
      8
      9
      s1 = {11, 22, 33, 44}
      s2 = {22, 33, 44, 55}
      s1.intersection_update(s2)
      print(s1)
                 
      # 输出
      {33, 44, 22}
                 
      # 注：将s1清空,把s1和s2中都存在的元素赋值给s1

    • isdisjoint()  判断两个集合是否有相同的元素，如果有，则返回False 否则返回True

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      s1 = {11, 22, 33, 44}
      s2 = {55}
      s3 = s1.isdisjoint(s2)
      print(s3)
                 
      # 输出
      True
                 
                 
      s1 = {11, 22, 33, 44}
      s2 = {22, 33, 44, 55}
      s3 = s1.isdisjoint(s2)
      print(s3)
                 
      # 输出
      False

    • issubset() 判断前者是否是后者的子集,返回一个布尔值

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      s1 = {11, 22, 33, 44}
      s2 = {44}
      s3 = s1.issubset(s2)
      print(s3)
                   
      # 输出
      False
                   
                   
      s1 = {44}
      s2 = {11, 22, 33, 44}
      s3 = s1.issubset(s2)
      print(s3)
                   
      # 输出
      True
                  
      # 注：就是判断前者中的所有元素在后者中是否都存在，返回一个布尔值

    • issuperset() 判断前者是否是后者的父集，返回一个布尔值

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      s1 = {11, 22, 33, 44}
      s2 = {44}
      s3 = s1.issuperset(s2)
      print(s3)
                  
      # 输出
      True
                  
                  
      s1 = {44}
      s2 = {11, 22, 33, 44}
      s3 = s1.issuperset(s2)
      print(s3)
                  
      # 输出
      False
                  
      # 同issubset()方法正好相反

    • pop() 随机删除一个set集合中的元素，并返回该元素, 如果该集合为空，则报错

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      s1 = {11, 22, 33, 44}
      s2 = s1.pop()
      print(s1)
      print(s2)
                  
      # 输出
      {11, 44, 22}
      33
                  
      # 如果从空集合中执行pop方法，则会报错
      s1 = set()
      s2 = s1.pop()
                  
      # 错误信息
      Traceback (most recent call last):
        File "D:/SVN/learning/s13/day3/class_code/set集合.py", line 218, in <module>
          s2 = s1.pop()
      KeyError: 'pop from an empty set'

    • remove() # 从集合中删除一个指定的元素，如果该元素不存在，则报错，可以直接忽略该方法，直接用上面介绍的discard方法，删除元素不会报错，没有返回值

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      s1 = {11, 22, 33, 44}
      s1.remove(11)
      print(s1)
                 
      # 输出
      {33, 44, 22}
                 
                 
      # 使用remove删除一个不存在的元素
      s1 = {11, 22, 33, 44}
      s1.remove(111)
      print(s1)
                 
      # 输出
      Traceback (most recent call last):
        File "D:/SVN/learning/s13/day3/class_code/set集合.py", line 222, in <module>
          s1.remove(111)
      KeyError: 111

    • symmetric_difference  # 前者有后者没有  和后者有，前者没有的  都取出来放到一个新的集合中并返回

      1
      2
      3
      4
      5
      6
      7
      s1 = {11, 22, 33, 44}
      s2 = {22, 33, 44, 55}
      s3 = s1.symmetric_difference(s2)
      print(s3)
                
      # 输出
      set([11, 55])

    • symmetric_difference_update 前者有后者没有  和后者有，前者没有的  都取出来放到一个新的集合中覆盖前者, 没有返回值

      1
      2
      3
      4
      5
      6
      7
      s1 = {11, 22, 33, 44}
      s2 = {22, 33, 44, 55}
      s1.symmetric_difference_update(s2)
      print(s1)
                
      # 输出
      set([11, 55])

    • union() 返回一个新的集合，返回一个集合，包含前者和后者所有的元素

      1
      2
      3
      4
      5
      6
      7
      s1 = {11, 22, 33, 44}
      s2 = {22, 33, 44, 55}
      s3 = s1.union(s2)
      print(s3)
                
      # 输出
      set([33, 11, 44, 22, 55])

    • update()   将后者的元素全部添加到前者中， 没有返回值

      1
      2
      3
      4
      5
      6
      7
      s1 = {11, 22, 33, 44}
      s2 = {22, 33, 44, 55, 1, 2, 3, 4}
      s3 = s1.update(s2)    # update中接受一个可以迭代的对象,可以是字典、元组、字符串、set集合
      print(s1)
                 
      # 输出
      set([33, 2, 3, 4, 1, 11, 44, 22, 55])


    函数

    一、函数的定义

    函数就是为了避免重复造轮子，避免造成代码量的冗余以及让代码的维护更简单

    简单来说，比如我有一个功能需要应用在10个地方，如果不用函数来实现的话，我就需要在10个地方将这个功能的代码都写一遍，这个时候你的老板说这个功能要加一个小的功能进去，这个时候你就崩溃了，在这10个地方写的代码都需要修改，如果使用函数的话，就只需要修改这个用函数封装起来的代码就可以了


    二、函数的语法和创建

    • 语法

      1
      2
      3
      4
      5
      6
      7
      def 函数名(参数):
          ...
          函数体
          ...
          返回值
                
      # 返回值不是必须的，如果没有return语句，则默认返回值None

    • 创建一个函数

      1
      2
      3
      4
      def test():  # 创建一个名为test的函数
          print("hello")   # 函数体输入"hello"
                
      test()  # 调用函数，会执行test函数的函数体


    三、参数

    1
    2
    3
    4
    5
    6
    python中函数的参数主要分为以下几种：
    1、普通参数
    2、默认参数
    3、指定参数
    4、动态参数
    5、万能参数

    • 普通参数

      1
      2
      3
      4
      5
      6
      7
      8
      def send(name, content):    # name 和 content是形式参数，简称形参
          print(name, content) return True
              
      send("zhangsan", "DaShaX") # 调用函数  "zhangsan" 和 "DaShaX" 是实际参数，简称实参
              
              
      # 输出
      zhangsan DaShaX

    •  默认参数

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      # 默认参数只能在形式参数的最后出现，否则会报错
      def send(name, content="DaShaX"):
          print(name, content)
          return True
             
      # 调用函数
      send("zhangsan")
             
             
      # 输出
      zhangsan DaShaX

    • 指定参数

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      def send(name, content):
          print(name, content)
          return True
             
      # 调用函数
      send(content="DaShaX", name="zhangsan")
             
             
      # 输出
      zhangsan DaShaX
             
             
      # 注：在调用函数时，指定形参对应的实参，可以不按照函数形参的顺序进行调用

    • 动态参数

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      动态参数主要包括两种：
          *args     # 接收一个可迭代的数据类型
          **kwargs    # 接收一个含有键值对的数据类型
              
      使用动态参数的好处主要是不需要指定参数的个数
               
               
      ### *args 对传进来的可迭代参数将其进行迭代，将迭代后的值组成一个元组
      def f1(*args):
          print(args, type(args))
               
      li = [1, 2, 3, 4]
      f1(*li)
               
      # 输出
      (1, 2, 3, 4) <class 'tuple'>
               
               
              
      ### **kwargs将传进来的字典或者键值对，保存到一个字典中
      def f1(**kwargs):
          print(kwargs, type(kwargs))
               
      dic = {'k1': 'v1', 'k2': 'v2'}
      f1(**dic)
      # 或者通过下面这种形式调用
      # f1(k1='v1', k2='v2') 得到的输出结果是一样的
               
      # 输出
      {'k1': 'v1', 'k2': 'v2'} <class 'dict'>

    • 万能参数

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      # 万能参数是由动态参数的两种形式组合而成，*args在前，**kwargs在后
             
      def f1(*args, **kwargs):
          print(args, type(args))
          print(kwargs, type(kwargs))
             
      f1(11, 22, 33, 44, k1="v1", k2="v2")  # 调用函数
             
      # 或者使用下面的方式进行调用，效果是一样的
      # l1 = [11, 22, 33, 44]
      # d1 = {"k1": "v1", "k2": "v2"}
      # f1(*l1, **d1)
             
             
      # 输出
      (11, 22, 33, 44) <class 'tuple'>
      {'k2': 'v2', 'k1': 'v1'} <class 'dict'>


    • 动态参数的应用

      1
      2
      3
      4
      5
      6
      7
      8
      9
      # 对字符串的format()方法进行传参的时候可以使用动态参数来完成，下面两种传参得到的结果都是一样的
      s1 = "i am {0}, age {1}".format("zhangsan", 20)
      print(s1)
      s2 = "i am {0}, age {1}".format(*["zhangsan", 20])
      print(s2)
             
      # 输出
      i am zhangsan, age 20
      i am zhangsan, age 20


    四、return语句

        return是函数执行的返回值，在函数执行的过程中，遇到return的时候，函数就结束了，并且返回对应的值，如果return没有定义返回值，则为None

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    # 创建两个函数，一个有返回值，一个没有返回值
    def f1(a1 , a2):
        return
           
           
    def f2(a1, a2):
        return a1 + a2
           
    a1 = 5
    a2 = 10
    ret1 = f1(a1, a2)   # 接收到的是None
    ret2 = f2(a1, a2)   # 接收到的是15
    print(ret1)
    print(ret2)
           
    # 输出
    None
    15


    五、变量作用域

    • 全局变量

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      ###定义在函数外面的变量为全局变量，全局变量使用大写来表示，例如：
      NAME = "zhangshan"
             
             
      ### 在函数中可以直接调用全局变量来使用，但是不能对其进行重新赋值
      NAME = "zhangshan"
      def f1():
          age = 18
          print(age, NAME)
             
      f1()
             
      # 输出
      18 zhangshan
             
             
             
      ### 如果全局变量为列表，字典或集合，在函数中可以对其进行修改，但是不能对其进行重新赋值，字符串不能进行任何操作
      # 全局变量为列表，在函数中对其进行append操作
      NAMES = ["zhangshan", "lisi", "wangwu"]  # 全局变量
      def f1():
          age = 18
          NAMES.append("dasha")   # 在函数中对全局变量进行操作
          print(age, NAMES)
             
      f1()   # 调用函数
      print(NAMES)  # 输出在函数内被操作的全局变量
             
      # 输出
      18 ['zhangshan', 'lisi', 'wangwu', 'dasha']
      ['zhangshan', 'lisi', 'wangwu', 'dasha']
             
             
      # 当全局变量为字典时，在函数中对其添加一对键值对
      NAMES = {"zhangshan": 18, "lisi": 20, "wangwu":100}
      def f1():
          age = 18
          NAMES["DaShanPao"] = 200
          print(age, NAMES)
             
      f1()
      print(NAMES)
             
      # 输出
      18 {'lisi': 20, 'DaShanPao': 200, 'wangwu': 100, 'zhangshan': 18}
      {'lisi': 20, 'DaShanPao': 200, 'wangwu': 100, 'zhangshan': 18}
             
             
      # 当全局变量为set集合时候，在函数中对其进行add操作
      NAMES = set(["zhangshan", "lisi", "wangwu"])
      def f1():
          age = 18
          NAMES.add("sss")
          print(age, NAMES)
             
      f1()
      print(NAMES)
             
      # 输出
      18 {'lisi', 'wangwu', 'sss', 'zhangshan'}
      {'lisi', 'wangwu', 'sss', 'zhangshan'}
             
             
      # 如果希望在函数内对全局变量进行重新赋值时，就需要在函数内使用global关键字对变量进行声明
      NAMES = ["zhangshan", "lisi", "wangwu"]
      def f1():
          global NAMES
          NAMES = "DaShanPao"
          print(age, NAMES)
             
      f1()
      print(NAMES)
             
      # 输出
      ['zhangshan', 'lisi', 'wangwu']
      DaShanPao
      DaShanPao
             
      # 注：可以看到在函数中对全局变量NAMES使用global关键字进行声明，
      #     然后对该变量进行修改，在函数外进行输出时输出的是修改过的值

    • 局部变量

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      ### 定义在函数内的变量为局部变量，局部变量使用大写来表示，例如：
      def f1():
          NAME = "zhangshan"
          print(NAME)
      f1()
      print(NAME)
             
      # 输出
      Traceback (most recent call last):
        File "D:/SVN/learning/s13/day3/class_code/函数.py", line 142, in <module>
          print(NAME)
      NameError: name 'NAME' is not defined
      zhangshan
             
      # 注：在函数内定义的变量为局部变量，在函数外使用函数内的变量是会报错的
             
             
             
      ### 要想让函数内的变量在函数外使用需要用global进行声明
      def f1():
          global NAME
          NAME = "zhangshan"
          print(NAME)
      f1()
      print(NAME)
             
      # 输出
      zhangshan
      zhangshan


    六、自定义函数及函数规范

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    def login(username, password):
        """
        用于用户登录
        :param username: 用户输入的用户名
        :param password:  用户输入的密码
        :return: True：表示登录成功   False：表示登录失败
        """
        f = open("db", "r")
        for line in f:
            line_list = line.split("|")
            if line_list[0] == username and line_list[1] == password:
                return True
           
        return False
           
           
    def register(username, password):
        """
        用户用户注册
        :param username: 用户输入的用户名
        :param password: 用户输入的密码
        :return: None
        """
        f = open("db", 'a')
        temp = " " + username + "|" + password
        f.write(temp)
        f.close()
           
           
    def main():
        t = input("1：登录   2：注册")
        if t == "1":
            user = input("请输入用户名：")
            pwd = input("请输入密码：")
            r = login(user, pwd)
            if r:
                print("登录成功")
            else:
                print("登录失败")
        elif t == "2":
            user = input("请输入用户名：")
            pwd = input("请输入密码：")
            register(user, pwd)


    七、lambda表达式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    # lambda表达式就是简单函数的缩写
    # 例如
    def f1(a1):
        return a1 + 100
           
    # 使用lambda表达式可以简写为：
    f2 = lambda a1: a1 + 100
           
    # 也可以有两个参数,还可以有默认参数
    # f2 = lambda a1, a2=0: a1 + a2 + 100
           
    # 对函数的调用
    ret = f1(10)
    print(ret)
           
    ret2 = f2(9)
    print(ret2)
           
    # 输出
    110
    110


    八、python内置函数

    python中有许多内置的函数 --> 点我查看python3内置函数官方文档

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    ### abs(x)  取绝对值
    print(abs(-10))
    # 输出
    10
          
          
    ### all(iterable)  返回一个bool值，传入一个可迭代的值，该值内的每一个元素都为真，才为真
    n = all([1, 2, 3])
    print(n)
    # 输出
    True
          
    n = all([1, 2, 3, 0])
    print(n)
    # 输出
    False
          
          
    ### any(iterable)  返回一个bool值，传入一个可迭代的值，该值内只要有一个元素都为真，就为真
    n = any([1, 0, False])
    print(n)
    # 输出
    True
          
    n = any([False, 0])
    print(n)
    # 输出
    False
          
          
    ### bool([x])   返回一个布尔值  True 或 False  x为可选，x为空时候，返回False
    x = 1
    x2 = 0
    ret = bool(x)
    ret2 = bool(x2)
    print(ret)
    print(ret2)
          
    # 输出
    True
    False
          
          
    ### bin(number)   # 将十进制转换成二进制
    number = 10
    ret = bin(number)
    print(ret)
          
    # 输出
    0b1010
          
          
    ### oct(number)   将十进制转换成为八进制
    number = 9
    ret = oct(number)
    print(ret)
          
    # 输出
    0o11
          
          
    ### hex()     # 将十进制转为十六进制
    number = 15
    ret = hex(number)
    print(ret)
          
    # 输出
    0xf
          
          
    ### bytes()    将字符串转换成为对应编码格式的字节类型
    name = "张三"
    ret = bytes(name, encoding="utf-8")
    print(ret)
    print(str(ret, encoding="utf-8"))   # 使用str()   将字节类型转换为字符串类型，编码格式需要对应
          
    ret = bytes(name, encoding="gbk")
    print(ret)
    print(str(ret, encoding="gbk"))     # 使用str()   将字节类型转换为字符串类型，编码格式需要对应
          
    # 输出
    b'xe5xbcxa0xe4xb8x89'
    张三
    b'xd5xc5xc8xfd'
    张三


    三元运算

    1
    2
    3
    4
    5
    6
    7
    8
    9
    # 三元运算就是对 if else的简写
    # 例如：
    if i == 1:
        name = "zhangshan"
    else:
        name = "SB"
          
    # 使用三元运算简写如下
    name = "zhangsan" if 1 == 1 else "SB"


    文件处理

    • 打开文件

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      # 打开文件
      # 第一种方法
      f = open("文件名(绝对路径或相对路径)", "方法", encoding="utf-8")    # 打开文件的时候一定要指定字符集
      # 第二种方法
      with open("文件名(绝对路径或相对路径)", "方法", encoding="utf-8") as f:    # with下面的代码块执行完毕，自动关闭文件
          
      # 方法主要包括以下几种：
      "r"   # 只读，文件必须存在，如果不存在，则报错
      "w"   # 只写，如果文件存在，则清空，如果不在，则创建
      "x"   # 如果文件存在，则报错，如果不存在，创建文件并只写
      "a"   # 追加，如果文件存在，在文件末尾写，如果不存在，则先创建文件
          
      "rb"  # 二进制读，以字节码方式表示，文件必须存在，如果不存在，则报错
      "wb"  # 二进制写，以字节码方式表示，如果文件存在，则清空，如果不在，则创建
      "xb"  # 二进制打开文件，以字节码方式表示，如果文件存在，则报错，如果不存在，创建文件并只写
      "ab"  # 二进制打开文件，以字节码方式表示，追加，如果文件存在，在文件末尾写，如果不存在，则先创建文件
          
      "r+"  # 读写  可读，可写    # 一般都用这个   先读在写，可以调整指针位置，然后在写入
      "w+"  # 写读  可读，可写    # 先清空文件，在可读可写
      "x+"  # 写读  可读，可写
      "a+"  # 写读  可读，可写    # 不管指针在哪里，永远写到最后面


    • 操作文件

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      f.read([number,])    # 无参数，读全部，看参数number是否有值，有b  读字节， 无b，读字符
      f.write()   # 写数据，当前指针位置写入文件    有b  写字节， 无b，写字符
      f.seek()    # 调整当前指针的位置(字节)
      f.tell()    # 获取当前指针的位置(字节)
      f.fileno()  # 检测文件是否发生变化
      f.flush()   # f.write会将内容写入到内存中，f.flush 会强制将内存中的内容写入到文件中
      f.readable() # 判断文件句柄是否可读   返回一个布尔值
      f.seekable() # 判断指针是否可以移动   返回一个布尔值
      f.writeable()  # 判断文件句柄是否可写   返回一个布尔值
      f.readline() # 每次读取一行
      f.readlines() # 将文件中的内容存放到一个列表中，每一行为一个元素
      f.truncate()  # 将文件进行截断，将指针后面的内容清空


    • 关闭文件

      1
      2
      f.close()
      如果使用with打开文件，with下面的代码块执行完毕，文件会自动关闭


    • 练习代码

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      # 循环文件每一行
      f = open("文件名", "r+", encoding="utf-8")
      for line in f:   # 循环文件句柄，可以得到每一行的内容
          print(line)
          
          
              
      # 通过with同时打开两个文件，从第一个文件将内容读出，写入到第二个文件
      with open("文件1", "r", encoding="utf-8) as f1, open("文件2", "w", encoding="utf-8") as f2:
          for line in f1:
              f2.write(line)
  • 相关阅读:
    CentOS7- 配置阿里镜像源
    MySQL学习笔记
    OSI&TCP/IP模型
    加密算法学习
    golang学习笔记
    Redis学习总结整理
    TCP
    HTTP/HTTPS
    HTTP2
    MVCC
  • 原文地址：https://www.cnblogs.com/CongZhang/p/5533109.html
Copyright © 2011-2022 走看看