Python Programming: General-Purpose Libraries; NumPy,Pandas,Matplotlib,Seaborn,Requests,os & sys: Python, #2

​Preface

●  Python has solidified its place as one of the most versatile and widely used programming languages in the world. From data science to web development, from automation to artificial intelligence, Python's rich ecosystem of libraries enables developers, researchers, and engineers to bring their ideas to life with efficiency and precision.

●  This book explores the most commonly used Python libraries across various domains, offering insights into their functionality, applications, and best practices. Whether you are a beginner taking your first steps in Python or an experienced programmer looking to expand your toolkit, this book serves as a guide to understanding and utilizing the power of Python’s libraries effectively.

●  We begin with general-purpose libraries like NumPy, Pandas, and Matplotlib—indispensable tools for data manipulation and visualization. As we progress, we delve into specialized libraries tailored for machine learning, web development, automation, and more. Through real-world examples and practical applications, we aim to provide a hands-on approach to mastering these libraries.

●  Our goal is not just to introduce these tools but to equip readers with the knowledge and confidence to integrate them seamlessly into their projects. By the end of this book, you will have a solid foundation in Python’s extensive library ecosystem, empowering you to tackle a wide range of programming challenges with ease.

●  Happy coding!

●  ​e3

​General-Purpose Libraries

The most used Python libraries vary depending on the domain, but here are some of the most widely used ones across different fields:

​General-Purpose Libraries

NumPy – Numerical computing and array manipulation

Pandas – Data manipulation and analysis

Matplotlib – Data visualization

Seaborn – Statistical data visualization (built on Matplotlib)

Requests – HTTP requests handling

os & sys – Operating system and system-specific functions

​NumPy

Mathematics is the foundation of scientific computing, data analysis, and engineering. In the digital age, performing complex mathematical operations efficiently is crucial for researchers, analysts, and engineers. NumPy, a powerful numerical computing library in Python, provides a robust set of mathematical tools that streamline calculations, enhance performance, and simplify data processing. This book delves into NumPy’s advanced mathematical capabilities, focusing on essential concepts such as the Least Common Multiple (LCM), Greatest Common Divisor (GCD), trigonometric and hyperbolic functions, and set operations.

Understanding LCM and GCD is fundamental in number theory, algebra, and computational mathematics. NumPy provides efficient methods for calculating these values, whether for individual numbers or entire datasets. The ability to compute these values across arrays with minimal computational overhead makes NumPy a powerful tool for solving real-world problems.

Trigonometric and hyperbolic functions are indispensable in fields like physics, engineering, and computer graphics. NumPy offers built-in functions to compute sine, cosine, tangent, and their respective inverse values, allowing users to manipulate and analyze angles with ease. The ability to convert between radians and degrees further enhances usability, ensuring compatibility across different mathematical conventions.

Set operations, such as unions, intersections, and differences, are critical in data processing, statistical analysis, and machine learning. NumPy provides efficient methods for handling unique values, merging datasets, and performing complex set computations. These operations allow users to work seamlessly with large datasets while maintaining computational efficiency.

This book is designed for anyone seeking to deepen their understanding of NumPy’s mathematical capabilities. Whether you are a student, researcher, or professional, the concepts and examples presented here will equip you with the knowledge needed to leverage NumPy for advanced numerical computations. By mastering these functions, you will be able to perform complex mathematical operations with ease and efficiency, making NumPy an indispensable tool in your computational toolkit.

​Introduction to NumPy: A Comprehensive Guide to Python’s Numerical Computing Library

​What is NumPy?

NumPy, short for Numerical Python, is a powerful library in Python designed for working with arrays. It provides functionalities for linear algebra, Fourier transforms, and matrices, making it an essential tool for data science and scientific computing. Developed in 2005 by Travis Oliphant, NumPy is an open-source project available for free use.

​Why Use NumPy?

While Python has built -in lists, they can be slow and inefficient for large-scale numerical computations. NumPy arrays, called ndarrays, are optimized for performance and can be up to 50 times faster than traditional lists. The core of NumPy is written in C and C++, allowing for high-speed computations.

​Installing NumPy

NumPy installation is straightforward with pip if Python and PIP are already installed:

python

​at the command prompt

​C:\Users>

pip install numpy

Alternatively, distributions like Anaconda and Spyder come with NumPy pre-installed.

​Importing NumPy

To use NumPy in a project , import it as follows:

python

import numpy 

A common convention is to use np as an alias:

python

import numpy as np 

You can check the installed NumPy version with:

python

print(np.__version__) 

​Creating NumPy Arrays

NumPy’s core data structure is the ndarray. It can be created using the array() function:

python

arr = np.array([1, 2, 3, 4, 5]) 

print(arr) 

print(type(arr))  # Output:

You can also create arrays from tuples:

python

arr = np.array((1, 2, 3, 4, 5)) 

print(arr) 

​Array Dimensions

NumPy arrays can have multiple dimensions, from simple scalars (0-D) to multi-dimensional tensors:

●  0-D Arrays (Scalars):

python

arr = np.array(42) 

print(arr) 

●  1-D Arrays:

python

arr = np.array([1, 2, 3, 4, 5]) 

print(arr) 

●  2-D Arrays (Matrices):

python

arr = np.array([[1, 2, 3], [4, 5, 6]]) 

print(arr) 

●  3-D Arrays (Tensors):

python

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]]) 

print(arr) 

●  Higher-Dimensional Arrays:

NumPy allows defining arrays with any number of dimensions using ndmin:

python

arr = np.array([1, 2, 3, 4], ndmin=5) 

print(arr) 

print(Number of dimensions:, arr.ndim)  # Output: 5

To check an array’s dimensions, use the .ndim attribute:

python

print(arr.ndim)  # Returns the number of dimensions

​Indexing in NumPy Arrays

Indexing allows access to specific elements in a NumPy array.

​Basic Indexing

NumPy follows zero -based indexing:

python

arr = np.array([1, 2, 3, 4]) 

print(arr[0])  # Output: 1

print(arr[1])  # Output: 2

​Indexing in Multi-Dimensional Arrays

●  2-D Arrays: Access elements using row and column indices:

python

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

print(arr[0, 1])  # Output: 2

●  3-D Arrays: Use three indices (depth, row, column):

python

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) 

print(arr[0, 1, 2])  # Output: 6

●  Negative Indexing: Allows access from the end:

python

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

print(arr[1, -1])  # Output: 10 (last element of the second row)

​Conclusion

NumPy is a fundamental tool in Python for numerical computing. It provides fast, efficient array operations, multi-dimensional support, and indexing capabilities that make handling large datasets seamless. With its extensive functionality, NumPy is widely used in data science, machine learning, and scientific research.

​NumPy: A Comprehensive Guide to Array Manipulation and Data Types

​Slicing Arrays in NumPy

NumPy provides powerful tools for slicing arrays, allowing users to extract specific sections of an array based on indices. This process is similar to slicing lists in standard Python but with additional flexibility and efficiency.

​Slicing One-Dimensional Arrays

Slicing an array involves specifying a range of indices using the syntax:

python

[start:end]

This extracts elements starting from start index up to, but not including, the end index.

Example:

python

import numpy as np

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

print(arr[1:5])  # Output: [2 3 4 5]

●  If the start index is omitted, the slice begins from the first element.

●  If the end index is omitted, the slice extends to the last element.

Example:

python

print(arr[:4])  # Output: [1 2 3 4]

print(arr[4:])  # Output: [5 6 7]

​Slicing with Negative Indices

Negative indices count from the end of the array.

python

print(arr[-3:-1])  # Output: [5 6]

​Using Step in Slicing

The step parameter allows skipping elements at a defined interval:

python

[start:end:step]

Example:

python

print(arr[1:5:2])  # Output: [2 4]

print(arr[::2])  # Output: [1 3 5 7]

​Slicing Multi-Dimensional Arrays

For 2D arrays, slicing works along multiple axes.

Example:

python

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

print(arr[1, 1:4])  # Output: [7 8 9]  (Row 2, Columns 2 to 4)

print(arr[0:2, 2])  # Output: [3 8]  (Column 3 of all rows)

​Understanding Data Types in NumPy

NumPy provides a wide range of data types, allowing efficient memory usage and computations. The data type of an array can be explicitly defined when creating an array or converted afterward.

​Built-in Data Types in NumPy

Each NumPy data type has a shorthand notation:

​Checking the Data Type of an Array

Each NumPy array has an attribute dtype that returns its data type.

Example:

python

arr = np.array([1, 2, 3, 4])

print(arr.dtype)  # Output: int64

For a string array:

python

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

print(arr.dtype)  # Output:

​Creating Arrays with a Specific Data Type

NumPy allows specifying the data type explicitly when creating an array:

Example (creating an array with string data type):

python

arr = np.array([1, 2, 3, 4], dtype='S')

print(arr)  # Output: [b'1' b'2' b'3' b'4']

print(arr.dtype)  # Output: |S1 (Byte string)

For integer arrays with a specific byte size:

python

arr = np.array([1, 2, 3, 4], dtype='i4')

print(arr.dtype)  # Output: int32

​Handling Type Conversion Errors

If a specified data type is incompatible with array elements, NumPy raises a ValueError.

Example:

python

arr = np.array(['a', '2', '3'], dtype='i')  # Raises ValueError

​Changing Data Type of an Existing Array

To change the data type of an existing array, use the astype() function, which returns a copy of the array with the new type.

Example: Converting float to integer

python

arr = np.array([1.1, 2.1, 3.1])

newarr = arr.astype('i')

print(newarr)  # Output: [1 2 3]

print(newarr.dtype)  # Output: int32

Alternatively:

python

newarr = arr.astype(int)

print(newarr)  # Output: [1 2 3]

Example: Converting integers to boolean

python

arr = np.array([1, 0, 3])

newarr = arr.astype(bool)

print(newarr)  # Output: [ True False True]

print(newarr.dtype)  # Output: bool

​Conclusion

This chapter covered fundamental operations with NumPy arrays, including slicing techniques and data type manipulations. Mastering these techniques allows for efficient data handling and manipulation in Python, making NumPy an essential tool for scientific computing and data analysis.

​Advanced NumPy Techniques: Copying, Viewing, Reshaping, and Flattening Arrays

NumPy provides a powerful array manipulation toolkit that allows users to copy arrays, create views, reshape data, and flatten multi-dimensional structures. Understanding the differences between copies and views, as well as how to reshape arrays, is crucial for efficient data processing.

​Copying vs. Viewing in NumPy

One of the fundamental aspects of working with NumPy arrays is understanding how data is stored and manipulated. The key difference between copying and viewing arrays is whether the new array retains ownership of the data or simply references the original.

​Copying Arrays

Acopy creates a completely independent new array. Any modifications made to the copy do not affect the original array and vice versa.

​Example: Copying an Array

python

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

x = arr.copy()  # Create a copy

arr[0] = 42

print(arr)  # [42  2  3  4  5]

print(x)  # [1  2  3  4  5]

Since x is a separate copy, changing arr[0] to 42 does not affect x.

​Viewing Arrays

Aview is a reference to the original data. Changes in the view affect the original array, and vice versa.

​Example: Viewing an Array

python

arr = np.array([1, 2, 3, 4, 5])

x = arr.view()  # Create a view

arr[0] = 42

print(arr)  # [42  2  3  4  5]

print(x)  # [42  2  3  4  5]

Since x is a view of arr, modifying arr also affects x.

​Checking Ownership of Data

To check whether an array owns its data or references another, use the .base attribute.

​Example: Checking Data Ownership

python

arr = np.array([1, 2, 3, 4, 5])

x = arr.copy()

y = arr.view()

print(x.base)  # None (x is a copy)

print(y.base)  # [1  2  3  4  5] (y is a view)

If .base returns None, the array owns its data (copy). If .base returns another array, the array is a view.

​Understanding Array Shape

The shape of a NumPy array refers to the number of elements in each dimension. The .shape attribute provides this information as a tuple.

​Getting the Shape of an Array

python

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

print(arr.shape)  # (2, 4)

This means the array has 2 rows and 4 columns.

​Reshaping NumPy Arrays

Reshaping means changing the dimensions of an array while preserving the data. This is useful when transitioning between 1D, 2D, and 3D structures.

​Reshaping from 1D to 2D

python

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

newarr = arr.reshape(4, 3)

print(newarr)

Output:

lua

[[ 1  2  3]

[ 4  5  6]

[ 7  8  9]

[10 11 12]]

Here, a 1D array with 12 elements is reshaped into a 2D array with 4 rows and 3 columns.

​Reshaping from 1D to 3D

python

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

newarr = arr.reshape(2, 3, 2)

print(newarr)

Output:

lua

[[[ 1  2]

[ 3  4]

[ 5  6]]

[[ 7  8]

[ 9 10]

[11 12]]]

The 1D array is now reshaped into a 3D array with 2 outer arrays, each containing 3 arrays of 2 elements.

​Reshaping Constraints

Reshaping works only if the number of elements remains the same . For example, an 8-element array cannot be reshaped into a (3,3) shape because 3×3=9 elements are required.

python

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

newarr = arr.reshape(3, 3)  # This will cause an error!

Error:

sql

ValueError: cannot reshape array of size 8 into shape (3,3)

​Checking if Reshape Creates a Copy or View

python

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

print(arr.reshape(2, 4).base)  # [1 2 3 4 5 6 7 8]

Since .base returns the original array, reshape created a view (not a copy).

​Using Unknown Dimensions (-1)

Instead of manually specifying one dimension, NumPy can infer the correct size by using -1.

​Example: Using -1 to Automatically Determine Dimensions

python

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

newarr = arr.reshape(2, 2, -1)

print(newarr)

Output:

lua

[[[1 2]

[3 4]]

[[5 6]

[7 8]]]

NumPy automatically calculates the missing dimension (2×2×2 = 8).

Note: You can only use one -1 per reshape operation.

​Flattening NumPy Arrays

Flattening converts multi-dimensional arrays into 1D arrays . This is useful for machine learning and data processing.

python

arr = np.array([[1, 2, 3], [4, 5, 6]])

newarr = arr.reshape(-1)

print(newarr)  # [1 2 3 4 5 6]

​Conclusion

NumPy provides powerful tools for managing and transforming arrays efficiently. Key takeaways include:

●  Copy vs. View: Copies are independent, while views reference original data.

●  Shape & Reshape: Understanding dimensions is crucial for reshaping arrays correctly.

●  Unknown Dimensions (-1): NumPy can auto-calculate missing dimensions.

●  Flattening: Reshapes multi-dimensional arrays into 1D for easier processing.

By mastering these concepts, you can efficiently manipulate and optimize data in NumPy. 🚀

​Iterating Over NumPy Arrays: A Comprehensive Guide

​Introduction to Iteration in NumPy

Iteration refers to the process of traversing through each element of an array one by one. In Python, iteration can be done using basic for loops. When dealing with NumPy arrays, iteration can be applied to one-dimensional (1D), two-dimensional (2D), and even multi-dimensional arrays.

In NumPy, iterating over a 1D array is straightforward, as each