面向对象
第1章 什么是面向对象
核心”对象“二字，对象指的是特征与技能的结合体，
基于该思想编写程序就好比在创造一个世界，你就是这个世界的上帝，是一种
上帝式的思维方式
优点：可扩展性强
缺点：编程的复杂度高于面向过程
与面向对象对比优缺点：
面向过程：
核心是”过程“二字，过程指的是解决问题的步骤，即先干什么再干什么
基于该思想编写程序就好比在编写一条流水线，是一种机械式的思维方式
优点：复杂的问题流程化、进而简单化
缺点：可扩展性差
第2章 类与对象
2.1 什么是类？
1、在现实世界中：一定先有对象，后来随着人类文明的发展总结出的类
对象是具体存在的，而类只是一种抽象概念
2、在现实世界中：一定先有对象，后来随着人类文明的发展总结出的类
对象是具体存在的，而类只是一种抽象概念.
3、在程序中,务必保证：先定义类，后调用类来产生对象
现实生活中的对象： 对象1： 特征： school="Oldboy" name="马冬梅" age=18 sex="female" 技能： 学习 选课 对象2： 特征： school="Oldboy" name="甜蜜蜜" age=21 sex="male" 技能： 学习 选课 对象3： 特征： school="Oldboy" name="原石开" age=22 sex="male" 技能： 学习 选课 现实生活中的老男孩学生类： 相同的特征 school="Oldboy" 相同的技能 学习 选课 \'\'\' #1、程序中的类 class OldboyStudent: # 用变量表示特征 school="Oldboy" # 用函数表示技能 def learn(self): print(\'is learning...\') def choose(self): print(\'choose course...\') # print(\'======>\')
# 注意：在定义类的阶段会立刻执行类体内的代码，然后将产生的名字存放于类名称空间中
# print(OldboyStudent.__dict__) # print(OldboyStudent.__dict__[\'school\']) # print(OldboyStudent.__dict__[\'learn\']) # OldboyStudent.__dict__[\'learn\'](123) # print(OldboyStudent.school) # OldboyStudent.__dict__[\'school\'] # print(OldboyStudent.learn) # OldboyStudent.__dict__[\'learn\'] # OldboyStudent.learn(\'xxx\') # OldboyStudent.learn(\'xxx\') OldboyStudent.country=\'China\' OldboyStudent.school=\'偶的博爱\' del OldboyStudent.country print(OldboyStudent.__dict__)
2.2 对象的使用
school=\'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\' 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 learning\' %self.name) def choose(self,course): print(\'%s is choosing %s\' %(self.name,course))
# 调用类---》产生类的对象，该对象也可以称为类的一个实例，调用类的过程也称为类的实例化
stu1=OldboyStudent(\'李三胖\',18,\'male\') #OldboyStudent.__init__(stu1,\'李三胖\',18,\'male\')
# OldboyStudent.country=\'CHINA\' # print(OldboyStudent.country) # print(OldboyStudent.__dict__) # print(stu1.__dict__) # print(stu1.__dict__[\'name\']) # print(stu1.name) # print(stu1.school) # print(school) stu2=OldboyStudent(\'王大炮\',28,\'male\') # print(stu2.__dict__)
# 类内部定义的变量是给所有对象共享，所有对象指向的都是同一个内存地址
# print(id(stu1.school)) # print(id(stu2.school)) # print(id(OldboyStudent.school))
# 类内部定义的函数，类可以使用，但类来用的时候就是一个普通函数，普通函数有几个参就传几个参数
# print(OldboyStudent.learn) # OldboyStudent.learn(123)
# 类内部定义的函数，其实是给对象使用的，而且是绑定给对象用，绑定给不同的对象就是不同的绑定方法
# print(stu1.learn) # print(stu2.learn)
# 绑定方法的特殊之处在于，谁来调用，就会将谁当作第一个参数自动传入
# stu1.learn() # OldboyStudent.learn(stu1) # stu2.learn() # OldboyStudent.learn(stu2) # stu1.choose(\'python\') # stu2.choose(\'linux\')
2.3 一切皆对象
一切皆对象:在python3中统一了类与类型的概念，类即类型
示例：
l=list([1,2,3]) # print(type(l)) # print(type(obj)) l.append(4)
2.4 小练习
\'\'\' 现实中的对象： 人1 特征： 名字=\'刘晴政\' 攻击力=60 生命值=100 技能： 咬 人2 特征： 名字=\'王苗璐\' 攻击力=50 生命值=100 技能： 咬 现实中的人类 相同的特征 相同的技能 咬 \'\'\' \'\'\' 现实中的对象： 狗1 特征： 名字=\'武培其\' 品种="京巴" 攻击力=80 生命值=50 技能： 咬 人2 特征： 名字=\'李杰\' 品种="藏獒" 攻击力=200 生命值=200 技能： 咬 现实中的狗类 相同的特征 相同的技能 咬 \'\'\' class People: def __init__(self, name, aggresivity, life_value=100): self.name = name self.aggresivity = aggresivity self.life_value = life_value def bite(self, enemy): #self=p1 enemy=d1 enemy.life_value-=self.aggresivity print(""" 人[%s] 咬了一口狗 [%s] 狗掉血[%s] 狗还剩血量[%s] """ %(self.name,enemy.name,self.aggresivity,enemy.life_value) ) class Dog: def __init__(self, name, dog_type, aggresivity, life_value): self.name = name self.dog_type = dog_type self.aggresivity = aggresivity self.life_value = life_value def bite(self, enemy): #self = d1 enemy= p1 enemy.life_value-=self.aggresivity print(""" 狗[%s] 咬了一口人 [%s] 人掉血[%s] 人还剩血量[%s] """ %(self.name,enemy.name,self.aggresivity,enemy.life_value) ) p1 = People(\'刘清政\', 60) d1=Dog(\'李杰\',"藏獒",200,200) # p1.bite(d1) d1.bite(p1)
2.5 总结
#一、类的实例化：调用类产生对象的过程称为类的实例化，实例化的结果是一个对象，或称为一个实例
class People: def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def run(self): print(\'%s is running\' %self.name)
#实例化做了三件事
#1、先产生一个空对象
#2、自动触发类内部__init__函数的执行
#3、将空对象，以及调用类括号内传入的参数，一同传给__init__，为对象定制独有的属性
# obj=People(\'egon\',18,\'male\') #People.__init__(obj,\'egon\',18,\'male\')
# 会产生对象的名称空间,如何查看
# print(obj.__dict__)
#二；对象的操作
# print(obj.name) #obj.__dict__ # obj.education=\'哈佛\' # del obj.name # obj.age=19 # print(obj.__dict__)
#三：对象属性的查找顺序:先找对象自己的名称空间----》类的名称空间
class People: x=1 def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def run(self): #self=obj print(\'%s is running\' %self.name) #obj.name obj=People(\'egon\',18,\'male\') #People.__init__(obj,\'egon\',18,\'male\') obj1=People(\'egon1\',18,\'male\') #People.__init__(obj,\'egon\',18,\'male\') obj2=People(\'egon2\',18,\'male\') #People.__init__(obj,\'egon\',18,\'male\')
#1、类的数据属性:是给对象用的，而且直接共享给所有对象用的，内存地址都一样
# print(People.x) # People.x=11111 # print(id(People.x),People.x) # obj.x=\'obj================》\' # print(id(obj.x),obj.x) # print(id(obj1.x),obj1.x) # print(id(obj2.x),obj2.x)
#2、类的函数属性：也是给对象用，但是绑定给对象用的，绑定到不同的对象就是不同的
#绑定方法，内存地址都不一样，但其实只想都是同一个功能
# print(People.run) #<function People.run at 0x00000226E7C78A60> # People.run(123123) # People.run(obj) # print(obj.run) # print(obj1.run) # print(obj2.run)
#四：绑定方法的特殊之处：
#1、 绑定给谁就应该由谁来调用，
#2、谁来调用就会把谁当做第一个参数传入
class People: x=1 def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def run(self): #self=obj print(\'%s is running\' %self.name) #obj.name def f1(): print(\'from f1\') def f2(self): pass obj=People(\'egon\',18,\'male\') #People.__init__(obj,\'egon\',18,\'male\') # obj1=People(\'egon1\',18,\'male\') #People.__init__(obj,\'egon\',18,\'male\') # obj2=People(\'egon2\',18,\'male\') #People.__init__(obj,\'egon\',18,\'male\') # # obj.run() # obj1.run() # obj2.run() # print(People.f1) # People.f1() # print(obj.f1) # obj.f1() #People.f1(obj)
#五：一切皆对象:在python3中统一了类与类型的概念，类即类型
l=list([1,2,3]) # print(type(l)) # print(type(obj)) l.append(4)