python 类,面向对象初探
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python 类,面向对象初探相关的知识,希望对你有一定的参考价值。
概述:
面向对象 是一种编程方式(OOP Object Oriented Programming).
三大编程范式:
一、面向过程
二、函数式编程
三、面向对象编程
Why:
面向对象的程序的程序设计:
python里要不就用面向过程,要不就用面向对象,两种编程网络
面向对象的程序设计:
可控性差,面向对象只解决了可扩展性的问题,一个软件包括了多个特性如图:
可见,面向对象并不是万能的。
How ( 如何使用面象对象编程)
第一步:面向对象的程序设计:OOD:
------找--------〉 对象归类(归纳对象共同的特征与技能,还有每个对象独有的特征。)
先定义类: 实例化对象
EXAMPLE: 如下例子,
程序设计: 例如学校有: # 定义学生类 共同的特征: Country=’China’ 共同的技能:查看成绩 独有的特征:ID、名字,性别,省
编程:
用def 做面向对象编程
编程: def Student: country=‘China‘ def __init__(self,ID,NAME,SEX,PROVINCE): self.id=ID self.name=NAME self.sex=SEX self.province=PROVINCE def search_score(self): print(‘tell score‘) def study(self): print(‘study‘)
用class 面向对象编程:
例如, 恐怖份子这一类,基本上都人手一把AK47 , 这是必须的,因为他们想捣乱, . 然后他们可以去破坏五角大楼, 还能引起国家战争, .
#defind class
class terrorist: #恐怖份子 这个类
gun=‘ak47‘ #都有AK47
def trouble(): #能去破坏五角大楼
print(‘destory Amercan the Pentagon‘)
def warfare(self): #能引起国家战争
print(‘country warfare %s‘%self)
# print(terrorist.gun)
# terrorist.trouble() # . 类. 点后面就可以调用 这个类的功能, 这个类能干什么.
# terrorist.warfare(‘Iraq,muslin‘)
WHAT?
类型与类:
Python3 中,将类型和类统称为类
经典类与新式类:
在python3 当中类都是新式类(广度优先)。 而在python2.x当中新式类是class B(objcet) : pass
例如继承 B 的类 class C(B)
python2.x中的是经典类:经典类是深度优先
面向对象编程OOP:
类 是同一类事物特征的集合,对象是技能的结合体。
类的属性:
类的属性:数据属性与函数属性
调用方式通过 .点的方式就可引用类的属性
类属性的增、删、改、查
class Chinese: ‘this is chinese class‘ dang=‘中华人民‘ country=‘China‘ def __init__(self,name,age,gender): # print(‘I"m initailize ‘) self.name=name self.age=age self.gender=gender # self.sui_di_tu_tan=‘ok tu‘ # print(‘I"m over ‘) def sui_di_tu_tan(self): print(‘吐一口痰‘) def cha_dui(self): print(‘插到了前面‘) def eat_food(self,food): print(‘%s 正在吃 %s‘%(self.name,food)) def play_basketball(self,ball): print(‘%s 正在打 %s‘%(self.name,ball)) # p1=Chinese(‘tony‘,19,‘male‘) # print(p1.__dict__) #查看对象的属性字典,这里对象只有数据属性,函数属性都是引用类的函数属性。 对象(实例)是没有自己的函数属性的。 # print(p1.gender) # print(p1.name) # print(p1.sui_di_tu_tan) # p1.eat_food(‘baozi‘) # p2=Chinese(‘wu sir ‘,100,‘nianmen‘) # p2.eat_food(‘jiucaixianbin‘) # print(dir(p2)) # print(Chinese.country) # Chinese.country=‘American‘ # print(Chinese.country) # p1=Chinese(‘tony‘,‘29‘,‘male‘) # print(p1.country) # # Chinese.food=‘fang‘ # print(Chinese.food) # del Chinese.eat_food # print(Chinese.food) # def dance(self,wu): # print(‘%s 正在跳%s‘%(self.name,wu)) # Chinese.dance=dance # # print(Chinese.dan) # p1.dance(‘tuoyiwu‘) # print(Chinese.dang) # # print(Chinese.sui_di_tu_tan()) # # print(dir(Chinese)) # Chinese.__dict__[‘sui_di_tu_tan‘]() # Chinese.__dict__[‘cha_dui‘](‘af‘) # # print(Chinese.__doc__) # print(Chinese.__class__) p1=Chinese(‘liang‘,18,‘man‘) # print(p1.name) # p1.play_basketball(‘backetball‘) # print(p1.play_basketball) p1.hobby=‘women‘ # print(p1.hobby) def aihao(self): print(‘women’) p1.aihao=aihao # print(p1.__dict__) # p1.aihao(‘self‘) #实例不能自己定义函数属性,因为这违反了class自动传self 的功能。 #所以实例只能有数据属性,能定义函数属性是因为修改了__dict__ del p1.gender # p1.gender=‘women‘ # print(p1.gender) # print(p1.__dict__) # p1.gender=‘male‘ # print(p1.gender) class People: contry=‘China‘ l=[1,2,3] def __init__(self,name): self.name=name p1=People(‘liang‘) print(p1.l) # p1.l=[‘a‘,‘b‘] p1.l.append(‘cc‘) p1.contry=‘japan‘ print(People.l) print(p1.__dict__) print(p1.l)
继承:
继承是一种创建新的类:解决代码重用
定义一个电脑的类,电脑有很多的品牌,再多的牌子它们还是电脑
继承父类与子类的关系是 ‘是’ 的关系,如:人是动物,狗也是动物,
都继承动物类。
#!-*- coding:utf-8 -*- class Compute: def __init__(self,name,cpu,disk,mem): self.name=name self.cpu=cpu self.disk=disk self.mem=mem def read_file(self,cpu): print(‘cpu running read_file‘) def brand(self,name): print(‘brand is %s‘%name) class Thinkpad(Compute): def __init__(self,name,cpu,disk,mem,small_read): Compute.__init__(self,name,cpu,disk,mem) self.small_read=small_read print(small_read,disk) def price(self,price): print(‘price is %s‘%price) Thinkpad_x220=Thinkpad(Thinkpad,‘thinkpad_x220‘,‘i7‘,‘200GB‘,‘yes‘,) Thinkpad_x220.price(20000) print(Thinkpad_x220) print(Thinkpad.__bases__)
查看继承:
print(‘我是继承查看‘,Thinkpad.__bases__)
继承不是遗传
组合:(为了节省代码) 组合是‘有’的关系,电脑可以WIND7 MACOS ,但电脑不是 WIN7 MACOS
#使用组合 实现功能 class Thinkpad: def __init__(self,name,years,system): self.name=name self.years=years self.system=system class lenvo: def __init__(self,name,years,system): self.name=name self.years=years self.system=system class Mac: def __init__(self,name,years,system): self.name=name self.years=years self.system=system class System: def __init__(self,name): self.name=name # print(‘oprate system is %s‘%name) oprate_sys=System([‘windows 7 ‘,‘Mac OS‘]) oprate_mac=System(‘Mac OS‘) compute1=Thinkpad(‘x220‘,‘2010‘,oprate_sys) compute2=lenvo(‘lenvo E430‘,‘2010‘,oprate_sys) compute3=Mac(‘Mac Air‘,‘2010‘,oprate_sys) print(compute1.system.name[0]) print(compute2.system.name[0]) print(compute3.system.name[1]) import abc print(lenvo.__bases__) print(Mac.__bases__)
接口归一化设计:
把应该有的功能实现一个集合体,然后子类来实现
抽象类: 上述的rais 抛出异常的方式不可取,
本质还是类,与类的区别在于,与变通类的额外的特点是:加了装饰器函数,子类必须实现他们
练习:
定义老师类,把老师的属性:薪资,隐藏起来,然后针对该属性开放访问接口 苑昊老师有多种癖好,把这种癖好隐藏起来,然后对外提供访问接口,而且以后还会苑昊老师培养很多其他的癖好,对外开放修改接口,可以新增癖好,并且需要保证新增的癖好都是字符串类型,否则无法增加成功。 class Teacher(object): __salary=25000 __hobby=[‘somke‘,‘drink‘] def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def hobby_modify(self,mod_hobby): if type(mod_hobby) is str: Teacher.__hobby.append(mod_hobby) print(‘you hobby very special‘) else: print(‘Can\\‘t be number or sign‘) def salary(self): """隐藏属性 查看接口""" print(‘salary: %s‘%Teacher.__salary) def hobby(self): return(Teacher.__hobby) T1=Teacher(‘yh‘,‘23‘,‘male‘) T4=Teacher(‘eg‘,‘22‘,‘male‘) T2=Teacher.hobby(T1) T2=T2[:] T3=‘,‘.join(T2) #teacher eg hobby print(‘__________________________________________________‘) def func1(n): n.name func1(T4) T4.salary() T4.hobby_modify(‘running‘) print(T4.name,T4.age,‘%s habby %s‘%(T4.name,T4.hobby())) print(‘__________________________________________________‘) # 访问隐藏属性 def func(n): n.salary() func(T1) print(‘teacher %s have %s‘% (T1.name,T3)) mod_hobby=Teacher.hobby_modify(T1,‘drive car‘) print(Teacher.hobby(T1)) print(‘----------------------------‘)
多态与多态性:
一种事物 不同的形态,多态指的是一类事物有多种形态,(一个抽象类有多个子类,因而多态的概念依赖于继承)
##一切皆文件:多态 与多态性练习题
import abc
class All_file(metaclass=abc.ABCMeta):
@abc.abstractmethod
def all(self):
pass
class disk(All_file):
def all(self):
print(‘disk is file‘)
class process(All_file):
def all(self):
print(‘process is file‘)
class Txt(All_file):
def all(self):
print(‘Txt file is file‘)
d1=Txt()
d2=disk()
# print(d1.all())
def func(d1):
d1.all()
func(d1)
func(d2)
多态性:
多态性是指具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名调用不同内容的函数。
多态性分为静态多态性和动态多态性
多态性是‘一个接口(函数func),多种实现(如f.click())
派生:
继承是子类继承父类,但是子类都有自己类的特征,这个就叫做“派生”。如果子类有自已的特征且与父类的特征有重名,就找自己的特征
但是又要在父类的基础上增加自己的功能,那就是重用父类的特征加上自己的特征。
在子类中调用父类的特征。
封装:
封装:
第一层封装:
第一个层面的封装(什么都不用做):创建类和对象会分别创建二者的名称空间,我们只能用类名.或者obj.的方式去访问里面的名字,这本身就是一种封装
第二层封装:
__名字(双下划线),这种语法,只在定义的时候才会有变形的效果,如果类或者对象已经产生了,就不会有变形效果。
在python中用双下划线的方式实现隐藏属性(设置成私有的)
要想不让外部访问需要用到一个函数property 详细见 进阶篇
以上是关于python 类,面向对象初探的主要内容,如果未能解决你的问题,请参考以下文章