欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

面向对象(一)

程序员文章站 2024-01-05 15:09:40
面向对象 一、面向对象介绍 介绍 二、类以及对象 类及对象的语法 类以及对象的具体使用 三、对象名字的查找顺序 查找顺序 一切皆对象 四、一个小游戏 人狗大战小游戏 ......

面向对象

一、面向对象介绍

  • 介绍
'''
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'>

上一篇:

下一篇: