- 什么是对象:
对象是指现实中的物体或实体
- 什么是面向对象:
把一切看成对象(实体),用各种对象之间的关系来描述事物
- 对象的特征:
1.对象有很多种属性(名词或者形容词)
年龄,姓名,性别
2.对象有很多行为(动作,动词)
学习,吃饭,睡觉,踢球,工作...
- 什么是类:
拥有相同属性和行为的对象分为一组,即一个类
类是用来描述对象的工具,用类可以创建此类的对象(实例)
类和对象示意:
车(类)------------->BYD E6(京A88888) 对象
狗(类)------------->哈士奇(户籍号:00001) 对象
- 类的创建语句class 语句
语法:
class 类名(继承列表):
'''类文档字符串'''
实例方法定义
类变量定义
类方法定义(@classmethod)
静态方法定义(@staticmethod)
作用:
创建一个类
类用于描述对象的行为和属性
类用于创建此类的一个或多个对象(实例)
说明:
类名必须为标识符(与变量名命名规则相同,建议首字母大写)
类名实质上就是变量,它绑定一个类
示例:
class Dog:
'''创建一个Dog类,此类用于描述一种小动物的行为和属性'''
pass
dog1 = Dog()#C创建Dog的第一个实例
print(id(dog1))
dog2 = Dog()#C创建Dog的第二个实例
print(id(dog2))
print('++++++++++++++++++++++++++++++++')
# 对比
lst1 = list() #创建一个空列表
print(id(lst1))
lst2 = list() #创建一个空列表
print(id(lst2))
- 构造函数
构造函数调用表达式;
类名([创建传参列表])
作用:
创建这个类的实例对象,并返回此实例对象的引用关系
说明:
实例有自己的作用域和名字空间,可以为该实例添加实例变量(也叫属性)
实例可以调用类的方法和实例方法
实例可以访问类变量和实例变量
- 实例方法(method)
语法:
class 类名(继承列表):
def 实例方法名(self,形参名1,形参名2.....):
'方法文档字符串'
语句快
作用:
用于描述一个对象的行为,让此类型的全部对象都拥有相同的行为
说明:
实例方法的实质是函数,是定义在类内的函数
实例方法至少有一个形参,第一个形参用来绑定调用这个方法的实例,一般命名为"self"
实例方法的调用语句:
实例.实例方法名(调用传参)
#或
类名.实例方法名(实参.调用传参)
示例:
class Dog:
'''创建一个Dog类,此类用于描述一种小动物的行为和属性'''
def eat(self,food): #self绑定的对象永远是方法的调用者
'''此方法用来描述小狗吃东西的行为'''
print('id为',id(self),'的小狗正在吃',food)
def sleep(self,hour):
print('小狗睡了',hour,'小时')
def play(self,obj):
print('小狗正玩',obj)
dog1 = Dog() #创建一个小狗对象
dog1.eat('骨头')
dog1.sleep(1)
dog1.play("皮球")
dog2 = Dog()
dog2.eat('狗粮') #创建另外一只狗
dog2.sleep(2)
dog2.play('飞盘')
- 实例属性 sttribute(也叫实例变量)
每个实例可以有自己的变量用来保存对象自己的数据,称为实例变量(也叫属性)
语法:
实例.属性名
赋值规则同变量的赋值规则
首次为属性赋值则创建此属性
再次为属性赋值则改变属性的绑定关系
作用:
记录每个对象自身的数据
练习:
定义一个'人'(hunman)类
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()
h2.show_info()
class Human:
def set_info(self,name,age,address = '不详'):
'''此方法用来给人对象添加姓名,年龄,家庭住址'''
self.name = name
self.age= age
self.address = address
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()
h2.show_info()del 语句
可以删除对象(实例)的属性
语法:
del对象.实例变量名
示例:
class Dog:
pass
dog1 = Dog()
dog1.color = '白色'
print(dog1.color) #白色
del dog1.color
print(dog1.color) #AttributeError 属性错误del语句小结:
1)删除变量 del name
2)删除列表的元素 del l[],del l[::2]
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,c,b,m):
self.color = c #颜色
self.brand = b #品牌
self.model = m #型号
# print('初始化方法被调用')
def run(self,spend):
print(self.color,'的',self.brand,self.model,
'正在以',spend,'公里/小时的速度行驶')
a4 = Car("红色",'奥迪','a4')
a4.run(199)
t1 = Car('蓝色','TESLA','Modle S')
t1.run(230)
练习:
写一个Student类,此类创建的对象有3个属性
姓名,年龄,成绩
1)用初始化方法为该类添加上述三个属性
2)添加set_score方法能为对象修改学生成绩
3)添加show_info()方法,打印学生信息
class Student:
def __init__(self,name,age,score= None):
self.name = name
self.age = age
self.score = score
def set_score(self,score):
if 0 <= score <= 100:
self.score = score
def show_info(self):
print(self.name,'今年',self.age,'岁','成绩为:',self.score,'分')
l = []
l.append(Student('小张',20,100))
l.append(Student('小李',18,95))
l.append(Student('小魏',18))
l[2].set_score(78)
for obj in l:
obj.show_info()析构方法:
class 类名(继承列表):
def __del__(self):
语句块
析构方法在对象被销毁时被自动调用
python语言建议不要在对象销毁时做任何事情,因为销毁时间难以确定
示例:
del_method.py
预置实例属性
__dict__属性
__dict__属性绑定一个存储此实例自身变量字典
示例:
class Dog:
pass
dog1 = Dog()
print(dog1.__dict__) #{}
dog1.color = '白色'
print(dog1.__dict__) #{'color':'白色'}
dog1.kinds = '京巴'
print(dog1.__dict__) #{'color':'白色','kinds':'京巴'} __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) 返回对象的类型
练习：
面向对象的综合示例:
有两个人:
属性:
1.姓名:张三,年龄 35岁
2.姓名:李四,年龄 8岁
行为:
1. 教别人学东西 teach
2. 工作赚钱 work
3. 借钱 borrow
事情:
张三 教 李四 学 python
李四 教 张三 学 王者荣耀
张三 上班赚了 1000 元钱
李四 向 张三 借了 200元钱
35 岁的 张三 有钱 800元,他学会的技能:王者荣耀
8 岁的 李四 有钱 200元,他学会的技能:python
class Human:
def __init__(self,name,age):
self.name = name #姓名
self.age = age #年龄
self.money = 0 #钱数为0
self.skill = [] #技能列表
def teach(self,other,skill):
print(self.name,'教',other.name,'学',skill)
other.skill.append(skill) #让other增加技能
def work(self,m):
print(self.name,'上班赚了',m,'元钱')
self.money += m
def borrow(self,other,m):
if other.money > m:
print(self.name,'向',other.name,'借',m,'元钱')
other.money -= m
self.money += m
else:
print(other.name,'没有钱借给',self.name)
def show_info(self):
print(self.age,'岁的',self.name,'有钱',self.money,
'元,他学会的技能为:','、'.join(self.skill))
zhang3 = Human("张三",35)
li4 = Human('李四',8)
#张三 教 李四 学 python
zhang3.teach(li4,'python')
#李四 教 张三 学 王者荣耀
li4.teach(zhang3,'王者荣耀')
#张三 上班赚了 1000 元钱
zhang3.work(1000)
li4.borrow(zhang3,200)
zhang3.show_info()
li4.show_info()- 类变量
类变量是类的属性，此属性属于类，不属于此类的实例
作用：
通常用来存储该类创建对象的共有属性
说明:
类变量可以通过该类直接访问
类变量可以通过类的实例直接访问
类变量可以通过此类的对象的__class__属性，间接访问
示例：
# 此示例示意类变量的定义和用法
class Human:
total_count = 0 #类变量，用来记Human 对象的个数
pass
print(Human.total_count)#访问类变量 0
h1 = Human() #创建一个对象
print(h1.total_count) #借助于此类的实例访问类变量（类属性） 0
h1.total_count = 10000 #为实例添加实例变量 优先访问实例属性
print(h1.total_count) #10000
print(Human.total_count) # 0
#类变量可以通过此类变量的对象的__class__属性间接访问
h1.__class__.total_count +=1
print(Human.total_count)
# Human.total_count +=1
# print(Human.total_count) #1
# 此示例示意用类变量来记录Huamn对象的个数
class Huamn:
total_count = 0
def __init__(self,n):
self.name = n
self.__class__.total_count +=1
print(n,'对象被创建')
def __del__(self):
print(self.name,'对象被销毁')
self.__class__.total_count -=1
l = []
l.append(Huamn('张飞'))
l.append(Huamn('关羽'))
l.append(Huamn('刘备'))
print("当前任务的个数是：",Huamn.total_count)
del l[1]
print("当前任务的个数是：",Huamn.total_count)
- 类的文档字符串：
类的第一个没有赋值给任何变量的字符串为类的文档字符串
类的文档字符串可以通过help()函数查看
类的文档字符串绑定在类的__doc__属性上
- 类的__slots__列表：
作用：
限定一个类创建的实例只能有固定的属性（实例变量）
不允许对象添加列表以外的实例属性（实例变量）
防止用户因错写属性名而发生程序错误
说明：
__slots__属性绑定一个字符串列表
含有__slots__属性的类所创建的二十里对象没有__dic_-属性，因此实例不用字典存储
示例：
#此示例示意类内__slots__列表的用法和作用
class Human:
__slots__ = ['name','age']
def __init__(self,n,a):
self.name = n
self.age = a
def info(self):
print(self.name,"今年",self.age,'岁了')
h1 = Human("校长",8)
h1.info()
h1.Age = 9 #此处会出错
h1.info()
- 类方法@classmethod
类方法是用来描述类的行为的方法,类方法属于类,不属于类的实例对象
说明:
类方法需要先使用@classmethod装饰器定义
类方法至少还有一个形参,第一个形参用于绑定类,约定写为'cls'
类和该了IDE实例都可以调用类方法
类方法不能访问此类创建的对象的实例属性
示例:
class A:
v = 0 #类属性
@classmethod
def get_v(cls):
return cls.v #用cla访问类变量v
@classmethod
def set_v(cls,a):
cls.v = a
print('A.v = ',A.get_v()) #调用类方法得到类变量的值
A.set_v(10000)
print("A.v = ",A.get_v())
- 静态方法 @staticemethod
静态方法是定义在类内部的函数,此函数的作用域是类的内部
说明:
静态方法需要使用@staticemethod装饰器定义
静态方法与普通函数定义相同,不需要传入self实例参数和cls类参数
静态方法只能凭借该类和该类创建的实例调用
练习:
用类来描述一个学生的信息,(可以修改值之前的student类)
class Studet:
...
学生信息有:
姓名,年龄,成绩
将这些学生对象存于列表中,可以任意添加和删除学生
1)打印出学生的个数
2)打印出学生的平均成绩
3)打印出学生的平均年龄
(建议用类内的列表来存储学生的信息)
class Student:
l = []
def __init__(self,n,a,s):
self.name = n
self.age = a
self.score = s
@classmethod
def add(cls):
cls.l.append(Student('xiaoming',16,100))
cls.l.append(Student('xiaoli',13,95))
cls.l.append(Student('moshou',13,99))
@classmethod
def del_student(cls):
del cls.l[0]
@classmethod
def st_count(cls):
return len(cls.l)
@classmethod
def av_score(cls):
# sum = float(0)
# for x in cls.l:
# sum += x.score
# return sum / len(cls.l)
return sum(map(lambda obj:obj.score,cls.l))/ len(cls.l)
@classmethod
def av_age(cls):
# sum = float(0)
# for x in cls.l:
# sum += x.age
# return sum / len(cls.l)
return sum(map(lambda obj:obj.age,cls.l))/ len(cls.l)
Student.add()
print('学生的人数是:',Student.st_count())
print('学生的平均年龄是:',Student.av_age())
pr
289
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
