day24：面向对象设计与面向对象编程、类和对象

一、三大编程范式：

面向过程：

面向函数：

面向对象：

二、程序的进化论：

1.编程最开始就是无组织无结构，从简单控制流中按步写指令

2.从上述的指令中提取重复的代码块或逻辑，组织到一起(比方说，你定义了一个函数)，便实现了代码重用，且代码由无结构走向了结构化，创建程序的过程变得更具逻辑性

3.我们定义函数都是独立于函数外定义变量，然后作为参数传递给函数，这意味着：数据与动作是分离的

4.如果我们把数据和动作内嵌到一个结构(函数或类)里面，那么我们就有了一个‘对象系统’（对象就是数据与函数整合到一起的产物）。

三、面向对象初见面：

3.1

#你是谁?【名字、属性、特征、。。】你在干什么【动作】?千年的哲学问题!
两者组合起来：实现了两者的交互：对象正在做什么事情!

#狗的属性特征
dog1={'name':'苑昊','gender':'母','type':'腊肠'}
dog2={'name':'alex', 'gender':'母','type':'津巴'}

person={'name':'武sir', 'gender':'母','type':'人'}
#狗的动作
def jiao(dog):
    print('一条狗[%s],汪汪汪'%dog['name'] )

def chi_shi(dog):
    print('一条狗[%s]正在吃屎' %dog['type'])
jiao(dog1)
chi_shi(dog1)
chi_shi(dog2)
jiao(person)

3.2、实现狗只能执行狗的动作，人执行狗的动作。 解决方法：绑定一块

　　　　解决方式：在对象里面加入属性的字段，之后在调用过程中，进行if判断。显得太low！

比较好的办法：

def dog():
    # 狗的动作
    def jiao(dog):
        print('一条狗[%s],汪汪汪' % dog['name'])
    def chi_shi(dog):
        print('一条狗[%s]正在吃屎' % dog['type'])
    # 狗的属性特征+属性
    dog1 = {'name': '苑昊',
            'gender': '母',
            'type': '腊肠',
            'jiao': jiao,
            'chi_shi':chi_shi
            }
    return dog1
d1=dog()  #拿到一个字典,里面有函数的内存地址
print(d1)
d1['jiao'](d1)
>>>

{'jiao': <function dog.<locals>.jiao at 0x10207c9d8>, 'type': '腊肠', 'gender': '母', 'name': '苑昊', 'chi_shi': <function dog.<locals>.chi_shi at 0x10207ca60>}
一条狗[苑昊],汪汪汪

 实现了：

字典dog1就是一个明确的对象：包含了狗的属性特征和动作（函数），内嵌动作的明确函数。有属性，有动作，就形成额一条完整的狗。

3.3、新的问题:狗的对象里面只有一条狗，被写死了。解决办法：作为参数传入。一个字典代表一一条狗的完整信息，批量生产字典

def dog(name,gender,type):
    # 狗的动作
    def jiao(dog):
        print('一条狗[%s],汪汪汪' % dog['name'])
    def chi_shi(dog):
        print('一条狗[%s]正在吃屎' % dog['type'])
    # 狗的属性特征+属性
    dog1 = {'name': name,
            'gender': gender,
            'type': type,
            'jiao': jiao,
            'chi_shi':chi_shi
            }
    return dog1
d1=dog('袁浩','母','京巴')  #拿到一个字典,里面有函数的内存地址:包含函数
d2=dog('alex','母','京巴') #一个字典就是一条丰满的对象。每执行一次就生产一条狗。
print(d1)
print(d2)
d1['jiao'](d1)
d2['chi_shi'](d2)

>>>
{'name': '袁浩', 'type': '京巴', 'gender': '母', 'chi_shi': <function dog.<locals>.chi_shi at 0x10217cae8>, 'jiao': <function dog.<locals>.jiao at 0x10217ca60>}
{'name': 'alex', 'type': '京巴', 'gender': '母', 'chi_shi': <function dog.<locals>.chi_shi at 0x10217cbf8>, 'jiao': <function dog.<locals>.jiao at 0x10217cb70>}
一条狗[袁浩],汪汪汪
一条狗[京巴]正在吃屎

3.4、定义初始化函数：init（）完成初始化对象：一条狗函数最终一条活色生香的狗！————————————→   明确的对象：一个独立的，完整的个体！是一个类具体的存在！

　　通过初始化函数把属性和正在进行的动作扎何在一块。

def dog(name,gender,type):
    # 狗的动作
    def jiao(dog):
        print('一条狗[%s],汪汪汪' % dog['name'])
    def chi_shi(dog):
        print('一条狗[%s]正在吃屎' % dog['type'])
    # 狗的属性特征+属性：初始化一条完整的狗！
    def init(name,gender,type):
        dog1 = {'name': name,
                'gender': gender,
                'type': type,
                'jiao': jiao,
                'chi_shi':chi_shi
                }
        return dog1
    return init(name,gender,type)
d1=dog('袁浩','母','京巴')  #拿到一个字典,里面有函数的内存地址:包含函数
d2=dog('alex','母','京巴') #一个字典就是一条丰满的对象。每执行一次就生产一条狗。
print(d1)
print(d2)
d1['jiao'](d1)
d2['chi_shi'](d2)

>>>
{'chi_shi': <function dog.<locals>.chi_shi at 0x10333db70>, 'jiao': <function dog.<locals>.jiao at 0x10333d9d8>, 'name': '袁浩', 'type': '京巴', 'gender': '母'}
{'chi_shi': <function dog.<locals>.chi_shi at 0x10333dae8>, 'jiao': <function dog.<locals>.jiao at 0x10333da60>, 'name': 'alex', 'type': '京巴', 'gender': '母'}
一条狗[袁浩],汪汪汪

二、顺序调整

def school(name,hangye,type,):
    def init(name, hangye, type, ):#初始化函数:该对象的属性特征和动作函数的集合,下面是所有动作函数的明细
        dic_q = {
            'name': name,
            'hangye': hangye,
            '类型': type,
            '考试': kaoshi,
            '招生': zhaoshen
        }
        return dic_q
    def  kaoshi(school2):
        print('一所%s企业,名字是:%s, 正在进行一场考试' %(school2['类型'],school2['name']))
    def  zhaoshen(school2):
        print('一所%s企业,名字是:%s, 正在进行招生' % (school2['类型'], school2['name']))
    return init(name,hangye,type,)
school1=school('老男孩','教育培训','民营',)
print(school1)
school1['招生'](school1)
school1['考试'](school1)

>>>>
{'hangye': '教育培训', '类型': '民营', '考试': <function school.<locals>.kaoshi at 0x10333eae8>, '招生': <function school.<locals>.zhaoshen at 0x10333e9d8>, 'name': '老男孩'}
一所民营企业,名字是:老男孩, 正在进行招生
一所民营企业,名字是:老男孩, 正在进行一场考试

3.5、类

对象：描述性特征+动作的结合。　　　　　　　　　　　　　　　　　　　　　　　　　针对类的一个明确的具体对象

　类：一个种类，具有相同子对象的集合，来分区于其他的种类，共同特征+动作的集合。抽象的概念，抽象共同的特征，共同的动作！

 3.6、面向对象设计和面向对象编程

　　1⃣️、面向对象设计：上面的用def函数的方法实现面向对象的过程就是

　　2⃣️、面向对象编程(object-oriented programming):用定义类+实例/对象的方式去实现面向对象的设计。用class独特的语法实现面向对象设计。

 小结：

　　一门面向对象的语言不一定会强制你写 OO 方面的程序。例如 C++可以被认为“更好 的 C”;而 Java,则要求万物皆类,此外还规定,一个源文件对应一个类定义。

然而,在 Python 中, 类和 OOP 都不是日常编程所必需的。尽管它从一开始设计就是面向对象的,并且结构上支持 OOP,但 Python 没有限定或要求你在你的应用中写 OO 的代码 

　　用面向对象语言写程序，和一个程序的设计是面向对象的，两者是八杆子打不着的两码事。

纯C写的linux kernel事实上比c++/java之类语言搞出来的大多数项目更加面向对象——只是绝大部分人都自以为自己到处瞎写class的面条代码才是面向对象的正统、而死脑筋的linus搞的泛文件抽象不过是过程式思维搞出来的老古董。

五 类和对象

1.什么叫类：类是一种数据结构，就好比一个模型，该模型用来表述一类事物(事物即数据和动作的结合体)，用它来生产真实的物体(实例)。

2.什么叫对象：睁开眼，你看到的一切的事物都是一个个的对象，你可以把对象理解为一个具体的事物(事物即数据和动作的结合体)

(铅笔是对象，人是对象，房子是对象，狗是对象，alex是对象，配齐是对象，元昊是对象)

3.类与对象的关系：对象都是由类产生的，上帝造人，上帝首先有一个造人的模板，这个模板即人的类，然后上帝根据类的定义来生产一个个的人

4.什么叫实例化：由类生产对象的过程叫实例化，类实例化的结果就是一个对象，或者叫做一个实例（实例=对象）

5.1、类的相关知识

　　5.1.1 初识类

在python中声明函数与声明类很相似

声明函数

1 def functionName(args):
2      '函数文档字符串'
3       函数体 

声明类

'''
class 类名:
    '类的文档字符串'
    类体
'''

#我们创建一个类
class Data:
    pass

#用类Data实例化出一个对象d1
d1=Data()

经典类与新式类

大前提：
1.只有在python2中才分新式类和经典类，python3中统一都是新式类
2.新式类和经典类声明的最大不同在于,所有新式类必须继承至少一个父类
3.所有类甭管是否显式声明父类，都有一个默认继承object父类（讲继承时会讲，先记住）
在python2中的区分
经典类：
class 类名:
    pass

经典类：
class 类名(父类):
    pass

在python3中，上述两种定义方式全都是新式类

5.1.2 属性

类是用来描述一类事物，类的对象指的是这一类事物中的一个个体

是事物就要有属性，属性分为

1：数据属性：就是变量

2：函数属性：就是函数，在面向对象里通常称为方法

注意：类和对象均用点来访问自己的属性

#类和对象的属性
'''
1、数据属性
2、函数属性
'''
class Chinese:
    '这是一个中国人的类'
    dang= '共产_党'  #数据属性
    def suiditutan():
        print('朝着墙上就是一口痰')
    def chadui(self):
        print('查到了前面')

print(Chinese.dang) #调用数据属性
Chinese.suiditutan() #调用函数属性
Chinese.chadui('yuanhao')
print(dir(Chinese))#查看该类下面的方法(列表类型,存放该类下所有属性名字,除了系统内置,还包含了:['chadui', 'dang', 'suiditutan'])自定义
print(Chinese.__dict__) #查看类的属性字典:(返回字典:如:{'suiditutan': <function Chinese.suiditutan at 0x10217c9d8>})
print(Chinese.__dict__['dang'])
print(Chinese.__dict__['suiditutan'])#内存地址
print(Chinese.__dict__['suiditutan']())

# 总结:[类名.方法]本质上是通过(类.__dict__sh)调用该方法
# p1=Chinese()   #实例化的过程,相当于函数ruturn返回的结果
# print(p1)

共产_党
朝着墙上就是一口痰
查到了前面
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'chadui', 'dang', 'suiditutan']
{'suiditutan': <function Chinese.suiditutan at 0x10217c9d8>, '__doc__': '这是一个中国人的类', '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, 'dang': '共产_党', '__dict__': <attribute '__dict__' of 'Chinese' objects>, 'chadui': <function Chinese.chadui at 0x10217ca60>}
共产_党
<function Chinese.suiditutan at 0x10217c9d8>
朝着墙上就是一口痰
None

总结：

　　峰式理论：数据属性即变量，类的定义与函数又极其类似，其实可以用函数的作用域来理解类的属性调用

类的数据属性

#定义一个中文人的类,然后在类中定义一个类的属性,政府是共产_党,这样，只要是中文人他们的党永远都是共产_党
#类属性又称为静态变量,或者是静态数据。这些数据是与它们所属的类对象绑定的,不依赖于任何类实例。
#如果你是一位Java或C++程序员,这种类型的数据相当于在一个变量声明前加上static关键字。

class ChinesePeople:
    government='共产_党'

print(ChinesePeople.government)

类的函数属性(又称为方法)

class ChinesePeople:
    government='共产_党'
    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)

ChinesePeople.sui_di_tu_tan()

person1_obj='alex'
ChinesePeople.cha_dui(person1_obj) #带参函数，所以调用时需要传入参数，将'alex'传给self

查看类属性

我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表

类名.__dict__:查出的是一个字典，key为属性名，value为属性值

特殊的类属性

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='共产_党'
    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)

print(ChinesePeople.__name__)# 类C的名字(字符串)
print(ChinesePeople.__doc__)# 类C的文档字符串
print(ChinesePeople.__base__)# 类C的第一个父类(在讲继承时会讲)
print(ChinesePeople.__bases__)# 类C的所有父类构成的元组(在讲继承时会讲)
print(ChinesePeople.__dict__)# 类C的属性
print(ChinesePeople.__module__)# 类C定义所在的模块
print(ChinesePeople.__class__)# 实例C对应的类(仅新式类中)

5.2 对象相关知识

对象是由类实例化而来，类实例化的结果称为一个实例或者称作一个对象

5.2.1 实例化

class Chinese:
    '这是一个中国人的类'
    dang= '共产_党'  #数据属性
    # def __init__(self,name,age,gender): #初始化函数,__init__系统内置,自动把函数的参数传入来。最外层无需参数
    #     dic={
    #         'name':name,
    #         'age':age,
    #         'gender':gender
    #     }
    #     return dic
    def __init__(self,name,age,gender):      #初始化函数定制每一个对象的属性(数据,函数) self就是实例本身
        print('初始化函数开始运行了')            #运行该类,就立即运行__init__函数
        self.mingzi=name     #p1.mingzi=name #运行类的时候会自动找到内置的__init__方法来运行:P1.mingzi=name
        self.nianji=age      #p1.mingzi=name #有一个默认的self参数,之后是数据属性。{'nianji':age,'xingbie':age}
        self.xingbie=gender  #p1.mingzi=name #定义数据属性;self.mingzi 赋予了一个mingzi的数据属性
        print('我结束了')      #最后把P1封装成为一个字典 #最后自动由class自动帮忙return:   self的数据属性。返回的是一个字典属性P1''默认：return None
    def suiditutan():
        print('朝着墙上就是一口痰')
    def chadui(self):
        print('查到了前面')
   # return init(name,age,gender) 无需return,自动运行
#实例化的过程,本质上调用init函数.self就是实例本身
p1=Chinese('袁浩','18','female')  #->>>__init__(self,name,age,gender)实例化过程中,P1会自动传给self
#相当于:p1=Chinese.__init__(p1 ,name,age,gender)
print(Chinese.__dict__)
print(p1)
print(p1.__dict__)      #可以通过__dict__调用显示字典,解释见前面的过程
#p1=Chinese()  #类的运行过程就是一个实例化。


>>>
初始化函数开始运行了
我结束了
{'dang': '共产_党', '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, 'chadui': <function Chinese.chadui at 0x10217cae8>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__doc__': '这是一个中国人的类', 'suiditutan': <function Chinese.suiditutan at 0x10217ca60>, '__init__': <function Chinese.__init__ at 0x10217c9d8>}
<__main__.Chinese object at 0x102180550>
{'xingbie': 'female', 'mingzi': '袁浩', 'nianji': '18'}

5.2.2 构造函数

数据属性：

class Chinese:
    '这是一个中国人的类'
    dang= '

共产_党

' #数据属性 def __init__(self,name,age,gender): self.mingzi=name self.nianji=age self.xingbie=gender def suiditutan(): print('朝着墙上就是一口痰') def chadui(self): print('查到了前面') p1=Chinese('袁浩','18','female') print(Chinese.__dict__) print(p1) print(p1.__dict__['mingzi']) #可以通过__dict__调用显示字典,解释见前面的过程 print(p1.mingzi) #直接通过 . 来调用 #P1这个人里面包含自己的数据属性。

实例的数据属性的作用域

class Chinese:
    '这是一个中国人的类'
    dang= '共产_党'  #数据属性
    def __init__(self,name,age,gender):
        self.mingzi=name
        self.nianji=age
        self.xingbie=gender
    def suiditutan():
        print('朝着墙上就是一口痰')
    def chadui(self):
        print('查到了前面')
p1=Chinese('袁浩','18','female')
#P1这个人里面包含自己的数据属性。
#由一个类产生的一个实例,那么这个实例应该具备这一类该有的数据属性和函数属性。可以通过.来获取数值
print(p1.__dict__) #里面是p1所有的数据集合
print(p1.mingzi)#到实例的属性字典里面去寻找数据
print(p1.dang)#??可以对于不在属性字典里面数据和函数也可以找到。可以用峰氏理论:作用域来解释!
#现在自己位置寻找,找不到的话,在上一级寻找。P1产生的字典是由chinese类帮忙产生的!【p1=Chinese('袁浩','18','female')】
#由Chinese类去触发运行__init__,所以P1的字典是由init产生的,所以作用域就在init函数里面。
#对于:p1.dang首先在init的作用域内找,没找打的情况下,去外一层找。直到找到类的最里一层。

上述的实例化过程，没有做任何事情，啥意思？

类是数据属性和函数属性的结合，描述的是一类事物

这类事物的一个具体表现就是一个实例/对象，比方说中国人是一个类，而你就是这个类的一个实例

你除了有中国人这个数据属性外，还应该有名字，年龄，性别等数据属性

如何为实例定制数据属性，可以使用类的一个内置方法__init__()该方法，在类()实例化是会自动执行

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='共产_党'
    def __init__(self,name,age,gender): #实例化的过程可以简单理解为执行该函数的过程，实例本身会当作参数传递给self（这是默认的步骤）
        self.name=name
        self.age=age
        self.gender=gender

    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)

# person1=ChinesePeople() #会报错
                        #自动执行__init__方法,而这个方法需要参数,
                        # 这些参数应该写在类名后面的括号里,然后由类传
                        #给__init__函数,也就说,传给类的参数就是传给__init__的参数

person1=ChinesePeople('alex',1000,'female')
person2=ChinesePeople('wupeiqi',10000,'female')
person3=ChinesePeople('yuanhao',9000,'female')

print(person1.__dict__)

注意：在说实例化的时候说过，执行类()会自动返回一值，这个值就是实例，而类()会自动执行__init__，所以一定不要在该函数内定义返回值，会冲突（不怕死可以自己测试）

5.2.3、实例的属性：

class Chinese:
    '这是一个中国人的类'
    dang= '共产_党'  #数据属性
    def __init__(self,name,age,gender):
        self.mingzi=name
        self.nianji=age
        self.xingbie=gender
    def suiditutan():
        print('朝着墙上就是一口痰')
    def chadui(self):
        print(self.__dict__)#就是实例化的
        print('%s查到了前面'%self.mingzi)
p1=Chinese('袁浩','18','female')
print(p1.__dict__)      #只有实例的数据属性  谁来实例化,self就是谁!
print(Chinese.__dict__) #数据属性和函数属性都有
Chinese.suiditutan()    #在作用域范围内,可以调用该函数。类调用
Chinese.chadui(p1)      #可以通过参数传递,进行赋值和调用name。完成通过,类的调用,显然太low!

#通过实例调用
#p1.suiditutan()    #首先会在p1的实例字典里面去找该字典,无法找到情况下,去外层找。
# 报错!默认会把p1参数传入。相当于:p1.suiditutan(p1)。传给第一个位置参数 可是函数设置的时候,没有参数传入。所以报错！

p1.chadui()  #可以运行，
#一、谁来实例化,self就是谁,如上述:print(self.__dict__)#就是实例化的打印结果:
    #{'mingzi': '袁浩', 'xingbie': 'female', 'nianji': '18'}
#二、 self做了一个统一。只要执行函数
#所以说实例只有数据属性。函数属性通过类查找

{'xingbie': 'female', 'nianji': '18', 'mingzi': '袁浩'}
{'dang': '共产_党', '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__module__': '__main__', '__init__': <function Chinese.__init__ at 0x10217c9d8>, 'suiditutan': <function Chinese.suiditutan at 0x10217ca60>, '__doc__': '这是一个中国人的类', 'chadui': <function Chinese.chadui at 0x10217cae8>, '__dict__': <attribute '__dict__' of 'Chinese' objects>}
朝着墙上就是一口痰
{'xingbie': 'female', 'nianji': '18', 'mingzi': '袁浩'}
袁浩查到了前面
{'xingbie': 'female', 'nianji': '18', 'mingzi': '袁浩'}
袁浩查到了前面

峰式理论：

1.实例只有数据属性（实例的函数属性严格来说是类的函数属性）

2.del 实例/对象，只是回收了实例的数据属性，函数属性是属于类的，是不会回收。

 实例化的过程实际就是执行__init__的过程，这个函数内部只是为实例本身即self设定了一堆数据(变量)，所以实例只有数据属性

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='共产_党'
    def __init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender

    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)


person1=ChinesePeople('alex',1000,'female')
print(person1.__dict__) #查看实例的属性,发现里面确实只有数据属性
print(person1.name,person1.age,person1.gender) #访问实例的数据属性

那么我们想访问实例的函数属性（其实是类的函数属性），如何实现

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='共产_党'
    def __init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender

    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)


person1=ChinesePeople('alex',1000,'female')
print(person1.__dict__) #查看实例的属性,发现里面确实只有数据属性
print(ChinesePeople.__dict__)#函数属性只存在于类中
ChinesePeople.cha_dui(person1)#我们只能通过类去调用类的函数属性,然后把实例当做变量传递给self

一个小小的改进，就大不一样了

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='共产_党'
    def __init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender

    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    # def cha_dui(self):
    #     print('一个中国人-->%s<--插到了前面' %self)

    def cha_dui(self):
        print('一个中国人-->姓名:%s 年龄:%s 性别:%s<--插到了前面' %(self.name,self.age,self.gender))

    def eat_food(self,food):
        print('%s 正在吃 %s' %(self.name,food))

person1=ChinesePeople('alex',1000,'female')
print(person1.__dict__) #查看实例的属性,发现里面确实只有数据属性
print(ChinesePeople.__dict__)#函数属性只存在于类中
ChinesePeople.cha_dui(person1)#我们只能通过类去调用类的函数属性,然后把实例当做变量传递给self
ChinesePeople.eat_food(person1,'韭菜馅饼')


person1.cha_dui()#其实就是ChinesePeople.cha_dui(person1)
person1.eat_food('飞禽走兽') #本质就是ChinesePeople.eat_food(person1,'飞禽走兽')

总结：

所以说实例只有数据属性。函数方法属性通过类去查找。

一、谁来实例化,self就是谁,如上述:print(self.__dict__)#就是实例化的打印结果:
    #{'mingzi': '袁浩', 'xingbie': 'female', 'nianji': '18'}
二、 self做了一个统一。只要执行函数

　三、实例调用的函数方法，都是到类里面去查找的。

通过数据属性和函数属性的分离，→init的数据属性可以快速生产多个实例，每个实例到类里面去要方法。和每个实例都分别定义数据属性和函数属性要更加的高效，同时省内存！

四、方式类当中定义的方法，默认都有一个参数self，放在函数的第一个位置。通过对象调用的时候，会自动把自己传递给self.

5.2.4 查看实例属性

　　同样是dir和内置__dict__两种方式

5.2.5 特殊实例属性

__class__

__dict__

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='共产_党'
    def __init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender

    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    # def cha_dui(self):
    #     print('一个中国人-->%s<--插到了前面' %self)

    def cha_dui(self):
        print('一个中国人-->姓名:%s 年龄:%s 性别:%s<--插到了前面' %(self.name,self.age,self.gender))

    def eat_food(self,food):
        print('%s 正在吃 %s' %(self.name,food))
person1=ChinesePeople('alex',1000,'female')
print(person1.__class__)
print(ChinesePeople)
person2=person1.__class__('xiaobai',900,'male')
print(person2.name,person2.age,person2.gender)

具体用法

警告：类和对象虽然调用__dict__返回的是一个字典结构，但是千万不要直接修改该字典，会导致你的oop不稳定

5.3 类属性与对象(实例)属性

#类属性又称为静态变量,或者是静态数据。这些数据是与它们所属的类对象绑定的,不依赖于任何类实例。
#如果你是一位Java或C++程序员,这种类型的数据相当于在一个变量声明前加上static关键字。
class ChinesePeople:
    country='China'
    def __init__(self,name):
        self.name=name

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name))

def say_word(self,word):
    print('%s 说 %s' %(self.name,word))

#查看类属性
print(ChinesePeople.country)
#修改类属性
ChinesePeople.country='CHINA'
print(ChinesePeople.country)
#删除类属性
del ChinesePeople.country
#增加类属性
ChinesePeople.Country='China'
ChinesePeople.location='Asia'
print(ChinesePeople.__dict__)

#类的数据属性增删改查与函数属性是一样的
ChinesePeople.say_word=say_word
print(ChinesePeople.__dict__)
alex_obj=ChinesePeople('alex')
ChinesePeople.say_word(alex_obj,'我是一只来自北方的狼狗')

类属性使用

class ChinesePeople:
    country='China'
    def __init__(self,name):
        self.name=name


    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))


p1=ChinesePeople('alex')
print(p1.__dict__)

#查看实例属性
print(p1.name)
# print(p1.age)#不存在于p1的属性字典中,会报错

print(p1.country)#country也不存在于p1的属性字典中,为何可以取到呢?

#删除
# del p1.country #报错,因为p1的属性字典里根本就没有country属性
del p1.name
print(p1.__dict__)


#增加
p1.gender='man'
print(p1.__dict__)

#修改
p1.gender='woman'
print(p1.__dict__)

实例属性的使用

1.其实你会发现，实例化就是 类名()，然后返回的结果是一个对象，加上括号是不是跟函数运行很像，函数运行完了有返回值，是不是很像，没错，就是一样的。

2.函数又作用域的概念，其实类也有作用域的概念，二者一样

3.你可以把class当做最外层的函数，是一个作用域

#定义一个类，只当一个作用域去用，类似于c语言中的结构体
class MyData:
    pass

x=10
y=20
MyData.x=1
MyData.y=2

print(x,y)
print(MyData.x,MyData.y)
print(MyData.x+MyData.y)

4.实例化会自动触发init函数的运行，最后返回一个值即实例，我们要找的实例属性就存放在init函数的局部作用域里

5.类有类的属性字典，就是类的作用域，实例有实例的属性字典，即实例的作用域

6.综上，一个点代表一层作用域，obj.x先从自己的作用域找，自己找不到去外层的类的字典中找，都找不到，就会报错

7.在类中没有使用点的调用，代表调用全局变量啊，这还tm用说，对，你就是不知道

age=1000
class ChinesePeople:
    country='China'
    age=10
    def __init__(self,name):
        self.name=name
        print('初始化函数中调用age',age) #不加点调用就跟类没关系了,找的就是全局的
        print('初始化函数中调用self.age',self.age)

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))

def say_word(self,word):
    print('%s 说 %s' %(self.name,word))

p1=ChinesePeople('alex')
print(p1.age)

#这属于在自己的作用域定义了一个age,类的age并不会变
p1.age=100000000
print(p1.age)
print(ChinesePeople.age)

#不是说实例无函数属性吗,他都是调用的类的,那么我们就为实例添加一个函数属性好了
p1.haha=say_word
print(p1.__dict__)
p1.haha(p1,'英语')#我擦嘞,怎么会这么玩

我就不信玩不懵你

age=10000000000
class ChinesePeople:
    country='China'
    age=10
    def __init__(self,name):
        self.name=name


    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))


p1=ChinesePeople('alex')
p2=ChinesePeople('wupeiqi')
p3=ChinesePeople('yuanhao')

p1.age=1000
p2.age=10000
p3.age=9000
print(p1.age,p2.age,p3.age)
print('全局变量',age)
print('类数据属性',ChinesePeople.age)

#开始玩你了
age=10000000000
class ChinesePeople:
    country='China'
    age=10
    l=[]
    def __init__(self,name):
        self.name=name


    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))


p1=ChinesePeople('alex')
p2=ChinesePeople('wupeiqi')
p3=ChinesePeople('yuanhao')

p1.l.append('p1')
p2.l.append('p2')
p3.l.append('p3')

print(ChinesePeople.l)
print(p1.l,p2.l,p3.l)

换个姿势搞你

 峰式理论 ：类的作用域即函数作用域