Loading

认识面向对象

一、面向对象基础

类：

  • 先定义模子，用来描述一类事物
  • 具有相同的属性和动作的一类事物

对象：

  • 就是类的具体表现。

  • 具体一点就是解释什么是人：有名字、性别、工作...等等，那么广义上，人就是类：但是具体到那个人，那个人就是对象。

  • 猫，是一类：你们家养的大橘，大橘就是对象

面向过程 : 想要一个结果 写代码 实现计算结果

面向对象开发 : 有哪些角色 角色的属性和技能 两个角色之间是如何交互的

面向对象编程的优点：
  • 是一类相似功能函数的集合，使你的代码更清晰化，更合理化。
  • 面向对象，要拥有上帝的视角看问题，类其实就是一个公共的模板，对象就从具体的模板实例化出来得。
类和对象之间的关系？
  • 类：是一个大范围，是一个模子，它约束了事物有哪些属性，但是不能约束具体的值
  • 对象：是一个具体的内容，是模子的产物，它遵循了类的约束，同时给属性赋上具体的值

二、类的结构

类的结构从大方向来说就分为两部分：

  • 静态变量
  • 动态方法

class：是关键字与def用法相同，定义一个类。

Person：是次类的类名，类名使用驼峰（CamelCase）命名风格，首字母大写私有类可用一个下划线开头

class Person:        # 此类主要是构建人类
    name = '小小'     # 第一部分：静态属性、属性、静态变量、静态字段
    sex = '男'
    job = '攻城师'
    hp = 500
    ad = 100
    weapon = '键盘'

    def beat(self):   # 第二部分：方法、函数、动态属性
        print('人会敲打')

三、从类名的角度研究类

  • 类名操作静态属性
    • 第一种：查看类中的所有内容：类名.__dict__方式。
      • 通过这种方式只能查询，不能增删改。
      • 第一种方式只用于查询全部内容（一般不用单独属性查询）
    class Person:        # 此类主要是构建人类
    name = '小小'     # 第一部分：静态属性、属性、静态变量、静态字段
    sex = '男'
    job = '攻城师'
    hp = 500
    ad = 100
    weapon = '键盘'

    def beat(self):   # 第二部分：方法、函数、动态属性
        print('人会用工具敲打')


print(Person.__dict__)			 # 查所有内容
print(Person.__dict__['name'])   # 查属性
Person.__dict__['name'] = '大大'  # 会报错

# 输出
{'__module__': '__main__', 'name': '小小', 'sex': '男',...}
小小
    • 第二种：万能的点。
      • 通过万能的点，可以增删改查类中的单个属性
    class Person:        # 此类主要是构建人类
    name = '小小'     # 第一部分：静态属性、属性、静态变量、静态字段
    sex = '男'
    job = '攻城师'
    hp = 500
    ad = 100
    weapon = '键盘'

    def beat(self):   # 第二部分：方法、函数、动态属性
        print('人会用工具敲打')


print(Person.name)      # 查属性
Person.name = '大大'     # 修改属性
print(Person.name)      # 查修改后的属性
del Person.name         # 删，删除name这个属性
print(Person.__dict__)  # 查看有没删除name属性
# 输出
小小
大大
{'__module__': '__main__', 'sex': '男', 'job': '攻城师',...}
    • 总结：如果想查询类中的所有内容，通过第一种__dict__方法，如果只是操作单个属性则用万能的点的方式。
  • 类名操作动态方法
    • 前提：除了两个特殊方法：静态方法，类方法之外，一般不会通过类名操作一个类中的方法。
    class Person:        # 此类主要是构建人类
    name = '小小'     # 第一部分：静态属性、属性、静态变量、静态字段
    sex = '男'
    job = '攻城师'
    hp = 500
    ad = 100
    weapon = '键盘'
    
	# 方法,又有一个必须传的参数-->self对象
    def beat(self):   # 第二部分：方法、函数、动态属性
        print(f'人会用键盘敲打{self}')

Person.beat('狗')
# 输出
人会用键盘敲打狗

三、从对象的角度研究类

  • 什么是对象
    • 对象是从类中出来的，只要是类名加上（），这就是一个实例化过程，就会实例化一个对象。
    class Person:
# 必须叫__init__这个名字,不能改变的,所有出现具体的人物拥有的属性
    def __init__(self):
        self.name = '鲍勃'
        self.sex = '男'
        self.job = '攻城狮'
        self.hp = 500
        self.weapon = '键盘'
        self.ad = 100
        print('self--->:', self)
        
    def beat(self):
        print(f'人会用键盘敲打{self}')


Bob = Person()            # 只要实例化对象，它就会自动执行__init__方法
print('Bob---->:', Bob)   # Bob的地址与self的地址相同

# 输出
self--->: <__main__.Person object at 0x0000022441C983D0>
Bob---->: <__main__.Person object at 0x0000022441C983D0>
    • 实例化所经历的步骤：
      1. 类名()：之后的第一件事儿，开辟一个类的内存空间
      2. 自动调用__init__把 init 空间的内存地址传给self
        • 所有的这一个对象需要使用的属性都需要和self关联起来
      3. 执行完 init 中的逻辑之后，self变量会自动的返回到调用处（通过self给对象空间添加属性）
  • 对象操作对象空间属性
    • 对象查询对象中所有属性。对象.__dict__
    class Person:
    stand = '站立的'
    def __init__(self, name, sex, job, weapon):
        # 所有出现具体的人物拥有的属性
        self.name = name
        self.sex = sex
        self.job = job
        self.hp = 500
        self.weapon = weapon
        self.ad = 100

    def beat(self):
        print(f'人会用键盘敲打{self}')


Bob = Person('鲍勃', '男', '攻城狮', '键盘')
print(Bob.__dict__)
# 输出
{'name': '鲍勃', 'sex': '男', 'job': '攻城狮', 'hp': 500, 'weapon': '键盘', 'ad': 100}
    • 对象操作对象中的单个属性。万能的点 .
    class Person:
    stand = '站立的'

    def __init__(self, name, sex, job, weapon):
        self.name = name
        self.sex = sex
        self.job = job
        self.hp = 500
        self.weapon = weapon
        self.ad = 100

    def beat(self):
        print(f'人会用键盘敲打{self}')


Bob = Person('鲍勃', '男', '攻城狮', '键盘')   # 实例化一个对象名为Bob
Bob.skill = '熬夜'         # 增
del Bob.job                # 删除job属性
Bob.sex = '女'             # 改
print(Bob.name)            # 查找name属性是什么
print(Bob.__dict__)
# 输出
鲍勃
{'name': '鲍勃', 'sex': '女', 'hp': 500, 'weapon': '键盘', 'ad': 100, 'skill': '熬夜'}
  • 对象查看类中的属性
    class Person:
    stand = '站立的'

    def __init__(self, name, sex, job, weapon):
        self.name = name
        self.sex = sex
        self.job = job
        self.hp = 500
        self.weapon = weapon
        self.ad = 100

    def beat(self):
        print(f'人会用键盘敲打{self}')


Bob = Person('鲍勃', '男', '攻城狮', '键盘')
print(Bob.stand)
Bob.stand = '站立行走的生物'
print(Bob.stand)
# 输出
站立的
站立行走的生物
  • 对象操作类中的方法
    class Person:
    stand = '站立的'

    def __init__(self, name, sex, job, weapon):
        self.name = name
        self.sex = sex
        self.job = job
        self.hp = 500
        self.weapon = weapon
        self.ad = 100

    def beat(self, dog):	# 方法,又有一个必须传的参数-->self对象
        print(f'人会用键盘敲打{dog}')


Bob = Person('鲍勃', '男', '攻城狮', '键盘')
Bob.beat('狗')		# 对象Bob调用类中的beat方法
# 输出
人会用键盘敲打狗

  • 类中的方法一般都是通过对象执行的（除去类方法，静态方法外），并且对象执行这些方法都会自动将对象空间传给方法中的第一个参数self.

  • 一个类可以实例化多个对象

    class Person:
    stand = '站立的'
    def __init__(self, name, sex, job, weapon):
        self.name = name
        self.sex = sex
        self.job = job
        self.hp = 500
        self.weapon = weapon
        self.ad = 100
        
    def beat(self, dog):  # 方法,又有一个必须传的参数-->self对象
        print(f'人会用键盘敲打{dog}')

Bob = Person('鲍勃', '男', '攻城狮', '键盘')
Alan = Person('艾伦', '女', '鼠标侠', '鼠标')
print(Bob)
print(Alan)
print(Bob.__dict__)
print(Alan.__dict__)
# 输出
<__main__.Person object at 0x000002AEBB9383D0>
<__main__.Person object at 0x000002AEBB968970>
{'name': '鲍勃', 'sex': '男', 'job': '攻城狮', 'hp': 500, 'weapon': '键盘', 'ad': 100}
{'name': '艾伦', 'sex': '女', 'job': '鼠标侠', 'hp': 500, 'weapon': '鼠标', 'ad': 100}
  • self是什么？
    • self其实就是类中方法（函数）的第一个位置参数，只不过解释器会自动将调用这个函数的对象传给self（把self指向被实例化对象的内存地址）。所以咱们把类中的方法的第一个参数约定俗成设置成self, 代表这个就是对象。
posted @ 2021-05-02 16:38  Mr-Yang`  阅读(67)  评论(0)  编辑  收藏  举报