Ներածություն Python- ին

Այս գլխի մի մասը հիմնված է Geek Girls Carrots- ի (https://github.com/ggcarrots/django-carrots) ձեռնարկների վրա:

Եկեք գրենք մի քանի ծրագրեր:

Python prompt (կահակալ)

Ընթերցողների համար տանը. Այս մասը ներառված է Python Basics: Integers, Strings, Lists, Variables and Errors (Python- ի հիմունքներ. Ամբողջ թվեր, տողեր, ցուցակներ, փոփոխականներ և սխալներ) տեսանյութում:

Python- ի հետ խաղալու համար մենք պետք է ձեր համակարգչում բացենք command line (հրամանի տող): Դուք արդեն պետք է իմանաք, թե ինչպես դա անել. Դուք դա սովորել եք Intro to Command Line (Հրամանի տողի ներածություն) գլխում:

Պատրաստ լինելուց հետո հետևեք ստորև ներկայացված հրահանգներին:

Մենք ուզում ենք Python կոնսոլ բացել, այնպես որ Windows- ում մուտքագրեք python կամ Mac OS / Linux համակարգում python3 և սեղմեք enter:

command-line

$ python3
Python {{ book.py_release }} (...)
Type "help", "copyright", "credits" or "license" for more information.
>>>

Ձեր առաջին Python command-ը (հրամանը):

Python հրամանը գործարկելուց հետո հուշումը փոխվեց >>>. Մեզ համար սա նշանակում է, որ առայժմ մենք կարող ենք օգտագործել միայն Python լեզվով հրամաններ: Պետք չէ մուտքագրել >>> - Python- ը դա կանի ձեզ համար:

Եթե ​​ցանկանում եք ցանկացած պահի դուրս գալ Python- ի վահանակից, մուտքագրեք ելք () կամ օգտագործեք դյուրանցում Ctrl + Z Windows- ի և Ctrl + D Mac / Linux- ի համար: Այդ դեպքում >>>այլևս չեք տեսնի:

Առայժմ մենք չենք ցանկանում դուրս գալ Python կոնսոլից: Մենք ուզում ենք ավելին իմանալ դրա մասին: Եկեք սկսենք մուտքագրել մի քանի մաթեմատիկա, ինչպիսին է 2 + 3 և սեղմելով մուտքագրումը:

command-line

>>> 2 + 3
5

Հոյակապ. Տեսեք, թե ինչպես հայտնվեց պատասխանը: Python- ը գիտի մաթեմատիկա: Կարող եք փորձել այլ հրամաններ, ինչպիսիք են ՝

• 4 * 5
• 5 - 1
• 40 / 2

Էքսպոնենտալ հաշվարկ կատարելու համար ասենք 2 հզորության 3-ը ՝ մենք մուտքագրում ենք.

command-line (հրամանի տող)

>>> 2 ** 3
8

Մի փոքր զվարճացեք դրանով, ապա վերադառնաք այստեղ :)

Ինչպես տեսնում եք, Python- ը հիանալի հաշվիչ է: Եթե ​​մտածում եք, թե էլ ինչ կարող եք անել ...

Strings (տողեր)

Ինչ վերաբերում է ձեր անունին: Մուտքագրեք ձեր անունը այսպիսի մեջբերումներում.

command-line

>>> "Ola"
'Ola'

Դուք այժմ ստեղծել եք ձեր առաջին string-ը (տողը): Դա նիշերի հաջորդականություն է, որը կարող է մշակվել համակարգչի կողմից: String-ը միշտ պետք է սկսվի և ավարտվի նույն նիշով: Սա կարող է լինել միայնակ (') կամ կրկնակի (") մեջբերումներ (տարբերություն չկա:) Գնանշումները Python- ին ասում են, որ իրենց մեջ եղածը string է:

String-երը կարելի է միասին դնել: Փորձեք այս:

command-line

>>> "Hi there " + "Ola"
'Hi there Ola'

Դուք կարող եք նաև բազմապատկել տողերը մի թվով.

command-line

>>> "Ola" * 3
'OlaOlaOla'

Եթե ​​ձեզ հարկավոր է ապոստերֆ դնել ձեր string-ի ներսում, ապա դա անելու երկու եղանակ ունեք:

Օգտագործելով կրկնակի գնանշումներ.

command-line

>>> "Runnin' down the hill"
"Runnin' down the hill"

կամ հետադարձ աղեղից խուսափելուց (\):

command-line

>>> 'Runnin\' down the hill'
"Runnin' down the hill"

Հետաքրքիր է, ոչ: Ձեր անունը մեծատառով տեսնելու համար մուտքագրեք ՝

command-line

>>> "Ola".upper()
'OLA'

Դուք հենց ձեր string-ի (տողի) վրա օգտագործեցիք upper(վերին) method(մեթոդը): Մեթոդը (ինչպիսին է upper() (վերին ())) հրահանգների հաջորդականությունն է, որը Python- ը պետք է կատարի տվյալ օբյեկտի վրա («Օլա»), երբ այն զանգահարեք:

Եթե ​​ուզում եք իմանալ ձեր անվան մեջ պարունակվող տառերի քանակը, դրա համար կա function ( գործառույթ) :

command-line

>>> len("Ola")
3

Հետաքրքիր է, թե ինչու եք երբեմն function-ներ (ֆունկցիաներ) կանչում a . String-ի (տողի) վերջում (ինչպես "Ola".upper()) և երբեմն նախ կանչում ես ֆունկցիա և string-ը դնում փակագծերում: Դե, որոշ դեպքերում function-ները (ֆունկցիաները) պատկանում են object-ների (օբյեկտների), ինչպես, օրինակ, վերին (), որը կարող է կատարվել միայն տողերի վրա: Այս դեպքում մենք function (ֆունկցիան) անվանում ենք method (մեթոդ) : Այլ ֆունկցիաներ, գործառույթները չեն պատկանում որևէ կոնկրետ բանի և կարող են օգտագործվել տարբեր տեսակի օբյեկտների վրա, ինչպես len (): Այդ պատճառով մենք"Ola" որպես պարամետր ենք տալիս len գֆունկցիաին:

Ամփոփում

Լավ, բավական է string-եր: Մինչ այժմ իմացել եք.

• prompt-ը - Python- ի մեջ հրահանգներ (code / կոդ) մուտքագրելը Python- ում տալիս է պատասխաններ
• numbers and strings (թվերն ու տողերը) - Python- ի համարներում օգտագործվում են մաթեմատիկայի համար, իսկ string-երը `տեքստային object- ների (օբյեկտների) համար
• operators (օպերատորները) - ինչպիսիք են + և *, միավորում են արժեքները ՝ նորը արտադրելու համար
• function-ներ - ինչպես upper() և len(), գործողություններ կատարել օբյեկտների վրա:

Սրանք յուրաքանչյուր սովորած ծրագրավորման լեզվի հիմունքներն են: Պատրա՞ստ եք ավելի դժվար բանի:

Errors (Սխալներ)

Փորձենք մի նոր բան: Կարո՞ղ ենք համարի երկարությունը ստանալ նույն կերպ, ինչպես կարող էինք պարզել մեր անվան երկարությունը: Մուտքագրեք len(304023) և սեղմեք enter:

command-line

>>> len(304023)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()

Մենք ստացանք մեր առաջին սխալը: icon-ը (պատկերակը) ձեզ նախապատվություն տալու այն ձևն է, որ այն կոդը, որը պատրաստվում եք գործարկել, չի աշխատի ինչպես սպասվում էր: Սխալներ թույլ տալը (նույնիսկ դիտավորյալները) ուսման կարևոր մասն է:

Այն ասում է, որ «int» տեսակի object-ները (օբյեկտները) (integers/ ամբողջ թվեր) երկարություն չունեն: Այսպիսով, ի՞նչ կարող ենք անել հիմա: Միգուցե կարո՞ղ ենք մեր թիվը գրել որպես string: String-երն ունեն length (երկարություն), չէ՞:

command-line

>>> len(str(304023))
6

Դա աշխատեց! Մենք str գործառույթի ներսում օգտագործեցինք str() function-ը: str() ամեն ինչ վերածում է string-երի:

• str function (ֆունկցիան) իրերը վերափոխում է string-երի
• int function (ֆունկցիան) իրերը վերափոխում է integers

Կարևոր. Մենք կարող ենք թվերը վերածել տեքստի, բայց պարտադիր չէ, որ տեքստը վերածենք թվերի. Ի՞նչ կլինի ամեն դեպքում int('hello'):

Variables (Փոփոխականներ)

Mingրագրավորման կարևոր հայեցակարգը variable- ներն (փոփոխականներն) են: Varaible-ը (Փոփոխականը) ոչ այլ ինչ է, քան ինչ-որ բանի անուն, այնպես որ այն հետագայում կարող եք օգտագործել: ծրագրավորողներ օգտագործում են այս փոփոխականները տվյալներ պահելու, իրենց կոդերն ավելի ընթեռնելի դարձնելու համար և ստիպված չեն անընդհատ հիշել, թե ինչ բաներ են:

Ասենք, որ ուզում ենք ստեղծել նոր variable (փոփոխական), որը կոչվում է name (անուն):

command-line

>>> name = "Ola"

Մենք մուտքագրում ենք name-ը (անունը) հավասար է Ola:

Ինչպես նկատել եք, ձեր ծրագիրը չի վերադարձրել այլ բան, ինչպես նախկինում էր: Այսպիսով, ինչպե՞ս իմանանք, որ variable-ն (փոփոխականն) իրականում գոյություն ունի: Մուտքագրեք name (անունը) և սեղմեք enter (մուտքագրեք)

command-line

>>> name
'Ola'

Ձեր առաջին variable-ը փոփոխականը! :) Դուք միշտ կարող եք փոխել այն, ինչին վերաբերում է.

command-line

>>> name = "Sonja"
>>> name
'Sonja'

Այն կարող եք օգտագործել նաև function-ներում.

command-line

>>> len(name)
5

Հիանալի է, չէ՞: Այժմ variable-ները (փոփոխականները )կարող են լինել ցանկացած ՝ թվեր նույնպես: Փորձեք այս:

command-line

>>> a = 4
>>> b = 6
>>> a * b
24

Բայց ի՞նչ կլինի, եթե մենք սխալ անուն օգտագործենք: Կարո՞ղ եք գուշակել, թե ինչ կլինի: Արի փորձենք!

command-line

>>> city = "Tokyo"
>>> ctiy
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'ctiy' is not defined

Սխալ! Ինչպես տեսնում եք, Python- ն ունի տարբեր տեսակի սխալներ, և այս մեկը կոչվում է NameError : Python- ը ձեզ կտա այս սխալը, եթե փորձեք օգտագործել դեռ չսահմանված variable (փոփոխական): Եթե ​​ավելի ուշ այս սխալի եք բախվել, ստուգեք ձեր կոդը ՝ ստուգելու համար, արդյոք սխալ եք մուտքագրել որևէ անուն:

Մի փոքր խաղացեք սրա հետ և տեսեք, թե ինչ կարող եք անել:

Print function (Տպման գործառույթը)

Փորձեք այս:

command-line

>>> name = 'Maria'
>>> name
'Maria'
>>> print(name)
Maria

Երբ դուք պարզապես մուտքագրում եք name (անուն), Python- ի թարգմանիչը պատասխանում է 'name' variable (փոփոխական) string-ի (տող) ներկայացմամբ , որը M-a-r-i-a տառերն են, որոնք շրջապատված են մեկ չակերտով, ": Երբ ասում եք տպել (անունը), Python- ը "print"-կանի («կտպագրի») variable-ի պարունակությունը էկրանին ՝ առանց չակերտների, որը ավելի կոկիկ է:

Ինչպես կտեսնենք ավելի ուշ, print () - ը օգտակար է նաև այն ժամանակ, երբ մենք ուզում ենք գործերը ներսից function-ներ տպել, կամ երբ ուզում ենք իրեր տպել բազմաթիվ տողերի վրա:

Lists (ցուցակները)

String-երի և integer-ի (թվերի) հետ մեկտեղ Python- ն ունի ամենատարբեր տեսակի object-ներ (օբյեկտներ): Այժմ մենք պատրաստվում ենք ներկայացնել մեկը, որը կոչվում է list (ցուցակ) : Ծուցակները հենց այն են, ինչ դուք կարծում եք. օբյեկտներ, որոնք այլ օբյեկտների ցուցակներ են: :)

Գնացեք և ստեղծեք ցուցակ.

command-line

>>> []
[]

Այո, այս ցուցակը դատարկ է: Շատ օգտակար չէ, չէ՞: Եկեք ստեղծենք վիճակախաղի համարների ցուցակ: Մենք չենք ուզում անընդհատ կրկնվել, այնպես որ այն նաև կդնենք փոփոխականի մեջ.

command-line

>>> lottery = [3, 42, 12, 19, 30, 59]

Լավ, մենք ցուցակ ունենք: Ի՞նչ կարող ենք անել դրա հետ: Տեսնենք, թե վիճակախաղի քանի համար կա ցուցակում: Դուք գաղափար ունե՞ք, թե որ function (ֆունկցիան) պետք է օգտագործեք դրա համար: Դուք դա արդեն գիտեք:

command-line

>>> len(lottery)
6

Այո՛ len() - ը կարող է ձեզ ցուցակում մի շարք օբյեկտներ տալ: Հարմար է, չէ՞: Միգուցե հիմա տեսակավորենք.

command-line

>>> lottery.sort()

Սա ոչինչ չի վերադարձնում, պարզապես փոխեց ցուցակի թվերը հայտնվելու հերթականությունը: Եկեք նորից տպենք և տեսնենք, թե ինչ է տեղի ունեցել:

command-line

>>> print(lottery)
[3, 12, 19, 30, 42, 59]

Ինչպես տեսնում եք, ձեր ցուցակի թվերն այժմ տեսակավորված են ամենացածրից բարձրագույն արժեքից: Շնորհավորանքներ

Միգուցե մենք ուզում ենք հետ շրջե՞լ այդ կարգը: Արի անենք դա!

command-line

>>> lottery.reverse()
>>> print(lottery)
[59, 42, 30, 19, 12, 3]

Եթե ցանկանում եք ինչ-որ բան ավելացնել ձեր ցուցակին, կարող եք դա անել ՝ մուտքագրելով այս հրահանգը.

command-line

>>> lottery.append(199)
>>> print(lottery)
[59, 42, 30, 19, 12, 3, 199]

Եթե ցանկանում եք ցույց տալ միայն առաջին համարը, ապա կարող եք դա անել ՝ օգտագործելով index (ինդեքսներ) : Ինդեկսը այն թիվն է, որն ասում է, թե որտեղ է ցուցակում ինչ-որ իր տեղի ունենում: Ծրագրավորողները նախընտրում են սկսել հաշվել 0-ից, այնպես որ ձեր ցուցակում առաջին օբյեկտը 0 ինդեքսում է, հաջորդը 1-ի վրա և այլն: Փորձեք այս:

command-line

>>> print(lottery[0])
59
>>> print(lottery[1])
42

Ինչպես տեսնում եք, ձեր ցուցակում կարող եք մուտք գործել տարբեր օբյեկտներ ՝ օգտագործելով ցուցակի անվանումը և քառակուսի փակագծերի ներսում գտնվող օբյեկտի ցուցիչը:

Ձեր ցուցակից ինչ-որ բան ջնջելու համար հարկավոր է օգտագործել indexes (ինդեքսները) , ինչպես սովորեցինք վերևում և pop() (փոփ()) մեթոդը: Եկեք փորձենք մի օրինակ և ամրապնդենք նախկինում սովորածը. մենք կջնջենք մեր ցուցակի առաջին համարը:

command-line

>>> print(lottery)
[59, 42, 30, 19, 12, 3, 199]
>>> print(lottery[0])
59
>>> lottery.pop(0)
59
>>> print(lottery)
[42, 30, 19, 12, 3, 199]

Դա հիանալի աշխատեց:

Լրացուցիչ զվարճանքի համար փորձեք մի քանի այլ ցուցանիշներ. 6, 7, 1000, -1, -6 կամ -1000: Տեսեք, արդյոք կարող եք կանխատեսել արդյունքը ՝ նախքան հրամանը փորձելը: Արդյո՞ք արդյունքները իմաստ ունեն:

Python- ի փաստաթղթավորման այս գլխում կարող եք գտնել ցուցակի բոլոր մատչելի մեթոդների ցուցակը. https://docs.python.org/3/tutorial/datastructures.html

Բառարաններ

Ընթերցողների համար տանը. Այս մասն ընդգրկված է Python Basics: Dictionaries (Python- ի հիմունքները: բառարաններ) տեսանյութում:

Բառարանը նման է ցուցակին, բայց արժեքներին մուտք եք գործում թվային ցուցիչի փոխարեն ստեղ փնտրելով: Բանալին կարող է լինել ցանկացած string(տո) կամ համար: Դատարկ բառարան սահմանելու համար շարահյուսությունն է.

command-line

>>> {}
{}

Սա ցույց է տալիս, որ դուք պարզապես ստեղծել եք դատարկ բառարան: Ուռա!

Այժմ փորձեք գրել հետևյալ հրահանգը (փորձեք փոխարինել նաև ձեր սեփական տեղեկությունները).

command-line

>>> participant = {'name': 'Ola', 'country': 'Poland', 'favorite_numbers': [7, 42, 92]}

Այս հրամանի միջոցով դուք պարզապես ստեղծեցիք participant (մասնակից) անունով փոփոխական `երեք առանցքային արժեքի զույգերով.

• name(անուն) ստեղնը մատնանշում է 'Ola' արժեքը (string օբյեկտ),
• country (երկիրը) մատնանշում է 'Poland' «Լեհաստան» (մեկ այլ string)
• և favorite_numbers (սիրված_համարները) ցույց են տալիս [7, 42, 92] (list (ցուցակ), որի մեջ կա երեք համար):

Անհատական ստեղների բովանդակությունը կարող եք ստուգել այս syntax (շարահյուսությամբ).

command-line

>>> print(participant['name'])
Ola

Տեսեք, դա նման է ցուցակին: Բայց հարկավոր չէ հիշել ինդեքսը, պարզապես անունը:

Ի՞նչ է պատահում, եթե Python- ից հարցնենք գոյություն չունեցող ստեղնաշարի արժեքը: Դուք կարող եք կռահել? Եկեք փորձենք և տեսնենք:

command-line

>>> participant['age']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'age'

Տեսեք, մեկ այլ սխալ: Այս մեկը KeyError է: Python- ը օգտակար է և ասում է, որ 'age' («տարիքը») բանալին գոյություն չունի այս բառարանում:

Ե՞րբ պետք է օգտագործեք բառարան կամ ցուցակ: Լավ, դա խորհելու լավ կետ է: Մտածեք պատասխանի մասին նախքան այն հաջորդ տողում դիտելը:

• Ուղղակի պե՞տք է իրերի պատվիրված հաջորդականություն: Գնացեք ցուցակի համար:
• Ձեզ հարկավոր է արժեքները կապել բանալիների հետ, որպեսզի հետագայում դրանք արդյունավետ (բանալիներով) որոնեք: Օգտագործեք բառարան

Բառարանները, ինչպես list-ները (ցուցակ)ները, mutable (փոփոխական) են , ինչը նշանակում է, որ դրանք կարող են փոփոխվել ստեղծվելուց հետո: Բառարանում կարող եք ավելացնել բանալի-արժեքի նոր զույգեր այն ստեղծվելուց հետո, ինչպես հետևյալը.

command-line

>>> participant['favorite_language'] = 'Python'

Ծուցակների նման, բառարաններում օգտագործելով len () ֆունկցիան, վերադարձնում է բառարանում բանալի-արժեք զույգերի քանակը: Գնացեք և մուտքագրեք այս հրամանը.

command-line

>>> len(participant)
4

Հուսով եմ ՝ դա մինչ այժմ իմաստ ունի: :) Պատրա՞ստ եք բառարանների հետ զվարճանալու համար: Կարդացեք մի քանի զարմանալի բաների մասին:

Կարող եք օգտագործել pop () method-(մեթոդ)ը ՝ բառարանում իրը ջնջելու համար: Ասեք, եթե ցանկանում եք ջնջել 'favorite_numebrs' «սիրված_համարները» բանալին համապատասխան գրառումը, մուտքագրեք հետևյալ հրամանը.

command-line

>>> participant.pop('favorite_numbers')
[7, 42, 92]
>>> participant
{'country': 'Poland', 'favorite_language': 'Python', 'name': 'Ola'}

Ինչպես տեսնում եք արդյունքից, 'favoritenumbers'(«սիրվածհամարներ») ստեղնին համապատասխանող ստեղն-արժեք զույգը ջնջվել է:

Բացի դրանից, դուք կարող եք նաև փոխել մի բառ, որը կապված է բառարանում արդեն իսկ ստեղծված բանալին: Մուտքագրեք սա ՝

command-line

>>> participant['country'] = 'Germany'
>>> participant
{'country': 'Germany', 'favorite_language': 'Python', 'name': 'Ola'}

Ինչպես տեսնում եք, 'country' («երկիր») ստեղնի արժեքը փոխվել է 'Poland' («Լեհաստան») - ից 'Germany' («Գերմանիա»): :) Հուզիչ? Ուռա! Դուք պարզապես սովորեցիք մեկ այլ զարմանալի բան:

Ամփոփում

Հոյակապ. Դուք հիմա շատ բան գիտեք ծրագրավորման մասին: Այս վերջին մասում իմացաք.

• errors (սխալներ) - Դուք այժմ գիտեք, թե ինչպես կարդալ և հասկանալ սխալները, որոնք հայտնվում են, եթե Python- ը չի հասկանում ձեր կողմից տրված հրամանը
• variables (փոփոխականներ) - օբյեկտների անուններ, որոնք թույլ են տալիս ավելի հեշտ ծածկագրել և ձեր կոդն ավելի ընթեռնելի դարձնել
• lists (ցուցակներ) - որոշակի հերթականությամբ պահված օբյեկտների ցուցակներ
• disctionaries (բառարաններ) - օբյեկտներ, որոնք պահվում են որպես ստեղն-արժեք զույգեր

Հիասթափվա՞ծ եք հաջորդ մասի համար: :)

Համեմատեք իրերը

Ընթերցողների համար տանը. Այս մասն ընդգրկված է Python Basics: Comparisons (Համեմատություններ ) տեսանյութում:

Ծրագրավորման մեծ մասը ներառում է իրերի համեմատություն: Ո՞րն է համեմատության մեջ ամենահեշտ բանը: Թվե՛ր: Տեսնենք, թե ինչպես է դա գործում.

command-line

>>> 5 > 2
True
>>> 3 < 1
False
>>> 5 > 2 * 2
True
>>> 1 == 1
True
>>> 5 != 2
True
>>> len([1, 2, 3]) > len([4, 5])
True

Մենք որոշ թվեր տվեցինք Python- ին համեմատելու համար: Ինչպես տեսնում եք, Python- ը ոչ միայն կարող է համեմատել թվերը, այլ նաև կարող է համեմատել մաթեմատիկական արտահայտությունների արժեքները, ինչպիսիք են 2 * 2 և ֆունկցիայի արդյունքները, ինչպիսին է 2 վերադարձվածը len ([4, 5]) `: Հաճելի է, հա՞:

Զարմանո՞ւմ եք, թե ինչու ենք իրար կողքի դնում երկու հավասար == նշաններ ՝ համեմատելու համար, եթե թվերը հավասար են: Մենք օգտագործում ենք մեկ = փոփոխականներին արժեքներ նշանակելու համար: Դուք միշտ, միշտ պետք է դնեք դրանցից երկուսը ՝ == - եթե ուզում եք ստուգել, արդյոք իրերը հավասար են միմյանց: Կարող ենք նաև փաստել, որ իրերն անհավասար են միմյանց համար: Դրա համար մենք օգտագործում ենք != խորհրդանիշը, ինչպես ցույց է տրված վերևում բերված օրինակում:

Python- ին տվեք ևս երկու առաջադրանք.

command-line

>>> 6 >= 12 / 2
True
>>> 3 <= 2
False

Մենք տեսել ենք >և < բայց ի՞նչ են նշանակում >= և <=: Կարդացեք դրանք այսպես.

• x > y նշանակում է ՝ x- ն y- ից մեծ է
• x < y նշանակում է `x- ը y- ից փոքր է
• x <= y նշանակում է `x- ը y- ից փոքր է
• x >= y նշանակում է. x- ը y- ից մեծ է կամ հավասար է դրան

Հիանալի! ուզում ես մի հատ էլ անել? Փորձեք այս:

command-line

>>> 6 > 2 and 2 < 3
True
>>> 3 > 2 and 2 < 1
False
>>> 3 > 2 or 2 < 1
True

Կարող եք Python- ին տալ այնքան թվեր, որպեսզի համեմատես, որքան ուզում ես, և դա քեզ կպատասխանի: Բավականին խելացի, այդպես չէ՞:

• and (և) - եթե օգտագործում եք and (և) օպերատորը, երկու համեմատություններն էլ պետք է լինեն Ճիշտ, որպեսզի ամբողջ հրամանը լինի Ճիշտ:
• or (կամ) - եթե օգտագործում եք or (կամ) օպերատոր, ապա համեմատություններից միայն մեկը պետք է լինի Ճիշտ, որպեսզի ամբողջ հրամանը լինի Ճիշտ

Լսե՞լ եք «խնձորը նարինջի հետ համեմատելը» արտահայտության մասին: Փորձենք Python- ի համարժեքը.

command-line

>>> 1 > 'django'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'int' and 'str'

Այստեղ տեսնում եք, որ ինչպես արտահայտության մեջ, Python- ը ի վիճակի չէ համեմատել համարը (int) և տողը (str): Փոխարենը, այն ցույց է տալիս TypeError և մեզ ասում է, որ երկու տիպերը չեն կարող համեմատվել միասին:

Boolean

Ի դեպ, դուք հենց նոր իմացաք Python- ի նոր տեսակի օբյեկտների մասին: Այն կոչվում է Boolean (Բուլյան) :

Boolean (Բուլյան) ընդամենը երկու օբյեկտ կա.

• Ճիշտ
• Կեղծ

Բայց որպեսզի Python- ը դա հասկանա, դուք պետք է այն միշտ գրեք որպես 'True' («Ճիշտ») (առաջին տառերը մեծատառով, մնացած տառերը փոքրատառերով): true, TRUE և tRUE չեն գործի. Միայն True- ն է ճիշտ: (Նույնը վերաբերում է նաև 'False' - ին):

Booleans- ը նույնպես կարող է փոփոխական լինել: Տեսեք այստեղ ՝

command-line

>>> a = True
>>> a
True

Դուք կարող եք նաև դա անել այս կերպ.

command-line

>>> a = 2 > 5
>>> a
False

Պարապեք և զվարճացեք Booleans- ի հետ `փորձելով կատարել հետևյալ հրահանգները.

• True and True
• False and True
• True or 1 == 1
• 1 != 2

Շնորհավորանքներ. Booleans- ը ծրագրավորման ամենաթեժ առանձնահատկություններից մեկն է, և դուք պարզապես սովորեցիք, թե ինչպես օգտագործել դրանք:

Պահպանել այն!

Ընթերցողների համար տանը. Այս մասը ներառված է Python Basics: Saving files and 'if' statement (Python- ի հիմունքներում. Ֆայլեր պահելը և «Եթե» հայտարարությունը) տեսանյութում:

Մինչ այժմ մենք թարգմանչի մեջ գրում էինք մեր պիթոնի բոլոր կոդերը, ինչը մեզ սահմանափակում է միանգամից մեկ տող կոդ մուտքագրելով: Նորմալ ծրագրերը պահվում են ֆայլերում և կատարվում են մեր ծրագրավորման լեզվի interpreter (թարգմանիչ) կամ compiler (կազմողի) կողմից: Մինչ այժմ մենք միանգամից տողեր ենք վարում մեր ծրագրերը Python- ի interpreter (թարգմանչի) մեջ: Հաջորդ մի քանի առաջադրանքների համար մեզ մեկից ավելի տող ծածկագիր է պետք, ուստի մեզ արագ անհրաժեշտ կլինի.

• Ելք Python- ի թարգմանիչից
• Բացեք մեր ընտրած կոդերի խմբագրիչը
• Մի քանի կոդ պահեք պիթոնի նոր ֆայլում
• Սկսե՛ք (run the code)

Մեզ համար օգտագործվող Python- ի interpreter (թարգմանիչից) դուրս գալու համար մուտքագրեք exit() (ելք()) ֆունկցիան

command-line

>>> exit()
$

Սա ձեզ կրկին կտեղադրի command-ի (հրամանի) տողի մեջ:

Ավելի վաղ մենք code editor (կոդերի խմբագիր) բաժնից ընտրեցինք code editor (կոդի խմբագիր): Մենք հիմա պետք է բացենք editor-ը (խմբագիրը) և մի քանի կոդ գրենք նոր ֆայլի մեջ (կամ եթե օգտագործում եք Chromebook, ստեղծեք նոր ֆայլ ամպային IDE- ում և բացեք այն ֆայլ, որը կլինի ներառված ծածկագրերի խմբագրում).

editor

print('Hello, Django girls!')

Ակնհայտ է, որ դուք այժմ Python- ի բավականին փորձառու մշակող եք, այնպես որ ազատորեն գրեք մի քանի կոդ, որոնք սովորել եք այսօր:

Այժմ մենք պետք է պահենք ֆայլը և տալ այն նկարագրական անուն: Եկեք զանգահարենք ֆայլը python_intro.py և պահենք այն ձեր աշխատասեղանին: Մենք կարող ենք ֆայլը անվանել այն, ինչ ուզում ենք, բայց այստեղ կարևոր մասն այն է, որ ֆայլը վերջանա .py : .py ընդլայնումը մեր օպերացիոն համակարգին ասում է, որ սա Python excutable file (գործարկվող ֆայլ) է, և Python- ը կարող է այն գործարկել:

Նշում Դուք պետք է նկատեք կոդերի խմբագիրների ամենաթեժ մեկը գույները: Python կոնսոլում ամեն ինչ նույն գույնն էր. հիմա պետք է տեսնեք, որ print (տպել) function-ը (գործառույթը) string-ից տարբեր գույն է: Սա կոչվում է "syntax highlighting" («շարահյուսական լուսաբանում»), և դա իսկապես օգտակար հատկություն է կոդավորման ժամանակ: Իրերի գույնը ձեզ հուշումներ կտա, ինչպիսիք են չփակված string-երը կամ կարևոր բառի տառասխալը (ինչպես ֆունկցիաի def (անջատումը) `, որը կտեսնենք ստորև): Սա է պատճառը, որ մենք օգտագործում ենք code editor ( կոդերի խմբագիր): :)

Ֆայլը պահված պահով ՝ այն գործարկելու ժամանակն է: Օգտագործելով command line (հրամանի տողի) բաժնում ձեր սովորած հմտությունները, օգտագործեք տերմինալը change directories (գրացուցակները փոխելու ) համար:

$ cd ~/Desktop

$ cd ~/Desktop

> cd %HomePath%\Desktop

> cd $Home\Desktop

Եթե խրվել եք, օգնություն խնդրեք: Դա հենց այն է, ինչի համար այստեղ են մարզիչները:

Այժմ օգտագործեք Python- ը ֆայլի ծածկագիրը այսպիսի կատարելու համար.

command-line

$ python3 python_intro.py
Hello, Django girls!

Նշում. Windows- ում 'python3' («python3») - ը չի ճանաչվում որպես հրաման: Փոխարենը, ֆայլը կատարելու համար օգտագործեք 'python' («python»).

command-line

> python python_intro.py

Լավ! Դուք պարզապես գործարկել եք ձեր առաջին Python ծրագիրը, որը պահվել է ֆայլում: Ձեզ հիանալի՞ եք զգում:

Այժմ կարող եք անցնել ծրագրավորման կարևոր գործիքի.

If … elif … else

Կոդում պարունակվող շատ բաներ պետք է կատարվեն միայն տրված պայմանների բավարարման դեպքում: Այդ պատճառով Python- ն ունի if statement (եթե հայտարարություններ) կոչվող մի բան:

Փոխարինեք կոդը ձեր python_intro.py ֆայլում հետևյալով.

python_intro.py

if 3 > 2:

Եթե մենք save/ փրկեինք և run / գործարկեինք սա, կտեսնեինք այսպիսի սխալ.

command-line

$ python3 python_intro.py
File "python_intro.py", line 2
         ^
SyntaxError: unexpected EOF while parsing

Python- ն ակնկալում է, որ մենք նրան հետագա հրահանգներ կտանք, որոնք կատարվում են, եթե3 > 2 պարզվում է, որ ճիշտ է (կամ True այդ հարցի համար): Փորձենք Python- ին տպել"It works!" («Այն գործում է»): Փոխեք ձեր կոդը ձեր python_intro.py ֆայլում հետևյալով ՝

python_intro.py

if 3 > 2:
    print('It works!')

Ուշադրություն դարձրեք, թե ինչպես ենք մենք մուտքագրել ծածկագրի հաջորդ տողը ըստ 4 տարածության: Մենք պետք է դա անենք, որպեսզի Python- ը իմանա, թե ինչ կոդ գործարկի, եթե արդյունքը ճիշտ է: Կարող եք մեկ տարածք անել, բայց Python- ի գրեթե բոլոր ծրագրավորողները կատարում են 4-ը, որպեսզի ամեն ինչ կոկիկ տեսք ունենա: Մեկ ներդիրը նույնպես կհամարվի 4 տարածություն, քանի դեռ ձեր տեքստի խմբագրիչը պատրաստ է դա անել: Երբ դու կատարեցիր քո ընտրությունը, մի փոխիր այն: Եթե դուք արդեն կտրել եք 4 տարածություն, ապա կատարեք ցանկացած ապագա խորացում նաև 4 տարածության հետ, հակառակ դեպքում կարող եք խնդիրներ առաջանալ:

Պահպանեք այն և նորից run /մեկնարկեք.

command-line

$ python3 python_intro.py
It works!

Նշում. Հիշեք, որ Windows- ում «python3» - ը չի ճանաչվում որպես հրաման: Այսուհետ, ֆայլը կատարելու համար փոխարինեք «python3» - ը «python» - ով:

Ի՞նչ կլինի, եթե պայմանը True (ճիշտ) չէ:

Նախորդ օրինակներում ծածկագիրը կատարվում էր միայն այն ժամանակ, երբ պայմանները True (ճշմարիտ) էին: Բայց Python- ը ունի նաև elif և else հայտարարություններ.

python_intro.py

if 5 > 2:
    print('5 is indeed greater than 2')
else:
    print('5 is not greater than 2')

Երբ սա գործարկվի, այն կտպագրվի ՝

command-line

$ python3 python_intro.py
5 is indeed greater than 2

Եթե 2-ը 5-ից մեծ թիվ լիներ, ապա երկրորդ հրամանը կկատարվեր: Տեսնենք, թե ինչպես է աշխատում elif:

python_intro.py

name = 'Sonja'
if name == 'Ola':
    print('Hey Ola!')
elif name == 'Sonja':
    print('Hey Sonja!')
else:
    print('Hey anonymous!')

և սկսեց.

command-line

$ python3 python_intro.py
Hey Sonja!

Տեսեք, թե ինչ է տեղի ունեցել այնտեղ: elif Ձեզ հնարավորություն է տալիս ավելացնել լրացուցիչ պայմաններ, որոնք գործում են նախորդ պայմանների ձախողման դեպքում:

Նախնական if (եթե) հայտարարությունից հետո կարող եք ավելացնել այնքան elif հայտարարություն, որքան ցանկանում եք: Օրինակ:

python_intro.py

volume = 57
if volume < 20:
    print("It's kinda quiet.")
elif 20 <= volume < 40:
    print("It's nice for background music")
elif 40 <= volume < 60:
    print("Perfect, I can hear all the details")
elif 60 <= volume < 80:
    print("Nice for parties")
elif 80 <= volume < 100:
    print("A bit loud!")
else:
    print("My ears are hurting! :(")

Python- ն անցնում է յուրաքանչյուր թեստի հաջորդականությամբ և տպում.

command-line

$ python3 python_intro.py
Perfect, I can hear all the details

Comments

Մեկնաբանությունները տողեր են, որոնք սկսվում են # - ով: # - ից հետո կարող եք գրել այն ամենը, ինչ ուզում եք, և Python- ը անտեսելու է այն: Մեկնաբանությունները կարող են հեշտացնել ձեր ծածկագիրը այլ մարդկանց համար:

Տեսնենք, թե ինչպես է դա թվում.

python_intro.py

# Change the volume if it's too loud or too quiet
if volume < 20 or volume > 80:
    volume = 50
    print("That's better!")

Կոդի յուրաքանչյուր տողի համար անհրաժեշտ չէ մեկնաբանություն գրել, բայց դրանք օգտակար են բացատրելու համար, թե ինչու է ձեր կոդն ինչ-որ բան անում, կամ ամփոփում է ներկայացնում, երբ այն ինչ-որ բարդ բան է անում:

Ամփոփում

Վերջին մի քանի վարժություններում, որոնց մասին իմացաք.

• comparing things (իրերի համեմատություն) - Python- ում դուք կարող եք համեմատել իրերը ՝ օգտագործելով>, >=, ==, <=, < և և, or (կամ) օպերատորները
• Boolean - օբյեկտի տեսակ, որը կարող է ունենալ միայն երկու արժեքներից մեկը ՝ Ture (Ճիշտ) կամ False (Սխալ)
• Saving files (Ֆայլեր պահելը) - ֆայլերում կոդ է պահվում, որպեսզի կարողանաք ավելի մեծ ծրագրեր իրականացնել:
• if… elif… other - հայտարարություններ, որոնք թույլ են տալիս կատարել կոդ միայն որոշակի պայմանների բավարարման դեպքում:
• comments (մեկնաբանություններ) - տողեր, որոնք Python- ը չի գործարկի, որոնք թույլ են տալիս փաստաթղթավորել ձեր կոդը

Ժամանակն է այս գլխի վերջին մասի:

Ձեր սեփական functions (ֆունկցիաները):

Ընթերցողների համար տանը. Այս մասն ընդգրկված է Python Basics: Functions տեսանյութում:

Հիշո՞ւմ եք len() - ի նման գֆունկցիաներ, որոնք կարող եք կատարել Python- ում: Դե, լավ նորություն. Դուք կսովորեք, թե ինչպես գրել ձեր սեփական ֆունկցիաները հիմա:

Ֆունկցիան հրահանգների հաջորդականություն է, որը Python- ը պետք է կատարի: Python- ում յուրաքանչյուր ֆունկցիան սկսվում է def հիմնաբառից, տրվում է անուն և կարող է ունենալ որոշ պարամետրեր: Եկեք փորձենք: Փոխարինեք կոդը python_intro.py - ում հետևյալով.

python_intro.py

def hi():
    print('Hi there!')
    print('How are you?')

hi()

Լավ, մեր առաջին ֆունկցիան պատրաստ է:

Կարող եք զարմանալ, թե ինչու ենք ֆունկցիայի անունը գրել ֆայլի ներքևում: Երբ մենք գրում ենք def hi (): և հետևյալ խորշված տողերը, սա մենք ենք, որ հրահանգներ ենք գրում, թե ինչ պետք է անի hi () ֆունկցիան: Python- ը կկարդա և կհիշի այս հրահանգները, բայց ֆունկցիան դեռ չի գործարկի: Python- ին ասելու համար, որ մենք ուզում ենք ֆունկցիան գործարկել, մենք պետք է ֆունկցիան կանչենք hi () - ով: Python- ը կարդում է ֆայլը և կատարում այն վերից վար, այնպես որ մենք պետք է ֆայլում սահմանենք ֆունկցիան նախքան այն կանչելը:

Եկեք վարենք սա հիմա և տեսնենք, թե ինչ է տեղի ունենում.

command-line

$ python3 python_intro.py
Hi there!
How are you?

Նշում. Եթե չի հաջողվել, մի խուճապի մատնվեք: Արդյունքը կօգնի ձեզ հասկանալ, թե ինչու.

• Եթե դուք ստանում եք NameError դա, հավանաբար, նշանակում է, որ դուք սխալ եք մուտքագրել ինչ-որ բան, ուստի պետք է ստուգեք, որ նույն անունն օգտագործել եք def hi (): ֆունկցիան ստեղծելիս և այն hi () - ով զանգահարելիս ,
• Եթե դուք ստանում եք IndentationError, տողի սկզբում ստուգեք, որ print (տպագիր) տողերն էլ ունենան նույն սպիտակ տարածությունը.
• Եթե ընդհանրապես ելք չկա, ստուգեք, որ վերջին hi() տրոհված չէ - եթե այդպես է, այդ տողը նույնպես կդառնա գործառույթի մաս: Այն երբեք չի սկսվի:

Եկեք կառուցենք մեր առաջին գործառույթը պարամետրերով: Մենք կփոխենք նախորդ օրինակը ՝ ֆունկցիան , որն ասում է "hi" («ողջույն») այն աշխատող անձին ՝ անունով.

python_intro.py

def hi(name):

Ինչպես տեսնում եք, մենք հիմա մեր ֆունկցիան տվեցինք մի պարամետր, որը կոչեցինք name ( անուն):

python_intro.py

def hi(name):
    if name == 'Ola':
        print('Hi Ola!')
    elif name == 'Sonja':
        print('Hi Sonja!')
    else:
        print('Hi anonymous!')

hi()

Հիշիր print (տպել) գործառույթը կտրված է չորս տարածության մեջ if (եթե) հայտարարության մեջ: Դա պայմանավորված է նրանով, որ ֆունկցիան աշխատում է պայմանը բավարարելիս: Տեսնենք, թե ինչպես է այն աշխատում այժմ.

command-line

$ python3 python_intro.py
Traceback (most recent call last):
File "python_intro.py", line 10, in <module>
  hi()
TypeError: hi() missing 1 required positional argument: 'name'

Սխալ: Բարեբախտաբար, Python- ը մեզ տալիս է օգտակար սխալի հաղորդագրություն: Այն մեզ ասում է, որ hi () ֆունկցիան (այն, ինչ մենք սահմանեցինք) ունի մեկ պահանջվող փաստարկ (կոչվում է name (անուն)) և որ մենք մոռացանք փոխանցել այն գործառույթը ակտիվացնելիս Եկեք ֆիքսենք այն ֆայլի ներքևում.

python_intro.py

hi("Ola")

Եվ նորից գործարկեք այն.

command-line

$ python3 python_intro.py
Hi Ola!

Իսկ եթե անունը փոխե՞նք:

python_intro.py

hi("Sonja")

Եվ run/գործարկեք այն.

command-line

$ python3 python_intro.py
Hi Sonja!

Հիմա ի՞նչ եք կարծում, ի՞նչ կլինի, եթե այնտեղ մեկ այլ անուն գրեք: (Ոչ Ola/Օլան կամ Sonja/Սոնյան): Փորձեք և տեսեք, արդյոք ճիշտ եք: Այն պետք է տպագրի սա ՝

command-line

Ողջույն անանուն:

Սա հիանալի է, չէ՞: Այս կերպ ձեզ հարկավոր չէ կրկնել ամեն անգամ, երբ ցանկանում եք փոխել այն անձի անունը, որը պետք է ողջունի ֆունկցիան: Եվ հենց այդ պատճառով մեզ ֆունկցիաներ են պետք. Դուք երբեք չեք ցանկանում կրկնել ձեր ծածկագիրը:

Եկեք ավելի խելացի բան անենք. Անուններն ավելի շատ են, քան երկուսը, և յուրաքանչյուրի համար պայման գրելը դժվար կլինի, չէ՞: Ձեր ֆայլի պարունակությունը փոխարինեք հետևյալով.

python_intro.py

def hi(name):
    print('Hi ' + name + '!')

hi("Rachel")

կեք հիմա զանգահարենք ծածկագիրը.

command-line

$ python3 python_intro.py
Hi Rachel!

Շնորհավորում եմ Դուք պարզապես իմացաք, թե ինչպես գրել ֆունկցիաներ: :)

Loops ( Օղակներ )

Ընթերցողների համար տանը. Այս մասը ընդգրկված է Python Basics: For Loop տեսանյութում:

Սա արդեն վերջին մասն է: Դա արագ էր, չէ՞: :)

Ծրագրավորողների չեն սիրում կրկնել իրենց: Ծրագրավորում բոլոր մասին, automating բաներ, այնպես որ, մենք չենք ուզում, որպեսզի ողջունելու յուրաքանչյուր անձին իրենց անունով ձեռքով, ճիշտ է? Դա այն վայրն է, որտեղ օղակները հարմար են:

Դեռ հիշու՞մ եք ցուցակները: Եկեք կատարենք աղջիկների ցուցակ.

python_intro.py

girls = ['Rachel', 'Monica', 'Phoebe', 'Ola', 'You']

Մենք ուզում ենք նրանց բոլորին ողջունել իրենց անունով: Դա անելու համար մենք ունենք hi function, ուստի եկեք օգտագործենք այն loop-ի (օղակի) մեջ.

python_intro.py

for name in girls:

for հայտարարությունը իրեն նույն կերպ է վերաբերվում if հայտարարությանը; Այս երկուսից էլ ներքևի ծածկագիրը պետք է փորված լինի չորս տարածության մեջ:

Ահա ամբողջական կոդը, որը կլինի ֆայլում.

python_intro.py

def hi(name):
    print('Hi ' + name + '!')

girls = ['Rachel', 'Monica', 'Phoebe', 'Ola', 'You']
for name in girls:
    hi(name)
    print('Next girl')

Եվ երբ մենք այն run/վարում ենք.

command-line

$ python3 python_intro.py
Hi Rachel!
Next girl
Hi Monica!
Next girl
Hi Phoebe!
Next girl
Hi Ola!
Next girl
Hi You!
Next girl

Ինչպես տեսնում եք, այն ամենը, ինչ դնում եք for (համար) հայտարարության ներդիրով, կկրկնվի girls (աղջիկների) ցուցակի յուրաքանչյուր տարր:

Դուք կարող եք նաեւ օգտագործել for (համար) է թվերի օգտագործելով range (հեռահար) ֆունկցիան:

python_intro.py

for i in range(1, 6):
    print(i)

Որը կտպագրի.

command-line

1
2
3
4
5

range (միջակայքը) ֆունկցիան է, որը ստեղծում է թվերի ցուցակը մեկը մյուսին հաջորդող (այս թվերը տրամադրվում են ձեր կողմից որպես պարամետրեր):

Նկատի ունեցեք, որ այս երկու թվերից երկրորդը ներառված չէ Python- ի կողմից թողարկվող ցուցակում (նկատի ունի range(1, 6) հաշվում է 1-ից 5-ը, բայց չի ներառում 6 թիվը): Դա այն պատճառով է, որ "range"-ը («միջակայքը») կիսաբաց է, և դրանով մենք նկատի ունենք, որ այն ներառում է առաջին արժեքը, բայց ոչ վերջինը:

Ամփոփում

Վերջ Դուք լիովին ռոք եք անում: Սա բարդ գլուխ էր, այնպես որ դուք պետք է հպարտանաք ինքներդ ձեզնով: Մենք անկասկած հպարտ ենք ձեզանով, որ հասել եք մինչ այժմ:

Python- ի պաշտոնական և ամբողջական ձեռնարկի համար այցելեք https://docs.python.org/3/tutorial/: Սա ձեզ լեզվի ավելի մանրակրկիտ և ամբողջական ուսումնասիրություն կտա: Ողջույն :)

Կարող եք համառոտ մեկ այլ բան անել ՝ ձգվել, մի փոքր շրջել, հանգստանալ ձեր աչքերով ՝ նախքան հաջորդ գլուխ անցնելը: :)