PYTON

Shift + enter komut satırını çalıştırır

camelCase snake_case yazım tipleri

Data Type
type() pythonda hangi veri tipine sahip olduğunu söyler
Data type(10)
Output int
int : integer
Data type(15.9)
Output float
Float : floating point
Data name = “maria”
Data type(name)
Output str
Str : string

Operation
Data 40/4
Output 10.0
2 tam sayı birbirine bölündüğünde float sonuç çıkar bunun sebebi iki sayının bölünmesinde
kesirli sayı çıkma ihtimali daha fazladır.

Data 2**5
Output 32
Üssü işlemin kolaylığı 2 **5 2 üssü 5
Data 10%3
Output 1
% remainder kalan bulma işlemidir

Print
Data “hello python”
Output “hello python” / ‘hello python’
Data ‘hello python’
Output ‘hello python’
Data print(“hello python”)
Output hello python

String
Data name = “meryem karabakal”

Data [Link]()
Output ‘Meryem karabakal’
Data help([Link])
Capitalize sadece ilk karakterini büyük yazar
Data [Link](“a”)
Output 4
Içinde kaç tane a harfi olduğunu söyler

Data [Link]()
Output ‘MERYEM KARABAKAL’
Data print([Link]())
Output MERYEM KARABAKAL
Stringin tüm harflerini büyük yazar

Bu fonksiyonlar tek seferliktir kalıcı olması için şu işlemler uygulanmalıdır :

Data nameUpper = [Link]()

Data nameUpper
Output ‘MERYEM KARABAKAL’

Data len(name)
Output 16
Len : lenght uzunluk kaç karakterden oluştuğunu söyler boşluklar dahil

Data print(“meryem \nkarabakal”)

Output meryem
Karabakal
Data print(“meryem \tkarabakal”)
Output meryem karabakal

INDEX
Data myString = “hello python”
Data myString[4]
Output ‘o’
Data len(myString)-1
Output 11
Data myString[len(myString)-1]
Output ‘n’
Data myString[-1]
Output ‘n’
myString[0] =”a” çalışmaz bunun sebebi immutable- immutability değiştirilemez

Data barcode = “NBVCE902345678”

Data barcode[3::]
Output ‘CE902345678’
Data barcode[:3:]
Output ‘NBV’
Data barcode[::2]
Output ‘NVE0357’
Barcode[#starting index : #stopping index : #stepping index]
Starting index kaçtan başlayacağını söyler 3 ise 3. index dahil yazar
Stopping index kaçta sonlanacağını söyler 3 ise 3. index dahil değildir
Stepping index kaçar kaçar atlayarak yazacağını söyler

Data name = “meryem karabakal”

Data [Link](“y”)
Output 3
Y harfini ilk gördüğü index sırasını yazar

List
Data myString = “helllo python”
Data [Link]()
Output [‘hello’ , ‘python’]

Data numberList = [1,2,3]

Data nameList = [“meryem”, “maria”, “mary”]
Data floatList = [3.14 , 2.5 , 25.0 ]
Data mixedList = [“meryem” , 3.14 , 40]

Data myList = [10,20,30]

Data type(myList)
Output list
Data x=10 y=20 z=30
Data myList = [x,y,z]
Data myList[0]
Output 10
Data type(myList[0])
Output int
Data myList[0] = 100
Data myList
Output [100,20,30]
Mutable-mutaability değiştirilebilir
Data len(myList)
Output 3
Data myList[len(myList)-1]
Output 30
Data myList[-1]
Output 30

Data [Link](40)
Data myList
Output [100,20,30,40]
Listenin sonuna verilen sayı değeri yazılır
Data [Link](20)
Output 1
Verilen sayı listenin içinde kaç tane geçtiğini söyler
Data [Link](40)
Output 3
Verilen sayı listede ilk olarak kaçıncı indexte görüldüğünü söyler
Data [Link](2,25)
Data myList
Output [100,20,25,30,40]
Ilk sayı kaçıncı indexe yerleşeceği ikinci sayı hangi sayının yerleşeceğini söyler
Data [Link]()
Output 40
Listenin sonuncu elemanını siler

Data [Link](100)
Data myList
Output [20,30]
Istenilen elemanı siler
Data [Link]()
Data myList
Output [30,20]
Listeyi tersine çevirir

Data x = input (“enter x:”)

İnput enter x:10
Data y = input (“enter y:”)
Input enter y:20
Data z= input (“enter z:)
Input enter z:30
Data x
Output ‘10’
Data type(x)
Output str
Data inputList = []
Data [Link](x) [Link](y) [Link](z)
Data inputList
Output [ ‘10’ , ‘20’ , ‘30’ ]
Data inputList[1] * 2
Output ‘2020’
Data type(inputList[1])
Output str
Data int(inputList[1]) * 2
Output 40

Data myInteger = 50
Data str(myInteger)
Output ‘50’

Data myString = “40”

Data int(myString)
Output 40
Data float(myString)
Output 40.0

Data list1 = [10,20,30] list2 = [40,50,60]

Data list1 + list2
Output [10,20,30,40,50,60]

Data myNestedList = [ 10,20,3.14,[1,2,3]]

Data myNestedList[4][1]
Output 2
#nestedList:iç içe geçmiş listeler

Data firstList = [10,20,30,40,50,60,70]

Data firstList[1:6:2]
Output [20,440,60]

Dictionary
key-value pairing
Data fitness_dictionary = {“banana”:100 , “apple”:150}
Data fitnes_dictionary[“banana”]
Output 100

Data fitness_dictionary.keys()
Output dict_keys([‘banana’, ‘apple’])
Sadece anahtarı verir
Data fitness_dictionary.values()
Output dict_values([100,150])
Sadece değeri verir

Data type(fitness_dictionary.values())
Output dict_values
Data list(fitness_dictionary.values())
Output [100,150]

Data fitness_dictionary[“banana”] = 200

Data fitness_dictionary
Output {‘banana’ : 200 , ‘apple’ : 150}
Data fitness_dictionary[“melon”] = 300
Data fitness_dictionary
Output {‘banana’ : 200 , ‘apple’ : 150 , ‘melon’ :300 }

Fitness_dictionary[“appl”] kodu çalışmaz uygulama çöker onun için önlem almak gerekir.
Data fitness_dictionary.get(“appl”,0)
Output 0
Data my_dictionary = {"key1":"value1" , "key2":"value2" , "key3":"value3"}
Data my_dictionary[“key1”]
Output ‘value1’

Data my_mixed_dictionary = {"key1":100 , "key2":3.14 , "key3":[10,20,30]}

Data my_mixed_dictionary[“key3”][1]
Output 20

Data emptyDictionary = dict() #emptyDictionary = {}

Data emptyDictionary[“a”] = 10 emptyDictionary[“b”] = 20
Data emptyDictionary
Output {‘a’ : 10, ‘b’ : 20}

Sets
Unique elements tekil elemanlar her elemandan bir tane olabilir
Unordered sırası önemli değildir index kullanılmaz
Data myList = [10,20,30,10,20,40,10,20,40]
Data len(myList)
Output 9
Data len(set(myList))
Output 4

Data mySet = {10,20,30,10,20,40,10,20,40}

Data mySet
Output {10,20,30,40}

Data mySet2 = {30,40,50,60,70}

Data [Link](50)
Data mySet
Output {10,20,30,40,50}

Data [Link](mySet2)
Output {10, 20, 30, 40, 50, 60, 70}
Birleşim
Data [Link](mySet2)
Output {30,40,50}
kesişim
Data emptSet ={}
Data type(emptySet)
output dict
={} syntex’i dictionaryle aynıdır bu sorunu düzeltmek gerekir
Data emptySet = set()
Data type(emptySet)
Output set
Data [Link](10) [Link](20) [Link](30)
[Link](10) [Link](10) [Link](20)
Data emptySet
Output {10,20,30}

Tuples
Data myTuple = (10, “a”, “b”, 3.14)
Data type(myTuple)
Output tuple
Data myTuple[0]
Output 10
myTuple[10] = 100 çalışmaz çünkü tuple immutability’dir

Data [Link](“a”)
Output 1
“a”’yı ilk olarak kaçıncı indexte gördüğünü söyler
Data [Link](“a”)
Output 1
“a”’dan kaç tane olduğunu söyler

Data myList = list(myTuple)

Data myList
Output [10, ‘a’, ‘b’ , 3.14]

Boolean
Data myBoolean = True
Data type(myBlooean)
Output bool

Data 5>3
Output True
Data 2>3
Output False
Data 2 > 1 and 3 > 2
Output True
Data 2 > 1 or 3 < 2
Output False

Data x=10 y=8

Data x == y #x eşit midir y’ye
Output False
Data x != y #x y’ye eşit değil midir
Data not 1 == 1
Output False

Data 10 in [10,20,30]
Output True
Data 5 not in [10,20,30]
Output False
Data my_dictionary = {"a":10,"b":20,"c":30}
Data 10 in my_dictionary
Output False
Data 10 in my_dictionary.values()
Output True
Data “b” in my_dictionary.keys()
Output True
Data 10 in (10,20,30)

Data X = input(“yasinizi giriniz: ”)

Input yasinizi giriniz: 18
Data int(x)
Output 15
Data int(x) >= 18
Output True
If Controls
Data x = input (“yoursuperhero: ”)
Input yoursuperhero= batman
Data If my_superhero == “superman”:
Print(“batman”) #indentation: boşluk bir tab bırakır
Print(“meryem karabakal”)
 Print(“hello python”)
Output hello python

Data my_age = 12
Data if my_age <=18:
print("age<=18")
elif my_age >18 and my_age <=30:
print ("18-age-30")
elif my_age > 30 and my_age <=40:
print("30-age-40")
else:
print("age>40")
Output age <= 18

For Loop
Data my_list = [10,20,30,40,50,60,70]
Data for x in my_list:
If x % 6 == 0:
Print(x)
Output 30
60

Data my_string = “meryem karabakal”

For x in my_string:
Print(x)
Output m/e/r/y/e/m/ /k/a/r/a/b/a/k/a/l

Data my_new_list = [("a","b"),("c","d"),("e","f"),("g","h")]

Data len(my_new_list)
Output 4
Data for elements in my_new_list: #listemin içindeki tüm elemanlar için
Print(elemet)
Output (‘a’, ‘b’) / (‘c’, ‘d’) / (‘e’, ‘f’) / (‘g’, ‘h’)
Data my_tuple_list = [(0,1,2),(3,4,5),(6,7,8),(9,10,11)]
Data for (x,y,z) in my_tuple_list:
Print(z)
Output 2 / 5 / 8 / 11
tuple unpacking

Data my_set = {1,2,3,4,5}

Data for num in my_set:
Print(num)
Output 1/2/3/4/5

Data my_dictionary = {"k1":100,"k2":200,"k3":300}

Data for element in my_dictionary:
Print(element)
Output k1 / k2 / k3
Data my_dictionary.items()
Output dict_items([('k1', 100), ('k2', 200), ('k3', 300)])
Data for (key,value) in my_dictionary.items():
Print(value)
Output 100 / 200 / 300
Data for num in my_dictionary.values():
Print(num)
Output 100 / 200 / 300

Continue-Break-Pass
Data my_list = [10,20,30,40,50,60,70]
Data for number in my_list:
 Print(number)
If number == 40:
Print (“yes)
Break #kırmak çıkarmak
Output 10 / 20 / 30 / 40 / yes
Data for number in my_list:
If number == 40
Continue #burada durur bundan sonra çalışmaz
Print(number)
Output 10 / 20 / 30 / 50 / 60 / 70
Data for number in my_list
Pass #bitmiş kodda görülmez dönüp bakıp tamamlamak içindir
While Loop
Data x=0
Data print (“while loop started”)
While x < 10:
Print (x)
X = x+1
Print (“while loop ended”)
Output while loop started
0/1/2/3/4/5/6/7/8/9
While loop ended

Data my_list = [10,20,30]

Print (my_list)
Output [10,20,30]
Data print (f“mylist: {my_list}”)
Output my list : [10,20,30]

Data name = input(“enter name: ”)

Input enter name : rose
Data print (“welcome”,name)
Output welcome rose

Range
Data range(50)
Output range(0,50)
0 dan 50 ye kadar rakamları dizer

Data list(range(5,25,2))
Output [5, 7, 9, 11, 13, 15, 17, 19, 21, 23]

Data my_list = [20,30,40,50,60]

Data for x in range(len(my_list)):
Print(x)
Output 0/1/2/3/4

Enumerate
Data for element in enumerate(my_list):
Print(element)
Output (0,20) / (1,30) / (2,40) / (3,50) / (4,60)

Random
Data my_list = [10,20,30,40,50,60,70]
Data from random import randint
Data my_list[randint(0,len(my_list)-1]
Output 20
Herhangi bir elemanı yazdır
Data shuffle(my_list)
Data my_list
Output [40,60,50,20,30]
Listeyi karıştır

Zip
Zip sıkıştırmak fermuarlamak
Data foodList = [“apple”, “banana”, “melon”]
caloriesList = [100,150,200]
dayList = [“monday”, “tuesday”, “wednesday”]
Data zippedList = list(zip(foodList, caloriesList, dayList))
Data type(zippedList)
Output list
Data zippedList
Output [('apple', 100, 'monday'),
('banana', 150, 'tuesday'),
('melon', 200, 'wednesday')]

List Comprehension
Data my_string = “metallica”
Data new_list = [element for element in my_string]
Data new_list
Output ['m', 'e', 't', 'a', 'l', 'l', 'i', 'c', 'a']
Data new_list = [] my_string = “metallica”
Data for element in my_string:
New_list.append(element)
Data new_list
Output ['m', 'e', 't', 'a', 'l', 'l', 'i', 'c', 'a']
Data number_list = [10,20,30,40,50,60]
Data new_number_list = [num/2 for num in number_list)
Data new_number_list
Output [5.0, 10.0, 15.0, 20.0, 25.0, 30.0]

Function
Function : kodu toplar kod blokları olarak görev yapar sonra istediğimizde tekrar kullanılabilir,
girdi alabilir, çıktı verebilir

Data def hello_python():

Print (“hello”)
Print (“python”)
Data hello_python
Output <function __main__.hello_python()>
Data hello_python()
Output hello
python
Def : define
Hello python yazınca aşağıdaki kod blokları çalışır pythonun kendi fonkiyonlarının yanında
istediğimiz fonksiyonu da yazabilmemizi sağlar

Data def hello_name(name):

Print(“hello”)
Print(name)
Data hello_name(“rose”)
Output hello
Rose
Name bir parametre bir değişkendir
Data def hello_surname(“surname = karabakal”):
Print(“hello”)
Print(surname)
Data hello_surname()
Output hello
Karabakal

Data def summation(num1,num2,num3):

Print(num1+num2+num3)
Data summation(10,15,35)
Output 60
Data x = summation(10,15,35)
Output 60
Data print(x)
Output none
Data type(x)
Output NoneType

Data def return_summation(num1+num2+num3):

Result = num1 + num2 + num3
Print (result)
Return result
Print (“return”)
Fonksiyonda return dedikten sonra iş biter ondan sonraki satırları okumaz
Data x = return_summation (10,2,8)
Data x
Output 20

Data def control_string(s):

If s [0] == “a”:
Print(“a”)
Data control_string(“aras”)
Output a

ARGS, KWARGS
Arguments, key word arguments

Data def args_sum(*args): #aslında args yazmaya gerek yoktur ama genelde yazılır.
Return sum(args)
Data args_sum (10,20,30,40,50,60)
Output 210

Data def kwargs_example(**kwargs):

Print(kwargs)
Data kwargs_example(apple=100,banana=150,melon=200)
Output {'apple': 100, 'banana': 150, 'melon': 200}
Bizim için dictionary oluşturur
Pratical Function
Data myResultList = []
x=0
while x<6:
[Link](divideNumber(myList[x]))
x = x+1
Data myResultList
Output [1.5, 2.5, 3.5, 5.0, 10.0, 15.0]
Data myResultList = []
For num in myList:
 [Link](divideNumber(num))
Datsa print(myResultList)
Output [1.5, 2.5, 3.5, 5.0, 10.0, 15.0]

Map
Map bir sınıftır
Data def divideNumber (number):
return number / 2
myList = [3,5,7,10,20,30]
Data map(divideNumber, myList)
Output <map at 0x105b471edd0>
Data list(map(divideNumber, myList))
Output [1.5, 2.5, 3.5, 5.0, 10.0, 15.0]

Filter
Data def controlString(string):
Return “meryem” in string
myStringList = [“meryem”, “meryem karabakal”, “karabakal”, “rose”
Data filter(controlString, myStringlist)
Output <filter at 0x1690c4c17e0>
Data list(filter(controlString, myStringlist))
Output [‘meryem’, ‘meryem karabakal’]

Lambda
Anonim, tek satırda yazıp hızlıca yazdırılacak fonksiyonlar
Data multiplyLambda = lambda num : num*3
Data type(multiplyLambda)
Output function
Data multiplyLambda(20
Output 60
Data numList = [10,20,30,40,50]
Data list(map(lambda num : num/4, numList))
Output [2.5, 5.0, 7.5, 10.0, 12.5]

Scope
Kapsam
Data x=20
Def multiply(num):
X=5
Return num*x
Data multiply(10)
Output 50
Data print(x)
Output 20

Data x=20
Def multiply(num):
Return num*x
Data multiply(10)
Output 200
LEGB
Local enclosing global built-in
Data myString = “meryem” #global
Def myFunction():
myString = “meryem2” #enclosing
Def myFunction2():
myString = “meryem3” #local
Print(myString)

myFunction2()
Data mystring
Output ‘meryem’
Data myFunction()
Output meryem3

Data def test1():

myVaariable = 10
Print (myVariable*2)
Data def test2():
Print (myVariable*3)
Data test1()
Output 20
Data #test2() ‘çalışmaz’

Data y = 10
def changeY():
global y
y=5
printy (y)
Data changeY()
Output 5
Data print(y)
Output 5

Classes Oop
Data class Person ():
#propety, özellik
name = ""
age = 0
gender = ""
job = "enginer"

def __init__(self,name,age,gender): #intializer method:ilk oluşturmmak

değerini atamak
#bu sınıftan bir obje oluşturulduğunda buradaki fonksiyon çalışır
#name,age,gendere vermek zorunludur -parantez içine yazıldığında-
 [Link] = name
[Link] = age
[Link] = gender
#selfi başa alınca değeri kaydeder

def PrintName(self): #self : kendisi

print([Link])

Data meryem = Person(“meryem”, 17, “female”)

Data type(meryem)
Output __main__.Person
Data [Link]
Output ‘meryem’
Data [Link]
Output 17
Data [Link]
Output ‘female’
Data [Link]
Output ‘enginer’

OOP
inheritance, polymorphisim, abstraction, encapsulation
İnheritance
Kalıtım almak
Data class Musician():

def __init__(self,name):
[Link] = name #property
print ("musician classs")

def test1(self):
print("test1")

def test2(self):
print("test2")
Data grup = Musician(“metallica”)
Output musician classs
Data [Link]
Output ‘metallica’
Data grup.test2
Output test2

Data class MusicianPlus(musician):

Def__init__(self,name):
Musician.__init__(self,name)
Print(“musician plus”)
Def test3(self):
Print(“test3”)
#ovirride
Def test1(self):
Print(“test1 test1 test1”)
Data atlas = MusicianPlus(“atlas”)
Output musician classs
Musician plus
Data atlas.test1()
Output test1 test1 test1
Data grup.test1()
Output test1

Polymorphism
Aynı isimle farklı işi yapmak