diff options
| -rw-r--r-- | be-by/python-by.html.markdown | 1136 |
1 files changed, 1136 insertions, 0 deletions
diff --git a/be-by/python-by.html.markdown b/be-by/python-by.html.markdown new file mode 100644 index 00000000..f16443b6 --- /dev/null +++ b/be-by/python-by.html.markdown @@ -0,0 +1,1136 @@ +--- +language: Python +contributors: + - ["Louie Dinh", "http://pythonpracticeprojects.com"] + - ["Steven Basart", "http://github.com/xksteven"] + - ["Andre Polykanine", "https://github.com/Oire"] + - ["Zachary Ferguson", "http://github.com/zfergus2"] + - ["evuez", "http://github.com/evuez"] + - ["Rommel Martinez", "https://ebzzry.io"] + - ["Roberto Fernandez Diaz", "https://github.com/robertofd1995"] + - ["caminsha", "https://github.com/caminsha"] + - ["Stanislav Modrak", "https://stanislav.gq"] + - ["John Paul Wohlscheid", "https://gitpi.us"] +translators: + - ["lucii7vel", "https://https://github.com/lucii7vel"] +filename: learnpython-by.py +lang: be-by +--- +Python быў створаны Гвіда ван Росумам у пачатку 90-х. Цяпер гэта адна з +самыя папулярных моў праграмавання. Я закахаўся ў Python за яго +сінтаксічную празрыстасць. Гэта літаральна выканальны псеўдакод. + +```python +# Аднарадковыя каментарыі пачынаюцца знакам рашоткі. + +""" Шматрадковыя каментарыі можна + рабіць выкарыстоўваючы тры ", яны часта + выкарыстоўваюцца ў якасці дакументацыі. +""" + +#################################################### +## 1. Прымітыўныя тыпы даных і аператары. +#################################################### + +# Лічбы +3 # => 3 + +# Відавочныя матэматычныя аперацыі +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 + +# Вынік цэлалікавага дзялення акругляецца як для пазітыўных, +# так і для негатыўных значэнняў. +5 // 3 # => 1 +-5 // 3 # => -2 + +# Працуе таксама на лічбах з плаваючай кропкай. +5.0 // 3.0 # => 1.0 +-5.0 // 3.0 # => -2.0 + +# Вынік дзялення — заўсёды лічба з плаваючай кропкай. +10.0 / 3 # => 3.3333333333333335 + +# Дзяленне па модулю +7 % 3 # => 1 +# У выніку i % j атрымаецца значэнне са знакам j +-7 % 3 # => 2 + +# Узвядзенне ў ступень +2**3 # => 8 + +# Прыярытэт аперацый праз дужкі +1 + 3 * 2 # => 7 +(1 + 3) * 2 # => 8 + +# Лагічныя значэнні з'яўляюцца прымітывамі +# (Звярніце ўвагу на рэгістр) +True # => True +False # => False + +# Адмаўленне праз not +not True # => False +not False # => True + +# Лагічныя аператары +# Звярніце ўвагу, "and" і "or" чуллівыя да рэгістра +True and False # => False +False or True # => True + +# True і False на самай справе 1 і 0, толькі з іншымі ключавымі словамі. +True + True # => 2 +True * 8 # => 8 +False - 5 # => -5 + +# Параўнальныя аператары звяртаюцца да лічбавых значэнняў True і False. +0 == False # => True +2 > True # => True +2 == True # => False +-5 != False # => True + +# None, 0 і пустыя радкі/спісы/слоўнікі/картэжы/мноства адпавядаюць False. +# Усе іншыя значэнні адпавядаюць True. +bool(0) # => False +bool("") # => False +bool([]) # => False +bool({}) # => False +bool(()) # => False +bool(set()) # => False +bool(4) # => True +bool(-6) # => True + +# Выкарыстоўванне лагічных аператараў на цэлалікавых значэннях ператварае +# іх у boolean для вылічэнняў, але вяртае значэнне іх зыходнага тыпу. +# Не блытайце з bool(int) і пабітавымі and/or (&, |). +bool(0) # => False +bool(2) # => True +0 and 2 # => 0 +bool(-5) # => True +bool(2) # => True +-5 or 0 # => -5 + +# Роўнасць == +1 == 1 # => True +2 == 1 # => False + +# Няроўнасць != +1 != 1 # => False +2 != 1 # => True + +# Больш параўнанняў +1 < 10 # => True +1 > 10 # => False +2 <= 2 # => True +2 >= 2 # => True + +# Праверка значэння на ўваход у дыяпазон +1 < 2 and 2 < 3 # => True +2 < 3 and 3 < 2 # => False +# Звязванне выглядае прыгажэй +1 < 2 < 3 # => True +2 < 3 < 2 # => False + +# (is супраць ==) is правярае, ці спасылаюцца дзве пераменныя на адзін і той жа +# аб'ект, а == правярае, ці маюць дзве пераменныя аднолькавыя значэнні. +a = [1, 2, 3, 4] # a спасылаецца на новы спіс [1, 2, 3, 4] +b = a # b спасылаецца туды ж, куды і a +b is a # => True, a і b спасылаюцца на адзін і той жа аб'ект +b == a # => True, аб'екты a і b аднолькавыя +b = [1, 2, 3, 4] # b спасылаецца на новы спіс [1, 2, 3, 4] +b is a # => False, a і b спасылаюцца на розныя аб'екты +b == a # => True, аб'екты a і b аднолькавыя + +# Радкі ствараюцца праз " ці ' +"Гэта радок." +'Гэта таксама радок.' + +# Радкі можна складваць +"Вітаю, " + "свет!" # => "Вітаю, свет!" +# Радковыя літаралы (але не пераменныя) магчыма злучаць без выкарыстоўвання '+' +"Вітаю, " "свет!" # => "Вітаю, свет!" + +# Радок можна успрымаць як спіс сімвалаў +"Вітаю, свет"[0] # => 'В' + +# Ёсць магчымасць знайсці даўжыню радка +len("Гэта радок") # => 10 + +# З версіі Python 3.6 магчыма выкарыстоўваць f-радкі +# або фарматаваныя радковыя літаралы. +name = "Рэйко" +f"Яна сказала, што яе завуць {name}." # => "Яна сказала, што яе завуць Рэйко" +# Любы дзейны Python-выраз унутры гэтых дужак вяртаецца ў радок. +f"Даўжыня {name} — {len(name)} сімвалаў." # => "Даўжыня Рэйко — 5 сімвалаў." + +# None — гэта аб'ект +None # => None + +# Не выкарыстоўвайце знак роўнасці '==' для параўнання аб'ектаў з None. +# Замест гэтага карыстайцеся 'is'. Ён правярае аб'екты на ідэнтычнасць. +"etc" is None # => False +None is None # => True + +#################################################### +## 2. Пераменныя і калекцыі +#################################################### + +# У Python ёсць функцыя print +print("Я Python. Рады бачыць!") # => Я Python. Рады бачыць! + +# Па змаўчанні print таксама пераводзіць на новы радок у канцы. +# Выкарыстоўвайце апцыянальны аргумент end каб змяніць канцоўку радка. +print("Вітаю, свет", end="!") # => Вітаю, свет! + +# Просты спосаб атрымаць уваходныя даныя з кансолі +input_string_var = input("Увядзіце даныя: ") # Вяртае даныя ў якасці радка + +# Ніякіх аб'яўленняў, толькі прызначэнні пераменных. +# Пераменныя заведзена называць у стылі snake_case. +some_var = 5 +some_var # => 5 + +# Звяртанне да непрызначаннай пераменнай прыводзіць да выключэння. +# Падрабязнасці пра апрацоўку выключэнняў у раздзеле "Паток кіравання". +some_unknown_var # Выкідвае NameError + +# if можа быць выкарыстаны ў якасці выражэння +# Эквівалент цернарнага аператара '?:' з C +"Так!" if 0 > 1 else "Не!" # => "Не!" + +# Спісы захоўваюць паслядоўнасці +li = [] +# Вы можаце стварыць запоўнены спіс +other_li = [4, 5, 6] + +# Дадаць нешта ў канец спіса праз append +li.append(1) # li цяпер [1] +li.append(2) # li цяпер [1, 2] +li.append(4) # li цяпер [1, 2, 4] +li.append(3) # li цяпер [1, 2, 4, 3] +# Выдаліць з канца праз pop +li.pop() # => 3 li цяпер [1, 2, 4] +# Пакладзём назад +li.append(3) # li цяпер зноў [1, 2, 4, 3] + +# Звяртайцеся да спіса як да звычайнага масіву +li[0] # => 1 +# Зварот да апошняга элемента +li[-1] # => 3 + +# Зварот за межы спіса выкідвае IndexError +li[4] # выклідвае IndexError + +# Магчыма звяртацца да дыяпазонаў праз адсячэнні. +# Пачатковы індэкс уключаецца ў дыяпазон, а канчатковы не +# (матэматыкі сярод вас ведаюць гэта як напаўадкрыты адцінак). +li[1:3] # Вярнуць спіс з індэкса 1 па 3 => [2, 4] +li[2:] # Вярнуць спіс з індэкса 2 => [4, 3] +li[:3] # Вярнуць спіс да індэкса 3 => [1, 2, 4] +li[::2] # Вярнуць спіс, абіраючы элементы з крокам 2 => [1, 4] +li[::-1] # Вярнуць спіс у адваротным парадку => [3, 4, 2, 1] +# Выкарыстоўвайце іх у рознай камбінацыі, каб ствараць лепшыя адсячэнні +# li[пачатак:канец:крок] + +# Зрабіць копію глыбінёй у адзін слой выкарыстоўваючы адсячэнні +li2 = li[:] # => li2 = [1, 2, 4, 3] але (li2 is li) верне false. + +# Выдаліць элемент са спіса па пазіцыі праз "del" +del li[2] # li цяпер [1, 2, 3] + +# Выдаліць першае знойдзенае значэнне +li.remove(2) # li цяпер [1, 3] +li.remove(2) # Выкідвае ValueError, бо ў спісе няма элемента са значэннем 2 + +# Уставіць элемент па дадзенаму індэксу +li.insert(1, 2) # li цяпер зноў [1, 2, 3] + +# Атрымаць індэкс першага элемента з дадзеным значэннем +li.index(2) # => 1 +li.index(4) # Выкідвае ValueError, бо ў спісе няма элемента са значэннем 4 + +# Магчыма складваць спісы. +# Заўвага: значэнні li і other_li не змяняюцца. +li + other_li # => [1, 2, 3, 4, 5, 6] + +# Аб'яднанне спісаў праз "extend()" +li.extend(other_li) # li цяпер [1, 2, 3, 4, 5, 6] + +# Праверка на наяўнасць элемента ў спісе праз "in" +1 in li # => True + +# Атрымаць даўжыню спіса праз "len()" +len(li) # => 6 + + +# Картэжы падобныя на спісы, але не змяняюцца +tup = (1, 2, 3) +tup[0] # => 1 +tup[0] = 3 # Выкідвае TypeError + +# Звярніце ўвагу, што картэжы даўжыні 1 павінны мець коску пасля +# апошняга элемента, але картэжы іншай даўжыні, нават 0, не. +type((1)) # => <class 'int'> +type((1,)) # => <class 'tuple'> +type(()) # => <class 'tuple'> + +# Большасць аперацый для спісаў працуюць таксама на картэжах +len(tup) # => 3 +tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6) +tup[:2] # => (1, 2) +2 in tup # => True + +# Вы можаце распакоўваць картэжы (або спісы) у пераменныя +a, b, c = (1, 2, 3) # a цяпер 1, b цяпер 2 і c цяпер 3 +# Таксама ёсць пашыраная распакоўка +a, *b, c = (1, 2, 3, 4) # a цяпер 1, b цяпер [2, 3] і c цяпер 4 +# Картэжы ствараюцца па змаўчанні, калі апусціць дужкі +d, e, f = 4, 5, 6 # картэж 4, 5, 6 распакоўваецца ў d, e, f, +# адпаведна, d = 4, e = 5 і f = 6. +# Цяпер паглядзіце, як лёгка абмяняць значэнні дзвюх пераменных +e, d = d, e # d цяпер 5, e цяпер 4 + + +# Слоўнікі змяшчаюць пары ключ/значэнне +empty_dict = {} +# Так выглядае папярэдне запоўнены слоўнік +filled_dict = {"адзін": 1, "два": 2, "тры": 3} + +# Звярніце ўвагу, што ключы ў слоўніках павінны быць нязменных тыпаў. Гэта для +# таго, каб пераканацца, што ключ заўсёды створыць аднолькавы хэш для пошуку. +# У нязменныя тыпы ўваходзяць цэлалікавыя значэнні, +# значэнні з плаваючай кропкай, радкі і картэжы. +invalid_dict = {[1,2,3]: "123"} # => Вікідвае TypeError: unhashable type: 'list' +valid_dict = {(1,2,3):[1,2,3]} # Значэнні, аднак, могуць быць любых тыпаў. + +# Пошук значэнняў праз [] +filled_dict["адзін"] # => 1 + +# Атрымаць усе ключы ў якасці itterable-аб'екта праз "keys()". Нам трэба +# абгарнуць вызаў у list(), каб ператварыць вынік у спіс. Паразмаўляем аб +# гэтым пазней. Заўвага, для версій Python, ніжэйшых за 3.7, парадак ключоў +# слоўніка не гарантуецца, вашыя вынікі могуць не адпавядаць прыкладам ніжэй. +# Аднак, з версіі Python 3.7, элементы слоўніка захоўваюць парадак, у якім яны +# былі ўстаўлены. +list(filled_dict.keys()) # => ["тры", "два", "адзін"] для Python <3.7> +list(filled_dict.keys()) # => ["адзін", "два", "тры"] для Python 3.7+ + + +# Атрымаць усе значэнні ў якасці itterable-аб'екта праз "values()". Зноў жа, +# нам трэба абгарнуць вызаў у list(), каб атрымаць спіс. Тая ж заўвага пра +# парадак, што і вышэй. +list(filled_dict.values()) # => [3, 2, 1] для Python <3.7 +list(filled_dict.values()) # => [1, 2, 3] для Python 3.7+ + +# Праверка на наяўнасць ключа ў слоўніку праз "in" +"адзін" in filled_dict # => True +1 in filled_dict # => False + +# Пошук неіснуючага ключа выкідвае KeyError +filled_dict["чатыры"] # KeyError + +# Выкарыстоўвайце метад "get()", каб пазбегнуць KeyError +filled_dict.get("адзін") # => 1 +filled_dict.get("чатыры") # => None +# get() падтрымлівае прадвызначаны аргумент, калі значэнне адсутнічае ў слоўніку +filled_dict.get("адзін", 4) # => 1 +filled_dict.get("чатыры", 4) # => 4 + +# "setdefault()" устаўляе ў слоўнік толькі калі дадзенага ключа не існуе +filled_dict.setdefault("пяць", 5) # filled_dict["пяць"] цяпер 5 +filled_dict.setdefault("пяць", 6) # filled_dict["пяць"] усё яшчэ 5 + +# Дадаванне ў слоўнік +filled_dict.update({"чатыры":4}) +# => {"адзін": 1, "два": 2, "тры": 3, "чатыры": 4} +filled_dict["чатыры"] = 4 # іншы спосаб дадаць у слоўнік + +# Выдаленне ключоў са слоўніка праз del +del filled_dict["адзін"] # выдаляе ключ "адзін" з запоўненага слоўніка + +# З версіі Python 3.5 таксама існуюць дадатковыя спосабы распакоўкі +{'a': 1, **{'b': 2}} # => {'a': 1, 'b': 2} +{'a': 1, **{'a': 2}} # => {'a': 2} + + + +# Мноства змяшчаюць... Ну, мноства +empty_set = set() +# Ініцыялізваць мноства з кучы значэнняў +some_set = {1, 1, 2, 2, 3, 4} # some_set цяпер {1, 2, 3, 4} + +# Адпаведна ключам слоўніка, элементы мноства павінны быць нязменнымі +invalid_set = {[1], 1} # => Выкідвае TypeError: unhashable type: 'list' +valid_set = {(1,), 1} + +# Дадаць яшчэ адзін элемент у мноства +filled_set = some_set +filled_set.add(5) # filled_set цяпер {1, 2, 3, 4, 5} +# Мноства не змяшчаюць паўторных элементаў +filled_set.add(5) # застаецца ранейшым {1, 2, 3, 4, 5} + +# Перасячэнне мностваў праз & +other_set = {3, 4, 5, 6} +filled_set & other_set # => {3, 4, 5} + +# Аб'яднанне мностваў праз | +filled_set | other_set # => {1, 2, 3, 4, 5, 6} + +# Рознасць мностваў праз - +{1, 2, 3, 4} - {2, 3, 5} # => {1, 4} + +# Сіметрычная рознасць мностваў праз ^ +{1, 2, 3, 4} ^ {2, 3, 5} # => {1, 4, 5} + +# Праверыць, ці з'яўляецца мноства злева надмноствам мноства справа +{1, 2} >= {1, 2, 3} # => False + +# Праверыць, ці з'яўляецца мноства злева падмноствам мноства справа +{1, 2} <= {1, 2, 3} # => True + +# Праверка на наяўнасць у мностве праз in +2 in filled_set # => True +10 in filled_set # => False + +# Зрабіць копію глыбінёй у адзін слой +filled_set = some_set.copy() # filled_set цяпер {1, 2, 3, 4, 5} +filled_set is some_set # => False + + +#################################################### +## 3. Паток кіравання і ітэрабельныя аб'екты +#################################################### + +# Давайце зробім пераменную +some_var = 5 + +# Так выглядае інструкцыя if. Водступы маюць значэнне ў Python! +# Заведзена выкарыстоўваць чатыры прабелы, не табуляцыю. +# Гэта выводзіць "some_var меньшая за 10" +if some_var > 10: + print("some_var цалкам большая за 10.") +elif some_var < 10: # гэты elif неабавязковы. + print("some_var меньшая за 10.") +else: # гэта таксама неабавязкова. + print("some_var насамрэч 10.") + + +""" +Ітэраванне спісаў праз цыкл for +выводзіць: + сабакі — млекакормячыя + каты — млекакормячыя + мышы — млекакормячыя +""" +for animal in ["сабакі", "каты", "мышы"]: + # Вы можаце выкарыстоўваць format() для ўводу фарматаваных радкоў + print("{} — млекакормячыя".format(animal)) + +""" +"range(number)" вяртае ітэрабельны аб'ект з лічбаў +ад 0 да дадзенай лічбы (не ўключна) +выводзіць: + 0 + 1 + 2 + 3 +""" +for i in range(4): + print(i) + +""" +"range(lower, upper)" вяртае ітэрабельны аб'ект з лічбаў +ад ніжэйшай(lower) да вышэйшай(upper) лічбы +выводзіць: + 4 + 5 + 6 + 7 +""" +for i in range(4, 8): + print(i) + +""" +"range(lower, upper, step)" вяртае ітэрабельны аб'ект з лічбаў +ад ніжэйшай да вышэйшай лічбы з дадзеным крокам. Калі крок не +вызначаны, прадвызначаным значэннем з'яўляецца 1 +выводзіць: + 4 + 6 +""" +for i in range(4, 8, 2): + print(i) + +""" +Прайсці цыклам праз спіс, каб атрымаць індэкс і значэнне кожнага элемента: + 0 сабака + 1 кот + 2 мыш +""" +animals = ["сабака", "кот", "мыш"] +for i, value in enumerate(animals): + print(i, value) + +""" +Цыклы while працуюць пакуль умова не парушана +prints: + 0 + 1 + 2 + 3 +""" +x = 0 +while x < 4: + print(x) + x += 1 # Скарачэнне x = x + 1 + +# Апрацоўка выключэнняў праз блок try/except +try: + # Выкарыстоўвайце "raise" каб выкінуць памылку + raise IndexError("Гэта памылка індэкса") +except IndexError as e: + pass # Не рабіце так, забяспечце аднаўленне. +except (TypeError, NameError): + pass # Некалькі выключэнняў можна апрацоўваць сумесна. +else: # Неабавязковая частка блока try/except. Павінна быць + # пасля ўсіх блокаў except. + print("Усё добра!") # Выконваецца толькі калі код унутры try не выкідвае + # выключэнняў +finally: # Выконваецца пры ўсіх абставінах. + print("Тут можна пачысціць рэсурсы") + +# Замест try/finally для ачысткі рэсурсаў магчыма выкарыстоўваць with +with open("myfile.txt") as f: + for line in f: + print(line) + +# Запіс у файл +contents = {"aa": 12, "bb": 21} +with open("myfile1.txt", "w") as file: + file.write(str(contents)) # запісвае радок у файл + +import json +with open("myfile2.txt", "w") as file: + file.write(json.dumps(contents)) # запісвае аб'ект у файл + +# Reading from a file +with open('myfile1.txt', "r") as file: + contents = file.read() # чытае радок з файла +print(contents) +# выводзіць: {"aa": 12, "bb": 21} + +with open('myfile2.txt', "r") as file: + contents = json.load(file) # чытае json аб'ект з файла +print(contents) +# выводзіць: {"aa": 12, "bb": 21} + + +# Python прапануе фундаментальную абстракцыю +# пад назвай Iterable ("ітэрабельны аб'ект" далей). +# Ітэрабельны аб'ект — гэта аб'ект, які можна разглядаць як паслядоўнасць. +# Аб'ект, які вяртаецца функцыяй range, з'яўляецца ітэрабельным. + +filled_dict = {"адзін": 1, "два": 2, "тры": 3} +our_iterable = filled_dict.keys() +print(our_iterable) # => dict_keys(['адзін', 'два', 'тры']). Гэта аб'ект, + # які рэалізуе інтэрфейс Iterable. + +# Мы можам прайсці па яму цыклам +for i in our_iterable: + print(i) # Выводзіць адзін, два, тры + +# Аднак, да элементаў нельга звяртацца па індэксу +our_iterable[1] # Выкідвае TypeError + +# Ітэрабельны аб'ект ведае, як стварыць ітэратар +our_iterator = iter(our_iterable) + +# Наш ітэратар з'яўляецца аб'ектам, які можа запамінаць +# стан падчас нашага праходу праз яго. +# Мы можам атрымаць наступны аб'ект з дапамогаю "next()" +next(our_iterator) # => "адзін" + +# Ён утрымлівае стан, пакуль мы ітэруем +next(our_iterator) # => "два" +next(our_iterator) # => "тры" + +# Калі ітэратар вярнуў усе дадзеныя, ён выкідвае выключэнне StopIteration +next(our_iterator) # Выкідвае StopIteration + +# Мы таксама можам прайсці па яму цыклам, +# насамрэч, "for" ускосна гэта і робіць +our_iterator = iter(our_iterable) +for i in our_iterator: + print(i) # Выводзіць адзін, два, тры + +# Вы можаце захапіць усе элементы ітэрабельнага аб'екта або ітэратара +# праз вызаў list() +list(our_iterable) # => Вяртае ["адзін", "два", "тры"] +list(our_iterator) # => Вяртае [], бо стан захоўваецца + + +#################################################### +## 4. Функцыі +#################################################### + +# Выкарыстоўвайце "def" для стварэння новых функцый +def add(x, y): + print("x = {}, а y - {}".format(x, y)) + return x + y # Вяртайце значэнні праз return + +# Вызаў функцый з параметрамі +add(5, 6) # => выводзіць "x = 5, а y = 6" і вяртае 11 + +# Таксама магчыма вызываць функцыі з найменнымі аргументамі +add(y=6, x=5) # Найменныя аргументы можна выкарыстоўваць у любым парадку + +# Вы можаце вызначыць функцыю, якая прымае зменлівую колькасць +# пазіцыйных аргументаў +def varargs(*args): + return args + +varargs(1, 2, 3) # => (1, 2, 3) + +# Таксама, вы можаце вызначаць функцыі, якія прымаюць зменлівую колькасць +# найменных аргументаў +def keyword_args(**kwargs): + return kwargs + +# Давайце вызавем яе і паглядзім, што будзе +keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"} + + +# Вы можаце выкарыстоўваць два спосабы адначасова, калі хочаце +def all_the_args(*args, **kwargs): + print(args) + print(kwargs) +""" +all_the_args(1, 2, a=3, b=4) выводзіць: + (1, 2) + {"a": 3, "b": 4} +""" + +# Вызываючы функцыі, вы можаце зрабіць адваротнае args/kwargs! +# Выкарыстоўвайце * для разгортвання пазіцыйных аргументаў (картэжаў) +# і ** для разгортвання найменных аргументаў (слоўнікаў) +args = (1, 2, 3, 4) +kwargs = {"a": 3, "b": 4} +all_the_args(*args) # адпавядае: all_the_args(1, 2, 3, 4) +all_the_args(**kwargs) # адпавядае: all_the_args(a=3, b=4) +all_the_args(*args, **kwargs) # адпавядае: all_the_args(1, 2, 3, 4, a=3, b=4) + +# Вяртанне некалькіх значэнняў (з прызначэннем картэжаў) +def swap(x, y): + return y, x # Вяртае некалькі значэнняў у выглядзе картэжу без дужак. + # (Заўвага: дужкі апускаюцца, але могуць выкарыстоўвацца) + +x = 1 +y = 2 +x, y = swap(x, y) # => x = 2, y = 1 +# (x, y) = swap(x,y) # Зноў жа, выкарыстоўваць дужкі неабавязкова + +# глабальная вобласць +x = 5 + +def set_x(num): + # лакальная вобласць пачынаецца тут + # лакальная пераменная x адрозніваецца ад глабальнай + x = num # => 43 + print(x) # => 43 + +def set_global_x(num): + # global пазначае, што пераменная знаходзіцца ў глабальнай вобласці + global x + print(x) # => 5 + x = num # глабальная пераменная x цяпер 6 + print(x) # => 6 + +set_x(43) +set_global_x(6) +""" +выводзіць: + 43 + 5 + 6 +""" + + +# Python падтрымлівае функцыі першага класа +def create_adder(x): + def adder(y): + return x + y + return adder + +add_10 = create_adder(10) +add_10(3) # => 13 + +# Замыканні ва ўкладзеных функцыях: +# Мы можам выкарыстоўваць ключавое слова nonlocal для працы з пераменнымі +# ўнутры ўкладзенай вобласці, якія не павінны быць аб'яўлены ва ўнутраных +# функцыях. +def create_avg(): + total = 0 + count = 0 + def avg(n): + nonlocal total, count + total += n + count += 1 + return total/count + return avg +avg = create_avg() +avg(3) # => 3.0 +avg(5) # (3+5)/2 => 4.0 +avg(7) # (8+7)/3 => 5.0 + +# Таксама існуюць ананімныя функцыі +(lambda x: x > 2)(3) # => True +(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5 + +# Існуюць убудаваныя функцыі вышэйшага парадку +list(map(add_10, [1, 2, 3])) # => [11, 12, 13] +list(map(max, [1, 2, 3], [4, 2, 1])) # => [4, 2, 3] + +list(filter(lambda x: x > 5, [3, 4, 5, 6, 7])) # => [6, 7] + +# Для прыгажосці, замест map і filter мы можам выкарыстоўваць спісачныя выразы +# Спісачныя выразы захоўваюць вынік у выглядзе спіса (які сам па сабе можа +# быць укладзеным). +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] + +# Таксама вы можаце стварыць адпаведныя выразы для мностваў і слоўнікаў +{x for x in 'abcddeef' if x not in 'abc'} # => {'d', 'e', 'f'} +{x: x**2 for x in range(5)} # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16} + + +#################################################### +## 5. Модулі +#################################################### + +# Вы можаце імпартаваць модулі +import math +print(math.sqrt(16)) # => 4.0 + +# Вы можаце ўзяць дакладныя функцыі з модуля +from math import ceil, floor +print(ceil(3.7)) # => 4 +print(floor(3.7)) # => 3 + +# Вы можаце імпартаваць усе функцыі з модуля. +# Заўвага: не рэкамендуецца так рабіць. +from math import * + +# Вы можаце скарачаць імёны модуляў +import math as m +math.sqrt(16) == m.sqrt(16) # => True + +# Модулі ў Python з'яўляюцца звычайнымі Python файламі. Вы можаце напісаць +# свае і імпартаваць іх. Імя модуля адпавядае імені файла. + +# Вы можаце даведацца, якія функцыі і атрыбуты вызначаны ў модулі +import math +dir(math) + +# Калі ў вас ёсць Python-скрыпт з назвай math.py у той жа папцы, +# што і бягучы скрыпт, файл math.py будзе загружаны замест убудаванага +# Python-модуля. Гэта адбываецца таму, што лакальная папка мае большы +# прыярытэт, чым убудаваныя Python-бібліятэкі. + + +#################################################### +## 6. Класы +#################################################### + +# Мы выкарыстоўваем інструкцыю "class" для стварэння класаў +class Human: + + # Атрыбут класа. Яго першапачатковае значэнне пашыраецца + # паміж усімі экзэмплярамі класа. + species = "H. sapiens" + + # Базавы канструктар, вызываецца пры стварэнні экзэмпляраў класа. + # Звярніце ўвагу, што двайное падкрэсліванне абазначае аб'екты або + # атрыбуты, якія выкарыстоўвае Python, але яны існуюць у прасторах назваў, + # якія кантралюе карыстальнік. Метады(або аб'екты ці атрыбуты), такія як + # __init__, __str__, __repr__ і г.д., называюцца спецыяльнымі метадамі, + # або магічнымі метадамі. Вам не варта ствараць такія імёны самастойна. + def __init__(self, name): + # Прызначэнне аргумента атрыбуту name экзэмпляра класа + self.name = name + + # Ініцыялізацыя ўласцівасці + self._age = 0 # папярэдняе падкрэсліванне абазначае, што ўласцівасць + # "age" створана для ўнутранага выкарыстання, + # але гэта ніяк не кантралюецца, а з'яўляецца + # звычайнай падказкай для іншых распрацоўшчыкаў. + + # Метад экзэмпляра. Усе метады прымаюць "self" у якасці першага аргумента. + def say(self, msg): + print("{name}: {message}".format(name=self.name, message=msg)) + + # Іншы метад экзэмпляра + def sing(self): + return 'ёў... ёў... праверка мікрафона... раз два... раз два...' + + # Метад класа пашыраецца паміж усімі экзэмплярамі. + # Яны вызываюцца з указаннем вызываючага класа ў якасці першага аргумента. + @classmethod + def get_species(cls): + return cls.species + + # Статычны метад вызываецца без спасылкі на клас або экзэмпляр + @staticmethod + def grunt(): + return "*рохкае*" + + # property зусім як гетэр + # гэты дэкаратар ператварае метад age() у аднайменны атрыбут, + # даступны толькі для чытання. + # У Python не трэба пісаць трывіяльныя гетэры і сэтэры, дарэчы. + @property + def age(self): + return self._age + + # Гэта дазваляе ўстанавіць уласцівасць + @age.setter + def age(self, age): + self._age = age + + # Гэта дазваляе выдаліць уласцівасць + @age.deleter + def age(self): + del self._age + + +# Калі інтэрпрэтатар Python чытае зыходны файл, ён выконвае ўвесь код. +# З дапамогай гэтай праверкі, блок кода выконваецца толькі калі модуль +# з'яўляецца асноўнай праграмай. +if __name__ == '__main__': + # Стварэнне экзэмпляра класа + i = Human(name="Ігар") + i.say("вітан") # "Ігар: вітан" + j = Human("Янка") + j.say("вітаю") # "Янка: вітаю" + # i з j з'яўляюцца экзэмплярамі тыпу Human, г.з., яны аб'екты Human + + # Вызаў метаду класа + i.say(i.get_species()) # "Ігар: H. sapiens" + # Змена агульнага атрыбута + Human.species = "H. neanderthalensis" + i.say(i.get_species()) # => "Ігар: H. neanderthalensis" + j.say(j.get_species()) # => "Янка: H. neanderthalensis" + + # Вызаў статычнага метаду + print(Human.grunt()) # => "*рохкае*" + + # Статычны метад магчыма вызваць таксама з экзэмпляра + print(i.grunt()) # => "*рохкае*" + + # Абнавіць уласцівасць для гэтага экзэмпляра + i.age = 42 + # Атрымаць уласцівасць + i.say(i.age) # => "Ігар: 42" + j.say(j.age) # => "Янка: 0" + # Выдаліць уласцівасць + del i.age + # i.age # => гэта выкіне AttributeError + + +#################################################### +## 6.1 Наследаванне +#################################################### + +# Наследаванне дазваляе вызначаць новыя вытворныя класы, якія наследуюць +# метады і пераменныя сваіх базавых класаў. + +# Выкарыстоўваючы клас Human, вызначаны раней, у якасці базавага або +# класа-папярэдніка, мы можам вызначыць вытворны клас Superhero, які наследуе +# пераменныя класа(species, name, age) і метады(sing, grunt) з класа Human, +# але таксама мае свае ўнікальныя ўласцівасці. + +# Каб выкарыстаць перавагі файлавай модульнасці, вы можаце змясціць класы +# ў асобныя файлы, напрыклад, human.py + +# Каб імпартаваць функцыі з іншых файлаў, выкарыстоўвайце наступны фармат +# from "імя-файла-без-пашырэння" import "функцыя-або-клас" + +from human import Human + + +# Пазначце клас-папярэднік ў якасці параметра ў вызначэнні вытворнага класа +class Superhero(Human): + + # Калі вытворнаму класу трэба толькі ўнаследаваць усе вызначэнні + # класа-папярэдніка без мадыфікацый, вы можаце выкарыстаць ключавое + # слова "pass" (і нічога больш), але ў гэтым выпадку яно закаментавана, + # каб мець магчымасць стварыць унікальны клас + # pass + + # Вытворныя класы могуць перавызначыць атрыбуты папярэднікаў + species = 'Суперчалавек' + + # Вытворныя класы аўтаматычна наследуюць канструктары папярэднікаў разам + # з аргументамі, але таксама могуць вызначаць дадатковыя аргументы або + # вызначэнні, і перавызначаць метады, такія як канструктар класа. + # Гэты канструктар наследуе аргумент name з Human + # і дадае superpowers і movie: + def __init__(self, name, movie=False, + superpowers=["суперсіла", "куленепрабівальнасць"]): + + # дадаць дадатковыя атрыбуты класа: + self.fictional = True + self.movie = movie + # сцеражыцеся прадвызначаных значэнняў зменных тыпаў, + # паколькі яны абагульняюцца + self.superpowers = superpowers + + # Функцыя "super" дазваляе атрымаць доступ да метадаў папярэдніка, + # якія былі перавызначаны ў вытворным класе, у гэтым выпадку + # да метаду __init__. + # Вызаў канструктара класа-папярэдніка: + super().__init__(name) + + # перавызначыць метад sing + def sing(self): + return 'Шчучыншчына!' + + # дадаць дадатковы метад экзэмпляра + def boast(self): + for power in self.superpowers: + print("Я маю такую моц, як {pow}!".format(pow=power)) + + +if __name__ == '__main__': + sup = Superhero(name="Клешч") + + # Праверка тыпу экзэмпляра + if isinstance(sup, Human): + print('Я — чалавек') + if type(sup) is Superhero: + print('Я — супергерой') + + # Атрымаць "Парадак Вырашэння Метаду"(Method Resolution Order), які + # выкарыстоўваюць getattr() і super() + # (парадак, у якім адбываецца пошук атрыбутаў або метадаў у класе). + # Гэты атрыбут дынамічны і можа абнаўляцца. + print(Superhero.__mro__) # => (<class '__main__.Superhero'>, + # => <class 'human.Human'>, <class 'object'>) + + # Вызывае метад папярэдніка, але выкарыстоўвае ўласны атрыбут класа + print(sup.get_species()) # => Суперчалавек + + # Вызывае перавызначаны метад + print(sup.sing()) # => Шчучыншчына! + + # Вызывае метад з Human + sup.say('Лыжка') # => Клешч: Лыжка + + # Вызывае метад, які існуе толькі ўнутры Superhero + sup.boast() # => Я маю такую моц, як суперсіла! + # => Я маю такую моц, як куленепрабівальнасць! + + # Унаследаваны атрыбут класа + sup.age = 31 + print(sup.age) # => 31 + + # Атрыбут, які існуе толькі ўнутры Superhero + print('Я магу атрымаць Оскар? ' + str(sup.movie)) + +#################################################### +## 6.2 Множнае наследаванне +#################################################### + +# Вызначэнне іншага класа +# bat.py +class Bat: + + species = 'рукакрылачка' + + def __init__(self, can_fly=True): + self.fly = can_fly + + # У гэтым класе таксама ёсць метад say + def say(self, msg): + msg = '... ... ...' + return msg + + # І свой уласны метад таксама + def sonar(self): + return '))) ... (((' + +if __name__ == '__main__': + b = Bat() + print(b.say('вітаю')) + print(b.fly) + + +# І вызначэнне яшчэ аднаго класа, які наследуецца ад Superhero і Bat +# superhero.py +from superhero import Superhero +from bat import Bat + +# Вызначыць Batman у якасці вытворнага класа, +# які наследуецца ад Superhero і Bat. +class Batman(Superhero, Bat): + + def __init__(self, *args, **kwargs): + # Звычайна, каб унаследаваць атрыбуты, вам трэба вызваць super: + # super(Batman, self).__init__(*args, **kwargs) + # Аднак, мы маем справу з множным наследаваннем, а super() працуе + # толькі з наступным базавым класам у спісе MRO. + # Таму, замест гэтага мы напрамую вызываем __init__ + # для кожнага з папярэднікаў. + # Выкарыстанне *args і **kwargs дазваляе ахайна перадаць аргументы, + # якія папярэднікі будуць разбіраць слой за слоем. + Superhero.__init__(self, 'ананім', movie=True, + superpowers=['Багаты'], *args, **kwargs) + Bat.__init__(self, *args, can_fly=False, **kwargs) + # перавызначэнне значэння атрыбута name + self.name = 'Сум Афлек' + + def sing(self): + return 'шчу шчу шчу шчу Шчучыншчына!' + + +if __name__ == '__main__': + sup = Batman() + + # Парадак Вырашэння Метаду(MRO) + print(Batman.__mro__) # => (<class '__main__.Batman'>, + # => <class 'superhero.Superhero'>, + # => <class 'human.Human'>, + # => <class 'bat.Bat'>, <class 'object'>) + + # Вызывае метад папярэдніка, але выкарыстоўвае ўласныя атрыбуты + print(sup.get_species()) # => Суперчалавек + + # Вызывае перавызначаны метад + print(sup.sing()) # => шчу шчу шчу шчу Шчучыншчына! + + # Вызывае метад з Human, бо парадак наследавання мае значэнне + sup.say('згодны') # => Сум Афлек: згодны + + # Вызывае метад, які існуе толькі ў другім папярэдніку + print(sup.sonar()) # => ))) ... ((( + + # Унаследаваны атрыбут класа + sup.age = 100 + print(sup.age) # => 100 + + # Унаследаваны атрыбут другога папярэдніка, прадвызначаныя значэнні + # якога былі пераназначаны + print('Я ўмею лятаць? ' + str(sup.fly)) # => Я ўмею лятаць? False + + + +#################################################### +## 7. Дадаткова +#################################################### + +# Генератары дапамагаюць пісаць лянівы код +def double_numbers(iterable): + for i in iterable: + yield i + i + +# Генератары эфектыўна выкарыстоўваюць памяць, таму што загружаюць толькі +# даныя, патрэбныя для апрацоўкі наступнага кроку ітэрацыі. Гэта дазваляе +# ім выконваць аперацыі з вялікімі дыяпазонамі даных, якія ў іншых выпадках +# былі б недапушчальнымі. +# Заўвага: `range` замяняе `xrange` у Python 3. +for i in double_numbers(range(1, 900000000)): # `range` гэта генератар. + print(i) + if i >= 30: + break + +# Адпаведна спісачным выразам, магчыма таксама ствараць генератарныя выразы. +values = (-x for x in [1,2,3,4,5]) +for x in values: + print(x) # выводзіць -1 -2 -3 -4 -5 у кансоль/тэрмінал + +# Таксама вы можаце ператварыць генератарны выраз прама ў спісак. +values = (-x for x in [1,2,3,4,5]) +gen_to_list = list(values) +print(gen_to_list) # => [-1, -2, -3, -4, -5] + + +# Дэкаратары з'яўляюцца формай сінтаксічнага цукру. +# Нягледзячы на дзіўны сінтаксіс, яны робяць код лягчэйшым для прачытання. + +# Абгорткі — адзін з відаў дэкаратараў. +# З іх дапамогай вельмі зручна дадаваць лагіраванне ў існуючыя функцыі без +# неабходнасці іх мадыфікаваць. + +def log_function(func): + def wrapper(*args, **kwargs): + print("Уваход у функцыю", func.__name__) + result = func(*args, **kwargs) + print("Выхад з функцыі", func.__name__) + return result + return wrapper + +@log_function # адпаведнік: +def my_function(x,y): # def my_function(x,y): + return x+y # return x+y + # my_function = log_function(my_function) +# Дэкаратар @log_function кажа, што падчас прачытання вызначэння функцыі +# my_function, яна будзе абгорнута ў log_function. +# Калі вызначэнні функцый доўгія, можа быць цяжка апрацаваць неабгорнутыя +# прызначэнні ў канцы вызначэнняў. + +my_function(1,2) # => "Уваход у функцыю my_function" + # => "3" + # => "Выхад з функцыі my_function" + +# Але ёсць праблема. +# Што калі мы паспрабуем атрымаць якую-небудзь інфармацыю пра my_function? + +print(my_function.__name__) # => 'wrapper' +print(my_function.__code__.co_argcount) # => 0. argcount у выніку 0 таму, што абодва аргументы ў сігнатуры wrapper() з'яўляюцца апцыянальнымі. + +# Таму, што наш дэкаратар адпавядае my_function = log_function(my_function), +# мы замянілі інфармацыю аб my_function інфармацыяй з абгорткі. + +# Выправіць гэта праз functools + +from functools import wraps + +def log_function(func): + @wraps(func) # Гэта гарантуе, што дакументацыйны радок (docstring), імя + # функцыі, спіс аргументаў і інш., капіруюцца ў выніковую + # функцыю замест іх замены інфармацыяй з абгорткі. + def wrapper(*args, **kwargs): + print("Уваход у функцыю ", func.__name__) + result = func(*args, **kwargs) + print("Выхад з функцыі ", func.__name__) + return result + return wrapper + +@log_function +def my_function(x,y): + return x+y + +my_function(1,2) # => "Уваход у функцыю my_function" + # => "3" + # => "Выхад з функцыі my_function" + +print(my_function.__name__) # => 'my_function' +print(my_function.__code__.co_argcount) # => 2 +``` + +### Бясплатныя анлайн-рэсурсы + +* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com) +* [The Official Docs](https://docs.python.org/3/) +* [Hitchhiker's Guide to Python](https://docs.python-guide.org/en/latest/) +* [Python Course](https://www.python-course.eu) +* [Free Interactive Python Course](http://www.Kikodo.io) +* [First Steps With Python](https://realpython.com/learn/python-first-steps/) +* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python) +* [30 Python Language Features and Tricks You May Not Know About](https://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html) +* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/) +* [Python 3 Computer Science Circles](https://cscircles.cemc.uwaterloo.ca/) +* [Dive Into Python 3](https://www.diveintopython3.net/index.html) +* [A Crash Course in Python for Scientists](https://nbviewer.jupyter.org/gist/anonymous/5924718) +* [Python Tutorial for Intermediates](https://pythonbasics.org/) +* [Build a Desktop App with Python](https://pythonpyqt.com/) |