Первая программа на питоне: Первая программа в Visual Studio

Python | PyCharm

PyCharm

Последнее обновление: 06.11.2020

В прошлой теме было описано создание простейшего скрипта на языке Python. Для создания скрипта использовался текстовый редактор. В моем случае это был Notepad++. Но есть и другой способ создания программ, который представляет использование различных интегрированных сред разработки или IDE.

IDE предоставляют нам текстовый редактор для набора кода, но в отличие от стандартных текстовых редакторов, IDE также обеспечивает полноценную подсветку синтаксиса, автодополнение или интеллектуальную подсказку кода, возможность тут же выполнить созданный скрипт, а также многое другое.

Для Python можно использовать различные среды разработки, но одной из самых популярных из них является среда PyCharm, созданная компанией JetBrains. Эта среда динамично развивается, постоянно обновляется и доступна для наиболее распространенных операционных систем — Windows, MacOS, Linux.

Правда, она имеет одно важное ограничение.

В нашем случае воспользуемся бесплатным выпуском Community. Для этого перейдем на страницу загрузки и загрузим установочный файл PyCharm Community. После загрузки выполним его установку.

После завершения установки запустим программу. При первом запуске открывается начальное окно:

Создадим проект и для этого выберем пункт Create New Project.

Далее нам откроется окно для настройки проекта. В поле Location необходимо указать путь к проекту. В моем случае проект будет помещаться в папку HelloApp. Собственно название папки и будет названием проекта.

Следует отметить, что PyCharm позволяет разграничить настройки проектов. Так, по умолчанию выбрано поле New Environment Using, что позволяет установить версию интерпретатора для конкретного проекта.

В реальности для первого простейшего приложения на PyCharm не имеет значения, как будет установлен интерпертатор. Однако данном же случае оставим выбранный по умолчанию флажок New Environment Using и под ним в поле Base Interpreter укажем путь к файлу интерпретатора, установка которого рассматривалась в первой теме.

Последняя опция Create a main.py welcome script позволяет сразу при создании проекта добавить в него файл main.py.

И после установки всех путей нажмем на кнопку Create для создания проекта.

После этого будет создан пустой проект:

В центре среды будет открыт файл main.py с некоторым содержимым по умолчанию.

Теперь создадим простейшую программу. Для этого изменим код файла main.py следующим образом:

name = input("Введите ваше имя: ")
print("Привет,", name)

Для запуска скрипта нажмем на зеленую стрелку в панели инструментов программы:

Также для запуска можно перейти в меню Run и там нажать на подпункт Run ‘main’)

После этого внизу IDE отобразится окно вывода, где надо будет ввести имя и где после этого будет выведено приветствие:

Первая программа в Visual Studio

Python в Visual Studio

Последнее обновление: 13.05.2017

Одной из сред разработки, которая позволяет работать с Python, является Visual Studio. Преимуществом данной IDE по сравнению, скажем, с PyCharm, следует отметить прежде всего то, что в ее бесплатной редакции VS 2019 Community бесплатно доступны ряд функций и возможностей, которые в том же PyCharm доступны только в платной версии Professional Edition. Например, это веб-разработка, в том числе с помощью различных фреймворков.

Итак, загрузим установочный файл Visual Studio 2019 Community по ссылке https://visualstudio.microsoft.com/downloads/. После запуска установочного файла выберем среди устанавливаемых опций Python:

После установки Visual Studio запустим ее. В меню выберем пунт File (Файл) -> New (Создать) -> Project (Проект), и перед нами откроется окно создания нового проекта. В этом окне в левом древовидном меню мы можем перейти к языку Python:

Выбрав слева Python, в центральной части окна мы можем увидеть богатую палитру типов проектов, которые мы можем создавать для разработке на данном языке программирования. Это и веб-разработка, и машинное обучение, и проекты для работы с облаком, проекты настольных приложений и т.д. В данном же случае выберем в качестве типа проекта Python Application, то есть тип простых консольных приложений, и назовем новый проект HelloApp. Нажмем на кнопку OK, и Visual Studio создаст новый проект:

Справа в окне Solution Explorer (Обозреватель решений) можно увидеть структуру проекта. По умолчанию здесь мы можем увидеть следующие элементы:

• Python Environments: здесь можно увидеть все используемые среды, в частности, здесь можно найти сведения о компиляторе, который используется.

• References: в этот узел помещаются все внешние зависимости, которые используются текущим проектом

• Search Paths: этот узел позволяет указать пути поиска для модулей Python

• HelloApp.py: собственно файл Python с исходным кодом

По умолчанию в Visual Studio уже открыт файл HelloApp.py, но он пока пуст. Добавим в него следующую строку:

print("Hello Python from Visual Studio!")

И затем в панели инструментов нажмем на зеленую стрелочку для запуска:

В результате запуска отобразится консоль, которая выведет нужную строку:

Пишем 3 программы на Python за пару минут

Питон замечательный язык и сегодня мы с вами разработаем сразу три программы на его основе. Каждая программа будет полезной, так что сможете их использовать в дальнейшем.

#1 — Перемещение файлов

Первая программа будет трансфером для файлов. Её можно применять для автоматической сортировки файлов по папкам. К примеру, через Питон программу вы отслеживаете тип файла что попал в папку «Загрузки» и далее программа автоматически перемещает файл в папку музыка, фото, программы и так далее в зависимости от типа самого файла.

Для выполнения такой программы сперва подключите библиотеку «watchdog»:

pip install watchdog

Теперь можно прописать весь код, он показан ниже вместе с комментариями:

# Подключение всех модулей
from watchdog.observers import Observer
import os
import time
# FileSystemEventHandler - класс по отслеживанию изменений
from watchdog.events import FileSystemEventHandler


# Создаем класс наследник, через него может отслеживать изменения в папках
class Handler(FileSystemEventHandler):
	# При любых изменениях в папке, мы перемещаем файлы в ней
	def on_modified(self, event):
		# Перебираем все файлы в папке folder_track
		for filename in os. listdir(folder_track):
			# Проверяем расширенеи файла
			extension = filename.split(".")
			# Если это фото,
			if len(extension) > 1 and (extension[1].lower() == "jpg" or extension[1].lower() == "png" or extension[1].lower() == "svg"):
				# то перемещаем файл в папку с фото
				file = folder_track + "/" + filename
				new_path = folder_dest + "/Photos/" + filename
				os.rename(file, new_path)
			# Если файл видео, то в папку с видео
			# Такое же можно прописать и для других расширений файлов
			elif len(extension) > 1 and extension[1].lower() == "mp4":
				file = folder_track + "/" + filename
				new_path = folder_dest + "/Videos/" + filename
				os.rename(file, new_path)


# Папка что отслеживается
folder_track = '/ПОЛНЫЙ_ПУТЬ_К_ВАШЕЙ_ПАПКЕ'
# Папка куда перемещать будем
folder_dest = '/ПОЛНЫЙ_ПУТЬ_К_ВАШЕЙ_ПАПКЕ'

# Запуск всего на отслеживание
handle = Handler()
observer = Observer()
observer.schedule(handle, folder_track, recursive=True)
observer.start()

# Программа будет срабатывать каждые 10 милисекунд 
try:
	while(True):
		time.
  sleep(10)
except KeyboardInterrupt:
	observer.stop()

observer.join()

#2 — Создание сервера

Наша вторая программа будет представлять из себя полноценный сервер, созданный с использованием лишь Python, без дополнительных фреймворков, по типу Django или Flask.

Что очень круто, так это то, что такой сервер можно создать используя лишь встроенные модули Python. Для этого импортируем из http.server два необходимых классах. Далее указываем «localhost» и порт по которому будем подключаться и создаем объект на основе HTTPServer. После этого запускаем сервер на постоянное выполнение.

from http.server import HTTPServer, CGIHTTPRequestHandler
server_data = ("localhost", 8080)
server = HTTPServer(server_data, CGIHTTPRequestHandler)
server.serve_forever()

Также можно добавить файл «index.html» и прописать в нем всю разметку. На странице сервера будет отображаться содержимое из этого файла.

#3 — Управление браузером

Первое что необходимо сделать, так это установить «Selenium» через терминал: 

pip install selenium

Далее нужно скачать специальный веб драйвер, который обеспечит работу с вашим браузером.

В программе нужно прописать полный путь к драйверу и выполнить открытие страницы:

from selenium import webdriver
browser = webdriver.Chrome('/ПУТЬ_К_ПАПКЕ_С_ДРАЙВЕРОМ/chromedriver')
browser.get("https://itproger.com")

Видео на эту тему

Также вы можете просмотреть детальное видео по разработке всех этих трёх программ:

Дополнительный курс

На нашем сайте также есть углубленный курс по изучению языка Питон. В ходе огромной программы вы изучите не только язык Питон, но также научитесь создавать веб сайты за счёт веб технологий и фреймворка Джанго. За курс вы изучите массу нового и к концу программы будете уметь работать с языком Питон, создавать на нём полноценные ПК приложения на основе библиотеки Kivy, а также создавать веб сайты на основе библиотеки Джанго.

HOW-TO: Программа на Python, Часть 1

Наберём код в текстовом редакторе (например, в gedit). Потом мы разберёмся, что делает каждая строка и пойдём дальше.

Введите эти 4 строки:

#!/usr/bin/env python3
print ("Hello. I am a python program.")
name = input("What is your name?")
print ("Hello there, " + name + "!")

Это всё. Сохраните файл как hello.py в любом месте. Я предлагаю сохранить его в папке python_examples в домашнем каталоге. Этот пример показывает, как просто написать программу на Python. Для запуска программы нужно сделать её файл исполняемым. Для этого введите в терминале

chmod +x hello.py

в папке, в которой вы сохранили программу. Теперь запустите её.

greg@earth:~/python_examples$ ./hello.py
Hello. I am a python program.
What is your name? Ferd Burphel
Hello there, Ferd Burphel!
greg@earth:~/python_examples$

Вот и всё. Теперь давайте рассмотрим что делает каждая строка программы.

#!/usr/bin/env python3

Эта строка сообщает системе, что для запуска программы необходимо использовать интерпретатор Python версии 3.

print ("Hello. I am a python program.")

Эта строка просто печатает в окне терминала Hello. I am a python program.

name = input("What is your name? ")

Эта строка немного сложнее. В ней две части. Первая часть: name = и вторая часть: input(«What is your name? «). Сначала рассмотрим вторую часть. Команда input печатает вопрос в терминале («What is your name? ») и ожидает, пока пользователь (вы) не напечатает что-нибудь (и не нажмёт {Enter}). Теперь рассмотрим первую часть команды: name =. Она создаёт переменную под названием «name». Что такое переменная? Переменную можно представить себе в виде ящика. В ящике можно хранить вещи: ботинки, части компьютера, бумаги, всё, что туда влезет. Ящику всё равно, что лежит внутри — оно просто лежит там. В нашем примере он хранит то, что вы напечатаете. Я напечатал Ferd Burphel. В данной программе Python просто берёт введённое значение и сохраняет его в ящике «name», чтобы использовать в программе в дальнейшем.

print ("Hello there, " + name + "!")

В этой строке мы опять используем команду print для вывода текста на экран, в данном случае для вывода «Hello there, » и того, что хранится в переменной «name» и восклицательного знака в конце. В данной строке мы соединяем три куска текста: «Hello there», информацию в переменной «name» и восклицательный знак.

Теперь давайте быстро обсудим то, что мы сделали, и перейдём к работе над следующим примером. Откройте окно терминала и наберите:

python3

Вы должны увидеть что-то наподобие этого:

greg@earth:~/python_examples$ python3
Python 3.4.3 (default, Oct 14 2015, 20:28:29)
[GCC 4.8.4] on linux
Type "help", "copyright", "credits" or "license" for more information.

Теперь вы находитесь в командной оболочке python. Здесь вы можете выполнять действия, но для начала разберёмся с тем, что у нас получилось. Первым делом вы увидите версию интерпретатора python — у меня стоит 3.4.3. Затем вы увидите сообщение о том, что для получения справки необходимо набрать «help» в командной строке. Это я оставляю Вам в качестве домашнего задания. А пока наберите:

print (2+2)

и нажмите Enter. вы увидите:

print (2+2)
4

Обратите внимание, что мы набрали слово «print» в нижнем регистре. Что произойдёт, если набрать «Print (2+2)»? Интерпретатор ответит следующим образом:

Print (2+2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'Print' is not defined

Это произошло потому, что слово «print» является зарегистрированной командой, а слово «Print» не является таковой. Для Python регистр очень важен.

Теперь поработаем с переменными ещё раз. Введите:

var = 2+2

Вы увидите, что ничего не происходит, за исключением того, что Python отобразит приглашение «>>>». Всё нормально. Мы поручили Python создать переменную (ящик) под названием «var» и положить в неё результат сложения «2+2». Чтобы увидеть, что теперь находится в переменной «var», введите:

print (var)

и нажмите Enter.

print (var)
4

Теперь мы можем снова использовать переменную «var» как число 4. Например, так:

print (var * 2)
8

Если мы снова наберём «print (var)», то увидим следующее:

print (var)
4

Переменная «var» не изменилась. В ней осталась храниться сумма 2+2, то есть 4.

Конечно, данная программа очень простая и написана для этого урока для начинающих. В последующих уроках программы станут более сложными. А сейчас давайте рассмотрим ещё несколько примеров с переменными.

Введите в интерпретаторе:

strng = 'The time has come for all good men to come to the aid of the party!'
print (strng)
The time has come for all good men to come to the aid of the party!

Вы создали переменную под названием «strng», которая содержит значение «The time has come for all good men to come to the aid of the party!». С этого момента (пока мы работаем с этим экземпляром интерпретатора) переменная «strng» будет содержать то же значение, пока мы её не изменим. Что будет, если мы попробуем умножить эту переменную на 4?

print (strng * 2)
The time has come for all good men to come to the aid of the party!The time has come for all good men to come to the aid of the party!

Произошло не совсем то, что вы ожидали. Python напечатал значение переменной «strng» 2 раза. Почему? Интерпретатор знал, что переменная «strng» — это строка, а не число. Невозможно производить математические операции над строками.

Если бы у нас была переменная под названием «s», которая содержала бы значение «4» как показано ниже:

s = '4'
print (s)
4

Кажется, что переменная «s» содержит число 4, но это не так. Она содержит текстовое значение «4». И если мы наберем «print (s * 4)», то получим…

print (s*4)
4444

Снова интерпретатор знает, что переменная «s» — это строка, а не число. Он знает это, потому что мы взяли число 4 в одинарные кавычки, что означает, что оно является строкой. Мы можем проверить это, набрав «print type(s)», чтобы увидеть, какой тип система присвоила данной переменной.

print (type(s))
<class 'str'>

Подтверждено. Переменная имеет тип «строка». Если мы захотим использовать её в качестве числа, то мы напечатаем следующее:

print (int(s) * 4)
16

Строка «s», содержащая значение «4», преобразована в число и умножена на 4, что равно 16.

Теперь у Вас есть основные знания о командах print и input, создании переменных и разнице между строками и числами.

Пойдём дальше. В интерпретаторе Python введите quit() для выхода в командную строку.

Теперь давайте рассмотрим пример программирования цикла. Запустите текстовый редактор и наберите следующую программу:

#!/usr/bin/env python3
for cntr in range(0,10):
    print (cntr)

Не забудьте поставить символ табуляции перед строкой «print (cntr)». Это важно. В Python для указания на блоки кода используются не круглые «(» и фигурные «{» скобки как в других языках программирования, а отступы.

Сохраните программу под именем «for_loop. py». До её запуска давайте поговорим о том, что такое цикл «for».

Цикл — это код, выполняющий определённую инструкцию или набор инструкций определённое число раз. В нашей программе мы выполним цикл 10 раз, печатая значение переменной «cntr». Вот перевод команды на русский язык «присвоить переменной «cntr» значение 0, выполнить печать значения переменной «cntr», прибавить к переменной «cntr» 1 и повторить это 10 раз». Выглядит довольно просто. Часть кода «range(0,10)» говорит: начать с 0, повторять, пока значение переменной «cntr» не будет равно 10, и выйти.

Теперь, как раньше, выполните команду

chmod +x for_loop.py

и запустите программу:

./for_loop.py

в терминале.

greg@earth:~/python_examples$ ./for_loop.py
0
1
2
3
4
5
6
7
8
9
greg@earth:~/python_examples$

Кажется, программа работает, но почему она считает только до 9 и останавливается? Посмотрите её вывод. Напечатано 10 цифр: от 0 до 9. Это то, что мы запрограммировали: напечатать значение переменной «cntr» 10 раз, каждый раз добавляя единицу к переменной, и выйти, когда её значение будет равно 10.

Теперь вы видите, что программирование может быть как простым, так и сложным. Вы должны точно знать, что вы хотите от программы. Если вы измените команду «range» на «range(1,10)», она начнёт считать с 1, но остановится на 9, так как при достижении верхнего порога (10) цикл прерывается. Чтобы заставить программу печатать «1,2,3,4,5,6,7,8,9,10», надо заменить команду на «range(1,11)», так как цикл «for» прерывается при достижении второго числа в команде «range».

Обратите также внимание на синтаксис цикла. Двоеточие в команде «for переменная in range(начальное значение,конечное значение):» означает начало блока кода, который должен быть смещен вправо. Вы должны использовать двоеточие «:» и смещать код вправо до конца блока — это очень важно.

Если мы изменим нашу программу таким образом:

#!/usr/bin/env python
for cntr in range(1,11):
    print (cntr)
print ("All Done")

Мы увидим на экране следующее:

greg@earth:~/python_examples$ . /for_loop.py
1
2
3
4
5
6
7
8
9
10
All Done
greg@earth:~/python_examples$

Убедитесь в том, что вы соблюдаете уровни вложенности. Запомните: от них зависит выделение блоков. В следующем уроке мы подробнее рассмотрим уровни вложенности.

На сегодня хватит. В следующем уроке мы продолжим изучать команды языка Python. А пока, вам стоит попробовать специализированные редакторы для Python, например, Dr. Python или SPE (Stani’s Python Editor). Обе программы вы найдёте в Synaptic.

Язык Python. Первое знакомство. Часть 1. Для учеников 4-5 классов

Язык Python. Первое знакомство.

О языке Python

Python — современный язык программирования, работающий на всех распространенных операционных системах для настольных компьютеров. Язык программирования Питон разрабатывается чуть более 20 лет. В настоящее время активно используется две версии языка — более старая версия 2 и современная версия. Версия 2 более не развивается, но до сих пор еще используется, поскольку очень много программного обеспечения и библиотек разработано именно для версии 2. Между версиями есть существенная несовместимость, в том числе в синтаксисе команд ввода-вывода (программа на языке Python 2-й версии может не работать в 3-й версии и наоборот), но в целом они очень похожи. Мы будет использовать именно версию 3, как более современную и совершенную.

Python — современный универсальный интерпретируемый язык программирования. Его достоинства:

1. Кроссплатформенность и бесплатность.

2. Простой синтаксис и богатые возможности позволяют записывать программы очень кратко, но в то же время понятно.

3. По простоте освоения язык сравним с бейсиком, но куда более богат возможностями и значительно более современен.

4. Богатая стандартная библиотека, возможность разработки промышленных приложений (для работы с сетью, GUI, базами данных и т.д.)

Большинство школьных олимпиад по информатике поддерживают язык Python. C 2015 года в текстах задач ЕГЭ примеры приводятся также и на языке Python. 

Практика показывает, что задания ЕГЭ по информатике, в которых требуется написать программу, существенно проще решать с использованием языка Python, чем классических языков Бейсик, Паскаль, C/C++.

РЕКОМЕНДУЕМАЯ ЛИТЕРАТУРА

• Марк Лутц. Изучаем Python. 4-е издание – очень толстый и подробный учебник.

• Марк Саммерфилд. Программирование на Python 3 – менее толстый, не столь подробный учебник

Python — стабильный и достаточно распространенный язык программирования. Он используется в некоторых проектах и в различных качествах: как основной язык программирования или для создания расширений и интеграции приложений, а также для написания скриптов. На Python реализовано некоторое количество проектов, также он активно используется для создания прототипов будущих программ.

Многие компании активно используют Python для написания своих продуктов или некоторых их частей. Среди крупнейших можно выделить:

Кроме того, Python активно используется в различных проектах:

• CherryPy — среда для разработки веб-приложений

• Django — среда для разработки веб-приложений

• Google App Engine — Google-хостинг

• Matplotlib — визуализация научных данных в стиле MATLAB

• BitTorrent — первый клиент-сервер для популярного протокола файлообменных сетей.

• Dropbox — приложение для прозрачной синхронизации данных на множестве компьютеров.

Следующие проекты используют Python для написания скриптов:

• Википедия использует Python для написания ботов

• OpenOffice.org — набор офисных программ, альтернатива Microsoft Office

• Vim — текстовый редактор

Python также активно используется разработчиками компьютерных игр (Eve Online, Civilization IV и др. )

Синтаксис языка Python, как и сам язык, очень прост. Он не содержит сложных неинтуитивных конструкций, поэтому достаточно прост в изучении.

Основные приципы синтаксиса языка Python

1. Конец строки является концом инструкции (точка с запятой не требуется).

ПРИМЕР

a = 5 
b = 3 
print(a + b)

2. Вложенные инструкции объединяются в блоки по величине отступов. Отступ может быть любым, главное, чтобы в пределах одного вложенного блока отступ был одинаков. 

ПРИМЕР

if a == 5: 
        print(‘yes’)
        a += 1

3. Вложенные инструкции в Python записываются в соответствии с одним и тем же шаблоном, когда основная инструкция завершается двоеточием, вслед за которым располагается вложенный блок кода, обычно с отступом под строкой основной инструкции.

Ввод данных

Для считывания строки со стандартного ввода используется функция input(), которая считывает строку с клавиатуры и возвращает значение считанной строки, которое сразу же можно присвоить переменным:

a = input()
b = input()

Правда, функция input возвращает текстовую строку. Если нужно сделать так, чтобы переменные имели целочисленные значения, то сразу же после считывания выполним преобразование типов при помощи фунцкии int, и запишем новые значения в переменные a и b:

a = int(a)
b = int(b)

Можно объединить считывание строк и преобразование типов, если вызывать функцию int для того значения, которое вернет функция input():

a = int(input())
b = int(input())

Сложнее считать значения переменных, если они записаны в отдельной строке. Здесь нужно применить к считанной строке метод split(), который разделяет строку на части по одному или двум пробелам. Затем результат выполнения этой функции присвоим кортежу из двух или нескольких чисел. Например, если в строке вводятся два числа через пробел, то считать их можно так:

a, b = input().split()
a = int(a)
b = int(b)

Аналогично, три переменные можно считать, записав слева от оператора присваивания кортеж из трех переменных:

a, b, c = input(). split()

Можно также сразу же преобразовать считанные значения в числовой тип (например, int), если воспользоваться функцией map, которая применяет к каждому элементу списка заданную функцию (для преобразования к типу int нужно, соответственно, задать функцию int для применения к каждому элементу). Для начала можно просто запомнить эту конструкцию:

a, b, c = map(int, input().split())

Вывод данных

Для вывода данных используется функция print может выводить не только значения переменных, но и значения любых выражений. Например, допустима запись print(2 + 2 ** 2). Также при помощи функции print можно выводить значение не одного, а нескольких выражений, для этого нужно перечислить их через запятую:

a = 1 
b = 2 
print(a, ‘+’, b, ‘=’, a + b)

В данном случае будет напечатан текст 1 + 2 = 3: сначала выводится значение переменной a, затем строка из знака “+”, затем значение переменной b, затем строка из знака “=”, наконец, значение суммы a + b.

Обратите внимание, выводимые значение разделяются одним пробелом. Но такое поведение можно изменить: можно разделять выводимые значения двумя пробелами, любым другим символом, любой другой строкой, выводить их в отдельных строках или не разделять никак. Для этого нужно функции print передать специальный именованный параметр, называемый sep, равный строке, используемый в качестве разделителя (sep — аббревиатура от слова separator, т.е. разделитель). По умолчанию параметр sep равен строке из одного пробела и между значениями выводится пробел. Чтобы использовать в качестве разделителя, например, символ двоеточия нужно передать параметр sep, равный строке ‘:’:

print(a, b, c, sep = ‘:’)

Аналогично, для того, чтобы совсем убрать разделитель при выводе нужно передать параметр sep, равный пустой строке:

print(a, ‘+’, b, ‘=’, a + b, sep = »)

Для того, чтобы значения выводились с новой строке, нужно в качестве параметра sep передать строку, состоящую из специального символа новой строки, которая задается так:

print(a, b, sep = ‘\n’)

Символ обратного слэша в текстовых строках является указанием на обозначение специального символа, в зависимости от того, какой символ записан после него. Наиболее часто употребляется символ новой строки ‘\n’. А для того, чтобы вставить в строку сам символ обратного слэша, нужно повторить его два раза: ‘\\’.

Вторым полезным именованным параметром функции print является параметр end, который указывает на то, что выводится после вывода всех значений, перечисленных в функции print. По умолчанию параметр end равен ‘\n’, то есть следующий вывод будет происходить с новой строки. Этот параметр также можно исправить, например, для того, чтобы убрать все дополнительные выводимые символы можно вызывать функцию print так:

print(a, b, c, sep = », end = »)

Задача 1. Что делают функции?

Установите соответствие между функцией и тем, что она делает.

Начало формы

int()

str()

input()

print()

Конец формы

Превращает в число то, что внутри скобок

Превращает в строку то, что внутри скобок

Считывает данные с клавиатуры

Выводит что-то на экран

Задача 2. Списки – комоды

Чтобы хранить много вещей, можно использовать комод. В языке python роль комода играют списки. Например, программа

Family = [‘мама’, ‘папа’, ‘бабушка’, ‘дедушка’, ‘я’]

создаст «комод» Family с пятью ящиками. В ящике №0 хранится строка ‘мама’, в ящике №1 хранится строка ‘папа’, и т.д. Нумерация ящиков начинается с 0.

Обратиться к содержимому ящика можно по номеру, например, программа 

Family = [‘мама’, ‘папа’, ‘бабушка’, ‘дедушка’, ‘я’]
print(Family[0])

напечатает слово мама.

Что напечатает такая программа:

Family = [‘мама’, ‘папа’, ‘бабушка’, ‘дедушка’, ‘я’]
print(Family[3])

Подсказка 1 из 2

Напишите программу и запустите.

Подсказка 2 из 2

Строка выводится без кавычек.

Правильный ответ: дедушка

Задача 3. Многократный вывод

Какое число нужно написать вместо знака вопроса в такой программе

for i in range(1, ?):
    print(‘Hello!’) 

чтобы строка Hello! была напечатана 17 раз?

Решение задачи

range(1, 11) создает последовательность чисел 1, 2, …, 10 (то есть, от 1 до 11, не включая при этом 11). Следовательно, вместо знака вопроса нужно записать число на 1 большее нужного количества итераций, то есть, 18. 

Задача 4. Сложение строк

В языке python строковые переменные можно складывать, результатом такого сложения будет тоже строка, состоящая из двух слагаемых, записанных друг за другом. Например, напишем такую программу:

a = ‘Fox’
b = ‘Ford’
c = a + b
print(c) 

В результате ее работы в переменной c будет храниться строка ‘FoxFord’ (в результат сначала записывается первая строка a, а потом к ней приписывается вторая строка b).

Раз можно складывать, то можно и умножать:

a = ‘Fox’
c = a * 3
print(c) 

В результате работы такой программы в переменной с будет храниться строка ‘FoxFoxFox’ (умножить на 3 означает сложить три раза).

Определите, что выведет такая программа:

a = ‘Fox’
a = a * 2
b = ‘Ford’
b = b * 3
c = b + a
print(c)

Решение задачи

В результате работы программы

a = ‘Fox’
a = a * 2 

в переменной a будет храниться строка ‘FoxFox’.

В результате работы программы

b = ‘Ford’
b = b * 3 

в переменной b будет храниться строка ‘FordFordFord’.

c = b + a

означает, что сначала записывается строка b, а затем к ней (без пробела!) приписывается строка a.

Кавычки при выводе не печатаются, поэтому будет напечатано FordFordFordFoxFox.

Задача 5. Превращения

В языке python строковые переменные типа a = ‘123’ можно превращать в числовые, и наоборот, числа можно превращать в строки. Для этого используются функции int() и str(). Например.

a = 123 # это число
a = str(a) # уже строка
a = int(‘321’) # опять число, но другое. 

Определите, что напечатает такая программа:

a = ‘111’
a = int(a)
a = a + 5
a = str(a)
a = a + ‘7’
print(a)

Решение задачи

Можно просто запустить программу и посмотреть. Но можно понять ответ и так:

a = ‘111’ # сейчас это строка

a = int(a) # теперь это число 111

a = a + 5 # теперь это число 116

a = str(a) # теперь это строка

a = a + ‘7’ # приписали к строке еще символ, получили строку 1167

print(a) # будет напечатано 1167

1. Программа, угадывающая число

input(‘Загадай число! Нажми enter, как будешь готов.’)
input(‘Вычти из своего числа 3. Нажми enter, как будешь готов.’)
input(‘Результат умножь на 2. Нажми enter, как будешь готов.’)
input(‘К полученному числу прибавь 7. Нажми enter, как будешь готов.’)
ans = input(‘А теперь скажи, что у тебя получилось.’)
print(‘Ты задумал число’, (int(ans) — 7) // 2 + 3)

2. Программа, отгадывающая дату рождения

D = {1: ‘января’, 2:’февраля’, 3:’марта’, 4:’апреля’, 5:’мая’, 6:’июня’, 7:’июля’, 8:’августа’, 9:’сентября’, 10:’октября’, 11:’ноября’, 12:’декабря’}
input(‘Привет! Я отгадаю дату твоего рождения. Нажми enter, как будешь готов.’)
input(‘Умножь день, в который ты родился, на 2. Если ты родился 15 февраля, умножай на 2 число 15. Нажми enter, как будешь готов. ‘)
input(‘К результату прибавь 5. Нажми enter, как будешь готов.’)
input(‘Полученное число умножь на 50. Нажми enter, как будешь готов.’)
input(‘К результату прибавь номер месяца, в который ты родился (число от 1 до 12). Нажми enter, как будешь готов.’)
ans = int(input(‘А теперь скажи, что у тебя получилось.’))
ans = ans — 250
print(‘Ты родился’, ans//100, D[ans % 100])

3. Программа, загадывающая число.

from random import*
print(‘Я загадал число от 1 до 20. Попробуй угадать!’)
secret = randint(1, 20)
ans = int(input())
while ans != secret:
    if ans > secret:
        print(‘Слишком большое число!’)
    else:
        print(‘Маловато…’)
    ans = int(input(‘Попробуй еще раз!\n’))
print(‘Молодец, угадал!’)    

4. Генератор паролей

from random import *
import string
adjs = [‘green’, ‘blue’, ‘yellow’, ‘good’, ‘cold’]
nouns = [‘ball’, ‘panda’, ‘dinosaur’, ‘cat’, ‘dog’]

while True:
    adj = choice(adjs)
    noun = choice(nouns)
    number = randint(1, 20)
    special = choice(string.punctuation)

    password = adj + noun + str(number) + special

    print(‘Новый пароль:’, password)   

    ans = input(‘Нужен другой пароль? да/нет\n’)
    if ans == ‘нет‘:
        break

Задача 6. Найди ошибку

Перед вами три фрагмента кода. Какие из них написан

Web-разработка • Python и Flask

Программа на Python может запускать другие программы с помощью функции Popen() (от process open) встроенного модуля subprocess. В качестве аргумента функция принимает имя программы, которую нужно запустить:

>>> import subprocess
>>> subprocess.Popen('C:\\Windows\\System32\\calc.exe')
<subprocess.Popen object at 0x0000020B18386438>

Возвращаемое значение представляет собой объект Popen, имеющий два полезных метода: poll() и wait().

Метод poll() возвращает значение None, если в момент его вызова процесс все еще выполняется. Если же процесс к этому моменту завершен, то он возвращает код завершения процесса. Код заверешения служит индикатором того, завершился ли процесс без ошибок (код равен нулю) или же его завершение было вызвано ошибкой (ненулевой код).

Метод wait() ожидает завершения запущенного процесса, прежде чем продолжить выполнение основной программы. Возвращаемым значением метода является целочисленный код завершения процесса.

>>> notepad = subprocess.Popen('C:\\Windows\\System32\\notepad.exe')
>>> notepad.poll() == None
True
>>> notepad.poll() == None
False
>>> notepad.wait()
0
>>> notepad.poll()
0

Сначала мы открываем процесс блокнота, затем проверяем, возвращает ли метод poll() значение None. Это означает, что процесс все еще выполняется. После этого закрываем блокнот и еще раз проверяем, возвращает ли метод poll() значение None. Теперь оба метода, wait() и poll() возвращают нулевое значение, что указывает на завершение программы notepad.exe без ошибок.

Передача аргументов командной строки

Процессам, создаваемым с помощью функции Popen(), можно передвать аргументы командной строки. Для этого функции Popen() надо передать список в качестве единственного аргумента. Первой строкой в этом списке должно быть имя исполняемого файла программы, которую надо запустить. Все последующие строки — это аргументы командной строки, которые будут переданы программе при запуске.

>>> subprocess.Popen(['C:\\Windows\\System32\\notepad.exe', 'C:\\example\\readme.txt'])
<subprocess.Popen object at 0x0000020B18386630>

Здесь мы не только запускаем приложение notepad.exe, но и открываем файл readme.txt.

Открытие файлов программ по умолчанию

Двойной клик на иконке файла с расширением .txt позволяет автоматически запустить приложение, ассоциированное с этим расширением. Функция Popen() также может открывать файлы подобным образом:

>>> subprocess.Popen(('start', 'C:\\example\\readme.txt'), shell = True)
<subprocess.Popen object at 0x0000020B183EDE10>

В каждой операционной системе есть программа, выполняющая те же функции, что и двойной клик на иконке файла. В Windows это программа start, в Ubuntu Linux — программа see.

Именованный аргумент shell = True нужен только для ОС Windows.

# Таймер обратного отсчета

import time, subprocess

wait = 10
while wait > 0:
    print(wait, end='')
    time.sleep(1)
    wait = wait - 1

# Воспроизведение звукового файла по завершении обратного отсчета
subprocess.Popen(['start', 'C:\\example\alarm.wav'], shell = True)

Поиск: Python • Web-разработка • Модуль • Процесс

Ваша первая программа на Python — погрузитесь в Python 3

Вы здесь: Домой ‣ Погрузитесь в Python 3 ‣

Уровень сложности: ♦ ♢♢♢♢

❝ Не ​​хороните свою ношу в святом молчании. У тебя проблема? Отлично. Радуйтесь, ныряйте и исследуйте. №
— Дост. Хенепола Гунаратана

Дайвинг в

гласит, что я должен утомить вас фундаментальными строительными блоками программирования, чтобы мы могли медленно работать над созданием чего-то полезного.Давайте все это пропустим. Вот полная работающая программа на Python. Возможно, для вас это не имеет никакого смысла. Не беспокойтесь об этом, потому что вы будете разбирать это строка за строкой. Но сначала прочтите его и посмотрите, что вы можете с этим поделать.

[загрузить humanize.py ]

  СУФФИКСОВ = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'],
            1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}

def приблизительный_размер (размер, a_kilobyte_is_1024_bytes = True):
    '' 'Преобразование размера файла в удобочитаемую форму.Аргументы ключевого слова:
    size - размер файла в байтах
    a_kilobyte_is_1024_bytes - если True (по умолчанию), использовать кратные 1024
                                если False, используйте число, кратное 1000

    Возвращает: строка

    '' '
    если размер <0:
        поднять ValueError ('число должно быть неотрицательным')

    multiple = 1024, если a_kilobyte_is_1024_bytes иначе 1000
    для суффикса в SUFFIXES [несколько]:
        size / = несколько
        если размер <несколько:
            вернуть '{0: .1f} {1}'. формат (размер, суффикс)

    поднять ValueError ('слишком большое число')

если __name__ == '__main__':
    print (приблизительный_размер (1000000000000; Ложь))
    печать (приблизительный_размер (1000000000000))  

Теперь давайте запустим эту программу из командной строки.В Windows это будет выглядеть примерно так:

  c: \ home \ diveintopython3 \ examples>   c: \ python31 \ python.exe humanize.py 
  1,0 ТБ
931,3 ГиБ  

В Mac OS X или Linux это будет выглядеть примерно так:

  you @ localhost: ~ / diveintopython3 / examples $   python3 humanize.py 
  1,0 ТБ
931,3 ГиБ  

Что только что произошло? Вы выполнили свою первую программу на Python. Вы вызвали интерпретатор Python в командной строке и передали имя сценария, который должен выполнить Python.Сценарий определяет единственную функцию, функцию corrective_size () , которая принимает точный размер файла в байтах и ​​вычисляет «красивый» (но приблизительный) размер. (Вы, вероятно, видели это в проводнике Windows, или в Mac OS X Finder, или в Nautilus, или Dolphin, или в Thunar в Linux. Если вы отобразите папку с документами в виде списка из нескольких столбцов, отобразится таблица со значком документа , имя документа, размер, тип, дату последнего изменения и т. д. Если папка содержит файл размером 1093 байта с именем TODO , ваш файловый менеджер не будет отображать TODO 1093 байта ; он скажет что-то вроде TODO 1 KB вместо этого.Это то, что делает функция приближаться к размеру () .)

Посмотрите на нижнюю часть скрипта, и вы увидите два вызова print (приблизительный_размер ( аргументов )) . Это вызовы функций - сначала вызывается функция приближаться к размеру () и передается ряд аргументов, затем берется возвращаемое значение и передается прямо в функцию print () . Функция print () является встроенной; вы никогда не увидите явного объявления этого.Вы можете просто использовать его в любое время и в любом месте. (Есть много встроенных функций, и намного больше функций, которые разделены на модули . Терпение, кузнечик.)

Так почему же выполнение сценария в командной строке каждый раз дает один и тот же результат? Мы к этому еще вернемся. Во-первых, давайте посмотрим на функцию apply_size () .

⁂

Объявление функций

Python имеет функции, как и большинство других языков, но у него нет отдельных файлов заголовков, таких как C ++ или интерфейс , реализация /, разделы , такие как Pascal.Когда вам нужна функция, просто объявите ее, например:

  def приблизительный_размер (размер, a_kilobyte_is_1024_bytes = True):  

Ключевое слово def запускает объявление функции, за ним следует имя функции, за которым следуют аргументы в круглых скобках. Несколько аргументов разделяются запятыми.

Также обратите внимание, что функция не определяет возвращаемый тип данных. Функции Python не указывают тип возвращаемого значения; они даже не указывают, возвращают ли они значение.(Фактически, каждая функция Python возвращает значение; если функция когда-либо выполняет оператор return , она вернет это значение, в противном случае она вернет None , нулевое значение Python.)

☞На некоторых языках функции (возвращающие значение) начинаются с , функция , а подпрограммы (которые не возвращают значение) начинаются с sub . В Python нет подпрограмм. Все является функцией, все функции возвращают значение (даже если это None ), и все функции начинаются с def .

Функция приближаться к размеру () принимает два аргумента - size и a_kilobyte_is_1024_bytes - но ни один из аргументов не определяет тип данных. В Python переменные никогда не вводятся явно. Python определяет, к какому типу относится переменная, и отслеживает ее внутри.

☞В Java и других языках со статической типизацией необходимо указать тип данных возвращаемого значения функции и каждого аргумента функции. В Python вы никогда не указываете явно тип данных для чего-либо.В зависимости от того, какое значение вы назначаете, Python отслеживает тип данных внутри себя.

Необязательные и именованные аргументы

Python позволяет аргументам функции иметь значения по умолчанию; если функция вызывается без аргумента, аргумент получает значение по умолчанию. Кроме того, аргументы можно указывать в любом порядке с помощью именованных аргументов.

Давайте еще раз посмотрим на это объявление функции приближенно_size () :

  def приблизительный_размер (размер, a_kilobyte_is_1024_bytes = True):  

Второй аргумент, a_kilobyte_is_1024_bytes , указывает значение по умолчанию True .Это означает, что аргумент необязательный ; вы можете вызвать функцию без него, и Python будет действовать так, как если бы вы вызвали ее с True в качестве второго параметра.

Теперь посмотрим на нижнюю часть скрипта:

  если __name__ == '__main__':
    print (приблизительный_размер (1000000000000, Ложь)) ①
    печать (приблизительный_размер (1000000000000)) ②  

1. Это вызывает функцию приближаться к размеру () с двумя аргументами. В функции приближаться к размеру () , a_kilobyte_is_1024_bytes будет False , поскольку вы явно передали False в качестве второго аргумента.
2. Это вызывает функцию приближаться к размеру () только с одним аргументом. Но это нормально, потому что второй аргумент не обязателен! Поскольку вызывающий не указывает, второй аргумент по умолчанию равен True , как определено в объявлении функции.

Вы также можете передавать значения в функцию по имени.

  >>>   из человеческого размера импорт приблизительно 
  >>>   приблизительный_размер (4000, a_kilobyte_is_1024_bytes = False)  ①
  '4.0 КБ '
  >>>   приблизительный_размер (размер = 4000, a_kilobyte_is_1024_bytes = False)  ②
  '4.0 КБ' 
  >>>   приблизительный_размер (a_kilobyte_is_1024_bytes = False, size = 4000)  ③
  '4,0 КБ' 
  >>>   приблизительный_размер (a_kilobyte_is_1024_bytes = False, 4000)  ④
  Файл "", строка 1
SyntaxError: аргумент без ключевого слова после аргумента ключевого слова 
  >>>   приблизительный_размер (размер = 4000, False)  ⑤
  Файл "", строка 1
SyntaxError: аргумент без ключевого слова после аргумента ключевого слова  

1. Это вызывает функцию приближаться к размеру () с 4000 для первого аргумента ( размер ) и False для аргумента с именем a_kilobyte_is_1024_bytes .(Это второй аргумент, но он не имеет значения, как вы увидите через минуту.)
2. Это вызывает функцию приближаться к размеру () с 4000 для аргумента с именем size и False для аргумента с именем a_kilobyte_is_1024_bytes . (Эти именованные аргументы оказываются в том же порядке, что и аргументы, перечисленные в объявлении функции, но это тоже не имеет значения.)
3. Это вызывает функцию приближаться к размеру () с False для аргумента с именем a_kilobyte_is_1024_bytes и 4000 для аргумента с именем размер .(Видите? Я сказал вам, что порядок не имеет значения.)
4. Этот вызов завершается ошибкой, потому что у вас есть именованный аргумент, за которым следует безымянный (позиционный) аргумент, и это никогда не работает. При чтении списка аргументов слева направо, если у вас есть единственный именованный аргумент, остальные аргументы также должны быть названы.
5. Этот вызов также не выполняется по той же причине, что и предыдущий. Это удивительно? В конце концов, вы передали 4000 в качестве аргумента с именем size , затем «очевидно», что значение False предназначалось для аргумента a_kilobyte_is_1024_bytes .Но Python так не работает. Как только у вас есть именованный аргумент, все аргументы справа от него тоже должны быть именованными аргументами.

⁂

Запись читаемого кода

Я не буду утомлять вас длинной речью о том, как важно документировать ваш код. Просто знайте, что код пишется один раз, но читается много раз, и самая важная аудитория для вашего кода - это вы сами через шесть месяцев после его написания (, т.е. после того, как вы все забыли, но вам нужно что-то исправить).Python позволяет легко писать читаемый код, поэтому воспользуйтесь им. Вы меня поблагодарите через полгода.

Строки документации

Вы можете задокументировать функцию Python, указав ей строку документации ( docstring для краткости). В этой программе функция приближенно_size () имеет строку документации :

  def приблизительный_размер (размер, a_kilobyte_is_1024_bytes = True):
    '' 'Преобразование размера файла в удобочитаемую форму.

    Аргументы ключевого слова:
    size - размер файла в байтах
    a_kilobyte_is_1024_bytes - если True (по умолчанию), использовать кратные 1024
                                если False, используйте число, кратное 1000

    Возвращает: строка

    ''  

Тройные кавычки обозначают многострочную строку. Все, что находится между начальными и конечными кавычками, является частью одной строки, включая символы возврата каретки, начальные пробелы и другие символы кавычек. Вы можете использовать их где угодно, но чаще всего они используются при определении строки документации .

☞Тройные кавычки - это также простой способ определить строку с одинарными и двойными кавычками, например qq /.../ в Perl 5.

Все, что находится в тройных кавычках, - это строка документации функции , которая документирует, что функция делает.Строка документации , если она существует, должна быть первой, что определено в функции (то есть на следующей строке после объявления функции). Технически вам не нужно давать вашей функции строку документации , но вы всегда должны это делать. Я знаю, что вы слышали это на каждом занятии по программированию, которое когда-либо посещали, но Python дает вам дополнительный стимул: строка документации доступна во время выполнения как атрибут функции.

☞Многие IDE Python используют строку документации для предоставления контекстно-зависимой документации, так что при вводе имени функции ее строка документа отображается как всплывающая подсказка.Это может быть невероятно полезно, но настолько хорошо, насколько хороша строка документации , которую вы напишете.

⁂

Импорт Путь поиска

Прежде чем это пойдет дальше, я хочу вкратце упомянуть путь поиска библиотеки. Когда вы пытаетесь импортировать модуль, Python смотрит в нескольких местах. В частности, он просматривает все каталоги, определенные в sys.path . Это просто список, и вы можете легко просмотреть или изменить его стандартными методами списка.(Вы узнаете больше о списках в Native Datatypes.)

  >>>   импортная система  ①
  >>>   sys.path  ②
  [',
 '/usr/lib/python31.zip',
 '/usr/lib/python3.1',
 '/usr/lib/python3.1/plat-linux2@EXTRAMACHDEPPATH@',
 '/usr/lib/python3.1/lib-dynload',
 '/usr/lib/python3.1/dist-packages',
 '/usr/local/lib/python3.1/dist-packages'] 
  >>>   систем  ③
  <модуль 'sys' (встроенный)> 
  >>>   систем.path.insert (0, '/ home / mark / diveintopython3 / examples')  ④
  >>>   sys.path  ⑤
  ['/ home / mark / diveintopython3 / examples',
 '',
 '/usr/lib/python31.zip',
 '/usr/lib/python3.1',
 '/usr/lib/python3.1/plat-linux2@EXTRAMACHDEPPATH@',
 '/usr/lib/python3.1/lib-dynload',
 '/usr/lib/python3.1/dist-packages',
 '/usr/local/lib/python3.1/dist-packages']  

1. Импорт модуля sys делает доступными все его функции и атрибуты.
2. sys.path - это список имен каталогов, составляющих текущий путь поиска. (Ваш будет выглядеть по-разному, в зависимости от вашей операционной системы, какой версии Python вы используете и где она была изначально установлена.) Python будет просматривать эти каталоги (в этом порядке) в поисках файла .py , имя которого совпадает с что вы пытаетесь импортировать.
3. На самом деле, я солгал; правда более сложная, потому что не все модули хранятся как .py файлов. Некоторые из них встроенных модулей ; они фактически встроены в сам Python. Встроенные модули ведут себя так же, как обычные модули, но их исходный код на Python недоступен, потому что они написаны не на Python! (Как и сам Python, эти встроенные модули написаны на C.)
4. Вы можете добавить новый каталог в путь поиска Python во время выполнения, добавив имя каталога в sys.path , и тогда Python также будет искать в этом каталоге всякий раз, когда вы пытаетесь импортировать модуль.Эффект длится, пока работает Python.
5. Используя sys.path.insert (0, new_path ) , вы вставили новый каталог в качестве первого элемента в списке sys.path и, следовательно, в начало пути поиска Python. Это почти всегда то, что вам нужно. В случае конфликтов имен (например, если Python поставляется с версией 2 определенной библиотеки, но вы хотите использовать версию 3), это гарантирует, что ваши модули будут найдены и использованы вместо модулей, поставляемых с Python.

⁂

Все является объектом

Если вы его пропустили, я только что сказал, что функции Python имеют атрибуты и что эти атрибуты доступны во время выполнения. Функция, как и все остальное в Python, является объектом.

Запустите интерактивную оболочку Python и следуйте:

  >>>   импорт человеческий  ①
  >>>   печать (humanize.approximate_size (4096, True))  ②
  4.0 КБ 
  >>>   печать (humanize.approximate_size .__ doc__)  ③
  Преобразование размера файла в удобочитаемую форму.

    Аргументы ключевого слова:
    size - размер файла в байтах
    a_kilobyte_is_1024_bytes - если True (по умолчанию), использовать кратные 1024
                                если False, используйте число, кратное 1000

    Возвращает: строка

  

1. Первая строка импортирует программу humanize как модуль - фрагмент кода, который можно использовать в интерактивном режиме или из более крупной программы Python.После импорта модуля вы можете ссылаться на любые его общедоступные функции, классы или атрибуты. Модули могут делать это для доступа к функциям других модулей, и вы также можете сделать это в интерактивной оболочке Python. Это важная концепция, и вы увидите ее гораздо больше в этой книге.
2. Если вы хотите использовать функции, определенные в импортированных модулях, вам необходимо указать имя модуля. Таким образом, вы не можете просто сказать приблизительный_размер ; он должен быть человеческий размер. приблизительный_размер .Если вы использовали классы в Java, это должно показаться смутно знакомым.
3. Вместо того, чтобы вызывать функцию, как вы ожидали, вы запросили один из атрибутов функции, __doc__ .

☞ import в Python - это как требует в Perl. Как только вы импортируете модуль Python, вы получаете доступ к его функциям с помощью модуля . функция ; как только вам потребуется модуль Perl, вы получите доступ к его функциям с помощью модуля :: функции .

Что такое объект?

Все в Python - это объекты, и все может иметь атрибуты и методы. Все функции имеют встроенный атрибут __doc__ , который возвращает строку документации , определенную в исходном коде функции. Модуль sys - это объект, который имеет (среди прочего) атрибут под названием path . И так далее.

Тем не менее, это не дает ответа на более фундаментальный вопрос: что такое объект? В разных языках программирования «объект» определяется по-разному.В некоторых случаях это означает, что все объекта должны иметь атрибуты и методы ; в других случаях это означает, что все объекты являются подклассами. В Python определение более расплывчатое. У некоторых объектов нет ни атрибутов, ни методов, , но могут . Не все объекты подклассифицируются. Но все является объектом в том смысле, что его можно присвоить переменной или передать в качестве аргумента функции.

Возможно, вы слышали термин «первоклассный объект» в других контекстах программирования.В Python функции - это первоклассных объектов . Вы можете передать функцию в качестве аргумента другой функции. Модули - это первоклассных объектов . Вы можете передать весь модуль в качестве аргумента функции. Классы являются объектами первого класса, а отдельные экземпляры класса также являются объектами первого класса.

Это важно, поэтому я повторю это, если вы пропустили первые несколько раз: все в Python является объектом . Строки - это объекты. Списки - это объекты.Функции - это объекты. Классы - это объекты. Экземпляры классов - это объекты. Даже модули - это объекты.

⁂

Код отступа

Функции Python не имеют явного begin или end , а также фигурных скобок, отмечающих начало и конец кода функции. Единственный разделитель - это двоеточие (: ) и отступ самого кода.

  def приблизительный_размер (размер, a_kilobyte_is_1024_bytes = True): ①
    если размер <0: ②
        поднять ValueError ('число должно быть неотрицательным') ③
                                                            ④
    multiple = 1024, если a_kilobyte_is_1024_bytes иначе 1000
    для суффикса в СУФФИКСАХ [несколько]: ⑤
        size / = несколько
        если размер <несколько:
            вернуть '{0 :.1f} {1} '. Формат (размер, суффикс)

    поднять ValueError ("слишком большое число")  

1. Кодовые блоки определяются их отступом. Под «блоком кода» я подразумеваю функции, , если операторы , для циклов , при циклах и т. Д. Отступ начинается с блока, а снятие отступа заканчивает его. Нет явных фигурных скобок, скобок или ключевых слов. Это означает, что пробелы имеют большое значение и должны быть согласованными. В этом примере код функции имеет отступ в четыре пробела.Это не обязательно должно быть четыре пробела, оно просто должно быть последовательным. Первая строка без отступа отмечает конец функции.
2. В Python за оператором if следует блок кода. Если выражение if истинно, выполняется блок с отступом, в противном случае он попадает в блок else (если есть). Обратите внимание на отсутствие скобок вокруг выражения.
3. Эта строка находится внутри блока кода if . Этот оператор raise вызовет исключение (типа ValueError ), но только если размер <0 .
4. Это , а не конец функции. Полностью пустые строки не учитываются. Они могут сделать код более читабельным, но не считаются разделителями блоков кода. Функция продолжается на следующей строке.
5. Цикл для также отмечает начало кодового блока. Блоки кода могут содержать несколько строк, если все они имеют одинаковый отступ. Этот цикл для содержит три строки кода. Другого специального синтаксиса для многострочных кодовых блоков нет.Просто сделайте отступ и продолжайте жить своей жизнью.

После некоторых первоначальных протестов и нескольких ехидных аналогий с Фортраном вы примиритесь с этим и начнете видеть его преимущества. Одним из основных преимуществ является то, что все программы Python выглядят одинаково, поскольку отступы - это требование языка, а не вопрос стиля. Это упрощает чтение и понимание кода Python других людей.

☞Python использует возврат каретки для разделения операторов и двоеточие и отступы для разделения блоков кода. C ++ и Java используют точки с запятой для разделения операторов и фигурные скобки для разделения блоков кода.

⁂

Исключения

Исключения в Python есть повсюду. Практически каждый модуль в стандартной библиотеке Python использует их, и сам Python будет вызывать их в самых разных обстоятельствах. Вы встретите их неоднократно на протяжении всей книги.

Что такое исключение? Обычно это ошибка, признак того, что что-то пошло не так.(Не все исключения являются ошибками, но пока это неважно.) Некоторые языки программирования поощряют использование кодов возврата ошибок, которые вы проверяете . Python поощряет использование исключений, которые вы обрабатываете .

Когда в Python Shell возникает ошибка, она распечатывает некоторые подробности об исключении и о том, как это произошло, и все. Это называется необработанным исключением . Когда возникло исключение, не было кода, который бы его явно заметил и обработал, поэтому он вернулся на верхний уровень оболочки Python, который выдает некоторую отладочную информацию и вызывает ее.В оболочке в этом нет ничего страшного, но если это произойдет во время работы вашей реальной программы Python, вся программа резко остановится, если ничто не обработает исключение. Может быть, вы этого хотите, а может, и нет.

☞В отличие от Java, функции Python не объявляют, какие исключения они могут вызвать. Вам решать, какие исключения вам нужно перехватывать.

Однако исключение не обязательно должно приводить к полному сбою программы.Исключения могут быть обработаны . Иногда исключение действительно возникает из-за ошибки в коде (например, при доступе к несуществующей переменной), но иногда исключение - это то, что вы можете ожидать. Если вы открываете файл, он может не существовать. Если вы импортируете модуль, возможно, он не установлен. Если вы подключаетесь к базе данных, она может быть недоступна или у вас нет правильных учетных данных для доступа к ней. Если вы знаете, что строка кода может вызвать исключение, вам следует обработать исключение с помощью попытки ... кроме блока .

☞Python использует try ... за исключением блоков для обработки исключений и оператора raise для их генерации. Java и C ++ используют блоки try ... catch для обработки исключений и оператор throw для их генерации.

Функция приближаться к размеру () вызывает исключения в двух разных случаях: если заданный размер больше, чем функция предназначена для обработки, или если он меньше нуля.

 , если размер <0:
    Raise ValueError ('число должно быть неотрицательным')  

Синтаксис вызова исключения достаточно прост. Используйте оператор raise , за которым следует имя исключения и необязательная удобочитаемая строка для целей отладки. Синтаксис напоминает вызов функции. (На самом деле исключения реализованы как классы, и этот оператор raise фактически создает экземпляр класса ValueError и передает строку 'number must be non-negative' его методу инициализации.Но мы забегаем вперед!)

☞Вам не нужно обрабатывать исключение в функции, которая его вызывает. Если одна функция не справляется с этим, исключение передается вызывающей функции, затем вызывающей функции этой функции и так далее «вверх по стеку». Если исключение никогда не обрабатывается, ваша программа выйдет из строя, Python напечатает «трассировку» до стандартной ошибки, и на этом все. Опять же, может быть, это то, что вы хотите; это зависит от того, что делает ваша программа.

Перехват ошибок импорта

Одно из встроенных исключений Python - ImportError , которое возникает, когда вы пытаетесь импортировать модуль и терпите неудачу.Это может происходить по разным причинам, но самый простой случай - когда модуль не существует в вашем пути поиска импорта. Вы можете использовать это для включения дополнительных функций в вашу программу. Например, библиотека chardet обеспечивает автоматическое определение кодировки символов. Возможно, ваша программа хочет использовать эту библиотеку , если она существует, , но продолжайте изящно, если пользователь ее не установил. Вы можете сделать это с помощью блока try..except .

   попробуйте :
  импортная диаграмма
 , кроме  ImportError:
  chardet = Нет  

Позже вы можете проверить наличие модуля chardet с помощью простого оператора if :

  если chardet:
  # сделай что-нибудь
еще:
  # все равно продолжить  

Другое распространенное использование исключения ImportError - это когда два модуля реализуют общий API , но один более желателен, чем другой.(Может быть, он быстрее или использует меньше памяти.) Вы можете попробовать импортировать один модуль, но вернуться к другому модулю, если первый импорт завершился неудачно. Например, в главе XML рассказывается о двух модулях, реализующих общий API , который называется ElementTree API . Первый, lxml , является сторонним модулем, который вам нужно скачать и установить самостоятельно. Второй, xml.etree.ElementTree , работает медленнее, но является частью стандартной библиотеки Python 3.

  попробовать:
    из lxml import etree
кроме ImportError:
    импортировать xml.etree.ElementTree как etree  

К концу этой попытки .. кроме блока вы импортировали какой-то модуль и назвали его etree . Поскольку оба модуля реализуют общий API , остальной части вашего кода не нужно постоянно проверять, какой модуль был импортирован. А поскольку модуль, который импортировал , всегда называется etree , остальная часть вашего кода не должна быть засорена операторами if для вызова модулей с разными именами.

⁂

Несвязанные переменные

Взгляните еще раз на эту строку кода из функции приближенно_size () :

  несколько = 1024, если a_kilobyte_is_1024_bytes иначе 1000  

Вы никогда не объявляете переменную кратной , вы просто присваиваете ей значение. Это нормально, потому что Python позволяет это делать. Что Python не позволит вам сделать, так это ссылаться на переменную, которой никогда не было присвоено значение. Попытка сделать это вызовет исключение NameError .

  >>>   x 
  Traceback (последний вызов последний):
  Файл "", строка 1, в 
NameError: имя 'x' не определено 
  >>>   x = 1 
  >>>   x 
  1  

Однажды вы поблагодарите Python за это.

⁂

Все с учетом регистра

Все имена в Python чувствительны к регистру: имена переменных, имена функций, имена классов, имена модулей, имена исключений.Если вы можете его получить, установить, вызвать, сконструировать, импортировать или поднять, он чувствителен к регистру.

  >>>   an_integer = 1 
  >>>   an_integer 
  1 
  >>>   AN_INTEGER 
  Traceback (последний вызов последний):
  Файл "", строка 1, в 
NameError: имя AN_INTEGER не определено 
  >>>   An_Integer 
  Traceback (последний вызов последний):
  Файл "", строка 1, в 
NameError: имя An_Integer не определено 
  >>>   ан_интегр 
  Traceback (последний вызов последний):
  Файл "", строка 1, в 
NameError: имя an_inteGer не определено 
 

И так далее.

⁂

Запуск сценариев

 
если __name__ == '__main__':
    print (приблизительный_размер (1000000000000; Ложь))
    печать (приблизительный_размер (1000000000000))  

  >>>   импорт человеческий 
  >>>   человеческий размер .__ имя__ 
  "человеческий размер"  

  c: \ home \ diveintopython3>   c: \ python31 \ python.exe peopleize.py 
  1,0 ТБ
931,3 ГиБ  

уволиться()
 

для x в диапазоне (1,10):
    печать (x * 10)
    уволиться()
 

10
 

sys.exit (аргумент)
 

import sys

х = 50

если x! = 100:
sys.exit («Значения не совпадают»)
еще:
print ("Проверка значений завершена !!")
 

Значения не совпадают
 

Выход()
 

для x в диапазоне (1,10):
    печать (x * 10)
    Выход()
 

10