├── students.txt
├── Persons.txt
├── customers.txt
├── chinook.db
├── conditionalBlocks2.py
├── functions.py
├── conditionalBlocks6.py
├── conditionalBlocks4.py
├── forIterationPart1.py
├── arraysPart3.py
├── conditionalBlocks.py
├── setIntersection.py
├── setDifference.py
├── conditionalBlocks3.py
├── functionsPart3.py
├── Workshops
    ├── conditionalBlocksWorkshop.py
    ├── variableSwaping.py
    ├── conditionalBlocksWorkshop1.py
    ├── convertKmToMiles.py
    ├── factorialComputation.py
    ├── wordSorting.py
    ├── matrixSums.py
    └── basicCalculator.py
├── stringFunctionsPart3.py
├── forIterationPart4RangeEx1.py
├── dictionaryPart2.py
├── setUnion.py
├── whileIterationPart1.py
├── forIterationPart2.py
├── setSymmetric_difference.py
├── Numpy
    ├── numpyArrayPart2.py
    ├── shapeManupulation.py
    ├── numpyArrayPart3.py
    ├── numpyArrayPart5.py
    ├── numpyArrayPart1.py
    └── numpyArrayPart4.py
├── conditionalBlocks7.py
├── fileOperationsPart3.py
├── loops.py
├── filter.py
├── arraysPart2.py
├── conditionalBlocks9.py
├── stringFunctionsPart4.py
├── setPart1.py
├── classesPart4.py
├── conditionalBlocks8.py
├── forIterationPart3Range.py
├── forIterationPart4RangeEx2.py
├── notes(12-12-2020).txt
├── reduce.py
├── modulesPart1.py
├── stringFunctionsPart5.py
├── tuplePart1.py
├── arraysPart1.py
├── jsonOperationsPart2.py
├── inputs.py
├── stringFunctionsPart1.py
├── dictionaryPart1.py
├── conditionalBlocks5.py
├── classesPart1.py
├── databaseOperationsPart8.py
├── stringFunctionsPart2.py
├── databaseOperationsPart7.py
├── modulesPart2.py
├── functionsPart1.py
├── exceptionHandlingPart1.py
├── iterators.py
├── functionsPart2.py
├── mapping.py
├── databaseOperationsPart9.py
├── variablesPart1.py
├── functionsPart4.py
├── fileOperationsPart2.py
├── databaseOperationsPart2.py
├── jsonOperationsPart1.py
├── classesPart3.py
├── tuplePart2.py
├── variablesPart2.py
├── breakAndcontinue.py
├── databaseOperationsPart4.py
├── classesPart2.py
├── exceptionHandlingPart2.py
├── databaseOperationsPart6.py
├── arraysPart4.py
├── databaseOperationsPart3.py
├── databaseOperationsPart5.py
├── classesPart5.py
├── databaseOperationsPart1.py
├── setPart2.py
├── arrayFunctions.py
├── fileOperationsPart1.py
├── databaseOperationsPart10.py
├── users.json
├── README.md
└── generalReview.py


/students.txt:
--------------------------------------------------------------------------------
1 | 
2 | melike
3 | 


--------------------------------------------------------------------------------
/Persons.txt:
--------------------------------------------------------------------------------
1 | Zafer
2 | Duygu
3 | Esra
4 | 


--------------------------------------------------------------------------------
/customers.txt:
--------------------------------------------------------------------------------
1 | melike
2 | python
3 | yapay 
4 | zeka
5 | 


--------------------------------------------------------------------------------
/chinook.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/melike-eryilmaz/pythonProgrammingLanguageForBeginners/HEAD/chinook.db


--------------------------------------------------------------------------------
/conditionalBlocks2.py:
--------------------------------------------------------------------------------
1 | dolarDun=7.95
2 | dolarBugun=7.85
3 | 
4 | if dolarDun<dolarBugun:
5 |   print("Dolar artıyor..")
6 | 
7 | else:
8 |   print("Bitti..")
9 | 


--------------------------------------------------------------------------------
/functions.py:
--------------------------------------------------------------------------------
1 | def kredileriListele():
2 |   krediler=["a","b","c"]
3 |   for i in krediler:
4 |     print("<option>"+i+"<option>")
5 | 
6 | kredileriListele()
7 | 


--------------------------------------------------------------------------------
/conditionalBlocks6.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 Conditional Blocks
 2 | 
 3 | num = 3.45
 4 | 
 5 | if num > 0:
 6 |     print("positive number")
 7 | elif num == 0:
 8 |     print("zero")
 9 | else :
10 |     print("negative number")
11 | 


--------------------------------------------------------------------------------
/conditionalBlocks4.py:
--------------------------------------------------------------------------------
 1 | birinciSayi = 9
 2 | ikinciSayi  = 6
 3 | 
 4 | if birinciSayi > ikinciSayi:
 5 |   print( "BirinciSayi büyüktür.")
 6 | elif ikinciSayi > birinciSayi :
 7 |   print("İkinciSayi büyüktür.")
 8 | else:
 9 |   print("Sayılar eşittir.")
10 | 


--------------------------------------------------------------------------------
/forIterationPart1.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 for iteration 
 2 | 
 3 | #list of numbers
 4 | numbers = [1,2,3,4,5]
 5 | 
 6 | # variable to store sum
 7 | sum = 0
 8 | 
 9 | for value in numbers:
10 |     sum = sum + value
11 |     
12 | 
13 | print('The sum is ',sum)
14 | 


--------------------------------------------------------------------------------
/arraysPart3.py:
--------------------------------------------------------------------------------
 1 | ogrenciler=["Melike","Duygu","Elif","Zafer"]
 2 | 
 3 | print(ogrenciler[0])
 4 | print(ogrenciler[1])
 5 | print(ogrenciler[2])
 6 | print(ogrenciler[3])
 7 | 
 8 | print(len(ogrenciler))
 9 | ogrenciler[1]="Elvin"
10 | 
11 | print(ogrenciler)
12 | 


--------------------------------------------------------------------------------
/conditionalBlocks.py:
--------------------------------------------------------------------------------
 1 | dolarDun=7.65
 2 | dolarBugun=7.75
 3 | 
 4 | if dolarDun<dolarBugun:
 5 |   print("Dolar artıyor..")
 6 | 
 7 | if dolarDun > dolarBugun:
 8 |   print("Dolar düşüyor..")
 9 | 
10 | if dolarDun == dolarBugun:
11 |   print("Dolar sabit kalıyor..")
12 | 


--------------------------------------------------------------------------------
/setIntersection.py:
--------------------------------------------------------------------------------
1 | # 21/12/2020 setIntersection 
2 | # setIntersection iki ayrı set de ortak olan elemanları almamızı sağlar.
3 | setA = {1,2,3,4,5}
4 | setB = {3,4,5}
5 | 
6 | print(setA & setB)
7 | print(setA.intersection(setB))
8 | print(setB.intersection(setA))
9 | 


--------------------------------------------------------------------------------
/setDifference.py:
--------------------------------------------------------------------------------
1 | # 21/12/2020 setDifference
2 | # setDifference iki ayrı set de birinde olup diğerinde olmayan elemanları almamızı sağlar.
3 | setA = {1,2,3,4,5}
4 | setB = {3,4,5}
5 | 
6 | print(setA - setB)
7 | print(setA.difference(setB))
8 | print(setB.difference(setA))
9 | 


--------------------------------------------------------------------------------
/conditionalBlocks3.py:
--------------------------------------------------------------------------------
 1 | dolarDun=7.65
 2 | dolarBugun=7.85
 3 | 
 4 | if   dolarDun < dolarBugun :
 5 |   print("Dolar artıyor..")
 6 | elif dolarDun > dolarBugun :
 7 |   print("Dolar azalıyor..")
 8 | else:
 9 |   print("Dolar yerinde sayıyor..")
10 | 
11 | print("İşlemler sonlanıyor..")
12 | 


--------------------------------------------------------------------------------
/functionsPart3.py:
--------------------------------------------------------------------------------
 1 | # Fonksiyonlar geriye değer döndüren ve geriye değer döndürmeyen şeklinde 2 ye ayrılır.
 2 | 
 3 | #Geriye değer dönen fonksiyon örneği aşağıdadır.
 4 | def dikucgenalanihesapla(a,b):
 5 |     return a*b/2;
 6 | 
 7 | 
 8 | alan=dikucgenalanihesapla(3,4)
 9 | print(alan)
10 | 
11 | 


--------------------------------------------------------------------------------
/Workshops/conditionalBlocksWorkshop.py:
--------------------------------------------------------------------------------
 1 | # Conditional blocks workshop 21/12/2020
 2 | 
 3 | sayi = int(input('Sayi giriniz:'))
 4 | 
 5 | if sayi == 0:
 6 |     print('Sayı sıfırdır.')
 7 | elif sayi > 0:
 8 |     print('Sayı sıfırdan büyüktür.')
 9 | else:
10 |     print('Sayı sıfırdan küçüktür.')
11 | 
12 | 


--------------------------------------------------------------------------------
/stringFunctionsPart3.py:
--------------------------------------------------------------------------------
1 | #12/12/2020 len() fonksiyonu
2 | #len() fonksiyonu geriye dizinin uzunluğunu döndürür.
3 | message = 'Hello World'
4 | 
5 | print(len(message))
6 | 
7 | #Dizinin son karakterini bulmak için substing ve len methodlarını kullanabiliriz.
8 | print(message[len(message)-1:len(message)])
9 | 


--------------------------------------------------------------------------------
/forIterationPart4RangeEx1.py:
--------------------------------------------------------------------------------
 1 | # 22/12/2020 for iteration example stars
 2 | 
 3 | 
 4 | sayi = int(input('Sayi giriniz :'))
 5 | 
 6 | yildiz = ''
 7 | 
 8 | # Başlangıç değeri dahil ,bitiş tarihi hariç olarak alır.
 9 | for x in range(1,sayi+1,1):
10 |     yildiz = yildiz + '*'
11 |     print(yildiz)
12 |     
13 | 


--------------------------------------------------------------------------------
/dictionaryPart2.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 dictionary
 2 | # 
 3 | 
 4 | sozluk = {
 5 |     'book' :'kitap',
 6 |     'table':'masa'
 7 |     
 8 |     }
 9 | 
10 | sozluk['book'] = 'kitap 1'
11 | sozluk['fruit'] = 'meyve'
12 | 
13 | print(sozluk)
14 | 
15 | del(sozluk['book'])
16 | 
17 | print(len(sozluk))
18 | print(sozluk)
19 | 


--------------------------------------------------------------------------------
/setUnion.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 setunion 
 2 | # setUnion iki ayrı seti ortak elemanları bir kez alarak birleştirmemizi sağlar.
 3 | #Birleştirdikten sonra kendi algoritmasına göre sıralar.
 4 | 
 5 | numberSet = {1,2,3}
 6 | numberSet1 = {2,3,5}
 7 | 
 8 | print(numberSet | numberSet1)
 9 | print:(numberSet.union(numberSet1))
10 | 


--------------------------------------------------------------------------------
/whileIterationPart1.py:
--------------------------------------------------------------------------------
 1 | # 22/12/2020 While Iteration
 2 | 
 3 | # for dongüsü gibi belirli bir şartı sağlayana kadar döngü kurmak için kullanılır.
 4 | # Genellikle for döngüsü tercih edilir.
 5 | 
 6 | 
 7 | sum = 0
 8 | i = 1
 9 | 
10 | while i <= 10:
11 |     sum = sum +i
12 |     i = i+1
13 |     
14 | 
15 | print('The sum is ',sum)
16 | 


--------------------------------------------------------------------------------
/forIterationPart2.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 forIteration 
 2 | 
 3 | sehirler = ['İstanbul','Ankara','İzmir']
 4 | print(sehirler[0])
 5 | print(sehirler[1])
 6 | print(sehirler[2])
 7 | 
 8 | for sehir in sehirler :
 9 |     if sehir != 'İstanbul':
10 |         print(sehir+' için sehir kodu:'+sehir[0:3])
11 |         print('***************************')
12 | 


--------------------------------------------------------------------------------
/setSymmetric_difference.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 symmetricDiffrence
 2 | # symmetricDiffrence iki ayrı set de A da olup Bde olmayanlar ile B de olup A da olmayanları almamızı sağlar.
 3 | 
 4 | setA = {1,2,3,4,5}
 5 | setB = {3,4,5,7}
 6 | 
 7 | print(setA ^ setB)
 8 | print(setA.symmetric_difference(setB))
 9 | print(setB.symmetric_difference(setA))
10 | 


--------------------------------------------------------------------------------
/Numpy/numpyArrayPart2.py:
--------------------------------------------------------------------------------
 1 | """ 04/01/2021 Numpy Array"""
 2 | import numpy as np
 3 | 
 4 | a = np.array([1,3,5,7,9,11])
 5 | a = a.reshape(2,3)
 6 | 
 7 | print(a)
 8 | print(a.dtype) # dtype dizinin elemanlarının tiplerini verir.
 9 | print(a.ndim)  # ndim dizinin boyutunu verir.
10 | 
11 | b = np.array([[1,3],[5,7],[9,11]])
12 | print(b)
13 | print(b.ndim)
14 | 


--------------------------------------------------------------------------------
/conditionalBlocks7.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 Conditional Blocks 
 2 | 
 3 | sayi1 = 20
 4 | sayi2 = 30
 5 | 
 6 | if sayi1 < sayi2:
 7 |     print("bir şey")
 8 |     print("ikinci bir şey")
 9 | print("şart bloğu içinde değil")
10 | 
11 | 
12 | 
13 | 
14 | if sayi1 >sayi2:
15 |     print("bir şey")
16 |     print("ikinci bir şey")
17 | print("şart bloğu içinde değil")
18 | 


--------------------------------------------------------------------------------
/fileOperationsPart3.py:
--------------------------------------------------------------------------------
 1 | """ 27/12/2020 File Operations
 2 |     Liste içerisindeki verileri sırasıyla dosyaya yazma uygulaması
 3 | 
 4 | """
 5 | Persons = ['Zafer','Duygu','Esra']
 6 | fileToAppend = open('Persons.txt','a')
 7 | 
 8 | for person in Persons:
 9 |     fileToAppend.write(person)
10 |     fileToAppend.write('\n')
11 | 
12 | fileToAppend.close()
13 | 


--------------------------------------------------------------------------------
/loops.py:
--------------------------------------------------------------------------------
 1 | krediler=["İhtiyaç Kredisi","Maaşını Halkbank İle Alanlara Özel","Emeklilik Kredisi","Araba Kredisi"]
 2 | 
 3 | for i in krediler:
 4 |    print(i)
 5 | 
 6 | for i in range(10):
 7 |   print(i)
 8 | 
 9 | for i in range(len(krediler)):
10 |   print(krediler[i])
11 | 
12 | for i in range(3,10):
13 |   print(i)
14 | 
15 | for i in range(0,10,2):
16 |   print(i)
17 | 


--------------------------------------------------------------------------------
/Numpy/shapeManupulation.py:
--------------------------------------------------------------------------------
 1 | """ 04/01/2021 """
 2 | import numpy as np
 3 |   
 4 |  a = np.floor(10*np.random.random())
 5 |  
 6 |  print(a)
 7 |  
 8 |  print(a.shape)
 9 |  
10 |  print(a.ravel())
11 |  
12 |  a = a.ravel()
13 |  
14 |  print(a)
15 |  
16 |  print(a.shape)
17 |  
18 |  
19 |  a = a.reshape(2,9)
20 |  print(a)
21 |  print(a.T)
22 |  print(a.reshape(2,-1))
23 | 


--------------------------------------------------------------------------------
/filter.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Mapping 
 2 |     filter() fonksiyonu
 3 |     Elinizde birsürü veri var ve belli şartlara göre o veriyi filtrelemek istiyorsanız filter() fonksiyonu kullanabiliriz.
 4 | 
 5 | 
 6 | """
 7 | 
 8 | 
 9 | numbers = [1,2,3,4,5]
10 | 
11 | numbersFilter = list(filter(lambda number : number >2,numbers))
12 | print('Filtrelenmiş liste :',numbersFilter)
13 | 


--------------------------------------------------------------------------------
/arraysPart2.py:
--------------------------------------------------------------------------------
 1 | krediler=["İhtiyaç Kredisi","Maaşını Halkbank İle Alanlara Özel","Emeklilik Kredisi","Araba Kredisi"]
 2 | 
 3 | 
 4 | print(krediler)
 5 | print(krediler[0])
 6 | print(krediler[1])
 7 | print(krediler[2])
 8 | print(krediler[3])
 9 | 
10 | #Dizinin uzunluğunu verir.
11 | print(len(krediler))
12 | 
13 | krediler[0]="Çabuk Kredi"
14 | 
15 | print(krediler)
16 | 
17 | 


--------------------------------------------------------------------------------
/Numpy/numpyArrayPart3.py:
--------------------------------------------------------------------------------
 1 | """ 04/01/2021 Linspace :Başlangıç bitiş ve adet verilerek dizi üretmemizi sağlar."""
 2 | import numpy as np 
 3 | 
 4 | # 1 den 10 a kadar eşit aralıklarla 5 sayı üretmek 
 5 | a = np.linspace(1,10,5)
 6 | print(a)
 7 | 
 8 | 
 9 | # 
10 | from  numpy import pi
11 | x = np.linspace(0,2*pi,100)
12 | print(x)
13 | # Sinüs hesaplayabiliriz.
14 | print(np.sin(x))
15 | 


--------------------------------------------------------------------------------
/conditionalBlocks9.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 Conditional Blocks
 2 | 
 3 | lights = ['red','yellow','green']
 4 | 
 5 | # currentLight = lights[0]
 6 | # currentLight = lights[1]
 7 | currentLight = lights[2]
 8 | print(currentLight)
 9 | 
10 | if currentLight == 'red':
11 |     print('STOP!')
12 | 
13 | elif  currentLight == 'yellow':
14 |     print('READY!')
15 |     
16 | else:
17 |     print('GO!')
18 | 


--------------------------------------------------------------------------------
/stringFunctionsPart4.py:
--------------------------------------------------------------------------------
 1 | #12/12/2020 replace() fonksiyonu
 2 | 
 3 | #replace() fonksiyonu string içerisindeki karakterleri veya karakter dizilerini yeniden adlandırmamızı sağlar.
 4 | 
 5 | message = 'Hello World!'
 6 | 
 7 | print(message.replace('o','ö'))
 8 | 
 9 | message = message.replace('e','t') #message değişkeninin değerinin değişmesi için bu şekilde atama yapmalıyız.
10 | 
11 | print(message)
12 | 


--------------------------------------------------------------------------------
/setPart1.py:
--------------------------------------------------------------------------------
 1 | #17/12/2020 setler
 2 | 
 3 | #Set ler listelere benzerdir.
 4 | #En önemli özelliği indexsiz ve sırasız elemanlardan oluşmasıdır.
 5 | #Veri tekrarı olamaz .Tüm elemanlar eşsizdir.(unique)
 6 | #Set veri yapısı çok performanslı bir data sağlar.(çok hızlı)
 7 | 
 8 | #set of integers
 9 | my_set = {1,2,3}
10 | print(my_set)
11 | 
12 | #set of mixed data types
13 | my_set = {1.0,'Hello',(1,2,3)}
14 | 


--------------------------------------------------------------------------------
/classesPart4.py:
--------------------------------------------------------------------------------
 1 | """ 25/12/2020 Object Orianted Programming Classes"""
 2 | 
 3 | class Person :
 4 |     def __init__(self,firstName,lastName,age):
 5 |         self.firstName = firstName
 6 |         self.lastName = lastName
 7 |         self.age      = age
 8 |         
 9 |         
10 |         
11 | person1 = Person('Melike','Eryılmaz',23)
12 | 
13 | print(person1.firstName)
14 | 
15 | print(person1.lastName)
16 | 


--------------------------------------------------------------------------------
/conditionalBlocks8.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 Conditional Blocks
 2 | 
 3 | lights = ['red','yellow','green']
 4 | 
 5 | # currentLight = lights[0]
 6 | # currentLight = lights[1]
 7 | currentLight = lights[2]
 8 | print(currentLight)
 9 | 
10 | if currentLight == 'red':
11 |     print('STOP!')
12 | 
13 | if currentLight == 'yellow':
14 |     print('READY!')
15 |     
16 | if currentLight == 'green':
17 |     print('GO!')
18 | 


--------------------------------------------------------------------------------
/forIterationPart3Range.py:
--------------------------------------------------------------------------------
 1 | # 22/12/2020 for iteration range
 2 | 
 3 | # 0 dan başlayıp 100 kez döner 99 da biter.
 4 | for x in range(100):
 5 |     print(x)
 6 |     
 7 | #Başlangıç ve bitiş değeri verilebilir. 
 8 | for x in range(1,100):
 9 |     print(x)
10 |     
11 | # Başlangıç bitiş ve artış değeri verilebilir.
12 | for x in range(1,100,2):
13 |     print(x)
14 |     
15 |     
16 | for x in range(2,100,2):
17 |     print(x)
18 | 


--------------------------------------------------------------------------------
/Workshops/variableSwaping.py:
--------------------------------------------------------------------------------
 1 | #12/12/2020
 2 | 
 3 | 
 4 | x = 10 
 5 | y = 20 
 6 | 
 7 | #Yöntem 1 : x değerini temp bir değişkene atarak x içerisine y yi koyup daha sonra y içerisine temp değişkende tutulan değeri
 8 | # atabiliriz.
 9 | # temp = x
10 | # x = y
11 | # y = temp  
12 | 
13 | # Sadece python diline özel aşağıdaki şekilde variable swaping yapılabilir.
14 | x,y = y,x
15 | 
16 | 
17 | 
18 | print("x = " + str(x))
19 | print("y = " + str(y))
20 | 


--------------------------------------------------------------------------------
/forIterationPart4RangeEx2.py:
--------------------------------------------------------------------------------
 1 | # 22/12/2020 for iteration example
 2 | 
 3 | # Girilen sayının asal sayı olup olmadığını belirten program kodu yer almaktadır.
 4 | 
 5 | sayi = int(input('Sayı giriniz :'))
 6 | 
 7 | asalMi = True
 8 | 
 9 | for x in range(2,sayi):
10 |     if(sayi % x == 0):
11 |         asalMi == False
12 |         break
13 |     
14 | 
15 | if(asalMi==True):
16 |     print('Asal Sayı')
17 | else:
18 |     print('Asal sayı değil')
19 |     
20 | 


--------------------------------------------------------------------------------
/notes(12-12-2020).txt:
--------------------------------------------------------------------------------
 1 | Python bir programlama dilidir.
 2 | Farklı sistemleri bir araya getirmek ve öğrenmek açısından hızlı ilerleyebileceğimiz bir dildir.
 3 | *Python web development
 4 | *Scientific and Numeric Computing
 5 | *Data Analysis
 6 | *Machine Learning
 7 | *Browser Automation
 8 | *Python Makes Robotics possible
 9 | *Hacking
10 | *Desktop Application
11 | *Game Development gibi.. bir çok alanda geliştirme yapılabilir.
12 | 
13 | 
14 | 
15 | 
16 | 


--------------------------------------------------------------------------------
/reduce.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Mapping 
 2 |     reduce() fonksiyonu
 3 |     Kümülatif işlemler yapıp bir sonuca ulaşmak için reduce() fonksiyonunu kullanabiliriz.
 4 | 
 5 | """
 6 | from functools import reduce 
 7 | 
 8 | 
 9 | numbers = [1,2,3,4,5]
10 | # x her seferinde x*y ye eşit olur.Çarpa çarpa gider.
11 | # Toplama,çıkarma,bölme gibi işlemlerde yapılabilir.
12 | numbersFact= reduce(lambda x,y : x*y,numbers)
13 | 
14 | print(numbersFact)
15 | 
16 | 
17 | 
18 | 


--------------------------------------------------------------------------------
/modulesPart1.py:
--------------------------------------------------------------------------------
 1 | """ 25/12/2020 Module Yapısı 
 2 |     Module yapısı bir dosyadan diğerine erişemek gibi diğer modülleri kullanabilmezi sağlar.
 3 | 
 4 | 
 5 | """
 6 | 
 7 | def sum(number1,number2):
 8 |     print('Sum is :',number1+number2)
 9 | 
10 | 
11 | def diff(number1,number2):
12 |     print('Diff is :',number1-number2)
13 | 
14 | 
15 | customer = {
16 |             'firstName':'Melike',
17 |             'lastName': 'Eryılmaz'
18 |     
19 |     
20 |             }
21 | 


--------------------------------------------------------------------------------
/Workshops/conditionalBlocksWorkshop1.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 conditional blocks workshop
 2 | 
 3 | 
 4 | sayi1 = int(input('İlk sayıyı giriniz:'))
 5 | 
 6 | sayi2 = int(input('İkinci sayıyı giriniz:'))
 7 | 
 8 | sayi3 = int(input('Üçüncü sayıyı giriniz:'))
 9 | 
10 | if sayi1 > sayi2 and sayi1 > sayi3:
11 |     enbuyuksayi = sayi1
12 | elif sayi2 > sayi1 and sayi2 > sayi3:
13 |     enbuyuksayi = sayi2
14 | else:
15 |     enbuyuksayi = sayi3
16 | 
17 | 
18 | print('En büyük sayi:',enbuyuksayi)
19 | 


--------------------------------------------------------------------------------
/stringFunctionsPart5.py:
--------------------------------------------------------------------------------
 1 | #12/12/2020 split() ve strip() fonksiyonları
 2 | 
 3 | # split fonksiyonu boşluk karakteri default olmak üzere verilen karaktere göre  string dizi içerisindeki elemanları ayırır.
 4 | # Strip metodu, karakter dizisinin baş ve sondaki boşluk karakterlerini siler. 
 5 | 
 6 | info  = '  Melike Eryılmaz 23 Antalya '
 7 | info2 = ' Melike;Eryılmaz;23;İstanbul'
 8 | print(info.split())
 9 | 
10 | print(info.split(' '))
11 | 
12 | print(info2.split(';'))
13 | 
14 | print(info.strip())
15 | 
16 | 


--------------------------------------------------------------------------------
/tuplePart1.py:
--------------------------------------------------------------------------------
 1 | #17/12/2020 Tuple veri yapısı
 2 | #Tuple lar listelerle benzer yapıdadır .
 3 | #Listelerden farkı listelerde elemanları değiştirebiliyorken tuple da değiştirmek söz konusu değildir.
 4 | #Tuple veri yapısı performanslı data sağlar.
 5 | 
 6 | #empty tuple 
 7 | my_tuple = ()
 8 | print(my_tuple)
 9 | 
10 | #tuple having integers 
11 | my_tuple = (1,2,3,4)
12 | print(my_tuple)
13 | 
14 | #tuple with mixed datatypes
15 | my_tuple = (1,'Hello',1.4)
16 | print(my_tuple)
17 | 
18 | #nested tuple 
19 | my_tuple = ('mouse',[8,4,6],[1,2,3])
20 | 


--------------------------------------------------------------------------------
/arraysPart1.py:
--------------------------------------------------------------------------------
 1 | 
 2 | """
 3 | Python Veri Yapıları
 4 | 
 5 | Listeler :
 6 | Python da en çok kullanılan veritiplerinden biri listelerdir.
 7 | Sıralı ve indexli bir yapıya sahiptir.
 8 | Listeler köşeli parantez ile belirtilir ve birden fazla veri tutabilirler.
 9 | liste[0] şeklinde listelerin elemanlarına erişebiliriz.
10 | Liste içerisinde başka bir liste eleman olarak yer alabilir.
11 | 
12 | """
13 | 
14 | #empty array
15 | my_list = []
16 | 
17 | #list of integers 
18 | my_list = [1,2,3,4]
19 | 
20 | #list with mixed data types
21 | my_list = [1,'Hello',3.4]
22 | 


--------------------------------------------------------------------------------
/jsonOperationsPart2.py:
--------------------------------------------------------------------------------
 1 | """ 27/12/2020 json Operations
 2 |     users.json dosyası içerisinden verileri okuyup ,json da farklı nodelara erişip ekrana yazdıran program.
 3 | 
 4 | 
 5 | """
 6 | 
 7 | import json
 8 | 
 9 | with open('users.json') as users:
10 |     data = json.load(users)
11 |     # print(data)
12 |     
13 |     for x in range(3):
14 |         print(data[x]["userId"])
15 |         print(data[x]["title"])
16 |         print(data[x]["adress"])
17 |         print(data[x]["adress"]["street"])
18 |         print(data[x]["adress"]["geo"]["lat"])
19 |         
20 | 


--------------------------------------------------------------------------------
/Workshops/convertKmToMiles.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """
 3 | Created on Wed Dec 16 17:06:41 2020
 4 | 
 5 | @author: Melike.Eryilmaz
 6 | """
 7 | 
 8 | #Kullanıcıdan km cinsinden değerler alıp kaç mil olduğu bulup ekrana yazdıran programdır.
 9 | #1.Yöntem
10 | km = input('Please enter the km : ')
11 | 
12 | mil = float(km)* float(0.621371192)
13 | 
14 | print(str(km)+' km = '+str(mil)+'mil')
15 | 
16 | 
17 | 
18 | # 2. Yöntem
19 | donusumOrani = 0.621371192
20 | km = float(input('Km? = '))
21 | mil = donusumOrani*km
22 | 
23 | print(str(km)+' km = '+str(mil)+'mil')
24 | 


--------------------------------------------------------------------------------
/inputs.py:
--------------------------------------------------------------------------------
 1 | #12/12/2020 
 2 | #Kullanıcıdan veri almak için input() kullanırız ve input olarak alınan değerler string olarak alınır.
 3 | 
 4 | name = input('Please enter your name : ')
 5 | surname = input('Please enter your surname : ')
 6 | 
 7 | firstNumber = input('Please enter  first number : ')
 8 | secondNumber = input('Please enter second number : ')
 9 | 
10 | #inputlar string olarak alındığı için matematiksel işlemleri tip dönüşümü yaptıktan sonra yapmalıyız.
11 | print('Sum:',firstNumber+secondNumber)
12 | 
13 | print('Real Sum : ',int(firstNumber)+int(secondNumber))
14 | 


--------------------------------------------------------------------------------
/stringFunctionsPart1.py:
--------------------------------------------------------------------------------
 1 | # 12/12/2020 lower() upper() fonksiyonları
 2 | #Python da stringler ile işlemler yapmak için özel string fonksiyonları vardır.
 3 | #Bunlardan bazıları upper() (string ifadeyi büyük harfe çevirir) ve lower() (string ifadeyi küçük harfe çevirir.
 4 | 
 5 | firstString = 'Python is awesome!'
 6 | secondStrşng='PYTHON is Awesome!'
 7 | 
 8 | print(firstString.lower())
 9 | print(firstString.upper())
10 | 
11 | if(firstString.lower() == secondStrşng.lower()):
12 |     print('Two string are same')
13 | else:
14 |     print('Two string are not same')
15 |     
16 | 


--------------------------------------------------------------------------------
/Workshops/factorialComputation.py:
--------------------------------------------------------------------------------
 1 | # 24/12/2020 Faktoriyel hesaplama 
 2 | # Kullanıcıdan alınan sayının faktöriyelini hesaplayan programı yazınız.
 3 | #  Örneğin 6! = 1*2*3*4*5*6 şeklindedir.
 4 | # Negatif sayıların faktoriyeli alınamamaktadır.
 5 | 
 6 | 
 7 | sayi = int(input('Faktoriyeli alınacak sayıyı giriniz : '))
 8 | faktoriyel = 1
 9 | 
10 | if sayi < 0:
11 |     print('Negatif sayıların faktoriyeli alınamaz.')
12 | 
13 | elif sayi == 0:
14 |     print(faktoriyel)
15 | 
16 | else:
17 |     for x in range(1,sayi+1,1):
18 |         faktoriyel = faktoriyel * x
19 |     print(faktoriyel)
20 | 
21 | 


--------------------------------------------------------------------------------
/dictionaryPart1.py:
--------------------------------------------------------------------------------
 1 | # 21/12/2020 dictionary
 2 | #Dictionary : sözlükler de aynen set gibi sırasız veri tutar.
 3 | # Günlük hayattaki sözlükler gibi düşünebiliriz key value şeklinde değerler tutar.
 4 | 
 5 | # empty dict
 6 | my_dict = {}
 7 | 
 8 | # dictionary with integer keys
 9 | my_dict = {1:'apple',2:'bottle'}
10 | print(my_dict)
11 | 
12 | # dictionary with mixed keys
13 | my_dict = {'name':'John',1:[1,2,3,4]}
14 | print(my_dict)
15 | 
16 | # using dict
17 | my_dict = dict({'name':'John',1:[1,2,3,4]})
18 | print(my_dict)
19 | 
20 | my_dict = dict([(1,'apple'),(2,'ball')])
21 | print(my_dict)
22 | 


--------------------------------------------------------------------------------
/Workshops/wordSorting.py:
--------------------------------------------------------------------------------
 1 | """ 25/12/2020 Kelime sıralama 
 2 |     Kullanıcıdan bir kelime dizisi isteyip girilen kelimeleri alfabetik sıraya sokan ve tek tek kelimeleri yazdıran program
 3 | """
 4 | 
 5 | # Kullanıcıdan kelimeleri alıyoruz.
 6 | kelimeler = input('Kelime dizisi veya cümle giriniz : ')
 7 | 
 8 | # split() ile kelimeleri ayırıp dizye atıyoruz.
 9 | kelimedizisi = kelimeler.split()
10 | 
11 | print(kelimedizisi)
12 | 
13 | # Kelimeleri sıralıyoruz.
14 | kelimedizisi.sort()
15 | 
16 | print(kelimedizisi)
17 | 
18 | # Kelimeleri tek tek yazdırıyoruz.
19 | for x in kelimedizisi:
20 |     print(x)
21 | 


--------------------------------------------------------------------------------
/conditionalBlocks5.py:
--------------------------------------------------------------------------------
 1 | sayi1=8
 2 | sayi2=9
 3 | sayi3=12
 4 | #Neden çalışmadı bir kontrol et
 5 | if sayi1>sayi2 & sayi1>sayi3 :
 6 |   print("En Büyük:",sayi1)
 7 |   if sayi2>sayi3:
 8 |     print("En Küçük",sayi3)
 9 |   else:
10 |     print("En Küçük",sayi2)
11 | 
12 | elif sayi2>sayi1 & sayi2>sayi3:
13 |   print("En Büyük:",sayi2)
14 |   if sayi1>sayi3:
15 |     print("En Küçük",sayi3)
16 |   else:
17 |     print("En Küçük",sayi1)
18 |     
19 | elif sayi3>sayi1 & sayi3>sayi2:
20 |   print("En Büyük",sayi3)
21 |   if sayi1>sayi2:
22 |     print("En küçük",sayi2)
23 |   else:
24 |     print("En Küçük",sayi1)
25 | else:
26 |   print("yok")
27 | 


--------------------------------------------------------------------------------
/classesPart1.py:
--------------------------------------------------------------------------------
 1 | """ 25/12/2020 Object Orianted Programming - Classes"""
 2 | """Ortak özellikleri ve fonksiyonları bir arada tutup erişmemizi sağlarlar."""
 3 | 
 4 | class Matematik :
 5 |     
 6 |     def _init_(self,sayi1,sayi2):
 7 |         self.sayi1 = sayi1
 8 |         self.sayi1 = sayi2
 9 |         
10 |     def topla(self):
11 |         return self.sayi1 + self.sayi2
12 |     
13 |     def cikar(self):
14 |         return self.sayi1 - self.sayi2
15 |         
16 |     def carp(self):
17 |         return  self.sayi1 * self.sayi2
18 |     
19 |     def bol(self):
20 |         return self.sayi1 / self.sayi2
21 |     
22 |     
23 |     
24 | 
25 | 
26 | 


--------------------------------------------------------------------------------
/databaseOperationsPart8.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Database Connections
 2 |     chinook.db dosyasını kendi dizinimize taşıdık ve üzerinden işlemler yapacağız.
 3 |     delete operasyonu
 4 | 
 5 | """
 6 | import sqlite3
 7 | 
 8 | # customerid si 60 olan müşteiriyi silelim.
 9 | def deleteCustomer():
10 |     connection = sqlite3.connect('chinook.db')
11 |     cursor = connection.execute("""
12 |                                  delete from Customers  where customerid=60                                                     
13 |                                 """)
14 |     connection.commit()
15 |     connection.close()
16 |     
17 |     
18 | 
19 | deleteCustomer()
20 | 


--------------------------------------------------------------------------------
/stringFunctionsPart2.py:
--------------------------------------------------------------------------------
 1 | #12/12/2020 substring() fonksiyonu
 2 | 
 3 | #Python da string ifadeler string dizi olarak tutulur .Yani indisleri vererek string dizi içerisindeki karakterlere veya karakter dizisine erişebiliriz.
 4 | 
 5 | message = 'Hello World'
 6 | 
 7 | print(message[1])
 8 | 
 9 | #Substring metodu string dizisini ayrıma işlemini gerçekleştirir.
10 | #İndis değerlerini aralık olarak verebiliriz.Sadece o aradaki string ifadeyi döndürür.
11 | newMessage = message[2:5]
12 | print(newMessage)
13 | 
14 | print(message[:4])#Başlangıç değerini vermez isek en baştan verilen indise kadar alır.
15 | print(message[2:])#Bitiş değerini vermezsek verilen indisten en son değere kadar alır.
16 | 


--------------------------------------------------------------------------------
/databaseOperationsPart7.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Database Connections
 2 |     chinook.db dosyasını kendi dizinimize taşıdık ve üzerinden işlemler yapacağız.
 3 |     update operasyonu
 4 | 
 5 | """
 6 | import sqlite3
 7 | 
 8 | # Şehri Prague olan customerların şehrini Ankara olarak güncelleme.
 9 | def updateCustomer():
10 |     connection = sqlite3.connect('chinook.db')
11 |     cursor = connection.execute("""
12 |                                  Update Customers set city='Ankara' where city='Prague'                                                     
13 |                                 """)
14 |     connection.commit()
15 |     connection.close()
16 |     
17 |     
18 | 
19 | updateCustomer()
20 | 


--------------------------------------------------------------------------------
/Numpy/numpyArrayPart5.py:
--------------------------------------------------------------------------------
 1 | """ 04/01/2021 İndexing """
 2 | 
 3 | import numpy as np 
 4 | 
 5 | numbers = np.array([0,5,10,15,20,25,30])
 6 | # Dizinin elemanlarını tersten yazdırır.
 7 | print(numbers[::-1])
 8 | 
 9 | print(numbers[6])
10 | # Dizinin elemanlarını 0. indisten 3 üncü indise kadar 3. indis dahil değil yazdırır.
11 | print(numbers[0:3])
12 | 
13 | 
14 | numbers2 = np.array([[0,5,10],[15,20,25]])
15 | # Tüm satırlarda 2. indisi alır.
16 | print(numbers2[:,2])
17 | 
18 | # Tüm satırlarda o. sütundan 2. sütuna kadar olan elemanları al.
19 | print(numbers2[:,0:2])
20 | 
21 | # Tüm sütunlarda -1 .ci satıra kadar olan elemanları al.
22 | print(numbers2[-1,:])
23 | 
24 | print(numbers2[:,-1])
25 | 


--------------------------------------------------------------------------------
/modulesPart2.py:
--------------------------------------------------------------------------------
 1 |  # mathModule ü burada import edip içerisindek,i fonksiyon  ve özellikleri kullanabiliriz.
 2 | #%%
 3 | import mathModule 
 4 | 
 5 | mathModule.sum(1,2)
 6 | mathModule.diff(5,3)
 7 | 
 8 | #%%
 9 | 
10 | #%%
11 | # Moduleleri import ederken program içerisinde farklı bir isimle erişmek istersek as ile takma ad koyabiliriz.
12 | import mathModule as mm
13 | 
14 | mm.sum(56,2)
15 | 
16 | #%%
17 | 
18 | 
19 | #%%
20 | # Module içerisinde sadece bir fonksiyona yada özelliğe erişmek istersek sadece o fonksiyonu import edebiliriz.
21 | from mathModule import sum
22 | mathModule.sum(1,2)
23 | #%%
24 | 
25 | #%%
26 | from mathModule import customer
27 | 
28 | print(customer['firstName'])
29 | #%%
30 | 


--------------------------------------------------------------------------------
/functionsPart1.py:
--------------------------------------------------------------------------------
 1 | # 22/12/2020 Functions
 2 | """Bir kodu birden fazla yerde kullanmamız gerekiyorsa her yerde teker teker yazmamızı engeller."""
 3 | """Örneğin uygulmanızda kdv tanımları bir çok yerde lazım ve bunları tek tek yapmamız gerekiyorsa kdv miktarını geriye
 4 | dönen bir fonksiyon yaptığımız zaman istediğimiz yerlerde bu fonksiyonu çağırabiliriz.
 5 | Her alanda farklı kdv tanımlanıyor diye düşünürsek fonksiyona parametre olarak hangi kdv tanımı istendiği gönderip
 6 | gönderilen değere göre kdv değerini bulup döndürebiliriz."""
 7 | 
 8 | # The function greets to person passed is a parameter.
 9 | def greet(name):
10 |     
11 |     print('Helloo '+name+'.Good Morning !')
12 | 
13 | 
14 | greet('Melike')
15 | 


--------------------------------------------------------------------------------
/exceptionHandlingPart1.py:
--------------------------------------------------------------------------------
 1 | """28/12/2020 Exception Handling"""
 2 | """ Herhangi bir hata olduğu zaman yakalamak için try except bloklarını kullanırız.
 3 |     try daki kod bloğu çalışmazsa alttaki except ,oda çalışmazsa alttaki except çalışır.
 4 |     ValueError-tip hatası ,ZeroDivisionError -sıfıra bölünememe hatası şeklinde pythonda hata türleri vardır.
 5 | """
 6 | 
 7 | try :
 8 |     sayi = int(input('Lütfen bir sayı giriniz :'))
 9 | except ValueError:
10 |     print('Tip uyuşmazlığı,lütfen sayı girin..')
11 | 
12 | except ZeroDivisionError:
13 |     print('Sıfıra bölünme hatası ,Payda sıfır olamaz.')
14 |     
15 | except:
16 |     print('Sebebi bilinemeyen bir hata oluştu.')
17 |     
18 |     
19 |     
20 | print('Bitti') 
21 | 


--------------------------------------------------------------------------------
/iterators.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Iterators 
 2 | 
 3 | iterator
 4 | Elinizde bir tane liste var ise ve elemanlarını tek tek dolaşmak istiyorsak iterator yöntemini kullanabiliriz.
 5 | Kendi iteratorlerimizi yazabiliriz.
 6 | iter() fonksiyonu ile kendi ıteratorümüzü oluştururuz..
 7 | next() ile tüm elemanları dolaşabiliriz.
 8 | next() sırasıyla elemanları dolaşır.
 9 | """
10 | cities = ['Ankara','İstanbul','Van']
11 | 
12 | 
13 | iterator = iter(cities)
14 | # next() ile her seferinde bir sonraki elemana erişiriz.
15 | # Eğer bir sonraki eleman yoksa hata alırız.
16 | print(next(iterator))
17 | print(next(iterator))
18 | print(next(iterator))
19 | 
20 | 
21 | # for döngüsünde arka planda iteratorler kullanılır.
22 | for city in cities:
23 |     print(city)
24 | 


--------------------------------------------------------------------------------
/functionsPart2.py:
--------------------------------------------------------------------------------
 1 | # 22/12/2020 Functions
 2 | 
 3 | # Fonksiyonlar tekrar tekrar kullanılabilir.
 4 | # Fonksiyonlara parametre olarak verilen değerlere default value atanabilir.
 5 | # Fakat birden fazla parametre içerisinde bazıları default değer alırken bazıları almıyorsa default değer alan parametreler en sağda-en sonda tanımlanmalıdır.
 6 | 
 7 | def selamVer(isim):
 8 |     print('Merhaba '+isim)
 9 | 
10 | selamVer('Melike')
11 | selamVer('Selin')
12 | selamVer('Selena')
13 | 
14 | 
15 | def selamVer2(isim,soyisim = 'Arkadaş'):
16 |     print('Merhaba '+isim+' '+soyisim)
17 |     
18 | 
19 | selamVer2('Derin')
20 | 
21 | selamVer2('Derin','Otto')
22 | 
23 | def selamVer3(isim='ziyaretçi',soyisim = 'Arkadaş'):
24 |     print('Merhaba '+isim+' '+soyisim)
25 | 


--------------------------------------------------------------------------------
/mapping.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Mapping 
 2 |     Mapping tüm programlama dillerinde olan bir terimdir.
 3 |     Kelime anlamı haritalamak,eşitlemek şeklindedir.
 4 |     Örneğin elimizde K nesnesi olsun ve bu nesnenin isim,soyisim,adres şeklinde özellikleri olsun.
 5 |     Bu nesnenin özelliklerini aynı veya farklı şekilde M nesnesine aktarmak için map() komutu kullanılır.
 6 | 
 7 | """
 8 | # Bir listenin elemanlarının karesini alıp yeni bir diziye atmanın iki yöntemi vardır.
 9 | # for ile dönerek yapabiliriz veya map() ile yapabiliriz.
10 | 
11 | numbers = [1,2,3,4,5]
12 | 
13 | numbers_sqrt = list(map(lambda number : number**2,numbers))
14 | numbers2=[]
15 | for x in numbers :
16 |     numbers2.append(x*x)
17 |     
18 |     
19 | print(numbers_sqrt)
20 | print(numbers2)
21 | 


--------------------------------------------------------------------------------
/databaseOperationsPart9.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Database Connections
 2 |     chinook.db dosyasını kendi dizinimize taşıdık ve üzerinden işlemler yapacağız.
 3 |     join operasyonu
 4 | 
 5 | """
 6 | 
 7 | import sqlite3
 8 | 
 9 | def joinOperations():
10 |     connection = sqlite3.connect("chinook.db")
11 |     cursor = connection.execute("""select 
12 |                                     	albums.Title,artists.name
13 |                                    from artists
14 |                                    inner join albums on artists.ArtistId = albums.ArtistId
15 |                                    """)                               
16 |     for row in cursor:
17 |         print("Title: "+row[0]+" "+"Name:"+row[1])
18 |         
19 |     connection.close()
20 | 
21 | joinOperations()
22 | 


--------------------------------------------------------------------------------
/variablesPart1.py:
--------------------------------------------------------------------------------
 1 | # Verileri değişkenlerde tutarız.
 2 | haber="Saaat 9 s kadar sokağa çıkma yasaklandı."
 3 | vade = 12
 4 | faizOranı=1.58
 5 | print(haber)
 6 | print(type(faizOranı))
 7 | # type fonksiyonu ile verilerin hangi türden olduğunu öğrenebiliriz.
 8 | 
 9 | mesaj="Hoşgeldin"
10 | musteriAdı="Melike"
11 | musteriSoyadı="Eryılmaz"
12 | # Program içerinde bir ifadeyi birden çok yerde kullanacaksak bunu bir değişkene atarız.
13 | # Böylece değişkenin değerini değiştirmek istersek sadece tanımlandığı yerde değiştirmemiz yeterli olur.
14 | print("Ad Soyad:",musteriAdı+" "+musteriSoyadı)
15 | sonucMesaji=mesaj+" "+musteriAdı+" "+musteriSoyadı
16 | print("Mesaj:",sonucMesaji)
17 | 
18 | birinciSayı=12
19 | ikinciSayi=14
20 | print("Toplam:",birinciSayı+ikinciSayi)
21 | 
22 | print("Mesaj",sonucMesaji)
23 | 


--------------------------------------------------------------------------------
/functionsPart4.py:
--------------------------------------------------------------------------------
 1 | # 22/12/2020 lambda fonksiyonlar 
 2 | # lambda fonksiyonlar bir çok satırdan oluşan operasyonları tek satıra indirgememizi sağlar.
 3 | 
 4 | 
 5 | # '#%%' arasına kodlarımızı yazıp sadece bu aradaki kodların çalışabilmesi için sağ tık run cell yapabiliriz.(syper editöründe)
 6 | #%%
 7 | def dikucgenalanihesapla(a,b):
 8 |     return a*b/2;
 9 | 
10 | 
11 | alan=dikucgenalanihesapla(3,4)
12 | print(alan)
13 | 
14 | 
15 | #%%
16 | #Üstteki fonksiyonu lambda kullanarak aşağıdaki şekilde yazabiliriz.
17 | 
18 | dikucgenalanihesapla2 =lambda a,b : a*b/2
19 | print(dikucgenalanihesapla2(3, 6))
20 | print(type(dikucgenalanihesapla2))
21 | 
22 | #Birçok dilde yapılamayan fonksiyonu aşağıdaki gibi bir değişkene atama işlemi pythonda yapılabilmektedir.
23 | #Bir alt satırda x(4,5) şeklinde fonksiyon çağrılmıştır.
24 | x= dikucgenalanihesapla2 
25 | print(x(4,5))
26 | 
27 | 
28 | 
29 | 
30 | 


--------------------------------------------------------------------------------
/fileOperationsPart2.py:
--------------------------------------------------------------------------------
 1 | """ 27/12/2020 File Operations """
 2 | #%%
 3 | # a mode :append mode dosyanın sonuna ekleme yapmamızı sağlar.
 4 | # Direkt sonuna boşluk vs koymadan ekleme yapar .
 5 | # \n ile bir satır in dedikten sonra yazabiliriz.
 6 | fileToAppend = open('students.txt','a')
 7 | fileToAppend.write('\n')
 8 | fileToAppend.write('Hellooo')
 9 | fileToAppend.close()
10 | 
11 | #%%
12 | 
13 | 
14 | #%%
15 | # append ile dosyanın sonuna yazarken write ile dosyanın üzerine yazarız.
16 | fileToAppend = open('students.txt','w')
17 | fileToAppend.write('\n')
18 | fileToAppend.write('melike')
19 | 
20 | #%%
21 | 
22 | #%%
23 | # Dosyaları silmek için os kütüphanesi kullanılır.
24 | import os 
25 | 
26 | if os.path.exists('exampleFile.txt'):
27 |     os.remove()
28 | else:
29 |     print('Dosya yok')
30 | 
31 | # Dizini silmek için rmdir() fonksiyonu kullanılır.
32 | os.rmdir('empty')
33 | 
34 | #%%
35 | 


--------------------------------------------------------------------------------
/databaseOperationsPart2.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Database Connections
 2 |     chinook.db dosyasını kendi dizinimize taşıdık ve üzerinden işlemler yapacağız.
 3 | 
 4 | """
 5 | # Python da sqlite veritabanını kullanabilmek için sqlite3 modülünü import etmeliyiz.
 6 | import sqlite3
 7 | 
 8 | # sqlite3.connect() komutuyla database e bağlanıyoruz.
 9 | connection = sqlite3.connect("chinook.db")
10 | 
11 | 
12 | # Göndereceğimiz sorguyu cursor ile connection.execute() ile yazar göndeririz.
13 | # Burada istediğimiz sorguyu gönderebiliriz.
14 | # cursor = connection.execute("Select * from Customers")
15 | # cursor = connection.execute("Select FirstName,LastName from Customers")
16 | cursor = connection.execute("Select FirstName,LastName from Customers where city='Prague'")
17 | for row in cursor:
18 |     print("First Name : "+row[0])
19 |     print("Last Name : "+row[1])
20 |     print('*****************')
21 |     
22 | # connection ı kapatıyoruz.
23 | connection.close()
24 | 


--------------------------------------------------------------------------------
/jsonOperationsPart1.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 json 
 2 | 
 3 |     Veri sistemleri içerisinde verilerin konuşabilmesi için belirlenen formatlar vardır.xml,json gibi.
 4 |     JSON (JavaScript Object Notation – JavaScript Nesne Notasyonu) 
 5 |     insanlar için okunabilir olan bilgi saklama ve alışveriş formatıdır. 
 6 |     Bir JSON dosyası sadece metin kapsar ve .json uzantısını kullanır.
 7 | 
 8 | """
 9 | 
10 | import json
11 | 
12 | # string den json oluşturmqk için ..
13 | stringData = '{"firstName" : "ece","lastName" :"eren"}'
14 | 
15 | jsonData = json.loads(stringData)
16 | 
17 | # print(type(jsonData))
18 | 
19 | print(jsonData["firstName"])
20 | print(jsonData["lastName"])
21 | 
22 | 
23 | # Dictionary den json oluşturmak için..
24 | Users =  {
25 |     "userId": 1,
26 |     "id": 1,
27 |     "title": "delectus aut autem",
28 |     "completed": "false"
29 |   }
30 | 
31 | userJson = json.dumps(Users)
32 | 
33 | # print(type(userJson))
34 | 
35 | print(json.dumps("ece"))
36 | 


--------------------------------------------------------------------------------
/Workshops/matrixSums.py:
--------------------------------------------------------------------------------
 1 | """
 2 |     24/12/2020 İki matirisin toplamını hesaplayan uygulama
 3 |     Matris toplamları şu şekilde hesaplanmaktadır.
 4 |     x[0][0]+y[0][0] = z[o][0]
 5 |     Bunun için x i gezmek için bir döngü y yi gezmek için bir döngü tanımlayabiliriz.
 6 | 
 7 | """
 8 | 
 9 | matris1 =[[1,2,3],
10 |           [4,5,6],
11 |           [4,5,6]]
12 |           
13 |           
14 | matris2 =[[1,2,3],
15 |           [4,5,6],
16 |           [4,5,6]]
17 | 
18 | matris3 =[[0,0,0],
19 |           [0,0,0],
20 |           [0,0,0] ]         
21 | # sabit uzunluk vererek
22 | for x in range(0,3):
23 |     for y in range(0,3):
24 |         matris3[x][y] = matris1[x][y]+matris2[x][y]
25 |     
26 |     
27 | print(matris3)
28 | 
29 | # Matrislerin uzunluğunu vererek
30 | for x in range(len(matris1)):
31 |     for y in range(len(matris2)):
32 |         matris3[x][y] = matris1[x][y]+matris2[x][y]
33 |         
34 |         
35 | print(matris3)
36 | 
37 | 
38 | 
39 | 
40 | 
41 | 


--------------------------------------------------------------------------------
/classesPart3.py:
--------------------------------------------------------------------------------
 1 | """ 25/12/2020 Object Orianted Programmimng -Class -İnit functions and self details
 2 |     
 3 |     Class lar çağrıldığı zaman her zaman arkada çalışan bir constructor bloğu bulunur.
 4 |     Python da constructor init fonksiyonudur.
 5 |     Constructor içerisinde fonksiyonların alacağı parametreleri belirleyip fonksiyonların 
 6 |     içersinde o parametrelere self ile erişebiliriz.
 7 | 
 8 | """
 9 | class Matematik :
10 |     
11 |     def __init__(self,sayi1,sayi2):
12 |         self.sayi1 = sayi1
13 |         self.sayi2 = sayi2
14 |         
15 |     def topla(self):
16 |         return self.sayi1 + self.sayi2
17 |     
18 |     def cikar(self):
19 |         return self.sayi1 - self.sayi2
20 |         
21 |     def carp(self):
22 |         return  self.sayi1 * self.sayi2
23 |     
24 |     def bol(self):
25 |         return self.sayi1 / self.sayi2
26 |     
27 |     
28 |     
29 | matematik = Matematik(1,2)
30 | 
31 | print('Toplam :'+ str(matematik.topla()))
32 | 
33 | 


--------------------------------------------------------------------------------
/tuplePart2.py:
--------------------------------------------------------------------------------
 1 | #17/12/2020 Tuple
 2 | """
 3 | Python tuple
 4 | Tuple lar read only yani sadece okunabilir sistemlerdir.
 5 | Perfomans gerektiren sistemlerde tuple veri yapısı tercih edilebilir.
 6 | Tuple içerisinde diziler,tuple lar eleman olarak yer alabilir.
 7 |   """
 8 | tupleListe = (1,2,'Hello',(1,'melike',1.2),[])
 9 | liste = [1,2,3,'Hello',(1,2,'a'),[2]]
10 | 
11 | 
12 | #Listelerde elemanlar değişebiliyorken tupleListe lerde değişiklik yapılamaz.
13 | #
14 | liste[2]='yeni'
15 | # tupleListe[3] = 'êlma'  #Tuple object does not support assigment hatası verir.
16 | 
17 | tupleDeger = ('Melek',)
18 | print(type(tupleDeger))
19 | 
20 | #Tuple listelerde 1:2 belirtildiğinde  1.index ten 2.ye kadar 2.dahl değil şeklinde alınır.
21 | print(tupleListe[1:2])
22 | print(liste[1:2])
23 | 
24 | #-2 inci index ler sağdan 2. anlamına gelir.
25 | #Diziler ve tuple larda aynı şekildedir.
26 | print(tupleListe[-2])
27 | 
28 | print(liste[-2])
29 | 
30 | print(type(tupleListe))
31 | print(type(liste))
32 | 
33 | print(tupleListe)
34 | print(liste)
35 | 


--------------------------------------------------------------------------------
/Numpy/numpyArrayPart1.py:
--------------------------------------------------------------------------------
 1 | 
 2 | """
 3 | 04/01/2021
 4 | Veri analizi ---Python
 5 | Pythonda veri analizinde kullanılan iki temel kütüphane numpy ve pandasdır. 
 6 | 
 7 | numpy --> num-py -sayısal python kütüphanesidir.
 8 | Diziler üzerinden işlemler gerçekleştirilir.
 9 |   
10 | """
11 | import numpy as np
12 | 
13 | # havaDurumu = [[12,23,34],[24,27,22],[12,26,16]]
14 | # print(havaDurumu)
15 | 
16 | # numpy arange() ile 0 dan verilen sayıya kadar bir array oluşturur.
17 | nparray = np.arange(15)
18 | print(nparray)
19 | 
20 | # Numpy ile oluşturduğumuz diziyi yeniden boyutlandırmak-yapılandırmak için reshape(satir,sütun) kullanırız.
21 | nparray_reshape = np.arange(15).reshape(3,5)
22 | print(nparray_reshape)
23 | print(type(nparray_reshape))
24 | # Dizinin boyutunu bulmak için ndim kullanılır.
25 | print("Dimension Count = "+str(nparray_reshape.ndim))
26 | 
27 | 
28 | # Kaç elemanlı ,boyutlu bir dizi olduğunu bulmak için shape kullanırız..
29 | nparray1 = np.arange(10)#10 elemanlı 1 boyutlu..
30 | print(nparray1.shape)
31 | print(nparray1.ndim)
32 | 


--------------------------------------------------------------------------------
/variablesPart2.py:
--------------------------------------------------------------------------------
 1 | #12/12/2020 14:30
 2 | #Python Değişkenler
 3 | 
 4 | #Değişken : Elimizde çeşitli veri türleri bulunmakta ve 
 5 | #bu değerlere program içerinde erişmek istiyorsak bunları hafızada değişkenler ile tutabiliriz.
 6 | #Uygulama içerisinde değerleri tutucu hafıza olarak düşünülebilir.
 7 | 
 8 | #Python da değişkenleri tanımlarken diğer dillerdeki gibi tip belirtmek zorunlu değildir.
 9 | 
10 | sayi = 12
11 | isim = 'Melike'
12 | soyisim = 'Eryılmaz'
13 | tc = '12345678901'
14 | telefonNumarasi = '053683333333'
15 | floatSayi = 12.44
16 | 
17 | 
18 | #tc bir string şekilde tanımlanmış değişken olduğu için float tipine dönüştürüp işlem yaptık.
19 | #Eğer floata dönüştürmeden string ifade ile sayıyı toplamaya çalışsaydık hata verirdi.String ile sayı toplanamaz.
20 | print(float(tc)+23)
21 | 
22 | #type() fonksiyonu geriye değişkenin tipini döndürür.
23 | print(type(floatSayi))
24 | 
25 | print(type(sayi))
26 | 
27 | print(type(tc))
28 | 
29 | #Spyder ıdesinde variable explorer adında yazılan kodların sonuçlarını grid şeklinde bir yapıda gösteren özellik 
30 | #bulunmaktadır.(View-Panes-Variable Explorer)
31 | 


--------------------------------------------------------------------------------
/breakAndcontinue.py:
--------------------------------------------------------------------------------
 1 | # 22/12/2020 break continue
 2 | # break bağlı bulunulan döngü için döngüyü bitirmek demektir.
 3 | # Örnek kullanım olarak :Uygulamanıza bir veri geldi ,eğer o veri gelirse bir sonraki adımları
 4 | # çalıştırmak istemiyorsanız ,uygulamayı orda kırmak için break kullanırız.
 5 | 
 6 | sehirler = ['Ankara','İstanbul','İzmir']
 7 | 
 8 | 
 9 | # Aşağıdaki gibi gelen veri İstanbul olunca işlemlere devam etmek istemiyorsak kullanırız.
10 | # Dikkat for iteration sonlandı diğer sehir için dönmedi.
11 | for sehir in sehirler :
12 |     if sehir == 'İstanbul':
13 |         break
14 |      
15 |     print('Şehir :',sehir)
16 |     print('*************')
17 | 
18 | 
19 | # continue ise döngüde sadece o anki değerde işlemleri geçip diğerlerinde devam eder.
20 | # break te karşılaşılan değerden sonra diğer değerlere bakılmamıştı ,continue da değerler tek tek değerlendirilir.
21 | 
22 | # Yani break döngüyü tamamen sonlandırırken continue sadece o anki loopu sonlandırır.
23 | for sehir in sehirler :
24 |     if sehir == 'İstanbul':
25 |         continue
26 |      
27 |     print('Şehir :',sehir)
28 |     print('*************')
29 | 


--------------------------------------------------------------------------------
/Workshops/basicCalculator.py:
--------------------------------------------------------------------------------
 1 | """ 27/12/2020 Hesap makinesi
 2 |     Kullanıcıdan yapılacak olan işlemi ve iki adet sayıyyı alarak fonskiyonlar ile 
 3 |     sonucu hesaplama ve ekrana yazdırma örneğidir.
 4 | 
 5 | """
 6 | def sumOp(number1,number2):
 7 |     return number1+number2
 8 | 
 9 | def difOp(number1,number2):
10 |     return number1-number2
11 | 
12 | def impactOp(number1,number2):
13 |     return number1*number2
14 | 
15 | def partitionOp(number1,number2):
16 |      return number1/number2
17 | 
18 | print('Lütfen yapmak istediğiniz operasyonu seçiniz..')
19 | print(' 1 : Topla')
20 | print(' 2 : Çıkar')
21 | print(' 3 : Çarp')
22 | print(' 4 : Böl')
23 | 
24 | operations = int(input('Operasyon ? :'))
25 | number1    = int(input('Birinci sayı :'))
26 | number2    = int(input('Birinci sayı :'))
27 | 
28 | if operations == 1:
29 |     sonuc = sumOp(number1,number2)
30 |     
31 | elif operations == 2:
32 |     sonuc = difOp(number1,number2)
33 |     
34 | elif operations == 3:
35 |     sonuc = impactOp(number1,number2)
36 |     
37 | elif operations == 4:
38 |     sonuc = partititonOp(number1,number2)
39 | else :
40 |     print('Geçersiz seçim yaptınız..')
41 |     
42 | print('Sonuc:',sonuc)
43 | 


--------------------------------------------------------------------------------
/databaseOperationsPart4.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Database Connections
 2 |     chinook.db dosyasını kendi dizinimize taşıdık ve üzerinden işlemler yapacağız.
 3 | 
 4 | """
 5 | import sqlite3
 6 | 
 7 | connection = sqlite3.connect("chinook.db")
 8 | 
 9 | """ Aşağıdaki sorguda  şehirlere göre gruplayarak en çok müşteri olan şehri ve müşteri sayısını buluyoruz.Azalan sırada getiriyoruz."""
10 | 
11 | """                            
12 |                               Select city,count(*) 
13 |                                from Customers 
14 |                                group by city
15 |                                having count(*)>1
16 |                                order by count(*) desc
17 | """
18 | 
19 | cursor = connection.execute("""Select city,count(*) 
20 |                                from Customers 
21 |                                group by city
22 |                                having count(*)>1
23 |                                order by count(*) desc
24 |                                """)
25 | for row in cursor:
26 |     print("City : "+row[0])
27 |     print("Count : "+str(row[1]))
28 |     print('*****************')
29 |     
30 | # connection ı kapatıyoruz.
31 | connection.close()
32 | 


--------------------------------------------------------------------------------
/Numpy/numpyArrayPart4.py:
--------------------------------------------------------------------------------
 1 | """ 04/01/2021 Basic Operations"""
 2 | 
 3 | import numpy as np
 4 | a = np.array([20,30,40,50])
 5 | b = np.arange(4)
 6 | 
 7 | print("a dizisi :",a)
 8 | print("b dizisi :",b)
 9 | 
10 | c = a-b #İki diziye birbirinden çıkarabiliriz.Aynı indislerde işlem yapar.
11 | print("c dizisi :",c)
12 | 
13 | d = b**3 #Dizinin kübünü alır.
14 | print("d dizisi :",d)
15 | 
16 | e = 10 * np.sin(a) #Dizinin sinüsünü alıp 10 ile çarpar.
17 | print("e dizisi :",e)
18 | 
19 | # Elemanlar 7 den küçük mü bakar küçükse true değilse false şeklinde yeni bir dizi oluşturur.
20 | print("e dizisi küçük 7 :",e<7)
21 | # İki diziyi çarpar.
22 | print("a*b dizisi :",a*b)
23 | # Matris çarpımı için @ kullanılır.
24 | print("a@b dizisi :",a@b)
25 | 
26 | print("a.dot(b) dizisi :",a.dot(b))
27 | 
28 | f = np.ones((2,4))
29 | print("f dizisi :",f)
30 | 
31 | g = np.zeros((2,4))
32 | print("g dizisi :",g)
33 | 
34 | h = np.random.random((2,4))
35 | print("h dizisi :",h)
36 | 
37 | i = np.sum(b)
38 | print("i dizisi :",i)
39 | 
40 | print("b.sum() dizisi :",b.sum())
41 | 
42 | j = np.min(b)
43 | print("j dizisi :",j)
44 | 
45 | k = np.max(b)
46 | print("k dizisi :",k)
47 | 
48 | l = np.sqrt(a)
49 | print("l dizisi :",l)
50 | 


--------------------------------------------------------------------------------
/classesPart2.py:
--------------------------------------------------------------------------------
 1 | """ 25/12/2020 Object Orianted Programming - Classes"""
 2 | """Ortak özellikleri ve fonksiyonları bir arada tutup erişmemizi sağlarlar."""
 3 | 
 4 | """" 25/12/2020 Object Orianted Programming 
 5 |     Classlar genel olarak bakıldığında bir şeyleri organize etmek için kullanılırlar.
 6 |     Örneğin uygulamanızda birden fazla yerde kullanmak istediğiniz belirli işlemleri gerçekleştiren 
 7 |     fonksiyonlarınız var ve bunlara hemen hızlıca erişmek istiyorsanız class içerisinde birbiriyle ilişkili
 8 |     fonksiyonları toplayarak ilgili fonksiyona classlar üzerinden hızlıca erişebiliriz.
 9 | 
10 | """
11 | class Matematik :
12 |     
13 |     def __init__(self,sayi1,sayi2):
14 |         self.sayi1 = sayi1
15 |         self.sayi2 = sayi2
16 |         
17 |     def topla(self,sayi1,sayi2):
18 |         return self.sayi1 + self.sayi2
19 |     
20 |     def cikar(self,sayi1,sayi2):
21 |         return self.sayi1 - self.sayi2
22 |         
23 |     def carp(self,sayi1,sayi2):
24 |         return  self.sayi1 * self.sayi2
25 |     
26 |     def bol(self,sayi1,sayi2):
27 |         return self.sayi1 / self.sayi2
28 |     
29 |     
30 |     
31 | matematik = Matematik(1,2)
32 | 
33 | print('Toplam :'+ str(matematik.topla(1,4)))
34 | 
35 | 


--------------------------------------------------------------------------------
/exceptionHandlingPart2.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020  Exception Handling - Hata Yakalama
 2 |     Bize gelen bir dizi içerisinde gelmesi gereke değerlerden farklı değerler de yanlışlıkla geldiğini düşünelim.
 3 |     Örneğin sayılardan oluşan bir dizi gelmesi gerekirken string ifadeler de karışmış olsun.
 4 |     Dolayısıyla dizi hatasız sayılardan gelecek diye düşünüp try except olmadan program kodu yazarsak hataları yakalayamayız.
 5 |     try except kullanarak hataları yakalayalım.
 6 | 
 7 | """
 8 | # sistem üzerinden verilen hataları okumak için sys kütüphanesini import ediyoruz.
 9 | import sys
10 | 
11 | data = [1,2,'abc',"6",0]
12 | 
13 | for x in data:
14 | 
15 |     try:
16 |         print('Sayı : '+str(x))
17 |         result = 1/int(x)
18 |         print('Sonuc :',result)
19 |     except ValueError:
20 |         print(str(x)+' bir sayı değil!')
21 |         
22 |     except ZeroDivisionError:
23 |         print('Sıfıra Bölme hatası')
24 |     except :
25 |         print(str(x)+' hesaplanamadı.')
26 |         print('Sistem tarafından :',sys.exc_info([0]))
27 |     finally:#finally kod bloğu her halukarda çalışır.Dosyalarla işlemler yaparken finally kod bloğunu en son dosyayı kapatmak için kullanabiliriz..
28 |         print('İşlemler sonlandı.')
29 | 


--------------------------------------------------------------------------------
/databaseOperationsPart6.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Database Connections
 2 |     chinook.db dosyasını kendi dizinimize taşıdık ve üzerinden işlemler yapacağız.
 3 |     select operasyonlarını function haline getirme ve insert operasyonları
 4 | 
 5 | """
 6 | import sqlite3
 7 | 
 8 | def selectOperations():
 9 |     connection = sqlite3.connect("chinook.db")
10 |     cursor = connection.execute("""Select FirstName,LastName 
11 |                                    from Customers where firstName like '%s'
12 |                                    """)                               
13 |     for row in cursor:
14 |         print("First Name : "+row[0])
15 |         print("Last Name : "+row[1])
16 |         print('*****************')
17 |         
18 |     connection.close()
19 | 
20 | def insertCustomer():
21 |     connection = sqlite3.connect('chinook.db')
22 |     cursor = connection.execute("""
23 |                                 insert into customers(FirstName,LastName,Email) 
24 |                                 values('Melike','Eryılmaz','default@gmail.com')                                                      
25 |                                 """)
26 |     # veriyi insert etmek için commit() etmeliyiz..
27 |     connection.commit()
28 |     connection.close()
29 |     
30 | 
31 |     
32 |     
33 | selectOperations()
34 | insertCustomer()
35 | 


--------------------------------------------------------------------------------
/arraysPart4.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """
 3 | Created on Thu Dec 17 11:07:47 2020
 4 | 
 5 | @author: Melike.Eryilmaz
 6 | """
 7 | 
 8 | # Eğer birden fazla oğrenciniz olan bir öğretmen olsaydınız oğrencilerinizi ayrı ayrı yerlerde tutmak yerine
 9 | #tek bir listede sıra ile tutmayı tercih ederdiniz .Dizilerde bu mantık ile çalışmaktadır.
10 | # ogrenci1 = "Melike"
11 | # ogrenci2 = "Leyla"
12 | # ogrenci3 = "Adnan"
13 | #17/12/2020
14 | 
15 | # print(ogrenci1)
16 | 
17 | # print(ogrenci2)
18 | 
19 | # print(ogrenci3)
20 | 
21 | 
22 | 
23 | ogrenciler = ['Melike','Leyla','Adnan']
24 | 
25 | print(ogrenciler[2]) 
26 | 
27 | #Diziye yeni bir eleman eklemek için append() fonksiyonu kullanılır.
28 | ogrenciler.append('Merve')
29 | 
30 | print(ogrenciler)
31 | 
32 | #Diziden bir eleman silmek için remove() fonksiyonu kullanılır.
33 | 
34 | ogrenciler.remove('Leyla')
35 | 
36 | print(ogrenciler)
37 | 
38 | #Dizi oluştururma list constructor ile de yapılabilir.
39 | 
40 | sehirler = list(('New york','Los Angeles','Boston'))
41 | print(sehirler)
42 | 
43 | print(len(sehirler))
44 | 
45 | #print(sehirler[3]) #Bu satırı açarsanız out of range hatası verir çünkü dizi 2 indexlidir şu anda.
46 | 
47 | sehirler.append('Şikago')
48 | 
49 | print(sehirler[3])# Burada ise bir üst satırda diziye yeni bir eleman eklendiği için hata vermemekte,dizinin 3. indexindeki elemanı ekranı yazdırmaktadır.
50 | 


--------------------------------------------------------------------------------
/databaseOperationsPart3.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Database Connections
 2 |     chinook.db dosyasını kendi dizinimize taşıdık ve üzerinden işlemler yapacağız.
 3 | 
 4 | """
 5 | # Python da sqlite veritabanını kullanabilmek için sqlite3 modülünü import etmeliyiz.
 6 | import sqlite3
 7 | 
 8 | # sqlite3.connect() komutuyla database e bağlanıyoruz.
 9 | connection = sqlite3.connect("chinook.db")
10 | 
11 | 
12 | # Göndereceğimiz sorguyu cursor ile connection.execute() ile yazar göndeririz.
13 | # Veritabanından string ifadeler order by asc olarak default gelir.
14 | 
15 | # Aşağıdaki sorgu Prague da yaşayan ,FistName olarak artan sırada ,FistName aynıysa LastName e göre artan sırada database den verileri getirmemizi sağlar.
16 | """                            
17 |                                Select FirstName,LastName 
18 |                                from Customers where city='Prague'
19 |                                order by FistName,LastName
20 | """
21 | 
22 | cursor = connection.execute("""Select FirstName,LastName 
23 |                                from Customers where city='Prague'
24 |                                order by FistName,LastName
25 |                                """)
26 | for row in cursor:
27 |     print("First Name : "+row[0])
28 |     print("Last Name : "+row[1])
29 |     print('*****************')
30 |     
31 | # connection ı kapatıyoruz.
32 | connection.close()
33 | 


--------------------------------------------------------------------------------
/databaseOperationsPart5.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Database Connections
 2 |     chinook.db dosyasını kendi dizinimize taşıdık ve üzerinden işlemler yapacağız.
 3 |     like deyimi
 4 | 
 5 | """
 6 | import sqlite3
 7 | 
 8 | connection = sqlite3.connect("chinook.db")
 9 | 
10 | 
11 | """                            
12 |     like deyimi içerisinde geçen anlamına gelmektedir.Belirli bir karakterle başlayan,biten,ya da içerisinde geçen 
13 |     verileri bulmak için like deyimini kullanabiliriz.                          
14 | """
15 | # FirstName inde a geçen müşterileri listelemek için
16 | # cursor = connection.execute("""Select FirstName,LastName 
17 | #                                from Customers where firstName like '%a%'
18 | #                                """)
19 |  # FirstName i w ile başlayan müşterileri listeleme
20 | # cursor = connection.execute("""Select FirstName,LastName 
21 | #                                from Customers where firstName like 'w%'
22 | #                                """)
23 | # FirstName i s ile biten müşterileri listeleme
24 | cursor = connection.execute("""Select FirstName,LastName 
25 |                                from Customers where firstName like '%s'
26 |                                """)                               
27 | for row in cursor:
28 |     print("First Name : "+row[0])
29 |     print("Last Name : "+row[1])
30 |     print('*****************')
31 |     
32 | connection.close()
33 | 


--------------------------------------------------------------------------------
/classesPart5.py:
--------------------------------------------------------------------------------
 1 | """ 25/12/2020 Object Orianted Programming Classes
 2 | 
 3 |     İnheritance : Ortak operasyonların bir yerde yazılıp her yerde kullanılabilmesi için kullanılır.
 4 |     Miras alma anlamına gelir.
 5 |     Örneğin Customer ve Worker sınıflarıda Person sınıfındandır.Person sınıfının özelliklerini alabilir.
 6 |     Ama Customer'ın kredikartınumarası varken Worker sınıfının maaş özelliği olabilir.
 7 |     Böyle durumlarda Customer ve Worker için iki ayrı sınıf -class oluşturup ortak olan özelliklerini ise 
 8 |     Person sınıfından miras alabiliriz.
 9 | """
10 | 
11 | class Person :
12 |     def __init__(self,firstName,lastName,age):
13 |         self.firstName = firstName
14 |         self.lastName = lastName
15 |         self.age      = age
16 |         
17 | # Worker Person dan miras olarak firstName,lastName,age özelliklerini alır.
18 | class Worker(Person):
19 |     def __init__(self,salary):
20 |         self.salary = salary
21 | # Customer Person dan miras olarak firstName,lastName,age özelliklerini alır.
22 | class Customer(Person):
23 |     def __init__(self,creditcardNumber):
24 |         self.creditcardNumber = creditcardNumber
25 |    
26 |         
27 | ahmet = Worker()
28 | # ahmet Person sınıfı özelliği olan fisrtName miras olarak almıştır.
29 | print(ahmet.firstName)
30 | print(ahmet.salary)
31 | 
32 | 
33 | mehmet = Worker()
34 | # mehmet Person sınıfı özelliği olan fisrtName miras olarak almıştır.
35 | print(mehmet.firstName)
36 | print(mehmet.creditcardNumber)
37 | 


--------------------------------------------------------------------------------
/databaseOperationsPart1.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Database Operations
 2 | """
 3 | 
 4 | """
 5 | Veritabanı nedir ?
 6 | Bir sosyal medyaya yada uygulamaya üye oluyorsunuz diyelim.
 7 | Girişte sizden alınan ad,soyad,telefon gibi bilgilerin tutulduğu sisteme vertabanı sistemleri denir.
 8 | Örneğin kullanıcı bilgileri Users tablosunda kullanıcıya ait fotoğraflar Photos tablosunda tutulsun.
 9 | Her kullanıcının bir fotoğrafı olabileceği için Users ve Photos tabloları birbiriyle ilişkilidir.
10 | Bu yapıdaki veritabanı sistemlerine ilişkisel veritabanı sistemleri denir.
11 | İlişkisel veri tabanı sistemleri yaygın olarak kulllanılır.
12 | Özetle veritabanı verilerin saklandığı yapılardır,ilişkisel veritabanı sistemleri de mevcuttur.
13 | """
14 | 
15 | """
16 | 
17 | Mssql server ,Microsoft tarafından geliştirlen ilişkisel verştabanı sistemidir.
18 | 
19 | Oracle ,ilişkisel verştabanı sistemidir.
20 | Mysql,Oracle tarafından satın alınmıştır.İlişkisel veritabanı sistemidir.
21 | SQLite
22 | 
23 | SQLite dosya üzerinden çalışabilme imkanı sunduğu ve mobil projelerde de
24 | kolaylıkla kullanılabilmesi açısından tercih ediliyor.
25 | 
26 | MongoDB ilişkisel vertabanı değildir.Nosql
27 | Büyük verilerde tercih edilen veritabanıdır.
28 | Json formatında data tutulur.
29 | Veritabanına yeni veriler eklenmek isteniyor .
30 | Daha performanslı çalışabilmek için mongodb kullanılır.
31 | 
32 | PostgreSql ,İlişkisel Veritabanına örnektir.
33 | 
34 | 
35 | 
36 | 
37 | 
38 | """
39 | 
40 | """
41 | Biz projemizde SQLite database kullanacağız.
42 | SQLite kolay olması,dosya üzerinden çalışabilme olanağı sağlaması ,mobilde ve diğer platformalardada
43 | rahatlıkla kullanılabilmesi sebebiyle tercih edilir.
44 | https://sqlitebrowser.org/ üzerinden sisteminize uygun version u kurabilirsiniz.
45 | 
46 | https://www.sqlitetutorial.net/ adrsinden sample database altından chinook database ini indirip sqllite da open database diyerek açalım.
47 | """
48 | 


--------------------------------------------------------------------------------
/setPart2.py:
--------------------------------------------------------------------------------
 1 | #17/12/2020 Setler
 2 | """
 3 | Setler de de elemanlar değiştirelemez ve sıralı değillerdir.
 4 | Oldukça hızlı çalışırlar.
 5 | Set lerde belirli elemanlarına erişmek için bir yöntem yoktur.
 6 | """
 7 | 
 8 | studentSet = {'Elif','Adnan','Gülbahar'}
 9 | print(studentSet)
10 | 
11 | 
12 | for student in studentSet:
13 |     print(student)
14 |     
15 | 
16 | 
17 | #Eğer Elif set içerisnde varsa true yoksa false döner.
18 | print('Elif' in studentSet)
19 | 
20 | 
21 | if 'Elif' in studentSet:
22 |     print('Listede var')
23 |     
24 | 
25 | #Setlere eleman eklemek için add() fonksiyonu kullanılır.
26 | studentSet.add('Ali')
27 | print(studentSet)
28 | 
29 | 
30 | studentSet.update(['Melisa','Ebru','İklim'])
31 | print(studentSet)
32 | 
33 | 
34 | print(len(studentSet))
35 | 
36 | studentSet.remove('Elif')
37 | print(len(studentSet))
38 | 
39 | # Üstte Elif elemanını silmiştik altta tekrar olmayan bie elemanı silemeye çalışırsak remove() keyerror hatasını fırlatır.
40 | #Eğer remove işlemi yaparken key yoksa hata vermemesini istersek discard() kullanırız.
41 | # studentSet.remove('Elif')
42 | print(len(studentSet))
43 | 
44 | #discard() silme işlemi yapar ve  eğer key yoksa hata fırlatmaz.
45 | studentSet.discard('Elif')
46 | print(len(studentSet))
47 | 
48 | 
49 | # pop() dizideki en son elemanı siler.Bellek içerisinde en üstte yer alanı siler.
50 | x = studentSet.pop()
51 | print(studentSet)
52 | print(len(studentSet))
53 | 
54 | 
55 | # clear() diziyi sıfır elemana ve boş bir sete çevirir.
56 | # clear() fonksiyonu seti oda gibi düşünürsek sadece odanın içini yani setin elemanlarını siler.Set durar.
57 | 
58 | y = studentSet.clear()
59 | print(studentSet)
60 | print(len(studentSet))
61 | 
62 | # del ise hem elemanları hem de seti temizler.
63 | 
64 | del studentSet
65 | print(len(studentSet))
66 | 
67 | # setler aşağıdaki gibi 2 şekilde tanımlanabilir.
68 | students = {'Elif','Adnan','Gülbahar','Ela'}
69 | students = set('Elvan','Arif')
70 | 
71 | 
72 | 


--------------------------------------------------------------------------------
/arrayFunctions.py:
--------------------------------------------------------------------------------
 1 | #17/12/2020 Array functions 
 2 | 
 3 | sehirler = ['Ankara','İstanbul','Mersin','Ankara']
 4 | 
 5 | 
 6 | #clear() fonksiyonu diziyi temizler.Tüm elemanları siler.
 7 | #sehirler.clear()
 8 | print(sehirler)
 9 | 
10 | #count() fonksiyonu dizide o elemanın kaç kez yer aldığını verir.
11 | print('Ankara sayısı = '+str(sehirler.count('Ankara')))
12 | 
13 | #index() fonkiyonu dizide o elemanın hangi indexte olduğunu verir ilk bulduğu indexi döner ve aramayı bırakır.
14 | print('Ankara İndexi = '+str(sehirler.index('Ankara')))
15 | 
16 | #pop() fonksiyonu dizi içerisinden eleman silmek için kullanılır remove gibi fakat indexler ile işlem yapar.
17 | sehirler.pop(3)
18 | print(sehirler)
19 | 
20 | 
21 | #insert() fonksiyonu dizi içerisine verilen indexe elaman eklememizi sağlar.
22 | sehirler.insert(2,'Edirne')
23 | print(sehirler)
24 | 
25 | #reverse() fonksiyonu diziyi ters çevirmemizi sağlar.
26 | sehirler.reverse()
27 | print(sehirler)
28 | 
29 | #Zaman zaman dizlerin kopyasını tutmak isteyebiliriz .Bunun için aşağıdaki gibi sehirler2 şeklinde yeni bir dizi oluşturabiliriz.
30 | #sehirler2 dizisinde herhangi bir elemanın değerini değiştirirsek seh,rler diziside değişir .
31 | #Bunun sebebi dizi yapılarının referams tipte olmasıdır.Yani bellekte yeri işaret ettiği için birinin değeri değiştiği zaman diğeri de değişir.
32 | sehirler2 = sehirler
33 | 
34 | sehirler[2] = 'İzmir'
35 | print(sehirler)
36 | print(sehirler2)
37 | 
38 | #copy() fonksiyonu aşağıdaki gibi dizinin bir kopyasını almamızı sağlar.
39 | #Kopya alınmış dizi üzerinde değişiklik yapınca referans dizi etkilenmez.
40 | sehirler3 = sehirler.copy()
41 | print(sehirler3)
42 | sehirler3[3] = 'Muğla'
43 | 
44 | print(sehirler)
45 | print(sehirler3)
46 | 
47 | #extend() fonksiyonu bir dizi arkasına diğer diziyi eklememizi sağlar.
48 | sehirler.extend(sehirler3)
49 | print(sehirler)
50 | 
51 | #sort() fonksiyonu dizileri alfabetik ise alfabetik şekilde sayısal ise sayısal olarak sıralamamızı sağlar.
52 | sehirler.sort()
53 | print(sehirler)
54 | 
55 | #Alfabetik olarak ters sıralamak için reverse() yapabiliriz.
56 | 
57 | sehirler.reverse()
58 | 
59 | print(sehirler)
60 | 


--------------------------------------------------------------------------------
/fileOperationsPart1.py:
--------------------------------------------------------------------------------
 1 | """ 27/12/2020 File Operations
 2 |     Programlama temeli aslında verilerle işlemlerdir.
 3 |     Verilere erişmek ,işlemek üzerine kurulu bir yapıdır.
 4 |     Burada da verilerin bulunduğu dosyaları okuma ,dosyalara yazma gibi işlemleri gerçekleştirebilmek
 5 |     için dosya işlemlerinden yararlanırız.
 6 | 
 7 | """
 8 | #%%
 9 | # Aşağıdaki şekilde ismi verilen dosyayı aç demiş oluruz .
10 | # Default olarak read modunda yani sadece var olan bir dosyayı açmamızı sağlar.
11 | # Eğer ismini verdiğiniz dosya henüz yoksa hata verir.(no such file or directory)
12 | f = open('customers.txt')
13 | #%%
14 | 
15 | #%%
16 | # Bir üstteki komutun aynısıdır.read mode
17 | f = open('customers.txt','r')
18 | #%%
19 | 
20 | #%%
21 | # Eğer dosya yoksa oluşturmak istiyorsak w modu yani write modunu verebiliriz.
22 | # write mode dosya yoksa o isimde bir dosya oluşturur.
23 |  f = open('customers.txt','w')
24 | #%%
25 | 
26 | #%% 
27 |  # Dosyayı okumak ama aynı zamanda dosyaya ekleme de yapabilmek için a modunu kullanabiliriz.
28 |  # append mode 
29 |  f = open('customers.txt','a')
30 | #%%
31 | 
32 | #%% 
33 |  # Dosya yoksa oluşturmak için x modunu kullanabiliriz.
34 |  # x :create mode
35 |   f = open('customers.txt','x')
36 |   
37 |   #%%
38 |   
39 |   #%%
40 |   f =open('customers.txt')
41 |   # Yukarıda dosya yoksa oluşturup ,okuma komutlarını gördük.
42 |   # customers.txt dosyasını oluşturduktan sonra içerisine txt metinler ekledim ve aşağıdaki gibi
43 |   # f.read() komutuyla dosya içerisindeki txt metni okuyabiliriz.
44 |   print(f.read())
45 |   
46 |   # Dosya içerinde sadece 2 karakteri okumak için 
47 |   print(f.read(2))
48 |   #%%
49 |   
50 |   
51 |   #%%
52 |   # read() dosya içerisindeki tüm herşeyi okurken readline() dosya içerisindeki satırları okur.
53 |   # Her seferinde bir sonraki satırı okumaızı sağlar.
54 |   # aynı anda hem read() hem readline() kullanmaya çalışırsanız zaten dosyayı baştan aşağı okuduğu
55 |   # için tek bir sefer okuyup ikinci fonksiyonu çalıştırmayacaktır.
56 |   # Bu yüzden okuma fonksiyonlarını aynı anda kullanmayız.
57 |   f = open('customers.txt')
58 |   print(f.readline())
59 |   print(f.readline())
60 |   print(f.readline())
61 |   
62 |   #%%
63 |   
64 |   #%%
65 |   # Birsürü satırdan oluşan bir verimiz olduğunu ve satır satır okumamız gerekli olsaydı
66 |   # Aşağıdaki gibi for ile kolayca veriyi okuyabilirdik .:)
67 |   f =open('customers.txt')
68 |   for l in f :
69 |        print(l)
70 |        
71 |   # İşlemlerimiz bitince dosyamızı kapatırız.
72 |   f.close()
73 |   #%%
74 | 


--------------------------------------------------------------------------------
/databaseOperationsPart10.py:
--------------------------------------------------------------------------------
 1 | """ 28/12/2020 Database Connections
 2 |     chinook.db dosyasını kendi dizinimize taşıdık ve üzerinden işlemler yapacağız.
 3 |     select ,join,insert,update,delete operasyonları toplu halde eklenmiştir.
 4 | 
 5 | """
 6 | 
 7 | import sqlite3
 8 | 
 9 | def selectOperations():
10 |     connection = sqlite3.connect("chinook.db")
11 |     cursor = connection.execute("""Select FirstName,LastName 
12 |                                    from Customers where firstName like '%s'
13 |                                    """)                               
14 |     for row in cursor:
15 |         print("First Name : "+row[0])
16 |         print("Last Name : "+row[1])
17 |         print('*****************')
18 |         
19 |     connection.close()
20 | 
21 | def joinOperations():
22 |     connection = sqlite3.connect("chinook.db")
23 |     cursor = connection.execute("""select 
24 |                                     	albums.Title,artists.name
25 |                                    from artists
26 |                                    inner join albums on artists.ArtistId = albums.ArtistId
27 |                                    """)                               
28 |     for row in cursor:
29 |         print("Title: "+row[0]+" "+"Name:"+row[1])
30 |         
31 |     connection.close()
32 |     
33 | def insertCustomer():
34 |     connection = sqlite3.connect('chinook.db')
35 |     cursor = connection.execute("""
36 |                                 insert into customers(FirstName,LastName,Email) 
37 |                                 values('Melike','Eryılmaz','default@gmail.com')                                                      
38 |                                 """)
39 |     # veriyi insert etmek için commit() etmeliyiz..
40 |     connection.commit()
41 |     connection.close()
42 | 
43 | def updateCustomer():
44 |     connection = sqlite3.connect('chinook.db')
45 |     cursor = connection.execute("""
46 |                                  Update Customers set city='Ankara' where city='Prague'                                                     
47 |                                 """)
48 |     connection.commit()
49 |     connection.close()
50 |     
51 | 
52 |     
53 | def deleteCustomer():
54 |     connection = sqlite3.connect('chinook.db')
55 |     cursor = connection.execute("""
56 |                                  delete from Customers  where customerid=60                                                     
57 |                                 """)
58 |     connection.commit()
59 |     connection.close()
60 |     
61 | selectOperations()
62 | joinOperations()
63 | insertCustomer()
64 | updateCustomer()
65 | deleteCustomer()
66 | 


--------------------------------------------------------------------------------
/users.json:
--------------------------------------------------------------------------------
  1 | [
  2 |   {
  3 |     "userId": 1,
  4 |     "id": 1,
  5 |     "title": "quidem molestiae enim",
  6 |     "adress":{
  7 |      "street":"example",
  8 |      "geo":{
  9 |         "lat":"sddkjfhds"
 10 |      
 11 |      }
 12 |     
 13 |     
 14 |     }
 15 |   },
 16 |   {
 17 |     "userId": 1,
 18 |     "id": 2,
 19 |     "title": "sunt qui excepturi placeat culpa",
 20 |     "adress":{
 21 |      "street":"example",
 22 |      "geo":{
 23 |         "lat":"sddkjfhds"
 24 |      
 25 |      }
 26 |     
 27 |     
 28 |     }
 29 |   },
 30 |   {
 31 |     "userId": 1,
 32 |     "id": 3,
 33 |     "title": "omnis laborum odio",
 34 |     "adress":{
 35 |      "street":"example",
 36 |      "geo":{
 37 |         "lat":"sddkjfhds"
 38 |      
 39 |      }
 40 |     
 41 |     
 42 |     }
 43 |   },
 44 |   {
 45 |     "userId": 1,
 46 |     "id": 4,
 47 |     "title": "non esse culpa molestiae omnis sed optio",
 48 |     "adress":{
 49 |      "street":"example",
 50 |      "geo":{
 51 |         "lat":"sddkjfhds"
 52 |      
 53 |      }
 54 |     
 55 |     
 56 |     }
 57 |   },
 58 |   {
 59 |     "userId": 1,
 60 |     "id": 5,
 61 |     "title": "eaque aut omnis a",
 62 |     "adress":{
 63 |      "street":"example",
 64 |      "geo":{
 65 |         "lat":"sddkjfhds"
 66 |      
 67 |      }
 68 |     
 69 |     
 70 |     }
 71 |   },
 72 |   {
 73 |     "userId": 1,
 74 |     "id": 6,
 75 |     "title": "natus impedit quibusdam illo est",
 76 |     "adress":{
 77 |      "street":"example",
 78 |      "geo":{
 79 |         "lat":"sddkjfhds"
 80 |      
 81 |      }
 82 |     
 83 |     
 84 |     }
 85 |   },
 86 |   {
 87 |     "userId": 1,
 88 |     "id": 7,
 89 |     "title": "quibusdam autem aliquid et et quia",
 90 |     "adress":{
 91 |      "street":"example",
 92 |      "geo":{
 93 |         "lat":"sddkjfhds"
 94 |      
 95 |      }
 96 |     
 97 |     
 98 |     }
 99 |   },
100 |   {
101 |     "userId": 1,
102 |     "id": 8,
103 |     "title": "qui fuga est a eum",
104 |     "adress":{
105 |      "street":"example",
106 |      "geo":{
107 |         "lat":"sddkjfhds"
108 |      
109 |      }
110 |     
111 |     
112 |     }
113 |   },
114 |   {
115 |     "userId": 1,
116 |     "id": 9,
117 |     "title": "saepe unde necessitatibus rem",
118 |     "adress":{
119 |      "street":"example",
120 |      "geo":{
121 |         "lat":"sddkjfhds"
122 |      
123 |      }
124 |     
125 |     
126 |     }
127 |   },
128 |   {
129 |     "userId": 1,
130 |     "id": 10,
131 |     "title": "distinctio laborum qui",
132 |     "adress":{
133 |      "street":"example",
134 |      "geo":{
135 |         "lat":"sddkjfhds"
136 |      
137 |      }
138 |     
139 |     
140 |     }
141 |   }
142 | ]
143 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # pythonProgrammingLanguageForBeginners
  2 | #Bu repository başlangıç seviyesinden ileri seviyeye kadar python dilinde yazılmış kaynak kodlar için oluşturulmuştur.
  3 | 
  4 | #Kodların eklenme sırası şu şekildedir:
  5 | 
  6 | 1.variables.py
  7 | 
  8 | 2.conditionalBolcks.py
  9 | 
 10 | 3.conditionalBolcks2.py
 11 | 
 12 | 4.conditionalBolcks4.py
 13 | 
 14 | 5.conditionalBolcks5.py
 15 | 
 16 | 6.arraysPart1.py
 17 | 
 18 | 7.arraysPart2.py
 19 | 
 20 | 8.arraysPart3.py
 21 | 
 22 | 9.loops.py
 23 | 
 24 | 10.functions.py
 25 | 
 26 | 11.variablesPart1.py
 27 | 
 28 | 12.variablesPart2.py
 29 | 
 30 | 13.stringFunctionsPart1.py
 31 | 
 32 | 14.stringFunctionsPart2.py
 33 | 
 34 | 15.stringFunctionsPart3.py
 35 | 
 36 | 16.stringFunctionsPart4.py
 37 | 
 38 | 17.stringFunctionsPart5.py
 39 | 
 40 | 18.inputs.py  
 41 | 
 42 | 19.notes(12-12-2020).txt
 43 | 
 44 | 20.Workshops/variableSwaping.py
 45 | 
 46 | 21.arraysPart4.py
 47 | 
 48 | 22.arrayFunctions.py
 49 | 
 50 | 23.tuplePart1.py
 51 | 
 52 | 24.tuplePart2.py
 53 | 
 54 | 25.setPart1.py
 55 | 
 56 | 26.setPart2.py
 57 | 
 58 | 27.setUnion.py
 59 | 
 60 | 28.setIntersection.py
 61 | 
 62 | 29.setDifference.py
 63 | 
 64 | 30.setSymmetric_difference.py
 65 | 
 66 | 31.dictionaryPart1.py
 67 | 
 68 | 32.dictionaryPart2.py
 69 | 
 70 | 33.conditionalBlocks6.py
 71 | 
 72 | 34.conditionalBlocks7.py
 73 | 
 74 | 35.conditionalBlocks8.py
 75 | 
 76 | 36.conditionalBlocks9.py
 77 | 
 78 | 37.Workshops/conditionalBlocksWorkshop.py
 79 | 
 80 | 38.Workshops/conditionalBlocksWorkshop1.py
 81 | 
 82 | 39.forIterationPart1.py
 83 | 
 84 | 40.forIterationPart2.py
 85 | 
 86 | 41.whileIterationPart1.py
 87 | 
 88 | 42.breakAndcontinue.py
 89 | 
 90 | 43.forIterationPart3Range.py
 91 | 
 92 | 44.forIterationPart3RangeEx.py
 93 | 
 94 | 45.functionsPart1.py
 95 | 
 96 | 46.functionsPart2.py
 97 | 
 98 | 47.functionsPart3.py
 99 | 
100 | 48.functionsPart4.py
101 | 
102 | 49.Workshops/factorialComputation.py
103 | 
104 | 50.Workshops/matrixSums.py
105 | 
106 | 51.Workshops/wordSorting.py
107 | 
108 | 52.classesPart1.py
109 | 
110 | 53.classesPart3.py
111 | 
112 | 54.classesPart4.py
113 | 
114 | 55.classesPart5.py
115 | 
116 | 56.modulesPart1.py
117 | 
118 | 57.modulesPart2.py
119 | 
120 | 58.Workshops/basicCalculator.py
121 | 
122 | 59.generalReview.py
123 | 
124 | 60.fileOperationsPart1.py
125 | 
126 | 61.customers.txt
127 | 
128 | 62.fileOperationsPart2.py
129 | 
130 | 63.students.py
131 | 
132 | 64.fileOperationsPart3.py
133 | 
134 | 65.Persons.txt
135 | 
136 | 66.jsonOperationsPart1.py
137 | 
138 | 67.jsonOperationsPart2.py
139 | 
140 | 68.users.json
141 | 
142 | 69.databaseOperationsPart1.py
143 | 
144 | 70.chinook.db
145 | 
146 | 71.databaseOperationsPart2.py
147 | 
148 | 72.databaseOperationsPart3.py
149 | 
150 | 73.databaseOperationsPart4.py
151 | 
152 | 74.databaseOperationsPart5.py
153 | 
154 | 75.databaseOperationsPart6.py
155 | 
156 | 76.databaseOperationsPart7.py
157 | 
158 | 77.databaseOperationsPart8.py
159 | 
160 | 78.databaseOperationsPart9.py
161 | 
162 | 79.exceptionHandlingPart1.py
163 | 
164 | 80.exceptionHandlingPart2.py
165 | 
166 | 81.iterators.py
167 | 
168 | 82.mapping.py
169 | 
170 | 83.filter.py
171 | 
172 | 84.reduce.py
173 | 


--------------------------------------------------------------------------------
/generalReview.py:
--------------------------------------------------------------------------------
  1 | """ 26/12/2020 Python Genel Tekrar
  2 |     Burada başlangıçtan bugüne kadar yazılan kodlara ve farklı yöntemlere değinmek adına 
  3 |     genel bir tekrar için kodlar eklenmiştir.
  4 | 
  5 | """
  6 | 
  7 | # Konsola bir şey yazdırmak için print() fonksiyonunu kullanırız.
  8 | 
  9 | print('Merhaba Python')
 10 | 
 11 | # Kullanıcıdan bir input değeri almak için input() fonksiyonunu kullanırız.
 12 | # Genellikle input alınan değeri bir değişkende saklarız.
 13 | # input() fonksiyonu default olarak string türde veri alır.
 14 | 
 15 | name = input('Please enter your name : ')
 16 | print('Hi!',name)
 17 | 
 18 | # Veri tipleri -data types
 19 | # Python'da data dinamik tiplerden oluşur ve tipler değişebilir
 20 | # Basit data tipleri integers (Tam sayı), floats (Noktalı sayı), strings (Metin), booleans (Mantıksal)
 21 | # Pythonda karakter data tipi yoktur
 22 | 
 23 | print(type(10))
 24 | print(type("10"))
 25 | print(type(10.0))
 26 | print(type(10.))
 27 | 
 28 | # Pythonda noktalı sayılar vardır.
 29 | # Noktalı sayılar en fazla 15 haneye duyarlıdır.
 30 | 
 31 | number1 = 1.1111111111111113
 32 | number2 = 1.1111111111111115
 33 | numberssum = number1 + number2
 34 | print(len(str(numberssum)))
 35 | print(numberssum)
 36 | 
 37 | # Python da string veri tipleri '' veya "" arasına yazılır.
 38 | stringEx = 'home sweet home'
 39 | print(stringEx)
 40 | 
 41 | # Python da tipleri birbirine çevirebiliriz.Type casting 
 42 | # \t string içerisinde bir tab ileri git anlamına gelir.
 43 | print('string to int \t',type(int('34')))
 44 | print('int to string \t',type(str(34)))
 45 | print('float to int \t',type(int(3.5)))
 46 | 
 47 | # print() içerisinde bir ayırıcı belirtilip ona göre ifade ayırılabilir.
 48 | 
 49 | print(12,34,56,sep='/')
 50 | 
 51 | # print() fonksiyonu default olarak yeni satıra geçer .Eğer bunu istemiyorsak sonunun ne olacağını belirtebiliriz.
 52 | print('No new line',end = '\t\t')
 53 | print('test')
 54 | 
 55 | # Pythonda temel olarak kullanılan matematiksel operatörler aşağıdaki gibidir.
 56 | 
 57 | print("5 + 2 =", 5 + 2)
 58 | 
 59 | print("5 - 2 =", 5 - 2)
 60 | 
 61 | print("5 * 2 =", 5 * 2)
 62 | 
 63 | print("5 / 2 =", 5 / 2)
 64 | 
 65 | print("5 % 2 =", 5 % 2) # Mod (Kalan)
 66 | 
 67 | print("5 ** 4 =", 5 ** 4) # Üs
 68 | 
 69 | print("5 // 2 =", 5 // 2) # Tam sayı bölme
 70 | 
 71 | #%%%
 72 | # Python da math kütüphanesi fonksiyonları çok geniştir.
 73 | import math
 74 | # Diğer matematik işlemleri
 75 | """
 76 |     abs, max, min, pow, ceil, floor, round, exp, log, sqrt 
 77 |     sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh
 78 |     hypot, radians, degrees
 79 | """
 80 | 
 81 | print(math.cos(0))
 82 | print(math.sin(math.pi/2))
 83 | print(math.sin(math.pi), "= 0")
 84 | print(math.cos(math.sin(math.tanh(0))))
 85 | 
 86 | print(math.inf) # Infinitive -sonsuz
 87 | print(math.inf - math.inf) # Nan-not a number
 88 | 
 89 | #%%
 90 | 
 91 | #%%
 92 | # Python random kütüphanesi kullanarak integer random değerler oluşturabiliriz.
 93 | import random
 94 | print("Random", random.randint(1, 101)) # random.randint(başlangıç:bitiş)
 95 | 
 96 | #%%
 97 | 
 98 | #%%
 99 | # Conditional Blocks
100 | # Pythonda kıyaslama operatörleri > < == <= >= != şeklindedir.
101 | # Pythonda mantıksal operatörler ise and ,or,not şeklindedir.
102 | # Yaş 5 ten küçükse okul yok,5 ve 6 ya eşit veya arasında ise anaokulu,6 dan büyük 17 ye eşit veya 
103 | # küçük ise yaş-5 ci sınıf hiçbiri değilse lise yazdıralım .
104 | age = 30
105 | if age < 5:
106 |     print("No school")
107 | elif (age >= 5) and (age <= 6):
108 |     print("Primary school")
109 | elif (age > 6) and (age <= 17):
110 |     print((age - 5), ". class ")
111 | else:
112 |     print("High School")
113 | 
114 | #%%
115 | 
116 | #%%
117 | # Eğer age 18 den büyükse canVote true olsun aşağıdaki gibide denebilir.
118 | canVote = True if age >= 18 else False
119 | print(canVote)
120 | # Eğer age büyüktür 18 ise yetişkin değilse genç yazdır.
121 | result = "Adult" if age >= 18 else "Young"
122 | print(result)
123 | #%%
124 | 
125 | 
126 | 
127 | 
128 | 
129 | 
130 | 
131 | 
132 | 
133 | 
134 | 
135 | 
136 | 
137 | 
138 | 
139 | 
140 | 
141 | 
142 | 
143 | 
144 | 
145 | 
146 | 
147 | 
148 | 
149 | 
150 | 
151 | 
152 | 
153 | 
154 | 
155 | 
156 | 
157 | 
158 | 
159 | 
160 | 
161 | 
162 | 


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