6.13-Python-语言及其应用-笔记-对象和类--未完！_python语言及其应用组合报错-CSDN博客

本文链接：https://blog.csdn.net/shichangcheng1314/article/details/73196141

１.对象的定义　
num = 8 ,’8’ 本身是一个对象，属于整数类，’8’这个对象包含属性，函数，对象是某一个具体事物的特别实例！当你创建一个别人从没有的对象的时候需要先定义一个类，指明这个类型的对象包含的内容

２.创建类class ,引入特殊化的对象化初始化对象_ init_(),
init()作用是根据类创建对象的实例

class Person(self):
    def __init__(self,name):
        self.name = name
    def saySth():
        print 'I am Person' 
>>> hunter = Person('Sam')

3.继承+覆盖,子类可以覆盖父类的所有方法，包括init()方法，如下图

class Sam(Person):
    def __init__(self,name):
        self.name = 'Doctor'+name
    def saySth():
        print 'I am Sam !'

４.super 表示需要调用父类的方法,理解为需要父亲的帮助,super.init(name)调用的是父类的函数，self.email =email是子类的函数`

class EmailPerson():
    def __init__(self,name,email):
        super.__init__(name)
        self.email =email

５.self变量的理解,Python利用self 找到对象对应的属性和方法　

person1 = Person():
>>>person1.saySth()

6.使用属性对特性进行访问和设置
面向对象的语言支持私有特性，私有特性没有办法从对象外部进行访问,@property属性函数

基础版本

class Duck():
    def __init__(self,input_name):
        self.name =input_name
    def get_name(self):
        print 'This is for get_name'
        return self.name
    def set_name(self):
        print "this is for set_name"
        self.hidden_name = input_name
    name = property(get_name,set_name)

利用装饰器定义属性，使用两个不同的装饰器的定义两个相同名字的函数
相对于上面的函数，不再有显式的get_name()，
@name.setter这个name 代表了属性，可以变化，两个name 函数都是对name 属性进行操作一个是get，一个set操作

class Duck():
    def __init__(self,input_name):
        self.name =input_name
    @property 
    def name(self):
        print ' inside the getter'
        return self.hidden_name
    @name.setter
    def name(self,name):
        print 'inside the setter '
        self.hidden_name =input_name

7.利用名称重组保护私有特性，利用__ 方式，这样的方式本质上并没有把特性变成私有，python 虽然把它的名字进行重整，使得外部的代码不能使用,“不能使用”的意思是不能通过属性的方式直接访问,fowl. __name 的形式，必须通过里面的函数name ,(get(),set()方法)，
实际上，python 只是改变访问的名称，如果你通过fowl._Duck__name　也是可以直接访问内部属性的，所以还是说python的保护机制不是很完整的！

class Duck():
    def __init__(self,input_name):
        self.__name = input_name
    @property
    def name(self):
        print('inside the getter')
        return self.__name
    @name.setter
    def name(self,input_name):
        print ('inside the setter')
        self.__name = input_name
>>>fowl =Duck('Howrad')
>>>fowl.name
'Howrad'
>>>fowl.name = 'Hpwrad'
inside the setter
>>>fowl.name 
inside the getter
'Donald'

８.方法的类型，有些数据和函数是类的一部分，有些是＂由类产生的实例＂的一部分，
在类中有三种函数，一种是类函数（class method）一种是实例函数（instance method）,实例函数的第一个参数对象本身，常用self 表示
类函数第一个参数是类本身，常用cls表示
第三种类中方法定义的方式，静态方法（static method）既不会影响类也不会影响对象，只会影响逻辑，也不需要self 和cls 参数，定义的时候＠staticmethod 表明

９.鸭子类型，多态的类型，意味着我们对不同的对象调用同名的操作，不需要这些对象的类型是什么,多态的意思是，同一个函数says函数，可以有三种不同的响应方式

>>>class Quote():
    def __init__(self,person,words):
        self.name =person
        self.words = words
    def who(self):
        return self.name
    def says(self):
        return self.words +'.'
>>>class QuestionQuote(Quote):
    def say(self):
        return self.words+'?'
>>>class ExclamationQuote(Quote):
    def says(self):
        return self.words+'!'

python 在多态的路上可以走的更加远，无论对象的类型是什么，只需要里面有对应的函数就可以调用它，举例子！创建一个和上面完全没有关系的类BabblingBrook(),里面有对应的say() 和who() 函数

hunter = Quote('Elmer Fudd','"I" am hunting wabbites')
hunter1 = QuestionQuote('Bugs Buggy','I am a girl')
brook = BabblingBrook()
#定义一个who_says函数,然后分别把上面三个对象放入，第三个对象和前两个都是没有关系的，但是都可以放入who_says这个函数中去

def who_says(obj):
    print (obj.who(),'says',obj.says())
>>>who_says(hunter)
>>>who_says(hunter1)
>>>who_says(brook)

１０.组合方式,is_a 和has_a 的组合方式,感觉是对上面父类＋子类模式的改变和补充，有一种has_a 的形式

class Bill():
    def __init__(self,description):
        self.description = description
    def Tail():
        def __init__(self,length):
            self.length = length 
    def Duck(self,bill,tail):
        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()

１1.使用对象－－－－类－－－－模块，封装位置是有要求的
Ｐ１２４

12 命名元组(named tuple),是元组的子类，不是python 自动支持的类型，需要在开始的时候进行模块加载工作from collections import namedtuple ,域名之间区别标致是　空格，下面这个例子的Duck，就是为了说明区分标致不是，
Duck = namedtuple(‘Duck’,’bill tail’) 是初始化named tuple，Duck(‘wide oragne’,’long’)是为了向里面传入值，duck 才是named tuple类型的！　　

>>>from collection import namedtuple
>>>Duck = namedtuple('Duck','bill tail')
>>>duck =Duck('wide oragne','long')
>>>duck
>>>Duck(bill='wide orange',tail='long')
>>>duck.bill
>>>duck.tail

Duck(bill=’wide orange’,tail=’long’)　才是真正的命名元组的样子，命名元组类似于不可辨对象，可以改变里面域的值，但是不能增加域，
这个和字典不一样！字典不仅可以改变域值，还可以增加域值