0% found this document useful (0 votes)

10 views56 pages

Python

Uploaded by

Enes Kaya

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

10 views56 pages

Python

Uploaded by

Enes Kaya

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

(*) Python Versiyon Görme:

------------------>
/commandline> python --version
------------------>

(*) Python Dosyasını Çalışırma:

------------------>
/commandline> python [Link]
------------------>

(*) Python Yorum Satırı:

------------------>
# Bu bir yorum satırı

"""
Bu bir yorum alanı
"""
------------------>

(*) Python Değişkenler:

------------------>
x = 5 # Bu bir değişkendir
------------------>

------------------>
x = 5
x = "Hello world"
print(x)

# Bize çıktı olarak 'Hello world' yazısı gelir

------------------>

------------------>
x = int(3) # değişken 3'tür

x = float(3) # değişken 3.0'dır

x = str(3) # değişken "3"tür

------------------>
------------------>
x = 4.932
type(x)

# x değişkeninin tipini döndürür

------------------>

------------------>
"var" ile 'var' arasında fark yoktur
------------------>

------------------>
a değişkeni ile A değişkeni farklıdır
------------------>

------------------------>
!- Değişken ismi sayı ile başlayamaz => 2var = "Hello world"

!- Değişken isminde "-" olamaz => var-me = "Hello world"

!- Değişken isminde boşluk olamaz => var me = "Hello world"

------------------------>

Sorunsuz Değişken İsmi Örnekleri:

------------------------>
myvar = "John"
my_var = "John"
_my_var = "John"
myVar = "John"
MYVAR = "John"
myvar2 = "John"
------------------------>

Değişkenlere Çoklu Değerler:

------------------------>
x, y, z = "Orange", "Banana", "Cherry"
------------------------>
x = "Orange"
y = "Banana"
z = "Cherry"
------------------------>

Yukarıdaki iki farklı tanımlama aynıdır

------------------------>
------------------------>
fruits = ["Orange", "banana", "cherry"]
x, y, z = fruits
------------------------>
x = "Orange"
y = "Banana"
z = "Cherry"
------------------------>

Yukarıdaki iki farklı tanımlama aynıdır

------------------------>

------------------------>
Integer Değişkeni:

(+) Tamsayı
------------------------>
x = 10
y = -10
# x'de y'de integer'dır
------------------------>

------------------------>
Float Değişkeni:

(+) Ondalıkla ifade edilen sayılar

------------------------>
x = 10.0
y = -10.0
# x'de y'de float'dır
------------------------>

------------------------>
Complex Değişkeni:

(+) Reel sayı olmayan karmaşık sayılardır

------------------------>
x = 5j
y = -5j
# x'de y'de complex'dir
------------------------>

Değişken Tipi Dönüşümleri:

------------------------>
x = 10
y = 28.3
z = 2j
------------------------>
------------------------>
Integer'dan Float'a:

x = float(x)
------------------------>

------------------------>
Float'dan Integer'a:

(+) Bu dönüşümde ondalıklı kısım atılır. Mesela değişken 5.8 ise dönüşümden sonra 5
olur

y = int(y)
------------------------>

------------------------>
Integer'dan Complex'e:

(+) Bu Dönüşümde değeri 10 olan değişken (10 + 0j) olur

a = int(x)
------------------------>

(*) Stringler:

------------------------>
(+) iki tırnağın arasında olan değerlere string denir örneğin "elma" ve 'elma'
string'dir

print("elma")

Yukarıdaki gibi bir stringin değerinin ne olduğunu öğrenmek için print kullanılır
------------------------>

------------------------>
!- "bana "selam" dedi" => çift tırnağın içinde çift tırnak kullanılmaz
!- 'bana 'selam' dedi' => tek tırnağın içinde tek tırnak kullanılmaz

/- "bana 'selam' dedi" => çift tırnağın içinde tek tırnak kullanılır
/- 'bana "selam" dedi' => tek tırnağın içinde çift tırnak kullanılır
------------------------>
------------------------>
(+) bir çok satırlı bir string yazmak için üç çift tırnak veya üç tek tırnak
kullanılır

paragraph = """ jelgjnrer grgrekrortnghktr gtokr gtktrlg htrlkgk ktlr grghrlg

htrlkgk

jhfenrjlırekfmogkrmelgkregergolrkgrlkmgmktklrgmnglmkrtçtmgtlrçglkmgrlmrtgk
fjrejgnmkerlgmrkegrklgıtrmgkegklregrekgemglerkmgkrmgrkmgreklmgkrmgkmgk
"""

print(paragraph)
------------------------>

------------------------>
(+) stringlerdeki harfleri tek tek yazdırabilirsin(index 0'dan başlar)

name = "enes"

first_letter = name[0] # bu değişken 'e' harfine karşılık gelir

second_letter = name[1] # bu değişken 'n' harfine karşılık gelir
third_letter = name[2] # bu değişken 'e' harfine karşılık gelir
fourth_letter = name[3] # bu değişken 's' harfine karşılık gelir
------------------------>

------------------------>
(+) stringlerin kaç karakterden oluştuğunu görmek için len kullanılır

name = "Enes Batu Kaya"

print(len(name))

# 14 sayısını yazdırır
------------------------>

Stringleri Dilimleme(Slicing)

------------------------>
message = "Hello, World!"
------------------------>

------------------------>
print(message[:5])

# Çıktısı 'Hello' olur

Yukarıda message[:5] baştan 0'dan başlayarak 5. karaktere kadar(5 dahil değil)

yazdırır
------------------------>

------------------------>
print(message[2:])

# Çıktısı 'llo, World!' olur

Yukarıda message[2:] sıfırdan başlayarak baştan ikinci index dahil sonrasını

yazdırır
------------------------>

Stringleri Modifiye Etme:

------------------------>
message = "Hello, World!"
------------------------>

------------------------>
print([Link]())

# Çıktısı 'HELLO, WORLD!' olur

Yukarıda [Link]() bütün karakterleri büyük yapar

------------------------>

------------------------>
print([Link]())

# Çıktısı 'hello, world!' olur

Yukarıda [Link]() bütün karakterleri küçük yapar

------------------------>

------------------------>
whitespace = " Hello, World! "
------------------------>
------------------------>
print([Link]())

# Çıktısı 'Hello, World!' olur

Yukarıdaki [Link]() asıl içerikten önce ve sonra gelen bütün boşlukları

stringlerdeki
------------------------>

------------------------>
print([Link]("H", "J"))

# Çıktısı "Jello, World!" olur

Yukarıdaki [Link]("H", "J") stringdeki bütün 'H' karakterlerini 'J'

karakterine dönüştürür
------------------------>

------------------------>
print([Link](","))

# Çıktısı ['Hello', 'World!'] olur

Yukarıdaki [Link](",") parantez içinde belirtilen karakterden önceyi ve

sonrayı ikiye böler
------------------------>

Stringleri Birleştirmek:

------------------------>
x = "Hello"
y = "World"
z = x + y
print(z)

# Çıktısı 'HelloWorld' olur

------------------------>

Format Strings:

------------------------>
age = 18
text = f"Hello, I'm {age} years old"
print(text)

# Çıktısı 'Hello, I'm 18 years old' olur

------------------------>

(*) Operatörler

Atama Operatörleri:

--------------------------------------------->
x = 5 <-> x = 5

x = x + 3 <-> x += 3

x = x -3 <-> x -= 3

x = x * 3 <-> x *= 3

x = x / 3 <-> x /= 3

x = x % 3 <-> x %= 3

x = x // 3 <-> x //= 3

x = x ** 3 <-> x **= 3
--------------------------------------------->

Karşılaştırma Operatörleri:

--------------------------------------------->
x == y => x ile y eşittir

x != y => x ile y eşit değildir

x > y => x büyüktür y

x < y => x küçüktür y

x >= y => x büyük eşittir y

x <= y => x küçük eşittir y

--------------------------------------------->

Mantıksal Operatörler:
--------------------------------------------->
x < 6 and x > 3 => Eğer iki ifade de doğruysa True döndürür değilse False
döndürür

x < 6 or x > 3 => Eğer ifadelerden her hangi biri doğruysa True döndürür yok
eğer iki ifade de yanlış ise False döndürür

not(x < 6 or x > 3 )=> Eğer ifadelerden her hangi biri doğruysa False döndürür yok
eğer iki ifade de yanlış ise True döndürür
--------------------------------------------->

Kimlik Operatörleri:

--------------------------------------------->
(+) Kimlik operatörleri değişkenlerin birbirine eşit olup olmadığını değil hafızada
aynı konumda bulunup bulunmadıklarını kontrol eder

x is y => ikiside aynı obje ise True döndürür

x is not y => ikiside aynı obje değilse True döndürür

--------------------------------------------->

Üyelik Operatörleri:

--------------------------------------------->
x in y => eğer x'in içinde y varsa True döndürür

x not in y => eğer x'in içinde y yoksa True döndürür

--------------------------------------------->

(*) Listeler:

--------------------------------------------->
mylist = ["apple", "banana", "cherry"]

print(mylist)

# Çıktısı ['apple', 'banana', 'cherry']

--------------------------------------------->

--------------------------------------------->
(+) Listenin elemanları sırasıyla: sıfırıncı eleman, birinci eleman...
--------------------------------------------->
--------------------------------------------->
(+) Listeye bir eleman eklediğinde listenin elemanlarının sırası değişmez
--------------------------------------------->

--------------------------------------------->
(+) Listeye eleman ekleyebilir, değiştirebilir ve silebilirsin,
--------------------------------------------->

--------------------------------------------->
(+) Listede aynı değere sahip farklı elemanlar olabilir

Örneğin: print(bool(thelist[3] == thelist[89]))

# Çıktısı True olabilir

--------------------------------------------->

--------------------------------------------->
(+) Listede kaç eleman olduğunu len(thelist) diyerek bulabilirsin
--------------------------------------------->

--------------------------------------------->
(+) Liste elemanları int, str, bool,... vs. her türlü veri tipi olabilir
--------------------------------------------->

--------------------------------------------->
(&) Farklı bir liste oluşturma yöntemi
|
|> thelist = list((1, 2, 3))
--------------------------------------------->

Liste Elemanlarına Erişmek:

--------------------------------------------->
thislist = ["apple", "banana", "cherry"]
print(thislist[1])

# 'banana' yazdırır
--------------------------------------------->

Negatif Sıralama:
--------------------------------------------->
(+) [-1] son elemandır, [-2] sondan ikinci elemandır, [-3] ...

thislist = ["apple", "banana", "cherry"]

print(thislist[-1])

# cherry yazdırır
--------------------------------------------->

Aralıklı Sıralama:

--------------------------------------------->
(/) thislist[x:y] => sıfırdan başlayarak x'inci sıradan(x dahil) y'inci sıraya
kadar(y dahil değil) olan aralık yazdırılır

Mesela x = 2 ve y = 5 olsun:

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]

print(thislist[2:5])

# ['cherry', 'orange', 'kiwi'] yazdırır

Bu durumda 2. index, 3. index ve 4. index yazdırılır

--------------------------------------------->

--------------------------------------------->
(+) thislist[0:4] yazmak ile thislist[:4] yazmak aynı sonucu verir. İkisinde de
baştan ilk sıradan(0. sıradan) 4. sıra(dahil değil) aralığı yazdırılır

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]

print(thislist[:4])

# ['apple', 'banana', 'cherry', 'orange'] yazdırır

--------------------------------------------->

--------------------------------------------->
(+) thislist[2:], sıfırdan başlayan sıralamada 2. sırada yer alan eleman ile(o
eleman dahil aralığa) listenin sonuna kadar olan aralığı belirtir

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]

print(thislist[2:])

# ['cherry', 'orange', 'kiwi', 'melon', 'mango'] yazdırır

--------------------------------------------->

Liste Elamanlarını Değerlerini Değiştirmek:

--------------------------------------------->
(+) thislist[x] ifadesinde x yerine değerini değiştirmek istediğiniz elemanın sıra
numarasını yazıp istediğiniz değeri eşitlik ifadesiyle verebilirsiniz

thislist = ["apple", "banana", "cherry"]

thislist[1] = "blackcurrant"
print(thislist)

# ['apple', 'blackcurrant', 'cherry'] yazdırır

--------------------------------------------->

Liste Elemanlarının Belli Bir Aralağının Değerlerini Değiştirmek:

--------------------------------------------->
(+) 'thislist' adlı liste değişkeninin sıfırdan başlayan sıralamada 1. ve 2.
sıranın elemanlarının değerlerini değiştirmek için o iki değere karşılık gelecek
iki yeni değer veriyoruz yalnız önemli nokta listenin eleman sayısı veya diğer
liste elemanlarının sıralamaları değişmiyor

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "mango"]

thislist[1:3] = ["blackcurrant", "watermelon"]
print(thislist)

# ['apple', 'blackcurrant', 'watermelon', 'orange', 'kiwi', 'mango'] yazdırır

--------------------------------------------->

Tek Bir Liste Elemanının Yerine İki Farklı yeni Eleman Eklemek:

--------------------------------------------->
(+) 'thislist' adlı liste değişkeninin sıfırdan başlayan sıralamada sıfırla iki
arasındaki elemanın yerine iki farklı yeni eleman ekleniyor ancak bunun sonucunda
listenin eleman sayısı ve listenin elemanlarının sıra numaraları değişiyor!

thislist = ["apple", "banana", "cherry"]

thislist[1:2] = ["blackcurrant", "watermelon"]
print(thislist)

# ['apple', 'blackcurrant', 'watermelon', 'cherry'] yazdırır

--------------------------------------------->

Listeye Insert Etmek:

--------------------------------------------->
(+) insert metodunu kullanarak spesifik bir sıra numarasına bir eleman
ekleyebilirsin

thislist = ["apple", "banana", "cherry"]

[Link](2, "watermelon")
print(thislist)
# ['apple', 'banana', 'watermelon', 'cherry'] yazdırır
--------------------------------------------->

Listeye Append Etmek:

--------------------------------------------->
(+) append() metodu kullanıldığı zaman listenin sonuna belirtilen eleman eklenir

thislist = ["apple", "banana", "cherry"]

[Link]("orange")
print(thislist)

# ['apple', 'banana', 'cherry', 'orange'] yazdırır

--------------------------------------------->

Listeye Extend Etmek

--------------------------------------------->
(+) extend() metodu kullanıldığı zaman parantez içindeki listenin, tuple'nin,
set'in, dictionary'nin vs.'nin elemanları ana listenin sonuna eklenir

thislist = ["apple", "banana", "cherry"]

tropical = ["mango", "pineapple", "papaya"]
[Link](tropical)
print(thislist)

# ['apple', 'banana', 'cherry', 'mango', 'pineapple', 'papaya'] yazdırır

--------------------------------------------->

Herhangi Bir değeri Listeden Silmek

--------------------------------------------->
(+) remove() metodu kullanıldığı zaman parantez içinde belirtilen değere sahip
liste elemanı veya sıra numarası en küçük olan liste elemanını listeden siler

thislist = ["apple", "banana", "cherry"]

[Link]("banana")
print(thislist)

# ['apple', 'cherry'] yazdırır

--------------------------------------------->

Belirli Bir Sıra Numarasındaki Elemanı Listeden Silmek

--------------------------------------------->
(+) pop(x) metodu kullanıldığı zaman parantez içinde yazan sıra numarasındaki
eleman listeden siler

thislist = ["apple", "banana", "cherry"]

[Link](1)
print(thislist)

# ['apple', 'cherry'] yazdırır

--------------------------------------------->

Listenin Son Elemanını Silmek

--------------------------------------------->
(+) pop() metodu eğer parentez içi boş ise listenin son elemanını siler

thislist = ["apple", "banana", "cherry"]

[Link]()
print(thislist)

# ['apple', 'banana'] yazdırır

--------------------------------------------->

Belirli Bir Sıra Numarasındaki Elemanı Listeden Silmek 2

--------------------------------------------->
(+) del list[x] kullanıldığı zaman x sıra numarasında bulunan elemanı listeden
siler

thislist = ["apple", "banana", "cherry"]

del thislist[0]
print(thislist)

# ['banana', 'cherry'] yazdırır

--------------------------------------------->

Bütün Bir Listeyi Silmek

--------------------------------------------->
thislist = ["apple", "banana", "cherry"]
del thislist
print(thislist)

# NameError: name 'thislist' is not defined yazdırır

--------------------------------------------->

Listenin Bütün Elemanlarını Silme

--------------------------------------------->
thislist = ["apple", "banana", "cherry"]
[Link]()
print(thislist),

# [] yazdırır
--------------------------------------------->

Listenin Sıralamasını Alfabetik Yapma

--------------------------------------------->
thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]
[Link]()
print(thislist)

# ['banana', 'kiwi', 'mango', 'orange', 'pineapple'] yazdırır

--------------------------------------------->

Listenin Sıralamasını Küçükten Büyüğe Doğru Yapma

--------------------------------------------->
thislist = [100, 50, 65, 82, 23]
[Link]()
print(thislist)

# [23, 50, 65, 82, 100] yazdırır

--------------------------------------------->

Listenin Sıralamasını Alfabetik Sıralamanın Tersi Yapma

--------------------------------------------->
thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]
[Link](reverse = True)
print(thislist)

# ['pineapple', 'orange', 'mango', 'kiwi', 'banana'] yazdırır

--------------------------------------------->

Listenin Sıralamasını Büyükten Küçüğe Yapma

--------------------------------------------->
thislist = [100, 50, 65, 82, 23]
[Link](reverse = True)
print(thislist)

# [100, 82, 65, 50, 23] yazdırır

--------------------------------------------->
Özelleştirilmiş Liste Sıralaması

--------------------------------------------->
(+) Belirtilen fonksiyonu liste elemanları üzerinde uygular ve çıkan sonuca göre
küçükten büyüğe doğru ORİJİNAL değerleri sıralar

def myfunc(n):
return abs(n - 50)

thislist = [100, 50, 65, 82, 23]

[Link](key = myfunc)
print(thislist)

# [50, 65, 23, 82, 100] yazdırır

--------------------------------------------->

Büyük Harflere Duyarlı Liste Sıralaması

--------------------------------------------->
(+) Büyük harfle başlayan elemanlar küçük harfle başlayan elemanlardan önce gelicek
şekilde liste oluşturulur

thislist = ["banana", "Orange", "Kiwi", "cherry"]

[Link]()
print(thislist)

# ['Kiwi', 'Orange', 'banana', 'cherry'] yazdırır

--------------------------------------------->

Büyük Harlere Duyarlı Olmayan Liste Sıralaması

--------------------------------------------->
thislist = ["banana", "Orange", "Kiwi", "cherry"]
[Link](key = [Link])
print(thislist)

# ['banana', 'cherry', 'Kiwi', 'Orange'] yazdırır

--------------------------------------------->

Listenin Elemanlarının Sıralamasını Tersine Çevirme

--------------------------------------------->
thislist = ["banana", "Orange", "Kiwi", "cherry"]
[Link]()
print(thislist)
# ['cherry', 'Kiwi', 'Orange', 'banana'] yazdırır
--------------------------------------------->

Listenin Bir Kopyasını Oluşturma

--------------------------------------------->
thislist = ["apple", "banana", "cherry"]
mylist = [Link]()
print(mylist)

# ['apple', 'banana', 'cherry'] yazdırır

--------------------------------------------->

Listenin Bir Kopyasını Oluşturma 2

--------------------------------------------->
thislist = ["apple", "banana", "cherry"]
mylist = list(thislist)
print(mylist)

# ['apple', 'banana', 'cherry'] yazdırır

--------------------------------------------->

Listenin Bir Kopyasını Oluşturma 3

--------------------------------------------->
thislist = ["apple", "banana", "cherry"]
mylist = thislist[:]
print(mylist)

# ['apple', 'banana', 'cherry'] yazdırır

--------------------------------------------->

İki Listeyi Birleştirme

--------------------------------------------->
list1 = ["a", "b", "c"]
list2 = [1, 2, 3]

list3 = list1 + list2

print(list3)

# ['a', 'b', 'c', 1, 2, 3] yazdırır

--------------------------------------------->
İki Listeyi Birleştirme 2

--------------------------------------------->
list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

for x in list2:
[Link](x)

print(list1)

# ['a', 'b', 'c', 1, 2, 3] yazdırır

--------------------------------------------->

İki Listeyi Birleştirme 3

--------------------------------------------->
list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

[Link](list2)
print(list1)

# ['a', 'b', 'c', 1, 2, 3] yazdırır

--------------------------------------------->

List Comprehension

--------------------------------------------->
fruits = ["Banana","Apple","Strawberry","Lemon","Pineapple"]

1. Yol:

newlist = []
for x in fruits:
if x != "Apple":
[Link](x)

# ['Banana', 'Strawberry', 'Lemon', 'Pineapple'] yazdırır

2. Yol:

newlist = [x for x in fruits if x != "Apple"]

# ['Banana', 'Strawberry', 'Lemon', 'Pineapple'] yazdırır

--------------------------------------------->
(*) Tuple'lar

--------------------------------------------->
(+) Tuple'ların sıralması listelerde olduğu gibi sıfırdan başlar yani ilk elemanı
[0] ile gösteririz
(+) Tuple'ların sıralaması veya elemanları kesinlikle değişikliğe uğratılamaz,
elemanlar silinemez ve tuple oluşturulduktan sonra yeni eleman eklenemz
(+) Tuple'lara aynı değere sahip elemanlar koyulabilir

1. Tuple Oluşturma Yolu:

thistuple = ("apple", "banana", "cherry")

print(thistuple)

# ('apple', 'banana', 'cherry') yazdırır

2. Tuple Oluşturma Yolu:

(+) iç içe iki parantez kullanılır

thistuple = tuple(("apple", "banana", "cherry"))

print(thistuple)

# ('apple', 'banana', 'cherry') yazdırır

--------------------------------------------->

Tek Elemeanlı Tuple Oluşturmak

--------------------------------------------->
(!) Yanlış Yol:

thistuple = ("apple")
print(type(thistuple))

# <class 'str'> yazdırır

(+) Doğru Yol:

thistuple = ("apple",)
print(type(thistuple))

# <class 'tuple'> yazdırır

--------------------------------------------->

--------------------------------------------->
(+) Tuple'lara ulaşmak, yazdırmak ve belli bir aralığı seçmek için listelerde
kullanılan yolların aynısı kullanılır
--------------------------------------------->

Tuple'ın Elemanlarının Değerlerini Değiştirmek!

--------------------------------------------->
(+) Tuple'ı ilk önce list'e dönüştürüp ardından listenin değerini değiştirip en son
olarakda o listeyi tekrar tuple'ye dönüştürebilirsin

x = ("apple", "banana", "cherry")

y = list(x)
y[1] = "kiwi"
x = tuple(y)

print(x)

# ("apple", "kiwi", "cherry") yazdırır

--------------------------------------------->

Tuple'a Eleman Eklemek

--------------------------------------------->
1. Yol:

(+) Tuple'ı ilk önce listeye dönüştürüp sonra append() metodu ile listeye istenilen
elemanı ekleyip en son olarak o liste tekrardan tuple'a dönüştürülebilir

thistuple = ("apple", "banana", "cherry")

y = list(thistuple)
[Link]("orange")
thistuple = tuple(y)

2. Yol

(+) Yeni bir Tuple Oluşturup ana tuple'yi oluşturulan yeni tuple ile'+' operatörü
yardımıyla birleştirebilirsin

thistuple = ("apple", "banana", "cherry")

y = ("orange",)
thistuple += y

print(thistuple)
--------------------------------------------->

Unpacking Tuples

--------------------------------------------->
(+) Bu şekilde bir tuple'nin elemanlarını tekrardan eski ilk değişken haline
döndürüp kullanabilirsin

fruits = ("apple", "banana", "cherry")

(green, yellow, red) = fruits

print(green)
print(yellow)
print(red)

# apple
# banana
# cherry yazdırır
--------------------------------------------->

Asterisk For Unpacking Tuples

--------------------------------------------->
(+) Eğer x elemanlı bir tuple'ı x - y adet değişkene unpack etmek istiyorsan en son
değişkenin adının başına yıldız koyarak o değişkeni list yapabilirsin

fruits = ("apple", "banana", "cherry", "strawberry", "raspberry")

(green, yellow, *red) = fruits

print(green)
print(yellow)
print(red)

# apple
# banana
# ['cherry', 'strawberry', 'raspberry'] yazdırır

(+) Eğer yıldızlı değişkeni sona değilde ortaya koyacak olursanız sondaki ve
baştaki
fruits = ("apple", "mango", "papaya", "pineapple", "cherry")

(green, *tropic, red) = fruits

print(green)
print(tropic)
print(red)

# apple
# ['mango', 'papaya', 'pineapple']
# cherry yazdırır
--------------------------------------------->

Tuple'ı Çarpmak

--------------------------------------------->
(+) tuple içinde kaç eleman varsa o elemanlardan hangi sayıyla çarpılıyorsa o kadar
kat daha konulur

fruits = ("apple", "banana", "cherry")

mytuple = fruits * 2

print(mytuple)

# ('apple', 'banana', 'cherry', 'apple', 'banana', 'cherry') yazdırır

--------------------------------------------->

count() Metodu

--------------------------------------------->
(+) count() metodu içinde belirtilen değer tuple içinde kaç kez tekrar edilmiş onu
döndürür

thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)

x = [Link](5)

print(x)

# 2 yazdırır
--------------------------------------------->

index() Metodu

--------------------------------------------->
(+) index() metodu içine yazılan değerin ilk defa kaçıncı sırada ortaya çıktığını
yazdırır

thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)

x = [Link](8)

print(x)

# 3 yazdırır
--------------------------------------------->

(*) Set'ler

--------------------------------------------->
(+) Set elemanlarının belli bir sıralaması yoktur her print ettirdiğinde farklı
sırada gözükür
(+) Set elemanları bir kere set oluşturulduktan sonra değiştirilemez ancak yeni bir
eleman eklenebilir veya var olan bir eleman silinebilir
(+) Set elemanlarının her birinin değeri farklı olmalıdır mesela değeri 3 olan
birden fazla eleman olamaz
(+) Setlerde 1 ve True ile 0 ve False değerleri eşittir

1. Oluşturma yöntemi:

thisset = {"apple", "banana", "cherry"}

print(thisset)

# Çıktısı tamamen rastgele olur

2. Oluşturma Yöntemi:

thisset = set(("apple", "banana", "cherry"))

print(thisset)

# Çıktısı tamamen rastgele olur

--------------------------------------------->

Set Elemanlarının Hepsini Yazdır

--------------------------------------------->
thisset = {"apple", "banana", "cherry"}

for x in thisset:
print(x)

# Set elemanlarının hepsini tamamen rastgele bir sırada yazdırır

--------------------------------------------->

Set İçinde Belli Bir Değerde Eleman Var Mı Görmek

--------------------------------------------->
thisset = {"apple", "banana", "cherry"}

print("banana" in thisset)

# True yazdırır
--------------------------------------------->

Set'e Bir Adet Eleman Eklemek

--------------------------------------------->
thisset = {"apple", "banana", "cherry"}

[Link]("orange")

print(thisset)
# {'banana', 'apple', 'cherry', 'orange'} yazdırır
--------------------------------------------->

Elimizdeki Set'e Başka Bir Set'in Bütün Elemanlarını Eklemek

--------------------------------------------->
thisset = {"apple", "banana", "cherry"}
tropical = {"pineapple", "mango", "papaya"}

[Link](tropical)

print(thisset)

# {'apple', 'mango', 'cherry', 'pineapple', 'banana', 'papaya'} yazdırır

--------------------------------------------->

Elimizdeki Set'e Başka Bir Tuple, List Veya Dictionary'nin Elemanlarını Eklemek

--------------------------------------------->
thisset = {"apple", "banana", "cherry"}
mylist = ["kiwi", "orange"]

[Link](mylist)

print(thisset)

# {'banana', 'cherry', 'apple', 'orange', 'kiwi'} yazdırır

--------------------------------------------->

Set'in Bir Adet Elemanını Silmek

--------------------------------------------->
(!) Eğer belirtilen değere sahip bir eleman yoksa hata döndürür

thisset = {"apple", "banana", "cherry"}

[Link]("banana")

print(thisset)

# {'cherry', 'apple'} yazdırır

--------------------------------------------->

Set'in Bir Adet Elemanını Silmek 2

--------------------------------------------->
thisset = {"apple", "banana", "cherry"}

[Link]("banana")

print(thisset)

# {'cherry', 'apple'} yazdırır

--------------------------------------------->

Set'in İçindeki Bütün Elemanları Silmek

--------------------------------------------->
thisset = {"apple", "banana", "cherry"}

[Link]()

print(thisset)

# set() yazdırır
--------------------------------------------->

Set Değişkenini Komple Silmek

--------------------------------------------->
thisset = {"apple", "banana", "cherry"}

del thisset

print(thisset)

# NameError: name 'thisset' is not defined yazdırır

--------------------------------------------->

union() Metodu İle İki Set'i Birleştirme

--------------------------------------------->
1. Yol:

set1 = {"a", "b", "c"}

set2 = {1, 2, 3}

set3 = [Link](set2)
print(set3)

# {'c', 'a', 1, 2, 3, 'b'} yazdırır

2. Yol:

set1 = {"a", "b", "c"}

set2 = {1, 2, 3}

set3 = set1 | set2

print(set3)

# {'c', 'a', 1, 2, 3, 'b'} yazdırır

(+) Birden Fazla Set'i Birleştirmek

1. Yol:

set1 = {"a", "b", "c"}

set2 = {1, 2, 3}
set3 = {"John", "Elena"}
set4 = {"apple", "bananas", "cherry"}

myset = [Link](set2, set3, set4)

print(myset)

# {'a', apple, banana, 1, Elena, 'b', John, 3, cherry, 2, 'c'} yazdırır

2. Yol:

set1 = {"a", "b", "c"}

set2 = {1, 2, 3}
set3 = {"John", "Elena"}
set4 = {"apple", "bananas", "cherry"}

myset = set1 | set2 | set3 |set4

print(myset)

# {'a', apple, banana, 1, Elena, 'b', John, 3, cherry, 2, 'c'} yazdırır

--------------------------------------------->

Bir Set ile Başka Bir Veri Taipini Birleştirmek

--------------------------------------------->
(!) '|' işareti sadece set'leri birleştirmek için kullanılır

x = {"a", "b", "c"}

y = (1, 2, 3)

z = [Link](y)
print(z)

# {'c', 3, 'a', 2, 'b', 1} yazdırır

--------------------------------------------->

Set'e Başka Bir Set'in Elemanlarını Eklemek

--------------------------------------------->
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

[Link](set2)
print(set1)

# {1, 2, 'a', 'b', 'c', 3} yazdırır

--------------------------------------------->

Set'lerin Kesişim Noktasını Yeni Bir Set Yapmak

--------------------------------------------->
1. Yol:

(!) Sadece setlerin kesişim noktasını değil aynı zamanda bir setle herhangi başka
bir değişkenin kesişim noktasını göstermek için de kullanılır

set1 = {"apple", "banana", "cherry"}

set2 = {"google", "microsoft", "apple"}

set3 = [Link](set2)
print(set3)

# {'apple'} yazdırır

2. Yol:

(!) Sadece setlerin kesişim noktası için kullanılır

set1 = {"apple", "banana", "cherry"}

set2 = {"google", "microsoft", "apple"}

set3 = set1 & set2

print(set3)

# {'apple'} yazdırır
--------------------------------------------->

Set'lerin Kesişim Noktasını Yeni Bir Set Oluşturmadan Döndürmek

--------------------------------------------->
(+) Yeni bir set oluşturulmaz, sadece var olan setlerden birinin içindeki tüm
elemanlar silinir ve içine kesişim elemanları konulur

set1 = {"apple", "banana", "cherry"}

set2 = {"google", "microsoft", "apple"}

set1.intersection_update(set2)

print(set1)

# {'apple'} yazdırır
--------------------------------------------->

Birinci Set'de Bulunan Ancak İkinci Set'de Bulunmayan Elemanları Döndürür

--------------------------------------------->
1. Yol:

set1 = {"apple", "banana", "cherry"}

set2 = {"google", "microsoft", "apple"}

set3 = [Link](set2)

print(set3)

# {'banana', 'cherry'} yazdırır

2. Yol:

(!) Sadece set'ler arasında kullsanılır

set1 = {"apple", "banana", "cherry"}

set2 = {"google", "microsoft", "apple"}

set3 = set1 - set2

print(set3)

# # {'banana', 'cherry'} yazdırır

--------------------------------------------->

Setler Arasındaki Farkı Halihazırda Var Olan Set İçine Yazmak

--------------------------------------------->
set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}

set1.difference_update(set2)

print(set1)
--------------------------------------------->

Setlerin Ortak Olmayan Bütün Elemanlarını Döndürme

--------------------------------------------->
1. Yol:

set1 = {"apple", "banana" , "cherry"}

set2 = {"google", "microsoft", "apple"}

set3 = set1.symmetric_difference(set2)
print(set3)
# {'google', 'banana', 'microsoft', 'cherry'} yazdırır

2. Yol:

(!) Sadece set'ler arasında kullanılır

set1 = {"apple", "banana", "cherry"}

set2 = {"google", "microsoft", "apple"}

set3 = set1 ^ set2

print(set3)

# {'google', 'banana', 'microsoft', 'cherry'} yazdırır

--------------------------------------------->

Setlerin Ortak Olmayan Bütün Elemanlarını Halihazırda Varolan Bir Set'de Döndürme

--------------------------------------------->
set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}

set1.symmetric_difference_update(set2)

print(set1)

# {'google', 'banana', 'microsoft', 'cherry'} yazdırır

--------------------------------------------->

(*) If Elif Else

--------------------------------------------->
a = 33
b = 200
if b > a:
print("b is greater than a")

# b is greater than a yazdırır

--------------------------------------------->

Elif

--------------------------------------------->
(+) Eğer if ile ifade edilen koşul gerçekleşmiyorsa bir de elif ile gösterdiğim
koşulu dene

a = 33
b = 33
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")

# a and b are equal yazdırır

--------------------------------------------->

Else

--------------------------------------------->
(+) Eğer if ve elif ile ifade edilen koşullar gerçekleşmiyorsa geri kalan bütün
durumlar else kapsamında değerlendirilir

a = 200
b = 33
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")

# a is greater than b yazdırır

--------------------------------------------->

If Kısa Yol

--------------------------------------------->
a = 5
b = 4
if a > b: print("a is greater than b")

# a is greater than b
--------------------------------------------->

If Else Kısa Yol

--------------------------------------------->
a = 2
b = 330
print("A") if a > b else print("B")

# B yazdırır
--------------------------------------------->
and

--------------------------------------------->
(+) and kullanıldığında belirtilen bütün koşulların sağlanıyor olması gerekir

a = 200
b = 33
c = 500
if a > b and c > a:
print("Both conditions are True")

# Both conditions are True yazdırır

--------------------------------------------->

--------------------------------------------->
(+) or kullanıldığında belirtilen koşullardan en az biri doğru olmalıdır

a = 200
b = 33
c = 500
if a > b or a > c:
print("At least one of the conditions is True")

# At least one of the conditions is True yazdırır

--------------------------------------------->

not

--------------------------------------------->
(+) Belirtilen koşulun doğru olmaması durumu sağlanmalıdır

a = 33
b = 200
if not a > b:
print("a is NOT greater than b")

# a is NOT greater than b yazdırır

--------------------------------------------->

pass

--------------------------------------------->
(+)

a = 33
b = 200

if b > a:
pass

# yazdırır
--------------------------------------------->

While Döngüsü

--------------------------------------------->
(+) belirtilen koşul sağlandığı sürece döngü devam eder

i = 1
while i < 6:
print(i)
i += 1

1
2
3
4
5 yazdırır
--------------------------------------------->

Break

--------------------------------------------->
(+) Break sayesinde koşul sağlanıyor olsa dahi döngüyü bitirebiliriz

i = 1
while i < 6:
print(i)
if i == 3:
break
i += 1

1
2
3 yazdırır
--------------------------------------------->

continue

--------------------------------------------->
(+) diyelim ki döngü 6 kez tekrar edecek continue sayesinde mesela 4. döngüyü
atlayıp 5. döngüye geçebiliriz

i = 0
while i < 6:
i += 1
if i == 3:
continue
print(i)

1
2
4
5
6 yazdırır
--------------------------------------------->

else

--------------------------------------------->
(+) else burada eğer döngüyü sağlayan koşul sağlanmazsa yani döngü biterse direkt
sonrasında olacak komutları gösterir

i = 1
while i < 6:
print(i)
i += 1
else:
print("i is no longer less than 6")

1
2
3
4
5
i is no longer less than 6 yazdırır
--------------------------------------------->

For Döngüsü

--------------------------------------------->
(+) for döngüsü bir iterator(yineleyici) işlevindedir ayrıca bir değişkenin her bir
elemanı için bir kod çalıştırır

fruits = ["apple", "banana", "cherry"]

for x in fruits:
print(x)

apple
banana
cherry yazdırır
--------------------------------------------->

Range Fonksiyonu

--------------------------------------------->
(!) range(6) => 0'dan 6'ya kadar(6 dahil değil)

for x in range(6):
print(x)

0
1
2
3
4
5 yazdırır

(!) range(2,6) => 2'den 6'ya kadar(6 dahil değil)

for x in range(2, 6):

print(x)

2
3
4
5

(!)

for x in range(2, 30, 3):

print(x)
--------------------------------------------->

Fonksiyonlar

--------------------------------------------->
def my_function():
print("Hello from a function")
--------------------------------------------->

Fonksiyonu Çağırma

--------------------------------------------->
def my_function():
print("Hello from a function")

my_function()
--------------------------------------------->

Argümanlar

--------------------------------------------->
def my_function(fname):
print(fname + " Refsnes")

my_function("Emil")
my_function("Tobias")
my_function("Linus")
--------------------------------------------->

Keyfi Argümanlar

--------------------------------------------->
(+) Ne kadar argüman kullanılacağını bilmiyorsan parametre isminin önüne '*' ekle
ve bu sayede sınırsız argüman alabilirsin

def my_function(*args):
print("The youngest child is " + args[2])

my_function("Emil", "Tobias", "Linus")

--------------------------------------------->

Anahtar Kelime Argümanlar

--------------------------------------------->
(+) key = value şeklinde de argümanları alabilirsin bu şekilde argümanların sırası
önemsizleşir

def my_function(child3, child2, child1):

print("The youngest child is " + child3)

my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")

--------------------------------------------->

Keyfi Anahtar Kelime Argümanlar

--------------------------------------------->
(+) Sınırsız anahtar kelime şeklinde argüman alabilirsin

def my_function(**kwargs):
print("His last name is " + kwargs["lname"])

my_function(fname = "Tobias", lname = "Refsnes")

--------------------------------------------->

Default Parametre Değeri

--------------------------------------------->
(+) Bu tür fonksiyonları hiçbir argüman vermeden çalıştırırız
def my_function(country = "Norway"):
print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
--------------------------------------------->

Return

--------------------------------------------->
def my_function(x):
return 5 * x

print(my_function(3))
print(my_function(5))
print(my_function(9))
--------------------------------------------->

Lambda

--------------------------------------------->
(+) a parametresine 10 ekleyip döndürür

x = lambda a : a + 10
print(x(5))

Çoklu Kullanım:

x = lambda a, b : a * b
print(x(5, 6))
--------------------------------------------->

--------------------------------------------->
--------------------------------------------->

--------------------------------------------->
--------------------------------------------->
--------------------------------------------->
--------------------------------------------->