一 、反射（根據字符串的形式去對象（某個模塊）中操作成員）

　　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、多態

多態性是指相同的操作或函數、過程可作用於多種類型的對象上並獲得不同的結果。不同的對象，收到同一消息可以產生不同的結果，這種現象稱為多態性

=====================總結============================

面向對象是一種編程方式，此編程方式的使用是基於類和對象的使用

類是一個模塊，模板中包含了多個“函數”（方法）供使用

根據模板創建的實例即為對象（類的實例化）實例用於調用被包裝在類中的函數

面向對象三大特性:封裝、繼承、多態

面向對象基礎 反射