how does local rebinding of global names in python make code faster/optimized?

Even if dictionary lookup is highly optimized, it can't beat indirect access.

import math
def f():
   math.sin(1)

4 0 LOAD_GLOBAL 0(math) ** *
   3 LOAD_ATTR 1(sin) ** *
   6 LOAD_CONST 1(1)
9 CALL_FUNCTION 1
12 POP_TOP
13 LOAD_CONST 0(None)
16 RETURN_VALUE

from math
import sin
def f():
   sin(1)

4 0 LOAD_GLOBAL 0(sin) ** *
   3 LOAD_CONST 1(1)
6 CALL_FUNCTION 1
9 POP_TOP
10 LOAD_CONST 0(None)
13 RETURN_VALUE

Suggestion : 2

How can I organize my code to make it easier to change the base class?,What are the rules for local and global variables in Python?,In Python you have to write a single constructor that catches all cases using default arguments. For example:,The callable object approach has the disadvantage that it is a bit slower and results in slightly longer code. However, note that a collection of callables can share their signature via inheritance:

>>> x = 10 >>>
   def bar():
   ...print(x) >>>
   bar()
10

>>> x = 10 >>>
   def foo():
   ...print(x)
   ...x += 1

>>> foo()
Traceback(most recent call last):
   ...
   UnboundLocalError: local variable 'x'
referenced before assignment

>>> x = 10 >>>
   def foobar():
   ...global x
   ...print(x)
   ...x += 1 >>>
   foobar()
10

>>> print(x)
11

>>> def foo():
   ...x = 10
   ...def bar():
   ...nonlocal x
   ...print(x)
   ...x += 1
   ...bar()
   ...print(x) >>>
   foo()
10
11

Suggestion : 3

By Bernd Klein. Last modified: 29 Jun 2022.

def f():
   print(s)
s = "I love Paris in the summer!"
f()

I love Paris in the summer!

def f():
   s = "I love London!"
print(s)

s = "I love Paris!"
f()
print(s)

I love London!
   I love Paris!

def f():
   print(s)
s = "I love London!"
print(s)

s = "I love Paris!"
f()

---------------------------------------------------------------------------
UnboundLocalError Traceback (most recent call last)
<ipython-input-3-d7a23bc83c27> in <module>
      5
      6 s = "I love Paris!"
      ----> 7 f()
      <ipython-input-3-d7a23bc83c27> in f()
         1 def f():
         ----> 2 print(s)
         3 s = "I love London!"
         4 print(s)
         5
         UnboundLocalError: local variable 's' referenced before assignment

Suggestion : 4

Python’s simple, easy-to-learn syntax can mislead Python developers – especially those who are newer to the language – into missing some of its subtleties and underestimating the power of the diverse Python language.,This can lead to gnarly problems, such as importing another library which in turns tries to import the Python Standard Library version of a module but, since you have a module with the same name, the other package mistakenly imports your version instead of the one within the Python Standard Library. This is where bad Python errors happen.,Familiarizing oneself with the key nuances of Python, such as (but by no means limited to) the moderately advanced programming problems raised in this article, will help optimize use of the language while avoiding some of its more common errors.,(Note: This article is intended for a more advanced audience than Common Mistakes of Python Programmers, which is geared more toward those who are newer to the language.)

Python allows you to specify that a function argument is optional by providing a default value for it. While this is a great feature of the language, it can lead to some confusion when the default value is mutable. For example, consider this Python function definition:

>>> def foo(bar = []): # bar is optional and defaults to[]
if not specified
   ...bar.append("baz") # but this line could be problematic, as we 'll see...
   ...
   return bar

But let’s look at what actually happens when you do this:

>>> foo()["baz"] >>>
   foo()["baz", "baz"] >>>
   foo()["baz", "baz", "baz"]

FYI, a common workaround for this is as follows:

>>> def foo(bar = None):
   ...
   if bar is None: # or
if not bar:
   ...bar = []
   ...bar.append("baz")
   ...
   return bar
      ...
      >>>
      foo()["baz"] >>>
      foo()["baz"] >>>
      foo()["baz"]

Makes sense.

>>> B.x = 2 >>>
   print A.x, B.x, C.x
1 2 1

Yup, again as expected.

>>> A.x = 3 >>>
   print A.x, B.x, C.x
3 2 3

Suggestion : 5

compilation will succeed and the compiled function will raise at runtime as Python would do:,There can be various reasons why Numba cannot compile your code, and raises an error instead. One common reason is that your code relies on an unsupported Python feature, especially in nopython mode. Please see the list of Supported Python features. If you find something that is listed there and still fails compiling, please report a bug.,Supported Python features in CUDA Python Language Execution Model Constructs Built-in types Built-in functions Standard library modules cmath math operator Numpy support ,To find out if type inference succeeded on your function, you can use the inspect_types() method on the compiled function.

@jit(nopython = True)
def f(x, y):
   return x + y

>>> f(1, 2)
3

>>> f(1, (2,))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
      File "<path>/numba/numba/dispatcher.py", line 339, in _compile_for_args
         reraise(type(e), e, None)
         File "<path>/numba/numba/six.py", line 658, in reraise
            raise value.with_traceback(tb)
            numba.errors.TypingError: Failed at nopython (nopython frontend)
            Invalid use of + with parameters (int64, tuple(int64 x 1))
            Known signatures:
            * (int64, int64) -> int64
            * (int64, uint64) -> int64
            * (uint64, int64) -> int64
            * (uint64, uint64) -> uint64
            * (float32, float32) -> float32
            * (float64, float64) -> float64
            * (complex64, complex64) -> complex64
            * (complex128, complex128) -> complex128
            * (uint16,) -> uint64
            * (uint8,) -> uint64
            * (uint64,) -> uint64
            * (uint32,) -> uint64
            * (int16,) -> int64
            * (int64,) -> int64
            * (int8,) -> int64
            * (int32,) -> int64
            * (float32,) -> float32
            * (float64,) -> float64
            * (complex64,) -> complex64
            * (complex128,) -> complex128
            * parameterized
            [1] During: typing of intrinsic-call at <stdin> (3)

               File "<stdin>", line 3:

@jit
def g(x, y):
   return x + y

>>> g(1, (2,))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
      TypeError: unsupported operand type(s) for +: 'int' and 'tuple'

In[1]: from numba
import jit

In[2]: @jit(nopython = True)
   ...: def f(x):
   ...: if x > 10:
   ...: return (1, )
      ...:
      else:
         ...: return 1
            ...:

            In[3]: f(10)