Python-初识面向对象

时间 2019-12-02

标签 python 面向对象栏目 Python 繁體版

原文原文链接

目录python

什么是面向对象？

面向对象指的是一门编程的思想，python中一切皆对象。编程

面向过程 VS 面向对象

面向过程编程：

核心是 “过程” 二字，过程指的是作事情的步骤，即先作什么再作什么，函数

基于该编程思想写程序，就比如一个工厂流水线，一种机械式的思惟方式code

优势：逻辑清晰，复杂的问题简单化对象

缺点：可扩展性差get

面向对象编程：

核心是 “对象” 二字，对象指的是特征和技能的结合体it

基于该编程思想写程序，就比如在创造世界，一种上帝式的思惟方式面向对象编程

优势：可扩展性高class

缺点：编写程序复杂程度高扩展

那么咱们在编程的时候优先使用面向过程思想呢？仍是面向对象思想呢？

一般是二者结合在一块儿使用

类与对象定义

对象：特征和技能的结合体

类：一系列对象相同的特征和技能的结合体

在现实生活中先有一个一个对象，而后再有人们对类的概念，
在程序中必须定义好类，而后调用类来创造对象

定义类：

class 类名
相同的特征
相同的技能

class Stut: # 类名，遵循驼峰体命名规范，首字母大写
    # 特征
    school = "oldboy"
    # 技能
    def learn(self):
        print("learning...")

定义类发生的两件事情

生成一个空的名称空间
把类内部全部名字，扔进类的名称空间中

注意：类在定义阶段产生好了名称空间，执行py文件时候会执行类内部的代码

建立对象

语法：类名 + () 调用产生对象

-------类调用-------
# 在咱们定义好类以后，咱们能够调用类的属性和方法
print(Stut.__dict__.get("school"))      # 类名.__dict__获取类内部所有属性
Stut.learn(123)     # 使用Stut的learn方法，此时由类来调用类内部的函数，该函数只是一个普通的函数，类内部learn函数有一个形参，那么在调用的时候也必须传一个参数才能调用


-------对象调用-------
s1 = Stut() # s1 -》 <__main__.Stut object at 0x0000000009FA9DD8>
#在咱们实例化类 建立出来一个s1对象以后，咱们可使用对象.属性来调用
print(s1.school)
s1.learn()      # 由对象来调用类内部的方法，self即对象自己，做为第一个参数传入。

建立对象(即调用类) 发生的三件事情

生成一个空的对象空间，
会自动触发类内部的 __init__函数
会把建立的对象自己以及调用类传入的参数一并传入给 init 函数

class OldboyStudend:
    """学生类"""
    # 给不一样对象添加不一样特征的方式二：
    def __init__(self,name,age,sex):
        # self 就是建立出来的对象自己，对象.属性 能够获取不一样对象的属性
        self.name = name
        self.age = age
        self.sex = sex
        print("调用类就运行__init__函数",name,age,sex)

    school = "oldboy"

    def learn(self):
        print("正在learn...")

    def chooice_course(self):
        print("正在chooice_course...")

# print(OldboyStudend.__dict__.get("school"))


s1 = OldboyStudend("qinyj",21,"男")    # 建立出一个 名 s1的对象
s2 = OldboyStudend("jack",22,"男")    # 建立出一个 名 s2的对象
print(s1.school)        # 调用类的特征
print(s2.school)        # 调用类的特征


'''
问题：不一样的对象特征技能同样，如何能不同
解决：两种方式：
    - 在类内部定义 __init__ 函数
    - 建立出对象后单独添加属性
'''

# 给不一样对象添加不一样特征的方式一：
s1.name = "qinyj"
s1.age = "21"
s1.sex = "female"

s2.name = "jack"
s2.age = "22"
s2.sex = "female"
print(s1.name,s1.age,s1.sex)
print(s2.name,s2.age,s2.sex)

对象与类的查找顺序

对象中属性的查找顺序：

对象.属性若对象自己有，则优先查找对象本身的
若对象自己没有，则去类里面找
若类没有，则报错

class OldboyStend:
    SCHOOL = "oldboy"
    NAME = "DDDDDDDD"

    def __init__(self,name,age,sex,school):
        self.name = name
        self.age = age
        self.sex = sex
        self.SCHOOL = school

s1 = OldboyStend("qinyj",22,"男","oldgirl")
print(s1.SCHOOL)
# oldgirl

print(s1.NAME)
# DDDDDDDD

对象绑定方法

类内部的函数主要是给对象用的

类来调用类内部的函数，这时候这个函数就是一个普通的函数，这个函数有一个形参，调用的时候必须传入几个参数
对象来调用类内部的函数称之为对象的绑定方法，不一样的对象调用该绑定方法，则会将不一样的对象传入该绑定方法中
对象的绑定方法是由对象来调用的，特殊之处就是把对象当作第一个参数传入该方法中

class OldboyStend:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def learn(self):
        print(f"{self.name} 正在learn...")

s1 = OldboyStend("qinyj",22,"男")
s1.learn()
# qinyj 正在learn...

print(s1.learn)     # bound method 称之为对象的绑定方法   再也不是一个普通的函数了
# <bound method OldboyStend.learn of <__main__.OldboyStend object at 0x000000000296C400>>

实战-人狗大做战

'''
需求：
    人 对象
    狗 对象
    人狗互咬，若是一方生命值为0，则该程序就结束

定义两个类：
    人类
    狗类
'''

class People:
    def __init__(self,name,damage,life):
        # 对象特有的特征
        self.name = name
        self.damage = damage
        self.life = life
    # 人咬狗 技能
    def bite(self,dog):
        if dog.life <= 0:
            return True
        if self.life == 0:
            print(f"{self.name} 死了，{dog.name} 赢了")
            return
        dog.life -= self.damage
        print(f'''
        人：[{self.name}] 开始咬狗：[{dog.name}]
        狗掉血：[{self.damage}]
        狗剩余血量：[{dog.life}]
        ''')

class Dog:
    def __init__(self,name,damage,life):
        # 对象特有的特征
        self.name = name
        self.damage = damage
        self.life = life

    # 狗咬人 技能
    def bite(self, people):
        if people.life <= 0:
            return True
        if self.life == 0:
            print(f"{self.name} 死了，{people.name} 赢了")
            return
        people.life -= self.damage
        print(f'''
        狗：[{self.name}] 开始咬人：[{people.name}]
        人掉血：[{self.damage}]
        人剩余血量：[{people.life}]
        ''')

people = People("qinyj",200,1000)
dog = Dog("哈士奇",500,400)
while True:
    flg1 = people.bite(dog)
    if flg1:
        break
    flg2 = dog.bite(people)
    if flg2:
        break

终端打印结果：

人：[qinyj] 开始咬狗：[哈士奇]
        狗掉血：[200]
        狗剩余血量：[200]
        

        狗：[哈士奇] 开始咬人：[qinyj]
        人掉血：[500]
        人剩余血量：[500]
        

        人：[qinyj] 开始咬狗：[哈士奇]
        狗掉血：[200]
        狗剩余血量：[0]
        
哈士奇 死了，qinyj 赢了

小结

面向过程编程:
        核心是“过程”二字，过程指的是作事情的步骤，即先作什么再作什么
        基于该编程思想编写程序，就比如一条工厂流水线，一种机械式的思惟方式。
            优势:逻辑清晰，复杂的问题流程化，进而简单化。
            缺点:可扩展性差。
    面向对象编程:
        核心是“对象”二字，对象指的是特征与技能的结合体。
        基于该编程思想编写程序，就比如在创造世界，一种上帝式的思惟方式。
            优势:可扩展性高。
            缺点:编写程序的复杂程度要远高于面向过程编程思想。

    在定义类发生的事情:
        1.类在定义时，会产生一个空的名称空间。
        2.会把类内部全部名字，扔进类的名称空间中。
        注意: 类在定义阶段就已经产生好了名称空间，执行python文件时会执行类内部的代码。


    调用类发生的事情(******):
        1.首先会产生一个空的对象，就是产生“对象的名称空间”。
        2.会自动触发__init__。
        3.会把对象自己以及括号内的参数一并传给__init__函数。
        总结: 调用类会产生一个对象,调用类的过程叫作类的实例化,产生的对象称之为类的一个实例.


    __init__: 会在调用类时，自动触发该函数。

    对象绑定方法特殊之处
        1.类调用类内部的函数,只是调用普通函数.
        2.对象的绑定方法特殊之处(*******):
            - 由对象来调用的,会把对象看成第一个参数传入该方法中
            - 由不一样的对象来调用,就会把不一样的对象传给不一样的绑定方法.