python类、super函数

#PYTHON语言及其应用学习笔记

1、创建简单的类

class Person():
    #python中特殊的对象初始化方法__init__,一个特殊的函数名
    #当你在类声明里定义__init__()方法时，第一个参数必须为self。
    def __init__(self,name):
        self.name=name
someone=Person('elmer fudd')
#上面一行代码实际做了如下工作：
1、查看Person类的定义
2、在内存中实例化（创建）一个新的对象
3、调用对象的__init__方法，将这个新创建的对象作为self传入，并将另一个参数
（‘elmer fudd’)作为name传入；
4、将name的值存入对象；
5、返回这个新的对象；
6、将名字hunter与这个对象关联。

2、类对象当做参数传递给函数，当做函数返回结果

#这个新对象与其他的python对象一样。你可以把它当做列表、元组、字典或集合中的元素，也可以把它当做参数传递给函数，或者把它作为函数的返回结果
class Person:
    def __init__(self,name):
        self.name=name
    def run(self):
        print(self.name + 'is running!')
hunter=Person('elmer fudd')
def hi(x):
    print(x.name)
    print(x.run())
hi(hunter)  #elmer fudd  elmer fuddis running!  None
#在Person类定义的内部，你可以直接通过self.name访问name属性，而当你创建了一个实际的对象后，例如这里的hunter，需要通过hunter.name来访问它
#在类的定义中，__init__并不是必需的。只有当需要区分由该类创建的不同对象时，才需要指定__init__方法。

3、继承

在你编写代码解决实际问题时，经常能找到一些已有的类，它们能够实现你所需的大部分
功能，但不是全部。这时该怎么办？当然，你可以对这个已有的类进行修改，但这么做很
容易让代码变得更加复杂，一不留神就可能会破坏原来可以正常工作的功能。
       当然，也可以另起炉灶重新编写一个类：复制粘贴原来的代码再融入自己的新代码。但这
意味着你需要维护更多的代码。 同时，新类和旧类中实现同样功能的代码被分隔在了不同
的地方（日后修改时需要改动多处）。
        更好的解决方法是利用类的继承：从已有类中衍生出新的类， 添加或修改部分功能。这是
代码复用的一个绝佳的例子。 使用继承得到的新类会自动获得旧类中的所有方法，而不需
要进行任何复制。
        你只需要在新类里面定义自己额外需要的方法， 或者按照需求对继承的方法进行修改即
可。修改得到的新方法会覆盖原有的方法。 我们习惯将原始的类称为父类、 超类或基类，
将新的类称作孩子类、 子类或衍生类。这些术语在面向对象的编程中不加以区分。

class Car:
    def exclaim(self):
        print('i am a car!')
class Yugo(Car):
    pass
#为每一个类各创建一个对象，并调用刚刚声明的 exclaim 方法
give_me_a_car=Car()
give_me_a_yugo=Yugo()
give_me_a_car.exclaim()    #i am a car!
give_me_a_yugo.exclaim()   #i am a car!
#我们不需要进行任何特殊的操作，Yugo就自动从Car那里继承了exclaim()方法。但事
#实上，我们并不希望Yugo在exlaim()方法里宣称它是一个Car，这可能会造成身份危机
#（无法区分Car和Yugo）。让我们来看看怎么解决这个问题。

4、覆盖方法

在子类中，可以覆盖任何父类的方法，包括__init__()

class Car:
    def exclaim(self):
        print('i am a car!')
class Yugo(Car):
    def exclaim(self):
        print('i am a yugo! much like a car, but more yugo-ish')
#为每一个类各创建一个对象，并调用刚刚声明的 exclaim 方法
give_me_a_car=Car()
give_me_a_yugo=Yugo()
give_me_a_car.exclaim()  #i am a car!
give_me_a_yugo.exclaim() #i am a yugo! much like a car, but more yugo-ish

#在子类中，可以覆盖任何父类的方法，包括 __init__()。
#医生（ MDPerson）和律师（ JDPerson）
class Person():
    def __init__(self,name):
        self.name=name

class MDPerson(Person):
    def __init__(self,name):
        self.name=',Doctor '+name

class JDPerson(Person):
    def __init__(self,name):
        self.name=', '+name+' esquire'
person=Person('fudd')
doctor=MDPerson('fund')
lawyer=JDPerson('fund')
print(person.name,doctor.name,lawyer.name) #fudd ,Doctor fund , fund esquire

5、添加新方法

子类还可以添加父类中没有的方法。

class Car():
    def exclaim(self):
        print("I'm a Car!")

class Yugo(Car):
    def exclaim(self):
        print("I'm a Yugo! Much like a Car, but more Yugo-ish.")
    def need_a_push(self):
        print("A little help here?")

6、使用super从父类得到帮助

我们知道如何在子类中覆盖父类的方法，但如果想要调用父类的方法怎么办？  ##继承可以直接调用父类的方法，这里方法是初始化方法(__init__)。

“哈哈！终于等到你问这个了。” super() 站出来说道。下面的例子将定义一个新的类
EmailPerson，用于表示有电子邮箱的 Person。

class Person():
    def __init__(self,name,age):
        self.name=name
        self.age=age
#下面是子类的定义，注意，子类的初始化方法__init__()中添加了一个额外的email参数：
class EmailPerson(Person):
    def __init__(self,name,age,email):
        super().__init__(name,age)
        self.email=email
email=EmailPerson('yangqie',18,'qq.com')
print(email.name,email.email,email.age)  #yangqie qq.com 18
在子类中定义__init__()方法时，父类的__init__()方法会被覆盖。因此，在子类中，
父类的初始化方法并不会被自动调用，我们必须显示地调用它。
只能全部调用或者全部不调用，上面例子要不就全部调用name、age，要不就都不调用。
以上代码实际上做了这样几件事情：
1、通过super()方法获取了父类Person的定义
2、子类的__init__()调用了Person.__init__()方法。它会自动将self参数传递给父类。
   因此，你只需传入其余参数即可(除去self后的参数)。上面例子即name、age
3、self.email=email这行新的代码才真正起到了将EmailPerson与Person区别开的作用。

#为什么不像下面这样定义EmailPerson类呢？
class EmailPerson(Person):
    def __init__(self,name,age,email):
        self.name=name
        self.age=age
        self.email=email
确实可以这样做，但这有悖我们使用继承的初衷。我们应该使用super()来让Person完成它应该做的事情，
就像任何一个单纯的Person对象一样。此外，如果Person类的定义在未来发生改变，使用super()可以
保证这些改变会自动反映到EmailPerson类上，而不需手动修改。
子类可以按照自己的方式处理问题，但如果仍需要借助父类的帮助，使用super()是最佳选择。

super写法注意：

1、子类的初始化方法__init__()中需要添加父类中init实例特性property，如上例中：

def __init__(self,name,age,email)    name age 均为父类中init实例特性

2、Python3与Python2写法不同

Python2：super(Person,self).__init__(name,age)

Python3：super().__init__(name,age)

3、有如下几个问题：子类继承父类，创建子类实例时，要输入父类中的实例特性参数。

问题1：如果子类没有init方法，父类有init方法，构建实例时要输入父类的实例特性参数吗？需要，子类继承了父类的init方法，需要输入！！！

             如下面代码1，修改为child=Child('yq')即可。子类没有init方法时，继承父类init方法。

问题2：如果子类有和父类相同的实例特性参数，构建实例时需要输入两个实例特性参数吗？如下面代码2，不用输入两个，输入一个即可。

　　　  子类覆盖了父类的init方法，所以不需要输入！！

问题3：如果子类中有init方法，父类中有init方法，构建实例时需要输入子类和父类中的实例特性参数吗？如下面代码3，只用输入子类实例特性参数。

总结：在没有使用super情况下，子类有init，就用子类的，子类没有找父类，父类有，用父类的，父类没有，就不用管了。

问题4：在使用super情况下，子类和父类中有相同实例特性参数，输入多少个呢？相同的输入一个即可，如代码4

代码1
class Model:
    def __init__(self,name):
        self.name=name
class Child(Model):
    def save(self):
        print('ok')
child=Child()
#TypeError: __init__() missing 1 required positional argument: 'name'

代码2
class Model:
    def __init__(self,name):
        self.name=name
class Child(Model):
    def __init__(self,name):
        self.name=name
    def save(self):
        print('ok')
child=Child('yq')  #ok

代码3
class Model:
    def __init__(self,age):
        self.age=age
class Child(Model):
    def __init__(self,name):
        self.name=name
    def save(self):
        print('ok')
child=Child('yq',20)
child.save()  #__init__() takes 2 positional arguments but 3 were given

代码4
class Model:
    def __init__(self,name,age):
        self.name=name
        self.age=age
class Child(Model):
    def __init__(self,name,age):
        super().__init__(name,age)
        self.name=name
    def save(self):
        print('ok')
child=Child('yq',20)
child.save()  #ok

下面再给出一个例子，用super调用父类方法，上面例子为__init__()方法，下面为super方法来调用父类中非__init__()方法

不过我们应该不会这样写，直接用子类覆盖掉父类方法即可，这样写感觉比较混乱。

class A:
    def read(self,name2):
        self.name2=name2
        print('{} is read'.format(self.name2))
class B(A):
    def read(self,name1,name2):
        self.name1=name1
        print(self.name1)
        super().read(name2)
        print('{} and {} read:python is very good!'.format(self.name1,self.name2))
a=B()
a.read('cmj','yq')
# cmj
# yq is read
# cmj and yq read:python is very good!

 7、self的自辩

python中经常被争议一点就是必须把self设置为实例方法的第一个参数。python使用self参数来找到正确的对象所包含的特性和方法。

car=Car()
car.exclaim()   #i am a Car!

python在背后做了以下两件事情：

1、查找car对象所属的类（Car）；

2、把car对象作为self参数传给Car类所包含的exclaim()方法

8、使用属性对特性进行访问和设置 装饰器

# 修饰符（ decorator）。下一个例子会定义两个不同的方法，它
# 们都叫 name()，但包含不同的修饰符：
# • @property，用于指示 getter 方法；
# • @name.setter，用于指示 setter 方法。
class Duck:
    def __init__(self,input_name):
        self.hidden_name=input_name
    @property
    def name(self):
        print('inside the getter')
        return self.hidden_name
    #如果你没有指定某一特性的 setter 属性（ @diameter.setter），
    #那么将无法从类的外部对它的值进行设置。
    @name.setter
    def name(self,input_name):
        print('inside the setter')
        self.hidden_name=input_name
fowl=Duck('yang')
fowl.name='abc'   #输出 inside the setter 调用了name.setter属性
print(fowl.name)  #输出inside the getter   abc

9、使用名称重整保护私有属性

怎么写怎么调用即可

10、方法的类型

有些属性和方法是类本身的一部分，还有一些是由类创建的实例的一部分。

在类的定义中，以self作为第一个参数的方法都是实例方法(instance method)。他们在创建自定义类时最常用。实例方法的首个参数是self，

当它被调用时，python会把调用该方法的对象作为self参数传入。

与之相对，类方法(classmethod)会作用于整个类，对类作出的任何改变会对它的所有实例对象产生影响。在类定义内部，用前缀修饰符

@classmethod指定的方法都是类方法。与实例方法类似，类方法的第一个参数都是类本身。在Python中，这个参数常被写作cls，因为全称

class是保留字，在这里无法使用。

类方法不能访问实例属性！！参数必须传入cls！！（即代表了此类对象与self代表实例对象区别），并且用此来调用类属性：cls.类属性名

静态方法不能访问实例属性！！参数不能传入self！！与类相关当事不依赖类与实例的方法！！

##静态方法与类方法都可以通过类火灾实例来调用，其两个特点都是不能调用实例属性。

类定义三种类型：类属性、类方法和静态方法
class A():
    count=0
    def __init__(self):
        A.count+=1
    def exclaim(self):
        print("i'm an A!")
    @classmethod
    def kids(cls):
        print('A has',cls.count,'little objects')  #cls.count 等价于 A.count
        #print('A has',A.count,'little objects')
    @staticmethod
    def hi():
        print('hi,jim!')
easy_a=A()
print(A.kids())  #A has 1 little objects
breezy_a=A()
print(A.kids())  #A has 2 little objects
wheezy_a=A()
A.kids()         #A has 3 little objects
A.hi()           #hi,jim!
注意，上面的代码中，我们使用的是A.count(类属性，有别于实例属性self.count)，在kids()
方法中，我们使用的是cls.count，它与A.count的作用一样
类定义中的静态方法(static method),用@staticmethod修饰，既不会影响类的对象，
出现只是为了方便

 思考如下代码

class A:
    a=10
    def run():
        print('a is running')
a=A()
a.run()
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-60-c7e444286c71> in <module>()
      4         print('a is running')
      5 a=A()
----> 6 a.run()

TypeError: run() takes 0 positional arguments but 1 was given

class A:
    a=10
    def run(self):
        print('a is running')
a=A()
a.run() #a is running

class A:
    a=10
    @classmethod
    def run(cls):  #必须要cls参数，否则报TypeError: run() takes 0 positional arguments but 1 was given
　　　　print('a is running')
a=A()
a.run() #a is running

使用类方法来调用类属性

class A:
    a='jim'
    @classmethod
    def run(cls):
        b=a
        print('{} is running'.format(b))
x=A()
print(x.run())  #<__main__.A object at 0x00000188456C6470> is running

class A:
    a='jim'
    @classmethod
    def run(cls):
        b=cls.a
        print('{} is running'.format(b))
x=A()
print(x.run())  #jim is running

11、鸭子类型

当我们输入像 a = 3 + 8 这样的式子时，整数 3 和 8 是怎么知道如何实现 + 的？同样， a又是怎么知道如何使用 = 来获取计算结果的？你可以使用 Python 的特殊方法（ special method），有时也被称作魔术方法（ magic method），来实现这些操作符的功能。
这些特殊方法的名称以双下划线（ __）开头和结束。没错，你已经见过其中一个： __init__，它根据类的定义以及传入的参数对新创建的对象进行初始化。假设你有一个简单的 Word 类，现在想要添加一个 equals() 方法来比较两个词是否一致，忽略大小写。也就是说，一个包含值 'ha' 的 Word 对象与包含 'HA' 的是相同的。

class Word():
    def __init__(self,text):
        self.text=text
    def equals(self,word2):
        return self.text.lower()==word2.text.lower()
first=Word('ha')
second=Word('HA')
third=Word('eh')
print(first==second)         #False
print(first.equals(second))  #True
print(first.equals(third))   #False

class Word():
    def __init__(self,text):
        self.text=text
    def __eq__(self,word2):
        return self.text.lower()==word2.text.lower()
    def __add__(self,word3):
        return self.text+word3.text
    def __mul__(self,word4):
        return self.text*word4.text
first=Word('ha')
second=Word('HA')
third=Word('eh')
four=Word('yq')
five=Word(4)
if __name__=='__main__':
    print(first==second)         #True
    print(first==third)          #False
    print(four+third)            #yqeh
    print(first*five)            #hahahaha
# 太神奇了！是不是如同魔术一般？仅需将方法名改为 Python 里进行相等比较的特殊方法名
# __eq__() 即可。

12、组合

如果你想要创建的子类在大多数情况下的行为都和父类相似的话（子类是父类的一种特
殊情况，它们之间是 is-a 的关系），使用继承是非常不错的选择。建立复杂的继承关系确
实很吸引人， 但有些时候使用组合（ composition） 或聚合（ aggregation） 更加符合现实的
逻辑（ x 含有 y，它们之间是 has-a 的关系）。

class Tail():
    def __init__(self,length):
        self.length=length
class Duck():
    def __init__(self,bill,tail):
        self.bill=bill
        self.tail=tail
    def about(self):
        print('this duck has a',bill.description,'bill and a',
             tail.length,'tail')
tail=Tail('long')
bill=Bill('wide orange')
duck=Duck(bill,tail)
duck.about()  #this duck has a wide orange bill and a long tail

13、何时使用类和对象而不是模块

当你需要许多具有相似行为（ 方法）但不同状态（特性）的实例时，使用对象是最好的选择。

类支持继承，但模块不支持。

用最简单的方式解决问题。 使用字典、列表和元组往往要比使用模块更加简单、简洁且
快速。而使用类则更为复杂。