Питон для начинающих с нуля windows - Доктор Windows

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

***

Python в Ubuntu предустановлен. Чтобы узнать версию Python, откроем терминал комбинацией клавиш Ctrl + Alt + T и введем следующую команду:

        python3 --version

Для Windows нужно скачать Python с официального сайта и установить как обычную программу.

Установка редактора кода

Для работы нам понадобится редактор кода (IDE). Самые популярные:

PyCharm
Atom
Visual Studio Code
Sublime Text

Для установки Atom в Ubuntu введем в терминале:

        wget -qO - https://packagecloud.io/AtomEditor/atom/gpgkey | sudo apt-key add -
sudo sh -c 'echo "deb [arch=amd64] https://packagecloud.io/AtomEditor/atom/any/ any main" > /etc/apt/sources.list.d/atom.list'
sudo apt-get update
sudo apt-get install atom

Рис. 1. Страница установки Atom для Windows

Для Windows скачаем Atom с официального сайта. После установки редактора кода установим для него плагин run-python-simply (есть и другие) для запуска Python. Два способа установки:

Перейдем на страничку плагина и нажмем кнопку Install.
Откроем Atom, перейдем во вкладку File → Settings → Install , введем в поле поиска run-python-simply и установим его.

Создание проекта

Создадим проект, в котором будем хранить код и другие файлы. Для этого перейдем во вкладку File → Add Project Folder и выберем любую свободную папку.

Онлайн-редакторы кода

Если под рукой только смартфон, воспользуемся бесплатными онлайн-редакторами кода:

repl.it
onlinegdb.com
tutorialspoint.com
paiza.io
onecompiler.com

1. Синтаксис

Python использует отступы, чтобы обозначить начало блока кода:

        if 3 > 1:
    print("Три больше единицы") # Три больше единицы

Python выдаст ошибку, если вы пропустите отступ:

        if 3 > 1:
print("Три больше единицы") # Ошибка: IndentationError: expected an indented block

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

2. Hello, World

Создадим файл example.py, где example – имя файла, .py – расширение, которое означает, что программа написана на языке программирования Python.

Напишем в example.py следующую строчку:

        print('Hello, World') # Hello, World

У нас установлен плагин run-python-simply и запустить код мы можем двумя способами:

перейти во вкладку Packages → Run Python Simply → Toggle F5;
или нажать на клавишу F5.

После запуска кода появится окно терминала с результатом или ошибкой.

В нашем случае в терминале отобразится фраза Hello, World.

Здесь:

print() – функция, выводящая на экран фразу Hello, World.

'Hello, World' – строка (заключена в кавычки).

Также можно использовать переменную word, которой присвоим значение 'Hello, World':

        word = 'Hello, World'
print(word) # Hello, World

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

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

3. Типы данных

3.1. Строки

Строка – упорядоченная последовательность символов, заключенная в одинарные или двойные кавычки:

        "Cat and dog" # пример записи строки
'Cat and giraffe'

Операции со строками

Изменение регистра первого символа к верхнему регистру с помощью метода title():

        string = 'cat'
print(string.title()) # Cat

Преобразование всех символов к верхнему и нижнему регистру методами upper() и lower() соответственно:

        string = 'cat'
print(string.upper()) # CAT

string = 'DOG'
print(string.lower()) # dog

Объединение строк (конкатенация). Строки объединяются с помощью знака сложения +:

        first_animal = 'cat'
second_animal = 'dog'
all_animals = first_animal + ',' + ' ' + second_animal
print(all_animals) # cat, dog

Повторение строки:

        animal = 'Cat'
print(animal * 5) # CatCatCatCatCat

Вычисление длины строки. Чтобы определить длину строки воспользуемся встроенной функцией len() (сокращённое от англ. length):

        animal = 'Cat'
print(len(animal)) # 3

Рис. 2. Доступ к элементу строки по индексу в Python

Индексация начинается с 0. В нашем случае символ C имеет индекс 0, a – 1, t – 2.

Для получения элемента по индексу воспользуемся квадратными скобками []:

        animal = 'Cat'
print(animal[0]) # C

В предыдущем примере по индексу мы получали один элемент строки. По срезу можно получить несколько элементов:

        animal = 'CatDog'
print(animal[1:3]) # at
print(animal[0:6:2]) # Cto – выводится нулевой элемент и каждый второй после него

Как формируется срез:

list_name[start:stop:step], где start – начало среза, stop – конец среза, step – шаг среза.

Получим с помощью среза последний элемент:

        animal = 'CatDog'
print(animal[-1]) # g

Все элементы, кроме первого:

        animal = 'CatDog'
print(animal[1:]) # atDog

Все элементы, кроме последнего:

        animal = 'CatDog'
print(animal[0:5]) # CatDo
print(animal[:5]) # CatDo
print(animal[:-1]) # CatDo

Создание копии строки через срез:

        animal = 'CatDog'
animal_copy = animal[:]
print(animal_copy) # CatDog

Методом replace() заменим символы в строке:

        animal = 'CatDog'
print(animal.replace('Cat', 'Dog')) # DogDog

В скобках метода replace() указана дополнительная информация: Cat – элемент, подлежащий замене на элемент Dog.

Для удаление пробелов слева и справа применяется метод strip(), только справа – rstrip(), только слева – lstrip():

        animal = ' CatDog  '
print(animal.strip()) # CatDog
print(animal.rstrip()) #  CatDog  – здесь остался пробел слева 
print(animal.lstrip()) # CatDog – здесь остался пробел справа

Преобразование строки в список индивидуальных символов:

        animal = 'CatDog '
print(list(animal)) # ['C', 'a', 't', 'D', 'o', 'g', ' ']

3.2. Числа

Целые числа (int) не имеют дробной части:

        print(25 + 0 - 24) # 1

Число с плавающей точкой (float) имеет дробную часть:

        print(2.8 + 4.1) # 6.8999999999999995

Операции над числами:

        print(2 + 3) # Сложение: 5
print(5 - 4) # Вычитание: 1
print(5 * 5) # Умножение: 25
print(4 / 2) # Деление: 2.0
print(4 ** 4) # Возведение в степень: 256

Порядок операций. Выражение в скобках будет просчитываться в первую очередь:

        print(3*4 + 5) # 17
print(3*(4 + 5)) # 27

Чтобы преобразовать число с плавающей точкой в целое воспользуемся функцией int(), а для обратного преобразования – функцией float():

        print(int(5.156)) # 5
print(float(4)) # 4.0

3.3. Списки

Список (англ. list) – набор упорядоченных элементов произвольных типов. Списки задаются квадратными скобками [] и содержат объекты любого типа: строки, числа, другие списки и так далее. Элементы можно менять по индексу.

Создадим список animals и выведем его на экран:

        animals = ['cat', 'dog', 'giraffe']
print(animals) # ['cat', 'dog', 'giraffe']

Обратимся к второму элементу списка:

        animals = ['cat', 'dog', 'giraffe']
print(animals[1]) # dog

Чтобы изменить элемент списка, обратимся к нему по индексу и присвоим новое значение:

        animals = ['cat', 'dog', 'giraffe']
print(animals) # ['cat', 'dog', 'giraffe']

animals[2] = 'orangutan' # меняем третий элемент
print(animals)  # ['cat', 'dog', 'orangutan']

animals[2] = ['orangutan']
print(animals) # ['cat', 'dog', ['orangutan']] – список внутри списка, вложенный список

Для добавления элемента в конец списка воспользуемся методом append():

        animals = ['cat', 'dog', 'giraffe']
animals.append('tyrannosaurus')
print(animals) # ['cat', 'dog', 'giraffe', 'tyrannosaurus']

Метод insert() вставляет элемент по индексу:

        animals = ['cat', 'dog', 'giraffe']
animals.insert(1, 43)
print(animals) # ['cat', 43, 'dog', 'giraffe']

Число 43 вставляется на место с индексом 1, остальные элементы сдвигаются вправо. Первый элемент остается на прежнем месте.

Для удаления элемента из списка, обратимся к элементу по индексу, используя команду del:

        animals = ['cat', 'dog', 'giraffe']
del animals[2]
print(animals) # ['cat', 'dog']

Другой способ удаления – метод pop():

        animals = ['cat', 'dog', 'giraffe']
animals.pop(2)
print(animals) # ['cat', 'dog']

В двух предыдущих примерах мы удаляли элемент по его индексу. Теперь удалим элемент по его значению с помощью метода remove():

        animals = ['cat', 'dog', 'giraffe']
animals.remove('dog')
print(animals) # ['cat', 'giraffe']

Чтобы упорядочить список по алфавиту используем метод sort():

        animals = ['giraffe', 'cat', 'dog']
animals.sort()
print(animals) # ['cat', 'dog', 'giraffe']

Список в обратном порядке выводится методом reverse():

        animals = ['cat', 'dog', 'giraffe']
animals.reverse()
print(animals) # [giraffe', 'dog', 'cat']

Для определения длины списка воспользуемся функцией len():

        animals = ['cat', 'dog', 'giraffe']
print(len(animals)) # 3

3.4. Кортежи

Рис. 3. Доступ к элементам кортежа по индексу в Python

Кортеж (англ. tuple), как и список хранит элементы, только в отличие от списка, элементы кортежа не изменяются. Кортеж задается круглыми скобками ():

        animals = ('cat', 'dog', 'giraffe')
print(animals[0]) # Получение элемента кортежа с индексом 0: cat

Одноэлементный кортеж задается с помощью запятой после первого элемента. Без запятой получим строку. Чтобы узнать какой тип данных мы получаем на выходе воспользуемся функцией type():

        animals = ('cat',)
print(animals) # ('cat',)
print(type(animals)) # <class 'tuple'> – кортеж

animals = ('cat')
print(animals) # cat
print(type(animals)) # <class 'str'> – строка

Конкатенация кортежей:

        print(('cat',) + ('dog', 2))  # ('cat', 'dog', 2)

Повторение кортежа:

        print(('cat', 'dog', 4) * 2) # ('cat', 'dog', 4, 'cat', 'dog', 4)

Срез кортежа:

        animals = ('cat', 'dog', 'giraffe')
print(animals[0:1]) # ('cat',)
print(animals[0:2]) # ('cat', 'dog')

Чтобы создать список из элементов кортежа применим функцию list():

        animals_tuple = ('cat', 'dog', 33)
animals_list = list(animals_tuple)
print(animals_list)  # ['cat', 'dog', 33]

3.5. Словари

Рис. 4. Устройство словаря в Python

Словарь – неупорядоченная коллекция произвольных элементов, состоящих из пар «ключ-значение». Словарь объявляется через фигурные скобки {}: dictionary = {‘pets‘: ‘cat‘, ‘numbers‘: (1, 2)}, где pets и numbers – ключи, а cat, (1, 2) – значения. Если в списке мы получаем объект по его индексу, то в словаре по ключу.

Получим по ключам соответствующие значения из словаря dictionary:

        dictionary = {'pets': 'cat', 'numbers': (1, 2)}
print(dictionary['pets']) # cat
print(dictionary['numbers'])  # (1, 2)
print(dictionary['numbers'][1])  # 2

Чтобы добавить новую пару «ключ-значение» используем следующую запись словарь['новый_ключ'] = новое_значение:

        dictionary = {'pets': 'cat', 'numbers': (1, 2)}
dictionary['dinosaur'] = 'tyrannosaurus', 'pterodactylus'
print(dictionary) # {'pets': 'cat', 'numbers': (1, 2), 'dinosaur': ('tyrannosaurus', 'pterodactylus')}

Изменение существующего значения похоже на добавление нового значения словарь['существующий_ключ'] = новое_значение:

        dictionary = {'pets': 'cat', 'numbers': (1, 2)}
dictionary['pets'] = 'dog'
print(dictionary) # {'pets': 'dog', 'numbers': (1, 2)}

Командой del можно удалить ключ со значением:

        dictionary = {'pets': 'cat', 'numbers': (1, 2)}
del dictionary['pets']
print(dictionary) # {'numbers': (1, 2)}

3.6. Множества

Множества – неупорядоченные последовательности не повторяющихся элементов. Множество задается через фигурные скобки {}:

        animals_and_numbers = {'cat', 'dog', 99, 100}
print(animals_and_numbers) # {'cat', 99, 100, 'dog'}

Операции над множествами:

        animals_and_numbers = {'cat', 'dog', 99, 100}
numbers = {555, 99}
animals = {'cat', 'dog'}

print(animals_and_numbers.union(numbers)) # {'cat', 99, 100, 'dog', 555} – добавляет в множество animals_and_numbers элементы множества numbers
print(animals_and_numbers.intersection(numbers)) # {99} – возвращает множество, являющееся пересечением множеств animals_and_numbers и numbers
print(animals_and_numbers.difference(numbers)) # {'cat', 'dog', 100} – Возвращает разность множеств animals_and_numbers и numbers
print(animals_and_numbers.issuperset(animals)) # True – Возвращает True, если animals является подмножеством animals_and_numbers.

3.7. Файлы

С помощью функции open() мы создаем файловый объект для работы с файлами. Создадим в папке с python-файлом текстовой файл example.txt, напишем в нем слово test, сохраним и закроем. Следующий код открывает и выводит на экран содержимое текстового файла example.txt:

        with open('example.txt', 'r') as file:
    for line in file:
        print(line)

Здесь:

example.txt – путь к файлу и его имя. В нашем случае файл расположен в папке с выполняемой программой.

r – режим работы «только чтение».

Попробуем дозаписать числа в конец файла:

        numbers = ['0', '1', '2', '3']

with open('example.txt', 'a') as file:
    for number in numbers:
        file.write(number + 'n')

0 # в файл запишется последовательность чисел, каждое число с новой строчки
1
2
3

Здесь:

numbers – список чисел.

a – режим записи «в конец текстового файла».

n – перенос на новую строчку.

Без переноса строки результат будет следующий:

        numbers = ['0', '1', '2', '3']

with open('example.txt', 'a') as file:
    for number in numbers:
        file.write(number)

0123 # результат записи без переноса строки

4. Ввод данных

Для ввода данных применяется функция input():

        input_word = input('Введите какое-нибудь слово: ')
print('Слово: ' + input_word)

5. Условные инструкции

Рис. 5. Условный оператор if в Python

Оператор if выполняет код в зависимости от условия. Проверим, если число три меньше пяти, то выведем на экран слово true:

        if 3 < 5:
    print('true') # true

Попробуем оператор if-else. else переводится как «в другом случае». Когда условие if не выполняется, то идет выполнение кода после else:

        if 3 > 5:
    print('true')
else:
    print('false') # false

elif = else + if – код выполняется, если предыдущее условие ложно, а текущее истинно:

        number = 15
if number < 3:
    print('число меньше трех')
elif 4 < number < 10:
    print('число в промежутке от 4 до 10')
elif number > 10:
    print('число больше 10') # число больше 10

6. Цикл while

Рис. 6. Цикл while в Python

Напишем цикл, который 5 раз выведет на экран слово hello:

        x = 0
while x < 5:
    print('hello')
    x += 1

# получаем пять раз слово hello
hello
hello
hello
hello
hello

Здесь:

while – обозначение цикла.

x < 5 – условие, которое записывается после while. Каждый раз после выполнения цикла (после одной итерации) проверяется это условие. Если оно становится ложным, цикл прекращает работу.

print('hello') – вывести на экран слово hello.

x += 1 – это сокращенный способ записи x = x + 1. То есть при каждой итерации значение x увеличивается на единицу.

Бесконечный цикл записывается с помощью while True:

        while True:
    print('hello')

hello
hello
hello
hello
hello
…

7. Цикл for

Рис. 7. Цикл for в Python

Цикл for перебирает элементы последовательности:

        numbers = ['0', '1', '2', '3']
for i in range(0, len(numbers)):
    print(numbers[i])

# на экран выводятся числа 0, 1, 2 и 3
0
1
2
3

Здесь:

i – переменная, которая принимает значение из диапазона значений range(0, len(numbers)).

range(0, len(numbers)) – последовательность чисел от 0 до значения длины списка numbers.

print(numbers[i]) – тело цикла, выводит на экран i-й элемент списка numbers.

Второй вариант записи:

        numbers = ['0', '1', '2', '3']
for number in numbers:
    print(number)

# идентичный результат
0
1
2
3

8. Функции

Функция выполняет одну конкретную задачу и имеет имя. Напишем функцию greeting(), которая выводит на экран приветствие:

        def greeting(): # объявление функции
    print('hello') # тело функции

greeting() # запуск функции

Здесь:

def – создает объект функции и присваивает ей имя greeting. В скобках можно указать аргументы (см. следующий пример). В нашем случае аргументов нет и скобки пустые.

print('hello') – выводит на экран слово hello.

Напишем функцию summation(), которая складывает два числа:

        def summation (a, b):
    return print(a + b)

summation(3, 8) # 11

Здесь:

a и b – аргументы функции.

return возвращает значение функции.

9. Модули

Модуль – файл, содержащий функции, классы и данные, которые можно использовать в других программах.

        from math import trunc

print(trunc(3.9)) # 3

Здесь:

from math import trunc – из встроенного в Python модуля math импортируем функцию trunc, которая отбрасывает дробную часть числа.

Это был импорт отдельной функции. Теперь импортируем весь модуль и обратимся к функции через модуль.имя_функции():

        import math

print(math.trunc(3.9))  # 3

10. Комментарии

Комментирование кода помогает объяснить логику работы программы. Однострочный комментарий начинается с хеш-символа #:

        a = 45 # комментарий к коду

Многострочный комментарий заключается с обеих сторон в три кавычки:

        """
a = 45
b = 99
"""

Литература

«Изучаем Python», Марк Лутц
«Программируем на Python», Майкл Доусон
«Изучаем программирование на Python», Пол Бэрри
«Начинаем программировать на Python», Тонни Гэддис
«Простой Python. Современный стиль программирования», Билл Любанович

Шпаргалки

Шпаргалка по Python3 (.pdf)
Python Cheat Sheet (.pdf)
Beginners Python Cheat Sheet (.pdf)
Essential Python Cheat Sheet
Python Conditions Cheat Sheet

Больше шпаргалок в нашей группе ВКонтакте.

YouTube-каналы и курсы

Бесплатные курсы на русском и английском языках в YouTube и на образовательных ресурсах:

На английском:

Programming with Mosh
freeСodeСamp.org
Microsoft Developer
Introduction To Python Programming (Udemy)

На русском:

Python с нуля
Python для начинающих
Python с нуля от А до Я
Программирование на Python (Stepik)
Python: основы и применение (Stepik)
Питонтьютор (онлайн-тренажер)

Python в «Библиотеке Программиста»

подписывайтесь на тег Python, чтобы получать уведомления о новых постах на сайте;
телеграм-канал «Библиотека питониста»;
телеграм-канал для поиска работы «Python jobs — вакансии по питону, Django, Flask».

***

Мы кратко познакомились с основными понятиями Python: команды, функции, операторы и типы данных. У этого языка низкий порог вхождения, простой синтаксис, поэтому вероятность освоить его человеку, который никогда не занимался программированием – высокая (по моей субъективной оценке – 90%).

***

На Python создают прикладные приложения, пишут тесты и бэкенд веб-приложений, автоматизируют задачи в системном администрировании, его используют в нейронных сетях и анализе больших данных. Язык можно изучить самостоятельно, но на это придется потратить немало времени. Если вы хотите быстро понять основы программирования на Python, обратите внимание на онлайн-курс «Библиотеки программиста». За 30 уроков (15 теоретических и 15 практических занятий) под руководством практикующих экспертов вы не только изучите основы синтаксиса, но и освоите две интегрированные среды разработки (PyCharm и Jupyter Notebook), работу со словарями, парсинг веб-страниц, создание ботов для Telegram и Instagram, тестирование кода и даже анализ данных. Чтобы процесс обучения стал более интересным и комфортным, студенты получат от нас обратную связь. Кураторы и преподаватели курса ответят на все вопросы по теме лекций и практических занятий.

Источник

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

Что такое Python

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

Python

Есть и другие преимущества:

Типы переменных назначаются автоматически. Операнды разных типов в одной операции «самостоятельно» приводятся к нужному согласно встроенным правилам.
Функции автоматически преобразуются в список, если просто указать их через запятую. Не нужно выделять память, передавать указатели.
Память на выполнение операций выделяется автоматически. Если выявляются объекты, на которые нет ссылок, они удаляются «сборщиком мусора».
Типы данных привязаны к значениям, что позволяет обходиться без их явного определения и упрощает повторное присваивание переменной.

Написанный код не нужно компилировать, он начинает работать сразу после запуска. Благодаря этому легко проверять каждую корректировку программы, которых набираются десятки во время отладки приложения. Такие особенности привели к тому, что в прошлом году Python оказался на 10% популярнее вездесущего Java.

Комьюнити теперь в Телеграм

Подпишитесь и будьте в курсе последних IT-новостей

Работа с интерпретатором в Linux

Интерпретатор Питона без проблем запускается в любой среде. Например, в Linux применяется команда для консоли:

$ python

После ее ввода откроется приглашение и отобразится текущая версия Python. Сейчас распространены релизы под номерами 2 и 3. Именно на них разработана масса библиотек, используемых кодерами для сборки собственных программ. Третья версия имеет расширенный набор функций, но на второй написано слишком много модулей, поэтому в дистрибутиве поставляются сразу обе.

По умолчанию запускается релиз v2, для запуска v3 требуется указать следующее:

$ python3

Если обучение происходит «с нуля», есть смысл за основу брать третью версию. Вторую осваивать в процессе оттачивания мастерства, например, если пришлось на практике разбираться в «чужом» коде. Или когда готовые модули написаны на старой версии и нет времени/желания переделывать их на новый лад (выгоднее сослаться на уже отлаженный код).

Установка Python на Windows

Пакет для поддержки Питона нужно скачать с официального сайта разработчика по ссылке. Скачивая его на сторонних ресурсах, нет гарантии, что дистрибутив будет без вирусов. Важно и выбрать правильную платформу 32-bit или 64-bit. Портал представляет сразу все выпущенные релизы, ориентироваться следует на последние.

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

После установки скачанного дистрибутива на рабочем столе Windows появляется ярлык для запуска программы IDLE (среды разработки на языке Питон). Внешне рабочее окно схоже с тем, которое видят пользователи Linux.

Операции со строками

Изучение проще начинать с простейших примеров базовых операций вроде операций со строками, числами, датой и временем, файловой системой. И только после освоения элементарных вещей приступать к более сложным решениям.

Примеры операций со строками:

Объединение:

str = "welcome " + "to python"

print (str)

Умножение:

str = "Losst" * 2

print (str)

Объединение с преобразованием (с числом или логическим значением):

str = "Это тестовое число " + str(15)

print (str)

Читайте также: Списки в Python и методы работы с ними

Каждый из примеров рекомендуется внести в интерпретатор и посмотреть на результат. Понятно, что такие пробы ни к чему не приведут без теоретической основы. В ее качестве рекомендуется взять книги «Программируем на Python» Майкла Доусона и «Hello World. Занимательное программирование» Картера и Уоррен Сэнд. Также будут полезны «Изучаем Python» Марца Лутца и «Python – к вершинам мастерства» Лучано Рамальо.

Избыток информации на начальном этапе пойдет только на пользу, ведь новичок еще не определил для себя специализацию, поэтому стоит взяться за все доступные основы.

Синтаксис Python

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

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

Почему моя программа не работает?

Ошибки при создании кода будут, особенно в начале изучения Python. Главное, научиться верно их истолковывать. Такой подход поможет быстрее избавляться от них, вплоть до приобретения навыка писать код без «косяков». Чтобы понять причину ошибки, достаточно на этапе проверки запустить программу через IDLE или консоль. Тогда пользователь увидит сообщения, которые укажут, где искать ошибку.

Вам будет интересно: Лучшие IDE и редакторы кода для Python

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

Источник

На чтение 25 мин. Просмотров 20.2k. Опубликовано 30 апреля, 2021

Как выучить самому Python или любой другой язык программирования? Такой вопрос возникает у тех, кто впервые решил погрузиться в сферу IT.

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

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

Содержание

Где используется Python и почему
Установка и подготовка среды
Начало работы в Питоне
Переменные в Python
Числа в Питоне и операции с ними
Строки (тип данных string)
Булевы операции
Условные выражения
Списки, кортежи, множества и словари
Циклы for, while в Питоне
Функции
Модули, библиотеки, import
Общий импорт
Импорт всех объектов (не рекомендуется, но не запрещен)
Импорт конкретной функции
Импорт функции с переименованием
Импорт модуля с переименованием
Работа с файлами
Изучаем Python: куда дальше?
Ответы на вопросы читателей
Дополнительные источники (книги и сайты)

Где используется Python и почему

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

К типичным областям использования Python относят:

Веб-разработка (сайты любой сложности и функциональности без проблем создаются при помощи данного языка);
Работа с базами данных (можно работать как с «встроенной» sqlite3, так и любыми другими – реляционными и нереляционными);
Графические приложения (реально не просто писать исполняемые скрипты, но и разрабатывать полноценные графические интерфейсы под свои нужды);
Научные задачи (сложные вычисления, машинное обучение, нейронные сети);
Сетевое программирование (включает не только взаимодействие с сайтами, но и почтовыми сервисами, JSON-объектами, Интернет-протоколами);
Бизнес-приложения и игровая индустрия (ERP-системы, непрерывная разработка и тестирование, простые игры).

Озвученный спектр направлений показывает, что Питон имеет определенные преимущества по сравнению с другими языками, раз он пригоден для такого широкого класса задач.

Основные показаны ниже (рис. 1).

Сильные стороны языка Python

Простота подразумевает легкость освоения и высокий уровень абстракции (минимум кода при максимальном эффекте).

Выразительность связана с минимальным количеством кода для достижения результата (некоторые особенности Питона сокращают объем кода чуть ли не до одной строки, если сравнивать с другими языками).

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

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

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

Кроссплатформенность в дополнение ко всему гарантирует достижение идентичных результатов что на Windows, Linux, MacOS, так и на мобильных системах.

Python – объектно-ориентированный высокоуровневый интерпретируемый язык с динамической типизацией и автоматическим управлением памятью.

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

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

Отметим, также, ключевые плюсы и минуса Питона (таблица 1).

Плюсы	Минусы
Легко изучать, писать и читать код	Относительно медленный
Интерпретируемый (исполняет код на лету)	Не всегда эффективно расходует память
Динамически типизированный	Ограничен в мобильной разработке
С открытым исходным кодом	При исполнении могут возникать ошибки, что требует тщательного тестирования
Имеет широкую поддержку

Таблица 1 – Сильные и слабые стороны Python’a

Установка и подготовка среды

Чтобы начать программировать на Питоне, требуется совершить 2 шага:

Установить последний релиз Python (скачивается с официального сайта https://www.python.org/downloads/);
Загрузить программу для разработки (для новичков лучше всего подойдет PyCharm версии Community – https://www.jetbrains.com/ru-ru/pycharm/download/).

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

Чтобы создать свой первый проект запускаем PyCharm и выбираем меню File -> New Project. Проверяем, чтобы в поле Base Interpreter стояла самая новая версия Питона.

Python реализован Гвидо ван Россумом в 1991 году. Несколько раз Питон признавался языком года (даже в 2020 году). Сегодня он применяется не только в среде средних и мелких разработчиков, но и в таких мировых компаниях как Google, Instagram, Facebook. Название языка происходит не от змеи, как часто думают новички, а от британского шоу «Летающий цирк Монти Пайтона».

Теперь в папке проекта можно создать файл с расширением «.py», в котором и будет писаться код. Чтобы запустить скрипт, нажимаем либо зеленую кнопку «Run», либо выбираем ее же через правую кнопку мыши. Внизу PyCharm при этом откроется окно консоли, отражающее итог и ход работы программы.

Таким образом, схема работы достаточно проста: пишем код, запускаем его, смотрим в терминал результат.

Чтобы проверить, что все установлено успешно и вы не напутали ничего в настройках, идем в панель терминала (внизу) и пишем там команду «python -V». Она отобразит версию Python, которая была проинсталлирована на компьютер.

В случае, если операционная система отличается от Windows, то команда будет выглядеть так: «python3 -V» (это связано с тем, что в UNIX-подобных ядрах по умолчанию включена более старая версия языка – 2.7. Так как она больше не поддерживается, рекомендуется работать с третьей – 3.9 или выше).

Начало работы в Питоне

Первое, что делают при изучении любого языка программирования, – вывод в консоль популярного сообщения «Hello world». Немного поменяем вывод, и в пустом файле скрипта напишем следующую команду:

-
print('Начинаем программировать')
-

Print – встроенная в Python функция, которая выводит на печать переданное в нее сообщение. Запуск скрипта отобразит в терминале соответствующую фразу.

Еще одна полезная команда – input. Она позволяет как бы общаться с пользователем при помощи консоли. Исполним следующий код:

-
print('Познакомимся?')
input('Как вас зовут, будущий мастер? ')
input('А сколько вам лет?')
print('Рад знакомству!')
-

Функция input приостанавливает исполнение скрипта до тех пор, пока пользователь не введет свой ответ. Сначала в консоли потребуется представиться, а потом передать свой возраст. И лишь потом в терминале отобразится сообщение: «Рад знакомству!».

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

Обсудим базовый синтаксис языка Python:

Любая часть кода отделяется от предыдущей переводом на новую строку (не нужно никаких точек с запятой в конце);
Отступы внутри блоков кода (о них пойдет речь дальше) задаются 4-мя пробелами;
Создаваемые функции и объекты отделяются друг от друга двумя пустыми строчками.

Даже если вы и забудете о сказанном, PyCharm вам напомнит: он подчеркнет синтаксические ошибки, даст подсказки по используемым функциям. Это не просто удобно, но и экономит массу времени.

Каждый символ в коде Python является существенным.

Гвидо ван Россум (https://blog.dropbox.com/topics/work-culture/-the-mind-at-work—guido-van-rossum-on-how-python-makes-thinking)

Данная фраза от создателя языка свидетельствует о том, что Питон в своем синтаксисе максимально прозрачен.

Переменные в Python

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

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

Пример плохих или неверных наименований:

abswqw – не понятно, какой смысл у данной переменной;
12Q – имена не могут начинаться с цифры;
myname – два слова, не отделенные нижним подчеркиванием;
nomer_telefona – не нужно транслита, следует использовать английские слова, чтобы ваш код понял программист из любой точки планеты.

Правильные переменные:

name – понятно и отражает суть;
birth_year – используем змеиную нотацию.

Реализуем простую задачу для новичков на Питоне, которая иногда встречается на собеседованиях!

Получим от пользователя следующие сведения: его имя и страну, в которой бы он хотел побывать. Выведем на печать сообщение: «Доброго дня, {ИМЯ}. {СТРАНА} – интересная страна!». А после этого продемонстрируем пользователю еще одну фразу: «Было приятно с вами поболтать, {ИМЯ}».

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

Чтобы передать в функцию print переменную вместе с текстом, удобно пользоваться так называемыми f-строками. Синтаксис следующий: print(f’Вы передали переменную {variable}’).

-
user_name = input('Каково ваше имя? ')
country_to_visit = input('В какой стране вы бы хотели побывать? ')
print(f'Доброго дня, {user_name}. {country_to_visit} – интересная страна!')
print(f'Было приятно с вами поболтать, {user_name}')
-

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

Числа в Питоне и операции с ними

Далее поговорим о типах данных. Начнем с чисел. В этом курсе мы затронем два их типа: целые и числа с плавающей точкой. Из названия понятно, что они подразумевают. Есть и другие: комплексные, десятичные, дробные (в Питоне они различаются).

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

-
x = 8
y = 5
z = 3.56
print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x ** y)
print(x // y)
print(x % y)
print(x + z)
-

Результат работы скрипта:

Мы создали 3 переменные: две в виде целых чисел и одну как число с плавающей точкой. При делении любых значений всегда получается число с плавающей точкой (даже если разделить 10 на 5, то получим 2.0).

Целочисленное деление обозначается как «//». Оно отбрасывает остаток. Деление по модулю подразумевает отображение только остатка и обозначается «%». Возведение в степень записывается двумя звездочками.

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

float – приводит число к типу с плавающей точкой;
int – преобразует число в целое (отбрасывает все числа после запятой);
type – показывает тип переменной.

-
x = -14
y = 2.981
print(int(y))
print(float(x))
print(type(x))
print(type(y))
-

Результат работы скрипта:

2
-14.0
<class 'int'>
<class 'float'>

При помощи type мы убедились, что первое число – целое, а второе – с плавающей точкой. А две другие функции позволили преобразовать данные к нужному типу.

Строки (тип данных string)

Строка – еще один тип данных в языке Python. Они записываются в одинарных или двойных кавычках. В нашем бесплатном гайде рассмотрим следующие операции с ними:

Конкатенация (сложение);
Дублирование (умножение);
Доступ по индексу;
Определение длины.

Конкатенация подразумевает объединение строк. При помощи же знака умножения можно строку продублировать несколько раз.

-
day = 'Wednesday'
weather = 'sunny'
print(day + weather)
print(day * 3)
day += day
print(day)
-

Результат работы скрипта:

Wednesdaysunny
WednesdayWednesdayWednesday
WednesdayWednesday

Операция «day += day» делает следующее: берет старую переменную, добавляет к ней некоторое значение (в нашем случае – ее же саму) и записывает полученный результат под тем же именем. Данная операция часто используется с числами (для умножения, сложение, деления и т.п.).

Строка является перебираемым (итерируемым) объектом. К каждому отдельному ее элементу можно получить доступ. Для этого используются индексы. Индекс первого элемента равен нулю (а остальные – по возрастанию). Можно пойти с конца: тогда последний элемент имеет индекс «-1», а оставшиеся – по убыванию.

Более того, с помощью индексов можно делать срезы: брать некоторую часть строки. Также, предусмотрен шаг среза (по умолчанию равен единице).

Например, нам требуется взять строку начиная с 3-го элемента и заканчивая 15-ым с шагом 2. Это значит следующее: делаем срез с 3-го элемента по 16-ый (он не включается), а из этого промежутка берем не каждый символ, а только четные.

-
quote = 'Начинаем программировать простые задачи на Питоне для новичков'
print(quote[0])
print(quote[5])
print(quote[-3])
print(quote[1:7])
print(quote[:5])
print(quote[3:16:2])
print(quote[::-1])
-

Результат работы скрипта:

Н
а
к
ачинае
Начин
иампорм
вокчивон ялд енотиП ан ичадаз еытсорп ьтавориммаргорп меаничаН

Запись quote[:5] подразумевает срез от начала строки до 5-го элемента (не включая его). Инструкция quote[::-1] говорит о срезе от начала до конца строки, с шагом -1, т.е. в обратном направлении. Это самый простой способ развернуть написанную фразу.

Так как к символам строки можно обращаться по индексу, то у нее есть некоторая длина. Узнать ее просто – применяем функцию len.

-
quote = 'Список команд для новичков'
print(len(quote))
-

Результат работы скрипта:

Можете проверить сами, что в данной строке 26 символов (с учетом пробелов).

Булевы операции

Булев тип данных и операции сравнения используются в любом языке программирования. Здесь мы работаем с двумя значениями: истина (True) или ложь (False). Сравнение переменных осуществляется следующими операторами:

– «==» - равны ли переменные;
– «!=» - не равны ли значения;
– «>», «<», «>=», «<=» – больше, меньше, больше-равно или меньше-равно.
-
x = 11
y = 12
z = 11
print(x == y)
print(x == z)
print(x >= y)
print(z <= y)
print(x != y)
-

Результат работы скрипта:

False
True
False
True
True

С булевым типом данных тесно связаны логические операторы:

AND (логическое И) – проверяет верность обеих частей выражения;
OR (логическое ИЛИ) – проверяет верность одной из частей выражения;
NOT (логическое НЕ) – обращает значение, возвращает обратную логическую величину.

Проще всего понять их на основании следующей таблицы (табл. 2).

Первое выражение	Второе выражение	AND	OR
True	True	True	True
True	False	False	True
False	True	False	True
False	False	False	False

Таблица 2 – Логические операторы в Python

Условные выражения

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

Например, на сайт заходит пользователь: если ему больше 18 лет, то ему показываются все темы, а если меньше – то только некоторые. Для таких случаев используется инструкция «if…elif…else». Она может состоять из 1, 2 или более вариантов ветвления.

Рассмотрим на практике.

-
# Одиночное условие
age = -5
if age < 0 or age > 140:
    print('Такого возраста не бывает')
-

Результат работы скрипта:

Такого возраста не бывает

Отметим, что комментарии в Питоне предваряются решеткой (эта часть кода не будет исполняться). В примере нам потребовалось узнать возраст пользователя. Но мы хотим получить реальное число, поэтому ограничили рамки человеческого возраста от 1 до 139 лет.

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

-
# Многоуровневое условие
age = 'Tom'
if type(age) is not int:
    if type(age) is float:
        print('Введите целое число')
    elif type(age) is str:
        print('Не нужно строк!')
    else:
        print('Требуется только целочисленное единичное значение')
elif age < 0 or age > 140:
    print('Рамки допустимого возраста 1-139 лет')
-

Результат работы скрипта:

Не нужно строк!

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

Списки, кортежи, множества и словари

Списки, кортежи, множества и словари – еще 4 типа данных в Питоне, включающие в себя несколько значений и являющиеся итерируемыми (перебираемыми, как строки).

Особенности показаны в таблице 3.

Список (list)	Кортеж (tuple)	Множество (set)	Словарь (dict)
Изменяемый	Неизменяемый	Изменяемое	Изменяемый
Значения могут дублироваться	Значения могут дублироваться	Значения не могут дублироваться	Ключи не могут дублироваться
Доступ по индексу возможен	Доступ по индексу возможен	Доступ по индексу невозможен	Есть доступ к ключам и значениям

Таблица 3 – Коллекции данных в Python

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

Рассмотрим часть функционала.

numbers = [3, -7, 32, 11.4, 9]
# Добавляем элемент в конец списка
numbers.append(101)
print(numbers)
# Добавляем элемент в начало списка
numbers.insert(0, -46)
print(numbers)
# Удаляем последний элемент
numbers.pop()
print(numbers)
# Разворачиваем список
numbers.reverse()
print(numbers)
# Удаляем первый элемент со значением -7
numbers.remove(-7)
print(numbers)
# Сортируем список по возрастанию
numbers.sort()
print(numbers)
-

Результат работы скрипта:

[3, -7, 32, 11.4, 9, 101]
[-46, 3, -7, 32, 11.4, 9, 101]
[-46, 3, -7, 32, 11.4, 9]
[9, 11.4, 32, -7, 3, -46]
[9, 11.4, 32, 3, -46]
[-46, 3, 9, 11.4, 32]

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

На их основании также возможны срезы, доступ по индексу, нахождение максимума или минимума (если элементы представлены числами), поиск количества вхождений значений.

-
numbers = (2, 2, 6, -1, 2, 11)
# Узнаем длину кортежа
print(len(numbers))
# Ищем максимальное число
print(max(numbers))
# Подсчитываем сумму всех элементов
print(sum(numbers))
# Выясняем, сколько раз в кортеже встречается двойка
print(numbers.count(2))
-

Результат работы скрипта:

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

-
names = {'Игорь', 'Пётр', 'Николай', 'Семён'}
# Добавляем имена в множество
names.add('Игорь')
names.add('Матвей')
names.add('Дмитрий')
print(names)
# Удаляем имя из множества
names.discard('Николай')
print(names)
# Очищаем множество
names.clear()
print(names)
-

Результат работы скрипта:

{'Пётр', 'Матвей', 'Дмитрий', 'Семён', 'Игорь', 'Николай'}
{'Пётр', 'Матвей', 'Дмитрий', 'Семён', 'Игорь'}
set()

Словарь – особый тип коллекций. Все его элементы состоят из пар «ключ: значение». Ключ должен быть уникальным, а значения могут повторяться. Обозначается фигурными скобками.

Рассмотрим некоторые операции со словарями.

-
student = {
    'name': 'Федор',
    'age': 28,
    'is_present_today': True,
    'hobbies': ['music', 'chess', 'literature']
}
# Выясняем хобби студента
print(student['hobbies'])
# Узнаем все ключи
print(student.keys())
# Узнаем все значения
print(student.values())
# Добавляем новую характеристику
student['avg_mark'] = 4.2
print(student)
# Узнаем рост студента, а если нет такого ключа, то возвращаем 0
print(student.get('height', 0))
-

Результат работы скрипта:

['music', 'chess', 'literature']
dict_keys(['name', 'age', 'is_present_today', 'hobbies'])
dict_values(['Федор', 28, True, ['music', 'chess', 'literature']])
{'name': 'Федор', 'age': 28, 'is_present_today': True, 'hobbies': ['music', 'chess', 'literature'], 'avg_mark': 4.2}
0

Таким образом, в зависимости от ситуации применяется тот или иной тип коллекций. Чаще всего это списки и словари.

Циклы for, while в Питоне

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

Конструкция цикла for представлена следующим образом:

for elem in sequence:
    что-то выполняем…

Либо:

for index in range(num):
    что-то выполняем…

Другими словами, мы можем проходиться по каждому элементу последовательности либо напрямую, либо при помощи функции range и индексов.

Для понимания рассмотрим примеры.

-
planets = ['Земля', 'Марс', 'Меркурий', 'Венера', 'Юпитер']
for planet in planets:
    print(planet)
-

Результат работы скрипта:

Земля
Марс
Меркурий
Венера
Юпитер

При помощи цикла for мы вывели на печать все имеющиеся в списке планеты. Такого же результата можно добиться через индексы (на основании длины списка). Функция range генерирует целые числа в заданном диапазоне. Так как всего у нас 5 планет, то в нее можно передать параметр 5. С другой стороны, для этого также подойдет длина списка.

-
planets = ['Земля', 'Марс', 'Меркурий', 'Венера', 'Юпитер']
for index in range(5):
    print(planets[index])
for index in range(len(planets)):
    print(planets[index])
-

Результат работы скрипта (нижеследующее выведется 2 раза):

Земля
Марс
Меркурий
Венера
Юпитер

Цикл while требует условие выхода, так как в противном случае может выполняться бесконечно. Хоть может и показаться, что эта бесконечность не нужна, в ряде случаев без нее никак: например, показывать окно программы до тех пор, пока пользователь ее не закрыл.

Реализуем следующую задумку: выведем все числа от 50 до 100 включительно, которые делятся на 7, но не делятся на 2.

-
start_number = 50
while start_number <= 100:
    if start_number % 7 == 0 and start_number % 2 != 0:
        print(start_number)
    start_number += 1
-

Результат работы скрипта:

63
77
91

Всего таких числа 3. Важно не забыть на каждой итерации увеличивать исходное число, иначе оно никогда не станет равным 100.

Функции

Очень часто встречается, что один и тот же кусок кода необходимо использовать в разных местах. Дублирование – плохая практика, ведущая к ошибкам и сложностям изменений. В таких ситуациях на помощь приходят функции.

Чтобы создать функцию, перед ее именем следует написать ключевое слово def, а также обозначить параметры, если таковые есть. Выше мы уже встречали некоторые из них, которые встроены в Python (sum, print, input).

Ничто не мешает создать свои. Важно учесть и то, что функция всегда что-то возвращает (после ключевого слова return), хоть return и не обязателен (тогда вернется None, т.е. «ничто»).

Структура функции следующая:

def foo(param1, param2):
    что-то делаем…
    return значение

Создадим функцию, которая в зависимости от возраста пользователя будет выводить его статус. Если ему меньше 10 лет – то вернем сообщение «Ребенок», если от 10 до 16 – «Подросток», если от 16 до 20 – «Юноша», если от 20 до 35 – «Молодой человек», если от 35 до 45 – «Мужчина», если от 45 до 55 – «Солидный мужчина», если от 55 до 70 – «Зрелый ум», если от 70 до 120 – «Познавший смыслы». В любом другом случае предупредим пользователя: «Такого возраста не бывает».

-
def status(age):
    if type(age) is int:
        if 0 < age < 10:
            return 'Ребенок'
        elif 10 <= age < 16:
            return 'Подросток'
        elif 16 <= age < 20:
            return 'Юноша'
        elif 20 <= age < 35:
            return 'Молодой человек'
        elif 35 <= age < 45:
            return 'Мужчина'
        elif 45 <= age < 55:
            return 'Солидный мужчина'
        elif 55 <= age < 70:
            return 'Зрелый ум'
        elif 70 <= age < 120:
            return 'Познавший смыслы'
        else:
            return 'Такого возраста не бывает'
    return 'Такого возраста не бывает'


print(status(6))
print(status(34))
print(status(61))
print(status(-3))
print(status('Николай'))
-

Результат работы скрипта:

Ребенок
Молодой человек
Зрелый ум
Такого возраста не бывает
Такого возраста не бывает

Теперь в нашей программе можно использовать данную функцию множество раз с разными аргументами.

Модули, библиотеки, import

Язык Python хорош тем, что в него встроено большое количество модулей и библиотек по умолчанию. Более того, их можно дополнительно установить из официального репозитория при помощи команды «pip install название_модуля» в терминале проекта.

Модули (один файл) и библиотеки (несколько файлов с обязательным наличием документа __init__.py) расширяют возможности программистов и упрощают работу. Не нужно создавать велосипед заново, так как его уже кто-то сделал ранее для вас. Нужно лишь им воспользоваться, чтобы добраться из точки А в точку Б.

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

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

Перечислим все способы абсолютного импортирования в Питоне:

Общий импорт

-
import random
print(random.randint(2, 12))
-

Результат работы скрипта:

Сначала указываем модуль, а потом функцию через точку.

Импорт всех объектов (не рекомендуется, но не запрещен)

-
from random import *
print(randint(2, 12))
-

Результат работы скрипта:

Модуль указывать не требуется.

Импорт конкретной функции

-
from random import randint
print(randint(2, 12))
-

Результат работы скрипта:

Модуль указывать не надо, но остальные его функции и переменные недоступны.

Импорт функции с переименованием

-
from random import randint as r
print(r(2, 12))
-

Результат работы скрипта:

Импорт модуля с переименованием

-
import random as rnd
print(rnd.randint(2, 12))
-

Результат работы скрипта:

Работа с файлами

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

Попробуем сгенерировать 10 случайных целых чисел от 1 до 100 и записать их в текстовый файл «random.txt», а затем выведем их на печать в консоль из этого документа.

Нам понадобится контекстный менеджер with и функция open, а также знакомая функция print, которая умеет заносить данные в файл.

Познакомимся с двумя режимами работы open: «r» — чтение, «w» – запись.

-
from random import randint

# Создаем файл со случайными числами
with open('random.txt', 'w', encoding='utf-8') as doc:
    for number in range(10):
        print(randint(1, 100), file=doc)

# Читаем созданный файл и выводим на печать все сгенерированные числа
with open('random.txt', 'r', encoding='utf-8') as doc:
    for line in doc.readlines():
        print(line.strip())
-

Итак, контекстный менеджер with автоматически закрывает файл после своей работы (чтобы он не оставался в памяти).

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

Функция print может принимать дополнительный аргумент file, в котором указывается файл на запись.

Метод readlines считывает содержимое документа и формирует из его строк список, по которому мы проходимся. Так как в текстовом файле у нас есть переносы (они появились благодаря функции print, которая при каждом вызове начинает вывод с новой строки), их удобнее удалить с помощью метода strip, примененного к каждой строке.

Изучаем Python: куда дальше?

Чтобы быстро усвоить азы Питона, предоставленного в уроке материала достаточно. Конечно, этого мало, дабы стать специалистом. Поэтому придется самостоятельно дома или при помощи дополнительных курсов углублять знания. Выбор за вами, но некоторые рекомендации мы дадим.

Какие темы освоить в первую очередь? Приводим список тем и команд для новичков:

типы данных в Python;
необязательные и ключевые аргументы функций (*args, **kwargs), лямбда-выражения (lambda);
объекты и классы, инициализация;
основные встроенные модули (functools, math, string, sys, os, collections, time);
генераторы и итераторы (yield, iter);
работа с разными файлами (csv, изображения, текст);
исключения и ошибки (exceptions);
списковые включения (list comprehension);
работа с сетью (requests, BeautifulSoup).

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

Потом стоит переходить к серьезным трудам (типа М. Лутца), ознакомлению с популярными фреймворками и библиотеками (Django, flask, pandas).

Ответы на вопросы читателей

Насколько сложно выучить Python?

Азы Питона изучаются достаточно просто. Чтобы стать экспертом и высококлассным специалистом потребуется практика и решение реальных задач. Быстро выучить можно, было бы желание.

Какие программы можно создавать, овладев Питоном?

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

Сколько времени потребуется на изучение Питона?

Стандартных временных рамок не существует. Однако уже через 1-2 месяца при интенсивной самостоятельной работе с языком можно создавать простые парсеры, небольшие игры, автоматизаторы рутинных задач. А вообще, есть правило 10 тыс. часов – именно столько времени практики потребуется, чтобы посчитать себя специалистом хорошего уровня.

Есть ли слабые стороны у Питона?

У любого языка программирования они имеются. Во-первых, скорость работы несколько ниже, чем у компилируемых языков (С++, Java), но ее обычно хватает. Во-вторых, работа с 3d-графикой ограничена. В-третьих, отсутствует проверка типа переменной в момент компиляции.

Какая зарплата у Python-разработчика начинающего уровня?

В зависимости от региона она варьируется, но даже Junior-разработчик вполне может рассчитывать на 30-50 тыс. руб. в первые месяцы работы. По мере роста количества навыков лимиты повышаются в разы, а то и десятки раз.

Как лучше учить Python?

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

Где можно посмотреть задачи для новичков, простые проекты?

Чтобы попрактиковаться в навыках, необходимо решать разные задачи и сравнивать результаты с другими программистами. Для этого подойдут следующие ресурсы: https://www.codingame.com/, https://www.codewars.com/, https://www.hackerrank.com/. Здесь имеются задания для специалистов любого уровня.

Дополнительные источники (книги и сайты)

A byte of Python («Укус питона»). URL: https://python.swaroopch.com/
Pycharm – среда разработки. URL: https://www.jetbrains.com/ru-ru/pycharm/
Гэддис Тони. Начинаем программировать на Python – 2019, 768 c.
Дауни Аллен Б. Основы Python. Научитесь думать как программист. – 2021, 304 c.
Мюллер Дж. П. Python для чайников. – 2019, 416 с.
Официальный сайт Python. URL: https://www.python.org/
Портал программистов: ответы на любые вопросы. URL: https://ru.stackoverflow.com/

Подписывайтесь на наш канал в Telegram, чтобы получать свежие статьи своевременно!

Источник

#статьи

8 окт 2021
0

Отдел продаж проклял нас за эту статью! От вас — пара часов в день, от нас — список бесплатных материалов для входа и прокачки в Python.

Альберто Блинчиков для Skillbox Media

Кандидат философских наук, специалист по математическому моделированию. Пишет про Data Science, AI и программирование на Python.

Python — основной язык в Data Science и один из трёх главных языков в веб-разработке — вместе с PHP и JavaScript. Кроме того, он широко используется для администрирования сетей, автоматического тестирования, создания приложений и даже 3D-анимации.

Для каких задач подходит Python
5 проектов на Python
Для чего нужен Python

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

Так что если вы решаете, с какого языка вам вкатиться в программирование, то Python — ваш кандидат!

Изображение: SacroHelgo / Wikimedia Commons

Мы собрали для вас ссылки на обучающие материалы, которые накопились за годы работы Skillbox. Они бесплатны и разбиты по трём направлениям: основы, приложения, Data Science. Внутри каждого направления статьи отсортированы по возрастанию сложности: от простых до заковыристых.

Как вам выучить Python по нашим материалам:

Читаете статьи.
Смотрите видео.
Повторяете за преподавателем или автором.
Гуглите, если что-то совсем не получается.
Вбиваете в Telegram слово «Python» и присоединяетесь к лучшим чатам, где опытные питонисты смогут ответить на любой ваш вопрос — если захотят, конечно.

Настало время добрых советов — часть из них могут показаться банальными, но они и правда работают!

Выделите на занятия 1–2 часа ежедневно, чтобы знания не успевали выветриваться (согласно кривой забывания), и постарайтесь продержаться в таком темпе три недели — говорят, за этот срок вырабатывается привычка.

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

Проба.
Ошибка.
Google, чат или помощь друга.
Исправление ошибки.
GO TO п. 1.
???
Воскресенье PROFIT!

Только учтите — статьи и вебинары могут не отражать самые новые фишки языка. Что-то могло измениться: исчезли команды, обновились библиотеки, сервисы стали другими. Это не помешает учиться, но в каких-то мелочах придётся разобраться самостоятельно — и да, это часть ежедневной работы программиста.

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

Программировать на Python можно на своём компьютере, скачав и установив дистрибутив (рекомендуем Anaconda или PyCharm), либо в браузере, с помощью специальных сервисов (например, Google Colab).

Как новичку установить Python на компьютер
Как запустить Python на Linux, Windows, macOS
Как использовать сервис Google Colab

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

График курса доллара в Anaconda. Установим дистрибутив Anaconda, изучим синтаксис и нарисуем график курса доллара.
Облако слов на Python. Нарисуем облако самых частотных слов со страницы «Википедии» прямо в браузере с помощью Google Colab.
Устанавливаем библиотеку в Python. Основные способы: ручная установка, с помощью easy install и самый популярный — c помощью утилиты pip.
Вебинар «Рисуем дерево с помощью Python». Изучим чуть больше команд и функций, разберёмся с циклами и условиями, импортируем библиотеку для рисования.

Хороший программист — любопытный программист. Знание фишек и неочевидных нюансов языка — один из признаков хорошего программиста, пусть и начинающего.

11 вопросов про списки. Если на собеседовании спросят про эту структуру данных, вы будете знать, что отвечать.
Форматированные строки на примерах. Разбираем этот удобный и наглядный способ вывода строк.
Генераторы в Python: что это и зачем они нужны. Одна из характерных фичей Python — создание сложных объектов буквально в одну-две строки. Генераторы нужны в том числе и для этого.
15 коротких программ на Python. Короткие и понятные программы позволяют лучше понять язык.

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

Правильное объединение строк в Python. Да, можно просто объединять строки с помощью знака +, но это не лучший способ.
Декораторы: что отвечать на собеседовании. Функция, которая изменяет (декорирует) другую функцию. Звучит перспективно!
Случайные числа в Python. Случайностей не бывает, особенно в Python. Или…
Рефакторинг кода в Python. Большая часть работы программиста — не написание нового кода, а чтение и переделка (рефакторинг) старого. Будем же делать это правильно!

Кадр: фильм «Мстители. Война бесконечности»

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

Можно проматывать и ускорять видео, пересматривать сложные места — записи именно для этого и сделаны.

Анастасия Борнева, ведущий исследователь данных в Сбербанке, демонстрирует процесс создания нескольких простых программ в PyCharm. Бонусом — советы по началу карьеры в Python.

Никита Левашов, технический директор в Lia, учит основам хакинга на Python.

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

Эмиль Богомолов, инженер-исследователь из Сколтеха, показывает, как написать мессенджер на питоне.

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

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

Изображение: Public Domain

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

Галопом по питону: языковой минимум для начинающего дата-сайентиста.
Первичное преобразование данных: использование библиотеки Pandas.
Ваша первая модель машинного обучения.

Николай Герасименко, ведущий исследователь данных в «Сбере», научит вас делать умных чат-ботов.

В первый день познакомимся с архитектурой будущего чат-бота, узнаем, что такое NLU, а также, как обычно, освежим в памяти основы Python.
Во второй день научим чат-бота понимать текст. Для этого подготовим данные, превратим слова в числа, обучим модель и встроим её в чат-бота.
На третий день создадим Telegram-бота и запустим наконец-то наше приложение. Восстание машин уже близко!

Уже знакомый нам Никита Левашов покажет, как сделать приложение с нейронкой внутри.

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

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

Самое главное — не останавливаться. Путь программиста — это путь постоянного обучения, и Python-программисты не исключение. Эта статья — лишь начало вашего путешествия в огромный мир IT. Заметим, что совершенно необязательно идти туда в одиночестве.

На курсе «Профессия Python-разработчик» в Skillbox вы получите ещё больше структурированных знаний и концентрированного опыта. Вас ждут общение с единомышленниками, персональные консультации от действующих разработчиков и гарантированное трудоустройство по окончании обучения. Приходите, и да пребудет с вами дух Python! Import this!

Учись бесплатно:
вебинары по программированию, маркетингу и дизайну.

Участвовать

Школа дронов для всех
Учим программировать беспилотники и управлять ими.
Узнать больше

Источник

В данной статье мы затронем основы Python. Мы все ближе и ближе к цели, в общем, скоро приступим к работе с основными библиотеками для Data Science и будем использовать TensorFlow (для написания и развертывания нейросетей, тобишь Deep Learning).

Установка

Python можно скачать с python.org. Однако если он еще не установлен, то вместо
него рекомендую дистрибутивный пакет Anaconda, который уже включает в себя большинство библиотек, необходимых для работы в области науки о данных.

Если вы не используете дистрибутив Anaconda, то не забудьте установить менеджер пакетов pip, позволяющий легко устанавливать сторонние пакеты, поскольку некоторые из них нам понадобятся. Стоит также установить намного более удобную для работы интерактивную оболочку IPython. Следует учитывать, что дистрибутив Anaconda идет вместе с pip и IPython.

Пробельные символы

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

# пример отступов во вложенных циклах for
for i in [ 1, 2, 3, 4, 5] :
print (i) # первая строка в блоке for i
for j in (1, 2, З, 4, 5 ] :
print ( j ) # первая строка в блоке for j
print (i + j) # последняя строка в блоке for j
print (i) # последняя строка в блоке for i
print ( "циклы закончились ")

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

# пример многословного выражения
long_winded_computation = (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 +
11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20)

и легко читаемого кода:

# список списков
list_of_lists = [ [ 1 , 2, 3 ) , [4, 5, 6 ] , [ 7 , 8, 9 ] ]
# такой список списков легче читается
easy_to_read_list_of_lists = [1, 2, 3 ) ,
                             [4, 5, 6 ) ,
                             [7, 8, 9 ) ]

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

two_plus_three = 2 + 
3

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

for i in [ 1, 2, 3, 4, 5] :
# обратите внимание на пустую строку
print (1)

в стандартную оболочку Python вызовет ошибку:

# Ошибка нарушения отступа : ожидается блок с отступом
IndentationError : expected an indented blосk

потому что для интерпретатора пустая строка свидетельствует об окончании блока кода с циклом for.

Оболочка IPython располагает «волшебной» функцией %paste, которая правильно вставляет все то, что находится в буфере обмена, включая пробельные символы.

Модули (Импортирование библиотек)

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

Один из подходов заключается в том, чтобы просто импортировать сам модуль:

import re
my_regex = re.compile ("[0-9]+",re.I)

Здесь re — это название модуля, содержащего функции и константы для’ работы с регулярными выражениями. Импортировав таким способом весь модуль, можно обращаться к функциям, предваряя их префиксом re.

Если в коде переменная с именем re уже есть, то можно воспользоваться псевдонимом модуля:

import re as regex
my_regex = regex.compile("[0-9)+",regex.I)

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

Например, при визуализации данных на основе модуля matplotlib для него обычно
используют следующий стандартный псевдоним:

import matplotlib.pyplot as plt

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

from collections import defaultdict , Counter
lookup = defaultdict(int)
my_counter = Counter()

Функции

Функция — это правило, принимающее ноль или несколько входящих аргументов и возвращающее соответствующий результат. В Python функции обычно определяются при помощи оператора def:

def double(х) :
"""здесь, когда нужно, размещают
многострочный документирующий комментарий docstring,
который поясняет, что именно функция вычисляет.
Например, данная функция умножает входящее значение на 2"""
return х * 2

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

# применить функцию f к единице
def apply_to_one(f):
'""'вызывает функцию f с единицей в качестве аргумента """
return f(1)
my _ double = double # ссылка на ранее определенную функцию
х = apply_to_one(my_double) # = 2

Кроме того, можно легко создавать короткие анонимные функции или лямбда выражения:

у = apply_to_one(lambda х: х + 4) # = 5

Лямбда-выражения можно присваивать переменным. Однако рекомендуют пользоваться оператором def:

another double = lаmbdа х: 2 * х # так не делать
def another_double (x) : return 2 * х # лучше так

Параметрам функции, помимо этого, можно передавать аргументы по умолчанию, которые следует указывать только тогда, когда ожидается значение, отличающееся от значения по умолчанию:

def my_print (message="мoe сообщение по умолчанию" ):
print (message )
my_print ( "пpивeт") # напечатает 'привет'
my_print () # напечатает 'мое сообщение по умолчанию'

Иногда целесообразно указывать аргументы по имени:

# функция вычитания
def subtract ( a=0, Ь=0 ) :
return а - b
subtract (10, 5)# возвращает 5
subtract (0, 5)# возвращает -5
subtract (b=5 )# то же, что и в предыдущем примере

В дальнейшем функции будут использоваться очень часто.

Строки

Символьные строки (или последовательности символов) с обеих сторон ограничиваются одинарными или двойными кавычками (они должны совпадать):

single_quoted_string = ' наука о данных ' # одинарные
double_quoted_string = "наука о данных" # двойные

Обратная косая черта используется для кодирования специальных символов. Например:

tab_string = "t" # обозначает символ табуляции
len (tab_string)# = 1

Если требуется непосредственно сама обратная косая черта, которая встречается
в именах каталогов в операционной системе Windows, то при помощи r ‘»‘ можно создать неформатированную строку:

not_tab_string = r"t" # обозначает символы '  ' и ' t '
len (not_tab_string) # = 2

Многострочные блоки текста создаются при помощи тройных одинарных (или
двойных) кавычек:

multi_line_string = """Это первая строка .
это вторая строка
а это третья строка """

Исключения

Когда что-то идет не так, Python вызывает исключение. Необработанные исключения приводят к непредвиденной остановке программы. Исключения обрабатываются при помощи операторов try и except:

try:
print (0 / 0)
except ZeroDivisionError :
рrint ( "нельзя делить на ноль ")

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

Списки

Наверное, наиважнейшей структурой данных в Python является список. Это просто упорядоченная совокупность (или коллекция), похожая на массив в других языках программирования, но с дополнительными функциональными возможностями.

integer_list = [1, 2, З] # список целых чисел
heterogeneous_list = ["строка", 0.1 , True] # разнородный список
list_of_lists = [integer_list, heterogeneous_list, [] ] # список списков

list_length = len(integer_list) #длина списка = 3
list_sum = sum(integer_list)#сумма значений в списке = 6

Устанавливать значение и получать доступ к n-му элементу списка можно при помощи квадратных скобок:

х = list(range (10)) # задает список {0, 1 , . . . , 9]
zero = х [0] # = 0 , списки нуль-индексные, т. е . индекс 1-го элемента = 0
one = x [1] # = 1
nine = х [-1] # = 9, по-питоновски взять последний элемент
eight = х [-2] # = 8, по-питоновски взять предпоследний элемент
х [0] = -1 # теперь х = { - 1 , 1 , 2, 3, . . . , 9]

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

first_three = х[:З] # первые три = [-1 , 1, 2] 
three_to_end = х[3:] #с третьего до конца = {3, 4, ... , 9] 
one_to_four = х[1:5] # с первого по четвертый = {1 , 2, 3, 4] 
last_three = х[-3:] # последние три = { 7, 8, 9] 
without_first_and_last = x[1:-1] # без первого и последнего = {1 , 2, ... , 8] 
сору_ of _х = х[:] # копия списка х= [ -1, 1, 2, ... , 91

В Python имеется оператор ln, который проверяет принадлежность элемента списку:

1 ln [1, 2, 3] #True
0 ln [1, 2, 3] #False

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

Списки легко сцеплять друг с другом:

х = [1, 2, 3]
х. extend ( [ 4, 5, 6] ) # теперь х = {1, 2, 3, 4, 5, 6}

Если нужно оставить список х без изменений, то можно воспользоваться сложением списков:

х = [1, 2, 3]
у = х + [4, 5, 6] #у= (1, 2, 3, 4, 5, 6] ; х не изменился

Обычно к спискам добавляют по одному элементу за одну операцию:

х = [1, 2, 3]
x.append (0)# теперь х = [1,2,3,0]
у= х [-1] # = 0
z = len (x)# = 4

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

х, у = [1, 2] # теперь х = 1, у = 2

Если с обеих сторон выражения число элементов не одинаково, то будет выдано сообщение об ошибке ValueError.

Для отбрасываемого значения обычно используется символ подчеркивания:

_, у = [1, 2] # теперь у == 2, первый элемент не нужен

Кортежи

Кортежи — это неизменяемые (или иммутабельные) двоюродные братья списков.

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

my_list = [1, 2] # задать список
my_tuple = (1, 2) # задать кортеж
other_tuple = 3, 4 # еще один кортеж
my_list [1] = 3 # теперь my_list = [1 , 3]

try:
my_tuple [1] = 3
except ТypeError :
print ( "кортеж изменять нель зя" )

Кортежи обеспечивают удобный способ для возвращения из функций нескольких значений:

# функция возвращает сумму и произведение двух параметров
def sum_and_product (x, у ) :
return (х + у) , (х * у)
sp = sum_and_product (2, 3) # = (5, 6)
s, р = sum_and_product (S, 10) # s = 15, р = 50

Кортежи (и списки) также используются во множественном присваивании:

х, у = 1, 2 # теперь х = 1, у = 2
х, у = у, х # обмен переменными по-питоновски; теперь х = 2, у = 1

Словари

Словарь или ассоциативный список — это еще одна основная структура данных.

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

empty_dict = {} # задать словарь по-питоновски
empty_dict2 = dict () # не совсем по-питоновски
grades = { "Grigoriy" : 80, "Tim" : 95 } # литерал словаря (оценки за экзамены)

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

rigory_aleksee =  grades[ "Grigoriy"] # = 80

При попытке запросить значение, которое в словаре отсутствует, будет выдано сообщение об ошибке KeyError:

try:
kates_grade = grades [ "Kate "]
except КeyError:
рrint ( "оценки для Кэйт отсутствуют ! " )

Проверить наличие ключа можно при помощи оператора in:

grigoriy_has_grade = "Grigoriy" in grades #true
kate_has_grade = "Kate" in grades #false

Словари имеют метод get(), который при поиске отсутствующего ключа вместо вызова исключения возвращает значение по умолчанию:

grigoriy_grade = grades. get ( "Grigoriy ", 0)  # =80
kates_grade = grades.get ("Kate" , 0) # = 0 
no_ones_grade = grades.get ( "No One" ) # значение по умолчанию = None

Присваивание значения по ключу выполняется при помощи тех же квадратных скобок:

grades [ "Tim" ] = 99 # заменяет старое значение
grades [ "Kate"] = 100 # добавляет третью запись
num_students = len(grades) # = 3

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

tweet = {
"user" : " grinaleks",
"text" : "Наука о данных - потрясающая тема",
" retweet_count" : 100,
"hashtags " : [ "# data", " #science", " #datascience " , " #awesome", "#yolo" ] }

Помимо поиска отдельных ключей можно обратиться ко всем сразу:

tweet_keys = tweet.keys() # список ключей
tweet_values = tweet.values() # список значений
tweet_items = tweet.items() # список кортежей (ключ, значение)

"user" in tweet_keys # True, но использует медленное in списка
"user" in tweet # по-питоновски, использует быстрое in словаря
"grinaleks" in tweet_values # True

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

Словарь defaultdict

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

# частотности слов
word_ counts = { }
document = { } # некий документ; здесь он пустой
for word in document :
if word in word counts:
word_counts [word] += 1
else :
word_counts [word] = 1

Кроме этого, можно воспользоваться nриемом под названием «лучше просить прощения, чем разрешения» и перехватывать ошибку при попытке обратиться к отсутствующему ключу:

word_ counts = { }
for word in document :
try:
word_counts [word] += 1
except КeyError :
word_counts [word] = 1

Третий прием — использовать метод get(), который изящно выходит из ситуации с отсутствующими ключами:

word_counts = { }
for word in document :
previous_count = word_counts.get (word, 0)
word_counts [word] = previous_count + 1

Все перечисленные приемы немного громоздкие, и по этой причине целесообразно использовать словарь defaultdict (который еще называют словарем со: значением по умолчанию). Он похож на обычный словарь за исключением одной особенности — при попытке обратиться к ключу, которого в нем нет, он сперва добавляет для него значение, используя функцию без аргументов, которая предоставляется при его создании. Чтобы воспользоваться словарями defaultdict, их необходимо импортировать из модуля collections:

from collections import defaultdict

word_counts = defaultdict(int) # int () возвращает 0
for word in document :
word_counts[word] += 1

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

dd_list = defaultdict (list)# list () возвращает пустой список
dd_list [2].append (l) # теперь dd_list содержит (2: {1] }
dd_dict = defaultdict (dict ) # dict () возвращает пустой словарь dict
dd_dict ["Grigoriy"] [ "City" ] = "Seattle" # { "Grigoriy" : { "City" : Seattle"}
dd_pair = defaultdict (lambda: [0,0] )
dd_pair [2][1] = 1 # теперь dd_pair содержит (2 : {0,1] }

Эти возможности понадобятся, когда словари будут использоваться для «сбора»
результатов по некоторому ключу и когда необходимо избежать повторяющихся
проверок на присутствие ключа в словаре.

Словарь Counter

Подкласс словарей counter трансформирует последовательность значений в похожий на словарь defaultdict(int) объект, где ключам поставлены в соответствие частотности или, выражаясь более точно, ключи отображаются (map) в частотности.

Он в основном будет применяться при создании гистограмм:

from collections import Counter
с = Counter([0,1,2,0]) # в результате с = { 0 : 2, 1 : 1, 2 : 1 }

Его функционал позволяет достаточно легко решить задачу подсчета частотностей слов:

# лучший вариант подсчета частотностей слов
word_counts = Counter (document)

Словарь counter располагает методом most_common( ), который нередко бывает полезен:

# напечатать 10 наиболее встречаемых слов и их частотность (встречаемость)
for word, count in word_counts.most_common(10) :
print (word, count )

Множества

Структура данных set или множество представляет собой совокупность неупорядоченных элементов без повторов:

s = set ()# задать пустое множество
s.add (1) # теперь s = { 1 }
s.add (2) # теперь s = { 1, 2 }
s.add (2) # s как и прежде = { 1, 2 }
х = len (s) # = 2
у = 2 in s # = True
z = 3 in s # = False

Множества будут использоваться по двум причинам. Во-первых, операция in на множествах очень быстрая. Если необходимо проверить большую совокупность элементов на принадлежность некоторой последовательности, то структура данных set подходит для этого лучше, чем список:

# список стоп-слов
stopwords_list = [ "a", "an" , "at "] + hundreds_of_other_words + [ "yet ", " you"]
" zip" in stopwords_list # False, но проверяется каждый элемент
# множество стоп-слов
stopwords_set = set(stopwords_list)
" zip" in stopwords_set # очень быстрая проверка

Вторая причина — получение уникальных элементов в наборе данных:

item_list = [1, 2, 3, 1, 2, 3] # список
num_items = len( item_list) # количество = 6
item_set = set(item_list) # вернет множество (1, 2, 3}
num_distinct_items = len(item_set) # число недублирующихся = 3
distinct_item_list = list(item_set) # назад в список = [1,2,3]

Множества будут применяться намного реже словарей и списков.

Управляющие конструкции

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

if 1 > 2:
message "если 1 была бы больше 2 . . . "
elif 1 > 3:
message "elif означает 'else if '"
else:
message = " когда все предыдущие условия не выполняются, используется else "

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

parity = "четное" if х % 2 === О else "нечетное "

В Python имеется цикл whlle:

х = 0
while х < 10:
print (x, "меньше 10")
х += 1

Однако чаще будет использоваться цикл for совместно с оператором in:

for х in range (lO) :
print (x, "меньше 10" )
51

Если требуется более сложная логика управления циклом, то можно воспользоваться операторами

continue и break:
for х 1n range (10) :
1f х == 3:
continue # перейти сразу к следующей итерации
if х == 5:
break
print (x)
# выйти из цикла

В результате будет напечатано 0, 1, 2 и 4.

Истинность

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

one_is_less_than_two = 1 < 2 #True
true_equals_false = True == False #False

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

х = None
print (x == None )# напечатает True, но это не по-питоновски
print ( х is None ) # напечатает True по-питоновски

В Python может использоваться любое значение там, где ожидается логический тип Boolean. Все следующие элементы имеют логическое значение False:

False; .
None;
set() (множество):
[] (пустой список);
{} (пустой словарь);

Практически все остальное рассматривается как True. Это позволяет легко применять операторы if для проверок на наличие пустых списков. пустых строк, пустых словарей и т. д. Иногда, правда, это приводит к труднораспознаваемым ошибкам, если не учитывать следующее:

s = some_function_that_returns_a_string () # возвращает строковое значение
if s:
first_char = s [0] # первый символ в строке
else:
first char = ""

Вот более простой способ сделать то же самое:

first_char = s and s [0]

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

safe х = х or 0 # безопасный способ

Встроенная функция all языка Python берет список и возвращает True только тогда, когда каждый элемент списка истинен, а встроенная функция any возвращает тrue, когда истинен хотя бы один элемент:

all ( [True, 1, { 3 }]) # True
all ( [True, 1, {}] ) # False, {} = ложное
any ( [ True, 1, {}]) # True, True = истинное
all ( [] ) # True, ложные элементы в списке отсутствуют
any ( [ ] ) # False, истинные элементы в списке отсутствуют

Источник