По вашему запросу ничего не найдено :(
Убедитесь, что запрос написан правильно, или посмотрите другие
наши статьи:
Транспортный уровень OSI (уровень 4) определяет несколько функций, наиболее важными из которых являются восстановление после ошибок и управление потоком. Точно так же протоколы транспортного уровня TCP / IP также реализуют те же типы функций. Обратите внимание, что и модель OSI, и модель TCP / IP называют этот уровень транспортным. Но, как обычно, когда речь идет о модели TCP / IP, имя и номер уровня основаны на OSI, поэтому любые протоколы транспортного уровня TCP / IP считаются протоколами уровня 4.
Ключевое различие между TCP и UDP заключается в том, что TCP предоставляет широкий спектр услуг приложениям, а UDP-нет. Например, маршрутизаторы отбрасывают пакеты по многим причинам, включая битовые ошибки, перегрузку и случаи, в которых не известны правильные маршруты. Известно, что большинство протоколов передачи данных замечают ошибки (процесс, называемый error detection), и затем отбрасывают кадры, которые имеют ошибки. TCP обеспечивает повторную передачу (error recovery) и помогает избежать перегрузки (управление потоком), в то время как UDP этого не делает. В результате многие прикладные протоколы предпочитают использовать TCP.
Разница между TCP и UDP в одном видео
Однако не думайте, что отсутствие служб у UDP делает UDP хуже TCP. Предоставляя меньше услуг, UDP требует меньше байтов в своем заголовке по сравнению с TCP, что приводит к меньшему количеству байтов служебных данных в сети. Программное обеспечение UDP не замедляет передачу данных в тех случаях, когда TCP может замедляться намеренно. Кроме того, некоторым приложениям, особенно сегодня, к передаче голоса по IP (VoIP) и видео по IP, не требуется восстановление после ошибок, поэтому они используют UDP. Итак, сегодня UDP также занимает важное место в сетях TCP / IP.
В таблице 1 перечислены основные функции, поддерживаемые TCP/UDP. Обратите внимание, что только первый элемент, указанный в таблице, поддерживается UDP, тогда как TCP поддерживаются все элементы в таблице.
Таблица № 1 Функции транспортного уровня TCP/IP
Функции
Описание
Мультиплексирование с использованием портов
Функция, которая позволяет принимающим хостам выбирать правильное приложение, для которого предназначены данные, на основе номера порта.
Восстановление после ошибок (надежность)
Процесс нумерации и подтверждения данных с помощью полей заголовка Sequence и Acknowledgment
Управление потоком с использованием окон
Процесс, использующий размеры окна для защиты буферного пространства и устройств маршрутизации от перегрузки трафиком.
Установление и завершение соединения
Процесс, используемый для инициализации номеров портов, а также полей Sequence и Acknowledgment.
Упорядоченная передача данных и сегментация данных
Непрерывный поток байтов от процесса верхнего уровня, который "сегментируется" для передачи и доставляется процессам верхнего уровня на принимающем устройстве с байтами в том же порядке
Далее описываются возможности TCP, а затем приводится краткое сравнение с UDP.
Transmission Control Protocol
Каждое приложение TCP / IP обычно выбирает использование TCP или UDP в зависимости от требований приложения. Например, TCP обеспечивает восстановление после ошибок, но для этого он потребляет больше полосы пропускания и использует больше циклов обработки. UDP не выполняет исправление ошибок, но требует меньшей пропускной способности и меньшего количества циклов обработки. Независимо от того, какой из этих двух протоколов транспортного уровня TCP / IP приложение выберет для использования, вы должны понимать основы работы каждого из этих протоколов транспортного уровня.
TCP, как определено в Request For Comments (RFC) 793, выполняет функции, перечисленные в таблице 1, через механизмы на конечных компьютерах. TCP полагается на IP для сквозной доставки данных, включая вопросы маршрутизации. Другими словами, TCP выполняет только часть функций, необходимых для доставки данных между приложениями. Кроме того, роль, которую он играет, направлена на предоставление услуг для приложений, установленных на конечных компьютерах. Независимо от того, находятся ли два компьютера в одном Ethernet или разделены всем Интернетом, TCP выполняет свои функции одинаково.
На рисунке 1 показаны поля заголовка TCP. Хотя вам не нужно запоминать названия полей или их расположение, оставшаяся часть этой лекции относится к нескольким полям, поэтому весь заголовок включен сюда для справки.
Сообщение, созданное TCP, которое начинается с заголовка TCP, за которым следуют данные приложения, называется сегментом TCP. В качестве альтернативы также может использоваться более общий термин PDU уровня 4 или L4PDU.
Мультиплексирование с использованием номеров портов TCP
И TCP, и UDP используют концепцию, называемую мультиплексированием. Поэтому этот подраздел начинается с объяснения мультиплексирования с TCP и UDP. После этого исследуются уникальные возможности TCP.
Мультиплексирование по TCP и UDP включает в себя процесс того, как компьютер думает при получении данных. На компьютере может быть запущено множество приложений, таких как веб-браузер, электронная почта или приложение Internet VoIP (например, Skype). Мультиплексирование TCP и UDP сообщает принимающему компьютеру, какому приложению передать полученные данные.
Определенные примеры помогут сделать очевидной необходимость мультиплексирования. Сеть из примера состоит из двух компьютеров, помеченных как Анна и Гриша. Анна использует написанное ею приложение для рассылки рекламных объявлений, которые появляются на экране Григория. Приложение отправляет Григорию новое объявление каждые 10 секунд. Анна использует второе приложение, чтобы отправить Грише деньги. Наконец, Анна использует веб-браузер для доступа к веб-серверу, который работает на компьютере Григория. Рекламное приложение и приложение для электронного перевода являются воображаемыми, только для этого примера. Веб-приложение работает так же, как и в реальной жизни.
На рисунке 2 показан пример сети, в которой Гриша запускает три приложения:
Рекламное приложение на основе UDP
Приложение для банковских переводов на основе TCP
Приложение веб-сервера TCP
Грише необходимо знать, в какое приложение передавать данные, но все три пакета поступают из одного и того же Ethernet и IP-адреса. Вы могли подумать, что Григорий может посмотреть, содержит ли пакет заголовок UDP или TCP, но, как вы видите на рисунке, два приложения (wire transfer и web) используют TCP.
TCP и UDP решают эту проблему, используя поле номера порта в заголовке TCP или UDP соответственно. Каждый из сегментов TCP и UDP Анны использует свой номер порта назначения, чтобы Григорий знал, какому приложению передать данные. На рисунке 3 показан пример.
Мультиплексирование основывается на концепции, называемой сокетом. Сокет состоит из трех частей:
IP-адрес
Транспортный протокол
Номер порта
Итак, для приложения веб-сервера Григория, сокет будет (10.1.1.2, TCP, порт 80), потому что по умолчанию веб-серверы используют хорошо известный порт 80. Когда веб-браузер Анны подключается к веб-серверу, Анна также использует сокет - возможно, такой: (10.1.1.1, TCP, 49160). Почему 49160? Что ж, Анне просто нужен номер порта, уникальный для Анны, поэтому Анна видит этот порт 49160.
Internet Assigned Numbers Authority (IANA), организация, которая управляет распределением IP-адресов во всем мире, и подразделяет диапазоны номеров портов на три основных диапазона. Первые два диапазона резервируют номера, которые IANA затем может назначить конкретным протоколам приложений через процесс приложения и проверки, а третья категория резервирует порты, которые будут динамически выделяться для клиентов, как в примере с портом 49160 в предыдущем абзаце. Имена и диапазоны номеров портов (более подробно описано в RFC 6335):
Хорошо известные (системные) порты: номера от 0 до 1023, присвоенные IANA, с более строгим процессом проверки для назначения новых портов, чем пользовательские порты.
Пользовательские (зарегистрированные) порты: номера от 1024 до 49151, присвоенные IANA с менее строгим процессом назначения новых портов по сравнению с хорошо известными портами.
Эфемерные (динамические, частные) порты: номера от 49152 до 65535, не назначены и не предназначены для динамического выделения и временного использования для клиентского приложения во время его работы.
На рисунке 4 показан пример, в котором используются три временных порта на пользовательском устройстве слева, а сервер справа использует два хорошо известных порта и один пользовательский порт. Компьютеры используют три приложения одновременно; следовательно, открыто три сокетных соединения. Поскольку сокет на одном компьютере должен быть уникальным, соединение между двумя сокетами должно идентифицировать уникальное соединение между двумя компьютерами. Эта уникальность означает, что вы можете использовать несколько приложений одновременно, разговаривая с приложениями, запущенными на одном или разных компьютерах. Мультиплексирование на основе сокетов гарантирует, что данные будут доставлены в нужные приложения.
Номера портов являются важной частью концепции сокетов. Серверы используют хорошо известные порты (или пользовательские порты), тогда как клиенты используют динамические порты. Приложения, которые предоставляют услуги, такие как FTP, Telnet и веб-серверы, открывают сокет, используя известный порт, и прослушивают запросы на подключение. Поскольку эти запросы на подключение от клиентов должны включать номера портов источника и назначения, номера портов, используемые серверами, должны быть известны заранее. Таким образом, каждая служба использует определенный хорошо известный номер порта или номер пользовательского порта. Как общеизвестные, так и пользовательские порты перечислены на www.iana.org/assignments/servicenames-port-numbers/service-names-port-numbers.txt.
На клиентских машинах, откуда исходят запросы, можно выделить любой локально неиспользуемый номер порта. В результате каждый клиент на одном и том же хосте использует другой номер порта, но сервер использует один и тот же номер порта для всех подключений. Например, 100 веб-браузеров на одном и том же хост-компьютере могут подключаться к веб-серверу, но веб-сервер со 100 подключенными к нему клиентами будет иметь только один сокет и, следовательно, только один номер порта (в данном случае порт 80). Сервер может определить, какие пакеты отправлены от какого из 100 клиентов, посмотрев на порт источника полученных сегментов TCP. Сервер может отправлять данные правильному веб-клиенту (браузеру), отправляя данные на тот же номер порта, который указан в качестве порта назначения. Комбинация сокетов источника и назначения позволяет всем участвующим хостам различать источник и назначение данных. Хотя в примере объясняется концепция использования 100 TCP-соединений, та же концепция нумерации портов применяется к сеансам UDP таким же образом.
Почитайте продолжение цикла про популярные приложения TCP/IP.
Ansible один из двух (наряду с SaltStack) наиболее популярных программных комплексов третьей волны, которые позволяют удалённо управлять конфигурациями. Тем не менее, в сегменте сетевого оборудования лидирует наш сегодняшний герой (если о ПО можно так сказать). В первую очередь это вызвано тем, что Ansible не поставит перед пользователем задачи устанавливать агент на хостинги, требующие от него управления. Тем паче ежели Ваш аппарат взаимодействует с ними через CLI, то Ansible это то, что доктор прописал.
Одним выстрелом три "электронных зайца"
Вообще, прежде чем знакомить уважаемых читателей со сценарием работы в данном программном комплексе, позвольте перечислить несколько его достоинств:
Ansible позволяет параллельно подключать по SSH к устройствам (пользователь может сам определить их число).
Ansible может передавать задачи на подключённые машины.
Ansible способен разбивать машины, входящих в систему, на подгруппы и передавать специальных задачи для каждой подгруппы.
Конечно, указаны не все достоинства Ansible. Просто в данных 3 пунктах, как мне кажется, отражена основная суть работы в данной среде. Выполняя эти три задачи, система автоматически освобождает Вас от головной боли по делегированию задач и функций в компании. Время деньги, как говорится.
Сценарии
Ну и переходим к основному блюду нашего материала - сценариям (playbook). Они состоят из двух частей набора команд для выполнения (play) и конкретных команд (task). Они выполняются друг за другом.
Все записи данных осуществляются с помощью YAMLа. К несомненным плюсам его использования следует отнести то, что он гораздо лучше воспринимается людьми, нежели тот же самый JSON. Ежели Вы больше привыкли Вы к Python, то тут у Вас не возникнет проблем с адаптацией, так как синтаксис у них схожий.
А вот так происходит процесс написания сценария (комментарии даны построчно к выводу):
Имя сценария обязательный элемент для любого сценария;
Сценарий применяется к машинам в подгруппе cisco-routers;
Выключение режима сбора событий в конкретной машине (если не выключить данный режим, то система потратит много времени на решение ненужных задач);
В разделе task указывается список команд для каждого конкретного случая;
После чего происходит выполнение команды:
PLAY [Run show commands on routers] ***************************************************
TASK [run sh ip int br] ***************************************************************
changed: [192.168.100.1]
changed: [192.168.100.3]
changed: [192.168.100.2]
TASK [run sh ip route] ****************************************************************
changed: [192.168.100.1]
changed: [192.168.100.3]
changed: [192.168.100.2]
PLAY [Run show commands on switches] **************************************************
TASK [run sh int status] **************************************************************
changed: [192.168.100.100]
TASK [run sh vlans] *******************************************************************
changed: [192.168.100.100]
PLAY RECAP ****************************************************************************
192.168.100.1 : ok=2 changed=2 unreachable=0 failed=0
192.168.100.100 : ok=2 changed=2 unreachable=0 failed=0
192.168.100.2 : ok=2 changed=2 unreachable=0 failed=0
192.168.100.3 : ok=2 changed=2 unreachable=0 failed=0
И запускаем проверку выполнения команд:
SSH password:
PLAY [Run show commands on routers] ***************************************************
TASK [run s hip int br] ***************************************************************
Changed: [192.168.100.1] => {“changed”: true, “rc”: 0, “stderr”: “Shared connection
To 192.168.100.1 closed.
”, “stdout”: “
Interface IP-Address
OK? Method Status Protocol
Ethernet0/0 192.
168.100.1 YES NVRAM up up
Ethernet0/1
192.168.200.1 YES NVRAM up up
Loopback0
10.1.1.1 YES manual up up
”, “stdout_lines
“: [“”, “Interface IP-Address OK? Method Status
Protocol”, “Ethernet0/0 192.168.100.1 YES NVRAM up
up “, “Ethernet0/1 192.168.200.1 YES NVRAM up
up “, “Loopaback0 10.1.1.1 YES manual up
up “]}
А что внутри?
А теперь поговорим о начинке сценария. Основу составляют переменные. Это могут быть данные о машине, выводы команд, а также их можно вводить вручную.
Главное не забывать правила написания имён. Их всего два:
имена всегда должны состоять из букв, цифр и нижнего подчёркивания;
имена всегда должны начинаться с буквы.
Переменные могут быть определены разными способами:
Инвентарным файлом
[cisco-routers]
192.168.100.1
192.168.100.2
192.168.100.3
[cisco-switches]
192.168.100.100
[cisco-routers:vars]
ntp_server=192.168.255.100
log_server=10.255.100.1
PLAYBOOKом
-name: Run show commands on router:
hosts: cisco-routers
gather_facts: false
vars:
ntp_server: 192.168.255.100
log_server: 10.255.100.1
tasks:
-name: run sh ip int br
raw: s hip int br | ex unass
-name: run s hip route
raw: sh ip route
Специальными файлами, созданными для групп:
[cisco-routers]
192.168.100.1
192.168.100.2
192.168.100.3
[cisco-switches]
192.168.100.100
Или группами каталогов
|– group_vars _
| |– all.yml |
| |–cisco-routers.yml | Каталог с переменными для групп устройств
| |–cisco-switches.yml _|
|
|–host vars _
| |–192.168.100.1 |
| |–192.168.100.2 |
| |–192.168.100.3 | Каталог с переменными для устройств
| |–192.168.100.100 _|
|
|–myhosts | Инвертарный файл
Команда register позволяет сохранять результаты выполнений модулей в переменные. После чего переменная может быть использована в шаблонах, принятиях решений о выполнении заданного сценария.
---
- name: Run show commands on routers
hosts: cisco-routers
gather_facts: false
tasks:
-name: run s hip int br
raw: s hip int br | ex unass
register: sh_ip_int_br_result
---
debug отображает информацию в стандартном потоке вывода в виде произвольной строки, переменной или фактах о машине.
---
- name: Run show commands on routers
hosts: cisco-routers
gather_facts: false
tasks:
-name: run s hip int br
raw: sh ip int br | ex unass
register: sh_ip_int_br_result
-name: Debug registered var
debug: var=sh_ip_int_br_result.stdout_lines
После чего результатом работы станет следующее:
SSH password:
PLAY [Run show commands on routers] ***************************************************
TASK [run sh ip int br] ***************************************************************
changed: [192.168.100.1]
changed: [192.168.100.2]
changed: [192.168.100.3]
TASK [Debug registered var] ***********************************************************
ok: [192.168.100.1] => {
“sh_ip_int_br_result.stdout_lines”: [
“”,
“Interface IP-Address OK? Method Status Protocol”,
“Ethernet0/0 192.168.100.1 YES NVRAM up up “,
“Ethernet0/1 192.168.200.1 YES NVRAM up up “,
“Loopback0 10.1.1.1 YES manual up up “
]
}
ok: [192.168.100.2] => {
“sh_ip_int_br_result.stdout_lines”: [
“”,
“Interface IP-Address OK? Method Status Protocol”,
“Ethernet0/0 192.168.100.1 YES NVRAM up up “,
“Ethernet0/2 192.168.200.1 YES NVRAM administratively down down “,
“Loopback0 10.1.1.1 YES manual up up “
]
}
ok: [192.168.100.3] => {
“sh_ip_int_br_result.stdout_lines”: [
“”,
“Interface IP-Address OK? Method Status Protocol”,
“Ethernet0/0 192.168.100.3 YES NVRAM up up “,
“Ethernet0/2 192.168.200.1 YES NVRAM administratively down down “,
“Loopback0 10.1.1.1 YES manual up up “,
“Loopback10 10.255.3.3 YES manual up up “
]
}
PLAY RECAP ****************************************************************************
192.168.100.1 : ok=2 changed=1 unreachable=0 failed=0
192.168.100.2 : ok=2 changed=1 unreachable=0 failed=0
192.168.100.3 : ok=2 changed=1 unreachable=0 failed=0
Вместо заключения
Можно ещё долго приводить примеры работы в системе, но ещё один факт так сказать "вишенка на торте". К плюсам Ansible следует отнести и то, что заданную команду система может выполнять практически до бесконечности. Пока не наступит требуемый результат трансформации не прекратятся. Пользователю можно не беспокоиться - программа сама всё сделает за Вас, а Вы можете заниматься другими делами.
@media screen and (max-width: 736px){
.video-container {
position: relative;
padding-bottom: 56.25%;
padding-top: 30px;
height: 0;
overflow: hidden;
}
.video-container iframe {
position: absolute;
top:0;
left: 0;
width: 100%;
height: 100%;
}}
В этом руководстве мы расскажем про основы языка Python, расскажем как его установить, как запускать программы и на примерах разберем все основные темы.
Прежде всего, что такое Python? По словам его создателя Гвидо ван Россума, Python - это:
«Язык программирования высокого уровня и его основная философия проектирования - это все о читабельности кода и синтаксисе, который позволяет программистам выражать концепции в нескольких строках кода».
Мы можем использовать кодирование на Python по-разному: здесь блистают наука о данных, автоматизация задач, написание скриптов, веб-разработка и машинное обучение. Quora, Pinterest и Spotify используют Python для своей внутренней веб-разработки. Итак, давайте немного узнаем об этом языке и разберем его основы.
О языке
Что умеет Python?
Python можно использовать на сервере для создания веб-приложений.
Python можно использовать вместе с программным обеспечением для создания рабочих процессов.
Python может подключаться к системам баз данных. Он также может читать и изменять файлы.
Python можно использовать для обработки больших данных и выполнения сложной математики.
Python можно использовать для быстрого создания прототипов или для разработки программного обеспечения, готового к производству.
Почему Python?
Python работает на разных платформах (Windows, Mac, Linux, Raspberry Pi и т.д.).
Python имеет простой синтаксис, аналогичный английскому языку.
Синтаксис Python позволяет разработчикам писать программы с меньшим количеством строк, чем в некоторых других языках программирования.
Python работает в системе интерпретатора, что означает, что код может быть выполнен, как только он будет написан. Это означает, что прототипирование может быть очень быстрым.
Python можно рассматривать как процедурный, объектно-ориентированный или функциональный.
Python популярный и имеет хорошо развитую экосистему.
Хорошо знать
Самая последняя основная версия Python - это Python 3. Однако Python 2, хотя и не обновляется ничем, кроме обновлений безопасности, по-прежнему довольно популярен.
Можно написать Python в интегрированной среде разработки, такой как Thonny, Pycharm, Netbeans или Eclipse, которые особенно полезны при управлении большими коллекциями файлов Python.
Синтаксис Python по сравнению с другими языками программирования
Python был разработан для удобства чтения и имеет некоторое сходство с английским языком с влиянием математики.
Python использует новые строки для завершения команды, в отличие от других языков программирования, в которых часто используются точки с запятой или круглые скобки.
Python полагается на отступы с использованием пробелов для определения области видимости; например, объем циклов, функций и классов. В других языках программирования для этой цели часто используются фигурные скобки.
Подготовка
Установка Python
На многих ПК и Mac уже установлен Python.
Чтобы проверить, установлен ли у вас Python на ПК с Windows, выполните поиск Python на панели запуска или выполните в командной строке cmd.exe следующее:
C:UsersYour Name>python --version
Чтобы проверить, установлен ли у вас python на Linux или Mac, то на Linux откройте командную строку или на Mac откройте Терминал и введите:
python --version
Если вы обнаружите, что на вашем компьютере не установлен python, вы можете бесплатно загрузить его со следующего веб-сайта: https://www.python.org/
Быстрый старт
Python - это интерпретируемый язык программирования, это означает, что как разработчик вы пишете файлы Python .py в текстовом редакторе, а затем помещаете эти файлы в интерпретатор Python для выполнения.
Способ запуска файла Python в командной строке выглядит следующим образом:
C:UsersYour Name>python helloworld.py
Где helloworld.py - это имя вашего файла python.
Давайте напишем наш первый файл Python под названием helloworld.py, который можно сделать в любом текстовом редакторе.
print("Hello, World!")
Сохраните ваш файл. Откройте командную строку, перейдите в каталог, в котором вы сохранили файл, и запустите:
C:UsersYour Name>python helloworld.py
Результат должен быть таким:
Hello, World!
Поздравляем, вы написали и выполнили свою первую программу на Python.
Командная строка Python
Чтобы протестировать небольшой объем кода на Python, иногда проще и быстрее всего не записывать код в файл. Это стало возможным, потому что Python можно запускать из командной строки.
Введите в командной строке Windows, Mac или Linux следующее:
C:UsersYour Name>python
Или, если команда python не сработала, вы можете попробовать py:
C:UsersYour Name>py
Оттуда вы можете написать любой Python, включая наш пример hello world из ранее в руководстве:
C:UsersYour Name>python
Python 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:04:45) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello, World!")
Которая напишет "Hello, World!" в командной строке:
C:UsersYour Name>python
Python 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:04:45) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello, World!")
Hello, World!
Когда вы закончите в командной строке Python, вы можете просто ввести следующее, чтобы выйти из интерфейса командной строки Python:
exit()
Основы
1. Переменные
Вы можете думать о переменных как о словах, хранящих значение. Вот так просто.
В Python действительно легко определить переменную и присвоить ей значение. Представьте, что вы хотите сохранить номер 1 в переменной под названием one (единица). Давай сделаем это:
one = 1
Заметили насколько это было просто? Вы только что присвоили значение 1 переменной one.
two = 2
some_number = 10000
Python - динамически типизированный язык, и это не нужно указывать типы переменных, которые вы используете, и переменные не привязаны к конкретному типу.
И вы можете присвоить любое другое значение любым другим переменным, которые захотите. Как вы видите в таблице выше, переменная two хранит целое число 2, а some_number хранит 10 000.
Помимо целых чисел, мы также можем использовать булевые логические значения (True или False), строки, числа с плавающей запятой и многие другие типы данных.
# booleans (булевые значения)
true_boolean = True
false_boolean = False
# string (строка)
my_name = "Leandro Tk"
# float (числа с плавающей запятой)
book_price = 15.80
Комментарии начинаются с символа #, и Python их игнорирует:
2. Поток управления: условные операторы
if использует выражение для оценки того, является ли утверждение истинным или ложным. Если это True, он выполняет то, что находится внутри оператора if. Например:
if True:
print("Hello Python If")
if 2 > 1:
print("2 is greater than 1")
Обратите внимание, что на после строк с if у нас стоит отступ. Если в других языках программирования отступы в коде предназначены только для удобства чтения, отступы в Python очень важны. Python использует отступ для обозначения блока кода. Тут должен стоять хотя бы один пробел, иначе мы получим ошибку.
2 больше 1, поэтому выполняется код print. Оператор else будет выполнен, если выражение if ложно.
Функция print () выводит указанное сообщение на экран.
if 1 > 2:
print("1 is greater than 2")
else:
print("1 is not greater than 2")
В Python при сравнении используется двойное равно ==, а при присвоении - одно.
1 не больше 2, поэтому код внутри оператора else будет выполнен.
Вы также можете использовать оператор elif, который значит else if:
if 1 > 2:
print("1 is greater than 2")
elif 2 > 1:
print("1 is not greater than 2")
else:
print("1 is equal to 2")
3. Цикл / Итератор
В Python мы можем выполнять итерацию в разных формах. Мы расскажем о двух: while и for.
Цикл while: пока оператор имеет значение True, код внутри блока будет выполнен. Итак, этот код напечатает число от 1 до 10.
num = 1
while num some_value
Это пример того, как его использовать. Для каждого ключа в словаре мы печатаем ключ и соответствующее ему значение.
Другой способ сделать это - использовать метод items, который вернет нам ключ и значение. Используем его для словаря, что будет выглядеть как dictionary.items()
dictionary = { "some_key": "some_value" }
for key, value in dictionary.items():
print("%s --> %s" %(key, value))
# some_key --> some_value
Мы назвали эти два параметра key и value, но это не обязательно. Мы можем называть их как угодно. Давай посмотрим:
dictionary_tk = {
"name": "Leandro",
"nickname": "Tk",
"birthplace": "Brazil",
"age": 24
}
for attribute, value in dictionary_tk.items():
print("My %s is %s" %(attribute, value))
# My name is Leandro
# My nickname is Tk
# My birthplace is Brazil
# My age is 24
Мы видим, что мы использовали атрибут в качестве параметра для ключа словаря, и он работает правильно. Отлично!
Функции
Функция - это блок кода, который запускается только при его вызове. Вы можете передавать данные, называемые параметрами, в функцию. В результате функция может возвращать данные. Все как везде
В Python функция определяется с помощью ключевого слова def:
def my_function():
print("Hello from a function")
Чтобы вызвать функцию, используйте имя функции, за которым следует скобка:
def my_function():
print("Hello from a function")
my_function()
Информация может быть передана в функции как аргументы. Аргументы указываются после имени функции в круглых скобках. Вы можете добавить сколько угодно аргументов, просто разделив их запятыми. В следующем примере есть функция с одним аргументом fname. Когда функция вызывается, мы передаем имя, которое используется внутри функции для печати полного имени:
def my_function(fname):
print(fname + " Refsnes")
my_function("Emil")
my_function("Tobias")
my_function("Linus")
По умолчанию функция должна вызываться с правильным количеством аргументов. Это означает, что если ваша функция ожидает 2 аргумента, вы должны вызвать функцию с 2 аргументами, не больше и не меньше. Если вы попытаетесь вызвать функцию с 1 или 3 аргументами, то получите ошибку.
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil", "Refsnes")
Если вы не знаете, сколько аргументов будет передано вашей функции, добавьте * перед именем параметра в определении функции.
def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Emil", "Tobias", "Linus")
Мы можем использовать значение параметра по умолчанию. Если мы вызываем функцию без аргументов, то она не сломается и будет использовать значение по умолчанию:
def my_function(country = "Norway"):
print("I am from " + country)
my_function("Sweden") #I am from Sweden
my_function() #I am from Norway
Вы можете отправить любой тип данных аргумента функции (строка, число, список, словарь), И он будет обрабатываться как тот же тип данных внутри функции.
Например если вы отправите список в качестве аргумента, он все равно будет списком, когда достигнет функции:
def my_function(food):
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)
Ну и чтобы позволить функции вернуть значение, используйте оператор return:
def my_function(x):
return 5 * x
print(my_function(3)) #15
print(my_function(5)) #25
Пользовательский ввод Python
Python позволяет вводить данные пользователем. Это означает, что мы можем попросить пользователя ввести данные.
Этот метод немного отличается в Python 3.6 от Python 2.7. Python 3.6 использует метод input().
username = input("Enter username:")
print("Username is: " + username)
Python 2.7 использует метод raw_input().
username = raw_input("Enter username:")
print("Username is: " + username)
Python прекращает выполнение, когда доходит до функции input (), и продолжает выполнение, когда пользователь ввел некоторый ввод.
Обработка ошибок Python
Блок try позволяет вам проверить блок кода на наличие ошибок.
Блок except позволяет вам обрабатывать ошибку.
Блок finally позволяет выполнять код независимо от результата блоков try и except.
Обработка исключений
Когда возникает ошибка или исключение, как мы это называем, Python обычно останавливается и генерирует сообщение об ошибке.
Эти исключения можно обрабатывать с помощью оператора try:
try:
print(x)
except:
print("An exception occurred")
Блок try сгенерирует исключение, потому что x не определен.
Поскольку блок try вызывает ошибку, блок except будет выполнен. Без блока try программа выйдет из строя и выдаст ошибку.
Вы можете определить столько блоков исключений, сколько захотите, например если вы хотите выполнить специальный блок кода для особого типа ошибки.
try:
print(x)
except NameError:
print("Variable x is not defined")
except:
print("Something else went wrong")
Выведите одно сообщение, если блок try вызывает NameError, а другое - для других ошибок.
Вы можете использовать ключевое слово else, чтобы определить блок кода, который будет выполняться, если ошибок не возникло:
try:
print("Hello")
except:
print("Something went wrong")
else:
print("Nothing went wrong")
Блок finally, если он указан, будет выполнен независимо от того, вызывает ли блок try ошибку или нет.
try:
print(x)
except:
print("Something went wrong")
finally:
print("The 'try except' is finished")
Как разработчик Python сами вы можете создать исключение при возникновении условия.
Чтобы вызвать (или выкинуть) исключение, используйте ключевое слово raise.
x = -1
if x < 0:
raise Exception("Sorry, no numbers below zero")
Вы можете определить, какую ошибку выдавать, и текст, который будет выводить пользователь.
x = "hello"
if not type(x) is int:
raise TypeError("Only integers are allowed")
Классы и объекты
Немного теории:
Объекты представляют собой объекты реального мира, таких как автомобили, собаки или велосипеды. У объектов есть две основные характеристики: данные и поведение.
У автомобилей есть данные, такие как количество колес, количество дверей и вместимость. Они также демонстрируют поведение: они могут ускоряться, останавливаться, показывать, сколько топлива осталось, и многое другое.
Мы идентифицируем данные как атрибуты, а поведение как методы в объектно-ориентированном программировании.
А класс - это чертеж или план, из которого создаются отдельные объекты. В реальном мире мы часто находим много объектов одного типа. Как машины. Каждая машина была построена по одному и тому же набору чертежей и состоит из одинаковых компонентов (у всех есть двигатель, колеса, двери и т.д.).
Объектно-ориентированное программирование Python
Python как объектно-ориентированный язык программирования имеет следующие концепции: класс и объект.
Класс - это план или чертерж, модель для своих объектов.
Итак, опять же, класс - это просто модель или способ определения атрибутов и поведения. Например, класс транспортного средства имеет свои собственные атрибуты, определяющие, какие объекты являются транспортными средствами. Количество колес, тип бака, вместимость и максимальная скорость - все это атрибуты транспортного средства.
Имея это в виду, давайте посмотрим на синтаксис Python для классов:
class Vehicle:
pass
pass это оператор-заглушка, равноценный отсутствию операции. Тут мы используем его потому что еще не указали атрибуты.
Мы определяем классы с помощью оператора class - и все. Легко, правда?
Объекты - это экземпляры класса. Мы создаем экземпляр, называя класс.
car = Vehicle()
print(car) #
Здесь car - это объект (или экземпляр) класса Vehicle.
Помните, что у нашего класса транспортных средств есть четыре атрибута: количество колес, тип бака, вместимость и максимальная скорость. Мы устанавливаем все эти атрибуты при создании объекта транспортного средства. Итак, здесь мы определяем наш класс для получения данных, когда он их инициирует:
class Vehicle:
def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
self.number_of_wheels = number_of_wheels
self.type_of_tank = type_of_tank
self.seating_capacity = seating_capacity
self.maximum_velocity = maximum_velocity
Метод __init__, который автоматически вызывается при создании объектов называется конструктором объектов класса
Переменная self представляет текущий объект класса.
Мы используем метод init. Мы называем это методом конструктора. Итак, когда мы создаем объект транспортного средства, мы можем определить эти атрибуты. Представьте, что мы любим Tesla Model S и хотим создать такой объект. У него четыре колеса, он работает на электроэнергии, вмещает пять сидений, а максимальная скорость составляет 250 км/час. Давайте создадим этот объект:
tesla_model_s = Vehicle(4, 'electric', 5, 250)
Четыре колеса + электробанк + пять сидений + максимальная скорость 250 км/час.
Все атрибуты установлены. Но как мы можем получить доступ к значениям этих атрибутов? Мы отправляем объекту сообщение с вопросом о них. Мы называем это методом. Это поведение объекта. Давайте применим это это:
class Vehicle:
def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
self.number_of_wheels = number_of_wheels
self.type_of_tank = type_of_tank
self.seating_capacity = seating_capacity
self.maximum_velocity = maximum_velocity
def number_of_wheels(self):
return self.number_of_wheels
def set_number_of_wheels(self, number):
self.number_of_wheels = number
Это реализация двух методов: number_of_wheels и set_number_of_wheels. Мы называем это геттером (getter) и сеттером (setter). Потому что первый получает значение атрибута, а второй устанавливает новое значение атрибута.
В Python мы можем сделать это, используя @property (декораторы) для определения геттеров и сеттеров. Посмотрим на код:
class Vehicle:
def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
self.number_of_wheels = number_of_wheels
self.type_of_tank = type_of_tank
self.seating_capacity = seating_capacity
self.maximum_velocity = maximum_velocity
@property
def number_of_wheels(self):
return self.__number_of_wheels
@number_of_wheels.setter
def number_of_wheels(self, number):
self.__number_of_wheels = number
И мы можем использовать эти методы как атрибуты, вызывав их через точку:
tesla_model_s = Vehicle(4, 'electric', 5, 250)
print(tesla_model_s.number_of_wheels) # 4
tesla_model_s.number_of_wheels = 2 # устанавливаем число колес равное 2
print(tesla_model_s.number_of_wheels) # 2
Это немного отличается от определения методов. Методы работают как атрибуты. Например, когда мы устанавливаем новое количество колес, мы не применяем два в качестве параметра, а устанавливаем значение 2 равным number_of_wheels. Это один из способов написания геттеров и сеттеров в Python.
Но мы также можем использовать методы для других вещей, например, метод make_noise. Давай увидим это:
class Vehicle:
def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
self.number_of_wheels = number_of_wheels
self.type_of_tank = type_of_tank
self.seating_capacity = seating_capacity
self.maximum_velocity = maximum_velocity
def make_noise(self):
print('VRUUUUUUUM')
Когда мы вызываем этот метод, он просто возвращает строку «VRRRRUUUUM».
tesla_model_s = Vehicle(4, 'electric', 5, 250)
tesla_model_s.make_noise() # VRUUUUUUUM
Инкапсуляция: скрытие информации
Инкапсуляция - это механизм, ограничивающий прямой доступ к данным и методам объектов. Но в то же время это облегчает работу с этими данными (методами объектов).
Все внутреннее представление объекта скрыто снаружи. Только объект может взаимодействовать со своими внутренними данными.
Во-первых, нам нужно понять, как работают общедоступные и непубличные переменные и методы экземпляра - pubulic и non-public.
Переменные общедоступного экземпляра
Для класса Python мы можем инициализировать общедоступную переменную экземпляра в нашем методе конструктора.
class Person:
def __init__(self, first_name):
self.first_name = first_name
Здесь мы применяем значение first_name в качестве аргумента к общедоступной переменной экземпляра (public instance variable).
tk = Person('TK')
print(tk.first_name) # => TK
Внутри класса:
class Person:
first_name = 'TK'
Здесь нам не нужно применять first_name в качестве аргумента, и все объекты экземпляра будут иметь атрибут класса, инициализированный с помощью TK.
tk = Person()
print(tk.first_name) # => TK
Теперь мы узнали, что можем использовать общедоступные переменные экземпляра и атрибуты класса. Еще одна интересная особенность публичной части - это то, что мы можем управлять значением переменной. Что то значит? Наш объект может управлять своим значением переменной: получать и устанавливать значения переменных.
Помня о классе Person, мы хотим установить другое значение для его переменной first_name:
tk = Person('TK')
tk.first_name = 'Kaio'
print(tk.first_name) # => Kaio
Мы просто устанавливаем другое значение kaio для переменной экземпляра first_name, и она обновляет значение. Вот так просто. Поскольку это общедоступная переменная, мы можем это сделать.
Непубличная переменная экземпляра
В качестве общедоступной переменной экземпляра мы можем определить непубличную (non-public) переменную экземпляра как внутри метода конструктора, так и внутри класса. Разница в синтаксисе: для закрытых переменных экземпляра используйте символ подчеркивания _ перед именем переменной.
«Частные» переменные экземпляра, к которым нельзя получить доступ, кроме как изнутри объекта, в Python не существует. Однако существует соглашение, которому следует большая часть кода Python: имя с префиксом подчеркивания (например, _spam) должно рассматриваться как закрытая часть API (будь то функция, метод или член данных).
Вот пример:
class Person:
def __init__(self, first_name, email):
self.first_name = first_name
self._email = email
Вы видели переменную _email? Вот как мы определяем непубличную переменную:
tk = Person('TK', 'tk@mail.com')
print(tk._email) # tk@mail.com
Мы можем получить к ней доступ и обновить. Непубличные переменные - это просто соглашение, и их следует рассматривать как непубличную часть API.
API - это программный интерфейс приложения. Это интерфейс взаимодействия с программой.
Итак, мы используем метод, который позволяет нам делать это внутри определения нашего класса. Давайте реализуем два метода (emali и update_email), чтобы понять это:
class Person:
def __init__(self, first_name, email):
self.first_name = first_name
self._email = email
def update_email(self, new_email):
self._email = new_email
def email(self):
return self._email
Теперь мы можем обновлять непубличные переменные и обращаться к ним с помощью этих методов. Давайте посмотрим:
tk = Person('TK', 'tk@mail.com')
print(tk.email()) # => tk@mail.com
# tk._email = 'new_tk@mail.com' -- рассматривать как непубличную часть API класса
print(tk.email()) # => tk@mail.com
tk.update_email('new_tk@mail.com')
print(tk.email()) # => new_tk@mail.com
Мы инициировали новый объект с именем TK и адресом электронной почты tk@mail.com
Распечатали email, обратившись к закрытой переменной с помощью метода
Пытались установить новый адрес электронной почты вне нашего класса
Нам нужно рассматривать непубличную переменную как непубличную часть API.
Обновлена непубличная переменная с помощью нашего метода экземпляра
Успех! Мы можем обновить ее внутри нашего класса с помощью вспомогательного метода
Публичный метод
С общедоступными методами мы также можем использовать их вне нашего класса:
class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def show_age(self):
return self._age
Давайте проверим это:
tk = Person('TK', 25)
print(tk.show_age()) # => 25
Отлично - мы можем использовать его без проблем.
Непубличный метод
Но с помощью закрытых методов мы не можем этого сделать. Давайте реализуем тот же класс Person, но теперь с закрытым методом show_age с подчеркиванием _.
class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def _show_age(self):
return self._age
А теперь мы попробуем вызвать этот непубличный метод с нашим объектом:
tk = Person('TK', 25)
print(tk._show_age()) # => 25
Тут все так же. Мы можем получить к нему доступ и обновить. Непубличные методы - это просто соглашение, и их следует рассматривать как непубличную часть API.
Вот пример того, как мы можем это использовать:
class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def show_age(self):
return self._get_age()
def _get_age(self):
return self._age
tk = Person('TK', 25)
print(tk.show_age()) # => 25
Здесь у нас есть закрытый метод _get_age и открытый метод show_age. show_age может использоваться нашим объектом (вне нашего класса), а _get_age может использоваться только внутри нашего определения класса (внутри метода show_age). Но опять же: условно.
Сводка по инкапсуляции
С помощью инкапсуляции мы можем гарантировать, что внутреннее представление объекта скрыто снаружи.
Наследование: поведение и характеристики
У некоторых объектов есть общие черты: их поведение и характеристики.
В объектно-ориентированном программировании классы могут наследовать общие характеристики (данные) и поведение (методы) от другого класса.
Давайте посмотрим на другой пример и реализуем его на Python.
Представьте себе машину. Количество колес, пассажировместимость и максимальная скорость - все это атрибуты автомобиля. Можно сказать, что класс ElectricCar наследует те же атрибуты от обычного класса Car.
class Car:
def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):
self.number_of_wheels = number_of_wheels
self.seating_capacity = seating_capacity
self.maximum_velocity = maximum_velocity
В нашем классе Car реализованы:
my_car = Car(4, 5, 250)
print(my_car.number_of_wheels)
print(my_car.seating_capacity)
print(my_car.maximum_velocity)
После запуска мы можем использовать все созданные переменные экземпляра. Отлично.
В Python мы применяем родительский (parent) класс к дочернему (child) классу в качестве параметра. Класс ElectricCar может быть унаследован от нашего класса Car.
class ElectricCar(Car):
def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):
Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity)
Вот так просто. Нам не нужно реализовывать какой-либо другой метод, потому что он уже есть в этом классе (унаследованный от класса Car). Докажем это:
my_electric_car = ElectricCar(4, 5, 250)
print(my_electric_car.number_of_wheels) # => 4
print(my_electric_car.seating_capacity) # => 5
print(my_electric_car.maximum_velocity) # => 250
Модули в Python
Что такое модуль? Считайте, что модуль - это то же самое, что и библиотека кода. Файл, содержащий набор функций, которые вы хотите включить в свое приложение.
Чтобы создать модуль, просто сохраните нужный код в файле с расширением .py:
Сохраните этот код в файле с именем mymodule.py
def greeting(name):
print("Hello, " + name)
Теперь мы можем использовать только что созданный модуль, используя оператор import:
import mymodule
mymodule.greeting("Jonathan") #Hello, Jonathan
Вы можете создать псевдоним при импорте модуля, используя ключевое слово as:
import mymodule as mx
Встроенные модули
В Python есть несколько встроенных модулей, которые вы можете импортировать в любое время.
import platform
x = platform.system()
print(x)
Существует встроенная функция для отображения всех имен функций (или имен переменных) в модуле. Это функция dir():
import platform
x = dir(platform)
print(x)
Получим такой вывод:
['DEV_NULL', '_UNIXCONFDIR', 'WIN32_CLIENT_RELEASES', 'WIN32_SERVER_RELEASES', '__builtins__', '__cached__', '__copyright__', '__doc__', '__file__', '__loader__', '__name__', '__package __', '__spec__', '__version__', '_default_architecture', '_dist_try_harder', '_follow_symlinks', '_ironpython26_sys_version_parser', '_ironpython_sys_version_parser', '_java_getprop', '_libc_search', '_linux_distribution', '_lsb_release_version', '_mac_ver_xml', '_node', '_norm_version', '_perse_release_file', '_platform', '_platform_cache', '_pypy_sys_version_parser', '_release_filename', '_release_version', '_supported_dists', '_sys_version', '_sys_version_cache', '_sys_version_parser', '_syscmd_file', '_syscmd_uname', '_syscmd_ver', '_uname_cache', '_ver_output', 'architecture', 'collections', 'dist', 'java_ver', 'libc_ver', 'linux_distribution', 'mac_ver', 'machine', 'node', 'os', 'platform', 'popen', 'processor', 'python_branch', 'python_build', 'python_compiler', 'python_implementation', 'python_revision', 'python_version', 'python_version_tuple', 're', 'release', 'subprocess', 'sys', 'system', 'system_aliases', 'uname', 'uname_result', 'version', 'warnings', 'win32_ver']
Работа с файлами в Python
Работа с файлами - важная часть любого приложения. Python имеет несколько функций для создания, чтения, обновления и удаления файлов.
Обработка файлов
Ключевой функцией для работы с файлами в Python является функция open().
Функция open() принимает два параметра - имя файла и режим.
Существует четыре различных метода (режима) открытия файла:
r - Чтение - значение по умолчанию. Открывает файл для чтения, возвращает ошибку, если файл не существует
a - Добавить - открывает файл для добавления, создает файл, если он не существует.
w - Запись - открывает файл для записи, создает файл, если он не существует.
x - Создать - создает указанный файл, возвращает ошибку, если файл существует.
Кроме того, вы можете указать, следует ли обрабатывать файл в двоичном или текстовом режиме.
t - Текст - значение по умолчанию. Текстовый режим
b - Двоичный - Двоичный режим (например, изображения)
Чтобы открыть файл для чтения, достаточно указать имя файла:
f = open("demofile.txt")
Код выше по сути такой же, как:
f = open("demofile.txt", "rt")
Поскольку r для чтения и t для текста являются значениями по умолчанию, вам не нужно их указывать.
Открыть файл на сервере
Предположим, у нас есть следующий файл, расположенный в той же папке, что и Python:
Чтобы открыть файл, используйте встроенную функцию open(). Функция open() возвращает файловый объект, у которого есть метод read() для чтения содержимого файла:
f = open("demofile.txt", "r")
print(f.read())
Если файл находится в другом месте, вам нужно будет указать путь к файлу, например:
f = open("D:\myfileswelcome.txt", "r")
print(f.read())
Вы можете вывести одну строку, используя метод readline():
f = open("demofile.txt", "r")
print(f.readline())
Рекомендуется всегда закрывать файл по окончании работы с ним. В некоторых случаях из-за буферизации изменения, внесенные в файл, могут не отображаться, пока вы не закроете файл.
f = open("demofile.txt", "r")
print(f.readline())
f.close()
Запись в существующий файл
Для записи в существующий файл необходимо добавить параметр к функции open():
a - Добавить - добавит в конец файла
w - Запись - перезапишет весь существующий контент
Откройте файл "demofile2.txt" и добавьте содержимое в файл:
f = open("demofile2.txt", "a")
f.write("Now the file has more content!")
f.close()
#откройте и прочитайте файл после добавления нового содержимого:
f = open("demofile2.txt", "r")
print(f.read())
Откройте файл "demofile3.txt" и перезапишите его содержимое:
f = open("demofile3.txt", "w")
f.write("Woops! I have deleted the content!")
f.close()
Создать новый файл
Чтобы создать новый файл в Python, используйте метод open() с одним из следующих параметров:
x - Создать - создаст файл, вернет ошибку, если файл существует
a - Добавить - создаст файл, если указанный файл не существует
w - Запись - создаст файл, если указанный файл не существует
Создайте файл с именем myfile.txt:
f = open ("myfile.txt", "x")
Результат: создан новый пустой файл!
Удалить файл
Чтобы удалить файл, вы должны импортировать модуль os и запустить его функцию os.remove():
import os
os.remove("demofile.txt")
Чтобы избежать появления ошибки, вы можете проверить, существует ли файл, прежде чем пытаться удалить его:
import os
if os.path.exists("demofile.txt"):
os.remove("demofile.txt")
else:
print("The file does not exist")
Удалить папку
Чтобы удалить всю папку, используйте метод os.rmdir():
import os
os.rmdir("myfolder")
Удалить можно только пустые папки.
Python PIP
Что такое PIP? PIP - это менеджер пакетов для пакетов Python или модулей, если хотите.
Примечание. Если у вас Python версии 3.4 или новее, PIP включен по умолчанию.
Что такое пакет? Пакет содержит все файлы, необходимые для модуля. Модули - это библиотеки кода Python, которые вы можете включить в свой проект.
Проверьте, установлен ли PIP
Перейдите в командной строке к каталогу скриптов Python и введите следующее:
C:UsersYour NameAppDataLocalProgramsPythonPython36-32Scripts>pip --version
Установить PIP
Если у вас не установлен PIP, вы можете загрузить и установить его с этой страницы: https://pypi.org/project/pip/
Скачать пакет
Загрузить пакет очень просто. Откройте интерфейс командной строки и скажите PIP загрузить нужный пакет. Перейдите в командной строке к каталогу сценариев Python и введите следующее:
C:UsersYour NameAppDataLocalProgramsPythonPython36-32Scripts>pip install camelcase
Мы скачали пакет camelcase
Использование пакета
После установки пакет готов к использованию. Импортируйте пакет camelcase в свой проект при помощи ключевого слова import.
import camelcase
c = camelcase.CamelCase()
txt = "hello world"
print(c.hump(txt))
Дополнительные пакеты можно найти на https://pypi.org/.
Удалить пакет
Используйте команду uninstall, чтобы удалить пакет:
C:UsersYour NameAppDataLocalProgramsPythonPython36-32Scripts>pip uninstall camelcase
Диспетчер пакетов PIP попросит вас подтвердить, что вы хотите удалить пакет:
Uninstalling camelcase-02.1:
Would remove:
c:usersYour Nameappdatalocalprogramspythonpython36-32libsite-packagescamecase-0.2-py3.6.egg-info
c:usersYour Nameappdatalocalprogramspythonpython36-32libsite-packagescamecase*
Proceed (y/n)?
Нажмите y, и пакет будет удален.
Список пакетов
Используйте команду list, чтобы вывести список всех пакетов, установленных в вашей системе:
C:UsersYour NameAppDataLocalProgramsPythonPython36-32Scripts>pip list
Package Version
-----------------------
camelcase 0.2
mysql-connector 2.1.6
pip 18.1
pymongo 3.6.1
setuptools 39.0.1
Вот и все!
Мы узнали много нового об основах Python:
Как установить Python и запустить свою первую программу
Как работают переменные Python
Как работают условные операторы Python
Как работает цикл Python (while и for)
Как работают функции Python
Как работают исключения Python
Как вводить данные в Python
Как работать с файлами в Python
Как работать с модулями в Python
Как пользоваться PIP
Как использовать списки: Коллекция и Массив
Коллекция ключей и значений словаря Dictionary
Как мы можем перебирать эти структуры данных
Объекты и классы
Атрибуты как данные объектов
Методы как поведение объектов
Использование геттеров и сеттеров Python и декоратора свойств
Инкапсуляция: скрытие информации
Наследование: поведение и характеристики
Также вам может быть интересно наше Руководство по изучению PHP с нуля с примерами