1.概念
2.编写步骤
3.魔法方法
4.封装
5.私有和公有
6.继承
7.重写
8.多态
9.属性和方法
1.概念
2.编写步骤
# 1.创建类
# 用 class 关键字定义类，类名用大驼峰命名法
class Cat:
# 创建方法，方法本质是函数
# self 是普通形参，python 解释器在执行代码的时候自动将调用这个方法的对象传递给了self，其本质是对象，只是对象是全局变量，self 是函数中的局部变量
def eat(self):
# 添加属性：对象.属性名 = 属性值，获取属性：对象.属性名
# 类内部添加：self.属性名，一般写在__init__中
print('小猫{self.name}吃鱼的方法')
# 2.创建对象
# 用 类名() 创建对象，将对象保存到变量中
blue_cat = Cat()
#3.调用方法
# 类外部添加：对象.属性名，一般不用类外部添加
blue_cat = '蓝猫'
blue_cat.eat()
3.魔法方法
# 魔法方法：形式为 __方法__ ，在满足某个特定条件下会自动调用的方法
class Cat:
# 1.初始化方法__init__
# 场景：创建对象后会自动调用
# 用途：①添加属性，②书写类中每次都会调用的重复代码
def __init__(self, name, age):
self.name = name
self.age = age
# 2.默认输出方法__str__
# 场景：print() 打印对象时会自动调用
# 用途：书写对象的属性信息，若未定义，默认输出对象的引用地址
# 注意：必须返回一个字符串
def __str__(self):
return f'小猫名字是{self.name}，年龄是{self.age}岁'
# 3.析构方法__del__
# 场景：程序代码运行结束，所有对象都被销毁
def __del__(self):
print(f'{self.name}的代码结束了')
blue_cat = Cat('蓝猫', 2) # 创建对象时传参，与__init__定义的参数要一致
print(blue_cat) # 打印对象输出__str__返回字符串
# 可在结束前使用 del 对象 来删除对象，但若对象有多个名字（即多个对象引用同一个对象），需要把所有对象名删除才可以真的删除这个对象
# 代码执行结束后会打印__del__结果内容
4.封装：定义类的过程称为封装，即将属性和方法封装到一个抽象的类中
5.私有和公有：在 python 中定义的方法和属性，可以添加访问控制权限，分为私有权限和公有权限
class Person:
def __init__(self, name, age, weight):
# 公有权限的写法：直接书写
# 公有的方法和属性可以在任意地方访问和使用
self.name = name
self.age = age
# 私有权限的写法：在方法或属性名前加 __
# 私有的方法和属性只能在类内部使用
self.__weight = weight
def __str__(self):
return f'{self.name}今年{self.age}岁了，现在体重是{self.__weight}公斤'
xm = Person('小明', 18, 50)
xm.age = 19 # 公有属性可修改
xm.weight = 40 # 私有属性不可修改
print(xm) # 执行结果：小明今年19岁了，现在体重是50公斤
# 补充：对象.__dict__ 魔法属性，可以将对象具有的属性组成字典返回
print(xm.__dict__) # {'name': '小明', 'age': 19, '_Person__weight': 50, 'weight': 40}
6.继承
# 书写父类（基类）
# 最原始的父类是 object，一般可省略书写
class Animal:
def __init__(self, name):
self.name = name
def eat(self):
print(f'{self.name}吃东西')
# 书写子类（派生类）
# 子类继承父类的语法：class 子类(父类):
class Dog(Animal):
def bark(self):
print(f'{self.name}要狗叫')
# 单继承：一个类只能继承一个父类
class XTQ(Dog):
pass
# 继承特点：子类继承父类后，子类的对象可以直接使用父类的属性和方法
xm = XTQ('哮天犬')
# 继承的调用方法模式：先在当前类中查找，若有直接调用，若没有去父类中查找...直到在object中仍没有查找方法，代码报错
xm.eat()
xm.bark()
7.重写
# 重写：在子类中定义与父类名字相同的方法
# 父类方法无法满足子类需求时可以重写，重写后子类对象直接调用子类方法
class Dog:
def bark(self):
print('汪汪汪叫')
class Xtq(Dog):
# 覆盖：在子类中直接书写新的代码
def bark(self):
print('嗷嗷嗷叫')
class Ceq(Dog):
# 扩展：在子类中合适的地方调用父类的方法，并添加新方法
def bark(self):
print('嘻嘻嘻叫')
# 调用父类方法的语法：super().方法名()
# super(object) 是一个继承到 object 的类
super().bark()
print('哈哈哈叫')
xtq = Xtq('哮天犬')
xtq.bark()
ceq = Ceq('嫦娥犬')
ceq.bark()
8.多态
# 多态：不同的对象 调用 相同的方法，产生 不同的执行结果，以增加代码的灵活度
# 定义不同岗位的类
class Person:
def work(self):
print('人需要工作')
class Coder(Person):
def work(self):
print('开发人员 --> 工作是写代码')
class Tester(Person):
def work(self):
print('测试人员 --> 工作是测试项目')
# 定义 公司类，方法：查看不同岗位的工作， 参数：人类对象
# 在这个方法中调用 work方法
class Company:
def show_work(self, worker):
worker.work()
c = Company()
cc = Coder()
tt = Tester()
c.show_work(cc) # 执行结果：开发人员 --> 工作是写代码
9.属性和方法
import random
# 1.1 类对象：就是 类，可理解为 类名
# 类对象是 python 解释器在执行代码的过程中创建的
class Game:
# 2.1类属性：类 具有的属性信息
# 定义：一般会在 类内部 方法外部 直接定义
# 使用：类名.属性名
top_score = 0
# 3.1 实例方法：在 类内部 直接书写的方法
# 使用：对象.方法名()
def __init__(self, name):
# 2.2 实例属性：实例对象 具有的属性信息
# 定义：一般会在 init方法中定义
# 使用：self.属性名
self.name = name
# 3.2 类方法：使用 @classmethod 装饰器的方法
# 场景：不需要实例属性但需要类属性的时候
# 使用方式一：类对象.方法名()
# 使用方式二：实例对象.方法名()
@classmethod # 使用类方法
def show_game(cls):
print(f'游戏当前的最高分是：{Game.top_score}分')
# 3.3 静态方法：使用 @staticmethod 装饰器的方法
# 场景：既不需要实例属性也不需要类属性的时候
# 使用方式一：类对象.方法名()
# 使用方式二：实例对象.方法名()
@staticmethod # 使用静态方法
def show_help():
print('这是游戏的帮助信息')
def start_game(self):
print(f'{self.name}开始一局游戏，', end='')
score = random.randint(10, 101) # 本次游戏得分
print(f'本次游戏得分为{score}')
if score > Game.top_score:
# 修改最高分
Game.top_score = score
# 1.2 实例对象：用 类名() 创建的对象，类的实例化：创建对象的过程
xm = Game('小明')
xm.start_game() # 执行结果：小明开始一局游戏，本次游戏得分为66
xm.show_game() # 执行结果：游戏当前的最高分是：66分
xm.start_game() # 执行结果：小明开始一局游戏，本次游戏得分为26
xm.show_game() # 执行结果：游戏当前的最高分是：66分
xm.show_help() # 执行结果：这是游戏的帮助信息
标签：__,name,04,python,self,面向对象,方法,def,属性 From： https://www.cnblogs.com/shiyi10086/p/16983791.html