首页 > 代码库 > python 类,面向对象初探
python 类,面向对象初探
概述:
面向对象 是一种编程方式(OOP Object Oriented Programming).
三大编程范式：
一、面向过程
二、函数式编程
三、面向对象编程
Why:
面向对象的程序的程序设计：
python里要不就用面向过程，要不就用面向对象，两种编程网络
面向对象的程序设计：
可控性差，面向对象只解决了可扩展性的问题，一个软件包括了多个特性如图：
可见，面向对象并不是万能的。
Ｈow
( 如何使用面象对象编程)
第一步：面向对象的程序设计：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 类,面向对象初探