面向对象编程:Object oriented programming 简写OOP
了解面向对象基本概念
之前学习的python变成方式是 面向过程的,而面向过程与面向对象,是两种不同的编程方式。
过程是早期的变成概念
过程类似于函数,只能执行,但是没有返回值
函数不仅能执行,还可以返回结果
1)面向过程怎么做?
特点
2)面向对象
相比函数,面向对象是更大的封装,职责在一个对象中封装多个方法
特点
类和对象是面向对象编程的两个核心概念
类一般需要满足以下三个要素:
面向对象是更大的封装,在一个类中封装多个方法,这样通过这个类创建出来的对象,就可以直接调用这些方法
在python中要定义一个只包含方法的类,语法格式如下:
class 类名:
def 方法1(self, 参数列表):
pass
def 方法2(self,参数列表):
pass
当一个类定义完成之后,要使用这个类来创建对象,语法格式如下:
对象变量 = 类名()
需求
分析
class Cat:
def eat(self):
print("小猫爱吃鱼")
def drink(self):
print("小猫爱喝水")
# 创建猫对象
tom = Cat()
tom.drink()
tom.eat()
案例进阶 使用Cat类再创建个对象
# 再创建个猫对象
lazy_cat = Cat()
lazy_cat.drink()
lazy_cat.eat()
其中lazy_cat与tom两个不是一个对象,但属于同一类中
案例改造
.
设置一个属性即可class Cat:
def eat(self):
print("%s 爱吃鱼" % self.name)
def drink(self):
print("%s 爱喝水" % self.name)
# 创建猫对象
tom = Cat()
# 访问对象的属性
tom.name = "Tom"
tom.drink()
tom.eat()
# 再创建个猫对象
lazy_cat = Cat()
# 访问对象的属性
lazy_cat.name = "大懒猫"
lazy_cat.drink()
lazy_cat.eat()
类名()
创建对象时,会自动执行以下操作:__init__
方法,它时对象的内置方法__init__
方法时专门用来定义一个类具有哪些属性的方法!
在Cat
中增加__init__
方法,验证该方法在创建对象时会被自动调用
class Cat:
def __init__(self):
print("这是一个初始化方法")
# 没有调用对象的属性,但是仍然会输出
tom = Cat()
__init__
方法内部使用self.属性名=属性的初始值
就可以定义属性Cat
类创建的对象都会拥有该属性class Cat:
def __init__(self):
print("这是一个初始化方法")
# self.属性名 = 属性的初始值
self.name = "Tom"
__init__
方法进行改造__init__
方法的参数self.属性=形参
接受外部传递的参数类名(属性1,属性2,...)
调用class Cat:
def __init__(self, new_name):
print("这是一个初始化方法")
# self.属性名 = 属性的初始值
self.name = new_name
序号 | 方法名 | 类型 | 作用 |
---|---|---|---|
01 | __del__ |
方法 | 对象从内存中销毁时,自动调用 |
02 | __str__ |
方法 | 返回对象的描述信息,print函数输出使用 |
__del__
方法
类名()
创建对象时,为对象分配完空间后,会自动调用__init__
方法__del__
方法__init__
改造初始化方法,可以让创建对象更加灵活__del__
如果希望在对象被销毁前,再做一些事情,可以考虑一下__del__
方法类名()
创建,生命周期开始__del__
方法一旦被调用,生命周期结束class Cat:
def __init__(self, new_name):
print("这是一个初始化方法")
# self.属性名 = 属性的初始值
self.name = new_name
def __del__(self):
print("%s 删了" % self.name)
tom = Cat("Tom")
print("-" * 50)
这样tom删了的字样会在打印分割线之下才能输出
class Cat:
def __init__(self, new_name):
print("这是一个初始化方法")
# self.属性名 = 属性的初始值
self.name = new_name
def __del__(self):
print("%s 删了" % self.name)
tom = Cat("Tom")
# 使用del关键字删除一个对象
del tom
print("-" * 50)
这样tom删了的字样会在分割线之上就已经输出
__str__
方法
pring
输出变量对象时,能够打印自定义内容,就可以利用__str__
方法class Cat:
def __init__(self, new_name):
print("这是一个初始化方法")
# self.属性名 = 属性的初始值
self.name = new_name
def __del__(self):
print("%s 删了" % self.name)
def __str__(self):
# 必须返回一个字符串
return "我是小猫 %s" % self.name
# 创建猫对象
tom = Cat("Tom")
print(tom)
案例
需求:
75
公斤0.5
公斤1
公斤封装:
Code:
class Person():
def __init__(self, name, weight):
# self.属性 = 形参
self.name = name
self.weight = weight
def __str__(self):
return "我的名字叫 %s 我的体重是 % .2f 公斤" % (self.name, self.weight)
def run(self):
print("%s 爱跑步,跑步锻炼身体" % self.name)
self.weight -= 0.5
def eat(self):
print("%s 爱吃,吃完再减肥" % self.name)
self.weight += 1
xiaoming = Person("小明", 75)
xiaoming.eat()
xiaoming.run()
print(xiaoming)
应用场景
定义方式
class Women():
def __init__(self, name, weight):
# self.属性 = 形参
self.name = name
# weight就是表示women类的私有属性,无法被调用输出
self.__weight = weight
def secret(self):
print("%s 的年龄是 %d" % (self.name, self.__weight))
def __msecret(self):
print("%s 的年龄是 %d" % (self.name, self.__weight))
xiaomei = Women("小明", 75)
xiaomei.secret()
# 私有方法,在外界也无法被直接访问
xiaomei.__msecret()
# 私有属性,在外界无法被直接访问
print(xiaomei.__weight)
目标
面向对象三大特性
继承的概念、语法和特点
继承的概念:子类拥有父类的所有方法和属性
1. 继承的语法
class 类名(父类名):
pass
2. 继承的传递性
c
类从b
类继承,b
类由从a
类继承c
类就具有b
类和a
类的所有属性和方法子类拥有父类以及父类的父类中封装的所有属性和方法
3.方法的重写
覆盖父类的方法
具体的实现方式,相当于在子类中定义了一个和父类同名的方法并实现,重写之后,在 运行时只会调用子类中重写的方法,而不再调用父类封装的方法
对父类方法进行扩展
可以使用扩展的方式:
在子类中重写父类的方法
在需要的位置使用super().父类方法
来调用父类方法的执行
代码其他的位置针对子类的需要,编写子类特有的代码实现
关于super
python
中super
是一个特殊的类super()
就是使用super
创建的对象4.父类的私有属性和私有方法
概念:
语法:
clsaa 子类名(父类名1, 父类名2,...)
pass
注意事项: 如果不同的父类中存在同名的方法,在开发时,应该尽量避免这种容易混淆的情况
面向对象三大特性
封装根据职责将属性和方法封装到一个抽象的类中
继承实现代码的重用,相同的代码不需要重复的编写
多态不同的子类对象调用相同的父类,产生不同的执行后果
class Dog(object):
def __init__(self, name):
self.name = name
def game(self):
print("%s 蹦蹦跳跳的玩耍..." % self.name)
class XiaoTianDog(Dog):
def game(self):
print("%s 飞到天上去玩耍..." % self.name)
class Person(object):
def __init__(self, name):
self.name = name
def game_with_dog(self, dog):
print("%s 和 %s 快乐的玩耍" % (self.name, dog.name))
dog.game()
# 创建一个狗对象
# wangcai = Dog("旺财") # 引用的是父类中的方法
wangcai = XiaoTianDog("飞天旺财") # 引用的Dog子类的方法
# 创建一个小明对象
xiaoming = Person("小明")
# 让小明与狗玩耍
xiaoming.game_with_dog(wangcai)
class
关键字下方可以定义类属性语法如下
@classmethod
def 类方法名(cls):
pass
@classmethod
来标识,告诉解释器这是一个类方法cls
cls
就是哪一个类的引用self
类似类名.
调用类方法,调用方法时,不需要传递cls
参数cls.
访问类的属性cls.
调用其他的类方法class Tool(object):
# 使用赋值语句定义类属性,记录所有工具对象的数量
count = 0
@classmethod
def show_tool_count(cls):
print("工具对象的数量 %d" % cls.count)
def __init__(self, name):
self.name = name
# 让类属性的值+1
Tool.count += 1
# 创建工具对象
tool1 = Tool("斧头")
# 调用类方法
Tool.show_tool_count()
语法如下
@staticmethod
def 静态方法名():
pass
@staticmethod
来进行标识,告诉解释器这是一个静态方法类名.
调用静态方法class Dog(object):
@staticmethod
def run():
print("小狗要跑...")
# 通过类名.调用静态方法
Dog.run()
本文地址:https://blog.csdn.net/qq_37000789/article/details/107338048
如对本文有疑问, 点击进行留言回复!!
网友评论