内置函数属性
1.声明是内置类属性
声明类的时候系统自动添加的属性（可能是字段也可能是对象属性）
class Person:
"""
说明文档：人类
num：人的数量
"""
num = 61
def __init__(self,name,gender,age):
self.name = name
self.gender = gender
self.age = age
def eat(self,food):
print('{}在吃{}'.format(self.name,food))
定制当前类的对象的打印
1）重写str方法，这个方法的返回值就是对应的打印结果（类型必须是字符串）,只能单独打印
def __str__(self):
return str(self.__dict__)
2)重写repr方法,这个方法的返回值就是对应的打印结果（类型必须是字符串）,可以打印列表等
def __repr__(self):
return str(self.__dict__)
p1=Person('小明','男',18)
1.name
类的字段；类名.name - 获取类的名字（字符串）
print(type(Person),Person) # <class 'type'> <class '__main__.Person'>
print(type(int)) # <class 'type'>
print(Person.__name__) # Person
2.doc
获取类的说明文档
print(Person.__doc__)
3.class
对象属性；对象.class - 获取对象对应的类，返回的是类
(和type（对象）功能一样)
print(p1.__class__) # <class '__main__.Person'>
print(type(p1)) # <class '__main__.Person'>
type1 = p1.__class__ # 拿到的是p1这个对象的类
print(type1.__name__) # Person
4.dict（将对象转换成字典）
对象属性：对象.dict - 将对象中所有的属性和对应的值转换成一个字典中的键值对（一个对象对应一个字典）
类的字段：类.dict - 将类转换成一个字典，字典中的元素是类中所有的字段和对应的值
注意：slots和dict不可同时使用，会报错，一般我们选择放弃slots
print(p1.__dict__) # {'name': '小明', 'gender': '男', 'age': 18}
print(Person.__dict__) # {'__module__': '__main__', '__doc__': '\n 说明文档：人类\n num：人的数量\n ', 'num': 61,
# '__init__': <function Person.__init__ at 0x00000254F09A4488>, 'eat': <function Person.eat at 0x00000254F09A4510>,
# '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
print([p1,p1])
5.module
类的字段；类.module - 获取当前类是在哪个模块中声明的（返回的是模块的名字）
6.bases
类的字段：类.bases - 获取当前类的父类（返回的是一个元祖）
print(Person.__bases__) # (<class 'object'>,)
练习：将字典转换成对象
class Data:
# 将字典作为属性添加，然后将键值对添加为属性
def __init__(self,dict1:dict):
for key in dict1:
setattr(self,key,dict1[key])
def __repr__(self):
return str(self.__dict__)
私有化
1.访问权限：公开、保护、私有
公开 - 公开的属性和方法在类的内部、外部狗能使用也能被继承
保护 - 保护的属性和方法在类的内部能够使用，外部不能使用，但是可以被继承
私有 - 私有的属性和方法只能在类的内部使用，外部不能使用，也不能被继承
2.python中属性和方法的访问权限
python类中所有的属性和方法本质都是公开的；
私有化是假私有化，只是提示程序员这个属性或者方法在外部不能使用，也不要去继承
怎么私有化：在需要私有化的属性名或者方法名前加''(注意：不能以结尾)
python私有化的原理：在私有的属性和方法前加了'_类名'
class Person:
num = 61
__num1 = 54 # 私有化
def __init__(self, name, age):
self.name = name
self.__age = age
def eat(self, food='米饭'):
print('{}在吃{}'.format(self.name, food))
print('内部：', Person.num) # 内部： 61
print('内部：', Person.__num1) # 内部： 54
p1 = Person('小明', 21)
print(Person.num) # 61
p1.eat() # 小明在吃米饭
# print(Person.__num) # AttributeError: type object 'Person' has no attribute '__num'
# 私有化属性的获取（实质上的私有就是换了个名字，所以无法直接取到）
print(p1.__dict__) # {'name': '小明', '_Person__age': 21}
print(p1._Person__age) # 21
属性的getter和setter
1.什么是getter和setter
当我们需要在获取属性值之前做点别的事情就需要给这个属性添加getter；
当需要给属性赋值之前做别的事情就需要给这个属性添加setter
2.给属性添加getter
1)属性命名的时候前面加一个下划线（对类本身无影响，主要是标识这个属性要添加getter或者setter）
2)在装饰器@property的后面声明一个对象方法
a.将属性去掉下划线作为方法名
b.方法除了self以外不需要其他参数
c.函数的返回值就是获取这个属性的时候得到的值
3)在外部使用属性的时候，通过'对象，不带下划线的'
注意：获取属性值的时候，就会自动去调用getter对应的函数
可以指定返回值、做提醒、做警告等
3.给属性添加setter
属性添加setter之前必须先添加getter
1)保证属性名前有一个下划线
2)在装饰器@属性名.setter的后面声明一个对象方法
a.将属性去掉下划线作为方法名
b.需要一个self以为的参数
c.不需要返回值
3)在外部使用属性的时候，通过'对象，不带下划线的属性’去使用
注意：当给属性赋值的时候，实质是调用setter对应的方法
可以修改属性，结合if raise 可以做判断，或者变成只读（一旦检测到修改操作就报错raise）
class Person:
def __init__(self, name, age, gender):
self.name = name
self._age = age
self.gender = gender
self._week = 0
# 添加getter
@property
def week(self):
if self._week == 0:
return '星期天'
else:
return '不是星期天'
@property
def age(self):
print('年龄值被访问！！！')
return self._age
# 添加setter
@age.setter
def age(self, value):
print('年龄被修改')
self._age = value
# p1 = Person('小明', 18, '男')
# print(p1.week) # 星期天 - 这儿实质实质爱调用week方法获得返回值
# print(p1.age) # 年龄值被访问！！！ 18
# p1.age = 20 # 年龄被修改
# print(p1.age) # 年龄值被访问！！！ 20
练习：写一个矩形类
有属性：长、宽、面积、周长
要求：从生活的角度看这个矩形
class Rec:
def __init__(self,length,wide):
self._length = length
self._wide = wide
self._area = length*wide
self.per = 2*(length+wide)
@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._wide
return self._area
@area.setter
def area(self,value):
print('休想修改面积')
raise ValueError
r1 = Rec(3, 4)
# r1.area = 12
r1.length = 14
print(r1.area)
类方法和静态方法
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, age, gender):
self.name = name
self.age = age
self.gender = gender
def eat(self,food):
# 对象能做的事情，self都能做
print(self.name+'在吃'+food)
@classmethod
def func1(cls):
# 类能做的事情，cls都能做
print('这是一个类方法',cls.num)
@staticmethod
def func2():
print('这是一个静态方法')
Person.func1() # 这是一个类方法 61
Person.func2() # 这是一个静态方法
继承
1.什么是继承
继承就是让子类直接拥有父类的属性和方法
子类 - 继承者
父类/超类 - 被继承者
2.怎么继承
1)语法
class 类名（父类1，父类2，父类...）:
说明文档
类的内容
2)说明：
() - 固定写法，如果省略，相当于(object)
声明类的时候如果没有写父类，默认继承object(object又叫基类)
父类 - 一个类的父类可以有一个或多个，但是一般情况下只有一个
class Person:
num = 61
def __init__(self,name, age, gender):
self.name = name
self.age = age
self.gender = gender
def eat(self,food):
print('{}在吃{}'.format(self.name,food))
def func1(self):
print('这是父类')
def func2(self):
print('父类的功能2')
@classmethod
def show(cls):
print('人类的数量{}'.format(cls.num))
class Student(Person):
num = 10
def __init__(self,name, age, gender):
# 在子类中添加对象属性，需要先通过super（）去调用父类的__init__来继承父类
super().__init__(name, age, gender)
self.id = '001'
self.class1 = 'py1904'
# 添加功能
def study(self):
print(self.name + '在认真敲代码')
# 功能重写
def func1(self):
print('重写覆盖父类')
def func2(self):
print('子类的功能2')
# 在子类中可以通过super（）可以去调用父类的方法
# 注意：super（）只能在对象方法和类方法中使用，因为静态方法找不到父类
super().func2()
s1 = Student('小米',32,'女')
s1.eat('菠萝')
s1.func2()
