python面向对象编程，,反射python中的

python面向对象编程，,反射python中的

反射

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。

import commas同等于下面字符串导入模块inp = input("请输入模块名：")dd = __import__(inp)ret =dd.f1()print(ret)

通过字符串的形式导入模块

#应用根据用户输入导入模块inp = input("请输入模块：")inp_func = input("请输入执行的函数：")# __import__以字符串的形式导入模块moudle = __import__(inp)#getattr  用以去某个模块中寻找某个函数target_func = getattr(moudle,inp_func)relust = target_func()print(relust)

指定函数中执行指定函数

1、getattr

通过字符串的形式去某个模块中寻找东西

import commas#去commas，寻找name变量，找不到返回nonetarget_func = getattr(commas ,"name",None)print(target_func)

demo

2、hasattr

通过字符串的形式去某个模块中判断东西是否存在

import commas#去commas模块中寻找f1，有返回true，没有返回nonetarget_func = hasattr(commas,"f1")print(target_func)

demo

3、setattr

通过字符串的形式去某个模块中设置东西

import commas#去commas模块中寻找name，有返回true，没有返回nonetarget_func1 = hasattr(commas,"name")print(target_func1)#在内存里往commas模块中添加name = "zhangyanlin"setattr(commas,"name","zhangyanlin")#在内存里往commas模块中创建函数setattr(commas,"f3",lambda x: "zhen" if x >10 else "jia")#去commas模块中寻找name，有返回true，没有返回nonetarget_func = hasattr(commas,"name")print(target_func)

demo

4、delattr

import commastarget_func = hasattr(commas,"f1")print(target_func)del_func = delattr(commas,"f1")target_func = hasattr(commas,"f1")print(target_func)

demo

案例：

‘‘‘基于web框架实现路由功能‘‘‘url = str(input("请输入URL："))  #输入URL，先输入模块，后面加函数target_moudle,target_func = url.split("/") # 用/把分割开，前面是模块 后面是函数moudle = __import__(target_moudle,fromlist=True)  #导入模块if hasattr(moudle,target_func):   #判断模块里有这个函数    target_func = getattr(moudle,target_func)   #找到那个函数    ret = target_func()   #执行函数    print(ret)else:                 #否则报错    print("404")

　　

面向对象编程

面向过程：根据业务逻辑从上到下写垒代码函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可面向对象：对函数进行分类和封装，让开发“更快更好更强...”

面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。

1、创建类和对象

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

class是关键字，表示类创建对象，类名称后加括号即可

# 创建类class Foo:         def Bar(self):        print ‘Bar‘     def Hello(self, name):        print ‘i am %s‘ %name # 根据类Foo创建对象objobj = Foo()obj.Bar()            #执行Bar方法obj.Hello(‘wupeiqi‘) #执行Hello方法　

　　

面向对象三大特性

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

将内容封装到某处从某处调用被封装的内容

第一步：将内容封装到某处

class Foo:    def feach(self):        print(self.backend)    def add(self):        print(self.backend)#创建对象，实例obj1 = Foo()#在对象中封装obj1.backend = "张岩林"#执行方法，执行过程中可以根据self去obj1中取已经封装在里面的数据obj1.feach()obj2 = Foo()obj2.backend = "Aylin"obj2.add()

demo

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

通过对象直接调用通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

class Foo:     def __init__(self, name, age):        self.name = name        self.age = age obj1 = Foo(‘张岩林‘, 18)print(obj1.name)    # 直接调用obj1对象的name属性print(obj1.age)     # 直接调用obj1对象的age属性 obj2 = Foo(‘Aylin‘, 18)print(obj2.name)    # 直接调用obj2对象的name属性print(obj2.age )    # 直接调用obj2对象的age属性

demo

2、通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容

class Foo:    def __init__(self,backend):        ‘‘‘构造方法‘‘‘        self.backend = backend  #普通字段        self.auther = "张岩林"    def feach(self):        print(self.backend,"作者：",self.auther)    def add(self):        print(self.backend,"作者：",self.auther)#创建对象并把www.baidu.com封装到对象中obj = Foo("www.baidu.com")obj.feach()obj1 = Foo("www.google.com")obj1.add()

demo

二、继承

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。

例如：

　　猫可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

　　动物：吃、喝、拉、撒

　　 猫：喵喵叫（猫继承动物的功能）

　　 狗：汪汪叫（狗继承动物的功能）

#继承实例class Animals:    def chi(self):        print(self.name+"吃")    def he(self):        print(self.name+"喝")    def la(self):        print(self.name+"拉")    def jiao(self):        print("叫叫")class Uncle:    def jiao(self):        print("叫叫叫")class dog(Animals,Uncle):    def __init__(self,name):        self.name = name    def jiao(self):        print("叫")ddog = dog("狗")ddog.chi()ddog.jiao()

demo

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。

那么问题又来了，多继承呢？

是否可以继承多个类如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

class Zhang(object):    def f1(self):        print("zhang")class A(Zhang):    def f(self):        print("A")class B(A):    def f(self):        print("B")class C(Zhang):    def f1(self):        print("C")class D(C):    def f(self):        print("D")class E(D,B):    def f(self):        print("E")ret = E()ret.f1()

demo

三、多态

Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

class F1:    passclass S1(F1):    def show(self):        print (‘S1.show‘)class S2(F1):    def show(self):        print( ‘S2.show‘)# 由于在Java或C#中定义函数参数时，必须指定参数的类型# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类# 而实际传入的参数是：S1对象和S2对象def Func(F1 obj):    """Func函数需要接收一个F1类型或者F1子类的类型"""        print (obj.show())    s1_obj = S1()Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.shows2_obj = S2()Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

python伪代码实现java，c#多态

class F1:    passclass S1(F1):    def show(self):        print (‘S1.show‘)class S2(F1):    def show(self):        print( ‘S2.show‘)def Func(obj):    print( obj.show())s1_obj = S1()Func(s1_obj) s2_obj = S2()Func(s2_obj) 

python“鸭子类型”

周末继续更新高级用法，先更新基础吧.....

python面向对象编程