面向对象(一)

阿里云2000元红包!本站用户参与享受九折优惠!

面向对象

一、面向对象介绍

  • 介绍
'''
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 类名:
    特征
    技能
定义类名的规范:
    - 驼峰命名法
    - 用变量表示特征
    - 用函数表示技能
    - 注意:在定义类的阶段会立刻执行类体内的代码,将产生的名字存放于名称空间中
    - 用.__init__的方法去查看名称空间
    - 在类内定义一个__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'>

https://www.cnblogs.com/yafeng666/p/11928813.html

「点点赞赏,手留余香」

    还没有人赞赏,快来当第一个赞赏的人吧!
Scrapy
0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论