面向对象（一）

面向对象

一、面向对象介绍

• 介绍

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

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

        优点:
            将复杂的问题流程化，进而简单化

        缺点:
            牵一发而动全身，程序的可扩展性差。


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

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

        优点:
            可扩展性高。

        缺点:
            编写程序的复杂程度比面向过程高。

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

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

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

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


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


        - 比如: 选课系统:
            - 选课系统学生类:
                - 学生对象1:
                    特征:
                        - 姓名: 马冬梅
                        - 性别: female
                        - 年龄: 26
                        - 学校: oldboy

                    - 技能:
                        - 技术: python
                        - 学习: learn
                        - 选课: course

                - 学生对象2:
                    特征:
                        - 姓名: 迪丽热巴
                        - 性别: female
                        - 年龄: 18
                        - 学校: oldboy

                    - 技能:
                        - 技术: python
                        - 学习: learn
                        - 选课: course


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

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

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

                - learn
                    def learn():
                        pass

                - course
                    def course():
                        pass
'''

二、类以及对象

• 类及对象的语法

'''
class 类名:
    特征
    技能

定义类名的规范:
    - 驼峰命名法
    - 用变量表示特征
    - 用函数表示技能
    - 注意：在定义类的阶段会立刻执行类体内的代码，将产生的名字存放于名称空间中
    - 用.__dict__的方法去查看名称空间
    - 在类内定义一个__init__的函数，该函数会在调用类时自动触发执行，并且会将对象自动传给
        传给函数的第一个参数，然后会将其他的参数一起传给__init__
        
    - 函数的名称空间：
        在调用函数时产生，函数调用结束后销毁。

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

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

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

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

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

'''

• 类以及对象的具体使用

class oldboy:

    school = 'oldboy'

    def __init__(self, name, age, gender):
        #给对象增加新的属性
        self.name = name
        self.age = age
        self.gender = gender

    def learn(self):
        print('is learning....')

obj = oldboy('热巴', 18, 'female')
print(obj)  #<__main__.oldboy object at 0x00000236533cde48>

print(obj.name)  #热巴(.后面的名字叫属性attribute)

print(obj.age) #18

print(obj.gender)  #female

#查看类的名称空间
print(oldboy.__dict__)
#{'__module__': '__main__', 'school': 'oldboy',
# '__init__': <function oldboy.__init__ at 0x000002c6b7afbee8>,
# 'learn': <function oldboy.learn at 0x000002c6b7b16948>,
# '__dict__': <attribute '__dict__' of 'oldboy' objects>,
# '__weakref__': <attribute '__weakref__' of 'oldboy' objects>, '__doc__': none}

#增
obj.hobby = 'dance'
print(obj.hobby)  #dance

#删
del obj.hobby
print(obj.hobby)
attributeerror: 'oldboy' object has no attribute 'hobby'

#改
obj.name = '迪丽热巴'
print(obj.name) #迪丽热巴

#查
print(obj.age)  #18

三、对象名字的查找顺序

• 查找顺序

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


class man:
    country = 'china'
    name = '亚峰'

    def __init__(self, name, age, gender):
        print(self.__dict__)  #此时是一个空{}
        self.name = name
        self.age = age
        self.gender = gender
        print(self.__dict__)  #此时是添加完以后的字典{'name': '热巴', 'age': 18, 'gender': 'female'}


    def run(self):
        print('running....')


obj = man('热巴', 18, 'female')
print(obj.name)  #热巴,对象自己有的属性，会用自己的属性
print(obj.country) #china,对象没有的属性，会拿类中的属性
print(obj.number)  #attributeerror: 'man' object has no attribute 'number'
#对象没有，类中也没有，会报错


#给对象添加自己的属性
obj.country = '中国'
print(obj.country)  #中国

• 一切皆对象

'''在python中一且皆对象'''

class province:
    def __init__(self, gdp, number, view):
        self.gdp = gdp
        self.number = number
        self.view = view


obj = province(12345678974123, 66666666, '黄山')
print(obj)  #<__main__.province object at 0x000001fa83dae7c8>


int  #class int(object):
float #class float(object):
str #class str(object):
list #class list(object):
set #class set(object):
tuple #class tuple(object):
dict #class dict(object):
filter #class filter(object):
....

四、一个小游戏

• 人狗大战小游戏

'''
需求: 有一个人对象，狗对象，人狗互咬。

- 对象人1:
    - 特征:
        - 生命
        - 名字: name = '小明'
        - 攻击力: arg

    - 技能:
        - 咬：bite

- 对象人2:
    - 特征:
        - 生命
        - 名字: name = '张三'
        - 攻击力: arg

    - 技能:
        - 咬：bite

- 抽象出类:
    - 人类:
        - 相同特征
            - 生命

        - 相同技能
            - 咬

狗对象1:
    - 特征:
        - 生命: 250
        - 名字: name = '阿黄'
        - 品种: dog_type = '哈士奇'
        - 攻击力: arg

    - 技能:
        - 咬：bite

狗对象2:
    - 特征:
        - 生命: 400
        - 名字: name = '旺财'
        - 品种: dog_type = '哈巴犬'
        - 攻击力: arg

    - 技能:
        - 咬：bite

狗类:
     - 相同特征

     - 相同技能
         - 咬
'''

#人类
class man:
    def __init__(self, name, life, attack_bility):
        self.name = name
        self.life = life
        self.attack_bility = attack_bility

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

        #减掉狗的生命值，值为人的攻击力
        dog_obj.life -= self.attack_bility
        print(f'狗的生命值减掉{self.attack_bility},还剩{dog_obj.life}!')

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


#狗类
class dog:
    def __init__(self, name, life, attack_bility):
        self.name = name
        self.life = life
        self.attack_bility = attack_bility

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

        #减掉人的生命值，值为狗的攻击力
        man_obj.life -= self.attack_bility
        print(f'人的生命值减掉{self.attack_bility},还剩{man_obj.life}!')

        if man_obj.life <= 0:
            print(f'人{man_obj.name}已经挂了')
            return true


man_obj = man('小明', 1001, 100)

dog_obj = dog('阿黄', 500, 200)
import time

while true:
    res1 = man_obj.bite(dog_obj)
    if res1:
        break
    time.sleep(1)
    res2 = dog_obj.bite(man_obj)
    if res2:
        break
    time.sleep(1)

五、总结

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

    优点:
        可扩展性强。

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


# 1.类的实例化: 调用类的过程称之为类的实例化，产生的对象也可以称之为类的一个实例。
'''
调用类产生对象发生的事情:
    1.会产生一个空对象的名称空间
    2.会自动触发__init__，并且会将对象当做第一个参数传入。
    3.会将调用类括号内的参数一并传给__init__().
'''

class people:
    country = 'china'
    def __init__(self, name, age, sex):
        print(self.__dict__)
        print(self)
        self.name = name
        self.age = age
        self.sex = sex
        print(self.__dict__)

    # 注意: 看到self就应该知道是对象本身
    def learn(self):
        print('learning....')


p_obj = people('tank', 17, 'male')
# print(p_obj.name, p_obj.age, p_obj.sex)

# 2.查看类与对象的名称空间 类.__dict__   对象.__dict__
# print(people.__dict__)
# print(p_obj.__dict__)

# 3.类或对象的属性操作: 查、增、改、删
# print(people.country)
# people.number = 1500
# print(people.number)
# people.country = '中国'
# print(people.country)
# del people.country
# print(people.country)

# print(p_obj.name)
# p_obj.sal = 150000000
# print(p_obj.sal)
# p_obj.age = 16
# print(p_obj.age)
# del p_obj.sal
# print(p_obj.sal)


# 4.类中数据属性（类中的变量）: 类中属性是给对象使用的，对象引用类中的属性，指向的都是类中同一个内存地址。
# p_obj1 = people('tank', 17, 'male')
# p_obj2 = people('jason', 71, 'female')
# p_obj3 = people('大饼', 72, 'female')
# print(p_obj1.country, id(p_obj1.country))
# print(p_obj2.country, id(p_obj2.country))
# print(p_obj3.country, id(p_obj3.country))


# 5.类中的方法（类中的函数）: 类中的方法是给对象使用的，
# 由不同的对象来调用就会将方法绑定给不同的对象, 并且会将对象当做第一个参数传入。
# print(people.learn)
# print(p_obj1.learn)  # bound method
# print(p_obj2.learn)
# print(p_obj3.learn)

# 6.对象属性的查找顺序: 先从对象自己名称空间中查找 ---》 类的名称空间中查找
# print(p_obj1.country)
# print(p_obj1.country2)


# 7.对象绑定方法的特殊之处:
'''
    1.会将对象当做第一个参数传入。******
    2.若对象的绑定方法中还有其他参数，会一并传入。
'''
# p_obj1对象.对象的绑定方法learn(p_obj1):
# p_obj1.learn()


# 8.一切皆对象: 在python3中，类即类型。
# print(type(p_obj1))  # <class '__main__.people'>
# str1 = 'tank'
# print(type(str1))  # <class 'str'>
#
# list1 = [1, 2, 3]
# print(type(list1))  # <class 'list'>