PEP-8 Eğitimi: Python’da Kod Standartları

Python Geliştirme Önerisi olan PEP-8, kodunuzu daha düzenli ve okunaklı hale getirmek için kullanabileceğiniz bazı kilit noktaları sunar. Python’un yaratıcısı Guido Van Rossum’un dediği gibi:

Kod, yazıldığından çok daha sık okunur.

Bu yazıda PEP-8’i bazı kod örnekleriyle keşfetmeye başlayacaksınız! Aşağıdaki konuları ele alacaksınız:

• Önce PEP-8’in ne olduğunu ve neden ihtiyaç duyduğunuzu öğreneceksiniz;
• Ardından, programcılar arasında hararetli bir konu olan girintilemeye (indentation) değineceksiniz. Sekme mi boşluk mu kullanmalı? Bu bölümde cevabı bulacaksınız;
• Belki beklemezsiniz, ancak azami satır uzunluğu için de yönergeler var;
• Ayrıca, boş satırların nasıl kullanılacağına dair önerilen bir yöntem mevcut;
• Sonra, ifadelerde ve deyimlerde boşluk kullanımını bir başlangıç düzeyi olarak kolayca ele alabilirsiniz;
• Encoding nedir ve Python ile çalışırken neden gerekebilir? Python3’ün varsayılan encoding’i nedir? Kaynak dosya kodlaması (source line encoding) bölümü tüm bunları ele alacak.
• Kodlarken sık sık import yapıyorsunuzdur. Bu bölümde import’ların sırası, mutlak (absolute) ve göreli (relative) import’lar, wildcard import’lar vb. konular işlenecek;
• Dokümantasyon, bir uygulamanın tüm yönlerini takip etmek ve nihai ürünün genel kalitesini artırmak için gereklidir. Burada yorumlar (comments) kritik öneme sahiptir!
• Modül düzeyi dunder adlarını biliyor musunuz? Bunlar docstring’lerde özellikle faydalıdır!
• Son olarak adlandırma kuralları hakkında daha fazla bilgi edineceksiniz: fonksiyon adlarını nasıl türetebileceğinizi, tipik olarak hangi adlandırma stilini kullanacağınızı ve çok daha fazlasını keşfedeceksiniz;
• Kodunuz PEP-8’e Uygun mu? Bu, kendinize mutlaka sormanız gereken bir sorudur. Bu yüzden son bölüm, burada ve burada ele almadığınız daha pek çok yönergeye uyup uymadığını görmek için kodunuzu denetlemenize yardımcı olacak bazı araçları kapsar!

PEP-8’e Giriş

Python programlama dili, birçok kişi için tercih edilen dillerden biri haline geldi. Öğrenmesi görece kolay, çok paradigmalı, dilin işlevselliğini artıran pek çok açık kaynak modüle sahip ve veri bilimi ile web geliştirme topluluğunun başvurduğu bir araç.

Ancak Python’un avantajlarından, fikirlerinizi kodla daha iyi ifade etmeyi bildiğinizde yararlanabilirsiniz. Python belirli hedeflerle tasarlandı; bu hedefler import this yazdığınızda görülebilir.

import this
Altyapı:

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
Altyapı:

Yukarıdakiler, Python programlamanın kullandığı ve Python’un Zen’i olarak bilinen 20 ilkedir. Çıktıda “Readability Counts” (Okunabilirlik Önemlidir) ifadesini de görürsünüz; bu, kod yazarken ana kaygınız olmalıdır: Diğer programcılar veya veri bilimcileri kodunuzu anlamalı ve eldeki görevi çözebilmesi için katkıda bulunabilmelidir.

İzleyen bölümler, bunu nasıl başarabileceğinize dair daha fazla içgörü sağlayacak!

Girintileme

Python ile programlarken girintileme kesinlikle kullanacağınız bir şeydir. Ancak dikkatli olmalısınız; sözdizimi hatalarına yol açabilir. Bu nedenle tavsiye, girinti için dört boşluk kullanmaktır. Örneğin, şu ifade dört boşlukla girintilenmiştir:

if True:
    print("If works")
Altyapı:

Ayrıca şu for döngüsü ve print ifadesi de dört boşlukla girintilenmiştir:

for element in range(0, 5):
    print(element)
Altyapı:

Büyük bir ifadeyi yazarken, ifadeyi dikeyde hizalı tutmak en iyisidir. Bunu yaptığınızda “asılı girinti” (hanging indent) oluşturursunuz.

İşte büyük ifadelerde asılı girinti kullanımına dair bazı örnekler; nasıl kullanabileceğinize ilişkin çeşitli varyasyonları gösterir:

1. value = square_of_numbers(num1, num2,
                          num3, num4)
   Altyapı:

2. def square_of_number(
        num1, num2, num3, 
        num4):
    return num1**2, num2**2, num3**2, num4**2
   Altyapı:

3. value = square_of_numbers(
                 num1, num2,
                 num3, num4)
   Altyapı:

4. list_of_people = [
    "Rama",
    "John",
    "Shiva"
   ]
   Altyapı:

5. dict_of_people_ages = {
    "ram": 25,
    "john": 29,
    "shiva": 26
   }
   Altyapı:

Python ya da başka bir dil ile çalışan her geliştirici, bir noktada girinti için sekme mi boşluk mu kullanılacağını kendine sorar. Sekme ve boşluk arasındaki fark toplulukta süregelen bir tartışmadır. Örneğin bu Stackoverflow yazısına göz atın.

Genel olarak boşluklar tercih edilir; ancak sekme kullanan Python betikleri bulursanız, girintilemeye sekmelerle devam etmelisiniz. Aksi halde, betiğinizdeki tüm ifadelerin girintisini boşlukla değiştirmelisiniz.

Not: Python 3, girintilemede sekme ve boşlukların karışık kullanılmasına izin vermez. Bu yüzden ikisinden birini seçip ona bağlı kalmalısınız!

Azami Satır Uzunluğu

Genel olarak, Python kodunuzda satır uzunluğunu 79 karakteri hedeflemek iyidir.

Bu hedefin pek çok avantajı vardır. Bunlardan birkaçı şunlardır:

• Dosyaları karşılaştırmak için yan yana açmak mümkündür;
• Tüm ifadeyi yatay kaydırma olmadan görebilir, bu da okunabilirlik ve kodun anlaşılabilirliğini artırır.

Yorumlar için satır uzunluğu 72 karakter olmalıdır. Bu eğitimde ileride yorumlar için en yaygın kuralları daha fazla öğreneceksiniz!

Sonuçta, küçük bir ekipte çalışıyorsanız hangi kodlama kuralları ve stili izlediğiniz size kalmıştır; azami satır uzunluğu yönergesinden sapmak çoğu geliştirici için kabul edilebilir olabilir. Ancak bir açık kaynak projeyi geliştiriyor veya katkıda bulunuyorsanız, PEP-8’in koyduğu azami satır uzunluğu kuralına uymak isteyebilir ve/veya ihtiyaç duyabilirsiniz.

+ operatörünü kullanırken, uygun bir satır kırımı yapmak kodunuzu daha anlaşılır kılar:

Alternatif olarak şöyle de yazabilirsiniz:

total = A
        + B
        + C
Altyapı:

Kısacası, ikili bir operatörden önce ya da sonra satır kırabilirsiniz; yeter ki tutarlı olun. Yeni kod yazıyorsanız, ikili operatörden önce satır kırdığınız son seçeneği izlemeye çalışın.

Boş Satırlar

Python betiklerinde, üst düzey fonksiyon ve sınıflar iki boş satırla ayrılır. Sınıflar içindeki metot tanımları ise bir boş satırla ayrılmalıdır. Bunu aşağıdaki örnekte açıkça görebilirsiniz:

import unittest

class SwapTestSuite(unittest.TestCase):
    """
        Swap Operation Test Case
    """
    def setUp(self):
        self.a = 1
        self.b = 2

    def test_swap_operations(self):
        instance = Swap(self.a,self.b)
        value1, value2 =instance.get_swap_values()
        self.assertEqual(self.a, value2)
        self.assertEqual(self.b, value1)


class OddOrEvenTestSuite(unittest.TestCase):
    """
        This is the Odd or Even Test case Suite
    """
    def setUp(self):
        self.value1 = 1
        self.value2 = 2

    def test_odd_even_operations(self):
        instance1 = OddOrEven(self.value1)
        instance2 = OddOrEven(self.value2)
        message1 = instance1.get_odd_or_even()
        message2 = instance2.get_odd_or_even()
        self.assertEqual(message1, 'Odd')
        self.assertEqual(message2, 'Even')Altyapı:

SwapTestSuite ve OddOrEvenTestSuite sınıfları iki boş satırla ayrılırken, .setUp() ve .test_swap_operations() gibi metot tanımları yalnızca bir boş satırla ayrılmıştır. Kod başarıyla çalışacaktır, ancak birim testi çalıştırmak için gereken kod eksik olduğundan herhangi bir çıktı üretmeyecektir (yalnızca en iyi uygulamaları sergilemektedir).

İfadelerde ve Deyimlerde Boşluklar

Aşağıdaki örneklerde olduğu gibi yazılmış kodunuzda gereksiz boşluklardan kaçınmalısınız:

Bu örnekler PEP-8’den alınmıştır.

Kaynak Dosya Kodlaması

Bir bilgisayar “harfleri”, “sayıları”, “resimleri” ya da başka bir şeyi depolayamaz; Yalnızca bitlerle çalışır ve bitler sadece ikili değerlere sahip olabilir: yes veya no, true veya false, 1 veya 0 vb. Bildiğiniz gibi bilgisayar elektrikle çalışır; Bu, “gerçek” bir bitin bir elektrik darbesinin varlığı ya da yokluğu olduğu anlamına gelir. Bu varlığı (ya da yokluğunu) genellikle 1 ve 0 ile gösterirsiniz.

Bitleri, bitlerin dışında bir şeyi temsil etmek için kullanmak istiyorsanız bir kurallar kümesine ihtiyacınız vardır. Bir bit dizisini, bir kodlama şeması veya kodlama kullanarak harfler, sayılar ve resimler gibi şeylere dönüştürmeniz gerekir. Kodlama şemalarına örnek olarak ASCII, UTF-8 vb. verilebilir:

• Bilgi Değişimi için Amerikan Standart Kodu (ASCII), bilgisayarlardaki ve İnternet’teki metin dosyaları için en yaygın biçimdir. Bu tür dosyalarda her alfabetik, sayısal veya özel karakter 7 bitlik ikili bir sayı (yedi adet 0 veya 1’den oluşan bir dizi) ile temsil edilir.
• Evrensel Karakter Standardı Unicode, kısaca Unicode, “modern dünyanın çeşitli dillerinin yazılı metinlerinin değişimi, işlenmesi ve görüntülenmesi” için bir sistemdir. Kısaca Unicode, dünyanın bilinen tüm yazı sistemlerini kapsayacak şekilde tasarlanmıştır. Unicode, Unicode karakter setlerini temsil etmek için şu üç farklı kodlamayı kullanır: UTF-8, UTF-16 ve UTF-32.
  • UTF-16, değişken uzunluklu bir Unicode kodlamasıdır: kod noktaları bir veya iki 16 bitlik kod birimi ile kodlanır.
  • UTF-8, bir ila dört 8 bitlik bayt kullanan başka bir değişken uzunluklu Unicode kodlamasıdır.
  • UTF-32, her bir Unicode kod noktası için tam olarak 32 bit kullanan sabit uzunluklu bir kodlamadır.

İpucu: Kodlama hakkında daha fazla bilgi istiyorsanız şu yazıya göz atın.

Peki bu neden önemli?

Python’da en sık kullanılan veri tiplerinden birinin dizgiler (string) olduğunu fark etmiş olmalısınız. Beklenebileceği gibi, standart ASCII kümesinin parçası olmayan karakterler içeren ya da tamamen onlardan oluşan dizgilerle çalışmak isteyeceğiniz zamanlar olacaktır. Sonuçta á, ž, ç gibi aksanlı karakterler içeren metinlerle çalışmanız gerekebilir.

Python 3’te varsayılan kaynak kodlaması UTF-8’dir. Ancak Python 2 kullananlarınız, orada varsayılanın ASCII olduğunu muhtemelen biliyordur.

Peki ya "Flügel" gibi ASCII dışı karakter içeren bir dizginiz varsa?

Python 2’de bu dizgiye başvurduğunuzda aşağıdakini görürsünüz:

>>> s 
'Fl\xfcgel'
Altyapı:

Bu, dizginize benzemiyor! Peki yazdırırsanız ne olur?

>>> print(s)
Flügel
Altyapı:

Yazdırma, değişkene atadığınız değeri verdi. ASCII dışı karakter ÃŒ kodlanmıştı. Bu yüzden dizgiye başvurduğunuzda \xfc döndü. Bunu ele almak için .encode() ve .decode() dizi metotlarını kullanabilirsiniz. İlki, Unicode dizginin istenen kodlamada 8 bitlik dizi sürümünü döndürürken, ikincisi dizgiyi verilen kodlamayı kullanarak yorumlar.

İçe Aktarmalar (Imports)

Kütüphane ve/veya modül import etmek, veri bilimi için Python ile çalışırken sıkça yapacağınız bir şeydir. Bildiğiniz üzere, kütüphaneleri her zaman betiğinizin başında import etmelisiniz.

Not: Çok sayıda import yapıyorsanız, her import’u tek bir satırda belirtmeye özen göstermelisiniz.

Bunu biraz daha iyi anlamak için aşağıdaki tabloya göz atın:

Ayrıca, kütüphaneleri import ederken uymanız gereken bir sıra olduğunu da göz önünde bulundurmalısınız. Genel olarak şu sıralamayı izleyebilirsiniz:

1. Standart kütüphane import’ları.
2. İlgili üçüncü taraf import’lar.
3. Yerel uygulama/kütüphane özel import’ları.

Mutlak ve Göreli Import’lar

Sonraki adımda, mutlak ve göreli import arasındaki farkı bilmek iyidir. Genel olarak, mutlak import’lar Python’da tercih edilir; okunabilirliği artırır. Ancak uygulamanız karmaşıklaştıkça göreli import’ları da kullanmaya devam edebilirsiniz. Örtük göreli import’lar asla kullanılmamalı ve Python 3’te kaldırılmıştır.

Peki bu mutlak ve göreli import’lar nedir?

• Mutlak import, . ile ayrılmış fonksiyon ya da sınıfın mutlak yolunu kullanan import’tur. Örneğin,

    import sklearn.linear_model.LogisticRegression
  Altyapı:

• Göreli import, Python dosyanızın bulunduğu mevcut konuma göre yapılan import’tur. Proje yapınız büyüyorsa bu tür import’u kullanabilirsiniz; projeyi daha okunabilir kılar. Yani, aşağıdakine benzer bir Python proje yapınız varsa:

    .
    ├── __init__.py
    ├── __init__.pyc
    ├── __pycache__
    │   ├── __init__.cpython-35.pyc
    │   ├── bubble_sort.cpython-35.pyc
    │   ├── selection_sort.cpython-35.pyc
    ├── bubble_sort.py
    ├── heap_sort.py
    ├── insertion_sort.py
    ├── insertion_sort.pyc
    ├── merge_sort.py
    ├── merge_sort.pyc
    ├── quick_sort.py
    ├── radix_sort.py
    ├── selection_sort.py
    ├── selection_sort.pyc
    ├── shell_sort.py
    ├── tests
    │   ├── test1.py
  Altyapı:

bubble_sort.py içinde saklanan BubbleSort kabarcık sıralama algoritmasını test1 içinde import etmek için göreli import kullanabilirsiniz. Bu şöyle görünür:

from ..bubble_sort import BubbleSort
Altyapı:

Mutlak ve göreli import’lar hakkında daha fazla bilgi istiyorsanız PEP 328’e bakabilirsiniz.

Wildcard Import’lar

Son olarak, wildcard import’lardan kaçınmalısınız; çünkü okunabilirliğe katkı sağlamazlar. Örneğin modülünüzden hangi sınıfları, metotları ya da değişkenleri kullandığınıza dair bir görüş sunmazlar:

from scikit import *Altyapı:

Yorumlar

Yorumlar, Python’da kod içi dokümantasyon için kullanılır. Kodun anlaşılmasına katkı sağlarlar. Kendi modülünüz için yorumlar ve docstring’ler gibi dokümantasyon üretmek üzere kullanabileceğiniz pek çok araç vardır. Yorumlar, birisi kodu okuduğunda kodun doğru anlaşılmasını ve kodun diğer parçalarıyla nasıl kullanıldığını kavramasını sağlayacak kadar açıklayıcı olmalıdır.

Yorumlar # sembolü ile başlar. Kareksten (#) sonra yazılan hiçbir şey yorumlayıcı tarafından çalıştırılmaz. Örneğin, aşağıdaki kod parçası yalnızca "This is a Python comment" çıktısını verir.

# This is a Python single line comment
print("This is a Python comment")
Altyapı:

Unutmayın: Önceki bölümde, yorumlar için satır uzunluğunun 72 karakter olması gerektiğini okumuştunuz!

Bu bağlamda, üç tür yorum vardır:

• Blok yorumları, daha karmaşık veya başkalarına yabancı olan kodu açıklamak için kullanırsınız. Bunlar tipik olarak daha uzun yorumlardır ve kendilerinden sonra gelen kodun bir kısmına ya da tamamına uygulanır. Blok yorumları, kodla aynı düzeyde girintilenir. Bir blok yorumunun her satırı kareksten # ve tek bir boşluktan sonra başlar. Birden fazla paragraf kullanmanız gerekiyorsa, bunlar yalnızca tek bir # içeren bir satırla ayrılmalıdır.

Aşağıdaki alıntıya, scikit-learn kütüphanesinden alınmıştır, bu yorumların nasıl göründüğünü anlamak için bakın:

   if Gram is None or Gram is False:
        Gram = None
        if copy_X:
            # force copy. setting the array to be fortran-ordered
            # speeds up the calculation of the (partial) Gram matrix
            # and allows to easily swap columns
            X = X.copy('F')
Altyapı:

• Satır içi yorumları (inline) ölçülü kullanmalısınız; kodunuzun bazı kısımlarını açıklamanız gerektiğinde etkili olabilirler. Belirli bir kod satırının ne anlama geldiğini hatırlamanıza da yardımcı olabilir veya kodunuzun tüm yönlerine aşina olmayan biriyle işbirliği yaparken işe yarayabilir. Satır içi yorumları, ifadenin kendisini izleyen aynı satıra yazarsınız. Bu yorumlar da # ve tek bir boşlukla başlar.

Örneğin:

counter = 0  # initialize the counter
Altyapı:

• Dokümantasyon dizgilerini veya docstring’leri, herkese açık modüllerin, dosyaların, sınıfların ve metotların başına yazarsınız. Bu tür yorumlar """ ile başlar ve """ ile biter:

    """
        This module is intended to provide functions for scientific computing 
    """Altyapı:

Modül Düzeyi Dunder İsimleri

Docstring’lerin ne olduğunu okuduğunuza göre, Modül Düzeyi dunder’lar hakkında da bilgi sahibi olmalısınız; başında ve sonunda ikişer alt çizgi bulunan adlar, Python’da oldukça etkilidir. Bunlar, Python’un kullanıcı tanımlı fonksiyonlar veya adlarla çakışmaması için tanımladığı özel isimlerdir. Daha fazla bilgi için bu makaleye göz atabilirsiniz.

(__all__, __author__, __version__) gibi bir modül düzeyi dunder, modülün ana docstring’inin bulunduğu yere yerleştirilmeli ve tüm import ifadelerinden önce gelmelidir. from __future__ import’larını, docstring’ler dışında başka hiçbir koddан önce tanımlamalısınız:

"""
    Algos module consists of all the basic algorithms and their implementation
"""

from __future__ import print

__all__ = ['searching', 'sorting']
__version__ = '0.0.1'
__author__ = 'Chitrank Dixit'

import os
import sys
Altyapı:

İpucu: Docstring yazımı için şu kurallara da göz atın.

Adlandırma Kuralları

Python’da program yazarken, değişkenleri, tipleri, fonksiyonları ve kaynak kod ile dokümantasyondaki diğer varlıkları gösteren tanımlayıcılar için hangi karakter dizisinin kullanılacağını belirleyen bir kural kümesi olan adlandırma kurallarından mutlaka yararlanırsınız.

Hangi adlandırma stillerinin bulunduğundan emin değilseniz, şunları göz önünde bulundurun:

• b ya da tek küçük harf;
• B ya da tek büyük harf;
• lowercase
• UPPERCASE
• lower_case_with_underscores
• UPPER_CASE_WITH_UNDERSCORES
• CapitalizedWords, ayrıca CapWords, CamelCase ya da StudlyCaps olarak da bilinir.
• mixedCase
• Capitalized_Words_With_Underscores
• _single_leading_underscore: zayıf “iç kullanım” göstergesi. örneğin, from M import * bir alt çizgiyle başlayan adlara sahip nesneleri import etmez.
• single_trailing_underscore_: Python anahtar sözcükleriyle çakışmalardan kaçınmak için geleneksel olarak kullanılır, örneğin Tkinter.Toplevel(master, class_='ClassName')
• __double_leading_underscore: bir sınıf özniteliği adlandırılırken ad karıştırmayı tetikler (sınıf FooBar içinde __boo, _FooBar__boo olur).
• __double_leading_and_trailing_underscore__: kullanıcı tarafından kontrol edilen ad alanlarında yaşayan “sihirli” nesneler veya öznitelikler. Örneğin, __init__, __import__ veya __file__. Bu tür adları asla icat etmeyin; yalnızca belgelenmiş şekilde kullanın.

Genel Adlandırma Kuralları

Aşağıdaki tablo, tanımlayıcılarınızı nasıl adlandıracağınıza dair bazı genel yönergeleri gösterir:

• Tek değişken adı olarak ‘l’, ‘O’ veya ‘I’ kullanmayın: Bu karakterler bazı yazı tiplerinde sıfıra (0) ve bire (1) benzer.
• Genellikle mümkünse kısa adlar kullanmak iyidir. Bazı durumlarda okunabilirliği artırmak için alt çizgi kullanabilirsiniz.

Genel adlandırma kurallarındaki istisnalar hakkında daha fazla bilgi için bu makaleye bakın.

Kodunuz PEP-8’e Uygun mu?

PEP-8 hakkında daha fazla şey öğrendikten sonra, kodunuzun gerçekten bu yönergelere (ve bu eğitimde ele alınmayan daha fazlasına) uyup uymadığını nasıl kontrol edebileceğinizi merak ediyor olabilirsiniz.

PEP-8’i bizzat inceleyip hakkında daha fazla bilgi edinmenin yanı sıra, bir sonraki bölümlerde açıklanan kullanışlı pep8 modülü, coala paketi ve diğer alternatiflere de mutlaka göz atmalısınız!

Python pep8 Paketi

pep8 paketi, Python kodunuzda PEP-8 uyumsuzluklarını kontrol etmek ve PEP-8 yönergelerine uyması için değişiklikler önermek amacıyla kullanılabilir. pep8 modülünü aşağıdaki komutu çalıştırarak pip ile kurabilirsiniz:

pip install pep8Altyapı:

pep8’in nasıl çalıştığını göstermek için, aşağıdaki kodla example.py adlı yeni bir Python dosyası oluşturun:

def my_function(a, b):
    print("The sum of a and b is: ", a + b)

a = 1
b = 2

my_function(a,b)Altyapı:

Dosyayı kaydedin ve ardından terminalinizde ya da komut isteminde pep8 komutunu şu şekilde çalıştırın:

pep8 example.pyAltyapı:

Bu, pep8’in kodda tespit ettiği PEP-8 uyumsuzluklarını aşağıdaki gibi çıktılayacaktır:

example.py:1:1: E302 expected 2 blank lines, found 0
example.py:3:5: E225 missing whitespace around operator
example.py:5:5: E225 missing whitespace around operatorAltyapı:

İlk satır, 1. satırdaki fonksiyon tanımından önce iki boş satır olması gerektiğini belirtir. Sonraki iki satır ise print ifadesinde ve atama ifadelerinde toplama operatörünün etrafında boşluk olması gerektiğini belirtir.

Bu sorunları düzeltmek için kodu aşağıdaki gibi değiştirebilirsiniz:

def my_function(a, b):
    print("The sum of a and b is:", a + b)

a = 1
b = 2

my_function(a, b)Altyapı:

Şimdi pep8 example.py komutunu tekrar çalıştırdığınızda hiçbir çıktı olmamalıdır; bu da kodun artık PEP-8’e uygun olduğu anlamına gelir.

Uyumsuzluğun bulunduğu kaynak kodu --show-source argümanı ile de görebilirsiniz:

$ pep8 --show-source --show-pep8 testsuite/E40.py
testsuite/E40.py:2:10: E401 multiple imports on one line
import os, sys
         ^
    Imports should usually be on separate lines.

    Okay: import os\nimport sys
    E401: import sys, os
Altyapı:

Ya da --statistics ekleyerek her hatanın kaç kez bulunduğunu görüntüleyebilirsiniz:

$ pep8 --statistics -qq Python-2.5/Lib
232     E201 whitespace after '['
599     E202 whitespace before ')'
631     E203 whitespace before ','
842     E211 whitespace before '('
2531    E221 multiple spaces before operator
4473    E301 expected 1 blank line, found 0
4006    E302 expected 2 blank lines, found 1
165     E303 too many blank lines (4)
325     E401 multiple imports on one line
3615    E501 line too long (82 characters)
612     W601 .has_key() is deprecated, use 'in'
1188    W602 deprecated form of raising exception
Altyapı:

İpucu: flake8, autopep8 veya pylint gibi diğer modüllere de mutlaka göz atın!

Kodunuzu coala ile Analiz Etme

coala tüm diller için linting ve düzeltme sağlar, ancak burada daha çok Python ile ilgileniyorsunuz; coala’yı pip kullanarak kurabilirsiniz:

$ pip3 install coala-bears
Altyapı:

Yukarıdaki kod parçasında, aslında coala-bears’ı kurduğunuzu görüyorsunuz: bears, coala’nın yeteneklerini genişleten ve dilden dile değişen eklentiler veya basit modüllerdir. Bu durumda, PEP-8’e uyumsuz kodu bulup yerinde düzelten pep8bear’ı kullanmak istiyorsunuz. Python kodunuzu kontrol etmek için bunu kesinlikle düşünmelisiniz.

$ coala -S python.bears=PEP8Bear python.files=\*\*/\*.py \
python.default_actions=PEP8Bear:ApplyPatchAction --save
# other output ...
Executing section python...
[INFO][11:03:37] Applied 'ApplyPatchAction' for 'PEP8Bear'.
[INFO][11:03:37] Applied 'ApplyPatchAction' for 'PEP8Bear'.
Altyapı:

pep8online: Python Kodunuzu Çevrimiçi Kontrol Edin

Kullanışlı pep8 modülü ve coala paketinin yanı sıra, Python kodunuzun PEP-8’e uygun olup olmadığını pep8online adresine giderek de kontrol edebilirsiniz. Bu sitede kodunuzu yapıştırıp “Check code” düğmesine basmanıza olanak tanıyan bir çevrimiçi editör vardır! Sonuç olarak, geliştirmeniz gereken noktalar hakkında geri bildirim alırsınız. Güzel ve kullanışlı!

Sonuç

Python kullanırken, bazen özellikleri daha hızlı yayınlama telaşıyla kod kalitesini önemsemeyebilirsiniz. Ancak bu eğitimde anlatılan uygulamalar —ve burada ele alınmayan daha birçoğu— geliştirme–hazırlık–test–dağıtım döngünüzün bir parçası olmalıdır. Bu, projede çalışan herkesin kodu anlamasına fayda sağlar ve çoğu zaman, hata ayıklayıcıları başlatmadan, derinlere inmeden değişiklik yapma olanağı verir. Bir açık kaynak projede çalışıyorsanız, katkıda bulunanlarınız PEP-8’i büyük nimet bulacak ve kodunuzu daha iyi anlayacaktır; çünkü bu evrensel standarttır, her Python geliştiricisi buna uyar.

Bu eğitimi tamamladığınıza göre, PEP-8’i bizzat incelemeniz harika bir fikir! Keşfedilecek çok şey var.

PEP-8’e uyum sağlamak için başka ipuçlarınız varsa ya da bu yazıda önemli bir şeyi atladığımızı düşünüyorsanız, bize @DataCamp üzerinden bildirmekten çekinmeyin.