什么是内置类属性
声明类的时候系统自动添加的属性（可能是字段也可能是对象属性）
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))
# 定制当前类的对象的打印
# 1）重写__str__方法,这个方法的返回值就是对应的打印结果（类型必须是字符串）
# def __str__(self):
# return 'hello'
# 2）重写__repr__方法，这个方法的返回值就是对应的打印结果（类型必须是字符串）
def __repr__(self):
return '<' + str(self.__dict__)[1:-1] + '>'
p = Person('小明', 12, 'male')
p.eat('面')
1、__ name __
类的字段；类名.__ name __ -- 获取类的名字（字符串）
print(Person.__ name __)
2、__ doc __
类的字段；类.__ doc __ -- 获取类的说明文档
print(Person.__ doc __ )
对象属性；对象.__ class __ --获取对象对应的类
（和type(对象)功能一样）
print(Person.__ class __)
4、__ dict __ （将对象转换成字典）
对象属性；对象.__ dict __ -- 将对象中的所有的属性和对应的值转换成一个字典中的键值对（一个对象对应一个字典）
类的字段；类. __ dict __ -- 将类转换成一个字典，字典中的元素是类中的所有的字段和对应的值
print(p.__ dict __)
print(Person. __ dict __)
print(p)
5、__ module __
类的字段；类.__ module __ -- 获取当前类是在哪个模块中声明的（返回的是模块的名字）
print(bool.__ module __)
6、__ bases __
类的字段；类.bases -- 获取当前类的父类（返回的是一个元组）
print(Person.bases)
"""--mark.zj--"""
访问权限：公开、保护、私有
公开 -- 公开的属性和方法在类的内部外部能够使用，也能被继承
保护 -- 保护的属性和方法在类的内部能使用，外部不可以使用，可以被继承
私有 -- 私有的属性和方法只能在类的内部使用，外部不能使用，也不能被继承
python中属性和方法的访问权限
python类中所有的属性和方法本质都是公开的；私有化是假的私有化；只是提示程序员这个方法
或属性在外部不要使用，也不要去继承
怎么私有化：在需要私有化的属性名或者方法名前加''(注意：不能以""结尾)
python私有化的原理：在私有化的属性和方法前加了'_类名'
class Person:
__num = 11
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self, food='米饭'):
print(f'{self.name}在吃{food}')
print(Person.__num)
p = Person('小明', 22)
p.eat()
# print(p._Person__num)
什么是getter和setter
当我们需要获取属性值之前做点别的事情就需要给这个属性添加getter
给属性添加getter
1)属性命名的时候前面加'_'
2)在@property装饰器后边声明一个对象方法
a.将属性去掉下划线作为方法名
b.方法除了self以外不需要其他参数
c.函数的返回值就是获取这个属性的时候得到的值
3）在外部使用属性的时候，通过'对象.不带下划线的属性'去使用
注意:获取属性值的时候，就会自动去调用getter对应的函数
给属性添加setter
属性添加setter之前必须先添加getter
1）保证属性名前有'_'
2）在@getter名.setter后面声明对象方法
a.将属性去掉下划线作为方法名
b.需要一个self以外的参数
c.不需要返回值
3）在外部使用属性的时候，通过'对象.不带下划线的属性'去使用
注意：当给属性赋值的时候，实质是调用setter对应的方法
# 练习：写一个矩形类
# 属性：长、宽、面积、周长
# 要求：从生活角度看这个矩形
class Rectangle:
def __init__(self, length, width):
self._length = length
self._width = width
self._perimeter = (length + width) * 2
self._area = length * width
@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 width(self):
return self._width
@width.setter
def width(self, value):
if not(isinstance(value, int) or isinstance(value, float)):
raise ValueError
@property
def perimeter(self):
self._perimeter = self._length * self._width
return self._perimeter
r = Rectangle(2, 3)
# class Person:
# def __init__(self, name, age, sex):
# self.name = name
# self.age = age
# self.sex = sex
# self._week = 0
#
# # 添加getter
# @property
# def week(self):
# if self._week == 0:
# return 'weekend'
# elif self._week == 1:
# return 'Monday'
# elif self._week == 2:
# return 'Tuesday'
# elif self._week == 3:
# return
# @week.setter
# def week(self, value):
# self._week = value
#
#
# p = Person('bob', 12, 'male')
# print(p.__dict__)
# print(p.week) # 这儿实质返回的是
# p.week = 2
类中的函数
类中的方法分为：对象方法、类方法和静态方法
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
@classmethod
def func1(cls):
# 类能做的事，cls都能做
print(cls)
print('这是一个类方法')
@staticmethod
def func2():
print('这是一个静态方法')
print(Person)
Person.func1()
Person.func2()
什么是继承
继承就是让子类直接用用父类的属性和方法
子类 -- 继承者
父类/超类 -- 被继承者
怎么继承
1）语法：
class 类名(父类1, 父类2, ...):
说明文档
类的内容
2）说明：
() -- 固定写法，如果省略相当于(object)
声明类的时候如果没有写父类，默认继承object(object又叫基类)
父类 -- 一个类的父类可以有多个，但是一般情况下只有一个（支持多继承）
