python基础语法14 面向对象

面向对象

1.什么是面向对象？
    面向对象是一门编程思想!

    - 面向过程编程思想:
        核心是 “过程” 二字，过程指的是解决问题的步骤，即先干什么再干什么！
        基于该编程思想编写程序，就好比在设计一条工厂流水线，一种机械式的思维方式。

        优点:
            将复杂的问题流程化，进而简单化
        缺点:
            牵一发而动全身，程序的可扩展性差。

    注意: 编程思想仅仅是一门思想，与任何的技术无关。

    - 面向对象编程思想:
        注意: 要将自己当做一个上帝！！！
        核心是 “对象” 二字，对象指的是 “特征与技能” 的结合体。
        基于该编程思想编写程序，就好比在创造世界，一种 “上帝式” 的思维方式。

        优点:
            可扩展性高。
        缺点:
            编写程序的复杂程度比面向过程高。

2.如何产生对象:
    1) 什么是类？
        类指的是类型、类别。

        - 在两种角度去看待:
            - 现实世界中:
                - 先有一个个的对象，经过社会的文明发展，随之总结出类。
                对象是实际存在的，而类抽象产生的。

            - 在程序中:
                - 必须先有类，再通过“调用类，产生对象”。

        对象指的是 “特征与技能” 的结合体， 类指的是一系列 “对象之间相同的特征与技能” 的结合体。

    2) 如何定义类:
        - 如何写类并产生对象:
            - 先从现实世界中通过一个个对象总结出类。
            - 然后再定义类，后调用类产生对象。

        - 比如: 选课系统:
            - 选课系统学生类:
                - 学生对象1:
                    特征:
                        - 姓名: 胡晨阳
                        - 性别: female
                        - 年龄: 95
                        - 学校: oldboy

                    - 技能:
                        - 技术: python
                        - 学习: learn
                        - 选课: course
                - 学生对象2:
                    特征:
                        - 姓名: 高弟
                        - 性别: female
                        - 年龄: 98
                        - 学校: oldboy
                    - 技能:
                        - 技术: python
                        - 学习: learn
                        - 选课: course

    3) 定义类语法:
        class 关键字: 帮你产生类的。

        class 类的名字:
            - 对象之间相同的特征
                - 学校
                school = 'oldboy'

            - 对象之间相同的技能
                - python
                    def python():
                        pass
                - learn
                    def learn():
                        pass
                - course
                    def course():
                        pass

类

class 类名:
　　特征
　　技能

定义类名的规范:
　　- 驼峰命名法

# 定义老男孩学生类
class OldboyStudent:  # 类名指向的是类的内存地址
    # 学生相同的特征
    # 在类中的特征 也称之为 “属性” attribute
    school = 'oldboy'

    # 学生相同的技能
    # 注意: 在类内部定义函数，会默认有一个参数self
    def learn(self):  # self此时当做一个形参
        print('learning....')

print(OldboyStudent)  # <class '__main__.OldboyStudent'>

# 查看类的名称空间  类.__dict__    对象.__dict__
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])
OldboyStudent.__dict__['learn'](123)

# 类提供一种特殊获取名字的方式  “类名.名字” 的方式
# 查
print(OldboyStudent.school)
OldboyStudent.learn('tank')

# 改
OldboyStudent.school = 'OldGirl'
print(OldboyStudent.school)

# 删
del OldboyStudent.school

# 增
OldboyStudent.school = 'Oldboy'
print(OldboyStudent.school)
OldboyStudent.old_student = 'HuChenYang'
print(OldboyStudent.old_student)

'''
- 函数的名称空间：
    在调用函数时产生，函数调用结束后销毁。

- 类的名称空间:
    在定义阶段时产生，会将类中所有的名字，扔进类的名称空间中。
'''

对象

对象的产生:
　　- 调用类产生对象

　　类名 + () 调用类产生对象

　　类的名称空间在定义时产生，对象的名称空间在调用类时产生。

　　调用类产生对象的过程称之为类的实例化，对象称之为类的一个实例。

class Student:
    # 学校
    school = 'oldboy'

    # 学习技能   ----> method ---》 方法
    def learn(self):
        print(self)  # 注意：看到self就应该知道是对象本身
        print('learning...')

stu1 = Student()
stu2 = Student()
stu3 = Student()
# print(Student)  #
# print(Student.school, 'Student...')
print(Student.learn, 'Student...')  #<function Student.learn at 0x00000000025789D8> Student...
Student.learn(123)  #
print('=' * 100)

print(stu1)  # <__main__.Student object at 0x0000017BFF8A5898>
# print(stu1.school, 'stu1...')
print(stu1.learn, 'stu1...')    # learning...
# print(stu1)
# 对象调用方法时: 会将对象当做第一个参数传入方法中。
stu1.learn()  #

print('=' * 100)
print(stu2)  # <__main__.Student object at 0x0000017BFF8A5898>
# print(stu2.school, 'stu2...')
print(stu2.learn, 'stu2...')
stu2.learn()

print('=' * 100)
print(stu3)  # <__main__.Student object at 0x0000017BFF8A5898>
# print(stu3.school, 'stu3...')
print(stu3.learn, 'stu3...')
stu3.learn()

由对象来调用类内部的函数，称之为对象的绑定方法。
　　对象的绑定方法特殊之处: 会将对象当做第一个参数传给该方法。

class Student:
    # 学校
    school = 'oldboy'

    def __init__(self, name, sex, age):  # stu1, 'tank', 'male', 17
        print(self.__dict__)

        # 给对象添加新的属性
        self.name = name  # stu1.x = 'tank'
        self.sex = sex  # stu1.y = 'male'
        self.age = age  # stu1.z = 17

        # 查看当前对象的名称空间
        print(self.__dict__)

    # 学习技能   ----> method ---》 方法
    def learn(self):
        print(self)  # 注意看到self就知道是对象本身
        print('learning...')
'''结果
{'__module__': '__main__', 'school': 'oldboy', '__init__': <function Student.__init__ at 0x00000000025989D8>, 'learn': <function Student.learn at 0x0000000009BD1730>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
{}
{'name': 'ldc', 'sex': 'female', 'age': 18}
江鹏 female 84
'''

# **** 想要在调用类时，为对象传入对象独有 特征
# ***** __init__(self, name, sex, age):  # name---> tank ,  sex---> male,  age----> 17
# 调用类时: 会将对象当做第一个参数，与括号内所有的参数一并传给__init__()
# stu1 = Student('tank', 'male', 17)

# 注意: 凡是在类内部定义的，__开头或者__结尾的方法都有特殊的意义。
# 在类内部定义的方法，在调用类时触发，会自动将对象本身当做第一个参数自动传入, 与括号内所有的参数一并传给__init__()。
# __init__(self):

对象名字的查找顺序： *******
　　1.对象.属性，会先找对象自己的。
　　2.若对象没有，会去找类的。
　　3.若类没有，则会报错。

class People:
    country = 'China'
    name = 'jason'
    def __init__(self,name,age,sex):
        self.name = name
        self.age=age
        self.sex=sex
    def fun(self):
        print('running...')

obj1 = People('tank',17,'male')
print(obj1.name)    # tank  找对象自己的name属性
print(obj1.country) # China  对象没有，找类中的属性
# print(obj1.jason)   # AttributeError: 'People' object has no attribute 'jason'
print(obj1.__dict__)    #{'name': 'tank', 'age': 17, 'sex': 'male'}
# 给对象的名称空间添加 country='中国' 属性
obj1.country = '中国'
print(obj1.__dict__)    # {'name': 'tank', 'age': 17, 'sex': 'male', 'country': '中国'}
print(People.__dict__)
# {'__module__': '__main__', 'country': 'China', 'name': 'jason', '__init__': <function People.__init__ at 0x00000000025989D8>, 'fun': <function People.fun at 0x0000000009BD1730>,
# '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}
print(obj1.country) # 中国

在python中一切皆对象。

number = 10   # int(10)  ----> __init__(number, 10)
int(10)
# l1 ---> list对象
l1 = list([1, 2, 3])
dict()
tuple((1, 2, 3))
float
str
set
bool
enumerate
bytes
filter

人狗大作战

# 人类
class People:

    def __init__(self, name, life, arg):
        self.name = name
        self.life = life
        self.arg = arg

    # 人调用bite时，传入狗对象
    def bite(self, dog_obj):
        print(f'人：[{self.name}] 开始 咬 狗:[{dog_obj.name}]!')

        # 减掉狗对象中的生命值  值为人的攻击力
        dog_obj.life -= self.arg
        print(f'狗的生命值减掉: [{self.arg}], 还剩狗的血量: [{dog_obj.life}]')

        if dog_obj.life <= 0:
            print(f'狗[{dog_obj.name}]已经挂了')
            return True

# 狗类
class Dog:
    def __init__(self, name, life, dog_type, arg):
        self.name = name
        self.dog_type = dog_type
        self.life = life
        self.arg = arg

    # 狗对象调用bite时，传入人对象
    def bite(self, p_obj):
        print(f'狗：[{self.name}] 开始 咬人:[{p_obj.name}]!')

        # 减掉人对象中的生命值  值为狗的攻击力
        p_obj.life -= self.arg
        print(f'人的生命值减掉: [{self.arg}], 还剩人的血量: [{p_obj.life}]')

        if p_obj.life <= 0:
            print(f'人[{p_obj.name}]已经挂了')
            return True

p1 = People('高弟', 2000, 500)
d1 = Dog('HCY', 250, '哈士奇', 2500)

p2 = People('高弟2', 5000, 50)
import time

while True:
    # 开始人狗互咬
    # if p1.life or d1.life:
    res1 = d1.bite(p2)

    if res1:
        break

    time.sleep(1)
    res2 = p1.bite(d1)

    if res2:
        break

    time.sleep(1)

总结：

面向对象编程:
　　核心是 “对象”， 对象指的是 特征与技能 结合体。
　　基于该编程思想编写程序，就好比在创造世界，一种上帝式思维方式。

　　优点:
　　　　可扩展性强。

　　缺点:
　　　　编写复杂难度较面向过程高。

1.类的实例化: 调用类的过程称之为类的实例化，产生的对象也可以称之为类的一个实例

调用类产生对象发生的事情:
　　1.会产生一个空对象的名称空间
　　2.会自动触发__init__，并且会将对象当做第一个参数传入。
　　3.会将调用类括号内的参数一并传给__init__().

2.查看类与对象的名称空间 类.__dict__   对象.__dict__

3.类或对象的属性操作: 查、增、改、删

4.类中数据属性（类中的变量）: 类中属性是给对象使用的，对象引用类中的属性，指向的都是类中同一个内存地址。

5.类中的方法（类中的函数）: 类中的方法是给对象使用的，
由不同的对象来调用就会将方法绑定给不同的对象, 并且会将对象当做第一个参数传入。

6.对象属性的查找顺序: 先从对象自己名称空间中查找 ---》 类的名称空间中查找

7.对象绑定方法的特殊之处:

　　1.会将对象当做第一个参数传入。******
　　2.若对象的绑定方法中还有其他参数，会一并传入。

8.一切皆对象: 在python3中，类即类型。