🔍 Як оголосити змінну в Python? Прості кроки та приклади для початківців!

Наприклад, якщо ви хочете оголосити змінну з ім'ям "x" і присвоїти їй значення 5, ви можете написати:

Детальна відповідь

Як оголосити змінну в Python

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

1. Просте оголошення змінної

Для оголошення змінної в Python необхідно вказати ім'я змінної та надати їй значення. Наприклад:

ім'я_змінної = значення

Назва змінної може містити літери, цифри та символ підкреслення (_), але не може починатися з цифри. Python чутливий до регістру, тому змінні myVariable і myvariable будуть відрізнятися. Приклад:

ім'я = "John" вік = 25 ріст = 1.75

У наведеному вище прикладі ми визначаємо змінні ім'я , вік і зростання з відповідними значеннями.

2. Оголошення змінної з явною вказівкою типу даних

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

ім'я: str = "John" вік: int = 25 зріст: float = 1.75

3. Зміна значення змінної

ім'я = "John" ім'я = "Jane" print(ім'я) # Виведе "Jane"

У наведеному вище прикладі ми спочатку встановлюємо значення змінної ім'я рівним "John", а потім змінюємо його на "Jane" за допомогою оператора присвоєння (=).

4. Глобальні та локальні змінні

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

глобальна_змінна = "Global Variable" def функція(): локальна_змінна = "Local Variable" print(глобальна_змінна) print(локальна_змінна) функція()

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

5. Константи

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

PI = 3.14159 URL = "https://www.example.com"

У наведеному вище прикладі, PI та URL є константами, і ми використовуємо великі літери та символ підкреслення для їх ідентифікації.

Висновок

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

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

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

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

Створення списку

Для створення списку застосовуються квадратні дужки [] , всередині яких кому перераховуються елементи списку. Наприклад, визначимо список чисел:

numbers = [1, 2, 3, 4, 5]

Подібним чином можна визначати списки даних інших типів, наприклад, визначимо список рядків:

people = ["Tom", "Sam", "Bob"]

Також для створення списку можна використовувати функцію-конструктор list():

numbers1 = [] numbers2 = list()

Обидва визначення списку аналогічні - вони створюють порожній список.

Список необов'язково має містити лише однотипні об'єкти. Ми можемо помістити в той самий список одночасно рядки, числа, об'єкти інших типів даних:

objects = [1, 2.6, "Hello", True]

Для перевірки елементів списку можна використовувати стандартну функцію print, яка виводить вміст списку в зручному для читання вигляді:

numbers = [1, 2, 3, 4, 5] people = ["Tom", "Sam", "Bob"] print(numbers) # [1, 2, 3, 4, 5] print(people) # [ "Tom", "Sam", "Bob"]

Конструктор list може приймати набір значень, на основі яких створюється список:

numbers1 = [1, 2, 3, 4, 5] numbers2 = list(numbers1) print(numbers2) # [1, 2, 3, 4, 5] letters = list("Hello") print(letters) # [' H', 'e', ​​'l', 'l', 'o']

Якщо необхідно створити список, в якому повторюється те саме значення кілька разів, то можна використовувати символ зірочки *, тобто фактично застосувати операцію множення до вже існуючого списку:

numbers = [5] * 6 # 6 разів повторюємо 5 print(numbers) # [5, 5, 5, 5, 5, 5] people = ["Tom"] * 3 # 3 рази повторюємо "Tom" print(people) # ["Tom", "Tom", "Tom"] students = ["Bob", "Sam"] * 2 # 2 рази повторюємо "Bob", "Sam" print(students) # ["Bob", "Sam", "Bob", "Sam"]

Звернення до елементів списку

Для звернення до елементів списку треба використовувати індекси, які представляють номер елемента списку. Індекси починаються з нуля. Тобто перший елемент матиме індекс 0, другий елемент індекс 1 і так далі. Для звернення до елементів з кінця можна використовувати негативні індекси, починаючи від -1. Тобто, у останнього елемента буде індекс -1, у передостаннього - -2 і так далі.

people = ["Tom", "Sam", "Bob"] # отримання елементів з початку списку print(people[0]) # Tom print(people[1]) # Sam print(people[2]) # Bob # отримання елементів з кінця списку print(people[-2]) # Sam print(people[-1]) # Bob print(people[-3]) # Tom

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

people = ["Tom", "Sam", "Bob"] people[1] = "Mike" # зміна другого елемента print(people[1]) # Mike print(people) # ["Tom", "Mike", "Bob"]

Розкладання списку

Python дозволяє розкласти список на окремі елементи:

люди = ["Tom", "Bob", "Sam"] Tom, bob, sam = людей print(tom) # Tom print(bob) # Bob print(sam) # Sam

У разі змінним tom, bob і sam послідовно присвоюються елементи зі списку people. Однак слід враховувати, що кількість змінних повинна дорівнювати числу елементів списку, що присвоюється.

Перебір елементів

Для перебору елементів можна використовувати як цикл for, і цикл while.

Перебір за допомогою циклу for :

люди = ["Tom", "Sam", "Bob"] для людей в людей: print(person)

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

Перебір також можна зробити за допомогою циклу while:

people = ["Tom", "Sam", "Bob"] i = 0 while i < len(people): print(people[i]) # застосовуємо індекс для отримання елемента i += 1

Для перебору з допомогою функції len() отримуємо довжину списку. За допомогою лічильника i виводить по елементу, поки значення лічильника не дорівнює довжині списку.

Порівняння списків

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

numbers1 = [1, 2, 3, 4, 5] numbers2 = list([1, 2, 3, 4, 5]) if numbers1 == numbers2: print("numbers1 equal to numbers2") else: print("numbers1 is not equal to numbers2")

В даному випадку обидва списки будуть рівними.

Отримання частини списку

Якщо необхідно отримати певну частину списку, то ми можемо застосовувати спеціальний синтаксис, який може приймати такі форми:

• list[:end] : через параметр end передається індекс елемента, до якого потрібно скопіювати список
• list[start:end] : параметр start вказує на індекс елемента, з якого треба скопіювати елементи
• list[start:end:step] : параметр step вказує на крок, через який копіюватимуться елементи зі списку.За промовчанням цей параметр дорівнює 1.

people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people1 = people[:3] # з 0 по 3 print(slice_people1) # ["Tom", " Bob", "Alice"] slice_people2 = people[1:3] # з 1 по 3 print(slice_people2) # ["Bob", "Alice"] slice_people3 = people[1:6:2] # з 1 по 6 з кроком 2 print(slice_people3) # ["Bob", "Sam", "Bill"]

Можна використовувати негативні індекси, тоді відлік буде йти з кінця, наприклад, -1 - передостанній, -2 - третій кінця і так далі.

people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people1 = people[:-1] # з передостаннього по нульовий print(slice_people1) # ["Tom", "Bob", "Alice", "Sam", "Tim"] slice_people2 = people[-3:-1] # з третього з кінця до передостаннього print(slice_people2) # [ "Sam", "Tim"]

Методи та функції по роботі зі списками

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

• append(item) : додає елемент item до кінця списку
• insert(index, item) : додає елемент item до списку індексу index
• extend(items) : додає набір елементів items до кінця списку
• remove(item): видаляє елемент item. Видаляється лише перше входження елемента. Якщо елемент не знайдено, генерує виняток ValueError
• clear() : видалення всіх елементів зі списку
• index(item): повертає індекс елемента item. Якщо елемент не знайдено, генерує виняток ValueError
• pop([index]) : видаляє та повертає елемент за індексом index. Якщо індекс не передано, просто видаляє останній елемент.
• count(item) : повертає кількість входжень елемента item до списку
• sort([key]) : сортує елементи. За умовчанням сортує за зростанням. Але за допомогою key ми можемо передати функцію сортування.
• reverse() : розставляє всі елементи у списку у зворотному порядку
• copy() : копіює список

Крім того, Python надає ряд вбудованих функцій для роботи зі списками:

• len(list) : повертає довжину списку
• sorted(list, [key]) : повертає відсортований список
• min(list) : повертає найменший елемент списку
• max(list) : повертає найбільший елемент списку

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

Для додавання елемента застосовуються методи append() , extend і insert , а видалення - методи remove() , pop() і clear() .

people = ["Tom", "Bob"] # додаємо в кінець списку people.append("Alice") # ["Tom", "Bob", "Alice"] # додаємо на другу позицію people.insert(1, " Bill") # ["Tom", "Bill", "Bob", "Alice"] # додаємо набір елементів ["Mike", "Sam"] people.extend(["Mike", "Sam"]) # ["Tom", "Bill", "Bob", "Alice", "Mike", "Sam"] # отримуємо індекс елемента index_of_tom = people.index( "Tom") # видаляємо за цим індексом removed_item = people.pop(index_of_tom) # ["Bill", "Bob", "Alice", "Mike", "Sam"] # видаляємо останній елемент last_item = people.pop() # ["Bill", "Bob", "Alice", "Mike"] # видаляємо елемент "Alice" people.remove ("Alice") # ["Bill", "Bob", "Mike"] print(people) # ["Bill", "Bob", "Mike"] # видаляємо всі елементи people.clear() print(people) # []

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

Якщо певний елемент не знайдено, то методи remove та index генерують виняток. Щоб уникнути подібної ситуації, перед операцією з елементом можна перевіряти наявність за допомогою ключового слова in :

люди = ["Tom", "Bob", "Alice", "Sam"] if "Alice" в людей: people.remove("Alice") print(people) # ["Tom", "Bob", "Sam "]

Вираз if "Alice" in people повертає True, якщо елемент "Alice" є у списку people. Тому конструкція if "Alice" in people може виконати наступний блок інструкцій залежно від наявності елемента у списку.

Видалення за допомогою del

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

people = ["Tom", "Bob", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[1] # видаляємо другий елемент print(people) # ["Tom", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[:3] # видаляємо по четвертий елемент не включаючи print(people) # ["Bill", "Kate", "Mike"] del people[1:] # видаляємо з другого елемента print(people) # ["Bill"]

Зміна підписку

Для зміни підсписку - набору елементів у списку можна використовувати синтаксис [start:end] :

nums = [10, 20, 30, 40, 50] nums [1: 4] = [11, 22] print (nums) # [10, 11, 22, 50]

Тут вираз nums [1: 4] фактично звертається до підписку [20, 30, 40]. Присвоєння цьому підписку списку [11, 22] дозволяє замінити елемент з 1 по 4 індекс не включаючи на елементи [11, 22] . І після зміни отримаємо список [10, 11, 22, 50]

Підрахунок входження

Якщо необхідно дізнатися, скільки разів у списку присутній той чи інший елемент, можна застосувати метод count() :

people = ["Tom", "Bob", "Alice", "Tom", "Bill", "Tom"] people_count = people.count("Tom") print(people_count) # 3

Сортування

Для сортування за зростанням застосовується метод sort():

people = ["Tom", "Bob", "Alice", "Sam", "Bill"] people.sort() print(people) # ["Alice", "Bill", "Bob", "Sam", "Tom"]

Якщо потрібно відсортувати дані у зворотному порядку, то ми можемо після сортування застосувати метод reverse() :

people = ["Tom", "Bob", "Alice", "Sam", "Bill"] people.sort() people.reverse() print(people) # ["Tom", "Sam", "Bob" , "Bill", "Alice"]

При сортуванні фактично порівнюються два об'єкти, і який з них "менший", ставиться перед тим, що "більше". Поняття "більше" і "менше" досить умовні. І якщо для чисел все просто - числа розставляють у порядку зростання, то для рядків та інших об'єктів ситуація складніша. Зокрема рядки оцінюються за першими символами. Якщо перші символи дорівнюють, оцінюються другі символи тощо.При чому цифровий символ вважається "меншим", ніж алфавітний заголовний символ, а заголовний символ вважається меншим, ніж малий.

Таким чином, якщо у списку поєднуються рядки з верхнім та нижнім регістром, то ми можемо отримати не зовсім коректні результати, тому що для нас рядок "bob" повинен стояти до рядка "Tom". І щоб змінити стандартну поведінку сортування, ми можемо передати в метод sort() як параметр функцію:

people = ["Tom", "bob", "alice", "Sam", "Bill"] people.sort() # стандартне сортування print(people) # ["Bill", "Sam", "Tom", " alice", "bob"] people.sort(key=str.lower) # сортування без урахування регістру print(people) # ["alice", "Bill", "bob", "Sam", "Tom"]

Крім методу sort, ми можемо використовувати вбудовану функцію sorted, яка має дві форми:

• sorted(list) : сортує список list
• sorted(list, key) : сортує список list, застосовуючи до елементів функцію key

people = ["Tom", "bob", "alice", "Sam", "Bill"] sorted_people = sorted(people, key=str.lower) print(sorted_people) # ["alice", "Bill", " bob", "Sam", "Tom"]

При використанні цієї функції слід враховувати, що ця функція не змінює список, що сортується, а всі відсортовані елементи вона поміщає в новий список, який повертається як результат.

Фільтрування списку

Для фільтрації списку застосовується функція filter() , в яку передається функція-умова та список, що фільтрується:

Функція приймає два параметри:

• fun : функція-умова, в яку передається кожен елемент колекції та яка повертає True, якщо елемент відповідає умові. Інакше повертається False.
• iter : колекція, що фільтрується

Як результат, функція повертає відфільтровані елементи. Наприклад, отримаємо зі списку чисел усі значення більше 1:

numbers = [-5, -4, -3 ,-2, -1, 0, 1, 2, 3, 4, 5] def condition(number): return number > 1 result = filter(condition, numbers) for n in result: print(n, end=" ") # 2 3 4 5

Тут фільтрується список номерів.Для фільтрації визначаємо функцію condition, яку як параметра передається кожен елемент списку numbers. Результатом функції є True, якщо число більше 1, або False, якщо число менше 2.

Результатом функції filter є відфільтровані значення зі списку, тобто числа, які більше 1.

Замість визначення окремої функції-умови, якщо умова коротка, зручно в подібних випадках використовувати лямбда-вирази:

numbers = [-5, -4, -3 ,-2, -1, 0, 1, 2, 3, 4, 5] result = filter(lambda n: n > 1, numbers) для n у результат: print( n, end=" ") # 2 3 4 5

Аналогічним чином можна відфільтрувати списки складніших об'єктів:

class Person: def __init__(self, name, age): self.name = name self.age = age people = [ Person("Tom", 38), Person("Kate", 31), Person("Bob", 42), Person("Alice", 34), Person("Sam", 25) ] # фільтрація елементів, у яких age > 33 view = filter(lambda p: p.age > 33, люди) для людини в view: print(f"Name: Age: ")

У цьому випадку фільтруємо список об'єктів Person, тому в функцію-умова/лямбда-вираз як параметр передається кожен об'єкт Person зі списку. Кожен об'єкт Person зберігає ім'я (Name) та вік (Age), і тут вибираємо всіх Person, у яких вік більше 33.

Проекція списку

Для проекції/перетворення елементів списку застосовується функція map() , на яку передається функція-умова і список, елементи якого треба перетворити:

Функція приймає два параметри:

• fun : функція перетворення, яку передається кожен елемент колекції.
• iter : колекція, що перебирається

З результату функції отримаємо перетворені елементи списку. Наприклад, перетворимо список чисел у квадрати цих чисел:

numbers = [ 1, 2, 3, 4, 5] def square(number): return number * number result = map(square, numbers) для результату: print(n, end=" ") # 1 4 9 16 25

Як функцію перетворення тут виступає функція square, до якої передається число зі списку і яка повертає його квадрат.

Також як функцію перетворення можна використовувати лямбда-вирази:

numbers = [ 1, 2, 3, 4, 5] result = map(lambda n: n * n, numbers) для n у результат: print(n, end=" ") # 1 4 9 16 25

Аналогічним чином можна перетворювати колекції складніших об'єктів:

class Person: def __init__(self, name, age): self.name = name self.age = age people = [ Person("Tom", 38), Person("Kate", 31), Person("Bob", 42), Person("Alice", 34), Person("Sam", 25) ] # отримуємо з Person рядок з ім'ям view = map(lambda p: p.name, people) for person in view: print(person)

Тут проекція застосовується до переліку об'єктів Person. Функція перетворення отримує кожен об'єкт Person і повертає значення атрибута name. Тобто ми отримаємо набір рядків (атрибути name всіх об'єктів Person). Консольний висновок:

Tom Kate Bob Alice Sam

Мінімальне та максимальне значення

Вбудовані функції Python min() і max() дозволяють знайти мінімальне та максимальне значення відповідно:

numbers = [9, 21, 12, 1, 3, 15, 18] print(min(numbers)) # 1 print(max(numbers)) # 21

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

При копіюванні списків слід враховувати, що списки представляють тип, що змінюється (mutable), тому якщо обидві змінних будуть вказувати на один і той же список, то зміна однієї змінної, торкнеться і іншу змінну:

people1 = ["Tom", "Bob", "Alice"] people2 = people1 people2.append("Sam") # додаємо елемент до другого списку # people1 і people2 вказують на один і той же список print(people1) # [" Tom", "Bob", "Alice", "Sam"] print(people2) # ["Tom", "Bob", "Alice", "Sam"]

Це так зване "поверхове копіювання" (shallow copy). І, як правило, така поведінка небажана. І щоб відбувалося копіювання елементів, але при цьому змінні вказували на різні списки необхідно виконати глибоке копіювання (deep copy). Для цього можна використовувати метод copy() :

people1 = ["Tom", "Bob", "Alice"] people2 = people1.copy() # копіюємо елементи з people1 до people2 people2.append("Sam") # додаємо елемент ТІЛЬКИ до другого списку # people1 і people2 вказують на різні списки print(people1) # ["Tom", "Bob", "Alice"] print(people2) # ["Tom", "Bob", "Alice", "Sam"]

З'єднання списків

Для об'єднання списків застосовується операція додавання (+):

people1 = ["Tom", "Bob", "Alice"] people2 = ["Tom", "Sam", "Tim", "Bill"] people3 = people1 + people2 print(people3) # ["Tom", " Bob", "Alice", "Tom", "Sam", "Tim", "Bill"]

Списки списків

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

people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] print(people[0]) # ["Tom", 29] print(people[0][0 ]) # Tom print(people[0][1]) # 29

Щоб звернутися до елемента вкладеного списку, необхідно використовувати пару індексів: people[0][1] - звернення до другого елемента першого вкладеного списку.

Додавання, видалення та зміна загального списку, а також вкладених списків аналогічно до того, як це робиться зі звичайними (одномірними) списками:

people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] # створення вкладеного списку person = list() person.append("Bill") person.append(41) # додавання вкладеного списку people.append(person) print(people[-1]) # ["Bill", 41] # додавання в вкладений список people[-1].append("+79876543210") print(people[-1]) # ["Bill", 41, "+79876543210"] # видалення останнього елемента з вкладеного списку people[-1].pop () print(people[-1]) # ["Bill", 41] # видалення всього останнього вкладеного списку people.pop(-1) # зміна першого елемента people[0] = ["Sam", 18] print(people) # [["Sam", 18], ["Alice", 33], ["Bob", 27]]

Перебір вкладених списків:

люди = [["Tom", 29], ["Alice", 33], ["Bob", 27]] для людей в людей: для людей в людей: print(item, end=" | ")

Том | 29 | Alice | 33 | Bob | 27 |

Списки та алгоритми

Списки нерідко використовуються для вирішення різних завдань, в яких, на перший погляд, у застосуванні списків немає сенсу, проте списки дозволяють спростити написання алгоритму або просто надати альтернативне рішення. Наприклад, візьмемо завдання щодо знаходження факторіалу числа:

fact = lambda n: [1,0] [n>1] або fact(n-1) * n print(fact(4))

Для обчислення факторіалу тут визначено змінну fact, яка зберігає лямбда-вираз. Розглянемо його частинами. Спочатку йде визначення списку із двох елементів:

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

Тут результат виразу n>1 і представлятиме індекс у списку. Тобто, якщо аргумент лямбда-виразу n більший за 1, то вираз n>1 дорівнює True або 1, а весь вираз [1,0] [n>1] поверне 0 (елемент за індексом 1). Якщо ж n дорівнює або менше 1, то вираз n>1 дорівнює False або 0, а вираз [1,0] [n>1] поверне 1 (елемент за індексом 0)

Далі йде оператор or. Якщо вираз [1,0] [n>1] поверне 1 (якщо n or повертає це число 1. Якщо ж вираз [1,0] [n>1] поверне 0 (якщо n>1), то оператор or повертає результат виразу fact(n-1) * n , яке рекурсивно викликає функцію fact, передаючи до неї число n-1. якщо n=4, ми отримаємо таку послідовність дій:

• [1,0] [4>1] or fact(4-1) * 4
• 0 or fact(4-1) * 4
• ([1,0] [3>1] or fact(3-1)) * 4
• (0 or fact(3-1)) * 4
• (([1,0] [2>1] or fact(2-1)) * 3) * 4
• ((0 or fact(2-1)) * 3) * 4
• ((([[1,0] [1>1] or fact(1-1)) * 2) * 3) * 4
• (((1 or fact(1-1)) * 2) * 3) * 4
• (((1) * 2) * 3) * 4