一、内置的类属性
内置类属性:python中每个类都拥有内置额类属性
__name__
__doc__
__dict__
__module__
__bases__
class Animal:
"""动物的类"""
pass
class Cat(Animal):
"""说明文档：猫的类"""
number = 0
def __init__(self, name='', color=''):
self.name = name
self.color = color
def run(self):
print('%s在跑' % self.name)
@staticmethod
def shout():
print('喵~')
@classmethod
def get_number(cls):
print('猫的数量：%d' % cls.number)
if __name__ == '__main__':
cat1 = Cat('花花', 'white_black')
"""
1.类.__name__
获取类的名字(字符串)
"""
print(Cat.__name__)
"""
2.类.__doc__
获取类的说明文档
"""
print(Cat.__doc__)
"""
3.类.__dict__ 获取类中所有的类属性和对应的值，以键值对的形式存到字典中
对象.__dict__ 获取对象中所有的对象属性和对应的值，以键值对的形式存到字典中
"""
print(Cat.__dict__)
print(cat1.__dict__)
"""
4.类.__module__ 获取当前类所在的模块的名字
"""
print(Cat.__module__)
"""
5.类.__bases__ 获取当前类的父类
"""
print(Cat.__bases__)
结果：
Cat
说明文档：猫的类
{'__module__': '__main__', '__doc__': '说明文档：猫的类', 'number': 0, '__init__': , 'run': , 'shout': , 'get_number': }
{'name': '花花', 'color': 'white_black'}
__main__
(,)
二、私有化
- python中类中的属性和方法的私有化：直接在属性名或者方法名前加__(命名以'__'开头)
- 属性或者方法私有：在外部不能直接使用,可以在类的内部使用
class Person:
"""人类"""
# 私有的类字段
__number = 10
def __init__(self, name='', age=0):
self.name = name
self.__age = age
def show_age(self):
print('%d' % self.__age)
# 私有的对象方法，只能在类的内部调用
def __run(self):
print('%s is running' % self.name)
@classmethod
def get_number(cls):
# 类的内部可以调用私有化的熟悉或者方法
print(cls.__number)
if __name__ == '__main__':
p1 = Person('张三', 20)
p1.name = 'joo'
# p1.__age = 18
# print(p1.name, p1.__age)
p1.show_age()
Person.get_number()
# 私有化的原理:在内部在私有的名字前加了前缀'_类名'
print(p1.__dict__)
结果：
20
10
{'name': 'joo', '_Person__age': 20}
三、getter 和 setter
属性的假的私有化：声明对象属性的时候在属性名前面加一个下划线'_'来告诉别这个属性不能直接使用。要通过getter和setter来获取属性的值和修改属性的值
- 1.getter:获取属性的值
@property
def 属性名（去掉下划线）(self):
return 返回值
如果在获取对象的某个属性前需要再干点别的事情，就给属性添加getter
- 2.setter:给属性赋值
一个属性必须要有getter才能添加setter
@属性名（去掉下划线）.setter
def 属性名（去掉下划线）(self, 变量名):
给带下划线的属性赋值
如果在给对象的某个属性赋值前要再干点别的事情，就给属性添加setter
class Student:
"""学生类"""
def __init__(self):
# 声明属性的时候前面加一个'_'是为了告诉别人这个属性不要直接使用
self._name = ''
self._score = 0
self._age = 0
# 给属性_name添加getter
@property
def name(self):
return self._name
# 给属性_name添加setter
@name.setter
def name(self, name):
self._name = name
@property
def score(self):
return self._score
@score.setter
def score(self, score):
self._score = score
@property
def age(self):
return str(self._age) + '岁'
@age.setter
def age(self, age):
if age >= 150 or age < 0:
print('输入的年龄存在错误')
# raise 抛出异常：raise 错误类型
# raise ValueError
self._age = None
return
self._age = age
if __name__ == '__main__':
stu1 = Student()
# 不添加getter和setter
# stu1._name = 'joe'
# print(stu1._name)
# 添加getter和setter
stu1.name = 'jerry'
print(stu1.name)
print(stu1.__dict__)
stu1.score = 80
print(stu1.score)
stu1.age = 88
print(stu1.age)
结果：
20
10
{'name': 'joo', '_Person__age': 20}
四、类的继承
子类：继承者
父类(超类)：被继承者
1.继承基础
python中类是可以继承的，并且支持多继承
class 类名(父类列表):
类的说明
属性
方法
说明：python中所有的类默认继承object类(python的基类)
2.能继承哪些内容
继承：直接拥有父类的属性和方法(继承后父类的属性和方法依然存在)
a.对象的属性和方法,类的字段、类的方法和静态方法（私有的继承无意义---不能继承）
b.slots不会被继承
c.getter和setter会被继承
class Person:
"""人类"""
# __slots__ = ('name', 'age', 'sex', '__height', '_face')
def __init__(self):
self.name = ''
self.age = 0
self.sex = '男'
self.__height = 0
self._face = 0
def eat(self):
print('%s:阿姆阿姆' % self.name)
# 类的字段
number = 66
@classmethod
def get_number(cls):
print(cls.number)
@staticmethod
def run():
print('running')
@property
def face(self):
return self._face
@face.setter
def face(self, face):
self._face = face
class Student(Person):
"""学生类"""
pass
if __name__ == '__main__':
stu1 = Student()
stu1.name = 'jo'
print(stu1.name)
stu1.eat()
print(stu1.number)
stu1.get_number()
stu1.run()
print(stu1.__dict__)
stu1.weight = 80
print(stu1.weight)
stu1.face = 50
print(stu1.face)
结果：
jo
jo:阿姆阿姆
66
66
running
{'name': 'jo', 'age': 0, 'sex': '男', '_Person__height': 0, '_face': 0}
80
50