محاسبه ریشه مربع یک عدد در پایتون

معرفی

را مربع root یک عدد یک تابع ریاضی بسیار رایج است که در تمام جنبه‌های علم – فیزیک، ریاضیات، علوم کامپیوتر و غیره استفاده می‌شود. – با مدلسازی آنچه می توانیم با حساب دیفرانسیل و انتگرال مشاهده کنیم.

در این مقاله نگاهی خواهیم داشت روش های مختلف برای محاسبه مربع root یک عدد در پایتون. در نهایت، ما یک را انجام می دهیم معیار عملکرد با اعداد ثابت و تصادفی، و همچنین لیستی از اعداد تصادفی برای قرار دادن تمام رویکردهای آزمایشی.

محاسبه ریشه مربع در پایتون با NumPy

NumPy یک کتابخانه محاسباتی علمی است که در آن حضور پیدا کرد زیاد برنامه ها و موارد استفاده طبیعی است که دارد زیاد بسته بندی توابع ریاضی به عنوان روش های کمکی.

اگر قبلاً نصب نشده‌اید، می‌توانید از طریق آن نصب کنید pip:

$ pip install numpy

از نظر NumPy، sqrt() تابع مربع را محاسبه می کند root از یک عدد، و نتیجه را برمی گرداند:

import numpy as np
x = np.sqrt(2)
print(x)

این منجر به:

1.4142135623730951

جدا از در نظر گرفتن یک متغیر منفرد به عنوان آرگومان، sqrt() همچنین قادر به تجزیه لیست ها و برگرداندن لیستی از ریشه های مربع است:

arr = (2, 3, 5, 7)
roots = np.sqrt(arr)
print(roots)

این منجر به:

(1.41421356 1.73205081 2.23606798 2.64575131)

را sqrt() هر چند تابع یک محدودیت دارد – نمی تواند مربع را محاسبه کند root از یک عدد منفی، زیرا مربع root عملیات با اعداد واقعی فقط برای اعداد مثبت تعریف شده است.

تلاش برای درج -4 به درون sqrt() تابع منجر به یک استثنا می شود:

print(np.sqrt(-4))

تلاش برای محاسبه مربع root از یک عدد منفی با یک اخطار و a nan ارزش:

RuntimeWarning: invalid value encountered in sqrt
nan

ریشه مربع اعداد مختلط را با Numpy محاسبه کنید

خوشبختانه، NumPy فقط با اعداد واقعی کار نمی کند – می تواند با اعداد مختلط نیز کار کند:

import numpy as np

complex_number = -1 + 1j
complex_array = (-2, 3, complex_number)

complex_root = np.sqrt(complex_number)
complex_array_roots = np.sqrt(complex_array)

print(f"Square root of '{complex_number}':\n {complex_root}")
print(f"Square roots of '{complex_array}':\n {complex_array_roots}")

اگر حداقل وجود دارد یکی اعداد مختلط در یک لیست، همه اعداد به صورت مختلط در نظر گرفته می شوند، بنابراین حتی اعداد صحیح منفی نیز می توانند اضافه شوند:

Square root of '(-1+1j)':
 (0.45508986056222733+1.09868411346781j)
Square roots of '(-2, 3, (-1+1j))':
 (0.        +1.41421356j 1.73205081+0.j         0.45508986+1.09868411j)

پایتون ریاضی مدول

را math ماژول یک ماژول استاندارد است که با پایتون بسته بندی شده است. همیشه در دسترس است، اما باید وارد شود، و برای برخی از عملکردهای رایج، مانند مربع، لفاف‌بندی ارائه می‌کند. root، قدرت ها و غیره:

import math

math.sqrt()

را sqrt() عملکرد از math ماژول یک تابع ساده است که مربع را برمی گرداند root از هر عدد مثبت:

print(math.sqrt(2))

این منجر به:

1.4142135623730951

برخلاف NumPy sqrt() عملکرد، فقط می تواند کار کند روی یک عنصر واحد، بنابراین اگر می خواهید مربع را محاسبه کنید root از بین تمام عناصر یک لیست، باید از a استفاده کنید for حلقه یا درک لیست:

import math

arr = (2, 3, 5, 7)
roots = ()

for x in arr:
    roots.append(math.sqrt(x))


roots = (math.sqrt(x) for x in arr)

در هر دو مورد، roots لیست شامل موارد زیر خواهد بود:

(1.4142135623730951, 1.7320508075688772, 2.23606797749979, 2.6457513110645907)

math.pow()

یک مربع root یک عدد را نیز می توان با بالا بردن عدد به توان محاسبه کرد ½:

$$
\sqrt x = x^{\frac 1 2}
$$

بنابراین واقعاً، پیدا کردن مربع root یک عدد را می توان به صورت افزایش عدد به توان ½ بیان کرد. math.pow() دو آرگومان – مبنا و توان را می گیرد و پایه را به توان یک توان افزایش می دهد:

print(math.pow(2, 0.5))

به طور طبیعی، این نتیجه می شود:

1.4142135623730951

را ** اپراتور

را ** عملگر یک عملگر باینری است به این معنی که با دو مقدار کار می کند، درست مانند ضرب منظم با * میکند. با این حال، از آنجایی که یک عملگر است که برای توان استفاده می‌شود، آرگومان چپ آن را به توان آرگومان راست آن افزایش می‌دهیم.

این روش را می توان به همان شکل قبلی استفاده کرد:

print(2 ** 0.5)

و همچنین به این نتیجه می رسد:

1.4142135623730951

را قدرت () تابع

پایتون داخلی دیگری دارد pow() روشی که نیازی به import از math مدول. این روش از نظر فنی متفاوت از math.pow() روش داخلی

math.pow() به طور ضمنی عناصر را به دو برابر می شود، در حالی که pow() با استفاده از پیاده سازی داخلی شی، بر اساس ** اپراتور. در حالی که این تفاوت در پیاده سازی ممکن است استفاده از یکی یا دیگری را در زمینه های خاص تضمین کند، اگر فقط مربع را محاسبه می کنید root از یک عدد، واقعاً تفاوت را نخواهید دید:

print(pow(2, 0.5))

این منجر به:

1.4142135623730951

معیار عملکرد

بنابراین کدام یک بهترین عملکرد را دارد و کدام یک را باید انتخاب کنید؟ طبق معمول، وجود ندارد یک برش واضح برنده، و آن بستگی دارد روی استفاده از روش ها یعنی، اگر با اعداد ثابت، اعداد تصادفی یا آرایه‌ای از اعداد تصادفی کار می‌کنید. روی در مقیاس بزرگتر – این روش ها متفاوت عمل می کنند.

بیایید همه آنها را آزمایش کنیم روی اعداد ثابت، اعداد تصادفی و آرایه های اعداد تصادفی:

import timeit

print("Time to execute 100k operations روی constant number: \n")
print("math.sqrt(): %ss" % timeit.timeit("math.sqrt(100)", setup="import math", number=100000))
print("math.pow(): %ss" % timeit.timeit("math.pow(100, 0.5)", setup="import math", number=100000))
print("pow(): %ss" % timeit.timeit("pow(100, 0.5)", number=100000))
print("np.sqrt(): %ss" % timeit.timeit("np.sqrt(100)", setup="import numpy as np", number=100000))
print("** operator: %ss" % timeit.timeit("100 ** 0.5", number=100000))

print("\nTime to execute 100k operations روی random number: \n")
print("math.sqrt() %ss" % timeit.timeit("math.sqrt(random.random())", setup="import math; import random;", number=100000))
print("math.pow(): %ss" % timeit.timeit("math.pow(random.random(), 0.5)", setup="import math; import random", number=100000))
print("pow(): %ss" % timeit.timeit("pow(random.random(), 0.5)", setup="import random", number=100000))
print("np.sqrt(): %ss" % timeit.timeit("np.sqrt(random.random())", setup="import numpy as np; import random", number=100000))
print("** operator: %ss" % timeit.timeit("random.random() ** 0.5", setup="import random", number=100000))

print("\nTime to execute 100k operations روی list of random numbers: \n")
print("math.sqrt() %ss" % timeit.timeit("(math.sqrt(x) for x in np.random.rand(100))", setup="import math; import numpy as np;", number=100000))
print("math.pow(): %ss" % timeit.timeit("(math.pow(x, 0.5) for x in np.random.rand(100))", setup="import math; import numpy as np;", number=100000))
print("pow(): %ss" % timeit.timeit("(pow(x, 0.5) for x in np.random.rand(100))", setup="import numpy as np;", number=100000))
print("np.sqrt(): %ss" % timeit.timeit("np.sqrt(np.random.rand(100))", setup="import numpy as np; import numpy as np;", number=100000))
print("** operator: %ss" % timeit.timeit("np.random.rand(100) ** 0.5", setup="import numpy as np", number=100000))

ما تمام روش‌های ذکر شده در بالا را از طریق یک آزمایش گذرانده‌ایم – یک عدد ثابت (که احتمالاً برای بهینه‌سازی در حافظه پنهان ذخیره می‌شود)، یک عدد تصادفی روی هر یک از 100k تکرار، و a فهرست از 100 عدد تصادفی

اجرای این قطعه کد به این نتیجه می رسد:

Time to execute 100k operations روی constant number: 

math.sqrt(): 0.014326499999999999s
math.pow(): 0.0165132s
pow(): 0.018766599999999994s
np.sqrt(): 0.10575379999999998s
** operator: 0.0006493000000000193s

Time to execute 100k operations روی random number: 

math.sqrt() 0.019939999999999958s
math.pow(): 0.022284300000000035s
pow(): 0.0231711s
np.sqrt(): 0.09066460000000004s
** operator: 0.018928s

Time to execute 100k operations روی list of random numbers: 

math.sqrt() 2.7786073s
math.pow(): 2.9986906s
pow(): 3.5157339999999992s 
np.sqrt(): 0.2291957s
** operator: 0.2376024000000001s

با اعداد ثابت – math.pow()، math.sqrt() و pow() توابع به طور قابل توجهی بهتر از NumPy است sqrt() عملکرد، زیرا می توانند بهتر از کش در CPU استفاده کنند روی سطح زبان

با اعداد تصادفی، حافظه پنهان کار نمی کند همچنین و شاهد اختلافات کوچکتری هستیم.

با لیستی از اعداد تصادفی، np.sqrt() از هر سه روش داخلی بهتر عمل می کند به طور قابل ملاحظه، و ** اپراتور در همان پارک توپ اجرا می کند.

به طور خلاصه:

بسته به روی ورودی ملموسی که با آن سروکار دارید – بین این توابع یکی را انتخاب خواهید کرد. در حالی که ممکن است به نظر برسد که آنها این کار را خواهند کرد همه عملکرد خوبی داشته باشد، و در حالی که در اکثر در موارد، تفاوت چندانی ایجاد نخواهد کرد، وقتی با مجموعه داده‌های عظیم سروکار داریم، حتی کاهش 10 درصدی زمان پردازش می‌تواند در بلندمدت کمک کند.

بسته به روی داده هایی که در حال پردازش هستید – روش های مختلف را تست کنید روی ماشین محلی شما.

نتیجه

در این مقاله کوتاه، نگاهی به چندین روش برای محاسبه آن انداخته ایم ریشه دوم یک عدد در پایتون

ما نگاهی به آن انداخته ایم math ماژول ها pow() و sqrt() توابع و همچنین داخلی pow() تابع، NumPy sqrt() تابع و ** اپراتور. در نهایت، ما روش ها را برای مقایسه عملکرد آنها محک زده ایم روی انواع مختلف ورودی – اعداد ثابت، اعداد تصادفی و لیست اعداد تصادفی.