Основы языка Python за 20 минут

1 Комментарий / Основы / От

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

Скачивайте книги ТОЛЬКО на русском языке у нас в телеграм канале: PythonBooksRU

Содержание

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

В Python переменная – это именованная область, в которой может храниться значение. Чтобы создать переменную, используйте имя переменной, затем символ = и значение. Например: имя_переменной = значение.

cats_count = 10

Здесь cats_count – это переменная, которая хранит значение 10.

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

  1. Числовые типы данных:
    • Integer (int) – представляет целые числа, такие как 42 или -7.
    • Float (float) – представляет десятичные числа, такие как 3,14 или -0,5.
    • Complex (complex) – представляет числа с вещественной и мнимой составляющей, например 1 + 2j.
  2. Булев тип данных (bool) – представляет значение True или False.
  3. Последовательные типы данных:
    • String (str) – представляет собой последовательность символов, например "Hello, World!".
    • Список (list) – представляет собой упорядоченную коллекцию элементов, например [1, 2, 3].
    • Кортеж (tuple) – аналогичен списку, но является неизменяемым, например (1, 2, 3).
  4. Тип данных отображения:
    • Словарь (dict) – представляет собой набор пар ключ-значение, например {"name": "John", "age": 30}.
  5. Множество (set) представляет собой неупорядоченную коллекцию уникальных элементов, например {1, 2, 3}.

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

Работа со строками

Форматирование строк в Python

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

1. Конкатенация. Вы можете объединять строки и переменные с помощью оператора +. Например:

name = "John" 
age = 30 
message = "My name is " + name + " and I am " + str(age) + " years old."

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

2. Оператор %. Его можно использовать для подстановки значений в строковый шаблон. Например:

name = "John" 
age = 30 
message = "My name is %s and I am %d years old." % (name, age)

Здесь %s – заполнитель для строкового значения, а %d – для десятичного (целого) значения. Подставляемые значения представлены в виде кортежа (name, age).

3. str.format(). Для вставки значений в строковый шаблон можно использовать метод str.format(). Например:

name = "John" 
age = 30 
message = "My name is {} and I am {} years old.".format(name, age)

Здесь фигурные скобки {} используются для указания места вставки значений. Подставляемые значения указываются в методе format().

4. f-строки. Это самый новый и широко используемый способ форматирования строк в Python. С помощью f-строк можно подставлять значения в шаблон, используя фигурные скобки {}. Например:

name = "John" 
age = 30 
message = f"My name is {name} and I am {age} years old."

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

Примечание редакции. Подробнее читайте в статье “f-строки в Python”.

Строковые методы Python

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

  • str.upper() переводит все символы в строке в верхний регистр
  • str.lower() преобразует все символы в строке в нижний регистр
  • str.strip() удаляет пробельные символы (пробелы, табуляции и символы новой строки) из начала и конца строки
  • str.split() разбивает строку на список подстрок по заданному разделителю
  • str.join() объединяет список строк в одну строку с использованием указанного разделителя
  • str.replace() заменяет все вхождения указанной подстроки в строке на другую подстроку
  • str.startswith() возвращает True, если строка начинается с указанной подстроки, иначе False
  • str.endswith() возвращает True, если строка заканчивается указанной подстрокой, иначе False
name = "John Doe"
name = name.lower()
print(name)
# john doe

Это лишь некоторые из множества строковых методов, доступных в Python. Более подробную информацию о строковых методах можно найти в документации по Python.

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

Структуры данных в Python

Список

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

my_list = [1, 2, 3, "apple", "banana", "cherry"]

Здесь my_list – это список, содержащий три целых числа и три строки.

Примечание редакции. О том, какие типы данных изменяемы, а какие – нет, читайте в статье “Что такое изменяемые типы данных в Python”.

Доступ к отдельным элементам списка осуществляется по их индексу, который начинается с 0 для первого элемента списка. Например:

print(my_list[0]) # выводит 1
print(my_list[3]) # выводит "apple".

Для доступа к элементам из конца списка можно также использовать отрицательную индексацию. Например:

print(my_list[-1]) # выводит " cherry"
print(my_list[-3]) # печатает "apple".

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

  • list.append(item) добавляет элемент в конец списка
  • list.insert(index, item) вставляет элемент на указанную позицию в списке
  • list.remove(item) удаляет первое вхождение указанного элемента из списка
  • list.pop(index) удаляет и возвращает элемент, находящийся на указанной позиции в списке
  • list.sort() сортирует элементы списка в порядке возрастания
  • list.reverse() изменяет порядок следования элементов в списке
  • len(list) возвращает количество элементов в списке
my_list.append('new')
print(my_list) # [1, 2, 3, 'apple', 'banana', 'cherry', 'new']
my_list.remove('new')
print(my_list) # [1, 2, 3, 'apple', 'banana', 'cherry']

Вы также можете использовать срезы для извлечения подпоследовательности из списка. Для срезов используется оператор двоеточия : для указания начального индекса (включительно) и конечного индекса (исключительно) подпоследовательности. Например:

my_list = [1, 2, 3, 4, 5]
sub_list = my_list[1:4]  # returns [2, 3, 4]

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

Кортеж

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

my_tuple = (1, 2, 3, "apple", "banana", "cherry")

Здесь my_tuple – это кортеж, содержащий три целых числа и три строки.

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

print(my_tuple[0]) # выводит 1
print(my_tuple[3]) # выводит "apple".

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

my_tuple[0] = 4 # выдаст TypeError: object 'tuple' does not support item assignment

Примечание редакции. О том, что такое ошибка в Python, можно почитать в статье “Ошибки и исключения в Python”.

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

  • tuple.count(value) возвращает количество вхождений указанного значения в кортеже
  • tuple.index(value) возвращает индекс первого появления указанного значения в кортеже
  • len(tuple) возвращает количество элементов в кортеже

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

def get_name_and_age():
    name = "John"
    age = 30
    return name, age

result = get_name_and_age()
print(result) # выводит (" John", 30)

Здесь функция get_name_and_age() возвращает кортеж, содержащий два значения: имя и возраст человека. Кортеж распаковывается в переменную result, которая содержит эти два значения в виде отдельных переменных.

Множество

В языке Python множество – это неупорядоченная коллекция уникальных элементов. Множества создаются путем заключения последовательности значений, разделенных запятыми, в фигурные скобки {} или с помощью функции-конструктора set(). Например:

my_set = {1, 2, 3, 4, 4, 5}

Здесь my_set – это множество, содержащее пять уникальных целых чисел (вторая четвертка во множество my_set не попадет).

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

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

  • set.add(element) добавляет элемент в множество
  • set.remove(element) удаляет элемент из множества. Вызывает ошибку KeyError, если во множестве нет указанного элемента
  • set.discard(element) удаляет элемент из множества, если он присутствует. Не выдает ошибку, если элемент отсутствует во множестве
  • set.pop() удаляет и возвращает произвольный элемент из множества
  • set.clear() удаляет все элементы из множества
  • set.union(other_set) возвращает новое множество, содержащее все элементы из обоих множеств
  • set.intersection(other_set) возвращает новое множество, содержащее только элементы, общие для обоих множеств
  • set.difference(other_set) возвращает новое множество, содержащее только те элементы, которые есть в первом множестве, но отсутствуют во втором
  • set.symmetric_difference(other_set) возвращает новое множество, содержащее только те элементы, которые есть либо в первом, либо во втором множестве, но не в обоих
  • len(set) возвращает количество элементов во множестве

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

my_list = [1, 2, 3, 4, 4, 5]
my_set = set(my_list)
print(my_set) # выводит {1, 2, 3, 4, 5}.

Здесь конструктор set() используется для создания множества из списка my_list, содержащего дублирующиеся элементы. Результирующее множество my_set содержит только уникальные элементы из списка my_list.

Словарь

В языке Python словарь – это неупорядоченная коллекция пар ключ-значение. Словари создаются путем заключения последовательности пар ключ-значение, разделенных запятыми, в фигурные скобки {} или с помощью функции-конструктора dict(). Например:

my_dict = {"apple": 2, " banana": 3, " cherry": 5}

Здесь my_dict – это словарь, в котором ключам “apple”, “banana” и “cherry” сопоставлены значения 2, 3 и 5 соответственно.

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

print(my_dict["apple"]) # выводит 2

Также можно добавлять в словарь новые пары ключ-значение, например, так:

my_dict["orange"] = 4

Можно изменять значение, связанное с ключом в словаре:

my_dict["banana"] = 6

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

del my_dict["cherry"]

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

Вот некоторые из этих методов:

  1. dict.keys() возвращает все ключи в словаре
  2. dict.values() возвращает список значений в словаре
  3. dict.items() возвращает список пар ключ-значение в словаре
  4. dict.get(key, default=None) возвращает значение, связанное с ключом в словаре, или значение default, если ключ отсутствует
  5. dict.pop(key, default=None) удаляет и возвращает значение, связанное с ключом в словаре, или значение default, если ключ отсутствует
  6. dict.update(other_dict) добавляет в словарь все пары ключ-значение из переданного словаря other_dict, перезаписывая значения для ключей, которые уже существуют в словаре
  7. len(dict) возвращает количество пар ключ-значение в словаре

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

Функции в Python

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

def greet(name):
    print("Hello, " + name + "!")

Здесь greet – это функция, которая принимает параметр name и печатает приветствие.

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

greet("Alice") # выводит "Hello, Alice!".

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

def calculate_sum(a, b=0):
    return a + b

Здесь calculate_sum – это функция, принимающая два параметра, a и b, со значением по умолчанию 0 для b. Функция возвращает сумму a и b.

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

print(calculate_sum(5)) # выводит 5
print(calculate_sum(5, 10)) # выводит 15

Функции также могут возвращать значения, используя ключевое слово return. Например:

def calculate_product(a, b):
    return a * b

Здесь calculate_product – это функция, которая принимает два параметра, a и b, и возвращает их произведение.

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

result = calculate_product(3, 4)
print(result) # выводит 12

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

Условия в Python

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

Ниже приведен пример оператора if в Python:

x = 5
if x > 0:
    print("x is positive")

В этом примере оператор if проверяет, больше ли значение x нуля. Если условие истинно, то выполняется оператор print, и на консоль выводится сообщение "x is positive".

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

Например:

x = -3
if x > 0:
    print("x is positive")
else:
    print("x is non-positive")

В данном примере, поскольку значение x отрицательно, условие if ложно, и вместо него выполняется блок else. На консоль выводится сообщение "x is non-positive".

Для проверки дополнительных условий после начального оператора if можно также использовать оператор elif (сокращение от “else if”). Например:

x = 0
if x > 0:
    print("x is positive")
elif x < 0:
    print("x is negative")
else:
    print("x is zero")

В данном примере, поскольку x равно нулю, первое условие if ложно, и вместо него проверяется условие elif. Поскольку x также не отрицателен, вместо него выполняется блок else. В консоль выводится сообщение "x is zero".

В условных операторах Python также можно использовать логические операторы and, or и not для объединения нескольких условий. Например:

x = 10
if x > 0 and x < 100:
    print("x is a positive two-digit number")

В данном примере условие if проверяет, является ли x одновременно больше нуля и меньше 100. Если условие истинно, то выполняется функция print.

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

Циклы в Python

Циклы позволяют выполнять блок кода несколько раз. В Python существует два типа циклов: цикл for и цикл while.

Цикл for используется для итерации по последовательности значений, например, по списку или строке. Пример:

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

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

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

i = 0
while i < 5:
    print(i)
    i += 1

В этом примере цикл while выводит значение i на консоль и каждый раз увеличивает его на 1, пока i не станет меньше 5.

Для управления ходом цикла можно также использовать операторы break и continue. Оператор break позволяет преждевременно завершить цикл, а оператор continue – пропустить текущую итерацию цикла. Например:

for i in range(10):
    if i == 5:
        break
    elif i % 2 == 0:
        continue
    print(i)

В этом примере цикл for печатает значения i от 0 до 9, но использует оператор break для преждевременного выхода из цикла, когда i равно 5. Также используется оператор continue для пропуска четных значений i.

Примечание редакции. Циклы в Python также могут находиться внутри других циклов. Об этом читайте в статье “Вложенные циклы в Python”.

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

Модули в Python

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

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

import math

print(math.sqrt(25))  # prints 5.0
print(math.sin(math.pi / 2))  # prints 1.0

В этом примере мы импортируем модуль math и используем его функции sqrt и sin для вычисления квадратного корня из 25 и синуса из pi/2, соответственно.

Также можно импортировать определенные функции или переменные из модуля с помощью ключевого слова from. Например:

from math import sqrt, pi

print(sqrt(25))  # prints 5.0
print(pi)  # prints 3.141592653589793

В этом примере мы импортируем из модуля math только функции sqrt и pi, что позволяет использовать их напрямую, без префикса math.

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

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

Классы и объекты

Класс в Python – это шаблон или “чертеж” для создания объектов, объединяющих данные (переменные) и функции (методы) для работы с ними. Класс определяет структуру и поведение объектов определенного типа, что позволяет создавать и управлять данными более организованным и модульным способом.

Ниже приведен пример простого класса в Python:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

В этом примере мы определяем класс Person с двумя атрибутами (name и age) и одним методом (say_hello). Метод __init__ – это специальный метод, который вызывается при создании объекта класса. Он инициализирует атрибуты name и age со значениями, переданными в качестве аргументов.

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

person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

В данном примере мы создаем два объекта (person1 и person2) из класса Person с разными значениями атрибутов name и age.

Мы можем вызвать метод say_hello для каждого объекта, чтобы отобразить приветствие:

person1.say_hello() # выводит "Hello, my name is Alice and I am 25 years old.".
person2.say_hello() # выводит "Hello, my name is Bob and I am 30 years old.".

В этом примере мы вызываем метод say_hello для каждого объекта, чтобы вывести персональное приветствие.

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

Заключение

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

Перевод статьи «Master the Basics of Python in 20 Minutes».

1 комментарий к “Основы языка Python за 20 минут”

Оставьте комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *