6.13-Python-语言及其应用-笔记-对象和类--未完!

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


2.创建类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 !'

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

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

5.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'        

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

9.鸭子类型,多态的类型,意味着我们对不同的对象调用同名的操作,不需要这些对象的类型是什么,多态的意思是,同一个函数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)

10.组合方式,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()

11.使用对象----类----模块,封装位置是有要求的
P124

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’) 才是真正的命名元组的样子,命名元组类似于不可辨对象,可以改变里面域的值,但是不能增加域,
这个和字典不一样!字典不仅可以改变域值,还可以增加域值

dict_
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值