Язык программирования Python с нуля.

Язык программирования Python с нуля.

Dark Ne
Зарабатываем до 25.000 рублей от Тинькофф
ФАРМИМ ХАЛЯВУ - Канал с разной халявой в интернете

ПОЛЕТЕЛИ

Данная статья написана только для образовательных целей. Мы никого ни к чему не призываем, только в целях ознакомления! Автор не несёт ответственности за ваши действия

Ес­ли ты дума­ешь, что хакеру прог­рамми­рова­ние не нуж­но, то глу­боко оши­баешь­ся! Да, мож­но кач­нуть Kali Linux и юзать готовые прог­рам­мки, копипас­тить код с форумов и всле­пую качать скрип­ты с GitHub. Но потолок тво­их уме­ний, пока ты не научишь­ся писать и понимать код, будет низ­ким. В этой статье я попыта­юсь в дос­тупной фор­ме научить тебя осно­вам прог­рамми­рова­ния. Начина­ем с абсо­лют­ного нуля!

Ес­ли у тебя на ком­пе есть сов­ремен­ный дис­три­бутив Linux, то в него уже вхо­дит Python 3, а писать пер­вые прог­раммы будет удоб­но в IDLE — прос­том редак­торе кода, который при­лага­ется к Python. В Ubuntu, что­бы уста­новить его, набери в кон­соли

sudo apt-get install idle3

В Windows при уста­нов­ке Python обя­затель­но отметь на пер­вом экра­не уста­нов­щика галоч­ку Add to Path, что­бы мож­но было запус­кать python3 из коман­дной стро­ки в любом удоб­ном мес­те.

За­пус­тив IDLE, зай­ди в Options → Configure IDLE, перей­ди на вклад­ку General и пос­тавь галоч­ку на пун­кте Open Edit Window, наж­ми ОK и переза­пус­ти IDLE. Теперь мож­но писать прог­раммы, сох­ранять их и запус­кать кла­вишей F5. Ну что, пог­нали?

 

ПЕРЕМЕННЫЕ

В любом язы­ке прог­рамми­рова­ния есть такая шту­ка, как перемен­ные. Это как в школь­ной алгебре: вот перемен­ная a = 1, вот перемен­ная b = 2. То есть это такие абс­трак­тные шту­ки, внут­ри них лежит зна­чение, которое может менять­ся — нап­ример, ког­да ты пишешь пос­ле перемен­ной знак рав­но и какое‑то новое зна­чение.


a = 2

a = a + 2

print(a)

Ну, то, что print(a) — это коман­да, которая печата­ет на экра­не текущее зна­чение перемен­ной, ты уже понял. Ты написал пос­ле зна­ка рав­но сно­ва саму перемен­ную + 2, то есть сна­чала в перемен­ной было зна­чение 2, потом к это­му зна­чению при­бави­ли еще 2. На экра­не гор­до кра­сует­ся 4. Поз­драв­ляю, два и два сло­жили!

А если изна­чаль­но неиз­вес­тно, какие чис­ла надо скла­дывать? Тог­да приш­лось бы спер­ва поп­росить юзе­ра ввес­ти их в кон­соли и нажать Enter. Давай так и сде­лаем:

a = input('Введи, сколько у тебя литров пива: ')

b = input('Сколько пива принес друг: ')

c = int(a) + int(b)

print('На двоих у вас: ' + str(c) + ' литров пива')

Внут­ри ско­бочек у input ты пишешь пояс­нение для юзе­ра, что кон­крет­но его про­сят ввес­ти. Но вот беда, по умол­чанию все, что вво­дит­ся через input, счи­тает­ся не чис­лом, а стро­кой, поэто­му, преж­де чем скла­дывать количес­тво лит­ров пива, нуж­но сна­чала пре­обра­зовать вве­ден­ные стро­ки в чис­ла с помощью фун­кции int().

Окей, пре­обра­зовал стро­ки в чис­ла, положил их в перемен­ную c, а даль­ше‑то что за треш внут­ри ско­бок у print? Тут скла­дыва­ются стро­ки (стро­ки всег­да пишут­ся внут­ри кавычек), пояс­няющие, что имен­но выводит­ся на экран, а резуль­тат сло­жения переда­ется в фун­кцию print().

Что­бы стро­ки без­болез­ненно сло­жились с перемен­ной c, в которой лежит чис­ло, надо пре­обра­зовать его в стро­ку фун­кци­ей str() — так же как мы прев­ращали стро­ки в чис­ла, толь­ко наобо­рот.

Во­обще, типов перемен­ных мно­го, но суть ты уло­вил — что­бы про­изво­дить с перемен­ными какие‑то дей­ствия, нуж­но их сна­чала при­вес­ти к одно­му типу — к стро­ково­му, или к чис­ловому, или еще к какому‑нибудь. Если с этим не замора­чивать­ся, Python сло­жит не чис­ла, а стро­ки и вве­ден­ные 2 и 3 лит­ра пива в сум­ме дадут не 5, а целых 23. Хорошо бы так было в реаль­нос­ти!

Вот еще при­мер­чик, рас­счи­тыва­ющий, сколь­ко тебе еще пить пиво, исхо­дя из сред­ней про­дол­житель­нос­ти жиз­ни в Рос­сии:

a = input('Введи, сколько тебе лет: ')

b = 73 - int(a)

print('Осталось примерно: ' + str(b) + " лет")

Здесь мы вызыва­ем фун­кцию input(), что­бы получить зна­чение, вычита­ем его из 73 (сред­няя про­дол­житель­ность жиз­ни рос­сияни­на), не забыв прев­ратить стро­ку в чис­ло, а потом печата­ем резуль­тат, прев­ратив чис­ло обратно в стро­ку и сло­жив с дру­гими стро­ками.

Итак, ты узнал, что такое целочис­ленные и стро­ковые перемен­ные, что эти типы мож­но пре­обра­зовы­вать друг в дру­га коман­дами int() и str(). К тому же теперь ты уме­ешь получать перемен­ные от поль­зовате­ля с помощью фун­кции input('Введите что-то') и печатать резуль­таты с помощью фун­кции print().

 

УСЛОВИЯ

В осно­ве любой прог­раммы лежат усло­вия. В зависи­мос­ти от того, выпол­няют­ся они или не выпол­няют­ся, прог­рамма может пой­ти по одно­му или дру­гому пути. Пред­ставь, ты едешь на машине и смот­ришь на часы: если уже есть десять вечера, то повора­чива­ешь домой, если нет, то мож­но заехать в гос­ти. Точ­но так же работа­ет и прог­рамма: про­веря­ет какое‑то зна­чение и сво­рачи­вает туда или сюда и выпол­няет соот­ветс­тву­ющий кусочек кода.


beer = input('Введите Yes, если пиво есть, и No, если пива нет: ')

if beer.lower() == 'yes':

    result = 'Ты взломаешь Пентагон'

else:

    result = 'Ты сломаешь свой мозг'

print(result)

На англий­ском if зна­чит «если», а else — «ина­че» или «в про­тив­ном слу­чае». В строч­ке пос­ле if идет усло­вие, которое мы про­веря­ем. Если оно вер­но, выпол­няет­ся пер­вый блок кода (он отде­лен четырь­мя про­бела­ми вна­чале). Если невер­но, то тот, что пос­ле else:.

Еще один важ­ный момент здесь — это знак равенс­тва в усло­вии. Он пишет­ся как двой­ное «рав­но» (==) и этим отли­чает­ся от прис­воения — оди­нар­ного «рав­но».

Фун­кция lower(), преж­де чем срав­нивать усло­вие, дела­ет все бук­вы в стро­ке малень­кими, потому что глу­пый юзер может ввес­ти сло­во YES с горящим Caps Lock, и это надо пре­дус­мотреть заранее.


Да­вай поп­робу­ем сде­лать усло­вие для про­вер­ки логина и пароля, исполь­зуя опе­ратор И, который пишет­ся как and. Он нужен для того, что­бы про­верить одновре­мен­но выпол­нение пер­вого и вто­рого усло­вия.

myname = input('Введите логин: ')

mypass = input('Введите пароль: ')

if myname == 'xakep' and mypass == 'superpassword123':

    result = 'Добро пожаловать, о великий хакер!'

else:

    result = 'Ты кто такой, давай до свидания...'

print(result)

Да­вай соз­дадим еще более слож­ное усло­вие, исполь­зовав опе­ратор or, который перево­дит­ся как ИЛИ.

myname = input('Введите логин: ')

mypass = input('Введите пароль: ')

if(myname == 'ivan' and mypass == 'superpassword123') or (myname == 'marina' and mypass == 'marinka93'):

    result = 'Привет, ' + myname + '. Добро пожаловать!'

else:

    result = 'Ты кто такой, давай до свидания...'

print(result)

Здесь исполь­зуют­ся скоб­ки — Python не тре­бует ско­бок для прос­тых усло­вий, но для слож­ных они при­меня­ются, что­бы явно опре­делить порядок дей­ствий. Прог­рамма при­ветс­тву­ет толь­ко двух поль­зовате­лей, ivan или marina. То есть сна­чала про­веря­ется, не сов­пали ли логин и пароль с логином и паролем Ива­на, а потом пос­ле опе­рато­ра or про­веря­ется то же для Марины.

Вот еще при­мер, в нем исполь­зует­ся elif, который озна­чает что‑то вро­де ИНА­ЧЕ‑ЕСЛИ. Это при­меня­ется для задания нес­коль­ких бло­ков команд: в слу­чае, если одно усло­вие не выпол­няет­ся, с помощью ELIF про­веря­ется сле­дующее и так далее.

v = int(input('Введи, сколько тебе лет: '))

if v < 18:

    print('Привет, юный хацкер')

elif v < 30:

    print('Превед, олдскул')

elif v < 65:

    print('Решил пересесть с ассемблера на Python?')

elif v < 100:

    print('На пенсии — самое время покодить')

elif v < 100000:

    print('Клан бессмертных приветствует тебя!')

В качес­тве усло­вий могут выс­тупать раз­личные опе­рато­ры срав­нения:

  • a == 9 (a рав­но 9)
  • a != 7 (a не рав­но 7)
  • a > 5 (a боль­ше 5)
  • a < 5 (a мень­ше 5)
  • a >= 3 (a боль­ше или рав­но 3)
  • a <= 8 (a мень­ше или рав­но 8)

Ты так­же можешь инверти­ровать истинность усло­вия (true) на лож­ность (false) и обратно с помощью сло­ва not.

beer = input('Введи Yes, если пиво есть, и No, если пива нет: ')

if beer.lower() == 'yes':

    print('Пива нет!')

if not beer.lower() == 'yes':

    print('Ура, пиво еще есть!')

Нап­ример, нуж­но, что­бы человек ввел чис­ло не (NOT) мень­ше 5.

x = int(input('Введи, сколько у вас литров пива: '))

if not (x < 5):

    print('Все нормально, можно начинать взлом')

else:

    print('Пива недостаточно.')

 

СПИСКИ

Обыч­ные перемен­ные хороши для хра­нения оди­ноч­ных зна­чений, будь то стро­ка или чис­ло. Но иног­да нуж­но хра­нить груп­пу перемен­ных. Здесь на помощь при­ходят спис­ки.


Нап­ример, спи­сок может быть таким:

a = [67,5,90,20,30]

Каж­дый эле­мент спис­ка име­ет свой индекс. Что­бы получить одно из зна­чений спис­ка, мож­но обра­тить­ся к его поряд­ковому номеру. Нумера­ция в спис­ках идет не с еди­ницы, а с нуля, то есть 0, 1, 2, 3, 4...

Ко­ман­да print(a[2]) напеча­тает чис­ло 90 — тре­тий эле­мент (нумера­ция‑то с нуля!) в спис­ке, который был объ­явлен выше. Эле­мен­тов в спис­ках может быть сколь­ко угод­но.

Так­же мож­но сде­лать спи­сок строк:

b = ['Маша', 'Ваня', 'Лена', 'Марина', 'Арнольд']

Тог­да print(b[1]) напеча­тает строч­ку Ваня.

Ты можешь добавить в сущес­тву­ющий спи­сок новое зна­чение с помощью метода append:

b.append('Дима')

Те­перь спи­сок выг­лядит так:

b = ['Маша', 'Ваня', 'Лена', 'Марина', 'Арнольд', 'Дима']

Ес­ли надо обра­тить­ся к какому‑то эле­мен­ту спис­ка, счи­тая от кон­ца это­го спис­ка, мож­но писать отри­цатель­ные чис­ла. Нап­ример, пос­ледний эле­мент спис­ка име­ет индекс -1, а print(b[-1]) напеча­тает Дима.

Лю­бой спи­сок мож­но отсорти­ровать по воз­раста­нию или по алфа­виту.

a = [67,5,90,20,30]

a.sort()

Пос­ле выпол­нения фун­кции a.sort() спи­сок при­мет такой вид: [5,20,30,67,90].

Те­перь нем­ного о сре­зах. Срез — это как бы получе­ние какой‑то час­ти спис­ка, которая, в свою оче­редь, тоже явля­ется спис­ком. Сре­зы зада­ются таким обра­зом:

список[x:y:z]

Здесь x — номер эле­мен­та, с которо­го берет­ся срез, y — пос­ледний эле­мент сре­за, z — интервал, через который мы берем эле­мен­ты (необя­затель­ное зна­чение).

По­луча­ем срез эле­мен­тов спис­ка b с 1 и до 3 (4 не вклю­чает­ся в срез):

print(b[1:4])

По­луча­ем срез эле­мен­тов спис­ка b с 2 и до кон­ца:

print(b[2:])

По­луча­ем каж­дый вто­рой эле­мент спис­ка:

print(b[::2])

Ме­няем порядок эле­мен­тов спис­ка на обратный:

print(b[::-1])

Кста­ти, обыч­ные стро­ки тоже под­держи­вают сре­зы, их резуль­тат тоже будет стро­кой. Нап­ример:

s = 'Hello world'

print(s[:5])

На экран выведет­ся Hello, потому что мы напеча­тали пер­вые пять сим­волов стро­ки.

Эле­мен­тами спис­ка могут быть дру­гие спис­ки. Что­бы обра­тить­ся к эле­мен­там спис­ка внут­ри спис­ка, исполь­зуй еще одни квад­ратные скоб­ки:

a = [[1, 2, 3], [44, 45, 46]]

Та­кой спи­сок из спис­ков называ­ется дву­мер­ным и напоми­нает таб­лицу. Нап­ример, что­бы получить пер­вое чис­ло во вто­рой стро­ке (индексы 0 и 1, пос­коль­ку нумера­ция с нуля), нуж­но написать:

print(a[1][0])

Ре­зуль­тат будет 44.

Спи­сок — это изме­няемая пос­ледова­тель­ность. Это зна­чит, что если ты сот­воришь какие‑то дей­ствия над спис­ком, то тебе не при­дет­ся его пере­опре­делять и заново сох­ранять в перемен­ную. А вот стро­ка — это неиз­меня­емая пос­ледова­тель­ность. Если ты с ней что‑то сде­лаешь, то при­дет­ся куда‑то помес­тить получен­ное новое зна­чение.

Еще один неиз­меня­емый тип дан­ных — это кор­теж. Это тот же спи­сок, но ты не можешь его изме­нять. Так он занима­ет мень­ше памяти. Объ­явить кор­теж мож­но с помощью круг­лых ско­бок:

a = (1, 2, 3, 4)

Мно­жес­тво — еще одна пос­ледова­тель­ность эле­мен­тов, каж­дый из которых не име­ет сво­его индекса. То есть эле­мен­ты не упо­рядо­чены и ты не можешь обра­тить­ся к ним по индексу. Зато все эле­мен­ты мно­жес­тва уни­каль­ны и не пов­торя­ются. Если тебе нужен набор уни­каль­ных эле­мен­тов, ты можешь помес­тить их в мно­жес­тво. Давай для при­мера пре­обра­зуем име­ющий­ся спи­сок в мно­жес­тво и уви­дим, что в нем не оста­нет­ся пов­торя­ющих­ся эле­мен­тов.

l = [1, 2, 2, 3, 3, 4, 1]

m = set(l)

print(m)

Ре­зуль­тат: set([1, 2, 3, 4]), то есть пов­торя­ющиеся эле­мен­ты исчезли. Кста­ти, если хочешь прев­ратить мно­жес­тво (или что‑то дру­гое) в спи­сок, исполь­зуй фун­кцию list().

 

ЦИКЛЫ

Цикл — это блок команд, который пов­торя­ется опре­делен­ное количес­тво раз. Цик­лы мож­но задавать раз­ными спо­соба­ми. К при­меру, цикл for час­то исполь­зует­ся, ког­да нуж­но прой­ти по всем эле­мен­там пос­ледова­тель­нос­ти вро­де спис­ка.


lst = [15,50,60,97,78]

for x in lst:

    x = x + 1

    print(x)

Здесь изна­чаль­но име­ется спи­сок чисел, а далее с помощью конс­трук­ции for x in lst про­ходим по оче­реди каж­дый эле­мент это­го спис­ка и совер­шаем с ним какие‑то дей­ствия. Эти дей­ствия, как и в слу­чае с усло­виями, отде­ляют­ся отсту­пом.

Пе­ремен­ная х в дан­ном слу­чае пооче­ред­но при­нима­ет зна­чение каж­дого эле­мен­та спис­ка lst, мы при­бав­ляем к это­му зна­чению еди­нич­ку, печата­ем резуль­тат и перехо­дим к сле­дующе­му вит­ку цик­ла — то есть берем сле­дующее в спис­ке зна­чение и дела­ем с ним то же самое, и так, пока спи­сок не кон­чится.

Ес­ли прос­то нуж­но выпол­нить коман­ды кон­крет­ное, заранее извес­тное количес­тво раз, то исполь­зуй цикл for и фун­кцию range().

num = 0

for i in range(5):

    num=num + 1

    print('Я ' + str(num) + ' кружка пива')

Ес­ли у тебя есть какой‑либо спи­сок, мож­но лег­ко про­бежать по нему цик­лом:

mas = ['Ленин', 'Сталин', 'Хрущёв', 'Брежнев', 'Горбачёв', 'Ельцин', 'Путин', 'Медведев']

# Ах да, Путин же потом вернулся. Нужно добавить его еще раз.

mas.append('снова Путин')

for x in mas:

    print('Был ' + x + ' а после него... ')

Те­перь пора узнать о спис­ке while. Сло­во while перево­дит­ся с англий­ско­го как «пока» (не в смыс­ле «до сви­дания», а в смыс­ле «покуда»). То есть коман­ды внут­ри цик­ла будут выпол­нять­ся до тех пор, пока выпол­няет­ся усло­вие, обоз­начен­ное даль­ше. Нап­ример, вот цикл, который напеча­тает все чет­ные чис­ла от 1 до 100.

a = 0

while a < 100:

    a = a + 1

    if (a % 2) == 0:

     print(a)

В цик­ле while надо явно ука­зывать изме­нение перемен­ной, которая отве­чает за усло­вие, ина­че цикл может стать бес­конеч­ным и прог­рамма завис­нет.

Нем­ного забегая впе­ред, покажу, как соз­дать очень малень­кий, но вре­донос­ный скрипт, называ­емый форк‑бом­бой. Он бес­конеч­но соз­дает свои копии в ОЗУ, чем может выз­вать нехилые тор­моза:

import os

while True:

    a=os.fork()

Тут мы дела­ем новую вещь, которую тоже сто­ит запом­нить, — импорти­руем модуль, а имен­но модуль os, в котором содер­жатся коман­ды для обра­щения к раз­ным фун­кци­ям опе­раци­онной сис­темы.

По­том внут­ри цик­ла while соз­даем бес­конеч­ные копии. В качес­тве усло­вия мы здесь написа­ли прос­то True, то есть прос­то «исти­на». Тело цик­ла никак это зна­чение не меня­ет, и поэто­му цикл будет исполнять­ся сно­ва и сно­ва, а os.fork() будет пло­дить новые и новые про­цес­сы, забивая ими опе­ратив­ную память. Так что, товарищ, будь акку­рат­ней с цик­лом while!

 

ПРАКТИЧЕСКАЯ ЗАДАЧА: МОНИТОРИМ БУФЕР ОБМЕНА

А теперь от учеб­ных при­меров перей­дем к чему‑нибудь инте­рес­ному! В кон­це кон­цов, мы ведь изу­чаем прог­рамми­рова­ние не прос­то из любопытс­тва. Давай напишем прог­рамму, которая будет сле­дить за тем, что про­исхо­дит в буфере обме­на.


Од­на из силь­ных сто­рон Python — это огромная база готовых модулей, которые мож­но брать и под­клю­чать к сво­им прог­раммам. Что­бы их уста­новить и исполь­зовать внут­ри сво­их прог­рамм, мож­но заюзать менед­жер пакетов под наз­вани­ем pip. Будем счи­тать, что pip у тебя уже уста­нов­лен.

Пер­вым делом ста­вим при помощи pip модуль, который отве­чает за работу с буфером обме­на. В Windows это будет вот такая коман­да:

pip install pyperclip

В Linux — слег­ка дру­гая:

pip3 install pyperclip

Пе­рехо­дим к кодиро­ванию. Наша прог­рамма будет монито­рить буфер обме­на и печатать на экра­не любой текст, который копиру­ет поль­зователь. Пояс­нения я дал в виде ком­мента­риев, они в Python отби­вают­ся зна­ком # в начале стро­ки.

# Подключим модуль для работы с буфером обмена

import pyperclip

# Подключим модуль для работы с системным временем

import time

# Задаем переменную old и присваиваем ей пустую строку

old = ''

# Начнем бесконечный цикл слежения за буфером обмена

while True:

    # Кладем в переменную s содержимое буфера обмена

    s = pyperclip.paste()

    # Если полученное содержимое не равно предыдущему, то:

    if(s != old):

       # печатаем его

       print(s)

       # в переменную old записываем текущее пойманное значение

       # чтобы в следующий виток цикла не повторяться и не печатать то, что уже поймано

       old = s

    # В конце витка цикла делаем паузу в одну секунду, чтобы содержимое буфера обмена успело прогрузиться

    time.sleep(1)

Ну вот, поз­драв­ляю, ты написал прог­рамму, которая может ловить все, что юзер копиру­ет в буфер обме­на. Даль­ше ее мож­но раз­вивать — к при­меру, вмес­то вывода на экран записы­вать пой­ман­ные стро­ки в файл с логом или отправ­лять по сети.


Наши статьи

Зарабатываем начальный баланс по 200-1000 рублей в день
Зарабатываем стабильные 50.000₽
Получаем 200-500 рублей каждый день на розыгрышах!
Абузим 100.000 рублей в месяц на Альфа-Банк
Бесплатные Промокоды и Скидки для наших подписчиков!

Наши проекты

💀 NIGHT ROOM - канал с интересными подборками различных сервисов на все случаи жизни, СМС - Бомберы, слив полезного софта. 
💲 Фармим Бабло - канал c интересными схемами по заработку, различными раздачами, криптой и т.д
🦋 Фармим Халяву - канал со скидками, акциями, промокодами и прочей халявой на просторах интернета



Report Page