Forem: Liz_decoder

NumPy: Understanding NumPy python library

Liz_decoder — Mon, 24 Mar 2025 15:44:40 +0000

NUMPY

NumPy is the core library for scientific computing in Python.

Foundational Python libraries such as pandas, SciPy, and Matplotlib are built on top of NumPy's API. So are machine learning libraries such as TensorFlow and scikit-learn, which use NumPy arrays as inputs.

NumPy arrays

The array is the main object in NumPy; it's a grid-like structure that holds data. An array can have any number of dimensions, and each dimension can be any length.

Creating 1D arrays from lists

We can create arrays from Python lists by passing a list as an argument to the np.array function.
The data type of this array is a NumPy nd.array, or n-dimensional array.

python_list =[3,2,5,9,7,1,4,3,6]
array = np.array(python_list)

array

array([3,2,5,9,7,1,4,3,6)

Creating 2D arrays from lists

To create a 2-dimensional array, pass np.array a list of lists. A list of lists of lists would generate a 3-dimensional array.

python_list_of_lists = ([[3,2,5],
                        [9,7,1],
                        [4,3,6]])

Arrays vs. Python lists

*Python lists can include many different data types:

python_list = ['beep', False, 56, .924, [3,2,5]]

NumPy array must be the same data type.
This makes NumPy very efficient: there's no need for NumPy to check the data type of each element in an array since they must all be the same.
Having only a single data type also means that a NumPy array takes up less space in memory than the same information would if stored as a Python list.

numpy_boolean_array = [[True, False], [True, True], [False, True]]
numpy_float_array = [1.9, 2.4, 3.1, 6.4]

Creating arrays from scratch

There are many Numpy functions used to create arrays. Using functions such as
- np.zeros()
- np.random.random()
- np.arange()

Creating arrays: np.zeros()

np.zeros() creates an array full of zeros. We can use the zeros array just as we might use an empty Python list, filling it with data later on. We tell np.zeros() the shape of the desired array using a tuple of integers, each representing the length of a given dimension.
A tuple is a Python data type used to store collections of data, similar to a list. Tuples are created with parentheses()
Here, when np.zeros() is given a tuple of five and three, it creates an array with five rows and three columns.

np.zeros((5,3))

array([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.].
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])

Creating arrays: np.random.random()

np.random.random() also accepts a tuple with the desired array's shape. The array will be made up of random floats between 0 - 1

 np.random.random((2,4))

 array([[0.8852461, 0.08564132, 0.33463107, 0.53337117],
        [0.69933362, 0.09295327, 0.93617865, 0.04532187]])

np.random.random() is called that, because np.random.random() is a function within NumPy's random module, which contains useful functions for random sampling.

np.random. {NumPy module}

random() {function name}

Creating arrays: np.arange()

np.arange() creates an evenly-spaced array of numbers based on given start and stop values. By default, np.arange() creates an array of sequential integers. The start value is included in the output array, but the stop value is not. The start value can be omitted if the range begins with zero. If a third argument is passed, it is interpreted as the step value. Now, the desired distance between elements is three. *np.arange() is particularly useful for plotting!

np.arange(-3,4)
array([-3, -2, -2, 0, 1, 2, 3])

np.arange(4)
array([0, 1, 2, 3])

np.arange(-3, 4, 3)
array([-3, 0, 3])

Understanding Tuple Unpacking and Iteration in Python: A Beginner's Guide

Liz_decoder — Fri, 17 Jan 2025 11:34:53 +0000

Ever tried carrying multiple items at once? That's exactly what Python tuples do! The concept of tuple unpacking in Python and how it relates to swapping elements in a list is important as it allows you to assign multiple variables from a tuple.

What's a Tuple?

Think of a tuple as a sturdy(unchangeable) container that keeps your items safe. Once you put something in, it stays exactly where you put it – no shuffling around allowed!
Technically, A tuple in Python is a collection data type just like a list in Python, that is immutable, meaning once it is created its contents cannot be changed.
Tuples are defined using parentheses (), and they can hold multiple items.
For example:

my_tuple = (1, 2, 3)

Magic of Tuple Unpacking

Tuple unpacking is like having a smart unboxing system, where you can unpack everything at once. Technically, it's a feature that lets you assign multiple values to multiple variables in a single line. For example:

a, b = (1, 2)

a will be 1 and b will be 2.

Swapping elements with tuple unpacking
Tuple unpacking is commonly used for swapping values. You can swap values without needing a temporary variable. Here's how it works:
You have a list
a = [65, 90, 80, 100]

If you want to swap the elements at index 1 and index 3,

a[1], a[3] = a[3], a[1]

The right side a[3], a[1] creates a tuple (100, 90) from the values at index 3 and 1.
The left side a[1], a[3] unpacks that tuple, assigning 100 to a[1] and 90 to a[3].
This operation effectively swaps the values in one line.

Why Can't We Modify Tuples?

Remember, tuples are like locked boxes. Once you create a tuple, you can't change what's inside.

Technically, Tuples are immutable, you cannot change their contents

For example:

scores = (95, 87, 92)
scores[0] = 95 # TypeError! Can't modify a tuple

This happens because tuples do not allow modification of individual elements. If you need to change values, you would need to create a new tuple.

Iterating over Tuples

Even though tuples are immutable that doesn't mean we can't look at everything inside! Iteration allows you to access and process each element in the tuple, one at a time. We can easily walk through each item: For example:

# Student's grades
grades = ('A', 'B+', 'A-')
for grade in grades:
    print(f"Got a {grade}!")

if grade A takes the first value from the tuple # prints: Got a A!
if grade B takes the second value # prints: Got a B+!
if grade A- takes the third value # prints: Got a A-!

Pro Tips

Use tuples when you want to store data safe from changes
Remember that tuple unpacking allows you to assign multiple variables from a tuple or sequence in one line and is your friend for multiple assignments.
When swapping values, tuple unpacking is cleaner than using temporary variables.
Iteration: You can iterate over tuples to access each value, but again, the tuple itself remains the same.
- If you need to modify values often, consider using a list.