#___author:
#date: 2021/6/19
'''''
#@property 装饰器
#测试@property的简化的使用
class Employee:
@property
def dowe(self):
print("努力上班")
return 10000
e = Employee()
#e.dowe()
print(e.dowe)
# #@property装饰器的用法
class Employee: #不用@property装饰器写的
def __init__(self,name,sakary):
self.__name = name
self.__salary = sakary
def get_salary(self):
return self.__salary
def set_salary(self,salary):
if 1000<salary<50000:
self.__salary = salary
else:
print("录入错误")
a=Employee("杨正",2000)
print(a.get_salary())
a.set_salary(30000)
print(a.get_salary())
#用@property装饰器
class Pado:
def __init__(self,name,salary): #初始化
self.__name=name #赋值
self.__salary = salary
@property #装饰器
def salary(self):
return self.__salary
@salary.setter
def salary(self,salary):
if 1000<salary<50000:
self.__salary=salary
else:
print("写入错误")
a = Pado("杨正",2000)
print(a.salary)
a.salary = 20000
print(a.salary)
'''''
'''''
#面向对象的三大特征介绍（封装，继承，多态）
#测试继承的基本使用
class Pastr:
def __init__(self,name,age):
self.name =name
self.__age =age
def tsmt1(self):
print("姓名:{0},年龄{1}".format(self.name,self.__age))
class Tsmt(Pastr):
def __init__(self,name,age,score):
Pastr.__init__(self, name, age) #必须显示的调用父类初始化方法，不然解释器不会去调用
self.score = score
print("分数:{0}".format(self.score))
a = Tsmt("杨正",24,85)
a.tsmt1()
'''''
'''''
#类成员的继承和重写
class Pastr:
def __init__(self,name,age):
self.name =name
self.__age =age
def tsmt1(self):
print("年龄{0}".format(self.__age))
def tsmt2(self):
print("姓名:{0}".format(self.name))
class Tsmt(Pastr):
def __init__(self,name,age,score):
Pastr.__init__(self, name, age) #必须显示的调用父类初始化方法，不然解释器不会去调用
self.score = score
print("分数:{0}".format(self.score))
def tsmt2(self): #重写
print("报告老师，我的名字叫:{0}".format(self.name))
a = Tsmt("杨正",18,86)
a.tsmt2()
'''''
'''''
#object根类查看属性的dir()方法
class Pastr:
def __init__(self,name,age):
self.name = name
self.age = age
def tsmt(self):
print("姓名:{0},年龄:{1}".format(self.name,self.age))
obj = object
print(dir(obj))
a =Pastr("杨正",21)
print(dir(a))
'''''
'''''
#重写object的__str__()方法
class Person: #默认继承object类
def __init__(self,name):
self.name = name
def __str__(self): #重写__str__()方法
return "名字叫：{0}".format(self.name)
a = Person("杨正")
print(a)
'''''
'''''
#多重继承 MRO()函数:两个类有同名的函数继承的顺序可以从左到右调
class A:
def a(self):
print("aa")
def sys(self):
print("AAAAAAA")
class B:
def b(self):
print("bb")
def sys(self):
print("BBBBBBB")
class C(B,A):
def c(self):
print("cc")
q = C()
q.a()
C.mro() #MRO()函数:两个类有同名的函数继承的顺序可以从左到右调
q.sys()
q.b()
q.c()
'''''
'''''
#super()获得父类定义，是代表父类的定义，而不是父类的对象
class A:
def dows(self):
print("a",self)
class B(A):
def dows(self):
#A.say(self) #调用A类里边的函数对象
super().dows() #调用A类里边的函数对象
print("bbb",self)
#B().dows() #可以调用A类里边的函数
B().dows() #调用A类里边的函数对象
'''''
'''''
#多态
#关于多态要注意以下2点
#1.多态是方法的多态，属性没有多态
#2.多态的存在有2个必要条件:继承，方法重写
class Mad:
def end(self):
print("他们在吃饭")
class Chinese(Mad):
def end(self):
print("中国人用筷子吃饭")
class Britisher(Mad):
def end(self):
print("英国人用刀叉吃饭")
class African(Mad):
def end(self):
print("非洲人用手吃饭")
def a(m):
if isinstance(m,Mad): #多态。一个方法调用，根据对象不同调用不同的方法
m.end()
else:
print("不能吃饭")
a(Chinese())
'''''
'''''
#运算符的重载
class Padsn:
def __init__(self,name):
self.name = name
def __add__(self, other):
if isinstance(other,Padsn):
return "{0}---{1}".format(self.name,other.name)
else:
return "失败" #不同的类对象，不能相加
def __mul__(self, other):
if isinstance(other,int):
return self.name*other
else:
return #"不同的类对象，不能相乘"
q1 = Padsn("杨正")
q2 = Padsn("sauw")
q = q1+q2
print(q*10)
'''''
'''''
#特殊方法
class A:
pass
class B:
pass
class C(A,B):
def __init__(self,name):
self.name=name
def sys(self):
print("cc")
c =C(12)
print(c.__dict__) #对象属性的字典
print(c.__class__) #对象所属的类
print(C.__bases__) #类的基类元组(多继承)
print(C.__base__) #类的基类
print(C.mro()) #类层次结构
print(A.__subclasses__()) #子类列表
'''''
'''''
#对象的浅复制和深复制
import copy
class A:
def __init__(self,b,c):
self.b = b
self.c = c
class B:
def b(self):
print("加123")
print("b对象",self)
class C:
def c(self):
print("哈喽")
print('c对象',self)
#测试赋值
a1 = B()
a2 = a1
print(a1)
print(a2)
#测试浅复制
b1 =C()
c1 = A(a1,b1)
c2 =copy.copy(c1) #浅复制只有主值会变其他值不会变
print(c1,c1.b,c1.c)
print(c2,c2.b,c2.c)
#测试深赋值
c3 =copy.deepcopy(c1) #深赋值所有内存的值都会变
print(c1,c1.b,c1.c)
print(c3,c3.b,c3.c)
'''''
'''''
#组合 is-a可以使用继承 has-a可以使用组合
#使用继承实现代码的复用
class A1:
def say(self):
print("a1a1a1a1")
class B1(A1):
pass
a = B1()
a.say()
#同样的效果， 使用组合实现代码的复用
class A2:
def say(self):
print("a2a2a2a2")
class B2:
def __init__(self,a):
self.a = a
a1 =A2()
b1 =B2(a1)
b1.a.say()
'''''
'''''
#测试has-a关系，组合
class A:
def __init__(self,b,c):
self.b = b
self.c = c
class B:
def b(self):
print("加123")
print("b对象",self)
class C:
def c(self):
print("哈喽")
print('c对象',self)
a = A(B(),C())
a.b.b()
a.c.c()
'''''
'''''
#设计模式——工厂模式实现和单例模式
#工厂模式
class CarFactory:
def create_car(self,brand):
if brand == "奔驰":
return Benz()
elif brand == "宝马":
return BMW()
elif brand == "比亚迪":
return BYD()
else:
print("未知品牌")
class Benz:
pass
class BMW:
pass
class BYD:
pass
factory =CarFactory()
a = factory.create_car("宝马")
b = factory.create_car("奔驰")
c = factory.create_car("水果")
print(a)
print(b)
print(c)
'''''
'''''
#设计模式———单例模式
class A:
__ode = None
__tsmt = True
def __new__(cls, *args, **kwargs):
if cls.__ode == None:
cls.__ode = object.__new__(cls)
return cls.__ode
def __init__(self,name):
if A.__tsmt:
self.name =name
print("init"*10)
A.__tsmt = False
a = A("tsmt")
b = A("123")
c = A("adinistrator")
print(a)
print(b)
print(c)
'''''
#工厂模式变成单例模式
class A:
__a = None
__b = True
def tsmt(self, bayta):
if bayta == "奔驰":
return B()
elif bayta == "宝马":
return C()
elif bayta == "比亚迪":
return D()
else:
print("没有匹配的型号")
def __new__(cls, *args, **kwargs):
if cls.__a == None:
cls.__a = object.__new__(cls)
return cls.__a
def __init__(self):
if A.__b:
print("ask")
A.__b = False
class B:
pass
class C:
pass
class D:
pass
a =A()
b = a.tsmt("奔驰")
c = a.tsmt("宝马")
print(b)
print(c)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
