Python Anahtar Kelimeleri ve Tanımlayıcıları (Güncel)

Python Anahtar Kelimeleri ve Tanımlayıcıları (Güncel)

Giriş

Python, dinamik ve güçlü yapısıyla yazılım geliştiricilerin en çok tercih ettiği dillerden biridir. Bu gücün temelinde, dilin temel yapı taşlarını oluşturan anahtar kelimeler (keywords) ve tanımlayıcılar (identifiers) yatar. Her programlama dilinde olduğu gibi, Python’da da bu temel kavramların doğru anlaşılması ve etkin bir şekilde kullanılması, okunabilir, sürdürülebilir ve hatasız kod yazmanın anahtarıdır. Bu makale, Python’ın anahtar kelimelerini ve tanımlayıcılarını derinlemesine inceleyecek, güncel Python versiyonlarındaki kullanımlarını, kurallarını ve en iyi uygulamalarını detaylandıracaktır. Amacımız, hem yeni başlayanlar hem de deneyimli Python geliştiricileri için bu kritik konular hakkında kapsamlı bir rehber sunmaktır.

Python kodunu okuduğunuzda veya yazdığınızda, belirli kelimelerin özel bir anlam taşıdığını ve belirli görevleri yerine getirdiğini fark edersiniz. Bunlar anahtar kelimelerdir. Diğer yandan, kendi değişkenlerinizi, fonksiyonlarınızı, sınıflarınızı veya modüllerinizi adlandırmak için kullandığınız isimler ise tanımlayıcılardır. Bu iki kavram, dilin sözdizimini (syntax) ve anlambilimini (semantics) oluşturarak, bilgisayarla etkileşim kurmamızı ve karmaşık problemleri çözmemizi sağlar. Python’ın sürekli gelişen yapısı göz önüne alındığında, özellikle async ve await gibi yeni anahtar kelimelerin eklenmesiyle bu temel kavramların güncel bir bakış açısıyla ele alınması büyük önem taşımaktadır.

Python Anahtar Kelimeleri (Keywords)

Tanım ve Önemi

Python anahtar kelimeleri, Python dilinde önceden tanımlanmış ve özel bir anlamı olan, rezerve edilmiş kelimelerdir. Bu kelimeler, dilin sözdiziminin bir parçasıdır ve belirli bir işlevi yerine getirmek üzere tasarlanmıştır. Örneğin, bir koşul belirtmek için if, bir döngü başlatmak için for veya bir fonksiyon tanımlamak için def anahtar kelimeleri kullanılır. Anahtar kelimeler, Python yorumlayıcısı tarafından özel olarak tanınır ve yorumlanır. Bu nedenle, anahtar kelimeleri değişken, fonksiyon veya sınıf adı gibi tanımlayıcı olarak kullanamazsınız. Bu kısıtlama, dilin tutarlılığını ve okunabilirliğini sağlar, çünkü her anahtar kelimenin belirli bir bağlamda net bir anlamı vardır.

Anahtar kelimeler, programın akışını kontrol etmek, veri yapılarını tanımlamak, istisnaları yönetmek, modülleri içe aktarmak ve daha birçok temel programlama görevini gerçekleştirmek için vazgeçilmezdir. Onlar olmadan, Python programları anlamsız bir karakter dizisi olmaktan öteye gidemezdi. Her anahtar kelime, Python’ın belirli bir özelliğini veya yapısını temsil eder ve bu yapıların doğru bir şekilde kullanılması, güçlü ve verimli kod yazmanın temelini oluşturur.

Anahtar Kelimelerin Listesi ve Erişimi

Python, zaman zaman yeni anahtar kelimeler ekleyerek veya mevcut anahtar kelimelerin davranışlarını güncelleyerek gelişir. Bu nedenle, hangi kelimelerin anahtar kelime olduğunu bilmek önemlidir. Python’da mevcut anahtar kelimelerin listesine keyword modülünü kullanarak erişebiliriz. Bu modül, Python’ın standart kütüphanesinin bir parçasıdır ve anahtar kelimelerle ilgili faydalı işlevler sunar.

Aşağıdaki kod parçacığı, mevcut tüm Python anahtar kelimelerini nasıl listeleyeceğimizi gösterir:

import keyword

print("Python Anahtar Kelimeleri:")
for kw in keyword.kwlist:
    print(kw)

Bir kelimenin anahtar kelime olup olmadığını kontrol etme
print(f"\n'if' bir anahtar kelime mi? {keyword.iskeyword('if')}")
print(f"'my_variable' bir anahtar kelime mi? {keyword.iskeyword('my_variable')}")

Bu kodu çalıştırdığınızda, Python’ın o anki sürümünde tanımlı olan tüm anahtar kelimelerin bir listesini göreceksiniz. Python 3.10 ve sonrası için tipik bir liste şunları içerecektir:

False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield.

Yaygın Anahtar Kelimeler ve Kullanımları

Python anahtar kelimeleri, farklı kategorilerde gruplandırılabilir ve her biri belirli bir programlama amacına hizmet eder:

Mantıksal Değerler ve Operatörler:

* True: Mantıksal doğru değeri temsil eder.
* False: Mantıksal yanlış değeri temsil eder.
* None: Bir değerin yokluğunu temsil eden özel bir null nesnesidir.
* and: Mantıksal VE operatörü. Her iki koşul da doğruysa doğru döner.
* or: Mantıksal VEYA operatörü. Koşullardan en az biri doğruysa doğru döner.
* not: Mantıksal DEĞİL operatörü. Bir koşulun tersini döndürür.

x = True
y = False
print(x and y) # False
print(x or y)  # True
print(not y)   # True
my_var = None
if my_var is None:
    print("Değer atanmamış.")

Kontrol Akışı:

* if, elif, else: Koşullu ifadeler için kullanılır.
* for: Tekrarlayan döngüler için (iterable nesneler üzerinde).
* while: Koşul doğru olduğu sürece döngü için.
* break: Döngüyü anında sonlandırır.
* continue: Döngünün mevcut iterasyonunu atlar ve bir sonraki iterasyona geçer.
* pass: Hiçbir şey yapmayan bir yer tutucu ifade. Boş bir blok tanımlamak için kullanılır.

sayi = 10
if sayi > 0:
    print("Pozitif")
elif sayi == 0:
    print("Sıfır")
else:
    print("Negatif")

for i in range(5):
    if i == 2:
        continue
    if i == 4:
        break
    print(i) # Çıktı: 0, 1, 3

Fonksiyonlar, Sınıflar ve Modüller:

* def: Bir fonksiyon tanımlamak için kullanılır.
* class: Bir sınıf tanımlamak için kullanılır.
* return: Bir fonksiyondan değer döndürmek için kullanılır.
* import: Bir modülü veya paketi içe aktarmak için kullanılır.
* from: Bir modülden belirli nesneleri içe aktarmak için kullanılır.
* as: İçe aktarılan modüllere veya nesnelere takma ad (alias) vermek için kullanılır.
* lambda: Anonim (isimsiz) fonksiyonlar oluşturmak için kullanılır.

def topla(a, b):
    return a + b

class MyClass:
    pass

import math as m
print(m.pi)

anonim_topla = lambda x, y: x + y
print(anonim_topla(3, 4))

İstisna Yönetimi:

* try: Hata potansiyeli olan kodu içeren blok.
* except: try bloğunda bir istisna oluştuğunda çalışacak blok.
* finally: try-except bloğu tamamlandıktan sonra her zaman çalışacak blok.
* raise: Bir istisnayı manuel olarak tetiklemek için kullanılır.
* assert: Bir koşulun doğru olduğunu iddia etmek için kullanılır; yanlışsa AssertionError yükseltir.

try:
    sonuc = 10 / 0
except ZeroDivisionError:
    print("Sıfıra bölme hatası!")
finally:
    print("İşlem tamamlandı.")

assert 1 == 2, "Bir eşit değil iki!" # Bu satır AssertionError yükseltir.

Değişken Kapsamı:

* global: Bir fonksiyon içinde genel (global) bir değişkene erişmek veya onu değiştirmek için kullanılır.
* nonlocal: İç içe geçmiş fonksiyonlarda dış (ancak genel olmayan) bir kapsamdaki değişkene erişmek veya onu değiştirmek için kullanılır.

global_var = 10

def func1():
    global global_var
    global_var = 20
    print(f"func1 içinden global_var: {global_var}")

def func2():
    outer_var = 30
    def inner_func():
        nonlocal outer_var
        outer_var = 40
        print(f"inner_func içinden outer_var: {outer_var}")
    inner_func()
    print(f"func2 içinden outer_var: {outer_var}")

func1() # Çıktı: func1 içinden global_var: 20
print(f"Dışarıdan global_var: {global_var}") # Çıktı: Dışarıdan global_var: 20
func2() # Çıktı: inner_func içinden outer_var: 40, func2 içinden outer_var: 40

Diğerleri:

* del: Nesneleri silmek veya referanslarını kaldırmak için kullanılır.
* in: Bir elemanın bir dizide (veya başka bir iterable’da) olup olmadığını kontrol etmek için kullanılır.
* is: İki nesnenin bellekte aynı nesne olup olmadığını kontrol etmek için kullanılır.
* with, as: Kaynak yönetimini (dosyalar, kilitler vb.) basitleştiren bağlam yöneticileri (context managers) için kullanılır.

my_list = [1, 2, 3]
del my_list[0]
print(my_list) # Çıktı: [2, 3]

if 2 in my_list:
    print("2 listede var.")

a = [1]
b = [1]
print(a is b) # False (farklı nesneler)
c = a
print(a is c) # True (aynı nesne)

with open("example.txt", "w") as f:
    f.write("Merhaba dünya!")
Dosya otomatik olarak kapanır.

Asenkron Programlama (Python 3.5+):

* async: Bir fonksiyonu veya bağlam yöneticisini asenkron olarak işaretlemek için kullanılır.
* await: Bir asenkron işlemin tamamlanmasını beklemek için kullanılır. Sadece async fonksiyonlar içinde kullanılabilir.

import asyncio

async def greet(name):
    await asyncio.sleep(1) # 1 saniye bekler
    print(f"Merhaba, {name}!")

async def main():
    await greet("Dünya")
    await greet("Python")

asyncio.run(main())
Bu kodu doğrudan bir script içinde çalıştırırsanız, çıktıyı göreceksiniz.
"Merhaba, Dünya!" ve sonra "Merhaba, Python!" 1 saniye arayla.

Anahtar Kelimelerin Özellikleri ve Kuralları

1. Rezerve Edilmişlerdir: Anahtar kelimeler, Python yorumlayıcısı tarafından özel bir anlam taşıdığı için değişken, fonksiyon, sınıf veya modül adları olarak kullanılamazlar. Bu kuralın çiğnenmesi SyntaxError ile sonuçlanır.
2. Büyük/Küçük Harf Duyarlıdır: Python anahtar kelimeleri büyük/küçük harf duyarlıdır. Örneğin, if bir anahtar kelime iken, If veya IF değildir (ancak bunları tanımlayıcı olarak kullanmak iyi bir uygulama değildir, çünkü kafa karışıklığına yol açabilir). True, False ve None dışındaki tüm anahtar kelimeler küçük harfle yazılır.
3. Değiştirilemezler: Anahtar kelimelerin anlamları veya işlevleri değiştirilemez.
4. Sınırlı Sayıdadırlar: Python’ın anahtar kelime sayısı nispeten küçüktür, bu da dilin basitliğini ve öğrenme kolaylığını destekler.

Python Tanımlayıcıları (Identifiers)

Tanım ve Önemi

Tanımlayıcılar, Python’da değişkenlere, fonksiyonlara, sınıflara, modüllere veya diğer program öğelerine verdiğimiz isimlerdir. Kendi kodumuzda oluşturduğumuz her isimlendirilmiş öğe bir tanımlayıcıdır. Örneğin, my_variable = 10 ifadesinde my_variable bir tanımlayıcıdır; def calculate_sum(a, b): ifadesinde calculate_sum, a ve b tanımlayıcılardır.

Tanımlayıcılar, kodun okunabilirliği ve anlaşılabilirliği için hayati öneme sahiptir. İyi seçilmiş tanımlayıcılar, kodun ne yaptığını ve hangi amaca hizmet ettiğini hızla kavramamıza yardımcı olur. Kötü adlandırılmış tanımlayıcılar ise kodun karmaşıklığını artırır, hata ayıklamayı zorlaştırır ve projenin sürdürülebilirliğini olumsuz etkiler. Bir programın sadece bilgisayar tarafından değil, aynı zamanda insanlar tarafından da anlaşılabilir olması gerektiği unutulmamalıdır.

Tanımlayıcı Oluşturma Kuralları

Python’da geçerli bir tanımlayıcı oluşturmak için belirli kurallar vardır:

1. Başlangıç Karakteri: Tanımlayıcılar bir harf (a-z, A-Z) veya bir alt çizgi (_) ile başlamalıdır. Sayı ile başlayamazlar.
* Geçerli: my_variable, _internal_var, Name
* Geçersiz: 1st_var, !invalid
2. Sonraki Karakterler: İlk karakterden sonraki karakterler harfler (a-z, A-Z), sayılar (0-9) veya alt çizgiler (_) olabilir.
* Geçerli: var_1, total_amount, userName2
* Geçersiz: my-variable (tire - özel bir karakterdir), user name (boşluk içerir)
3. Anahtar Kelime Yasağı: Tanımlayıcılar Python’ın anahtar kelimelerinden biri olamaz.
* Geçerli: my_if_statement, class_name_var
* Geçersiz: if, class, for
4. Özel Karakter Yasağı: Tanımlayıcılar !, @, #, $, %, ^, &, *, (, ), -, +, =, {, }, [, ], |, \, ;, :, ', ", <, >, /, ?, . gibi özel karakterler içeremez. Sadece alt çizgiye (_) izin verilir.
5. Boşluk Yasağı: Tanımlayıcılar boşluk içeremez. Birden fazla kelimeden oluşan tanımlayıcılar için genellikle alt çizgi (_) veya büyük harfle başlama (camelCase/PascalCase) kullanılır.
6. Büyük/Küçük Harf Duyarlılığı: Python tanımlayıcılar konusunda büyük/küçük harf duyarlıdır. Yani, myVar, myvar ve MyVar üç farklı tanımlayıcı olarak kabul edilir.

# Geçerli Tanımlayıcılar
my_variable = 10
_private_data = "Gizli"
ClassName = "Örnek Sınıf"
calculateSum = lambda x, y: x + y
MAX_VALUE = 1000

Geçersiz Tanımlayıcılar (Yorum satırı olarak, hata verirler)
1st_number = 5        # Sayı ile başlıyor
my-var = 20           # Tire (-) içeriyor
class = "Python"      # Anahtar kelime
user name = "Alice"   # Boşluk içeriyor
$amount = 50          # Özel karakter içeriyor

Tanımlayıcı Adlandırma Konvansiyonları (PEP 8)

Geçerli bir tanımlayıcı oluşturmak bir şeydir, ancak iyi bir tanımlayıcı oluşturmak başka bir şeydir. Python topluluğu, kodun okunabilirliğini ve tutarlılığını artırmak için PEP 8 (Python Geliştirme Önerisi 8) stil rehberinde belirli adlandırma konvansiyonları belirlemiştir. Bu konvansiyonlara uymak şiddetle tavsiye edilir:

1. Değişkenler, Fonksiyonlar, Modüller ve Paketler:
* Küçük harfli, kelimeler arasında alt çizgi (_) ile ayrılmış (snake_case) olmalıdır.
* Örnek: my_variable, calculate_total, my_module.py, my_package
2. Sınıflar:
* Her kelimenin ilk harfi büyük, kelimeler arasında boşluk veya alt çizgi olmayan (PascalCase veya CamelCase) olmalıdır.
* Örnek: MyClass, HttpRequestHandler, UserProfile
3. Sabitler (Constants):
* Tüm harfler büyük, kelimeler arasında alt çizgi (_) ile ayrılmış olmalıdır.
* Örnek: MAX_CONNECTIONS, PI, DATABASE_URL
4. Özel Kullanımlar (Leading/Trailing Underscores):
* Tek Başa Gelen Alt Çizgi (_):
* Bir döngüde veya atamada kullanılmayacak bir değeri belirtmek için "atıl" bir değişken olarak kullanılır.
* Bir önceki ifadenin sonucunu depolayan interaktif yorumlayıcı değişkenidir.
* Bazen bir isim çakışmasını önlemek için kullanılır (örneğin, bir parametre bir anahtar kelime ile aynı adı taşıyorsa).
* Örnek: for _ in range(5): print("Hello"), def func(class_): pass
* Tek Başa Gelen Alt Çizgi ile Başlayan (_variable):
* Dahili kullanım için bir "zayıf özel" (weak "private") göstergesidir. Python'da gerçek özel (private) üyeler yoktur, ancak bu konvansiyon, bu değişkenin veya metodun bir modül veya sınıfın dahili bir parçası olduğunu ve dışarıdan doğrudan erişilmemesi gerektiğini belirtir.
from module import kullanılırken bu isimler içe aktarılmaz.
* Örnek: _internal_helper_function, _cache
* Çift Başa Gelen Alt Çizgi ile Başlayan (__variable):
* "İsim karıştırma" (name mangling) için kullanılır. Bir sınıf içinde bu şekilde adlandırılan bir özellik, sınıfın adı ile karıştırılır (_ClassName__variable). Bu, alt sınıflarda isim çakışmalarını önlemek için kullanılır ve daha "güçlü özel" bir gösterge olarak kabul edilir.
* Örnek: class MyClass: def __private_method(self): pass
* Çift Başa ve Çift Sona Gelen Alt Çizgi ile Başlayan ve Biten (__method__):
* "Dunder metotlar" (double underscore methods) olarak bilinir. Bunlar, Python tarafından özel anlam taşıyan ve genellikle dilin dahili davranışlarını özelleştirmek için kullanılan özel metotlardır (örneğin, __init__, __str__, __add__). Bu isimler rezerve edilmiştir ve kendi özel metotlarınızı bu şekilde adlandırmaktan kaçınmalısınız.
* Örnek: __init__, __str__, __len__, __call__

Adlandırma konvansiyonlarına uymak, özellikle büyük projelerde veya ekip ortamlarında kodun tutarlılığını ve okunabilirliğini büyük ölçüde artırır. Bu sadece bir stil meselesi değil, aynı zamanda yazılım mühendisliğinin önemli bir yönüdür.

Geçerli ve Geçersiz Tanımlayıcı Örnekleri

Aşağıda, kurallara ve konvansiyonlara uygun ve uygun olmayan tanımlayıcılara dair bazı örnekler verilmiştir:

# Geçerli ve İyi Adlandırılmış Tanımlayıcılar
user_name = "Alice"           # snake_case, değişken
calculate_area = lambda w, h: w * h # snake_case, fonksiyon
MyDatabaseConnector = None    # PascalCase, sınıf
MAX_RETRIES = 5               # ALL_CAPS, sabit
_internal_data = []           # Tek alt çizgi, dahili kullanım
__api_key = "secret"          # Çift alt çizgi, isim karıştırma (sınıf içinde daha anlamlı)
__len__ = 5                   # Dunder metot, Python tarafından rezerve edilmiş (kendi değişkeniniz için kullanmayın!)

Geçersiz Tanımlayıcılar (SyntaxError veya mantıksal hata verirler)
7days = "hafta"             # Sayı ile başlıyor
my-list = [1, 2, 3]         # Tire (-) içeriyor
for = "döngü"               # Anahtar kelime
def func_name(): pass      # def anahtar kelime
my name = "Bob"             # Boşluk içeriyor
$amount = 100               # Özel karakter içeriyor

Geçerli ama Kötü Adlandırılmış Tanımlayıcılar (PEP 8 ihlalleri)
A = 10                        # Tek harf, amacı belirsiz
myVar = 20                    # camelCase, değişkenler için önerilmez
CalculateSum = lambda x, y: x + y # PascalCase, fonksiyonlar için önerilmez
some_constant = "value"       # snake_case, sabitler için önerilmez (ALL_CAPS olmalı)

Anahtar Kelimeler ve Tanımlayıcılar Arasındaki İlişki

Çakışmama Prensibi

Anahtar kelimeler ve tanımlayıcılar arasındaki en temel ilişki, anahtar kelimelerin tanımlayıcı olarak kullanılamamasıdır. Bu "çakışmama prensibi", Python dilinin sözdiziminin netliğini ve tutarlılığını sağlar. Eğer if kelimesini hem bir koşul ifadesi başlatmak hem de bir değişken adı olarak kullanabilseydik, Python yorumlayıcısı kodu nasıl yorumlayacağı konusunda kafa karışıklığı yaşardı. Bu durum, SyntaxError ile sonuçlanarak programın çalışmasını engeller.

Bu prensip sayesinde, bir Python programını okuduğunuzda veya yazdığınızda, anahtar kelimelerin her zaman belirli bir dil yapısını temsil ettiğini bilirsiniz. Bu da kodun anlaşılmasını ve hata ayıklamasını kolaylaştırır.

İyi Kodlama Uygulamaları

İyi bir Python geliştiricisi olmak, sadece dilin kurallarını bilmekle kalmaz, aynı zamanda bu kuralları etkin ve anlaşılır bir şekilde uygulamak anlamına gelir. Anahtar kelimeler ve tanımlayıcılar bağlamında, bu aşağıdaki iyi kodlama uygulamalarını içerir:

1. Anlamlı İsimler Kullanın: Tanımlayıcılarınızın amacını ve içeriğini açıkça yansıtmasına özen gösterin. Örneğin, x yerine customer_name veya a yerine invoice_amount kullanmak, kodun okunabilirliğini önemli ölçüde artırır.
2. PEP 8 Konvansiyonlarına Uyun: Python topluluğunun kabul ettiği adlandırma standartlarına (PEP 8) uymak, kodunuzun diğer geliştiriciler tarafından daha kolay anlaşılmasını sağlar. Bu, özellikle açık kaynak projelerde veya ekip çalışmasında kritik öneme sahiptir.
3. Anahtar Kelimeleri Karıştırmayın: Anahtar kelimelerin büyük/küçük harf varyasyonlarını (örneğin, If veya CLASS) tanımlayıcı olarak kullanmaktan kaçının. Bu, kodun anahtar kelimelerle karıştırılmasına ve potansiyel hatalara yol açabilir.
4. Kısa ve Öz Olun, Ancak Açıklayıcı Olun: Tanımlayıcılar ne çok uzun ne de çok kısa olmalıdır. Amacını açıkça belirten ancak gereksiz kelimelerden kaçınan isimler tercih edin.
5. Tutarlılık: Projeniz boyunca aynı adlandırma konvansiyonlarını tutarlı bir şekilde kullanın. Bir kere snake_case kullanmaya başladıysanız, o projede tüm değişkenler ve fonksiyonlar için snake_case kullanmaya devam edin.

Bu prensiplere uymak, sadece hatasız kod yazmanıza yardımcı olmakla kalmaz, aynı zamanda kodunuzu daha "Pythonic" hale getirir. Python, "okunabilirlik" felsefesini benimsemiş bir dildir ve bu felsefe, anahtar kelimelerin netliğinden ve tanımlayıcıların iyi adlandırılmasından büyük ölçüde beslenir.

Sonuç

Python'da anahtar kelimeler ve tanımlayıcılar, dilin temel direkleridir. Anahtar kelimeler, Python yorumlayıcısının özel olarak tanıdığı, belirli işlevleri yerine getiren rezerve edilmiş kelimelerdir. Programın akışını kontrol etmekten veri yapılarını tanımlamaya kadar birçok temel programlama görevini mümkün kılarlar. async ve await gibi yeni anahtar kelimelerin eklenmesi, Python'ın modern programlama paradigmalarına uyum sağladığını ve dilin dinamik gelişimini göstermektedir.

Diğer yandan, tanımlayıcılar, programcıların değişkenlere, fonksiyonlara, sınıflara ve diğer program öğelerine verdikleri isimlerdir. Onlar, kodun okunabilirliğini, anlaşılabilirliğini ve sürdürülebilirliğini doğrudan etkiler. Python'ın katı adlandırma kuralları ve PEP 8 gibi güçlü adlandırma konvansiyonları, geliştiricilerin tutarlı ve anlamlı kod yazmalarına yardımcı olur.

Bu iki kavram arasındaki ilişki basittir: anahtar kelimeler asla tanımlayıcı olarak kullanılamaz. Bu kural, dilin sözdiziminin netliğini ve yorumlayıcının kod üzerindeki yorumlama yeteneğini garanti eder. İyi adlandırılmış tanımlayıcılar ve anahtar kelimelerin doğru kullanımı, sadece çalışan bir program yazmakla kalmaz, aynı zamanda bakımı kolay, anlaşılır ve işbirliğine açık bir yazılım geliştirmenin temelini oluşturur. Bu nedenle, her Python geliştiricisinin bu temel kavramları derinlemesine anlaması ve en iyi uygulamaları benimsemesi büyük önem taşımaktadır. Kod yazarken her zaman "Bu kod başkası tarafından okunduğunda ne kadar anlaşılır olacak?" sorusunu sormak, sizi daha iyi bir geliştirici yapacaktır.