类:用来描述具有相同属性和方法的对象的集合。

一、类的命名方式

1.大驼峰 首字母大写
2.见名知意
3.区分大小写
实例:

class Women:
  sex = '女'
  faceValue = '高'
  height = '168'
  color = 'white'
  def makeChild(self):
    print('可以生宝宝')
  def cookie(self):
     print('做饭')
#打印Women类
print(Women) #<class '__mian__.Women'>

二、对象

类的实例化为对象
object = 类名([参数... ...])
实例

zhang = Women() #将Women类实例化成对象
print(zhang) #<__main__.women object at 0x000001B6873C8CC0>

三、属性和方法的使用

调用属性
object.属性名
调用方法
object.方法名()
注意:类里面的变量称之为属性，类里面的函数称之为方法。

四、self的说明

方法里面的self代表的是当前类的实例化后的对象。
self不是只能叫self，别的也可以，但是规范来说，都是使用self。
实例:

class A:
    name = 'zhang'
    def demo(self):
        print(self)
        print(id(self))
a = A()
a.demo()
print(a.name)
print(a)
print(id(a))

五、return方法的返回值

和函数一样，代码遇到return下面就不再执行，会将值返回给调用处
没有return的方法，打印调用处的值为None
实例

class Demo:
  name = ' '
  def speak(self):
    print ("我是{}号楼".format(self.name))
  def myReturn(self):
    return self.name
    print(self.name) #不再执行
d2 = Demo
d2.name = 'd2' #给当前对象添加对象属性
#print(d2.name)
d2Name = d2.myReturn()
print(d2Name) #d2

六、对象属性和类属性

1.使用对象创建的属性称之为对象属性，只有当前对象里才存在。
2.如果使用对象属性创建了一个和类里面同名的属性，那么调用的时候会优先查找对象里面的属性。
3.使用类里面的方法的参数，self创建的属性，也为对象属性。
4.使用当前 对象.属性名 来改类里面的属性的时候，其实是在对象里面创建了一个同名的属性。
5.当将对象里面同名的属性删除掉以后，还是会调用类的属性。
6.不能在对象里删除类里面的属性，只有使用的权利。
7.使用类操作过的属性，所有对象在调用类属性的时候，都是修改后的属性。

创建对象属性的方法

class A:
#通过方法创建对象属性
  def createVar(self):
    self.xx = 'oo'
a = A()
#对象名.属性名
a.name = 'xx'

创建类属性的方法
类名.属性名

七、给对象和类绑定方法

(1)给对象和类绑定方法

from types import MethodType
实例

def func(self):
  print('func')
  from types import MethodType
a = A()
#a.func = MethodType(方法名,对象名)
a.func = MethodType(func,a)

(2)给类绑定方法

实例

def func(self):
  print('func')
#类名.属性名 = 函数名
A.func = func

注意:
1.给对象绑定属性或者方法，只有当前对象有。
2.给类绑定属性或者方法，所有当前类的实例化的对象都会拥有。

八、slots限制对象 动态添加属性

只能创建slots允许的属性否则会报 AttributeError:'A'object has no attribute 'xxx'
实例

class A :
  __slots__ = ('属性1'，'属性2'。。。。)

九、私有属性和私有方法

(1)类的私有属性:以作为开头 不能在类的外部进行使用和访问 在类的里面使用 self.属性名
私有属性的访问:
在类的外部: 对象.类名属性名 调用
在类的内部： 方法里面的变量 self.属性名 调用
注意:
在类的内部只要使用 self.属性名 那么就会去找私有属性 '类名属性名'

十、继承

概念:面向对象编程带来最大的好处就是代码的重用，实现代码重用的操作就是类的继承。被继承的类称为父类、基类、或者超类。
继承的类称为子类
所有的类都会继承一个超类 object

（1）单一继承

class 类名(继承的父类):
pass
实例:

class A:
    """docstring for A"""
    def __init__(self,n,a,s):

        self.name = n
        self.age = a
        self.sex = s

    def speak(self):
        print('我现在{}岁了，我叫{}，我的性别是{}'.format(self.age,self.name,self.sex))

a = A('张',18,'女')
a.speak()
print(a.name)
class B(A):
    grade = ''
    def __init__(self,name,age,sex,grade):
        print('我是子类的__init__')
        self.grade = grade
        A.__init__(self,name,age,sex)
    def speak(self):
        A.speak(self)
        print('我今年{}我叫{}我的 成绩是{}'.format(self,name,age,sex,grade))

b = B('李四',18,'男',20)
print(b.name)
print(b.__dict__)
b.speak()

注意:
1.类的单一继承 子类会继承父类私有以外的全部属性和方法。
2.如果子类里存在和父类同名的属性或方法，叫做方法或属性的重写(也就是会被覆盖掉)，再次调用的时候用的是子类的方法和属性。
3.在子类里面调用父类的方法 类名.方法名(self[,参数... ...])self代表当前类的实例化的对象。
4.super(当前类名,self).方法名 (如果是单一继承 super方法 不建议加参数)
5.super().方法名(建议)

（2）多继承

class 类名(继承的父类1，继承的父类2[，父类3... ...]):
pass
注意:
1.当类进行多继承的时候 注意父类的顺序 当父类存在同名的属性或者方法的时候，会从继承的父类类从左到右依次查找。
调用父类的方法

class A:
  def speak(self):
    print('我是A类的speak方法')
  def a(self):
    print('a') 
class B:
  def speak(self):
    print('我是B类的speak方法')
  def b(self):
    print('b')
class C(A,B):
  def speak(self):
    super().speak() #还是从左往右查找
    #super(C,self).speak
     #super(A,self).speak
    # super(B,self).speak'

十一、常用的属性

1.__doc__类的说明
2.__name__返回类名
3.__base__返回一个父类
4.__bases__返回多个父类
5.__dict__返回对象或者类的信息

十二、静态方法

@staticmethod
可以在类的实例化成对象调用，可以使用类名来调用
实例

class A:
  @staticmethod
  def demo():
    print('类的调用')
a = A()
a.demo()
A.demo()

十三、魔术方法

1.__init__构造方法 作为类的初始化
2.__del__析构方法 在当前文件执行完毕之前去执行或者是使用del对象名，去触发
3.__str__用于转换成人类能够阅读的形式
4.__repr__转换成解释器查看的形式
5.__add__运算符重载
6.__getattr__调用不存在的属性的时候触发
7.__len__返回集合中所包含的元素数量
8.__getitem__返回与所给键对应的值
9.__setitem__按一定方式存储和key相关的value