Python基础篇-day7

本节目录-面向对象
1 类介绍
1.1 面向对象oo特征
1.2 类的特性
1.3 创建与调用
1.3.1 基本结构
1.3.2 结构说明
1.3.3 对外部提供只读访问接口
1.3.4 析构方法
2 继承
2.1 继承介绍
2.2 横向关系（组合）VS纵向关系（继承）
2.3 内置函数
2.3.1 issubclass
2.3.2 isinstance
2.3.3 hassttr

1 类介绍
1.1 面向对象oo特征
oo=Object Oriented
1、封装---信息隐蔽技术
2、继承---子类自动共享父类之间数据和方法的机制
3、多态---不同对象对同一方法响应不同的行动(不同的class中可以含有相同的函数名，响应根据函数中的定义进行)

1.2 类的特性
封装:
1、防止数据被随意修改； 2、使外部程序不需要关注对象内部的构造，只需要通过此对象对外提供的接口进行直接访问即可；
继承：
通过父类-子类的方式以最简洁的方式实现，不同角色

1.3 创建与调用
1.3.1 基本结构
类创造对象，对象称为类的一个实例（实例对象）
类对象（class、大写字母开头）=属性（变量）+方法（函数）
class Tirle:#python中类以大写字母开头

class Dog(object):
nation = 'china' #公有属性
def __init__(self,name,food): #构造函数、构造方法==初始化函数
self.name = name #成员属性
# self.food = food
self.__heart = 'namal' #私有属性

def wark(self): #类的方法
print('%s is dog'% self.name)
def eat(self,food):
print("%s is eating %s" %(self.name,food))

D = dog('sss','dutou') #实例化后产生的对象称为实例
D.wark()
D.eat('baozi')

1.3.2 结构说明
类-->>实例化-->>实例
self 就是调用当前方法的对象
__init__ #构造方法
返回值为None，强制添加返回值会报错TypeError:__init__() should return None
self.name = name #属性--成员属性 外部可以调用，并且内部方法也可以调用
self.__name = name #私有属性(对外部不可见，内部的方法可以调用)
__private_attr_name = value私有属性
def sayhi() #方法
++++++++++++++++++++++++++
__init__(self)方法:构造方法
返回值为None，强制添加返回值会报错TypeError:__init__() should return None
>>> class ball:
def __init__(self,name):
self.name = name
def kick(self):
print ('I am %s , who kick me' % self.name)
>>> a = ball('A')
>>> a.kick()
I am A , who kick me
>>> a = ball() #----->>必须添加参数、否则报错
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
a = ball()
TypeError: __init__() missing 1 required positional argument: 'name'
添加默认参数：
>>> class ball:
def __init__(self,name='null'):
self.name = name
def kick(self):
print ('I am %s , who kick me' % self.name)
>>> a = ball('A')
>>> a.kick()
I am A , who kick me
>>> a = ball()
>>> a.kick()
I am null , who kick me
不添加默认参数会报错：
++++++++++++++++++++++++++

1.3.3 对外部提供只读访问接口
def get_heart(self): #比较安全
return self.__heart
强制访问私有属性:
r1._Role__heart

公有属性:所有实例化的对象都可以访问的属性为公有属性(在类中直接定义)
Role.nation = 'US' 更改公有属性
+++++++++++++++++++++++++++++++++
私有变量或者函数：在python中定义私有变量或者函数只需要在变量名或函数名前加上“__”两个下划线
>>> class person():
__name = "a"
def getname(self):
return self.__name
>>> p = person()
>>> p.__name
Traceback (most recent call last):
File "<pyshell#52>", line 1, in <module>
p.__name
AttributeError: 'person' object has no attribute '__name'
>>> p.getname()
'a'
伪私有：将变量或者函数改成"_类名__变量名"的形式
>>> p._person__name
'a'
+++++++++++++++++++++++++++++++++

1.3.4 析构方法
删除实例化的实例
def __del__(self):
print("del--run")

2 继承
2.1 继承介绍
继承概念的实现方式主要有2类：实现继承、接口继承。
实现继承是指使用基类的属性和方法而无需额外编码的能力；
接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)；

多继承时--继承顺序的区别(py2中才能体现，py3全部使用广度查询的方式进行继承)
新式类，查询使用广度查询，将同级的所有类全部查询完毕才继续往上一层类中查找
经典式类，查询使用深度查询，将纵深的所有类全部查询完毕才继续同一层的其他层中查找

class 子类（基类、父类、超类）
class DerivedClassName(BaseClassName):
……
>>> class parent:
def hello(self):
print ('old jaksjd parent')
>>> class child(parent):
pass
>>> p = parent()
>>> p.hello()
old jaksjd parent
>>> c = child()
>>> c.hello()
old jaksjd paren
注意：如果子类中定义与父类同名的方法或者属性，在调用时调用自己的属性或者方法。
>>> class parent:
def hello(self):
print ('old jaksjd parent')
>>> class child(parent):
def hello(self):
print ('new jaksjd child')
>>> p = parent()
>>> p.hello()
old jaksjd parent
>>> c = child()
>>> c.hello()
new jaksjd child

注意：经典类VS新式类 #建议使用新式类
class Person(object): #new style
super
class Person: #classical style
ParentClass.__init__
#SchoolMember.__init__(self,name,age,sex) #经典类继承写法
super(Teacher,self).__init__(name,age,sex) #新式类继承写法

2.2 横向关系（组合）VS纵向关系（继承）
class tutle:
def __init__(self,x):
self.num = x

class fish:
def __init__(self,x):
self.num = x
class pool:
def __init__(self,x,y):
self.tutle = tutle(x)
self.fish = fish(y)
def print_num(self):
print('the totel of tutle is %d in the pool,the totel of fish is %d in the pool!' % (self.tutle.num,self.fish.num))
>>> pool = pool(1,10)
>>> pool.print_num()
the totel of tutle is 1 in the pool,the totel of fish is 10 in the pool!

Mix_in
绑定：
python严格要求方法需要有实例才能被调用，这种限制就是python的绑定。

2.3 内置函数
所有的类的统称为：object
2.3.1 issubclass
issubclass(class,classinfo)检查class是否是classinfo的一个子类，是则返回true
1、一个类被认为是自身的一个子类
2、classinfo可以是类对象组成的元组，只要class是其中任何一个候选类的子类，则返回true
>>> class a:
pass
>>> class b(a):
pas
>>> class c :
pass
>>> issubclass(a,b)
False
>>> issubclass(b,a)
True
>>> issubclass(a,a)
True
>>> issubclass(c,b)
False
>>> issubclass(a,object)
True

2.3.2 isinstance
isinstance(object,classinfo)检查一个实例对象object是否属于一个类classinfo，
1、如果第一个参数不是对象，则永远返回false
2、如果第二个参数不是类或者由类对象组成的元组，会抛出TypeError异常
>>> b1 = b()
>>> isinstance (b1,b)
True
>>> isinstance (b1,a)
True
>>> isinstance (b1,(a,b,c))
True

2.3.3 hassttr
attr = attribute:属性
hassttr(object,name)检查一个对象是否有指定的属性
name表示一个属性名，需要用单引号将其括起来，格式为：‘name’
>>> class C:
def __init__(self,x=0):
self.x=x
>>>
>>> c1 = C()
>>> hasattr(c1,'x')
True
>>> hasattr(c1,'y')
False
>>> hasattr(c1,x)
Traceback (most recent call last):
File "<pyshell#26>", line 1, in <module>
hasattr(c1,x)
NameError: name 'x' is not defined
getattr(object,name[,default])返回一个对象中指定的属性的值；如果指定的属性不存在，当
含有default参数时返回默认值，否则返回no attribute 'name'
>>> getattr(c1,'x')
0
>>> getattr(c1,'y')
Traceback (most recent call last):
File "<pyshell#28>", line 1, in <module>
getattr(c1,'y')
AttributeError: 'C' object has no attribute 'y'
>>> getattr(c1,'y',"您所访问的属性不存在……")
'您所访问的属性不存在……'
setattr(object,name,value)设置一个对象中指定属性的值，如果指定的属性不存在则新建属性并赋值
>>> setattr(c1,'y','fish')
delattr(object,name)删除一个对象中指定的属性，如果指定的属性不存在则抛出AttributeError
>>> getattr(c1,'y')
'fish'
>>> delattr(c1,'y')
>>> delattr(c1,'y')
Traceback (most recent call last):
File "<pyshell#36>", line 1, in <module>
delattr(c1,'y')
AttributeError: y
property(fget=None,fset=None,fdel=None,doc=None)用过属性来控制属性
>>> class C:
def __init__(self,size=10):
self.size=size
def getsize(self):
return self.size
def setsize(self,value):
self.size=value
def delsize(self):
del self.size
x=property(getsize,setsize,delsize)
>>> c1=C()
>>> c1.size
10
>>> c1.getsize()
10
>>> c1.x=18
>>> c1.getsize()
18

3 多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。