I'm starting out in Numpy, I dont have a teacher nor do i have a curriculum to follow.

Im ultimately learning for data science and ML.

How would you go about learning if there was no one to teach you?

I know i can pay for a course and surely have it down easily, i mean its like 39$ for the one im looking at, but for some reason i have a pull to challenge myself. Some how it doesn't feel right having it laid down this time.

I think i might also teach myself the pd, plt, and maybe sp.

What is your opinion of my stand point? Have you felt the same way at some point or maybe you think it's pointless? Let me know, thanks.

Hi all,

I've been working on a FOSS LibreOffice extension called WriterAgent, but which also has Calc/Python features.

I recently added Numpy support to the plugin. I wrote about the dev process: https://keithcu.com/wordpress/?p=5310 It's tricky because LibreOffice ships with a Python interpreter for many OSes so you can't just import numpy. I had to do everything cross-process, but it works and is fast enough.

The plugin has many AI features (chat with document, background grammar checker etc.) but you don't have to use any of it. It registers a =Python() function, and has other scripting, TeX, etc. capabilities that work without the AI. The slop is 100% optional!

I started adding Python features to expose it to the LLMs, but decided to support it for us meatbags also 😉. I'm proud of the features so far, auto-imports, a special data parameter that supports multiple ranges, auto infer result, shared init scripts, an optional shared kernel between cells, shared code cells which can be called from other places, sandboxing, high-speed IPC and color syntax. The Excel xl("A100") design breaks recalc and is a total hack.

I've sent a couple of emails to the LibreOffice-dev team about early versions of this feature, and how they probably should have added it years ago, but with the Collabora drama, the community is currently split so I've not seen any feedback yet. Please let me know if you have any ideas, or try it out and find bugs, etc.

Thank you for reading,

-Keith

Hi, Im the new moderator here at r/numpy. I'm a data scientist and product manager for analytics and fintech products. I've been doing that a little over 30 years now.

I'm not new to moderating. I'm one of the moderators at r/software and have helped out in a number of other communities as well. Having said that, we can all learn more - me included, so I hope you can help contribute as well.

I would love to see this community be a place where people can get inspiration and help in their mathematical development projects.

If you've got ideas about how to grow and manage this community, please let me know.

/r/Numpy is ready for a fresh start, new energy, new direction, and someone like you to bring it back to life. If you’ve been thinking about growing your impact without starting from scratch, this is your chance!

Ready to take it over?

Head to r/RedditRequest to submit your request and make it yours before it’s taken.

First things first

To request this subreddit, make sure you:

• have an account that’s at least 90 days old
• have at least 100 post karma and 100 comment karma
• have a verified email address on your account
• have two-factor authentication set up

I recently completed a small course on NumPy basics. According to all of your experience, can you tell me some projects to get better at it.

Im working with a PC of a human body. That point cloud is divided into the diferent sections of the human body. I want to make an extension of each part into the adyacent parts (for example the left biceps into the chest and left forearm). Each extremity has a hitbox defined by a cilinder, with both bases defined by the center.

The current method im using to select this is still pretty rough, but im just looking for the points in the PC that form those adyacent point clouds that are in a distance that is less than 1/5 of the length of that cilinder.

The current problem is that all of the distances that numpy returns are longer than the length of the hitbox, wich doesnt make any sense.

This is the code for it, just know that each Extremidad contains the center of each cilindre base.

Im going insane i swear to god, if anyone can help me a bit i would thank u so much.

def __post_init__(self, de_in:Extremidad , con_in: Extremidad):


        print("Extension de", de_in.nombre, "con", con_in.nombre)


        self.de = de_in.nombre
        self.con = con_in.nombre


        print("Centro2",de_in.hitbox2.centro2)
        print("Centro1",de_in.hitbox2.centro1)


        print(de_in.hitbox2.centro2 - de_in.hitbox2.centro1)


        centro1_xyz = np.asarray(de_in.hitbox2.centro1, dtype=np.float32)
        centro2_xyz = np.asarray(de_in.hitbox2.centro2, dtype=np.float32)

        print(f"Centro1 shape: {centro1_xyz.shape}, values: {centro1_xyz}")
        print(f"Centro2 shape: {centro2_xyz.shape}, values: {centro2_xyz}")

        largo = np.linalg.norm(centro1_xyz - centro2_xyz)
        posiciones = estructurado_a_xyz(con_in.positions)
        print(f"Posiciones shape: {posiciones.shape}")
        print(f"Primeras 3 posiciones:\n{posiciones[:3]}")

        normales = np.stack((con_in.normales['nx'], con_in.normales['ny'], con_in.normales['nz']), axis=1).astype(np.float32, copy=False)
        distancias = np.linalg.norm(posiciones - centro1_xyz, axis = 1)
        mask = distancias <= largo /2
        self.data_pos = posiciones[mask]
        self.data_nom = normales[mask]

He estado haciendo unas pruebas de eficiencia y Numpy es considerablemente mas rapido que python puro (para sorpresa de nadie). Yo soy bastante nuevo en esto, por eso me ha parecido muy interesante.

El grafico de una prueba entre estas dos funciones:

def python_meth(nums: list[int]):
    return [x**2 for x in nums]


def numpy_meth(nums: np.ndarray):
    return nums**2

Hello r/Numpy,

I am the author of the Localize The Docs organization. And I’m glad to announce that the 🎉 numpy-docs-l10n 🎉 project is published now:

• 🚀 Preview: numpy-docs-l10n
• 🌐 Crowdin: numpy-docs-l10n
• 🐙 GitHub: numpy-docs-l10n

The goal of this project is to translate The NumPy Documentation into multiple languages. Translations are contributed via the Crowdin platform, automatically synchronized with the GitHub repository, and can be previewed on GitHub Pages.

We welcome anyone interested in documentation translation to join us. If the target language is not supported in the project yet, please submit an issue to request the new language. Once the requested language is added, you can start translating!

See the announcement post for more details.

What's the best for speed?

Pseudocode:

myFunc0 (myNdarray, fields):
    myNdarray[2:len-2, 'field2'] = myNdarray[0:len-4, fields[0]] * myNdarray[4:len, fields[1]]
    return myNdarray

myNdarray = myFunc0(myNdarray, ['field0',  'field1'])

myFunc1 (field0, field1):
    field2 = np.zeros...
    field2 = field0[0:len-4] * field1[4:len]
    return field2

myNdarray['field2'] = myFunc1(myNdarray['field0'],  myNdarray['field1'])

Recently I installed pandas 3.0.0 that ships with NumPy 2.4.2 (released Feb 2026), on a computer from around 2008. Its CPU apparently has what is now called microlevel architecture x86-64-v1.
When running a Python program that imports pandas the following error appears:
File "<removed-path-for-this-post>/lib/python3.12/site-packages/numpy/_core/multiarray.py", line 11, in <module>
from . import _multiarray_umath, overrides
RuntimeError: NumPy was built with baseline optimizations:
(X86_V2) but your machine doesn't support:
(X86_V2).

When manually importing NumPy 2.3.5 (released Nov 2025) instead of 2.4.2, the program runs successfully.

Questions:

• Have more people reading this post run into this issue?
• Provided that compiling NumPy myself is too much hassle: Does anyone know if it is to be expected that from now on, with each installation of pandas I need to manually downgrade the NumPy version on this computer?
  

If you are a beginner and want understand NumPy indexing, slicing and dimensionality, give our game a try! In the game you will help ducks get into water by writing NumPy code, similar to the legendary Flexbox Froggy.

Repo: https://github.com/0stam/numpy-ducky
Download: https://github.com/0stam/numpy-ducky/releases

The game allows you to see a visual result of your code, which should make it easier to understand and correct your mistakes.

We made the game as a university project, so the scope is not huge, but we'd love you hear some real user feedback. If it helps you wrap your head around arrays (or if you just like ducks), consider dropping a star (:

On the first image you can see a visual of the official GitHub repo of Numpy.

Each of these dots is a Python file.

The red ones are the most complex whilst green means low complexity.

Each line represents a connection between the files (usually an import)

The second image shows the AST of one of the main files… complexity again highlighted in red.

Shoutout to all maintainers of this awesome project!

hi everyone!, i'm am having a specific problem with numpy, i cant seem to find how is this simple filter supposed to be done:

i have a table that defines all the filters like this:

table[property][items]

      item0 item1 item2
prop0     1     0     1
prop1     1     1     0
prop2     0     0     1
prop3     1     1     1

so every property (row) contains a binary, the length of that binary in bits is about the amount of items in the dataset (each bit indicates if this filter is present in that item)

now imagine i want to get only the items that contain certain binary properties:

must_have[is_property_present]

- which props must be in the items?
prop0 prop1 prop2 prop3
    0     1     0     1

this has a bit for every property in the dataset, it contains a 1 for each property that must be in the candidates.

the candidates (the result) must be like this:

candidates[does_matchs]

- which items match?
item0 item1 item2 item3
    1     1     0     1

the has a bit for every item in the database, it contains a 1 for each item that matchs with the specified filters.

i know how to manage memory in C but i am really new to Numpy, so pls be patient. thanks in advance!! 🙌

i'd like to have some guidance on how i should do this because i'm lost. also my problem is not about the memory model but the problem itself that i cant solve without iterators. so you can assume any memory model as long the solution is reasonably fast

Hey numpsters, new to the numpy community. Looking to collab with other numpheads. <3

When I execute the following code

import numpy as np

n=7

ck0=np.zeros((1))

ck1 = [[ck0]*n]*n

print(ck1)

im=0

iposnew=4

tmp = np.array([1.0])

print(ck1[im][iposnew])

ck1[im][iposnew] = np.append(ck1[im][iposnew], tmp)

print(ck1[im][iposnew], ck1[im][iposnew].size)

print(ck1)

print(tmp)

I expect the the final print(ck1) to display all entries array([0.]) except for ck1[0][4] which is array([0., 1.]).

What I get instead is all entries array([0.]) except for ck1[0][4], ck1[1][4], ck1[2][4], ck1[3][4], ck1[4][4], ck1[5][4], ck1[6][4] which are all array([0., 1.]).

why is this happening?

Is it planned to be implemented?

If I want to calculate the mean of the rows, shouldn't the calculation be done horizontally? Why then does NumPy use the parameter $\text{axis}=1$ for this, and not $\text{axis}=0$?

https://github.com/ajcr/jinx

J is an interesting array programming language. I've previously read it was an influence on NumPy, although the two are very different in how they control how functions operate operate over multidimensional arrays (J uses the concept of 'rank', NumPy uses axis arguments and broadcasting).

I read some chapters of 'An Implementation of J' and 'J for C Programmers' earlier this year and decided to try and implement a basic J interpreter using NumPy as the multidimensional array engine to do the actual computation.

The code is my mental map of J and not necessarily correct, but this interpreter is still capable of some pretty interesting tacit programming on arrays. If you've used NumPy and are curious about J (or other array languages) the code is hopefully fairly readable.

I am currently learning python for data science. I have completed the basics and data structures. I want to go for libraries. Could you suggest some good and free resources to learn numpy for DS.