一、面向对象编程
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]