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 abcclass 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 详细见　进阶篇