#接口类：多继承，父类不实现
# from abc import ABCMeta,abstractmethod
# class Fly_Animal(metaclass=ABCMeta):#规范
# @abstractmethod
# def fly(self):pass
#
# class Swim_Animal(metaclass=ABCMeta):
# @abstractmethod
# def swim(self):pass
#
# class Walk_Animal(metaclass=ABCMeta):
# @abstractmethod
# def walk(self):pass
#
# class Frog(Walk_Animal,Swim_Animal):
# def walk(self):
# print("自己实现")
#
# def swim(self): pass
# class Swan(Walk_Animal,Swim_Animal,Fly_Animal):
# pass
# class Bird(Walk_Animal,Fly_Animal):
# pass
#applepay alipay
# from abc import ABCMeta,abstractmethod
# # 接口类：
# # 是规范子类的一个模板，只是接口类中定义的，就应该在子类中实现
# #接口类不能被实例化，它只能被继承
# 支持多继承
# class Payment(metaclass=ABCMeta):#模板,接口类
# @abstractmethod #装饰接口类中方法的，加上这个装饰器，自动检测子类中的方法名
# def pay(self,money):pass
#
# @abstractmethod
# def get(self,money):pass
# class Apple_pay(Payment):
# def pay(self,money):
# print('用苹果支付了%s元'%money)
# class Ali_pay(Payment):
# def pay(self, money):
# print('用支付宝支付了%s元'%money)
# class WeChat_pay(Payment):
# def pay(self,money):
# print('用微信支付了%s元'%money)
# def pay(obj,money):
# return obj.pay(money)
# apple = Apple_pay()
# ali = Ali_pay()
# wechat = WeChat_pay()
# # apple.pay(100)
# # ali.pay(50)
# # pay(apple,100)#apple.pay(100)
# pay(wechat,200)
#抽象类
#模板 规范
#抽象类可以实现一些子类共有的功能和属性 抽象不鼓励多继承
#抽象类不能被实例化
#这个抽象类可以规范子类必须实现抽象类中的抽象方法
#文件操作：打开文件，关闭文件，写文件，读文件
#硬盘操作：打开，关闭，写，读
#进程文件：打开，关闭，读，写
# python 没有接口的概念
# 只能借助抽象类的模具 来实现接口类
#接口——Java：没有多继承——Interface
# from abc import ABCMeta,abstractmethod
# class Base(metaclass=ABCMeta):
# def __init__(self,filename):
# self.filename = filename
#
# @abstractmethod #抽象方法
# def open(self):
# return "shabi"
#
# @abstractmethod
# def close(self):pass
#
# @abstractmethod
# def read(self):pass
#
# @abstractmethod
# def write(self):pass
# class File(Base):
# def open(self):pass
# def close(self):pass
# def read(self):pass
# def write(self):pass
#封装 :把一些属性和方法放到类里 这本身就是一种封装
# 封装 ： 把属性和方法藏在类里 我只能在类内部调用，不能再外部使用
#从类的外面不能直接调用，在类内的使用加上了一层密码：_类名
# class Dog:
# __role = 'dog' #私有的静态属性
# def __discount(self): #私有的方法
# print('in __func')
#
# def price(self):
# self.__discount()
# print(Dog.__dict__)
# print(Dog._Dog__role)#不推荐用这种方法
#定义一个私有变量属性方法 ： __名字
#在类的内部可以直接用 : __名字
#在类的外部不能直接使用，如果一定要用，在私有方法之前加上：_类名,变成 _类名__名字
#在类外的名字 通过__dict__就可以查看
# class Room:
# def __init__(self,name,price,length,width):
# self.name = name
# self.price = price
# self.__length =length #私有的对象属性
# self.__width = width
#
# def area(self):
# return self.__length*self.__width
#
# house = Room('小超超',1000000,2,1)
# print(house.area())
# class A:
# def __func(self):
# print('__a_func')
#
# class B(A):
# def __init__(self):
# self._A__func()
#
# b = B()
#私有的
#私有的静态属性、方法、对象属性
#使用__名字的方式调用，保证在类内部可以调用，外部不行
#私有的 不能被继承
# 当有一个名字，不想被外部使用也不想被子类继承，只想在内部使用的时候就定义私有的
#公有的
#私有的 + property
# class Person:
# def __init__(self,name,height,weight):
# self.name = name
# self.height = height
# self.__weight = weight
#
# @property
# def bmi(self):
# return self.__weight / (self.height ** 2)
#
# li = Person('博',1.80,70)
# print(li.bmi)#调用属性一样的调用他的方法
#@property 把一个方法 伪装成一个属性
#1.属性的值 是这个方法的返回值
#2.这个方法不能有参数了
#圆形类 ： 面积 周长
# from math import pi
# class Circle:
# def __init__(self,r):
# self.r = r
# @property
# def area(self):
# return self.r*self.r*pi
#
# @property
# def perimeter(self):
# return self.r*pi*2
# c1 = Circle(5)
# print(c1.area)
# print(c1.perimeter)
# class Goods:
# __discount = 0.8 #静态属性
# def __init__(self,name,price):
# self.__name = name
# self.__price = price #原价
# @property
# def name(self):
# return self.__name
#
# @name.setter
# def name(self,new_name):
# self.__name = new_name
#
# @property
# def price(self): #折后价
# return self.__price * Goods.__discount
#
# @price.setter
# def price(self,new_price): #修改原价
# if type(new_price) is int:
# self.__price = new_price
# apple = Goods('苹果',10)
# apple.price = '10' #settrt
# print(apple.price) #property
# apple.price = 8
# print(apple.price)
# 封装
# __私有+property
# 让对象的属性变得更安全了
# 获取到的对象的值可以进行一些加工
# 修改对象的值的同时可以进行一些验证
class Foo:
@property
def AAA(self):
print('get的时候运行我啊')
@AAA.setter
def AAA(self,value):
print('set的时候运行我啊')
@AAA.deleter
def AAA(self):
print('delete的时候运行我啊')
#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
# print(f1.AAA) #property
# f1.AAA='aaa'#setter
print(f1.AAA)
# del f1.AAA #deleter
# 定义一个类
#类里面的方法
#并没有用到self
# class Goods:
# __discount = 0.8
# @classmethod #类方法
# def change_discount(cls,new_discount):
# cls.__discount = new_discount
# @classmethod
# def get_discount(cls):
# return cls.__discount
# # apple = Goods()
# Goods.change_discount(0.75)
# print(Goods.get_discount())
#类方法
#调用：不需要实例化 直接用类名调用就好
#定义：不用接受self参数，默认传cls，cls就代表当前方法所在的类
#什么时候用类方法？
#需要使用静态变量 且 不需要和对象相关的任何操作的时候
#静态方法
#如果这个方法 既不需要操作静态变量
# 也不需要使用对象相关的操作，
# 就使用静态方法
class A:
@staticmethod
def func(name): #静态方法
print(123)
A.func('alex')
#面向对象编程：专门为面向对象编程提供的一个方法——staticmethod
#它完全可以当做普通函数去用，只不过这个函数要通过类名.函数名调用
#其他 传参 返回值 完全没有区别
#类里面，一共可以定义这三种方法：
#普通方法 self
#类方法 cls
#静态方法
#绑定方法 和 非绑定方法
class A:
@staticmethod
def func1(name): #静态方法
print(123)
@classmethod
def func2(cls): # 静态方法
print(123)
def func3(self):pass
a = A()
print(a.func1) #静态方法
print(a.func2) #类方法 ： 绑定到A类的func
print(a.func3) #普通方法：绑定到A类对象的func
#静态方法和类方法 都是直接可以使用类名调用
#普通方法：对象调用