Как да разработим качествен Python код

Работни потоци и инструменти за развитие

От Бенджамин Бенфорт

Разработването в Python е много различно от развитието на други езици. Python е интерпретиран език като Ruby или Perl, така че разработчиците могат да използват контурите за четене-оценка-печат (REPLs), за да изпълняват Python в реално време. Тази функция на Python означава, че може да се използва за бързо развитие и прототипиране, тъй като няма процес на изграждане. Python включва много функционални инструменти за програмиране, подобни на Scala или Javascript, за да подпомогнат разработването на скриптове, базирани на затваряне. Но Python също е напълно мащабируем обектно-ориентиран език, парадигма, използвана за изграждане на голям модулен софтуер, а не просто за изпълнение на скриптове, по-близки до Java или C ++.

Python седи в средата на тези парадигми, предоставяйки най-доброто от много светове. Python се използва за писане на бързи еднократни скриптове, широкомащабни уеб рамки като Django, обработка на данни с Celery, дори числени и научни изчисления. Python е лек, стандартен за много операционни системи и е ефективен, като по този начин го прави най-добрият избор за учени и анализатори на данни за проектиране на данни и аналитични задачи.

Въпреки това широчината на Python означава, че няма нито един работен процес, който да се развива с него и със сигурност няма стандартна IDE или среда за околната среда, която да взема тези решения от ваше име. Повечето учебни материали на Python се фокусират върху сценариите на езика, оставяйки важни подробности как да се конструират по-големи проекти. Тази публикация ще се съсредоточи върху въпроса как един програмист взаимодейства с Python за изграждане на по-големи приложения за данни.

Среда за развитие

И така, какво ви е необходимо, за да разработите успешно приложения за данни с Python? Просто всичко, от което се нуждаете, е:

  1. Текстовият редактор - Sublime, Notepad ++, Vim, Emacs и Text Wrangler работят.
  2. Терминал с питон изпълним във вашия път.

Това е! Има много среди за разработка за използване на Python, които добавят допълнителни инструменти към работния ви процес, включително отстраняване на грешки, попълване на код и подчертаване на синтаксис. Когато обаче се стигне до това, тези софтуерни програми просто обвиват основния текстов редактор и терминал заедно с някои добавени функции. Ако трябва да използвате IDE, бих предложил следното:

  1. IDLE - тази среда ще бъде позната на потребителите на Windows, които вероятно изпълниха първите си Python команди в нея. Много е просто, но е по подразбиране и ефективно.
  2. Komodo Edit - този безплатен IDE за Python е написан от ActiveState и предоставя много инструменти и функционалност.
  3. PyCharm - този IDE не е безплатен, но осигурява подобно на IntelliJ изживяване.
  4. Aptana Studio - Aptana има вградена поддръжка на Python и се фокусира върху мрежата.
  5. Spyder - студио на Python, специално за научно изчисление.
  6. iPython - интерактивна среда за разработка, която ви позволява да създавате тетрадки за представяне на Python код и данни.

Въпреки това, дори когато използвате един от тези инструменти, все пак ще използвате основния работен процес, описан по-долу. Много професионални разработчици на Python се задоволяват с Sublime Text 3 за неговите фино мощни функции и подчертаване на синтаксиса, съчетани с pdb и командния ред. Това правя аз и ще ви даде възможност наистина да се развивате!

Тъй като вашите проекти стават все по-големи, вие също ще искате да включите следните инструменти в работната си система:

  1. Git / Github.com - хранилище с кодове, но с Github, също проследяващ проблем и уики.
  2. pip - мениджърът на пакети python за инсталиране на инструменти на трети страни.
  3. virtualenv и virtualenvwrapper - управлявайте виртуални среди за развитие.

Има много инструменти за подпомагане на разработването на софтуер, но тези три инструмента са жизненоважна част от съвременната разработка на Python и ще бъдат разгледани по-нататък в останалата част от този пост.

Библиотеки на трети страни

Докато разработвате Python код, неизбежно ще започнете да включвате пакети на трети страни, особено ако правите наука за данни и се нуждаете от инструменти като Numpy, Pandas и други. Изграждането на тези библиотеки на трети страни и инсталирането им във вашата система обикновено се извършва с pip - мениджъра на пакети python. Уверете се, че имате инсталиран pip на вашата система, това ще ви спести много време и усилия!

За да инсталирате библиотеката request.py Python, проста HTTP библиотека, която ви позволява много лесно да извличате неща от мрежата, просто ще изпълните следната команда:

$ pip заявки за инсталиране

Деинсталирането и управлението на пакети, включително надстройката, също са включени в pipcommand. Използвайки pip freeze, можете също да получите списък на пакетите Python на трети страни, които сте инсталирали във вашата система. За да търсите различни библиотеки, които да използвате във вашия код, вижте Python Package Index (PyPI).

Виртуални среди

Когато започнете да разработвате повече код, ще започнете да откривате, че специфични версии на инструменти или инструменти, които са трудни за изграждане и поддръжка, са необходими за конкретни проекти и че те противоречат на версии на софтуер в други проекти. Дори Python може да бъде проблем, ако разработите както за Python 2, така и за 3, в зависимост от средата на разполагане! Още по-притеснително е, че Python също е решаващ аспект на много операционни системи, съществува (малката) възможност, че можете да стигнете до счупване на системата Python по време на разработката!

Решението на тези проблеми е да използвате virtualenv за пакетиране на цялостна среда за разработка с вашия код. Virtualenv ви позволява да създадете директория, която съдържа специфична за проекта версия на Python, pip и всички зависимости на трети страни. Virtualenv може да се активира и деактивира в командния ред, което ви позволява да създадете самостоятелна среда. Освен това може да се използва за създаване на среди, които съответстват на вашата производствена среда (обикновено Linux сървър).

Virtualenvwrapper е друга библиотека, която ви позволява да управлявате множество виртуални среди и да ги свързвате с конкретни проекти. Този инструмент също бързо ще стане от съществено значение за вашия работен процес. За да инсталирате virtualenv и virtualenvwrapper, използвайте следния код:

$ pip инсталирате virtualenv virtualenvwrapper

След това редактирайте .profile в домашната си директория и добавете следното към края:

експортиране WORKON_HOME = $ HOME / .virtualenvs
експортиране PROJECT_HOME = $ HOME / Проекти
източник /usr/local/bin/virtualenvwrapper.sh

Всички ваши виртуални среди ще се съхраняват в скрита директория, наречена virtualenvs, а вашата директория за проекти е там, където ще съхранявате кода си. Ще обсъдим това повече в следващия раздел. Аз също псевдоним много от скриптове virtualenv, за да се улесни работата, можете да видите моите разширения в VirtualEnv Cheat Sheet на Ben.

Забележка: Може да се наложи на потребителите на Windows да следват специфични за ОС инструкции, които бих се радвал да актуализирам и да включа в тази публикация.

Код на работния процес в строителството

Създаването и изпълнението на Python код следва два различни модела на работния процес.

  1. Създайте код в текстов файл и го изпълнете с Python
  2. Създайте код в текстов файл и го импортирайте в Python REPL.

Най-общо, разработчиците правят и двете. Програмите Python са предназначени да се изпълняват в командния ред през битовия файл python, а това, което се изпълнява, обикновено е входна точка за много по-голяма библиотека от код, която се импортира. Разликата между импортирането и изпълнението е незначителна, но когато правите повече Python, тя става по-важна.

С всеки от тези работни процеси вие създавате кода си възможно най-модулно и по време на процеса на създаване го изпълнявате по един от описаните по-горе методи, за да проверите дали работи. Повечето разработчици на Python се връщат напред-назад между терминала и редактора и могат да правят изчерпателно тестване на всеки един ред код, докато го пишат. Това е аспектът на бързото прототипиране на Python.

Нека започнем с един прост пример.

  1. Отворете прозорец на терминал (вижте вашата конкретна операционна система за инструкции как да направите това).
  2. ЗАБЕЛЕЖКА: Командите са в bash (Linux / Mac) или Windows Powershell
  3. Създайте работно пространство за себе си. Работното пространство в този смисъл е просто празна директория, в която можете да се приготвите да започнете да работите по разработка. Вероятно трябва също така да съхранявате различните си проекти (тук, синоним на работно пространство) в тяхната собствена директория, тъй като сега просто ще го наречем „Проекти“ и ще приемем, че е в домашната ви директория. Първият ни проект ще бъде наречен „myproject“, но просто трябва да назовете това, каквото искате.
$ cd ~ / Проекти
$ mkdir myproject
$ cd myproject

Нека създадем първия си скрипт Python Можете или да отворите любимия си редактор и да запазите файла в работното си пространство (директорията ~ / Projects / myproject), или можете да го докоснете и след това да отворите този файл с вашия редактор.

$ touch foo.py

PRO СЪВЕТ: Ако използвате Sublime Text 3 и инсталирате инструмента за команден ред subl (Вижте инструкциите за инсталиране на Sublime Text), можете да използвате следната команда, за да отворите текущата директория в редактора:

$ subl. &

Използвам това толкова много, че оставих командата на e.

Така че ето къде трябва да бъдете: Трябва да имате отворен текстов редактор и да редактирате файла на ~ / Projects / myproject / foo.py, и трябва да имате отворен терминален прозорец, чиято текуща работна директория е ~ / Проекти / myproject. Вече сте готови да се развивате. Добавете следния код към foo.py:

#! / usr / bin / env python
import csv

дефиниране на данни (път):
    с отворен (път, 'rU') като данни:
        читател = csv.reader (данни)
        за ред в четеца:
            ред [2] = int (ред [2])
            доходност ред

Този код е много прост. Той просто изпълнява функция, която приема път и връща итератор, така че да имате достъп до всеки ред от CSV файл, като същевременно преобразувате третия елемент от всеки ред в цяло число.

ПРО СЪВЕТ: #! (произнася се "shebang") редът трябва да се появи в самото начало на изпълним скрипт Python, без нищо преди това. Той ще каже на вашия компютър, че това е Python файл и ще изпълни скрипта правилно, ако стартира от командния ред като самостоятелно приложение. Този ред не е необходимо да се показва в библиотечни модули, тоест код Python, който планирате да импортирате, а не да изпълните.

Създайте някои данни, за да можем да използваме функцията си. Нека да запазим всички наши данни в директория на тела в нашия проект.

$ mkdir тела
$ touch приспособления / калории.csv

Използвайте своя редактор, добавете тези данни към файла калории.csv:

масло, супена лъжица, 102
сирене чедър, филийка, 113
пълномаслено мляко, чаша, 148
хамбургер, т, 254

Добре, сега е време да използваме нашия код. Първо, нека се опитаме да изпълним кода в интерпретатора. Отворете REPL, както следва:

$ python
>>>

Сега трябва да бъдете представени с подкана Python (>>>). Всичко, което въвеждате сега, трябва да е в Python, а не bash. Винаги отбелязвайте подканите в инструкциите. Подкана с $ означава въведете в инструкции за команден ред (bash), подкана, която казва >>> означава тип в Python на REPL, и ако няма подкана, вероятно редактирате файл. Импортирайте кода си:

>>> от набора данни за импортиране на Foo
>>> за ред в набора от данни („приспособления / калории.csv“):
... печат ред [0]
масло
сирене чедър
пълномаслено мляко
хамбургер
>>>

Тук се случи много, така че нека да го проверим. Първо, когато импортирахте функцията за набор от данни от foo, Python потърси текущата ви работна директория и намери файла foo.py и оттам го импортира. Къде се намирате в командния ред и какъв е вашият Python път!

Когато импортирате функцията за набор от данни по начина, по който го направихме, модулът се зарежда и изпълнява наведнъж и се предоставя в пространството от имена на интерпретатора. Вече можете да го използвате, като напишете цикъл за преминаване през всеки ред и отпечатване на първия елемент. Обърнете внимание на ... подкана. Това означава, че Python очаква разрезен блок. За да излезете от блока, натиснете Enter два пъти. Резултатите за печат се появяват точно на екрана и след това ще се върнете към подкана.

Но какво ще стане, ако направите промяна в кода, например, изписване с главна буква на първата буква от думите в първия елемент на всеки ред? Промените, които напишете във вашия файл, няма да се покажат в REPL. Това е така, защото Python вече е заредил кода веднъж. За да получите промените, трябва или да излезете от REPL и да рестартирате, или трябва да импортирате по различен начин:

>>> импортиране на Foo
>>> за ред във foo.dataset ('приспособления / калории.csv'):
...

Сега можете да презаредите модула foo и да получите промените в кода:

>>> презареди (foo)

Това може да стане доста грозно, тъй като кодът става все по-голям и се случват повече промени, така че нека да прехвърлим стратегията си за развитие към изпълнение на Python файлове. Вътре в foo.py добавете следното в края на файла:

ако __name__ == '__main__':
    за ред в набора от данни („приспособления / калории.csv“):
        печат ред [0]

За да изпълните този код, просто въведете следното в командния ред:

$ python foo.py
масло
сирене чедър
пълномаслено мляко
хамбургер

Изразът if __name__ == '__main__': означава, че кодът ще се изпълни само ако кодът се изпълнява директно, а не е импортиран. В действителност, ако отворите REPL и въведете foo import, нищо няма да бъде отпечатано на вашия екран. Това е невероятно полезно. Това означава, че можете да поставите тестов код във вашия скрипт, докато го разработвате, без да се притеснявате, че той ще пречи на вашия проект. Не само това, той документира на други разработчици как трябва да се използва кодът в този файл и предоставя прост тест, за да се уверите, че не създавате грешки.

В по-големите проекти ще видите, че повечето разработчици поставят код за тестване и отстраняване на грешки под така наречените операции „ifmain“ в долната част на своите файлове. И вие трябва да направите това!

С този пример, надяваме се, че сте научили работния процес за разработване на Python програми както чрез изпълнение на скриптове и използване на „ifmain“, така и чрез импортиране и презареждане на скриптове в REPL. Повечето разработчици използват и двата метода взаимозаменяемо, използвайки всичко, което е необходимо по това време.

Структуриране на по-големи проекти

Добре, така че как да напишете действителна Python програма и да преминете от експериментиране с кратки фрагменти от код към по-големи програми? Първото нещо, което трябва да направите, е да организирате кода си в проект. За съжаление наистина няма нищо, което да направи това автоматично за вас, но повечето разработчици следват добре познат модел, който беше представен от Зед Шоу в книгата си Learn Python the Hard Way.

За да създадете нов проект, ще внедрите скелета на проект Python - набор от директории и файлове, които принадлежат във всеки един създаден от вас проект. Скелетът на проекта е много познат на разработчиците на Python и бързо ще започнете да го разпознавате, докато проучвате кода на други разработчици на Python (което трябва да правите). Основният скелет е реализиран в директорията на проекти, които се съхраняват в работното ви пространство, както е описано по-горе. Структурата на директория е следната (за примерен проект, наречен myproject):

$ myproject
,
├── README.md
├── LICENSE.txt
├── изисквания.txt
├── setup.py
├── кошче
| └── myapp.py
├── док
| ├── _ изграждане
| ├── conf.py
| ├── index.rst
| └── Makefile
├── тела
├── foo
| └── __init__.py
└── тестове
    └── __init__.py

Това е много, но не се страхувайте Тази структура реализира много инструменти, включително опаковки за дистрибуция, документация със Sphinx, тестване и др.

Да преминем през парчетата едно по едно. Проектната документация е първата част, реализирана като README.md и LICENSE.txt файлове. Файлът README е документ за маркиране, който можете да добавите специфична за разработчици документация към вашия проект. ЛИЦЕНЗИЯТ може да бъде всеки лиценз с отворен код или декларация за авторско право в случай на собствен код. И двата файла обикновено се генерират за вас, ако създадете проекта си в Github. Ако създадете файла си в Github, трябва да използвате и Python .gitignore, който Github предоставя, което ви помага да поддържате вашите хранилища чисти.

Скриптът setup.py е скрипт за инсталиране на Python за настройка или distutils и ще ви позволи да конфигурирате вашия проект за внедряване. Той ще използва изисквания.txt, за да посочи зависимостите на трети страни, необходими за изпълнение на вашия проект. Други разработчици също ще използват тези файлове, за да създадат своите среди за разработка.

Директорията на документите съдържа генератора на документация за Sphinx, документацията на Python е написана в restructuredText, език за маркиране, подобен на Markdown и други. Тази документация трябва да бъде по-обширна и да бъде както за потребители, така и за разработчици. Директорията на бин ще съдържа всички изпълними скриптове, които възнамерявате да изградите. Учените за данни също обикновено имат директория с приспособления, в която да съхраняват файлове с данни.

Директориите Foo и тестове всъщност са модули на Python, тъй като съдържат файла __init__.py. Ще поставите кода си в foo и вашите тестове в тестове. След като започнете да се развивате във вашата директория foo, обърнете внимание, че когато отворите REPL, трябва да импортирате всичко от пространството от имена „foo“. Можете да поставите декларации за импортиране във вашите файлове __init__.py, за да улесните и импортирането. Все още можете да изпълните вашите скриптове в директорията foo, използвайки метода „ifmain“.

Настройване на първия ви проект

Не е необходимо да създавате ръчно структурата по-горе, много инструменти ще ви помогнат да изградите тази среда. Например проектът Cookiecutter ще ви помогне да управлявате шаблоните на проекти и бързо да ги изградите. Командата spinx-quickstart ще генерира вашата директория с документация. Github ще добави стъблата README.md и LICENSE.txt. Накрая, pip замразяването ще генерира файла файл.txt.

Стартирането на проект Python обаче е ритуал, така че ще ви преведа през моя процес за стартиране на такъв. Запалете свещ, запретнете ръкави и вземете кафе. Време е.

Вътре в директорията на Проектите създайте директория за работното си пространство (проект). Нека се преструваме, че създаваме проект, който ще генерира социална мрежа от имейли, ще го наречем „имейл“.

$ mkdir ~ / Проекти / имейлграф
$ cd ~ / Проекти / имейлграф

Инициализирайте хранилището си с Git.

$ git init

Инициализирайте своя virtualenv с обвивка virtualenv.

$ mkvirtualenv -a $ (pwd) имейлграф

Това ще създаде виртуалната среда в ~ / .virtualenvs / emailgraph и автоматично ще я активира за вас. По всяко време и на всяко място в командния ред можете да издадете командата на workon имейлграф и ще бъдете отведени в директорията на вашия проект (флагът -a указва, че това е директорията на проекта за този virtualenv).

Създайте различни директории, от които ще се нуждаете:

(имейлграф) $ mkdir кош за тестване на тел

И след това създайте различните файлове, които са необходими:

(имейл) $ touch тестове / __ init__.py
(имейл) $ touch emailgraph / __ init__.py
(имейл) $ touch setup.py README.md LICENSE.txt .gitignore
(имейл) $ touch bin / emailgraph-admin.py

Генериране на документацията с помощта на сфинкс-бърз старт:

(имейл) $ sphinx-quickstart

Можете безопасно да използвате настройките по подразбиране, но се уверете, че в края на краищата приемате Makefile за бързо и лесно генериране на документацията. Това трябва да създаде файл index.rst и conf.py във вашата директория с документи.

Инсталирайте носа и покритието, за да започнете пробната си сбруя:

(имейл) $ pip инсталация покритие на носа

Отворете теста / __ init__.py файла с любимия си редактор и добавете следните тестове за инициализация:

импортиране unittest

клас InitializationTests (unittest.TestCase):

    def test_initialization (самостоятелно):
        "" "
        Проверете тиражите на тестовия пакет, като потвърдите 2 + 2 = 4
        "" "
        self.assertEqual (2 + 2, 4)

    def test_import (самостоятелно):
        "" "
        Уверете се, че тестовият пакет може да импортира нашия модул
        "" "
        опитвам:
            импортиране на имейлграф
        с изключение на ImportError:
            self.fail („Не можах да импортирам имейла“)

От директорията на вашия проект вече можете да стартирате тестовия пакет със покритие, както следва:

(имейлграф) $ nostests -v - с покритие - покритие-пакет = имейл \
              - тестово покритие - тестове за покриване и изтриване

Трябва да видите два теста, преминаващи заедно със 100% доклад за тестово покритие.

Отворете файла setup.py и добавете следните редове:

#! / usr / bin / env python
повишаване NotImplementedError ("Настройката все още не е внедрена.")

Настройването на приложението ви за внедряване е тема на друга публикация, но това ще предупреди другите разработчици за факта, че още не сте се запознали с него.

Създайте файла файл.txt, използвайки pip freeze:

(имейлграф) $ pip freeze> изисквания.txt

И накрая, ангажирайте цялата работа, която сте свършили, за да изпратите имейл графика в хранилището.

(имейл) $ git add - всички
(имейлграф) $ git статус
На майстор на клона

Първоначален ангажимент

Промени, които трябва да бъдат извършени:
  (използвайте "git rm --cached  ..." до неустойчивост)

    нов файл: LICENSE.txt
    нов файл: README.md
    нов файл: bin / emailgraph-admin.py
    нов файл: документи / Makefile
    нов файл: docs / conf.py
    нов файл: docs / index.rst
    нов файл: имейл / __ init__.py
    нов файл: изисквания.txt
    нов файл: setup.py
    нов файл: тестове / __ init__.py

(имейл) $ git commit -m "Първоначална настройка на хранилището"

С това трябва да имате готовност за вашия проект и готов за стартиране. Вземете още кафе, време е да започнете работа!

заключение

С тази публикация, надяваме се, че сте открили някои най-добри практики и работни процеси за разработка на Python. Структурирането на вашия код и проекти по този начин ще ви помогне да се организирате и също така ще помогне на другите бързо да разберат какво сте изградили, което е изключително важно при работа върху проекти, включващи повече от един човек. По-важното е, че тази структура на проекта е подготовката за внедряване и базата за по-големи приложения и професионален софтуер за производствен клас. Независимо дали използвате сценарии или пишете приложения, надявам се, че тези работни процеси ще бъдат полезни.

Ако искате да проучите по-нататък как да включите инструменти за професионални оценки в разработката си на Python, разгледайте някои от следните инструменти:

  • Travis-CI е непрекъсната интеграционна услуга, която автоматично ще стартира тестовата ви система, когато се ангажирате с Github. Той ще се увери, че всичките ви тестове са преминали, преди да се насочите към производство!
  • Waffle.io ще превърне вашите проблеми с Github в пълен съвет Agile, който ви позволява да проследявате етапи и спринтове и по-добре да координирате своя екип.
  • Pylint автоматично ще провери за добри стандарти за кодиране, откриване на грешки и дори ще изготви UML диаграми за вашия код!

Допълнително четене

  • Научете Python по трудния път
  • Учене Python, 5-то издание
  • Програмиране на Python
  • Практическа готварска книга за научни данни

District Data Labs предоставя консултации за научни данни и корпоративни обучителни услуги. Работим с компании и екипи от всякакви размери, помагайки им да направят дейността си по-задвижвана от данни и засилвайки аналитичните способности на своите служители. Интересувате се да работите с нас? Уведоми ни!