1. 类的定义和使用
1.1 面向对象最基础的概念就是类和对象（就是实例），面向对象设计思想就是把事物的特征和行为包含在类中。
1.2 定义类就是class 类名，
实例化为 对象名=类名()，
1.3 而在类里边创建方法参数需要以self为前缀，大概理解为self就是将其创建的对象传入方法，因为类可以创建多个对象，加self就是可以区分运用多个对象。在外部调用对象方法时不需要传递该参数。例如：
Class a:
def b(self):
print("输出")
aa=a()
a.b()（补充）当然self的命名可以随意更改，只不过self命名只是一个习惯。
1.4 构造方法固定名称为__init__(),当创建类的对象时，则系统会自动调用构造方法，从而实现对对象进行初始化。例：
class a:
def__init__(self):
self.l=1
self.w=2
def tangle(self):
print('长为{}，宽为{}'.format(self.l,self.w)
aa=a()#无论创多少个对象，l和w属性的初值都是默认值
a.tangle当然也有带参构造方法。
只需加参数，然后在创建对象时传参即可。
1.5 析构方法就是当一个对象被删除时，释放类所占的资源时自动调用，也可以用del语句删除对象手动调用，固定名称为def__del__(self)
2. 类成员和实例成员的区别
类成员时在类中所有方法之外定义的数据成员，可以通过类名或对象名访问；实例成员一般定义在构造函数里边，定义和使用必须以self作为前缀，只能通过对象名访问。
3. 封装
封装时面向对象的特征之一，就是把客观事物封装成抽象的类，并规定类中的数据和方法只让可信的或对象操作(书上的话真的有哲理，越读越明白‘小蒙b’）
封装可分为两个层面:
1）第一层为，创建类和对象时，分别创建两者的名称，只通过类名或者对象名加“.”的方式访问内部成员和方法
2）第二层为，类中把某些成员和方法隐藏起来，或者定义为私有，只在类中内部使用，在类的外部无法访问，可以留少量接口供外部访问
补充（前面的大部分都为第一种封装，下面主要介绍第二种）例子如下：
class A: #定义类
def__init__(self):
self._X=10 #定义私有变量
def__foo(self): #定义私有方法
print('from A')
def bar(self): #定义接口函数
self.__foo() #类内部访问私有
return self.__X
a=A()
b=a.bar() #调用接口函数
print(b)4.继承
继承学过Java大家应该都有所了解就是事物的从属关系，就是子类继承父类，子类就可以使用父类的属性（公有方法和变量）
4.1 单继承
意思就是一个子类只有一个父类。
4.2 多继承
当然就是一个子类有多个父类，就继承多个父类的特性（如果多个父类有相同的方法名，同时调用时，则优先调用参数的第一个）例：
class s(a,b):表示s继承a和b，若父类中有相同方法名优先调用a
4.3 重写父类方法与调用父类方法
例：
class Person():
def__init__(self,name,sex):
self.name=name
self.sex=sex
class Stu(Person):
def__init__(self,name,sex,score):
super().__init__(name,sex) #调用父类
self.score=score
student=Stu('liming','male',66)
print("姓名:%s,性别:%s,成绩:%s"%(student.name,student.sex,student.score))5.多态
就是多个子类继承父类：向不同对象发送同一个消息，不同的对象在接收时会产生不同行为（方法），也即每个对象可以用自己的方式区响应共同的消息（调用函数）
#定义父类
class Person:
def __init__(self, name, gender):
self.name = name
self.gender = gender
def who(self): #定义who方法
print('I am a Person, my name is %s' % self.name)
#定义学生子类
class Student(Person):
def __init__(self, name, gender, score):
super().__init__(name, gender)
self.score = score
def who(self): #重写父类方法
print('I am a Student, my name is %s' % self.name)
#定义教师子类
class Teacher(Person):
def __init__(self, name, gender, course):
super().__init__(name, gender)
self.course = course
def who(self): #重写父类方法
print('I am a Teacher, my name is %s' % self.name)
#定义函数用于接收对象
def fun(x):
x.who() #调用who方法
#创建对象
p = Person('Jack', 'Male')
s = Student('Tom', 'Male', 88)
t = Teacher('Lily', 'Female', 'English')
#调用函数
fun(p)
fun(s)
fun(t)通过向函数中传入不同对象，who方法输出不同的结果
6.类方法和静态方法
1）类方法是类所拥有的方法，需要用修饰器“@classmethod”来标识其为类方法，第一参数必须是类对象，一般以cls作为参数（和self一样）例子：
#定义类
class People:
country = 'china' #定义类成员并赋值
#类方法，用classmethod来进行修饰
@classmethod
def getCountry(cls):
return cls.country #返回类成员的值
p = People() #创建对象
print(p.getCountry()) #通过实例对象引用
print(People.getCountry()) #通过类对象引用用对象名和类名调用类方法的效果一样。
（类方法可以访问类成员，但无法访问实例成员）
2）静态方法
使用静态方法，需在类方法前加上“@staticmethod"标记符以表示下面的成员方法是静态方法，静态方法可以不带任何参数，所有无法访问类的实例成员和类成员。例子：
#定义类
class Test:
#静态方法，用@staticmethod进行修饰
@staticmethod
def s_print():
print('----静态方法----')
Test.s_print() #通过类名调用
t = Test() #创建对象
t.s_print() #通过对象名调用一般不用静态方法，大部分用于辅助功能，打印菜单。
