Month: September 2024

Менеджер пакетів

PIP — це менеджер пакетів для пакетів або модулів Python.

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

#команда для перевірки версії
pip  --version
#команда для встановлення відповідного пакету
pip install nameOfPackage
#команда для видалення відповідного пакету
pip uninstall nameOfPackage
#команда для виведення списку пакетів
pip list

Приклад введення команди в cmd:

Приклад введення команди в терміналі:

Масиви в Python

Для роботи з масивами в Python вам доведеться імпортувати бібліотеку, наприклад бібліотеку NumPy. NumPy — це бібліотека Python, яка використовується для роботи з масивами. NumPy створив у 2005 році Тревіс Оліфант. Це проект з відкритим кодом. NumPy означає Numerical Python.

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

Встановлення NumPy

Якщо у вас уже встановлено Python і PIP, установити NumPy дуже просто. Використовуйте команду: pip install numpy

Приклад введення команд для встановлення в Visual Studio Community:

Створення масивів

numpy.array — це функція в бібліотеці NumPy, яка використовується для створення масивів (об’єктів типу ndarray). Ці масиви є основним об’єктом в NumPy і дозволяють ефективно зберігати та обробляти дані.

Спершу слід імпортувати бібліотеку NumPy. Далі за допомогою функції array можна створити потрібний нам масив. Приклад з відео:

#NumPy зазвичай імпортується під псевдонімом np.
import numpy as np

numbersArray1 = np.array([1,3,5,7,9])
print(numbersArray1)
print(type(numbersArray1))

for num in numbersArray1:
    print(num)

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

Доступ до елементів масивів, створених за допомогою numpy.array, здійснюється за допомогою індексації. Також можна використати властивості ndim (number of array dimensions) – кількість вимірів масиву, та  size – яка виначає розмір масиву. Приклад з відео:

import numpy as np

numArray1 = np.array([1,2,3])
print(numArray1[1])

#ndim property - defines number of array dimension
print(numArray1.ndim)
#size property
print(numArray1.size)

Двовимірні масиви

Щоб створити двовимірний масив за допомогою numpy.array, ви можете просто передати список списків (або вкладені масиви) у функцію np.array(). Приклад з відео:

#2-вимірний масив
import numpy as np

numArray1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(numArray1[0][2])
print(numArray1[1][1])
print(numArray1[2][0])

for i in numArray1:
    print(i)

Приклад з відео з двовимірним масивом та визначенням кількості вимірів і розміром та використанням вкладеного циклу for для перегляду всіх елементів масиву за вимірами:

import numpy as np

numArray = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(numArray)
print("Dimensions number equals {}".format(numArray.ndim))
print("Size of array is {}".format(numArray.size))

for i in numArray:
    for j in i:
        print(j)

Тривимірні масиви

Створення тривимірного масиву за допомогою numpy.array виконується аналогічно створенню двовимірного масиву, просто потрібно передати відповідні списки (або вкладені масиви). Приклад з відео:

import numpy as np

numArray = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])
print(numArray)
print("Dimensions number equals {}".format(numArray.ndim))
print("Size of array is {}".format(numArray.size))

print("Element from array {}".format(numArray[0][1][0]))
print("Element from array {}".format(numArray[0][1][1]))
print("Element from array {}".format(numArray[1][0][0]))
print("Element from array {}".format(numArray[1][1][0]))

for i in numArray:
    for j in i:
        for k in j:
            print(k)

В цьому відео поговоримо про:
00:11 PIP – встановлювач пакетів Python
03:01 Python Arrays – масиви
06:02 Install Numpy – встановлення Numpy
08:46 Array creation – ствопення масиву
10:44 Access items – доступ до елементів
13:31 2-dimensional arrays – двовимірні масиви
21:31 3-dimensional arrays – тривимірні масиви

Приклади на Github

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

#Словники використовуються для зберігання значень даних у парах ключ:значення.
#Словник — це збірка, яка є впорядкованою, змінною та
#не допуска' дублікатів.
#Починаючи з версії Python 3.7, словники впорядковані.
#У Python 3.6 і попередніх версіях словники були не впорядковані.
carDictionary1 = {
    "brand": "Dodge",
    "model": "Charger",
    "year": 2020
    }
print(carDictionary1)

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

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

Значення (Value): Це дані, які асоційовані з ключем. Значення можуть бути будь-якого типу даних, включаючи інші словники, списки або навіть функції.

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

#Елементи словника впорядковані, змінні та не
#дозволяють дублікати.
#Елементи словника представлені в парах ключ:значення і
#до них можна звертатися за допомогою імені ключа.
carDictionary1 = {
    "brand": "Dodge",
    "model": "Charger",
    "year": 2020
    }

print(carDictionary1["brand"])

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

#Словники не можуть мати два елементи з однаковим ключем
#Дубльовані значення перезапишуть наявні значення
carDictionary = {
    "brand": "Dodge",
    "model": "Charger",
    "year": 2019,
    "year": 2020
    }

print(carDictionary)

Довжина словника

Довжина словника в Python визначається кількістю пар ключ-значення, які він містить. Щоб отримати цю довжину, можна скористатися функцією len(). Приклад з відео:

#Щоб визначити, скільки елементів містить словник, використовуйте
#функцію len().
carDictionary = {
    "brand": "Dodge",
    "model": "Charger",
    "year": 2020
    }

lengthOfDictionary = len(carDictionary)
print(carDictionary)
print(lengthOfDictionary)

Типи даних елементів у словниках

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

#Значення в елементах словника можуть мати будь-який тип даних
carDictionary = {
    "brand": "Dodge",
    "electric": False,
    "year": 2020,
    "colors": ["yellow","blue","orange", "black", "white"]
    }

print(carDictionary)

Функція type() та словники

Функція type() у Python використовується для визначення типу об’єкта. Коли ви використовуєте цю функцію з словниками, вона поверне, що об’єкт є словником (dict). Приклад з відео:

#словники визначаються як об'єкти з типом даних "dict"
carDictionary = {
    "brand": "Dodge",
    "model": "Charger",
    "year": 2020
    }

print(carDictionary)
print(type(carDictionary))

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

Конструктор dict() у Python створює новий словник. Він є універсальним способом для ініціалізації словників і може приймати різні типи вхідних даних. Приклад з відео:

#Також можна використовувати конструктор dict()
#щоб створити словник
carDictionary = dict(brand="Dodge", model="Charger", year=2020)
print(carDictionary)
print(type(carDictionary))

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

Доступ до елементів словника у Python здійснюється за допомогою ключів. Словники в Python є колекціями пар ключ-значення. Щоб отримати значення, що відповідає певному ключу, ви використовуєте квадратні дужки [] або метод .get(). Приклад з відео:

#Ви можете отримати доступ до елементів словника, посилаючись на
#його ключове ім'я в квадратних дужках
#Існує також метод під назвою get(), який надасть вам
#той же результат
carDictionary = dict(brand="Dodge", model="Charger")
brandExtract = carDictionary["brand"]
modelExtract = carDictionary.get("model")
print(carDictionary)
print(brandExtract)
print(modelExtract)

Метод keys()

Метод keys() у словниках Python використовується для отримання видимих ключів словника. Він повертає вью-об’єкт (dict_keys), який є динамічним і відображає ключі словника в момент виклику. Приклад з відео:

#метод keys() поверне список усіх ключів
#в словнику
carDictionary=dict(brand="Dodge", model="Charger")
keysCarDictExtract = carDictionary.keys()
print(carDictionary)
print(keysCarDictExtract)
#додаванння нової key=value пари до словника
carDictionary["year"]=2020
print(carDictionary)
print(keysCarDictExtract)

Метод values()

Метод values() у словниках Python використовується для отримання всіх значень, які відповідають ключам словника. Він повертає вью-об’єкт (dict_values), який є динамічним і відображає значення словника на момент виклику. Приклад з відео:

#Метод values() поверне список усіх значень
#в словнику.
carDictionary = dict(brand="Dodge", model="Charger")
valuesExtract = carDictionary.values()
print(carDictionary)
print(valuesExtract)
#додавання новї key=value пари
carDictionary["year"]=2020
print(carDictionary)
print(valuesExtract)

Метод items()

Метод items() у словниках Python використовується для отримання всіх пар ключ-значення з словника. Він повертає вью-об’єкт (dict_items), який є динамічним і відображає пари ключ-значення словника на момент виклику. Приклад з відео:

#метод items() поверне кожен елемент у словнику,
#як кортежі в списку
carDictionary=dict(brand="Dodge", model="Charger")
itemsExtract = carDictionary.items()
print(carDictionary)
print(itemsExtract)
#додавання нової key=value пари
carDictionary["year"]=2020
print(carDictionary)
print(itemsExtract)

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

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

# Щоб визначити, чи присутній вказаний ключ у словнику
#використовуйте ключове слово "in".
carDictionary = {
    "brand": "Dodge",
    "model": "Charger",
    "year": 2020
    }
print(carDictionary)
if "brand" in carDictionary:
    print("Key 'brand' is present in dictionary")
    
else:
    print("Key 'brand' is not present in dictionary")

Зміна значень у словниках

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

#Ви можете змінити значення певного елемента шляхом посилання
#на назву ключа
carDictionary = dict(brand="Dodge", model="Charger", year=2020)
print(carDictionary)
carDictionary["model"]="Challenger"
carDictionary["year"]=2021
print(carDictionary)

Метод update() у словниках

Метод update() у словниках Python використовується для оновлення словника новими парами ключ-значення. Він дозволяє додати нові пари або оновити існуючі пари ключ-значення в словнику. Приклад з відео:

#метод update() оновить словник елементами
#від заданого аргументу.
#Якщо елемент не існує, його буде додано.
#Аргументом має бути словник або ітерований об’єкт
#з парами ключ:значення.
carDictionary = dict(brand="Dodge", model="Charger")
print(carDictionary)
carDictionary.update({"model":"Challenger"})
carDictionary.update({"year":2020})
print(carDictionary)

Методи pop() and popitem()

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

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

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

#метод pop() видаляє елемент із вказаною назвою ключа
#метод popitem() видаляє останній вставлений елемент
#(у версіях до 3.7 замість цього видаляється випадковий елемент)
carDictionary=dict(brand="Car", model="Some model", year=2000)
print(carDictionary)
carDictionary.pop("year")
print(carDictionary)
carDictionary.popitem()
print(carDictionary)

del та clear()

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

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

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

#ключове слово del може видалити елемент із вказаною назвою ключа
#ключове слово #del також може повністю видалити словник
#метод clear() очищає словник
carDictionary = dict(brand="Car", model="Some model", year=2000)
print(carDictionary)
del carDictionary["year"]
print(carDictionary)
carDictionary.clear()
print(carDictionary)
del carDictionary
#print(carDictionary)

Цикл for та словники

Цикл for у Python дозволяє ітеруватися по словниках різними способами, щоб обробити їх ключі, значення або пари ключ-значення. Приклад з відео:

#Ви можете переглядати словник за допомогою циклу for
carDictionary = dict(brand="Dodge", model="Charger")
print("option 1 - loop through keys")
for carkey in carDictionary:
    print(carkey)
print("option 2 - loop through values")
for carkey in carDictionary:
    print(carDictionary[carkey])
print("option 3 - use values method")
for car in carDictionary.values():
    print(car)
print("option 4 - use keys method")
for carkey in carDictionary.keys():
    print(carkey)
print("option 5 - use items method")
for carkey, car in carDictionary.items():
    print(carkey, car)

Копія словника

Для створення копії словника можна використати метод copy() або конструктор. Приклад з відео:

#Ви не можете скопіювати словник, просто ввівши dictionary2 = dictionary1,
#бо: dictionary2 буде лише посиланням на dictionary1,
#і зміни, зроблені в dictionary1, автоматично також будуть внесені в dictionary2.
#Ви можете використовувати метод copy() або конструктор, щоб створити копію словника.
carDictionary1 = dict(brand="Dodge", model="Charger")
carDictionary2 = carDictionary1.copy()
carDictionary3 = dict(carDictionary2)
print(carDictionary1)
print(carDictionary2)
print(carDictionary3)
carDictionary1["year"]=2020
carDictionary2["color"]="yellow"
print(carDictionary1)
print(carDictionary2)
print(carDictionary3)

Вкладені словники у Python

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

#Словник може містити словники, це називається вкладеними словниками
carPark = {
    "car1":{
        "brand":"Dodge",
        "model": "Charger"
        },
    "car2":{
        "brand": "Ford",
        "model": "Mustang"
        }    
    }

print(carPark["car1"]["brand"])
print(carPark["car1"]["model"])
print(carPark["car2"]["brand"])
print(carPark["car2"]["model"])

# for car in carPark:
#     for carIn in carPark[car]:
#         print(carPark[car][carIn])

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

#ви можете додати кілька словників у новий словник
car1 = {
    "brand": "Dodge",
    "model": "Charger"
    }
car2 = {
    "brand": "Ford",
    "model": "Mustang"
    }
carPark = {
    "car1": car1,
    "car2": car2
    }
for car in carPark:
    for carIn in carPark[car]:
        print(carPark[car][carIn])

В цьому відео поговоримо про:
00:13 Python Dictionary – Словник
02:02 Dictionary Items – Елементи словників
03:26 Duplicates and Dictionaries – Дуплікати і словники
04:54 Dictionary Length – Довжина словника
06:35 Data Types – Типи даних
07:40 type() функція
08:40 dict() конструктор
11:47 Accessing Dictionary Items – Доступ до елементів словника
14:30 keys() метод
18:00 values() метод
20:47 items() метод
23:29 Check if key exists – Перевірка чи є ключ
26:17 Change values in dictionary – Зміна значень у словниках
27:54 update() метод
30:24 pop() and popitem() методи
33:22 del and clear() – ключове слово del та метод clear()
38:21 Dictionary and for loop – Словник і цикл for
44:35 Copy Dictionary – Копіювання словника
47:53 Nested Dictionary – Вкладений словник

Приклади на Github

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

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

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

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

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

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

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

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

#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")

В цьому відео поговоримо про:
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

Кортежі в 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)

В цьому відео поговоримо про:
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