<jupyter_start><jupyter_text>Contents* [Using Print](Using-Print)* [Basic Mathematical Operations](Basic-Mathematical-Operations)* [Boolean and Logic Operators](Boolean-and-Logic-Operators)* [Variable Types](Variable-Types)* [Converting Between Variable Types](Converting-Between-Variable-Types)* [Lists](Listeler)* [Tuple](Tuple)* [Strings](Stringler)* [Dictionary](Dictionary)* [Sets](Sets)* [Conditional Statements](Conditional-Statements)* [While Loop](While-Loop)* [For Loop](For-Loop)* [Break and Continue](Break-and-Continue)* [List Comprehensions](List-Comprehensions)* [Convert a list to a dictionary](Convert-a-list-to-a-dictionary)* [User Defined Function](User-Defined-Function)* [Lambda Function](Lambda-Function)* [Anonymous Funcion](Anonymous-Funcion)* [Iterators](Iterators)* [Zip](Zip)* [Classes](Classes)* [Extra](Extra)* [Referans Link](Referans-Link)  Using Print<jupyter_code>print "<NAME>" #Mesajı yazdırır.
print 5 #sayıyı yazdırır.<jupyter_output><NAME>
5<jupyter_text>Basic Mathematical Operations<jupyter_code>print 3+4 #Toplama
print 3-4 #Çıkarma
print 3*4 #Çarpma
print 3/4 #Bölme (int türünde)
print 3.0/4 #Bölme (float)
print 3**3 #Kuvvet alama
print 4**0.5 #Karakök alma
print 34%5 #Mod alma
x = 3
x += 1 # x = x + 1 yerine
print x # x'in eski değeri 3, yeni değeri 4

x *= 2 # x = x * 2 yerine
print x # x'in eski değeri 4, yeni değeri 8<jupyter_output>4
8<jupyter_text>Boolean and Logic Operators<jupyter_code>t, f = True, False

print (t and f) # Mantıksal AND;
print (t or f)  # Mantıksal OR;
print (not t)   # Mantıksal NOT;
print (t != f)  # Mantıksal XOR;<jupyter_output>False
True
False
True<jupyter_text>Variable Types<jupyter_code>a = 3.0
b = 5
c = "string"
d = True
#type değişken türünü döndürür.
print type(a)
print type(b)
print type(c)
print type(d)<jupyter_output><type 'float'>
<type 'int'>
<type 'str'>
<type 'bool'><jupyter_text>Converting Between Variable Types<jupyter_code>a = 3
b = 4.3
c = "3"
print float(a), type(a)
print str(b), type(b)
print int(c), type(c)<jupyter_output>3.0 <type 'int'>
4.3 <type 'float'>
3 <type 'str'><jupyter_text>Lists<jupyter_code>liste = [2,3,5,6,5,5] 
print type(liste) #Listenin type'ını yazdırır.

print liste #listenin tamamını yazdırır.
print liste[0] #listenin 0. indeksli elemanını yazdırır.
print liste[-1] #listenin son elemanını yazdırır.
print liste[:2] #listenin 2. indeks'e kadarki elamanlarını yazdırır.
print liste[::-1] #listeyi tersten yazdırır.
print len(liste) #listenin uzunluğunu yazdırır.
liste[2] = "python" # Listelerde farklı veri tipleri tutulabilir
liste.insert(3,555) #listemizin istediğimiz bir indisine eleman ekleyebiliriz.
print type(liste)
print liste
liste.append("yeni eleman") # Listenin en sonuna `append` ile veri eklenebilir
print liste
liste.pop() # Listenin son elemanını atar.
print liste
print liste.index('python') #elemanın kaçıncı indekste olduğunu verir.
print liste.count(5) #elemandan listede kaç adet bulunduğunu verir.

liste.remove('python')
print liste
liste.sort() #listeyi küçükten büyüğe sıralar.
print liste
liste.reverse() #listeyi ters çevirir.
print liste
ek_liste = [1, 11, 111, 1111]
liste.extend(ek_liste) # listenin sonuna başka bir bir listeyi ekleyebiliriz.
print liste
print "python" in liste #listenin içinde python elemanı varmı kontrol eder.
print "python" not in liste
string = "a,b,c,d,e"
liste = string.split(',') # girilen karaktere göre string'i ayırır.
print liste
liste1 = [1,2,3,4]
liste2 = liste1 #liste1 ve liste2 aynı adrese bağlıdır.
liste1.append(5) #liste1'e eleman eklendiğinde liste2 de etkilenir.
print liste2 

liste1 = [5,6,7] #ama liste1'in tamamen değişmesinden etkilenmez.
print liste2
liste1 = [1,2,3,4]
copy_liste = list(liste1) #liste1 bu metod ile kopyalamak liste1 deki değişikliklerden copy_liste'yi etkilemez.
#copy_liste = liste1[:] #bir diğer metod ise listeyi dilimleyerek kopyalamaktır.

liste1.append(5)
print liste1

print copy_liste
sayilar = list(range(5)) # 0'dan 5'e kadar (5 hariç) tam sayı listesi oluşturalım
print sayilar<jupyter_output>[0, 1, 2, 3, 4]<jupyter_text>Tuple<jupyter_code>tuples = (3,5,6)
print type(tuples)
print tuples

print type(tuple(liste)) #listeyi tuple'a dönüştürelim.
print type(list(tuples)) #tuple'ı listeye dönüştürelim.<jupyter_output><type 'tuple'>
(3, 5, 6)
<type 'tuple'>
<type 'list'><jupyter_text>Strings<jupyter_code>merhaba = 'merhaba' # tek tırnak da kullanılabilir
dunya = "dünya" # çift tırnak da

print merhaba # "merhaba" yazdırır
print len(merhaba) # "merhaba" da kaç karakter olduğunu yazdırır
print merhaba, len(merhaba) # ikisi birlikte
print merhaba + str(len(merhaba)) # sayıyı str() fonksiyonu ile string'e çevirelim

print '%s %d' % (merhaba, len(merhaba))  # önce veri tipi sonra değişkenler tanımlanabilir 
print("{}".format(merhaba)) # .format() ile ekrana değişken yazdırma
print("{} {}".format(merhaba, dunya)) 
print("{a} {b}".format(b = merhaba, a = dunya)) 

birlesim = merhaba + " " + dunya #iki string birleştirilebilir.
print birlesim
kelime = "<NAME>"
print kelime[1] #kelimenin 1. indeksini yazdırır.
print kelime[-2] #kelimenin sondan 2. elemanını yazdırır.
print kelime[3:] #kelimenin 3. indeksinden sonraki elemanlarını yazdırır.
print kelime[::-1] #kelimeyi tersten yazdırır.
print kelime.capitalize()  # İlk harf büyük 
print kelime.upper()      # Hepsi büyük harf
print kelime.lower()      # Hepsi küçük harf
print kelime.rjust(15)     # Sağa yasla
print kelime.center(15)    # Merkeze ortala
print kelime.replace('ZEKA', 'zekalar')  # "ZEKA"ları "zekalar" ile değiştirelim
print '        yapay zeka önemlidir :) '.strip()  # boşlukları silmek için strip() kullanılır
print kelime.count("a")
print kelime.startswith("zeka") #kelime zeka ilemi başlıyor? (true yada false döndürür.)
print kelime.index("A") #"A" harfinin hangi indiste bulunduğunu verir. (İlk bulduğu indeksi döndürür.) 
print kelime.find("A") #"A" harfinin hangi indiste bulunduğunu verir. (İlk bulduğu indeksi döndürür.) 
d = "1234"
e = "asdf"
h = "1as"
j = ".,"
print d.isdigit() #sitring içerisindeki karakterlerin hepsi sayımı diye kontrol eder.
print e.isalpha() #sitring içerisindeki karakterlerin hepsi harf mi diye kontol eder.
print h.isalnum(), j.isalnum() #sitring içerisindeki karakterler harf veya sayımı diye kontrol eder.<jupyter_output>True
True
True False<jupyter_text>Dictionary<jupyter_code>meshur = {'Kayseri': 'Manti', 'Amasya': 'Elma', 'Malatya': 'Kayisi'}  # Sözlük oluşturalım
print type(meshur)
print meshur
print meshur.keys()
print meshur.values()
meshur.items()
print meshur['Malatya'] # "Malatya" anahtar değerine ait değer ekrana yazdırılır.
print 'Amasya' in meshur # "Amasya" anahtar değeri sözlüğümüzde varsa "True" döndürür. 
meshur['Istanbul'] = 'Trafik' # Sözlüğe yeni bir girdi ekleyelim.
print meshur
print (meshur.get('Ankara', 'N/A')) # "N/A" döndürür
print (meshur.get('Amasya', 'N/A')) # "Elma" döndürür
del meshur['Amasya'] # Sözlükten bir değeri silelim.
print meshur.get('Amasya', 'N/A') # "Amasya" silindiği için "N/A" döndürür.
print meshur
meshur.clear() # Dictionary'yi temizler.
print(meshur)<jupyter_output>{}<jupyter_text>Sets<jupyter_code>hayvanlar = {'kedi', 'kopek'}

print type(hayvanlar)
print hayvanlar

print 'kedi' in hayvanlar # Kümede o elemanın olup olmadığına bakalım = "True"
print 'balik' in hayvanlar # Kümede o elemanın olup olmadığına bakalım = "False"
hayvanlar.add('balik') # Kümeye eleman ekleyelim
print 'balik' in hayvanlar

print len(hayvanlar) # Kümenin eleman sayısını yazdıralım
hayvanlar.add('kedi') # Kedi zaten kümede ekli olduğu için tekrar eklenmeyecek.
print len(hayvanlar)       
hayvanlar.remove('kedi') # Kümeden bir elemanı kaldıralım.
print len(hayvanlar)  
print hayvanlar<jupyter_output>3
2
set(['balik', 'kopek'])<jupyter_text>Conditional Statements<jupyter_code>A = 10
if A > 10: # A büyüktür müdür 10 dan?
    print "10 dan büyüktür."
    
if A >= 10: #A büyük eşit midir 10 dan?
    print "10 a eşit yada büyüktür."

if A < 20: #A küçük müdür 20 den?
    print "20 den küçüktür."

if A <= 20: #A küçük eşit midir 20 den?
    print "20 ye eşit yada küçüktür."

if A == 10: #A eşit midir 10 a?
    print "10 a eşittir."

if A != 0: #A farklımıdır 0 dan?
    print "0 dan farklıdır."
A = 20

if A > 10: # A büyüktür müdür 10 dan?
    print "10 dan büyüktür."

elif A < 10: #A küçük müdür 10 dan?
    print "10 dan küçüktür."

else :
    print "10 a eşittir."

#if koşulu sağlanırsa bir elif ve else koşullarına bakmaz. Hiç bir koşul sağlanaması durumunda else koşulu geçerlidir.<jupyter_output>10 dan büyüktür.<jupyter_text>While Loop<jupyter_code>liste = []
i = 0
while i < 10:
    liste.append(i)
    i += 1

print liste<jupyter_output>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<jupyter_text>For Loop<jupyter_code>iller = ['İstanbul', 'Ankara', 'İzmir', 'Malatya']

for i in iller: #listenin tüm elemanlarını sırayla i'ye atar.
    print i
for harf in 'Yapay Zeka': #string'in tüm karakterlerini sırayla harf'e atar.
    print harf
iller = ['İstanbul', 'Ankara', 'İzmir', 'Malatya']

#Döngü içerisinde her bir liste elemanının indeks değerine ulaşmak için enumerate fonksiyonunu kullanabilirsiniz.
# index : value = 0:'İstanbul', 1:'Ankara', 2:'İzmir', 3:'Malatya'
for index, value in enumerate(iller):
    print '%d: %s' % (index + 1, value)
dictionary = {'spain':'madrid','france':'paris'}

for key in dictionary:
    value = dictionary[key]
    print key," : ",value

print "------------\n"
for key,value in dictionary.items():
    print key," : ",value
    
print "------------\n"
for key in dictionary.keys():
    print key

print "------------\n"
for value in dictionary.values():
    print value
hayvanlar = {'kedi', 'köpek', 'balık'}

for sira, hayvan in enumerate(hayvanlar):
    print '%d: %s' % (sira + 1, hayvan)
liste = []
for i in range(10):
    liste.append(i**2)

print liste<jupyter_output>[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]<jupyter_text>Break and Continue<jupyter_code>liste = []
for i in range(10):
    if i == 5:
        continue #Döngünün bir sonraki elemanına geçer.
    elif i >= 8:
        break #Dögüyü kırar.
        
    liste.append(i)

print liste<jupyter_output>[0, 1, 2, 3, 4, 6, 7]<jupyter_text>List Comprehensions<jupyter_code>rakamlar = list(range(10))
kareler = [rakam ** 2 for rakam in rakamlar]

print kareler
#Conditionals on iterable
cift_kareler = [rakam ** 2 for rakam in rakamlar if rakam % 2 == 0]
tek_kareler = [rakam ** 2 for rakam in rakamlar if (rakam % 2) == 1]

print cift_kareler
print tek_kareler
num1 = [5,10,15]
num2 = [i**2 if i == 10 else i-5 if i < 7 else i+5 for i in num1]
print num2<jupyter_output>[0, 100, 20]<jupyter_text>Convert a list to a dictionary<jupyter_code>sayilar = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
cift_kare = {x: x ** 2 for x in sayilar  if x % 2 == 0}
print cift_kare
print type(cift_kare)<jupyter_output>{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}
<type 'dict'><jupyter_text>User Defined Function<jupyter_code>def tuble_ex():
    """ return defined t tuble"""
    t = (1,2,3)
    return t
a,b,c = tuble_ex()
print a,b,c
x = 2
def f():
    x = 3
    return x
print x      # x = 2 global scope
print f()    # x = 3 local scope
# What if there is no local scope
x = 5
def f():
    y = 2*x        # there is no local scope x
    return y
print(f())         # it uses global scope x
# ilk olarak local scope'a bakar yok ise global scope'u kullanır.
#nested function # iç içe fonksiyonlar
def square():
    """ return square of value """
    def add():
        """ add two local variable """
        x = 2
        y = 3
        z = x + y
        return z
    return add()**2
print(square())   
# default arguments
def f(a, b = 1, c = 2):
    y = a + b + c
    return y
print(f(5))
# what if we want to change default arguments
print(f(5,4,3))
# flexible arguments *args
def f(*args):
    for i in args:
        print(i)
f(1)
print("")
f(1,2,3,4)
# flexible arguments **kwargs that is dictionary
def f(**kwargs):
    """ print key and value of dictionary"""
    for key, value in kwargs.items():               # If you do not understand this part turn for loop part and look at dictionary in for loop
        print(key, " ", value)
f(country = 'spain', capital = 'madrid', population = 123456)<jupyter_output>('country', ' ', 'spain')
('population', ' ', 123456)
('capital', ' ', 'madrid')<jupyter_text>Lambda Function<jupyter_code># lambda function
square = lambda x: x**2     # where x is name of argument
print square(4)
tot = lambda x,y,z: x+y+z   # where x,y,z are names of arguments
print tot(1,2,3)<jupyter_output>16
6<jupyter_text>Anonymous FuncionLike lambda function but it can take more than one arguments.* map(func,seq) : applies a function to all the items in a list<jupyter_code>number_list = [1,2,3]
y = map(lambda x:x**2,number_list)
print(list(y))<jupyter_output>[1, 4, 9]<jupyter_text>Iterators<jupyter_code># iteration example
name = "ronaldo"
it = iter(name)
print next(it)    # print next iteration
print next(it)
#print *it         # print remaining iteration<jupyter_output>r
o<jupyter_text>Zip<jupyter_code># zip example
list1 = [1,2,3,4]
list2 = [5,6,7,8]
z = zip(list1,list2)
print(z)
z_list = list(z)
print(z_list)
un_zip = zip(*z_list)
un_list1,un_list2 = list(un_zip) # unzip returns tuble
print(un_list1)
print(un_list2)
print(type(un_list2))<jupyter_output>(1, 2, 3, 4)
(5, 6, 7, 8)
<type 'tuple'><jupyter_text>Classes<jupyter_code>class Karsilayici:

    # Oluşturma
    def __init__(self, isim):
        self.isim = isim  # Örnek (instance) değişkeni tanımlayalım

    # Örnek (instance) yöntemi
    def selam(self, buyukHarf = False):
        if buyukHarf:
            print ('MERHABA, %s!' % self.isim.upper())
        else:
            print ('Merhaba, %s' % self.isim)

g = Karsilayici('Fuat')     # Karşılayıcı sınıfında bir örnek oluşturalım 
g.selam()                   # Merhaba, Fuat
g.selam(buyukHarf = True)   # MERHABA, FUAT!<jupyter_output>Merhaba, Fuat
MERHABA, FUAT!<jupyter_text>Extra<jupyter_code>help(len) #komutlar hakkında bilgi verir.
import math #kütüphaneyi yükler.

dir(math) #math kütüphanesi ile birlikte kullanılabilecek fonksiyonları listeler.<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1313904842941218, 'fraction_numerical': 0.02630645961852088, 'mean_word_length': 4.61241543971349, 'pattern_counts': {'":': 0, '<': 91, '<?xml version=': 0, '>': 90, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '23', 'dir': 'jupyter-structured-clean-dedup', 'id': '198996', 'license': 'MIT', 'n_tokens_mistral': 6314, 'n_tokens_neox': 5881, 'n_words': 1585, 'path': 'Python/python.ipynb', 'repo_name': 'NevzatBOL/Paket-Kurulumlar-', 'size': '14121'}