Наглядно синтаксис словарей выглядит следующим образом:

items_dict = {"vehicle": "Tesla", "fruit": "apple", "lucky_number": 7}

Вот ещё один пример словаря, где ключами являются числа, а значениями — строки:

gender_dict = {0: 'woman',
               1: 'man'}

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

Другой способ создать словарь - это использовать функцию dict().

empty_dict = dict()

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

Параметры:

• kwarg - ключевые аргументы one=1, two=2, three=3
• iterable - итерируемый объект, например список следующего вида [('one', 1), ('two', 2), ('three', 3)]
• mapping - словарь, например {'three': 3, 'two': 2, 'one': 1}

Если позиционный аргумент не задан, создается пустой словарь, как в примере выше.

Примеры использования функции dict:

# создание словаря с помощью ключевых аргументов
dict_sample = dict(one=1, two=2, three=3)
print(dict_sample) # {'one': 1, 'two': 2, 'three': 3}

# создание словаря с помощью другого словаря
dict_sample = dict({0: 'orange', 1: 'pawpaw'})
print(dict_sample) # {0: 'orange', 1: 'pawpaw'}

# создание словаря с помощью последовательности
dict_sample = dict([(0,'apple'), (1,'pawpaw')])
print(dict_sample) # {0: 'apple', 1: 'pawpaw'}

Важно отметить некоторые особенности словарей:

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

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

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

items_dict = {"vehicle": "Tesla", "fruit": "apple", "lucky_number": 7}
print(items_dict["vehicle"])

Выведет:

Tesla

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

items_dict = {"vehicle": "Tesla", "fruit": "apple", "lucky_number": 7}

print(items_dict["test"])

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

print(items_dict["test"])
      ~~~~~~~~~~^^^^^^
KeyError: 'test'

Как получить элементы списка без ошибок?

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

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

items_dict = {"vehicle": "Tesla", "fruit": "apple", "lucky_number": 7}

print("vehicle" in items_dict)
print("qwerty" in items_dict)
print("123" in items_dict)

Выведет:

True
False
False

Второй способ. Использование специального метода get(key[, default])

Этот метод возвращает значение для ключа, если ключ находится в словаре, иначе возвращает значение по умолчанию default. Если значение по умолчанию не задано, метод возвращает None (но никогда не возвращает исключение).

Добавление и изменение содержимого словаря

Добавление новых пар в словарь происходит достаточно просто:

temp_dict = {}
temp_dict["key"] = "value"
print(temp_dict)

в результате получим:

{"key": "value"}

Изменение выполняется абсолютно также:

temp_dict = {"key": "value"} 
temp_dict["key"] = "new_value" 
print(temp_dict["key"])

Вывод программы:

new_value

Для добавления/изменения сразу нескольких объектов в словаре, используется специальный метод update([other]). Он обновляет словарь парами ключ-значение из other, перезаписывая существующие ключи.

В дальнейших примерах мы будем использовать следующий словарь, содержащий в себе информацию о студентах:

students = {
    'Alice': {'age': 22, 'major': 'Computer Science'},
    'Bob': {'age': 21, 'major': 'Mathematics'}
}

Пример 1: Добавление нового студента

new_student = {'Charlie': {'age': 23, 'major': 'Physics'}}
students.update(new_student)

print(students)

Получим:

{'Alice': {'age': 22, 'major': 'Computer Science'}, 'Bob': {'age': 21, 'major': 'Mathematics'}, 'Charlie': {'age': 23, 'major': 'Physics'}}

Пример 2: Обновление информации о существующем студенте

update_info = {'Bob': {'age': 22, 'major': 'Data Science'}}
students.update(update_info)

print(students)

Получим:

{'Alice': {'age': 22, 'major': 'Computer Science'}, 'Bob': {'age': 22, 'major': 'Data Science'}, 'Charlie': {'age': 23, 'major': 'Physics'}}

Пример 3: Добавление нового студента и обновление информации о другом с помощью ключевых аргументов

students.update({'David': {'age': 24, 'major': 'Biology'}}, Alice={'age': 23, 'major': 'Artificial Intelligence'})

print(students)

Получим:

{'Alice': {'age': 23, 'major': 'Artificial Intelligence'}, 'Bob': {'age': 22, 'major': 'Data Science'}, 'Charlie': {'age': 23, 'major': 'Physics'}, 'David': {'age': 24, 'major': 'Biology'}}

Пример 4: Обновление словаря с помощью итерируемого объекта

students.update([('Eve', {'age': 25, 'major': 'Chemistry'}), ('Charlie', {'age': 24, 'major': 'Quantum Physics'})])

print(students)

Получим:

{'Alice': {'age': 23, 'major': 'Artificial Intelligence'}, 'Bob': {'age': 22, 'major': 'Data Science'}, 'Charlie': {'age': 24, 'major': 'Quantum Physics'}, 'David': {'age': 24, 'major': 'Biology'}, 'Eve': {'age': 25, 'major': 'Chemistry'}}

Пример 5: Обновление словаря с помощью другого словаря, содержащего вложенные словари

new_data = {
    'Alice': {'age': 24, 'major': 'Machine Learning'},
    'Frank': {'age': 26, 'major': 'Economics'}
}
students.update(new_data)

print(students)

Результат:

{'Alice': {'age': 24, 'major': 'Machine Learning'}, 'Bob': {'age': 22, 'major': 'Data Science'}, 'Charlie': {'age': 24, 'major': 'Quantum Physics'}, 'David': {'age': 24, 'major': 'Biology'}, 'Eve': {'age': 25, 'major': 'Chemistry'}, 'Frank': {'age': 26, 'major': 'Economics'}}

Удаление элементов из словаря

Для удаления элемента из словаря можно использовать либо оператор del dict[key], либо метод dict.pop(key[, default]). В первом случае из словаря удаляется соответствующая пара. Или, если такого ключа нет, возвращается KeyError.

Пример 1: Использование del для удаления элемента

temp_dict = {"key": "value"}

# Удаляем элемент с ключом "key"
del temp_dict["key"]
print(f"temp_dict = {temp_dict}")

# Удаляем элемент с несуществующим ключом
del temp_dict["python"]

Результат:

temp_dict = {}
Traceback (most recent call last): 
  File "", line 1, in 
KeyError: 'python'

Метод dict.pop(key[, default]) удаляет из словаря элемент с заданным ключом и возвращает его значение. Если ключ отсутствует, метод возвращает значение default . Если значение default не задано и ключа не существует, метод pop() вызовет исключение KeyError.

Пример 2: Использование dict.pop(key[, default]) для удаления элемента

temp_dict = {"key": "value"}

deleted_value = temp_dict.pop("key")

print(f"Удаленное значение: {deleted_value}")
print(f"temp_dict = {temp_dict}\n")

deleted_value = temp_dict.pop("non_existent_key", "default_value")

print(f"Возвращенное значение: {deleted_value}")
print(f"temp_dict = {temp_dict}")

Результат:

Удаленное значение: value
temp_dict = {}

Возвращенное значение: default_value
temp_dict = {'key': 'value'}

Пример 3: Использование dict.pop(key[, default]) с отсутствующим ключом без значения по умолчанию

temp_dict = {"key": "value"}

value = temp_dict.pop("non_existent_key")

print(f"temp_dict = {temp_dict}")

Результат:

Traceback (most recent call last):
  File "", line 4, in <module>
    value = temp_dict.pop("non_existent_key")
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
KeyError: 'non_existent_key'

Методы словарей

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

1. copy()

Сигнатура:

dict.copy()

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

Пример:

dict1 = {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}
dict2 = dict1.copy()
print(dict2)  # Выведет {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}

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

Пример:

import copy

# Исходный словарь с вложенными списками
original_dict = {
    'a': [1, 2, 3],
    'b': (4, 5, 6),
    'c': {7, 8, 9}
}

# Создаем поверхностную копию
shallow_copy = original_dict.copy()

# Изменяем вложенный список в поверхностной копии
shallow_copy['a'].append(4)

# Выводим оригинальный словарь и поверхностную копию
print("Оригинальный словарь:", original_dict)
print("Поверхностная копия:", shallow_copy)

Результат:

Оригинальный словарь: {'a': [1, 2, 3, 4], 'b': (4, 5, 6), 'c': {8, 9, 7}}
Поверхностная копия: {'a': [1, 2, 3, 4], 'b': (4, 5, 6), 'c': {8, 9, 7}}

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

Чтобы избежать этой проблемы, можно создать глубокую копию словаря, используя функцию copy.deepcopy(x). Глубокая копия создает независимую копию всех вложенных объектов.

Пример:

import copy

# Исходный словарь с вложенными списками
original_dict = {
    'a': [1, 2, 3],
    'b': (4, 5, 6),
    'c': {7, 8, 9}
}

# Создаем глубокую копию
deep_copy = copy.deepcopy(original_dict)

# Изменяем вложенный список в глубокой копии
deep_copy['a'].append(4)

# Выводим оригинальный словарь и глубокую копию
print("Оригинальный словарь:", original_dict)
print("Глубокая копия:", deep_copy)

Результат:

Оригинальный словарь: {'a': [1, 2, 3], 'b': (4, 5, 6), 'c': {8, 9, 7}}
Глубокая копия: {'a': [1, 2, 3, 4], 'b': (4, 5, 6), 'c': {8, 9, 7}}

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

Пояснения:

• Поверхностная копия: Создает копию словаря, но вложенные объекты (списки, кортежи, множества) остаются ссылками на оригинальные объекты.
• Глубокая копия: Создает полностью независимую копию словаря, включая все вложенные объекты.

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

2. get(key[, default])

Синтаксис:

dict.get(key[, default])

Описание:
Возвращает значение по указанному ключу. Если ключ отсутствует, возвращает значение default (по умолчанию None).

Пример:

dict1 = {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}
print(dict1.get('car'))  # Выведет 'машина'
print(dict1.get('home', 'дом'))  # Выведет 'дом', так как ключ 'home' отсутствует

3. clear()

Синтаксис:

dict.clear()

Описание:
Удаляет все элементы из словаря.

Пример:

dict1 = {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}
dict1.clear()
print(dict1)  # Выведет {}

4. keys()

Синтаксис:

dict.keys()

Описание:
Возвращает объект представления, содержащий все ключи словаря.

Пример:

dict1 = {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}
print(dict1.keys())  # Выведет dict_keys(['car', 'apple', 'orange'])

5. values()

Синтаксис:

dict.values()

Описание:
Возвращает объект представления, содержащий все значения словаря.

Пример:

dict1 = {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}
print(dict1.values())  # Выведет dict_values(['машина', 'яблоко', 'апельсин'])

6. items()

Синтаксис:

dict.items()

Описание:
Возвращает объект представления, содержащий пары ключ-значение в виде кортежей.

Пример:

dict1 = {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}
print(dict1.items())  # Выведет dict_items([('car', 'машина'), ('apple', 'яблоко'), ('orange', 'апельсин')])

7. pop(key[, default])

Синтаксис:

dict.pop(key[, default])

Описание:
Удаляет элемент с указанным ключом и возвращает его значение. Если ключ отсутствует, возвращает значение default (если оно указано) или вызывает исключение KeyError.

Пример:

dict1 = {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}
print(dict1.pop('car'))  # Выведет 'машина'
print(dict1.pop('home', 'дом'))  # Выведет 'дом', так как ключ 'home' отсутствует
print(dict1)  # Выведет {'apple': 'яблоко', 'orange': 'апельсин'}

8. popitem()

Синтаксис:

dict.popitem()

Описание:
Удаляет и возвращает последнюю добавленную пару ключ-значение в виде кортежа. Если словарь пуст, метод вызывает исключение KeyError.

Пример:

dict1 = {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}
print(dict1.popitem())  # Выведет ('orange', 'апельсин')
print(dict1)  # Выведет {'car': 'машина', 'apple': 'яблоко'}

9. setdefault(key[, default])

Синтаксис:

dict.setdefault(key[, default])

Описание:
Возвращает значение по указанному ключу. Если ключ отсутствует, метод добавляет его в словарь со значением default (по умолчанию None).

Пример:

dict1 = {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}
print(dict1.setdefault('car'))  # Выведет 'машина'
print(dict1.setdefault('home', 'дом'))  # Выведет 'дом'
print(dict1)  # Выведет {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин', 'home': 'дом'}

10. update([other])

Синтаксис:

dict.update([other])

Описание:
Обновляет словарь, добавляя пары ключ-значение из другого словаря или итерируемого объекта. Существующие ключи перезаписываются новыми значениями.

Пример:

dict1 = {'car': 'машина', 'apple': 'яблоко', 'orange': 'апельсин'}
dict1.update({'car': 'автомобиль', 'home': 'дом'})
print(dict1)  # Выведет {'car': 'автомобиль', 'apple': 'яблоко', 'orange': 'апельсин', 'home': 'дом'}

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

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

Списки в Python, хотя и имеют ограниченное количество методов (всего 11), однако они весьма функциональны и часто применяются на практике. Я рекомендую вам внимательно изучить и запомнить эти методы, так как они являются ключевыми для работы со списками.

Метод 1. append(item)

Метод append(item) в Python - это метод, который позволяет нам добавить элементы в конец списка.

Синтаксис:

list_name.append(item)

где :

• list_name - это имя списка
• item - элемент, который мы хотим добавить в КОНЕЦ списка.

Рассмотрим применение этого метода, на примере:

Представим, что вы очень преданы программированию и ведёте все свои записи в виде кода. Ну что поделать, вот такие мы программисты:)
У вас есть список продуктов, которые вы хотите купить:

shop_list = ["bread", "milk", "egg"]

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

shop_list = ["bread", "milk", "egg"]
shop_list.append("cookie")

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

shop_list = ["bread", "milk", "egg"]
shop_list.append("cookie")
print(shop_list)

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

["bread", "milk", "egg", "cookie"]

Как вы можете заметить, мы добавили в КОНЕЦ нашего списка.

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

Метод 2. insert(index, item)

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

Синтаксис метода insert():

list_name.insert(index, item)

где:

• list_name — список, в который нужно вставить элемент;
• index — индекс позиции, на которую нужно вставить элемент;
• item — элемент, который нужно вставить в список.

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

Давайте добавим масло в наш список покупок перед молоком:

shopping_list = ["bread", "milk", "egg", "cookie"]
shopping_list.insert(1, "butter")

Проверим, что у нас получилось:

shopping_list = ["bread", "milk", "egg", "cookie"]
shopping_list.insert(1, "butter")
print(shopping_list)

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

["bread", "butter", "milk", "egg", "cookie"]

Как видите, масло теперь находится на втором месте в списке, перед молоком.

Отлично, по пути вы вспомнили о необходимых покупках, а вместе с этим и выучили два новых метода.

Метод 3. remove(item)

Метод remove() в Python позволяет удалить первый элемент из списка, который соответствует заданному значению. Если элемент не найден в списке, возникает ошибка ValueError.

Синтаксис метода remove():

list.remove(item)

где:

• list — список, из которого нужно удалить элемент;
• item — элемент, который нужно удалить из списка.

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

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

Давайте удалим печенье из нашего списка покупок:

basket = ["bread", "butter", "chips", "milk", "egg", "cookie", "cola"]
basket.remove("chips")

Проверим результат:

basket = ["bread", "butter", "chips", "milk", "egg", "cookie", "cola"]
basket.remove("chips")
print(basket)

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

["bread", "butter", "milk", "egg", "cookie", "cola"]

Теперь в нашем списке покупок нет печенья.

Если у вас возник вопрос: "А что с колой?". Резко всё бросать нельзя, пока попридержим её. =)

Метод 4. pop(index)

Еще один полезный метод для работы со списками — pop(). Этот метод удаляет элемент по указанному индексу и возвращает его. Если индекс не указан, pop() удаляет и возвращает последний элемент списка.

Синтаксис метода pop():

list_name.pop(index)

где:

• list — список, из которого нужно удалить элемент;
• index — индекс элемента, который нужно удалить (НЕОБЯЗАТЕЛЬНЫЙ параметр).

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

basket = ["bread", "butter", "milk", "egg", "cookie", "cola"]
removed_item = basket.pop()

Проверим, что у нас получилось:

basket = ["bread", "butter", "milk", "egg", "cookie", "cola"]
removed_item = basket.pop()
print(basket)
print(f"Удаленный элемент: {removed_item}")

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

["bread", "butter", "milk", "egg", "cookie"]
Удаленный элемент: cola

Теперь в нашей корзине нет колы, и мы знаем, что удалили именно её.

Давайте удалим ещё что-то?) Например, 3 элемент в списке и проверим результат:

basket = ["bread", "butter", "milk", "egg", "cookie"]
removed_item = basket.pop(2)
print(basket)
print(f"Удаленный элемент: {removed_item}")

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

["bread", "butter", "egg", "cookie"]
Удаленный элемент: milk

Важно! Если ваш список будет пустым или вы укажете несуществующий индекс, тогда возникнет ошибка IndexError.

Метод 5. extend()

Метод extend() в Python используется для добавления элементов в конец списка из другого итерируемого объекта, такого как список, кортеж или строка. Это позволяет объединить несколько списков в один.

Опр. Итерируемый объект (iterable) - это объект, который способен возвращать элементы по одному.

P.S. Это довольно сложное определение для начинающих. Условно запомните, что итерируемый объект это тот, который состоит из нескольких других. Из нами изученных это: строки и списки.

Синтаксис метода extend() выглядит следующим образом:

list_name.extend(iterable)

где:

• list_name — имя списка, к которому применяется метод
• iterable — итерируемый объект, элементы которого нужно добавить в список.

Пример:

my_list = []
my_list.extend([1, 2, 3])  # my_list = [1, 2, 3]
my_list.extend('add')  # my_list = [1, 2, 3, 'a', 'd', 'd']

В предыдущем примере, метод pop мог вернуть нам объект, который он "забрал" из списка. Так вот, если вы попробуете присвоить результат применения метода extend какой либо переменной, то вы получите None.

None - это особый тип данных, который обозначает "ничего" или "пустоту".

Метод 6. clear()

Бывают случаи, когда вы не хотите удалять список, но вам необходимо очистить его. Для этой задачи идеально подходит метод clear().

Синтаксис метода clear:

your_list.clear()

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

Давайте вспомним наш пример с магазином и уберем вообще все продукты из корзины:

basket = ["bread", "butter", "egg", "cookie"]
basker.clear()
print(basket)

Выведет:

[]

В этом примере мы взяли нашу корзину и удалили все продукты из неё. Как вы можете заметить, теперь наш список (корзина из примера) стал пустым.

Метод 7. count(item)

Иногда вам будет необходимо подсчитать количество определенных элементов в списке. На небольших данных, мы можем сделать это быстро и вручную, но что если у нас в списке 100, 1000 или 1.000.000 элементов? Для этого существует метод count().

Его синтаксис, весьма прост:

your_list.count(item)

где:

• your_list - это список, в котором необходимо подсчитать число входящих элементов
• item - искомый элемент, количество которого хотим найти

Пример 1.

У нас есть список оценок учащихся за контрольную по математике и нам нужно посчитать количество "5", "4", "3" и "2":

test_scores = [5, 4, 5, 4, 3, 4, 3, 3, 2, 5, 3, 4, 5, 5, 
               4, 5, 4, 3, 5, 4, 3, 5, 4, 4, 2, 4, 3, 5, 4]

count_5 = test_scores.count(5)
count_4 = test_scores.count(4)
count_3 = test_scores.count(3)
count_2 = test_scores.count(2)

print(count_5) # 9
print(count_4) # 11
print(count_3) # 7
print(count_2) # 2

Пример 2.

Мы можем считать не только количество чисел, но и любых других объектов в Python:

mixed_list = ["apple", "banana", "apple", 1, 2, "banana", 1, "apple"]

apple_count = mixed_list.count("apple")
banana_count = mixed_list.count("banana")
number_one_count = mixed_list.count(1)

print(f"Количество 'apple': {apple_count} шт")
print(f"Количество 'banana': {banana_count} шт")
print(f"Количество числа 1: {number_one_count} шт")

Выведет:

Количество 'apple': 3 шт
Количество 'banana': 2 шт
Количество цифры 1: 2 шт

Метод 8. reverse()

Что делать, если нам нужно отобразить элементы списка в обратном порядке? Конечно же использовать метод reverse().

Синтаксис этого метода весьма прост:

your_list.reverse()

где:

• your_list - список, порядок которого мы хотим изменить.

Пример:

fruits = ["apple", "banana", "cherry", "date"]

# Использование метода reverse() для изменения порядка элементов
fruits.reverse()

print(fruits)

Выведет:

['date', 'cherry', 'banana', 'apple']

Таким образом, метод reverse() позволяет легко и быстро изменить порядок элементов в списке на обратный

Метод 9. sort()

Элементы в списке разбросаны в непонятном порядке? Вы хотите это исправить? Используйте метод sort(). Он сортирует элементы списка в порядке возрастания или убывания. По умолчанию он сортирует значения в порядке возрастания.

При этом, данный метод изменяет исходный объект, а не создаёт новый.

Его синтаксис:

your_list.sort(key=None, reverse=False)

где:

• your_list - список, который необходимо отсортировать
• reverse (необязательно): для reverse=True, это приведет к сортировке списка по убыванию. По умолчанию значение reverse=False (Сортировка по возрастанию)
• key (необязательно) – функция для указания критериев сортировки

Примеры:

Пример 1: Сортировка по возрастанию

numbers = [4, 2, 1, 3, 5]
numbers.sort()
print(numbers)  # Вывод: [1, 2, 3, 4, 5]

Здесь мы имеем список чисел [4, 2, 1, 3, 5]. Используя метод sort(), мы сортируем элементы этого списка в порядке возрастания. После выполнения метода, список изменяется, и его элементы располагаются в последовательности от меньшего к большему: [1, 2, 3, 4, 5].

Пример 2: Сортировка по убыванию

numbers = [4, 2, 1, 3, 5]
numbers.sort(reverse=True)
print(numbers)  # Вывод: [5, 4, 3, 2, 1]

В этом примере мы снова начинаем с того же списка чисел [4, 2, 1, 3, 5]. Однако на этот раз мы используем параметр reverse=True в методе sort(), чтобы отсортировать элементы в порядке убывания. В результате, список изменяется, и его элементы располагаются от большего к меньшему: [5, 4, 3, 2, 1].

Пример 3: Сортировка с использованием ключа

words = ["apple", "banana", "cherry", "date"]
words.sort(key=len)  # Сортировка по длине строк
print(words)  # Вывод: ['date', 'apple', 'banana', 'cherry']

Тут мы работаем со списком строк ["apple", "banana", "cherry", "date"]. Перед нами стоит задача отсортировать эти строки не по алфавиту, а по их длине. Для этого мы используем параметр key=len в методе sort(), который указывает, что сортировка должна быть выполнена на основе длины строк. В результате, список изменяется, и строки располагаются в порядке возрастания их длины: ['date', 'apple', 'banana', 'cherry'].

В этом примере len, переданная как значение ключа - это функция len(), для расчёта длины строки.

Пример 4: Сортировка списка словарей по ключу

(Это сложный пример можете его пропустить, если только начинаете изучать язык)

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

Для этого мы используем параметр key с функцией-лямбдой lambda x: x["age"], которая указывает, что сортировка должна быть выполнена по значению ключа "age" в каждом словаре.

people = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Charlie", "age": 35}
]
people.sort(key=lambda x: x["age"])  # Сортировка по возрасту
print(people)

Выведет:

[{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]

В результате, список изменяется, и словари располагаются в порядке возрастания возраста: [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}].

Метод 10. index()

Метод index() в Python используется для нахождения индекса первого вхождения заданного элемента в списке. Если элемент не найден, метод вызывает исключение ValueError. Этот метод особенно полезен, когда вам нужно знать позицию конкретного элемента в списке.

Синтаксис метода index():

temp_list.index(value, start, end)

где:

• value — элемент, который мы ищем в списке temp_list.
• start (необязательный параметр, по умолчанию 0) — индекс начала среза в списке, в котором требуется найти элемент. Индекс берется включительно.
• end (необязательный параметр, по умолчанию None, что означает конец списка) — индекс конца среза списка, в котором требуется найти элемент. Конечный индекс не входит в отрезок для поиска.

Примеры использования:

Пример 1. Давайте просто найдём индекс какого-то элемента в нашем списке:

fruits = ['apple', 'banana', 'cherry']
index = fruits.index('banana')
print(index)  # Вывод: 1

При чём, если у нас будет несколько одинаковых элементов, то мы всё равно получим индекс первого найденного:

fruits = ['apple', 'banana', 'banana', 'cherry']
index = fruits.index('banana')
print(index)  # Вывод: 1

Пример 2. Попробуем использовать необязательные параметры этого метода:

numbers = [10, 20, 30, 40, 50, 20, 60]
index = numbers.index(20, 2, 5)
print(index)

Выведет:

Traceback (most recent call last):
  File "main.py", line 2, in <module>
	index = numbers.index(20, 2, 5)
ValueError: 20 is not in list

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

Первая 20 имела индекс 1, она не входит в наш интервал. Вторая 20 в этом списке имеет индекс 5, что находится на границе указанного нами интервала.

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

Метод 11. copy()

Этот метод возвращает поверхностную копию исходного списка. Действие метода эквивалентно выражению my_list[:].

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

Синтаксис метода copy():

copy_list = main_list.copy()

где:

• main_list - это список, который мы хотим скопировать
• copy_list - это список, который получился в результате копирования основного

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

Пример:

main_list = [1, 2, [3, 4]]
copy_list = main_list.copy()

# Изменим парочку элементов в поверхностной копии
copy_list[2][0] = 5
copy_list[0] = 3

print(main_list)  # Вывод: [1, 2, [5, 4]]
print(copy_list)  # Вывод: [3, 2, [5, 4]]

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

Сейчас это может быть немного трудным, но подробнее о "поверхностных" и "глубоких" копиях, мы поговорим в одной из следующих статьей! ;)

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

Что такое списки?

Список (list) - это упорядоченный набор элементов, каждый из которых имеет свой номер, или индекс, позволяющий быстро получить к нему доступ. Индексация элементов в списке, как и в строках, начинается с 0. Являясь изменяемым типом данных, содержимое списков можно изменять и после создания.

Зачем нужны списки?

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

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

Кроме того, списки предлагают обширный набор инструментов для работы с ними. Например, различные методы (append(), remove(), sort(), reverse()), поддержка индексации и срезов, ну и конечно же вложенности.

Это были объективные плюсы использования списков, но в тоже время...

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

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

Как создавать списки?

Это можно сделать несколькими способами, например вы можете просто перечислить элементы в квадратных скобках:

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

Пример 1: Список из строки

Пример 2: Список из кортежа

Не обращайте, внимания на то, что мы ещё не изучили кортежи. Это просто пример ;)

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

Пример 1: Создание списка с квадратами чисел

Пример 2: Список Фильтрация четных чисел

Совсем скоро мы познакомимся с циклами и условиями в Python, и этот код перестанет быть для вас чем-то страшным и непонятным:)

Доступ к элементам из списка

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

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

Примеры доступа к элементам списка

Положительная индексация

Отрицательная индексация

В Python можно использовать отрицательные индексы для доступа к элементам списка, начиная с конца. Индекс -1 относится к последнему элементу, -2 — к предпоследнему и так далее.

Доступ к элементам вложенных списков

Этот пункт, часто вызывает затруднения у новичков. Мой совет - посоздавайте свои вложенные списки и поработайте с ними. Таким образом вы довольно хорошо преисполнитесь в понимании индексации и понятия "вложенности".

Если список содержит другие списки (вложенные списки), доступ к элементам внутренних списков осуществляется с помощью вложенной индексации.

Примеры с отрицательной индексацией во вложенных списках

Работа со списками и полезные методы

Получение размера списка Python

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

Пример 1: Простой список

В этом примере len(simple_list) возвращает 5, так как в списке simple_list пять элементов.

Пример 2: Список со вложенными списками

В этом примере len(nested_list) возвращает 3, так как в списке nested_list три элемента, каждый из которых является вложенным списком.

Пример 3: Получение размера вложенного списка

В этом примере len(nested_list[0]) возвращает 3, так как первый элемент в nested_list является списком [1, 2, 3], который содержит три элемента.

Пример 4: Список с различными типами данных

В этом примере len(mixed_list) возвращает 5, так как в списке mixed_list пять элементов различных типов данных.

Добавление элементов в список Python

Метод 1: Использование метода append()

Элементы могут быть добавлены в список с помощью встроенного метода append(). Этот метод позволяет добавлять только один элемент за раз в конец списка.

Пример:

Метод 2: Использование метода insert()

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

Пример:

Метод 3: Использование метода extend()

Метод extend() используется для одновременного добавления нескольких элементов в конец списка. Этот метод принимает итерируемый объект (например, другой список) и добавляет все его элементы в текущий список.

Пример:

Переворачивание списка

Метод 1: Использование метода reverse()

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

Пример:

Метод 2: Использование функции reversed()

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

Пример:

Метод 3: Использование среза

Да-да, используя срезы вы можете перевернуть список. Внимание, следите за руками :)

Сортировка списков. Метод sort()

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

Пример сортировки чисел по возрастанию

Пример сортировки чисел по убыванию

Для сортировки элементов от большего к меньшему можно использовать параметр reverse:

Сортировка строк

Сортировка строк выполняется на основе лексикографического порядка (то есть по алфавиту). Python сравнивает строки посимвольно, используя ASCII-значения символов.

Пример сортировки строк по возрастанию

Пример сортировки строк по убыванию

Сортировка с использованием ключа

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

Пример сортировки списка словарей по значению ключа

Операции над списками

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

1. x in mylist — вернет True, если элемент x есть в списке mylist

Этот оператор проверяет, содержится ли элемент x в списке mylist .
Пример:

2. x not in mylist — вернет True, если элемент x отсутствует в mylist

Этот оператор проверяет, отсутствует ли элемент x в списке mylist.

Пример:

3. mylist1 + mylist2 — объединение двух списков

Этот оператор объединяет два списка mylist1 и mylist2 в один новый список.

Пример:

4. mylist * n, n * mylist — копирует список n раз

Этот оператор создает новый список, который является копией списка mylist, повторенного n раз.

Пример:

6. min(mylist) — наименьший элемент

Эта функция возвращает наименьший элемент в списке mylist.

Пример:

7. max(mylist) — наибольший элемент

Эта функция возвращает наибольший элемент в списке mylist.

Пример:

8. sum(mylist) — сумма чисел списка

Эта функция возвращает сумму всех чисел в списке mylist.

Пример:

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

Подписывайтесь на наш телеграмм канал: ссылка на канал!

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

Чтобы вызвать метод для конкретной строки, необходимо указать объект, поставить точку, записать имя метода и в круглых скобках список аргументов, если они необходимы: объект.метод(аргументы)

Формально я разделяю все методы на:

1. Методы для сравнения строк
2. Методы изменяющие строки
3. Методы для поиска подстрок
4. Методы ASCII

Методы сравнения

Эти методы сравнивают строки на соответствие с определенным типом данных или параметром. Вот некоторые из них:

• isalpha(): Проверяет, состоит ли строка только из букв.
• isdigit(): Проверяет, состоит ли строка только из цифр.
• isnumeric(): Проверяет, состоит ли строка только из числовых символов.
• isalnum(): Проверяет, состоит ли строка только из букв и цифр.
• istitle(): Проверяет, является ли строка заголовком (каждое слово начинается с заглавной буквы).
• isspace(): Проверяет, состоит ли строка только из пробельных символов.
• islower(): Проверяет, являются ли все буквы в строке строчными.
• isupper(): Проверяет, являются ли все буквы в строке заглавными.
• startswith(str): Проверяет, начинается ли строка с подстроки str.
• endswith(str): Проверяет, заканчивается ли строка подстрокой str.

Методы изменяющие строки

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

Эти методы изменяют строки различными способами:

• lower(): Преобразует все буквы в строке в строчные.
• upper(): Преобразует все буквы в строке в заглавные.
• title(): Преобразует первую букву каждого слова в строке в заглавную.
• rjust(width): Выравнивает строку по правому краю в поле заданной ширины.
• ljust(width): Выравнивает строку по левому краю в поле заданной ширины.
• center(width): Центрирует строку в поле заданной ширины.
• capitalize(): Преобразует первую букву строки в заглавную.
• strip(): Удаляет пробельные символы с обоих концов строки.
• lstrip(): Удаляет пробельные символы с левого конца строки.
• rstrip(): Удаляет пробельные символы с правого конца строки.
• replace(old, new): Заменяет все вхождения подстроки old на подстроку new.
• split(): Разбивает строку на список подстрок.
• partition(sep): Разбивает строку на кортеж, содержащий часть перед разделителем, сам разделитель и часть после разделителя.
• join(iterable): Объединяет элементы итерируемого объекта в строку с разделителем.
• swapcase(): Преобразует заглавные буквы в строчные и наоборот.

Методы для поиска подстрок

Эти методы помогают находить подстроки в строках:

• find(sub): Возвращает индекс первого вхождения подстроки sub.
• rfind(sub): Возвращает индекс последнего вхождения подстроки sub.
• index(sub): Возвращает индекс первого вхождения подстроки sub, но вызывает исключение, если подстрока не найдена.
• rindex(sub): Возвращает индекс последнего вхождения подстроки sub, но вызывает исключение, если подстрока не найдена.
• count(sub): Возвращает количество вхождений подстроки sub.

ASCII методы

Эти методы работают с ASCII символами:

• ord(char): Возвращает ASCII-код символа.
• chr(code): Возвращает символ по его ASCII-коду.

Основные методы

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

• Подсчёт элементов в строке: String.count(sub[, start[, end]])Возвращает число повторений подстроки sub в строке String. Два необязательных аргумента:
• start — индекс, с которого начинается поиск;
• end — индекс, которым заканчивается поиск.

• Следующий метод: String.find(sub[, start[, end]])Возвращает индекс первого найденного вхождения подстроки sub в строке String. А аргументы start и end работают также как и в методе count. Если подстрока не найдена, метод возвращает -1.

• Третий метод, аналогичный find – это: String.index(sub[, start[, end]])Он работает абсолютно также как find, но с одним отличием: если указанная подстрока sub не находится в строке String, то метод приводит к ошибке.
• Спрашивается: зачем нужен такой ущербный метод index?
• В действительности такие ошибки можно обрабатывать как исключения и это бывает полезно для сохранения архитектуры программы, когда неожиданные ситуации обрабатываются единым образом в блоке исключений.
• Следующий метод: String.replace(old, new, count=-1) Метод replace заменяет все вхождения подстроки old на подстроку new и возвращает новую строку. Аргумент count указывает, сколько замен должно быть выполнено. Значение -1 означает, что замены не ограничены.

• Следующий метод: String.split(sep=None, maxsplit=-1)Метод split возвращает список строк, полученных путем разделения исходной строки String по указанному разделителю sep.

• Обратный метод: String.join(список)Возвращает строку из объединенных элементов списка, между которыми будет разделитель String.

• Следующий метод String.strip()Удаляет пробелы и переносы строк в начале и конце строки.

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

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

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

Что такое строки и какие их виды существуют

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

Главное условие строк - это необходимость в том, чтобы с двух сторон их окружали одинаковые кавычки.

В Python строки обозначаются, как str (сокращение от английского слова string - строка).

Виды строк:

1. Однострочные строки - это строки, которые записываются в одну строку и окружаются с двух сторон одинарными или двойными кавычками.

Hello, world!
Hello, world!

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

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

Когда мы попытаемся выполнить нашу программу, всё отработает корректно:

Приезжаю завтра, остановлюсь в гостинице "Москва"
It's not an apostrophe — it's a catastrophe!

Если же выбрать неправильные кавычки, это приведет к ошибке синтаксиса:

  File "c:\Users\Python\tuition\test.py", line 2
    example2 = 'It's not an apostrophe — it's a catastrophe!'
                                       ^
SyntaxError: invalid character '—' (U+2014)

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

Идем сегодня мы пораньше,
Чтобы не 'быть' опаздунами.
Мы так намерены и "дальше",
Чтоб было счастье между нами.

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

Отлично, с этим разобрались! Давайте перейдём к следующему пункту.

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

В Python вы можете выполнять арифметические операции не только с числами, но и со строками. Рассмотрим две основные операции: сложение (конкатенация) и умножение (повторение).

Сложение (конкатенация)

В Python мы действительно можем складывать строки и эта операция называется - конкатенацией.

HelloWorld!

Как видно из примера, две строки "Hello" и "World!" были объединены в одну строку "HelloWorld!". Однако этот результат может показаться недостаточно читаемым из-за отсутствия пробела между словами.

Давайте добавим пробел между строками:

Hello World!

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

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

Теперь, когда мы разобрались с операцией сложения, перейдём к умножению! Мы будем называть эту операцию повторением или дублированием строк, и вот почему:

HelloHelloHelloHelloHello

При выполнении операции умножения строка повторяется указанное количество раз. В данном случае строка «Hello» умножается на 5, что приводит к её повторению пять раз

Важный момент! Строку можно умножать на число, но нельзя умножать строку на строку — это приведёт к ошибке!

Индексы и срезы

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

Индексы

Мы уже говорили, что строки - это упорядоченные наборы символов (последовательности).

Давайте создадим переменную строкового типа:

и подробнее рассмотрим как она устроена:

Смотрите, каждый символ строки имеет свой уникальный, порядковый номер. Эти номера называются индексами. Первый – 0, второй – 1 и так до конца. Мы можем использовать эти индексы для обращения к отдельному символу строки. Для этого, записывается имя переменной и в квадратных скобках указывается номер символа:

H
l

Однако вам стоит быть внимательнее, если при обращении вы укажите не существующий индекс, то это приведёт к возникновению ошибки!

Важно! Нумерация индексов в Python начинается с 0, если мы читаем слева на право и с -1, если мы читаем в обратном порядке. Таким образом у каждого символа в строке, есть два индекса - положительный и отрицательный.

Так, к первому элементу нашей строки мы можем обратиться несколькими способами:

example[0]
#или
example[-13]

Не отходя от кассы, расскажу вам про одну полезную функцию, которая может вам пригодиться:
len() - это функция, возвращающая длину строки, которую мы передаём в качестве параметра.

13
17
5
1
0

Срезы

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

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

строка(start:stop:step)

где,

• start - индекс, с которого мы начнём выбирать символы из строки.
• stop - индекс (не включительно), на котором у нас закончится выбор.
• step - шаг выбора символов (каждый, через один, через два и т.д)

Выделенная последовательность символов называется срезом строки.

Посмотрим на примере:

1234
0123456789
01234
02468

Разберемся:

• В первом выводе, мы выбрали все символы, индексы которых начинаются с 1 и заканчиваются 4. Конкретное значение параметра stop - не учитывается, при срезе. По этой причине мы не взяли символ с индексом 5.
• Во втором выводе, мы вообще не указывали параметры для среза, что привело к выводу всей строки. Это аналогичная форма записи вывода print(example)
• В третьем выводе мы не указали начальный параметр start, но указали конечный - stop. Следовательно символы вывелись с начала строки и до указанного (не включительно).
• В четвёртом выводе, мы не указывали параметры start и stop, но указали параметр step = 2 - это привело к тому, что мы выбрали из строки все символы с чётными индексами.

Изменение строк

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

Например, попытка изменить первый символ строки таким образом:

example[0] = 'h'

вызовет ошибку.

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

example = 'h' + s[1:]

Этот подход применяется всякий раз, когда требуется внести изменения в существующую строку.

Примечание. Если вам не понятно, почему строки ведут себя именно таким образом. Вам следует прочитать нашу статью - "Изменяемые и неизменяемые типы данных".

Что необходимо запомнить из этой статьи:

1. Строка – упорядоченный набор символов (последовательность);
2. Как работает сложение строк (конкатенация) и умножение строк (повторение);
3. У каждого символа в строке, есть свой порядковый номер - называемый индексом;
4. Индексация строк начинается с 0, но если вы читаете строку в обратном порядке, то с -1;
5. Мы можем обращаться к конкретному символу строки, при помощи её индекса - example[0]. В тоже время, мы можем выбрать сразу несколько символов, используя срезы - example[1:5:2].

Ещё больше статьей для начинающих и не только, вы можете прочитать в нашем телеграмм канале Python Jungle.

Изначально стоит сказать о том, что объектом в Python является абсолютно все, а каждый объект относится к какому-либо типу данных. Новичкам важно сразу усвоить, что все типы данных в Python могут быть либо изменяемыми (mutable), либо неизменяемыми (immutable).

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

• id: адрес в памяти, на который ссылается данный объект
• тип: тип создаваемого объекта. Например, целое число, список, строка и т. д.
• значение: значение, которое хранится в данном объекте.

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

Неизменяемые объекты (Immutable)

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

Для проверки такого поведения, мы можем воспользоваться функцией id - она возвращает уникальный номер, который присваивается переменной при создании.

I am 25 years old. id my_age = 140703593987256
I am 26 years old. id my_age = 140703593987288

Когда мы прибавляем год к нашему возрасту (переменной my_age), на его месте создаётся новый объект с тем же именем. Мы можем это понят, так как до прибавления года id переменной my_age = 140703593987256, а после id my_age = 140703593987288.

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

    names[0] = "Python"
    ~~~~~^^^
TypeError: 'tuple' object does not support item assignment

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

Давайте ещё раз взглянем на неизменяемые типы данных:

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

Задание: создайте неизменяемый тип данных (например кортеж) и поместите в него изменяемый тип данных. Что произойдёт? Сможем ли мы изменить изменяемый тип данных внутри неизменяемого?

Изменяемые объекты (Mutable)

Изменяемые объекты могут быть изменены после их создания. Рассмотрим на примере:

1877224118528
1877224118528

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

Важность понимания изменяемости

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

1. Неизменяемые типы данных (например, строки, числа, кортежи) не могут быть изменены после их создания. Это означает, что любая операция, которая кажется изменением, на самом деле создает новый объект. Это обеспечивает целостность данных и избавляет нас от возможных ошибок.
2. Изменяемые типы данных (например, списки, словари, множества) могут быть изменены после их создания. Вы можете добавлять, удалять или изменять элементы этих объектов. Однако, это также означает, что вы должны быть осторожны, чтобы не изменить объект непреднамеренно, особенно когда он передается в функции или используется в качестве значения в словарях.

В этой статье мы поговорим о числовых типах данных, арифметических операциях над ними и поймём как работает присваивание.

В python имеются три базовых типа для представления чисел:

1. int – для целочисленных значений;
2. float – для вещественных;
3. complex – для комплексных.

Мы затронем первые два: int и float. Поскольку комплексные числа редко встречаются на практике и этот тип мы рассмотрим отдельно.

Первый целочисленный тип представляет собой, следующие числа:
0, 1, 2, 100, 6697959484, -1, -2, -7567658

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

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

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

Оператор присваивания

Отлично! Теперь вы знаете, какие типы чисел есть в Python. Давайте рассмотрим способ, как мы можем зафиксировать значение за определенной переменной. Для этого нам понадобится оператор присваивания =.

Разберем, как работает оператор присваивания на примере:

age = 21

В этом примере мы создали переменную age и присвоили ей значение 21.

Получается, что оператор присваиванию говорит компьютеру: "Смотри у нас есть именованная коробочка age, давай положим в неё значение 21".

Вот так вот, ничего сложного ^.^

Основные арифметические операции

Следующим шагом, нам с вами нужно научиться делать арифметические операции над ними. Что это за операции? Базовыми из них являются, следующие:

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

Некоторые из операций могут быть вам незнакомы. Давайте, я поясню их работу на конкретных примерах:

Сложение, вычитание и умножение

Пример:

a = 10
b = 13
print(a+b)

Выведет: 23

Примечание. Мы можем складывать много переменных/чисел за один раз: a+b+10+5.0

Давайте рассмотрим ещё один пример сложения:

Пример:

a = 10
b = 5.5
print(a+b)
c = 10
d = 10.0
print(c+d)

Выведет:

15.5
20.0

Заметили что произошло? При сложении целочисленного типа с дробным, вы всегда будете получать дробное число. Аналогично будет работать с вычитанием и умножением.

Пример умножения:

a = 5
b = 3
print(a*b)
a = 2.5
b = 2
print(a*b)

Выведет:

15
5.0

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

Деление

А вот деление отличается довольно сильно и как вы могли заметить в Python их 3!

Пример классического деления:

a = 10
b = 3
c = 2
print(a/b)
print(a/c)

Выведет:

3.3333333333333335
5.0

Теперь давайте обсудим результат, который у нас получился. При делении 10 на 3, мы получили 3.3333333333333335. Только вот откуда там взялась 5?

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

Приведем пример. Мы не можем представить дробь 2/3 в виде десятичного числа. 2/3 = 0.6666666666666666... цифра 6 будет повторяться бесконечно. Поэтому хранить можно лишь приблизительное значение этого числа.

В Python точность чисел с плавающей точкой обеспечивается только до 15 знака, на 16 могут возникать неточности.

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

Давайте рассмотрим ещё один пример такого поведения:

print(1.1+2.2)

Выведет: 3.3000000000000003

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

Её синтаксис round(number, ndigits), где

• number - это число или выражение, которое мы хотим округлить
• ndigits - число цифр, после запятой

Пример:

print(round(2/3, 2))
print(round(1.1+2.2, 2))

Выведет:

0.67
3.3 (Функция round в Python округляет число до указанного количества 
десятичных знаков, но не добавляет незначащие нули.)

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

Целочисленное деление

Ещё один из видов деления, который позволяет нам находить целое число при деление. (Автоматически округляет число до наименьшего кратного). Перейдём сразу к примеру:

Пример:

a = 10
b = 5
print(a//b)
print(b//a)
c = 10
d = 3
print(c//d)

Выведет:

2 (на выходе получаем 2, поскольку 2 ближайшее наименьшее целое число к 2.0)
0 (на выходе получаем 0, поскольку 0 ближайшее наименьшее целое число к 0.5)
3 (на выходе получаем 3, поскольку 3 ближайшее наименьшее целое число 
к 3.(3))

Примечание: 3.(3) - это сокращенная запись числа 3.3333333333...

Рассмотрим целочисленное деление отрицательных чисел.

Пример:

c = -7 // 2
print(c)

Выведет:

-4 (На выходе получили -4, поскольку -4 ближайшее наименьшее целое 
число к -3.5)

Теперь рассмотрим операцию нахождения остатка при делении.

Что это вообще такое? Например, если делить 10/3 то остаток будет равен 1.

Почему так? Все просто, число 3 трижды входит в число 10 и остается значение 10 - 3∙3 = 1.

Для вычисления этого значения в Python используется оператор %.

Пример:

a = 10
b = 3
print(a % b)
print(a % 4)
print(a % 10)
print(a % 5)

Выведет:

1
2
0
0

Согласитесь, удобно и просто. Если вам тяжело это понять, то попробуйте посчитать уравнения из примера на листочке ;)

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

Возведение в степень

Последняя из операций, которые нам необходимо рассмотреть - это возведение в степень (**).

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

Рассмотрим парочку примеров:

1. 3**3 = 27 (3*3 = 9, 9*3=27)
2. 2**4 = 16 (2*2=4, 4*2=8, 8*2=16)
3. Ну и так далее...

Давайте рассмотрим парочку более интересных примеров:

print(36**0.5)
print(144**0.5)

Выведет:

6
12

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

Таким образом, 36**0.5 вычисляет квадратный корень из 36, что равно 6, а 144**0.5 вычисляет квадратный корень из 144, что равно 12.

Пример:

print(2**3**2)

Выведет:

512

В Python операции возведения в степень выполняются справа налево. Поэтому сначала вычисляется 3**2, что равно 9, а затем 2**9, что равно 512.

Таким образом, 2**3**2 эквивалентно 2**(3**2), и результатом является 512.

Что необходимо запомнить:

• В Python есть 3 числовых типа данных - int, float, complex.
• Для присвоения переменной значения, используется оператор присваивания =
• В Python поддерживаются все арифметические операции из школьной математики (сложение, вычитание, умножение, деление, возведение в степень)
• При выполнение операции с разными типами данных, Python автоматически преобразует тип к тому, что будет более "точным".
• При классическом (обычном) делении всегда получается вещественное (дробное) число, независимо от входных данных.
• В Python точность чисел с плавающей точкой обеспечивается только до 15 знака, на 16 могут возникать неточности. Помните об этом.
• При помощи операции возведения в степень, можно не только возводить числа в степень, но и вычислять корни.
• для округления чисел используется функция round(number, ndigits), где
• number - это число или выражение, которое мы хотим округлить
• ndigits - число цифр, после запятой

Вывод данных, команда print

Для вывода данных на экран используется команда print(). Эти данные мы можем записать и в файл, но об этом мы поговорим позже.

Внутри круглых скобок пишем, что хотим вывести на экран. Если это текст, то обязательно указываем его внутри кавычек. Кавычки могут быть одинарными (') или двойными ("). До и после текста мы ставим только одинаковые кавычки.

Приведённый ниже код:

print('Привет мир! Я изучаю Python.')

выводит:

Привет мир! Я изучаю Python.

Если вы напишите этот код в VS Code, то вывод отобразится во вкладке TERMINAL:

Использование кавычек

Мы можем использовать, как 'одинарные' кавычки, так и "двойные". Python не делает различий между одинарными и двойными кавычками: они работают одинаково для определения строк.

Однако у вас мог возникнуть вопрос: "Если мы можем использовать разные кавычки, то для чего это нужно?". Вопрос закономерный и правильный. Python использует различные кавычки для обрамления текста.

Приведённый ниже код:

print('В тексте есть "двойные" кавычки')
print("В тексте есть 'одинарные' кавычки")

выводит:

В тексте есть "двойные" кавычки
В тексте есть 'одинарные' кавычки

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

Что можно выводить при помощи print?

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

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

Аргументы – это конкретные значения, которые вы передаете функции при ее вызове.

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

Приведённый ниже код:

print('Я', 'учусь', 'программировать', 'на', 'Python!')

выводит:

Я учусь программировать на Python!

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

Запомни: при написании кода между аргументами команды print() после запятой мы ставим один символ пробел. Это общепринятое соглашение в языке Python. Этот символ пробела не влияет на вывод данных. Делается это для повышения читабельности кода.

Если вы напишите две команды print(), друг за другом. То каждый текст, выводимый этими командами будет начинаться с новой строки.

Рассмотрим на примере:

print("Здесь, я напишу первый текст")
print("Вот тут уже будет второй")

получим вывод:

Здесь, я напишу первый текст
Вот тут уже будет второй

Что будет если написать print, без аргументов? Всё будет хорошо, Python просто вставит пустую строку вместо текста.

Пример:

print("Здесь, я напишу первый текст")
print()
print("Вот тут уже будет второй")

выведет:

Здесь, я напишу первый текст

Вот тут уже будет второй

Необязательные параметры

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

• sep – разделитель между данными;
• end – завершающий символ или строка.

Рассмотрим их применение на практике, предположим, мы выводим три переменные:

a = -6.84
b = 7
c = 25.6
print(a, b, c)

Вывод:

-6.84 7 25.6

При выводе между каждой переменной автоматически ставится один символ пробела. Но мы можем изменить это поведение при помощи параметра sep (сокращение от английского слова separator, в переводе "разделитель")

print(a, b, c, sep=" | ")

Вывод:

-6.84 | 7 | 25.6

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

Второй необязательный параметр end. Судя из названия и проводя аналогию с sep, получается, что этот параметр отвечает за окончание строки вывода.

По умолчанию значением этого параметра является \n, т.е. символ новой строки. Благодаря этому два последовательных вызова функции print() напечатают текст с новой строки. Пример такого поведения мы уже рассматривали выше.

Рассмотрим ещё раз :)

print("Здесь, я напишу первый текст")
print("Вот тут уже будет второй")

получим вывод:

Здесь, я напишу первый текст
Вот тут уже будет второй

Теперь изменим значение end и посмотрим на результат:

print("Здесь, я напишу первый текст", end=' + ')
print("Вот тут уже будет второй")

Результат:

Здесь, я напишу первый текст + Вот тут уже будет второй

Заметили разницу? Отлично!

На этом мы закончим наше базовое знакомство с функцией print и выводом данных на экран. Давайте же приступим к знакомству с вводом данных.

Ввод данных, команда input()

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

Для считывания данных в языке Python используется команда input().

Ее синтаксис выглядит так:

input([prompt])

prompt — это строка, которую мы хотим вывести на экран, когда будем запрашивать ввод с клавиатуры у пользователя.

Рассмотрим на примере, как это работает и выполним следующий код в VS Code:

user_name = input('Введите ваше имя: ')
print(user_name)

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

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

Сначала нужно определиться с тем, как будет работать программа:

1. Сначала нам нужно поприветствовать пользователя
2. Узнать его имя
3. Пожелать удачи

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

1. Поздороваемся с пользователем и узнаем имя пользователя:

print("Здравствуйте, я робот Саша! Как вас зовут?")

1. Запросим имя пользователя при помощи функции input и запишем её значение в переменную name:

print("Здравствуйте, я робот Саша! Как вас зовут?")
name = input()

1. Выведем пожелание удачи пользователю на экран, используя данные из переменной :

print("Здравствуйте, я робот Саша! Как вас зовут?")
name = input()
print("Удачи в изучении языка Python", name, "!")

Выполним этот код в VS Code и посмотрим на его выполнение:

Смотрите, программа вывела текст, а потом запросила ввод из терминала (Место куда указывает красная стрелочка), теперь мы можем написать своё имя, нажать на клавишу Enter и посмотреть на то, что получилось:

Отлично, программа работает!

Задание: подумайте, как можно переписать программу при помощи ваших знаний о prompt.

Что необходимо запомнить:

1. Для вывода данных на экран, используется функция print(), у которой есть два необязательных параметра sep и end.
2. Если вы хотите вывести текст, его необходимо "обернуть" в кавычки. Для этого можно использовать, как одинарные, так и двойные.
3. Мы можем передавать переменные в print(), записывая их через пробел в скобочках. Переменные разделяются друг от друга запятой, после которой должен идти символом пробела. Пример: print(first_name, last_name, '!')
4. Для получения данных с клавиатуры, используется функция input([prompt]). prompt - это текст, который будет выводиться перед запросом на ввод данных.

P.S. Больше статей вы можете посмотреть в нашем телеграмм канале.