16，类和对象

1，初识面向对象

例子

开发游戏：
人狗大战：
    人：姓名，性别，职业，等级，生命值，攻击力
        技能：搓澡
    狗：姓名，品种，生命值，攻击力
        技能：舔

# 人
alex = {
    'name': 'alex',
    'sex': '不详',
    'job': '搓澡工',
    'level': 0,
    'hp': 250,
    'ad': 1,
    'weapon': '搓澡巾'
}
# 狗
mimi = {
    'name': '小白',
    'kind': '泰迪',
    'level': 0,
    'hp': 500,
    'ad': 249,
}

1，如何保证所有玩家初始化的时候都拥有相同的属性
2，每一个新的玩家，我们都自己手动的创建一个字典，然后向字典中填值
3，人物和狗的技能如何去写

# 创建人物
def Person(name, sex, job, hp, weapon, ad, level=0):
    def P_D(dog):
        dog['hp'] -= dic['ad']
        print(f"{dic['name']}攻击了{dog['name']}，{dog['name']}掉了{dic['ad']}点血")
    dic = {
        'name': name,
        'sex': sex,
        'job': job,
        'level': level,
        'hp': hp,
        'weapon': weapon,
        'ad': ad,
        'action' : P_D
    }
    return dic



alex = Person('alex', '不详', '搓澡工', 250, '搓澡巾', 1)
wusir = Person('wusir', 'male', '律师', 500, '打狗棍', 1000)


print(alex)
print(wusir)

# 创建动物
def Dog(name, kind, hp, ad):
    def D_P(person):
        person['hp'] -= dic['ad']
        print(f"{dic['name']}攻击了{person['name']}，{person['name']}掉了{dic['ad']}点血")
    dic = {
        'name': name,
        'kind': kind,
        'hp': hp,
        'ad': ad,
        'action': D_P
    }
    return dic



mimi = Dog('mimi', '泰迪', 5000, 249)
nini = Dog('nini', '柯基', 10000, 499)
print(mimi)
print(nini)



# 人狗大战开始
mimi['action'](alex)
alex['action'](mimi)

引入类

面向过程开发：只想要一个结果，写代码。实现计算结果
面向对象开发：有哪些角色 角色的属性和技能 两个角色之间是如何交互的，

复杂的 拥有开放式结局的程序 比较适合面向对象开发
        # 比如：游戏
        # 购物
        # 网页

类：这个类有什么属性 用什么方法 大致的样子
    但是不知道具体的属性和对应得值
对象：明确类中的属性值
类型：int float str dict list tuple set -- 类(内置的数据类型，内置的类)
变量名 = xx数据类型对象

a = 10
b = 12
c = [1,2,3,4]
d = {'k': 'v'}
o = 函数名
q = 迭代器
u = 生成器
i = 类名

python中一切皆对象，对象的类型就是类

所有的对象都有一个类型，class A 实例化出来的对象的类型就是A类

123是int/float类
'serjhad213'是str类
{}是dict类

2，面向对象编程

类是什么

就是同一类事物的集合

        比如：车类

                        包含：奥迪，奔驰，比亚迪.....等

                动物类：

                        猫，狗，兔子......等

                人类：

                        男性，女性

先来定义一个模子，用来描述一类事物
具有相同的属性和方法

定义类

模版

class 类名():
    def __init__(self):
        这个类的通用属性
        self.属性名 = 值
        ...
        self.属性名 = 值
    def 方法名():
        写实现的过程

例子

class Person:  # 类名
    def __init__(self):
        '''
        必须叫这个名字，不能改变，所有的在一个具体的人物出现之后拥有的属性
        都可以写在这里
        '''
        self.name = 'alex'
        self.sex = '男'
        self.job = '搓澡工'
        self.level = 0
        self.hp = 250
        self.weapon = '搓澡巾'
        self.ad = 1


# alex就是对象 alex = Person()的过程就是通过类获取一个对象的过程--实例化
alex = Person()  

类名()会自动调用__init__方法

类与对象的关系

1，类 是具有相同属性和相似功能的一类事物
    是一个大范围 是一个模子 他约束了事物有哪些属性 但是不能约束具体的值
2，对象 实例
    是一个具体的内容 是模子的产物 他遵循了类的约束 同时给属性赋上具体的值

class Person:
    def __init__(self, name, sex, job, hp, weapon, ad, level=0):
        '''
        必须叫这个名字，不能改变，所有的在一个具体的人物出现之后拥有的属性
        都可以写在这里
        '''
        self.name = name
        self.sex = sex
        self.job = job
        self.level = level
        self.hp = hp
        self.weapon = weapon
        self.ad = ad


wusir = Person('wusir', 'male', 'IT', 500, '电脑', 100)
print(wusir, wusir.__dict__)        # 查看一个对象的所有属性

关于属性的一些方法

class Person:
    def __init__(self, name, sex, job, hp, weapon, ad, level=0):
        '''
        必须叫这个名字，不能改变，所有的在一个具体的人物出现之后拥有的属性
        都可以写在这里
        '''
        self.name = name
        self.sex = sex
        self.job = job
        self.level = level
        self.hp = hp
        self.weapon = weapon
        self.ad = ad

alex = Person('alex', 'male', 'IT', 500, '电脑', 100)
print(alex, alex.__dict__)
print(alex.name)               # 属性的查看
alex.name = 'alexsb'           # 属性的修改
print(alex.name)
print(alex, alex.__dict__)

alex.money = 10000               # 属性的添加
print(alex.money)
print(alex, alex.__dict__)

del alex.money                   # 属性的删除
print(alex, alex.__dict__)

Person是一个类 ：alex wusir都是这个类的对象
    类有一个空间，存储的是定义在class中的所有名字
    每一个对象又有自己的空间，通过对象名.__dict__就可以查看地址的值，通过字典的形式返回

实例化所经历的步骤 *****
    1，类名() 之后的第一个事，开辟一块儿内存空间
    2，调用__init__把空间的内存地址作为self参数传递到函数内部
    3，所有的这一个对象需要使用的属性都需要和self关联起来
    4，执行完__init__中的逻辑之后，self变量会自动的被返回到调用处(发生实例化的地方)

3，初识方法

方法就是写在类中的函数

class Person:
    def __init__(self, name, sex, job, hp, weapon, ad, level=0):
        '''
        必须叫这个名字，不能改变，所有的在一个具体的人物出现之后拥有的属性
        都可以写在这里
        '''
        self.name = name        # 对象的属性/实例变量
        self.sex = sex
        self.job = job
        self.level = level
        self.hp = hp
        self.weapon = weapon
        self.ad = ad

    def P_D(self, dog):
        dog.hp -= self.ad
        print(f'{self.name}搓了{dog.name}，{dog.name}掉了{self.ad}点血')


wusir = Person('wusir', 'male', 'IT', 500, '电脑', 100)
# wusir.P_D()     # 调用方法

class Dog:
    def __init__(self, name, kind, hp, ad, weapon):
        self.name = name
        self.kind = kind
        self.hp = hp
        self.ad = ad
        self.weapon = weapon

    def D_P(self, person):
        person.hp -= self.ad
        print(f'{self.name}攻击了{person.name}，{person.name}掉了{self.ad}点血')


mimi = Dog('mimi', '牧羊犬', 500, 200, '舔')  # 对象/实例 = 类名()--->实例化的过程
# mimi.D_P()


wusir.P_D(mimi)
mimi.D_P(wusir)

4，面向对象的命名空间

类的成员和命名空间

class A:
    country = '中国'  # 静态变量/静态属性   存储在类的命名空间里

    def __init__(self, name, age, country):
        self.name = name
        self.age = age
        self.country = country

    def func1(self):
        print(self)


a = A('wusir', 30, '印度')
b = A('alex', 35, '美国')
print(a.country)        # 印度
print(A.country)        # 中国


class A:
    country = '中国'

    def __init__(self, name, age, country):
        self.name = name
        self.age = age

    def func1(self):
        print(self)


a = A('wusir', 30, '印度')
b = A('alex', 35, '美国')
A.country = '日本'
print(a.country)        # 日本
print(b.country)        # 日本
print(A.country)        # 日本

类中的变量是静态变量
对象中的变量只属于对象本身，每个对象有属于自己的空间来存储对象的变量
当使用对象名去调用某一个属性的时候会优先在自己的空间中去寻找对应的，找不到再到对用的类中去寻找
如果自己没有就引用类的，如果类也没有就报错
对于类来说，类中的变量所有的对象都是可以读取的，并且读取的是同一分变量

练习

实现一个类，自动统计这个类实例化了多少个对象

class A():
    count = 0
    def __init__(self):
        A.count += 1

a1 = A()
print(A.count)
a2 = A()
print(a2.count)

总结

'''
类中静态变量的用途
    1，如果一个变量 是所有的对象共享值，那么这个变量应该被定义成静态变量
    2，所有的静态变量相关的增删改查都应该使用类名来处理
'''


'''
命名空间：
    在类的命名空间里：静态变量 绑定方法
    在对象的命名空间里：指针 类属性(实例变量)
    
调用的习惯：
1，类名.静态变量
    对象.静态变量 (对象调用静态变量的时候，不能对变量进行赋值操作 对象.静态变量 = ***都不行 )
    
2，绑定方法：
    对象.绑定方法()  ==>  类名.绑定方法(对象)
    
3，实例变量;
    对象.实例变量

'''

5，组合

组合：
一个类的对象是另一个类对象的属性
适用场景：什么有什么的关系
    班级有学生 学生有课程 学生有成绩 图书有作者 图书有书名

例子

学生类
姓名 性别 年龄 学号 班级 手机号

班级类
班级名字
开班时间
当前讲师

class Student():
    def __init__(self, name, sex, age, student_id, clas, phone):
        self.name = name
        self.sex = sex
        self.age = age
        self.student_id = student_id
        self.clas = clas
        self.phone = phone


class Clas():
    def __init__(self, cl_name, begin_time, teacher):
        self.cl_name = cl_name
        self.time = begin_time
        self.teacher = teacher


py22 = Clas('python22期', '2023-06-20', 'jing')
py23 = Clas('python23期', '2023-08-20', 'jing')
mack = Student('mack', '男', '18', '001', py22, '13855147793')
jan = Student('jan', '女', '18', '003', py23, '15955147793')

# 查看mack的班级开班日期是多少
print(mack.clas.time)       # py22这个对象变成了mack这个对象的属性
# 查看jan的班级开班日期是多少
print(jan.clas.time)

6，练习

'''
练习
1，班级类
    一个属性 -- 课程
2，课程类
    三个属性 -- 
        课程名称
        周期
        价格
        
        
创建两个班级  linux57期
            python22期


要求：
查看linux57期的班级所学的课程的价格
查看python22期班级所学课程的周期

'''

class Clas():
    def __init__(self, course):
        self.count = course

class Course():
    def __init__(self, count_name, time_len, price):
        self.count_name = count_name
        self.time_len = time_len
        self.money = price


linux = Course('linux57期', '5个月', 18000)
python = Course('python22期', '5个月', 18000)
clas1 = Clas(linux)
clas2 = Clas(python)
print(f'linux57期的班级所学的课程的价格{linux.money}元')
print(f'python22期班级所学课程的周期{python.time_len}')
linux.money = 21000     # 修改属性
print(f'linux57期的班级所学的课程的价格{linux.money}元')

更多内容可以查看自己学python的过程，简单笔记。-CSDN博客

更多内容可以查看自己学python的过程，简单笔记。-CSDN博客

更多内容可以查看自己学python的过程，简单笔记。-CSDN博客