类与对象

面向对象设计

1.函数式编程

2.面向过程编程

3.面向对象编程

 

利用函数也可以实现面向对象编程

def peple(name,gender):
    def head(peple):
        print("this is %s head"%peple["name"])
    def hand(peple):
        print("this is %s hand"%peple["name"])
    def stomach(peple):
        print("this is %s stomach"%peple["name"])
    def init(name,gender):
        choice = {
            "name" :name,
            "gender":gender,
            "head": head,
            "hand" :hand,
            "stomach":stomach}
        return choice
    return init(name,gender)
d1 = peple("alex","female")
print(d1)
d1["hand"](d1)
d2 = peple("pppp","male")
d2["stomach"](d2)

利用类也可以实现面向对象编程

class Peple:
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender
    def head(self):
        print("this is %s head"%(self.name))
    def hand(self):
        print("this is %s hand"%(self.name))
    def stomach(self):
        print("this is %s stomach"%(self.name))
d1 = Peple("alex","female")
d1.hand()
d2 = Peple("pppp","male")
d2.stomach()

 

类名.__dict__ 可以查看类里面所有属性和对象。

 

静态属性

@proprty 能让类的一个函数改为看似是普通数据的属性，即是不需要加括号直接点之后就能访问。self=实例本身

类方法

@classmethod 能让类的一个函数改为类能直接调用的函数，不参与实例的数据属性，即没有self参数了，改为cls参数。cls=类名

类的工具包，即静态方法

@staticmethod 在类里的函数加上这个后，任何一个实例都不能调用它。

 

组合

class School:
    def __init__(self,name,address):
        self.name = name
        self.address = address
class Course:
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school=school
s1 = School("华联","广州")
s2 = School("南中","广州南村")
msg = '''
    1 ：华联 广州
    2 ：南中 广州南村
    '''
dic_coures = {
    "1":s1,
    "2":s2
}
while True:
    print(msg)
    a1 = input("请输入您选择的地区：")
    chioce = dic_coures[a1]
    name = input("请输入课程名字：")
    price = input("请输入价格：")
    period = input("请输入学时：")
    c1 = (name,price,period,chioce)
    print(c1)

 继承

class aaa:
    def __init__(self,n):
        self.n=n
    def aaa(self):
        print("%sa" %self.n)
class bbb(aaa):
    def __init__(self,n):
        self.n =n
    def bbb(self):
        print("%sb" % self.n)
b = bbb(2)
print(b.bbb())
print(b.aaa())
#此时的aaa能被bbb调用

 派生

是继承原有的函数后，在继承父类函数名字下更新了新的功能叫做派生，可以理解为衍生出新的代码、

 

接口继承

 

import abc
class All_file(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def read(self):
        pass

    @abc.abstractmethod
    def write(self):
        pass
#导入abc 然后父类定义一个固定的格式叫做接口，父类可以不实现功能
class Disk(All_file):
    def read(self):
        print('disk read')

    def write(self):
        print('disk write')

class Cdrom(All_file):
    def read(self):
        print('cdrom read')

    def write(self):
        print('cdrom write')


class Mem(All_file):
    def read(self):
        print('mem read')

    def write(self):
        print('mem write')

 利用super方法实现父类的调用

class Vehicle1:
    Country='China'
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print('开动啦')
        print('开动啦')
class Subway(Vehicle1):
        def __init__(self,name,speed,load,power,line):
           # Vehicle.__init__(self,name,speed,load,power)
           # super().__init__(name,speed,load,power)  #super(__class__,self).__init__(name,speed,load,power)
           super(Subway,self).__init__(name,speed,load,power)
           self.line=line
        def show_info(self):
            print(self.name,self.speed,self.load,self.power,self.line)
        def run(self):
            # Vehicle.run(self)
            super().run()
            print('%s %s 线，开动啦' %(self.name,self.line))
line13=Subway('北京地铁','10km/s',1000000000,'电',13)
line13.show_info()
line13.run()

print(line13.__class__)

 封装

在类里定义封装的方法用“_”或“__”

利用"_"定义的变量外部能直接调用

利用"__"定义的变量外部也能调用但需要在前面加上"_类名"

 

自省/反射

利用函数hasattr(),getattr(),setattr(),delattr(),等四个内置函数可进行类的自省。

class 中的内置函数

__getattr()__[常用]，__delattr()__，__setattr()__

__getattr()__ 查找输入的值若存在，则返回自定义值，不存在运行下面的代码。

 

 内置函数isinstance()，issubclass()

函数isinstance（）是判断对象是不是又该函数产生的

函数issubclass（）判断该类是不是另一个类的子类。

 

类的内置函数__getattribute()__

创建实例时候会运行该函数但__getattribute()__比__getattr（）__更优先，当getattribute异常抛出 AttributeError错误时候，会跳转到__getattr__

 

 类的内置函数__getitem()__，__setitem()__，__delitem()__

使用方法类似字典，例如 a= g[age] 这样就能使用到该内置函数

 

 类的内置函数__str()__，__repr()__，__format()__。用于字符串打印

repr和str同时存在时候，repr比str优先打印结果

 

类的内置函数__next()__，__iter()__ 实现迭代器生成器协议

 

 

 

 

 

 

 

·