一、复习
1. 什么是类，什么是对象
类就是拥有相同功能相同属性的对象的集合（抽象）
对象是类的实例
2. 类的声明
class 类名:
类的说明文档
类的属性（字段,对象属性）
类中的方法（对象方法、类方法、静态方法）
3. 创建对象
类()
4. 对象方法
- a. 怎么声明: 直接声明在类中的函数
- b. 特点: 自带的参数self，通过对象调用的时候这个参数不用传参，系统会自动将当前对象传给self
- c. 怎么调用: 通过对象来调用
5. init方法和构造方法
6. 属性
1）字段：
a.怎么定义：直接声明在类中的变量
b.怎么使用：通过类去使用(类.字段)
c.什么时候用：如果属性值不会因为对象不同而不一样2）对象属性：
a.怎么定义：声明在init方法中, 以'self.属性 = 值'
b.怎么使用：通过对象去使用
c.什么时候用：如果属性值会因为对象不同而不一样
3）对象属性的增删改查
4）内置类属性
class Person:
# 注意：如果设置字段__slots__的值，那么当前类的对象就不能再使用__dict__属性
# __slots__ = ('name', 'age')
def __init__(self, name):
print('init方法', name)
self.name = name
# 定制，单独打印对象的时候的样式。返回值是什么就打印什么(要求返回值的类型必须是字符串)
# def __str__(self):
# # 打印的谁self就是谁
# return '<'+str(self.__dict__)[1:-1]+'>'
# 定制，打印对象的时候的样式。返回值是什么就打印什么(要求返回值的类型必须是字符串)
def __repr__(self):
return '<' + str(self.__dict__)[1:-1] + '>'
"""
def Person(*args, **kwargs):
对象 = 创建对象
对象.__init__(*args, **kwargs)
return 对象
"""
p1 = Person(name='xiaoming')
p2 = Person(name='小花')
persons = [p1, p2]
print(p1, p2)
print(persons)
二、作业
- 声明个电脑类: 属性:品牌、颜、内存小 方法:打游戏、写代码、看视频
a.创建电脑类的对象，然后通过对象点的方式获取、修改、添加和删除它的属性
b.通过attr相关方法去获取、修改、添加和删除它的属性
import math
from random import randint
class Computer:
def __init__(self, brand, color, ram):
self.brand = brand
self.color = color
self.ram = ram
def play_game(self):
print('打游戏')
def coding(self):
print('写代码')
com1 = Computer('联想', '黑色', 8)
# 增
# com1.size = 15
setattr(com1, 'size', 15)
# 删
# del com1.color
delattr(com1, 'color')
# 改
# com1.brand = '戴尔'
setattr(com1, 'brand', '戴尔')
# 查
print(com1.brand)
print(getattr(com1, 'brand1', '苹果'))
2.声明个人的类和狗的类:
狗的属性:名字、颜色、年龄
狗的方法:叫唤
人的属性:名字、年龄、狗
人的方法:遛狗
a.创建人的对象小明，让他拥有一条狗大黄，然后让小明去遛大黄
class Dog:
def __init__(self, name, age, color='黄色'):
self.name = name
self.color = color
self.age = age
def shout(self):
print('%s:汪汪汪！' % self.name)
class Person:
def __init__(self, name: str, age=0):
self.name = name
self.age = age
self.dog = None
def walk_the_dog(self):
if self.dog:
print('%s牵着%s在散步' % (self.name, self.dog.name))
else:
print('没有狗！遛自己！')
p1 = Person('小明', 18)
p1.dog = Dog('大黄', 3)
p1.walk_the_dog()
3.声明一个圆类，自己确定有哪些属性和方法
class Circle:
def __init__(self, radius):
self.radius = radius
def get_perimeter(self):
return 2*math.pi*self.radius
def get_area(self):
return math.pi * self.radius**2
4.创建一个学生类:
属性:姓名，年龄，学号
方法:答到，展示学生信息
创建一个班级类:
属性:学生，班级名
方法:添加学生，删除学生，点名, 求班上学生的平均年龄
class Student:
def __init__(self, name, age=18):
self.name = name
self.age = age
self.stu_id = '001'
def reply(self):
print('%s，到！' % self.name)
def show(self):
print('姓名:%s,年龄: %d,学号:%s' % (self.name, self.age, self.stu_id))
class Class:
def __init__(self, name: str):
self.students = []
self.name = name
self.id_creater = ('stu'+str(x).zfill(3) for x in range(1, 101))
def add_student(self):
# 输入信息
name = input('姓名:')
age = int(input('年龄:'))
stu_id = next(self.id_creater)
# 创建学生
stu = Student(name, age)
stu.stu_id = stu_id
self.students.append(stu)
def del_student(self, name):
flag = False
for stu in self.students[:]:
if stu.name == name:
flag = True
stu.show()
value = input('是否删除(Y/N):')
if value == 'Y':
self.students.remove(stu)
if not flag:
print('没有找到该学生！')
def call_the_roll(self):
for stu in self.students:
print(stu.name)
if randint(0, 1) == 1:
# 答到
stu.reply()
c1 = Class('py1902')
print('===========添加学生============')
for _ in range(5):
c1.add_student()
print('===========删除学生============')
c1.del_student('小明')
print('===========点名===============')
c1.call_the_roll()
三、属性
本质上，python中所有的属性和方法都是公开，在类的外部可以使用也可以被继承。
1. 私有化 - 让属性和方法只能在类的内部使用，不能在类的外部使用
1）语法：
声明属性或者方法的时候，在属性名或者方法名前加'__'
2）python私有化的原理
python并不能像java一样从访问权限上去限制属性和方法，没有真正的私有属性和方法。
私有化的实质只是在两个下划线开头的名字前加前缀'_类名',导致不能直接通过原名进行访问
class Person:
__num = 30
def __init__(self, name, age=10):
self.name = name
self.age = age
self.__gender = '男'
def eat(self, food='米饭'):
print(Person.__num)
print(self.__gender)
print('%s在吃%s' % (self.name, food))
def __run(self):
print('%s在跑步' % self.name)
p1 = Person('小明')
# print(Person.num)
# print(p1.name)
p1.eat()
# print(Person.__num)
# print(p1.__gender)
# p1.__run()
# print(Person.__num)
print(p1.__dict__, p1._Person__gender)
2. 对象属性的保护: 不要直接访问或者修改对象属性的值，而是通过属性访问器(getter)和修改器(setter)去操作对象属性
需要添加getter或者setter的对象属性，属性命名的时候需要在最前面加'_'。
（添加'_'的目的是为了告诉使用者，这个属性我给它添加了getter或者setter）
-
1）getter - 获取属性的值(间接)
a.语法:
@property
def 函数名(self):
其他语句
return 属性值b.说明:
函数名 - 对应的属性名去掉下划线
属性值 - 和对应的有下划线的属性值有关联c.什么时候用
如果希望在获取某个属性的值之前干点别的事情，就给这个属性添加getter
-
2）setter - 给属性赋值(间接)
想要添加setter必须先添加gettera.语法:
@getter名.setter
def 函数名(self, 参数):
其他语句
self.属性 = 值b.什么时候用
如果在给属性赋值之前干点儿别的事情，就给这个属性添加setter
class Student:
def __init__(self, name1):
self._name = name1
self._week = 1
self._age = 0
self.is_adult = False
@property
def name(self):
return self._name
@property
def week(self):
if self._week == 1:
return '星期一'
elif self._week == 2:
return '星期二'
elif self._week == 3:
return '星期三'
elif self._week == 4:
return '星期四'
elif self._week == 5:
return '星期五'
elif self._week == 6:
return '星期六'
elif self._week == 7:
return '星期天'
@property
def age(self):
return self._age
@age.setter
def age(self, value):
if value >= 18:
self.is_adult = True
else:
self.is_adult = False
self._age = value
# if isinstance(value, int):
# if value < 0 or value > 200:
# print('年龄范围只能在0~200')
# self._age = 0
# else:
# self._age = value
#
# else:
# print('年龄只能是整数！')
# self._age = 0
stu = Student('xiaoming')
# print(stu._name)
print(stu.name) # 通过不带下划线去获取属性的值的时候，本质是在调用属性对应的getter方法,结果是getter的返回值
print(stu.week)
stu.age = 1099323
# stu.age = 'abc'
print('===================')
class Circle:
def __init__(self, r):
self.r = r
self._area = None
@property
def area(self):
return self.r**2*3.1415926
c1 = Circle(2)
print(c1.area)
c1.r = 10
print(c1.area)
# 练习: 声明矩形类，有属性: 长、宽、周长、面积。要求修改长和宽的值的时候，周长和面积自动变化。
# 并且不能修改周长和面积的值(如果主动给周长和面积赋值，程序直接报错)
print('=================练习===================')
class WriteError(Exception):
def __str__(self):
return '尝试修改一个只读的属性!'
class Rect:
def __init__(self, length, width):
self._length = length
self._width = width
self._perimeter = (length + width) * 2
self._area = length * width
# 1.length
@property
def length(self):
return self._length
@length.setter
def length(self, value):
self._length = value
self._perimeter = (self._length + self._width)*2
self._area = self._length * self._width
# 2.width
@property
def width(self):
return self._width
@width.setter
def width(self, value):
self._width = value
self._perimeter = (self._length + self._width) * 2
self._area = self._length * self._width
# 3.perimeter
@property
def perimeter(self):
return self._perimeter
@perimeter.setter
def perimeter(self, value):
print('周长不能直接改修！')
raise WriteError
# 4.area
@property
def area(self):
return self._area
@area.setter
def area(self, value):
print('面积不能直接改修！')
raise WriteError
r1 = Rect(4, 5)
print(r1.perimeter, r1.area)
r1.width = 10
print(r1.perimeter, r1.area)
r1.length = 10
print(r1.perimeter, r1.area)
# r1.perimeter = 300
# print(r1.width, r1.length)
# r1.perimeter = 200
# r1.area = 300
print(r1.perimeter)
r1.perimeter = 10
四、类的方法
1. 类中的方法: 对象方法、类方法、静态方法
1）对象方法
a.怎么声明: 直接声明在类中
b.特点: 有默认参数self；调用的时候不用传参，指向当前对象
c.怎么调用: 通过对象来调用(对象.对象方法())
d.什么时候使用: 如果实现函数的功能，需要使用对象属性，就用对象方法2）类方法
a.怎么声明: 声明函数前添加@classmethod装饰器
b.特点: 有默认参数cls; 调用的时候不用传参, 系统将调用这个方法的类传给它，指向当前类
c.怎么调用: 通过类来调用
d.什么时候使用: 在不需要对象属性的前提下，需要类的字段，就使用类方法
3)静态方法
a.怎么声明:声明前添加@staticmethod装饰器
b.特点: 没有默认参数
c.怎么调用: 通过类来调用
d.什么时候使用: 既不需要对象属性也不需要类的字段，就使用静态方法
class Person:
num = 61
def __init__(self, name='张三', age=0):
self.name = name
self.age = age
# 对象方法
def eat(self, food):
print('%s在吃%s' % (self.name, food))
# 类方法
@classmethod
def show_count(cls):
print('类方法', cls)
# cls：当前类，当前类能做的事情，cls都能做
print(cls.num) # 使用类的字段
p = cls() # 创建对象
print(p)
# 静态方法
@staticmethod
def static():
print('静态方法', Person.num)
五、继承
1. 继承
继承者 - 子类
被继承者 - 父类
继承 - 让子类直接拥有父类的属性和方法
- 1）语法：
class 类名(父类):
类的内容
2. 在子类中添加内容
- 1）在子类中添加字段和方法
直接在子类中声明新的字段和方法 - 2）添加对象属性
在子类中实现__init__方法，并且添加新属性。同时需要通过super().__init__()去调用父类的init方法
补充: 类中的函数的调用过程
先看当前类中是否有这个方法，如果有直接调用自己的方法；没有就去看父类有没有这个方法，如果有就调用父类的方法；如果父类也没有就找父类的父类，以此类推, 如果直到找到object都没有找到这个方法，才报错！
python中所有的类默认都是继承object， object是python中所有类的基类
3. 重写
在子类中重新实现父类的函数; 可以通过super()去调用父类中的方法。
注意: super()不能在静态方法中使用，只能在对象方法和类方法中用
class Person:
num = 61
def __init__(self):
self.name = '张三'
self.age = 0
self.gender = '女'
def eat(self, food):
print('%s在吃%s' % (self.name, food))
@staticmethod
def run():
print('人在跑步')
def func(self):
print('我是一个对象方法', self.name)
class Student(Person):
# 1.添加字段和方法
num = 100
id_pre = 'stu'
@staticmethod
def study():
print('好好学习，天天向上')
# 2.添加对象属性
def __init__(self):
# 调用当前类的父类的__init__方法
super().__init__()
self.stu_id = '001'
self.score = 0
# 3.重写方法
@classmethod
def run(cls):
print('==============')
# super().run()
# cls.__bases__[0].run()
print('学生在跑步！')
print('==============')
def func(self):
super().func()
# self.__class__.__bases__[0]().func()
print('++++++++++')
stu = Student()
# 继承
# print(Student.num)
# print(stu.name, stu.age, stu.gender)
# stu.eat('面条')
# 添加字段和方法
# print(Student.id_pre)
# Student.study()
# 添加对象属性
print(stu.stu_id, stu.score)
print(stu.name)
Student.run()
Person.run()
stu.func()
print(Student.__bases__, Person.__bases__)