Arithmetic operations are fundamental, playing an important role in science and computer applications. In data manipulation and numerical computation, NumPy (Numerical Python) stands out as a powerful library that provides a wide range of mathematical functions for efficient data manipulation.<\/p>\n
In this beginner-friendly course, we will explore the important arithmetic functions of NumPy and their use to perform element-wise operations on arrays. Let’s learn how to do it!<\/p>\n
NumPy is a popular library in the Python ecosystem, known for its ability to perform numerical calculations. When it comes to arithmetic operations on arrays, it offers several advantages:<\/strong><\/p>\n Performance:<\/strong> NumPy programs are optimized for speed, making them significantly faster than traditional Python programs.<\/p>\n Flexibility:<\/strong> NumPy simplifies complex numerical operations by providing a unified interface that allows you to manage arrays.<\/p>\n Propagation:<\/strong> NumPy allows you to perform operations on arrays of different sizes, thanks to its propagation feature that changes the dimensions automatically.<\/p>\n Versatility:<\/strong> NumPy supports a wide range of mathematical functions and applications, making it suitable for a variety of scientific and technical applications.<\/p>\n Now, let’s dive into some of the most commonly used arithmetic operations in NumPy.<\/p>\n Here is a list of commonly used arithmetic operations in NumPy, along with their associated operators and built-in functions:<\/strong><\/p>\n To perform each operation, you can choose either the associated operator or the corresponding built-in function. For example, to perform addition, you can use either the + operator or the add() function.<\/p>\n Element-wise addition allows you to add corresponding elements of two NumPy arrays.<\/p>\n Let’s see how to do this using both the + operator and the add() function:<\/strong><\/p>\n In this example, we create two arrays, first_array and second_array, and then perform element-wise addition using both the + operator and the add() function. As you can see, both methods produce the same result.<\/p>\n Output:<\/strong><\/p>\n Using the + operator:<\/strong> [ 3 7 11 15] Both + and add() deliver the same outcome, giving you the flexibility to choose the method that suits your coding style.<\/p>\n Similar to addition, subtraction in NumPy can be accomplished using either the – operator or the subtract() function:<\/strong><\/p>\n This code snippet demonstrates subtraction between two NumPy arrays, first_array and second_array, using both the – operator and the subtract() function.<\/p>\n Output:<\/strong><\/p>\n Using the – operator:<\/strong> [ 1 5 19 65] Again, you can choose either method based on your preference.<\/p>\n Element-wise multiplication involves multiplying the corresponding elements of two NumPy arrays.<\/p>\n You can achieve this using the * operator or the multiply() function:<\/strong><\/p>\n In this example, we demonstrate two ways to multiply the two arrays element-wise, utilizing the * operator and the multiply() function.<\/p>\n Output:<\/strong> Both approaches provide the same result, allowing you to choose the one that fits your coding style.<\/p>\n Element-wise division entails dividing the corresponding elements of two NumPy arrays.<\/p>\n You can perform this operation using either the \/ operator or the divide() function:<\/strong><\/p>\n This code snippet demonstrates element-wise division between two NumPy arrays, first_array and second_array, using both the \/ operator and the divide() function.<\/p>\n Output:<\/strong> As shown, both the \/ operator and the divide() function yield the same result.<\/p>\n Element-wise exponentiation involves raising each element of an array to a given power. NumPy offers two options for performing this operation: the ** operator and the power() function.<\/p>\n In this example, we use the ** operator and the power() function to perform the element-wise exponentiation operation on the array1 array, raising each element to the power of 2.<\/p>\n Output:<\/strong> Both the ** operator and the power() function achieve the same result by raising each element of array1 to the power of 2.<\/p>\n The modulus operation in NumPy arrays calculates the remainder of element-wise division between two arrays.<\/p>\n You can perform this operation using either the % operator or the mod() function:<\/strong><\/p>\n This code demonstrates element-wise modulus operations using both the % operator and the mod() function with the first_array and second_array.<\/p>\n Output:<\/strong> As illustrated, both the % operator and the mod() function yield the same result, making it convenient for you to choose the method that suits your coding style.<\/p>\n Arithmetic Operations Table:<\/strong><\/p>\n NumPy’s array arithmetic operations are essential for working with large amounts of numerical data efficiently in Python. This tutorial covers some of the most common arithmetic operations in NumPy, including addition, subtraction, multiplication, division, exponentiation, and modulus.<\/p>\n We show how to perform these operations using both operators and built-in functions, giving you flexibility and versatility in your data manipulation tasks. By mastering these operations, you’ll be well-prepared to tackle a wide range of numerical computing challenges with NumPy.<\/p>\n In simpler terms:<\/strong><\/p>\n NumPy is a Python library that makes it easy to work with numerical data. Array arithmetic operations are a fundamental part of NumPy, and they allow you to perform complex calculations on large amounts of data quickly and efficiently.<\/p>\n This tutorial covered the most common array arithmetic operations in NumPy, and it showed you how to perform them using both operators and built-in functions. By learning how to use these operations, you’ll be able to tackle a wide range of numerical computing challenges with NumPy. Arithmetic operations are fundamental, playing an important role in science and computer applications. In data manipulation and numerical computation, NumPy (Numerical Python) stands out as a powerful library that provides a wide range of...<\/p>\n","protected":false},"author":1,"featured_media":447117,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[385],"tags":[5486,383,5485,5488,5286,5487],"class_list":["post-89098","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-numpy-tutorials","tag-arithmetic-operations-in-numpy","tag-learn-numpy","tag-numpy-arithmetic-operations","tag-numpy-arithmetic-operations-with-examples","tag-numpy-tutorials","tag-what-is-arithmetic-operations-in-numpy"],"yoast_head":"\nList of NumPy Arithmetic Operations<\/h3>\n
\n\n
\n Element-wise Operation<\/span><\/td>\n Operator<\/span><\/td>\n Function<\/span><\/td>\n<\/tr>\n \n Addition<\/span><\/td>\n +<\/span><\/td>\n add()<\/span><\/td>\n<\/tr>\n \n Subtraction<\/span><\/td>\n –<\/span><\/td>\n subtract()<\/span><\/td>\n<\/tr>\n \n Multiplication<\/span><\/td>\n *<\/span><\/td>\n multiply()<\/span><\/td>\n<\/tr>\n \n Division<\/span><\/td>\n \/<\/span><\/td>\n divide()<\/span><\/td>\n<\/tr>\n \n Exponentiation<\/span><\/td>\n **<\/span><\/td>\n power()<\/span><\/td>\n<\/tr>\n \n Modulus<\/span><\/td>\n %<\/span><\/td>\n mod()<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n NumPy Array Element-Wise Addition<\/h3>\n
import numpy as np\r\n\r\nfirst_array = np.array([1, 3, 5, 7])\r\nsecond_array = np.array([2, 4, 6, 8])\r\n\r\n# Using the + operator\r\nresult1 = first_array + second_array\r\nprint(\"Using the + operator:\", result1)\r\n\r\n# Using the add() function\r\nresult2 = np.add(first_array, second_array)\r\nprint(\"Using the add() function:\", result2)<\/pre>\n
\nUsing the add() function:<\/strong> [ 3 7 11 15]<\/p>\nNumPy Array Element-Wise Subtraction<\/h3>\n
import numpy as np\r\n\r\nfirst_array = np.array([3, 9, 27, 81])\r\nsecond_array = np.array([2, 4, 8, 16])\r\n\r\n# Using the - operator\r\nresult1 = first_array - second_array\r\nprint(\"Using the - operator:\", result1)\r\n\r\n# Using the subtract() function\r\nresult2 = np.subtract(first_array, second_array)\r\nprint(\"Using the subtract() function:\", result2)<\/pre>\n
\nUsing the subtract() function:<\/strong> [ 1 5 19 65]<\/p>\nNumPy Array Element-Wise Multiplication<\/h3>\n
import numpy as np\r\n\r\nfirst_array = np.array([1, 3, 5, 7])\r\nsecond_array = np.array([2, 4, 6, 8])\r\n\r\n# Using the * operator\r\nresult1 = first_array * second_array\r\nprint(\"Using the * operator:\", result1)\r\n\r\n# Using the multiply() function\r\nresult2 = np.multiply(first_array, second_array)\r\nprint(\"Using the multiply() function:\", result2)<\/pre>\n
\nUsing the * operator:<\/strong> [ 2 12 30 56]
\nUsing the multiply() function:<\/strong> [ 2 12 30 56]<\/p>\nNumPy Array Element-Wise Division<\/h3>\n
import numpy as np\r\n\r\nfirst_array = np.array([1, 2, 3])\r\nsecond_array = np.array([4, 5, 6])\r\n\r\n# Using the \/ operator\r\nresult1 = first_array \/ second_array\r\nprint(\"Using the \/ operator:\", result1)\r\n\r\n# Using the divide() function\r\nresult2 = np.divide(first_array, second_array)\r\nprint(\"Using the divide() function:\", result2)<\/pre>\n
\nUsing the \/ operator:<\/strong> [0.25 0.4 0.5 ]
\nUsing the divide() function:<\/strong> [0.25 0.4 0.5 ]<\/p>\nNumPy Array Element-Wise Exponentiation<\/h3>\n
import numpy as np\r\n\r\narray1 = np.array([1, 2, 3])\r\n\r\n# Using the ** operator\r\nresult1 = array1 ** 2\r\nprint(\"Using the ** operator:\", result1)\r\n\r\n# Using the power() function\r\nresult2 = np.power(array1, 2)\r\nprint(\"Using the power() function:\", result2)<\/pre>\n
\nUsing the ** operator:<\/strong> [1 4 9]
\nUsing the power() function:<\/strong> [1 4 9]<\/p>\nNumPy Array Element-Wise Modulus<\/h3>\n
import numpy as np\r\n\r\nfirst_array = np.array([9, 10, 20])\r\nsecond_array = np.array([2, 5, 7])\r\n\r\n# Using the % operator\r\nresult1 = first_array % second_array\r\nprint(\"Using the % operator:\", result1)\r\n\r\n# Using the mod() function\r\nresult2 = np.mod(first_array, second_array)\r\nprint(\"Using the mod() function:\", result2)<\/pre>\n
\nUsing the % operator:<\/strong> [1 0 6]
\nUsing the mod() function:<\/strong> [1 0 6]<\/p>\n\n\n
\n Function<\/span><\/td>\n Description<\/span><\/td>\n<\/tr>\n \n add(x1, x2, …)<\/span><\/td>\n Perform element-wise addition.<\/span><\/td>\n<\/tr>\n \n reciprocal(x, …)<\/span><\/td>\n Calculate the element-wise reciprocal of a number.<\/span><\/td>\n<\/tr>\n \n positive(x, …)<\/span><\/td>\n Obtain the element-wise positive value of a number.<\/span><\/td>\n<\/tr>\n \n negative(x, …)<\/span><\/td>\n Determine the element-wise negative value of a number.<\/span><\/td>\n<\/tr>\n \n multiply(x1, x2, …)<\/span><\/td>\n Perform element-wise multiplication.<\/span><\/td>\n<\/tr>\n \n divide(x1, x2, …)<\/span><\/td>\n Perform element-wise division.<\/span><\/td>\n<\/tr>\n \n power(x1, x2, …)<\/span><\/td>\n Raise elements of the first array to the power of the elements in the second array, element-wise.<\/span><\/td>\n<\/tr>\n \n subtract(x1, x2, …)<\/span><\/td>\n Perform element-wise subtraction.<\/span><\/td>\n<\/tr>\n \n true_divide(x1, x2, …)<\/span><\/td>\n Perform element-wise division, ensuring accurate floating-point results.<\/span><\/td>\n<\/tr>\n \n floor_divide(x1, x2, …)<\/span><\/td>\n Calculate the largest integer smaller than or equal to the division of the inputs.<\/span><\/td>\n<\/tr>\n \n float_power(x1, x2, …)<\/span><\/td>\n Raise elements of the first array to the power of the elements in the second array, element-wise, with support for floating-point powers.<\/span><\/td>\n<\/tr>\n \n fmod(x1, x2, …)<\/span><\/td>\n Calculate the element-wise remainder of division.<\/span><\/td>\n<\/tr>\n \n mod(x1, x2, …)<\/span><\/td>\n Calculate the element-wise remainder of division, adhering to specified casting rules.<\/span><\/td>\n<\/tr>\n \n modf(x, …)<\/span><\/td>\n Split an array into its fractional and integral parts, element-wise.<\/span><\/td>\n<\/tr>\n \n remainder(x1, x2, …)<\/span><\/td>\n Calculate the element-wise remainder of division, following specified casting rules.<\/span><\/td>\n<\/tr>\n \n divmod(x1, x2, …)<\/span><\/td>\n Calculate element-wise quotient and remainder simultaneously, with optional output arrays.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Conclusion<\/h3>\n
\nHappy coding!<\/p>\n","protected":false},"excerpt":{"rendered":"