目录
面向对象是把构成问题的事务分解成各个对象,每个对象都有自己独立的属性和行为, 对象可以将整个问题事务进行分工, 不同的对象做不同的事情, 这种面向对象的编程思想由于更加贴近实际生活, 所以被计算机语言广泛应用。
常见的面向对象编程语言:Java / C++ / Python等等;
面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。
面向过程:C
总之,Python中万事万物皆对象,而面向对象的三大特性:封装、继承和多态。
类的定义
Python 中定义一个类使用 class 关键字实现,其基本语法格式如下:
class 类名:
多个(≥0)类属性...
多个(≥0)类方法...
注意,无论是类属性还是类方法,对于类来说,它们都不是必需的,可以有也可以没有。另外,Python 类中属性和方法所在的位置是任意的,即它们之间并没有固定的前后次序。
和变量名一样,类名本质上就是一个标识符,因此我们在给类起名字时,必须让其符合 Python 的语法。有读者可能会问,用 a、b、c 作为类的类名可以吗?从 Python 语法上讲,是完全没有问题的,但作为一名合格的程序员,我们必须还要考虑程序的可读性。
因此,在给类起名字时,最好使用能代表该类功能的单词,例如用Student
作为学生类的类名;甚至如果必要,可以使用多个单词组合而成。
class Dog:
name: str = "小黑"
age: int = 2
注意,如果由单词构成类名,建议每个单词的首字母大写,其它字母小写;同属一个类的所有类属性和类方法,要保持统一的缩进格式,通常统一缩进 4 个空格
实例化对象
对已定义好的类进行实例化,其语法格式如下:
类名(参数)
定义类时,如果没有手动添加 __init__()
构造方法,又或者添加的 __init__()
中仅有一个 self 参数,则创建类对象时的参数可以省略不写。
# 1.实例化对象
# java方式:Dog d1=new Dog();
d1 = Dog()
d2 = Dog()
print(d1)
print(d2)
类变量
类变量指的是在类中,但在各个类方法外定义的变量。举个例子:
class Dog:
name: str="小花"
type: str="金毛"
age: int = 3
上述代码中,name和age都是类变量。
类变量的特点是,所有类的实例化对象都同时共享类变量,也就是说,类变量在所有实例化对象中是作为公用资源存在的。类方法的调用方式有 2 种,既可以使用类名直接调用,也可以使用类的实例化对象调用。
-
通过类名调用类变量和修改类变量的值:
# 使用类名直接调用
print(f"name={Dog.name},type={Dog.type},age={Dog.age}")
# 修改类变量的值
Dog.name="钱多多"
print(Dog.name)
-
通过类对象来调用所属类中的类变量:(此方式不推荐使用)
# 实例化对象
d1 = Dog()
# 获取对象中的属性
print(f"name={d1.name},age={d1.age}")
# 修改对象中的属性
d1.name="小黑"
d1.gender="公"
print(f"name={d1.name},gender={d1.gender}")
注意:通过类对象是无法修改类变量的。通过类对象对类变量赋值,其本质将不再是修改类变量的值,而是在给该对象定义新的实例变量
-
所有类的实例化对象都同时共享类变量:
class Dog:
name: str = "小黑"
age: int = 3
d2 = Dog()
d3 = Dog()
print(d2.name)
print(d3.name)
Dog.name="小白"
print(d2.name)
print(d3.name)
显然,通过类名修改类变量,会作用到所有的实例化对象
函数和实例变量
实例变量指的是在任意类方法内部,以“self.变量名”的方式定义的变量,其特点是只作用于调用方法的对象。另外,实例变量只能通过对象名访问,无法通过类名访问。
给类添加方法,方法就是定义再类中的函数:
class Dog:
name: str="小花"
type: str="金毛"
age: int = 3
def say(self):
pass
每个与类相关联的方法调用都自动传递实参self,它是一个指向实例本身的引用,让实例能够访问类中的属性和方法。相当于Java中的this
def say(self):
print(f"你好,我是{self.name}")
携带多个参数时,其他的参数放在 self 之后:
def say(self,food: str):
print(f"你好,我是{self.name}!我喜欢吃{food}")
类中,实例变量和类变量可以同名,但这种情况下使用类对象将无法调用类变量,它会首选实例变量,这也是不推荐类变量使用对象名调用的原因。
init()构造函数
在创建类时,我们可以手动添加一个 __init__()
方法,该方法是一个特殊的类实例方法,称为构造方法(或构造函数)。
构造方法用于创建对象时使用,每当创建一个类的实例对象时,Python解释器都会自动调用它。Python类中,手动添加构造方法的语法格式如下:
def __init__(self,...):
代码块
注意,此方法的方法名中,开头和结尾各有 2 个下划线,且中间不能有空格。Python 中很多这种以双下划线开头、双下划线结尾的方法,都具有特殊的意义
-
定义类时,如果没有手动添加
__init__()
构造方法,又或者添加的__init__()
中仅有一个 self 参数,则创建类对象时的参数可以省略不写,如下所示:
class Dog:
def __init__(self):
print("实例化")
d = Dog()
-
init() 方法可以包含多个参数,但必须包含一个名为 self 的参数,且必须作为第一个参数。也就是说,类的构造方法最少也要有一个 self 参数。如下所示:
class Dog:
def __init__(self,sname: str,sage: int):
print("正在使用多参数的init函数进行实例化")
d = Dog("小白",2)
-
在python没有重载一说,如果硬是要做,可以使用默认值方式:
class Dog:
def __init__(self,sname: str='',sage: int=0):
print("正在使用多参数的init函数进行实例化")
d = Dog(sname="小白")
魔法函数
Python 类中,凡是以双下划线 "" 开头和结尾命名的成员(属性和方法),都被称为类的特殊成员(特殊属性和特殊方法)。例如,类的 init__(self) 构造方法就是典型的特殊方法。
-
示例一:
__str__()
重载父类object中的__str__()
用于将值转化为字符串形式:
class Dog:
def __str__(self):
return f"name={self.name},age={self.age},sex={self.sex}"
-
示例二:
__call__()
Python类中一个非常特殊的实例方法,即 __call__()
。该方法的功能类似于在类中重载 () 运算符,使得类实例对象可以像调用普通函数那样,以“对象名()”的形式使用。
class Dog:
# 定义__call__方法
def __call__(self,name,age):
print("调用__call__()方法",name,age)
d1 = Dog()
d1("小花",2)
可以看到,通过在 Dog 类中实现 __call__()
方法,使的 d1实例对象变为了可调用对象。
更多内容,请查看Python中的魔法函数。
三大特性
封装
简单的理解封装(Encapsulation),即在设计类时,刻意地将一些属性和方法隐藏在类的内部,这样在使用此类时,将无法直接以“类对象.属性名”(或者“类对象.方法名(参数)”)的形式调用这些属性(或方法),而只能用未隐藏的类方法间接操作这些隐藏的属性和方法。
property()函数
我们一直在用“类对象.属性”的方式访问类中定义的属性,其实这种做法是欠妥的,因为它破坏了类的封装原则。正常情况下,类包含的属性应该是隐藏的,只允许通过类提供的方法来间接实现对类属性的访问和操作。
因此,在不破坏类封装原则的基础上,为了能够有效操作类中的属性,类中应包含读(或写)类属性的多个 getter(或 setter)方法,这样就可以通过“类对象.方法(参数)”的方式操作属性,例如:
通过添加 __ 修饰符将变量声明为私有化属性。
class Dog:
name: str = '小黑'
age: int = 3
__sex: str = '公'
被修饰的变量无法再类的外部被访问,但是可以通过 self 对象来调用。
# 提供getter/setter
def get_sex(self):
return self.__sex
def set_sex(self, sex: str):
self.__sex = sex
类方法
Python 类方法和实例方法相似,它最少也要包含一个参数,只不过类方法中通常将其命名为 cls,Python 会自动将类本身绑定给 cls 参数(注意,绑定的不是类对象)。也就是说,我们在调用类方法时,无需显式为 cls 参数传参。
和 self 一样,cls 参数的命名也不是规定的(可以随意命名),只是 Python 程序员约定俗称的习惯而已。
和实例方法最大的不同在于,类方法需要使用@classmethod
修饰符进行修饰,例如:
class Dog:
# 类方法
@classmethod
def info(cls):
print(cls)
注意,如果没有
@classmethod
,则 Python 解释器会将 fly() 方法认定为实例方法,而不是类方法。
类方法推荐使用类名直接调用,当然也可以使用实例对象来调用(不推荐)。
d1 = Dog()
d1.info()
Dog.info()
静态方法
静态方法,其实就是我们学过的函数,和函数唯一的区别是,静态方法定义在类这个空间(类命名空间)中,而函数则定义在程序所在的空间(全局命名空间)中。
静态方法没有类似 self、cls 这样的特殊参数,因此 Python 解释器不会对它包含的参数做任何类或对象的绑定。也正因为如此,类的静态方法中无法调用任何类属性和类方法。
静态方法需要使用@staticmethod
修饰,例如:
class Dog:
# 静态方法
@staticmethod
def say():
print("静态方法被调用了...")
静态方法的调用,既可以使用类名,也可以使用类对象,例如:
d1 = Dog()
d1.say()
Dog.say()
继承
Python 中,实现继承的类称为子类,被继承的类称为父类(也可称为基类、超类)。
子类继承父类时,只需在定义子类时,将父类(可以是多个)放在子类之后的圆括号里即可。语法格式如下:
class 类名(父类1, 父类2, ...): #类定义部分
注意,如果该类没有显式指定继承自哪个类,则默认继承 object 类(object 类是 Python 中所有类的父类,即要么是直接父类,要么是间接父类)。另外,Python 的继承是多继承机制(和 C++一样),即一个子类可以同时拥有多个直接父类。
class Father(object):
height=180
money=100
def work(self):
print("会工作")
pass
class Mother(object):
fact='漂亮'
money=90
def cook(self):
print("会做饭")
pass
class Son(Father,Mother):
pass
# 创建son的实例
s=Son()
s.cook()
s.work()
print(s.fact)
print(s.height)
print(s.money)
同时继承 Father类和 Mother类时,Father类在前,当属性和方法重复时,越往前优先级越高。
查看继承关系
print(Dog.__bases__)
print(Dog.__mro__)
多态
class Animal(object):
def play(self):
pass
class Tiger(Animal):
def play(self):
print("正在表演老虎后脚直立行走")
class Lion(Animal):
def play(self):
print("正在表演狮子跳火圈")
class Person(object):
def show(self, a: Animal):
print("动物表演开始了")
a.play()
p = Person()
tiger = Tiger()
lion = Lion()
p.show(tiger)
p.show(lion)
扩展
slots
每个类都有实例属性。默认情况下Python⽤⼀个字典来保存⼀个对象的实例属性。所以我们在可以在运⾏时去设置任意的新属性。
所以,动态给类或者实例对象添加属性或方法,是非常灵活的。但与此同时,如果胡乱地使用,也会给程序带来一定的隐患,即程序中已经定义好的类,如果不做任何限制,是可以做动态的修改的。
Python 提供了 __slots__
属性,通过它可以避免用户频繁的给实例对象动态地添加属性或方法。
class Dog(object):
__slots__ = ["name","age"]
def __init__(self,name,age):
print("实例化")
self.name=name
self.age=age
__slots__
只能限制为实例对象动态添加属性和方法,而无法限制动态地为类添加属性和方法。
类装饰器
类装饰器在内部的装饰函数是用__call__()
方法实现的。
class Logger(object):
def __init__(self, path='out.txt'):
self.path = path
def __call__(self, func):
def inner():
log = func.__name__ + "执行"
with open(self.path, 'a') as opened_file:
opened_file.write(log + '\n')
self.notify()
return inner
def notify(self):
pass
@Logger()
def hello():
pass
hello()
@Logger 在这里的作用实际就是实例化一个fun对象(fun=Logger(fun))