第十篇:python基础之面向对象初级
一.面向过程和面向对象
1.1什么是面向过程编程？
核心是”过程“二字，过程指的是解决问题的步骤，即先干什么再干什么
基于该思想编写程序就好比在编写一条流水线，是一种机械式的思维方式
优点：复杂的问题流程化、进而简单化
缺点：可扩展性差
1.2什么是面向对象编程?
核心”对象“二字，对象指的是特征与技能的结合体，
基于该思想编写程序就好比在创造一个世界，你就是这个世界的上帝，是一种
上帝式的思维方式
优点：可扩展性强
缺点：编程的复杂度高于面向过程
二.类与对象
2.1什么是类?
对象是特征与技能的结合体，那类就是一系列对象相同的特征与技能的结合体
2.2现实生活中的类与对象与程序世界中的类与对象的区别
在现实世界中：一定先有对象，后来随着人类文明的发展总结出的类,对象是具体存在的，而类只是一种抽象概念。在程序中,务必保证：先定义类，后调用类来产生对象。
现实生活中的对象
现实生活中的类与对象： 对象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" # stu1, "马冬梅", 18, 'female' def __init__(self,name,age,sex): #self=stu1 name= "马冬梅" age=18 sex="female" # print('==========init run=============>') 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...') # 在程序中：必须先定义类 - -----》调用类 - -----》对象 # stu1=OldboyStudent() # stu1.NAME='马冬梅' # stu1.AGE=18 # stu1.SEX="female" # # stu2=OldboyStudent() # stu2.NAME='甜蜜蜜' # stu2.AGE=21 # stu2.SEX="male" # # stu3=OldboyStudent() # stu3.NAME='原石开' # stu3.AGE=22 # stu3.SEX="male" # # print(stu1.NAME,stu1.school) # print(stu2.NAME,stu2.school) # print(stu3.NAME,stu3.school) # 上述产生的三个对象都一样了 # 调用类发生哪些事： #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)
三.类名称空间与对象名称空间及属性查找
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))
3.1调用类---》产生类的对象，该对象也可以称为类的一个实例，调用类的过程也称为类的实例化
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__)
3.2类内部定义的变量是给所有对象共享，所有对象指向的都是同一个内存地址
print(id(stu1.school)) print(id(stu2.school)) print(id(OldboyStudent.school))
3.3类内部定义的函数，类可以使用，但类来用的时候就是一个普通函数，普通函数有几个参就传几个参数
print(OldboyStudent.learn) OldboyStudent.learn(123)
3.4类内部定义的函数，其实是给对象使用的，而且是绑定给对象用，绑定给不同的对象就是不同的绑定方法
print(stu1.learn) print(stu2.learn)
3.5类的两种属性
1. 类的数据属性是所有对象共享的
2. 类的函数属性是绑定给对象用的
四.绑定方法的特殊之处
绑定方法的特殊之处在于，谁来调用，就会将谁当作第一个参数自动传入
school='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' class OldboyStudent: school='oldboy' def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex 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') stu2=OldboyStudent('王大炮',28,'male') stu1.learn() # OldboyStudent.learn(stu1) stu2.learn() # OldboyStudent.learn(stu2) stu1.choose('python') stu2.choose('linux')
五.一切皆对象
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)) stu2=OldboyStudent('王大炮',28,'male') # print(id(stu2)) # print(type(stu2)) # 类与类型是一个概念 # print(stu2) l1=[1,2,3] #l1=list([1,2,3]) # print(type(l1)) # l1.append(4) list.append(l1,4) print(l1) l2=['a','b','c'] l2.append('d') # list.append('d') print(l2) print(int) print(str) print(dict) print(tuple) print(set) print(OldboyStudent)
六.练习
需求1:记录下功能，自动实例化了几次
class Foo: n=0 def __init__(self): Foo.n+=1 # Foo.n=3 obj1=Foo() obj2=Foo() obj3=Foo() print(obj1.__dict__) print(obj2.__dict__) print(obj3.__dict__) print(obj1.n) print(obj2.n) print(obj3.n)
class Bar: n=1111111111 def __init__(self,x): self.x=x obj=Bar(111) # print(obj.__dict__) # print(obj.n) obj.y=2 obj.n=3 print(obj.__dict__) print(obj.n) obj.x=123 del obj.x print(obj.x)
需求2:对象交互之人狗大战
''' 现实中的对象： 人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)
七.继承与派生
八.组合
9.1解决代码冗余的问题
解决类与类之间代码冗余问题有两种解决方案：1、继承 2、组合 1、继承：描述的是类与类之间，什么是什么的关系 2、组合：描述的是类与类之间的关系，是一种什么有什么关系 一个类产生的对象，该对象拥有一个属性，这个属性的值是来自于另外一个类的对象
class Date: def __init__(self,year,mon,day): self.year = year self.mon = mon self.day = day def tell_birth(self): print('出生年月日<%s-%s-%s>' % (self.year, self.mon, self.day)) class OldboyPeople: school = 'oldboy' def __init__(self, name, age, sex): self.name = name self.age = age self.sex = sex class OldboyTeacher(OldboyPeople): def __init__(self,name,age,sex,level,salary): super().__init__(name,age,sex) self.level=level self.salary=salary def change_score(self): print('teacher %s is changing score' %self.name) class Oldboystudent(OldboyPeople): def __init__(self,name,age,sex,course,): super().__init__(name,age,sex,) self.course=course def choose(self): print('student %s choose course' %self.name) tea1=OldboyTeacher('egon',18,'male',9,3.1) date_obj=Date(2000,1,1) # date_obj.tell_birth() tea1.birth=date_obj # print(tea1.birth) # tea1.birth.tell_birth() # tea1.change_score() stu1=Oldboystudent('张三',16,'male','linux') stu1.birth=Date(2002,3,3) stu1.birth.tell_birth()
class OldboyPeople: school = 'oldboy' def __init__(self, name, age, sex,): self.name = name self.age = age self.sex = sex class OldboyTeacher(OldboyPeople): def __init__(self,name,age,sex,level,salary): super().__init__(name,age,sex) self.level=level self.salary=salary self.courses=[] def change_score(self): print('teacher %s is changing score' %self.name) def tell_course_info(self): print(('老师%s 教授的课程信息如下' %self.name).center(50,'=')) for course_obj in self.courses: course_obj.info() class Oldboystudent(OldboyPeople): def __init__(self,name,age,sex): super().__init__(name,age,sex,) self.courses=[] def choose(self): print('student %s choose course' %self.name) def tell_course_info(self): print(('学生%s 学习的课程信息如下' % self.name).center(50, '=')) for course_obj in self.courses: course_obj.info() class Course: def __init__(self,cname,period,price): self.cname=cname self.period=period self.price=price def info(self): print('课程信息<名字：%s 周期：%s 价钱：%s>' %(self.cname,self.period,self.price)) tea1=OldboyTeacher('egon',18,'male',9,3.1) stu1=Oldboystudent('张三',16,'male') python=Course('Python全栈开发','5mons',3000) linux=Course('Linux高级架构师','5mons',2000) go=Course('Go开发工程师','3mons',1000) # # 给老师添加课程 # tea1.courses.append(python) # tea1.courses.append(linux) # print(tea1.courses) # tea1.courses[0].info() # for course_obj in tea1.courses: # course_obj.info() # tea1.tell_course_info() # 给学生添加课程 stu1.courses.append(python) stu1.courses.append(go) stu1.courses.append(linux) stu1.tell_course_info()
