Python'da Yıldız İşaretlerinin Kullanımı

Çoğumuz yıldız işaretlerini çarpma ve üs operatörleri olarak kullanırız, ancak Python'da bir ön ek operatörü olarak kullanıldığında çok daha geniş bir kullanım alanına sahiptirler. Bu makaleyi okuduktan sonra yıldız işaretlerinin tüm kullanımını öğrenmiş olacaksınız.

Yıldız işaretlerinin Python'da birçok özel kullanım alanı vardır. Genel olarak çarpma ve üs operatörlerine aşinayız. Farklı durumlarda açma (unpacking), argüman iletme gibi başka işlemler de yapabilir. Önce yıldız işaretlerinin genel kullanımına bakalım.

* ve ** İşaretlerinin Genel Kullanımı

* çarpma operatörü, ** ise üs operatörü olarak kullanılır.

## declaring variables
a, b = 2,3

## multiplication
print("Multiplication of 2 and 3 is {}".format(a * b))

## as power operator
print("2 power 3 is {}".format(a ** b))
Altyapı:

Multiplication of 2 and 3 is 6
2 power 3 is 8
Altyapı:

Artık en genel ve en yaygın yıldız kullanımlarını gördünüz. Ancak muhtemelen bilmediğiniz başka yıldız kullanım alanları da var. Yıldız işaretlerinin gizli kullanımını ortaya çıkarmaya geçelim.

1. * Kullanarak Açma (Unpacking)

* kullanarak bir liste/demet (tuple)/kümeye (set) ait öğelerin açılması. İleride yıldız işaretlerinin bazı diğer özelliklerini uygulamak için açmayı kullanacağız. Açma (unpacking), yıldız işaretlerini ön ek operatörü olarak kullanmanın temel fikridir.

Diyelim ki liste/demet/kümenin ilk elemanını a'ya, kalan elemanlarını ise b'ye atamak istiyoruz. Genelde bunu dilimleme ile yaparız.

## general approach
nums = [i for i in range(1, 6)]
a = nums[0]
b = nums[1:]
print(a, b)

print("--------------------------")

## hard approach
squares = [i ** 2 for i in range(1, 6)]
a = squares[0]
b = []
for i in range(1, len(squares)):
    b.append(squares[i])
print(a, b)
Altyapı:

1 [2, 3, 4, 5]
--------------------------
1 [4, 9, 16, 25]
Altyapı:

Şimdi bunu tek satırda gerçekleştirmek için * operatörünü kullanacağız.

nums = [i for i in range(1, 6)]

## a 1 olur ve b geri kalan elemanları içeren bir liste olur
a, *b = nums
print(a, b)
Altyapı:

1 [2, 3, 4, 5]
Altyapı:

Burada a, listeden tek bir değer alan bir değişken, b ise bir listedir. Açma işlemi, demetler ve kümeler üzerinde de listelerde olduğu gibi çalışır. Bazı örneklere bakalım.

## using tuple
## here first element will assign to a and last element to c
a, *b, c = (1, 2, 3, 4, 5)
print(a, b, c)

print("--------------------------")

## using sets
a, *b, c = {1, 4, 9, 16, 25}
print(a, b, c)
Altyapı:

1 [2, 3, 4] 5
--------------------------
1 [4, 9, 16] 25Altyapı:

1.1. Farklı Yineleyicileri (Iterable) Birleştirme

Açma kullanarak iki farklı yineleyiciyi liste/küme/demet içine ekleyebiliriz. Normalde yineleyicileri dönüştürüp tek bir yapıda birleştirmemiz gerekirdi. Ancak * kullanırsak bu gerekli değildir. Bir örneğe bakalım.

## combining a tuple, list, set
nums = [1, 2, 3]
nums2 = (4, 5, 6)
nums3 = {7, 8, 9}

## we convert the combined elements into any iterable we want
## here i am converting into a list
_list = [*nums, *nums2, *nums3]
_tuple = (*nums, *nums2, *nums3)
_set = {*nums, *nums2, *nums3}

print(type(_list))
print(_list)
print("------------------------")
print(type(_tuple))
print(_tuple)
print("------------------------")
print(type(_set))
print(_set)
Altyapı:

<class 'list'>
[1, 2, 3, 4, 5, 6, 8, 9, 7]
------------------------
<class 'tuple'>
(1, 2, 3, 4, 5, 6, 8, 9, 7)
------------------------
<class 'set'>
{1, 2, 3, 4, 5, 6, 7, 8, 9}Altyapı:

1.2. İç İçe Açma (Nested Unpacking)

İç içe açma, çıkarılan öğelerin ilk düzeyinden elemanları ayıklamaktır. Neden bahsettiğimi görmek için örneğe bakın.

languages = ["Python", "HTML", "CSS", "JS"]

## unpacking
[[first_letter, *remaining], *other] = languages

print(first_letter, remaining, other)
Altyapı:

P ['y', 't', 'h', 'o', 'n'] ['HTML', 'CSS', 'JS']Altyapı:

2. ** Kullanarak Açma (Unpacking)

Daha önce gördüğümüz gibi, ** bir sözlükten (dictionary) öğeleri açmak için kullanılır. Açma sırasında değerleri çıkarmak için sözlüğün anahtarlarını bilmemiz gerekir. Bir örneğe bakalım.

## sample dictionary
person = {"name":"John", "age":19, "year_of_passing":"2021"}
string = "Name:-{name} Year Of Graduation:-{year_of_passing} Age:-{age}".format(**person)
print(string)
Altyapı:

Name:-John Year Of Graduation:-2021 Age:-19
Altyapı:

** kullanarak bir sözlükten öğeleri çıkarmak yaygın değildir.

3. Fonksiyonlarda Yıldız İşaretleri

Kod satırlarını azaltmak için fonksiyonlarda yıldız işaretlerini kullanarak argümanları iletebilir ve yakalayabiliriz.

3.1. Fonksiyonlarda Açma (Unpacking)

* operatörü, bir yineleyiciyi açarak fonksiyonu çağırmak için kullanılır. Diyelim ki bir listemiz var ve bunun tüm elemanlarını print()'e ayrı ayrı geçirmemiz gerekiyor. Ne yaparsınız? Muhtemelen bir döngü düşünüyorsunuz. Ancak * bunu bizim için çok kolaylaştırır.

Yineleyiciyi *yineleyici_adı şeklinde iletin. Yineleyiciyi açar ve tüm elemanları ayrı ayrı geçirir.

nums = [i for i in range(1, 6)]
## passsing list using the *
print(*nums)
Altyapı:

1 2 3 4 5
Altyapı:

nums = (i for i in range(1, 6))
## passsing tuple using the *
print(*nums, sep = ", ")
Altyapı:

1, 2, 3, 4, 5Altyapı:

3.2. Öğeleri Paketleme (Packing)

Paketleme, birden fazla öğeyi aynı anda yakalamak anlamına gelir. Bu özelliği fonksiyon çağrılarında kullanırız.

def average(*nums):
    return sum(nums) / len(nums)
Altyapı:

Artık ortalama hesaplamak için istediğimiz sayıda tamsayı geçebiliriz. average fonksiyonu tüm argümanları bir liste olarak yakalar.

## calling the average with some numbers
print(average(1, 2, 3, 4, 5))
Altyapı:

3.0
Altyapı:

* kullanarak birden çok öğeyi bir listede nasıl yakalayacağımızı gördük. Şimdi ise ** kullanarak çeşitli anahtar-değer çiftlerini nasıl yakalayacağımızı öğreneceğiz.

def _object(name, **properties):
    print(name, properties)

_object("Car", color="Red", cost=999999, company="Ferrari")
Altyapı:

Car {'ceo': 'Louis', 'color': 'Red', 'cost': 999999, 'company': 'Ferrari'}Altyapı:

4. Konumsal Argümanlarla Birlikte Yalnızca-Anahtar Kelime (Keyword-Only) Argümanlar

Adla verilen argümanlara anahtar kelime argümanları denir. Diğer argümanlar ise konumsal (positional) argümanlardır. Önce anahtar kelime (keyword) ve konumsal (positional) argümanlar arasındaki farkı anlamalısınız. Bir örneğe bakalım.

## name is a positional argument
## color and cost are keyword arguments
def sample(car, color = None, cost = None):
    print("Car:-{} Color:-{}, Cost:-{}".format(car, color, cost))
Altyapı:

Bir fonksiyonu çağırırken, anahtar kelime argümanları için parametrenin adını kullanarak argümanları geçebiliriz. Anahtar kelime argümanları için bir şey vermezsek, fonksiyon tanımında sağlanan varsayılan değeri alırlar.

Anahtar kelime argümanlarını anahtarlarla veya argümanların konumuyla belirtebiliriz.

sample("Ferrari", "Red", 999999)
Altyapı:

Car:-Ferrari Color:-Red, Cost:-999999
Altyapı:

sample("Ferrari", cost = 999999, color = "Red")
Altyapı:

Car:-Ferrari Color:-Red, Cost:-999999
Altyapı:

Fonksiyonda tanımlanan adları kullanarak çağırırsak, anahtar kelime argümanlarının sırası önemli değildir.

sample("Ferrari", color = "Green")
Altyapı:

Car:-Ferrari Color:-Green, Cost:-None
Altyapı:

Artık konumsal ve anahtar kelime argümanları hakkında bir fikriniz var. Ana konumuza geçelim.

Yalnızca-Anahtar Kelime argümanlar sadece anahtarlarla belirtilir. Daha önce gördüğümüz gibi konumsal olarak ayarlanamazlar. Yalnızca-anahtar kelime argümanlarını yakalamak için * argümanlarından sonra anahtar kelime argümanlarını bildirmeliyiz.

def keyword_only(*items, _list, default = False):
    print(items)
    print(_list)
    print(default)
Altyapı:

*items'tan sonra geldikleri için fonksiyonu çağırırken _list ve default anahtarlarını kullanmak zorundayız. Onları çağırmak için anahtarları kullanmazsak hata alırız. Her iki duruma da bakalım.

nums = [i ** 2 for i in range(1, 6)]
## calling the function
keyword_only(1, 2, 3, 4, 5, _list = nums, default = True)
Altyapı:

(1, 2, 3, 4, 5)
[1, 4, 9, 16, 25]
True
Altyapı:

Fonksiyon keyword_only'yi konumsal argümanlarla çağırırsak ne olur?

nums = [i ** 2 for i in range(1, 6)]
## calling the function will raise an error
keyword_only(1, 2, 3, 4, 5, nums, False)
Altyapı:

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-85-bf737d8a8bfc> in <module>()
      1 nums = [i ** 2 for i in range(1, 6)]
----> 2 keyword_only(1, 2, 3, 4, 5, nums, False)


TypeError: keyword_only() missing 1 required keyword-only argument: '_list'
Altyapı:

Gerekli bir yalnızca-anahtar kelime argümanının eksik olduğunu belirten bir hata aldık. Bu nedenle, yalnızca-anahtar kelime argümanlarını çağırırken anahtarları kullanmalıyız. Yalnızca-Anahtar Kelime argümanlar, fonksiyonlarda * argümanlarından sonra tanımlanır.

5. Konumsal Argümanlar Olmadan Yalnızca-Anahtar Kelime Argümanlar

Eğer herhangi bir konumsal argüman olmadan yalnızca Yalnızca-Anahtar Kelime argümanları kabul etmek istiyorsak, Python bunu başarmak için fonksiyon parametrelerinde * kullanılmasına izin verir. Bir örneğe bakalım.

def _sample(*, name):
    print(name)
Altyapı:

Yukarıdaki fonksiyon yalnızca yalnızca-anahtar kelime argümanları alır. Argümanı anahtar kelimeyle geçirmemiz gerekir. Aksi halde hata alırız. Fonksiyon tanımındaki * işareti, fonksiyonun argümanları yalnızca anahtar kelimeler ile almasını garanti eder. Fonksiyondaki * parametresinden sonra tanımladığımız tüm parametreler, fonksiyon çağrısı sırasında anahtar kelimelerle belirtilmelidir.

## calling the function using keyword 'name'
_sample(name = "Datacamp")
Altyapı:

Datacamp
Altyapı:

## calling the function without using keyword 'name'
## we will get a TypeError
_sample("Datacamp")
Altyapı:

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-fe0d3718b56c> in <module>()
      1 ## calling the function without using keyword 'name'
      2 ## we will get a TypeError
----> 3 samp("Datacamp")


TypeError: samp() takes 0 positional arguments but 1 was given
Altyapı:

_sample() fonksiyonunun yalnızca yalnızca-anahtar kelime* argümanları aldığı açıktır.

Sonuç

Geliştiriciler Python'un her yeni sürümünde yeni özellikler ekliyor. Yıldız işaretleri özeldir ve kodun bazı kısımlarını kısaltır. * olmadan birden çok konumsal argümanı kabul edemeyiz ve yalnızca-anahtar kelime argümanları da bu özelliği uygulamak için * gerektirir. Yıldız işaretlerinin diğer işlemleri, birden fazla satır kodla da elde edilebilir. Tam olarak anlamak için pratik yapın. Okuduğunuz için teşekkürler!

Python hakkında daha fazla bilgi edinmek isterseniz, DataCamp'in Python Data Science Toolbox (Bölüm 1) kursunu alın.

Keyifli Kodlamalar :)