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 类,面向对象初探的主要内容,如果未能解决你的问题,请参考以下文章

Java学习笔记之十三初探Java面向对象的过程及代码实现

JavaScript初探系列之面向对象

[Java初探07]__关于面向对象的简单认识

Go语言的面向对象模型初探

Javascript 面向对象编程初探--- 封装

python之路之前没搞明白4面向对象(封装)