面向对象(一)

面向对象

一、面向对象介绍

  • 介绍
'''
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'>
posted @ 2019-11-25 16:46  alen_zhan  阅读(192)  评论(2编辑  收藏  举报
返回顶部