0_类

面向对象介绍与类

面向过程：
        -- 核心是过程二字，过程指的是问题解决的步骤，即先干什么再干什么，基于面向过程去设计程序就好比在设计一条流水线，是一种机械思维方式.

    优点：
        复杂的问题流程化，进而简单化.
    缺点：
        可扩展性差.
    应用：
        脚本程序，比如Linux系统管理脚本，案例：linux 内核，httpd,git.

面向对象：
       -- 核心是对象二字,对象就是特征与技能的结合体，如果把设计程序比喻成创造一个世界，那程序员就是这个世界的上帝，
                                     与面向过程对机械流水的模拟形成鲜明的对比，面向对象更加注重的对现实世界的模拟。

    优点：
        可扩展性强

    缺点：
        程序的设计的复杂度高.

---------------------------------------------------------------------------------------------------------------------------------------------------

类即种类，类别，对象是特征和技能的集合体，那么类就是一系列对象相似的特征与技能的结合体。
            
            在现实世界中先有一个个具体存在的对象 -------> 总结相似之处，现实中的类。

            在程序中：一定要先定义类，后调用类产生对象。
        

            类名首字母大写.....


========    类体的代码在定义阶段就会执行
            查看类的名称空间:
                class_name.__dict__ :存放类内部定义的名字   key:value 存放

---------------------------------------------------------------------------------------------------------------------------------------------------

定义类：

class Student:　　　　　　　　　　　　　　# 类名首字母大写

    school = 'oldboy'                 # 类的数据属性

    def learn(self):                  # 绑定方法：绑定给实例化的对象，self 将自动传值。
        print('is learning ....')


    def eat(self):                    # 绑定方法：绑定给实例化对象,self 将自动传值。
        print('is eating ... ')
    
    print('======>>>')                # 可以加任意代码。

#执行结果：
======>>>
# 定义阶段类内部代码会执行... 

类的属性

class Student:

    school = 'oldboy'                 # 类的数据属性

    def learn(self):                  # 绑定方法：绑定给实例化的对象，self 将自动传值。
        print('is learning ....')


    def eat(self):                    # 绑定方法：绑定给实例化对象,self 将自动传值。
        print('is eating ... ')
    
    print('======>>>')                # 可以加任意代码。

# ---------------------                                                                            
#                                           类访问属性
# ---------------------                                                                            
#                                      类体代码在定义阶段就会执行。


print(Student.__dict__)               # 类的名称空间，存放属性、方法，以key Value 字典结构存入。

print(Student.__dict__['school'])     # 字典方式访问属性,key value 去名称空间里取值。

print(Student.__dict__['eat'])        # 字典的方式访问类的方法。
Student.__dict__['eat']('tony')       # 字典的方式调用类的方法，因为绑定方法有个位置参数self,所以要传值，如果实例化的对象调用self将自动传值了。



print(Student.school)                 # 类名访问数据属性,不以key Value 形式，Python提供用点 . 访问。

Student.eat('good luck ')             # 类调用绑定方法，有self位置参数，需手动传值,       实例化的对象访问self将自动传值,不需要手动传值。 

执行结果:

{'__module__': '__main__', 'school': 'oldboy', 'learn': <function Student.learn at 0x7f3cd46706a8>, '__doc__': None, 'eat': <function Student.eat at 0x7f3cd4670730>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>}
oldboy
<function Student.eat at 0x7f3cd4670730>
is eating ... 
oldboy
is eating ... 

实例化对象：

class Foo:              # 类名首字母大写

    def __init__(self,name,age):        # 初始化方法,每次实例化对象时,自动初始化的数据。
        self.name = name             
        self.age = age
    school = 'oldboy'  　　　　　　　　　　 # 静态属性、静态数据


    def read(self):   　　　　　　　　　　  # 动态属性，这通常是一个功能。同样也是一个绑定方法，绑定给对象的 self 将自动把对象本身传值过来。
        print('come from Foo_read ... ')


# --------------------------------------------------------------------------------------------------------------------

f1 = Foo('tony',29)    # 类实例化一个对象

print(f1.name)         # 对象访问属性
print(f1.age)          # 对象访问属性
f1.read()              # 对象调用动态属性
print(Foo.__dict__)    # 类的名称空间，属性以 key 、value 的方式存放与字典中。 类体的代码在定义阶段就会执行
f1.sex = 'male'        # 给对象动态添加属性：类实例化对象后增加的属性。
print(f1.sex)          # 可以用。


# --------------------------------------------------------------------------------------------------------------------

f2 = Foo('eggtea',28)   # 类实例化第二个对象。 print(f2.name)          # 对象访问属性 print(f2.age)           # 对象访问属性
f2.read()               # 对象调用动态属性
#print(f2.sex)          # 不可用，因为第一个实例化后添加的属性，并非类的属性。


# --------------------------------------------------------------------------------------------------------------------
                        # 此时在给类增加属性或者方法。

Foo.city = 'biejing'    # 类创建完对象后，给类动态添加属性，所有基于此类创建的对象都继承此属性。

print(f1.city)
print(f2.city)

'''     
        类的绑定方法是绑定给实例化对象使用的,所以第一个位置参数是self,自动传值。

        类创建对象后可动态加载属性，单独对象可用此属性。
        
        类创建对象后类动态加载新属性，所有基于此类创建的对象都会继承新属性。
'''


# -------------------------------------------------------------------------------------------------------------------

                        
f1.add = 'work IT '     # 增
print(f1.add)           
del f1.add              # 删
f1.add = 'work market'  # 改
print(f1.add)           # 查



# -------------------------------------------------------------------------------------------------------------------

执行结果：

tony
29
come from Foo_read ... 
{'__module__': '__main__', 'school': 'oldboy', '__dict__': <attribute '__dict__' of 'Foo' objects>, 'read': <function Foo.read at 0x7f3cd4670840>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__init__': <function Foo.__init__ at 0x7f3cd46707b8>}
male
come from Foo_read ... 
biejing
biejing
work IT 
work market

小例子：自动计算实例化对象的个数

class Auto_object_num:
    object_nu = 0           # 静态数据
    def __init__(self,x,y): # 初始化方法,每次实例化对象时,自动初始化的数据。
        self.x = x
        self.y = y
        Auto_object_num.object_nu +=1       # 类调用自己的属性。if self.的话就绑定给一个对象了。

    def learn(self):        # 绑定方法，self 自动传值 绑定给对象使用。
        print('day day learning')

a1 = Auto_object_num(1,2)       # 实例化对象。
a2 = Auto_object_num(3,4)
a3 = Auto_object_num(6,5)
a4 = Auto_object_num(7,8)
a5 = Auto_object_num(9,0)
a6 = Auto_object_num(11,32)


print(a1.object_nu)            # 不管用那个对象访问object_nu 结果都是 6 个。因为创建了6个对象。

a3.learn()
a2.learn()                      # 同一个类所实例化的对象,共享绑定属性、方法。
a1.learn()
print(Auto_object_num.object_nu)    # 类可以调用类内部的属性。
Auto_object_num.learn(a5)           # 类调用类内部绑定给对象的方法时，必须传值：实例化的对象。self的原因。
Auto_object_num.learn('tony')       # 类调用内部绑定给对象的方法时，必须传值，self 位置参数需要一个值，对象是自动将对象本身传值了。类给一个位置参数即可。

执行结果：

6
day day learning
day day learning
day day learning
6
day day learning
day day learning