mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
300 lines
9.6 KiB
Markdown
300 lines
9.6 KiB
Markdown
# Temel Python
|
||
|
||
{{#include ../../banners/hacktricks-training.md}}
|
||
|
||
## 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.
|
||
```python
|
||
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](https://towardsdatascience.com/decorating-functions-in-python-619cbbe82c74)):
|
||
```python
|
||
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
|
||
```
|
||
{{#include ../../banners/hacktricks-training.md}}
|