目录
面向对象编程: Object-Oriented Programing
isinstance(obj,class_or_tuple)
面向对象编程: Object-Oriented Programing
什么是对象:
对象是指现实中的物体或实体
什么是面向对象
把一切看成对象(实例),用各种对象之间的关系来描述事物
对象都有什么特征:
对象有很多属性(名词)
姓名,性别,年龄,...
对象有很多行为(动作,动词)
学习,吃饭,睡觉,工作,...
示意:
车(类) ---->> BYD E6 (京A.88888) (实例,对象)
\ --->> BWM X5 (京B.66666) (对象)
什么是类:
拥有相同属性和行为的对象分为一组,即为一个类
类是用来描述对象的工具,用类可以创建此类的对象(实例)
类的创建语句:
class 语句
语法:
class 类名(继承列表):
'''类文档字符串'''
实例方法定义
类变量定义
类方法定义(@classmethod)
静态方法定义(@staticmethod)
作用:
创建一个类
用于描述对象的行为和属性
用于创建此类的一个或多个同类对象(实例)
说明:
继承列表可以省略,省略继承列表表示类继承自object
类名必须为标识符
类名实质上是变量,它绑定一个类
# 此示例示意定义最简单一个类
class Dog:
'''这个类用于描述一种小动物的行为和属性'''
pass
dog1 = Dog() # 创建一个新的Dog类的对象
print(id(dog1)) # 打印这个对象的id
dog2 = Dog() # 创建另一个Dog类的对象
print(id(dog2))
# 对比
lst1 = list() # 创建一个空列表
print(id(lst1))
lst2 = list() # 创建另一个空列表
print(id(lst2))
lst1.append(100)
lst2.append(200)
# dog1.append(10000) # 只要在类中添加方法就可以实现此操作
# dog2.append(20000)
构造函数:
构造函数调用表达式:
类名([创建传参列表])
作用:
创建这个类的实例对象,并返回此实例对象的引用关系
实例说明:
1.实例有自己的作用域和名字空间,可以为该实例添加实例变量(也叫属性)
2.实例可以调用类方法和实例方法
3.实例可以访问类变量和实例变量
实例方法(method)
语法:
class 类名(继承列表):
def 实例方法(self,形参1,形参2,...)
'''方法的文档字符串'''
语句块
作用:
用于描述一个对象的行为,让此类型的全部对象都拥有相同的行为
说明:
实例方法的实质是函数,是定义在类内的函数
实例方法至少有一个形参,第一个形参代表调用这个方法的实例,一般命名为'self'
实例方法的调用语法:
实例.实例方法名(调用传参):
或
类名.实例方法名(实例,调用传参)
# 此示例示意定义Dog类,并让Dog创建的对象有相同的行为
# 吃,睡,玩
class Dog:
def eat(self, food):
print('id为', id(self), "的小狗正在吃", food)
dog1 = Dog() # 创建一个新的Dog类的对象
print("dog1的id", id(dog1))
dog1.eat('骨头')
dog2 = Dog()
print("dog2的id", id(dog2))
dog2.eat('包子')
# 此示例示意定义Dog类,并可以用help(Dog) 查看类的文档字符串
class Dog:
'''这是自定义的类, 用来描述小动物行为'''
def eat(self, food):
'''描述小狗吃饭的行为...'''
print("小狗正在吃", food)
def sleep(self, hour):
print("小狗睡了", hour, '小时')
def play(self, obj):
print("小狗正在玩", obj)
dog1 = Dog() # 创建一个新的Dog类的对象
dog1.eat('骨头')
dog1.sleep(1)
dog1.play('球')
dog2 = Dog()
dog2.eat('包子')
dog2.sleep(3)
dog2.play('飞盘')
实例属性 attribute (也叫实例变量)
每个实例可以用自己的变量,称为实例变量(也叫属性)
使用语法:
实例.属性名
属性的赋值规则:
1.首次为属性赋值则创建此属性
2.再次为属性赋值则改变属性的绑定关系
作用:
记录每个对象自身的数据
# 此示例示意为每个对象添加实例属性,并通过对象的方法等访问
class Dog:
def infos(self):
print(self.color, '的', self.kinds)
def eat(self, food):
'''
当Dog类型的对象吃东西时,用food 属性记住
此对象吃的是什么
'''
print(self.color, '的', self.kinds,
'正在吃', food)
self.food = food
def food_info(self):
print(self.color, '的', self.kinds,
'上次吃的是', self.food)
dog1 = Dog()
dog1.kinds = '京巴' # 为dog1绑定的Dog对象添加kinds属性
dog1.color = '白色' # 创建color实例变量
dog1.color = '黄色' # 改变实例变量color的绑定关系
dog2 = Dog() # 另一个对象
dog2.kinds = '导盲犬'
dog2.color = '黑色'
dog1.infos()
dog2.infos()
# print(dog1.color, '的', dog1.kinds) # 获取属性的数据
# print(dog2.color, '的', dog2.kinds)
dog1.eat('骨头')
dog1.food_info()
# dog2.food_info() # dog2没有food这个属性,调用出错
练习:
定义一个描述人的信息的类: Human
class Human:
def set_info(self,name,age,address= '不详'):
'''此方法为'人',
添加:姓名,年龄,家庭住址属性'''
# ... 此处自己实现
def show_info(self):
'''此处显示此人的信息'''
# ... 此处自己实现
如:
h1 = Human()
h1.set_info('小张',20,'北京市朝阳区')
h2 = Human()
h2.set_info('小李',18)
h1.show_info() # 小张 今年 20 岁 家庭住址:北京市朝阳区
h2.show_info() # 小李 今年 18 岁 家庭住址:不详
class Human:
def set_info(self, n, a, addr='不详'):
'''此方法为'人', 添加:姓名,年龄,家庭住址属性'''
self.name = n
self.age = a
self.address = addr
def show_info(self):
'''此处显示此人的信息'''
print(self.name, '今年', self.age,'岁 家庭住址:', self.address)
h1 = Human()
h1.set_info('小张', 20, '北京市朝阳区')
h2 = Human()
h2.set_info('小李', 18)
h1.show_info() # 小张 今年 20 岁 家庭住址: 北京市朝阳区
h2.show_info() # 小李 今年 18 岁 家庭住址: 不详
删除属性:
del 语句
语法:
def 对象.属性名
class Dog:
pass
dog1 = Dog()
dog1.color = '白色' # 添加属性
del dog1.color 删除属性
del 语句总结:
1) 删除变量 del a
2) 删除列表中的元素 del L[0]
3) 删除字典中的键 del d['name']
4) 删除对象的属性 del dog1.color
初始化方法:
作用:
对新创建的对象添加属性等初始化操作
语法格式:
class 类名(继承列表):
def __init__(self[,形参列表])
语句块
注: [] 里的内容代表可省略
说明:
1.初始化方法名必须为__init__不可改变
2.初始化方法会在构造函数创建实例后自动调用,且将实例自身通过第一个参数self传入__init__ 方法
3.构造函数的实参将通过 __init__ 方法的参数列表传入到 __init__ 方法中
4.初始化方法内如果需要return语句返回,则只能返回None
class Car:
def __init__(self, clr, brand, model):
self.color = clr # 颜色
self.brand = brand # 品牌
self.model = model # 型号
# print('Car的初始化方法被调用')
def run(self, speed):
print(self.color, '的', self.brand,
self.model, '正在以', speed,
'公里/小时的速度行驶')
c1 = Car('红色', '奥迪', 'A6')
c1.run(200)
c2 = Car('蓝色', 'TESLA', 'Model S')
c2.run(180)
练习:
写一个学生类,用来描述学生信息
要求:
1) 为该类添加初始化方法,实现在创建时自动设置'姓名','年龄','成绩'属性
2) 添加set_score 方法能为对象修改成绩信息,并限制成绩在0~100之间
3) 添加show_info 方法打印学生对象的信息
class Student:
def __init__(......):
....
def set_score(self,score):
....
def show_info(self):
....
s1 = Student('小魏',17,59)
s2.set_score(68)
s1.show_info() # 小魏 今年 17 岁 , 成绩是: 68
class Student:
def __init__(self,name,age,score=0):
self.name = name
self.age = age
self.score = score
def set_score(self,score):
if 0 <= score <= 100:
self.score = score
else:
raise ValueError('值不再相应的范围内')
def show_info(self):
print(self.name,'今年',self.age,'岁','成绩是:',self.score)
s1 = Student('小魏',17,59)
s1.set_score(68)
s1.show_info() # 小魏 今年 17 岁 , 成绩是: 68
析构方法
语法:
class 类名(继承列表):
def __del__(self):
语句块
作用:
通常用来释放此对象占用的资源
说明:
1.析构方法会在对象被销毁时自动调用
2.python语句建议不要在对象销毁时做任何事情,因为对象销毁的时间难以确定
# 此示例示意析构方法的用法
class Car:
def __init__(self, name):
self.name = name
print("汽车", name, '对象被创建')
def __del__(self):
print("汽车", self.name, '对象被销毁')
c1 = Car("BYD E6")
# del c1
# L = []
# L.append(c1)
c1 = None # 让c1变量绑定None
while True:
pass
print("程序结束")
预置的实例属性
__dict__属性
__dict__属性绑定一个存储此实例自身变量的字典
示例:
class Dog:
pass
dog1 = Dog()
print(dog1.__dict__) # {}
dog1.color = "白色"
print(dog1.__dict__) # {'color':'白色'}
__class__属性
__class__属性绑定创建此实例的类(类实例)
作用:
可以借助于此属性来访问创建此实例的类
class Dog:
pass
dog1 = Dog()
print(dog1.__class__)
dog2 = dog1.__class__()
print(dog2.__class__)
用于类的函数:
isinstance(obj,class_or_tuple)
返回这个对象obj是否是类的对象,或者某些类中的一个类对象,
如果是则返回True,否则返回False
type(obj) 返回对象的类
isinstance(3.14,float) # True
isinstance('hello',str) # True
class Dog:
pass
dog1 = Dog()
isinstance(dog1,Dog) # True
综合练习:
有两个人:
1. 姓名:张三
年龄:35岁
2. 姓名:李四
年龄:8岁
行为:
1.教别人学东西 teach
2.工作赚钱 work
3.借钱 borrow
用程序描述如下事情:
张三 教 李四 学 python
李四 教 张三 学 滑冰
张三 上班 赚了 1000元钱
李四 向 张三 借了 200元钱
显示李四的全部信息
显示张三的全部信息
class Human:
def __init__(self, name, age):
self.name = name # 姓名
self.age = age # 年龄
self.money = 0 # 钱数
self.skill = [] # 技能
def teach(self, other, skl):
other.skill.append(skl) # other得到了技能
print(self.name, '正在教', other.name,
'学', skl)
def work(self, money):
self.money += money
print(self.name, '上班赚了', money, '元钱')
def borrow(self, other, money):
'''借钱成功返回True,失败返回False'''
# 先判断other有没有钱借
if other.money > money:
other.money -= money
self.money += money
print(other.name, '借给了',
self.name, money, '元钱')
return True
print(other.name, '没借给', self.name)
return False # 借钱失败
def show_info(self):
print(self.age, "岁的", self.name,
'有技能:', self.skill, ',钱包内的钱数是',
self.money)
zhang3 = Human("张三", 35)
li4 = Human('李四', 8)
zhang3.teach(li4, 'python')
li4.teach(zhang3, '滑冰')
zhang3.work(1000) # 张三 上班 赚了 1000元钱
li4.borrow(zhang3, 200) # 李四 向 张三 借了 200元钱
zhang3.show_info()
li4.show_info()
练习:
将之前的学生信息管理
原代码中用字典来保存每个学生信息,现改为用对象来保存每个学生信息
学生类的存于模块student.py中
# file: student.py
class Student:
def __init__(self, n, a, s):
.....
.....
# student_info.py
from student import Student # 导入Student类