Съдържание на курса

Урок 1 — Инсталиране на Python на твоя Linux Mint

От Dorian Chávez · основател на Hábil и архитект на интеграции ·

Време: 90 минути

Какво изграждаш: виртуалната среда на курса, първия си скрипт (hola.py) и файла, в който ще живее revisor

Какво научаваш: python3 на системата и защо не инсталира пакети (No module named pip и предупреждението externally-managed-environment); да създаваш, активираш и деактивираш виртуална среда (venv); pip вътре в средата; REPL и изпълнение на файл; да четеш първия traceback

Откъде идваш. От Урок 0, който беше за четене: вече знаеш, че Python чете твоя файл, превежда го до bytecode и го изпълнява; че типовете се проверяват при изпълнение, а не преди; че GIL няма да ти пречи; и че съществува нещо, наречено виртуална среда, което пази Python на твоята система. Днес спираш да четеш и минаваш към терминала. Работиш на компютър с Linux Mint 22.x (коя да е от версиите му, от 22 до 22.3, които споделят една и съща основа) и с отворен терминал. Почти нищо от това, което ще правиш, не изисква администраторски права: най-много един ред (с две администраторски команди вътре), и то само ако твоят Mint не носи частта, която създава виртуални среди (ще го видиш в 1.2.2). Нещо повече, едно от нещата, които днес ще научиш, е да не инсталираш пакети на Python с такива права.

Какво не прави този урок. Още не учи езика: print, който ще използваш, се обяснява с един ред, а Урок 2 го изучава подробно. Нито инсталира uv или pipx, други инструменти, които ще видиш по-нататък: днес се използва това, което системата вече носи, защото разбирането на средата с основните части е онова, което после ти позволява да разбереш защо останалите инструменти съществуват.

След урока ще можеш да

  • Провериш кой Python носи твоят Mint (python3 --version) и откъде работи (which python3).
  • Опиташ нарочно да инсталираш пакет в Python на системата, да прочетеш отговора и да обясниш защо Mint защитава своя Python, как изглежда предупреждението externally-managed-environment в системите, които носят pip, и кой е правилният изход.
  • Създадеш виртуалната среда на курса с python3 -m venv, да я активираш, да провериш с which python, че си вътре, да инсталираш пакет с pip и да я деактивираш.
  • Напишеш израз в REPL, да излезеш от него и да различаваш кога е удобен REPL и кога файл.
  • Създадеш и изпълниш hola.py и revisor/revisor.py, вътре и вън от средата, и да отбележиш кой python е използван във всеки случай.
  • Прочетеш traceback от NameError от последния ред нагоре и да кажеш коя неправилно написана дума го е причинила.

Защо, преди как

За да направиш първата стъпка с revisor, е нужна здрава основа: Python, който работи, място, където да се пазят пакетите, от които курсът ще има нужда, и папка, в която ще живее проектът. Ако тази основа се импровизира, проблемите се появяват по-късно и във възможно най-объркващия вид: пакет, който „се инсталира“, но не се намира, версия на Python, която не е тази, която си мислел, команда, която вчера работеше, а днес не. Този урок съществува, за да не ти се случи това.

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

Има още една причина да го направиш добре сега: спънката, която ще видиш днес, е същата, която ще имаш в истинска работа. Почти всеки, който инсталира Python в съвременен Linux, рано или късно се натъква на системен Python, който отказва да инсталира пакети: в твоя Mint, защото дори не носи pip; в други системи, със съобщение, което казва externally-managed-environment. Много хора го четат като пречка, търсят в интернет как да я заобиколят и накрая използват опция, която чупи защитата на системата. Този курс прави обратното: предизвиква отказа нарочно, чете го ред по ред и показва, че е помощ, а не стена. Който го разбере веднъж, го решава за десет секунди до края на живота си.

Минимумът от терминала, който ти трябва днес

Терминалът е прозорец, в който пишеш команди, вместо да щракаш. В Mint се отваря с прекия път Ctrl + Alt + T или като потърсиш „Terminal“ в менюто. В този курс редовете, които започват с $, са онова, което пишеш ти, а останалите са онова, което компютърът отговаря. Самото $ не се пише: това е символът, който терминалът ти показва, за да покаже, че чака команда. Командите за днес са малко:

  • pwd (print working directory): показва в коя папка си.
  • ls: изброява какво има в текущата папка.
  • cd carpeta: те премества в тази папка. cd .. се качва едно ниво нагоре, а cd без нищо те връща в личната ти папка.
  • mkdir carpeta: създава папка.
  • which nombre: показва кой файл би се изпълнил, ако напишеш това име. Това е инструментът, който отговаря на „кой Python използвам?“.
  • ~: е пряк път към личната ти папка, тази, която съдържа документите ти. ~/curso-python значи „папката curso-python вътре в личната ти папка“.

Ако някоя от тях ти е нова, изпробвай я сега в терминала си, преди да продължиш: напиши pwd, натисни Enter и сравни с това, което казва. Нищо не чупи.

Понятията

Те са четири: Python на системата и грешката, която го защитава; виртуалната среда с pip; REPL и файловете; и първият traceback. Всяко завършва с нещо, което можеш да провериш на екрана си.

1.1 python3 на системата и грешката externally-managed-environment

1.1.1 Какъв Python имаш

Отвори терминал и напиши:

$ python3 --version
Python 3.12.3

Изходът, който ще видиш, е от вида Python 3.12.x: последното число (поправката) зависи от обновленията, които твоят Mint е получил. Важното е 3.12. Това е версията, с която работи курсът, и както видя в предишния урок, целият код работи и на 3.14. Ако терминалът ти казва нещо друго (3.10 или 3.11), курсът почти сигурно ще работи същото, но 3.10 стигна края на живота си на 1 октомври 2026; отбележи го в дневника и продължи.

Сега попитай откъде идва този Python:

$ which python3
/usr/bin/python3

/usr/bin/ е папката, където системата пази собствените си програми. Това, че твоят python3 е там, значи, че е на Mint: инсталирала го е дистрибуцията, обновява го мениджърът на пакети (apt) и от него зависят няколко системни инструмента. Това е „домашният килер“ от предишния урок.

Ако си в друга система (macOS или Linux с Python, инсталиран по друг начин), which ще покаже друг път. Нищо не става, но грешката от следващия дял може да е различна или да не се появи, а този курс е писан за Mint.

1.1.2 Да опиташ да инсталираш нещо и системата да каже не

pip е инструментът на Python за инсталиране на пакети: библиотеки с код, които други хора са написали и публикували в публичен каталог, наречен PyPI, за да не се налага да ги пишеш ти. По-нататък курсът ще има нужда от пакет, наречен httpx, който служи за заявки към услуги по мрежата. Ще опитаме да го инсталираме нарочно, по грешния начин: с Python на системата, извън всяка среда. На прясно инсталиран Linux Mint 22 ето какво става:

$ python3 -m pip install httpx
/usr/bin/python3: No module named pip

Командата се чете: „изпълни модула pip с Python (-m значи модул) и му поискай да инсталира httpx“. Пише се python3 -m pip, а не просто pip, по причина, която обяснява документацията на pip: така си сигурен, че pip, който се изпълнява, е този на този Python, а не друг, който има в системата ти.

Отговорът се чете като всеки доклад за грешка, от края: No module named pip, „няма модул, наречен pip“. Преди двоеточието идва кой говори: /usr/bin/python3, Python на системата. Не е твоя грешка, нито на курса. В семейството Debian и Ubuntu, от което идва Mint, pip е отделен пакет на системата (python3-pip) и прясно инсталиран Mint не го носи. Този Python се управлява от мениджъра на пакети на системата, не от теб. Практическият резултат е този, който има значение: извън среда не се инсталира нищо. Вътре във виртуалната среда, която ще създадеш след малко, pip идва включен.

1.1.3 Предупреждението, което ще видиш, ако един ден инсталираш pip на системата

Има втора защита, по-изрична, и е добре да я разпознаваш, защото е тази, която ще срещнеш в почти всеки съвременен Linux, където pip има в системата (например ако един ден инсталираш пакета python3-pip на Mint или в друга дистрибуция). Не я предизвиквай: не е нужно да инсталираш нищо, за да я разбереш. Там същата команда не казва No module named pip, а съобщение, което започва така:

error: externally-managed-environment

Това казва спецификацията, която го причинява, PEP 668: инструментите на Python „не бива да инсталират, нито да премахват пакети в глобалния контекст на интерпретатора, по подразбиране“, когато този интерпретатор се управлява от друг мениджър на пакети. Механизмът е прост: дистрибуцията оставя файл, наречен EXTERNALLY-MANAGED, в папката на стандартната библиотека на своя Python, и pip го търси, преди да инсталира. Ако го намери, спира. Тази папка може да се попита от Python:

$ python3 -c "import sysconfig; print(sysconfig.get_path('stdlib'))"

Отпечатва пътя на стандартната библиотека на твоя Python, папка, чието име завършва на python3.12; спецификацията казва, че там отива файлът-маркер.

Тази команда е рецепта за копиране както е; не е нужно да я разбереш изцяло днес, но да знаеш какво прави всяко парче. -c значи „изпълни този текст като програма“: това е бърз начин да зададеш отделен въпрос на Python, без да създаваш файл. Текстът между кавичките са две инструкции, разделени с точка и запетая ;, която в Python позволява две инструкции в един и същи ред (във файловете на курса не се използва: всяка инструкция е на свой ред). Първата, import sysconfig, внася един модул, набор от инструменти, който идва с Python и не е достъпен, докато не го поискаш; Урок 3 обяснява import подробно. Втората, print(sysconfig.get_path('stdlib')), иска от този модул пътя (path) на стандартната библиотека (stdlib) и го показва с print.

Пълното съобщение освен това ти казва какво да правиш и затова е урок, а не стена. Спецификацията позволява дистрибуцията да сложи собствен текст за помощ във файла-маркер, така че тялото се променя от система на система; обичайното е да предложи три изхода: да инсталираш пакета с мениджъра на системата, ако има опакована версия, да създадеш виртуална среда, ако няма, или да използваш pipx, ако това, което искаш да инсталираш, е приложение, а не библиотека. За това, което прави курсът, изходът е вторият: виртуална среда. В раздела „Грешката, която ще видиш“ имаш пълен пример, прочетен по части.

Има и четвърти изход, и pip сам ти го казва в бележката, с която затваря съобщението: опция, наречена --break-system-packages, която изключва защитата и позволява да инсталираш все пак. Спецификацията признава, че трябва да съществува, и тя съществува. Този курс не я преподава, нито я използва. Тя е равностойна на това да махнеш ключалката, защото не си намерил ключа: работи, докато някой пакет, който си инсталирал, не презапише библиотека, от която системата се нуждаеше, и тогава се чупят инструменти, които нямат нищо общо с твоя проект. Ключът съществува и се казва виртуална среда.

1.2 Виртуалната среда: създаване, активиране, pip, деактивиране

1.2.1 Създаване на средата

Първо папката на курса. Всичко, което правиш, ще живее вътре в ~/curso-python/:

$ mkdir ~/curso-python
$ cd ~/curso-python
$ python3 -m venv .venv

Третият ред е този, който създава средата. Чете се: „изпълни модула venv с python3 и създай среда в папка, наречена .venv“. Точката в началото на името прави папката „скрита“ по конвенция: не се появява в обикновен ls. Това е обичайното име на средите и някои инструменти го разпознават сами. Когато всичко мине добре, не отпечатва нищо; в терминала мълчанието е успех.

Средата живее в ~/curso-python/.venv, не вътре в папката на проекта revisor/, която ще създадеш по-долу. Има причина: документацията на модула venv казва, че една среда се счита за „за еднократна употреба“ (трябва да е лесно да се изтрие и да се създаде отново от нулата) и че „кодът на проекта не се поставя вътре в средата“. Да я държиш отделно от кода е най-чистият начин да се спази това.

1.2.2 Ако твоят Mint не носи частта за средите

В прясно инсталиран Mint 22 най-вероятно третият ред няма да излезе мълчаливо, а с това съобщение:

$ python3 -m venv .venv
The virtual environment was not created successfully because ensurepip is not
available.  On Debian/Ubuntu systems, you need to install the python3-venv
package using the following command.

    apt install python3.12-venv

You may need to use sudo with that command.  After installing the python3-venv
package, recreate your virtual environment.

Failing command: /home/tu_usuario/curso-python/.venv/bin/python3

Прочети го по части. Първото изречение казва какво се е случило: средата „не е създадена успешно“, защото липсва ensurepip, частта, която слага pip вътре във всяка нова среда. Второто казва защо: в системите от семейството Debian и Ubuntu, от което идва Mint, тази част идва в отделен пакет. Третото ти дава точната команда, apt install python3.12-venv, а следващото те предупреждава за две неща: че може да ти трябва sudo и че след инсталирането трябва да създадеш отново средата. Последният ред, Failing command, казва коя вътрешна команда се е провалила; не е нужно да правиш нищо с нея.

Обърни внимание на думата „създадеш отново“, защото крие клопка. Макар съобщението да казва, че средата не е създадена, папката .venv е останала на диска, наполовина: има pyvenv.cfg, папките lib и include и, вътре в bin, само преките пътища към Python (python, python3 и python3.12). Липсват ѝ две неща: pip и скриптът activate. Затова още не може да се ползва: source .venv/bin/activate би отговорило No such file or directory („няма такъв файл“), съобщение, което не споменава средата и обърква, ако не знаеш какво е станало.

Изходът са две команди:

$ sudo apt update && sudo apt install python3.12-venv
$ python3 -m venv .venv
  • sudo apt update && sudo apt install python3.12-venv. apt е мениджърът на пакети на системата, този, който инсталира и обновява програмите на Mint. sudo значи „изпълни тази команда с администраторски права“: да инсталираш нещо за цялата система ги изисква, затова терминалът ще те попита за твоята парола (докато я пишеш, на екрана не се появява нищо, дори звездички; нормално е). Редът всъщност са две команди, свързани с &&, което значи „и, ако първата мине добре, втората“. Първата, apt update, не инсталира нищо: изтегля актуалния списък на наличните пакети, за да намери втората действащата версия (със стар списък apt може да не намери пакета или да избере версия, която вече не съществува). Втората инсталира python3.12-venv; apt ще те предупреди, че инсталира три пакета (python3.12-venv и два, от които зависи: python3-pip-whl, който носи pip, който ще влиза във всяка среда, и python3-setuptools-whl, друг инструмент за опаковане, който курсът не използва) и ще те попита дали да продължи: отговори с буквата за „да“ (y, ако Mint ти е на английски; s, ако е на испански) и Enter. Тук не инсталираш пакет на Python с pip, а програма на системата, която допълва Python на системата, и затова това е работа за apt. Освен този ред, курсът използва sudo отново само в Урок 11, за да инсталира pipx, и е от същия вид.
  • python3 -m venv .venv, отново, върху същата папка. Сега вече трябва да излезе мълчаливо. Не е нужно да триеш наполовина направената папка: venv я използва повторно и допълва онова, което липсваше, скрипта activate и pip.

Провери, че този път средата носи своя pip, като го извикаш по пътя му (още без да активираш нищо):

$ .venv/bin/python -m pip --version
pip 24.0 from /home/tu_usuario/curso-python/.venv/lib/python3.12/site-packages/pip (python 3.12)

pip 24.0 е версията, която Mint 22 слага в новите среди; важното е да отговори с версия и път вътре в .venv, а не с No module named pip. Ако първото ти изпълнение на python3 -m venv .venv не е отпечатало нищо, нищо от този дял не те засяга: средата ти вече е била пълна.

Да видим какво е създало. Погледни вътре в папката с ls .venv:

$ ls .venv
bin  include  lib  lib64  pyvenv.cfg

Има пет записа, но четири различни неща: lib64 не е още една папка, а пряк път към lib, който venv създава в 64-битовите Linux за програмите, които търсят библиотеките си с това име. bin съдържа програмите на средата: нейния собствен python, нейния собствен pip и скриптовете за активиране. lib е мястото, където ще се пазят пакетите, които инсталираш. include пази помощни файлове, които този курс не използва. А pyvenv.cfg е малък текстов файл, който сочи към Python, с който е създадена средата; документацията на модула обяснява, че носи ключ home с това местоположение. Можеш да го прочетеш с cat .venv/pyvenv.cfg.

Едно важно следствие: python на средата е пряк път към Python, с който е създадена, а не независимо копие. Затова, ако някой ден смениш или обновиш Python на системата, средата може да се счупи и ще трябва да се създаде отново. И точно затова една среда не се мести, нито се копира в друга папка или на друг компютър: документацията го казва с всички букви („не се счита за преместваема или копируема“; създава се отново на местоназначението). Програмите, инсталирани в една среда, пазят в първия си ред абсолютния път на своя интерпретатор; ако средата се премести, този път вече не сочи към нищо. Да създадеш среда отново струва десет секунди. Целта е да се научиш да го правиш без страх.

1.2.3 Активиране на средата

Създаването на средата още не я използва. За да може терминалът ти да използва нейния Python вместо този на системата, трябва да я активираш:

$ source .venv/bin/activate
(.venv) $

source е команда на терминала, която изпълнява скрипт „вътре“ в текущия терминал (вместо да отваря нов). Скриптът activate променя три неща, само в този терминал: добавя префикс към подканата на командния ред (prompt), (.venv), който е твоят визуален знак, че си вътре; нагласява списъка с папки, където терминалът търси програми (променливата PATH), като слага .venv/bin на първо място; и създава една променлива, VIRTUAL_ENV, с пътя на средата, за да знаят другите програми в коя си (echo $VIRTUAL_ENV я показва). Освен това оставя достъпна командата deactivate, която отменя всичко. Промяната на PATH е тази, която прави python да започне да значи „Python на средата“. Документацията го обобщава: активирането „променя средата, така че изпълнението на python да използва тази конкретна версия“.

Провери го, това е важното. С активна среда попитай кой е python:

(.venv) $ which python
/home/tu_usuario/curso-python/.venv/bin/python
(.venv) $ python --version
Python 3.12.3

Обърни внимание на две неща. Първото: сега python (без 3) съществува и сочи вътре в твоята среда. Извън среда, в твоя Mint, командата python не съществува: съществува само python3 (which python не отпечатва нищо). Ако я напишеш и терминалът ти каже, че не я намира или ти предложи python3, това е очакваното. Правилото за целия курс: извън средата python3; вътре в активираната среда python. Второто: версията е същата като преди, защото средата е създадена с този Python. Ако си създал средата с python3.14, python --version би казал 3.14. Средата решава версията; ти я избра, когато я създаде.

Тази двойка команди, which python и python --version, е рутината за сигурност на целия курс. Преди да подозираш кода си, провери кой Python работи.

1.2.4 Инсталиране на пакет: сега вече да

С активна среда същата команда, която преди беше отказана, работи:

(.venv) $ python -m pip install httpx
Collecting httpx
  Downloading httpx-0.28.1-py3-none-any.whl.metadata (7.1 kB)
...
Successfully installed anyio-4.15.1 certifi-2026.7.22 h11-0.16.0 httpcore-1.0.9 httpx-0.28.1 idna-3.20 typing_extensions-4.16.0

(Междинните редове са изрязани. Номерата на версиите, които ще видиш, са действащите в деня, в който инсталираш, така че почти сигурно няма да съвпадат с тези; важното е крайният ред Successfully installed.)

Какво стана: pip изтегли httpx и още шест пакета, от които httpx се нуждае, за да работи. Наричат се зависимости: пакети, от които зависи друг. Всичко падна вътре в .venv/lib, без да докосне Python на системата. Провери го с:

(.venv) $ python -m pip list
Package           Version
----------------- ---------
anyio             4.15.1
certifi           2026.7.22
h11               0.16.0
httpcore          1.0.9
httpx             0.28.1
idna              3.20
pip               24.0
typing_extensions 4.16.0

Списъкът показва какво има в тази среда. Ако сега отвориш друг терминал (без да активираш нищо) и поискаш списъка с python3 -m pip list, няма да видиш httpx (в твоя Mint, всъщност, отговорът ще бъде No module named pip): това, което инсталираш в една среда, не съществува извън нея. Така изглежда изолацията. В края на инсталацията може да се появи и предупреждение, което казва нещо като [notice] A new release of pip is available: то е информативно. Да обновяваш pip не е нужно за курса.

Една бележка за httpx: никоя програма от курса не го използва преди Урок 9. Инсталираме го днес само за да демонстрираме pip, с истински пакет, който има зависимости, и за да видиш каква е разликата между инсталиране вътре в средата и вън от нея.

1.2.5 Деактивиране и навикът, който трябва да придобиеш

(.venv) $ deactivate
$ which python

deactivate възстановява предишното състояние на терминала: префиксът (.venv) изчезва и python отново значи каквото е значел (в Mint, както видяхме, обикновено нищо). Затварянето на терминала има същия ефект и затова се появява навикът, който трябва да придобиеш: всеки път, когато отвориш нов терминал, за да работиш по курса, трябва да активираш средата отново:

$ cd ~/curso-python
$ source .venv/bin/activate
(.venv) $

Два реда, винаги едни и същи, и префиксът (.venv) като потвърждение. Почти всички „не ми работи“ на този етап се решават, като погледнеш дали префиксът е на екрана.

Има и друг начин да използваш среда, без да я активираш, и е добре да знаеш, че съществува: да извикаш Python на средата по пълния му път, ~/curso-python/.venv/bin/python hola.py. Документацията го потвърждава: не е необходимо да активираш средата, достатъчно е да посочиш пътя на нейния интерпретатор. Активирането е удобство (пише се python вместо дългия път), не изискване.

1.3 REPL и изпълнение на файл

Има два начина да говориш с Python и се използват за различни неща.

1.3.1 REPL: разговор

С активна среда напиши само python и Enter. Python не изпълнява файл; отваря разговор: показва ти символа >>> и чака инструкция. Това се нарича REPL (от read-eval-print loop: чете каквото пишеш, оценява го, отпечатва резултата и пак чака). Изпробвай го така (ти пишеш това, което е след >>>; поздравителният ред на първите редове се променя с твоята версия):

(.venv) $ python
Python 3.12.3 (main, ...) [GCC ...] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 142 + 1
143
>>> "reportes"
'reportes'
>>> tiempo_ms = 142
>>> tiempo_ms
142
>>> print("142" + 1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
>>> exit()
(.venv) $

Прегледай разговора. 142 + 1 връща 143, без нужда от print: REPL отпечатва вместо теб стойността на каквото напишеш. "reportes" се връща с единични кавички, защото така Python показва един текст, когато го представя. tiempo_ms = 142 е присвояване и не връща нищо; после, ако напишеш tiempo_ms, връща 142: REPL помни това, което му каза, докато не го затвориш. Четвъртата е грешката, която вече познаваш от Урок 0, TypeError, и забележи: REPL не се затваря от грешката. Показва доклада и пак чака. Това го прави идеален за грешене и учене. За да излезеш, се пише exit() (или неговият близнак quit()) или се натиска Ctrl + D; документацията дава Ctrl + D като основния начин и quit() като алтернатива.

Две подробности за версията, за да не те обърка, ако екранът ти изглежда различно. REPL от 3.13 нататък е обновен: има цвят и редактиране на няколко реда, а името, което показва в доклад за грешка, е <python-input-0> вместо <stdin>, и самия ред, който се е провалил. А REPL на 3.12, този на твоя Mint, е простият отгоре. Нищо от това, което се прави в курса, не зависи от тази разлика.

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

1.3.2 Файл: първият ти скрипт

Скриптът (script) е текстов файл с инструкции на Python, който се изпълнява от началото до края. За да го създадеш, ти трябва текстов редактор. Mint носи един, наречен Xed (в менюто се появява като „Текстов редактор“). Добре е да го настроиш веднъж: в предпочитанията му включи вмъкване на интервали вместо табулации и задай ширината на табулацията на 4. Python отдава голямо значение на интервалите в началото на редовете (Урок 2 ти обяснява защо), а смесването на табулации с интервали е класически източник на грешки, който предпочитаме да избегнем от първия ден. Ако предпочиташ терминала, nano hola.py отваря прост редактор: пиши, запиши с Ctrl + O и Enter, излез с Ctrl + X.

Създай файла ~/curso-python/hola.py с това съдържание:

# fig01_01.py
print("Hola, Python")
$ cd ~/curso-python
$ python3 hola.py
Hola, Python

Името fig01_01.py в първия ред е етикетът на фигурата в курса (в хранилището на курса файлът се казва така); ти го записваш като hola.py и затова командата е python3 hola.py. Първият ред е коментар (започва с #, Python го игнорира) и можеш да го пропуснеш. Вторият е програмата. print е функция, която Python вече носи: показва на екрана това, което е в скобите. Това, което е между кавичките, е текст, както видя в предишния урок. Това е цялото обяснение, което ти трябва днес; Урок 2 влиза в дълбочина.

Изпълни го два пъти: веднъж без активна среда и веднъж с нея. Извън средата командата е python3 hola.py. Вътре е python hola.py, защото вътре в средата python съществува и сочи към нейния Python. И в двата случая изходът е Hola, Python; това, което се променя, без да забележиш, е кой Python го е изпълнил. Тази разлика е невидима, докато всичко работи, и решаваща, когато нещо се провали, и затова в края има упражнение да я отбележиш.

С това се появява вторият файл за днес, първият от проекта. Създай папката на revisor и файла, в който ще расте:

$ mkdir ~/curso-python/revisor
# fig01_02.py
print("revisor: todavía no revisa nada")

Записва се като ~/curso-python/revisor/revisor.py (етикетът fig01_02.py е, отново, само името на фигурата). За да го пуснеш, влез първо в неговата папка, защото python3 revisor.py търси файла в папката, в която си:

$ cd ~/curso-python/revisor
$ python3 revisor.py
revisor: todavía no revisa nada

Това е програма от един ред, нарочно: важното е файлът да съществува, да работи и да е отправната точка. От Урок 2 расте, докато стане цялата програма. Думата „todavía“ („още“) е обещание.

1.4 Първият traceback

В Урок 0 видя един доклад за грешка и прочете последния му ред. Днес го четеш цял, с грешка, която ще правиш още в началото и много пъти: да напишеш неправилно името на нещо. Тази програма има нарочна печатна грешка. Този път я запиши с името на фигурата, ~/curso-python/fig01_03.py, за да съвпада докладът на екрана ти с този по-долу:

# fig01_03.py
pirnt("hola")
$ cd ~/curso-python
$ python3 fig01_03.py
Traceback (most recent call last):
  File "fig01_03.py", line 2, in <module>
    pirnt("hola")
    ^^^^^
NameError: name 'pirnt' is not defined. Did you mean: 'print'?

(На твоя екран пътят до файла ще е пълният път; тук е съкратен до името.)

Правилото за четене на доклад за грешка на Python: от последния ред нагоре. Отговарят се три въпроса, в този ред.

Какъв вид грешка е? Погледни началото на последния ред: NameError. NameError се случва, когато използваш име, което Python не познава. Урок 0 обясни, че името е етикет, който сочи към стойност; Python има няколко имена по подразбиране (като print), а други създаваш ти с присвояване. pirnt не е нито едното, нито другото.

Какво казва точно? Остатъкът от последния ред: name 'pirnt' is not defined, „името pirnt не е дефинирано“. И помощта: Did you mean: 'print'?, „имаше ли предвид print?“. Python сравни непознатото име с тези, които познава, намери едно много подобно и ти го предлага. Тази подсказка, която за този вид грешка е идентична във версиите 3.12 и 3.14, решава по-голямата част от спънките на начинаещия.

Къде е станало? Редовете отгоре. File "fig01_03.py", line 2, in <module> казва файла и реда (2, защото 1 е коментарът). Отдолу Python повтаря текста на този ред от твоя код, а циркумфлексите ^^^^^ сочат точната дума: пет знака, точно pirnt.

Направи каквото казва подсказката: смени pirnt с print, запиши и изпълни отново. С тази малка церемония (чети, разбери, поправи, повтори) ще работиш през останалата част на курса. Грешката не значи, че си го направил зле; значи, че Python ти отговаря с точност.

Грешката, която ще видиш

Днес има три съобщения, които си струва да умееш да четеш: две вече видя, а третото е предупреждение за по-късно.

NameError е това от предишния раздел. Варианти, които ще видиш: главна буква, където не трябва (Print("hola") дава NameError: name 'Print' is not defined. Did you mean: 'print'?, защото Python различава главни от малки букви), излишна буква, име, което си забравил да дефинираш. Във всички случаи се чете еднакво.

No module named pip е отговорът на твоя Mint в 1.1.2, а неговият роднина, съобщението на ensurepip от 1.2.2, е това на среда, на която ѝ липсва същата част. И двете казват с всички букви какво липсва и и двете се решават, без да се докосва Python на системата: първото, като се работи вътре в средата; второто, като се инсталира python3.12-venv и се създаде отново средата върху наполовина направената папка.

externally-managed-environment е предупреждението от 1.1.3: няма да го видиш в прясно инсталиран Mint, но ще го видиш в деня, в който инсталираш pip на системата, или в друга дистрибуция. Първият ред, error: externally-managed-environment, го слага pip: PEP 668 не фиксира този текст, а само изисква инсталаторът да откаже с грешка и да покаже съобщението, което дистрибуцията е написала във файла-маркер (или, ако няма, свое собствено, което предлага виртуална среда). Затова тялото го пише всяка система. Като истински пример, ето пълното съобщение, което дава Python на Homebrew в macOS (мениджърът на пакети там се казва brew; в Mint би бил apt):

error: externally-managed-environment

× This environment is externally managed
╰─> To install Python packages system-wide, try brew install
    xyz, where xyz is the package you are trying to
    install.

    If you wish to install a Python library that isn't in Homebrew,
    use a virtual environment:

    python3 -m venv path/to/venv
    source path/to/venv/bin/activate
    python3 -m pip install xyz

    If you wish to install a Python application that isn't in Homebrew,
    it may be easiest to use 'pipx install xyz', which will manage a
    virtual environment for you. You can install pipx with

    brew install pipx

    You may restore the old behavior of pip by passing
    the '--break-system-packages' flag to pip, or by adding
    'break-system-packages = true' to your pip.conf file. The latter
    will permanently disable this error.

    If you disable this error, we STRONGLY recommend that you additionally
    pass the '--user' flag to pip, or set 'user = true' in your pip.conf
    file. Failure to do this can result in a broken Homebrew installation.

    Read more about this behavior here: <https://peps.python.org/pep-0668/>

note: If you believe this is a mistake, please contact your Python installation or OS distribution provider. You can override this, at the risk of breaking your Python installation or OS, by passing --break-system-packages.
hint: See PEP 668 for the detailed specification.

Прочети го, както четеш traceback, без страх, по части. Първият ред е класът: externally-managed-environment, „външно управлявана среда“. Вторият, This environment is externally managed, казва причината: този Python принадлежи на друг мениджър. Третият отваря списъка с изходи. Първо, да инсталираш пакета с мениджъра на системата (тук brew; в Mint би бил apt), стига пакетът да съществува там. Второ, ако пакетът не е в мениджъра, да създадеш виртуална среда и да използваш python3 -m pip вътре в нея: трите реда, които показва, са точно venv, source ... activate и pip install, които току-що използва. Трето, ако това, което искаш, е приложение (а не библиотека, която да ползваш в кода си), pipx, който създава изолирана среда за всяко приложение. revisor ще завърши инсталиран така, в Урок 11.

Под трите изхода идват още два абзаца, които е написал Homebrew: как да „възстановиш предишното поведение“ с --break-system-packages и предупреждението, с главни букви, че това може да счупи инсталацията. А последните два реда вече не са на дистрибуцията, а на pip: една note:, която отново споменава --break-system-packages „с риск да счупиш инсталацията си на Python или операционната си система“, и една hint:, която препраща към PEP 668. Това, че опцията се появява два пъти, не я прави препоръчителна: появява се, за да знаеш, че съществува и какво струва, което е онова, което казва следващият раздел.

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

Какво се прави погрешно

  • Да използваш sudo pip install. Инсталира в Python на системата с администраторски права. Това е най-бързият начин да презапишеш библиотека, от която Mint се нуждае, и да го откриеш седмици по-късно. Всеки пакет влиза във виртуална среда.
  • Да използваш --break-system-packages, за да „заработи вече“. Изключва точно защитата, която ти помага. Курсът не я преподава, нито я използва. Ако я видиш в отговор от интернет, игнорирай я.
  • Да инсталираш, без да виждаш префикса (.venv). Ако си отворил нов терминал и си забравил да активираш, инсталацията се отхвърля (защото си извън средата) или, в система без защита, става на грешното място. Рутината е да погледнеш префикса, преди да инсталираш, и да провериш с which python при съмнение.
  • Да местиш или копираш папката .venv. Една среда пази абсолютни пътища и не оцелява при смяна на папката. Изтрива се и се създава отново с python3 -m venv .venv; пакетите се инсталират пак. Тя е за еднократна употреба по дизайн.
  • Да слагаш кода на проекта вътре в средата. Средата съдържа Python и пакетите; твоят код живее до нея, в revisor/. Така изтриването на средата не ти струва и един ред от твоето.
  • Да смесваш табулации и интервали в редактора. Python използва интервалите в началото на реда, за да структурира програмата, а смесването на двата вида дава трудни за виждане грешки. Настрой редактора си на 4 интервала днес, преди да пишеш истински код.
  • Да напишеш командата python извън средата и да заключиш, че „Python не е инсталиран“. Липсва псевдонимът python: извън средата се пише python3. Това, че python не съществува в прясно инсталиран Mint, е нормално.
  • Да стоиш часове с една грешка, без да я прочетеш. Един доклад на Python почти винаги казва какво и къде. Навикът да започваш от последния ред решава повечето.

Упражнения

Упражнение 1 — Твоята среда, измерена

Изпълни в терминал без активна среда: python3 --version и which python3. После активирай средата и изпълни python --version, which python и python -m pip --version. Запиши в своя дневник петте изхода и едно изречение, което отговаря: какво се промени между which python3 отвън и which python отвътре, и защо?

Упражнение 2 — Предизвикай отказа и го прочети

Деактивирай средата (deactivate) и изпълни python3 -m pip install httpx. Запиши в дневника точния отговор и обясни със свои думи кой говори (това, което е преди двоеточието) и какво казва. После прочети примера за externally-managed-environment от раздела „Грешката, която ще видиш“ и напиши какво казва всяка от първите му три части (класът, причината, списъкът с изходи). Накрая активирай средата и повтори инсталацията. Опиши какво се промени и какво провери с python -m pip list.

Упражнение 3 — revisor вътре и вън от средата

Създай ~/curso-python/revisor/revisor.py с реда от фигура 2 и влез в неговата папка (cd ~/curso-python/revisor). Изпълни го без средата (с python3 revisor.py) и със нея (с python revisor.py). Преди всяко изпълнение пусни which python3 или which python според случая и запиши в дневника кой Python е използван всеки път. Различен ли излезе резултатът?

Упражнение 4 — Предизвикай нова грешка и я прочети

Без да докосваш средата, създай файл с реда Print("hola") (с главно P). Преди да го изпълниш, предвиди последния ред на доклада. Изпълни го и сравни. После предизвикай втора, различна грешка: създай файл от два реда, print("primera") и print("hola) (вторият без затварящата кавичка), и виж какъв вид грешка се появява. Успява ли да се покаже primera?

Решения

Решение 1

Типичен изход е Python 3.12.x, /usr/bin/python3, Python 3.12.x, /home/tu_usuario/curso-python/.venv/bin/python и pip с пътя .venv/lib/python3.12/site-packages/pip. Това, което се промени между отвън и отвътре, е пътят: отвън е /usr/bin/python3, Python на системата; отвътре е този в .venv/bin/, на средата. Промени се, защото activate постави .venv/bin в началото на списъка с места, където терминалът търси програми; затова python (който дори не съществуваше отвън) започва да значи „този на средата“. Версията е същата, защото средата е създадена с python3 на системата.

Решение 2

Извън средата твоят Mint отговаря /usr/bin/python3: No module named pip: говори Python на системата и казва, че няма pip, така че там не се инсталира нищо. В примера с externally-managed-environment класът е externally-managed-environment: видът на проблема. Причината е, че този Python се управлява от друг мениджър на пакети и pip уважава маркера EXTERNALLY-MANAGED, оставен от този, който го е инсталирал. Списъкът с изходи е: да инсталираш с мениджъра на системата, ако пакетът съществува там, да създадеш виртуална среда за библиотеки или pipx за приложения. Когато активираш средата и повториш, инсталацията се завършва: вътре в средата има pip и защитата му не се прилага, защото там не докосва Python на системата. python -m pip list показва httpx и неговите зависимости в списъка на средата, а не в този на системата.

Решение 3

Трябва да излезе revisor: todavía no revisa nada и в двата случая. Това, което се променя, е Python: без среда which python3 дава /usr/bin/python3; със среда which python дава пътя вътре в .venv/bin/. Резултатът не се променя, защото програмата използва само print, който не зависи от никакъв пакет; разликата ще стане видима, когато една програма импортира нещо, инсталирано в средата (от Урок 9): тази програма би работила само с активна среда. Да знаеш кой Python си използвал, е онова, което ти позволява да разбереш защо.

Решение 4

С Print("hola") последният ред е NameError: name 'Print' is not defined. Did you mean: 'print'?: Python различава главни от малки букви. С print("hola) грешката сменя класа си: появява се SyntaxError: unterminated string literal (detected at line 2), което значи „текст без край“, защото липсва кавичката, която го затваря. primera не се показва: грешката става, преди да се изпълни каквото и да е. Това е грешка във формата и Python я открива в стъпката, в която чете и превежда файла (първата от четирите стъпки на Урок 0). Не е NameError, която се открива само когато се стигне до този ред с програмата вече в ход. Урок 2 изучава тази грешка подробно.

Как разбирам, че съм успял

  • python3 --version показва версия, която започва с Python 3., и си я записал в дневника.
  • python3 -m pip install httpx, с деактивирана среда, завършва с No module named pip, умееш да обясниш без да гледаш урока какво значи и кой е правилният изход, и би разпознал предупреждението externally-managed-environment, ако един ден го видиш.
  • Съществува папката ~/curso-python/.venv; с активна среда подканата на терминала започва с (.venv), а which python показва път, който завършва на .venv/bin/python.
  • С активна среда python -m pip list показва httpx; с деактивирана среда python3 -m pip list отговаря No module named pip: извън средата няма pip и следователно няма и httpx.
  • python3 hola.py извън средата и python hola.py вътре показват Hola, Python.
  • ~/curso-python/revisor/revisor.py съществува и, когато се изпълни, показва revisor: todavía no revisa nada.
  • Умееш да четеш, без да искаш помощ, доклада за NameError от фигура 3: казваш коя дума е сгрешена, на кой ред и каква подсказка е дал Python.
  • Можеш да кажеш, без да гледаш, защо средата не се мести, нито се копира, и защо никога не се инсталира със sudo pip.

Обобщение

Отговори, без да гледаш урока:

  1. Кой е Python, който идва с твоя Mint, чий е и как проверяваш откъде работи?
  2. Какво казва externally-managed-environment, кой го слага и кои са трите изхода, които предлага? Кой е този, който използва курсът?
  3. Кои три неща променя source .venv/bin/activate в терминала ти и как разбираш, че си вътре?
  4. Защо средата живее извън папката revisor/ и защо не се мести, нито се копира?
  5. Каква е разликата между REPL и файл? Кога използваш всеки?
  6. В какъв ред се чете доклад за грешка на Python и на кои три въпроса отговаря?
  7. Кой Python използва python вътре в средата и кой Python използва python3 отвън?

За допълнително четене

Да обсъдим вашия проект

Предпочитате имейл? Пишете ни на hola@habil.mx