python 之 面向对象基础（定义类、创建对象，名称空间）

第七章面向对象

1、面向过程编程 核心是”过程“二字，过程指的是解决问题的步骤，即先干什么再干什么 基于该思想编写程序就好比在编写一条流水线，是一种机械式的思维方式

优点：复杂的问题流程化、进而简单化 ​ 缺点：可扩展性差

2、面向对象 核心”对象“二字，对象指的是特征（变量）与技能（函数）的结合体，需要创造出一个个的具体存在的对象，程序的执行就是由对象直接交互完成

优点：可扩展性强 ​ 缺点：编程的复杂度高于面向过程

7.1 类

7.11 定义类

1、类：对象是特征与技能的结合体，那类就是一系列对象相似的特征与技能的结合体

2、在现实世界中：一定先有对象，后来随着人类文明的发展总结出的类，对象是具体存在的，而类只是一种抽象概念

3、在程序中,务必保证：先定义类，后调用类来产生对象

class OldboyStudent:
    
    school="Oldboy"                      # 对象们相似的特征
   
    def learn(self):                     # 对象们相似的技能
        print('is learning...')

 

注意：在类定义阶段就会立刻执行类体代码，会产生类的名称空间，将执行类体代码过程中产生的名字存放于类的名称空间

如何查看：

print(OldboyStudent.__dict__)               # 查看类的名称空间，以字典形式显示
​
print(OldboyStudent.__dict__['school'])      # Oldboy
print(OldboyStudent.school)                 # Oldboy
​
print(OldboyStudent.__dict__['learn'])       #<function OldboyStudent.learn at 0x00000146F735BD90>
print(OldboyStudent.learn)                  #<function OldboyStudent.learn at 0x00000146F735BD90>
​
OldboyStudent.__dict__['learn'](123)         # is learning...
OldboyStudent.learn('xxx')                  # is learning...
OldboyStudent.country='China'               #增
OldboyStudent.school='偶的博爱'              #改
del OldboyStudent.country                   #删
​
print(OldboyStudent.__dict__)

7.12 调用类产生对象

class OldboyStudent:
    school="Oldboy"                 # 用变量表示特征
                                 
    def __init__(self,name,age,sex): #self=stu1     name= "马冬梅"   age=18     sex="female"
        self.name=name              # stu1.name = "马冬梅"
        self.age=age                # stu1.age = 18
        self.sex=sex                # stu1.sex = "female"
  
    def learn(self):                #  用函数表示技能
        print('is learning...',self)
​
    def choose(self):
        print('choose course...')

调用类发生哪些事：

1、首先会产生一个空对象stu1 2、会自动触发类内部的__init__函数 3、然后将空对象stu1连同调用类时括号内的参数组成（stu1,"马冬梅",18,'female'）,将这四个参数一起传给__init__函数

初始化创建对象过程中，设置对象特征

stu1=OldboyStudent("马冬梅",18,'female')  # OldboyStudent.__init__(stu1,"马冬梅",18,'female')
stu2=OldboyStudent("甜蜜蜜",21,'male')    # OldboyStudent.__init__(stu2,"甜蜜蜜",21,'male')
stu3=OldboyStudent("原石开",22,'male')
print(stu1.name,stu1.age,stu1.sex)
print(stu2.name,stu2.age,stu2.sex)
print(stu3.name,stu3.age,stu3.sex)

初始化创建对象过程后，设置对象特征

stu1=OldboyStudent()
stu1.NAME='马冬梅'
stu1.AGE=18
stu1.SEX="female"
​
print(stu1.NAME,stu1.school)

调用类---》产生类的对象，该对象也可以称为类的一个实例，调用类的过程也称为类的实例化

7.13 类名称空间和对象名称空间

#school='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
class OldboyStudent:
    #school='oldboy'
    name='axaxaxaxxaaxs'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex    
stu1=OldboyStudent('李三胖',18,'male') #OldboyStudent.__init__(stu1,'李三胖',18,'male')
print(stu1.name)                      #stu1对象的名称空间和类的名称空间都有name时优先自己的  #李三胖         
print(stu1.school)                    #stu1对象的名称空间没有school时，到类的名称空间查找  oldboy
                                    #类的名称空间没有时报错

对象属性的查找顺序 : 先找对象自己的名称空间----》类的名称空间

7.14 绑定方法的特殊之处

class OldboyStudent:
    def learn(self):
        print('%s is learning' %self.name)

1.类内部定义的变量是给所有对象共享，所有对象指向的都是同一个内存地址

print(id(stu1.school))          #   2143429964384
print(id(stu2.school))          #   2143429964384
print(id(OldboyStudent.school))  #   2143429964384

2.类内部定义的函数，类可以使用，但类来用的时候就是一个普通函数，普通函数有几个参就传几个参数

print(OldboyStudent.learn)      #<function OldboyStudent.learn at 0x000001E46CA5CF28>
OldboyStudent.learn(stu1)       #李三胖 is learning

3.类内部定义的函数，其实是给对象使用的，而且是绑定给对象用，绑定给不同的对象就是不同的绑定方法,内存地址都不一样，但其实指向同一个功能

print(stu1.learn)#<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x000001FC28E2BB38>>
print(stu2.learn)#<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x000001FC28E2BB70>>

绑定方法的特殊之处在于：

1、 绑定给谁就应该由谁来调用 2、谁来调用就会把谁当做第一个参数传入，但也可以有其他参数

stu1.learn()        # OldboyStudent.learn(stu1)         #李三胖 is learning
stu2.learn()        # OldboyStudent.learn(stu2)         #王大炮 is learning

7.15 创建对象计数器

class Foo:
    n=0
    def __init__(self):
        Foo.n+=1                # 不要写成 self.n+=1
obj1=Foo()
obj2=Foo()
obj3=Foo()
print(obj1.__dict__)        # {}
print(obj2.__dict__)        # {}
print(obj3.__dict__)        # {}
​
print(obj1.n)               # 3
print(obj2.n)               # 3
print(obj3.n)               # 3