python 面向对象

Posted 2021-03-26 S-skill

 

一. 面向对象的初识

　　class 定义一个类别

　　类:具有相同属性和技能的一类事物

　　对象:具体的类的表现,具体的实实在在的一个实例

　　例:比如食物是一个类,苹果是一个对象,苹果是食物的一种,食物包含了苹果

 

 

三. 类, 对象
    类:
        class (类的关键字, 类的首字母一定要大写)
        操作类中的方法 
        类体:两部分:变量部分,方法(函数)部分
        类里的变量,静态变量 比如: server = 服务端
        在函数里(def work(self):):方法,函数,动态变量
        在类中可以执行函数
        通过类名可以更改我的类中的静态变量值
    对象:
        对象操作类中的静态变量: 只能查询
        对象调用类中的方法 (工作中 通过对象执行类中的方法,而不是通过类名 )
        在对象里 self(对象空间,也可以是一个对象)
        对象可直接执行函数,不用传参
        用对象中可以直接进行(正删改查)
        可以用默认值进行(固定),但是再次调用原来的参数,会从新覆盖(那个固定的)变成原来的
        Person() 实例化对象, 实例,对象
        可以通过对象,对函数传值
        可以在外面加入对象值传入对象      # 在__init__里面
        用对象可以在其他函数封装属性,用对象给func函数封装属性(self.name = name)
        用对象直接执行,在查看
        但是通过对象,不能改变,只能引用类中的静态变量


四. 类, 对象调用类中的变量和方法
    类名的角度
        操作类中的静态变量:
            1. __dict__ 查询类中的所有内容 (不能进行增删改操作)
            2. 万能的  "." 对类中的单个的变量进行增删改查, 用万能的 "点"
    对象的角度
        类名+()的这个过程:实例化的过程(创建一个对象的过程)
            1. 只要产生类名+() 产生一个对象,自动执行类中的__init__方法,类名+()产生一个实例(对象,对象空间)
            2. 自动执行类中的__init__方法.并且将对象空间传给__init__的self参数
            3. 给对象封装相应的属性



1. 第一步

class Food:     # 定义一个类, 首字母需要大写
    def apple(self):    # 用每一个函数进程分类,
        pass

    def banana(self):   # 比如:这个是香蕉的种类,只能放香蕉
        pass

    def pear(self):
        pass

    def chestnut(self):
        pass

f1 = Food() # 实例化一个对象,类名+()

 

2. 第二步

# class (类的关键字, 类的首字母一定要大写)
class Food:
    banana = ‘香蕉‘        # 变量,静态变量
    apple = ‘苹果‘    # 是公共的,可以用类名调用,也可以用对象进行调用
    pear = ‘梨子‘

    def work(self):     # 方法,函数,动态变量
        print(self)     # 打印的是对象
        print(‘工作‘)
    def shopping(self):
        print(‘消费‘)

f = Food()
# 在类名的角度
# print(Food.__dict__)    # 查询类中的所有内容 (不能进行增删改操作)
# Food.__dict__[‘chestnut‘] = ‘栗子‘    # 不支持会报错
# print(Food.__dict__[‘chestnut‘])    # 一样会报错,不能进行增删改操作

# 万能的  "." 对类中的单个的变量进行增删改查, 用万能的 "点"
print(Food.apple)   # 查
Food.chestnut = ‘栗子‘    # 增
print(Food.chestnut)    # 可以单独查一个静态变量
print(Food.__dict__)  # 查看类名中的所有的内容
Food.apple = ‘不是苹果‘ # 改
print(Food.__dict__)
del Food.apple  # 删
print(Food.__dict__)

# 调用函数名(用对象和类名的区别)
# 用类名调用函数,必须要传一个值
Food.work(111)  # 执行类中的函数,,把值传给函数里面的self,然后在打印出来
f.work()    # 用对象调用函数不用传参,
# 但是函数里面的self就没有值,就直接打印的是对象的地址

 

3. 第三步

class Food:
    banana = ‘香蕉‘        # 变量,静态变量
    apple = ‘苹果‘    # 是公共的,可以用类名调用,也可以用对象进行调用
    pear = ‘梨子‘
    def __init__(self,meal,potato,beef):    # 类名传的值到了这里
        self.meal = meal    # 封装了一个属性
        self.potato = potato
        self.beef = ‘牛肉‘ # 固定了,不用传值了,但是可以覆盖
        self.beef = beef    # 从新覆盖变成原来的,可以重新传值了
        print(self) # 打印的对象地址
        print(potato,meal,beef)

    def work(self):     # 方法,函数,动态变量
        print(self)     # 打印的是对象
        print(‘工作‘)
    def shopping(self):
        print(‘消费‘)

# 可以在类名 + ()里面传值,是传给 __init__方法里面的
f = Food(‘饭‘,‘土豆‘,‘牛肉‘)  # 类名+()的这个过程:实例化的过程(创建一个对象的过程),
print(f)    # 打印对象,
# 可以发现打印的f, 和__init__方法里面打印的self的地址是一样的
# 1. 只要产生类名+() 产生一个对象,
# 2. 自动执行类中的__init__方法,并且将对象空间传给__init__的self参数
# 3. 给对象封装相应的属性

# 在对象的角度
    # 对__init__里面的值进行 增删改查
f.name = ‘名字‘   # 增加到 __init__的方法里面
print(f.__dict__)   # 只查看对象里面的值 查
del f.beef  # 删
print(f.__dict__)   # 查
f.potato = ‘不是土豆‘   # 改
print(f.__dict__)

# 对象操作类中的静态变量: 只能查询
# f.banana = ‘不是香蕉‘   # 用对象修改类中的静态变量,不能修改,只会在__init__方法里面增加一个封装属性
# 用对象只能查询类中的静态变量
# print(Food.banana)

# 对象调用类中的方法
f.work()    # 可直接执行,不用传参
# 用类名调用类中的方法,需要传参
Food.work(11),# 把值传给self

 

4. 第四步