python学习总结----内置函数及数据持久化

抽象基类(了解)

- 说明：
  - 抽象基类就是为了统一接口而存在的
  - 它不能进行实例化
  - 继承自抽象类的子类必须实现抽象基类的抽象方法
- 示例：
      from abc import ABC, abstractmethod
      
      # 抽象基类
      class Animal(ABC):
          # 定义抽象方法：规定接口
          @abstractmethod
          def run(self):
              pass   
          
      # 抽象基类不能实例化
      # a = Animal()
      
      class Cat(Animal):
          # 必须实现基类中规定的抽象方法，才能实例化
          def run(self):
              print('猫喜欢走猫步')
              
      c = Cat()

内置函数

- 构造和析构
      __init__、__del__
- 属性操作    
      __getattr__、__setattr__、__delattr__
- 支持字典操作
      __getitem__、__setitem__、__delitem__
- 像函数一样调用
      __call__
- 打印输出
      __str__
- 对象的字符串表示
        class Person:
            def __init__(self, name, age):
                self.name = name
                self.age = age
      
            # print/str都会自动触发该方法
            def __str__(self):
                print('__str__')
                return '姓名:{}，年龄:{}'.format(self.name, self.age)
      
            # 通常用来返回对象的字符串表示形式
            # 调用repr方法时会自动触发
            def __repr__(self):
                return 'Person("{}", {})'.format(self.name, self.age)
              
              
      	xiaoming = Person('小明', 20)
          # print(xiaoming)
          # s = str(xiaoming)
          # print(s)
      
          r = repr(xiaoming)
          print(r)
          # eval：可以指向有效python字符串
          x = eval(r)
          print(x)
          print(type(x))       

- 算术运算符重载
  - 示例
        class Number:
            def __init__(self, num):
                self.num = num
      
            def __str__(self):
                return str(self.num)
      
            # 对象出现在'+'的左边时自动触发
            def __add__(self, other):
                print('__add__')
                return self.num + other
      
            # 对象出现在'+'的右边时自动触发
            def __radd__(self, other):
                return self.num + other
      
            # +=运算时会自动触发，若没有则会调用__add__方法
            def __iadd__(self, other):
                return Number(self.num + other)
              
      n = Number(10)
      # ret = n + 10
      # ret = 20 + n
      n += 50 # n = n + 50
      print(n)
      
  - 自行测试
      加法：__add__、__radd__、__iadd__
      减法：__sub__、__rsub__、__isub__
      乘法：__mul__、__rmul__、__imul__
      除法：__truediv__、__rtruediv__、__itruediv__
      求余：__mod__、__rmod__、__imod__
- 关系运算符重载
        class Number:
            def __init__(self, num):
                self.num = num
      
            # 大于：>
            def __gt__(self, other):
                return self.num > other
      
            # 小于：<
            def __lt__(self, other):
                return self.num < other
      
            # 等于，==会触发，不实现__ne__时，!=也会触发该方法
            def __eq__(self, other):
                print('__eq__')
                return self.num == other
      
            # 大于等于：>=
            def __ge__(self, other):
                return self.num >= other
      
            # 小于等于：<=
            def __le__(self, other):
                return self.num <= other
      
            # 不等于：!=
            def __ne__(self, other):
                return self.num != other
          
      n = Number(20) 
      print(n > 10)
      print(n < 10)
      print(n != 10)

内存管理

- 引用计数
  - python中所有的变量都是通过对象完成的，对象的管理时通过引用计数解决的。
  - 当创建一个对象赋值给一个变量时，引用为1，当多一个变量指向对象时，计数值加1；当少一个变量指向对象时，计数值减1，减到0时调用对象__del__方法，释放对象相关资源
  - 不可变变量的引用计数值是没有意义的
  - 通过函数sys.getrefcount(lt)可以查看对象的引用计数，该函数本身会对对象的引用计数加1
- 函数传参
  - 对不可变的变量来说，传递的值，函数中不会改变传递进来的变量。
  - 对于可变对象、自定义对象来说，传递的是引用，函数中操作的就是原对象。
  - 示例：
      def test(n):
            n += 10
            
      num = 2
      test(num)
      print(num)
      
      def test2(lt):
      	lt[0] = 20
      	
      lt = [1, 2, 3]
      test2(lt)
      print(lt)

- 深浅拷贝
  - 不可变的类型不存在深浅拷贝
  - 浅拷贝只会拷贝对象本身，其中的元素只会增加引用
  - 深拷贝不但会拷贝对象本身，还会对其中的元素进行拷贝
  - 示例：  
      import copy
      
      lt = [[1, 11], 2, 3]
      # lt2 = lt
      # 浅拷贝：只拷贝对象本身，里面的元素只增加引用
      # lt2 = lt.copy()
      # 浅拷贝
      # lt2 = copy.copy(lt)
      # 深拷贝：拷贝对象本身，对象中的元素也进行拷贝
      lt2 = copy.deepcopy(lt)
      lt2[0] = 100
      print(id(lt))
      print(id(lt2))
      
      # 判断是否是同一对象的引用
      print(lt is lt2)
      print(lt)

数据持久化存储

- 说明：持久化存储方案，普通文件、数据库、序列化
- 示例：
      import pickle
      
      class Person:
          def __init__(self, name, age):
              self.name = name
              self.age = age
      
          def __str__(self):
              return 'name:{}，age:{}'.format(self.name, self.age)
          
          
      xiaoming = Person('xiaoming', 20)
      
      # 序列化，会将对象转换为bytes
      # s = pickle.dumps(xiaoming)
      # print(s)
      
      # 从字节流中加载转换为对象
      # xm = pickle.loads(s)
      # print(xm)
      # print(type(xm))
      
      # 直接保存到文件中
      # fp = open('data.txt', 'wb')
      # pickle.dump(xiaoming, fp)
      
      # 从文件中读取对象
      fp = open('data.txt', 'rb')
      xm = pickle.load(fp)
      print(xm)
      print(type(xm))