Temel Python

Reading time: 8 minutes

Python Temelleri

Faydalı bilgiler

list(xrange()) == range() --> Python3'te range, python2'nin xrange'idir (bu bir liste değil, bir jeneratördür)
Bir Tuple ile bir Liste arasındaki fark, bir tuple'daki bir değerin konumunun ona anlam katmasıdır, ancak listeler sadece sıralı değerlerdir. Tuple'lar yapıya sahiptir, ancak listeler bir sıraya sahiptir.

Ana işlemler

Bir sayıyı yükseltmek için: 3**2 kullanırsınız (3^2 değil)
Eğer 2/3 yaparsanız, iki int (tam sayı) böldüğünüz için 1 döner. Ondalık istiyorsanız, float'ları bölmelisiniz (2.0/3.0).
i >= j
i <= j
i == j
i != j
a ve b
a veya b
not a
float(a)
int(a)
str(d)
ord("A") = 65
chr(65) = 'A'
hex(100) = '0x64'
hex(100)[2:] = '64'
isinstance(1, int) = True
"a b".split(" ") = ['a', 'b']
" ".join(['a', 'b']) = "a b"
"abcdef".startswith("ab") = True
"abcdef".contains("abc") = True
"abc\n".strip() = "abc"
"apbc".replace("p","") = "abc"
dir(str) = Mevcut tüm yöntemlerin listesi
help(str) = str sınıfının tanımı
"a".upper() = "A"
"A".lower() = "a"
"abc".capitalize() = "Abc"
sum([1,2,3]) = 6
sorted([1,43,5,3,21,4])

Karakterleri birleştir
3 * ’a’ = ‘aaa’
‘a’ + ‘b’ = ‘ab’
‘a’ + str(3) = ‘a3’
[1,2,3]+[4,5]=[1,2,3,4,5]

Bir listenin parçaları
‘abc’[0] = ‘a’
'abc’[-1] = ‘c’
'abc’[1:3] = ‘bc’ [1]'den [2]'ye kadar
"qwertyuiop"[:-1] = 'qwertyuio'

Yorumlar
# Tek satırlık yorum
"""
Birden fazla satırlık yorum
Başka bir tane
"""

Döngüler

if a:
#somethig
elif b:
#something
else:
#something

while(a):
#comething

for i in range(0,100):
#something from 0 to 99

for letter in "hola":
#something with a letter in "hola"

Demetler

t1 = (1,'2,'three')
t2 = (5,6)
t3 = t1 + t2 = (1, '2', 'three', 5, 6)
(4,) = Tekil
d = () boş demet
d += (4,) --> Bir demete ekleme
OLMAZ! --> t1[1] == 'Yeni değer'
list(t2) = [5,6] --> Demetten listeye

Liste (dizi)

d = [] boş
a = [1,2,3]
b = [4,5]
a + b = [1,2,3,4,5]
b.append(6) = [4,5,6]
tuple(a) = (1,2,3) --> Listeden demete

Sözlük

d = {} boş
monthNumbers={1:’Jan’, 2: ‘feb’,’feb’:2}—> monthNumbers ->{1:’Jan’, 2: ‘feb’,’feb’:2}
monthNumbers[1] = ‘Jan’
monthNumbers[‘feb’] = 2
list(monthNumbers) = [1,2,’feb’]
monthNumbers.values() = [‘Jan’,’feb’,2]
keys = [k for k in monthNumbers]
a={'9':9}
monthNumbers.update(a) = {'9':9, 1:’Jan’, 2: ‘feb’,’feb’:2}
mN = monthNumbers.copy() #Bağımsız kopya
monthNumbers.get('key',0) #Anahtarın var olup olmadığını kontrol et, monthNumbers["key"] değerini döndür veya yoksa 0 döndür

Küme

Kümede tekrar yoktur
myset = set(['a', 'b']) = {'a', 'b'}
myset.add('c') = {'a', 'b', 'c'}
myset.add('a') = {'a', 'b', 'c'} #Tekrar yok
myset.update([1,2,3]) = set(['a', 1, 2, 'b', 'c', 3])
myset.discard(10) #Varsa, kaldır, yoksa, hiçbir şey
myset.remove(10) #Varsa kaldır, yoksa, istisna fırlat
myset2 = set([1, 2, 3, 4])
myset.union(myset2) #myset VEYA myset2 değerleri
myset.intersection(myset2) #myset VE myset2 değerleri
myset.difference(myset2) #myset'teki ama myset2'de olmayan değerler
myset.symmetric_difference(myset2) #myset VE myset2'de olmayan değerler (her ikisinde de yok)
myset.pop() #Kümenin ilk elemanını al ve kaldır
myset.intersection_update(myset2) #myset = Hem myset hem de myset2'deki elemanlar
myset.difference_update(myset2) #myset = myset'teki ama myset2'de olmayan elemanlar
myset.symmetric_difference_update(myset2) #myset = Her ikisinde de olmayan elemanlar

Sınıflar

__It__ içindeki yöntem, bu sınıfın bir nesnesinin diğerinden büyük olup olmadığını karşılaştırmak için sıralama tarafından kullanılacaktır.

class Person(name):
def __init__(self,name):
self.name= name
self.lastName = name.split(‘ ‘)[-1]
self.birthday = None
def __It__(self, other):
if self.lastName == other.lastName:
return self.name < other.name
return self.lastName < other.lastName #Return True if the lastname is smaller

def setBirthday(self, month, day. year):
self.birthday = date tame.date(year,month,day)
def getAge(self):
return (date time.date.today() - self.birthday).days


class MITPerson(Person):
nextIdNum = 0	# Attribute of the Class
def __init__(self, name):
Person.__init__(self,name)
self.idNum = MITPerson.nextIdNum  —> Accedemos al atributo de la clase
MITPerson.nextIdNum += 1 #Attribute of the class +1

def __it__(self, other):
return self.idNum < other.idNum

map, zip, filter, lambda, sorted ve tek satırlar

Map şöyle: [f(x) for x in iterable] --> map(tutple,[a,b]) = [(1,2,3),(4,5)]
m = map(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9]) --> [False, False, True, False, False, True, False, False, True]

zip foo veya bar'ın daha kısa olanı durduğunda durur:

for f, b in zip(foo, bar):
print(f, b)

Lambda, bir fonksiyonu tanımlamak için kullanılır
(lambda x,y: x+y)(5,3) = 8 --> Lambda'yı basit bir fonksiyon olarak kullanın
sorted(range(-5,6), key=lambda x: x** 2) = [0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5] --> Lambda'yı bir listeyi sıralamak için kullanın
m = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9]) = [3, 6, 9] --> Lambda'yı filtrelemek için kullanın
reduce (lambda x,y: x*y, [1,2,3,4]) = 24

def make_adder(n):
return lambda x: x+n
plus3 = make_adder(3)
plus3(4) = 7 # 3 + 4 = 7

class Car:
crash = lambda self: print('Boom!')
my_car = Car(); my_car.crash() = 'Boom!'

mult1 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x%3 == 0 ]

İstisnalar

def divide(x,y):
try:
result = x/y
except ZeroDivisionError, e:
print “division by zero!” + str(e)
except TypeError:
divide(int(x),int(y))
else:
print “result i”, result
finally
print “executing finally clause in any case”

Assert()

Eğer koşul yanlışsa, dize ekranda yazdırılacaktır.

def avg(grades, weights):
assert not len(grades) == 0, 'no grades data'
assert len(grades) == 'wrong number grades'

Generatörler, yield

Bir generatör, bir şey döndürmek yerine, "yield" eder. Ona eriştiğinizde, üretilen ilk değeri "döndürür", ardından tekrar erişebilir ve bir sonraki üretilen değeri döndürebilir. Yani, tüm değerler aynı anda üretilmez ve bu yöntem, tüm değerlerin bulunduğu bir liste yerine kullanıldığında çok fazla bellek tasarrufu sağlayabilir.

def myGen(n):
yield n
yield n + 1

g = myGen(6) --> 6
next(g) --> 7
next(g) --> Hata

Düzenli İfadeler

import re
re.search("\w","hola").group() = "h"
re.findall("\w","hola") = ['h', 'o', 'l', 'a']
re.findall("\w+(la)","hola caracola") = ['la', 'la']

Özel anlamlar:
. --> Her şey
\w --> [a-zA-Z0-9_]
\d --> Sayı
\s --> Boşluk karakteri[ \n\r\t\f]
\S --> Boşluk olmayan karakter
^ --> İle başlar
$ --> İle biter
+ --> Bir veya daha fazla
* --> 0 veya daha fazla
? --> 0 veya 1 kez

Seçenekler:
re.search(pat,str,re.IGNORECASE)
IGNORECASE
DOTALL --> Noktanın yeni satırı eşleştirmesine izin ver
MULTILINE --> ^ ve $'nın farklı satırlarda eşleşmesine izin ver

re.findall("<.*>", "<b>foo</b>and<i>so on</i>") = ['<b>foo</b>and<i>so on</i>']
re.findall("<.*?>", "<b>foo</b>and<i>so on</i>") = ['<b>', '</b>', '<i>', '</i>']

IterTools
product
from itertools import product --> 1 veya daha fazla liste arasında kombinasyonlar oluşturur, belki değerleri tekrar eder, kartesyen çarpımı (dağıtım özelliği)
print list(product([1,2,3],[3,4])) = [(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]
print list(product([1,2,3],repeat = 2)) = [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]

permutations
from itertools import permutations --> Her pozisyondaki tüm karakterlerin kombinasyonlarını oluşturur
print list(permutations(['1','2','3'])) = [('1', '2', '3'), ('1', '3', '2'), ('2', '1', '3'),... Her olası kombinasyon
print(list(permutations('123',2))) = [('1', '2'), ('1', '3'), ('2', '1'), ('2', '3'), ('3', '1'), ('3', '2')] Uzunluğu 2 olan her olası kombinasyon

combinations
from itertools import combinations --> Tekrar eden karakterler olmadan tüm olası kombinasyonları oluşturur (eğer "ab" mevcutsa, "ba" oluşturmaz)
print(list(combinations('123',2))) --> [('1', '2'), ('1', '3'), ('2', '3')]

combinations_with_replacement
from itertools import combinations_with_replacement --> Karakterden itibaren tüm olası kombinasyonları oluşturur (örneğin, 3. karakter 3. karakterden itibaren karışır ama 2. veya 1. ile değil)
print(list(combinations_with_replacement('1133',2))) = [('1', '1'), ('1', '1'), ('1', '3'), ('1', '3'), ('1', '1'), ('1', '3'), ('1', '3'), ('3', '3'), ('3', '3'), ('3', '3')]

Dekoratörler

Bir fonksiyonun çalışması için gereken süreyi ölçen dekoratör (from here):

from functools import wraps
import time
def timeme(func):
@wraps(func)
def wrapper(*args, **kwargs):
print("Let's call our decorated function")
start = time.time()
result = func(*args, **kwargs)
print('Execution time: {} seconds'.format(time.time() - start))
return result
return wrapper

@timeme
def decorated_func():
print("Decorated func!")

Eğer bunu çalıştırırsanız, aşağıdakine benzer bir şey göreceksiniz:

Let's call our decorated function
Decorated func!
Execution time: 4.792213439941406e-05 seconds