面向对象基础反射

一、反射（根据字符串的形式去对象（某个模块）中操作成员）

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

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

inp=input("请输入模块名：")
mo=__import__(inp)

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

两种情况：1、如果在同级目录下面直接用__import__("xxxx")

　　　　 2、如果不在同一级目录下面（目录嵌套）用__import__("xxx.xxxx.xxx",fromlist=True)

# getattr
inp = input("请输入模块名：")   #以字符串的形式导入模块
mo = __import__(inp)
inm = input("请输入函数名：")  #以字符串的形式在模块中找方法   相当于form  xxx  import  xxx
f = getattr(mo,inm)
f()

getattr（模块名，"xxx",None）去模块中找xxx，如果没有没有找到则报错，我们也可以设置默认值None 如果没有找到则返回None(不报错)

hasattr（模块名，"xxx"）根据字符串的形式判断xxx是否存在

setattr（模块名，"xxx",xxx）在内存中为某个模块设置一个东西

import asd
print(hasattr(asd,"age"))
setattr(asd,"age",18)
print(hasattr(asd,"age"))

False
True

delattr(模块名，"xxx") 在内存中删除某个东西

import asd
print(hasattr(asd,"name"))    #以前有
delattr(asd,"name")              #现在删除
print(hasattr(asd,"name"))

True
False

基于反射实现类web框架的路由系统

import asd
url=input("请输入网址：")
new=url.split("/")
ret=hasattr(asd,new[1])　　　　　　　　　　　　　　　　#用户直接输入网址www.xxxxxx/方法  就可以执行方法
if ret:
    r=getattr(asd,new[1])
    r()
else:
    print("404")

url=input("请输入模块名/方法：")
mo,faf=url.split("/")
m=__import__("xxx."+mo)
ret=hasattr(m,faf)　　　　　　　　　　　　　　　　　　#用户通过输入模块名/犯法就可以从任意的一个模块下执行任意一个方法
if ret:
    r=getattr(m,faf)
    r()
else:
    print("404")

二、面向对象

概述：

面向过程：根据业务逻辑从上到下垒代码

函数式编程：将某功能代码分装到函数中，日后便无需再写，直接调用

创建类和对象

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

（类中函数的第一个参数必须是self，且此self就等同于方法的调用者既对象）

class f:
    def f1(self):
        pass
    def f2(self):
        pass
obj=f()
obj.f1()

面向对象的三大特性：

封装，继承和多态

1、封装，顾名思义就是把内容分装到某个地方

使用场景1：当同一类型的方法具有相同的参数时，直接封装到对象即可

使用场景2：把类当做模板，创建多个对象（对象内封装的数据可以不一样）

所以在使用面向对象的封装功能时：

1、将内容分装到某处

2、从某处调用封装的函数

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

self.xxx=xxx 称为普通字段

def __init__(self, name, age):构造方法

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age　　

obj1 = Foo('wupeiqi', 18)
print (obj1.name)    # 直接调用obj1对象的name属性
print (obj1.age)     # 直接调用obj1对象的age属性

obj2 = Foo('alex', 73)
print (obj2.name)    # 直接调用obj2对象的name属性
print (obj2.age)     # 直接调用obj2对象的age属性

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

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def detail(self):
        print (self.name)
        print (self.age)

obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18

obj2 = Foo('alex', 73)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。

2、继承（既派生类可以继承基类的方法或子类可以继承父类的方法）

注意：派生类和基类同时存在某个功能，优先使用派生类中的功能

　　　 python类可以继承多个类（c#、java不行）

　　　　优先：自己 >>>> 左边 >>>> 右边

　　动物：吃、喝、拉、撒

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

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

class Animal:
    def eat(self):
        print ("%s 吃 " %self.name)

    def drink(self):
        print ("%s 喝 " %self.name)

    def shit(self):
        print ("%s 拉 " %self.name)

    def pee(self):
        print ("%s 撒 " %self.name)


class Cat(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def cry(self):
        print ('喵喵叫')

class Dog(Animal): 
    def __init__(self, name):
        self.name = name
        self.breed = '狗'
        
    def cry(self):
        print ('汪汪叫')     

# ######### 执行 #########
c1 = Cat('小白家的小黑猫')
c1.eat()
c2 = Cat('小黑的小白猫')
c2.drink()
d1 = Dog('胖子家的小瘦狗')
d1.eat()

3、多态

多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性

=====================总结============================

面向对象是一种编程方式，此编程方式的使用是基于类和对象的使用

类是一个模块，模板中包含了多个“函数”（方法）供使用

根据模板创建的实例即为对象（类的实例化）实例用于调用被包装在类中的函数

面向对象三大特性:封装、继承、多态

面向对象基础 反射

面向对象基础反射