python 面向对象

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

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

    def pear(self):
        pass

    def chestnut(self):
        pass

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

# 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就没有值,就直接打印的是对象的地址

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