python 中的面向对象

定义功能函数：

责任 = 功能 = 能力 = 行为 = 能力 = 函数 定义函数：面向对象中把任 = 功能 = 能力 = 行为 = 能力 = 函数。统统定义为函数。 定义函数可以很复杂也可以很简单。因为函数可以写逻辑代码，可以包含多行内容。
计算机属于先下定义、在创建模板。

在现实生活中：当我们看见遇见一个实物的时候:大脑会不自觉的去匹配大脑中的模板。
语法问题： 1. 创建对象对象名 = 类名（） 2. 访问属性、方法对象名.属性名 /方法名 3. 属性赋值对象名.属性名 = 值

面向对象-类和对象

类和对象是面向对象编程的两个核心概念。注意：在开发中，先有类，再定义对象。

类

类：是对一系列具有相同特征和行为的一个统称，抽象的，不能直接使用（不是真是存在的实物）

类的作用？

类是用来创建对象的。

类：是概念比如说（猫类，狗类等）

类：是一个概念谁都可以定义（经常要使用而且经常要自定义）一类：一定是具有相同特的。

特征就是一个变量，在类里我们称之为属性（特征即是属性：类似于洗衣机的宽高）。
行为就是一个函数，在类里我们称之为方法（行为即是方法：类似于洗衣机的功能）。
类其实就是由属性和方法组成的一个抽象概念。

属性和方法是抽象来的。是你观察，发现的相同点。可以说 : 属性与方法被类封装起来了/保护起来了。（在python中缩进代表着包含的意思）

总结:

类属对象的抽象出来的
对象是类的实例出来的
万物皆对象物 --->>> 实实在在的物体
对象（拥有属性和方法的集合体）

对象

什么是对象：

对象是由类实例化出来真实存在的事物，可以直接使用。例如：图纸造出飞机电视洗衣机...

由那一个类创建出来的对象，就拥有在哪一个类中定义的属性和方法。

类和对象的关系：

用类去创建一个对象，可以把创建称之为实例化亦可以用类去实例化一个对象。

类是模板，对象是根据类这个模板创建的，应该先有类，再有对象。
使用同一个类，能够创建出n多个对象。要符合 is a 的关系。
类中定义了什么属性和方法，对象中就有什么属性和方法。
不同对象对应的属性值也会不同。

类的设计

在程序开发中，要设计一个类，通常需要满足一下三个要素：

类名： 这类事物的名字，安照大驼峰命名法(每个单词的首字母大写)起名。
属性： 这类事物具有什么样的特征。== 属性
方法： 这类事物具有什么样的行为。== 函数

定义类名

名词提炼法:分析整个业务流程，出现的名词，通常就是找到的类。（可以两个名词拼接成的缩写）

注意：类名要满足标识符命名规则，同事要遵守大驼峰的命名习惯。(首字母大写)

属性和方法的确定

对象的特征描述，可以定义成属性

对象具有的行为（动词）可以定义成方法

练习需求1:

小明今年18 岁，身高 1.75，每天早上跑完步，会去吃东西
小美今年17 岁，身高 1.65，小美不跑步，小美喜欢吃东西

class Person(object):
    """ 这是一个人类 """
    # 类属性
    name = ''
    age = '12'
    height = '1.0'

    # 功能函数
    def run(self):
        # 判断 
        if self.name == '小明':
            print('每天每天早上跑完步，会去 吃 东西')
        elif self.name == '小美':
            print('小美不跑步，小美喜欢 吃 东西')

    def showInfo(self):
        print(f'{self.name}\t今年:{self.age}\t身高:{self.height}')


# 拦截 测试 
if __name__ == '__main__':
    ming = Person()
    ming.name = '小明'
    ming.run()
    ming.showInfo()

面向对象基本语法

在Python中，对象几乎是无处不在的，一切接对象；使用dir内置函数来查看这个对象里的方法。

在python 处处皆对象。

# 可以使用`dir`内置函数来查看这个对象里的方法。
a = []
print(dir(a)) # ['__add__', '__class__', '__class_getitem__'....

定义简单的类（只包含方法）

面向对象是更大的封装，在一个类中封装多个方法，这样通过这个类创建出来的对象，

对象名.方法/属性名 可以直接调用这些方法了！

什么是封装？

将复杂的丑陋的,隐私的细节隐藏到内部,对外提供简单的使用接口

对外隐藏内部实现细节,并提供访问的接口

什么时候应该封装？

当有一些数据不希望外界可以直接修改时

当有一些函数不希望给外界使用时

为什么需要封装 ？

1.为了保证关键数据的安全性

2.对外部隐藏实现细节,隔离复杂度

定义类

手动添加属性：对象名.属性名 = 赋值

获取：类外面获取属性 print（对象名.属性名）可以访问到值

类里面获取对象属性：self.属性名 = （属性名的值）

object -- 默认状态下，类不去继承自己书写得类，默认继承所有类的顶级类，就是object（父类，基类）

定义类中的方法

定义函数不要重名一旦重名调用的是最后一个（替换），也不要和类名重名。命名规则首字母小写其余单词首字母大写

# 方法里的第一个参数必须是self  、类名要遵守大驼峰命名法
class 类名（object）:
    def 方法1(self,参数列表):
        pass
    def 方法2(self,参数列表):
        pass


class Dog(object):
    """ 这是一个狗类  """
    def run(self):
        print(f'{self.name}在奔跑')

    def set(self):
        print('狗狗在吃东西')

    def playPan(self):
        print('狗狗在玩耍')


if __name__ == '__main__':
    xiaoHang = Dog()  # 创建新对象 就会开辟新空间
    '''
      Python语法特点:
         脚本语言 解释性语言 可以动态给对象添加属性
         给对象添加属性 是添加到了某一个对象身上并不会影响其他对象和类模板
        
    '''
    # 类外面添加属性 对象名.属性名 = 赋值
    xiaoHang.name = '小黄'
    xiaoHang.run()

    xiaoHen = Dog()  # 创建新对象 就会开辟新空间
    xiaoHen.name = '小黑'
    xiaoHen.run()

    print(xiaoHen == xiaoHang)
    print(id(xiaoHen))
    print(id(xiaoHang))

创建对象

对象又叫实例（先有类在创建对象）

对象名 = 类名()  # 类名（） 等号赋值到 对象变量名  （变量名即使对象名）

例子：

第一个面向对象代码

需求

小猫爱吃鱼，小猫要喝水

分析

定义一个猫类 Cat
定义两个方法 eat 和 drink
按照需求 —— 不需要定义属性

class Cat:
    """这是个猫类"""

    def eat(self):
        print("小猫在吃东西")

    def drink(self):
        print("小猫在喝水")

tom = Cat()           # 创建了一个Cat对象  开辟新空间
tom.eat()
tom.drink()
print(id(tom))    

hello_kitty = Cat()   # 又创建了一个新的Cat对象  开辟新空间
hello_kitty.eat()
hello_kitty.drink()
print(id(hello_kitty)) # 查看内存地址  id（）将空间地址数值化

self的使用

给对象添加属性：python 是脚本语言.python支持动态属性，当一个对象创建好了以后，直接使用 对象.属性名 = 属性值 就可以很方便的给对象添加一个属性。（不建议使用这种方式给对象添加属性）

# 这种方法很方便，但是，不建议使用这种方式给对象添加属性。
tom = Cat()
tom.name = 'Tom'  # 可以直接给 tom 对象添加一个 name 属性
self的概念

self 表示 本身，作为函数的第一个参数,python语法默认提供 ，代表 当前调用此函数的对象。

对象为：return.__new__(cls) 开辟的空间

哪个对象调用了方法，方法里的self指的就是谁。

通过 self.属性名 可以访问到这个对象的属性；通过 self.方法名() 可以调用这个对象的方法。

class Cat:
    """这是个猫类"""
    '''
        self 代表调用这个函数的对象   
        没有定义属性值 ，通过self .  的形式调用这个对象的属性和函数
    '''
    
    def eat(self):
        print("小猫{}在吃东西".format(self.name))
        self.drink() # 使用self.方法名打印（drink内的方法内容）

def drink(self):
    print("小猫在喝水")

print('demo.py   ', __name__)
if __name__ == '__main__':
    tom = Cat()    # 创建了一个Cat对象
    tom.name='汤姆' 
    tom.eat()
    print(tom.name)
    print(id(tom))


    kt = Cat()
    kt.name="花花"
    print(kt.name)
    kt.eat()

这种方法很方便，但是，不建议使用这种方式给对象添加属性。
顺序掌握不好会报错 要注意先后顺序 （先定义属性，在调用）

"""
self是调用概函数的对象，打印对象内存地址，与打印self内存地址相同。
那个象调用了 washer方法 就会把 pi对象属性传入self 里面去
一个类 可以创建多个对象， 多个对象都调用方法函数（内存地址不同的）
创建一个对象调用方法 就会开辟新的空间
"""

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)