Tip:
Highlight text to annotate it
X
В последните няколко урока, написахме хубава програмка,
която пита потребителя за входни данни,
изчислява факториела на даденото число
и извежда резултата.
И това е много хубаво, но предтавете си
че бихте искали да изчислите факториел на няколко места,
или в няколко различни програми,
или в една и съща програма,
но на различни места.
И не желаете да пишете
същия код отново и отново,
за да изчислите факториел.
В това видео ще ви покажа
как се дефинира функция за изчисляване на факториел
която след това можем да използваме
всеки път, когато искаме да изчислим факториел.
Значи тази фукнция,
ще съдържа целия този код,
ето този код тук,
на едно място и тогава във всяка друга програма,
която искам да изчислява факториел,
ще мога да презиползвам кода.
Няма да е нужно да го пиша пак.
Нека ви покажа за какво става въпрос.
Ще дефинирам фукнция,
а ключовата дума в Python,
това е един вид запазена дума,
която указва на интерпретатора,
че нещо специално ще се случи.
Ключовата дума в Python за дефиниране на фукнция е "def".
Сега ще дефинирам функция.
Ще я нарека factorial.
Добра идея е да именовате нещата
според това, което всъщност правят.
Някои начинаещи програмисти имат навика
да дават имена от сорта на "x245"
и когато някой се включи след това,
няма да има и представа за какво е
тази променлива или функция.
Така че, задължително я именовайте така,
че да дава представа за предназначението ѝ.
Моята фукнция се казва factorial
и потребителите, които извикват factorial,
трябва да укажат на factorial,
кое е числото, за което ще се изчислява.
И така, те трябва да подадат аргумент наречен "number".
Може тези думи ви се струват объркващи
ще ги обясня подробно след секунда,
а и нядявам се, че колкото повече гледате,
толкова по-ясни ще ви стават тези понятия.
Потребителят подава аргумента number,
и аз ще трябва да върна обратно
към извикващата програма
Всъщност нямах предвид,
че потребителя ще подаде аргумента number,
а извикващата програма ще подаде аргумента number,
и ще трябва да върна резултата от факториела на това число
до извикващата програма.
Нека го напиша като коментар всъщност.
Връща факториела на аргумента number.
Понякога ще го чуете като параметър,
а понякога като аргумент.
Когато дефинирате фукнция,
това по-често се нарича параметър.
"Number" е един от параметрите
на функцията factorial.
Конкретното число, което някой друг подава на функцията,
да кажем че, някой извиква factorial с "3",
тогава по-официално това 3 ще се нарича аргумент.
*Връща факториела на аргумента "number"*
И това е аргументът "number" ето тук.
И нямам предвид, че това е думата number.
Аз буквално говоря за това число точно тук.
Може да го нарека аргументът "number"
и да го сложа в кавички, за да е по-ясно,
че това е аргументът.
Не говоря за което и да е число.
Нека я дефинираме.
Общо взето ще ползваме същия код.
Всъщност, просто ще копирам и поставя
по-голямата част от това тук.
Ще премахна това
и ще го поставя ето тук,
но ще трява да внимавам с интервалите,
защото по тях Python разбира
кое към какво принадлежи, за да интерпретира правилно нещата.
Всичко, което е част от тази дефиниця на функцията,
трябва да бъде отместено с четири интервала.
1,2,3,4
И отново четири тук
1,2,3,4
А това е част от for-цикъла.
1,2,3,4
Нека помислим какво имаме до тук.
Ще бъде подадено някакво число,
дефинираме променлива product равна на 1.
Ще говорим повече за обхвата на на променливите,
но в случая тази променлива ще бъде ползваема
само вътре в дефиницията на factorial,
защото за първи път я дефинирам тук,
ето тук вътре.
За обхвата на променливите предстои да говорим.
След това, със същата логика, която направихме преди,
"за i в поредицата(number)",
обаче сега не вземаме числото чрез входни данни,
а то просто се подава на функцията
после на "product" присвояваме стойността *"product" x ("i"+1)*
Същата логика като преди.
След това се завърта for-цикъл
и след като преминем през него,
толкова пъти, колкото е "number"
"Product" ще съдържа факториел от "number"
Но вместо да го изведем директно,
ще го върнем като резултат,
обратно към извикващата програма
в следващото видео ще опиша това малко по-ясно,
ако в момента ви изглежда объркващо.
Ще върна product
Това е в действителност същия код, който имахме преди
но го обособихме във функция,
дефинирахме функция.
И тя има параметър "number"
Ако искате факториела на 3
ще напишете factorial(3)
и 3 ще бъде аргументът, нещото
което замества променливата "number"
или по-точно, онова, към това се отнася "number".
Дефинираме "product" е равно на 1
и след това повтаряме "number" пъти
Така "за i в range(number)",
Обяснихме вече логиката на това в предишното видео
Всеки път започвате с 1
после имате 1 по 1, което е 1,
тогава "product" ще бъде 1
но тогава "i" ще бъде 1.
"i" започва от нулата.
така че имаме *1 по (0 +1)*, което ни дава 1
тогава "i" е 2, и ще имаме 1 по 1,
извинете, "i" е 1
ще имаме *1 по (1 + 1)*, което е 1 по 2
и тогава ще бъде 2
и ще се увеличава по този начин
но това го разяснихме в предишното видео.
Накрая ще върнем променливата "product'
Ако искаме да имаме същото поведение като преди
но сега използваме функция
Какво можем да направим? Можем да кажем
все още имаме входящ параметър, ето това е нашата дефиниция на функията
Тогава в главната ни програма
вече имаме дефинирана функцията
и сега можем да кажем:
"Вземи от потребителя положително цяло число
на което да върнем факториела"
и нека запишем това число
в променлива наречена "число на потребителя".
След това
ще дефинирам друга променлива
наречена "факториел от числото на потребителя"
и сега ще стане интересно
Ще извикам функцията тук,
променливата ще е равна на
факториел от числото на потребителя
Факториел от променливата "число на потребителя".
факториел от ето тази промелнива
Факториелът от числото на потребителя
Сега "факториел от числото на потребителя" ще съдържа
познайте какво ще кажа
ще сочи истинския отговор
и просто трябва да го изведем
Сега можем да изведем стойността на "факториел от числото на потребителя"
Изглеждат като изречения,
но са имена на променливи,
които съм именовал така,
за да се знае какво наистина има в тези променливи
или към какво сочат те
И така "факториел от числото на потребителя"
Моментът на истината идва
когато запазваме програмата и пробваме да я пуснем.
Нека пуснем програмата и да видим какво ще стане.
Да видим какво става тук
Поне нищо не се е счупило засега
и отново
искам да поясня, че програмата започва тук
а тук горе просто сме дефинирали това
и там няма никакви взаимодействия с потребителя
всъщност още не изчислява нищо,
само дефинира как ще работи функцията, тогава отиваме долу
и казваме: "Нека потребителя да напише нещо"
това правим точнно тук
След като потребителя въведе число
тогава вече ще извикаме функцията
подавайки числото, което е въведено
то отвива в променливата "число на потребителя"
и тогава викваме функцията factorial
с аргумент "число на потребителя"
Нека опитаме с числото 3.
И не стана!
О, виждам защо не работи
защото това е останало от предишната програма
а то няма смисъл сега
Нека го премахна.
Това е добър урок - че рядко при първия опит
нещото проработва гладко.
Нека опитам пак!
Това беше безсмислено
не осъзнавах какво имаше там.
Нека опитам пак.
Отново числото 3
И получаваме правилен отговор.
Върна ми факториел от 3
И сега нещо готино -
интерпретатора на Python
вижда, че има направена дефиниция
и мога да извикам функцията направо от интерпретатора
ако имах друга програма
бих могъл да я викам многократно
и сега, надявам се, оценявате
защо е хубаво, че дефинирахме функцията
защото можем да изчислим
понеже дефинирахме фунцкцията factorial
Мога да изчисля факториела на 4
Той е 24.
Мога да поискам факториел от 5 минус факториел от 3
114
факториел от 12
и може да кажете на компютъра,
дори само интерпретирайки всичко това,
ще говорим повече за интерпретиране и компилиран код
това е изключително бързо
По-бързо, отколкото можем да осмислим
Истинската сила на функцията е
че не трябва да пиша кода всеки път
Просто мога да викам функцията с различни аргументи
Факториел от 2, мога да го направя по всяко време
Няма нужда да пускам програмата отново
И ако пиша други програми, които ползват factorial,
може би нещо с комбинаторика,
Просто ще ползвам това като функция
даже не трябва да знам
какво точно става вътре във функцията
Това е една от силните страни на функциите
Нека кажем, че напиша много програми, които викат функцията
имам например една програма, която я вика factorial
Но нека кажем, че намеря по-добър начин
да напиша кода тук
Докато програмата прави
едно и също, макар и по различен начин
потребителят няма да забележи.
Може да напишете по-бърз начин
или по-лесен начин функцията да смята това
По начин, по който използва по-малко памет или процесор
Тогава просто можете да замените това
и всяка програма, която я вика
стига все още да работи,
ще работи за тази програма
и ще работи много по-добре