Python

Що таке Пітон?

Python – популярна мова програмування. Він був створений Гвідо ван Россум і випущений в 1991 році.

Він використовується для:

веб-розробка (серверна частина),

розробка програмного забезпечення,

математика,

системний скриптинг.

Що може Пітон?

Python можна використовувати на сервері для створення веб-застосунків.

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

Python може підключатися до систем бази даних. Він також може читати та змінювати файли.

Python можна використовувати для обробки великих даних та виконання складних математичних операцій.

Python можна використовувати для швидкого прототипування або розробки готового програмного забезпечення.

Чому пітон?

Python працює на різних платформах (Windows, Mac, Linux, Raspberry Pi тощо).

Python має простий синтаксис, схожий на англійську мову.

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

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

Python можна розглядати процедурно, об'єктно-орієнтовано чи функціонально.

Добре знати

Остання основна версія Python — Python 3. Тим не менш, Python 2, хоч і не оновлюється нічим, крім оновлень безпеки, як і раніше, досить популярний.

Можна написати Python в інтегрованому середовищі розробки, наприклад Thonny, Pycharm, Netbeans або Eclipse, які особливо корисні при керуванні великими колекціями файлів Python.

Синтаксис Python у порівнянні з іншими мовами програмування

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

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

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

Відступ Python

Відступи – це пробіли на початку рядка коду.

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

Python використовує відступ для позначення блоку коду.

Приклад:

if 5 > 2:

  print("Five is greater than two!") 

Python видасть вам помилку, якщо ви пропустите відступ:

if 5 > 2:

print("Five is greater than two!") 

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

if 5 > 2:

 print("Five is greater than two!") 

if 5 > 2:

        print("Five is greater than two!")  

Ви повинні використовувати однакову кількість прогалин в тому самому блоці коду, інакше Python видасть вам помилку:

if 5 > 2:

 print("Five is greater than two!")

        print("Five is greater than two!") 

Змінні Python

У Python змінні створюються, коли ви надаєте їм значення:

x = 5

y = "Hello, World!" 

Python не має команди для оголошення змінної.

Коментарі

Python має можливість коментувати документацію в коді.

Коментарі починаються з #, а частину рядка Python, що залишилася, відобразить як коментар:

Приклад:

#This is a comment.

print("Hello, World!") 

Введення даних користувачем

name = input("Введіть ім'я: ")

print("Привіт,", name)

Коментарі можна використовувати для пояснення коду Python.

Коментарі можна використовувати, щоб зробити код більш читати.

Коментарі можна використовувати для запобігання виконання під час тестування коду.

Створення коментаря

Коментарі починаються з #, і Python їх проігнорує:

Приклад:

#This is a comment

print("Hello, World!") 

Коментарі можуть бути розміщені в кінці рядка, і Python проігнорує частину рядка, що залишилася:

Коментар не обов'язково має бути текстом, який пояснює код, його також можна використовувати для запобігання виконання коду Python:

Приклад:

#print("Hello, World!")

print("Cheers, Mate!") 

Багаторядкові коментарі

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

Щоб додати багаторядковий коментар, ви можете вставити # для кожного рядка:

Приклад:

#This is a comment

#written in

#more than just one line

print("Hello, World!") 

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

Оскільки Python ігноруватиме рядкові літерали, які не призначені змінною, ви можете додати до свого коду рядковий рядок (потрійні лапки) і помістити в нього свій коментар:

Приклад:

"""

This is a comment

written in

more than just one line

"""

print("Hello, World!") 

Поки рядку не присвоєна змінна, Python читатиме код, але потім ігноруватиме його.

Змінні— це контейнери для збереження значень даних.

Створення змінних

Python не має команди для оголошення змінної.

Змінна створюється в той момент, коли ви вперше надаєте їй значення.

Приклад:

x = 5

y = "John"

print(x)

print(y) 

Змінні не потрібно оголошувати з конкретним типом, і вони можуть навіть змінити тип після того, як вони були встановлені.

x = 4       # x is of type int

x = "Sally" # x is now of type str

print(x) 

Casting

Якщо ви хочете вказати тип даних змінної, це можна зробити за допомогою типів даних.

Приклад:

x = str(3)    # x will be '3'

y = int(3)    # y will be 3

z = float(3)  # z will be 3.0 

Получить тип

Ви можете отримати тип змінної даних за допомогою функції type().

Приклад:

x = 5

y = "John"

print(type(x))

print(type(y)) 

Одинарні чи подвійні лапки?

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

Приклад:

x = "John"

# is the same as

x = 'John' 

З урахуванням регістру

Імена змінних чутливі до регістру.

Приклад:

a = 4

A = "Sally"

#A will not overwrite a 

Змінна може мати коротке ім'я (наприклад, x та y) або більше описове ім'я (вік, ім'я автомобіля, загальний об'єм). Правила для змінних Python:

Ім'я змінної повинне починатися з літери або символу підкреслення.

Ім'я змінної не може починатися з цифри

Ім'я змінної може містити лише буквено-цифрові символи та символи підкреслення (A-z, 0-9 та _).

Імена змінних чутливі до регістру (age, Age и AGE  — це три різні змінні).

Приклад:

myvar = "John"

my_var = "John"

_my_var = "John"

myVar = "John"

MYVAR = "John"

myvar2 = "John" 

Неприпустимі імена змінних:

2myvar = "John"

my-var = "John"

my var = "John" 

Імена змінних із кількох слів

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

Є кілька методів, які ви можете використати, щоб зробити їх більш читабельними:

Camel Case

Кожне слово, крім першого, починається з великої літери:

myVariableName = "John"

Pascal Case

Кожне слово починається з великої літери:

MyVariableName = "John"

Snake Case

Кожне слово відокремлюється символом підкреслення:

my_variable_name = "John"

Python дозволяє вам надавати значення декільком змінним в одному рядку:

x, y, q = "Orange", "Banana", "Cherry"

print(x)

print(y)

print(q) 

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

Одне значення для кількох змінних

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

x = y = q = "Orange"

print(x)

print(y)

print(q) 

Розпакувати колекцію

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

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

x, y, q = fruits

print(x)

print(y)

print(q) 

Функція print() використовується виведення змінних.

x = "Python is awesome"

print(x) 

У функції print() ви можете виводити кілька змінних, розділених комою:

x = "Python"

y = "is"

z = "awesome"

print(x, y, z) 

Ви також можете використовувати оператор + для виведення кількох змінних:

x = "Python "

y = "is "

z = "awesome"

print(x + y + z) 

Зверніть увагу на пропуск після "Python" і "is", без них результат був би "Pythonisawesome".

Для чисел символ + працює як математичний оператор:

x = 5

y = 10

print(x + y) 

У функції print(), коли ви намагаєтеся об'єднати рядок та число за допомогою оператора +, Python видасть вам помилку:

x = 5

y = "John"

print(x + y) 

Найкращий спосіб вивести кілька змінних у функції print() - розділити їх комами, які навіть підтримують різні типи даних:

x = 5

y = "John"

print(x, y) 

Змінні, створені поза функцією (як і всіх наведених вище прикладах), називаються глобальними змінними.

Глобальні змінні можуть використовуватися всіма як усередині функцій, так і зовні.

x = "awesome"

def myfunc():

  print("Python is " + x)

myfunc() 

Якщо ви створите змінну з тим самим ім'ям усередині функції, ця змінна буде локальною і може використовуватися лише всередині функції. Глобальна змінна з тим самим ім'ям залишиться колишньою, глобальною та з вихідним значенням.

x = "awesome"

def myfunc():

  x = "fantastic"

  print("Python is " + x)

myfunc()

print("Python is " + x) 

Глобальне ключове слово

Зазвичай, коли ви створюєте змінну всередині функції, ця змінна локальна і може використовуватися тільки всередині цієї функції.

Щоб створити глобальну змінну всередині функції, можна використовувати ключове слово global.

def myfunc():

  global x

  x = "fantastic"

myfunc()

print("Python is " + x) 

Крім того, використовуйте ключове слово Global, якщо ви хочете змінити глобальну змінну всередині функції.

x = "awesome"

def myfunc():

  global x

  x = "fantastic"

myfunc()

print("Python is " + x) 

Вбудовані типи даних

У програмуванні тип даних є важливою концепцією.

Змінні можуть зберігати дані різних типів і різні типи можуть виконувати різні дії.

У Python за замовчуванням вбудовано такі типи даних у наступних категоріях:

Text Type: str

Numeric Types: int, float, complex

Sequence Types: list, tuple, range

Mapping Type: dict

Set Types: set, frozenset

Boolean Type: bool

Binary Types: bytes, bytearray, memoryview

None Type: NoneType

Отримання типу даних

Ви можете отримати тип даних будь-якого об'єкта, використовуючи функцію type():

x = 5

print(type(x)) 

Встановлення типу даних

У Python тип даних встановлюється, коли ви надаєте значення змінної:

x = "Hello World" - str

x = 20 - int

x = 20.5 - float

x = 1j - complex

x = ["apple", "banana", "cherry"] - list

x = ("apple", "banana", "cherry") - tuple

x = range(6) - range

x = {"name" : "John", "age" : 36} - dict

x = {"apple", "banana", "cherry"} - set

x = frozenset({"apple", "banana", "cherry"}) - frozenset

x = True - bool

x = b"Hello" - bytes

x = bytearray(5) - bytearray

x = memoryview(bytes(5)) - memoryview

x = None - NoneType

Встановлення певного типу даних

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

x = str("Hello World") - str

x = int(20) - int

x = float(20.5) - float

x = complex(1j) - complex

x = list(("apple", "banana", "cherry")) - list

x = tuple(("apple", "banana", "cherry")) - tuple

x = range(6) - range

x = dict(name="John", age=36) - dict

x = set(("apple", "banana", "cherry")) - set

x = frozenset(("apple", "banana", "cherry")) - frozenset

x = bool(5) - bool

x = bytes(5) - bytes

x = bytearray(5) - bytearray

x = memoryview(bytes(5)) - memoryview

Числа Python

У Python існує три числові типи:

• int

• float

• complex

Змінні числових типів створюються, коли ви надаєте їм значення:

x = 1    # int

y = 2.8  # float

z = 1j   # complex 

Щоб перевірити тип будь-якого об'єкта в Python, використовуйте функцію type():

print(type(x))

print(type(y))

print(type(z)) 

Int.

Int, або ціле число, є цілим числом, позитивним або негативним, без десяткових знаків, необмеженої довжини.

x = 1

y = 35656222554887711

z = -3255522

print(type(x))

print(type(y))

print(type(z)) 

Float

Float або "число з плаваючою комою" - це число, позитивне або негативне, що містить один або кілька десяткових знаків.

x = 1.10

y = 1.0

z = -35.59

print(type(x))

print(type(y))

print(type(z)) 

Число з плаваючою комою також може бути науковим числом з літерою «е», що означає ступінь 10.

x = 35e3

y = 12E4

z = -87.7e100

print(type(x))

print(type(y))

print(type(z)) 

Complex  

Complex числа записуються з буквою «j» як уявну частину:

x = 3+5j

y = 5j

z = -5j

print(type(x))

print(type(y))

print(type(z)) 

Преобразование типа

Ви можете перетворити один тип на інший за допомогою методів int(), float() і complex():

x = 1    # int

y = 2.8  # float

z = 1j   # complex

#convert from int to float:

a = float(x)

#convert from float to int:

b = int(y)

#convert from int to complex:

c = complex(x)

print(a)

print(b)

print(c)

print(type(a))

print(type(b))

print(type(c)) 

Random Number

Python не має функції random() для створення випадкових чисел, але Python має вбудований модуль random, який можна використовувати для створення випадкових чисел:

import random

print(random.randrange(1, 10)) 

Вкажіть тип змінної

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

Тому приведення в python виконується з використанням функцій-конструкторів:

int() - створює ціле число з цілого чисельного літералу, літерала з плаваючою комою (шляхом видалення всіх десяткових знаків) або рядкового літералу (за умови, що рядок є цілим числом)

float() - створює число з плаваючою комою з цілісного літералу, літерала з плаваючою комою або рядкового літералу (за умови, що рядок є числом з плаваючою комою або ціле число)

str() - створює рядок з різних типів даних, включаючи рядки, цілочисленні літерали і літерали з плаваючою комою.

x = int(1)   # x will be 1

y = int(2.8) # y will be 2

z = int("3") # z will be 3 

x = float(1)     # x will be 1.0

y = float(2.8)   # y will be 2.8

z = float("3")   # z will be 3.0

w = float("4.2") # w will be 4.2 

x = str("s1") # x will be 's1'

y = str(2)    # y will be '2'

z = str(3.0)  # z will be '3.0' 

Рядки вносяться або в одинарні, або в подвійні лапки.

'hello'  — це те саме, що "hello". 

Ви можете відобразити рядковий літерал за допомогою функції print():

print("Hello")

print('Hello') 

Присвоїти рядок змінної

Присвоєння рядка змінної виконується з ім'ям змінної, за яким слідує знак рівності та рядок:

a = "Hello"

print(a) 

Багаторядкові рядки

Ви можете призначити багаторядковий рядок змінної, використовуючи три лапки:

a = """Lorem ipsum dolor sit amet,

consectetur adipiscing elit,

sed do eiusmod tempor incididunt

ut labore et dolore magna aliqua."""

print(a) 

Або три одинарні лапки:

a = '''Lorem ipsum dolor sit amet,

consectetur adipiscing elit,

sed do eiusmod tempor incididunt

ut labore et dolore magna aliqua.'''

print(a) 

Примітка: в результаті розриви рядків вставляються в тому ж місці, що й у коді.

Рядки - це масиви

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

Однак у Python немає символьного типу даних, один символ це просто рядок довжиною 1.

Квадратні дужки можна використовувати для доступу до елементів рядка.

a = "Hello, World!"

print(a[1]) 

Перебір рядка

Оскільки рядки є масивами, ми можемо перебирати символи у рядку за допомогою циклу for.

for x in "banana":

  print(x) 

Довжина рядка

Щоб отримати довжину рядка, скористайтеся функцією len().

a = "Hello, World!!!"

print(len(a)) 

Перевірити рядок

Щоб перевірити, чи є у рядку певна фраза або символ, ми можемо використовувати ключове слово in.

txt = "The best things in life are free!"

print("free" in txt) 

Використовуйте його в операторі if:

txt = "The best things in life are free!"

if "free" in txt:

  print("Yes, 'free' is present.") 

Проверьте, if NOT

Щоб перевірити, чи не в рядку є певна фраза або символ, ми можемо використовувати ключове слово not in.

txt = "The best things in life are free!"

print("expensive" not in txt) 

Використовуйте його в операторі if:

txt = "The best things in life are free!"

if "expensive" not in txt:

  print("No, 'expensive' is NOT present.") 

Slicing

Ви можете повернути діапазон символів за допомогою синтаксису зрізу.

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

b = "Hello, World!"

print(b[2:5]) 

Примітка: перший символ має індекс 0.

Slice From the Start

Якщо виключити початковий індекс, діапазон починається з першого символу:

b = "Hello, World!"

print(b[:5]) 

Slice To the End

Якщо виключити кінцевий індекс, діапазон буде доведено до кінця:

b = "Hello, World!"

print(b[2:]) 

Негативне індексування

Використовуйте негативні індекси, щоб почати зріз з кінця рядка:

b = "Hello, World!"

print(b[-5:-2]) 

Змінити рядки

Upper Case

a = "Hello, World!"

print(a.upper()) 

Lower Case

a = "Hello, World!"

print(a.lower()) 

Remove Whitespace

Пробіл — це простір до та або після фактичного тексту, і дуже часто ви хочете видалити цей простір.

a = " Hello, World! "

print(a.strip()) # returns "Hello, World!" 

Replace String

Метод replace() замінює рядок іншим рядком:

a = "Hello, World!"

print(a.replace("H", "J")) 

Split String

Метод split() повертає список, у якому текст між зазначеним роздільником стає елементами списку.

a = "Hello, World!"

print(a.split(",")) # returns ['Hello', ' World!'] 

Конкатенація рядків

Щоб з'єднати або об'єднати два рядки, можна використовувати оператор +.

a = "Hello"

b = "World"

c = a + b

print(c) 

Щоб додати пробіл між ними, додайте " ":

a = "Hello"

b = "World"

c = a + " " + b

print(c) 

Рядковий формат

Як ми дізналися з розділу «Змінні Python», ми не можемо комбінувати рядки та числа таким чином:

age = 36

txt = "My name is John, I am " + age

print(txt) 

Але ми можемо комбінувати рядки та числа за допомогою методу format()!

Метод format() приймає передані аргументи, форматує їх та поміщає у рядок із заповнювачами {}:

age = 36

txt = "My name is John, and I am {}"

print(txt.format(age)) 

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

quantity = 3

itemno = 567

price = 49.95

myorder = "I want {} pieces of item {} for {} dollars."

print(myorder.format(quantity, itemno, price)) 

Ви можете використовувати порядкові номери {0}, щоб переконатися, що аргументи поміщені у правильні заповнювачі:

quantity = 3

itemno = 567

price = 49.95

myorder = "I want to pay {2} dollars for {0} pieces of item {1}."

print(myorder.format(quantity, itemno, price)) 

escape-символ

Щоб вставити неприпустимі символи в рядок, використовуйте символ escape.

Керуючий символ - це зворотна коса риса.

Прикладом неприпустимого символу є подвійна лапка всередині рядка, що міститься в подвійні лапки:

txt = "We are the so-called "Vikings" from the north."

Чтобы решить эту проблему, используйте escape-символ \":

txt = "We are the so-called \"Vikings\" from the north."

Інші escape-символи, що використовуються в Python:

\' - Single Quote

\\ - Backslash

\n - New Line

\r - Carriage Return

\t - Tab

\b - Backspace

\f - Form Feed

\ooo - Octal value

\xhh - Hex value

Логічні значення є одним із двох значень: True або False.

У програмуванні вам часто потрібно знати, чи є вираз істинним чи хибним.

Ви можете оцінити будь-який вираз у Python і отримати одну з двох відповідей: True або False.

Коли ви порівнюєте два значення, обчислюється вираз, і Python повертає логічний відповідь:

print(10 > 9)

print(10 == 9)

print(10 < 9) 

Коли ви запускаєте умову в операторі if, Python повертає True або False:

a = 200

b = 33

if b > a:

  print("b is greater than a")

else:

  print("b is not greater than a") 

Оцінка значень та змінних

Функція bool() дозволяє оцінити будь-яке значення і повернути вам True або False натомість,

print(bool("Hello"))

print(bool(15)) 

------------------------------

x = "Hello"

y = 15

print(bool(x))

print(bool(y)) 

Більшість значень істинні

Майже будь-яке значення оцінюється як True, якщо має якийсь контент.

Будь-який рядок є True, крім порожніх рядків.

Будь-яке число є істинним, крім 0.

Будь-який список, кортеж, набір та словник мають значення True, крім порожніх.

bool("abc")

bool(123)

bool(["apple", "cherry", "banana"]) 

Деякі значення помилкові

Насправді існує не так багато значень, які оцінюються як False, за винятком порожніх значень, таких як (), [], {}, "", число 0 та значення None. І, звичайно, значення False оцінюється як False.

bool(False)

bool(None)

bool(0)

bool("")

bool(())

bool([])

bool({}) 

Еще одно значение или объект в этом случае оценивается как False, и это если у вас есть объект, созданный из класса с функцией __len__, которая возвращает 0 или False:

class myclass():

  def __len__(self):

    return 0

myobj = myclass()

print(bool(myobj)) 

Функції можуть повертати логічне значення

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

def myFunction() :

  return True

print(myFunction()) 

Ви можете виконати код на основі логічної відповіді функції:

def myFunction() :

  return True

if myFunction():

  print("YES!")

else:

  print("NO!") 

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

x = 200

print(isinstance(x, int)) 

Оператори використовуються для виконання операцій над змінними та значеннями.

У наведеному нижче прикладі ми використовуємо оператор + для складання двох значень:

print(10 + 5)

Python делит операторы на следующие группы:

Арифметичні оператори

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

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

Логічні оператори

Оператори ідентифікації

Оператори членства

Побітові оператори

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

Operator Name Example

+ Addition x + y

- Subtraction x - y

* Multiplication x * y

/ Division x / y

** Exponentiation x ** y

// Floor division x // y

Оператори присвоєння використовуються для присвоєння значень змінним:

Operator Example Same As

= x = 5 x = 5

+= x += 3 x = x + 3

-= x -= 3 x = x - 3

*= x *= 3 x = x * 3

/= x /= 3 x = x / 3

%= x %= 3 x = x % 3

//= x //= 3 x = x // 3

**= x **= 3 x = x ** 3

&= x &= 3 x = x & 3

|= x |= 3 x = x | 3

^= x ^= 3 x = x ^ 3

>>= x >>= 3 x = x >> 3

<<= x <<= 3 x = x << 3

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

Operator Name Example

== Equal x == y

!= Not equal x != y

> Greater than x > y

< Less than x < y

>= Greater than or equal to x >= y

<= Less than or equal to x <= y

Логічні оператори використовуються для об'єднання умовних операторів:

Operator Name Example

and Returns True if both statements are true x < 5 and  x < 10

or Returns True if one of the statements is true x < 5 or x < 4

not Reverse the result, returns False if the result is true not(x < 5 and x < 10)

Оператори ідентичності використовуються для порівняння об'єктів не в тому випадку, якщо вони рівні, а в тому, що вони насправді є одним і тим самим об'єктом з тим самим розташуванням пам'яті:

Operator Name Example

is Returns True if both variables are the same object x is y

is not Returns True if both variables are not the same object x is not y

Оператори приладдя використовуються для перевірки наявності послідовності в об'єкті:

Operator Name Example

in Returns True if a sequence with the specified x in y

  value is present in the object

not in Returns True if a sequence with the specified       x not in y 

value is not present in the object

Побітові оператори використовуються для порівняння (двійкових) чисел:

Operator Name Example

& AND     Sets each bit to 1 if both bits are 1

| OR             Sets each bit to 1 if one of two bits is 1

^ XOR     Sets each bit to 1 if only one of two bits is 1

~ NOT     Inverts all the bits

<< Zero fill left shift         Shift left by pushing zeros in from the right and 

let the leftmost bits fall off

>> Signed right shift     Shift right by pushing copies of the leftmost 

bit in from the left, and let the rightmost bits fall off

Умови Python та оператори If

Python підтримує звичайні логічні умови математики:

Рівно: а == б

Не одно: а! = б

Менше ніж: а < б

Менше чи одно: a <= b

Більше, ніж: а > б

Більше або одно: a >= b

Ці умови можна використовувати декількома способами, найчастіше в операторах if та циклах.

Оператор if записується за допомогою ключового слова if.

a = 33

b = 200

if b > a:

  print("b is greater than a") 

У цьому прикладі ми використовуємо дві змінні, a та b, які використовуються як частина оператора if, щоб перевірити, чи більше b, ніж a. Оскільки a дорівнює 33, а b дорівнює 200, ми знаємо, що 200 більше 33 тому ми виводимо на екран, що «b більше, ніж a».

Відступ

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

a = 33

b = 200

if b > a:

print("b is greater than a") # you will get an error 

Elif

Ключове слово elif - це спосіб python сказати: "Якщо попередні умови були неправильні, спробуйте цю умову".

a = 33

b = 33

if b > a:

  print("b is greater than a")

elif a == b:

  print("a and b are equal") 

У цьому прикладі a дорівнює b, тому перша умова невірна, але умова elif істинна, тому ми виводимо на екран, що a і b рівні.

else 

Ключове слово else вловлює все, що не вловлюється попередніми умовами.

a = 200

b = 33

if b > a:

  print("b is greater than a")

elif a == b:

  print("a and b are equal")

else:

  print("a is greater than b") 

У цьому прикладі a більше, ніж b, тому перша умова неправильна, також умова elif невірна, тому ми переходимо до іншої умови та виводимо на екран, що «a більше, ніж b».

Ви також можете мати else без elif:

a = 200

b = 33

if b > a:

  print("b is greater than a")

else:

  print("b is not greater than a") 

Коротка форма, якщо

Якщо вам потрібно виконати лише один оператор, ви можете помістити його в той самий рядок, що й оператор if.

if a > b: print("a is greater than b") 

Короткая форма, If ... Else

Якщо у вас є тільки один оператор для виконання, один для if і один для else, ви можете помістити їх у один рядок:

a = 2

b = 330

print("A") if a > b else print("B") 

Цей метод відомий як тернарні оператори чи умовні висловлювання.

Ви також можете мати кілька операторів else в одному рядку:

a = 330

b = 330

print("A") if a > b else print("=") if a == b else print("B") 

and 

Ключове слово and є логічним оператором та використовується для об'єднання умовних операторів:

a = 200

b = 33

c = 500

if a > b and c > a:

  print("Both conditions are True") 

or 

Ключове слово or є логічним оператором та використовується для об'єднання умовних операторів:

a = 200

b = 33

c = 500

if a > b or a > c:

  print("At least one of the conditions is True") 

Вкладений якщо(Nested If)

Ви можете мати оператори if всередині операторів if, це називається вкладеними операторами if.

x = 41

if x > 10:

  print("Above ten,")

  if x > 20:

    print("and also above 20!")

  else:

    print("but not above 20.") 

Заява про пропуск(pass Statement)

оператори if не можуть бути порожніми, але якщо з якоїсь причини у вас є оператор if без вмісту, додайте оператор pass, щоб уникнути помилки.

a = 33

b = 200

if b > a:

  pass 

У Python є дві примітивні команди циклу:

• while loops

• for loops

Цикл while

За допомогою циклу while ми можемо виконувати набір операторів і команд, поки умова є істинною.

i = 1

while i < 6:

  print(i)

  i += 1 

Примітка: не забудьте збільшити i, інакше цикл триватиме вічно.

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

break

За допомогою оператора break ми можемо зупинити цикл, навіть якщо умова while істинно:

i = 1

while i < 6:

  print(i)

  if i == 3:

    break

  i += 1 

continue 

За допомогою оператора continue ми можемо зупинити поточну ітерацію та продовжити таку:

i = 0

while i < 6:

  i += 1

  if i == 3:

    continue

  print(i) 

else 

З оператором else ми можемо запустити блок коду один раз, коли умова більше не виконується:

i = 1

while i < 6:

  print(i)

  i += 1

else:

  print("i is no longer less than 6") 

Цикл for використовується для перебору послідовності (тобто списку, кортежу, словника, набору чи рядка).

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

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

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

for x in fruits:

  print(x) 

Цикл for не вимагає попередньої установки індексуючої змінної.

Перебір рядка

Навіть рядки є об'єктами, що ітеруються, вони містять послідовність символів:

for x in "banana":

  print(x) 

break 

За допомогою оператора break ми можемо зупинити цикл перед тим, як він перегляне всі елементи:

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

for x in fruits:

  print(x)

  if x == "banana":

    break 

--------------------------------------------------------------------------

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

for x in fruits:

  if x == "banana":

    break

  print(x) 

continue 

За допомогою оператора continue ми можемо зупинити поточну ітерацію циклу та продовжити таку:

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

for x in fruits:

  if x == "banana":

    continue

  print(x) 

Функція range()

Щоб перебрати набір коду задану кількість разів, ми можемо використовувати функцію range(),

Функція range() повертає послідовність чисел, починаючи з 0 за замовчуванням, збільшуючись на 1 (за замовчуванням) і закінчуючи вказаним числом.

for x in range(6):

  print(x) 

Зверніть увагу, що range(6) — це значення від 0 до 6, а значення від 0 до 5.

Функція range() за умовчанням дорівнює 0 як початкове значення, проте можна вказати початкове значення, додавши параметр: range(2, 6), що означає значення від 2 до 6 (але не включаючи 6):

for x in range(2, 6):

  print(x) 

Функція range() за замовчуванням збільшує послідовність на 1, проте можна вказати значення приросту, додавши третій параметр: range(2, 30, 3):

for x in range(2, 30, 3):

  print(x) 

Else У For

Ключове слово else у циклі for визначає блок коду, який буде виконано після завершення циклу:

for x in range(6):

  print(x)

else:

  print("Finally finished!") 

Примітка. Блок else НЕ виконуватиметься, якщо цикл зупинено оператором break.

for x in range(6):

  if x == 3: break

  print(x)

else:

  print("Finally finished!") 

Вкладений цикл — це цикл усередині циклу.

"Внутрішній цикл" буде виконуватися один раз для кожної ітерації "зовнішнього циклу":

adj = ["red", "big", "tasty"]

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

for x in adj:

  for y in fruits:

    print(x, y) 

pass 

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

for x in [0, 1, 2]:

  pass 

Функція – це блок коду, який запускається лише під час виклику.

Ви можете передавати дані, відомі як параметри, у функцію.

В результаті, функція може повертати дані.

Створення функції

У Python функція визначається за допомогою ключового слова def:

def my_function():

  print("Hello from a function") 

Виклик функції

Щоб викликати функцію, використовуйте ім'я функції, за яким слідують круглі дужки:

def my_function():

  print("Hello from a function")

my_function() 

Аргументи

Інформація може передаватися до функцій як аргументи.

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

У цьому прикладі є функція з одним аргументом (fname). Коли функція викликається, ми передаємо ім'я, яке використовується всередині функції для повного імені:

def my_function(fname):

  print(fname + " Refsnes")

my_function("Emil")

my_function("Tobias")

my_function("Linus") 

З погляду функції:

Параметр — це змінна, вказана у дужках для визначення функції.

Аргумент – це значення, яке передається функції під час її виклику.

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

За замовчуванням функція повинна викликатись з правильною кількістю аргументів. Це означає, що якщо ваша функція чекає на 2 аргументи, ви повинні викликати функцію з 2 аргументами, не більше і не менше.

def my_function(fname, lname):

  print(fname + " " + lname)

my_function("Emil", "Refsnes") 

Якщо ви спробуєте викликати функцію з 1 або 3 аргументами, ви отримаєте помилку:

def my_function(fname, lname):

  print(fname + " " + lname)

my_function("Emil") 

Довільні аргументи *args

Якщо ви не знаєте, скільки аргументів буде передано до вашої функції, додайте * перед ім'ям параметра у визначенні функції.

Таким чином, функція отримає кортеж аргументів та зможе отримати відповідний доступ до елементів:

def my_function(*kids):

  print("The youngest child is " + kids[2])

my_function("Emil", "Tobias", "Linus") 

Довільні аргументи часто скорочуються до args в документації Python.

Аргументи ключових слів

Ви також можете надсилати аргументи із синтаксисом key = value syntax.

Отже, порядок аргументів немає значення.

def my_function(child3, child2, child1):

  print("The youngest child is " + child3)

my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus") 

Фраза Аргументи ключового слова часто скорочується до kwargs у документації Python.

Довільні аргументи ключового слова, **kwargs

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

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

def my_function(**kid):

  print("His last name is " + kid["lname"])

my_function(fname = "Tobias", lname = "Refsnes") 

Довільні аргументи Kword часто скорочуються до **kwargs у документації Python.

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

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

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

def my_function(country = "Norway"):

  print("I am from " + country)

my_function("Sweden")

my_function("India")

my_function()

my_function("Brazil") 

Передача списку як аргумент

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

Наприклад. якщо ви відправите список як аргумент, він все одно буде списком, коли він досягне функції:

def my_function(food):

  for x in food:

    print(x)

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

my_function(fruits) 

Значення, що повертаються

Щоб функція повертала значення, використовуйте оператор return:

def my_function(x):

  return 5 * x

print(my_function(3))

print(my_function(5))

print(my_function(9)) 

pass 

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

def myfunction():

  pass 

Рекурсія

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

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

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

У цьому прикладі tri_recursion() — це функція, яку ми визначили для виклику себе («рекурсія»). Ми використовуємо змінну k як дані, які зменшуються (-1) щоразу, коли ми рекурсивно. Рекурсія закінчується, коли умова не більше 0 (тобто коли вона дорівнює 0).

Новому розробнику може знадобитися деякий час, щоб зрозуміти, як саме це працює, найкращий спосіб дізнатися про це - протестувати і змінити його.

def tri_recursion(k):

  if(k > 0):

result = k + tri_recursion(k - 1)

print(result)

  else:

result = 0

  return result

print("\n\nRecursion Example Results")

tri_recursion(6) 

Примітка. Python не має вбудованої підтримки масивів, але натомість можна використовувати списки Python.

Масиви

Примітка. Показано, як використовувати СПИСКИ як МАСИВІВ, проте для роботи з масивами в Python вам доведеться імпортувати бібліотеку, наприклад бібліотеку NumPy.

Масиви використовуються для зберігання кількох значень в одній змінній:

cars = ["Ford", "Volvo", "BMW"] 

Що таке масив?

Масив – це спеціальна змінна, яка може містити більше одного значення одночасно.

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

car1 = "Ford"

car2 = "Volvo"

car3 = "BMW" 

Однак що, якщо ви хочете перебрати всі машини та знайти конкретну? А якби у вас було не 3 машини, а 300?

Рішення є масивом!

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

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

Ви звертаєтесь до елемента масиву, звертаючись до номера індексу.

Отримати значення першого елемента масиву:

x = cars[0] 

Змініть значення першого елемента масиву:

cars[0] = "Toyota" 

Довжина масиву

Використовуйте метод len(), щоб повернути довжину масиву (кількість елементів у масиві).

x = len(cars) 

Примітка. Довжина масиву завжди на одиницю більша, ніж найвищий індекс масиву.

Зациклювання елементів масиву

Ви можете використовувати цикл for in для вибору всіх елементів масиву.

for x in cars:

  print(x) 

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

Ви можете використовувати метод append() для додавання елемента до масиву.

cars.append("Honda")

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

Ви можете використовувати метод pop(), щоб видалити елемент з масиву.

cars.pop(1) 

Ви також можете використовувати remove() метод для видалення елемента з масиву.

cars.remove("Volvo") 

Примітка. Метод remove() списку видаляє лише перше входження вказаного значення.

Array Methods

Python has a set of built-in methods that you can use on lists/arrays.

Method Description

append() Adds an element at the end of the list

clear() Removes all the elements from the list

copy() Returns a copy of the list

count() Returns the number of elements with the specified value

extend() Add the elements of a list (or any iterable), to the end of the current list

index() Returns the index of the first element with the specified value

insert() Adds an element at the specified position

pop() Removes the element at the specified position

remove() Removes the first item with the specified value

reverse() Reverses the order of the list

sort() Sorts the list

Списки використовуються для зберігання кількох елементів в одній змінній.

Списки — це один із 4 вбудованих типів даних у Python, які використовуються для зберігання колекцій даних, інші 3 — це Tuple, Set і Dictionary, усі з різними якостями та використанням.

Списки створюються за допомогою квадратних скобок:

thislist = ["apple", "banana", "cherry"]

print(thislist) 

Елементи списку

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

Елементи списку індексуються, перший елемент має індекс [0], другий елемент має індекс [1]...

Упорядкованість

Коли ми говоримо, що списки впорядковані, це означає, що елементи мають певний порядок, і цей порядок не зміниться.

Якщо ви додаєте нові елементи до списку, нові елементи будуть розміщені в кінці списку.

Примітка. Є деякі методи списку, які змінюють порядок, але загалом порядок елементів не зміниться.

Змінний

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

Дозволити дублікати

Оскільки списки індексуються, списки можуть мати елементи з однаковим значенням:

thislist = ["apple", "banana", "cherry", "apple", "cherry"]

print(thislist) 

Довжина списку

Щоб визначити, скільки елементів у списку, використовуйте функцію len():

thislist = ["apple", "banana", "cherry"]

print(len(thislist)) 

Елементи списку – типи даних

Елементи списку можуть мати будь-який тип даних:

list1 = ["apple", "banana", "cherry"]

list2 = [1, 5, 7, 9, 3]

list3 = [True, False, False] 

Список може містити різні типи даних:

list1 = ["abc", 34, True, 40, "male"] 

ТИП()

З точки зору Python списки визначаються як об'єкти з типом даних "список":

mylist = ["apple", "banana", "cherry"]

print(type(mylist)) 

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

Також можна використовувати конструктор list() при створенні нового списку.

thislist = list(("apple", "banana", "cherry")) # note the double round-brackets

print(thislist) 

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

Елементи списку проіндексовані, і ви можете отримати доступ до них, звернувшись до номера індексу:

thislist = ["apple", "banana", "cherry"]

print(thislist[1]) 

Примітка. Перший елемент має індекс 0.

Негативне індексування

Негативна індексація означає початок з кінця

-1 відноситься до останнього елементу, -2 відноситься до передостаннього елемента і т.д.

thislist = ["apple", "banana", "cherry"]

print(thislist[-1]) 

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

Ви можете вказати діапазон індексів, вказавши, де починати та де закінчувати діапазон.

При вказуванні діапазону повертається значенням буде новий список із зазначеними елементами.

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]

print(thislist[2:5]) 

Примітка. Пошук розпочнеться з індексу 2 (включно) та закінчиться з індексом 5 (не включено).

Пам'ятайте, перший елемент має індекс 0.

Якщо не вказувати початкове значення, діапазон починається з першого елемента:

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]

print(thislist[:4]) 

Якщо виключити кінцеве значення, діапазон триватиме до кінця списку:

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]

print(thislist[2:]) 

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

Вкажіть негативні індекси, якщо хочете розпочати пошук із кінця списку:

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]

print(thislist[-4:-1]) 

Перевірити, чи існує елемент

Щоб визначити, чи є вказаний елемент у списку, використовуйте ключове слово in:

thislist = ["apple", "banana", "cherry"]

if "apple" in thislist:

  print("Yes, 'apple' is in the fruits list") 

Змінити значення елемента

Щоб змінити значення певного елемента, зверніться до номера індексу:

thislist = ["apple", "banana", "cherry"]

thislist[1] = "blackcurrant"

print(thislist) 

Змінити діапазон значень елементів

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

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "mango"]

thislist[1:3] = ["blackcurrant", "watermelon"]

print(thislist) 

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

thislist = ["apple", "banana", "cherry"]

thislist[1:2] = ["blackcurrant", "watermelon"]

print(thislist) 

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

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

thislist = ["apple", "banana", "cherry"]

thislist[1:3] = ["watermelon"]

print(thislist) 

Вставити елементи

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

Метод insert() вставляє елемент за вказаним індексом:

thislist = ["apple", "banana", "cherry"]

thislist.insert(2, "watermelon")

print(thislist) 

Примітка. В результаті наведеного вище прикладу список тепер міститиме 4 елементи.

Додати елементи

Щоб додати елемент до кінця списку, використовуйте метод append():

thislist = ["apple", "banana", "cherry"]

thislist.append("orange")

print(thislist) 

Вставити елементи

Щоб вставити елемент списку за вказаним індексом, використовуйте метод insert().

Метод insert() вставляє елемент за вказаним індексом:

thislist = ["apple", "banana", "cherry"]

thislist.insert(1, "orange")

print(thislist) 

Примітка. В результаті наведених вище прикладів списки тепер будуть містити 4 елементи.

Розширити список

Щоб додати елементи з іншого списку до поточного списку, використовуйте метод extend().

thislist = ["apple", "banana", "cherry"]

tropical = ["mango", "pineapple", "papaya"]

thislist.extend(tropical)

print(thislist) 

Додати будь-який об'єкт, що ітерується.

Методу extend() не потрібно додавати списки, ви можете додати будь-який об'єкт, що ітерується (кортежі, набори, словники).

thislist = ["apple", "banana", "cherry"]

thistuple = ("kiwi", "orange")

thislist.extend(thistuple)

print(thislist) 

Видалити вказаний елемент

Метод remove() видаляє вказаний елемент.

thislist = ["apple", "banana", "cherry"]

thislist.remove("banana")

print(thislist) 

Видалити вказаний індекс

Метод pop() видаляє зазначений індекс.

thislist = ["apple", "banana", "cherry"]

thislist.pop(1)

print(thislist) 

Якщо ви не вкажете індекс, метод pop() видалитиме останній елемент.

thislist = ["apple", "banana", "cherry"]

thislist.pop()

print(thislist) 

Ключове слово del також видаляє зазначений індекс:

thislist = ["apple", "banana", "cherry"]

del thislist[0]

print(thislist) 

Ключове слово del також може повністю видалити список.

thislist = ["apple", "banana", "cherry"]

del thislist 

Очистити список

Метод clear() очищає перелік.

Список все ще залишається, але в ньому немає змісту.

thislist = ["apple", "banana", "cherry"]

thislist.clear()

print(thislist) 

Цикл за списком

Ви можете переглянути елементи списку за допомогою циклу for:

thislist = ["apple", "banana", "cherry"]

for x in thislist:

  print(x) 

Цикл за номерами індексів

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

Використовуйте функції range() і len() для створення відповідного об'єкта, що ітерується.

thislist = ["apple", "banana", "cherry"]

for i in range(len(thislist)):

  print(thislist[i]) 

Об'єкт, що ітерується, створений у наведеному вище прикладі, має значення [0, 1, 2].

Використання циклу while

Ви можете переглянути елементи списку за допомогою циклу while.

Використовуйте функцію len(), щоб визначити довжину списку, потім почніть з 0 і прокручуйте елементи списку, звертаючись до їх індексів.

Не забувайте збільшувати індекс на 1 після кожної ітерації.

thislist = ["apple", "banana", "cherry"]

i = 0

while i < len(thislist):

  print(thislist[i])

  i = i + 1 

Зациклювання з використанням розуміння списку

List Comprehension пропонує найкоротший синтаксис для перебору списків:

thislist = ["apple", "banana", "cherry"]

[print(x) for x in thislist] 

Перегляд списку

Ви можете прокручувати елементи списку за допомогою циклу for:

thislist = ["apple", "banana", "cherry"]

for x in thislist:

  print(x) 

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

Ви також можете прокручувати елементи списку, посилаючись на їхній індексний номер.

Використовуйте функції range() і len(), щоб створити відповідну ітерацію.

Надрукуйте всі елементи, посилаючись на їхні індексні номери:

thislist = ["apple", "banana", "cherry"]

for i in range(len(thislist)):

  print(thislist[i]) 

Використання циклу While

Ви можете прокручувати елементи списку за допомогою циклу while.

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

Не забудьте збільшити індекс на 1 після кожної ітерації.

Надрукуйте всі елементи, використовуючи цикл while, щоб переглянути всі номери індексів

thislist = ["apple", "banana", "cherry"]

i = 0

while i < len(thislist):

  print(thislist[i])

  i = i + 1 

Цикл із використанням розуміння списку

List Comprehension пропонує найкоротший синтаксис для циклічного перегляду списків:

Короткий цикл Hand for, який друкує всі елементи в списку:

thislist = ["apple", "banana", "cherry"]

[print(x) for x in thislist] 

Розуміння списку

Розуміння списку пропонує коротший синтаксис, коли ви хочете створити новий список на основі значень існуючого списку.

приклад:

На основі списку фруктів вам потрібен новий список, який містить лише фрукти з літерою «а» в назві.

Без розуміння списку вам доведеться написати оператор for з умовним тестом всередині:

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]

newlist = []

for x in fruits:

  if "a" in x:

    newlist.append(x)

print(newlist) 

З розумінням списку ви можете зробити все це за допомогою лише одного рядка коду:

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]

newlist = [x for x in fruits if "a" in x]

print(newlist) 

Синтаксис

newlist = [expression for item in iterable if condition == True]

Поверненим значенням є новий список, який залишає старий список без змін.

Стан

Умова схожа на фільтр, який приймає лише ті елементи, які мають значення True.

Приймайте лише товари, які не є "apple":

newlist = [x for x in fruits if x != "apple"] 

Умова if x != "apple" поверне True для всіх елементів, крім "apple", завдяки чому новий список міститиме всі фрукти, крім "apple".

Умова необов’язкова і її можна опустити:

З оператором no if:

newlist = [x for x in fruits] 

Iterable

Ітерованим може бути будь-який ітерований об’єкт, наприклад список, кортеж, набір тощо.

Ви можете використовувати функцію range() для створення ітерованого:

newlist = [x for x in range(10)]

Той самий приклад, але з умовою:

Приймати лише числа менше 5:

newlist = [x for x in range(10) if x < 5]

Вираз

Вираз є поточним елементом у ітерації, але це також результат, яким ви можете маніпулювати, перш ніж він закінчиться як елемент списку в новому списку:

Установіть значення у новому списку у верхній регістр:

newlist = [x.upper() for x in fruits]

Ви можете встановити будь-який результат:

Установіть для всіх значень у новому списку значення «hello»:

newlist = ['hello' for x in fruits] 

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

Повернути «апельсин» замість «банан»:

newlist = [x if x != "banana" else "orange" for x in fruits] 

Сортувати список буквено-цифровим способом

Об’єкти списку мають метод sort(), який за замовчуванням сортує список алфавітно-цифровим способом за зростанням:

Відсортуйте список за алфавітом:

thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]

thislist.sort()

print(thislist) 

Відсортуйте список за числами:

thislist = [100, 50, 65, 82, 23]

thislist.sort()

print(thislist) 

Сортувати за спаданням

Щоб відсортувати за спаданням, використовуйте аргумент ключового слова reverse = True:

thislist = ["orange", "mango", "kiwi", "pineapple", "banana"]

thislist.sort(reverse = True)

print(thislist) 

Відсортуйте список за спаданням:

thislist = [100, 50, 65, 82, 23]

thislist.sort(reverse = True)

print(thislist) 

Налаштувати функцію сортування

Ви також можете налаштувати власну функцію за допомогою ключового аргументу ключ = функція.

Функція поверне число, яке буде використано для сортування списку (найменше число спочатку):

Відсортуйте список залежно від того, наскільки близьке число до 50:

def myfunc(n):

  return abs(n - 50)

thislist = [100, 50, 65, 82, 23]

thislist.sort(key = myfunc)

print(thislist) 

Сортування без урахування регістру

За замовчуванням метод sort() чутливий до регістру, в результаті чого всі великі літери сортуються перед малими:

Сортування з урахуванням регістру може дати неочікуваний результат:

thislist = ["banana", "Orange", "Kiwi", "cherry"]

thislist.sort()

print(thislist) 

На щастя, ми можемо використовувати вбудовані функції як ключові під час сортування списку.

Отже, якщо вам потрібна функція сортування без урахування регістру, використовуйте str.lower як ключову функцію:

Виконайте сортування списку без урахування регістру:

thislist = ["banana", "Orange", "Kiwi", "cherry"]

thislist.sort(key = str.lower)

print(thislist) 

Зворотний порядок

Що робити, якщо ви хочете змінити порядок списку, незалежно від алфавіту?

Метод reverse() змінює поточний порядок сортування елементів.

thislist = ["banana", "Orange", "Kiwi", "cherry"]

thislist.reverse()

print(thislist) 

Скопіюйте список

Ви не можете скопіювати список, просто ввівши list2 = list1, тому що: list2 буде лише посиланням на list1, а зміни, внесені в list1, також будуть автоматично внесені в list2.

Існують способи зробити копію, один із способів – використати вбудований метод List copy().

Скопіюйте список за допомогою методу copy():

thislist = ["apple", "banana", "cherry"]

mylist = thislist.copy()

print(mylist) 

Ще один спосіб зробити копію — використати вбудований метод list().

Скопіюйте список за допомогою методу list():

thislist = ["apple", "banana", "cherry"]

mylist = list(thislist)

print(mylist) 

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

У Python існує кілька способів об’єднати або об’єднати два чи більше списків.

Одним із найпростіших способів є використання оператора +.

Приєднайтеся до двох списків:

list1 = ["a", "b", "c"]

list2 = [1, 2, 3]

list3 = list1 + list2

print(list3) 

Ще один спосіб об’єднати два списки – додавати всі елементи зі списку list2 до list1 по одному:

Додайте список2 до списку1 (list2 до list1):

list1 = ["a", "b" , "c"]

list2 = [1, 2, 3]

for x in list2:

  list1.append(x)

print(list1) 

Або ви можете використати метод extend(), метою якого є додавання елементів з одного списку до іншого:

Використовуйте метод extend(), щоб додати list2 у кінець list1:

list1 = ["a", "b" , "c"]

list2 = [1, 2, 3]

list1.extend(list2)

print(list1) 

Методи списку

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

Method Description

append() Adds an element at the end of the list

clear() Removes all the elements from the list

copy() Returns a copy of the list

count() Returns the number of elements with the specified value

extend() Add the elements of a list (or any iterable), to the end of the current list

index() Returns the index of the first element with the specified value

insert() Adds an element at the specified position

pop() Removes the element at the specified position

remove() Removes the item with the specified value

reverse() Reverses the order of the list

sort() Sorts the list

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

Tuple - це один з 4 вбудованих типів даних в Python, що використовуються для зберігання колекцій даних, решта 3 - це List, Set і Dictionary, все з різною якістю та використанням.

Кортеж - це впорядкована та незмінна колекція.

Кортежі пишуться із круглими дужками.

thistuple = ("apple", "banana", "cherry")

print(thistuple) 

Елементи кортежу (Tuple Items)

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

Елементи кортежу індексуються, перший елемент має індекс [0], другий елемент має індекс [1] тощо.

Наказав(Ordered)

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

Постійний(Unchangeable)

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

Дозволити дублікати (Allow Duplicates)

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

thistuple = ("apple", "banana", "cherry", "apple", "cherry")

print(thistuple) 

Довжина кортежу

Щоб визначити, скільки елементів містить кортеж, використовуйте функцію len():

thistuple = ("apple", "banana", "cherry")

print(len(thistuple)) 

Створити кортеж з одним елементом

Щоб створити кортеж тільки з одним елементом, ви повинні додати ком після елемента, інакше Python не розпізнає його як кортеж.

thistuple = ("apple",)

print(type(thistuple))

#NOT a tuple

thistuple = ("apple")

print(type(thistuple)) 

Елементи кортежу - типи даних

Елементи кортежу можуть мати будь-який тип даних:

tuple1 = ("apple", "banana", "cherry")

tuple2 = (1, 5, 7, 9, 3)

tuple3 = (True, False, False) 

Кортеж може містити різні типи даних:

tuple1 = ("abc", 34, True, 40, "male")

тип()

З точки зору Python кортежі визначаються як об'єкти з типом даних "кортеж":

mytuple = ("apple", "banana", "cherry")

print(type(mytuple)) 

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

Також можна використовувати конструктор tuple() для створення кортежу.

thistuple = tuple(("apple", "banana", "cherry")) # note the double round-brackets

print(thistuple) 

Колекції Python (масиви)

У мові програмування Python є чотири типи даних колекції:

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

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

Набір — це невпорядкована, незмінна* та неіндексована колекція. Немає дублікатів учасників.

Словник – збірник, який є впорядкованим** і змінним. Немає дублікатів учасників.

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

Ви можете отримати доступ до елементів кортежу, посилаючись на номер індексу у квадратних дужках:

thistuple = ("apple", "banana", "cherry")

print(thistuple[1]) 

Негативна індексація

Негативна індексація означає початок з кінця.

-1 стосується останнього елемента, -2 стосується передостаннього елемента тощо.

thistuple = ("apple", "banana", "cherry")

print(thistuple[-1]) 

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

Ви можете вказати діапазон індексів, вказавши, де починати і де закінчувати діапазон.

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

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

print(thistuple[2:5]) 

Примітка. Пошук розпочнеться з індексу 2 (включено) і завершиться з індексу 5 (не включено).

Пам'ятайте, що перший елемент має індекс 0.

Якщо пропустити початкове значення, діапазон розпочнеться з першого елемента:

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

print(thistuple[:4]) 

Якщо залишити кінцеве значення, діапазон перейде до кінця списку:

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

print(thistuple[2:]) 

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

Вкажіть негативні індекси, якщо ви хочете почати пошук з кінця кортежу:

thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

print(thistuple[-4:-1]) 

Перевірте, чи існує елемент

Щоб визначити, чи присутній певний елемент у кортежі, використовуйте ключове слово in:

thistuple = ("apple", "banana", "cherry")

if "apple" in thistuple:

  print("Yes, 'apple' is in the fruits tuple") 

Оновити кортежі

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

Але є деякі обхідні шляхи.

Змінити значення кортежу

Після створення кортежу ви не можете змінити його значення. Кортежі є незмінними або незмінними, як їх ще називають.

Але є обхідний шлях. Ви можете перетворити кортеж на список, змінити список і перетворити список назад на кортеж.

x = ("apple", "banana", "cherry")

y = list(x)

y[1] = "kiwi"

x = tuple(y)

print(x) 

Додати елементи

Оскільки кортежі є незмінними, вони не мають вбудованого методу append(), але існують інші способи додавати елементи до кортежу.

1. Перетворити на список: так само, як обхідний шлях для зміни кортежу, ви можете перетворити його на список, додати свій елемент(и) і перетворити його назад на кортеж.

Перетворіть кортеж на список, додайте «помаранчевий» і знову перетворите його на кортеж:

thistuple = ("apple", "banana", "cherry")

y = list(thistuple)

y.append("orange")

thistuple = tuple(y) 

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

Створіть новий кортеж зі значенням "orange" і додайте цей кортеж:

thistuple = ("apple", "banana", "cherry")

y = ("orange",)

thistuple += y

print(thistuple) 

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

Видалити елементи

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

Кортежі не змінюються, тому ви не можете видалити з них елементи, але ви можете скористатися тим самим обхідним шляхом, який ми використали для зміни та додавання елементів кортежу:

Перетворіть кортеж на список, видаліть «яблуко» та перетворите його назад на кортеж:

thistuple = ("apple", "banana", "cherry")

y = list(thistuple)

y.remove("apple")

thistuple = tuple(y) 

Або ви можете повністю видалити кортеж:

Або ви можете повністю видалити кортеж:

thistuple = ("apple", "banana", "cherry")

del thistuple

print(thistuple) #this will raise an error because the tuple no longer exists 

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

Коли ми створюємо кортеж, ми зазвичай призначаємо йому значення. Це називається «упаковкою» кортежу:

Упаковка кортежу:

fruits = ("apple", "banana", "cherry")

Але в Python нам також дозволено витягувати значення назад у змінні. Це називається «розпакуванням»:

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

fruits = ("apple", "banana", "cherry")

(green, yellow, red) = fruits

print(green)

print(yellow)

print(red) 

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

Використання Asterisk*

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

Призначте решту значень у вигляді списку під назвою «червоний»:

fruits = ("apple", "banana", "cherry", "strawberry", "raspberry")

(green, yellow, *red) = fruits

print(green)

print(yellow)

print(red) 

Якщо зірочка додана до назви змінної, відмінної від останньої, Python призначатиме значення змінній, доки кількість значень, що залишилися, не збігатиметься з кількістю змінних, які залишилися.

Додайте список значень змінної "тропік":

fruits = ("apple", "mango", "papaya", "pineapple", "cherry")

(green, *tropic, red) = fruits

print(green)

print(tropic)

print(red) 

Цикл через кортеж

Ви можете прокручувати елементи кортежу за допомогою циклу for.

Перегляньте елементи та надрукуйте значення:

thistuple = ("apple", "banana", "cherry")

for x in thistuple:

  print(x) 

Перегляньте номери індексів

Ви також можете прокручувати елементи кортежу, посилаючись на їхній індексний номер.

Використовуйте функції range() і len(), щоб створити відповідну ітерацію.

Надрукуйте всі елементи, посилаючись на їхні індексні номери:

thistuple = ("apple", "banana", "cherry")

for i in range(len(thistuple)):

  print(thistuple[i]) 

Використання циклу While

Ви можете прокручувати елементи кортежу за допомогою циклу while.

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

Не забудьте збільшити індекс на 1 після кожної ітерації.

Надрукуйте всі елементи, використовуючи цикл while, щоб переглянути всі номери індексів:

thistuple = ("apple", "banana", "cherry")

i = 0

while i < len(thistuple):

  print(thistuple[i])

  i = i + 1 

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

Щоб об’єднати два або більше кортежів, ви можете скористатися оператором +:

Об’єднайте два кортежі:

tuple1 = ("a", "b", "c")

tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2

print(tuple3) 

Множення кортежів

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

Помножте кортеж фруктів на 2:

fruits = ("apple", "banana", "cherry")

mytuple = fruits * 2

print(mytuple) 

Методи кортежу

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

Повертає кількість разів, коли значення 5 з’являється в кортежі:

Визначення та використання

Метод count() повертає кількість разів, коли вказане значення з’являється в кортежі.

Синтаксис

tuple.count(значення)

Повертає кількість разів, коли значення 5 з’являється в кортежі:

thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)

x = thistuple.count(5)

print(x) 

Визначення та використання

Метод index() знаходить перше входження вказаного значення.

Метод index() викликає виняток, якщо значення не знайдено.

Синтаксис

tuple.index(значення)

Знайдіть перше значення 8 і поверніть його позицію:

thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)

x = thistuple.index(8)

print(x) 

Набори використовуються для зберігання кількох елементів в одній змінній.

Набір – це один з 4 вбудованих типів даних у Python, які використовуються для зберігання колекцій даних, решта 3 – це список, кортеж та словник, всі з різними якостями та використанням.

Набір – це невпорядкована, незмінна* та неіндексована колекція.

* Примітка. Не можна змінити елементи набору, але ви можете видаляти елементи та додавати нові елементи.

Набори пишуться із фігурними дужками.

thisset = {"apple", "banana", "cherry"}

print(thisset) 

Примітка. Набори не впорядковані, тому ви не можете бути впевнені, в якому порядку будуть відображатися елементи.

(Set Items)

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

Невпорядкований(Unordered)

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

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

Незмінний(Unchangeable)

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

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

Дублікати не допускаються(Duplicates Not Allowed)

У наборах може бути двох елементів з однаковим значенням.

thisset = {"apple", "banana", "cherry", "apple"}

print(thisset)