面向对象
一、内置内属性
1.什么是内置内属性
声明类的时候系统自动添加的属性（可能是字段也可能是字段属性）
class Person:
"""
说明文档：人类
num ：人的数量
"""
num = 61
# 注意：如果设置了__slots__的值，那么当前类的随想就不能使用__dict__属性
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 '<' + str(self.__dict__)[1:-1] + '>'
# 2)重写__repr__方法
def __repr__(self):
return '<' + str(self.__dict__)[1:-1] + '>'
p1 = Person('小明', '男', 18
# 1.__name__
"""
类的字段；类名.__name__ - 获取类的名字（字符串）
"""
# print(type(Person), Person)
# print(Person.__name__)
# 2.__doc__
"""
类的字段；类.__doc__ - 获取类的说明文档
"""
print(Person.__doc__)
# 3.__class__
"""
对象属性；对象.__class__ - 获取对象对应的类，返回的是类
(和type（对象）功能一样)
"""
print(p1.__class__)
print(type(p1))
type1 = p1.__class__
print(type.__name__)
p2 = type1('小花', 'nv', 13)
# 4.__dict__(将对象转换成字典)
"""
对象属性；对象.__dict__ - 将对象中所有的属性和对应的值转换成一个字典中的键值对(一个对象就是一个字典)
类的字段；类.__dict__ - 将类转换成一个字典，字典中所有的元素是类中的字段和对应的值
"""
# print(p1.__dict__) # {'name': '小明', 'gender': '男', 'age': 18}
# print(Person.__dict__)
print(p1)
persons = [p1, p2]
print(persons)
# 5.__module__
"""
类的字段；类.__module__ - 获取当前类是在哪个模块中声明的（返回的是模块的名字）
"""
print(Person.__module__)
print(bool.__module__)
# 6.__bases__
"""
类的字段； 类.__bases__ - 获取当前类的父类（返回的是一个元组）
"""
二、私有化
1.访问权限:公开、保护、私有
公开 - 公开的属性和方法在类的内部、外部能够使用，也能被继承
保护 - 保护的属性和方法只能在类的内部使用，外部不能使用，可以被继承
私有 - 私有的属性和方法只能在类的内部使用，外部不能使用，也不能被继承
2.python中属性和方法的访问权限
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)
p1 = Person('小明', 20)
# print(Person.num, p1.name, p1.name)
p1.eat()
# print(Person.__num) # AttributeError: type object 'Person' has no attribute '__num'
print(p1.__dict__) # {'name': 'xiaoming', '_Person__age': 20}
# print(p1._Person__age)
print(list('abcdef'))
三、属性的getter和setter
1.什么是getter和setter
当我们需要获取属性值之前做点别的事情就需要给这个属性添加getter；
当需要给属性赋值之前做点别的事情，就需要则这个属性添加setter
2.给属性添加getter
1）属性命名的时候前面加‘_’
2）在装饰器@property的后面声明一个对象方法
a.将属性去掉下划线作为方法名
b.方法处理self以外不需要其他参数
c.函数的返回值就是获取这个属性的时候得到的值
3）在外部使用属性的时候，通过‘对象.不带下划线的属性’去使用
注意：获取属性值时，就会自动去调用getter对应的函数
3.给属性添加setter
属性添加setter之前必须先添加getter
1）保证属性名前有‘_’
2)在@getter名.setter后面声明对象方法
a.降属性去电下划线作为方法名
b.需要一个self以外的参数
c.不需要返回值
3）在外部使用属性的时候，通过‘对象.不带下划线的属性’去使用
注意：当属性赋值的时候，实质是调用setter的方法
class Person:
def __init__(self, name, age, gender):
self.name = name
self._age = age
self._gender = 0
self._week = 0
@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):
print('年龄被访问！！！')
return self._age
@age.setter
def age(self, value):
print('年龄值被修改')
if not isinstance(value, int):
raise ValueError
if not 0 <= value <= 150:
raise ValueError
self._age = value
@property
def gender(self):
if self._gender == 0:
return '男'
elif self._gender == 1:
return '女'
# @gender.setter
# def gender(self, value):
p1 = Person('xiaoming', 18, 'nan')
print(p1.week) # 这儿实质是在调用week方法获取返回值
print(p1.age)
p1.age = 23
# 练习：写一个矩形类
# 有属性：长、宽、面积、周长
class Rect:
def __init__(self, length, width):
self._length = length
self._width = width
@property
def length(self):
return self._length
@length.setter
def length(self, value):
if not isinstance(value, int):
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
if value <= 0:
raise ValueError
self._width = value
def area(self):
return self._length * self._width
def per(self):
return 2*(self._length + self._width)
r1 = Rect(46, 12)
print(r1.length)
r1.length = 23
print(r1.area())
r1.area = 1
print()
print(r1.area)
四、类方法和静态方法
类中的方法分为：对象方法、类方法和静态方法
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('%s吃%s' % (self.name, food))
@classmethod
def func1(cls):
t = cls('a', 12, 'c')
print('t', t)
print('这是一个类方法！')
@staticmethod
def func2():
print('这是一个静态方法！')
@staticmethod
def func3():
print('这是个啥')
Person.func1()
p1 = Person('夏明', 90, '男')
Person.func2()
五、继承
1.什么是继承
继承就是让子类直接拥有父类全部属性和方法
子类 - 继承者
父类/超类 - 被继承者
2.怎么继承
1）语法
class 类名（父类1， 父类2， 父类3，……）:
说明文档
类的内容
2）说明：
（） - 固定写法，如果省略相当于（object）
声明类的时候如果没有写父类，默认继承object，（object又称基类）
父类 - 一个类的父类可以有一个，也可以有多个，单一般情况下只有一个（支持多继承）
class Person:
num = 61
def __init__(self):
self.name = '小明'
self.age = 18
self.gender = '男'
def eat(self, food='米饭'):
print('{}在吃{}'.format(self.name, food))
@classmethod
def show(cls):
print('人类的数量:%s' % cls.num)
class Student(Person):
# 在子类中添加对象属性需要先通过super（）去调用父类的__init__来继承父类的对象属性
# 在子类中可以通过super（）去调用父类的方法
# 注意：super（）只能在对象方法和类方法中去使用
pass