1、方法没有重载:即在一个类中,定义多个同名函数,在调用时只调用最新定义的方法。
2、Person 可以动态新增方法,还可以动态替换方法。
私有属性和私有方法(实现封装)
Python 对于类的成员没有严格的访问控制限制,这与其他面向对象语言有区别。关于私有属性和私有方法,有如下要点:
1. 通常我们约定,两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2. 类内部可以访问私有属性(方法)
3. 类外部不能直接访问私有属性(方法)
4. 类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)
【注】方法本质上也是属性!只不过是可以通过()执行而已。所以,此处讲的私有属性和公有属性,也同时讲解了私有方法和公有方法的用法。如下测试中,同时也包含了私有方法和公有方法的例子。
class Employee:
__company = "百战程序员" #私有类属性. 通过dir 可以查到_Employee__company
def __init__(self,name,age):
self.name = name
self.__age = age #私有实例属性
def say_company(self):
print("我的公司是:",Employee.__company) #类内部可以直接访问私有属性
print(self.name,"的年龄是:",self.__age)
self.__work()
def __work(self): #私有实例方法通过dir 可以查到_Employee__work
print("工作!好好工作,好好赚钱,娶个媳妇!")
p1 = Employee("高淇",32)
print(p1.name)
print(dir(p1)) #
p1.say_company()
print(p1._Employee__age) #通过这种方式可以直接访问到私有属
性。通过dir 可以查到属性:_Employee__age
#print(p1.__age) #直接访问私有属性,报错
#p1.__sleep() #直接访问私有方法,报错
@property 装饰器:@property 可以将一个方法的调用方式变成“属性调用”。下面是一个简单例,让大家体会一下这种转变:
class Employee:
@property
def salary(self):
return 3000
emp1=Employee()
print(emp1.salary)
也就是说,在使用该方法时可以不用加()调用方法,和属性调用一致
@property 主要用于帮助我们处理属性的读操作、写操作。对于某一个属性,我们可以直接通过:
emp1.salary = 30000
如上的操作读操作、写操作。但是,这种做法不安全。比如,我需要限制薪水必须为1-10000的数字。这时候,我们就需要通过getter、setter 方法来处理。
def __init__(self,name,salary):
self.name = name
self.__salary = salary
@property #相当于salary 属性的getter 方法
def salary(self):
print("月薪为{0},年薪为
{1}".format(self.__salary,(12*self.__salary)))
return self.__salary;
@salary.setter
def salary(self,salary): #相当于salary 属性的setter 方法,在属性赋值的时候输出,不赋值无作用
if(0<salary<1000000):
self.__salary = salary
else:
print("薪水录入错误!只能在0-1000000 之间")
emp1 = Employee("高淇",100)
print(emp1.salary)
emp1.salary = -200
总结:1、@property相当于把某个函数转化为了属性,在调用时相当于在调用函数的属性,也就是说要有返回值,调用的是返回值
2、在面向对象编程中,setter 方法用于设置类的属性值。它是一个方法,用于接收新值并将其分配给相应的属性。通过使用 setter 方法,我们可以在属性赋值时执行一些额外的操作,例如进行输入验证、触发其他操作或更新相关的属性。
属性和方法的命名总结:
· _xxx:保护成员,不能用“from module import * ”导入,只有类对象和子类对象能访问这些成员。
· __xxx__:系统定义的特殊成员
· __xxx: 类中的私有成员,只有类对象自己能访问,子类对象也不能访问。(但,在类外部可以通过“对象名. _类名__xxx”这种特殊方式访问。Python 不存在严格意义的私有成员)
注:再次强调,方法和属性都遵循上面的规则。
类编码风格
1. 类名首字母大写,多个单词之间采用驼峰原则。
2. 实例名、模块名采用小写,多个单词之间采用下划线隔开。
3. 每个类,应紧跟“文档字符串”,说明这个类的作用。
4. 可以用空行组织代码,但不能滥用。在类中,使用一个空行隔开方法;模块中,使用两个空行隔开多个类。
2. 设计一个名为MyRectangle 的矩形类来表示矩形。这个类包含:
(1) 左上角顶点的坐标:x,y
(2) 宽度和高度:width、height
(3) 构造方法:传入x,y,width,height。如果(x,y)不传则默认是0,如果width
和height 不传,则默认是100.
(4) 定义一个getArea() 计算面积的方法
(5) 定义一个getPerimeter(),计算周长的方法
(6) 定义一个draw()方法,使用海龟绘图绘制出这个矩形
import turtle
class MyRectangle:
def __init__(self,x=0,y=0,width=100,height=100):
self.x=x
self.y=y
self.width=width
self.height=height
def getArea(self):
print(f'该矩形的面积是:{self.width*self.height}')
return self.width*self.height
def getPerimeter(self):
print(f'该矩形的周长为{2*(self.width+self.height)}')
def draw(self):
turtle.speed(5)
turtle.penup()
turtle.goto(self.x,self.y)
turtle.pendown()
turtle.goto(self.x+self.width, self.y)
turtle.goto(self.x + self.width, self.y+self.height)
turtle.goto(self.x, self.y + self.height)
turtle.goto(self.x, self.y)
turtle.done()
MR=MyRectangle(2,3,190,180)
print(MR.getPerimeter())
面向对象三大特征介绍:
Python 是面向对象的语言,也支持面向对象编程的三大特性:继承、封装(隐藏)、多态。
继承:
语法格式
Python 支持多重继承,一个子类可以继承多个父类。继承的语法格式如下:
class 子类类名(父类1[,父类2,...]):
类体
如果在类定义中没有指定父类,则默认父类是object 类。也就是说,object 是所有类的父类,里面定义了一些所有类共有的默认实现,比如:__new__()。
class Person:
def __init__(self,name,age):
self.name = name
self.__age = age
def say_age(self):
print(self.name,"的年龄是:",self.__age)
class Student(Person):
def __init__(self,name,age,score):
self.score = score
Person.__init__(self,name,age) #构造函数中包含调用父类构造函数。根据需要,不是必须。子类并不会自动调用父类的__init__(),我们必须显式的调用它。
s1 = Student("张三",15,85)
s1.say_age()
print(dir(s1))
类成员的继承和重写
1. 成员继承:子类继承了父类除构造方法之外的所有成员。
2. 方法重写:子类可以重新定义父类中的方法,这样就会覆盖父类的方法,也称为“重写”
查看类的继承层次结构
通过类的方法mro()或者类的属性__mro__可以输出这个类的继承层次结构。
查看类的继承层次结构
class A:pass
class B(A):pass
class C(B):pass
print(C.mro())
执行结果:
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
object 根类
object 类是所有类的父类,因此所有的类都有object 类的属性和方法。我们显然有必要深入研究一下object 类的结构。对于我们继续深入学习Python 很有好处。
dir()查看对象属性
内置函数dir(),他可以让我们方便的看到指定对象所有的属性。
重写__str__()方法:object 有一个__str__()方法,用于返回一个对于“对象的描述”,对应于内置数str()经常用于print()方法,帮助我们查看对象的信息。__str__()可以重写。
'''将对象转化成一个字符串,一般用于print 方法'''
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return f'{self.name}的年龄是{self.age}'
p=Person('高崎',19)
print(p)
多重继承:Python 支持多重继承,一个子类可以有多个“直接父类”。这样,就具备了“多个父类”的特点。但是由于,这样会被“类的整体层次”搞的异常复杂,尽量避免使用。
MRO():Python 支持多继承,如果父类中有相同名字的方法,在子类没有指定父类名时,解释器将“从左向右”按顺序搜索。
MRO(Method Resolution Order):方法解析顺序。我们可以通过mro()方法获得“类的层次结构”,方法解析顺序也是按照这个“类的层次结构”寻找的。
super()获得父类定义:在子类中,如果想要获得父类的方法时,我们可以通过super()来做。
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
def say_name(self):
print(f'{self.name}的年龄是{self.age}')
class Animal(Person):
def say_name(self):
super().say_name()
print(f'{self.name}我爱你')
p=Animal('高崎',19)
print(p.say_name())
多态:
多态(polymorphism)是指同一个方法调用由于对象不同可能会产生不同的行为。在现实生活中,我们有很多例子。比如:同样是调用人的休息方法,张三的休息是睡觉,李四的休息是玩游戏,高淇老师是敲代码。同样是吃饭的方法,中国人用筷子吃饭,英国人用刀叉吃饭,印度人用手吃饭。
关于多态要注意以下2 点:
1. 多态是方法的多态,属性没有多态。
2. 多态的存在有2 个必要条件:继承、方法重写。(底层原理就是方法重写)
class Animal:
def shout(self):
print("动物叫了一声")
class Dog(Animal):
def shout(self):
print("小狗,汪汪汪")
class Cat(Animal):
def shout(self):
print("小猫,喵喵喵")
def animalShout(a):
if isinstance(a,Animal):
a.shout() #传入的对象不同,shout 方法对应的实际行为也不同。
animalShout(Dog())
animalShout(Cat())
运行结果:
小狗,汪汪汪
小猫,喵喵喵
特殊方法和运算符重载
class Person:
def __init__(self,name):
self.name = name
def __add__(self, other):
if isinstance(other,Person):
return "{0}--{1}".format(self.name,other.name)
else:
return "不是同类对象,不能相加"
def __mul__(self, other):
if isinstance(other,int):
return self.name*other
else:
return "不是同类对象,不能相乘"
p1 = Person("高淇")
p2 = Person("高希希")
x = p1 + p2
print(x)
print(p1*3)
运算结果:
高淇--高希希
高淇高淇高淇
特殊属性:
Python 对象中包含了很多双下划线开始和结束的属性,这些是特殊属性,有特殊用法。这里我们列出常见的特殊属性:
class A:
pass
class B:
pass
class C(A,B):
def __init__(self,name):
self.name=name
def say_name(self):
print(f'他的名字叫{self.name}')
m=C('大傻子')
print(dir(m))
print(m.__dict__)
print(m.__class__)
print(C.__bases__)
print(C.__base__)
print(C.mro())
print(A.__subclasses__())
对象的浅拷贝和深拷贝:
·变量的赋值操作
只是形成两个变量,实际还是指向同一个对象。
·浅拷贝
Python 拷贝一般都是浅拷贝。拷贝时,对象包含的子对象内容不拷贝。因此,源对象和拷贝对象会引用同一个子对象。
·深拷贝
使用copy 模块的deepcopy 函数,递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同。
组合
“is-a”关系,我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系:狗是动物,dog is animal。狗类就应该继承动物类。
“has-a”关系,我们可以使用“组合”,也能实现一个类拥有另一个类的方法和属性。”has-a”关系指的是这样的关系:手机拥有CPU。MobilePhone has a CPU。
class Mobilephone:
def __init__(self,cpu,screen):
self.cpu=cpu
self.screen=screen
class CPU:
def calculate(self):
print('计算,计算个12345')
class Screen:
def show(self):
print('显示一个好看的图案')
c=CPU()#c拥有了cpu的方法
s=Screen()#s拥有了screen的方法
m=Mobilephone(c,s)#c和s分别赋值给cpu及screen
print(m.cpu.calculate())#调用时调用cpu的方法calculate
print(m.screen.show())
设计模式_工厂模式实现
设计模式是面向对象语言特有的内容,是我们在面临某一类问题时候固定的做法,设计模式有很多种,比较流行的是:GOF(Goup Of Four)23 种设计模式。当然,我们没有必要全部学习,学习几个常用的即可。
对于初学者,我们学习两个最常用的模式:工厂模式和单例模式。工厂模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。
class Carfactory:
def carbrand(self,brand):
if brand=='Benzi':
return Benzi()
elif brand=='BMW':
return BMW()
elif brand == 'BYD':
return BYD()
else:
print('无该品牌,无法创建')
class Benzi:
pass
class BMW:
pass
class BYD:
pass
factory=Carfactory()
print(factory.carbrand('BMW'))
print(factory.carbrand('haif'))
<__main__.BMW object at 0x000001D0E57606D0>
无该品牌,无法创建
None
总结:由一个类判断能否创建,如果可以,则创建该类返回对应的类
设计模式_单例模式实现
单例模式(Singleton Pattern)的核心作用是确保一个类只有一个实例,并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象,减少了对系统资源的开销。当一个对象的产生需要比较多的资源,如读取配置文件、产生其他依赖对象时,可以产生一个“单例对象”,然后永久驻留内存中,从而极大的降低开销。
单例模式有多种实现的方式,我们这里推荐重写__new__()的方法。
class Mysingleton:
__obj = None
__init_flag = True
def __new__(cls, *args, **kwargs): #利用new()创建新对象
if cls.__obj ==None: #仅在obj是None的时候创建新的对象
cls.__obj=object.__new__(cls)
return cls.__obj #当创建一次对象后不再通过if函数直接返回首次创建的对象
def __init__(self,name):
if Mysingleton.__init_flag: #首次实例化过程
print('int.....')
self.name=name
Mysingleton.__init_flag=False #之后出现新的值不再创建新的实例,永久驻留系统
S=Mysingleton('高崎')
print(S)
k=Mysingleton('张三')
print(k)
int.....
<__main__.Mysingleton object at 0x0000022E839C0850>
<__main__.Mysingleton object at 0x0000022E839C0850>
class Computerfactory:
__obj=None
__init_flag=True
def computers(self,brand):
if brand=='联想':
return Lenvon()
elif brand=='华硕':
return Ausu()
elif brand=='神舟':
return Sz()
else:
return '输入有误,无法生产'
def __new__(cls, *args, **kwargs):
if cls.__obj==None:
cls.__obj=object.__new__(cls)
return cls.__obj
def __init__(self):
if Computerfactory.__init_flag:
print('.......')
Computerfactory.__init_flag = False
class computer:
def calculate(self):
print('计算完毕母亲')
class Lenvon(computer):
def calculate(self):
print('计算完毕Lenvon')
class Ausu(computer):
def calculate(self):
super().calculate()
print('计算完毕Ausu')
class Sz(computer):
def calculate(self):
print('计算完毕Sz')
factory=Computerfactory()
print(factory.computers('联想').calculate())
print(id(factory.computers('神舟').calculate()))
factory2=Computerfactory()
print(factory)
print(factory2)
print(id(factory2.computers('华硕').calculate()))
class Car:
def __init__(self,workm,works,workc):
self.workm=workm
self.works=works
self.workc=workc
def run(self):
return f'{self.workm}是发动机,{self.works}是座椅,{self.workc}是底盘'
class Motor:
def work(self):
return 'Motor'
class Seat:
def work(self):
return 'Seat'
class Chassis:
def work(self):
return 'Chassis'
a=Motor()
b=Seat()
e=Chassis()
p=Car(a.work(),b.work(),e.work())
print(p.run())
class Employee:
id=1000
def __init__(self,name,salary):
self.name=name
self._salary=salary
Employee.id+=1
def __add__(self, other):
if isinstance(other,int):
return self+other
@property
def salary(self):
return f'{self.name}的薪水是{self._salary}'
@salary.setter
def salary(self,salary):
if 1000<salary<50000:
print(f'{self.name}的薪水Wie{self._salary}')
else:
print('薪水输入有误')
s=Employee('高崎',5000)
print(s.salary)
s.salary=8000