Modül Mantığı
Bu konuda modüllerin ne demek olduğunu ve mantığını anlamaya çalışacağız.
Pythonda aslında her bir dosya bir modüldür ve her bir modül içinde fonksiyonlar, sınıflar ve objeler barındırır. Biz de bu modülleri programımıza dahil ederek içindeki fonksiyonlardan, sınıflardan ve objelerden faydalanabiliriz.
Gerçek hayattan benzetme yapacak olursak bir matematik ödevini yaparken kullandığımız formül kitabı aslında bir modül olarak düşünülebilir. Bu kitabı ödev yaparken kullanarak ödevimizi çok hızlı ve pratik bir şekilde bitirebiliriz.
Pythonda da modül kavramı oldukça önemli bir kavramdır. Bir Python modülünü programımıza dahil ederek bu modüller içinde yazılan fonksiyonlardan ve sınıflardan kullanabilir ve programlarımızı daha efektif bir şekilde yazabiliriz. Eğer modül diye bir kavram olmasaydı, programlarımızdaki herbir fonksiyonu ve sınıfı kendimiz yazmak zorunda kalacaktık.
Pythonda Python geliştiricileri tarafından yazılmış bir çok hazır modül bulunmaktadır. Ayrıca , programcıların internete ve Githuba yükledikleri bir çok modülü programlarımızda kullanabilir ve daha güzel programlar yazabiliriz.
Modül Kullanımı – math Modülü
Bu derste Pythonda modüller nasıl kullanılır öğrenmeye çalışacağız. Ayrıca bir modülü içeri aktarmanın değişik yöntemlerini göreceğiz.
İsterseniz hazır bir modül olan math modülünü kullanmaya başlayalım.
Yöntem1 – import modül_adı¶
Bir modülü içeri aktarmak yani programımıza dahil etmek için import modül_adı yazabiliriz. İsterseniz bunun için math modülünü içeri aktaralım.
|
1 |
import math # Modülü içeri aktarıyoruz. Artık bu modülün tüm fonksiyonlarını kullanabiliriz. |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
print(dir(math)) # Math modülünün içindekileri görmek için dir fonksiyonunu kullanabiliriz. """ Çıktı ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc'] """ |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 |
print(help(math)) # Fonksiyonların görevlerini görebilmek için help fonksiyonunu kullanabiliriz. """ Çıktı Help on built-in module math: NAME math DESCRIPTION This module is always available. It provides access to the mathematical functions defined by the C standard. FUNCTIONS acos(...) acos(x) Return the arc cosine (measured in radians) of x. acosh(...) acosh(x) Return the inverse hyperbolic cosine of x. asin(...) asin(x) Return the arc sine (measured in radians) of x. asinh(...) asinh(x) Return the inverse hyperbolic sine of x. atan(...) atan(x) Return the arc tangent (measured in radians) of x. atan2(...) atan2(y, x) Return the arc tangent (measured in radians) of y/x. Unlike atan(y/x), the signs of both x and y are considered. atanh(...) atanh(x) Return the inverse hyperbolic tangent of x. ceil(...) ceil(x) Return the ceiling of x as an Integral. This is the smallest integer >= x. copysign(...) copysign(x, y) Return a float with the magnitude (absolute value) of x but the sign of y. On platforms that support signed zeros, copysign(1.0, -0.0) returns -1.0. cos(...) cos(x) Return the cosine of x (measured in radians). cosh(...) cosh(x) Return the hyperbolic cosine of x. degrees(...) degrees(x) Convert angle x from radians to degrees. erf(...) erf(x) Error function at x. erfc(...) erfc(x) Complementary error function at x. exp(...) exp(x) Return e raised to the power of x. expm1(...) expm1(x) Return exp(x)-1. This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. fabs(...) fabs(x) Return the absolute value of the float x. factorial(...) factorial(x) -> Integral Find x!. Raise a ValueError if x is negative or non-integral. floor(...) floor(x) Return the floor of x as an Integral. This is the largest integer <= x. fmod(...) fmod(x, y) Return fmod(x, y), according to platform C. x % y may differ. frexp(...) frexp(x) Return the mantissa and exponent of x, as pair (m, e). m is a float and e is an int, such that x = m * 2.**e. If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. fsum(...) fsum(iterable) Return an accurate floating point sum of values in the iterable. Assumes IEEE-754 floating point arithmetic. gamma(...) gamma(x) Gamma function at x. ... """ |
Peki bu içeri aktarma yöntemiyle math modülünün herhangi bir fonksiyonunu nasıl kullanacağız ?
|
1 |
modül_adı.fonksiyonadı() |
Örneğin ilk olarak math modülünün içindeki factorial fonksiyonu ne iş yapıyor bakalım.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
print(help(math.factorial)) """ Çıktı Help on built-in function factorial in module math: factorial(...) factorial(x) -> Integral Find x!. Raise a ValueError if x is negative or non-integral. """ |
|
1 2 3 4 5 6 7 8 9 10 |
print(math.factorial(5)) print(math.factorial(10)) """ Çıktı 120 3628800 """ |
Peki biz bir modülü kendi belirlediğimiz isimle nasıl kullanıyoruz ? Bunun için de şu şekilde bir şey yapacağız.
|
1 2 3 4 5 6 7 8 9 10 11 |
import math as matematik print(matematik.factorial(6)) # Modülü artık matematik ismiyle kullanabiliriz. print(matematik.factorial(0)) """ Çıktı 720 1 """ |
Yöntem2 – from modül_adı import *
Bir modülü programımıza dahil etmek için bu yöntemi de kullanabiliriz. İsterseniz math modülünü bu yöntem içeri aktaralım.
|
1 |
from math import * # Yıldızın anlamı math modülünün içindeki bütün fonksiyonları almak istediğimizi belirtiyor. |
Peki böyle bir durumda math modülünün içindeki fonksiyonları nasıl kullanacağız. Bunun için modül ismini yazmamıza gerek kalmamaktadır.
|
1 |
fonksiyon_adı() |
|
1 2 3 4 5 6 7 8 |
print(factorial(5)) """ Çıktı 120 """ |
Peki bir modül içindeki fonksiyonların belli bir kısmını almak için ne yapacağız ? Bunun için hangi fonksiyonları alacağımızı özellikle belirtmemiz gerekiyor.
Not : Öncelikle IDLE üzerinden veya Jupyter üzerinden çalışıyorsanız programları tekrardan başlatın.
|
1 2 3 4 5 6 7 8 9 10 11 |
from math import factorial,floor # Sadece 2 tanesini dahil ettik. print(factorial(5)) print(floor(3.5)) """ Çıktı 120 3 """ |
|
1 |
ceil(3.4) # Dahil etmediğimiz için hata verdi. |
|
1 2 3 4 5 6 |
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-5-3fffe6b889eb> in <module>() ----> 1 ceil(3.4) # Dahil etmediğimiz için hata verdi. NameError: name 'ceil' is not defined |
Peki bu yöntemlerin birbirinden farkı ne ? 2.yöntemi kullandığımızda bildiğimiz gibi sadece fonksiyon isimlerini kullanıyoruz. Ancak eğer programa birden fazla modül dahil edersek veya dahil ettiğimiz modülün içindeki fonksiyon kendi tanımladığımız fonksiyon ismiyle aynıysa Python son gördüğü fonksiyonu çalıştıracaktır.
Not : Öncelikle IDLE üzerinden veya Jupyter üzerinden çalışıyorsanız programları tekrardan başlatın.
|
1 |
from math import * |
|
1 2 3 4 5 6 7 8 9 |
def factorial(sayı): print("Kendi Factorial fonksiyonum.") faktoriyel = 1 if (sayı == 0 or sayı == 1): return 1 while (sayı >= 1): faktoriyel *= sayı sayı -= 1 return faktoriyel |
|
1 2 3 4 5 6 7 8 9 10 |
print(factorial(5)) """ Çıktı Kendi Factorial fonksiyonum. 120 """ |
