Alıştırma Sorularının Cevapları

    1. Sıcaklığı Kelvin cinsinden verilen bir karacismin ışınımının maksimumunun dalgaobyunu cm cinsinden Wien kayma yasası uyarınca hesaplayan ve döndüren bir fonksiyon yazınız.
In [1]:
def Wien(T):
    """
    Kelvin cinsinden verilen sicaklik (T) icin
    karacisim isiniminin maksimum oldugu dalgaboyunu
    cm cinsinden veren fonksiyon
    """
    lamda = 0.2898 / T
    return lamda

sicaklik = 5780 # Gunes
lamdamax = Wien(sicaklik)*1e8 # Angstrom donusumu
print('Gunesin maksimum isinim yaptigi dalgaboyu: {:g} A'.format(lamdamax))
Gunesin maksimum isinim yaptigi dalgaboyu: 5013.84 A
  1. Görsel parlaklığı (m) kadir cinsinden ve uzaklığı (d) parsek cinsinden verilen bir yıldızın mutlak parlaklığını uzaklık modülünü kullanarak hesaplayan ve döndüren bir fonksiyon yazınız.
In [2]:
def uzaklikmodulu(m, d):
    """
    Görünen parlakligi kadir cinsinden (m),
    uzakligi parsek cinsinden (d) verilen
    bir yildizin mutlak parlakligini kadir cinsinden
    uzaklik modulu ile hesaplayan fonksiyon
    Uzaklik modulu: M = m + 5 - 5 log(d)
    """
    from math import log
    M = m + 5 - 5*log(d, 10)
    return M

# Vega icin literatur paralaks degeri 130 miliyaysaniyesidir
uzaklik = 1 / 130e-3 # Bu degeri parsek cisinden uzakliga donusturelim
gorselparlaklik = 0.03 # Vega icin gorunen parlaklik (V bandinda)
mutlakparlaklik = uzaklikmodulu(d = uzaklik, m=gorselparlaklik)
print('Uzakligi {:.2f} pc olan yildizin gorsel parlakligi {:.2f} kadirse, \
mutlak parlakligi {:.2f} kadirdir'.format(uzaklik, gorselparlaklik, mutlakparlaklik))
Uzakligi 7.69 pc olan yildizin gorsel parlakligi 0.03 kadirse, mutlak parlakligi 0.60 kadirdir
  1. Verilen iki sayının eşitliğini belirli bir tolerans değeri çerçevesinde denetleyen, bu iki sayının arasındaki farkın multak değeri verilen tolerans değerinden küçükse $True$, değilse $False$ döndüren bir fonksiyon yazınız. Tolerans değerini bir anahtar kelime argümanı (ing. keyword argument) olarak, varsayılan değeri $10^{-6}$ olacak şekilde tanımlayınız. Fonksiyonunuzu test etmek için 1.0 ile 1 / 49 x 49 işleminin sonucunun eşit olup olmadığını denetlemek üzere varsayılan tolerans değeri ve $10^{-16}$ tolerans değerini kullanınız.
In [3]:
def esitlik(a, b, tolerans=1e-6):
    if abs(a - b) < tolerans:
        return True
    else:
        return False

x = 1.0
y = 1/49*49
print('x == y -->', esitlik(x, y))
print('x == y -->', esitlik(x, y, tolerans = 1e-16))
x == y --> True
x == y --> False
In [4]:
# Bir onceki alistirmanin alternatif cozumu
def esitlik(a, b, tolerans=1e-6):
    return abs(a - b) < tolerans
    
x = 1.0
y = 1/49*49
print('x == y -->', esitlik(x, y))
print('x == y -->', esitlik(x, y, tolerans = 1e-16))
x == y --> True
x == y --> False
  1. İki sayıyı argüman olarak alıp, toplamlarını döndüren bir normal fonksiyon, bir de onun özdeşi $lambda$ fonksiyonu yazınız ve x = 1 ve y = 1 için fonksiyonlarınızın vereceği değeri ekrana yazdırarak test ediniz.
In [5]:
def f(x,y):
    return x + y
print(f(1,1))
# ozdes lambda fonksyonu
f = lambda x, y : x + y
print(f(1,1))
2
2
  1. Santigrad dereceyi Fahrenheit'a dönüştüren bir normal fonksiyon, bir de özdeşi $lambda$ fonksiyonu yazınız ve 11 derece santigrat değeri için fonksiyonlarınızın vereceği değeri ekrana yazdırarak test ediniz.
In [5]:
def C2F(C):
    return 9/5*C + 32
print(C2F(11))
# ozdes lambda fonksiyonu
C2F = lambda C: 9/5*C + 32
print(C2F(11))
51.8
51.8
  1. İlk hızı $V_{0}$ olan bir cismin dikey atış formülünü kullanarak t anındaki konumunu bulan bir fonksiyon yazınız. Fonksiyonunuzun son argümanı varsayılan değeri 9.81 $m/s^{2}$ olan yerçekimi ivmesi ($g = 9.81$) olmalıdır. $yol$ adını vereceğinizi bu fonksiyona özdeş bir de $lambda$ fonksiyonu yazarak, testini $V_{0} = 5 m/s$, $t = 1 s$ ve $g = 10 m/s^{2}$ için fonksiyonlarınızın hesaplayacağı değeri ekrana yazdırmak suretiyle yapınız.
In [7]:
def yol(t, v0, g=9.81):
    return v0*t - 0.5*g*t**2
print(yol(1, 5, 10))
# ozdes lambda fonksiyonu
yol = lambda t,v0,g=9.81: v0*t - 0.5*g*t**2
print(yol(1, 5, 10))
0.0
0.0
  1. Aynı uzunlukta üç listenin karşılıklı elemanlarını toplayarak bir listeye atan ve programda çağrıldığı noktaya döndüren bir fonksiyon yazınız. Fonksiyonunuzu $a = [1,2,3,4], b = [17,12,11,10], c = [-1,-4,5,9]$ listeleri üzerinden test ediniz.
In [7]:
def listetoplam(liste1, liste2, liste3):
    sonuc = []
    for i in range(len(liste1)):
        sonuc.append(liste1[i] + liste2[i] + liste3[i])
    return sonuc
        
a = [1,2,3,4]
b = [17,12,11,10]
c = [-1,-4,5,9]
print(listetoplam(a,b,c))
[17, 10, 19, 23]
In [8]:
# Ayni islemi listeleri eleman uzerinden tarayarak da yapabilirsiniz
# ancak bunun icin zip fonksiyonunu kullanabilirsiniz
# Listeleri eleman uzerinden taramak daha Pythonik bir yoldur!
def listetoplam(liste1, liste2, liste3):
    sonuc = []
    for e1, e2, e3 in zip(liste1, liste2, liste3):
        sonuc.append(e1+e2+e3)
    return sonuc

a = [1,2,3,4]
b = [17,12,11,10]
c = [-1,-4,5,9]
print(listetoplam(a,b,c))
[17, 10, 19, 23]
In [9]:
# Bu islemleri hizli liste olusturma yontemlerini (list comprehensions)
# kullanarak da yapabilirsiniz.

a = [1,2,3,4]
b = [17,12,11,10]
c = [-1,-4,5,9]
d = [e1+e2+e3 for e1,e2,e3 in zip(a,b,c)]

print(d)
[17, 10, 19, 23]
In [11]:
# Hizli liste olusturma yontemlerini (liste comprehensions)
# indeksle liste tarayarak da kullanabilirsiniz.

a = [1,2,3,4]
b = [17,12,11,10]
c = [-1,-4,5,9]
d = [a[i]+b[i]+c[i] for i in range(len(a))]

print(d)
[17, 10, 19, 23]
In [12]:
# map fonksiyonu bir fonksiyonun bir liste ya da demet degisken
# gibi birden fazla eleman iceren bir dizi uzerinde bir seferde
# uygulanmasini saglar.

a = [1,2,3,4]
b = [17,12,11,10]
c = [-1,-4,5,9]
d = list(map(lambda x,y,z: x+y+z, a,b,c))

print(d)
[17, 10, 19, 23]
  1. $fib = [0,1,1,2,3,5,8,13,21,34,55]$ listesindeki ikiyle bölünebilen sayıları $ikiyle$_$tam$_$bolunenler$ listesinde bölünmeyenleri $ikiyle$_$tam$_$bolunmeyenler$ listesinde toplayınız ve bu listeleri ekrana yazdırınız.
In [13]:
fib = [0,1,1,2,3,5,8,13,21,34,55]
ikiye_tam_bolunenler = []
ikiye_tam_bolunmeyenler = []
for eleman in fib:
    if eleman % 2 == 0:
        ikiye_tam_bolunenler.append(eleman)
    # ikiyle bolunememe kosulunu bir elif
    # bloguyla verebileceğiniz gibi
    #elif eleman % 2 != 0:
    #    ikiye_tam_bolunmeyenler.append(eleman)
    # basit bir else blogu ile de verebilirsiniz
    else:
        ikiye_tam_bolunmeyenler.append(eleman)

print(ikiye_tam_bolunenler)
print(ikiye_tam_bolunmeyenler)
[0, 2, 8, 34]
[1, 1, 3, 5, 13, 21, 55]
  1. $a = [0.1, 9.0, -4.2, 0.5, -2.3, 3.1, 11.0]$ listesinde -2'den küçük sayıları, -2 ile 2 arasındaki sayıları (-2 ve 2 dahil) ve 2'den büyük sayıları ekrana yazdıran bir program yazınız.
In [14]:
a = [0.1, 9.0, -4.2, 0.5, -2.3, 3.1, 11.0]
for sayi in a:
    if sayi < -2:
        print("x={:g} -2'den kucuk".format(sayi))
    elif -2 <= sayi <= 2:
        print("x={:g} -2 ile 2 arasinda".format(sayi))
    else:
        print("x={:g} 2'den buyuk".format(sayi))
x=0.1 -2 ile 2 arasinda
x=9 2'den buyuk
x=-4.2 -2'den kucuk
x=0.5 -2 ile 2 arasinda
x=-2.3 -2'den kucuk
x=3.1 2'den buyuk
x=11 2'den buyuk
  1. Belirli integral alabilmek için kullanılan yöntemlerden biri de yamuk yöntemidir. $x = a$ ile $x = b$ arasında tanımlı, sürekli ve integrallanebilir bir $f$ fonksiyonunun bu aralıktaki belirli integrali yamuk yöntemiyle aşağıdaki şekilde hesaplanabilir.

$$\int_{a}^{b} f(x) dx \approx \frac{1}{2} \frac{f(a) + f(b)}{b - a}$$

Bu ifadeyle integral hesaplayan ve programda çağrıldığı yere döndüren bir fonksiyon yazınız. Fonksiyonunuzu a) $math$ kütüphanesindeki $sin$ fonksyonunun $0$ ile $\pi / 2$ değerleri arasındaki integralini alarak, b) argüman olarak verilen bir $x$ için $x^3$ 'ü hesaplayıp döndüren kendi yazacağınız bir fonksiyonun $1$ ile $3$ değerleri arasındaki integralini hesaplayarak test ediniz.

In [16]:
from math import *
# Yamuk yontemiyle integral alan fonksiyon
def yamukyontemi(f, a, b):
    # f: integrali alinacak fonksiyon
    # a, b: integralin sinirlari
    return 0.5*(f(a) + f(b))*(b-a)

def kup(x):
    # x'in kubunu hesaplayan fonksiyon
    return x**3

print(yamukyontemi(sin, 0, pi/2))
print(yamukyontemi(kup, 1, 3))
0.7853981633974483
28.0
  1. Verilen iki aynı tür nesneyi o nesnelerin toplamına ilişkin kurallar dahilinde toplayıp çağrıldığı noktaya döndüren bir fonksyon yazınız. a) Fonksiyonunuzu iki tam, iki kayan sayı, iki liste ve iki metin nesnesi toplayarak test ediniz. b) Fonksiyonunuzu hiçbir sayı göndermeden, sırasıyla tek bir tane ve üç tane sayı göndererek test ediniz. Çalışmıyorsa neden çalşmadığını anlamaya çalışınız.
In [17]:
def toplam(x, y):
    return x + y

print(toplam(3, 5))
print(toplam(3.14, -3.14))
print(toplam([1,2,3],['elma', 'armut']))
print(toplam('uc', 'bes'))
print(toplam())
print(toplam(2))
print(toplam(1.1, 3.1, 4.3))
8
0.0
[1, 2, 3, 'elma', 'armut']
ucbes
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-17-0d7b6e4c812d> in <module>()
      6 print(toplam([1,2,3],['elma', 'armut']))
      7 print(toplam('uc', 'bes'))
----> 8 print(toplam())
      9 print(toplam(2))
     10 print(toplam(1.1, 3.1, 4.3))

TypeError: toplam() missing 2 required positional arguments: 'x' and 'y'
  1. Bir önceki soruda yazdığınız $toplam$ fonksiyonunu belirsiz sayıda ve anahtar kelime argümanı içermeyen sayıyı (tam ya da kayan noktalı) toplayacak şekilde düzenleyiniz.Fonksiyonunuzu hiçbir sayı göndermeden, sırasıyla tek bir tane, iki tane ve üç tane sayı göndererek test ediniz.
In [18]:
def toplam(*sayilar):
    s = 0
    for sayi in sayilar:
        s += sayi
    return s

print("3 + 5 = ",(toplam(3, 5)))
print("2 = ", toplam(2))
print("1.1 + 3.1 + 4.3 = ", toplam(1.1, 3.1, 4.3))
print("0 = ", toplam())
3 + 5 =  8
2 =  2
1.1 + 3.1 + 4.3 =  8.5
0 =  0
  1. Belirsiz sayıda rengi anahtar kelime ($keyword$), bu renklere karşılık HTML renk kodlarını ise değer ($value$) olarak $anahtar = deger$ şeklinde tanımlanan anahtar elime argümanlarını alarak her renk ve ona karşılık renk kodunu ekrana yazdıran bir fonksiyon yazınız. Fonksiyonunuzu kırmızı, beyaz ve siyah renkleri için test ediniz.
In [19]:
def htmlrenkler(**renkler):
    for renk in renkler:
        print('Renk:{:}\tHTML kodu: {:}'.format(renk, renkler[renk]))

htmlrenkler(
    kirmizi='#FF0000',
    beyaz='FFFFFF',
    siyah='000000'
)
Renk:siyah	HTML kodu: 000000
Renk:beyaz	HTML kodu: FFFFFF
Renk:kirmizi	HTML kodu: #FF0000
  1. Belirsiz sayıda anahtar kelime argümanları olarak tanımlayacağınız nesneyi alan ve sırasıyla sadece anahtar isimlerini ekrana yazdıran $sabitler$ isimli bir fonksiyon yazınız. Fonksiyonunuzu yer çekimi sabiti ($g$), evrensel çekim sabiti ($G$), Boltzman sabiti ($k$) ve ışık hızı ($c$) ile test ediniz.
In [20]:
def sabitler(**kwargs):
    for key in kwargs:
        print(key)
    print("-----------------------")
    print(kwargs)
sabitler(g=9.81, G=6.67e-11, c=3e8, k=1.38e-23)
G
c
g
k
-----------------------
{'G': 6.67e-11, 'c': 300000000.0, 'g': 9.81, 'k': 1.38e-23}
  1. Bir önceki soruda yazdığnız fonksiyonu gönderdiğiniz sabitlerin sadece değerlerini ekrana yazdıracak şekilde düzenleyiniz.
In [21]:
def sabitler(**kwargs):
    for key in kwargs:
        print(kwargs[key])
    print("-----------------------")
    print(kwargs)
sabitler(g=9.81, G=6.67e-11, c=3e8, k=1.38e-23)
6.67e-11
300000000.0
9.81
1.38e-23
-----------------------
{'G': 6.67e-11, 'c': 300000000.0, 'g': 9.81, 'k': 1.38e-23}
  1. Bir önceki soruda yazdığınız fonksiyonu gönderdiğiniz sabitler ve değerlerini birlikte ekrana yazdıracak şekilde düzenleyiniz.
In [22]:
def sabitler(**kwargs):
    for key in kwargs:
        print("{:} = {:}".format(key, kwargs[key]))
    print("-----------------------")
    print(kwargs)
sabitler(g=9.81, G=6.67e-11, c=3e8, k=1.38e-23)
G = 6.67e-11
c = 300000000.0
g = 9.81
k = 1.38e-23
-----------------------
{'G': 6.67e-11, 'c': 300000000.0, 'g': 9.81, 'k': 1.38e-23}
  1. Program tarafında gönderilen bir n tam sayısına kadar (n hariç) tam sayılar içerisinden 5 ile bölünebilenleri ekrana yazdıran (listeye atmanız ya da programa döndürmeniz istenmemektedir) $beslebolunenler$ isimli bir fonksiyon yazınız. n'in pozitif bir sayı olabileceği gibi negatif bir sayı da olabileceğine; n'in pozitif olması durumunda n'e sayacınızı arttırarak, negatif olması durumunda ise azaltarak ulaşabileceğinize dikkat ediniz. Fonksiyonunuzu $n = 102$ ve $n = -102$ için test ediniz.
In [23]:
def beslebolunenler(n):
    if n > 0:
        for i in range(n):
            if i % 5 == 0: # ya da if not(i % 5):
                print(i, end = ",") # sondaki virgul sayilari yanyana yazdirmak icin
        # bir satir atlayalim
        print("\n-----------------------")
    elif n < 0:
        for i in range(0, n, -1):
            if not(i % 5):
                print(i, end = ",")
        # bir satir atlayalim
        print("\n-----------------------")
    else:
        print("n = 0")

beslebolunenler(102)
beslebolunenler(-102)
beslebolunenler(0)
0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100,
-----------------------
0,-5,-10,-15,-20,-25,-30,-35,-40,-45,-50,-55,-60,-65,-70,-75,-80,-85,-90,-95,-100,
-----------------------
n = 0
  1. Kenar uzunlukları verilen bir üçgenin türünü (eşkenar, ikizkenar ya da çeşitkenar) ekrana yazdıran bir fonksiyon yazınız. Fonksiyonunuzu bir eşkenar, bir ikizkenar, bir de çeşitkenar üçgen için test ediniz. Kenar uzunluklarını birbirleriyle karşılaştırırken $10^{-16}$ değerini bir tolerans değeri olarak kullanınız. (örn. Eğer |a - b| < $10^{-16}$ ise a, b'ye eşittir.) Tolerans değerini bir anahtar kelime argümanı yapınız ve fonksiyonunuzun bir testini de bu argümanın değerini $10^{-3}$ yaparak gerçekleştiriniz.
In [24]:
def ucgenturu(a, b, c, tolerans = 1e-16):
    if abs(a - b) < tolerans and abs(b - c) < tolerans:
        print("a = {:g}, b = {:g}, c = {:g} ucgeni bir eskenar ucgendir.".format(a, b, c))
    elif abs(a - b) > tolerans and abs(b - c) > tolerans and abs(a - c) > tolerans:
        print("a = {:g}, b = {:g}, c = {:g} ucgeni bir cesitkenar ucgendir.".format(a, b, c))
    else:
        print("a = {:g}, b = {:g}, c = {:g} ucgeni bir ikizkenar ucgendir.".format(a, b, c))
        
ucgenturu(2.2, 2.2, 2.2)
ucgenturu(2.2, 2.2, 3.3)
ucgenturu(2.2, 3.3, 2.2)
ucgenturu(3.3, 2.2, 2.2)
ucgenturu(1.1, 2.2, 3.3)
ucgenturu(1.0001, 1.0002, 1.0003, tolerans = 1e-3)
a = 2.2, b = 2.2, c = 2.2 ucgeni bir eskenar ucgendir.
a = 2.2, b = 2.2, c = 3.3 ucgeni bir ikizkenar ucgendir.
a = 2.2, b = 3.3, c = 2.2 ucgeni bir ikizkenar ucgendir.
a = 3.3, b = 2.2, c = 2.2 ucgeni bir ikizkenar ucgendir.
a = 1.1, b = 2.2, c = 3.3 ucgeni bir cesitkenar ucgendir.
a = 1.0001, b = 1.0002, c = 1.0003 ucgeni bir eskenar ucgendir.
  1. "Eratosthenes'in eleği" 2'den bir N pozitif tam sayısına kadar (N dahil) tüm asal sayıları veren bir algoritmadır. Verilen bir N pozitif tam sayısı için Eratosthenes'in eleği algoritması ile belirlediği N'den küçük veya eşit tüm asal sayıları bir liste içerisine toplayan ve programda çağrıldığı yere döndüren bir Python fonksiyonu yazınız. Fonksiyonunuzu N = 100 için test ediniz.
In [25]:
def eratosthenes(N):
    # Algoritmaya gore oncelikle N'e kadar ve N dahil 
    # sadece True degerlerden olusan bir liste olusturulur
    kontrolsayi = [True for i in range(N + 1)]
    sayi = 2
    # Her bir sayinin karesi N'le karsilastilir
    # ve N'den kucuk oldugu surece
    while (sayi**2 <= N):
        # Eger kontrolsayi[sayi] bu dongu icinde True kaliyorsa
        # sayi asalsayidir ve tum katlari asal olmayacak sekilde
        # dongu icinde False yapilmalidir.
        if (kontrolsayi[sayi] == True):
            for i in range(sayi*2, N+1, sayi):
                kontrolsayi[i] = False
        sayi += 1
    # Simdi asalsayilari bir asalsayilar listesinde toplayalim
    asalsayilar = []
    for sayi in range(2, N+1):
        if kontrolsayi[sayi]:
            asalsayilar.append(sayi)
    return asalsayilar

N = 100
print("N = {:d}'ye kadar tum asal sayilar: {:}".format(N, eratosthenes(N)))
        
N = 100'ye kadar tum asal sayilar: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
  1. Aşağıda bazı yıldızlar, parsek (pc) cinsinden uzaklıkları ve gezegen içerip içermediklerine iişkin Boolean bir değerden oluşan demet nesenlerini içeren bir Python listesi içerisinde verilmiştir. Bu yıldızlardan gezegen barındıran ve varsayılan değeri 5 pc'lik bir uzaklıktan yakın olanlarını ekrana yazdıran bir fonksiyon yazınız. Fonksiyonunuzu bu varsayılan uzaklık değeri için ve bu değeri 3 ve 20 pc olacak şekilde değiştirerek test ediniz.

veri = [ ('Proxima', 1.30, True), ('Alfa Cen A', 1.32, False), ('Alfa Cen B', 1.32, False), ('Barnard Yildizi', 1.83, True), ('Wolf 359', 2.59, False), ('Wolf 940', 12.39, True), ('Wolf 503', 42.68, True), ('Wolf 1061', 4.31, True), ('Ross 128', 3.31, True), ('Lalande 21185', 2.55, False), ('GJ 3779', 13.75, True), ('Sirius', 2.64, False), ('Ross 154', 2.98, False), ('Epsilon Eridani', 3.22, True), ('EZ Aqr', 3.40, False), ('Procyon', 3.52, False), ('Tau Ceti', 3.65, True), ('Gliese 832', 4.96, False), ('HD 2685', 198.2, True), ('K2 136', 59.4, True), ('HD 219134', 6.55, True), ('Vega', 7.68, False) ]

In [26]:
def gezegenli_yakin_yildizlar(yildizlar, d=5):
    for yildiz in yildizlar:
        yildizadi, uzaklik, gezegen = yildiz
        if uzaklik < d and gezegen:
            print("{:.2f} uzakliktaki {:s} yildizi gezegen barindirmaktadir.".format(uzaklik, yildizadi))

veri = [ ('Proxima', 1.30, True), 
        ('Alfa Cen A', 1.32, False), 
        ('Alfa Cen B', 1.32, False),
        ('Barnard Yildizi', 1.83, True), 
        ('Wolf 359', 2.59, False), 
        ('Wolf 940', 12.39, True), 
        ('Wolf 503', 42.68, True), 
        ('Wolf 1061', 4.31, True), 
        ('Ross 128', 3.31, True), 
        ('Lalande 21185', 2.55, False), 
        ('GJ 3779', 13.75, True), 
        ('Sirius', 2.64, False), 
        ('Ross 154', 2.98, False), 
        ('Epsilon Eridani', 3.22, True), 
        ('EZ Aqr', 3.40, False), 
        ('Procyon', 3.52, False), 
        ('Tau Ceti', 3.65, True), 
        ('Gliese 832', 4.96, False), 
        ('HD 2685', 198.2, True), 
        ('K2 136', 59.4, True), 
        ('HD 219134', 6.55, True), 
        ('Vega', 7.68, False) ]            

print("d < 5")
print("---------")
gezegenli_yakin_yildizlar(veri)
print("d < 3")
print("---------")
gezegenli_yakin_yildizlar(veri, d=3)
print("d < 20")
print("---------")
gezegenli_yakin_yildizlar(veri, d=20)
d < 5
---------
1.30 uzakliktaki Proxima yildizi gezegen barindirmaktadir.
1.83 uzakliktaki Barnard Yildizi yildizi gezegen barindirmaktadir.
4.31 uzakliktaki Wolf 1061 yildizi gezegen barindirmaktadir.
3.31 uzakliktaki Ross 128 yildizi gezegen barindirmaktadir.
3.22 uzakliktaki Epsilon Eridani yildizi gezegen barindirmaktadir.
3.65 uzakliktaki Tau Ceti yildizi gezegen barindirmaktadir.
d < 3
---------
1.30 uzakliktaki Proxima yildizi gezegen barindirmaktadir.
1.83 uzakliktaki Barnard Yildizi yildizi gezegen barindirmaktadir.
d < 20
---------
1.30 uzakliktaki Proxima yildizi gezegen barindirmaktadir.
1.83 uzakliktaki Barnard Yildizi yildizi gezegen barindirmaktadir.
12.39 uzakliktaki Wolf 940 yildizi gezegen barindirmaktadir.
4.31 uzakliktaki Wolf 1061 yildizi gezegen barindirmaktadir.
3.31 uzakliktaki Ross 128 yildizi gezegen barindirmaktadir.
13.75 uzakliktaki GJ 3779 yildizi gezegen barindirmaktadir.
3.22 uzakliktaki Epsilon Eridani yildizi gezegen barindirmaktadir.
3.65 uzakliktaki Tau Ceti yildizi gezegen barindirmaktadir.
6.55 uzakliktaki HD 219134 yildizi gezegen barindirmaktadir.