<jupyter_start><jupyter_text>Son değiştirilme tarihi:16.10.2021 ÖNSÖZ NOT:Dokümanda zaman zaman güncellemeler olacağı için arada bir güncel versiyon kontrolü yapmanızı tavsiye ederim."nbviewer" üzerinden görüntülüyorsanız, dosyayı kaydetmek için sayfanın sağ üst köşesindeki download butonuna tıklayın, açılan sayfada herhangi bir yere sağ tıklayın ve `farklı kaydet` diyerek dosyayı istediğiniz klasöre kaydedin. Dosyayı açabilmek için Jupyter'in kurulması gerekmekte olup, yeni başlayan biriyseniz aşağıda kurulumla ilgili detayları inceleyin. Python'a ilk kez başlıyorsanız önce "Anaconda" kurulumu yapmanız gerekmektedir. Bu işlemi şu sayfadan  öğrenebilir veya hemen alttaki videodan izleyebilirsiniz. **NOT: Normalde Anaconda birçok paketi ve programı baırndırdığı için bilgisayarınızda çok yer kaplamakta olup ilerde anacondayı kaldırıp pure python kurulumu yapmanızı, ve sadece ihtyiacınız olan paketleri kurmanızı tavsiye ederim. Ancak herşeyin hazır gelmesi sebebiyle ilk başta anaconda ile başlamanız yerinde oalcaktır. Disk sorununuz yoksa anaconda ile devam da edebilirsiniz.**Anaconda ile birlikte Python environment'ına ek olarak Jupyter notebook uygulaması ve Spyder gibi IDE'ler de kurulacaktır. Ayrıca birçok önemli kütüphane(numpy, pandas, sklearn gibi) kurulmuş olacak. Ben de bu dokümanı Jupyter üzerinde hazırladım. O yüzden Jupyter ağırlıklı gideceğiz. Spyder'ı, kurcalayarak ve Youtube'da birkaç video izleyerek kendiniz de öğrenebilirsiniz.Bu notebookta detaylı Jupyter kullanımı olmayacak. Her detayı vermekten ziyade bir başucu rehberi hazırlamayı amaçladım. Yani tam bir eğitim dokümanından ziyade büyük bir cheatsheet(hızlı başvuru kaynağı) tadında bir doküman bulacaksınız. Dokümanın en altında süper konsantre bir cheatsheet daha bulacaksınız.Gereksiz açıklamalarla dokümanı şişirmek istemedim. Çoğu durumda kodları çalıştırdığınızda neyin ne olduğunu anlayabileceksiniz. Anlaşılması zor durumlar için ilave açıklamalar olacaktır.Bununla birlikte bir nebze de olsa programcılık dünyasına aşina olmanızda fayda var. Eğer tamamen sıfır noktasındaysanız bu doküman size biraz ağır gelebilir. Önce başka bir kaynaktan temelleri(değişken, fonksiyon, algoritma, nesne v.s) öğrenin, bu dokümanı ise cheatsheet olarak kullanın. DİKKAT: En altta Verimlilik bölümünde gösterdiğim "code(input) hücrelerini saklama yöntemi"nde kullandığım kod, sayfadaki tüm input hücrelerinin gizlenmesine neden olmaktadır. Bunun için aşağıdaki butona tıklamanız gerekebilir. (İçinde yazan kod python kodu olmayıp javascripttir, şimdilik buna takılmayın)<jupyter_code>from IPython.display import HTML

HTML('''<script>
code_show=true; 
function code_toggle() {
if (code_show){
$('div.input').hide();
} else {
$('div.input').show();
}
code_show = !code_show
} 
$( document ).ready(code_toggle);
</script>
<form action="javascript:code_toggle()"><input type="submit" value="Kodları Göster/Gizle"></form>''')
from IPython.display import YouTubeVideo
YouTubeVideo('JEv5oigBUL0')<jupyter_output><empty_output><jupyter_text>Jupyter  Rehber  Jupyter kullanırken neleri bilmenizde fayda var? * Kısayol tuşları(Jupyter'de H tuşuna basınca çıkar)-->bunları mutlaka kullanın, büyük hız kazandırır. Herşeyi yukarıdaki menülerden yapmaya kalkarsanız yavaş ilerlersiniz.* magic functions(Googlelayın)-->Bir süre sonra, şimdi değil* smart suggestions(tab, tab+tab)-->sınıflar ve metodlar hakkında bilgi alırsınız, kod pratiğine başlayınca deneyin. Aşağıda print için örnek ekran görüntüleri var.* nbextensions ve jupyter_helpers-->sol paneldeki içindekiler ve indeksleme dahil birçok güzellik * help, dir ile yardım alınır-->deneyin(aşağıda örnek var)* type fonksiyonu ile sık sık bir değişkenin tipini öğrenmeniz gerekecek -->deneyin* naming convention(pep 0008)-->Kritik değil ama bence önemli, googlelayın* jupyteri ektin kullanma rehberleri(medium v.s)-->Hemen değil ama bir süre sonra googlelayın* https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/<jupyter_code>a=1
liste=[]
print(type(a),type(liste))
help(print) #print fonksiyonu hakkında yardım
[x for x in dir(dict) if not "__" in x] #dictionary nesnesinin property ve metodları. tek başına dir(dict) yapsaydım 
#çok uzun bi liste çıkardı. Biraz aşağıda göreceğimiz 'list comprehension' yönteminden faydalanarak listeyi daralttım<jupyter_output><empty_output><jupyter_text>![image.png](attachment:image.png) ![image.png](attachment:image.png) Anacondayı kurduktan sonra yukarda bahsettiğim nbextensionsı kurar ve bu notebooku kendi pcnize indirip jupyter içinden açarsanız aşağıdaki gibi İçindekiler tablolu ve indeksli şekilde görebilirsiniz. Kurulumun nasıl yapılacağını https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/install.html sayfasından görebilirsiniz. Onun öncesinde biraz aşağıdaki Modül, Package, Class bölümüne bakıp kavramlar hakkında kısa bir bilgi edinebilirsiniz. (Bu işlem size karışık gelirse bu aşamayı pas geçebilir ve biraz daha deneyim kazandıktan sonra tekrar denersiniz. Ancak benim tavsiyem, bikaç kez deneyin ve kurmaya çalışın, inanın çok faydasını göreceksiniz) ![image.png](attachment:image.png) NOT: Yukarıdaki ekran görüntüsü gibi resimleri kolayca notebookunuz içine ekleyebiliyorsunuz. Sadece bir Markdown tipli hücre açıp içine girin ve clipboarda aldığınız resmi yapıştırın.  Çoklu output Normalde bir hücrede "print" ifadesi kullanmazsak sadece son değişken çıktı olarak gösterilir. Ancak aşağıdaki kod bloğu ile tüm değişkenler çıktı olarak elde edilebilmektedir.from IPython.core.interactiveshell import InteractiveShellInteractiveShell.ast_node_interactivity = "all"Örneğin bu interactive kodları girilmeden aşağıdaki kod çalışıtırılırsa sadece 2 sonucunu alırkena=1b=2abYukarıdaki iki satırlık kod girilirse hem 1 hem 2 sonucu görünür.<jupyter_code>from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"
a=1
b=2
a
b<jupyter_output><empty_output><jupyter_text>Çeşitli operatörler<jupyter_code>#! işareti ile işletim sistemi komutları kullanılabilir
import os #os modülü ayrıca anlatılacak, aşağıdaki kod ile geçerli klasörü değiştiriyoruz
os.chdir(r"E:\OneDrive\Uygulama Geliştirme") 
# sanki meşhur siyah cmd ekranımızda "dir" demişim gibi
!dir
# "#" işareti ile yorum yazarız
%%HTML
Farklı dil seçeneklerin <em>kullanabiliyoruz</em>. Burada HTML kullanmış olduk.<jupyter_output><empty_output><jupyter_text>Matematiksel ifadeler<jupyter_code>%%latex #Latex ile matematiksel formüller girebiliyoruz
$$E=mc^2$$
$sin(x)/x$<jupyter_output><empty_output><jupyter_text>HizalamaYukarıdaki code hücresiyidi, bu ise markdown hücresidir$$ ile yazım formülü ortalar\$ ile yazımda ise sola dayalı ve küçük$$\Pi p(n)$$$\frac \pi 2$ Diğer ifadeler\frac ifadesi ile kesirler_ karakteri ile indis(subscript)\pi, \sum, \bar ve \hat gibi özel ifadeler$$\sum p(n)$$$$y_i, \bar{y}_i, \hat{y}_i$$$$TSS=\sum_{i=1}^n(y_i-\bar{y}_i)^2$$$$P(c|x)=\frac {P(x|c).P(c)}{P(x)}$$<jupyter_code>#bu modül ile de daha gösterişli matematiksel formüller girebiliyoruz
from IPython.display import Math
Math(r'F(k) = \int_{-\infty}^{\infty} f(x) e^{2\pi i k} dx')
#dahası da var, müzik ve video da ekleyebiliyoruz
from IPython.display import Audio
Audio(url="http://www.nch.com.au/acm/8k16bitpcm.wav")
from IPython.display import YouTubeVideo
YouTubeVideo('NGrJjLCpKSA') # reklamımı da yapayım :)<jupyter_output><empty_output><jupyter_text>Latex ve Ipython.display hakkında daha fazla bilgi için https://nbviewer.jupyter.org/github/ipython/ipython/blob/2.x/examples/Notebook/Display%20System.ipynb<jupyter_code>#print edilecek liste çok büyükse ekranda çok yer kaplamaması adına bu aşağıdaki modül oldukça kullanışlıdır. 
#bunun önemini henüz anlamayabilirsiniz, bi köşede dursun
#https://towardsdatascience.com/productivity-tips-for-jupyter-python-a3614d70c770
from jupyter_helpers.following_tail import FollowingTail

max5=FollowingTail(5)
max5.activate()
liste=range(100)

for i in liste:
    max5(i)<jupyter_output><empty_output><jupyter_text>Genel syntax<jupyter_code>sayi=1 #değişkenler doğrudan atanır. türkçe karakter kullanmamaya çalışın<jupyter_output><empty_output><jupyter_text>Değişkenlerde çoklu satır kullanımı<jupyter_code>linecont="merhaba burada line "+ \
" contination uygulandı" + \
"ama sonuç yine de bitişik yazar"
print(linecont)
satırayaygın="""
bu satırlar
ise satırlara
yayılmış durum
"""
print(satırayaygın)
#veri yapıları için ise yukarıdaki iki yönteme de gerek olmadan kaydırabiliriz
gunler=["Pzt","salı",
       "çar","perş"]
print(gunler)<jupyter_output>['Pzt', 'salı', 'çar', 'perş']<jupyter_text>Başlıklar Başlıklar normalde , , ,... ifadeleriyle HTML'deki h1,h2,h3...'e denk gelecek şekilde oluşturulur. Bu dokümandaki tüm başlıklar da böyle oluşuturuldu. Dokümanı kendi jupyterinizde açtıysanız, herhangi bir başlık hücresine gelip Enter'a basın. Enter ile hücreyi edit moduna sokmuş oluruz. Böylece başlığın nasıl yazıldığını da görmüş olursunuz. Mesela bu paragrafın başlığı aşağıdaki gibidir ![image.png](attachment:image.png) Bu tür başlıklar, eğer nbextension kurduysanız 1.1.2 gibi indeksli şekilde görünür. Eğerki bu dokümana bir notebook gösterici(github veya nbviewer gibi) üzerinden bakıyorsanız 1.1.2 şeklindeki gösterimi görmüyorsunuzdur. Detaylar için en baştaki Rehber kısmına bakınız Bu ise html(strong tag'i) kullanılarak oluşturulmuş kalın bi başlık. Sol paneldeki "İçindekiler" paneline girmesini istemediğiniz başlıkları bu şekilde oluşturabilirsiniz. Diğer başlık türleri***üç yıldız ile bold&italik*****iki yıldız ile bold yapma***tek yıldız ile italik yapma*`sağa dönük tek tırnak ile` vurgulu yapma. Bu karakteri Alt+96 ile yazabilirsiniz.  Paragraf, satır geçme ve html kullanımı Üst paragrafİki kere entera basarak paragraf açabilirsiniz(bu satırda olduğu gibi. hücreye çift tıklayın ve görün)veya bi satırın sonunda "br" tagi ekleyerek bir alt satıra geçebilrsiniz. (bu satırda olduğu gibi. hücreye çift tıklayın ve görün)NOT:Bu kolaylıkları öğrenene/keşfedene kadar ben bu paragraf ve bi alt satır işlerini Markdown değil de Raw NB Convert hücre tipi ile yapıyordum. Bunu öğrendikten sonra Raw NB Covnert tipli hücrelere pek ihtiyaç duymadım.  Naming convention "Pep 008 python" araması yapın ve tüm detayları görün. aşağıda sadece "_" kullanımını koydum<jupyter_code>_privatevariable=3
#_privatemethod()
list_=[1,2,3] #rezerv keylerin sonuna _ gelir. list diye bir değişken adı kullanamayız, list_ olabilir
dict_={"ad":"ali","soyad":"yılmaz"}
for x,_ in dict_.items(): #ilgilenmediğimiz değerler için "_"
    print(x)<jupyter_output>ad
soyad<jupyter_text>Bununu dışında sklearn(Machine Learning kütüphanesi)de bazı propertylerin _ ile bittiğini görürsünüz. bunların anlamı da, ilgili propertyle ulaşmak için öncelikle modelin eğitilmesi(fit edilmesi) gerekmekte, eğitilmemiş  modelde bu bilgiye ulaşamak anlamsızdır demek.  Modül, Package, Class Bu 3 kavram hiyerarşik olarak şöyle sıralanır. Package>module>class.Yani her sınıf bir modül içindedir. modüller py uzantılı dosylardır. birkaç modül biraraya gelerek bir paket oluşturur. Ör: DataScience çalışmalarında pandas paketi kullanılır, bu anaconda sürümü ile birlikte gelir.Bir de kütüphane kavramı var. Python'daki kütüphane(library) kavramı C/C gibi dillerdeki dll dosyalarından farklı bir anlama sahiptir. Burada daha çok belirli modüllerin veya package'ların biraraya gelerek kavramsal bir topluluk oluşturumasından bahsediyoruz. Ör:Makine öğrenme kütüphanesi gibi. Bu arada ille bir fiziksel karşılık aranacaksa package'lar gibi düşünülebilirler. **DİKKAT:Kafa karışıtırıcı bir paragraf, isterseniz şimdilik atlayın ma sonra mutlaka glin ve özellikle alttaki linki okuyun**Yeni bir paket kurmak istediğinizde;conda install paketadı demeniz yeterlidir. Eğer bu yeterli gelmezse;pip install paketadı diyebilirsiniz. Bunu bazen başında ! olacak şekilde yapmak gerekebiliyor. ! varsa aslında komut satırı komutu gibi çalışmış oluyor, ! yoksa da % işareti varmış gibi çalışıyor. % işareti olması automagic olarak çalışması anlmamına gleiyor. automagic konusunu araştırrsanız anlarsınız.Ama şimdi bu yukarıdaki iki yöntemi de unutun ve aşağıdaki şu linke bakın. kurulumları nasıl yapmanız gerektiğini göreceksiniz.Daha detaylı bilgiyi aşağıdaki linkten edinebilirsiniz:https://jakevdp.github.io/blog/2017/12/05/installing-python-packages-from-jupyter/<jupyter_code>#örnek olarak şimdi DeepLearning paketi olan kerası kuruyorum
#conda install keras
#mevcut packageların listesi
!pip list
#bi kapet hakkında bilgi
!pip show numpy
# bir paketi sorgulama, var mı yok mu, hangi versiyonu kurulu v.s
!pip search matplotlib
#eğer, daha üst sürümü varsa ona upgrade etmek için
!pip install numpy --upgrade 
#veya conda update numpy
#yeni sürümle çalışıtırma sıkıntısı yaşarsanız eski sürüme dönebilirsiniz
#!pip install --upgrade paketadı=versiyonno #(Ör:pip install --upgrade werkzeug==0.12.2)
#paketi komple kaldırmak için
#!pip uninstall paketadı
#python versiyonu öğrenmek
!python --version
#python'ın versiyonunu yükseltmek
#!conda update python
#packageler hangi klasörlere kuruluyor
import sys
sys.path
import site
print(site.getsitepackages())<jupyter_output>['C:\\Users\\volka\\Anaconda3', 'C:\\Users\\volka\\Anaconda3\\lib\\site-packages']<jupyter_text>Özel kurulum şekillleri In IPython (jupyter) 7.3 and later, there is a magic %pip and %conda command that will install into the current kernel (rather than into the instance of Python that launched the notebook).%pip install geocoder! pip install --user  (The ! tells the notebook to execute the cell as a shell command.)  Modül ve sınıflar(ve hatta fonksiyonları) kodumuza dahil etme * Modül referansı: import x, kullanımı: x'i takipeden üye şeklinde. x.falanmetod, x.falanproperty, x.falanfalan* Modüldeki herşeyi dahil etme: from x import * , kullanımı: falanca(...) * Tek birşeyi dahil etme: from x import falanca. falanca doğrudan kullanılabilir, x.falanca demeye gerek yok(üsstekinden farkı daha az şey importladık) NOT: Performans açısından mümkün mertebe az şey import etmeye çalışın.<jupyter_code>from math import sqrt #math modülünden sqrt fonksiyonu
kök=sqrt(16)
kök
from os import * # os modülündeki herşeyi
mkdir("test") #os dememize gerek yok. test diye bi klasör yarattık
removedirs("test") #hemen arkadan bu klasörü sildik
!dir<jupyter_output>Volume in drive E is MYHDD
 Volume Serial Number is 9E4D-C087

 Directory of E:\OneDrive\Uygulama GeliŸtirme

16.01.2020  20:42    <DIR>          .
16.01.2020  20:42    <DIR>          ..
09.09.2019  23:42    <DIR>          java
09.01.2020  23:52    <DIR>          PDF dok�mantasyon
15.06.2019  16:35    <DIR>          Scratch
12.12.2019  15:32    <DIR>          silinecek
18.08.2019  13:38    <DIR>          Visual Studio
19.08.2019  23:18    <DIR>          web js asp
08.01.2020  00:52    <DIR>          web sitelerim
               0 File(s)              0 bytes
               9 Dir(s)  510.644.449.280 bytes free<jupyter_text>Kendi modüllerinizi import etme Zaman geçtiktçe, bazı işleri sık yaptığınızı farkedeceksiniz ve bunları(sınıflar, fonkisyonlar) kendinize ait bir modülde toplayacaksınız. Sonrasında bunu normal bir modül import eder gibi ederiz.<jupyter_code># mypythonutility.py isminde bir dosyanız olduğunuzu düşünrsek
# import mypythonutility<jupyter_output><empty_output><jupyter_text>Ancak bazen, kodlarımızda sık güncelleme yapmak durumunda kalabiliyoruz. o sırada da bu modülümü import ettiğimiz bir başka notebookta çalışırken güncel halini dikkate almasını isteriz. Bu işi, notebooku restart etmeden yapmanın bir yolu var:<jupyter_code>%load_ext autoreload
%autoreload 2<jupyter_output><empty_output><jupyter_text>Kendi modülünüzü paket gibi kullanma Burayı daha ileride okuyun, şimdilik aklınızda bulunması için ve konu bütünlüğü adına burda olması daha iyi diye düşündüm. Yoksa bi üstteki maddeyi bilmeniz şimdilik yeterli. Yazdığınız modülü çağırmak istediğinizde ya onunla aynı klasörde olmanız ya da os.chdir() yaparak ilgili klasöre konumlanmanız gerekir. Sürekli bununla uğraşmamak için modülünüzü bir package haline getirmeniz faydalı olacaktır.Bunun için bir klasör yaratın ve içine bu py dosyanızı koyun. Bu klasöre bir de içi boş bir `'__init__.py'` dosyası koyun. Sonra bu klasörü tüm python paketlerinin olduğu klasöre(site-packages) taşıyın.Eğer ki jupyterhub gibi yetkilerinizin sınırlı olduğ bir ortamda çalışıyorsanız, ve site-packages'ta klasöre açma yetkiniz yoksa, kendinize ayrılmış alanda bu klasörü oluşturup sistem pathine ekleyin. Bunu da aşağıdaki komutla yapabilirsiniz.<jupyter_code># import sys
# sys.path += "klasörün konumu"
# print(sys.path) #path'e eklenmiş mi görmek için bunu da yazalım<jupyter_output><empty_output><jupyter_text>Virtual Environment https://realpython.com/python-virtual-environments-a-primer/ sayfasında güzel anlatılmış.<jupyter_code>#En güncel pip'i kuralım
!py -m pip install --upgrade pip
#înstalling
!py -m pip install --user virtualenv
#yaratma
!py -m venv env #bulunduğumuz aktif klasör içinde yaratır
#aktivasyon
!.\env\Scripts\activate
#bakalım PATH'e eklenmiş mi
p=!PATH
str(p).split(";")
!where python
!deactivate<jupyter_output><empty_output><jupyter_text>Veri Tipleri<jupyter_code>i=1
f=1.0
s="merhaba"
#bu bir yorum
"""
merhaba
Bu 3 tırnak ifadesi fonksiyonların docstringi amaçlı kullanılır
Ankca çok satıra yayılan yorumlar için de kullanılabilir
"""
print(type(i))
print(type(f))
print(type(s))
#Legal variable names:
myvar = "John"
my_var = "John"
_my_var = "John"
myVar = "John"
MYVAR = "John"
myvar2 = "John"
#Illegal variable names:
# 2myvar = "John"
# my-var = "John"
# my var = "John"
#çoklu değer atama
x, y, z = "Orange", "Banana", "Cherry"
print(x)
print(y)
print(z)
#exponential
x = 1e9
y = 123E9
x
y<jupyter_output><empty_output><jupyter_text>Veri tipi dönüştürme<jupyter_code>y=float(1)
z=int(2.8)
s=str(y)

y,type(y)
z,type(z)
s,type(s)
print(s,type(s))
z="1"
y=int(z)
type(y)
x=1
print(isinstance(x,int))<jupyter_output>True<jupyter_text>Fonksiyonlar   Klasik fonksiyon Genel olarak fonksiyonların ne olduğunu başka bir dokümandan öğrenmiş olmanız beklenimektedir. Başta da belirttiğim gibi bu dokümanın amacı büyük bir cheatsheet sağlamak.<jupyter_code>def islem_yapan_parametresiz_fonksiyon(): #c tabanlı dillerdeki void dönüş tipi
    print("selam")
    
islem_yapan_parametresiz_fonksiyon()
def sonuc_donduren_ve_parametre_almis_fonksiyon(karesi_alinacak_sayi):
    """
    bu fonksiyon kendisine gelen sayının karesini döndürür
    Args:
        karesi_alinacak_sayi: sayı
    """
    return karesi_alinacak_sayi**2

sonuc=sonuc_donduren_ve_parametre_almis_fonksiyon(4) #dönen sonucu bi dğeişkene atıyorum
print(sonuc)
#pythonda fonksiyonlar bazı dillerdeki durumun aksine çok değer döndürülebilir.
def cokdegerdondur(sayı):
    return sayı,sayı*10,sayı*100

kendi,onkat,yuzkat=cokdegerdondur(5)
print(onkat)
print(kendi)<jupyter_output>50
5<jupyter_text>Paramarray ile esnek sayıda parametre kullanımı ve default değer kavramı Parametreler belirlenmiş sayıda olmak zorunda değil. Esnek sayıda parametre alma imkanı var.<jupyter_code>def SayılarıToplaXeBöl(arg1,*args): #arg1 olmak zorunda değil, ama olacaksa paramarrayden önce olmalı
    """
    Bu fonksiyon ilk parametreden sonrakileri toplayıp ilk parametreye böler
    """
    Toplam=0
    for a in args:
        Toplam+=a
    return Toplam/arg1

x=SayılarıToplaXeBöl(10,1,2,3,4,5,6,7,8,9,10) #parametreler hardcoded yazıldıysa "*" yazmıyoruz. 
print(x)  
y=SayılarıToplaXeBöl(10,*range(1,11)) #parametreler bir fonksiyon ile dönüyorsa veya bir değişkense "*" var
print(y)
def dictparametreli(**kwargs): #** olursa parametre olarak dictioanry alır
    for k,v in kwargs.items():
        print(k,v)

dict_={}
dict_["ad"]="Volkan"
dict_["soyad"]="Yurtseven"
dictparametreli(**dict_) #değişken şeklinde olduğu için ** ile<jupyter_output>ad Volkan
soyad Yurtseven<jupyter_text>Bazı parametreler default değerleriyle yazılırlar. Fonksiyona ilgili değer geçirilimezse bu default değer kullanılır<jupyter_code>def opsiyonelli(adet,min_=1, max_=10):
    print(adet,min_,max_)

opsiyonelli(100,5) #son parametre 10 geçer<jupyter_output>100 5 10<jupyter_text>Lambda ve anonymous function Lambda ifadeler, fonksiyon tanımlamak yerine inline şekilde işlem yapmaya imkan verir<jupyter_code>def kareal(sayı):
    return sayı**2

#yukarıdaki fonksiyonu tanımlamak yerine lambda yazabilriz
kareal2=lambda x:x**2

print(kareal(10))
print(kareal2(10))
def KelimeSay(metin):
    kelimeler = [m for m in metin.replace(",","").split(" ")]
    print(" ".join(sorted(list(set(kelimeler)))))
    
KelimeSay("sen seni bil sen seni, yoksa severim seni")<jupyter_output>bil sen seni severim yoksa<jupyter_text>Stringler  Slicing<jupyter_code>from utility import * #kendi yazdığım utility modülünü import ediyorum. burada farklı print şekilleri var. 
#satır numarsını yazdırmak gibi. View menüsünden Toggle Line Numbers yapmış olmanız lazım.
metin="<NAME>"
printy(metin[0])
printy(metin[:3]) #left 3
printy(metin[4:]) #substr
printy(metin[2:5]) #substr
printy(metin[-1]) #son
printy(metin[-3:]) #right 3
printy(metin[::-1]) #ters<jupyter_output>2 ----------
v
 
3 ----------
vol
 
4 ----------
an yurtseven
 
5 ----------
lka
 
6 ----------
n
 
7 ----------
ven
 
8 ----------
nevestruy naklov<jupyter_text>String formatlama<jupyter_code>mesaj="İnsanların yaklaşık %s kadın olup %s erkektir" % ("yarısı","kalanı")
mesaj
#s:string, d:sayı
#daha çok bu yöntem, {}
mesaj="Python {} bir dildir".format("güzel")
mesaj
# ya da + ile basit concat
mesaj="python"
mesaj=mesaj + " güzel bir dildir"
mesaj
#en son yöntem: f-string / f-literal olarak da geçer
ad="volkan"
yas=41
print(f"Benim adım {ad} olup yaşım {yas}")
#f ilteral ile binlik ayraç ve küsurat işleri
dunyanufusu=8000000000
pi=3.14159
print(f"pi sayısı yaklaşık olarak {pi:.2f} olup dünyada yaklaşık {dunyanufusu:,} kişi yaşamaktadır")<jupyter_output>pi sayısı yaklaşık olarak 3.14 olup dünyada yaklaşık 8,000,000,000 kişi yaşamaktadır<jupyter_text>metinsel fonksiyonlar<jupyter_code>parçalı=metin.split()
parçalı
print(metin*3)
metin.replace("e","i")
print(metin.upper(), metin.lower(), metin.capitalize(), metin.title())
print(metin.startswith("v"),metin.endswith("d"))
kelime="     naber   dostum     " 
print("yeni:"+kelime.strip()+".") #ortadakini silmez
isim="Volkan"
user="ABC123"
yas="42" #tırnak içinde olmalı
mail="<EMAIL>"

print(isim.isalnum(),user.isalnum(),yas.isalnum(),mail.isalnum())
print(isim.isalpha(),user.isalpha(),yas.isalpha(),mail.isalpha())
print(isim.isdigit(),user.isdigit(),yas.isdigit(),mail.isdigit()) #isnumeric de olur. fark için https://stackoverflow.com/questions/44891070/whats-the-difference-between-str-isdigit-isnumeric-and-isdecimal-in-python
print(isim.isprintable(),user.isprintable(),yas.isprintable(),mail.isprintable())<jupyter_output>True True True False
True False False False
False False True False
True True True True<jupyter_text>Tüm diğer string metodları için şuraya bakabilirsiniz: https://www.w3schools.com/python/python_ref_string.asp  özel karekterler ve literaller<jupyter_code>#escape
print("Şifre:\"abc123\"")
print("c:\\python\\abc\\xyz\\sdf")
print(r"c:\python\abc\xyz\sdf") #r:raw, escape char'ı görmezden gel demek<jupyter_output>Şifre:"abc123"
c:\python\abc\xyz\sdf
c:\python\abc\xyz\sdf<jupyter_text>![image.png](attachment:image.png)<jupyter_code>#literaller: b,r,f
a=b"volkan" 
b="volkan"
print(type(a))
print(type(b))
import sys
sys.getsizeof(a)
sys.getsizeof(b)
adres1="c:\\falanca\\filanca"
adres2=r"c:\falanca\filanca"
adres1==adres2<jupyter_output><empty_output><jupyter_text>diğer işlemler<jupyter_code>#liste çevirme
liste=list(metin)
print(liste)
#içinde var mı kontrolü
print("l" in metin)
print(metin.find("z")) #bulamazsa -1
print(metin.index("z")) #bulamazsa hata alır
for m in metin:
    print(m,end="\n")
#aralarda boşluk falan varsa "r" başta olacak şekilde kullanırız. c#'taki @ gibi
path=r"E:\falan filan klasörü\sub klasör"
metin.count("e") #metin değişkeninde e harfi kaç kez geçiyor<jupyter_output><empty_output><jupyter_text>string modülü<jupyter_code>import string
string.punctuation
string.printable
string.whitespace
string.digits
string.ascii_letters<jupyter_output><empty_output><jupyter_text>Koşullu yapılar Koşullu yapılar, döngüler ve veri yapıları tüm programalama dillerinin ortak özellikleri olup iyi kavranması gerekirler. Bu konuda kendinizi test edeceğiniz güzel bir site var. Burada çeştli konularda kolaydan zora kadar farklı seviyelerde sorular var, bunları çözüp gönderiyorsunuz, puan kazanıyorsunuz. bu siteyi kullanmanızı tavsiye ederim.https://www.hackerrank.com<jupyter_code>i=10 #bunu sırasıyla 10,20 ve 30 yapark çalışıtırın
if i<20:
    print("20den küçük")
elif i==20: #çift =
    print("tam 20")
else:
    print("20den büyük")
#one-liner -(ternary) if-else
x=3
sonuc="high" if x>10 else "low"
print(sonuc)<jupyter_output>low<jupyter_text>Döngüler Genelde list, dict gibi veri yapıları içinde dolaşmaya yararlar. Bu veri yapılarını az aşağıda detaylı göreceğiziki tür döngü yapımız var. while ve for.for, foreach şeklindedir, klasik for yok. onun yerine range fonksiyonundan yararlanılabilir.<jupyter_code>fruits = ["apple", "banana", "cherry"]
for x in fruits:
    print(x)
#klasik for için range kullanımı.
for i in range(len(fruits)):
    print(fruits[i])
#metinler de loop ile dolaşılabilir
isim="volkan"
for i in isim:
    print(i,end="-")
#döngüden çıkış
fruits = ["apple", "banana", "cherry"]
for x in fruits:
    print(x)
    if x == "banana":
        break
#while ile bir şart gerçekleş(me)tiği sürece döngüde kalırız
i = 1
while i < 6:
    print(i)
    i += 1
#belirli bir ara şart gerçekleşirse döngüden çıkabiliriz
i = 1
while i < 6:
    print(i)
    if i == 3:
        break
    i += 1
#hackerrank sitesindeki bir ödev
def staircase(n):
    for i in range(n):
        print((n-i-1)*" "+"#"*(i+1))
staircase(6)<jupyter_output>#
    ##
   ###
  ####
 #####
######<jupyter_text>Döngü içinde "else" kullanımı  for döngülerinde tüm liste bittiğinde son olarak bu kısım yürütülür<jupyter_code>for i in range(4):
    print(i)
else:
    print("bitti")
for num in range(10,20):
    for i in range(2,num):
        if num%i==0:
            j=num/i
            print("{} equals {}*{}".format(num,i,j))
            break
    else:
        print(num," bir asal sayıdır")<jupyter_output>10 equals 2*5.0
11  bir asal sayıdır
12 equals 2*6.0
13  bir asal sayıdır
14 equals 2*7.0
15 equals 3*5.0
16 equals 2*8.0
17  bir asal sayıdır
18 equals 2*9.0
19  bir asal sayıdır<jupyter_text>while döngülerinde koşul sağlanmadığında yürütülür<jupyter_code>n=5
while n!=0:
    print(n)
    n-=1
else:
    print("artık sağlanmıyor")<jupyter_output>5
4
3
2
1
artık sağlanmıyor<jupyter_text>içiçe döngülerden çıkış içiçe döngü varsa, break ifadesi en içteki döngüden çıkar ve o bloktan sonraki ilk satırdan devam eder  iç döngüden çıkış, dış döngüye devam<jupyter_code>liste=[]
for x in list("bacde"):
    for z in ["ali","dursun","ıtır","emel","cemil"]:
        print(x,z) #kontrol için
        if x in z:
            print(f"{z} ekleniyor ve iç döngüden çıkış yapılacak\n")
            liste.append(z)
            break #bir kez ekledikten sonra çıkıyorum, o yüzden mükerrer ekleme olmuyor, comment/uncomment
    else:
        print(f"{x} için iç döngüde eşleşme bulunamadı\n")
print(liste)<jupyter_output>b ali
b dursun
b ıtır
b emel
b cemil
b için iç döngüde eşleşme bulunamadı

a ali
ali ekleniyor ve iç döngüden çıkış yapılacak

c ali
c dursun
c ıtır
c emel
c cemil
cemil ekleniyor ve iç döngüden çıkış yapılacak

d ali
d dursun
dursun ekleniyor ve iç döngüden çıkış yapılacak

e ali
e dursun
e ıtır
e emel
emel ekleniyor ve iç döngüden çıkış yapılacak

['ali', 'cemil', 'dursun', 'emel']<jupyter_text>tüm döngüden çıkış<jupyter_code>#herhangi birinin olması yeterliyse, ilk gördüğümü ekleyip çıkayım
liste=[]
for x in list("bkcde"): #a'yı k yapalım
    for z in ["ali","dursun","ıtır","emel","cemil"]:
        print(x,z) #kontrol için
        if x in z:
            print(f"{z} ekleniyor ve tüm döngüden çıkış yapılacak\n")
            liste.append(z)
            break
    else:
        print(f"dış döngüdeki {x} için tur tamamlandı,sonraki için devam\n")
        continue      
    break #iç döngüden çıkıldığında buraya gelinir
    
print(liste)
#iki dizidekilerin toplamı 20den büyük olduğunda çık
dizi=[[11,21,3],[5,15,6]]
records=[]

for j in dizi[0]:
    for i in dizi[1]:        
        if j+i>20:
            records.append((j,i,j+i))
            break
    else:
        continue
    break

records
#2.yöntem. bi fonk içinte return kullanmak
records=[]
def myfonk():
    dizi=[[11,21,3],[5,15,6]]    
    for j in dizi[0]:
        for i in dizi[1]:        
            if j+i>20:
                records.append((j,i,j+i))
                return

myfonk()
print(records)
#3.yöntem: exception
records=[]
try:
    dizi=[[11,21,3],[5,15,6]]    
    for j in dizi[0]:
        for i in dizi[1]:        
            if j+i>20:
                records.append((j,i,j+i))
                raise StopIteration
except StopIteration: pass
records<jupyter_output><empty_output><jupyter_text>Data Structures(Veri yapıları)  List<jupyter_code>liste=[0,1,2,3,4,5]
liste.append(6)
print(liste[:2]) #stringler gibi slicing yapılır
print(3 in liste) #üyelik kontrolü
son=liste.pop() #son elemanı çıkarıp buna atar
print(son)
print(liste)
rangelist=list(range(0,100,3))
print(rangelist)<jupyter_output>[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]<jupyter_text>Sıralama Sort metodu bir listeyi kendi üstünde sıralar, sonuç olarak birşey döndürmez. yani sıralanmış  listeyi bir değişkene atayamayız. sıralanmış halini başka bir değişkene atamak istersek sorted fonkisyonunu kullanırız.<jupyter_code>meyveler=["elma","muz","portakal","çilek","üzüm","armut","muz"]
printy(meyveler.index("muz")) #ilk gördüğün indeksi
printy(meyveler.count("muz"))
meyveler.sort()
printy(meyveler)
meyveler.reverse()
printy(meyveler)
siralimeyveler=sorted(meyveler,reverse=True) #ayrıca tersten sırala demiş olduk. bu parametre normal sort metodunda da var
print(siralimeyveler)<jupyter_output>['üzüm', 'çilek', 'portakal', 'muz', 'muz', 'elma', 'armut']<jupyter_text>Tuple List gibi ama değişmez yapılardır yani eleman eklenip çıkarılamaz. [] yerine () veya parantezsiz<jupyter_code>tpl=(1,2,3)
tpl2=1,2,3
print(type(tpl2))<jupyter_output><class 'tuple'><jupyter_text>Comprehension tüm veri yapılarıyla uygulanabilir. uzun döngü yazmaktan kurtarır. c'taki LINQ işlemlerinin benzer hatta daha güzel alternatifi<jupyter_code>rangelistinikikatı=[x*2 for x in rangelist]
print(rangelistinikikatı)<jupyter_output>[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96, 102, 108, 114, 120, 126, 132, 138, 144, 150, 156, 162, 168, 174, 180, 186, 192, 198]<jupyter_text>koşullu comprehension [x for x in datastruct if x ...][x if ... else y for x in datastruct]<jupyter_code>kısaisimlimeyveler=[x for x in meyveler if len(x)<5]
kısaisimlimeyveler
liste=range(1,10)
sadecetekler=[sayı for sayı in liste if sayı % 2 !=0] #tek if
tekler=[sayı if sayı%2!=0 else "" for sayı in liste] #if-else
print(sadecetekler)
print(tekler)<jupyter_output>[1, 3, 5, 7, 9]
[1, '', 3, '', 5, '', 7, '', 9]<jupyter_text>içiçe(nested) list comprehension ****syntax:[x for iç in dış for x in iç]**** 2 boyutlu bir matrisi düzleştirmek istiyorummatrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]Beklediğimiz çıktı: flatten_matrix = [1, 2, 3, 4, 5, 6, 7, 8, 9]<jupyter_code># 2-D List 
matrix = [[1, 2, 3], [4, 5], [6, 7, 8, 9]] 

flatten_matrix = [] 

for sublist in matrix: 
	for val in sublist: 
		flatten_matrix.append(val) 
		
print(flatten_matrix) 

# 2-D List 
matrix = [[1, 2, 3], [4, 5], [6, 7, 8, 9]] 

# Nested List Comprehension to flatten a given 2-D matrix 
flatten_matrix = [val for sublist in matrix for val in sublist] 

print(flatten_matrix) 
# 2-D List of planets 
planets = [['Mercury', 'Venus', 'Earth'], ['Mars', 'Jupiter', 'Saturn'], ['Uranus', 'Neptune', 'Pluto']] 

flatten_planets = [] 

for sublist in planets: 
	for planet in sublist: 
		
		if len(planet) < 6: 
			flatten_planets.append(planet) 
		
print(flatten_planets) 
flatten_planets = [planet for sublist in planets for planet in sublist if len(planet) < 6] 
print(flatten_planets)
kısalar=[p for iç in planets for p in iç if len(p)<6]
kısalar<jupyter_output><empty_output><jupyter_text>Daha genel bir gösterim için https://stackoverflow.com/questions/18072759/list-comprehension-on-a-nested-list sayfasındaki gif animasyonlu açıklamaya bakınız  Matrisler ve matrislerde comprehension<jupyter_code>matris=[
    [1,2,3],
    [4,5,6],
    [7,8,9]
]
print(len(matris))
printy([satır for satır in matris]) #satır satır
printy([satır[0] for satır in matris]) #ilk sütun
printy([[satır[i] for satır in matris] for i in range(3)]) #sütun sütun, transpozesi
printy([x for iç in matris for x in iç]) #nested<jupyter_output>3
7 ----------
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 
8 ----------
[1, 4, 7]
 
9 ----------
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
 
10 ----------
[1, 2, 3, 4, 5, 6, 7, 8, 9]<jupyter_text>amaç aşağıdakini elde etmek olsunmatrix = [[0, 1, 2, 3, 4],          [0, 1, 2, 3, 4],          [0, 1, 2, 3, 4],          [0, 1, 2, 3, 4],          [0, 1, 2, 3, 4]]<jupyter_code>matrix = [] 

for i in range(5): 
	
	# Append an empty sublist inside the list 
	matrix.append([]) 
	
	for j in range(5): 
		matrix[i].append(j) 
		
print(matrix) 

# Nested list comprehension 
matrix = [[j for j in range(5)] for i in range(5)] 

print(matrix)<jupyter_output>[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]<jupyter_text>Stack Normalde böyle bi sınıf yok. list'i stack gibi kullanırız. append ve pop sayesinde. ilk giren ilk çıkar<jupyter_code>stack=[1,2,3]
stack.append(4)
stack.pop()
stack<jupyter_output><empty_output><jupyter_text>Queue Bunu da istersek listten yaparız, ilk giren son çıkar. ama bunun için collections modülünde bi sınıf var<jupyter_code>from collections import deque
kuyruk=deque([1,2,3])
kuyruk.append(4)
sıradaki=kuyruk.popleft()
print(sıradaki)
print(kuyruk)<jupyter_output>1
deque([2, 3, 4])<jupyter_text>Dictionary Key-value ikililerini tutarlar. Sırasızdırlar(EDIT:Python 3.7den itibaren girdilen sırayı korur), indeksle ulaşamayız. key'lerle valuelara ulaşırız veya döngü içinde dolanarak ikisine birden tek seferde de ulaşabiliriz.  Yaratım  Klasik<jupyter_code>dict_={}
dict_["one"]="bir" #add,append, insert gibi bir metodu yok, direkt atanıyor
dict_["two"]="iki"
dict_["two"]="zwei"
printy(dict_.keys())
printy(dict_.values())
printy(dict_.items())
print(dict_["one"])
#print(dict_["three"]) # hata alır, almaması için get kullan
print(dict_.get("three","N/A"))<jupyter_output>5 ----------
dict_keys(['one', 'two'])
 
6 ----------
dict_values(['bir', 'zwei'])
 
7 ----------
dict_items([('one', 'bir'), ('two', 'zwei')])
 
bir
N/A<jupyter_text>dict metodu ile ikili elemanlardan oluşan bir yapıdan bu ikili yapılar genelde zip veya enumerate olacaktır. bakınız ilgili fonksiyonar.<jupyter_code>tpl=[("one","bir"),("two","iki"),("three","üç")]
dict_=dict(tpl)
print(type(dict_))
dict_["one"]<jupyter_output><class 'dict'><jupyter_text>comprehension ile<jupyter_code>sayılar=list(range(10))
ciftlerinkaresi={x: x**2 for x in sayılar if x%2==0}
print(ciftlerinkaresi.items())<jupyter_output>dict_items([(0, 0), (2, 4), (4, 16), (6, 36), (8, 64)])<jupyter_text>elemanlarda dolaşma<jupyter_code>for k,v in ciftlerinkaresi.items():
    print(k,v)<jupyter_output>0 0
2 4
4 16
6 36
8 64<jupyter_text>çeşitli metodlar<jupyter_code>ciftlerinkaresi.clear()
ciftlerinkaresi.items()
del ciftlerinkaresi
ciftlerinkaresi #hata verir, artık bellekten uçtu<jupyter_output><empty_output><jupyter_text>Set Bunlar da dict gibi sırasızdır. dict gibi {} içinde tanımlanırlar. uniqe değerleri tutarlar. bir listteki duplikeleri ayırmak ve membership kontrolü için çok kullanılırlar<jupyter_code>liste=[1,1,2,3,4,4,5]
set_=set(liste)
set_
set1={1,2,3,4,5}
set2={2,3,4}
set3={2,3,4,5,6}

printy(set1,set2,set3)
printy("----diff")
printy(set1.difference(set2))
printy(set1.difference(set3))
printy(set2.difference(set1))
printy(set2.difference(set3))
printy(set3.difference(set1))
printy(set3.difference(set2))
printy("- intersection----")
printy(set1.intersection(set2))
printy(set1.intersection(set3))
printy(set2.intersection(set1))
printy(set2.intersection(set3))
printy(set3.intersection(set1))
printy(set3.intersection(set2))
printy("----union---")
printy(set1.union(set2))
printy(set1.union(set3))
printy(set2.union(set1))
printy(set2.union(set3))
printy(set3.union(set1))
printy(set3.union(set2))<jupyter_output>5 ----------
{1, 2, 3, 4, 5} {2, 3, 4} {2, 3, 4, 5, 6}
 
6 ----------
----diff
 
7 ----------
{1, 5}
 
8 ----------
{1}
 
9 ----------
set()
 
10 ----------
set()
 
11 ----------
{6}
 
12 ----------
{5, 6}
 
13 ----------
- intersection----
 
14 ----------
{2, 3, 4}
 
15 ----------
{2, 3, 4, 5}
 
16 ----------
{2, 3, 4}
 
17 ----------
{2, 3, 4}
 
18 ----------
{2, 3, 4, 5}
 
19 ----------
{2, 3, 4}
 
20 ----------
----union---
 
21 ----------
{1, 2, 3, 4, 5}
 
22 ----------
{1, 2, 3, 4, 5, 6}
 
23 ----------
{1, 2, 3, 4, 5}
 
24 ----------
{2, 3, 4, 5, 6}
 
25 ----------
{1, 2, 3, 4, 5, 6}
 
26 ----------
{2, 3, 4, 5, 6}<jupyter_text>Not: Yukarıdaki altalta aynı hizada olan tüm printy ifadesini tek seferde yapmanın yolu var. ben mesela bunların hepsi print iken printy'yi tek seferde yaptım. Alt tuşuna basarak seçmek. aşağıdaki gibi seçip t tuşuna basarsam tüm ty'ler t olur. ![image.png](attachment:image.png)  Zip<jupyter_code>x=[1,2,3]
y=[10,20,30]
onkatlar=zip(x,y)
#print(list(onkatlar)) #yazdırmak için liste çevir. bi kez liste çevirlince artık zip özelliği kalmaz, 
#o yüzden alttaki blok çalışmaz,o yüzden geçici olarak commentledim. deneyin ve görün
#tekrar ayırmak için
x2, y2 = zip(*onkatlar)
x2<jupyter_output><empty_output><jupyter_text>Zip vs Dict<jupyter_code>a=[1,2,3]
b=[10,20,30]
c=zip(a,b)
for i,j in c:
    print(i,j)
a=[1,2,3]
b=[10,20,30]
c=zip(a,b)
print(type(list(c)[0]))
dict_=dict(c) #zipten dict üretimi
for k,v in dict_.items():
    print(k,v)<jupyter_output><class 'tuple'><jupyter_text>Listlerle kullanılan önemli fonksiyonlar  Map ve Reduce Map: bir veri yapısındaki elemanları sırayla bir fonksiyona gönderir ve sonuç yine bir veri yapısıdırReduce: elemanları sırayla gönderir, bir eritme mantığı var, her bir önceki elamnını sonucyla bir sonraki eleman işleme girer  Map<jupyter_code>items=[1,2,3,4,5]
def kareal(sayı):
    return sayı**2

kareler=map(kareal,items) #lambdalı da olur. map(lambda x: x**2, items)
list(kareler) #yazdırmak için liste çevir

#birden fazla veri yapısı da girebilir işleme
range1=range(1,10)
range2=range(1,20,2)

mymap=map(lambda x,y:x*y,range1,range2)
for i in mymap:
    print(i)
#comprehensionla da yapılabilir.
çarpım=[x*y for x,y in zip(range1,range2)]
çarpım
harfler=map(chr,range(97,112))
list(harfler)
harfler2=[chr(x) for x in range(97,112)]
harfler2<jupyter_output><empty_output><jupyter_text>Reduce<jupyter_code>from functools import reduce
def faktoriyel(sayı1,sayı2):
    return sayı1*sayı2

sayılar=range(1,10)
fakt=reduce(faktoriyel,sayılar)
fakt<jupyter_output><empty_output><jupyter_text>Filter<jupyter_code>ages = [5, 12, 17, 18, 24, 32]

def myFunc(x):
    if x < 18:
        return False
    else:
        return True

adults = filter(myFunc, ages)

for x in adults:
    print(x)
#veya lambda ile
list(filter(lambda x:x>=18,ages))<jupyter_output><empty_output><jupyter_text>Enumerate<jupyter_code>aylar=["Ocak","Şubat","Mart"]
print(list(enumerate(aylar,start=1)))
dict_=dict(enumerate(aylar,start=1))
for k,v in dict_.items():
    print(k,v)<jupyter_output>[(1, 'Ocak'), (2, 'Şubat'), (3, 'Mart')]
1 Ocak
2 Şubat
3 Mart<jupyter_text>All ve Any<jupyter_code>liste1=[True,True,False]
liste2=[True,True,True]
print(all(liste1))
print(any(liste1))
print(all(liste2))<jupyter_output>False
True
True<jupyter_text>Date Time işlemleri  Modüller ve üyeleri<jupyter_code>import datetime as dt
import time as t
import timeit as tit
import dateutil as du
#import timer as tr #bu threadlerle ilgili kullanma, settimer ve killtimer var<jupyter_output><empty_output><jupyter_text>datetime<jupyter_code>print([i for i in dir(dt) if not "__" in i])
print(dt.datetime.now())
print(dt.datetime.now().hour) #saliseden yıla kadar hepsi elde edilebilir
print(dt.date.today())
print(dt.date.today().year)
print(dt.date(2019,4,3))<jupyter_output>2020-01-16 20:44:06.031080
20
2020-01-16
2020
2019-04-03<jupyter_text>time (süre ölçümlerinde bunu kullancaz, bundaki time metodunu)<jupyter_code>print([i for i in dir(t) if not "__" in i])
print([i for i in dir(tit) if not "__" in i])<jupyter_output>['Timer', '_globals', 'default_number', 'default_repeat', 'default_timer', 'dummy_src_name', 'gc', 'itertools', 'main', 'reindent', 'repeat', 'sys', 'template', 'time', 'timeit']<jupyter_text>dateutil<jupyter_code>print([i for i in dir(du) if not "__" in i])<jupyter_output>['_common', '_version', 'parser', 'relativedelta', 'tz']<jupyter_text>Süre ölçümü  Performans amaçlı süre ölçümü(sonuçtan bağımsız) - `%'li` olanı bir fonksiyon takip eder, `%%'li` kullanımda ise alt satırdan yazarsın. - `Time` olan tek seferlik run'ın süresini verirken `timeit` onlarca kez çalıştırıp ortalama süre verir<jupyter_code>%%timeit
x=sum(range(1000000))
%%time
x=sum(range(1000000))
def hesapla():    
    y=sum(range(1000000))
    
%timeit hesapla()<jupyter_output>75.6 ms ± 1.4 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)<jupyter_text>Süreyle birlikte sonuç görme<jupyter_code>#tit.Timer(hesapla).timeit() uzun sürüyo ve bitmiyo ??
bas=t.time()
print("hey")
hesapla()
bit=t.time()
print("süre:{}".format(bit-bas))<jupyter_output>hey
süre:0.07879209518432617<jupyter_text>jupyter nbextensions ![image.png](attachment:image.png) nbextensionsı hala kurmadıysanız alın size bir sebep daha. bu süre ölçümü kodlarına gerek yok. yukarıdaki eklentiyle her hücrenin çalışma süresini veriyor. Bir örnek: ![image.png](attachment:image.png)  Önemli bazı modüller Aşağıda önemli olduğunu düşündüğüm bazı modülleri bulacaksınız. Tabiki bunların dışında da başak kütüphaneler/modüller var, bunları da zamanla öğreneceksiniz.  os  İşletim sisteminden bağımsız çalışacak bir koda(dosyalama sistemi v.s ile ilgili) ihtiyacımız olduğunda os modülünü kullanırız.  Klasör ve dosya işlemleri<jupyter_code>import os
os.getcwd() #o anki aktif folder
os.curdir #mevcut dizini temsil eden karakter, genelde bu . oluyor. Bunu daha çok prefix path olarak kullanırız
os.chdir(os.curdir + "\.git") #aktif klasörü değiştiriyoruz
os.pardir #parent klasörü temsil eden karakter
os.listdir() #o anki aktif folderdaki dosyaları lsiteler
os.listdir(os.pardir)
os.path.exists('Python Genel.ipynb') #bir dosya/klasör mevcut mu
os.path.isfile('olmayandosya.txt') #parametredeki bir dosya mı? veya bir dosya mevcut mu anlamında da kullanılabilir.
os.path.isdir("klasor")
# list all files in a directory in Python.
from os import listdir
from os.path import isfile, join
p=os.getcwd()
files_list = [f for f in listdir(p) if isfile(join(p, f))]
print(files_list);
dizin= r"E:\OneDrive\udemy dosyaları\vba2\FSO Örnek"
for kökdizin, altdizinler, dosyalar in os.walk(dizin):
    print(kökdizin)
for kökdizin, altdizinler, dosyalar in os.walk(dizin):
    for dosya in dosyalar:
        print(os.sep.join([kökdizin, dosya]))
import os.path, time, datetime
print("Last modified: %s" % os.path.getmtime("abc.txt")) #formatlanmamış
print("Created: %s" % time.ctime(os.path.getctime("abc.txt")))
os.startfile('calc.exe') #dosya açar, program başaltır, internet sitesine gider v.s
os.startfile(r'E:\OneDrive\Uygulama Geliştirme\PDF dokümantasyon\AI & DS\Pandas & EDA & ML\pandas.pdf')
os.startfile("www.volkanyurtseven.com")<jupyter_output><empty_output><jupyter_text>Sistem ve Environment bilgileri<jupyter_code>import platform, os
print(os.name)
print(platform.system())
print(platform.release())
dict(os.environ)
print(dict(os.environ)["HOMEPATH"])
print(dict(os.environ)["USERNAME"])
os.path.expanduser('~')<jupyter_output><empty_output><jupyter_text>random<jupyter_code>import random
dizi=[3,5,8,3,2,1,9]
random.seed(1)
print(random.randint(2,48)) #2 ile 48 arasında
print(random.randrange(1,100,3))
print(random.choice(dizi))
print(random.choices(dizi,k=3)) #çektiğini geri koyar, sampledan farkı bu, o yüzden aynısı çıkabilir
print(random.random()) #0-1 arası
print(random.uniform(2,5)) #2-5 arası küsurlu sayı
print(random.sample(dizi,2)) #çektiğini geri koymaz, choicestan farkı bu
#liste karıştırmak
random.shuffle(dizi)
dizi<jupyter_output><empty_output><jupyter_text>array listin hemen hemen aynısı olup önemli bir farkı, içine sadece belli tipte eleman almasıdır. Bu yüzden memory performansı  açısından liste göre daha iyidir.ancak list'ler daha hızlıdır. Ayrıca sayısal bir dizi kullanacaksanız numpy kullanmanızı tavsiye ederim. Bunun dışıdna çok büyük metinsel diziler oluşturacaksanız array kullanabilirsinz.<jupyter_code>from array import array
import sys
arr=array('i',[1,2,3])
lst=[1,2,3]
print(sys.getsizeof(arr),sys.getsizeof(lst)) #arr'ın memory kullanımı daha düşüktür<jupyter_output>76 88<jupyter_text>collections<jupyter_code>my_list = ["a","b","c","c","e","c","b","b","a"]
my_list.count("a")
from collections import Counter

cn = Counter(my_list) #dictionary benzeri bir yapı. tüm dictionary metodları kullanılabilir
print(cn)
print(cn["a"]) #yukarda list ile yaptığımızın aynısı
str_ = "sen seni bil sen seni sen bilmezsen kendini"
cn = Counter(str_.split(' '))
cn
print(cn.most_common(2)) #en çok kullanılan 2 kelime
print(list(cn)) #key değerlerinin listeye çevrilmiş hali
print(dict(cn)) #key-value değerlerinin sözlüğe çevrilmiş hali
#OrderDict'e artık ihtiyaç yoktur. Python 3.7den itibaren de dictioanryye girilen sırayı korumaktadır
#aşağıdaki örnekten de görebiliyoruz
from collections import OrderedDict 
liste = ["a","c","c","a","b","a","a","b","c"]
cnt = Counter(liste)
od = OrderedDict(cnt.most_common())
d=dict(cnt.most_common())
for key, value in od.items():
    print(key, value)
print("----")
for key, value in d.items():
    print(key, value)
from collections import namedtuple

Student = namedtuple('Student', 'fname, lname, age') #class yapısına benzer bir kullanım. indeks ezberlemeye son!
s1 = Student('John', 'Clarke', '13')
print(s1.fname)<jupyter_output>John<jupyter_text>itertools  Permütasyon<jupyter_code>from itertools import permutations #sadece tekrarsızlar yapılabiliyor. n!/(n-r)!
liste=["A","B","C"]
per1=list(permutations(liste))
per2=list(permutations(liste,2))
print(per1)
print(per2)<jupyter_output>[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]<jupyter_text>Kombinasyon<jupyter_code>from itertools import combinations #n!/(r!*(n-r)!)
com=list(combinations(liste,2))
com<jupyter_output><empty_output><jupyter_text>Kartezyen çarpım<jupyter_code>from itertools import product
list1=["A","B","C"]
list2=[2000,2001,2002,2003]
krt=list(product(list1,list2))
krt<jupyter_output><empty_output><jupyter_text>Regex (Düzenli ifadeler) Pythona özgü değildir, hemen her dilde implementasyonu vardır. Başlı başına büyük bi konudur. Burada özet vermeye çalışıcam. İleride Text mining, NLP v.s çalışacaksanız iyi öğrenmenizde fayda var  Isınma<jupyter_code>import re
a="<NAME> volkan"
#match: başında var mı diye kontrol eder
re.match("volkan",a) #eşleşme yok, sonuç dönmez
re.match("ben",a) #var
a.startswith("ben") #bu daha kullanışlıdır.
#search, herhangi bi yerde var mı, matche göre daha yavaş çalışır
re.search("volkan",a)
"volkan" in a #bu daha pratik
b="sen seni bil sen seni"
bul=re.findall("sen", b)

print(bul)
print(len(bul))
print(b.count("sen"))<jupyter_output>['sen', 'sen', 'sen', 'sen']
4
4<jupyter_text>Metakarakter kullanımı<jupyter_code>isimler=["123a","ali","veli","hakan","volkan","osman","kandemir","VOLkan"]
#kan ile bitenler, regex olmadan
kan=[x for x in isimler if x[-3:]=="kan"]
kan<jupyter_output><empty_output><jupyter_text>![image.png](attachment:image.png)  [ ] Köşeli parantez [] işareti, "içine giren karakterleri içeren" filtresi uygular. Burada önemli olan [] içinde gördügümüz tüm karaktereleri tek tek uyguluyor olmasıdır. Ör: [abc]: a veya b veya c içeren demek. [a-z]: A ile Z arasındakiler demek<jupyter_code>#regex ile
for i in isimler:
    if re.search("[a-z]kan",i):
        print(i)
#başta veya ortada bir yerde a-z arasında bir karekter olsun, sonu kan olsun demiş olduk. yani "kan"ın önünde bir harf 
#olsun da nerede olursa olsun, bşta mı ortada mı önemli değil, önemli olan kan'ın öncesinde olmaslı
#içinde e veya m geçenler, bu sefer list comprehension ile yapalım
[i for i in isimler if re.search("[em]",i)]
#rakam içerenler
liste = ["123a","b123","1234","volkan"]
sayıiçerenler=[x for x in liste if re.search("[0-9]",x)]
sayıiçerenler
#rakam ile başlayanları bulma
rakamlabaşlayanlar=[x for x in liste if re.match("[0-9]",x)] #yukardakinden farklı olarak match kullandık, daha hızlı çalışır
rakamlabaşlayanlar
liste=["ABC","Abc","abc","12a","A12","123","Ab1","Ab23"]
print([x for x in liste if re.search("[A-Za-z]",x)]) #büyük veya küçük harf içerenler
print([x for x in liste if re.search("[A-Z][a-z]",x)]) #ilki büyük ikincisi küçük harf içerenler
print([x for x in liste if re.search("[A-Za-z0-9]",x)]) #büyük veya küçük harf veya sayı içerenler
print([x for x in liste if re.search("[A-Z][a-z][0-9]",x)]) #ilki büyük ikincisi küçük üçüncüsü sayı olanlar<jupyter_output>['ABC', 'Abc', 'abc', '12a', 'A12', 'Ab1', 'Ab23']
['Abc', 'Ab1', 'Ab23']
['ABC', 'Abc', 'abc', '12a', 'A12', '123', 'Ab1', 'Ab23']
['Ab1', 'Ab23']<jupyter_text>. Nokta "." tek karekteri için joker anlamındadır<jupyter_code>isimler=["arhan","volkan","osman","hakan","demirhan","1ozan"]
#5 karekterli olup an ile biten gerçek isimler(gerçek isim: sayı ile başlayan birşey isim olamaz)
liste=[x for x in isimler if re.match("[a-z]..an",x)]
liste<jupyter_output><empty_output><jupyter_text>* Yıldız Kendinden önce gelen 1 ifadeyi en az 0(evet 0, 1 değil) sayıda eşleştirir. Özellikle bir ifadenin yazılamayabildiği durumları da kapsamak için kullanılır. Aşağıdkai örnek gayet açıklayıcıdır.<jupyter_code>liste = ["kıral", "kral", "kıro", "kro", "kırmızı","kırçıllı","kritik","kıritik","kııral"]
[x for x in liste if re.match("kı*r[aeıioöuü]",x)]<jupyter_output><empty_output><jupyter_text>Bu örnekte, yabancı dilden geçen kelimelerden "kr" ile başlayanları inceledik. Bunlar bazen aralarına ı harfi girilerek yazılabiliyor. Bu kelimelerde genelde r'den sonra sesli bi harf gelir. Biz de bunları yakalamaya çalıştık.  + Artı Yıldıza benzer, ancak bu sefer en az 1 sayıda eşleşme yapar.<jupyter_code>liste = ["kıral", "kral", "kıro", "kro", "kırmızı","kırçıllı","kritik","kıritik","kııral"]
[x for x in liste if re.match("kı+r[aeıioöuü]",x)]
#yukardaki kan'la biten isimler örneğin. bu sefer VOLkan yazdırılır
for i in isimler:
    if re.search(".+kan",i):
        print(i)<jupyter_output>hakan
volkan
VOLkan<jupyter_text>? Soru işareti Kendinden önce gelen karakterin 0 veya 1 kez geçtiği durumları eşleştirir.<jupyter_code>liste = ["kıral", "kral", "kıro", "kro", "kırmızı","kırçıllı","kritik","kıritik","kııral"]
[x for x in liste if re.match("kı?r[aeıioöuü]",x)]<jupyter_output><empty_output><jupyter_text>{} süslü parantez bir karekterin n adet geçtiği durumlar eşleştirilir.<jupyter_code>liste = ["kıral", "kral", "kıro", "kro", "kırmızı","kırçıllı","kritik","kıritik","kııral"]
[x for x in liste if re.match("kı{2}r[aeıioöuü]",x)]
#böyle de yapılabilirdi ama n sayısı yükseldikçe {} ile yapmak daha mantıklı
[x for x in liste if re.match("kıır[aeıioöuü]",x)]
#{min,max}
liste=["gol","gool","gooool","gööl","gooooooool"]
[x for x in liste if re.match("[a-z]o{2,5}l",x)] #en az 2 en çok 5 oo içersin<jupyter_output><empty_output><jupyter_text>Çeşitli linkler Regex dünyası çok büyük bi dünya, burada hepsini anlatmak yerine kısa bir girizgah yapmış olduk. Öncelikle genel oalrak regexi kavramanız sonrasında da python implementasonunu kavramanız gerekiyor. Aşağıdaki linkleri incelemenizi tavisye ederim.**Genel bilgi**- https://en.wikipedia.org/wiki/Regular_expression- https://regexr.com/ (pratik amaçlı) **Python**- https://docs.python.org/3/howto/regex.html- https://docs.python.org/3/library/re.html  json   jsondan pythona json yapısı python dictionary'lerine çok benzer. elde edeceğimiz nesne de bir dictionary olacaktır<jupyter_code>import json
#örnek bir json stringden
x =  '{ "name":"John", "age":30, "city":"New York"}'
y=json.loads(x) #dcitionary olarak yükler
type(x)
type(y)
y["name"]
#veya json dosyadan. ama bu indenti dikkate almıyor, çünkü elde edilen nesne bi string değil, dictioanry
with open(r"E:\OneDrive\Dökümanlar\GitHub\dataset\json\indentli_bolgesatis.json", mode='r') as f:
    data = json.load(f)
type(data)
data    
#indentli formatı yazdırmak istersek dosya okuması yaparak bi string içine okuruz
with open(r"E:\OneDrive\Dökümanlar\GitHub\dataset\json\indentli_bolgesatis.json", mode='r') as f:
    content=f.read()    # bu stringdir, ve indentli yapı korunmuştur
print(content)
#split oriented kaydedilmiş dosyadan
with io.open(r"E:\OneDrive\Dökümanlar\GitHub\dataset\json\indentli_bolgesatis_split.json", mode='r') as f:
    content=f.read()    
print(content)
#table oriented kaydedilmiş dosyadan
with open(r"E:\OneDrive\Dökümanlar\GitHub\dataset\json\indentli_bolgesatis_table.json", mode='r') as f:
    content=f.read()    
print(content)
c=json.loads(content)
type(c)
c
#içteki tek bir bilgiye ulaşma
c["data"][0]["Bolge"] #dict of list of dict
#tüm bölgeleri alma
for l in c["data"]:
    print(l["Bolge"])<jupyter_output>Akdeniz
Marmara
Akdeniz
Marmara<jupyter_text>pythondan jsona<jupyter_code>x = {
  "name": "John",
  "age": 30,
  "city": "New York"
}

j = json.dumps(x)
type(x)
type(j)
j
#komplike(nested) json
x = {
  "name": "John",
  "age": 30,
  "married": True,
  "divorced": False,
  "children": ("Ann","Billy"),
  "pets": None,
  "cars": [
    {"model": "BMW 230", "mpg": 27.5},
    {"model": "Ford Edge", "mpg": 24.1}
  ]
}

print(json.dumps(x))
#bu da şık hali
print(json.dumps(x,indent=4))
print(json.dumps(x,indent=4,sort_keys=True))<jupyter_output>{
    "age": 30,
    "cars": [
        {
            "model": "BMW 230",
            "mpg": 27.5
        },
        {
            "model": "Ford Edge",
            "mpg": 24.1
        }
    ],
    "children": [
        "Ann",
        "Billy"
    ],
    "divorced": false,
    "married": true,
    "name": "John",
    "pets": null
}<jupyter_text>Bunları aşağıdaki I/O işlemleriyle bir dosyaya da yazdırabilirsiniz.  Request https://realpython.com/python-requests/ sitesinden faydalandım  Basics<jupyter_code>import requests
httpget0=r"https://www.excelinefendisi.com/httpapiservice/ResponseveRequestTarget.aspx" #buna parametre verebiliyoruz, Anakonu=VBAMakro, Altkonu=Temeller
httpget0j=r"https://www.excelinefendisi.com/httpapiservice/ReturnJson.aspx" #tüm duyurlar as json
httpget1=r"http://ptsv2.com/t/trump/d/1"
httpget1json=r"http://ptsv2.com/t/trump/d/1/json"
httpget1txt=r"http://ptsv2.com/t/trump/d/1/text"
httpget2_auth=r"http://ptsv2.com/t/volkitolki/post" #sırayla volki, tolki
httpget3=r"https://httpbin.org/get" #as json
httpget4img=r"https://httpbin.org/image"
httpget5=r"https://www.google.com/search?q=excel&oq=excel&aqs=chrome..69i57j35i39l2j0i433l4j46i433l2j0.839j0j15&sourceid=chrome&ie=UTF-8"
httpget6githubjson=r"https://raw.githubusercontent.com/VolkiTheDreamer/dataset/master/json/bolgesatis.json"
getlist=[httpget0,httpget0j,httpget1,httpget1json,httpget1txt,httpget2_auth,httpget3,httpget4img,httpget5]

httppost1=r"http://ptsv2.com/t/trump/d/20001"
httppost2=r"http://ptsv2.com/t/trump/post"
httppost3=r"https://httpbin.org/post"
httppos4=r"benimsitedekileri daha sonra ekle"
r=requests.get(httpget3)
r.headers
requests.get('http://volkanyurtseven.com')
requests.get('https://volkanyurtseven.com') #https versiyonu yok, hata alcaz
requests.get('http://volkanyurtseven.com/olmayansayfa') #bu sefer site doğru ama bahsekonu sayfa yoksa 404
response = requests.get('http://volkanyurtseven.com')
response.status_code
response = requests.get(httpget1)
response.content #byte olarak
response.text #string olarak
response.raw<jupyter_output><empty_output><jupyter_text>Böyle çok karışık oldu, bunu json olarak okuyalım. ama tabi önce bunun son versiyonuna tekrar bi get atalım.<jupyter_code>#hala biraz okunaklı değil gibi
response = requests.get(httpget1json)
response.text
json.loads(response.text)
#veya responseun json metopdunu kullanabiliriz
response.json()<jupyter_output><empty_output><jupyter_text>It should be noted that the success of the call to r.json() does not indicate the success of the response. Some servers may return a JSON object in a failed response (e.g. error details with HTTP 500). Such JSON will be decoded and returned. To check that a request is successful, use r.raise_for_status() or check r.status_code is what you expect.<jupyter_code>response.raise_for_status()
response.status_code
dict(response.headers)
response.headers['Content-Type']<jupyter_output><empty_output><jupyter_text>QueryString parameters<jupyter_code># Search GitHub's repositories for requests
response = requests.get(
    'https://api.github.com/search/repositories',
    params={'q': 'requests+language:python'},
)

# Inspect some attributes of the `requests` repository
json_response = response.json()
repository = json_response['items'][0]
print(f'Repository name: {repository["name"]}')  # Python 3.6+
print(f'Repository description: {repository["description"]}')  # Python 3.6+
print(response.url)
response = requests.get(
    'https://www.excelinefendisi.com/httpapiservice/ResponseveRequestTarget.aspx',
    params={'Anakonu':'VBAMakro', 'Altkonu':'Temeller'},
)

print(response.url)
response.text
payload = {'key1': 'value1', 'key2': 'value2'}
r = requests.get('https://httpbin.org/get', params=payload)<jupyter_output><empty_output><jupyter_text>Headers<jupyter_code>r.headers
#custimize header
response = requests.get(
    'https://api.github.com/search/repositories',
    params={'q': 'requests+language:python'},
    headers={'Accept': 'application/vnd.github.v3.text-match+json'},
)

# View the new `text-matches` array which provides information
# about your search term within the results
json_response = response.json()
repository = json_response['items'][0]
print(f'Text matches: {repository["text_matches"]}')
requests.post('https://httpbin.org/post', data={'key':'value'})
requests.put('https://httpbin.org/put', data={'key':'value'})
requests.delete('https://httpbin.org/delete')
requests.head('https://httpbin.org/get')
requests.patch('https://httpbin.org/patch', data={'key':'value'})
requests.options('https://httpbin.org/get')
response = requests.head('https://httpbin.org/get')
response.headers['Content-Type']
response = requests.delete('https://httpbin.org/delete')
json_response = response.json()
json_response['args']<jupyter_output><empty_output><jupyter_text>According to the HTTP specification, POST, PUT, and the less common PATCH requests pass their data through the message body rather than through parameters in the query string.<jupyter_code>requests.post('https://httpbin.org/post', data={'key':'value'}) #veya data=[('key', 'value')]
>>> response = requests.post('https://httpbin.org/post', json={'key':'value'})
>>> json_response = response.json()
>>> json_response['data']
'{"key": "value"}'
>>> json_response['headers']['Content-Type']
'application/json'
>>> response = requests.post('https://httpbin.org/post', json={'key':'value'})
>>> response.request.headers['Content-Type']
'application/json'
>>> response.request.url
'https://httpbin.org/post'
>>> response.request.body
b'{"key": "value"}'
response.url
response.headers
response.request.url
response.request.headers
#authhentication
>>> from getpass import getpass
>>> requests.get('https://api.github.com/user', auth=('username', getpass()))<jupyter_output>········<jupyter_text>webserive  BeautifulSoup https://realpython.com/beautiful-soup-web-scraper-python/<jupyter_code>URL = 'https://www.monster.com/jobs/search/?q=Software-Developer&where=Australia'
page = requests.get(URL)
import requests
from bs4 import BeautifulSoup

URL = 'https://www.excelinefendisi.com/Konular/Excel/Giris_PratikKisayollar.aspx'
page = requests.get(URL)

soup = BeautifulSoup(page.content, 'html.parser')
results = soup.find_all(class_='alterantelitable')
for r in results:    
    print(r, end='\n'*2)<jupyter_output><table class="alterantelitable">
<th>Amaç</th>
<th>Kısayol</th>
<tr>
<td>Sayfalar arasında dolaşmak</td>
<td>CTRL + PgUp/PgDn</td>
</tr>
<tr>
<td>Bugünün Tarihini yazmak</td>
<td>CTRL + SHIFT +, </td>
</tr>
<tr>
<td>Tüm açık dosyalarda calculation yapmak</td>
<td>F9</td>
</tr>
<tr>
<td>Seçili kısmın değerini hesaplayıp göstermek</td>
<td>Hücre içindeki formül seçilip F9</td>
</tr>
<tr>
<td>Aktif sayfada calculation yapmak</td>
<td>SHIFT+F9</td>
</tr>
<tr>
<td>Sadece belli range için calculation yapmak</td>
<td>VBA ile yapılır. <a href="/Konular/VBAMakro/DortTemelNesne_Range.aspx#Calculation">Burdan </a>bakın.</td>
</tr>
<tr>
<td>Bulunduğun hücrenin <abbr title="Bulunulan hücrenin etrafındaki tüm dolu alandır">CurrentRegion</abbr>'ını seçme</td>
<td>CTRL+ A</td>
</tr>
<tr>
<td>Bulunduğun hücreden <abbr title="Bulunulan hücrenin etrafındaki tüm dolu alandır">CurrentRegion</abbr>'ın uç noktlarına gitmek</td>
<td>CTRL+ Ok tuşları</td>
</tr>
<tr>
<td>Bulunduğun hücreden itibaren belli bir y[...]<jupyter_text>Gereksiz elementlerden ve taglerden kurtulalım<jupyter_code>results = soup.find_all(class_='alterantelitable')
for r in results:
    tds=r.find_all("td")
    for td in tds:
        print(td.text)<jupyter_output>Sayfalar arasında dolaşmak
CTRL + PgUp/PgDn
Bugünün Tarihini yazmak
CTRL + SHIFT +, 
Tüm açık dosyalarda calculation yapmak
F9
Seçili kısmın değerini hesaplayıp göstermek
Hücre içindeki formül seçilip F9
Aktif sayfada calculation yapmak
SHIFT+F9
Sadece belli range için calculation yapmak
VBA ile yapılır. Burdan bakın.
Bulunduğun hücrenin CurrentRegion'ını seçme
CTRL+ A
Bulunduğun hücreden CurrentRegion'ın uç noktlarına gitmek
CTRL+ Ok tuşları
Bulunduğun hücreden itibaren belli bir yöne doğru seçim yapmak
SHIFT+Ok tuşları
Bulunduğun hücreden itibaren CurrentRegion bir ucuna doğru toplu seçim yapmak
CTRL+SHIFT+Ok tuşları
Bulunduğun hücreden CurrentRegion'ın Sağ Aşağı uç noktlasına gitmek
CTRL+END
Bulunduğun hücreden CurrentRegion'ın Sağ Aşağı uç noktlasına kadar seçmek
CTRL+SHIFT+END
Bulunduğun hücreden  A1 hücresine kadar olan alanı(sol yukarı) seçmek
CTRL+SHIFT+HOME
Bir hücre içinde veri girerken, aynı hücre içinde yeni bir satır açıp oradan devam etmek
ALT+ENTER
Veri/Formül girişi yap[...]<jupyter_text>İşlemle ilgili kısayolu altalta değil de yanyana yazmasını sağlayalım,<jupyter_code>results = soup.find_all(class_='alterantelitable')
for r in results:
    trs=r.find_all("tr")
    for tr in trs:
        td1=tr.select("td")[0] #tr.find("td") de olurdu ama aşağıdakiyle bütünlük olması adına ikisini de select ile yaptık
        td2=tr.select("td")[1]
        print(td1.text,":",td2.text)<jupyter_output>Sayfalar arasında dolaşmak : CTRL + PgUp/PgDn
Bugünün Tarihini yazmak : CTRL + SHIFT +, 
Tüm açık dosyalarda calculation yapmak : F9
Seçili kısmın değerini hesaplayıp göstermek : Hücre içindeki formül seçilip F9
Aktif sayfada calculation yapmak : SHIFT+F9
Sadece belli range için calculation yapmak : VBA ile yapılır. Burdan bakın.
Bulunduğun hücrenin CurrentRegion'ını seçme : CTRL+ A
Bulunduğun hücreden CurrentRegion'ın uç noktlarına gitmek : CTRL+ Ok tuşları
Bulunduğun hücreden itibaren belli bir yöne doğru seçim yapmak : SHIFT+Ok tuşları
Bulunduğun hücreden itibaren CurrentRegion bir ucuna doğru toplu seçim yapmak : CTRL+SHIFT+Ok tuşları
Bulunduğun hücreden CurrentRegion'ın Sağ Aşağı uç noktlasına gitmek : CTRL+END
Bulunduğun hücreden CurrentRegion'ın Sağ Aşağı uç noktlasına kadar seçmek : CTRL+SHIFT+END
Bulunduğun hücreden  A1 hücresine kadar olan alanı(sol yukarı) seçmek : CTRL+SHIFT+HOME
Bir hücre içinde veri girerken, aynı hücre içinde yeni bir satır açıp oradan devam etmek : ALT+[...]<jupyter_text>Bunun bir de MechanicalSoup versiyonu var, onda websitelerindeki formları da otomatik doldurma işlemi yaptırabiliyorsunuz.  Logging Programınızı test ederken print değil bunu kullanmanız önerilir.<jupyter_code>import logging

logging.debug('This is a debug message') 
logging.info('This is an info message')
#by default, the logging module logs the messages with a severity level of WARNING or above
logging.warning('This is a warning message')
logging.error('This is an error message')
logging.critical('This is a critical message')<jupyter_output>WARNING:root:This is a warning message
ERROR:root:This is an error message
CRITICAL:root:This is a critical message<jupyter_text>root= default logger<jupyter_code>logging.basicConfig(level=logging.DEBUG,force=True) #son parametre gerekli. Detay için: https://stackoverflow.com/questions/30861524/logging-basicconfig-not-creating-log-file-when-i-run-in-pycharm/42210221
logging.debug('This will get logged')
logging.basicConfig(filename='app.log', filemode='w', format='%(name)s - %(levelname)s - %(message)s',force=True)
logging.warning('This will get logged to a file')
logging.basicConfig(format='%(name)s - %(levelname)s - %(asctime)s - %(message)s', level=logging.INFO,force=True)
logging.info('Admin logged in')
name = 'John'
logging.error(f'{name} raised an error')
a = 5
b = 0

try:
    c = a / b
except Exception as e:
    logging.error("Exception occurred", exc_info=True)<jupyter_output>root - ERROR - 2021-05-13 00:02:03,893 - Exception occurred
Traceback (most recent call last):
  File "<ipython-input-17-ed4209066cce>", line 5, in <module>
    c = a / b
ZeroDivisionError: division by zero<jupyter_text>tqdm Döngüsel işlemlerde progressbar sağlar<jupyter_code>from tqdm import tqdm
from time import sleep
  
for i in tqdm(range(10)):
    sleep(.1)
# Simple loop
for i in range(100):
    pass

# Loop with a progress bar
for i in trange(100):
    time.sleep(0.01)
from tqdm.notebook import trange, tqdm
from time import sleep

for i in trange(3, desc='1st loop'):
    for j in tqdm(range(100), desc='2nd loop'):
        sleep(0.01)<jupyter_output><empty_output><jupyter_text>Eğer progresbar görünmüyorsa mıuhtemelen nbextensionstaki bi widget üyüzndendir, şuraya bakın : https://stackoverflow.com/questions/57343134/jupyter-notebooks-not-displaying-progress-bars<jupyter_code>!jupyter nbextension enable --py widgetsnbextension
from tqdm import tqdm_notebook
from tqdm.notebook import trange
from time import sleep

for i in trange(4, desc='1st loop'):
    for j in trange(100, desc='2nd loop'):
        sleep(0.01)
from tqdm.notebook import tqdm_notebook
import time

for i in tqdm_notebook(range(10)):
    time.sleep(0.5)<jupyter_output><empty_output><jupyter_text>looplarda tqdm<jupyter_code>from tqdm import tqdm
for i in tqdm(range(2), desc = 'Loop 1'):
    for j in tqdm(range(20,25), desc = 'Loop 2'):
        time.sleep(0.5)
from tqdm.notebook import tqdm_notebook
for i in tqdm_notebook(range(2), desc = 'Loop 1'):
    for j in tqdm_notebook(range(20,25), desc = 'Loop 2'):
        time.sleep(0.5)<jupyter_output><empty_output><jupyter_text>I/O (Dosya okuma yazma)  işlemleri  Okuma dosya = open(dosya_adı, kip)<jupyter_code>os.chdir(r"C:\Users\volka\Documents\GitHub\PythonRocks")
import io
dp = io.open("utility.py", "r")
#oku
#import io #normalde bu satıra gerek yok, open=io.open için bi alias
dosya = io.open("utility.py", "r") #yine bunda da başta io yazmazdık normalde ama os'nin open'ından ayırmak için ekledik
print(dosya.readline(1))
print("----")
print(dosya.read()) #ilk satırı okuduğumuz için ikinci satırdan okumaya devam ediyor
print("----")
dosya.seek(0) #başa konumlanalım tekrar
print(dosya.readline(2)) #baştan ilk 2 karakter
#her satırın başına satır no ekleyelim
dosya.seek(0)
i=1
for satır in dosya.readlines():
    print("{}-{}".format(i,satır),end="")
    i+=1
#yarat
yenidosya=io.open("test.txt","w")
yenidosya.close()
#varolana yaz, sonuna ekleme
yenidosya=io.open("test.txt","a")
yenidosya.write("\nselam")
yenidosya.flush() #hemen yazsın. bunu kullanmazsak yaptığımız değişiklikleri hemen görmeyiz<jupyter_output><empty_output><jupyter_text>Güvenli dosya işlemleri Dosyalarla işiniz bitince kapatmak önemlidir. Kapandığından emin olmak için with bloğu içinde yazmak gerekir<jupyter_code>with io.open("test.txt", "r") as dosya:
    print(dosya.read())
#hem okuma hem yazma moduyla açıp başa bilgi ekleme
with io.open("test.txt", "r+") as f:
    content = f.read()
    f.seek(0) #Dosyayı başa sarıyoruz
    f.write("volkan\n"+content)<jupyter_output><empty_output><jupyter_text>**Türkçe karakter** utf-8 mi cp1254 mü?https://python-istihza.yazbel.com/karakter_kodlama.html<jupyter_code>import locale
locale.getpreferredencoding()
with open(r"E:\OneDrive\Dökümanlar\GitHub\PythonRocks\abc.txt", "r", encoding='cp1254') as f:
    print(f.read())<jupyter_output>Bu birinci satır
bu ikinci
bu da üçüncü<jupyter_text>Yazma<jupyter_code>yenidosya=io.open("writetest.txt","w") #x
yenidosya.write("merhaba\n")
lines=["satır1\n","satır2\n"]
yenidosya.writelines(lines)
yenidosya.close()
#varolana yaz, sonuna ekleme
yenidosya=io.open("writetest.txt","a")
yenidosya.write("\nselam")
yenidosya.flush() #hemen yazsın. bunu kullanmazsak yaptığımız değişiklikleri hemen görmeyiz
yenidosya.close()
f = io.open(r"E:\OneDrive\Dökümanlar\GitHub\PythonRocks\abc.txt", "a", encoding='utf-8')
f.write("yeni satır ekleniyor")
f.close()<jupyter_output><empty_output><jupyter_text>Veritabanı işlemleri<jupyter_code>import sqlite3 as sql #python içinde otomatikman gelir<jupyter_output><empty_output><jupyter_text>sqlite sayfasından chinook databaseini indirin<jupyter_code>vt = sql.connect(r'C:\Users\volka\Downloads\chinook\chinook.db')
cur=vt.cursor()
cur.execute("select * from albums")
cur.fetchmany(3)
veriler = cur.fetchall()
veriler[:5] #ilk 3ünü çektiğimiz için 4ten devam ediyor
vt.close()<jupyter_output><empty_output><jupyter_text>NOT:sqlite3 çok basit bir veritabanı olup, oracle veya sql server gibi güçlü veritabanlarını sorgulamak için sqlalchemy veya pyodbc gibi modülleri kullanırız ve buradan aldığmız datayı pandas ile işleyebiliriz. Bunun için benim github repomdaki Python Veri Analizi notebookuna bakmanızı tavsiye ederim. http://sqlitebrowser.org/. sitesi de incelenebilir  Classlar Python nesne yönelimli(oo) bir dildir ve tüm oo dillerde olduğu gibi sınıflar yaratılabilir. Örnek bir sınıf yaratımı aşağıdaki gibi olup detaylar için googlelamanızı rica ederim.<jupyter_code>class Araba:
    aractipi="Mekanik" #class seviyesinde, tüm Arabalar tarafından paylaşılan bir değer
    def __init__(self,model,marka,km):
        self.model=model
        self.marka=marka
        self.km=km
        print("yeni araç hazır")
    def run(self):
        print("çalışıyor")
    def stop(self):
        print("durdu")

bmw0=Araba(2011,"bmw",0)
bmw1=Araba(2014,"bmw",0)
audi=Araba(2011,"audi",0)
print(bmw0)
bmw0.run()
bmw0.stop()
print(bmw0.aractipi)
print(audi.aractipi)<jupyter_output>yeni araç hazır
yeni araç hazır
yeni araç hazır
<__main__.Araba object at 0x0000018A63391860>
çalışıyor
durdu
Mekanik
Mekanik<jupyter_text>Paralelleştirme Özellikle analitik model kurma sırasında çok işimize yarayan bir olgudur. Bunun için ayrı bir notebook'um olacak. Önden araştırmak isteyenler şu kavramları araştırabilir. Multi-threading, multiprocessing, conccurency ve parallelism  Verimlilik ve Diğer  debugging<jupyter_code>import pdb
print(4)
pdb.set_trace() #c devam, n:next gibi seçenekler var
print("asda")
def myfunc(list_):
    return [1/x for x in list_]
        
liste=[3,5,0,6,7]    
yeniliste=myfunc(liste)
yeniliste
%debug<jupyter_output>> [1;32m<ipython-input-14-1b775e2893d4>[0m(2)[0;36m<listcomp>[1;34m()[0m
[1;32m      1 [1;33m[1;32mdef[0m [0mmyfunc[0m[1;33m([0m[0mlist_[0m[1;33m)[0m[1;33m:[0m[1;33m[0m[1;33m[0m[0m
[0m[1;32m----> 2 [1;33m    [1;32mreturn[0m [1;33m[[0m[1;36m1[0m[1;33m/[0m[0mx[0m [1;32mfor[0m [0mx[0m [1;32min[0m [0mlist_[0m[1;33m][0m[1;33m[0m[1;33m[0m[0m
[0m[1;32m      3 [1;33m[1;33m[0m[0m
[0m[1;32m      4 [1;33m[0mliste[0m[1;33m=[0m[1;33m[[0m[1;36m3[0m[1;33m,[0m[1;36m5[0m[1;33m,[0m[1;36m0[0m[1;33m,[0m[1;36m6[0m[1;33m,[0m[1;36m7[0m[1;33m][0m[1;33m[0m[1;33m[0m[0m
[0m[1;32m      5 [1;33m[0myeniliste[0m[1;33m=[0m[0mmyfunc[0m[1;33m([0m[0mliste[0m[1;33m)[0m[1;33m[0m[1;33m[0m[0m
[0m
ipdb> x
0
ipdb> quit<jupyter_text>memory yönetimi<jupyter_code>import sys
import array
t=(1,2,3)
l=[1,2,"3"]
a=array.array("l",[1,2,3])
print(sys.getsizeof(t)) #immutabel olduğu için daha az
print(sys.getsizeof(l)) #mutable olduğu için tupldan daha çok, içine farklı tipler alabileceğim için arraydan daha çok
print(sys.getsizeof(a)) #eleman tipi belli olduğu için listten daha az<jupyter_output>64
80
76<jupyter_text>Kod saklama Özellikle Data Science çalışmalarınızda olmak üzere bazen detay bilgi verdiğiniz markdown açıklamaları bazen de python kodunuzu gizlemek ve dokümanınızın boyutunu küçültebilrsiniz. Markdownlar için, sadece ilgili yeri okumak isteyenler gizlenmiş kısmı açarak okuyabilir. Kodlar için ise, kodun kendisinden ziyade kodun sonucunu(özellikle görselleştirme kodunu) görmek isteyenlere sadece sonucunu gösterme imkanı bulmuş olursunuz.  Markdownda detay bilgi gizleme Falanca konu(detay görmek için tıklayın)Buraya çeşitli bilgiler yazılabilir.Burası bir markdown hücresi olup içeriği görmek için çift tıklayın. Gördüğünüz gibi burada details elementi içinde summary elementi kullanıyoruz  Kod gizleme Kodlarınızı gizlemek için ise aşağıdaki kodu kullanabilirsiniz.DİKKAT:Bu örnekte, butona bastığınızda sayfadaki tüm input hücreleri gizlenir. Bunlar tekrar göstermek için butona bir kez daha basın.Bu konuda daha farklı çözümleri şu sayfada bulabilirsiniz.<jupyter_code>#python code
import matplotlib.pyplot as plt
%matplotlib inline
_, axes = plt.subplots(2, 2)

axes[0, 0].plot(range(10), 'r') #row=0, col=0
axes[1, 0].plot([x**2 for x in range(10)], 'b') #row=1, col=0
axes[0, 1].plot([x**3 for x in range(10)], 'g') #row=0, col=1
axes[1, 1].plot([x**4 for x in range(10)], 'k') #row=1, col=1
plt.show()

#kod gizlemek için burdan itibaren olan kısım kullanılır
from IPython.display import HTML

HTML('''<script>
code_show=true; 
function code_toggle() {
if (code_show){
$('div.input').hide();
} else {
$('div.input').show();
}
code_show = !code_show
} 
$( document ).ready(code_toggle);
</script>
<form action="javascript:code_toggle()"><input type="submit" value="Kodu görmek/gizlemek için tıklayın."></form>''')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1271716469770674, 'fraction_numerical': 0.026393863259742342, 'mean_word_length': 5.6805642353361305, 'pattern_counts': {'":': 34, '<': 469, '<?xml version=': 0, '>': 510, 'https://': 46, 'lorem ipsum': 0, 'www.': 11, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 2, 'word_list_counts': {'cursed_substrings.json': 21, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '106', 'dir': 'jupyter-structured-clean-dedup', 'id': '189484', 'license': 'Apache-2.0', 'n_tokens_mistral': 34773, 'n_tokens_neox': 32193, 'n_words': 7193, 'path': 'Python Genel.ipynb', 'repo_name': 'VolkiTheDreamer/PythonRocks', 'size': '74863'}