类的操作
定义一个类
# 定义一个类 class: 类名()
# 类名后面可以不加括号
# Washer 必须是大驼峰
class Washer:
# 方法 方法就是类的功能或者行为 他可以实现的事情
def wash(self):
# self = haier = 类创建的对象 (不是唯一的)
# self, 谁调用wash 谁就是self
print("self:", self)
print("洗衣机开始洗衣服")
if __name__ == '__main__':
# 必须通过类 创建一个对象 类名() 就是创建对象
haier = Washer()
# 类对象,类的对象,实例化对象
print("haier:", haier, type(haier))
# 可以通过类的对象 调用类中的方法
# 使用的对象 会传递给self
haier.wash()
# 创建另外一个对象
meidi = Washer()
print("meidi", meidi)
meidi.wash()
类外部添加属性
# 定义一个类
class Washer:
# 方法 方法就是类的功能或者行为 他可以实现的事情
def wash(self):
# self = haier
print("洗衣机开始洗衣服")
# 在方法中打印类对象的属性
print(self.height)
print(self.weight)
if __name__ == '__main__':
# 必须通过类 创建一个对象 类名() 就是创建对象
haier = Washer()
# 类对象,类的对象,实例化对象
print("haier:", haier, type(haier))
# 给类的对象添加属性
haier.height = 150
haier.weight = 60
# 类的对象调用方法
haier.wash()
在类里创建属性
# 定义一个类
class Baike():
# 定义ride方法
def ride(self):
print("我骑自行车 车速180")
# self = phoenix
# 给类对象 添加对象属性
self.color = "black"
self.price = 250
print(self.color)
print(self.price)
if __name__ == '__main__':
# 创建一个凤凰牌自行车对象
phoenix = Baike()
# 通过类的对象调用类中的方法
phoenix.ride()
-int魔术方法
# 定义一个人类
class Person():
def __init__(self):
'''
init魔术方法 在实例化对象的时候被触发
self = lyg
'''
print("init被触发")
# 定义对象属性
self.name = "啊啊啊啊"
self.age = 20
# 定义一个普通方法
def eat(self):
print(f"{self.name}在吃饭, 他今年{self.age}岁")
if __name__ == '__main__':
# 实例化罗一根 对象
lyg = Person()
# 调用类中的方法
lyg.eat()
类传递参数
# 定义一个人类
class Person():
def __init__(self, name, age):
'''
init魔术方法 在实例化对象的时候被触发
self = 类的对象
'''
print("init被触发")
# 定义对象属性
self.name = name
self.age = age
# 定义一个普通方法
def eat(self):
print(f"{self.name}在吃饭, 他今年{self.age}岁")
if __name__ == '__main__':
# 实例化罗一根 对象
lyg = Person("啊啊啊啊", 20)
# 调用类中的方法
lyg.eat()
lh = Person("嗷嗷嗷", 18)
lh.eat()
-str魔术方法
# 定义一个Monkey类
class Monkey:
def __init__(self, name, hair):
'''
name = "金丝猴"
hair = “gold”
'''
self.name = name
self.hair = hair
def __str__(self):
'''
当实例化对象被打印的时候 触发 打印输出的是返回值
'''
return f"这之猴子的名字叫{self.name}, 毛发颜色是{self.hair}"
if __name__ == '__main__':
# 实例化一个金丝猴对象
jsh = Monkey("金丝猴", "gold")
print(jsh)
-del魔术方法
# 定义一个类
class Computer:
def __init__(self, name, address):
self.name = name
self.address = address
def __del__(self):
'''
触发时机:在对象被删除的时候 触发
'''
print(f"{self.name}对象被删除")
if __name__ == '__main__':
# 定义一个联想的电脑
Lenovo = Computer("联想", "青岛")
# 删除对象
del Lenovo
继承
# 定义一个父类
# Python中所有的类都默认继承object基类
class A(object):
def __init__(self):
self.num = 1
def print_info(self):
print(self.num)
# 定义一个子类
# 在B后面的括号中写A说明 A是B的父类
class B(A):
pass
if __name__ == '__main__':
# 实例化一个B的对象
b = B()
# b调用父类的方法
b.print_info()
# 子类的对象调用父类的属性
print(b.num)
单继承
# 定义一个师傅类
class Master(object):
def __init__(self):
self.kongfu = '[大师煎饼果子配方]'
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子")
# 定义一个徒弟类 只有一对父子关系 的叫做单继承
class Prentice(Master):
pass
if __name__ == '__main__':
# 创建一个徒弟类的对象
rpp = Prentice()
# 使用徒弟类的对象去 使用kongfu
print(rpp.kongfu)
# 使用徒弟类的对象去调用 大师类的方法
rpp.make_cake()
多继承
# 定义一个大师类
class Master(object):
def __init__(self):
self.kongfu = '[大师煎饼果子配方]'
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子")
# 定义一个学校类
class School(object):
def __init__(self):
self.kongfu = "[连锁品牌的煎饼果子配方]"
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子")
# 定义一个徒弟类 一个类有两个 甚至多个父类 叫做多继承
# 寻找父类的方法 会找第一个父类
class Prentice(School, Master):
pass
if __name__ == '__main__':
# 创建一个徒弟类的对象
rpp = Prentice()
# 使用徒弟类的对象去 使用kongfu
print(rpp.kongfu)
# 使用徒弟类的对象去调用 大师类的方法
rpp.make_cake()
重写方法
# 定义一个大师类
class Master(object):
def __init__(self):
self.kongfu = '[大师煎饼果子配方]'
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子")
# 定义一个学校类
class School(object):
def __init__(self):
self.kongfu = "[连锁品牌的煎饼果子配方]"
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子")
# 定义一个徒弟类 一个类有两个 甚至多个父类 叫做多继承
# 寻找父类的方法 会找第一个父类(超类)
class Prentice(School, Master):
# 定义子类自己的init函数 不会触发父类的init
def __init__(self):
self.kongfu = "[独创煎饼果子配方]"
# 重写父类的方法
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子")
if __name__ == '__main__':
# 创建一个徒弟类的对象
rpp = Prentice()
# 使用的是子类自己的配方
print(rpp.kongfu)
# 使用的是子类自己的方法
rpp.make_cake()