一 、反射（根据字符串的形式去对象（某个模块）中操作成员）
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、多态
多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性
=====================总结============================
面向对象是一种编程方式，此编程方式的使用是基于类和对象的使用
类是一个模块，模板中包含了多个“函数”（方法）供使用
根据模板创建的实例即为对象（类的实例化）实例用于调用被包装在类中的函数
面向对象三大特性:封装、继承、多态