I am trying to print all the functions and their help docstrings in the strings module but am not getting the desired results. Below are the things which I have tried:
r = 'A random string'
1. [help(fn) for fn in r.__dir__() if not fn.startswith('__')]
2. [help(r.fn) for fn in r.__dir__() if not fn.startswith('__')]
3. [fn.__doc__ for fn in r.__dir__() if not fn.startswith('__')]
4. [r.fn.__doc__ for fn in r.__dir__() if not fn.startswith('__')]
and a few things more. Some of them throw errors saying that r does not have attribute named 'fn'. Others just print the help documentation for the 'str' function. Is there any way I can print this for all the functions dynamically?
In python2:
for i in dir(r):
if not i.startswith('__'):
print getattr(r, i).__doc__
In python3:
for i in dir(r):
if not i.startswith('__'):
print(getattr(r, i).__doc__)
(it's basically the same, changes the print function only). You need to get the method object wth getattr in order to show its __doc__ attribute.
To print the docstring you use func.__doc__.
r = 'A random string'
for fn in r.__dir__():
if not fn.startswith("__"):
print ("Function:",fn)
print (fn.__doc__)
print()
Related
I have some code like:
def example(parameter):
global str
str = str(parameter)
print(str)
example(1)
example(2)
The first call to example works, but then the second time around I get an error like:
Traceback (most recent call last):
File "test.py", line 7, in <module>
example(2)
File "test.py", line 3, in example
str = str(parameter)
TypeError: 'str' object is not callable
Why does this happen, and how can I fix it?
If you are in an interactive session and encountered a problem like this, and you want to fix the problem without restarting the interpreter, see How to restore a builtin that I overwrote by accident?.
Where the code says:
global str
str = str(parameter)
You are redefining what str() means. str is the built-in Python name of the string type, and you don't want to change it.
Use a different name for the local variable, and remove the global statement.
Note that if you used code like this at the Python REPL, then the assignment to the global str will persist until you do something about it. You can restart the interpreter, or del str. The latter works because str is not actually a defined global variable by default - instead, it's normally found in a fallback (the builtins standard library module, which is specially imported at startup and given the global name __builtins__).
While not in your code, another hard-to-spot error is when the % character is missing in an attempt of string formatting:
"foo %s bar %s coffee"("blah","asdf")
but it should be:
"foo %s bar %s coffee"%("blah","asdf")
The missing % would result in the same TypeError: 'str' object is not callable.
In my case I had a class that had a method and a string property of the same name, I was trying to call the method but was getting the string property.
Note that TypeError: 'str' object is not callable means only that there is an attempt to call (i.e., use function-call syntax) a string (i.e., any name that previously had a string assigned to it). Using any other built-in method as variable name can cause the exact same error message.
You can get this error if you have variable str and trying to call str() function.
Whenever that happens, just issue the following ( it was also posted above)
>>> del str
That should fix it.
Another case of this: Messing with the __repr__ function of an object where a format() call fails non-transparently.
In our case, we used a #property decorator on the __repr__ and passed that object to a format(). The #property decorator causes the __repr__ object to be turned into a string, which then results in the str object is not callable error.
Check your input parameters, and make sure you don't have one named type. If so then you will have a clash and get this error.
str = 'Hello World String'
print(str(10)+' Good day!!')
Even I faced this issue with the above code as we are shadowing str() function.
Solution is:
string1 = 'Hello World String'
print(str(10)+' Good day!!')
I had the same error. In my case wasn't because of a variable named str. But because I named a function with a str parameter and the variable the same.
same_name = same_name(var_name: str)
I run it in a loop. The first time it run ok. The second time I got this error. Renaming the variable to a name different from the function name fixed this. So I think it's because Python once associate a function name in a scope, the second time tries to associate the left part (same_name =) as a call to the function and detects that the str parameter is not present, so it's missing, then it throws that error.
This error can also occur as a result of trying to call a property (as though it were a function):
class Example:
#property
def value():
return 'test'
e = Example()
print(e.value()) # should just be `e.value` to get the string
This problem can be caused by code like:
"Foo" ("Bar" if bar else "Baz")
You can concatenate string literals by putting them next to each other, like "Foo" "Bar". However, because of the open parenthesis, the code was interpreted as an attempt to call the string "Foo" as if it were a function.
it could be also you are trying to index in the wrong way:
a = 'apple'
a(3) ===> 'str' object is not callable
a[3] = l
it is recommended not to use str int list etc.. as variable names, even though python will allow it.
this is because it might create such accidents when trying to access reserved keywords that are named the same
This error could also occur with code like:
class Shape:
def __init__(self, colour):
self.colour = colour
def colour(self):
print("colour:", self.colour)
myShape = Shape("pink")
myShape.colour()
In the __init__ method, we assign an attribute colour, which has the same name as the method colour. When we later attempt to call the method, the instance's attribute is looked up instead. myShape.colour is the string "pink", which is not callable.
To fix this, change either the method name or the variable name.
I also got this error.
For me it was just a typo:
I wrote:
driver.find_element_by_id("swal2-content").text()
while it should have been:
driver.find_element_by_id("swal2-content").text
In my case, I had a Class with a method in it. The method did not have 'self' as the first parameter and the error was being thrown when I made a call to the method. Once I added 'self,' to the method's parameter list, it was fine.
FWIW I just hit this on a slightly different use case. I scoured and scoured my code looking for where I might've used a 'str' variable, but could not find it. I started to suspect that maybe one of the modules I imported was the culprit... but alas, it was a missing '%' character in a formatted print statement.
Here's an example:
x=5
y=6
print("x as a string is: %s. y as a string is: %s" (str(x) , str(y)) )
This will result in the output:
TypeError: 'str' object is not callable
The correction is:
x=5
y=6
print("x as a string is: %s. y as a string is: %s" % (str(x) , str(y)) )
Resulting in our expected output:
x as a string is: 5. y as a string is: 6
It also give same error if math library not imported,
import math
I realize this is not a runtime warning, but PyCharm gave me this similarly-worded IDE warning:
if hasattr(w, 'to_json'):
return w.to_json()
# warning, 'str' object is not callable
This was because the IDE assumed w.to_json was a string. The solution was to add a callable() check:
if hasattr(w, 'to_json') and callable(w.to_json):
return w.to_json()
Then the warning went away. This same check may also prevent the runtime exception in the original question.
I need your help on gettattr(function, __doc__)
this works if you use it within the file of the definition
BUT
I want to find all functions withing a given file and then run gettattr(function, __doc__) for all the returned functions to get associated doc strings
to list all my function within the module I use :
import module
functionsList = [o for o in getmembers(module) if isfunction(o[1])]
function[0] is a string and function[1] is the memory allocation ?
if I want to use the function as a string i need to do:
for function in functionList:
exec ("docStrings = "+function[0]+".__doc__")
print docStrings
then I would have this error:
Error: NameError: file line 1: name 'anotherTestFunction' is not defined
and I tried to directly use the function
for function in functionList:
docStrings = gettattr(function[1], __doc__)
print docStrings
This time I have no error but it returns : None ...
I might be missing something ... Do you have any idea ?
Cheers
So finally... This was a stupid mistake...
I forgot the " " around _ _doc__ ...
It solves everything. But here is an other way of doing it in case. Use inspect
import module
functionsList = [o for o in getmembers(module) if isfunction(o[1])]
docString = functionsList.__doc__
this is working !
In python everything is an object and you can pass it around easily.
So I can do :
>> def b():
....print "b"
>> a = b
>> a()
b
But if I do
a = print
I get SyntaxError . Why so ?
In Python 2.x, print is a statement not a function. In 2.6+ you can enable it to be a function within a given module using from __future__ import print_function. In Python 3.x it is a function that can be passed around.
In python2, print is a statement. If you do from __future__ import print_function, you can do as you described. In python3, what you tried works without any imports, since print was made a function.
This is covered in PEP3105
The other answers are correct. print is a statement, not a function in python2.x. What you have will work on python3. The only thing that I have to add is that if you want something that will work on python2 and python3, you can pass around sys.stdout.write. This doesn't write a newline (unlike print) -- it acts like any other file object.
print is not a function in pre 3.x python. It doesn't even look like one, you don't need to call it by (params)
I understand what print does, but of what "type" is that language element? I think it's a function, but why does this fail?
>>> print print
SyntaxError: invalid syntax
Isn't print a function? Shouldn't it print something like this?
>>> print print
<function print at ...>
In 2.7 and down, print is a statement. In python 3, print is a function. To use the print function in Python 2.6 or 2.7, you can do
>>> from __future__ import print_function
>>> print(print)
<built-in function print>
See this section from the Python Language Reference, as well as PEP 3105 for why it changed.
In Python 3, print() is a built-in function (object)
Before this, print was a statement. Demonstration...
Python 2.x:
% pydoc2.6 print
The ``print`` statement
***********************
print_stmt ::= "print" ([expression ("," expression)* [","]]
| ">>" expression [("," expression)+ [","]])
``print`` evaluates each expression in turn and writes the resulting
object to standard output (see below). If an object is not a string,
it is first converted to a string using the rules for string
conversions. The (resulting or original) string is then written. A
space is written before each object is (converted and) written, unless
the output system believes it is positioned at the beginning of a
line. This is the case (1) when no characters have yet been written
to standard output, (2) when the last character written to standard
output is a whitespace character except ``' '``, or (3) when the last
write operation on standard output was not a ``print`` statement. (In
some cases it may be functional to write an empty string to standard
output for this reason.)
-----8<-----
Python 3.x:
% pydoc3.1 print
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
print is a mistake that has been rectified in Python 3. In Python 3 it is a function. In Python 1.x and 2.x it is not a function, it is a special form like if or while, but unlike those two it is not a control structure.
So, I guess the most accurate thing to call it is a statement.
In Python all statements (except assignment) are expressed with reserved words, not addressible objects. That is why you cannot simply print print and you get a SyntaxError for trying. It's a reserved word, not an object.
Confusingly, you can have a variable named print. You can't address it in the normal way, but you can setattr(locals(), 'print', somevalue) and then print locals()['print'].
Other reserved words that might be desirable as variable names but are nonetheless verboten:
class
import
return
raise
except
try
pass
lambda
In Python 2, print is a statement, which is a whole different kind of thing from a variable or function. Statements are not Python objects that can be passed to type(); they're just part of the language itself, even more so than built-in functions. For example, you could do sum = 5 (even though you shouldn't), but you can't do print = 5 or if = 7 because print and if are statements.
In Python 3, the print statement was replaced with the print() function. So if you do type(print), it'll return <class 'builtin_function_or_method'>.
BONUS:
In Python 2.6+, you can put from __future__ import print_function at the top of your script (as the first line of code), and the print statement will be replaced with the print() function.
>>> # Python 2
>>> from __future__ import print_function
>>> type(print)
<type 'builtin_function_or_method'>
Environment: python 2.x
If print is a built-in function, why does it not behave like other functions ? What is so special about print ?
-----------start session--------------
>>> ord 'a'
Exception : invalid syntax
>>> ord('a')
97
>>> print 'a'
a
>>> print('a')
a
>>> ord
<built-in function ord>
>>> print
-----------finish session--------------
The short answer is that in Python 2, print is not a function but a statement.
In all versions of Python, almost everything is an object. All objects have a type. We can discover an object's type by applying the type function to the object.
Using the interpreter we can see that the builtin functions sum and ord are exactly that in Python's type system:
>>> type(sum)
<type 'builtin_function_or_method'>
>>> type(ord)
<type 'builtin_function_or_method'>
But the following expression is not even valid Python:
>>> type(print)
SyntaxError: invalid syntax
This is because the name print itself is a keyword, like if or return. Keywords are not objects.
The more complete answer is that print can be either a statement or a function depending on the context.
In Python 3, print is no longer a statement but a function.
In Python 2, you can replace the print statement in a module with the equivalent of Python 3's print function by including this statement at the top of the module:
from __future__ import print_function
This special import is available only in Python 2.6 and above.
Refer to the documentation links in my answer for a more complete explanation.
print in Python versions below 3, is not a function. There's a separate print statement which is part of the language grammar. print is not an identifier. It's a keyword.
The deal is that print is built-in function only starting from python 3 branch. Looks like you are using python2.
Check out:
print "foo"; # Works in python2, not in python3
print("foo"); # Works in python3
print is more treated like a keyword than a function in python. The parser "knows" the special syntax of print (no parenthesis around the argument) and how to deal with it. I think the Python creator wanted to keep the syntax simple by doing so. As maverik already mentioned, in python3 print is being called like any other function and a syntx error is being thrown if you do it the old way.