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_