Data Science Archives - Be on the Right Side of Change

The JSON Trick – How to Scrape All Answers in a Subreddit? (Example Find User Needs)

Chris — Mon, 29 Dec 2025 11:17:42 +0000

Step 1: Open a subreddit with lots of comments and answers relevant to your niche.

Step 2: Append “.json” to the URL

Example Subreddit URL: https://www.reddit.com/r/GeminiAI/comments/1pyi6ax/how_to_tell_if_an_image_is_ai_generated
Example JSON: https://www.reddit.com/r/GeminiAI/comments/1pyi6ax/how_to_tell_if_an_image_is_ai_generated.json

Step 3: Copy and paste the whole JSON data into ChatGPT/Gemini/Claude

Step 4: Prompt something like this to discover user needs:

Look at this Subreddit (JSON format). Find and list all user pain points, needs, and struggles. Suggest top products and unique selling propositions (USPs) to satisfy these needs. Research similar products and find unique positions.

Here’s a sample output on my ChatGPT 5.2 Thinking:

It also shows a number of products that would fill these needs:

I omit the rest for brevity – you get the point.

This truly is a goldmine of business need analysis.

The post The JSON Trick – How to Scrape All Answers in a Subreddit? (Example Find User Needs) appeared first on Be on the Right Side of Change.

42 Free University Books (PDF/HTML)

Chris — Mon, 03 Nov 2025 14:13:32 +0000

About this free book collection. Below are some of the highest-quality university textbooks that you can legally read and download for free. Each entry lists the title (in bold), the author(s) in italics, and the available formats with notes on whether a sign-up is required. Links point directly to the free books – I have manually checked the link quality (by hand).

Structure and Interpretation of Computer Programs – Harold Abelson & Gerald Jay Sussman (HTML, no sign-up) – the classic MIT programming text is released as an open-access web edition under a Creative Commons license

The Feynman Lectures on Physics – Richard P. Feynman, Robert B. Leighton & Matthew Sands (HTML, no sign-up) – Caltech’s website hosts the complete three-volume lecture series free of charge.
Deep Learning – Ian Goodfellow, Yoshua Bengio & Aaron Courville (HTML, no sign-up) – the authors and MIT Press offer a complete online version that will remain freely accessible.
Operating Systems: Three Easy Pieces – Remzi H. Arpaci-Dusseau & Andrea C. Arpaci-Dusseau (PDF, no sign-up) – a comprehensive OS text that the authors explicitly intend to remain freely available.
Category Theory for Scientists – David I. Spivak (PDF, no sign-up) – MIT’s open-courseware site links to this freely downloadable textbook.

Algebraic Topology – Allen Hatcher (PDF, no sign-up) – the author and publisher allow free download of this standard graduate-level text.
Linear Algebra – Jim Hefferon (PDF & HTML, no sign-up) – Hefferon’s textbook is free to download and is licensed for redistribution.
Introduction to Real Analysis – William F. Trench (PDF, no sign-up) – a free, Creative Commons–licensed edition of this undergraduate text.
Abstract Algebra: Theory and Applications – Thomas W. Judson (PDF, no sign-up) – an open textbook published under the GNU Free Documentation License.
Introduction to Probability – Charles M. Grinstead & J. Laurie Snell (HTML & PDF, no sign-up) – the authors distribute this complete text under a free documentation license.

The Elements of Statistical Learning – Trevor Hastie, Robert Tibshirani & Jerome Friedman (PDF, no sign-up) – a highly regarded machine-learning reference with a free PDF.
Reinforcement Learning: An Introduction – Richard S. Sutton & Andrew G. Barto (HTML & PDF, no sign-up) – the authors provide free HTML and PDF downloads under a Creative Commons license.
Convex Optimization – Stephen Boyd & Lieven Vandenberghe (PDF, no sign-up) – Cambridge University Press permits the authors to host the PDF for free.
Open Data Structures – Pat Morin (HTML & PDF, no sign-up) – the book and source code are free (libre and gratis) under a Creative Commons license.
Algorithms – Jeff Erickson (PDF, no sign-up) – this self-published textbook remains free; anyone may download, copy and redistribute it under a Creative Commons license.

Think Python – Allen B. Downey (HTML & PDF, no sign-up) – a beginner-friendly Python book released under a Creative Commons license and explicitly described as a free book.
Think Stats – Allen B. Downey (HTML & PDF, no sign-up) – the author’s site hosts a free, online version and encourages readers to share it under a Creative Commons license.
Eloquent JavaScript – Marijn Haverbeke (HTML & PDF, no sign-up) – the fourth edition is available online under a Creative Commons Attribution–Noncommercial license.
Dive Into Deep Learning – Aston Zhang, Zachary C. Lipton, Mu Li & Alex J. Smola (HTML & PDF, no sign-up) – this open-source interactive book offers free online and PDF versions.

APEX Calculus – Gregory Hartman et al. (PDF, no sign-up) – an open-source calculus textbook; anyone can download and print the PDF version for free.
OpenIntro Statistics – David M. Diez, Christopher D. Barr & Mine Çetinkaya-Rundel (PDF, no sign-up) – the OpenIntro collection notes that all its textbooks have free PDF versions.
Introduction to Modern Statistics – Mine Çetinkaya-Rundel & Johanna Hardin (PDF, no sign-up) – an OpenIntro statistics text; the series offers free PDF downloads.
Introductory Statistics for the Life and Biomedical Sciences – Nathaniel Horton & Benjamin S. Baumer (PDF, no sign-up) – another OpenIntro textbook with a freely downloadable PDF.
Advanced High School Statistics – David M. Diez & Christopher D. Barr (PDF, no sign-up) – OpenIntro’s AP/advanced-high-school statistics book; the PDF is free.
Introductory Statistics with Randomization & Simulation – David M. Diez, Christopher D. Barr & Mine Çetinkaya-Rundel (PDF, no sign-up) – part of OpenIntro’s free-PDF series.

OpenStax textbooks (free PDF & web view, no registration)

OpenStax, a nonprofit initiative at Rice University, publishes a wide range of peer-reviewed textbooks. Their policy explicitly states that the books are free to read online or download in PDF with no passwords or registration required. The following OpenStax titles are excellent resources:

Calculus Volume 1 – Gilbert Strang et al. (PDF & Web, no sign-up) – first-semester calculus with interactive examples and problem sets.

Calculus Volume 2 – Gilbert Strang et al. (PDF & Web, no sign-up) – covers sequences, series, and multivariable calculus.
Calculus Volume 3 – Gilbert Strang et al. (PDF & Web, no sign-up) – advanced topics such as vector calculus and partial differential equations.
University Physics Volume 1 – Samuel J. Ling, William Moebs & Jeff Sanny (PDF & Web, no sign-up) – covers mechanics and thermodynamics.
University Physics Volume 2 – Samuel J. Ling, William Moebs & Jeff Sanny (PDF & Web, no sign-up) – electromagnetism and optics.
University Physics Volume 3 – Samuel J. Ling, William Moebs & Jeff Sanny (PDF & Web, no sign-up) – modern physics and waves.
Chemistry 2e – Paul Flowers et al. (PDF & Web, no sign-up) – a full general-chemistry text.
Biology 2e – Mary Ann Clark et al. (PDF & Web, no sign-up) – comprehensive introductory biology.

Microbiology – OpenStax (PDF & Web, no sign-up) – covers microbial structure, physiology and genetics.
College Algebra – Jay Abramson (PDF & Web, no sign-up) – functions, polynomials and graphs for precalculus preparation.
Linear Algebra – Jim Hefferon (PDF & Web, no sign-up) – a modern introduction to linear algebra and matrix theory.
Differential Equations – William F. Trench (PDF & Web, no sign-up) – an OpenStax adaptation of Trench’s classic book.
Principles of Macroeconomics 2e – OpenStax (PDF & Web, no sign-up) – macroeconomics with current policy examples.
Principles of Microeconomics 2e – OpenStax (PDF & Web, no sign-up) – microeconomic theory and applications.
Psychology 2e – OpenStax (PDF & Web, no sign-up) – foundational topics in psychology.
Introduction to Sociology 3e – OpenStax (PDF & Web, no sign-up) – explores social institutions, culture, and modern issues.
Biology for AP Courses – OpenStax (PDF & Web, no sign-up) – designed for advanced high-school or introductory university biology.

These books span mathematics, computer science, physics, statistics, economics and the life sciences. Because they carry open licenses and are distributed via trusted publishers such as MIT Press, Caltech, OpenIntro and OpenStax, they are excellent resources for self-learners and educators alike.

You may also be interested in my collection on free Artificial Intelligence books!

42 Free AI Books (PDF/HTML)

The post 42 Free University Books (PDF/HTML) appeared first on Be on the Right Side of Change.

Leverage Plays — Growing $10k to $472k using 50% Margin Loans to Buy a 30% CAGR Asset

Chris — Mon, 06 May 2024 18:10:44 +0000

Problem Formulation

In this investment analysis, we explore three scenarios to compare how leveraging impacts the growth of an initial $10,000 investment over a period of 10 years.

The first scenario demonstrates simple growth at a rate of 30% per year without leverage.
In the second scenario, we introduce a one-time 50% margin loan reinvested into the asset, with loan costs at 7% annually, showing a more pronounced growth due to increased initial capital.
The third and most dynamic scenario applies continuous re-leveraging each year, recalculating leverage based on the asset’s increased value, thereby exponentially boosting the investment’s growth potential. This method reflects not only the highest return but also illustrates the increasing risk associated with continuous borrowing.

By visualizing these scenarios, we clearly see the potential gains from leverage and the exponential increase in asset value, particularly in the aggressive re-leveraging approach.

Note: The third scenario provides the most gains when the investment works out. But it is path-dependent, meaning that if at any time the asset goes down by 50% or more (even for a short period of time), the margin call can completely wipe out the strategy.

Analysis

Here is the comparison of the three investment scenarios, each starting with an initial investment of $10,000 over a span of 10 years:

The attached chart visually compares these investment values over the years, showing the exponential increase particularly in Scenario 3 due to the compounding effect of continual re-leveraging.

Year	Scenario 1: No Leverage	Scenario 2: One-time Leverage	Scenario 3: Re-leverage Each Year
0	10,000	10,000	10,000
1	13,000	14,150	14,150
2	16,900	19,626	20,637
3	21,970	26,830	30,401
4	28,561	36,288	44,930
5	37,129	48,681	66,469
6	48,268	64,898	98,366
7	62,749	86,094	145,584
8	81,573	113,769	215,476
9	106,045	149,875	318,925
10	137,858	196,952	472,039

Scenario 1 shows straightforward growth without leveraging, resulting in a final investment value of $137,858 after 10 years.

The compound annual growth rate is 30%:

Scenario 2 involves taking an initial 50% margin loan and reinvesting it into the asset. The total investment grows to $196,952, accounting for the cost of the loan.

The compound annual growth rate is 34.72%:

Scenario 3 is the most aggressive strategy where leverage is recalculated and reapplied each year, reflecting the increase in asset value and allowing for exponential growth. This strategy results in a significantly higher value of $472,039 after 10 years, though it also carries higher risk due to increasing leverage.

The compound annual growth rate is 47.03%:

Python Script

Here’s the Python code you can use to simulate and compare the three investment scenarios. This code calculates the growth of an initial investment under different leverage and reinvestment conditions, and plots the results for visual comparison:

import numpy as np
import matplotlib.pyplot as plt

# Parameters
initial_investment = 10000
growth_rate = 0.30
loan_interest_rate = 0.07
loan_ratio = 0.5
years = 10

# Scenario 1: Simple growth
scenario_1 = np.array([initial_investment * (1 + growth_rate) ** year for year in range(years + 1)])

# Scenario 2: Initial margin loan and reinvestment
loan_amount = initial_investment * loan_ratio
total_investment_2 = initial_investment + loan_amount
scenario_2 = np.array([total_investment_2 * (1 + growth_rate) ** year - loan_amount * (1 + loan_interest_rate) ** year for year in range(years + 1)])

# Scenario 3: Re-leverage each year
assets_3 = [initial_investment * (1+loan_ratio)]
loans_3 = [initial_investment * loan_ratio]
for year in range(years):
    # grow asset
    new_assets = assets_3[-1] * (1 + growth_rate)
    current_loan = loans_3[-1] * (1 + loan_interest_rate)
    new_loan = new_assets * loan_ratio - current_loan
    assets_3.append(new_assets + new_loan)
    loans_3.append(new_assets * loan_ratio)

scenario_3 = np.array([asset - loan for asset, loan in zip(assets_3, loans_3)])

# Create a chart
plt.figure(figsize=(12, 8))
plt.plot(range(years + 1), scenario_1, label='Scenario 1: No Leverage', marker='o')
plt.plot(range(years + 1), scenario_2, label='Scenario 2: One-time Leverage', marker='o')
plt.plot(range(years + 1), scenario_3, label='Scenario 3: Re-leverage Each Year', marker='o')
plt.title('Comparison of Investment Scenarios')
plt.xlabel('Years')
plt.ylabel('Investment Value ($)')
plt.legend()
plt.grid(True)
plt.show()

This code uses NumPy for array operations and matplotlib for plotting the growth of investments over time. Each scenario is defined based on the investment strategy:

Scenario 1 represents a straightforward investment without leverage.
Scenario 2 incorporates a one-time margin loan.
Scenario 3 applies a re-leveraging strategy each year, dynamically adjusting the loan based on the asset’s performance.

You can run this script in any Python environment that supports these libraries to visualize and analyze the different investment scenarios.

Feel free to also read the following Finxter article:

The Math of Becoming a Millionaire in 13 Years

The post Leverage Plays — Growing $10k to $472k using 50% Margin Loans to Buy a 30% CAGR Asset appeared first on Be on the Right Side of Change.

NumPy @ Operator vs np.dot()

Emily Rosemary Collins — Tue, 02 Apr 2024 20:25:47 +0000

Both the @ operator and the dot function are pivotal for matrix multiplication. However, beginners and even some seasoned programmers might find themselves puzzled over which to use and when.

What are the `@` Operator and `dot` Function?

NumPy, Python’s fundamental package for scientific computing, offers several ways to perform operations on arrays and matrices.

Among these, the @ operator and the dot function stand out for matrix multiplication.

The @ Operator: Introduced in Python 3.5, the @ operator is specifically designed for matrix multiplication. It’s a syntactic sugar that makes code involving matrix operations more readable and concise.
The dot Function: The dot function in NumPy is used for dot products of vectors, multiplication of two matrices, and more.

When to Use Each?

Use @ for Matrix Multiplication: If you’re working solely with matrix multiplication, the @ operator is your go-to for its readability and simplicity. It’s perfect for operations where the intent is explicitly matrix multiplication, making your code easier to read and understand at a glance.

Use dot for Flexibility: The dot function is more flexible. Beyond matrix multiplication, it can handle dot products of vectors and multiplication between a scalar and an array. If your operations aren’t limited to matrix multiplication or if you’re working with versions of Python older than 3.5, dot is the more appropriate choice.

Example

Let’s dive into a fun example that clearly demonstrates the difference between the @ operator and the dot function in NumPy, using a scenario where we’re working with a small game development project. Imagine we have two matrices representing transformations applied to game characters: one for scaling their size and another for rotating them. We’ll see how both operators are used to apply these transformations.

First, ensure you have NumPy installed:

pip install numpy

Here’s the minimal code example:

import numpy as np

# Transformation matrices for our game characters
# Scaling matrix (to double the size)
scaling_matrix = np.array([[2, 0],
                           [0, 2]])

# Rotation matrix (90 degrees)
rotation_matrix = np.array([[0, -1],
                            [1,  0]])

# Position of our character in 2D space (x, y)
character_position = np.array([1, 0]).reshape(2, 1)  # Making it a column vector

# Using the @ operator for a clear, straightforward matrix multiplication
transformed_position_at = scaling_matrix @ rotation_matrix @ character_position

# Using the dot function for the same operation
transformed_position_dot = np.dot(np.dot(scaling_matrix, rotation_matrix), character_position)

# Display the results
print("Transformed Position with @:", transformed_position_at.flatten())
print("Transformed Position with dot:", transformed_position_dot.flatten())

In this playful example, we first define matrices for scaling and rotation, applying them to a character’s position to move them around the game world. The character starts at position (1, 0), and we want to double their size and rotate them 90 degrees.

The @ operator example uses a clear and concise syntax that makes it evident we’re performing sequential matrix multiplications to transform the character’s position. In contrast, the dot function example achieves the same result but requires a more nested and slightly less readable approach.

Both methods will give the same result, demonstrating their functional similarity despite the syntactic differences. This minimal example underscores the choice between @ and dot as largely a matter of code readability and stylistic preference, rather than functionality.

Performance Differences

Is there a significant performance difference between the @ operator and the dot function?

The answer is generally no. Under the hood, both perform the same matrix multiplication operation with similar efficiency. Performance might slightly vary depending on the context, but for most practical purposes, they are interchangeable in terms of speed.

Syntax and Readability

One of the main differences lies in syntax and readability:

# Using the @ operator
result = matrix1 @ matrix2

# Using the dot function
result = numpy.dot(matrix1, matrix2)

The @ operator allows for a cleaner and more intuitive expression of multiplication, especially when dealing with complex mathematical formulas. It reduces the cognitive load, making it easier for someone reading your code to understand your intentions.

Compatibility Considerations

While the @ operator is sleek and modern, it’s essential to remember it’s only available in Python versions 3.5 and above. For codebases that must remain compatible with earlier versions of Python, or when working in environments where you cannot guarantee the Python version, the dot function remains a reliable and compatible choice.

Best Practices

Readability First: Opt for the @ operator when you’re focused on matrix multiplication to enhance code readability.
Consider Your Audience: Use the dot function in environments where Python versions earlier than 3.5 are still in use or when you need the extra flexibility it offers.
Performance Testing: If you’re in a situation where performance is critical, test both methods in your specific use case. However, remember that differences are likely to be minimal.

The post NumPy @ Operator vs np.dot() appeared first on Be on the Right Side of Change.

How to Fit a Curve to Power-law Distributed Data in Python

Chris — Sun, 31 Mar 2024 07:21:01 +0000

In this tutorial, you’ll learn how to generate synthetic data that follows a power-law distribution, plot its cumulative distribution function (CDF), and fit a power-law curve to this CDF using Python. This process is useful for analyzing datasets that follow power-law distributions, which are common in natural and social phenomena.

Prerequisites

Ensure you have Python installed, along with the numpy, matplotlib, and scipy libraries. If not, you can install them using pip:

pip install numpy matplotlib scipy

Step 1: Generate Power-law Distributed Data

First, we’ll generate a dataset that follows a power-law distribution using numpy.

import numpy as np

# Parameters
alpha = 3.0  # Exponent of the distribution
size = 1000  # Number of data points

# Generate power-law distributed data
data = np.random.power(a=alpha, size=size)

How to Generate and Plot Random Samples from a Power-Law Distribution in Python?

The data looks like this:

Let’s make some sense out of it and plot it in 2D space:

Step 2: Plot the Cumulative Distribution Function (CDF)

Next, we’ll plot the CDF of the generated data on a log-log scale to visualize its power-law distribution.

import matplotlib.pyplot as plt

# Prepare data for the CDF plot
sorted_data = np.sort(data)
yvals = np.arange(1, len(sorted_data) + 1) / float(len(sorted_data))

# Plot the CDF
plt.plot(sorted_data, yvals, marker='.', linestyle='none', color='blue')
plt.xlabel('Value')
plt.ylabel('Cumulative Frequency')
plt.title('CDF of Power-law Distributed Data')
plt.xscale('log')
plt.yscale('log')
plt.grid(True, which="both", ls="--")
plt.show()

The plot:

Step 3: Fit a Power-law Curve to the CDF

To understand the underlying power-law distribution better, we fit a curve to the CDF using the curve_fit function from scipy.optimize.

from scipy.optimize import curve_fit

# Power-law fitting function
def power_law_fit(x, a, b):
    return a * np.power(x, b)

# Fit the power-law curve
params, covariance = curve_fit(power_law_fit, sorted_data, yvals)

# Generate fitted values
fitted_yvals = power_law_fit(sorted_data, *params)

Step 4: Plot the Fitted Curve with the CDF

Finally, we’ll overlay the fitted power-law curve on the original CDF plot to visually assess the fit.

# Plot the original CDF and the fitted power-law curve
plt.plot(sorted_data, yvals, marker='.', linestyle='none', color='blue', label='Original Data')
plt.plot(sorted_data, fitted_yvals, 'r-', label='Fitted Power-law Curve')
plt.xlabel('Value')
plt.ylabel('Cumulative Frequency')
plt.title('CDF with Fitted Power-law Curve')
plt.xscale('log')
plt.yscale('log')
plt.grid(True, which="both", ls="--")
plt.legend()
plt.show()

Voilà!

This visualization helps in assessing the accuracy of the power-law model in describing the distribution of the data.

Visualizing Wealth: Plotting the Net Worth of the World’s Richest in Log/Log Space

Chris — Mon, 25 Mar 2024 11:30:48 +0000

The distribution of wealth, especially when it comes to the ultra-wealthy, is a subject of immense fascination and study. It can reveal patterns and insights into economic structures, inequality, and financial dynamics at the highest levels.

One of the most revealing ways to examine this distribution is through a log/log plot of the net worths of the world’s richest individuals. Here’s how to visualize the net worth of the top 100 richest people using Python, providing a step-by-step guide to create a log/log space plot.

Understanding the Data

The dataset consists of the net worths of the top 100 richest people in the world. This information is often available from financial news outlets and wealth-tracking websites. For the purpose of this demonstration, assume we have this data in a list where each value represents an individual’s net worth in billions of dollars.

Here’s a sample from the data:

Why Log/Log Space?

A log/log plot is particularly useful for data that spans several orders of magnitude, as it does with the world’s wealthiest individuals. This type of plot can help to linearize exponential relationships, making it easier to identify patterns that might not be apparent in a linear plot. For wealth distributions, which often follow a power law, log/log plots can highlight the underlying distribution’s scale-free nature.

Preparing for the Plot

Before plotting, ensure you have Python installed on your system along with the necessary libraries: Matplotlib for plotting and NumPy for numerical operations.

If you haven’t already, you can install these libraries using pip:

pip install matplotlib numpy

The Python Script

First, import the necessary libraries:

import matplotlib.pyplot as plt
import numpy as np

Assuming you have the net worth data in a list named net_worths in billions of dollars, you can prepare your data.

For ease of reproducibility, I’ll include my list at the point of writing here:

net_worths_float = [
    234.0, 156.0, 155.0, 126.0, 125.0, 124.0, 118.0, 117.0, 116.0, 116.0,
    87.8, 84.6, 82.4, 74.3, 72.6, 70.6, 69.6, 67.8, 63.2, 61.7, 61.6, 59.4,
    50.5, 50.5, 42.3, 41.3, 41.3, 40.0, 39.9, 39.1, 38.8, 37.0, 36.1, 36.0,
    35.2, 35.1, 34.2, 32.9, 32.0, 31.9, 31.9, 31.5, 30.1, 29.5, 29.3, 29.2,
    28.9, 28.5, 28.0, 27.9, 27.9, 27.7, 27.3, 27.1, 26.6, 26.5, 26.5, 25.9,
    25.1, 23.9, 23.9, 23.4, 23.2, 23.2, 23.0, 22.6, 22.3, 22.1, 21.8, 21.6,
    21.5, 21.5, 21.4, 21.4, 21.3, 21.2, 20.6, 20.6, 20.4, 20.3, 19.9, 19.7,
    19.6, 19.1, 19.0, 18.9, 18.8, 18.8, 18.5, 18.5, 18.5, 18.5, 18.4, 17.7,
    17.6, 17.6, 17.5, 17.2, 17.2, 17.2
]

If your data isn’t sorted, sort it in descending order:

net_worths = sorted(net_worths, reverse=True)

Next, create a rank for each individual based on their position in the sorted list. The richest person gets rank 1, the second richest gets rank 2, and so on:

ranks = np.arange(1, len(net_worths) + 1)

Plotting the Data

Now, you’re ready to plot the data in log/log space:

plt.figure(figsize=(10, 6))
plt.loglog(ranks, net_worths, marker='o', linestyle='-', color='b')
plt.xlabel('Rank (log scale)')
plt.ylabel('Net Worth in Billions (log scale)')
plt.title('Net Worth of the Top 100 Richest People (Log/Log Space)')
plt.grid(True, which="both", ls="--")
plt.show()

This code snippet will generate a log/log plot of the net worths. The loglog function from Matplotlib is used to automatically scale both axes to a logarithmic scale. Markers are added for each point to clearly delineate the individual net worths, and a grid is added for better readability.

Interpreting the Plot

In the resulting plot, each point represents an individual’s net worth plotted against their rank. A straight line in a log/log plot indicates a power law distribution, common in wealth distributions and many natural phenomena. The slope of this line (if it appears roughly straight) can give you the power law’s exponent, offering deeper insights into the inequality of wealth distribution.

This visualization technique is not just limited to financial data; it can be applied to any dataset that spans multiple orders of magnitude and is suspected to follow a power law or similar distribution. Whether you’re a data scientist, economist, or simply a curious observer, plotting data in log/log space can unveil patterns and relationships that are not immediately visible in traditional linear plots.

Follow Up Analysis

For instance, you can examine the cumulative net worth as people are sampled from this distribution:

Also, check out our Finxter article:

8 Millionaire Tips to Reach Financial Freedom as a Coder

The post Visualizing Wealth: Plotting the Net Worth of the World’s Richest in Log/Log Space appeared first on Be on the Right Side of Change.

5 Best Ways to Create NumPy Arrays of Random Numbers in Python

Emily Rosemary Collins — Tue, 20 Feb 2024 13:20:25 +0000

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

numpy.random.choice() generates a random sample from a given 1-D array or integer. It can be especially useful when you have a predefined pool of numbers to sample from, or for random selections with replacement or without replacement.

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

The numpy.random.permutation() function randomly permutes a sequence, or returns a permuted range. If you pass it an integer, it will permute a sequence of that length like np.arange() would generate, effectively creating a random arrangement of numbers.

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

NumPy’s numpy.random.randint() is perfect for creating arrays of random integers within a specified range. This method allows for both a low and high boundary, and you can define the desired shape of the array.

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

array_random = np.random.rand(5)
print(array_random)

Output:

[0.72356185 0.52973365 0.70121909 0.07551513 0.82938063]

This code snippet generates an array of 5 random floating-point numbers. Each number is from the uniform distribution in the interval [0, 1), meaning any number within this range is equally likely to appear.

Method 2: Using numpy.random.randn()

The numpy.random.randn() function returns an array filled with random floats sampled from a standard normal distribution (mean 0 and variance 1), often used when Gaussian distribution is desired.

Here’s an example:

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

array_random = np.random.rand(5)
print(array_random)

Output:

[0.72356185 0.52973365 0.70121909 0.07551513 0.82938063]

Method 2: Using numpy.random.randn()

The numpy.random.randn() function returns an array filled with random floats sampled from a standard normal distribution (mean 0 and variance 1), often used when Gaussian distribution is desired.

Here’s an example:

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

array_random = np.random.rand(5)
print(array_random)

Output:

[0.72356185 0.52973365 0.70121909 0.07551513 0.82938063]

Method 2: Using numpy.random.randn()

The numpy.random.randn() function returns an array filled with random floats sampled from a standard normal distribution (mean 0 and variance 1), often used when Gaussian distribution is desired.

Here’s an example:

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

array_random = np.random.rand(5)
print(array_random)

Output:

[0.72356185 0.52973365 0.70121909 0.07551513 0.82938063]

Method 2: Using numpy.random.randn()

The numpy.random.randn() function returns an array filled with random floats sampled from a standard normal distribution (mean 0 and variance 1), often used when Gaussian distribution is desired.

Here’s an example:

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

array_random = np.random.rand(5)
print(array_random)

Output:

[0.72356185 0.52973365 0.70121909 0.07551513 0.82938063]

Method 2: Using numpy.random.randn()

The numpy.random.randn() function returns an array filled with random floats sampled from a standard normal distribution (mean 0 and variance 1), often used when Gaussian distribution is desired.

Here’s an example:

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

array_random = np.random.rand(5)
print(array_random)

Output:

[0.72356185 0.52973365 0.70121909 0.07551513 0.82938063]

Method 2: Using numpy.random.randn()

The numpy.random.randn() function returns an array filled with random floats sampled from a standard normal distribution (mean 0 and variance 1), often used when Gaussian distribution is desired.

Here’s an example:

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

array_random = np.random.rand(5)
print(array_random)

Output:

[0.72356185 0.52973365 0.70121909 0.07551513 0.82938063]

Method 2: Using numpy.random.randn()

The numpy.random.randn() function returns an array filled with random floats sampled from a standard normal distribution (mean 0 and variance 1), often used when Gaussian distribution is desired.

Here’s an example:

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

Problem Formulation: In scientific computing with Python, it’s a common task to create arrays of random numbers using the NumPy library, whether for initializing parameters in machine learning algorithms, for simulations, or just for data analysis. For instance, a user may need an array of 10 random floats within the range 0 to 1 for testing a function. This article will explore different methods to achieve this using NumPy.

Method 1: Using numpy.random.rand()

NumPy’s numpy.random.rand() function is used to create an array of specified shape filled with random samples from a uniform distribution over [0, 1). This function is straightforward and easy to use when you need random floats.

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

import numpy as np

array_random = np.random.rand(5)
print(array_random)

Output:

[0.72356185 0.52973365 0.70121909 0.07551513 0.82938063]

Method 2: Using numpy.random.randn()

The numpy.random.randn() function returns an array filled with random floats sampled from a standard normal distribution (mean 0 and variance 1), often used when Gaussian distribution is desired.

Here’s an example:

import numpy as np

normal_array = np.random.randn(5)
print(normal_array)

Output:

[-0.23471354 1.34085684 0.18792722 -1.86084279 0.23723502]

The generated array contains 5 random numbers that are drawn from a standard normal distribution. This means that the numbers are centered around 0, with a standard deviation of 1.

Method 3: Using numpy.random.randint()

Here’s an example:

import numpy as np

int_array = np.random.randint(10, size=(5))
print(int_array)

Output:

[2 4 7 6 9]

This snippet produces an array of 5 random integers between 0 (inclusive) and 10 (exclusive). It’s an easy way to generate random discrete data efficiently.

Method 4: Using numpy.random.choice()

Here’s an example:

import numpy as np

sample_array = np.random.choice([1, 2, 3, 4, 5], size=5)
print(sample_array)

Output:

[4 1 2 2 5]

This code generates an array of 5 elements by randomly choosing numbers from the predefined array. This is particularly handy when the random values need to come from a specific set of numbers.

Bonus One-Liner Method 5: Using numpy.random.permutation()

Here’s an example:

import numpy as np

permuted_array = np.random.permutation(5)
print(permuted_array)

Output:

[4 0 2 1 3]

This snippet outcome is a randomly permuted arrangement of the numbers 0 through 4. It’s a neat one-liner that’s perfect for shuffling data or labels within machine learning contexts.

Summary/Discussion

Choosing the right method to create random arrays with NumPy depends on the specific needs of your task:

Method 1: numpy.random.rand(). Strength: Simple, uniform distribution. Weakness: Only produces floats in [0, 1).
Method 2: numpy.random.randn(). Strength: Outputs are from a standard normal distribution. Weakness: Output is not bounded within a specific range.
Method 3: numpy.random.randint(). Strength: Useful for discrete numbers, allows range specification. Weakness: Only generates integers.
Method 4: numpy.random.choice(). Strength: Select from a predefined array. Weakness: Not for generating truly continuous random values.
Method 5: numpy.random.permutation(). Strength: Great for shuffling. Weakness: Limited to permuting existing arrays or sequences.

The post 5 Best Ways to Create NumPy Arrays of Random Numbers in Python appeared first on Be on the Right Side of Change.

5 Best Ways to Create a NumPy Array of Size N in Python

Emily Rosemary Collins — Tue, 20 Feb 2024 13:20:25 +0000

Problem Formulation: When working with numerical computations in Python, a frequent requirement is to create a NumPy array of a specific size. For instance, a data scientist may need to initialize an array of size n with zeros before populating it with data. This article guides you through various methods to create a NumPy array of size n, with an emphasis on ease of use and different initialization values.

Method 1: Using numpy.zeros()

Creating an array of size n with all elements initialized to zero can be quickly achieved using the numpy.zeros() function. This method is especially useful for initializing arrays for algorithms that rely on a zero baseline. The function takes the desired array size as an argument and returns a new NumPy array of that size, filled with zeros.

Here’s an example:

import numpy as np

n = 10  # Define array size
zero_array = np.zeros(n)

print(zero_array)

Output:

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

This code snippet demonstrates the simplicity of creating an array filled with zeros. The variable n represents the desired array size, and the np.zeros(n) function is used to create an array of this size.

Method 2: Using numpy.ones()

Similarly to the zeros, NumPy offers the numpy.ones() function to create an array of size n where every element is initialized to one. This type of array is particularly useful when dealing with algorithms that require a starting value of one for each element or for creating a neutral multiplicative identity element in array operations.

Here’s an example:

import numpy as np

n = 10
ones_array = np.ones(n)

print(ones_array)

Output:

[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

By calling np.ones(n), we quickly get an array of ones, with n defining the size. This approach is as straightforward as the first, showcasing the ease of initializing arrays in NumPy.

Method 3: Using numpy.full()

For more general array initializations where each element is a specific number other than zero or one, the numpy.full() function fills the bill. This versatile function accepts the array size and the number to fill the array with, accommodating diverse initialization needs.

Here’s an example:

import numpy as np

n = 10
filled_array = np.full(n, 3.14)

print(filled_array)

Output:

[3.14 3.14 3.14 3.14 3.14 3.14 3.14 3.14 3.14 3.14]

The function np.full(n, 3.14) creates an array of size n where each element is initialized with the value 3.14. It showcases the flexibility of NumPy in array initialization.

Method 4: Using numpy.arange()

When the requirement is to create an array with a sequence of numbers, numpy.arange() is the go-to function. This method starts at zero (by default) and generates numbers up to a specified number, providing a simple way to generate a range of values within an array.

Here’s an example:

import numpy as np

n = 10
sequence_array = np.arange(n)

print(sequence_array)

Output:

[0 1 2 3 4 5 6 7 8 9]

The code utilizes np.arange(n) to generate an array containing a sequence of n numbers starting from 0. It is perfect when a specific progression of numbers is required.

Bonus One-Liner Method 5: Using numpy.empty()

To create an uninitialized array of size n, which can be slightly faster than other methods when initialization is not a concern, numpy.empty() is the ideal solution. Note that the array will contain arbitrary values, essentially whatever was in the allocated memory at the time of creation.

Here’s an example:

import numpy as np

n = 10
empty_array = np.empty(n)

print(empty_array)

Output:

[random_values_based_on_memory]

Here, np.empty(n) generates an uninitialized array of size n. This method can be faster for large arrays when the initial values will be immediately overwritten. Be cautious as it will contain arbitrary values.

Summary/Discussion

Method 1: numpy.zeros(). Creates an array with zeros. Ideal for algorithms that start from a zero-baseline. Not suitable if non-zero initialization is needed.
Method 2: numpy.ones(). Initializes an array with ones. Perfect for when working with algorithms needing a starting value of one. Less flexible in terms of initial values.
Method 3: numpy.full(). Fills an array with any specified value. Offers flexibility for specific initializations. Slightly more verbose than zeros or ones.
Method 4: numpy.arange(). Generates an array with a sequence of numbers. Very useful for creating ordered datasets. Not meant for single-value initialization.
Method 5: numpy.empty(). Creates an uninitialized array. Fast when starting values will be overwritten. Risky if unexpected values could cause issues.

The post 5 Best Ways to Create a NumPy Array of Size N in Python appeared first on Be on the Right Side of Change.

5 Best Ways to Create a NumPy Array of Strings

Emily Rosemary Collins — Tue, 20 Feb 2024 13:20:25 +0000

Problem Formulation:

How do you create a NumPy array consisting solely of strings? Understanding how to construct a NumPy array of strings is essential for handling textual data in scientific computing. The problem tackled here is the creation of such an array given a sequence of strings, such as ['apple', 'banana', 'cherry'], and transforming it into a NumPy array, where each element is a string from the sequence.

Method 1: Using `numpy.array()` Function

This method involves the use of the numpy.array() function to convert a list of strings into a NumPy array. The function is straightforward and serves as the primary means of creating array objects in NumPy. It is versatile and easily understandable for beginners.

Here’s an example:

import numpy as np

fruit_list = ['apple', 'banana', 'cherry']
fruit_array = np.array(fruit_list)

Output:

array(['apple', 'banana', 'cherry'], dtype='


This code snippet creates a list of fruit names and then converts it to a NumPy array of strings. When the np.array() function is called with a list of strings, it automatically deduces that the contents are of type string and assigns an appropriate data type (' in this case, meaning Unicode strings of a maximum length of 6).




Method 2: Specifying the Data Type


NumPy arrays can have their data type explicitly defined upon creation using the dtype keyword. The advantage here is the control over the type of string data, which may be essential for memory management with large arrays of strings.


Here’s an example:


import numpy as np

names = ['Alice', 'Bob', 'Charlie']
names_array = np.array(names, dtype='str')


Output:


array(['Alice', 'Bob', 'Charlie'], dtype='


In this example, the list of names is converted into a NumPy array with an explicitly declared data type of string (dtype='str'). This ensures that the array elements are stored as fixed-size strings.



Method 3: Using numpy.asarray()


The numpy.asarray() function converts an existing list or sequence to a NumPy array. If the input object is already an array, no copy is performed, making this method efficient for such cases.


Here’s an example:


import numpy as np

greetings = ['Hello', 'Hi', 'Hey']
greetings_array = np.asarray(greetings)


Output:


array(['Hello', 'Hi', 'Hey'], dtype='


This code uses the np.asarray() function to transform a regular Python list of greetings into a NumPy array of strings.



Method 4: Creating an Array of Fixed-length Strings


Creating an array of strings with a specified maximum length is often necessary to ensure that all strings consume equal amounts of memory. This is done via the numpy.chararray() function, which may help optimize memory usage in cases with large datasets.


Here’s an example:


import numpy as np

fixed_length_array = np.chararray(3, itemsize=10)
fixed_length_array[:] = 'text'


Output:


chararray([b'text', b'text', b'text'], dtype='|S10')


The code creates a NumPy chararray with a fixed string length of 10 bytes. Then it fills the entire array with the byte-string version of the text ‘text’. The advantage of this method is the efficiency in memory use when the lengths of strings are known in advance.



Bonus One-Liner Method 5: Using List Comprehension and numpy.array()


The elegance of Python’s  list comprehension  can be combined with numpy.array() to create a NumPy array of strings concisely. This is particularly useful when the strings in the array are derived from a transformation of another sequence.


Here’s an example:


import numpy as np

nums = [1, 2, 3]
str_array = np.array([f"Number {n}" for n in nums])


Output:


array(['Number 1', 'Number 2', 'Number 3'], dtype='


In this example, we generate a list of strings with a list comprehension, where each string is a formatted text that includes numbers from another list. This list is directly converted into a NumPy array.



Summary/Discussion



    
Method 1: Using numpy.array(). Strengths: Direct and easy to use. Weaknesses: Less control over data types.

    
Method 2: Specifying the Data Type. Strengths: Control over data type. Weaknesses: Requires knowledge of NumPy data types.

    
Method 3: Using numpy.asarray(). Strengths: No redundant copying if input is already an array. Weaknesses: Behavior is similar to numpy.array() when the input is not an array.

    
Method 4: Creating an Array of Fixed-length Strings. Strengths: Optimizes memory usage. Weaknesses: Not flexible if varying string lengths are required.

    
Method 5: Using List Comprehension and numpy.array(). Strengths: Concise and powerful for derived string arrays. Weaknesses: Can be less readable for complex transformations.


The post 5 Best Ways to Create a NumPy Array of Strings appeared first on Be on the Right Side of Change.



5 Best Ways to Create Numpy Arrays of Tuples in Python
Emily Rosemary Collins — Tue, 20 Feb 2024 13:20:25 +0000


  
  
   Problem Formulation: 
  
When working with large datasets in Python, it’s common to need to create Numpy arrays that hold tuples as their elements. This problem revolves around transforming a collection of tuples, representing multidimensional data points, into a structured Numpy array where each tuple becomes an array element. Suppose the input is a list of tuples like [(1, 2), (3, 4)], the desired output would be a Numpy array, potentially for further vectorized operations.

  
  
Method 1: Using numpy.array


This method involves the direct use of the numpy.array() function to transform a list of tuples into a Numpy array. The function delineates the structure of the resultant array, allowing for multidimensional array creation that can be tailored through data types and order parameters.

  
Here’s an example:

  
import numpy as np
  
tuples_list = [(1, 2), (3, 4), (5, 6)]
np_array_of_tuples = np.array(tuples_list)
print(np_array_of_tuples)

  
Output:

  
[[1 2]
 [3 4]
 [5 6]]

  
This code snippet first defines a list of tuples. It then uses the numpy.array() function to convert this list into a Numpy array, preserving the tuple structure as the elements of the array.

  
  
Method 2: Using numpy.asarray


The numpy.asarray() function is an alternative that converts an input sequence into an array. It’s similar to numpy.array(), but does not copy the object if it is already an ndarray with matching dtype and order. It is efficient when you’re dealing with sequences already in a numpy-like structure.

  
Here’s an example:

  
import numpy as np
  
tuples_list = [(7, 8), (9, 10), (11, 12)]
np_array_of_tuples = np.asarray(tuples_list)
print(np_array_of_tuples)

  
Output:

  
[[ 7  8]
 [ 9 10]
 [11 12]]

  
This example starts with a list of tuples and uses numpy.asarray() to create a numpy array. If the provided list of tuples were already an array, asarray() would not needlessly make a copy of the data.

  
  
Method 3: Using numpy.fromiter


The numpy.fromiter() function creates a new one-dimensional array from an iterable object, such as a generator expression or iterator. To create an array of tuples, the iterable should yield tuples. This method can be more memory-efficient than creating a list first.

  
Here’s an example:

  
import numpy as np
  
tuples_iterator = iter([(13, 14), (15, 16), (17, 18)])
np_array_of_tuples = np.fromiter(tuples_iterator, dtype='i,i')
print(np_array_of_tuples)

  
Output:

  
[(13, 14) (15, 16) (17, 18)]

  
Here, we create an iterator from a list of tuples and pass it to numpy.fromiter(), specifying the data type as a pair of integers (i,i). The output is a one-dimensional array of tuple elements, making it ideal for sequence conversions.

    
  
Method 4: Using numpy.zeros with a structured dtype


NumPy’s numpy.zeros() can create an array filled with zeros. By specifying a structured data type (dtype), you can form an array of zeros where each zero element is replaced with a tuple structure.

  
Here’s an example:

  
import numpy as np
  
tuple_shape = (3,)  # the desired shape of the array
dtype = [('x', 'int32'), ('y', 'int32')]  # specifying tuple structure as a list of pairs
np_array_of_tuples = np.zeros(tuple_shape, dtype=dtype)
print(np_array_of_tuples)

  
Output:

  
[(0, 0) (0, 0) (0, 0)]

  
In this code snippet, we use numpy.zeros() with a specified structured dtype to create a structured array. While the initial array is filled with zeros, it can be subsequently populated with the actual tuple data.


  
Bonus One-Liner Method 5: List Comprehension with numpy.array


A one-liner method involves using a  list comprehension  inside the numpy.array() function call. This method is great for cases where the tuples need to be generated or transformed before creating the array.

  
Here’s an example:

  
import numpy as np
  
np_array_of_tuples = np.array([(x, x+1) for x in range(3)])
print(np_array_of_tuples)

  
Output:

  
[[0 1]
 [1 2]
 [2 3]]

  
This one-liner uses list comprehension to create tuples on the fly and immediately converts them into a Numpy array using numpy.array().

  
  
Summary/Discussion

  

    
Method 1: numpy.array. Straightforward. Ideal for lists. Can be memory intensive.

    
Method 2: numpy.asarray. Efficient for existing sequences. Less intuitive for tuple creation.

    
Method 3: numpy.fromiter. Memory-efficient for large sequences. Limited to one-dimensional arrays.

    
Method 4: numpy.zeros with structured dtype. Allows preset array structure. Initial values will be zeros.

    
Method 5: List Comprehension with numpy.array. Compact and convenient for on-the-fly transformations. Less readable with complex transformations.

  

The post 5 Best Ways to Create Numpy Arrays of Tuples in Python appeared first on Be on the Right Side of Change.

Data Science Archives - Be on the Right Side of Change

The JSON Trick – How to Scrape All Answers in a Subreddit? (Example Find User Needs)

42 Free University Books (PDF/HTML)

OpenStax textbooks (free PDF & web view, no registration)

Leverage Plays — Growing $10k to $472k using 50% Margin Loans to Buy a 30% CAGR Asset

Problem Formulation

Analysis

Python Script

NumPy @ Operator vs np.dot()

What are the @ Operator and dot Function?

When to Use Each?

Example

Performance Differences

Syntax and Readability

Compatibility Considerations

Best Practices

How to Fit a Curve to Power-law Distributed Data in Python

Prerequisites

Step 1: Generate Power-law Distributed Data

Step 2: Plot the Cumulative Distribution Function (CDF)

Step 3: Fit a Power-law Curve to the CDF

Step 4: Plot the Fitted Curve with the CDF

Visualizing Wealth: Plotting the Net Worth of the World’s Richest in Log/Log Space

Understanding the Data

Why Log/Log Space?

Preparing for the Plot

The Python Script

Plotting the Data

Interpreting the Plot

Follow Up Analysis

5 Best Ways to Create NumPy Arrays of Random Numbers in Python

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Method 3: Using numpy.random.randint()

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Method 2: Using numpy.random.randn()

Method 3: Using numpy.random.randint()

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Method 2: Using numpy.random.randn()

Method 3: Using numpy.random.randint()

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Method 2: Using numpy.random.randn()

Method 3: Using numpy.random.randint()

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Method 3: Using numpy.random.randint()

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Method 2: Using numpy.random.randn()

Method 3: Using numpy.random.randint()

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Method 3: Using numpy.random.randint()

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Method 2: Using numpy.random.randn()

Method 3: Using numpy.random.randint()

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

Summary/Discussion

Method 4: Using numpy.random.choice()

Bonus One-Liner Method 5: Using numpy.random.permutation()

What are the `@` Operator and `dot` Function?

Method 1: Using `numpy.array()` Function

Method 3: Using `numpy.asarray()`

Bonus One-Liner Method 5: Using List Comprehension and `numpy.array()`