pypy | Pyramids | AWS library

I want to implement the following procedure in the fastest way using Python3: given a list of N random integers I need to return the K smallest ones (and I do not need the returned integers to be sorted). I implemented it in three different ways (as you can see in the code below).

• the test_sorted() function use the built-in sorted() function to order the whole list of integers and then takes a slice of the first K elements. The cost of this operation should be essentially the cost of running the sorted() function, which has a time complexity of O(N log(N)).

• the test_heap() function use a heap to store only the lowest K elements and returns them. Inserting an element on a heap has a time complexity of O(log(N)) and in theory the number of time we need to push an item in the heap is N. However, after the first K insertions we will be pushing and popping from the heap and I would expect that if the incoming element is bigger than any element in the heap no insertion would occur and time complexity should be somewhere between O(K log(N)) and O(N log(N)) (depending on the actual ordering of the input list). Anyway, even if my assumption is not true, the worst complexity should be O(N log(N)) (as usual, I consider negligible the cost of all the comparisons we need).

• the test_nsmallest() function use the nsmallest() function from the heapq module. I had no expectation about this approach and since in the official python documentation I only found that

  For larger values, it is more efficient to use the sorted() function. I decided to give it a try.

I want to install Numpy on PyPy on windows but I cannot. Here is my errors:

Following this post I created an environment for pypy2.7: conda create -c conda-forge -n pypy2.7 pypy2.7. In the new environment I can now do

I have an M1 processor from Apple, which is a new ARM64 architecture, and the binaries provided for many data science Python packages will not run on it, and compiling them fails in most cases.

Questions such as How to install SciPy on Apple Silicon (ARM / M1) or numpy build fail in M1 Big sur 11.1 offer many different answers, some of which work and most don't. However, even for those that manage to make the modules compile, I don't understand how I can make pip install my locally compiled packages instead of fetching them (and failing) from pypy.

How can I install numpy, scipy, numexpr and others as a dependency on a computer with an M1 processor?

I have a project with two existing Virtualenv environments. One uses CPython 3.7 and one uses CPython 3.8. I want to add another interpreter that uses PyPy. Currently, I have Python 3.8 specified as my PATH python executable. I'm running PyCharm Professional 2020.3 on Windows 10.

I go to "Settings", "Project: xx", "Python Interpreter". Then, under the drop-down menu, I selected "show all". Then I clicked the plus sign, and under "Virtualenv Environment" listed a new folder name in the project directory for the "Location", and navigated to one of my python executables for the "Base Interpreter". I then click "OK", and PyCharm creates a new Virtualenv for me.

I first downloaded and extracted PyPy to my desktop from the link highlighted below, which is found here. I then copied the extracted folder to my C:\\Users\xx\AppData\Local\Programs\ folder so it was in the same place as the rest of my Python interpreters. Then, I tried to replicate the CPython workflow to set up a PyPy Virtualenv environment. This failed, as, after the last step, Python generates the following error message:

I want to upgrade my python version from 3.5 to 3.6 to use the new features.

I first copy the base env as base3.6 using Clone base environment in anaconda,

then I want to upgrade the python3.5 to 3.6 using conda install python=3.6, but I have this error

I would like to run some 100k+ simulations with some millions of data points, which are represented as decimals. I choose decimals over floats for floating point accuracy and ease of unit testing my logic (since 0.1 + 0.1 + 0.1 does not equal 0.3 with floats...).

My hope was to speed up the simulations by using PyPy. But during my testing I encountered that PyPy does not handle decimal.Decimal or even _pydecimal.Decimal well at all - and gets dramatically slower than the CPython interpreter (which uses C for decimal.Decimal arithmetics). So I copy/pasted my whole codebase and replaced all Decimals with floats and the performance increase was huge: x60-x70 times faster with PyPy than CPython - with the sacrifice of accuracy.

Are there any solutions to use Decimals precision in PyPy with the performance benefit? I "could" maintain two codebases: float for batch running the 100k simulations, Decimal for inspecting the interesting results later - but this bears the overhead of maintaining two codebases...

Here are some simple tests I ran on a Raspberry Pi 4 (Ubuntu Server 20.10, 4 x 1.5GHZ ARM Cortex-A72, 8GB RAM) for reproduction:

test_decimal.py

This i my scenario: I have a python project that runs in cPython. and I have some .pyc, .so files in this project, and I don't have these files's source code. This project runs well in cPython. But if I change the interpreter to pypy, it can't import these modules which contained by the .pyc files and .so files. Is there any way that I can solve this problem?

I would like to ask some questions about the underlying principles of python interpreters, because I didn't get much useful information during my own search.

I've been using rust to write python plugins lately, this gives a significant speedup to python's cpu-intensive tasks, and it's also faster to write comparing to c. However it has one disadvantage is that, compared to the old scheme of using cython to accelerate, the call overhead of rust (I'm using pyo3) seems to be greater than that of c(I'm using cython),

For example , we got an empty python function here: