NumPy is a fundamental library in Python for numerical computing. It is designed to efficiently handle large datasets and perform various mathematical operations. One of the primary reasons for its popularity is the numpy.ndarray data structure, known as a NumPy array. Unlike Python’s built-in lists, NumPy arrays offer several advantages that make them indispensable in data analysis, scientific computing, and machine learning.<\/p>\n
Memory Efficiency:<\/strong> NumPy arrays are more memory efficient compared to Python lists. This efficiency arises due to the homogeneous nature of NumPy arrays, meaning all elements are of the same data type, while lists can hold a mix of different data types.<\/p>\n Performance:<\/strong> NumPy arrays provide superior performance in terms of computation speed. They are implemented in C and Fortran, which allows them to take advantage of low-level optimizations, making operations significantly faster compared to Python lists.<\/p>\n Multidimensional Support:<\/strong> NumPy arrays are designed to handle multi-dimensional data efficiently. They can represent matrices and tensors of any size, which is crucial for scientific computing tasks.<\/p>\n Broadcasting:<\/strong> As mentioned earlier, NumPy arrays support broadcasting, allowing mathematical operations between arrays of different shapes and making complex computations concise and efficient.<\/p>\n Functionality:<\/strong> NumPy provides a vast collection of mathematical functions (ufuncs) and methods tailored for array operations. This extensive functionality simplifies complex numerical operations and data manipulation tasks.<\/p>\n The numpy.array() function is used to create a NumPy array from a given object, such as a list or tuple. This function allows you to explicitly specify the data type of the elements in the array, along with other optional parameters for customization.<\/p>\n object:<\/strong> It signifies the input information used to generate the array. It can be an array itself, any object that exposes the array interface, an object that produces an array through its array method, or any nested sequence. If the object is a single value, a 0-dimensional array containing that value will be produced.<\/p>\n dtype:<\/strong> It specifies the desired data type for the array. If it is not given, NumPy will try to use a default dtype that can represent the values by applying promotion rules when required. Moreover, the data type will be inferred based on the input data.<\/p>\n Copy:<\/strong> It controls whether the object is copied or not. If True (default), a copy is made. Otherwise, a copy will only be made if __array__ returns a copy, if the object is a nested sequence, or if a copy is needed to satisfy other requirements like dtype or order.<\/p>\n Order:<\/strong> The order parameter allows you to indicate how the array’s memory arrangement should be. If the input isn’t already an array, the freshly generated array will adopt the C order (row-major) by default, unless ‘F’ is indicated, in which case it will adhere to the Fortran order (column-major). When the input is an array, the guidelines for maintaining the order are detailed in the earlier provided table.<\/p>\n subok:<\/strong> When the subok parameter is set to True, sub-classes will be passed through. If it is set to False (default), the returned array will be forced to be a base-class array. This parameter is good for maintaining the characteristics of subclasses.<\/p>\n ndmin:<\/strong> This parameter specifies the minimum number of dimensions that the resulting array should have. Ones will be prepended to the shape according to the requirement. It is useful when you want to ensure a minimum shape for your array.<\/p>\n Like:<\/strong> The like parameter was introduced in NumPy version 1.20.0, it allows referencing of an object to create arrays that are not NumPy arrays. If the array-like object passed as like supports the __array_function__ protocol, the result will be defined by it. This parameter ensures the creation of an array compatible with the object passed via this argument.<\/p>\n Now that we understand the key differences, let’s dive into how to work with NumPy arrays in Python!<\/p>\n To start using NumPy in your Python program, you need to begin importing it.<\/p>\n Let’s create a basic 1-dimensional array:<\/strong><\/p>\n Output:<\/strong><\/p>\n [1 2 3 4 5]<\/p>\n Arrays are essential data structures in programming, especially for data manipulation and numerical computations. There are two primary types of arrays: one-dimensional arrays and multi-dimensional arrays.<\/p>\n One-Dimensional Array:<\/strong><\/p>\n A one-dimensional array, often referred to as a 1D array or vector, is a linear sequence of elements. It’s like a list of values, where each value is assigned an index. One-dimensional arrays are commonly used to store data in a single row or column, making them suitable for tasks like representing time series, sensor readings, or sequences of values.<\/p>\n Example:<\/strong><\/p>\n Output:<\/strong> 3<\/p>\n Multi-Dimensional<\/strong> Array:<\/strong><\/p>\n A multi-dimensional array extends the concept of a 1D array into two or more dimensions. The most common form is a 2D array, which can be thought of as a table or matrix. Multi-dimensional arrays are used to represent structured data, such as images, tables of numerical data, or grids of values.<\/p>\n Example:<\/strong><\/p>\n Output:<\/strong> 6<\/p>\n NumPy arrays can have multiple dimensions. For example, a 2-dimensional array is like a matrix with rows and columns:<\/p>\n Output:<\/strong> NumPy arrays have several attributes that provide useful information about the array:<\/p>\n Output:<\/strong><\/p>\n Shape: (5,) You can access individual elements or slices of a NumPy array using indexing and slicing:<\/p>\n Output:<\/strong><\/p>\n First element: 1 NumPy arrays support element-wise mathematical operations:<\/p>\n Output:<\/strong> NumPy arrays support broadcasting for element-wise operations between arrays with different shapes:<\/p>\n Output:<\/strong><\/p>\n Scalar Multiplication: [2 4 6]<\/p>\n NumPy provides universal functions (ufunc) for common mathematical operations:<\/p>\n Output:<\/strong><\/p>\n Sine: [0.0000000e+00 1.0000000e+00 1.2246468e-16]<\/p>\n NumPy arrays are a fundamental tool for numerical computing in Python. Their memory efficiency, performance, and extensive functionality make them a top choice for handling large datasets and complex mathematical operations. As you progress in your Python journey, mastering NumPy will be invaluable in various data science and scientific computing projects. Happy coding with DataFlair and NumPy!<\/p>\n","protected":false},"excerpt":{"rendered":" NumPy is a fundamental library in Python for numerical computing. It is designed to efficiently handle large datasets and perform various mathematical operations. One of the primary reasons for its popularity is the numpy.ndarray...<\/p>\n","protected":false},"author":1,"featured_media":89262,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[385],"tags":[5198,412,2242,5199],"class_list":["post-88419","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-numpy-tutorials","tag-array-in-numpy","tag-numpy-array","tag-python","tag-python-numpy-array"],"yoast_head":"\nUnderstanding numpy.array()<\/h4>\n
Syntax<\/h4>\n
numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0, like=None)\n<\/pre>\n
Working with NumPy Arrays<\/h3>\n
1. Importing NumPy<\/h4>\n
import numpy as np<\/pre>\n
2. Creating NumPy Arrays<\/h4>\n
import numpy as np\n\n# Create a 1-dimensional NumPy array\ndataflair_array = np.array([1, 2, 3, 4, 5])\nprint(dataflair_array)\n<\/pre>\n
3. One and Multidimensional Arrays<\/h4>\n
import numpy as np\n\none_dim_array = np.array([1, 2, 3, 4, 5])\nprint(one_dim_array[2]) \n<\/pre>\n
import numpy as np\n\ntwo_dim_array = np.array([[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]])\nprint(two_dim_array[1, 2]) \n<\/pre>\n
import numpy as np\n\n# Create a 2-dimensional NumPy array\ndataflair_matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\nprint(dataflair_matrix)\n<\/pre>\n
\n[[1 2 3]
\n[4 5 6]
\n[7 8 9]]<\/p>\n4. Array Attributes<\/h4>\n
import numpy as np\n\ndataflair_array = np.array([1, 2, 3, 4, 5])\n\nprint(\"Shape:\", dataflair_array.shape) # Shape of the array\nprint(\"Dimensions:\", dataflair_array.ndim) # Number of dimensions\nprint(\"Size:\", dataflair_array.size) # Total number of elements\nprint(\"Data type:\", dataflair_array.dtype) # Data type of the elements\n\n<\/pre>\n
\nDimensions: 1
\nSize: 5
\nData type: int64<\/p>\n5. Array Indexing and Slicing<\/h4>\n
import numpy as np\n\ndataflair_array = np.array([1, 2, 3, 4, 5])\n\nprint(\"First element:\", dataflair_array[0]) # Access the first element\nprint(\"Last element:\", dataflair_array[-1]) # Access the last element\nprint(\"Slicing:\", dataflair_array[1:4]) # Slice elements from index 1 to 3 (exclusive)\nprint(\"Reverse:\", dataflair_array[::-1]) # Reverse the array\n\n<\/pre>\n
\nLast element: 5
\nSlicing: [2 3 4]
\nReverse: [5 4 3 2 1]<\/p>\n6. Mathematical Operations<\/h4>\n
import numpy as np\n\ndataflair_array1 = np.array([1, 2, 3])\ndataflair_array2 = np.array([4, 5, 6])\n\n# Element-wise addition\nresult = dataflair_array1 + dataflair_array2\nprint(\"Addition:\", result)\n\n# Element-wise multiplication\nresult = dataflair_array1 * dataflair_array2\nprint(\"Multiplication:\", result)\n<\/pre>\n
\nAddition: [5 7 9]
\nMultiplication: [ 4 10 18]<\/p>\n7. Broadcasting<\/h4>\n
import numpy as np\n\ndataflair_array = np.array([1, 2, 3])\n\n# Scalar multiplication (Broadcasting)\nresult = dataflair_array * 2\nprint(\"Scalar Multiplication:\", result)\n<\/pre>\n
8. Universal Functions (ufunc)<\/h4>\n
import numpy as np\n\ndataflair_array = np.array([0, np.pi \/ 2, np.pi])\n\n# Calculate sine of each element\nresult = np.sin(dataflair_array)\nprint(\"Sine:\", result)\n<\/pre>\n
Conclusion<\/h3>\n