Як створити штучний інтелект? Як створити власну нейронну мережу з нуля мовою Python Умови та цикли

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

Стадія 1. Розчарування

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

Лінійна алгебра;

Теорія графів;

Теорія ймовірностей та математична статистика.

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

Стадія 2. Прийняття

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

Стадія 3. Розвиток

Тепер переходимо безпосередньо до теорії ІІ. Їх умовно можна розділити на 3 категорії:

Слабкий ІІ - боти, яких ми бачимо в комп'ютерних іграх, або прості підручні помічники, як Siri. Вони або виконують вузькоспеціалізовані завдання або є незначним комплексом таких, а будь-яка непередбачуваність взаємодії ставить їх у глухий кут.

Сильний ІІ – це машини, інтелект яких можна порівняти з людським мозком. На сьогоднішній день немає реальних представників цього класу, але комп'ютери, як Watson дуже близькі до досягнення цієї мети.

Досконалі ІІ – майбутнє, машинний мозок, який перевершить наші можливості. Саме про небезпеку таких розробок попереджають Стівен Хоккінг, Елон Маск та кінофраншиза «Термінатор».

Звичайно, починати слід з найпростіших роботів. Для цього згадайте стару-добру гру «Хрестики-нуліки» при використанні поля 3х3 і постарайтеся з'ясувати для себе основні алгоритми дій: ймовірність перемоги при безпомилкових діях, найбільш вдалі місця на полі для розташування фігури, необхідність зводити гру до нічиєї і так далі.

Як ви зрозуміли навіть із назв, це API, які дозволять без зайвих витрат часу створити деяку подобу серйозного ІІ.

Стадія 5. Робота

Тепер, коли ви вже цілком ясно уявляєте, як ІІ створювати і чим при цьому користуватися, настав час виводити свої знання на новий рівень. По-перше, для цього знадобиться вивчення дисципліни, яке зветься «Машинне навчання». По-друге, необхідно навчитися працювати з відповідними бібліотеками вибраної мови програмування. Для Python, що розглядається, це Scikit-learn, NLTK, SciPy, PyBrain і Nump. По-третє, у розвитку нікуди не обійтися від

Джеймс Лой, технологічний університет штату Джорджія. Посібник для новачків, після якого ви зможете створити власну нейронну мережу на Python.

Мотивація:орієнтуючись на особистий досвід у вивченні глибокого навчання, я вирішив створити нейронну мережу з нуля без складної навчальної бібліотеки, наприклад, . Я вважаю, що для початківця Data Scientist-а важливо розуміння внутрішньої структури нейронної мережі.

Ця стаття містить те, що я засвоїв, і, сподіваюся, вона буде корисною і для вас! Інші корисні статті на тему:

Що таке нейронна мережа?

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

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

вхідний шар, x
довільна кількість прихованих шарів
вихідний шар, ŷ
набір вагі зміщеньміж кожним шаром W і b
вибір функції активаціїдля кожного прихованого шару σ ; у цій роботі ми будемо використовувати функцію активації Sigmoid

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

Створення класу Neural Network на Python виглядає просто:

Навчання нейронної мережі

Вихід ŷ простий двошарової нейронної мережі:

У наведеному вище рівнянні, ваги W та зміщення b є єдиними змінними, що впливають на вихід ŷ.

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

Кожна ітерація навчального процесу складається з наступних кроків

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

Послідовний графік нижче ілюструє процес:

Пряме поширення

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

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

Проте потрібен спосіб оцінити «добротність» наших прогнозів, тобто, наскільки далекі наші прогнози). Функція втратисаме дозволяє нам це зробити.

Функція втрати

Є багато доступних функцій втрат, і характер нашої проблеми повинен диктувати вибір функції втрати. У цій роботі ми будемо використовувати суму квадратів помилокяк функція втрати.

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

Мета навчання - знайти набір ваг і зсувів, який мінімізує функцію втрати.

Зворотне поширення

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

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

Нагадаємо з аналізу, що похідна функції - це тангенс кута нахилу функції.

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

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

Фух! Це було громіздко, але дозволило отримати те, що нам потрібно-похідну (нахил) функції втрат по відношенню до ваг. Тепер ми можемо належним чином регулювати ваги.

Додамо функцію backpropagation (зворотного розповсюдження) у наш код на Python-і:

Перевірка роботи нейромережі

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

Ідеальний набір ваг

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

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

Подивимося на остаточне передбачення (виведення) з нейронної мережі після 1500 ітерацій.

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

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

Фінальні роздуми

Я багато чому навчився у процесі написання з нуля своєї власної нейронної мережі. Хоча бібліотеки глибинного навчання, такі як TensorFlow і Keras, допускають створення глибоких мереж без повного розуміння внутрішньої роботи нейронної мережі, я знаходжу, що початківцям Data Scientistам корисно отримати більш глибоке їх розуміння.

Я інвестував багато свого особистого часу у цю роботу, і я сподіваюся, що вона буде корисною для вас!

Ми зараз переживаємо справжній бум нейронних мереж. Їх застосовують для розпізнання, локалізації та обробки зображень. Нейронні мережі вже зараз вміють багато чого не доступного людині. Потрібно ж і самим вклинюватись у цю справу! Розглянемо нейтронну мережу, яка буде розпізнавати числа на вхідному зображенні. Все дуже просто: лише один шар та функція активації. Це не дозволить нам розпізнати абсолютно всі тестові зображення, але ми впораємося з переважною більшістю. Як дані будемо використовувати відому у світі розпізнання чисел добірку даних MNIST.

Для роботи з нею в Python є бібліотека python-mnist. Щоб встановити:

Pip install python-mnist

Тепер можемо завантажити дані

З mnist import MNIST mndata = MNIST("/path_to_mnist_data_folder/") tr_images, tr_labels = mndata.load_training() test_images, test_labels = mndata.load_testing()

Архіви з даними необхідно завантажити самостійно, а програмі вказати шлях до каталогу з ними. Тепер змінні tr_images та test_images містять зображення для тренування мережі та тестування відповідно. А змінні tr_labels і test_labels – мітки з правильною класифікацією (тобто цифри із зображень). Усі зображення мають розмір 28х28. Задамо змінну з розміром.

Img_shape = (28, 28)

Перетворимо всі дані на масиви numpy і нормалізуємо їх (приведемо до розміру від -1 до 1). Це збільшить точність обчислень.

Import numpy np for i in range(0, len(test_images)): test_images[i] = np.array(test_images[i]) / 255 for i in range(0, len(tr_images)): tr_images[i] = np.array(tr_images[i]) / 255

Зазначу, що хоч і зображення прийнято представляти як двомірного масиву ми використовуватимемо одномірний, це простіше для обчислень. Тепер потрібно зрозуміти "що ж таке нейронна мережа"! А це просто рівняння із великою кількістю коефіцієнтів. Ми маємо на вході масив із 28*28=784 елементів та ще по 784 ваги для визначення кожної цифри. У процесі роботи нейронної мережі необхідно перемножити значення входів на ваги. Скласти отримані дані та додати зсув. Отриманий результат подати на активацію. У нашому випадку це буде Relu. Ця функція дорівнює нулю всім негативних аргументів і аргументу всім позитивних.

Є ще багато функцій активації! Але це ж найпростіша нейронна мережа! Визначимо цю функцію за допомогою numpy

Def relu(x): return np.maximum(x, 0)

Тепер, щоб обчислити зображення на картинці, потрібно прорахувати результат для 10 наборів коефіцієнтів.

Def nn_calculate(img): resp = list(range(0, 10)) for i in range(0,10): r = w[:, i] * img r = relu(np.sum(r) + b[ i]) resp[i] = r return np.argmax(resp)

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

У цьому випадку 7. Ось і все! Але ні... Адже треба ці коефіцієнти десь взяти. Потрібно навчити нашу нейронну мережу. Для цього застосовують метод зворотного розповсюдження помилки. Його суть у тому, щоб розрахувати виходи мережі, порівняти їх з правильними, а потім відібрати від коефіцієнтів числа необхідні, щоб результат був правильним. Потрібно пам'ятати, що для того, щоб обчислити ці значення, потрібна похідна функції активації. У разі вона дорівнює нулю всім негативних чисел і 1 всім позитивних. Визначимо коефіцієнти випадковим чином.

W = (2*np.random.rand(10, 784) - 1) / 10 b = (2*np.random.rand(10) - 1) / 10 for n in range(len(tr_images)): img = tr_images[n] cls = tr_labels[n] #forward propagation resp = np.zeros(10, dtype=np.float32) for i in range(0,10): r = w[i] * img r = relu( np.sum(r) + b[i]) resp[i] = r resp_cls = np.argmax(resp) resp = np.zeros(10, dtype=np.float32) resp = 1.0 #back propagation true_resp = np. zeros(10, dtype=np.float32) true_resp = 1.0 error = resp - true_resp delta = error * ((resp >= 0) * np.ones(10)) for i in range(0,10): w[i ] -= np.dot(img, delta[i]) b[i] -= delta[i]

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

Перевіримо точність роботи:

Def nn_calculate(img): resp = list(range(0, 10)) for i in range(0,10): r = w[i] * img r = np.maximum(np.sum(r) + b[ i], 0) #relu resp[i] = r return np.argmax(resp) total = len(test_images) valid = 0 invalid = for i in range(0, total): img = test_images[i] predicted = nn_calculate (img) true = test_labels[i] if predicted == true: valid = valid + 1 else: invalid.append(("image":img, "predicted":predicted, "true":true)) print("accuracy ()".format(valid/total))

У мене вийшло 88%. Не так круто, але дуже цікаво!

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

Стадія 1. Розчарування

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

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

Стадія 2. Прийняття

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

Стадія 3. Розвиток

Тепер переходимо безпосередньо до теорії ІІ. Їх умовно можна розділити на 3 категорії:

Слабкий ІІ - боти, яких ми бачимо в комп'ютерних іграх, або прості підручні помічники, як Siri. Вони або виконують вузькоспеціалізовані завдання або є незначним комплексом таких, а будь-яка непередбачуваність взаємодії ставить їх у глухий кут.
Сильний ІІ – це машини, інтелект яких можна порівняти з людським мозком. На сьогоднішній день немає реальних представників цього класу, але комп'ютери, як Watson дуже близькі до досягнення цієї мети.
Досконалі ІІ – майбутнє, машинний мозок, який перевершить наші можливості. Саме про небезпеку таких розробок попереджають Стівен Хоккінг, Елон Маск та кінофраншиза «Термінатор».

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

До речі, якщо ви все-таки взялися за мову Python, створити досить простого бота можна, звернувшись до цього докладного мануалу. Для інших мов, таких як C++ або Java, вам також не важко знайти покрокові матеріали. Відчувши, що за створенням ІІ немає нічого надприродного, ви зможете сміливо закрити браузер і розпочати особисті експерименти.

Стадія 4. Азарт

Тепер, коли справа зрушила з мертвої точки, вам, напевно, хочеться створити щось серйозніше. У цьому вам допоможе низка наступних ресурсів:

Стадія 5. Робота

Тепер, коли ви вже цілком ясно уявляєте, як ІІ створювати і чим при цьому користуватися, настав час виводити свої знання на новий рівень. По-перше, для цього знадобиться вивчення дисципліни, яке зветься «Машинне навчання». По-друге, необхідно навчитися працювати з відповідними бібліотеками вибраної мови програмування. Для Python, що розглядається, це Scikit-learn, NLTK, SciPy, PyBrain і Numpy. По-третє, у розвитку нікуди не обійтися. Ну і найголовніше, ви тепер зможете читати літературу про ІІ з повним розумінням справи:

Artificial Intelligence for Games, Ян Міллінгтон;
Game Programming Patterns, Роберт Найсторм;
AI Algorithms, Data Structures, and Idioms in Prolog, Lisp, and Java, Джордж Люгер, Вільям Стбалфілд;
Computational Cognitive Neuroscience, Ренделл О'Рейлі, Юко Мунаката;
Artificial Intelligence: A Modern Approach, Стюарт Рассел, Пітер Норвіг.

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

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

Матеріал розрахований на людей, які не знайомі з мовами програмування.

Спочатку Python треба встановити. Потім потрібно встановити зручне середовище для написання програм на Python. Цим двом крокам присвячено на порталі.

Якщо все встановлено та настроєно, можна починати.

Змінні

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

Наприклад, ми хочемо створити змінну x , яка повинна зберігати значення 10. У Python код створення цієї змінної буде виглядати так:

Зліва ми оголошуємозмінну з ім'ям x. Це рівнозначно тому, що ми приклеїли на коробку іменний ярлик. Далі йде знак рівності та число 10. Знак рівності тут відіграє незвичайну роль. Він означає, що «x дорівнює 10». Рівність у разі кладе число 10 в коробку. Якщо говорити коректніше, то ми привласнюємозмінною х число 10.

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

Можна просто вивести значення цієї змінної на екран:

X=10 print(x)

Напис print(x) є викликом функції. Їх ми розглядатимемо далі. Зараз важливим є те, що ця функція виводить у консоль те, що розташоване між дужками. Між дужками у нас стоїть x. Раніше ми надали x значення 10. Саме 10 і виводиться в консолі, якщо ви виконаєте програму вище.

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

X = 2 y = 3 # Додавання z = x + y print(z) # 5 # Різниця z = x - y print(z) # -1 # Твір z = x * y print(z) # 6 # Поділ z = x / y print(z) # 0.66666... # Зведення в ступінь z = x ** y print(z) # 8

У коді вище ми спочатку створюємо дві змінні, що містять 2 і 3. Потім створюємо змінну z, яка зберігає результат операції з x і y виводить результати в консоль. У цьому прикладі добре видно, що змінна може змінювати своє значення під час виконання програми. Так, наша змінна z змінює своє значення аж 5 разів.

Функції

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

"Це дуже важливий текст!"
«Цей текст не можна не прочитати»
«Помилка у верхньому рядку допущена спеціально»
"Привіт і пока"
«Кінець»

Наш код буде виглядати так:

X = 10 y = x + 8 - 2 print("Це дуже важливий текст!") print("Цей текст не можна не прочитати") print("Помилка у верхньому рядку допущена спеціально") print("Привіт і поки") print ("Кінець") z = x + y print("Це дуже важливий текст!") print("Цей текст не можна не прочитати") print("Помилка у верхньому рядку допущена спеціально") print("Привіт і поки") print ("Кінець") test = z print("Це дуже важливий текст!") print("Цей текст не можна не прочитати") print("Помилка у верхньому рядку допущена спеціально") print("Привіт і поки") print(" Кінець")

Виглядає це дуже надмірно і незручно. Крім того, у другому рядку припущено помилку. Її можна виправити, але виправляти доведеться відразу в трьох місцях. А якщо у нас у проекті ці п'ять рядків викликаються 1000 разів? І все у різних місцях та файлах?

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

Функція- окремий блок коду, який можна викликати на ім'я.

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

Def print_5_lines(): print("Це дуже важливий текст!") print("Цей текст не можна не прочитати") print("Помилка у верхньому рядку допущена спеціально") print("Привіт і поки") print("Кінець")

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

# Визначаємо функцію def print_5_lines(): print("Це дуже важливий текст!") print("Цей текст не можна не прочитати") print("Помилка у верхньому рядку допущена спеціально") print("Привіт і поки") print(" Кінець") # Код нашого проекту x = 10 y = x + 8 - 2 print_5_lines() z = x + y print_5_lines() test = z print_5_lines()

Зручно, чи не так? Ми серйозно підвищили читання коду. Крім того, функції хороші ще й тим, що якщо ви хочете змінити якусь з дій, достатньо підправити саму функцію. Ця зміна буде працювати у всіх місцях, де викликається ваша функція. Тобто ми можемо виправити помилку в другому рядку тексту («не можна» > «не можна») в тілі функції. Правильний варіант автоматично буде викликатись у всіх місцях нашого проекту.

Опції з параметрами

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

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

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

Def sum(a, b): result = a + b return result

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

Параметри можна використовувати всередині функції як перемінні. На другому рядку ми створюємо змінну result, яка дорівнює сумі параметрів a і b. На третьому рядку ми повертаємо значення змінної result.

Тепер, надалі коді ми можемо писати щось на кшталт:

New = sum(2, 3) print(new)

Ми викликаємо функцію sum і по черзі передаємо їй два аргументи: 2 і 3. 2 стає значенням змінної a, а 3 стає значенням змінної b. Наша функція повертає значення (суму 2 та 3), і ми використовуємо його для створення нової змінної new .

Запам'ятайте. У коді вище числа 2 і 3 – аргументи функції sum. А в самій функції sum змінні a та b - параметри. Інакше кажучи, змінні, які передаємо функції під час її виклику називаються аргументами. А от усередині функції ці передані змінні називаються параметрами. По суті, це дві назви однієї й тієї ж, але плутати їх не варто.

Розглянемо ще один приклад. Створимо функцію square(a), яка приймає якесь одне число і зводить його в квадрат:

Def square(a): return a * a

Наша функція складається лише з одного рядка. Вона відразу повертає результат множення параметра a на a.

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

Масиви

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

Array =

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

Array = print(array)

У консолі ви побачите число 89. Але чому 89, а чи не 1? Вся справа в тому, що Python, як і в багатьох інших мовах програмування, нумерація масивів починається з 0. Тому array дає нам другийелемент масиву, а чи не перший. Для виклику першого треба було написати array.

Розмір масиву

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

Array = print(len(array))

У консолі виведеться число 4.

Умови та цикли

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

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

У першій ситуації допомагають умови, а у другій – цикли.

Умови

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

У Python умови можна записувати з допомогою конструкції if: ... else: ... . Нехай ми маємо деяку змінну x = 10 . Якщо x менше 10, то ми хочемо розділити x на 2. Якщо ж x більше або дорівнює 10, ми хочемо створити іншу змінну new , яка дорівнює сумі x і числа 100. Ось так буде виглядати код:

X = 10 if(x< 10): x = x / 2 print(x) else: new = x + 100 print(new)

Після створення змінної x ми починаємо записувати нашу умову.

Починається все із ключового слова if (у перекладі з англійської «якщо»). У дужках ми вказуємо вираз, що перевіряється. В даному випадку ми перевіряємо, чи дійсно наша змінна x менша за 10. Якщо вона дійсно менша за 10, то ми ділимо її на 2 і виводить результат у консоль.

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

Якщо вона більша або дорівнює 10, то ми створюємо нову змінну new, яка дорівнює x + 100 і теж виводимо її в консоль.

Цикли

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

Print("Квадрат 1 дорівнює" + str(1**2)) print("Квадрат 2 дорівнює" + str(2**2)) print("Квадрат 3 дорівнює" + str(3**2)) print( "Квадрат 4 дорівнює" + str(4**2)) print("Квадрат 5 дорівнює" + str(5**2)) print("Квадрат 6 дорівнює" + str(6**2)) print("Квадрат 7 дорівнює " + str(7**2)) print("Квадрат 8 дорівнює " + str(8**2)) print("Квадрат 9 дорівнює " + str(9**2)) print("Квадрат 10 дорівнює + str(10**2))

Нехай вас не дивує той факт, що ми складаємо рядки. "початок рядка" + "кінець" в Python означає просто з'єднання рядків: "початок рядка". Так само і вище ми складаємо рядок «Квадрат x дорівнює» і перетворений за допомогою функції str(x**2) результат зведення числа у 2 ступінь.

Виглядає код вище надмірно. А якщо нам треба вивести квадрати перших 100 чисел? Замучимося виводити…

Саме для таких випадків і є цикли. Всього в Python 2 види циклів: while і for. Розберемося з ними по черзі.

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

X = 1 while x<= 100: print("Квадрат числа " + str(x) + " равен " + str(x**2)) x = x + 1

Спочатку ми створюємо змінну і привласнюємо їй число 1. Потім створюємо цикл while і перевіряємо, чи менше (або дорівнює) 100 наш x . Якщо менше (або дорівнює) то ми виконуємо дві дії:

Виводимо квадрат x
Збільшуємо x на 1

Після другої команди програма повертається до умови. Якщо умова знову істинна, ми знову виконуємо ці дві дії. І так до тих пір, поки x не стане рівним 101. Тоді умова поверне брехню і цикл більше не виконуватиметься.

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

For x in range(1,101): print("Квадрат числа" + str(x) + " дорівнює " + str(x**2))

Розберемо перший рядок. Ми використовуємо ключове слово для створення циклу. Далі ми вказуємо, що хочемо повторити певні дії для всіх x в діапазоні від 1 до 100. Функція range(1,101) створює масив зі 100 чисел, починаючи з 1 до 100.

Ось ще приклад перебору масиву за допомогою циклу:

For i in : print(i * 2)

Код вище виводить 4 цифри: 2, 20, 200 і 2000. Тут видно, як бере кожен елемент масиву і виконує набір дій. Потім бере наступний елемент і повторює той самий набір дій. І так поки що елементи в масиві не закінчаться.

Класи та об'єкти

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

Вона має деякі параметри. До них відносяться колір вовни, колір очей, її прізвисько. Але це ще не все. Крім параметрів, кішка може виконувати різні дії: муркотіти, шипіти і дряпатися.

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

Важливо розуміти різницю між класом та об'єктом. Клас - схемаяка описує об'єкт. Об'єкт – її матеріальне втілення. Клас кішки - опис її властивостей та дій. Об'єкт кішки і є реальною кішкою. Може бути багато різних реальних кішок – багато об'єктів-кішок. Але клас кішки лише один. Гарною демонстрацією служить картинка нижче:

Класи

Для створення класу (схеми нашої кішки) треба написати ключове слово class і вказати ім'я цього класу:

Class Cat:

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

Метод- Функція, визначена всередині класу.

Словесно ми вже описали методи кішки вище: муркотіти, шипіти, дряпатися. Тепер зробимо це мовою Python.

# Клас кішки class Cat: # Муркати def purr(self): print("Муррр!") # Шипіти def hiss(self): print("Кшшш!") # Дряпатися def scrabble(self): print("Дряп-царап !")

Отак усе просто! Ми взяли та визначили три звичайні функції, але тільки всередині класу.

Для того, щоб розібратися з незрозумілим параметром self, додамо ще один метод нашої кішки. Цей метод разом викликатиме всі три вже створені методи.

# Клас кішки class Cat: # Муркати def purr(self): print("Муррр!") # Шипіти def hiss(self): print("Кшшш!") # Дряпатися def scrabble(self): print("Дряп-царап !") # Всі разом def all_in_one(self): self.purr() self.hiss() self.scrabble()

Як бачите, обов'язковий для будь-якого методу параметр self дозволяє нам звертатися до методів та змінних самого класу! Без цього аргументу виконати подібні дії ми б не змогли.

Давайте тепер задамо властивості нашої кішки (колір шерсті, колір очей, прізвисько). Як це зробити? У будь-якому класі можна визначити функцію __init__() . Ця функція завжди викликається, коли створюємо реальний об'єкт нашого класу.

У виділеному методі __init__() ми задаємо змінні нашої кішки. Як ми це робимо? Спочатку ми передаємо в цей метод 3 аргументи, що відповідають за колір вовни, колір очей та прізвисько. Потім, ми використовуємо параметр self для того, щоб при створенні об'єкта відразу задати нашій кішки 3 описаних вище атрибутів.

Що означає цей рядок?

Self.wool_color = wool_color

У лівій частині ми створюємо атрибут для нашої кішки з ім'ям wool_color, а далі ми присвоюємо цьому атрибуту значення, яке міститься у параметрі wool_color, який ми передали у функцію __init__(). Як бачите, рядок вище не відрізняється від звичайного створення змінної. Тільки приставка self вказує на те, що ця змінна відноситься до класу Cat.

Атрибут- Змінна, яка відноситься до якогось класу.

Отже, ми створили готовий клас кішки. Ось його код:

# Клас кішки class Cat: # Дії, які треба виконувати при створенні об'єкта "Кішка" def __init__(self, wool_color, eyes_color, name): self.wool_color = wool_color self.eyes_color = eyes_color self): print("Муррр!") # Шипіти def hiss(self): print("Кшшш!") # Дряпатися def scrabble(self): print("Дряп-царап!") # Всі разом def all_in_one(self) : self.purr() self.hiss() self.scrabble()

Об'єкти

Ми створили схему кішки. Тепер давайте створимо за цією схемою реальний об'єкт кішки:

My_cat = Cat("чорний", "зелені", "Зося")

У рядку вище ми створюємо змінну my_cat, а потім привласнюємо їй об'єкт класу Cat. Виглядає цей як виклик деякої функції Cat(...) . Насправді, так і є. Цим записом ми викликаємо метод __init__() класу Cat. Функція __init__() у нашому класі приймає 4 аргументи: сам об'єкт класу self, який вказувати не треба, а також ще 3 різні аргументи, які потім стають атрибутами нашої кішки.

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

Print(my_cat.wool_color) print(my_cat.eyes_color) print(my_cat.name)

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

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

My_cat.name = "Нюша"

Тепер, якщо ви знову виведете в консоль ім'я кішки, замість Зосі побачите Нюшу.

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

My_cat.purr()

Виконання цієї команди виведе у консоль текст "Муррр!". Як бачите, звертатися до методів об'єкта так само просто, як і звертатися до його атрибутів.

Модулі

Будь-який файл із розширенням.py є модулем. Навіть той, у якому ви відпрацьовуєте цю статтю. Навіщо вони потрібні? Для зручності. Дуже багато людей створюють файли з корисними функціями та класами. Інші програмісти підключають ці сторонні модулі і можуть використовувати всі певні функції і класи, тим самим спрощуючи собі роботу.

Наприклад, вам не потрібно витрачати час та писати свої функції для роботи з матрицями. Достатньо підключити модуль numpy та використовувати його функції та класи.

На даний момент інші Python програмісти вже написали понад 110 000 різноманітних модулів. Згадуваний вище модуль numpy дозволяє швидко та зручно працювати з матрицями та багатовимірними масивами. Модуль math надає безліч методів для роботи з числами: синуси, косинуси, переведення градусів у радіани та інше.

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

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

Якщо ви хочете використовувати модуль, який не входить до стандартного набору, вам потрібно встановити його. Для встановлення модуля відкрийте командний рядок (Win + R, потім введіть у поле «cmd») і введіть у нього команду:

Pip install [назва_модуля]

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

Підключення та використання модуля

Сторонній модуль підключається дуже легко. Треба написати лише один короткий рядок коду:

Import [назва_модуля]

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

Import math

Як звернутися до функції модуля? Треба написати назву модуля, потім поставити крапку та написати назву функції/класу. Наприклад, факторіал 10 знаходиться так:

Math.factorial(10)

Тобто ми звернулися до функції factorial(a), яка визначена всередині модуля math. Це зручно, адже нам не потрібно витрачати час і створювати вручну функцію, яка вважає факторіал числа. Можна підключити модуль і виконати необхідну дію.