That being said, here are some tips that might help:

1. Measure, don’t guess!
Human beings are terrible at predicting where the hotspots in code are. So instead of trying to optimize based on intuition or gut feeling, measure your code using a profiler like cProfile or vmprof (which is included with PyPy). This will give you an accurate picture of which parts of your code are taking up most of the time and where you should focus your optimization efforts.

2. Build a regression-test suite!
Before you start optimizing, build a test suite for your code that covers all the functionality you want to preserve. This will help ensure that any changes you make don’t introduce new bugs or break existing features. And if you do find yourself making significant changes, be sure to re-run your tests and measure performance again to see how much of an improvement (if any) you’ve made.

3. Focus on tight loops!
Most high time costs are caused by expensive operations that occur inside tight loops especially in code that does something like a searching/matching/lookup operation or any kind of graph traversal. So if you want to optimize your code, start by looking for these kinds of patterns and see if there’s anything you can do to make them faster.

4. Keep it simple!
Simple is better than complex especially when it comes to Python optimization techniques. The PyPy JIT (which stands for Just-in-Time compiler) is not very smart, so the simpler your code is, the better it will run. And if you’re using CPython instead of PyPy, remember that global variables and functions are much more expensive to reference than locals so avoid them whenever possible!

5. Avoid regular expressions!
Regular-expression compilation can be very slow, especially in code where the regex pattern is not static (i.e., it changes at runtime). So if you’re using regular expressions in your code, consider refactoring to use a more efficient alternative like string concatenation or list comprehension instead. And remember that old-style classes are slower than new-style classes so avoid them whenever possible!

6. String concatenation is expensive!
In CPython, string concatenation can be very slow due to multiple allocation overheads. So if you’re using string concatenation in your code, consider refactoring to use a more efficient alternative like list comprehension or generator expressions instead. And remember that frame introspection and tracing are also expensive so avoid them whenever possible!

7. Frame introspection and tracing are slow!

Certain function calls can disable PyPy’s speed options over stretches of surrounding code called “JIT scopes”. So if you want to optimize your code, be sure to avoid using functions like locals(), globals(), sys._getframe(), sys.exc_info(), and sys.settrace whenever possible!

1. Measure, don’t guess!
2. Build a regression-test suite!
3. Focus on tight loops!
4. Keep it simple!
5. Avoid regular expressions!
6. String concatenation is expensive!
7. Frame introspection and tracing are slow!