python 动态构造类 type

1. 使用 getattr

#a.py
    class b(){...}
#c.py
package = __import__('a')
temp_class    = getattr(package,'b')
temp = temp_class() #b()

如果是在当前文件中，则

import sys

class F:
    def __init__:
        ......


getattr(sys.modules[__name__], 'F')()

2. 使用global 

class A():
    def __init__(self): print('A')

class B():
    def __init__(self): print('B')

globals()['A']()
globals()['B']()

global太好用了 

import uuid
import threading
import os,sys
import grpc

current_path = os.path.dirname(__file__)
sys.path.append(os.path.join(current_path, 'grpc_bin'))


import grpc_bin.journal_event_pb2 as pb_event
import grpc_bin.journal_event_pb2_grpc as journal_event_pb2_grpc
from grpc_bin.journal_event_pb2 import User

queue_locker = threading.Lock()

class Node :
    def __init__(self, name, service_name, method_name, server_info="localhost:50052", input_value=None, input_type=None, pre=None, next=None):
        self.status = "Waiting"  # "Ready"  "Waiting" "Running" 'Done'
        self.ID = uuid.uuid4()
        self.name= name
        self.service_name = service_name
        self.server_info = server_info
        self.method = method_name
        self.input_data = input_value
        self.input_type = input_type
        self.pre = pre
        self.next = next

    def execute(self):
        print(f"Execute node : {self.name}")


        # aa = globals()[self.input_type]()
        # print(dir(aa))
        # aa.ParseFromString(self.input_data)
        # print(aa)

        request = globals()[self.input_type]()
        request.ParseFromString(self.input_data)
        restful_api = f"/{self.service_name}/{self.method}"
        with grpc.insecure_channel(self.server_info) as channel:
            func = channel.unary_unary(
                # '/JournalEvents/GetFileMetas',
                restful_api,
                request_serializer=pb_event.User.SerializeToString,
                response_deserializer=pb_event.FileSet.FromString,
            )
            response = func(request)
        print(response)
        # create thread to run
        # create stub
        # Run method
        # if all pre[i].status == "Done":
        #     execute (self)
        #     self.status = "Done"
        # else:
        #     self.status = "Waiting"
    def monitor_status(self):
        # check if all pre[] finished
        # if all pre[] finished: self.states = "Ready"
        pass



user = pb_event.User(username='lc-host')

node = Node(name='lc-host', service_name='JournalEvents', method_name='GetFileMetas', input_type='User', input_value=user.SerializeToString())
node.execute()

python-获取类名和方法名，动态创建类和方法及属性 - 南方的墙 - 博客园

　1.在函数外部获取函数名称，用func.__name__获取
　　2.在函数内部获取当前函数名称，用sys._getframe().f_code.co_name方法获取
　　3.使用inspect模块动态获取当前运行的函数名，return inspect.stack()[1][3]需要封装个方法在被测函数中调用
　　4.在类内部获取类名称self.__class__.__name__

import inspect,sys
def get__function_name():
    #获取正在运行函数(或方法)名称
    return inspect.stack()[1][3]
def shuzf():
    print(sys._getframe().f_code.co_name)
    print(get__function_name())

动态创建类和方法及属性

　　1.使用type动态创建类
　　type('child_example', (class_example,), {'echo': echo}) #（类名，继承，属性）
　　type() #可以被用来动态创建class，这是因为实际上type是一个metaclass

def __init__(self,name,age):
    self.name = name
    self.age = age
Dog_class = type("Dog",(object,),{"role":"dog","__init__":__init__})   #动态添加属性与方法

d = Dog_class('shuzf',22)
print(type(Dog_class))   
print(type(d))
print(d.role,d.name,d.age)

out：
<class 'type'>
<class '__main__.Dog'>
dog shuzf 22

　　2.使用setattr() 动态创建方法、属性

class A():
    name = 'python'
    @classmethod
    def funcmethod(cls):
        return 'Hello world：funcmethod'

setattr(A, 'age',30)  #创建变量并赋值,可在下次直接使用
setattr(A,'funcmethod_class',A.funcmethod) #创建变量并赋值方法

 

获取函数信息

import inspect
#函数信息
def test1():
    pass
print("函数信息：",inspect.getfullargspec(test1))

#函数的入参出参信息
def test2(a:"描述",b:object,c:int=None,d:str='http') -> str:
    print("函数的入参出参信息：",test2.__annotations__)
test2(a=1,b='2')