Урок 15. Множини в Python

Множини (також зустрічається переклад набори) використовуються для зберігання кількох елементів в одній змінній. Елементи множин не впорядковані, незмінні та не допускають повторюваних значень.

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

Елементи множини можуть відображатися в іншому порядку кожного разу, коли ви їх використовуєте, і на них не можна посилатися за індексом або ключем.

Елементи множини є незмінними, тобто ми не можемо змінити елементи після створення множини.

Після створення множини ви не можете змінити її елементи, але ви можете видалити елементи та додати нові елементи.

Множини не можуть мати два елементи з однаковим значенням. Повторювані значення ігноруватимуться.

У множинах не можна використовувати дублікати. Кожен елемент має бути унікальним.

Приклад з відео:

#True та 1 у множинах вважаються однаковими значеннями.
#Значення False та 0 у множинах також розглядаються як однакові 
#та вважаться дублікатами.
varCarSet = {"Dodge", "Ford", "Toyota", "Dodge", True, 1, False,0}
print(varCarSet)

Визначення довжини множин в Python

Для визначення довжини множин використовуй функцію len(). Приклад з відео:

#Для визначення кількості елементів множини
#використовуйте функцію len()
varCarSet = {"Dodge", "Ford", "Toyota"}
print(varCarSet)
lengthOfVarCarSet = len(varCarSet)
print(lengthOfVarCarSet)

Типи даних елементів множин

У множинах можуть зберігатися дані різних типів. Приклад з відео:

#Елементи множини можуть бути будь-якого типу
#Множина може містити елементи різних типів
varCarSet = {"Dodge", "Ford", "Toyota"}
varNumSet = {1,3,5,7,9}
varBoolSet = {True, False}
varBusketSet = {3, "Text", True, 5.75}
print(varCarSet)
print(varNumSet)
print(varBoolSet)
print(varBusketSet)

Конструктор set()

Конструктор set() у Python використовується для створення нового об’єкта множини. Він може приймати ітеровані об’єкти (наприклад, списки або рядки) і створювати множину з унікальних елементів. Якщо викликати set() без аргументів, він створює порожню множину.

Приклад з відео:

#Можна використовувати конструктор set() для створення множини.
varCarSet1 = set(("Dodge", "Ford", "Toyota"))
print(varCarSet1)
print(type(varCarSet1))

Доступ до елементів множин

Множини (sets) у Python не підтримують доступ до своїх елементів за індексом, оскільки вони не мають порядку. Приклад з відео:

#Ви не можете отримати доступ до елементів множини 
#за допомогою індекса або ключа.
#Але можна пройти через елементи множини 
#за допомогою цикла for.
varCarSet = {"Dodge", "Ford", "Toyota", "BMW", "Lincoln"}
for car in varCarSet:
    print(car)
    
if "Lincoln" in varCarSet:
    print("Lincoln is in varCarSet")
    
else:
    print("Lincoln is not in varCarSet")

Додавання елементів множин

Метод add() у множинах Python використовується для додавання нового елемента до множини. Якщо елемент вже існує у множині, метод нічого не змінює, оскільки множини не допускають дублікати. Приклад з відео:

#Коли множину створено, 
#ви не можете змінити її елементи,
#але ви можете додати нові елементи.
#Щоб додати новий елемент до множини 
#використовуйте метод add().
varCarSet = {"Dodge", "Ford", "Toyota"}
print(varCarSet)
varCarSet.add("Lincoln")
varCarSet.add("Chrysler")
print(varCarSet)

Метод update()

Метод update() у множинах Python використовується для додавання елементів з іншого ітерованого об’єкта (наприклад, списку, кортежу, або іншої множини) до існуючої множини. Якщо нові елементи вже є в множині, вони не будуть додані повторно, оскільки множини не допускають дублікати. Приклад з відео:

#Для того щоб додати елементи в однієї множини в іншу, 
#використовуйте метод update()
varCarSet1 = {"Dodge", "Ford", "Toyota"}
varCarSet2 = {"Alfa Romeo", "Chrysler"}
print(varCarSet1)
print(varCarSet2)
varCarSet1.update(varCarSet2)
print(varCarSet1)
print(varCarSet2)

Приклад з відео з додаванням списку:

#Об'єкт у методі update() необов'язково 
#повинен бути множиною, 
#це може бути будь-який ітерабельний об'єкт
varCarSet1 = {"Dodge", "Ford", "Toyota"}
varCarList1 = ["BMW", "Lincoln"]
print(varCarSet1)
print(varCarList1)
varCarSet1.update(varCarList1)
print(varCarSet1)
print(varCarList1)

Метод remove()

Метод remove() у множинах Python використовується для видалення конкретного елемента з множини. Якщо елемента, який потрібно видалити, немає в множині, метод викликає помилку KeyError. Приклад з відео:

#Для видалення елемента з множини
#використовуйте метод remove()
#Якщо елемент, який потрібно видалити, не існує, 
# метод remove() поверне помилку 
varCarSet = {"Dodge", "Ford", "Toyota", "Car1"}
print(varCarSet)
varCarSet.remove("Car1")
print(varCarSet)
#varCarSet.remove("Car1")

Метод discard()

Метод discard() у множинах Python використовується для видалення конкретного елемента з множини, але на відміну від remove(), він не викликає помилку, якщо елемент не знайдено. Це робить discard() зручнішим, коли ти не впевнений, чи є елемент у множині. Приклад з відео:

#Можна використовувати метод discard для видалення елементу
#Якщо елемент, який потрібно видалити, не існує, 
#то метод discard() не поверне помилку
varCarSet = {"Dodge", "Ford", "Toyota", "Car1"}
print(varCarSet)
varCarSet.discard("Car1")
print(varCarSet)
varCarSet.discard("Car1")
print(varCarSet)

Метод pop()

Метод pop() у множинах Python видаляє та повертає довільний елемент з множини. Оскільки множини не мають певного порядку, який елемент буде видалено, не можна передбачити. Якщо множина порожня і ти спробуєш викликати pop(), буде викликана помилка KeyError. Приклад з відео:

#Можна також використовувати метод pop()  
#для видалення елементу,
#але цей метод видалить випадковий елемент, 
#тому ви не можете бути певні, 
#який саме елемент буде видалено.
#Значення, яке повертає метод pop(), 
#і є тим самим видаленим елементом.
varCarSet = {"Car1", "Car2", "Car3"}
print(varCarSet)
removedItem = varCarSet.pop()
print(varCarSet)
print("Removed item  is {}".format(removedItem))

Метод clear()

Метод clear() у множинах Python видаляє всі елементи з множини, в результаті чого множина стає порожньою. Приклад з відео:

#Метод clear() очищає множину
varCarSet = {"Dodge", "Ford", "Toyota"}
print(varCarSet)
varCarSet.clear()
print(varCarSet)
del varCarSet
#print(varCarSet)

Метод union()

Метод union() у множинах Python використовується для створення нової множини, яка містить усі елементи з двох або більше множин. Це метод повертає нову множину, яка є об’єднанням двох або більше множин. Приклад з відео:

#Можна використати метод union(), 
#який повертає нову 
#множину, що містить всі елементи 
#об'єднуваних множин
varCarSet1 = {"Dodge", "Ford", "Toyota"}
varCarSet2 = {"BMW", "Lincoln"}
varCarSet3 = varCarSet1.union(varCarSet2)
print(varCarSet1)
print(varCarSet2)
print(varCarSet3)

Метод intersection_update()

Метод intersection_update() у множинах Python оновлює множину, зберігаючи тільки ті елементи, які є спільними для всіх наданих ітерованих об’єктів. Це модифікує оригінальну множину. Приклад з відео:

#Метод intersection_update() збереже тільки ті  
#елементи, які є в наявності в обох множинах.
varCarSet1 = {"Dodge", "Ford", "Toyota", "Lincoln", "BMW"}
varCarSet2 = {"Honda","Alfa Romeo","Chrysler","Dodge","Lincoln"}
print(varCarSet1)
print(varCarSet2)
varCarSet1.intersection_update(varCarSet2)
print(varCarSet1)
print(varCarSet2)

Метод intersection()

Метод intersection() у множинах Python повертає нову множину, що містить тільки ті елементи, які є спільними для всіх наданих ітерованих об’єктів. Це дозволяє знайти перетин множин або інших ітерованих об’єктів. Приклад з відео:

#Метод intersection() поверне нову множину, яка 
#містить тільки ті елементи, які є в обох множинах.
varCarSet1 = {"Dodge", "Ford", "Toyota"}
varCarSet2 = {"Honda", "Dodge", "Ford", "Lincoln"}
varCarSet3 = varCarSet1.intersection(varCarSet2)
print(varCarSet1)
print(varCarSet2)
print(varCarSet3)

Метод symmetric_difference_update()

Метод symmetric_difference_update() у множинах Python оновлює множину, зберігаючи тільки ті елементи, які є унікальними для кожної з наданих множин (тобто, ті, що не зустрічаються в обох множинах). Це модифікує оригінальну множину, залишаючи тільки симетричну різницю. Приклад з відео:

#Метод symmetric_difference_update() збереже тільки 
#ті елементи, які НЕ є спільними для обох множин
varCarSet1 = {"Dodge", "Ford", "Toyota"}
varCarSet2 = {"Dodge", "Honda", "Lincoln"}
print(varCarSet1)
print(varCarSet2)
varCarSet1.symmetric_difference_update(varCarSet2)
print(varCarSet1)
print(varCarSet2)

Метод symmetric_difference()

Метод symmetric_difference() у множинах Python повертає нову множину, яка містить тільки ті елементи, які є унікальними для кожної з наданих множин (тобто, елементи, які не зустрічаються в обох множинах). Це означає, що він обчислює симетричну різницю між множинами. Приклад з відео:

#Метод symmetric_difference() поверне нову множину, яка 
#містить тільки ті елементи, які НЕ є спільними для обох множин.
varCarSet1 = {"Dodge", "Ford", "Toyota"}
varCarSet2 = {"Honda", "Dodge", "Lincoln"}
varCarSet3 = varCarSet1.symmetric_difference(varCarSet2)
print(varCarSet1)
print(varCarSet2)
print(varCarSet3)

Функція frozenset()

Функція frozenset() у Python створює новий об’єкт множини, яка є незмінною (іммутабельною). Це означає, що після створення frozenset не можна додавати, видаляти або змінювати його елементи. Приклад з відео:

#Функція frozenset() повертає немутабельний об'єкт frozenset
varCarSet = {"Dodge", "Ford", "Toyota"}
print(varCarSet)
varCarSet.add("Lincoln")
print(varCarSet)

frozenVarCarSet = frozenset(varCarSet)
print(frozenVarCarSet)
#frozenVarCarSet.pop("Ford")
#frozenVarCarSet.add("Chrysler")
Урок 15. Множини в Python

В цьому відео поговоримо про:
00:17 Python Sets – множини
02:03 Duplicates Not Allowed – дуплікати не дозволені
04:22 Get the Length of a Set – Отримання довжини множини
05:29 Set Items – Data Types – Типи даних елементів у множинах
06:47 set() Constructor – Конструктор
08:06 Access Items – Доступ до елементів
09:57 Add Items – Додавання елементів
11:40 Add Sets – Додавання множин
13:52 Add Iterable – Додавання ітерабельного об’єкту
15:30 Remove Item – Видалення елементу
18:12 Discard Item – Видалення елементу за допомогою методу discard
20:47 Pop Item – Видалення елементу за допомогою методу pop
23:57 Clear set – Очищення множини
26:38 union() метод
30:53 intersection_update() метод
34:04 intersection() метод
36:21 symmetric_difference_update() метод
40:20 symmetric_difference() метод
42:29 frozenset() метод

Приклади на Github

Урок 14. Кортежі в Python

Кортежі в Python — це незмінні (immutable) послідовності, які можуть містити кілька елементів. Вони дуже схожі на списки, але на відміну від списків, елементи кортежів не можна змінювати після їх створення. Це означає, що ви не можете додавати, видаляти або змінювати елементи кортежу.

Приклад з відео:

#Кортежі використовуються для зберігання кількох елементів в одній змінній.
#Кортеж — це впорядкована та незмінна колекція.
carTuple1 = ("Dodge", "Ford", "Toyota")
print(carTuple1)

Елементи кортежів проіндексовані, перший елемент має індекс 0, себто аналогічно до списків в цьому аспекті.

Приклад з відео:

#Елементи кортежу індексуються, перший елемент має індекс [0],
#другий елемент має індекс [1] тощо.
#Коли ми говоримо, що кортежі впорядковані, це означає, що
#елементи мають визначений порядок, і цей порядок не зміниться.
#Кортежі незмінні, тобто ми не можемо змінити,
#додати або видалити елементи після створення кортежу.
carTuple1 = ("Dodge", "Ford", "Toyota", "Dodge", "Ford")
print(carTuple1)
lengthOfCarTuple1 = len(carTuple1)
print("Length of carTuple1 equlas {}".format(lengthOfCarTuple1))

Є опція створення кортежу з одним елементом. Приклад з відео:

#Щоб створити кортеж лише з одним елементом, потрібно додати
#кому після елемента, інакше Python не розпізнає
#це як кортеж.
varCarTuple1 = ("Dodge",)
print(type(varCarTuple1))

varCarTuple2 = ("Dodge")
print(type(varCarTuple2))

Типи даних у кортежах

Кортежі в Python можуть містити елементи різних типів даних. Вони дозволяють зберігати різноманітні типи даних разом у одному об’єкті. Приклад з відео:

#Елементи кортежу можуть мати будь-який тип даних
varCarTuple1 = ("Dodge", "Ford", "Toyota")
numTuple1 = (1,3,5,7,9)
boolTuple1 = (True, False)
itemBusketTuple1 = (5.7, True, "Text", 25)
print(varCarTuple1)
print(numTuple1)
print(boolTuple1)
print(itemBusketTuple1)

Конструктор tuple()

У Python конструктор tuple() використовується для створення нового кортежу з будь-якого ітерованого об’єкта або послідовності. Це функція, яка може перетворити інші типи даних, такі як списки, рядки, чи інші ітеровані об’єкти, в кортежі.

Приклад з відео:

#Також можна використовувати конструктор tuple().
#щоб створити кортеж
varCarTuple1 = tuple(("Dodge", "Ford", "Toyota"))
print(varCarTuple1)
print(type(varCarTuple1))

Доступ до елементів кортежу

Доступ до елементів кортежу в Python здійснюється подібно до списків, використовуючи індексацію елементів.

Приклад з відео:

#Ви можете отримати доступ до елементів кортежу, 
#посилаючись на номер індексу, в квадратних дужках
varCarTuple1 = ("Dodge", "Ford", "Toyota")
print(varCarTuple1[0])
print(varCarTuple1[1])
print(varCarTuple1[2])
#Негативна індексація означає початок з кінця
#-1 стосується останнього елемента, 
#-2 стосується передостаннього елемента тощо
print(varCarTuple1[-1])
print(varCarTuple1[-2])
print(varCarTuple1[-3])

Діапазони індексів

Діапазони індексів, або зрізи (slices), дозволяють отримувати підмножини елементів в тому числі і з кортежу. Приклад з відео:

#Ви можете вказати діапазон індексів, вказавши де
#почати і де закінчити діапазон
varCarTuple1 = ("Dodge", "Ford", "Toyota", "Chrysler", "Lincoln")
print(varCarTuple1[1:4]) #індекс 4 не включається
print(varCarTuple1[:4]) #індекс 4 не включається
print(varCarTuple1[1:])

Перевірка наявності елементу

За допомогою ключового слова in можна перевірити наявність певного елемента у кортежі. Приклад з відео:

# Щоб визначити, чи присутній певний елемент у кортежі
#використовуйте ключове слово in
varCarTuple1 = ("Dodge", "Ford", "Toyota")
if "Dodge" in varCarTuple1:
    print("Dodge is present in varCarTuple1")
    
else:
    print("Dodge is not present in varCarTuple1")

Зміна значень у кортежах

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

Приклад з відео:

#Кортежі є незмінними або немутабельними, як їх ще називають
#Ви можете перетворити кортеж на список, змінити список,
#і перетворити список назад у кортеж
varCarTuple1 = ("Dodge", "Ford", "Toyota")
print(varCarTuple1)
print(type(varCarTuple1))
tempList = list(varCarTuple1)
tempList[1] = "Honda"
print(tempList)
print(type(tempList))
varCarTuple1 = tuple(tempList)
print(varCarTuple1)
print(type(varCarTuple1))

Додавання елементів

Аналогічна ситуація з додаванням елементів до кортежу. Приклад з відео:

#кортежі незмінні. Якщо вам потрібно додати 
#елемент до кортежу, то можна
#перетворити його на список, внести зміни 
#та перетворити список назад на кортеж
varCarTuple1 = ("Dodge", "Ford", "Toyota")
print(varCarTuple1)
tempList = list(varCarTuple1)
tempList.append("Lincoln")
varCarTuple1 = tuple(tempList)
print(varCarTuple1)

Видалення елементів

Стосовно видалення елементів з кортежу – ситуація також аналогічна, себто користоємось попереднім алгоритмом дій – перетворюємо кортеж на список, далі вносимо зміни і знову перетворюємо на кортеж. Приклад з відео:

#Кортежі незмінні, тому ви не можете видалити елементи з нього
#Обхідний шлях той самий, перетворити кортеж на список, внести зміни,
#і перетворити список назад на кортеж
varCarTuple1 = ("Dodge", "Ford", "Toyota", "Car1")
print(varCarTuple1)
tempList = list(varCarTuple1)
tempList.pop()
varCarTuple1 = tuple(tempList)
print(varCarTuple1)

Додавання кортежів

В Python можна додавати кортеж до кортежу. Приклад з відео:

#В Python дозволено додавати кортежі до кортежів
varCarTuple1 = ("Dodge", "Ford", "Toyota")
varCarTuple2 = ("Lincoln", "BMW")
print(varCarTuple1)
print(varCarTuple2)
varCarTuple1 += varCarTuple2
print(varCarTuple1)
print(varCarTuple2)

Розпакування кортежу

Познайомимося з синтаксисом розпакування кортежу. Приклад з відео:

#упаковка кортежу
varCarTuple1 = ("Dodge", "Ford", "Toyota")
print(varCarTuple1)
#розпакування кортежу
(car1, car2, car3) = varCarTuple1
print(car1)
print(car2)
print(car3)

Також при розпакуванні кортежу можна скористатися синтаксичною опцією з зірочкою. Приклад з відео:

#Якщо кількість змінних менша за кількість значень,
#ви можете додати * до назви змінної тоді значеня
#буде призначено змінній у вигляді списку
varCarTuple1 = ("Dodge", "Ford", "Toyota", "Lincoln", "BMW")
print(varCarTuple1)
(car1, car2, *car3) = varCarTuple1
print(car1)
print(car2)
print(car3)

Цикл for та кортежі

Цикли for в Python є дуже зручним інструментом для ітерації через елементи різних типів даних, включаючи кортежі. Вони дозволяють перебирати всі елементи кортежу один за одним і виконувати над ними операції.

Приклад з відео:

#Ви можете пройти через елементи 
#кортежу за допомогою циклу for
varCarTuple1 = ("Dodge", "Ford", "Toyota")
for car in varCarTuple1:
    print(car)

Приклад використання циклу for у поєднанні з функціями range() та len() на кортежах:

#Ви також можете переглядати елементи кортежу, посилаючись
#на індексний номер елемента
#Використовуйте функції range() і len(), щоб створити відповідну ітерацію
varCarTuple1 = ("Dodge", "Ford", "Toyota")
for i in range(len(varCarTuple1)):
    print(varCarTuple1[i])

Цикл while та кортежі

Цикл while в Python є ще одним корисним інструментом для ітерації, але його використання з кортежами дещо відрізняється від циклу for. Цикл while зазвичай використовується, коли потрібно продовжувати ітерацію до виконання певної умови, а не для простого перебору елементів.

Приклад з відео:

#Ви можете пройти через елементи 
#кортежу за допомогою циклу while
varCarTuple = ("Dodge", "Ford", "Toyota")
counter = 0
while counter < len(varCarTuple):
    print(varCarTuple[counter])
    counter = counter+1

Об’єднання та множення кортежів

В Python кортежі можуть бути об’єднані (конкатеновані) і помножені. Ці операції дозволяють вам легко працювати з кортежами, комбінуючи їх або створюючи нові на основі існуючих.

Приклад з відео:

#щоб додати кортежі, використовуйте оператор +
varCarTuple1 = ("Dodge", "Ford", "Toyota")
varCarTuple2 = ("Alfa Romeo", "BMW")
varCarTuple3 = varCarTuple1+varCarTuple2
print(varCarTuple1)
print(varCarTuple2)
print(varCarTuple3)
#Якщо ви хочете помножити вміст кортежу
#на вказану кількість разів, 
#ви можете використовувати оператор *
varCarTuple4 = varCarTuple3*2
print(varCarTuple4)
Урок 14. Кортежі в Python

В цьому відео поговоримо про:
00:14 Python Tuples – Кортежі
03:47 Syntax for tuple with one item – синтаксис для кортежу з одного елементу
06:34 Data Types in Tuples – Типи даних у кортежах
07:43 Tuple Constructor – Конструктор кортежу
10:42 Access Items – Доступ до елементів
12:17 Range of Indexes – Діапазон індексів
15:36 Check if item exists – Перевірка наявності елементу
17:47 Change values in tuples – Зміна значення у кортежах
25:17 Add items – Додавання елементів
27:39 Remove items – Видалення елементів
29:32 Add tuples – Додавання кортежів
33:44 Unpacking tuple – Розпаковання кортежу
36:35 Unpacking tuple with * – Розпакування кортежу з *
39:06 For loop – цикл
41:07 While loop – цикл
42:43 Join and multiply tuples – Об’єднання та множення кортежів

Приклади на Github

З Днем Незалежності України!

Щиро вітаю всіх співвітчизників з Днем Незалежності України! Нехай цей день наповнить ваші серця гордістю за нашу країну, а наш спільний шлях до процвітання буде сповнений віри, сили та єдності. Бажаю кожному з вас міцного здоров’я, щастя та перемоги.

Слава Україні!

Урок 13. Списки

В Python виділяють наступні типи колекцій:

  • Список – це колекція, яка є впорядкованою та змінною. Дозволяє дублювати елементи.
  • Кортеж – це впорядкована та незмінна колекція. Дозволяє дублювати елементи.
  • Набір – це невпорядкована, незмінна та неіндексована колекція. Не дозволяє дублювати елементи.
  • Словник – збірка, яка є впорядкованою та змінною. Не дозволяє дублювати елементи.

Списки в Python — це один з основних типів даних, який дозволяє зберігати колекцію елементів. Вони дуже зручні для роботи з групами даних, оскільки дозволяють зберігати елементи різного типу (числа, рядки, інші списки тощо) і виконувати різноманітні операції над цими елементами.

Приклад з відео:

#Списки використовуються для зберігання кількох елементів в одній змінній
#Елементи списку впорядковані, змінні та допускають дублювання значень
#Елементи списку проіндексовано, перший елемент має індекс [0]
carList1 = ["Dodge", "Ford", "Toyota"]
print(carList1)
print(carList1[0])
print(carList1[1])
print(carList1[2])

Дублікати та довжина списку

В Python списки можуть містити дублікати значень, тобто однакові елементи можуть з’являтися кілька разів.

У Python для отримання довжини списку використовують вбудовану функцію len(). Ця функція повертає кількість елементів у списку.

Приклад з відео:

#Списки можуть містити елементи з однаковим значенням
#Функцію len можна використовувати для визначення довжини списку
varCarList1 = ["Dodge", "Ford", "Toyota", "Dodge", "Ford"]
print(varCarList1)
varCarList1Length = len(varCarList1)
print("Length of varCarList1 equals ", varCarList1Length)

Типи даних у списках

У Python списки можуть містити елементи будь-якого типу даних, і навіть комбінації різних типів. Це робить списки дуже гнучкими для зберігання та обробки різних видів даних.

#Елементи списку можуть мати будь-який тип даних
#Список може містити різні типи даних
varCarList1 = ["Dodge", "Ford", "Toyota"]
varNumbersList1 = [1,2,3,4,5]
varBoolList1 = [True, False]
varBusketList1 = [1, "Text", True, 27]
print(varCarList1)
print(varNumbersList1)
print(varBoolList1)
print(varBusketList1)

type та list

У Python для перевірки типу змінної, включаючи списки, використовують функцію type(). Якщо вам потрібно перевірити, чи є змінна списком, ви можете порівняти результат type() з типом list.

У Python конструктор list використовується для створення нових списків.

Приклад з відео:

#списки визначаються як об'єкти з типом даних "list"
varCarList1 = ["Dodge", "Ford", "Toyota"]
print(varCarList1)
print(type(varCarList1))
#Використання конструктора list() для створення списку
varCarList2 = list(("Dodge","Ford","Toyota", "BMW"))
print(varCarList2)

Доступ до елементів списку

В Python індексація є основним способом доступу до елементів списку. Індексація дозволяє отримувати окремі елементи списку за допомогою індекса, який вказує на позицію елемента в списку.

Приклад з відео:

#ви можете отримати доступ до елементів списку, 
#посилаючись на номер індексу
#перший елемент має індекс 0
varCarList1 = ["Dodge", "Ford", "Toyota", "BMW", "Nissan"]
print(varCarList1[0])
print(varCarList1[1])
print(varCarList1[2])
#негативна індексація
#-1 відноситься до останнього елемента, 
#-2 відноситься до передостаннього елемента
print(varCarList1[-1])
print(varCarList1[-2])
print(varCarList1[-3])
#діапазон індексів [1:4] [:3] [-3:-1]
print(varCarList1[1:4])
print(varCarList1[:3])
print(varCarList1[-3:-1])
print(varCarList1[2:])

Пошук і зміна елементів

У Python перевірити наявність елемента у списку можна за допомогою ключового слова in.

Приклад з відео:

# Щоб визначити, чи присутній певний елемент у списку
#використовуйте ключове слово 'in'
varCarList1 = ["Dodge", "Ford", "Toyota"]
checkForItem1 = "Dodge" in varCarList1
checkForAbsenceItem1 = "Dodge" not in varCarList1
print(varCarList1)
print(checkForItem1)
print(checkForAbsenceItem1)
#Щоб змінити значення певного елемента,
#посилайтеся на індекс
varCarList1[2] = "Honda"
print(varCarList1) #['Dodge', 'Ford', 'Honda']
varCarList1[0:2]=["Chrysler", "Lincoln"]
print(varCarList1) #['Chrysler', 'Lincoln', 'Honda']
varCarList1[0:2] = ["Dodge", "Ford", "Nissan"]
print(varCarList1) #['Dodge', 'Ford', 'Nissan', 'Honda']
varCarList1[0:2] = ["Chrysler"] #['Chrysler', 'Nissan', 'Honda']
print(varCarList1)

Метод insert

Метод insert у Python використовується для вставки елемента в конкретну позицію в списку. Цей метод дозволяє вказати індекс, на якому потрібно вставити новий елемент, а також сам елемент.

Приклад з відео:

#insert() метод вставляє елемент за вказаним індексом
varCarList1 = ["Dodge", "Ford", "Toyota"]
print(varCarList1)
varCarList1.insert(2, "Lincoln")
print(varCarList1)

Метод append

Метод append у Python використовується для додавання одного елемента в кінець списку. Це один з найбільш часто використовуваних методів для роботи зі списками, оскільки він дозволяє ефективно розширювати список, додаючи нові елементи.

Приклад з відео:

#Використання методу append() для додавання елемента
varCarList1 = ["Dodge", "Ford", "Toyota"]
print(varCarList1)
varCarList1.append("Chrysler")
print(varCarList1)

Метод extend

Метод extend у Python використовується для додавання всіх елементів з ітерабельного об’єкта (наприклад, списку, множини, рядка) в кінець існуючого списку. Це відрізняється від методу append, який додає ітерабельний об’єкт як один елемент.

Приклад з відео:

#Для додавання елементів з іншого ітерабельного об’єкта
#до поточного списку,
#використовуйте метод extend().
varCarList1 = ["Dodge", "Ford", "Toyota"]
varCarList2 = ["Chrysler", "Lincoln"]
print(varCarList1)
varCarList1.extend(varCarList2)
print(varCarList1)
print(varCarList2)

Метод remove

Метод remove у Python використовується для видалення першого входження вказаного елемента зі списку. Якщо елемент не існує у списку, метод викличе помилку ValueError. Метод remove працює тільки для видалення значень, а не за індексом.

Приклад з відео:

#Метод remove() видаляє перший вказаний елемент
varCarList1 = ["Dodge", "Ford", "Toyota", "Ford"]
print(varCarList1)
varCarList1.remove("Ford")
print(varCarList1)

Метод pop

Метод pop у Python використовується для видалення і повернення елемента зі списку за вказаним індексом. Якщо індекс не вказаний, метод pop видалить і поверне останній елемент списку. Метод pop змінює список на місці, і він може бути корисним, коли потрібно отримати видалений елемент, а не просто видалити його.

Приклад з відео:

#pop() метод видаляє вказаний індекс
varCarList1 = ["Dodge", "Ford", "Toyota"]
print(varCarList1)
varCarList1.pop(1)
print(varCarList1)
#Якщо не вказати індекс,
#Метод pop() видаляє останній елемент
varCarList1.pop()
print(varCarList1)
#Ключове слово del також видаляє вказаний індекс
varCarList2 = ["Chrysler", "Honda", "Lincoln"]
print(varCarList2)
del varCarList2[0]
print(varCarList2)
del varCarList2
#print(varCarList2)
# varCarList2 = ["Chrysler", "Honda", "Lincoln"]
# print(varCarList2)

Метод clear

Метод clear у Python використовується для видалення всіх елементів зі списку, очищаючи його. Це простий і ефективний спосіб скинути список до порожнього стану.

Приклад з відео:

#Метод clear() очищає список
#Список все ще залишається, але в ньому немає змісту
varCarList1 = ["Car1", "Car2", "Car3"]
print(varCarList1)
varCarList1.clear()
print(varCarList1)

Цикл for та списки

Цикл for у Python є потужним інструментом для ітерації через елементи списку. Використання циклу for дозволяє легко обробляти всі елементи списку один за одним. Це особливо корисно для виконання операцій над кожним елементом списку, таких як обчислення, модифікації або просто друк значень.

Приклад з відео:

#Ви можете пройтися черз елементи списку 
#за допомогою циклу for
varCarList1 = ["Dodge", "Ford", "Toyota"]

for car in varCarList1:
    print(car)

Також можливо комбінувати використання циклу for з функціями range() та len(), що по суті надає можливість звертатися до елементів списку за індексом.

Приклад з відео:

#Ви також можете переглядати елементи списку, посилаючись
#до відповідного номера індексу за допомогою функцій range() і len().
varCarList1 = ["Dodge", "Ford", "Toyota"]
for i in range(len(varCarList1)):
    print(varCarList1[i])

Цикл while та списки

Цикл while у Python є ще одним потужним інструментом для роботи зі списками, хоча його використання дещо відрізняється від циклу for. Цикл while продовжує виконуватись доти, поки умова залишається істинною, що дає більшу гнучкість у деяких випадках, але також вимагає ручного управління індексами або станом списку.

Приклад з відео:

#Ви можете пройти через елементи списку за допомогою циклу while
#Використовуйте функцію len(), щоб визначити довжину списку,
#тоді почніть з 0 і пройдіть по елементам списку,
#посилаючись на їхні індекси
varCarList1 = ["Dodge", "Ford", "Toyota"]
counter = 0
while counter<len(varCarList1):
    print(varCarList1[counter])
    counter = counter+1

Спрощений синтаксис

Існує спрощений синтаксис, який можна використовувати при створенні спсиків. Приклад з відео:

#newlist = [вираз для елемента в iterable if condition == True]
#Поверненим значенням є новий список, який залишає старий список без змін.
varCarList1 = ["Dodge", "Ford", "Toyota"]
varCarList2 = []
for car in varCarList1:
    varCarList2.append(car)    
print("varCarList 1 {}".format(varCarList1))
print("varCarList 2 {}".format(varCarList2))
varCarList3 = [car for car in varCarList1]
print("varCarList 3 {}".format(varCarList3))
#print elements of the list with comprehension syntax
[print(car) for car in varCarList3]

Метод sort

Метод sort у Python використовується для сортування елементів списку в порядку зростання або спадання. Метод sort змінює порядок елементів у списку на місці, тобто він не повертає нового списку, а змінює оригінальний.

Приклади з відео:

#Об’єкти List мають метод sort(), який сортує
#список у алфавітно-цифровому порядку, за замовчуванням
varCarList1 = ["Dodge", "Ford", "Toyota", "BMW", "Honda"]
varCarList1.sort()
print(varCarList1)
numList1 = [5,7,3,9,1]
numList1.sort()
print(numList1)
#Щоб відсортувати за спаданням, 
#використовуйте аргумент ключового слова reverse = True
varCarList1 = ["Dodge","Ford","Toyota","BMW","Honda"]
varCarList1.sort(reverse=True)
print(varCarList1)
numList1 = [1,3,5,7,9]
numList1.sort(reverse=True)
print(numList1)
#За замовчуванням метод sort() чутливий до регістру, що призводить до
#того, що усі великі літери сортуються перед малими
itemsList1= ["notebook", "Pencil", "flash drive", "Scissors"]
itemsList1.sort()
print(itemsList1)

itemsList1.sort(key=str.lower)
print(itemsList1)
#Метод reverse() змінює поточний порядок сортування
#елементів
itemsList1.reverse()
print(itemsList1)

Метод copy

Метод copy у Python використовується для створення поверхневої копії списку. Це означає, що метод copy створює новий список, який має ті ж елементи, що й оригінальний, але сам список і його елементи в пам’яті є окремими. Це корисно, коли потрібно створити копію списку, щоб уникнути змін в оригінальному списку під час маніпуляцій з його копією.

Приклад з відео:

#Ви не можете скопіювати список, просто ввівши list2 = list1,
#бо: list2 буде лише посиланням на list1, і
#зміни, зроблені в списку1, автоматично також будуть внесені в список2.
#використовуйте вбудований метод copy()
varCarList1=["Dodge", "Ford", "Toyota"]
varCarList2=varCarList1.copy()
print(varCarList1)
print(varCarList2)
varCarList1.append("Honda")
varCarList2.append("BMW")
print(varCarList1)
print(varCarList2)

varCarList3=list(varCarList1)
print(varCarList3)
varCarList3.append("Alfa Romeo")
print(varCarList3)

Об’єднання списків

Існує кілька варіантів об’єднання списків, зокрем можна використати оператор + чи метод extend або комбінацію циклу for та методу append.

Приклад з відео:

#використовуйте оператор + для об'єнання списків
varCarList1=["Dodge", "Ford", "Toyota"]
varCarList2=["Honda","BMW"]
varCarList3=["Alfa Romeo", "Chevrolet"]
varCarList4 = varCarList1+varCarList2
print(varCarList4)
#метод extend
varCarList1.extend(varCarList3)
print(varCarList1)
#цикл for для додавання елементів
for car in varCarList3:
    varCarList2.append(car)
    
print(varCarList2)
Урок 13. Списки у Python

В цьому відео поговоримо про:
00:00:19 Python Collections – Колекції
00:03:01 Python Lists – Списки
00:04:52 Duplicates and List Length – Дуплікати і розмір (довжина) списку
00:07:07 List Data Types – Типи даних у списках
00:09:06 функція type and конструктор list
00:11:21 Indexing (access list items) – Індекси елементів списку
00:19:56 Check for and change – Перевірка і зміна
00:29:02 Insert items – Введення елементів
00:30:44 Append items – Додавання елементів
00:32:21 Extend list – Розширення списку
00:34:56 Remove item – Видалення елементу
00:36:51 Remove specified index – Видалення елементу по індексу
00:44:17 Clear method – Метод очистити
00:45:46 For Loop and List – Цикл For і список
00:48:14 For Loop with index numbers – Цикл For з номерами індексів
00:51:59 While Loop and List – Цикл while і список
00:54:35 List Comprehension – Спрощення списку
00:58:59 Sort ascending – Сортування за зростанням
01:00:38 Sort descending – Сортування за зменшенням
01:02:21 Case Insensitive Sort – Сортування нечутливе до регістру
01:06:24 Copy List – Копіювання списку
01:10:50 Join Lists – Об’єднання списку

Урок 12. Функції у Python

У Python функції є засобом організації коду, який дозволяє групувати і повторно використовувати блоки коду для виконання певних завдань. Функції використовуються для виконання конкретних операцій або обчислень при виклику з інших частин програми.

Приклад з відео:

#Функція — це блок коду, який виконується лише тоді, коли його викликають.
#Ви можете передавати дані, відомі як параметри, у функцію.
#Функція може повертати дані як результат.
#У Python функція визначається за допомогою ключового слова def
def greeting_function():
    print("Hello buddy!")
    
greeting_function()

Аргументи функції

Аргументи функції у Python — це значення, які передаються у функцію під час її виклику. Ці значення використовуються в тілі функції для виконання певних операцій або обчислень. Вони дозволяють функціям приймати зовнішні дані і оперувати ними всередині свого тіла.

Приклад з відео:

#Інформацію можна передати у функції як аргументи.
#Аргументи вказуються після імені функції,
#в дужках.
#Ви можете додати скільки завгодно аргументів,
#просто розділіть їх комою.
def greeting_function(nameVar):
    print("Hello",nameVar)
    
greeting_function("Walter")
greeting_function("Skyler")

Відмінність між параметрами та аргументами

Параметри функції — це іменовані змінні, оголошені в заголовку функції, які визначають дані, які функція очікує отримати при своєму виклику. Вони вказуються в круглих дужках після імені функції і визначають, які дані можна передати у функцію.

Аргументи функції — це конкретні значення, які передаються у функцію під час її виклику. Це дані або значення, які ви передаєте у функцію для обробки або виконання операцій, що вона виконує.

Приклад з відео:

#Параметр — це змінна, вказана в дужках
#у визначенні функції.
#Аргумент — це значення, яке надсилається функції
#коли її викликають.
def add_two_numbers(num1, num2):
    print(num1+num2)
    
add_two_numbers(5,10)

Кількість аргументів

У Python функції можуть приймати різну кількість аргументів залежно від потреб програми. Це дозволяє створювати більш гнучкі та універсальні функції.

Приклад з відео:

#функцію потрібно викликати з правильною кількістю аргументів.
#Це означає, що якщо ваша функція очікує 2 аргументи,
#ви повинні викликати функцію з 2 аргументами,
#не більше і не менше.
def greeting_function(nameVar, surnameVar):
    print("Hello", nameVar, surnameVar)
    
greeting_function("Walter", "White")

*args

У Python параметр *args використовується для передачі довільної кількості позиційних аргументів у функцію. Цей параметр дозволяє функції приймати будь-яку кількість аргументів, які передаються у вигляді кортежу.

Приклад з відео:

#Якщо ви не знаєте, скільки аргументів буде передано
#у свою функцію додайте * перед назвою параметра
#у визначенні функції
#Таким чином функція отримає кортеж аргументів,
#і може отримати доступ до елементів відповідно
def greeting_function(*namesVar):
    print("Hello {}, {}".format(namesVar[0], namesVar[1]))
    
greeting_function("Walter", "Skyler")

Синтаксис ключ-значення

У Python синтаксис ключ-значення при використанні аргументів функцій використовується для передачі іменованих аргументів у вигляді пари “ключ=значення”. Цей підхід дозволяє передавати аргументи у будь-якому порядку, не обов’язково використовувати порядок, вказаний у визначенні функції, і також задавати значення за замовчуванням для параметрів.

Приклад з відео:

#Ви також можете надсилати аргументи 
#за допомогою синтаксису ключ = значення.
def greeting_function(name1, name2, name3):
    print("Hello {}, {}, {}!".format(name1, name2, name3))
    
greeting_function(name3="Walter", name2="Skyler", name1="Hank")

**kwargs

У Python параметр **kwargs використовується для передачі довільної кількості іменованих (ключованих) аргументів у функцію. Цей параметр дозволяє функції приймати будь-яку кількість іменованих аргументів, які не є обов’язковими, і збирає їх у словник.

Приклад з відео:

#Якщо ви не знаєте, скільки аргументів ключових слів
#буде передано у вашу функцію, додайте
#дві зірочки: ** перед назвою параметра при
#визначенні функції.
#Таким чином функція отримає словник аргументів,
#і може отримати доступ до елементів відповідно
def greeting_function(**names):
    print("Hello {}, {}!".format(names["name1"], names["name2"]))
    
greeting_function(name1 = "Skyler", name2 = "Walter")

Значення параметру за помовчанням

У Python значення параметру за замовчуванням використовується для встановлення значення параметра, яке буде використовуватися, якщо при виклику функції або при створенні об’єкта параметр не передається. Це дає можливість функціям мати значення аргументів, які вони використовують за замовчуванням, що спрощує їхнє використання в коді.

Приклад з відео:

#Якщо ми викликаємо функцію без аргументів,
#використовуються значення за умовчанням
def greeting_function(name="James"):
    print("Hello {}!".format(name))
    
greeting_function("Walter")
greeting_function()

Використання return та pass

У Python оператор return використовується для завершення виконання функції та повернення значення (або значень) з функції до місця її виклику. Коли викликають функцію із return, вона повертає обчислене значення (або нічого, якщо return відсутній) та перериває подальше виконання функції.

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

Приклад з відео:

#Щоб дозволити функції повертати значення, 
#використовуйте оператор return
def multiply_by_itself(num1):
    return num1*num1

result1 = multiply_by_itself(3)
print(result1)
result2 = multiply_by_itself(5)
print(result2)
result3 = multiply_by_itself(7)
print(result3)

# визначення функції не можуть бути порожніми, але якщо ви
#з якихось причин маєте визначення функції без вмісту,
#введіть оператор pass, щоб уникнути помилки.
def greeting_function():
    pass

Рекурсія

Рекурсія в Python (і в інших мовах програмування) є технікою, коли функція викликає саму себе під час свого виконання. Це дозволяє вирішувати складні завдання, розбиваючи їх на менші або подібні задачі. Рекурсія є важливим інструментом у програмуванні, особливо в алгоритмах, де задачі мають структуру, що повторюється або рекурсивну.

Приклад з відео:

#Рекурсія — поширена математична та програмна концепція.
#Це означає, що функція викликає сама себе.
#Це має перевагу, оскільки ви можете перерахувати дані
#для досягнення потрібного результату.
def recursion_function(num1):
    if(num1<10):
        result=0
        print(num1)
        print(result)
        result = num1 + recursion_function(num1+1)
        print(result)
    else:
        result=10
        print("Else statement works.")
    return result

recursion_function(1)

Лямбда-функції

У Python лямбда-функція – це коротка функція, яка може мати лише один вираз. Вона створюється за допомогою ключового слова lambda, яке дозволяє швидко оголосити функцію без необхідності використання імені через звичайний визначення def.

Приклад з відео:

#Лямбда-функція — це невелика анонімна функція.
#Лямбда-функція може приймати будь-яку кількість аргументів,
#але може мати лише один вираз.
#синтаксис
#лямбда-аргументи : вираз
#lambda arguments : expression
plusFive = lambda num1 : num1+5
print(plusFive(10))

multiplyTwoNums = lambda num1, num2 : num1*num2
print(multiplyTwoNums(5,7))

sumOfThreeNums = lambda num1, num2, num3 : num1+num2+num3
print(sumOfThreeNums(5,7,9))

Ще один приклад використання лямбда-функції:

#Потужність лямбда краще проявляється, 
#коли ви використовуєте їх як
#анонімну функція всередині іншої функції.
def my_function(num1):
    return lambda unknownNum : unknownNum * num1

doubleNum = my_function(2)
print("Doubled results")
print(doubleNum(1))
print(doubleNum(5))
print(doubleNum(10))

numByFive = my_function(5)
print("Multiplied by five results")
print(numByFive(5))
print(numByFive(10))
Урок 12. Функції у Python

В цьому відео поговоримо про:
00:19 Functions – Функції
02:36 Arguments – Аргументи
04:10 Parameters and arguments – Параметри і аргументи
06:26 Number of arguments – Кількість аргументів
07:51 *args – якщо не знаємо скільки аргументів
11:47 Keyword arguments – Синтаксис ключ-значення
17:07 **kwargs – якщо невідомо скільки агрументів, але можливе використання ключових слів
22:03 Default parameter value – Параметр за помовчанням
24:11 Return values and pass statement – Повернення значень та pass
29:34 Recursion – Рекурсія
42:05 Lambda functions – Лямбда функції

Приклади на Github