类(Class)是现实或思维世界中的实体在计算机中的反映,它将数据以及这些数据上的操作封装在一起。
对象(Object)是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概
念
类(Class)是是创建实例的模板;对象(Object)是一个一个具体的实例
实例化是指在面向对象的编程中,把用类创建对象的过程称为实例化。是将一个抽象的概念类,具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名(参数1,参数2…参数n)
构成
class Cat():
## 属性 名词
name = 'CCC'
kind = '布偶'
## 方法 动词
def eat(self):
print('cat like eat fish')
## 对象:类的实例化
neni = Cat()
print(Cat) ## 类
print(neni) ## 类的对象<__main__.Cat object at 0x000001749CBB22E0>
(1)封装是将内容封装到某个地方,以后再去调用被封装在某处的内容。在使用面向对象的封装特性时,需要:
1). 将内容封装到某处
2). 从某处调用被封装的内容
通过对象直接调用被封装的内容: 对象.属性名
通过self间接调用被封装的内容: self.属性名
通过self间接调用被封装的内容: self.方法名()
(2)构造方法__init__
与其他普通方法不同的地方在于,当一个对象被创建后,会立即调用构造方法。自动执行构造方法里面的内容
(3)对于面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过对象直接或者self间接获取被封装的内容
class Cat():
def __init__(self,name,kind):
## 1. 构造方法,实例化对象时自动执行的方法
## 2. self是什么? self实质上是实例化的对象
## 3. 类方法中, python解释器会自动把对象作为参数传给self
print("正在执行__init__构造方法")
print('self',self) ## self <__main__.Cat object at 0x00000193F3C3AA60>
# 封装: self.name将对象和name属性封装/绑定
self.name=name
self.kind=kind
## 方法 动词
def eat(self):
print(self) ## <__main__.Cat object at 0x00000193F3C3AA60>
print('cat %s like eat fish' %(self.name))
## 对象:类的实例化
neni = Cat('neni','布偶')
print(neni.name) ## 类
print(neni.kind) ## 类的对象<__main__.Cat object at 0x000001749CBB22E0>
neni.eat() ## 调用封装的内容
## 输出
正在执行__init__构造方法
self <__main__.Cat object at 0x00000193F3C3AA60>
neni
布偶
<__main__.Cat object at 0x00000193F3C3AA60>
cat neni like eat fish
练习:
创建一个类People,拥有的属性为姓名, 性别和年龄, 拥有的方法为购物,学习;实例化对象执行相应的方法,输出如下的内容
小明,18岁,女去购物
小华,23岁,女去购物
小红,13岁,女学习
class People():
def __init__(self,name,age,gender):
self.name=name
self.age=age
self.gender=gender
def Shopping(self):
print(f'{self.name},{self.age}岁,{self.gender}去购物')
def Learning(self):
print(f'{self.name},{self.age}岁,{self.gender}学习')
p1=People("小明",18,'女')
p2=People("小华",23,'女')
p3=People("小红",13,'女')
p1.Shopping()
p2.Shopping()
p3.Learning()
输出:
小明,18岁,女去购物
小华,23岁,女去购物
小红,13岁,女学习
继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、Superclass)。
子类在继承的时候,在定义类时,小括号()中为父类的名字
(1)继承的工作机制
父类的属性、方法,会被继承给子类。 举例如下: 如果子类没有定义__init__方法,父类有,那么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的__init__方法。
class Cat(): ## 父类
def __init__(self):
print("正在运行Cat的__init__方法")
class BlueCat(Cat): ## 子类,BlueCat是Cat的字类
pass
tom=BlueCat()
输出:
正在运行Cat的__init__方法
(2)重写父类方法: 就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法。
class Cat():
def eat(self):
print('Cat like eat fish')
class BlueCat(Cat):
def eat(self): ## 当子类和父类方法同名时,父类的方法会被子类覆盖
print('BlueCat dislike eat Vegetables')
tom=BlueCat()
tom.eat()
输出:
BlueCat dislike eat Vegetables
(3)调用父类的方法:
需求: 先执行父类的eat()方法, 再个性化执行自己的方法
父类名.父类的方法名()
super(): py2.2+的功能
class Cat():
def eat(self):
print('Cat like eat fish')
def sleep(self):
print('Cat like sleep')
class BlueCat(Cat):
def eat(self):
# Cat.eat(self) 解决方法1: 直接执行父类的方法,但不建议
super(BlueCat,self).eat() ## 通过super找到父类,再执行方法
print('BlueCat dislike eat Vegetables')
tom=BlueCat()
tom.eat()
输出:
Cat like eat fish
BlueCat dislike eat Vegetables
在Python 2及以前的版本中,由任意内置类型派生出的类,都属于“新式
类”,都会获得所有“新式类”的特性;反之,即不由任意内置类型派生出的类,则称之为“经典类
新式类: 广度优先算法
经典类: 深度优先算法(py2中的部分类属于经典类)
在Python 3之后的版本,因为所有的类都派生自内置类型object(即使没有显示的继承object类型),即所有的类都是“新式类”。新式类的继承算法是广度优先
经典类和新式类最明显的区别在于继承搜索的顺序不同,即:
(1)python中的私有属性和私有方法
确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护, 代码更加健壮。默认情况下,属性在 Python 中都是“public“
(2)私有属性的使用
class Student:
"""父类Student"""
def __init__(self, name, age, score):
self.name = name
self.age = age
# 私有属性,以双下划线开头。
# 工作机制: 类的外部(包括子类)不能访问和操作,类的内部可以访问和操作。
self.__score = score
s1=Student('tom',12,80)
print(s1.score) ## AttributeError: 'Student' object has no attribute 'score'
class Student:
"""父类Student"""
def __init__(self, name, age, score):
self.name = name
self.age = age
# 私有属性,以双下划线开头。
# 工作机制: 类的外部(包括子类)不能访问和操作,类的内部可以访问和操作。
self.__score = score
def get_score(self): ## 私有属性只能在类内部访问
return self.__score
s1=Student('tom',12,80)
score=s1.get_score()
print(score)
(3)私有方法的使用
def __init__(self, name, age, score):
self.name = name
self.age = age
# 私有属性,以双下划线开头。
# 工作机制: 类的外部(包括子类)不能访问和操作,类的内部可以访问和操作。
self.__score = score
def get_score(self):
self.__modify_score() ## 私有方法只能在类内部调用
return self.__score
def __modify_score(self):
self.__score += 20
s1=Student('tom',12,80)
#score=s1.get_score() 报错AttributeError: 'Student' object has no attribute '__modify_score'
score=s1.get_score()
print(score)
输出:
100
多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口
的多种不同的实现方式即为多态。通俗来说: 同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。
多态的使用
class Student:
"""父类Student"""
def __init__(self, name, age, score):
self.name = name
self.age = age
# 私有属性,以双下划线开头。
# 工作机制: 类的外部(包括子类)不能访问和操作,类的内部可以访问和操作。
self.score = score
def info(self):
print(f'{self.name}年龄{self.age}分数{self.score}')
s1=Student('tom',12,80)
s1.info()
s1=Student('jarry',19,90)
s1.info()
s1=Student('lily',16,70)
s1.info()
输出:
tom年龄12分数80
jarry年龄19分数90
lily年龄16分数70