Python中lf⽤法详解
在介绍Python的lf⽤法之前，先来介绍下Python中的类和实例……
1、以Student类为例，在Python中，定义类如下：
class Student(object)
pass
（Object）表⽰该类从哪个类继承下来的，Object类是所有类都会继承的类。
2、实例：定义好了类，就可以通过Student类创建出Student的实例，创建实例是通过类名+()实现：
过生日吃什么class Student(object):
def __init__(lf,name,score):
lf.name=name
lf.score=score
student=Student("帅哥",100)
print(student.name,"获得",student.score)
3、由于类起到模板的作⽤，因此，可以在创建实例的时候，把我们认为必须绑定的属性强制填写进去。这⾥就⽤到Python当中的⼀个内置⽅法__init__⽅法，例如在Student类时，把name、score等属性绑上去:
这⾥注意：（1）、__init__⽅法的第⼀参数永远是lf，表⽰创建的类实例本⾝，因此，在__init__⽅法内部，就可以把各种属性绑定到lf，因为lf就指向创建的实例本⾝。（2）、有了__init__⽅法，在创建实例的时候，就不能传⼊空的参数了，必须传⼊与__init__⽅法匹配的参数，但lf不需要传，Python解释器会⾃⼰把实例变量传进去：
另外，这⾥lf就是指类本⾝，lf.name就是Student类的属性变量，是Student类所有。⽽name是外部传来的参数，不是Student类所⾃带的。故，lf.name = name的意思就是把外部传来的参数name的值赋值给Student类⾃⼰的属性变量lf.name。
4、和普通数相⽐，在类中定义函数只有⼀点不同，就是第⼀参数永远是类的本⾝实例变量lf，并且调⽤时，不⽤传递该参数。除此之外，类的⽅法(函数）和普通函数没啥区别，你既可以⽤默认参数、可变参数或者关键字参数（*args是可变参数，args接收的是⼀个
tuple，**kw是关键字参数，kw接收的是⼀个dict）。
5、既然Student类实例本⾝就拥有这些数据，那么要访问这些数据，就没必要从外⾯的函数去访问，⽽可以直接在Student类的内部定义访问数据的函数（⽅法），这样，就可以把”数据”封装起来。这些封装数据的函数是和Student类本⾝是关联起来的，称之为类的⽅法：
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线，在Python中，实例的变量名如果以开头，就变成了⼀个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把Student类改⼀改：
class Student(object):
def __init__(lf, name, score):
lf.__name = name
lf.__score = score
def print_score(lf):
print "%s: %s" %(lf.__name,lf.__score)
改完后，对于外部代码来说，没什么变动，但是已经⽆法从外部访问实例变量.__name和实例变量.__score了：
>>> student = Student('Hugh', 99)
>>> student.__name
Traceback (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(lf):
天日成语return lf.__name
def get_score(lf):
return lf.__score
如果⼜要允许外部代码修改score怎么办？可以给Student类增加t_score⽅法：
class Student(object):
...
def t_score(lf, score):
lf.__score = score
需要注意的是，在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能⽤__name__、__score__这样的变量名。
有些时候，你会看到以⼀个下划线开头的实例变量名，⽐如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。
封装的另⼀个好处是可以随时给Student类增加新的⽅法，⽐如：get_grade:
class Student(object):
...
def get_grade(lf):
if lf.score >= 90:
return 'A'
elif lf.score >= 60:
return 'B'
el:
return 'C'
深圳户口入户条件同样的，get_grade⽅法可以直接在实例变量上调⽤，不需要知道内部实现细节.
6、lf的仔细⽤法
(1)、lf代表类的实例，⽽⾮类
class Test:
def ppr(lf):
print(lf)
print(lf.__class__)
t = Test()
t.ppr()
建国七十周年执⾏结果：
<__main__.Test object at 0x000000000284E080>
<class '__main__.Test'>
从上⾯的例⼦中可以很明显的看出，lf代表的是类的实例。⽽lf.__class__则指向类。
注意：把lf换成this，结果也⼀样，但Python中最好⽤约定俗成的lf。
（2）、lf可以不写吗？
在Python解释器的内部，当我们调⽤t.ppr()时，实际上Python解释成Test.ppr(t)，也就是把lf替换成了类的实例。
class Test:
def ppr():
print(lf)
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。
这⾥实际上已经部分说明了lf在定义时不可以省略。
当然，如果我们的定义和调⽤时均不传类实例是可以的，这就是类⽅法。
（3）、在继承时，传⼊的是哪个实例，就是那个传⼊的实例，⽽不是指定义了lf的类的实例。
class Parent:
def pprt(lf):
print(lf)
class Child(Parent):
def cprt(lf):
print(lf)你呢用英语怎么说
c = Child()
c.cprt()
c.pprt()
怎么组合图片
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.pprt(c)，所以lf指的依然是Child类的实例，由于lf中没有定义pprt()⽅法，所以沿着继承树往上找，发现在⽗类Parent中定义了pprt()⽅法，所以就会成功调⽤。
（4）、在描述符类中，lf指的是描述符类的实例
class Desc:
def __get__(lf, ins, cls):
print('lf in Desc: %s ' % lf )
print(lf, ins, cls)
class Test:
x = Desc()
def prt(lf):
print('lf in Test: %s' % lf)在宇宙中有一个宝
t = Test()
t.prt()
t.x
结果：
lf in Test: <__main__.Test object at 0x0000000002A570B8>
lf in Desc: <__main__.Desc object at 0x000000000283E208>
<__main__.Desc object at 0x000000000283E208> <__main__.Test object at 0x0000000002A570B8> <class '__main__.Test'>
这⾥主要的疑问应该在：Desc类中定义的lf不是应该是调⽤它的实例t吗？怎么变成了Desc类的实例了呢？
因为这⾥调⽤的是t.x，也就是说是Test类的实例t的属性x，由于实例t中并没有定义属性x，所以找到了类属性x，⽽该属性是描述符属性，为Desc类的实例⽽已，所以此处并没有顶⽤Test的任何⽅法。
那么我们如果直接通过类来调⽤属性x也可以得到相同的结果。
下⾯是把t.x改为Test.x运⾏的结果。
lf in Test: <__main__.Test object at 0x00000000022570B8>
lf in Desc: <__main__.Desc object at 0x000000000223E208>
<__main__.Desc object at 0x000000000223E208> None <class '__main__.Test'>
