How to find out what methods, properties, etc a python module possesses
Lets say I import a module. In order for me to make the best use of it, I would like to know what properties, methods, etc. that I can use. Is there a way to find that out? As an example: Determining running programs in Python In this line:
os.system('WMIC /OUTPUT:C:\ProcessList.txt PROCESS get Caption,Commandline,Processid') Let’s say I wanted to also print out the memory consumed by the processes. How do I find out if that’s possible? And what would be the correct ‘label’ for it? (just as the author uses ‘Commandline’, ‘ProcessId’) Similarly, in this:
import win32com.client def find_process(name): objWMIService = win32com.client.Dispatch("WbemScripting.SWbemLocator") objSWbemServices = objWMIService.ConnectServer(".", "root\cimv2") colItems = objSWbemServices.ExecQuery( "Select * from Win32_Process where Caption = ''".format(name)) return len(colItems) print find_process("SciTE.exe") 4 Answers 4
As for Python modules, you can do
>>> import module >>> help(module) and you’ll get a list of supported methods (more exactly, you get the docstring, which might not contain every single method). If you want that, you can use
although now you’d just get a long list of all properties, methods, classes etc. in that module.
In your first example, you’re calling an external program, though. Of course Python has no idea which features wmic.exe has. How should it?
Thanks! So in my first example, how would I go about it if I needed to know additional features that I have at my disposal. As an example, if I also wanted to print out the executable path?
Thanks for pointing me to the documentation. But I fail to see how I can retrieve the additional properties that I want. What am I missing?
@Tim I’m not sure if you had received a notification because I hadn’t tagged you in the comment. Just in case 🙂
Sorry, I can’t help you here. My answer is about how to find out the properties of Python modules (which was what you had asked about). Your problem appears to be finding out what capabilities a certain Windows server tool has — about which I haven’t the foggiest idea besides RTM.
dir(module) returns the names of the attributes of the module
module.__dict__ is the mapping between the keys and the attributes objects themselves
module.__dict__.keys() and dir(module) are lists having the same elements, though they are not equals because the elements aren’t in same order in them
it seems that help(module) iswhat you really need
@ldmvcd I don’t understand your question. The attributes of a module are objects, as all in Python. To be attainable and usable, objects are binded to names : «Names refer to objects. Names are introduced by name binding operations. Each occurrence of a name in the program text refers to the binding of that name established in the innermost function block containing the use.» doc . Keys of this binding are names of nearly arbitrary nature, see here what the names can be: (docs.python.org/reference/lexical_analysis.html#identifiers)
You mentioned that module.__dict__ is a mapping between keys and the attribute objects. I meant to ask what does one mean by ‘keys’ in this context. I’m not sure why I’m confused, but if I understand correctly, the ‘keys’ are names that are bound to the attributes of a module so that the said attributes can be accessed and used? But the keys(names) are arbitrary in nature?
Python has a build in function called dir(). I’m not sure if this is what you are referring to, but fire up a interactive python console and type:
import datetime dir(datetime) This should give you a list of methods, properties and submodules
I understand. For my second example, I tried help(win32com.client) and it shows up a lot of information. But I want to narrow it down to finding out how to retrieve the executable path and memory consumed. How do I find out the names for those properties(are they called properties?)?
Ok, excuse me, I think you are a beginner and you don’t see to what fundamental notions I am refering.
Objects are Python’s abstraction for data. All data in a Python program is represented by objects or by relations between objects. http://docs.python.org/reference/datamodel.html#the-standard-type-hierarchy
I don’t understand why it is called «abstraction»: for me an object is something real in the machine, a series of bits organized according certain rules to represent conceptual data or functionning.
Names refer to objects. Names are introduced by name binding operations. Each occurrence of a name in the program text refers to the binding of that name established in the innermost function block containing the use. http://docs.python.org/reference/executionmodel.html#naming-and-binding
A namespace is a mapping from names to objects. Most namespaces are currently implemented as Python dictionaries, but that’s normally not noticeable in any way (except for performance), and it may change in the future. Examples of namespaces are: the set of built-in names (containing functions such as abs(), and built-in exception names); the global names in a module; and the local names in a function invocation. In a sense the set of attributes of an object also form a namespace. http://docs.python.org/tutorial/classes.html#a-word-about-names-and-objects
By the way, I use the word attribute for any name following a dot — for example, in the expression z.real, real is an attribute of the object z. Strictly speaking, references to names in modules are attribute references: in the expression modname.funcname, modname is a module object and funcname is an attribute of it. In this case there happens to be a straightforward mapping between the module’s attributes and the global names defined in the module: they share the same namespace! http://docs.python.org/tutorial/classes.html#a-word-about-names-and-objects
The namespace for a module is automatically created the first time a module is imported. The main module for a script is always called main. http://docs.python.org/reference/executionmodel.html#naming-and-binding
Well, a Python programm is a big machine that plays with objects, references to these objects , names of these objects, and namespaces in which are binded the names and the objects , namespaces being implemented as dictionaries.
So, you’re right: when I refer to keys , I refer to names being the keys in the diverse namespaces. Names are arbitrary or not , according if the objects they have been created to name are user’s objects or built-in objects.
I give advise you to read thoroughly the parts
Python Module identifies as dict
Lets say I have a lot of key-pair data. I would like to have this data in a package so that it can be imported. Is there a way to make modules work like dicts, for performance and extendibility reasons? Example:
common/pairs/ ├── BUILDINGS.py └── __init__.py import BUILDINGS BUILDINGS["foo"] == "bar" Note: The desired result can be archived by putting declaring BUILDINGS in __init__.py but they will all be compiled every time, its not drag and undroppable, and it seems ugly. Is there a way to achieve this well? Is there a way to achieve it at all?
I am curious, what do you expect to gain by importing data from a package versus loading it from an external resource ?
Compile? If you import it once, a cache pyc file will exist and you don’t need to «recompile» to bytecode. True that if you import pairs then the dict is loaded.
5 Answers 5
Not that I recommend it, but you can assign the dict into sys.modules . Python doesn’t care that what’s there is actually a module object.
# BUILDINGS.py from sys import modules if __name__ != "__main__": modules[__name__] =
Modules are already dicts with their atributes stored in BUILDINGS.__dict__ . Just make an utility fonction to write directly to it.
If I understand you correctly, I think what you want is the pickle package
In [16]: import pickle In [17]: mydict = In [18]: mydict Out[18]: In [20]: outfile = open('/tmp/mydict.pickle', 'w') In [21]: pickle.dump(mydict, outfile) In [22]: outfile.close() In [23]: infile = open('/tmp/mydict.pickle', 'r') In [24]: mydict_loaded = pickle.load(infile) In [25]: mydict_loaded Out[25]: If you want to store key-value data that you want to reference later, you should try the shelve module
Example from the above linked page
import shelve d = shelve.open(filename) # open -- file may get suffix added by low-level # library dPython get module dict = data # store data at key (overwrites old data if # using an existing key) data = dPython get module dict # retrieve a COPY of data at key (raise KeyError if no # such key) del dPython get module dict # delete data stored at key (raises KeyError # if no such key) flag = d.has_key(key) # true if the key exists klist = d.keys() # a list of all existing keys (slow!) # as d was opened WITHOUT writeback=True, beware: d['xx'] = range(4) # this works as expected, but. d['xx'].append(5) # *this doesn't!* -- d['xx'] is STILL range(4)! # having opened d without writeback=True, you need to code carefully: temp = d['xx'] # extracts the copy temp.append(5) # mutates the copy d['xx'] = temp # stores the copy right back, to persist it # or, d=shelve.open(filename,writeback=True) would let you just code # d['xx'].append(5) and have it work as expected, BUT it would also # consume more memory and make the d.close() operation slower. If you really want a module that you can use as a dict , you have to make it implement the mapping protocol.
In particular, you need to make sure that type(BUILDINGS).__getitem__(BUILDINGS, key) is defined (as, e.g., getattr(BUILDINGS, key) . And likewise for __setitem__ , __delitem__ , and anything else you want to implement. (You can get most of what you want through collections.abc.MutableMapping , or collections.MutableMapping if you’re on 2.x. See the docs for exactly what you have to implement to get everything else for free.)
The problem is that (at least in CPython, which is probably what you care about) module is a builtin type whose attributes cannot be modified. So, you need to cause BUILDINGS to be an instance of a different type, which you can then add __getitem__ to. For example:
class DictModuleType(types.ModuleType, collections.abc.MutableMapping): def __getitem__(self, key): return getattr(self, key) def __setitem__(self, key, value): return setattr(self, key, value) # . etc. import BUILDINGS as _BUILDINGS BUILDINGS = DictModuleType('BUILDINGS') for name, member in inspect.getmembers(_BUILDINGS): if not name.startswith('_'): setattr(BUILDINGS, name, member) Now you’ve got a BUILDINGS that acts just like the real module, except that it also provides dict-like access instead of just namespace-like access.
You can wrap this up in a variety of different ways.
The simplest way is to take effectively that code (but using __import__ or imp so you don’t pollute globals and sys.modules with the intermediate value) and put it in a function, so instead of import BUILDINGS you’d write helper_mod.dict_import(BUILDINGS) .
The most powerful way is to create and install an import hook that just returns a DictModuleType instead of ModuleType (you may need to implement __new__ and/or __init__ to make this work) for, say, all modules whose names are in all caps (just check if fullname.split(‘.’)[-1].isupper() , and, if not, don’t wrap it). Then, you can just write a module named BUILDINGS.py , and import BUILDINGS , and BUILDINGS will act like a dict .
Accessing dict from another module in Python
@CoryKramer let’s say : name = raw_input(«Enter a name») now from this get me the age from the user input .
6 Answers 6
You can use a nested dictionary to pass the person’s name to the dictionary and then access the age via the key «Age»:
john = mark = Will = new_data = print(new_data["John"]["Age"]) Edit: Without a nested dictionary, you can try this:
john = mark = Will = user_input=raw_input("enter a Name: ") final_age = [b["Age"] for a, b in globals().items() if a == user_input][0] First of all in my opinion you should NOT do it like this. @Ajax1234 offers a much better solution, but to ask your question:
import File1 name = input('>>> Name: ') print(getattr(File1, name)['Age']) # 35 You can use get function in dictionary
get take two parameter first the key then the default value to load if key not found
You can use the built-in globals function. From documentation (emphasis mine):
Return a dictionary representing the current global symbol table. This is always the dictionary of the current module (inside a function or method, this is the module where it is defined, not the module from which it is called).
As you are using separate files, you can create a function in the file File1.py that accepts the dictionary name and returns the appropriate value using the globals() function.
john = mark = Will = def get_age(person): return globals()[person]['Age'] import File1 person = input('Enter name:') print(File1.get_age(person))