反射、面向对象（基础篇）

反射

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

　　通过字符串的形式，去模块中寻找指定的函数，并执行

1、本质

　　__import__  例：dd == __import__('commons')

　　__import__("lib.commons.s1"）  #这样只能导入到lib,不能导入到s1

　　__import__("lib.commons.s1",fromlist=true)  #这样就能导入到s1

2、应用

inp = input（"请输入模块："）

inp_func = input("请输入要执行的函数：")

print(inp,type(inp))

dd = __import__(inp)  #__import__ 用于一字符串的形式导入模块

target_func = getattr(dd,inp_func)  #在获取到函数名后加 （） 表示执行函数

result = target_func()

print(result)

 

3、反射功能

不只是在模块中操作，根据字符串的形式去对象中操作成员（一切事物皆对象！）

　　getattr()  根据字符串的形式去某个模块中寻找东西

　　hasattr()  根据字符串的形式去某个模块中判断东西是否存在

　　setattr()   根据字符串的形式去某个模块设置东西

　　delattr()   根据字符串的形式去某个模块中删除东西

实例：

NAME = "alex"
def f1():
    print("f1")
    return "F1"

def f2():
    return "F2"

 

import commons

target_func = getattr(commons,'NAME',None) #获取成员
print(target_func)
#target_func()

r = hasattr(commons,'Aamse')  #在模块中查询输入的东西，查到返回True,查不到返回False
print(r)

commons.f1()
r =hasattr(commons,'AGE')  #检查是否含有成员
print(r)

setattr(commons,"AGE",lambda  a: a + 1)  #设置成员
r = hasattr(commons,'AGE')
print(r)

delattr(commons,'NAME')  #删除成员
r = hasattr(commons,'NAME')
print(r)

访问一个对象的成员操作：

class Foo(object):
    def __init__(self):
        self.name = 'alex'
        #print(self.name)

    def func(self):
        return "func"

obj = Foo()

obj.name  #访问字段
obj.func()  #执行方法
#详解：
#name和func是变量名
#obj.name表示去obj中或是类寻找变量名是name，并获取对应内存地址中的内容。
#**********
#用其他方式获取obj对象中的name变量指向内存中的值“alex”
class Foo(object):

    def __init__(self):
        self.name = 'alex'

obj = Foo()
#法一：
# class Foo(object):
#
#     def __init__(self):
#         self.name = 'alex'
#
#     def func(self):
#         return 'func'
#

# obj = Foo()
#
# print(obj.__dict__['name'])
#法二：
class Foo(object):

    def __init__(self):
        self.name = 'alex'

    def func(self):
        return 'func'


obj = Foo()

print(getattr(obj, 'name'))

 

 

Web框架实例

def login():
    return "login"

def logout():
    return "logout"

def nb():
    return "特别牛逼页面"

 

def f1():
    return "添加订单"

 

def f2():
    return "加入购物车"

 

用下面调用：

#基础调用
# from lib import acccount
#
# url = input('请输入url: ')
# if url.endswith('login'):
#     r = acccount.login()
#     print(r)
# elif url.endswith('logout'):
#     r = acccount.login()
#     print(r)
# elif url.endswith('nb'):
#     r = acccount.nb()
#     print(r)
# else:
#     print("404")
#**************************
#用反射写如下：
# from lib import acccount
#
#
# url = input('请输入URL：')
# inp = url.split('/')[-1]
# if hasattr(acccount,inp):
#     target_func = getattr(acccount,inp)
#     r = target_func()
# else:
#     print("404")
#****************************
#动态的调用
url = input('请输入URL：')

target_module,target_func = url.split('/')

m = __import__("lib."+target_module,formlist=True)

if hasattr(m,target_func):
    target_func = getattr(m,target_func)
    r = target_func()
    print(r)
else:
    print("404")

 

面向对象

c#、Java:  只能面向对象编程

Ruby、Python: 函数编程 + 面向对象编程

一，面向过程编程

二，面向对象编程，类，def 函数

def fetch(backend):
    pass

def add_record(backend, record):
    pass

fetch("www.oloboy.org")
add_record("www.oloboy.org",xxxxx)

 

三，面向对象式编程，def 函数

class Oldboy:

    def fetch(self,backend):
        pass

    def add_record(self,backend):
        pass

obj = Oldboy()
obj.fetch("www.oloboy.org")
obj.add_record("www.oloboy.org",xxxxx)

 

 

1，面向对象不是所有情况都适用

2，面向对象编程

a.定义类

class Foo:
    def 方法1（self,bb）:
        pass

 

b,根据类创建对象（创建一个Foo类实例）

  使用对象去执行类中的方法

class Oldboy:

    def fetch(self,backend):
        print(backend)

    def add_record(self,backend,record):
        pass


obj = Oldboy()  #创建对象
obj.fetch("bbb")

 

3，self,形式参数，代指执行方法的对象。python内部传递。

class Oldboy:
    def fetch(self,backend):
        print(backend,self)  #<__main__.Oldboy object at 0x0000000000D44630>

obj = Oldboy()
print(obj)
obj.fetch("bbb")  #bbb <__main__.Oldboy object at 0x0000000000D44630>

 

4，类+括号  

自动执行类中的__init__方法；创建了一个对象

class Foo:
    def __init__(self,name,age):  #称为构造方法，根据创建对象时自动执行
        self.name = name
        self.age = age

#根据类Foo创建对象
#自动执行Foo类的__init__方法
obj1 = Foo('fen',45)  #将fen和45分别封装到name和age属性中

#根据类Foo创建对象
#自动执行Foo类的__init__ 方法
obj2 = Foo（’gen',80）#将gen和80分别封装到name和age属性中

 

在__init__方法中执行具体封装的操作 

__init__ 有一个特殊的名字：构造方法

__init__作用：1，创建对象；2，封装

class Oldboy:
    def __init__(self,bk):  #bk是形参，对应外部传过来的实参
        """
        构造方法
        :param bk:
        
        """
        self.backend = bk  #普通字段；self.backend = bk相当于在__init__中bk的参数

    def fetch(self):  #方法
        print(self.backend)  #backend用来接收init方法中bk的参数

    def add_record(self,record):
        print(self.backend)

    def del_record(self):
        print(self.backend)

obj1 = Oldboy("www.oldboy.org")  #创建对象obj1并且将"www.oldboy.org"封装在对象中

#obj1.backend = "www.oldboy.org"  #封装一种方式；在对象中封装数据

obj1.del_record()  #执行方法，执行过程中可以根据self去obj1中去取已经封装在里面的数据

 

 

 

面向对象三大特性

1，封装

使用场景：当同一类型的方法具有相同参数时，直接封装到对象即可。
使用场景：把类当做模板，创建多个对象（对象内封装的数据可以不一样）

class Oldboy:

    def fetch(self):
        print(self.backend)

    def add_record(self,record):
        print(self.nackend)

    def del_record(self):
        print(self.backend)

#创建对象实例
obj1 = Oldboy()
obj1.backend = "www.oldboy.org"  #在对象中封装数据
obj1.fetch()

obj2 = Oldboy()
obj2.backend = "www.oldboy.org"
obj2.fetch()  #执行方法，执行过程中可以根据self去obj1中去取已经封装在里面的数据。

 

实例：

class Person:
    def __init__(self,name,age,weight):
        self.Name = name
        self.Age = age
        self.Weight = weight

    def chi(self):
        self.Weight = self.Weight + 2
        print(self.Weight)

    def jianshen(self):
        self.Weight = self.Weight - 1
        print(self.Weight)

o1 = Person('小明', 5,200)
o1.jianshen()
o1.chi()
o1.chi()
o1.chi()

 

 

2，继承

派生类继承基类

python2.7 多继承：
　　未继承object（经典类）:
　　　　　　一条道走到黑（深度优先）
　　继承object（新式类）：
　　　　　　顶部最后（广度优先）

python3.5 多继承：
　　　　　　顶部最后

 

派生类和基类同时存在，优先找派生类
python类中可以继承多个,优先自己，再从左至右继承

用上述图阐述下面继承关系

class Animals:  #基类（父类）

    def chi(self):
        print(self.name + " 吃")

    def he(self):
        print(self.name + " 喝")

    def piao(self):
        print("buai")

class Uncle:
    def du(self):
        print("赌")

    def piao(self):
        print("1212")

class Dog(Animals,Uncle):  #派生类（子类）
    def __init__(self,name):
        self.name = name

    # def piao(self):
    #     print("ai")

    def jiao(self):
        print(self.name + " 汪")


alex = Dog("李杰")
alex.chi()
alex.he()
alex.jiao()
alex.piao()

 

 

多次继承

用图形阐述继承顺序

class Alex(object):
    def f1(self):
        print("Alex")

class A(Alex):
    def f(self):
        print("A")

class B(Alex):
    def f1(self):
        print("B")

class C(A):
    def f(self):
        print("C")

class D(B):
    def f1(self):
        print("D")

class E(C,D):
    def f(self):
        print("E")

obj = E()
obj.f1()

 重点示例：

用上述图阐述（每次都是从最底层开始找）

首先从自身找，自身没有开始从A找;如果A找不到,再从C找;如果C中再找不到，再到B中找；

class A:
    def bar(self):
        print('BAR')
        self.f1()

class B(A):
    def f1(self):
        print('B')

class C:
    def f1(self):
        print('C')

class D(C,B):  #主要self指向谁，就执行谁
    pass

d1 = D()  #输出BAR
d1.bar()  #输出C

 

 2.7的多继承

 

3，多态

多种形态
Python本身支持多态

 

 

*更加详细参考：http://www.cnblogs.com/wupeiqi/p/4493506.html

                       http://www.cnblogs.com/wupeiqi/articles/5017742.html