学完了 Python 基础之后,当我想要把自己的一些小项目通过 Python OOP 的方式来编写的时候,却发现很难很难,于是这次重新回过头来重新学习 Python 中面向对象的思想
学习资料参考:传送门
类:用户定义的对象原型(prototype),该原型定义了一组可描述该类任何对象的属性,属性是数据成员(类变量 和 实例变量)和方法,可以通过 ‘.’ 来访问。说简单一点,类是一个模板,我们可以使用该模板生成不同的具体的对象,来完成我们想要的操作
实例:某一个类的单个对象,例如我们定义了一个 Person 类,而具体的人,比如小明,小黄就是 Person 类的实例
属性:描述该类具有的特征,比如人类具备的属性,身份证,姓名,性别,身高,体重等等都是属性
方法:是该类对象的行为,例如这个男孩会打篮球,那个女孩会唱歌等等都是属于方法,常常通过方法改变一些类中的属性值
这是早期学习基础的时候编写的文章,仅供参考学习
Python 面向对象编程(OOP)—— 类
Python 面向对象编程(OOP) ——取值,赋值方法and逻辑
Python面向对象编程(OOP) —— 继承、使用槽
Python 中定义类是使用关键字 class,一个简单的实例
class Student:
pass
# 创建对象实例
stu = Student()
print(stu)
print(property(stu))
print(type(stu))
在定义一个类的时候,我们常常会使第一个字母大写,当然小写也是可以的,但是使用大写是因为这是一种规范问题,打印的结果也可以看得到,我们创建的实例在我的计算机的 内存地址
在类中属性,包含两种
下面来看一看基本用法
# 细心的同学会发现,我这里给 类加上了括号,其实这个括号如果传参的话,我们可以传入另一类,这样的话就变成了 继承的关系
class Student():
student = "大学生"
def __init__(self,name,age):
# 定义两个对象属性,这个属性在不同的对象中是不一样的
self.name = name
self.age = age
stu1 = Student("小红",18)
stu2 = Student("小黄",19)
print(f"{stu1.name}今年{stu1.age}岁,是{stu1.__class__.student}")
print(f"{stu2.name}今年{stu2.age}岁,是{stu1.__class__.student}")
添加方法也很简单,使用 def 关键字定义一个方法,然后在方法体编写方法具体的功能即可,看下边的示例
class Student():
student = "大学生"
def __init__(self,name,age):
self.name = name
self.age = age
def sing(self):
print(f"{self.name} 会唱歌")
def basketbal(self):
print(f"{self.name} 会打篮球")
stu1 = Student("小红",18)
stu2 = Student("小黄",19)
print(f"{stu1.name}今年{stu1.age}岁,是{stu1.__class__.student}")
print(f"{stu2.name}今年{stu2.age}岁,是{stu1.__class__.student}")
stu1.sing()
stu2.basketbal()
类中的方法的定义中,第一个参数必须是 self,这个 self 就相当于 java 构造方法中的 this 关键字,它指的是当前对象,比如 stu1 是当前对象,self 指的就是 stu1。
当我们需要调用对象方法的时候,只需要使用 对象.方法([参数]) 即可,也就是上面的 stu1.sing()
在学习 java 的过程中,我们知道 java 拥有 public > default > protected > private 的四大访问修饰符。
在 Python 中也访问权限修饰符,在 Python 中修改一个属性值,可以直接通过 对象.属性 直接修改,这样是有问题的,比如我们把一个人的年龄 设置为 200,正常人都知道,一个人的最长寿命也不会超过 150 岁,所以为了防止这种情况的出现,我们可以把人的年龄设置为 私有变量,这样年龄属性就无法在外面直接访问得到了。因此我们只需要把 age字段前面加上 ‘__’ 即可,这样在外面,我们就无法使用 对象.age 或 对象.__age 访问到年龄了
class Student():
# student 是类属性,可以他通过 对象.__class__.student 访问
student = "大学生"
# init 是类的构造方法,在对象被创建的时候,就会自动调用这个方法
def __init__(self,name,age):
# 定义两个对象属性,这个属性在不同的对象中是不一样的
self.name = name
if age>150:
raise ValueError("人的年龄无法达到 150 岁以上")
self.__age = age
def sing(self):
print(f"{self.name} 会唱歌")
def basketbal(self):
print(f"{self.name} 会打篮球")
stu1 = Student("小红",18)
stu2 = Student("小黄",19)
print(stu1.age)
print(stu2.__age)
这样 age 属性就无法被直接访问了,所以,我们就需要创建两个方法,和 java 中的 setter 和 getter 方法很像
class Student():
student = "大学生"
def __init__(self,name,age):
self.name = name
if age>150:
raise ValueError("人的年龄无法达到 150 岁以上")
self.__age = age
def getAge(self):
return self.__age
def setAge(self, age):
if age > 150:
raise ValueError("人的年龄无法达到150岁")
self.__age = age
stu1 = Student("小红",18)
stu2 = Student("小黄",19)
stu1.setAge(20)
print(stu1.getAge())
我们还可以使用 ‘__’ 修饰一个方法,使其外部不可访问
示例代码如下
class Dog():
def __init__(self,name,age):
self.name = name
self.age = age
# 定义公共方法
def bark(self):
print(f"{self.name} can bark")
class pipi(Dog):
def play(self):
print(f"{self.name} 会打滚")
class dandan(Dog):
def other(self):
print(f"{self.name} 会杂技")
dog1 = pipi("皮皮",2)
dog2 = dandan("蛋蛋",3)
dog1.play()
dog1.bark() # 调用公共的方法
dog2.other()
我们在上面的代码找那个分别编写了 pipi 类 和 dandan 类,它们分别继承于 Dog 类,因此他们都会具备 Dog 类具有的属性和方法,然后他们也可以拥有他们独有的属性和方法
假设有这种情况,子类和父类拥有同样的方法名,但是我们调用的方法是属于父类的还是子类的呢?我们改一下代码看看。
class Dog():
def __init__(self,name,age):
self.name = name
self.age = age
def bark(self):
print(f"{self.name} can bark")
def eat(self):
print(f"{self.name} 喜欢吃鸡肉")
class pipi(Dog):
def play(self):
print(f"{self.name} 会打滚")
def eat(self):
print(f"{self.name} 喜欢吃火腿")
dog1 = pipi("皮皮",2)
dog1.eat()
运行结果:
所以我们发现,当子类和父类方法同名时,子类方法会覆盖父类的方法。
封装的核心:封装是隐藏对象中一些不希望被外部访问到的属性或方法
在学习 Java 的过程中,我们进行封装操作的时候,设置属性的访问权限为 private(只在当前类可以访问),所以我们会使用 getter 和 setter 方法来修改属性的值。在 Python 中我们也可以使用 同样的 getter 和 setter 方法
class Dog():
# 安全性问题,属性值不能乱改
def __init__(self,name,age):
# 方式一,换一个属性名保存
self.hidden_name = name
self.hidden_age = age
def getAge(self):
return self.hidden_age
def setAge(self, age):
if age < 0 or age > 150:
raise ValueError('年龄值不合格')
self.hidden_age = age
虽然我们这样做, 还是不希望 hidden_xx 属性被外部访问,因此使用更高级的封装
class Retangle():
# 内部访问,使用 hidden 任然可以被访问
# 使用 __作为私有属性,是外部不可以被访问
def __init__(self,width, height):
self.__width = width
self.__height = height
def setWidth(self,width):
self.__width = width
def getWidth(self):
return self.__width
def setHeight(self,height):
self.__height = height
def getHeight(self):
return self.__height
我们使用 ‘__’ 作为隐藏属性,使外部不可见,这也是很常用的一种方法,
接下来解释一下 双下划线的作用:
在 Python 中,双下换线是作为隐藏属性而存在的,但它其实还是可以通过方法访问的到的,在 Python 内部当中,双下划线实际上是把 属性换了一个更复杂的方式表示,比 hidden_属性 更复杂,它其实是把
__xxx
替换成了_类名__属性名
表示。
所以 Python 中的封装一般做到这一步就差不多了
使用装饰器把 getter 和 setter 更好的封装
class Person():
'''
__xxxx 成为隐藏属性
__name -> _Person__name
使用 _xxx 作为私有属性,没有特殊需求,不要修改私有属性
类一般使用属性或方法不可见可以使用单下划线
'''
# 使用一个
def __init__(self,name):
self.__name = name
@property
def name(self):
return self.__name
'''
setter
getter 方法更好的使用
@property,将一个 get 方法,转换为对象属性
@属性名.setter 讲一个 set 方法,转换为对象属性
两者缺一不可
'''
# setter 方法的的装饰器: @属性名.setter
@name.setter
def name(self, name):
self.__name = name
p = Person('猴赛雷')
p.name = 'aaa' # 使用属性的方式 调用 setter 和 getter
print(p.name)
多态:它指的是一个声明为 A类型的变量,可能是指 A类型的对象,也可以是 A类型的任何子类对象
class Dog():
def __init__(self,name,age):
self.name = name
if age > 100:
raise ValueError("狗狗的年龄不可能这么大")
self.__age = age
def getAge(self):
return self.__age
def setAge(self,age):
if age > 100:
raise ValueError ("狗狗的年龄不可能这么大")
self.__age = age
# 定义公共方法
def bark(self):
print(f"{self.name} can bark")
def eat(self):
print(f"{self.name} 喜欢吃鸡肉")
class pipi(Dog):
def play(self):
print(f"{self.name} 会打滚")
def eat(self):
print(f"{self.name} 喜欢吃火腿")
# 方法覆盖
def bark(self):
print(f"{self.name} 在叫,嘻嘻....")
class dandan(Dog):
def other(self):
print(f"{self.name} 会杂技")
def dog_bark(dog):
if isinstance(dog, Dog):
dog.bark()
d = Dog("阿拉斯加",3)
dog_bark(d)
d1 = pipi("小皮",2)
dog_bark(d1)
d2 = dandan("蛋蛋",1)
dog_bark(d2)
在上面的代码中,我们定义了一个 dog_bark() 方法,它可以介绍父类的对象,也可以接受子类的对象
使用多态,我们并不需要给每一个 子类定义一个调用 bark() 的方法,pipi_bark(), dandan_bark(),只需要定义一个 dog_bark(), 在调用的时候给它传递对应的子类对象即可。
面向对象三大特征
2020年3月23日 更新补充
在 python 面向对象中,总共包括五类(属性 + 方法)
class A(object):
# 类属性
count = 0
def __init__(self):
self.name = 'swk' # 实例属性
a = A() # a 就是 A对象的实例
a.count = 10 # 创建实例
A.count = 100 # 创建类对象
类属性:
第三点特性可以通过测试如下两个属性,分别单独打印,就可以看到结论
a.count = 10 # 创建实例
A.count = 100 # 创建类对象
#!/usr/bin/python
# -*- coding: utf-8 --
#@File: 35 属性和方法.py
#@author: Gorit
#@contact: [email protected]
#@time: 2020/3/18 17:30
class A(object):
count = 0 # 类属性
def __init__(self):
self.name = 'swk' # 实例属性
def test(self):
'''
以 self 为第一个参数的方法都是实例方法
实例方法在调用时,Python 会默认将调用对象作为 self 传入
实例方法可以通过实例和类去调用
- 当通过实例调用时,会自动将当前调用对象作为 self 传入
- 当通过类调用时,不会自动传递 self, 此时需要我们手动传递 self
:return:
'''
print('hello World')
'''
类方法
在类内部使用 @classmethod 来修是的方法属于类方法
类方法和实例方法的区别,实例方法第一个参数是 self, 而类方法第一个参数是 cls
类方法可以通过 类调用,也可以通过实例调用,没有区别
'''
@classmethod
def test_2(cls):
print('这是 test2 方法')
'''
静态方法:(可以直接调用)
在类中使用 @staticmethod 来修饰的方法属于静态方法
静态方法不需要任何默认参数,可以通过类和实例调用
静态方法:基本是和当前类无关的方法,它只是保存在当前类中的函数
静态方法都是一些工具方法,和当前里无关
'''
@staticmethod
def test_3():
print('test_3 执行了')
在 Python 中大家应该都用过 len(), str() 等等一些内部的函数8,其实这些方法我们也可以在类中自己定义的。
特殊方法:
也成为魔术方法,它的使用也很简单,我们使用
__
开始 以及结尾 就可以使用了
我们来简单的使用一下吧
class Test():
def __init__(self):
print("我是初始化方法")
def __len__(self):
return 55
def __str__(self):
return "Hello World"
t = Test()
print(t)
print(len(t))
print(str(t))
# 常见的还有很多,大家可以自行尝试
'''
特殊方法,也成为魔术方法
特殊方法以 __ 开头和结尾,比如
__init__ 初始化方法
__str__() str() 这个特殊方法会在尝试将对象转换为字符串的时候调用
__rpr__() rpr()
__len__() 获取长度 len()
__bool__() 返回布尔值 bool()
__pow__
__lshift__()
__lt__()
__add__()
__and__
__or__
__eq__
__sub__
'''