面向对象

 

一、面向对象编程

1、面向过程编程：

　　核心是'过程'二字，过程指的是解决问题的步奏，即想干什么后干什么基于该思想编写程序就好比在

　　编写一条流水线，是一种机械式的思维方式。

　　

　　优点：复杂的问题流程化，进而简单化

　　缺点：可扩展性差

2、面向对象：

　　核心'对象'二字，对象指的是特征与技能的结合体，基于该思想编写程序就好比在创造一个世界，你就

　　是这个世界的上帝，是一种上帝式的思维方式。

　　

　　优点：可扩展性强

　　缺点：编程的复杂度高于面向过程

　　

二、类

1、类：

　　对象是特征与技能的结合体，类就是一系列对象相同的特征与相同技能的结合体

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

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

2、现实生活中的对象：

　　对象1：

　　　　特征：

　　　　　　school=‘oldboy’

　　　　　　name=‘马冬梅’

　　　　　　age=18

　　　　　　sex=‘female’

　　　　　技能：

　　　　　　学习

　　　　　　选课

　　对象2：

　　　　特征：

　　　　　　school=‘oldboy’

　　　　　　name=‘甜蜜蜜’

　　　　　　age=21

　　　　　　sex=‘male’

　　　　　技能：

　　　　　　学习

　　　　　　选课

　　对象3：

　　　　特征：

　　　　　　school=‘oldboy’

　　　　　　name=‘袁世凯’

　　　　　　age=18

　　　　　　sex=‘male’

　　　　　技能：

　　　　　　学习

　　　　　　选课

现实生活中的老男孩学生类：

　　相同的特征

　　　　school='oldboy'

　　相同的技能

　　　　学习

　　　　选课

3、程序中的类

class OldboyStudent:
    #用变量表示相同的特征
    school='01dboy'

    #用函数表示相同的技能
    def learn(self):
        print('is learning...')


    def choose(self):
        print('choose course....')

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

print(OldboyStudent.__dict__['school'])#01dboy
print(OldboyStudent.__dict__['learn'])#<function OldboyStudent.learn at 0x0000022548708AE8>
OldboyStudent.__dict__['learn'](123)#is learning...

print(OldboyStudent.school)#01dboy相似于 print(OldboyStudent.__dict__['school'])#01dboy
print(OldboyStudent.learn)#<function OldboyStudent.learn at 0x000002C5AA488AE8>
OldboyStudent.learn(123)#is learning...
#点之后是类的属性

#类的增删改查（类可以理解为一个字典）
OldboyStudent.country='china'
OldboyStudent.school='xxxx'
del OldboyStudent.country
print(OldboyStudent.__dict__)

三、调用类、产生程序中的对象

1、定义类

class OldboyStudent:
    #用变量表示特征
    school='oldboy'

    #创建__init__的函数,用来接收对象和位置参数
    #stu1, '马冬梅', 18, 'female'
    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'
        #self就是一个变量名，为了接收第一个位置参数,self代表对象stu1自己

    #用函数表示技能
    def learn(self):
        print('is learn ....')

    def choose(self):
        print('is choose...')

2、调用类产生三个空对象

stu1=OldboyStudent()
stu2=OldboyStudent()
stu3=OldboyStudent()
print(stu1)#<__main__.OldboyStudent object at 0x000001D060D87A20>
print(stu2)#<__main__.OldboyStudent object at 0x000001D060D87A58>
print(stu3)#<__main__.OldboyStudent object at 0x000001D060D87A90>

上述产生的三个对象都一样没有独特的属性，

因此需要在OldboyStudent类内定义一个__init__的函数，该函数会在调用类时自动触发执行

stu1=OldboyStudent( ' 马冬梅' ,18, ' female ' ) # OldboyStudent.__init__(stu1,'马冬梅',18,'female') 
print (stu1.name) # 马冬梅
print (stu1.age) # 18 
print (stu1 .sex) # female


stu2 =OldboyStudent( ' 甜蜜蜜' ,21, ' male ' )
#stu2.NAME = ' 甜蜜蜜' 
#stu2.AGE =21 
#stu2.SEX = ' male ' 
print (stu2.name) # 甜蜜蜜
print (stu2.age) # 21 
print (stu2.sex) # male


stu3 =OldboyStudent( ' 袁世凯' ,23, ' male ' )
 print (stu3.name,stu3.age,stu3.sex)
 # 袁世凯23 male

总结：调用类发生哪些事：

　　1、首先会产生一个空的对象stu1

　　2、会自动触发类内部的__init__函数

　　3、然后将空对象stu1连同调用类时括号内的参数组成（stu1，'马冬梅'，18，'female'），将这四个参数一起传给__init__函数

四、对象的使用

定义类的时候就会产生类的名称空间

class OldboyStudent:
    school='oldboy'

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    #self=stu1
    def learn(self):
        print('%s is learn....'%self.name)

    def choose(self,course):
        print('%s is choosing %s'%(self.name,course))

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

stu1=OldboyStudent('张三',18,'male')#OldboyStudent.__init__('张三',18,'male')

#查看对象的名称空间
print(stu1.__dict__)#{'name': '张三', 'age': 18, 'sex': 'male'}
print(stu1.name)#张三

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

print(OldboyStudent.learn)
#<function OldboyStudent.learn at 0x00000234D9ED8B70>
OldboyStudent.learn(123)
#is learn....

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

类内部定义的函数，其实就是给对象使用的，而且是绑定给对象使用的，绑定给不同的对象就是不同的绑定关系

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

绑定方法的特殊之处就在于，谁来调用，就会将谁当做第一个参数自动传入

stu1.learn()#OldboyStudent.learn(stu1)
#张三 is learn....
stu1.choose('python')#张三 is choosing python

#一切皆对象
class OldboyStudent:
    school='oldboy'

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    #self=stu1
    def learn(self):
        print('%s is learn....'%self.name)

    def choose(self,course):
        print('%s is choosing %s'%(self.name,course))

stu1=OldboyStudent('张三',18,'male')#OldboyStudent.__init__('张三',18,'male')

l1=[1,2,3]
l1.append(4)
print(l1)#[1, 2, 3, 4]

l1=[1,2,3]
list.append(l1,4)#其实类就是类型，list就是一个类
print(l1)#[1, 2, 3, 4]