В настоящата глава ще се запознаем със следните концепции и програмни техники:
- Как да работим с типове данни и променливи, които са ни необходими при обработка на числа и стрингове.
- Как да изпечатаме резултат на екрана.
- Как да четем потребителски вход.
- Как да извършваме прости аритметични операции: събиране, изваждане, умножение, деление, съединяване на стринг.
- Как да закръгляме числа.
За компютрите знаем, че са машини, които обработват данни. Всички данни се записват в компютърната памет (RAM памет) в променливи. Променливите са именувани области от паметта, които пазят данни от определен тип, например число или текст. Всяка една променлива в Python има име и стойност. Ето как бихме дефинирали една променлива, като едновременно с декларацията ѝ, ѝ присвояваме и стойност:
След тяхната обработка, данните се записват отново в променливи (т.е. някъде в паметта, заделена от нашата програма).
В програмирането всяка една променлива съхранява определена стойност от даден тип. Типовете данни могат да бъдат например: число, буква, текст (стринг), дата, цвят, картинка, списък и др. Ето няколко примера за типове данни и стойности за тях:
- int - цяло число: 1, 2, 3, 4, 5, ...
- float - дробно число: 0.5, 3.14, -1.5, ...
- str - текст (низ) от символи: 'a', 'Здрасти', 'Hi', 'Beer', ...
- datetime - дата: 21-12-2017, 25/07/1995, ...
В езика Python типът се определя от стойността, която се присвоява и не се задава изрично при декларирането на променливи (за разлика от C#, Java и C++).
За да изпечатаме текст, число или друг резултат на екрана, е необходимо да извикаме вградената функция print(). С нея можем да принтираме както стойността на променлива, така и директно текст или число:
print(9) # печатане на число
print('Hello!') # печатане на текст
msg = 'Hello, Python!'
print(msg) # печатане на стойност на променливаЗа да прочетем потребителски вход под формата на цяло число, е необходимо да декларираме променлива и да използваме вградените функции input(…) за четене на текстов ред от конзолата и int(…) за преобразуване на текстова стойност към числена:
num = int(input())Ако това преобразуване не се направи, за програмата всяко едно число ще бъде просто текст, с който не бихме могли да извършваме аритметични операции. При извикването на input(…) можем да подадем подканващо съобщение за потребителя, с което да го насочим какво искаме от него да въведе, примерно:
size = int(input('Enter the size = '))За пример да вземем следната програма, която прочита цяло число, умножава го по него самото (т.е. вдига го на квадрат) и отпечатва резултата от умножението. Така можем да пресметнем лицето на квадрат по дадена дължина на страната:
a = int(input('a = '))
area = a * a
print('Square area = ', area)Ето как би работила програмата при квадрат с размер на страната 3:
Опитайте да въведете грешно число, например "hello". Ще получите съобщение за грешка по време на изпълнение (exception). Това е нормално. По-късно ще разберем как можем да прихващаме такива грешки и да караме потребителят да въвежда число наново.
Първият ред a = int(input('a = ')) печата информативно съобщение, което подканва потребителя да въведе страната на квадрата a, след това прочита текст (стринг) и го преобразува до цяло число (извършва се т.нар. парсване) чрез функцията int(…). Резултатът се записва в променлива с име a.
Следващата команда area = a * a записва в нова променлива area резултата от умножението на a по a.
Последният ред print('Square area = ', area) отпечатва посочения текст, като до него долепя изчисленото лице на квадрата, който сме записали в променливата area.
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#0.
Когато искаме да прочетем няколко числа от конзолата, ако те са дадени всяко на отделен ред, ги четем последователно ето така:
num1 = input()
num2 = input()
num3 = input()
print(num1, num2, num3)Ако въведем следния вход:
10
20
30
ще получим съответно следния резултат:
10 20 30
Когато искаме да прочетем няколко числа от конзолата и те са дадени заедно на един ред, разделени с интервал, можем да използваме следна конструкция:
num1, num2, num3 = map(int, input().split())
print(num1 + num2 + num3)Ако въведем следния вход:
100 200 300
ще получим съответно следния резултат:
600
Как работи горният код? Чрез .split(…) разделяме елементите на въведения текстов ред по разделител интервал. Ако въведем горния вход, ще получим 3 елемента: '100', '200' и '300'. След това чрез функцията map(int, elements) преобразуваме поредицата елементи от текст към число.
За да прочетем потребителски вход под формата на дробно число, отново е необходимо да декларираме променлива, но този път ще използваме функцията float(…), която преобразува прочетената текстова стойност към числена:
num = float(input())Да напишем програма, която чете дробно число в инчове и го обръща в сантиметри:
inches = float(input('Inches = '))
centimeters = inches * 2.54
print('Centimeters = ', centimeters)Да стартираме програмата и да се уверим, че при подаване на стойност в инчове, получаваме коректен резултат в сантиметри:
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#1.
За да прочетем текст (стринг) от конзолата, отново декларираме нова променлива и използваме стандартната команда за четене от конзолата:
str = input()Да напишем програма, която въвежда името на потребителя и го поздравява с текста "Hello, {име}!".
name = input()
print('Hello, ', end='')
print(name, end='!')По подразбиране вградената функция print(…) печата резултат и отива на следващия ред. Това е така, защото print(…) използва параметъра end, който по подразбиране има стойност \n (нов ред). За да останем на същия ред, може да променим стойността на end=''.
Ето и резултата, ако извикаме функцията с името "Иван":
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#2.
При печат на текст, числа и други данни, можем да ги съединим, като използваме шаблони {0}, {1}, {2} и т.н. В програмирането тези шаблони се наричат placeholders.
В Python използваме вградения метод .format(…), чрез който изреждаме променливите, които искаме да се поставят на мястото на шаблоните (плейсхолдърите). Пример: въвеждаме име и фамилия на курсист, неговата възраст и от град е и отпечатваме текст в стил “You are {име} {фамилия}, a {възраст}-years old person from {град}.”. Ето едно решение с текстови шаблони:
first_name = input()
last_name = input()
age = int(input())
town = input()
print('You are {0} {1}, a {2}-years old person from {3}.'
.format(first_name, last_name, age, town))Ето резултата, който ще получим, след изпълнение на този пример:
Обърнете внимание как всяка една променлива трябва да бъде подадена в реда, в който искаме да се печата. По същество, шаблонът (placeholder) приема променливи от всякакъв вид и това създава голямо удобство при печатане.
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#3.
Възможно е един и същ номер на шаблон да се използва по няколко пъти и не е задължително шаблоните за функцията .format(…) да са номерирани поредно. Ето пример:
print('{1} + {1} = {0}'.format(1+1, 1))Резултатът е:
1 + 1 = 2Да разгледаме базовите аритметични операции в програмирането.
Можем да събираме числа с оператора +:
a = 5
b = 7
sum = a + b # резултатът е 12Изваждането на числа се извършва с оператора -:
a = int(input())
b = int(input())
result = a - b
print(result)Ето резултата от изпълнението на програмата (при числа 10 и 3):
За умножение на числа използваме оператора *:
a = 5
b = 7
product = a * b # 35Делението на числа се извършва с оператора /.
Забележка: Делението на 0 предизвиква грешка по време на изпълнение (runtime exception) - ZeroDivisionError.
Ето няколко примера за използване на оператора за делене:
print(10 / 2.5) # Резултат: 4
print(10 / 4) # Резултат: 2.5
print(10 / 6) # Резултат: 1.6666666666666667
print(5 / 0) # Резултат: ZeroDivisionError: division by zero
print(-5 / 0) # Резултат: ZeroDivisionError: division by zero
print(0 / 0) # Резултат: ZeroDivisionError: division by zero
print(2.5 / 0) # Резултат: ZeroDivisionError: float division by zeroЗа повдигане на степен в Python използваме оператора **:
print(2 ** 10) # 1024
print(2 ** 20) # 1048576
print(2 ** 30) # 1073741824
print(2 ** 64) # 18446744073709551616
print(2 ** 128) # 340282366920938463463374607431768211456
print(2.5 ** 1.5) # 3.952847075210474Както се вижда от примера, Python работи с лекота с големи целочислени стойности, без специални усилия. Ето един по-голям пример:
print(2 ** 1024)Резултатът е следното голямо цяло число:
179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216
Операторът + освен за събиране на числа служи и за съединяване на текст (долепяне на два символни низа един след друг). В програмирането съединяване на текст с още текст или с число наричаме "конкатенация". Ето как можем да съединяваме текст и число с оператора +:
first_name = 'Maria'
last_name = 'Ivanova'
age = 19
str = first_name + ' ' + last_name + ' @ ' + str(age)
print(str) # Maria Ivanova @ 19В Python не можем директно да долепяме (конкатенираме) число към даден текст и затова първо превръщане числото към текст с функцията str(…).
Ето още един пример:
a = 1.5
b = 2.5
sum = 'The sum is: ' + str(a) + str(b)
print(sum) # The sum is 1.52.5Забелязвате ли нещо странно? Може би очаквахте числата a и b да се сумират? Всъщност конкатенацията работи последователно отляво надясно и горният резултат е абсолютно коректен. Ако искаме да сумираме числата, ще трябва да ползваме скоби, за да променим реда на изпълнение на операциите:
a = 1.5
b = 2.5
sum = 'The sum is: ' + str(int(a + b))
print(sum) # The sum is: 4Операторът * може да се използва за повтаряне на даден текст няколко пъти:
text = 'hi'
print(3 * text) # hihihiТази особеност на оператора за умножение може да доведе до следния грешен резултат, когато не съобразим типа на умножаваната стойност:
count = input() # Enter 20
print(5 * count) # 2020202020, not 100Ако искаме да умножим по 5 число, прочетено от входа, трябва първо да преобразуване към число с функцията int():
count = int(input()) # Enter 20
print(5 * count) # 100В езика Python има няколко начина да отпечатаме форматиран текст, т.е. текст, смесен с числа, стойности на променливи и изрази. Вече се сблъскахме с някои от тях, но нека разгледаме въпроса по-детайлно.
При печатане с print(…) можем да изброяваме няколко стойности със запетайки:
width = 5
height = 7
print('width =', width, '; height =', height, '; area =', width * height)Резултатът е следният:
width = 5 ; height = 7 ; area = 35
Както се вижда от примера, при такова отпечатване всеки две стойности от изброените се отделят с интервал.
Вече знаем как да съединяваме текст и числа с оператора +. Използвайки +, горният пример може да се напише по следния начин:
width = 5
height = 7
print('width = ' + str(width) + ' ; height = ' + str(height) + ' ; area = ' + str(width * height))Резултатът е същият като в предния пример:
width = 5 ; height = 7 ; area = 35
Понеже в Python текст не може да се съединява директно с числа, те трябва да се преобразуват първо към текст чрез функцията str(num).
Печатането с шаблони може да се извърши и чрез форматиращи низове (които се ползват в езици като C и Java). Ето пример как става това:
width = 5
height = 7
text = "area"
print('width = %d ; height = %d ; %s = %d' % (width, height, text, width * height))В горния пример използваме оператора %, който замества в текстов шаблон стойности, подадени като поредица от елементи в скоби. Използват се следните основни placeholders (форматиращи низове): %d обозначава цяло число, %f обозначава дробно число, %s обозначава текст. Резултатът от горния код е същият като в предходните примери:
width = 5 ; height = 7 ; area = 35
Ако е подаден грешен форматиращ низ, може да получим грешка.
При форматирането на дробни числа можем да закръгляме до определен брой цифри след десетичната точка, например с форматиращ низ %.2f отпечатваме дробно число с 2 знака след десетичната точка:
print('price = %.2f \nVAT = %.3f' % (1.60, 1.60 * 0.2))Резултатът от горния код е следният:
price = 1.60
VAT = 0.320
В горния пример използваме специалния символ \n, който означава „отиди на нов ред“. Аналогично специалният символ \b връща курсора с една позиция назад (изтрива последния отпечатан символ) и съответно следния код:
print('ab\bc')отпечатва следния резултат:
ac
Вече разгледахме как можем да форматираме текст и числа чрез .format(…) с използването на номерирани шаблони {0}, {1}, {2} и т.н. Всъщност, когато числова номерация не е необходима, можем да напишем само {}, за да създадем placeholder. Ето пример как можем да ползваме форматиране с текст.format(…), за да отпечатаме резултата от предходния пример:
width = 5
height = 7
print('width = {} ; height = {} ; area = {}'.format(width, height, width * height))Резултатът е отново същият:
width = 5 ; height = 7 ; area = 35
Може би най-лесното, най-интуитивното и най-краткото за писане форматиране на текст и числа в Python е чрез f-string синтаксиса:
width = 5
height = 7
print(f'width = {width} ; height = {height} ; area = {width * height}')Използването на f-string форматиране е много лесно: поставяме префикс f пред стринга и в него вмъкваме на произволни позиции стойности на променливи и изрази във фигурни скоби {expression}. В горния пример имаме три израза: {width}, {height} и {width * height}, които се изчисляват и се заместват с текстовата им стойност. Можем да ползваме текстови изрази, целочислени изрази, изрази с дробни числа и всякакви други изрази.
Форматирането с f-string в Python е препоръчителният начин за печатане на форматиран текст, защото ползва най-кратък синтаксис и кодът е най-лесно разбираем се чете най-лесно.
В програмирането можем да пресмятаме и числови изрази, например:
expr = (3 + 5) * (4 – 2) # 16В сила е стандартното правило за приоритетите на аритметичните операции: умножение и деление се извършват винаги преди събиране и изваждане. При наличие на израз в скоби, той се изчислява пръв, но ние знаем всичко това от училищната математика.
Да напишем програма, която въвежда дължините на двете основи на трапец и неговата височина (по едно дробно число на ред) и пресмята лицето на трапеца по стандартната математическа формула:
b1 = float(input())
b2 = float(input())
h = float(input())
area = (b1 + b2) * h / 2
print('Trapezoid area = ' + str(area))Тъй като искаме програмата да работи, както с цели, така и с дробни числа, използваме float(…). Ако стартираме програмата и въведем за страните съответно 3, 4 и 5, ще получим следния резултат:
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#4.
Понякога, когато работим с дробни числа, се налага да приведем числата към еднотипен формат. Това привеждане се нарича закръгляне. Езикът Python ни предоставя няколко метода за закръгляне на числа:
math.ceil(…)- закръгляне нагоре, до следващо (по-голямо) цяло число:
up = math.ceil(23.45) # up = 24math.floor(…)- закръгляне надолу, до предишно (по-малко) цяло число:
down = math.floor(45.67) # down = 45round(…)- закръглянето се извършва по основното правило за закръгляване - ако десетичната част е по-малка от 5, закръглението е надолу и обратно, ако е по-голяма от 5 - нагоре:
round(5.439) # 5
round(5.539) # 6round(…, [брой символи след десетичната запетая])- закръгляне до най-близко число с определен на брой символи след десетичната запетая:
round(123.456, 2) # 123.46
round(123, 2) # 123.0
round(123.456, 0) # 123.0
round(123.512, 0) # 124.0Нека напишем програма, която при въвеждане радиуса r на кръг изчислява лицето и периметъра на кръга / окръжността.
Формули:
- Лице = π * r * r
- Периметър = 2 * π * r
- π ≈ 3.14159265358979323846…
import math
r = float(input('Enter circle radius => r = '))
area = math.pi * r * r
perimeter = 2 * math.pi * r
print('Area = ', area)
print('Perimeter = ', perimeter)Нека изпробваме програмата с радиус r = 10:
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#5.
Правоъгълник е зададен с координатите на два от своите два срещуположни ъгъла. Да се пресметнат площта и периметъра му:
В тази задача трябва да съобразим, че ако от по-големия x извадим по-малкия x, ще получим дължината на правоъгълника. Аналогично, ако от по-големия y извадим по-малкия y, ще получим височината на правоъгълника. Остава да умножим двете страни. Ето примерна имплементация на описаната логика:
x1 = float(input())
y1 = float(input())
x2 = float(input())
y2 = float(input())
width = max(x1, x2) - min(x1, x2)
height = max(y1, y2) - min(y1, y2)
area = width * height
perimeter = 2 * (width + height)
print('Area = ', area)
print('Perimeter = ', perimeter)Използваме функцията max(a, b), за намиране на по-голямата измежду стойностите a и b и аналогично min(a, b) - за намиране на по-малката от двете стойности.
При стартиране на програмата със стойностите от координатната система в условието, получаваме следния резултат:
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#6.
Да резюмираме какво научихме от тази глава на книгата:
- Въвеждане на текст:
str = input(). - Въвеждане на цяло число:
num = int(input()). - Въвеждане на дробно число:
num = float(input()). - Извършване на пресмятания с числа и използване на съответните аритметични оператори [+, -, *, /, ()]:
sum = 5 + 3. - Извеждане на текст по шаблон на конзолата:
print('{0} + {1} = {2}'.format(3, 5, 3 + 5)).
Нека затвърдим наученото в тази глава с няколко задачи.
Създаваме нов проект в PyCharm (от [Create New Project] или [File] -> [New Project]), за да организираме по-добре задачите за упражнение. Целта на този проект e да съдържа по един Python файл за всяка задача от упражненията:
- Стартираме PyCharm.
- Създаваме нов проект: [Create New Project] (или [File] -> [New Project]).
Първата задача от тази тема е следната: да се напише конзолна програма, която въвежда цяло число a и пресмята лицето на квадрат със страна a. Задачата е тривиално лесна: прочитаме въведеното число, умножаваме го само по себе си и печатаме получения резултат на конзолата.
Създаваме нов файл в съществуващия PyCharm проект. Кликваме с десен бутон на мишката върху SimpleCalculations и избираме [New] -> [Python File]:
Ще се отвори диалогов прозорец за избор на името на файла. Наименуваме го "square_area":
Вече имаме проект с един файл в него. Остава да напишем кода за решаване на задачата. За целта отиваме във файла и пишем следния код:
Кодът прочита цяло число чрез a = int(input('a = ')), след това изчислява area = a * a и накрая печата стойността на променливата area. Стартираме програмата с [Ctrl + Shift + F10] или с десен бутон - [Run], и я тестваме с различни входни стойности:
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#0. Трябва да получите 100 точки (напълно коректно решение):
Да се напише програма, която чете от конзолата число (не непременно цяло) и преобразува числото от инчове в сантиметри. За целта умножава инчовете по 2.54 (защото 1 инч = 2.54 сантиметра).
Първо създаваме нов Python файл в проекта "SimpleCalculations". За целта кликаме с десен бутон на мишката върху решението SimpleCalculations и избираме [New] -> [Python File]. Задаваме име "inches_to_centimeters":
Следва да напишем кода на програмата:
Стартираме програмата с [Ctrl + Shift + F10] или с десен бутон - [Run]:
Да тестваме с дробни числа, например с 2.5:
 |
В зависимост от регионалните настройки на операционната система, е възможно вместо десетична точка (US настройки) да се използва десетична запетая (BG настройки). |
Ако програмата очаква десетична точка и бъде въведено число с десетична запетая или обратното (бъде въведена десетична точка, когато се очаква десетична запетая), ще се получи следната грешка:
Препоръчително е да променим настройките на компютъра си, така че да се използва десетична точка. В Windows това става от контролния панел:
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#1.
Решението би трябвало да бъде прието като напълно коректно:
Да се напише програма, която чете от конзолата име на човек и отпечатва Hello, <name>!, където <name> е въведеното преди това име.
Първо създаваме нов Python файл с име "greeting_by_name" в проекта "SimpleCalculations":
Следва да напишем кода на програмата. Ако се затруднявате, може да ползвате примерния код по-долу:
Стартираме програмата с [Ctrl + Shift + F10] или с десен бутон - [Run], за да тестваме дали работи коректно:
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#2.
Напишете програма, която прочита от конзолата име, фамилия, възраст и град и печата съобщение от следния вид: You are <firstName> <lastName>, a <age>-years old person from <town>.
Добавяме към текущия PyCharm проект още един Python файл с име "concatenate_data". Пишем кода, който чете входните данни от конзолата:
Кодът, който отпечатва описаното в условието на задачата съобщение, е целенасочено размазан и трябва да се допише от читателя:
Следва да се тества решението локално с [Ctrl + Shift + F10] или с десен бутон - [Run], и въвеждане на примерни входни данни.
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#3.
Напишете програма, която чете от конзолата три числа b1, b2 и h и пресмята лицето на трапец с основи b1 и b2 и височина h. Формулата за лице на трапец е (b1 + b2) * h / 2.
| Вход | Изход |
|---|---|
| 8 13 7 |
73.5 |
| 12 8 5 |
50 |
На фигурата по-долу е показан трапец със страни 8 и 13 и височина 7. Той има лице (8 + 13) * 7 / 2 = 73.5.
Отново трябва да добавим към текущия PyCharm проект още един Python файл с име "trapezoid_area" и да напишем кода, който чете входните данни от конзолата, пресмята лицето на трапеца и го отпечатва. Кодът на картинката е нарочно размазан, за да помисли читателят върху него и да го допише сам:
Тествайте решението локално с [Ctrl + Shift + F10] или с десен бутон - [Run], и въвеждане на примерни данни.
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#4.
Напишете програма, която чете от конзолата число r и пресмята и отпечатва лицето и периметъра на кръг/окръжност с радиус r.
| Вход | Изход |
|---|---|
| 3 | Area = 28.2743338823081 Perimeter = 18.8495559215388 |
| 4.5 | Area = 63.6172512351933 Perimeter = 28.2743338823081 |
За изчисленията можете да използвате следните формули:
area = math.pi * r * r.perimeter = 2 * math.pi * r.
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#5.
Правоъгълник е зададен с координатите на два от своите срещуположни ъгъла (x1, y1) – (x2, y2). Да се пресметнат площта и периметъра му. Входът се чете от конзолата. Числата x1, y1, x2 и y2 са дадени по едно на ред. Изходът се извежда на конзолата и трябва да съдържа два реда с по една число на всеки от тях – лицето и периметъра.
| Вход | Изход |
|---|---|
| 60 20 10 50 |
1500 160 |
| 30 40 70 -10 |
2000 180 |
| 600.25 500.75 100.50 -200.5 |
350449.6875 2402 |
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#6.
Напишете програма, която чете от конзолата страна и височина на триъгълник и пресмята неговото лице. Използвайте формулата за лице на триъгълник: area = a * h / 2. Закръглете резултата до 2 цифри след десетичния знак използвайки функцията round(area, 2).
| Вход | Изход |
|---|---|
| 20 30 |
Triangle area = 300 |
| 15 35 |
Triangle area = 262.5 |
| 7.75 8.45 |
Triangle area = 32.74 |
| 1.23456 4.56789 |
Triangle area = 2.82 |
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#7.
Напишете програма, която чете градуси по скалата на Целзий (°C) и ги преобразува до градуси по скалата на Фаренхайт (°F). Потърсете в Интернет подходяща формула, с която да извършите изчисленията. Закръглете резултата до 2 символа след десетичния знак.
| Вход | Изход |
|---|---|
| 25 | 77 |
| 0 | 32 |
| -5.5 | 22.1 |
| 32.3 | 90.14 |
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#8.
Напишете програма, която чете ъгъл в радиани (rad) и го преобразува в градуси (deg). Потърсете в Интернет подходяща формула. Числото π в Python програмите е достъпно чрез math.pi като преди това трябва да реферираме библиотеката math чрез import math. Закръглете резултата до най-близкото цяло число използвайки метода round().
| Вход | Изход |
|---|---|
| 3.1416 | 180 |
| 6.2832 | 360 |
| 0.7854 | 45 |
| 0.5236 | 30 |
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#9.
Напишете програма за конвертиране на щатски долари (USD) в български лева (BGN). Закръглете резултата до 2 цифри след десетичния знак. Използвайте фиксиран курс между долар и лев: 1 USD = 1.79549 BGN.
| Вход | Изход |
|---|---|
| 20 | 35.91 BGN |
| 100 | 179.55 BGN |
| 12.5 | 22.44 BGN |
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#10.
Напишете програма за конвертиране на парична сума от една валута в друга. Трябва да се поддържат следните валути: BGN, USD, EUR, GBP. Използвайте следните фиксирани валутни курсове:
| Курс | USD | EUR | GBP |
|---|---|---|---|
| 1 BGN | 1.79549 | 1.95583 | 2.53405 |
Входът e сума за конвертиране, входна валута и изходна валута. Изходът е едно число – преобразуваната сума по посочените по-горе курсове, закръглен до 2 цифри след десетичната точка.
| Вход | Изход |
|---|---|
| 20 USD BGN |
35.91 BGN |
| 100 BGN EUR |
51.13 EUR |
| 12.35 EUR GBP |
9.53 GBP |
| 150.35 USD EUR |
138.02 EUR |
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#11.
Напишете програма, която въвежда рождена дата във формат dd-MM-yyyy и пресмята датата, на която се навършват 1000 дни от тази рождена дата и я отпечатва в същия формат.
| Вход | Изход |
|---|---|
| 1995-02-25 | 20-11-1997 |
| 2003-11-07 | 02-08-2006 |
| 2002-12-30 | 24-09-2005 |
| 2012-01-01 | 26-09-2014 |
| 1980-06-14 | 10-03-1983 |
- Потърсете информация за
datetimeв Python и по-конкретно разгледайте методитеstrptime(str, format),timedelta(days=n). С тяхна помощ може да решите задачата, без да е необходимо да изчислявате дни, месеци и високосни години. - Не печатайте нищо допълнително на конзолата освен изискваната дата!
Тествайте решението си тук: https://judge.softuni.org/Contests/Practice/Index/1047#12.
За да упражним работата с променливи и пресмятания с оператори и числови изрази, ще направим нещо интересно: ще разработим настолно приложение с графичен потребителски интерфейс. В него ще използваме пресмятания с дробни числа.
От нас се изисква да създадем графично приложение (GUI application), което пресмята стойността в евро (EUR) на парична сума, зададена в лева (BGN). Използваме курс лева / евро: 1.95583).
Забележка: тази задача излиза извън изучавания в книгата материал и има за цел не да ви научи как да програмирате GUI приложения, а да ви запали интереса към разработката на софтуер. Да се залавяме за работа.
Добавяме към текущия PyCharm проект още един Python файл. Наименуваме го "BGN_to_EUR_converter". За да направим графично приложение с Python, ще използваме стандартната библиотека tkinter.
Първо създаваме графично приложение (Application), което представлява правоъгълна рамка за компоненти (Frame). На този етап всичко ще се случва без обяснения, като на магия:
Вече може да добавим компонентите на приложението ни в т.нар. функция, която ще извикаме във функцията init, или т.нар. конструктор:
Подреждаме следните UI компоненти:
- Label - ще ни служи за статично изобразяване на текст.
- Entry - ще въвежда сумата за конвертиране.
- Button - ще конвертира въведената сума.
- Още един Label, който ще показва резултата след конвертиране.
Нашите компоненти се намират във функцията create_widgets(). Добавяме текст за визуализация на първия Label, който ни е под името label. numberEntry е Entry, където ще се въвежда сумата за конвертиране. convertButton ще хваща събитие и ще изпълнява команда (в нашата задача ще извиква функцията convert(), която ще напишем малко по-късно). output е нашия Label за показване на резултат след като сме въвели сума и кликнали върху бутон:
След като сме инициализирали нашите компоненти е ред да ги визуализираме. Това става лесно чрез вградения метод в tkinter - pack():
Остана да напишем кода (програмната логика) за конвертиране от лева към евро. Това ще го направим във функцията convert():
def convert(self):
entry = self.numberEntry.get()
value = float(entry)
result = round(value * 1.95583, 2)
self.output.config(
text=str(value) + ' BGN = ' + str(result) + ' EUR',
bg="green", fg="white")На последния ред подаваме резултата на нашия Label output и задаваме цвят на фона (bg) и на текста (fg).
Стартираме приложението с [Ctrl + Shift + F10] или с десен бутон + [Run], и тестваме дали работи коректно.
С този код ще имаме проблем. Какво ще стане, ако въведем нещо, различно от число?
Тази грешка можем да я хванем и да получаваме user-friendly съобщение в приложението ни. За целта нека променим кода на нашата програмна логика:
def convert(self):
entry = self.numberEntry.get()
try:
value = float(entry)
result = round(value * 1.95583, 2)
self.output.config(
text=str(value) + ' BGN = ' + str(result) + ' EUR',
bg="green", fg="white")
except ValueError:
self.output.config(
text="That's not a number!",
bg="red", fg="black")По този начин ние прихващаме грешката в try блок и когато въведем нещо, различно от число, ще получаваме съобщение That's not a number!.
Накрая стартираме приложението с [Ctrl + Shift + F10] или с десен бутон + [Run], и тестваме дали работи коректно.
Създайте забавно графично приложение „хвани бутона“. При преместване на курсора на мишката върху бутона той се премества на случайна позиция. Така се създава усещане, че „бутонът бяга от мишката и е трудно да се хване“. При „хващане“ на бутона се показва съобщение-поздрав.
Ще започнем със същия код от предната задача. Нека променим името на приложението ни на Catch the Button! и този път ще зададем размера на прозореца:
Ще имаме следните компоненти:
- Button - бутонът, който трябва да хванем.
- Label - съобщението-поздрав.
Създаваме бутон с текст "Catch me!" и команда - функцията on_click(), която ще напишем по-късно. Визуализираме компонентите чрез метода pack(). Нека и двата компонента са най-отгоре (top):
В нашата задача ще ползваме т.нар. операция binding. Това представлява хващане на промяна и изпълняване на определена функция. Чрез този код указваме на програмата ни, че при преместване на курсора на мишката върху бутона, ще се изпълни функцията on_enter(), а при преместването на курсора на мишката извън бутона, ще се изпълни функцията on_leave():
За преместването на бутона на случайна позиция ще използваме random:
Нека имплементираме трите функции, които са програмната логика в приложението ни:
on_enter(self, event)- избираме случайниxиyкоординати, които ще се променят всеки път, когато преместим курсора на мишката върху бутона; променяме и местоположението на бутона - в нашия пример ще бъде статично отдясно, но може да направите своя логика и да променяте всеки път посоката на бутона, заедно със случайните числа за координати.on_leave(self, event)- когато курсора на мишката не е върху бутона, нашият поздрав не трябва да се показва; конфигурираме нашия label да няма текст.on_click()- когато кликнем върху бутона, нашия label вече е с текст - You win!.
Възможно е не всичко да тръгне гладко от първия път. Примерите по-горе съдържат неизучаван материал и имат за цел да ви запалят любопитството и да ви накарат да се поразровите в Интернет и да потърсите сами решения за възникващите трудности.
Ако имате проблеми със задачите по-горе, питайте във форума на СофтУни: https://softuni.bg/forum.