day15-面向对象
一.内置类属性
1.什么是内置类属性
声明类的时候系统自动添加的属性（可能是字段也可能是对象属性）
import json
class Person:
"""
说明文档: 人类
num - 人类的数量
name - 人的名字
"""
num = 61
# 注意: 如果设置了__slots__的值，那么当前类的对象就不能使用__dict__属性
# __slots__ = ('name', 'gender', 'age')
def __init__(self, name, gender, age):
self.name = name
self.gender = gender
self.age = age
def eat(self,food):
print('%s在吃%s' % (self.name, food))
# 定制当前类的对象的打印
# 1) 重写__str__方法, 这个方法的返回值就是对应的打印结果(类型必须是字符串)
# def __str__(self):
# # return '姓名:{}, 年龄:{}, 性别:{}'.format(self.name, self.age, self.gender)
# return '<'+str(self.__dict__)[1:-1]+'>'
# 2)重写 __repr__方法，这个方法的返回值就是对应的打印结果(类型必须是字符串)
def __repr__(self):
# return '姓名:{}, 年龄:{}, 性别:{}'.format(self.name, self.age, self.gender)
# <'name': '小明', 'gender': '男', 'age': 18>
return '<' + str(self.__dict__)[1:-1] + '>'
# return 'abc'
p1 = Person('小明', '男', 18)
# 1.__name__
"""
类的字段; 类.__name__ - 获取类的名字(字符串)
"""
print(type(Person), Person)
print(type(int))
print(Person.__name__)
# 2.__doc__
"""
类的字段; 类.__doc__ - 获取类的说明文档
"""
print(Person.__doc__)
print(int.__doc__)
# 3.__class__
"""
对象属性; 对象.__class__ - 获取对象对应的类,返回的是类
(和type(对象)功能一样)
"""
print(p1.__class__)
print(type(p1))
# type1 = p1.__class__
type1 = type(p1)
print(type1.__name__)
p2 = type1('小花', '女', 17)
print(p2.name, p2.gender, p2.age)
# 4.__dict__ (将对象转换成字典)
"""
对象属性; 对象.__dict__ - 将对象所有的属性和对应的值转换成一个字典中的键值对(一个对象对应一个字典)
类的字段; 类.__dict__ - 将类转换成一个字典,字典中的元素是类中所有的字段和对应的值
"""
print(p1.__dict__)
print(Person.__dict__)
print('p1:', p1)
print('p2:', p2)
persons = [p1, p2]
print(persons)
# 5. __module__
"""
类的字段; 类.__module__ - 获取当前类是在哪个模块中声明的(返回的是模块的名字)
"""
print(Person.__module__)
print(bool.__module__)
# 6.__bases__
"""
类的字段; 类.__bases__ - 获取当前类的父类(返回的是一个元祖)
"""
print(Person.__bases__)
# 练习: 将字典转换成对象
with open('data', 'r', encoding='utf-8') as f:
content = json.loads(f.read())
datas = content['data']
class Data:
def __init__(self, dict1: dict):
for key in dict1:
setattr(self, key, dict1[key])
def __repr__(self):
return '<'+str(self.__dict__)[1:-1]+'>'
for item in datas:
data = Data(item)
print(data.name, type(data))
# print(data)
二.私有化
1.访问权限
公开，保护，私有
公开 - 公开的属性和方法在类的内部，外部以及子类能够使用，也能被继承
保护 - 保护的属性和方法在类的内部能够使用，外部不能使用，可以被继承
私有 - 私有的属性和方法只能在类的内部使用，外部不能使用，也不能被继承
2.python中属性和方法的访问权限
python类中所有的属性和方法本质都是公开的；
私有化是假私有化，只是提供程序员这个属性或者方法在外部不能要使用，也不要去继承
怎么私有化：
在需要私有化的属性名或者方法名前加''（注意，不能以结尾）
class Person:
__num = 61
def __init__(self, name, age):
self.name = name
self.__age = age
def eat(self,food='米饭'):
print('%s在吃%s' % (self.name, food))
print('内部:', Person.__num)
self.func1()
def func1(self):
print('函数')
print(self.__age)
self.__func2()
def __func2(self):
print('私有函数')
p1 = Person('xiaoming', 20)
# print(Person.num, p1.name, p1.age)
# p1.eat()
# p1.func1()
# print(Person.__num) # AttributeError: type object 'Person' has no attribute '__num'
# p1.eat()
# print(p1.__age) # AttributeError: 'Person' object has no attribute '__age'
p1.func1()
# p1.__func2() # AttributeError: 'Person' object has no attribute '__func2'
print(p1.__dict__)
print(p1._Person__age)
p1._Person__func2()
三.属性的getter和setter
1.什么是getter和setter
当我们需要在获取属性值之前做点别的事情就需要给这个属性添加getter；
当需要给属性赋值之前做别的事情，就需要给这个属性添加setter
2.给属性添加getter
- 属性命名的时候前面加'_'
- 在@property装饰器的后面声明一个对象方法
a.将属性去掉下划线作为方法名
b.方法除了self以外不需要其他参数
c.函数的返回值就是获取这个属性的时候得到的值 - 在外部使用属性的时候，通过'对象.不带下滑的属性'去使用
注意: 获取属性值的时候，就会自动去调用getter对应的函数
3.给属性添加setter
属性添加setter之前必须先添加getter
1)保证属性名前有''，后面不能有''
2)在@getter名.setter后面声明对象方法
a.将属性去掉下划线作为方法名
b.需要一个self以外的参数
c.不需要返回值
- 在外部使用属性的时候，通过'对象.不带下滑的属性'去使用
注意: 当给属性赋值的时候，实质是调用setter对应的方法
class Person:
count = 0
def __init__(self, name, age, gender):
self.name = name
self._age = age
self._gender = 1
self._week = 3
# 添加getter
@property
def week(self):
if self._week == 0:
return '星期天'
elif 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 '星期六'
@property
def age(self):
Person.count += 1
print('年龄值被访问!!!!')
return self._age
@age.setter
def age(self, value):
print('年龄值被修改！')
if not isinstance(value, int):
raise ValueError
if not 0 <= value <= 200:
raise ValueError
self._age = value
@property
def gender(self):
if self._gender == 1:
return '女'
return '男'
@gender.setter
def gender(self, value):
raise ValueError
p1 = Person('xiaoming', 18, '男')
# p1.age = 1908
# print(p1.age)
# print(p1.name, p1.age, p1.gender, p1.week)
print(p1.week) # 这儿实质是在调用week方法获取返回值
p2 = Person('小花', 20, '女')
p2._week = 5
print(p2.week)
print(p1.age) # p1.age()
age1 = p1.age
print(p2.age) # p2.age()
p1.age = 67 # p1.age(200)
print(p1.gender)
# p1.gender = '男'
# 练习: 写一个矩形类
# 有属性: 长、宽、面积、周长
# 要求从生活的角度看这个矩形
class WriteError(Exception):
def __str__(self):
return '修改只读属性!'
class Rect:
def __init__(self, length, width):
if isinstance(length, int) or isinstance(length, float):
self._length = length
else:
raise ValueError
# self._length = 0
self._width = width
self._area = 0
self.perimeter = 0
@property
def length(self):
return self._length
@length.setter
def length(self, value):
if not (isinstance(value, int) or isinstance(value, float)):
raise ValueError
if value < 0:
raise ValueError
self._length = value
@property
def area(self):
self._area = self._length * self._width
return self._area
@area.setter
def area(self, value):
raise WriteError
r1 = Rect(100, 300)
print(r1.area)
r1.length = 20
print(r1.area)
# r1.area = 100
r2 = Rect('abc', 'ui')
四.类方法和静态方法
1.类中的函数
类中的方法分为：对象方法，类方法和静态方法
1)对象方法
a.怎么声明: 直接声明
b.怎么调用: 用对象来调用
c.特点: 有指向当前对象的self
d.什么时候用：如果实现函数的功能需要用到对象属性，就使用对象方法
2)类方法
a.怎么声明: 声明在@classmethod后面
b.怎么调用: 用类来调用, '类.类方法()'
c.特点: 有自带的参数cls，表示当前类; 这个参数在调用的时候不用传参，系统会自动将当前类传给它；
cls:谁调用就指向谁（如果是对象指向的是对象对应的类）
d.什么时候用: 如果实现函数的功能不需要对象属性，但是需要类的字段, 就使用类方法
3)静态方法
a.怎么声明: 声明在@staticmethod后面
b.怎么调用: 通过类来调用, '类.静态方法()'
c.特点: 没有默认参数
d.什么时候用: 实现函数的功能既不需要类也不需要对象，就使用静态方法
class Person:
num = 61
def __init__(self, name: str, age: int, gender: str):
self.name = name
self.age = age
self.gender = gender
def eat(self, food: str):
# 对象能做的事情，self都能做
print(self.name+'在吃'+food)
@classmethod
def func1(cls):
# 类能做的事情，cls都能做
print(cls)
t = cls('a', 10, 'b')
print('t:',t)
print(cls.num)
print('这是一个类方法!')
@staticmethod
def func2():
print('这是一个静态方法!')
print(Person.num)
def func3(self):
print('这是一个函数!', self.name)
def func4(self):
print(self.age, Person.num)
Person.func1()
print(Person)
# p1 = Person('夏明', 90, '男')
# p1.func1()
Person.func2()
p1 = Person('夏明', 90, '男')
p1.func4()
class Student(Person):
num = 10
@staticmethod
def func2():
print('这是一个静态方法!')
print(Student.num)
print('============1=============')
Student.func1()
Person.func1()
print('=============2============')
Student.func2()
Person.func2()
五.继承
1.什么是继承
继承就是让子类直接拥有父类的属性和方法
子类 - 继承者
父类/超类 - 被继承者
2.怎么继承
1)语法
class 类名(父类1,父类2,..):
说明文档
类的内容
2)说明:
() - 固定写法，如果省略相当于(object)
声明类的时候如果没有写父类，默认继承object（object又叫基类）
父类 - 一个类的父类可以有多个，但是一般情况下只有一个(支持多继承)
class Person:
num = 61
def __init__(self):
print('Person中init')
self.name = '小明'
self.age = 18
self.gender = '男'
self.__a = 10
def eat(self, food='米饭'):
print('{}在吃{}'.format(self.name, food))
@classmethod
def show(cls):
print('人类的数量:%d' % cls.num)
@staticmethod
def func1():
print('人类')
def func2(self):
print('我是'+self.name)
class Student(Person):
num = 10
def __init__(self):
# 在子类中添加对象属性，需要先通过super()去调用父类的__init__来继承父类的对象属性
super().__init__()
print('Student中init')
self.study_id = '001'
self.class1 = 'py1904'
# 添加功能
def study(self):
print(self.name+'在好好学习!')
@staticmethod
def func1():
print('学生')
def func2(self):
print('我是学生!')
# 在子类中可以通过super()可以去调用父类的方法
# 注意: super()只能在对象方法和类方法中使用
super().func2()
stu1 = Student()
print(Student.num)
print(stu1.name, stu1.age, stu1.gender)
stu1.eat()
Student.show()
print(stu1.__dict__)
Student.func1()
stu1.func2()
