class Student(object): pass
（Object）表示该类从哪个类继续下来的，Object类是所有类都会继续的类。即class Name()中是表示从哪个类继续下来的
2、由类创建实例定义好了类，就可以通过Student类创建出Student的实例，创建实例是通过类名+()实现：
student = Student()3、添加属性
由于类起到模板的浸染，因此，可以在创建实例的时候，把我们认为必须绑定的属性逼迫填写进去。这里就用到Python当中的一个内置方法__init__方法，例如在Student类时，把name、score等属性绑上去:
class Student(object): slogan = 'I ame a student'# 类属性：类名访问 def __init__(self, name, score): self.name =i name # 实例属性 ：实例与类名均可访问 self.score = score# 实例属性__init__方法的第一参数永久是self，表示类的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，由于self就指向创建的实例本身（通过self绑定的属性是实例属性）其余，这里self便是指由类创建的实例本身，self.name是Student类实例本身的属性变量，而name是外部传来的参数，以是，self.name = name的意思便是把外部传来的参数name的值赋值给Student类实例本身自己的属性变量self.name有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不须要传，Python阐明器会自己把实例变量传进去
>>>student = Student("Hugh", 99)>>>student.name"Hugh">>>student.score994、类中的函数与普通函数作比较
和普通函数比较，在类中定义函数只有一点不同，便是第一参数永久是类的本身实例变量self，并且调用时，不用通报该参数。除此之外，类的方法(函数）和普通函数没啥差异，你既可以用默认参数、可变参数或者关键字参数（args是可变参数，args吸收的是一个tuple，kw是关键字参数，kw吸收的是一个dict）。
5、类的方法既然Student类实例本身就拥有这些数据，那么要访问这些数据，就没必要从表面的函数去访问，而可以直接在Student类的内部定义访问数据的函数（方法），这样，就可以把”数据”封装起来。这些封装数据的函数是和Student类本身是关联起来的，称之为类的方法（类实例与类均可访问）：
class Student(obiect): def __init__(self, name, score): self.name = name self.score = score def print_score(self): print "%s: %s" % (self.name, self.score)
>>>student = Student("Hugh", 99)>>>student.print_scoreHugh: 99
这样一来，我们从外部看Student类，创建实例须要给出name和score。而如何打印，都是在Student类的内部定义的，这些数据和逻辑被封装起来了，调用很随意马虎，但却不知道内部实现的细节。
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线'__'，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，以是，我们把Student类改一改：
class Student(object): def __init__(self, name, score): self.__name = name self.__score = score def print_score(self): print "%s: %s" %(self.__name,self.__score)
改完后，对付外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__score了：
>>> student = Student('Hugh', 99)>>> student.__nameTraceback (most recent call last): File "<stdin>", line 1, in <module>AttributeError: 'Student' object has no attribute '__name'
这样就确保了外部代码不能随意修正工具内部的状态，这样通过访问限定的保护，代码更加健壮。
但是如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_score这样的方法：
class Student(object): ... def get_name(self): return self.__name def get_score(self): return self.__score
如果又要许可外部代码修正score怎么办？可以给Student类增加set_score方法：
class Student(object): ... def set_score(self, score): self.__score = score
须要把稳的是，在Python中，变量名类似__xxx__的，也便是以双下划线开头，并且以双下划线结尾的，是分外变量，分外变量是可以直接访问的，不是private变量，以是，不能用__name__、__score__这样的变量名。
有些时候，你会看到以一个下划线'_'开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思便是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。
封装的另一个好处是可以随时给Student类增加新的方法，比如：get_grade:
class Student(object): ... def get_grade(self): if self.score >= 90: return 'A' elif self.score >= 60: return 'B' else: return 'C'
同样的，get_grade方法可以直接在实例变量上调用，不须要知道内部实现细节：
>>> student.get_grade()'A'6、self的仔细用法(1)、self代表类的实例，而非类
class Test: def ppr(self): print(self) print(self.__class__)t = Test()t.ppr()实行结果：<__main__.Test object at 0x000000000284E080><class '__main__.Test'>
从上面的例子中可以很明显的看出，self代表的是类的实例。而self.__class__则指向类。
把稳：把self换成this，结果也一样，但Python中最好用约定俗成的self。
（2）self可以不写吗？在Python阐明器的内部，当我们调用t.ppr()时，实际上Python阐明成Test.ppr(t)，也便是把self更换成了类的实例。
class Test: def ppr(): print(self)t = Test()t.ppr()运行结果如下：Traceback (most recent call last): File "cl.py", line 6, in <module> t.ppr()TypeError: ppr() takes 0 positional arguments but 1 was given
运行时提醒缺点如下：ppr在定义时没有参数，但是我们运行时强行传了一个参数。由于上面阐明过了t.ppr()等同于Test.ppr(t)，以是程序提醒我们多传了一个参数t。这里实际上已经部分解释了self在定义时不可以省略。
当然，如果我们的定义和调用时均不传类实例是可以的，这便是类方法。
class Test: def ppr(): print(__class__)Test.ppr()运行结果：<class '__main__.Test'>（3）在继续时，传入的是哪个实例，便是那个传入的实例，而不是指定义了self的类的实例。
class Parent: def pprt(self): print(self)class Child(Parent): def cprt(self): print(self)c = Child()c.cprt()c.pprt()# 等同于Child.pprt(c)p = Parent()p.pprt()
运行结果：<__main__.Child object at 0x0000000002A47080><__main__.Child object at 0x0000000002A47080><__main__.Parent object at 0x0000000002A47240>
运行c.cprt()时该当没有理解问题，指的是Child类的实例。
但是在运行c.pprt()时，等同于Child.ppt(rc)，以是self指的依然是Child类的实例，由于self中没有定义pprt()方法，以是沿着继续树往上找，创造在父类Parent中定义了pprt()方法，以是就会成功调用。
（4）在描述符类中，self指的是描述符类的实例class Desc: def __get__(self, ins, cls): print('self in Desc: %s ' % self ) print(self, ins, cls)class Test: x = Desc() def prt(self): print('self in Test: %s' % self)t = Test()t.prt()t.x
运行结果如下：self in Test: <__main__.Test object at 0x0000000002A570B8>self in Desc: <__main__.Desc object at 0x000000000283E208><__main__.Desc object at 0x000000000283E208> <__main__.Test object at 0x0000000002A570B8> <class '__main__.Test'>
这里紧张的疑问该当在：Desc类中定义的self不是该当是调用它的实例t吗？怎么变成了Desc类的实例了呢？
由于这里调用的是t.x，也便是说是Test类的实例t的属性x，由于实例t中并没有定义属性x，以是找到了类属性x，而该属性是描述符属性，为Desc类的实例而已，以是此处并没有中用Test的任何方法。
那么我们如果直接通过类来调用属性x也可以得到相同的结果。下面是把t.x改为Test.x运行的结果。
self in Test: <__main__.Test object at 0x00000000022570B8>self in Desc: <__main__.Desc object at 0x000000000223E208><__main__.Desc object at 0x000000000223E208> None <class '__main__.Test'>
题外话：由于在很多时候描述符类中仍旧须要知道调用该描述符的实例是谁，以是在描述符类中存在第二个参数ins(insctance)，用来表示调用它的类实例，以是t.x时可以看到第三行中的运行结果中第二项为<main.Test object at 0x0000000002A570B8>。而采取Test.x进行调用时，由于没有实例，以是返回None。
总结self在定义时须要定义，但是在调用时会自动传入。self的名字并不是规定去世的，但是最好还是按照约定是用selfself总是指调用时的类的实例。
