Three---面向对象与面向过程/属性和变量/关于self/一些魔法方法的使用/继承/super方法/多态
python的面向对象
面向对象与面向过程
面向过程
- 面向过程思想：需要实现一个功能的时候，看重的是开发的步骤和过程，每一个步骤都需要自己亲力亲为，需要自己编写代码（自己来做）
面向对象
- 面向对象的三大特征：封装性、继承性、多态性
- 面向对象思想：需要实现一个功能的时候，看重的并不是过程和步骤，而是关心谁帮我做这件事（偷懒，找人帮我做）
类与对象
- 对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另一个新的概念——类
- 类：抽象的，是一张“手机设计图”
- 对象：具体的，是一个“真正的手机实例”
- 类是抽象的，在使用的时候通常会找到这个类的一个具体的存在；一个类可以找到多个对象
#学生案例
class Student(): #创建一个学生类
#定义一个info函数，并传参至self本身
def info(self,name,age,sex):
print('学生的姓名是：',self.name)
print('学生的年龄是：',self.age)
print('学生的性别是：',self.sex)
yinianji = Student() #创建一个具体的对象：一年级
yinianji.info() #实例化对象调用定义的info函数
案例
当创建一个对象时，就是用一个模子来制造一个实物
成都创新互联是一家专业提供桐城企业网站建设,专注与成都做网站、网站制作、成都外贸网站建设、H5页面制作、小程序制作等业务。10年已为桐城众多企业、政府机构等服务。创新互联专业网站制作公司优惠进行中。
#案例
class Dog(): #定义一个类的形式
#info是一个实例方法，类对象可以调用实例方法，实例方法的第一个参数一定是self
def info(self):
#当对象调用实例化方法时，python会自动将对象本身的引用作为参数，传递到实例方法的第一个参数self里面
print(self)
print("狗祖宗")
#Dog这个类实例化了一个对象 jinmao
jinmao = Dog()
#对象调用实例化方法info()，执行info()中封装的代码 .表示选择属性或方法
jinmao.info()
#打印对象，则默认打印对象在内存中的地址，结果等同于info中的print(self)
print(jinmao)
#id(taidamier)则时内存地址的十进制形式表示
print(id(jinmao))
-----------------------------------------------------------
<__main__.Dog object at 0x00000190A9DC67F0>
狗祖宗
<__main__.Dog object at 0x00000190A9DC67F0>
属性和变量
属性和变量的区别
- 属性：指某个对象的具体特性
- 变量：指可以更改的量
属性和变量的判断依据
- 根据宿主判断：变量无宿主，属性有宿主
- 根据宿主的不同又分为对象属性以及类属性
对象属性获取
- 对象既然有实例方法，也可以有自己的属性
- 在方法内通过self获取对象属性
#对象属性获取
class Dog(): #定义一个狗类
def move(self): #移动实例方法
print("moving...")
def attack(self): #咬人实例方法
print("咬人")
#实例化一个狗对象 jinmao
jinmao = Dog()
#给对象添加属性，以及对应的属性值
jinmao.name = "xiao"
jinmao.hp = 200
jinmao.atk = 40
jinmao.armor = 100
#通过.成员选择运算符，获取对象的属性值
print("%s 的生命值为：%d" %(jinmao.name,jinmao.hp))
print("%s 的攻击力为：%d" %(jinmao.name,jinmao.atk))
print("%s 的护甲值为：%d" %(jinmao.name,jinmao.armor))
#通过.成员选择运算符，获取对象的实例方法
jinmao.move()
jinmao.attack()
-----------------------------------------------------------
xiao 的生命值为：200
xiao 的攻击力为：40
xiao 的护甲值为：100
moving...
咬人
关于self
- self就是实例化对象本身
#关于self
class A:
def f(self,data):
print(self.name)
print(data)
o = A()
print(A.f)
print(o.f)
-----------------------------------------------------------
>
- 其中A.f对应的时function 即为一个普通的函数
- o.f为bound method 即在函数上绑定了一个对象 —— o
- 结论：o.f 是返回了一个method object ，而当去调用这个object时，他会记住被创建时绑定的对象，即返回该对象，默认参数为self
魔法方法
魔法方法__init__()
__init__方法可以在创建对象时就拥有一些属性，__init__通常用来做属性初始化 或 赋值 操作
- 如果类没有写__init__方法,python会自动创建，但不会执行任何操作
- 所以一个类里无论自己是否编写__init__方法 都一定有__init__方法
案例一
#init方法
class Dog():
#方法，用来做变量初始化 或 赋值 操作，在类实例化对象的时候，会被自动调用
def __init__(self,name,hp) -> None:
#__init__方法也可以带参数
self.name = name
self.hp = hp
print(self.name,self.hp)
#实例化一个对象，并自动调用__init__方法
xiaohuang = Dog("小黄",200)
---------------------------------------------------------
class Dog():
def f(self,name,hp):
self.name = name
self.hp = hp
print(self.name,self.hp)
xiaohuang = Dog()
xiaohuang.f("小黄",200)
案例二
#init方法二
class Dog():
def __init__(self,name,skill,hp) -> None:
self.name = name
self.skill = skill
self.hp = hp
def move(self):
print("%s 正在前往事发地点..." % self.name)
def attack(self):
print("%s 咬人 %s..."%(self.name,self.skill))
def info(self):
print("%s 的生命值：%d"%(self.name,self.hp))
#实例化对象时，参数会传递到对象的__init__()方法中
jinmao = Dog("金毛","连环咬",200)
hashiqi = Dog("哈士奇","不松口",300)
#直接输出对象即为地址
print(jinmao)
print(hashiqi)
#不同对象的属性值的单独保存
print(id(jinmao.name))
print(id(hashiqi.name))
#同一个类的不同对象，实例方法共享
print(id(jinmao.attack))
print(id(hashiqi.attack))
-----------------------------------------------------------
<__main__.Dog object at 0x000001AF0>
<__main__.Dog object at 0x000001AF250>
总结
- 在类内部获取 属性 和 实例方法，通过self获取
- 在类外部获取 属性 和 实例方法，通过对象名获取
- 如果有一个类有多个对象，每个对象的属性时各自保存的，都有各自独立的地址
- 实例方法时所有对象共享的，只占用一份内存空间
- 类会通过self来判断是哪个对象，调用了实例方法
魔法方法__str__()
该方法用来显示信息，通过一个字符串来描述实例对象，该方法需要return一个数据，并且只有self一个参数，在类的外部时用print(对象)打印这个数据（面向用户）
#str方法
class Person():
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return "此人姓名为%s,此人的年龄为%s"%(self.name,self.age)
p1 = Person("李四",18)
P2 = Person("王五",19)
print(p1)
print(P2)
-------------------------------------------------------------
此人姓名为李四,此人的年龄为18
此人姓名为王五,此人的年龄为19
触发方式：
1、直接通过print函数去打印
2、通过出发str函数进行转换
魔法方法__repr__()
通过一个字符串描述实例对象的信息（面向开发人员）
#repr方法
class Person():
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return "此人姓名为%s,此人的年龄为%s"%(self.name,self.age)
p1 = Person("李四",18)
P2 = Person("王五",19)
print(repr(p1))
print(P2)
-------------------------------------------------------------
<__main__.Person object at 0x000001E7D9FD67F0>
此人姓名为王五,此人的年龄为19
#修改repr值
class Person():
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return "此人姓名为%s,此人的年龄为%s"%(self.name,self.age)
def __repr__(self): #更改repr参数值
return "self"
p1 = Person("李四",18)
P2 = Person("王五",19)
print(repr(p1))
print(repr(P2))
print(P2)
-------------------------------------------------------------
self
self
此人姓名为王五,此人的年龄为19
repr与str
在输出值时当存在str方法便会优先输出str，repr可以面向开发者，同样repr方法也可以作为一种方法去输出str
#repr与str
import datetime
t = datetime.datetime.now()
print(t) #此处输出的为datetime库中的类对应的str字符串
print(repr(t)) #同时输出repr进行对比
-------------------------------------------------------------
2022-07-15 23:53:55. #此为对应字符串输出值
datetime.datetime(2022, 7, 15, 23, 53, 55, ) #此为repr值
#通过eval函数输出repr
import datetime
t = datetime.datetime.now()
print(t) #此处输出的为datetime库中的类对应的str字符串
tmp = repr(t)
result = eval(tmp) #使用eval函数执行输出repr值的t
print(result)
-------------------------------------------------------------
2022-07-16 00:00:31.
2022-07-16 00:00:31.
魔法方法__del__()
创建对象后，python解释器默认调用__init__()方法
当删除一个对象时，python解释器也会默认调用一个方法，这个方法叫__del__()
#del方法
class Dog():
#创建对象后__init__方法会自动被调用
def __init__(self, name):
print("__init__方法被调用",name+"出生了")
self.name = name
#当对象执行完毕被删除时，__del__方法会自动被调用
def __del__(self):
print("__del__方法被调用%s死了"%(self.name))
jinmao = Dog("金毛")
---------------------------------------------------------
__init__方法被调用 金毛出生了
__del__方法被调用金毛死了
继承
- 子类可以重写父类的属性和方法后，依然可以调用父类的属性和方法
- 使用super方法调用父类
- 多层继承关系同样可以实现
- 装饰器
class Dog(): #创建父类Dog
def __init__(self) -> None:
self.name = "dog dad"
def skill_dad1(self):
print("attack people")
class Dog2(): #创建父类Dog2
def __init__(self) -> None:
self.name = "dog mom"
def skill_mom1(self):
print("attack dog")
def skill_mom2(self):
print("摇尾巴")
class Son(Dog,Dog2):
#创建子类Son并继承父类Dog和Dog2，继承时优先继承第一个父类Dog
def __init__(self) -> None:
self.name = "dog son"
def skill(self):
print("lick people")
def dad_skill(self):
#通过super方法进行调用父类所定义的函数与方法
super().__init__()
super().skill_dad1()
def mom_skill(self):
super().__init__()
super().skill_mom1()
super().skill_mom2()
jinmao = Son()
jinmao.dad_skill()
jinmao.mom_skill()
--------------------------------------------------------------
attack people
attack dog
摇尾巴
多态
- 不同的子对象调用相同的父类放啊，产生不同的结果（继承+重写）
- 一个父类可以拥有多个子类继承
#多态
class Dog():
def __init__(self) -> None:
self.name = "dog mom"
def skill(self):
print("attack dog")
#子类/派生类
class Son1(Dog):
def skill(self):
print("attack man")
class Son2(Dog):
def skill(self):
print("attack woman")
class Son3(Dog):
def skill(self):
print("attack child")
#实例化
son1 = Son1().skill()
son2 = Son2().skill()
son3 = Son3().skill()
---------------------------------------------------------
attack man
attack woman
attack child
新闻标题：Three---面向对象与面向过程/属性和变量/关于self/一些魔法方法的使用/继承/super方法/多态
转载源于：http://6mz.cn/article/dsogiej.html