python 面向对象，python面向对象编程思想,一. 面向对象的初识

python 面向对象，python面向对象编程思想,一. 面向对象的初识

一. 面向对象的初识

　　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):        passf1 = 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. 第四步

python 面向对象