Python基础篇-day7

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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)是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。
那么,多态的作用是什么呢?我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用!多态的作用,就是为了类在继承和派生的时候,保证使用“家谱”中任一类的实例的某一属性时的正确调用。

























































































































































































































































以上是关于Python基础篇-day7的主要内容,如果未能解决你的问题,请参考以下文章

Python基础篇第2篇: Python文件操作

Python基础篇

python基础篇

[资料分享]Python视频教程(基础篇进阶篇项目篇)

Python基础篇第1篇: 内置库模块 OS

python基础篇