一、面向对象基础
1.概念
1.1面向对象的设计思想
面向对象是基于万物皆对象这个哲学观点,在Python中,一切皆对象
举例说明:
案例一:我想要吃大盘鸡
面向过程 面向对象
1.自己去买菜 1.委托一个会砍价的人帮忙去买菜
2.自己择菜 2.委托一个临时工帮忙择菜
3.自己做菜 3.委托一个厨师帮忙做菜
4.自己开始吃 4.自己开始吃
案例二:小明是一个电脑小白,想要配一台电脑,买完零件后需要运到家里,组装完成后打开电脑玩游戏
面向过程 面向对象
1.小明补充电脑知识 1.委托一个懂电脑的朋友(老王)去帮忙买零件
2.小明去买零件 2.委托一个能跑腿的人将零件运送到家里
3.小明把零件带回家里 3.委托一个会组装电脑的人帮小明组装电脑
4.小明组装电脑 4.小明自己打开电脑,开始玩游戏
5.小明开机玩电脑
1.2面向过程和面向对象的区别【面试题】
面向过程
在生活案例中:
一种看待问题的思维方式,在思考问题的时候,着眼于问题是怎样一步一步解决的,然后亲力亲为的去解决问题
在程序中:
1》代码从上而下顺序执行
2》每一模块内部均是由顺序、选择和循环三种基本结构组成
3》程序流程在写程序时就已决定
面向对象
在生活案例中:
也是一种看待问题的思维方式,着眼于找到【一个具有特殊功能的具体个体,然后委托这个个体去做某件事情】,我们把这个个体就叫做对象,一切皆对象
是一种更符合人类思考习惯的思想【懒人思想】,可以将复杂的事情简单化,将程序员从执行者角度转换成了指挥者角度
在程序中:
把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象
1》对同类对象抽象出其共性,形成类
2》类中的大多数数据,只能用本类的方法进行处理
3》程序流程由用户在使用中决定
4》使用面向对象进行开发,先要去找具有所需功能的对象,如果该对象不存在,那么创建一个具有该功能的对象
注意:面向对象只是一种思想,不是一门编程语言,也不会绑定编程语言
面向过程和面向对象的优缺点【面试题】
面向过程:
优点:性能较高,比如单片机,嵌入式开发等一般采用的是面向过程的方式,因为性能是最重要的因素
缺点:没有面向对象易于维护,易于复用,易于扩展,开销比较大,比较消耗资源
面向对象:
优点:易于维护,易于复用,易于扩展,因为面向对象有封装、继承和多态的特征,可以涉及出低耦合的系统,使得系统更加灵活
缺点:性能较低
使用面向对象解决问题,其中的核心内容:类和对象
2.类和对象【重点掌握】
2.1概念
类:一个具有特殊功能的实体的集合【群体】,是抽象的概念
对象:在一个类中,一个具有特殊功能的实体,能够帮忙解决特定的问题【对象也被称为实例】,是具体的存在
两者之间的关系:类用于描述某一类对象的共同特征,而对象则是类的具体存在
问题:先有对象还是先有类?
先有对象,再有类-----》将多个具有共同特征的对象,抽取一个类出来
先有类,再有对象----》在代码中,一般都是先定义类,通过类创建对象,
举例:
类 对象
人 张三、李四、王麻子、杨阳。。。
SuperHero 蝙蝠侠、蜘蛛侠、美国队长。。。
快递 顺丰、圆通、申通、韵达。。。
帮助理解:类也是一种数据类型,只不过是自定义的,用于描述生活中的一些事物,且Python中并没有提供这些类型,跟学过的intAct,float,str。。。。类似,用类创建对象则相当于定义一个类的变量
2.2类的定义
格式:
class 类名():类体# ()可以省略说明:
a.Python中使用class关键字定义类
b.类名只要是一个合法的标识符即可,但是要求:遵循大驼峰命名法【每个单词的首字母大写】 ,如:KeyError,ValueError,NameError,IndexError…….
c.尽量使用单个或多个有意义的单词连接而成,类名中一般不使用下划线
d.通过缩进来体现类体的存在
e.类体一般包含两部分内容:对类的特征描述和行为描述
f.类的包含两部分:类的声明和类的实现
# 1.类是一种数据类型 # a num = 10 # 定义一个变量 print(type(num)) # <class 'int'> # b. v = ValueError() # 创建一个对象 print(type(v)) # <class 'ValueError'> # 2.类的定义 # a.函数的定义 # def func(): # print('ok~~~~~func') # b.类的定义 class Check():# 一般不会在类中printprint('ok~~~~class') class MyClass1():pass class MyClass2:pass # 通过类创建对象,语法:变量 = 类名() m1 = MyClass1() print(m1) m2 = MyClass2() print(m2,id(m2)) m22 = MyClass2() print(m22,id(m22)) ''' 总结:a.类和函数相比,函数必须调用才能执行其中的代码,但是类只要定义完毕,其中的内容就会被加载一遍b.在同一个py文件中,可以定义多个类,但是,如果要实现的需求较为复杂,一般会结合模块使用,在一个模块中定义一个类c.定义类的过程中,类名后面的()可以省略d.创建对象:变量 = 类名(),此处的()不能省略e.同一个类,默认情况下,可以创建无数个对象,每个对象都会被分配不同的地址f.直接输出对象,默认的情况下,会得到一个地址 '''
2.3对象的创建
# 通过类创建对象,语法:变量 = 类名() m1 = MyClass1() print(m1) m2 = MyClass2() print(m2,id(m2)) m22 = MyClass2() print(m22,id(m22))
2.4类的设计
只需要关心3个要素
事物名称(类名):人类(Person)
特征:身高(height)、年龄(age)—————》名词———》变量
行为:跑(run)、打架(fight)———————》动词————》函数
初期学习,通过提炼动名词进行类的提取
# 类的定义 class Person():# 行为描述:函数'''关于selfa.self不是关键字,本质上可以是一个任意的标识符,但是使用self表示自己【self在Java中是关键字】b.类中的函数,默认的情况下,形参列表的第一个参数都是selfc.self表示当前对象,哪个对象调用该函数,则self表示哪个对象d.当调用函数的时候,self无需手动传参,会自动将当前对象传参给self,只需要注意自己定义的参数的传参即可'''def eat(self,food):print(f'eating {food}',f'self:{id(self)}')def run(self):print('running')def show(self):print(f'姓名:{self.name},年龄:{self.age}') # 哪个对象调用show函数,则输出的就是该对象对应的属性 # 创建对象 p1 = Person() print(p1) p2 = Person() print(p2) # 特征描述:变量,语法:对象.属性 = 值 # 对一个对象进行某个特征的描述,可以借助于变量表示,此时的变量也可以被称为属性 p1.name = '张三' p1.age = 20 # print(p1.name,p1.age) p2.name = '李四' p2.age = 18 p2.height = 180 # print(p2.name,p2.age,p2.height) # 对象能且只能执行当前类中的行为【对象调用当前类中的函数】,语法:对象.函数(实参) print('p1:',id(p1)) p1.eat('apple') # p1.run() p1.show() print('p2:',id(p2)) p2.eat('banana') # p2.run() p2.show()
2.5案例一
''' 需求:开学了,王老师让小明,小花,小丽做自我介绍介绍内容包括:姓名,年龄,爱好展示一段才艺 ''' ''' 分析:a.定义教师类和学生类b.教师类特征:姓名行为:让 学生 做自我介绍c.学生类特征:姓名,年龄,爱好行为:做 自我介绍才艺展示 ''' # 第一步:定义类 class Teacher():# self表示老师对象,stu是一个学生对象,只要一个变量表示的是某个对象,则该变量作为对象使用,可以访问对象的属性或类中的函数def let_stu_introduce(self,stu):print(stu)print(f'{self.name}让{stu.name}做自我介绍')# 学生开始执行自己的行为:做自我介绍和才艺战术stu.introduce()stu.show_talent() class Student():def introduce(self):print(f'大家好,我是{self.name},今年{self.age},爱好{self.hobby}')def show_talent(self):if self.name == '小明':print(f'接下来给大家展示一段{self.hobby},我家里有几百头牛,几百头🐏~~~~')elif self.name == '小花':print(f'接下来给大家展示一段{self.hobby},一起来摇摆~~~~')elif self.name == '小丽':print(f'接下来给大家展示一段{self.hobby},看谁在唱歌~~~~') # 第二步:创建对象并描述特征 tea = Teacher() tea.name = '王老师' stu1 = Student() stu1.name = '小明' stu1.age = 18 stu1.hobby = '吹牛逼' stu2 = Student() stu2.name = '小花' stu2.age = 17 stu2.hobby = '跳舞' stu3 = Student() stu3.name = '小丽' stu3.age = 19 stu3.hobby = '唱歌' # 第三步:在类中定义函数并调用函数 tea.let_stu_introduce(stu2) tea.let_stu_introduce(stu1) tea.let_stu_introduce(stu3)
3.构造函数
# 一、构造函数的工作原理 ''' 构造函数:包括__new__和__init__ 在Python中,以__xxx__方式命名的函数,被称为魔术函数/魔术方法,该类函数都是在特定的场景下被自动调用的,无需手动调用__new__:从无到有的过程,表示真正意义上创建对象__init__:初始化的过程,表示将__new__创建出来的对象进行初始化 代码执行顺序:当x = 类名()创建对象的时候,首先会自动调用__new__,创建出来一个对象,且将该对象返回,同时自动将该对象传递给__init__,对该对象完成初始化 ''' class Person():def __new__(cls, *args, **kwargs):print('new~~~~')return super().__new__(cls) # 返回一个对象def __init__(self):print('init~~~~~') p = Person() # 二、构造函数常用的形式 ****** # 1.基本语法 class Person():def __init__(self,name,age):self.name = nameself.age = agedef show(self):print(f'name:{self.name},age:{self.age}') # 一般在创建对象的时候,倾向于将对象创建完有初始状态的【初始状态:创建对象的同时进行特征的描述,或者定义属性】 # 注意:当类中定义了__init__,创建对象的时候,一定要注意参数保持一致 p1 = Person('aaa',10) # p1.name = 'aaa' # p1.age = 10 print(p1.name,p1.age) p2 = Person('bbb',10) # p2.name = 'bbb' # p2.age = 10 print(p2.name,p2.age) p3 = Person('ccc',20) print(p3.name,p3.age) p1.show() p2.show() p3.show() # 2.应用 # 第一步:定义类 class Teacher():def __init__(self,name):self.name = name# self表示老师对象,stu是一个学生对象,只要一个变量表示的是某个对象,则该变量作为对象使用,可以访问对象的属性或类中的函数def let_stu_introduce(self,stu):print(stu)print(f'{self.name}让{stu.name}做自我介绍')# 学生开始执行自己的行为:做自我介绍和才艺战术stu.introduce()stu.show_talent() class Student():def __init__(self,name,age,hobby):self.name = nameself.age = ageself.hobby = hobby def introduce(self):print(f'大家好,我是{self.name},今年{self.age},爱好{self.hobby}')def show_talent(self):if self.name == '小明':print(f'接下来给大家展示一段{self.hobby},我家里有几百头牛,几百头🐏~~~~')elif self.name == '小花':print(f'接下来给大家展示一段{self.hobby},一起来摇摆~~~~')elif self.name == '小丽':print(f'接下来给大家展示一段{self.hobby},看谁在唱歌~~~~') # 第二步:创建对象并描述特征 tea = Teacher('王老师') stu1 = Student('小明',18,'吹牛逼') stu2 = Student('小花',17,'跳舞') stu3 = Student('小丽',19,'唱歌') # 第三步:在类中定义函数并调用函数 tea.let_stu_introduce(stu2) tea.let_stu_introduce(stu1) tea.let_stu_introduce(stu3)
4.属性的动态绑定和限制绑定
# 1.对象属性的动态绑定 # 只要是 对象.属性 = 值 类似这样的语法,都是给对象动态绑定属性,在默认情况下,对于属性的绑定没有任何限制 # class Doctor(): # def __init__(self,name,age): # self.name = name # self.age = age # # doc = Doctor('张大夫',40) # doc.kind = '外科' # print(doc.name,doc.age,doc.kind) # doc.a = 234 # doc.eggw= 45 # 2.限制对象属性的动态绑定 class Doctor():# 用__slots__限制对象属性的动态绑定,定义一个元组,将属性名以字符串的形式书写在元组中,一般是结合实际需求或实际情况确定__slots__ = ('name','age','kind')# 注意:当元组中只有一个元素的时候,要添加逗号# __slots__ = ('name',)def __init__(self,name,age):self.name = nameself.age = age doc = Doctor('张大夫',40) doc.kind = '外科' print(doc.name,doc.age,doc.kind) # doc.a = 234 # AttributeError: 'Doctor' object has no attribute 'a' # doc.eggw= 45
5.类中的属性【重点掌握】
【面试题】简述类属性【类的字段】和实例属性【对象属性,对象的字段】的区别1.定义位置不同:类属性直接定义在类中,只要是动态绑定的属性都是实例属性【在init中或在类的外面直接动态绑定定义】2.访问方式不同:类属性可以通过类名或对象访问,而实例属性只能通过对象访问3.访问优先级不同:当类属性和实例属性重名时,通过对象访问,优先访问的是实例属性4.在内存中出现的时机不同:类属性优先于实例属性出现在内存中,类属性随着类的加载而出现,实例属性是对象创建完毕之后才会出现5.使用场景不同:类属性用于表示多个对象共享的数据,实例属性表示每个对象特有的数据
class Person():# 1.定义位置不同:类属性直接定义在类中,只要是动态绑定的属性都是实例属性【在__init__中或在类的外面直接动态绑定定义】# 注意:只要是 对象.属性 = 值 这样的语法,其实都是实例属性# 类属性place = '地球'num = 66 def __init__(self,name,age):# 实例属性/对象属性self.name = nameself.age = age p1 = Person('赵四',34) # 实例属性/对象属性 p1.height = 170 p1.num = 100 # 2.访问方式不同 # 类属性可以通过类名或对象访问 print(Person.place) print(p1.place) # 而实例属性只能通过对象访问 print(p1.name,p1.age,p1.height) # 3.访问优先级不同 # 当类属性和实例属性重名时,通过对象访问,优先访问的是实例属性 print(p1.num) # 100 实例属性 del p1.num # 实例属性优先被访问,所以此处被删除的是实例属性 print(p1.num) # 66 类属性 # 4.内存中的类属性和实例属性 p2 = Person('小王',18) print(p1.name is p2.name) # False print(p1.place is p2.place) # True # 问题:p1.name和p2.name是否共享同一份内存地址?----》是不同的地址 p1.name = 'Jack' print(p2.name) # 问题:p1.palce和p2.place是否共享同一份内存地址?----》是同一份地址 # p1.place = '火星' # 并不是在修改类属性的值,而是给p1动态绑定了一个place的实例属性 # 如果要修改类属性的值,则格式:类名.类属性 = 值 Person.place = '火星' print(p1.place,p2.place) # 5.使用场景不同:类属性用于表示多个对象共享的数据,实例属性表示每个对象特有的数据 class Student():# 类属性:多个对象公共的数据school_name = '千锋'def __init__(self,name,city):self.name = nameself.city = city stu1 = Student('小明','北京') stu2 = Student('小王','成都') print(stu1.name,stu1.city,stu1.school_name) print(stu2.name,stu2.city,stu2.school_name) Student.school_name = '万锋' print(stu1.name,stu1.city,stu1.school_name) print(stu2.name,stu2.city,stu2.school_name)
5.类中的函数【重点掌握】
class Book():__slots__ = ('name','author')# 1.定义# 1_a.实例函数,特点:第一个形参是self,self表示当前对象def __init__(self,name,author):self.name = nameself.author = author # 3.函数之间相互调用# 3_a.实例函数之间相互调用,格式:self.xxx()def show1(self):print('实例函数~~~~~~')print(f'书名:{self.name},作者:{self.author}')# 在show1中调用show2self.show2()def show2(self):print('show~~~2222') # 1_b.类函数,特点:用@classmethod装饰器装饰,第一个形参是cls,cls是class的缩写,表示当前类@classmethoddef func1(cls):print('类函数~~~~',cls)# 3_b.类函数之间相互调用,格式:cls.xxx()cls.func2() # 3_c.类函数中调用实例函数,格式:先通过cls创建对象,然后再调用# 创建对象,同样会调用__init__,注意参数b = cls('Python机器学习入门与精通','tom')b.show2() @classmethoddef func2(cls):print('func~~~~22222') # 1_c.静态函数,特点:用@staticmethod装饰器装饰,参数没有特别之处@staticmethoddef check1():print('静态函数~~~~~') book = Book("Python疯狂讲义",'jack') # 2.调用 # a.实例函数:只能通过对象调用 book.show1() # b.静态函数和类函数:可以通过类名或对象调用 Book.func1() Book.check1() # book.func1() # book.check1()
6.析构函数
''' 构造函数:__new__和__init__,创建对象并给对象初始化【对象从无到有】 析构函数:__del__,对象被销毁的时候会自动调用的函数, 对象被销毁的时机a.程序执行完毕,对象的声明周期完成b.程序还未执行执行完毕,但是手动销毁对象,语法:del xxx ''' class Animal():def __init__(self):print('init被调用了')def __del__(self):print('del被调用了~~~~~') # 1.程序执行完毕,对象自动被销毁:全局变量 # print('start') # a = Animal() # print('end') ''' start init被调用了 end del被调用了~~~~~ ''' # 2.程序执行完毕,对象自动被销毁:局部变量 # print('start') # def func(): # print('func函数被调用了') # a = Animal() # func() # print('end') ''' start func函数被调用了 init被调用了 del被调用了~~~~~ end ''' # 3.程序未执行完毕,对象被手动销毁 print('start') a = Animal() print('end') del a print('over') ''' start init被调用了 end del被调用了~~~~~ over '''
7.案例二
'''
1.定义一个Number类,其中定义加减乘除的函数,分别计算两个数的相关运算
'''
# 方式一:实例函数
class Number():
def __init__(self,num1,num2):
self.num1 = num1
self.num2 = num2
def add(self):
return self.num1 + self.num2
def sub(self):
return self.num1 - self.num2
def mul(self):
return self.num1 * self.num2
def div(self):
if self.num2 != 0:
return self.num1 / self.num2
num = Number(10,20)
print(num.add(),num.sub(),num.mul(),num.div())# 方式二:类函数
class Number():
@classmethod
def add(cls,num1,num2):
return num1 + num2
@classmethod
def sub(cls,num1,num2):
return num1 - num2
@classmethod
def mul(cls,num1,num2):
return num1 * num2
@classmethod
def div(cls,num1,num2):
if num2 != 0:
return num1 / num2
print(Number.add(10,20),Number.sub(10,20),Number.mul(10,20),Number.div(10,20))# 方式三:静态函数
class Number():
@staticmethod
def add(num1,num2):
return num1 + num2
@staticmethod
def sub(num1,num2):
return num1 - num2
@staticmethod
def mul(num1,num2):
return num1 * num2
@staticmethod
def div(num1,num2):
if num2 != 0:
return num1 / num2
print(Number.add(10,20),Number.sub(10,20),Number.mul(10,20),Number.div(10,20))
'''
2.构造一个圆,求该圆的面积和周长,最后判断一个点和该圆之间的关系
'''
'''
圆类
特征:圆心【本质上就是一个点】和半径
行为:该圆的面积
该圆的周长
判断一个点和该圆之间的关系
点类:
特征:x y
'''
import math
class Point():
__slots__ = ('x','y')
def __init__(self,x,y):
self.x = x
self.y = y
class Circle():
__slots__ = ('circle_center','radius')
# circle_center:圆心,本质上就是一个点,所以此处传参Point类的对象
def __init__(self,circle_center,radius):
self.circle_center = circle_center
self.radius = radius
def length(self):
return round(2 * math.pi * self.radius,3)
def area(self):
return round(math.pi * self.radius ** 2,3)
def judge(self,point):
# self:圆的对象 point:某点的对象
'''
判断某点和圆之间的关系:判断某点到圆心的距离和圆的半径之间的大小关系
两点之间的距离:(x1,y1) (x2,y2) math.sqrt((x1 - x2) ** 2 + (y1- y2) ** 2)圆心的坐标:(self.circle_center.x,self.circle_center.y)
某点的坐标:(point.x,point.y)
'''
distance = math.sqrt((self.circle_center.x - point.x) ** 2 + (self.circle_center.y - point.y) ** 2)
if distance > self.radius:
return '圆外'
elif distance < self.radius:
return '圆内'
else:
return '圆上'# 创建圆心的对象
circle_center = Point(23,18)
# 创建圆的对象
circle = Circle(circle_center,10)
r1 = circle.length()
r2 = circle.area()
print(f'该圆的面积:{r2},周长:{r1}')point = Point(56,19)
print(f'某点和该圆之间的关系为:{circle.judge(point)}')'''
3.定义类,用来描述数字时钟时钟类:
特征:时分秒
行为:走针
'''
import time
class Clock():
__slots__ = ('hour','minutes','seconds')
def __init__(self,hour=0,minutes=0,seconds=0):
self.hour = hour
self.minutes = minutes
self.seconds = seconds
def run(self):
self.seconds += 1 # 17:20:59---->17:21:00
if self.seconds == 60:
self.seconds = 0
self.minutes += 1 # 17:59:59
if self.minutes == 60:
self.minutes = 0
self.hour += 1 # 23:59:59
if self.hour == 24:
self.hour = 0def show(self):
print('%.2d:%.2d:%.2d' % (self.hour,self.minutes,self.seconds))# clock = Clock()
# clock = Clock(17,24,30)# 获取当前时间
t1 = time.localtime()
# print(t1[3],t1[4],t1[5])
clock = Clock(t1[3],t1[4],t1[5])while True:
clock.show()
time.sleep(1)
clock.run()