Python 抽象类、repr、算术定义、传参、深浅拷贝、序列化

from abc import ABC, abstractmethod
# 抽象基类
class Animal(ABC):
    # 定义抽象方法：规定接口
    @abstractmethod
    def run(self):
        pass

# 抽象基类不能实例化
# a = Animal()
class Cat(Animal):
    # 必须实现基类中规定的抽象方法，才能实例化
    def run(self):
        print('猫喜欢走猫步')

c = Cat()





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))





d = {'name': 'xiaoming', 'age': 20}

# 用来获取对象的字符串表示形式
r = repr(d)
print(r)
print(type(r))

# 执行有效的python字符串
d2 = eval(r)
print(d2)
print(type(d2))

a = 10
b = 20

c = eval('a+b')
# c = a + b
print(c)





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)



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)





import sys

# 不可变的对象的引用计数没有意义
a = 20
print(sys.getrefcount(a))

lt = [1, 2, 3]
lt2 = lt

# 该函数本身会对引用计数加1
print(sys.getrefcount(lt))
del lt2
print(sys.getrefcount(lt))


class Person:
    def __del__(self):
        print('释放变量')

p = Person()
print(sys.getrefcount(p))
del p
print('OVER')






#传参
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][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))