python123动物重量排序_python进阶
⾯向对象oopclass Student(object):
def __init__(lf,name,score)
lf.name = name
lf.score = score
def print_score(lf)
print('%s: %s' % (lf.name,lf.score))
给对象发消息实际上就是调⽤对象对应的关联函数，我们称之为对象的⽅法(Method)。⾯向对象的程序写出来就像这样：
bart = Student(‘zhangyuang’,90)
lisa = Student(‘janvier’,90)
小学生一周计划表
bart.print_score()
lisa.print_score()
类和实例class Student(object):
pass
class后⾯紧接着是类名，即Student，类名通常是⼤写开头的单词，紧接着是(object)，表⽰该类是从哪个类继承下来的，继承的概念⼀⾏再讲。通常，如果没有合适的继承类，就使⽤object类，这是所有类最终都会继承的类。
定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现
>>> bart = Student()
>>> bart
>>> Studeng
可以看到，变量bart指向的就是⼀个Student的实例，后⾯的0x10a67a590
是内存地址，每个object的地址都不⼀样，⽽Student本⾝则是⼀个类。
可以⾃由的给⼀个实例变量绑定属性
>>> bart.name = 'zhangyuang'
>>> bart.name
'zhangyuang'
由于类可以起到模版的作⽤，因此在创建实例的时候，把⼀些我们认为必须绑定的属性强制天蝎进去。通过定义⼀个特殊的init⽅法，在创建实例的时候，就把name,score等属性绑上去：
>>> class Student(object):
def __init__(lf,name,score):
lf.name = name
lf.score = score
注意到init⽅法的第⼀个参数永远是lf.表⽰创建的实例本⾝，因此，在init⽅法内部，就可以把各种属性绑定到lf，因为lf就指向创建的实例本⾝。
有了init⽅法，在创建实例的时候，就不能传⼊空的参数了，必须传⼊与init⽅法匹配的参数，但lf不需要传，Python解释器⾃⼰会把实例变量传进去：番茄牛腩怎么做
>>> bart = Student('zhangyuang','90')
>>> bart.name
'zhangyuang'
>>> bart.score
90
数据封装
⾯向对象编程的⼀个重要特点就是数据封装。在上⾯的Student类中，每个实例就拥有各⾃的name和score这些数据。我们可以通过函数来访问这些数据，⽐如打印⼀个学⽣的成绩：
>>> def print_score(std):
print('%s: %s' % (std.name,std.score))
>>> print_score(bart)
zhangyuang:90
但是既然Student实例本⾝就拥有这些数据，要访问这些数据就没有必要从外⾯的函数去访问，可以直接在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和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))
要定义⼀个⽅法，除了第⼀个参数是lf外，其他和普通函数⼀样。要调⽤⼀个⽅法，只需要在实例
变量上直接调⽤，除了lf不⽤传递，其他参数正常传⼊。
郑元畅>>> bart.print_score()
zhangyuang: 90
封装的另⼀个好处是可以给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’
>>&_grade()
'c'
访问限制
如果要让内部属性不被外部访问，可以把属性的名称前加两个下划线，在python中，实例的变量名如果以开头就变成了⼀个私有变量(private)，只有内部可以访问，外部不能访问。
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了
>>> bart = Student('zhangyuang',90)
>>> bart.__name
Traceback (most recent call last):
File "", line 1, in
西游记内容梗概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
你也许会问，原先那种直接通过bart.score = 59也可以修改啊，为什么要定义⼀个⽅法⼤费周折？因为在⽅法中，可以对参数做检查，避免传⼊⽆效的参数：
class Student(object):
def t_score(lf,score):
if 0<=score<=100:
lf.score = score
el:
rai ValueError(‘bad score’)迢迢牵牛星的作者是谁
需要注意的是，在Python中，变量名类似xxx的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能⽤name、score这样的变量名。
有些时候，你会看到以⼀个下划线开头的实例变量名，⽐如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。
再审答辩状继承和多态
在OOP程序设计中，当我们定义⼀个class的时候，可以从某个现有的class继承，新的class称为⼦类(Subclass)，⽽被继承的class称为基类、⽗类或超类(Ba class、Super class)。
⽐如，我们已经编写了⼀个名为Animal的class，有⼀个run()⽅法可以直接打印：
class Animal(object):
def run(lf):
print(‘Animal is running’)
当我们需要编写Dog和Cat类时，就可以直接从Animal继承：
class Dog(Animal):
pass
class Cat(Animal):
pass
对于Dog来说，Animal就是它的⽗类，对于Animal来说，Dog就是它的⼦类。cat和Dog类似。
继承有什么好处？最⼤的好处是⼦嘞获得了⽗类的全部功能。由于Animal实现了run()⽅法，因此Dog Cat作为它的⼦类，什么事也没⼲就拥有了run()⽅法。
dog = Dog()
dog.run()
cat = Cat()
cat.run()
Animal is running
当然也可以对⼦类增加⼀些⽅法，
class Dog(Animal):
def run(lf):
print(‘dog is running’)
杜仲平压片def eat(slef)
print(‘eating meat’)
继承的第⼆个好处需要我们对代码做⼀点改进。你看到了，⽆论是dog还是cat它们run()的时候，显⽰的都是Animal is running 符合逻辑的做法是分别显⽰dog is running 和 cat is running因此对Dog类和Cat类做如下改进
关于青春的作文class Dog(Animal):
def run(lf):
print('Dog ')
class Cat(Animal):
def run(lf):
print('Cat ')
当⼦类和⽗类都存在相同的run()⽅法时，我们说，⼦类的run()覆盖了⽗类的run()，在代码运⾏的时候，总是会调⽤⼦类的run()。这样，我们就获得了继承的另⼀个好处：多态。
要理解什么是多态，我们⾸先要对数据类型再作⼀点说明。当我们定义⼀个class的时候，我们实际上就定义了⼀种数据类型。我们定义的数据类型和Python⾃带的数据类型，⽐如str、list、dict没什么两样：
a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # 是Dog类型
判断⼀个变量是否是某个类型可以⽤istance()判断
>>> isintance(a,list)
True
>>> isinstance(b,Animal)
True
>>> isinstance(c,Dog)
True
>>> isinstance(c,Animal)
True
看来b不仅是Dog类型还是Animal类型
>>> b =Animal()
>>> isinstance(b,Dog)
Fal
Dog可以看成Animal，但Animal不可以看成Dog
要理解多态的好处，我们还需要再编写⼀个函数，这个函数接受⼀个Animal类型的变量
def run_twice(animal):
animal.run()
animal.run()
当我们传⼊Animal的实例时，run_twice()就打印出：
>>> run_twice(Animal())
Animal
Animal
当我们传⼊Dog的实例时，run_twice()就打印出：
>>> run_twice(Dog())
Dog
