Mga komento

Ang mga komentong sumasalungat sa code ay mas malala kaysa walang komento.

Palaging iwasto ang mga komento kung babaguhin mo ang code!

Ang mga komento ay dapat na mga kumpletong pangungusap. Kung ang komento ay isang parirala o pangungusap, ang unang salita ay dapat na naka-capitalize maliban kung ito ay isang variable na pangalan na nagsisimula sa isang maliit na titik (huwag baguhin ang case ng isang variable!).

Kung maikli ang komento, maaari mong alisin ang tuldok sa dulo ng pangungusap. Ang isang bloke ng komento ay karaniwang binubuo ng isa o higit pang mga talata na binubuo ng mga kumpletong pangungusap, kaya ang bawat pangungusap ay dapat magtapos sa isang tuldok.

Maglagay ng dalawang puwang pagkatapos ng tuldok sa dulo ng pangungusap.

Mga programmer na hindi nagsasalita ng Ingles Ingles, mangyaring sumulat ng mga komento sa Ingles, maliban kung ikaw ay 120% sigurado na ang iyong code ay hindi kailanman mababasa ng mga taong hindi alam ang iyong sariling wika.

Mga block ng komento

Karaniwang ipinapaliwanag ng bloke ng komento ang code (lahat o ilang bahagi lang) na kasunod ng bloke, at dapat na naka-indent katulad ng mismong code. Ang bawat linya ng naturang bloke ay dapat magsimula sa # na simbolo at isang puwang pagkatapos nito (maliban kung ang teksto ng komento mismo ay naka-indent).

Ang mga talata sa loob ng bloke ng komento ay pinaghihiwalay ng isang linya na binubuo ng isang # character.

Mga inline na komento

Subukang gumamit ng gayong mga komento nang mas madalas.

Ang komentong ito ay lilitaw sa parehong linya ng pagtuturo. Ang mga inline na komento ay dapat paghiwalayin ng kahit man lang dalawang puwang mula sa mga tagubilin. Dapat silang magsimula sa isang # character at isang espasyo.

Ang mga komento sa linya ng code ay hindi kailangan at nakakaabala lamang sa pagbabasa kung ipinapaliwanag nila ang halata. Huwag sumulat ng ganito:

x = x + 1 # Pagtaas ng x

Gayunpaman, kung minsan ang mga komentong ito ay kapaki-pakinabang:

x = x + 1 # Kabayaran sa hangganan

Ang Mga Komento ng Python ay lubhang makatuwiran at may ilang mga tampok:

Ang mga komento ay inilaan upang magpasok ng mga paliwanag sa teksto ng programa na ganap na hindi pinapansin ng interpreter.

Ang anumang teksto ay maaaring makita sa loob ng isang komento, kabilang ang mga tagubilin na hindi dapat sundin.

PAYO Tandaan, ang mga komento ay para sa programmer, hindi sa Python interpreter. Ang pagpasok ng mga komento sa code ay magbibigay-daan sa iyong mabilis na matandaan ang layunin ng isang piraso ng code pagkaraan ng ilang sandali.

Ang Python ay mayroon lamang isang linyang komento. Nagsisimula ito sa isang # na simbolo:

# Ito ay isang komento

Ang isang linyang komento ay maaaring magsimula hindi lamang sa simula ng linya, ngunit matatagpuan din pagkatapos ng pahayag.

Halimbawa, sa sumusunod na halimbawa, isang komento ang inilagay pagkatapos ng isang pahayag na nagsasabing "Kumusta, mundo!":

рrint("Hello, world!") # I-print ang inskripsiyon gamit ang print() function

Kung ang isang character ng komento ay inilagay bago ang isang pagtuturo, hindi ito isasagawa:

# print("Hello, world!") Ang tagubiling ito ay hindi isasagawa

Kung ang # character ay nasa loob ng mga quote o apostrophe, hindi ito isang character ng komento:

print("#This is NOT a comment")

Dahil ang Python ay wala multiline na komento, pagkatapos ang nagkomento na fragment ay madalas na inilalagay sa loob ng triple quotes (o triple apostrophes):

«»»
Ang tagubiling ito ay hindi isasagawa
print ("Kumusta, mundo!")
«»»

Dapat tandaan na ang piraso ng code na ito ay hindi binabalewala ng interpreter, dahil hindi ito isang komento. Bilang resulta ng pagpapatupad ng fragment, isang bagay na may uri ng string ay malilikha.

Gayunpaman, ang mga tagubilin sa loob ng triple quote ay hindi isasagawa dahil isasaalang-alang ng interpreter ang mga ito sa simpleng teksto. Ang mga naturang string ay mga string ng dokumentasyon, hindi mga komento.

Mga linya ng dokumentasyon ay ang "gatong" para sa tulong():

madalas para magkomento malaking fragment gumagamit ang code ng triple quotation marks o triple apostrophes. Ang mga nasabing linya ay hindi mga komento sa buong kahulugan ng salita. Sa halip na magkomento sa fragment, isang bagay na may uri ng string ay nilikha at iniimbak sa _doc_ attribute.

Ang help() function, kapag nag-compile ng dokumentasyon, ay nakakakuha ng impormasyon mula sa attribute na ito. Ang ganitong mga string ay tinatawag na mga string ng dokumentasyon.

Inaanyayahan ko ang lahat na magsalita

Kung saan, sa isang condensed form,
pag-usapan ang mga pangunahing kaalaman ng wikang Python. Nag-aalok ako sa iyo ng pagsasalin ng artikulong ito. Hindi literal ang pagsasalin. Sinubukan kong ipaliwanag nang mas detalyado ang ilang mga punto na maaaring hindi malinaw.

Kung nagpaplano kang matutunan ang wikang Python, ngunit hindi makahanap ng angkop na gabay, kung gayon ito
Ang artikulo ay magiging lubhang kapaki-pakinabang sa iyo! Sa maikling panahon, maaari kang makilala
mga pangunahing kaalaman sa wikang Python. Bagama't madalas umaasa ang artikulong ito
na mayroon ka nang karanasan sa programming, ngunit, umaasa ako, kahit na para sa mga nagsisimula
magiging kapaki-pakinabang ang materyal na ito. Basahing mabuti ang bawat talata. Dahil sa
ang pagiging maikli ng materyal, ang ilang mga paksa ay tinalakay nang mababaw, ngunit naglalaman ng lahat
kinakailangang sukatan.

Mga pangunahing katangian

Ang Python ay hindi nangangailangan ng tahasang deklarasyon ng mga variable, at ito ay case-sensitive (var variable ay hindi katumbas ng Var o VAR - sila ay tatlong magkakaibang variable) object-oriented na wika.

Syntax

Una, ito ay nagkakahalaga ng pagpuna kawili-wiling tampok sawa. Hindi ito naglalaman ng mga bracket ng operator (simula..magtatapos sa pascal o (..) sa C), sa halip ang mga bloke ay naka-indent: mga puwang o tab, at ang pagpasok ng isang bloke ng mga pahayag ay ginagawa gamit ang isang tutuldok. Ang mga single-line na komento ay nagsisimula sa isang pound sign na "#", ang mga multi-line na komento ay nagsisimula at nagtatapos sa tatlong double quotes na """".
Upang magtalaga ng isang halaga sa isang variable, gamitin ang “=” sign, at upang ihambing -
"=". Upang taasan ang halaga ng isang variable, o idagdag sa isang string, gamitin ang "+=" operator, at "-=" upang bawasan ito. Ang lahat ng mga operasyong ito ay maaaring makipag-ugnayan sa karamihan ng mga uri, kabilang ang mga string. Halimbawa

>>> myvar = 3
>>> myvar += 2
>>> myvar -= 1
""Ito ay isang multi-line na komento
Mga linyang nakapaloob sa tatlo dobleng panipi hindi pinapansin"""
>>> mystring = "Hello"
>>> mystring += "mundo."
>>> print mystring
Hello mundo.
# Nagbabago ang susunod na linya
ang mga halaga ng mga variable ay pinapalitan. (Isang linya lang!)
>>> myvar, mystring = mystring, myvar

Mga istruktura ng data

Ang Python ay naglalaman ng mga istruktura ng data tulad ng mga listahan, tuple at diksyunaryo). Ang mga listahan ay katulad ng mga one-dimensional na array (ngunit maaari kang gumamit ng Listahan na naglalaman ng mga listahan - isang multidimensional array), ang mga tuple ay mga hindi nababagong listahan, ang mga diksyunaryo ay mga listahan din, ngunit ang mga index ay maaaring maging anumang uri, hindi lamang numeric. Ang "Arrays" sa Python ay maaaring maglaman ng data ng anumang uri, iyon ay, ang isang array ay maaaring maglaman ng numeric, string, at iba pang mga uri ng data. Ang mga array ay nagsisimula sa index 0 at ang huling elemento ay maaaring ma-access sa index -1 Maaari kang magtalaga ng mga function sa mga variable at gamitin ang mga ito nang naaayon.

>>> sample = , ("a" , "tuple" )] #Ang listahan ay binubuo ng isang integer, isa pang listahan at isang tuple
>>> #Ang listahang ito ay naglalaman ng isang string, isang integer at praksyonal na numero
>>> mylist = "Ilista muli ang item 1" #Baguhin ang unang (zero) na elemento ng mylist ng sheet
>>> mylist[-1 ] = 3 .14 #Baguhin ang huling elemento ng sheet
>>> mydict = ("Susi 1" : "Halaga 1" , 2 : 3 , "pi" : 3 .14 ) #Gumawa ng diksyunaryo na may mga numeric at integer index
>>> mydict[“pi” ] = 3 .15 #Baguhin ang elemento ng diksyunaryo sa ilalim ng index na "pi".
>>> mytuple = (1 , 2 , 3 ) #Tumukoy ng tuple
>>> myfunction = len Binibigyang-daan ka ng #Python na magdeklara ng mga kasingkahulugan ng function sa ganitong paraan
>>> print myfunction(listahan)
3

Maaari mong gamitin ang bahagi ng isang array sa pamamagitan ng pagtukoy sa una at huling index na pinaghihiwalay ng isang tutuldok na ":". Sa kasong ito, makakatanggap ka ng bahagi ng array, mula sa unang index hanggang sa pangalawa, hindi kasama. Kung hindi tinukoy ang unang elemento, magsisimula ang bilang sa simula ng array, at kung hindi tinukoy ang huling elemento, babasahin ang array hanggang sa huling elemento. Tinutukoy ng mga negatibong halaga ang posisyon ng elemento mula sa dulo. Halimbawa:

>>> mylist = [“List item 1” , 2 , 3 .14 ]
>>> print mylist[:] #Nabasa ang lahat ng elemento ng array
["List item 1" , 2 , 3 .14000000000000001 ]
>>> print mylist #Nabasa ang zero at unang elemento ng array.
["Ilista ang aytem 1" , 2 ]
>>> print mylist[-3 :-1 ] #Ang mga elemento mula sa zero (-3) hanggang sa pangalawang (-1) ay binabasa (hindi kasama)
["Ilista ang aytem 1" , 2 ]
>>> print mylist #Ang mga elemento ay binabasa mula una hanggang huli

Mga string

Mga string sa Python pinaghihiwalay ng double quotes """ o single quotes """. Ang mga double quote ay maaaring maglaman ng mga single quotes, o vice versa. Halimbawa, ang linyang “Hello!” ay ipapakita bilang "He said hi!". Kung kailangan mong gumamit ng isang string ng ilang mga linya, ang linyang ito ay dapat magsimula at magtapos sa tatlong double quote na """". at pinapalitan ng tuple ang mga character sa string na “%s” sa isang elemento ng tuple. Sa kasong ito, sa halip na "%(index)s" ang halaga ng diksyunaryo sa ibinigay na index ay papalitan.

>>>print "Pangalan: %s\nNumero: %s\nString: %s"% (aking klase.pangalan, 3 , 3 * "-")
Pangalan: Poromenos
Numero: 3
String: -
strString = """Nakalagay ang text na ito
sa ilang linya"""

>>> print“Ito %(verb)s a %(noun)s.”
%("noun" : "test" , "verb" : "is")

Isa itong pagsubok.

Mga operator Habang ang mga pahayag, kung para sa make up move operators. Walang analogue dito piliin ang pahayag Habang ang mga pahayag, kaya kailangan mong gawin kung. Sa operator nagaganap ang paghahambing variable at listahan . Upang makakuha ng listahan ng mga digit hanggang sa isang numero - gamitin(function ng saklaw

). Narito ang isang halimbawa ng paggamit ng mga operator rangelist = range(10)
>>> print#Kumuha ng listahan ng sampung numero (mula 0 hanggang 9)
kung rangelist numero sa rangelist: #Bye variable ng numero
(na tumataas ng isa sa bawat pagkakataon) ay kasama sa listahan...
# Suriin kung kasama ang variable(3 , 4 , 7 , 9 )
Habang ang mga pahayag# na numero sa isang tuple ng mga numero numero sa (3 , 4 , 7 , 9 ):
#Kung ang variable na numero ay nasa tuple (3, 4, 7, 9)... # Operasyon " break
»nagbibigay
# Operasyon "
# lumabas sa loop anumang oras :
# « iba pa magpatuloy
# loop. Hindi ito kinakailangan dito, dahil pagkatapos ng operasyong ito
# sa anumang kaso, ang programa ay babalik sa pagproseso ng loop
iba pa
# lumabas sa loop anumang oras :
# « # lumabas sa loop anumang oras» Hindi kailangang ipahiwatig. Ang kundisyon ay natutugunan
# kung ang loop ay hindi nagambala sa " # Operasyon "».
pumasa # Huwag kang gumawa

Habang ang mga pahayag rangelist == 2 :
print "Ang pangalawang item (mga listahan ay 0-based) ay 2"
elif rangelist == 3 :
print "Ang pangalawang item (mga listahan ay 0-based) ay 3"
# lumabas sa loop anumang oras :
print"Ewan"

habang rangelist == 1 :
pumasa

Mga pag-andar

Upang magdeklara ng isang function, gamitin keyword " def» . Ang mga argumento ng function ay ibinibigay sa mga panaklong pagkatapos ng pangalan ng function. Maaari mong tukuyin ang mga opsyonal na argumento, na nagbibigay sa kanila ng default na halaga. Maaaring ibalik ng mga function ang mga tuple, kung saan kailangan mong isulat ang mga halaga ng pagbabalik na pinaghihiwalay ng mga kuwit. Keyword " lambda" ay ginagamit upang ideklara ang mga elementarya na function.

Ang # arg2 at arg3 ay mga opsyonal na argumento, kunin ang halaga na idineklara bilang default,
# maliban kung bibigyan mo sila ng ibang halaga kapag tumatawag sa function.
def myfunction(arg1, arg2 = 100 , arg3 = "test" ):
bumalik arg3, arg2, arg1
#Ang function ay tinatawag na may halaga ng unang argumento - "Argument 1", ang pangalawa - bilang default, at ang pangatlo - "Named argument".
>>>ret1, ret2, ret3 = myfunction("Argument 1" , arg3 = "Named argument")
Kinukuha ng # ret1, ret2 at ret3 ang mga value na "Named argument", 100, "Argument 1" ayon sa pagkakabanggit
>>> print ret1, ret2, ret3
Pinangalanang argumento 100 Argumento 1

# Susunod na entry katumbas def f(x): bumalik x+1
functionvar = lambda x:x+1
>>> print functionvar(1)
2

Mga klase

Ang wikang Python ay limitado sa maramihang mana sa mga klase. Mga panloob na variable at panloob na pamamaraan nagsisimula ang mga klase sa dalawang salungguhit na "__" (halimbawa "__myprivatevar"). Maaari rin kaming magtalaga ng isang halaga sa isang variable ng klase mula sa labas. Halimbawa:

klase Aking klase:
karaniwan = 10
def __init__(sarili):
sarili .myvariable = 3
def myfunction(self , arg1, arg2):
bumalik sarili .myvariable

# Dito natin idineklara ang klase na My klase. Ang __init__ function ay awtomatikong tinatawag kapag ang mga klase ay sinimulan.
>>> classinstance = Aking klase() # Nasimulan na namin ang klase at ang myvariable variable ay may value 3 gaya ng nakasaad sa paraan ng pagsisimula
>>> #Method myfunction ng klase My klase ibinabalik ang halaga ng variable na myvariable
3
# Ang karaniwang variable ay ipinahayag sa lahat ng mga klase
>>> classinstance2 = Aking klase()
>>> classesinstance.common
10
>>> classesinstance2.common
10
# Kaya kung babaguhin natin ang halaga nito sa Aking klase klase magbabago
# at ang mga halaga nito sa mga bagay na sinimulan ng My class klase
>>> Myclass.common = 30
>>> classesinstance.common
30
>>> classesinstance2.common
30
# At dito hindi namin binabago ang variable ng klase. sa halip
# ipinapahayag namin ito sa isang bagay at itinalaga ito ng isang bagong halaga
>>> classesinstance.common = 10
>>> classesinstance.common
10
>>> classesinstance2.common
30
>>> Myclass.common = 50
# Ngayon ang pagbabago ng variable ng klase ay hindi makakaapekto
# variable na object ng klase na ito
>>> classesinstance.common
10
>>> classesinstance2.common
50

# Ang susunod na klase ay isang inapo ng Aking klase klase
# sa pamamagitan ng pagmamana ng mga pag-aari at pamamaraan nito, sino ang makakapagbigay ng klase
# magmana mula sa ilang mga klase, sa kasong ito ang entry
# ganito: klase Otherclass(Myclass1, Myclass2, MyclassN)
klase Otherclass(Myclass):
def __init__(sarili, arg1):
sarili .myvariable = 3
print arg1

>>> classinstance = Otherclass("hello")
hello
>>> classesinstance.myfunction(1 , 2 )
3
# Ang klase na ito ay walang pagsubok sa pag-aari, ngunit maaari namin
# ipahayag ang gayong variable para sa isang bagay. At saka
# ang variable na ito ay magiging miyembro lamang klase halimbawa.
>>> classinstance.test = 10
>>> classesinstance.test
10

Mga pagbubukod

Ang mga pagbubukod sa Python ay may istraktura subukan-maliban sa [maliban sa ionname]:

def somefunction():
subukan :
Nagdudulot ng error ang # division by zero
10 / 0
maliban sa ZeroDivisionError:
# Ngunit ang programa ay hindi "Magsagawa ng ilegal na operasyon"
# At pinangangasiwaan ang exception block na naaayon sa error na "ZeroDivisionError".
print"Oops, invalid."

>>>fn maliban sa()
Oops, hindi wasto.

Mag-import

Ang mga panlabas na aklatan ay maaaring konektado gamit ang pamamaraan na " import", saan ang pangalan ng library na konektado. Maaari mo ring gamitin ang command na " mula sa import" para makagamit ka ng function mula sa library

import random #Import ang "random" na library
mula sa oras import orasan #At kasabay nito ang function na "orasan" mula sa aklatan ng "oras".

Randomt = random .randint(1 , 100 )
>>> print randomint
64

Paggawa gamit ang file system

Maraming built-in na library ang Python. Sa halimbawang ito, susubukan naming i-save ang isang istraktura ng listahan sa isang binary file, basahin ito at iimbak ang linya text file. Upang baguhin ang istraktura ng data, gagamitin namin ang karaniwang library na "pickle"

import atsara
mylist = ["Ito" , "ay" , 4 , 13327 ]
# Buksan ang file C:\binary.dat para sa pagsusulat. karakter na "r".
# pinipigilan ang pagpapalit ng mga espesyal na character (tulad ng \n, \t, \b, atbp.).
myfile = file (r"C:\binary.dat" , "w")
pickle .dump(mylist, myfile)
myfile.close()

Myfile = file (r"C:\text.txt" , "w")
myfile.write("Ito ay isang sample na string" )
myfile.close()

Myfile = file (r"C:\text.txt")
>>> print myfile.read()
"Ito ay isang sample na string"
myfile.close()

# Buksan ang file para sa pagbabasa
myfile = file (r"C:\binary.dat")
loadedlist = pickle .load(myfile)
myfile.close()
>>> print loadlist
["Ito" , "ay" , 4 , 13327 ]

Mga kakaiba

• Maaaring pagsamahin ang mga kundisyon. 1 < a < 3 выполняется тогда, когда а больше 1, но меньше 3.
• Gamitin ang operasyon" del"sa malinaw na mga variable o elemento ng array.
• Nag-aalok ang Python ng magagandang pagkakataon para sa nagtatrabaho sa mga listahan. Maaari mong gamitin ang mga operator ng deklarasyon ng istraktura ng listahan. Operator kung nagbibigay-daan sa iyo na tukuyin ang mga elemento ng listahan sa isang tiyak na pagkakasunud-sunod, at Habang ang mga pahayag- nagbibigay-daan sa iyong pumili ng mga elemento ayon sa kundisyon.

>>> lst1 =
>>> lst2 =
>>> print
>>> print
# Ang "anumang" operator ay nagbabalik ng totoo kung bagaman
# kung nasiyahan ang isa sa mga kundisyon na kasama dito.
>>> anuman(i % 3 kung ako sa)
totoo
# Susunod na pamamaraan binibilang ang bilang
# tumutugmang elemento sa listahan
>>> kabuuan (1 kung ako sa Habang ang mga pahayag ako == 3)
3
>>> del lst1
>>> print lst1
>>> del lst1

• Mga Global Variable ay idineklara sa labas ng mga function at maaaring basahin nang walang anumang mga deklarasyon. Ngunit kung kailangan mong baguhin ang halaga ng isang pandaigdigang variable mula sa isang function, kailangan mong ideklara ito sa simula ng function na may keyword na " global" kung hindi mo gagawin ito, ang Python ay magdedeklara ng isang variable na naa-access lamang sa function na iyon.

numero = 5

def myfunc():
# Mga Output 5
print numero

def anotherfunc():
# Naglalabas ito ng exception dahil ang global variable
# ay hindi tinawag mula sa isang function. Lumilikha ang Python sa kasong ito
# variable ng parehong pangalan sa loob ng function na ito at naa-access
# para lamang sa mga operator ng function na ito.
print numero
numero = 3

def yet anotherfunc():
global numero
# At mula lamang sa function na ito ang halaga ng variable ay nabago.
numero = 3

Epilogue

Siyempre, hindi inilalarawan ng artikulong ito ang lahat ng mga tampok ng Python. Umaasa ako na ang artikulong ito ay makakatulong sa iyo kung nais mong magpatuloy sa pag-aaral ng programming language na ito.

Mga Pakinabang ng Python

• Ang bilis ng pagpapatupad ng mga program na nakasulat sa Python ay napakataas. Ito ay dahil sa ang katunayan na ang pangunahing Python library
  ay nakasulat sa C++ at tumatagal ng mas kaunting oras upang makumpleto ang mga gawain kaysa sa iba pang mataas na antas ng mga wika.
• Dahil dito, maaari kang sumulat ng iyong sariling mga module ng Python sa C o C++
• Sa pamantayan Mga aklatan ng Python makakahanap ka ng mga tool para sa pagtatrabaho sa email, mga protocol
  Internet, FTP, HTTP, mga database, atbp.
• Ang mga script na isinulat gamit ang Python ay tumatakbo sa karamihan ng mga modernong operating system. Ang portability na ito ay nagpapahintulot sa Python na magamit sa isang malawak na iba't ibang mga lugar.
• Ang Python ay angkop para sa anumang solusyon sa programming, maging ito man mga programa sa opisina, mga web application, GUI application, atbp.
• Libu-libong mga mahilig mula sa buong mundo ang nagtrabaho sa pagbuo ng Python. Suporta makabagong teknolohiya V karaniwang mga aklatan maaari nating utangin ito sa katotohanan na ang Python ay bukas sa lahat.

Mga Tag: Magdagdag ng mga tag

Sa mga halimbawa sa ibaba, ang input at output ay nakikilala sa pamamagitan ng presensya at kawalan ng mga prompt, ayon sa pagkakabanggit (ang mga prompt ay >>> at...): Upang kopyahin ang halimbawa, kailangan mong ipasok ang lahat ng sumusunod sa prompt pagkatapos na ito ay lumitaw; Ang mga linyang hindi nagsisimula sa mga senyas ay ang output ng interpreter. Tandaan na ang isang linya na naglalaman lamang ng isang prompt (" ... ") ay nangangahulugang kailangan mong magpasok ng isang walang laman na linya - ito ang paraan na ginamit upang wakasan ang mga multi-line na command.

Karamihan sa mga halimbawa sa tutorial na ito - kahit na ang mga ipinakilala sa interactive na mode- naglalaman ng mga komento. Ang mga komento sa Python ay nagsisimula sa hash character # (hash) at magpapatuloy hanggang sa pisikal na dulo ng linya. Maaaring lumabas ang mga komento sa simula ng isang linya o sundan ito mga character na whitespace o code - ngunit hindi nakapaloob sa loob ng isang linya. Ang simbolo ng hash sa linya ay nananatiling simbolo lamang ng hash. Dahil nilayon ang mga komento na gawing mas nauunawaan ang code at hindi binibigyang-kahulugan ng Python, maaari silang alisin kapag naglalagay ng mga halimbawa.

Ilang halimbawa:

# ito ang unang komento SPAM = 1 # at ito ang pangalawang komento # ... at sa wakas ang pangatlo! STRING = "#This is not a comment."

Paggamit ng Python bilang isang Calculator

Subukan natin ang ilang mga simple Mga utos ng Python. Simulan ang interpreter at hintayin ang pangunahing prompt - >>> na lumitaw. (Hindi ito dapat magtagal.)

Mga numero

Ang pag-uugali ng interpreter ay katulad ng sa isang calculator: nagpasok ka ng isang expression, at bilang kapalit ay nagpi-print ito ng isang halaga. Ang syntax ng mga expression ay pamilyar: ang mga operasyon + , - , * at / ay gumagana katulad ng sa karamihan ng iba pang mga wika (halimbawa, Pascal o C); Maaari kang gumamit ng mga panaklong para sa pagpapangkat. Halimbawa:

>>> 2 +2 4 >>> # Ito ay isang komento ... 2 +2 4 >>> 2 +2 # at narito ang isang komento sa parehong linya kasama ang code 4 >>> (50 -5 * 6 ) /4 5.0 >>> 8 /5 # Kapag hinahati ang mga integer, ang mga fractional na bahagi ay hindi mawawala 1.6000000000000001

Mangyaring tandaan: Maaari kang makakuha ng bahagyang naiibang mga resulta kaysa sa ipinapakita: ang mga resulta ng floating point division ay maaaring mag-iba sa iba't ibang mga system. Pag-uusapan natin kung paano kontrolin ang output ng mga numero ng floating point sa ibang pagkakataon. Ang pinaka-kaalaman na bersyon ng pag-output ng halagang ito ay ginagamit dito, at hindi ang mas madaling mabasa na posible:

>>> print (8/5 ) 1.6

Upang gawing mas madaling basahin ang tutorial, magpapakita kami ng pinasimpleng pagpapakita ng mga numero ng floating point at ipaliwanag sa ibang pagkakataon kung bakit magkaiba ang dalawang paraan ng pagpapakita ng mga numero ng floating point. Sumangguni sa aplikasyon Floating-Point Arithmetic: Mga Problema at Limitasyon para sa isang detalyadong talakayan.

Upang makakuha ng resulta ng integer kapag hinahati ang mga integer, pinutol ang mga fractional na resulta, isa pang operasyon ang inilaan: // :

>>> # Ang paghahati ng mga integer ay bumabalik na bilugan sa pinakamababang halaga: ... 7 //3 2 >>> 7 //-3 -3

Ang equal sign ("=") ay ginagamit para magtalaga ng value sa isang variable. Pagkatapos ng pagkilos na ito, walang ipinapakitang interactive:

>>> lapad = 20 >>> taas = 5 * 9 >>> lapad * taas 900

Ang isang halaga ay maaaring italaga sa ilang mga variable sa parehong oras:

>>> x = y = z = 0 # Zero x, y at z >>> x 0 >>> y 0 >>> z 0

Ang mga variable ay dapat determinado(tinukoy) (dapat may nakatalagang halaga) bago gamitin, kung hindi, magkakaroon ng error:

>>> # pagtatangkang i-access ang isang hindi natukoy na variable... n Traceback (huling huling tawag) : File " " , linya 1, sa< module>NameError : hindi tinukoy ang pangalan na "n".

Present buong suporta pagpapatakbo ng floating point; Ang mga operasyon sa mixed type operand ay nagko-convert ng integer operand sa isang floating point number:

>>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5

Ang mga kumplikadong numero ay sinusuportahan din sa pamamagitan ng pagdaragdag ng suffix na j o J sa mga haka-haka na bahagi. Ang mga kumplikadong numero na may di-zero na tunay na bahagi ay isinusulat bilang ( <вещественная_часть> +<мнимая_часть> j) , o maaaring malikha gamit ang complex( function <вещественная_часть> , <мнимая_часть> ) .

>>> 1j * 1J (-1+0j) >>> 1j * complex (0 , 1 ) (-1 +0j) >>> 3 +1j* 3 (3 +3j) >>> (3 +1j) * 3 (9 +3j) >>> (1 +2j) /(1 +1j) (1.5 +0.5j)

Palaging kinakatawan ang mga kumplikadong numero bilang dalawang floating point na numero - isang tunay at isang haka-haka na bahagi. Upang makuha ang mga bahaging ito mula sa kumplikadong bilang na z, z.real at z.imag ay ginagamit ayon sa pagkakabanggit.

>>> a=1.5 +0.5j >>> a.real 1.5 >>> a.imag 0.5

Ang mga function ng conversion (paghahagis) sa tunay at mga integer na numero (float(), int()) ay hindi gumagana sa mga kumplikadong numero, dahil walang kakaiba ang tamang paraan I-convert ang isang kumplikadong numero sa isang tunay na numero. Gamitin ang abs(z) function para makuha modyul numero (bilang float) o z.real upang makuha ang tunay na bahagi nito:

>>> a=3.0+4.0j >>> float (a) Traceback (huling huling tawag) : File " " , line 1, in ? TypeError : can`t convert complex to float ; gumamit ng abs (z) >>> a.real 3.0 >>> a.imag 4.0 >>> abs (a) # sqrt(a.real* *2 + a.imag**2) 5.0 >>>

Sa interactive na mode, ang huling expression na naka-print ay naka-imbak sa _ variable. Nangangahulugan ito na kung gagamit ka ng Python bilang isang desktop calculator - palaging may paraan upang ipagpatuloy ang mga kalkulasyon na may kaunting pagsisikap, halimbawa:

>>> buwis = 12.5 / 100 >>> presyo = 100.50 >>> presyo * buwis 12.5625 >>> presyo + _ 113.0625 >>> bilog (_, 2 ) 113.06 >>>

Ang variable ng user na ito ay dapat na may katayuan read-only. Huwag pilitin ang isang halaga sa iyong sarili - gagawa ka ng isang independiyenteng variable na may parehong pangalan, itinatago ang built-in na variable kasama ang mga mahiwagang katangian nito.

Mga string

Bilang karagdagan sa mga numero, ang Python ay maaaring gumana sa mga string, na kung saan ay maaaring ilarawan sa iba't ibang paraan. Ang mga string ay maaaring nakapaloob sa isa o dobleng panipi:

>>> "spam itlog" "spam itlog" >>> "hindi \"t""hindi" >>> "hindi" "hindi" >>> ""Oo," sabi niya." "Oo," sabi niya." >>> " \"Oo," sabi niya.""Oo," sabi niya." >>> "" Ay\"t," sabi niya." >>> "" Ay

"" Ay Inilalabas ng interpreter ang mga resulta ng mga string operation sa parehong paraan tulad ng ipinasok sa kanila: napapalibutan ng mga quote, at, bilang karagdagan, ang pagtakas sa mga panloob na quote at iba pang nakakatawang character na may mga backslashes - upang maipakita eksaktong halaga . Ang isang string ay nakapaloob sa double quotes kung ang string ay naglalaman single quotes at hindi isang solong doble, kung hindi, ito ay nakapaloob sa mga solong panipi. Ulitin natin, function ng pag-print

() ay nagbibigay ng mas nababasang output. Ang mga string literal ay maaaring i-spanned sa maraming linya sa iba't ibang paraan. Maaaring gamitin patuloy na mga linya

, na may backslash bilang huling character ng linya, na nagpapahiwatig na ang susunod na linya ay isang pagpapatuloy ng kasalukuyang linya: Hello ="Ito ay medyo mahabang string na naglalaman ng\n \ ilang linya ng text tulad ng gagawin mo sa C.\n \ Tandaan na ang whitespace sa simula ng linya ay\ makabuluhan."

print(hello)

Tandaan na ang mga bagong linya ay kailangan pa ring isama sa linya sa pamamagitan ng \n ; ang isang bagong linya na sinusundan ng isang backslash ay hindi naproseso. Ang pagpapatakbo ng halimbawa ay maglalabas ng sumusunod:

Ito ay isang medyo mahabang string na naglalaman ng ilang linya ng teksto tulad ng gagawin mo sa C. Tandaan na ang whitespace sa simula ng linya ay makabuluhan. Kung magdedeklara tayo ng literal na string hilaw (raw) - \n mga character ay hindi mako-convert sa mga bagong linya, ngunit ni isang backslash sa dulo ng isang linya, o isang bagong linya na character sa source code

- ay idadagdag sa linya bilang data. Samakatuwid, ang halimbawang code ay: Hello = r"Ito ay medyo mahabang string na naglalaman ng\n \ ilang linya ng text tulad ng gagawin mo sa C.\n \ Tandaan na ang whitespace sa simula ng linya ay\ makabuluhan."

"Ito ay isang medyo mahabang string na naglalaman ng\n \ ilang mga linya ng teksto tulad ng gagawin mo sa C."

O kaya, ang mga string ay maaaring palibutan ng magkatugmang pares ng triple quotes: """ o """ . Ang mga pagtatapos ng linya ay hindi kailangang wakasan ng triple quotes - isasama sila sa string.

Print( """ Paggamit: thingy -h Ipakita ang mensahe ng paggamit na ito -H hostname Hostname para kumonekta sa """)

resulta sa mga sumusunod:

Paggamit: thingy -h Ipakita ang mensahe ng paggamit na ito -H hostname Hostname upang kumonekta

Ang mga string ay maaaring pagsama-samahin (nakadikit) sa + operator at paulit-ulit sa * operator:

>>> salita = "Tulong" + "A" >>> salitang "TulongA" >>> "<" + word* 5 + ">" ""

Dalawang literal na string na inilagay nang magkasunod ay awtomatikong pinagsama; ang unang linya sa nakaraang halimbawa ay maaari ding isulat bilang word = "Tulong" "A" ; gumagana lang ito sa dalawang literal - hindi sa mga arbitrary na expression na naglalaman ng mga string.

>>> "str" ​​​​ing" #<- Так - верно "string" >>> "str" ​​​​.strip() + "ing" #<- Так - верно "string" >>> "str" ​​​​.strip() "ing" #<- Так - не верно File "" , line 1, in ? "str" ​​​​.strip () "ing" ^ SyntaxError : invalid syntax

Maaaring ma-index ang mga hilera; tulad ng sa C, ang unang character ng isang linya ay may index 0. Walang hiwalay na uri para sa mga simbolo; ang character ay isang unit-length string. Tulad ng sa Icon programming language, maaaring tukuyin ang mga substring gamit ang slice notation: dalawang indeks na pinaghihiwalay ng colon.

>>> salita[ 4 ] "A" >>> salita[ 0 :2 ] "Siya" >>> salita[ 2:4 ] "lp"

Ang mga indeks ng slice ay may mga kapaki-pakinabang na default na halaga; ang tinanggal na unang index ay pinapalitan ng zero, ang tinanggal na pangalawang index ay pinapalitan ng laki ng cut string.

>>> salita[ :2 ] # Unang dalawang character"Siya" >>> salita[ 2 :] # Lahat maliban sa unang dalawang character"lpa"

Hindi tulad ng mga string sa C, hindi maaaring baguhin ang mga string ng Python. Ang pagtatalaga ayon sa posisyon ng row index ay nagdudulot ng error:

>>> word[ 0 ] = "x" Traceback (huling tawag sa pinakahuling tawag): File " " , linya 1, sa ? TypeError : "str" ​​​​object ay hindi "t sumusuporta sa pagtatalaga ng item >>> salita[:1] = " Splat " Traceback (huling huling tawag): File " ", linya 1, sa ? TypeError: " str " object ay hindi sumusuporta sa slice assignment

Gayunpaman, ang paggawa ng bagong string na may halo-halong nilalaman ay isang madali at halatang proseso:

>>> "x" + salita[ 1 :] "xelpA" >>> "Splat" + salita[ 4 ] "SplatA"

Isang kapaki-pakinabang na invariant para sa slice operation: s[:i] + s ay katumbas ng s .

>>> salita[ :2 ] + salita[ 2 :] "HelpA" >>> word[ :3 ] + word[ 3 :] "HelpA"

Ang mga slice index degeneracies ay pinangangasiwaan nang elegante: ang isang sobrang malaking index ay pinapalitan ng laki ng string, at ang upper bound na mas maliit kaysa sa lower bound ay nagbabalik ng walang laman na string.

>>> salita[ 1 :100 ] "elpA" >>> salita[ 10 :] "" >>> salita[ 2 :1 ] ""

Ang mga indeks ay maaaring mga negatibong numero, na nagpapahiwatig ng pagbibilang mula kanan hanggang kaliwa. Halimbawa:

>>> salita[ -1 ] # Huling karakter"A" >>> salita[ -2 ] # Huling karakter"p" >>> salita[ -2 :] # Huling dalawang character"pA" >>> salita[ :-2 ] # Lahat maliban sa huling dalawang character"Hel"

Ngunit tandaan na ang -0 ay talagang katumbas ng 0 - hindi ito binibilang mula sa kanan.

>>> salita[ -0 ] # (dahil -0 ay 0)"H"

Pinutol ang mga negatibong index sa labas ng hanay, ngunit hindi namin inirerekumenda na gawin ito sa mga index na may iisang elemento ( non-cuts):

>>> salita[ -100 :] "HelpA" >>> word[ -10 ] # error Traceback (huling huling tawag) : File " " , linya 1, sa ? IndexError : string index na wala sa saklaw

Ang isang paraan upang matandaan kung paano gumagana ang mga slice ay ang isipin ang mga ito bilang mga pointer sa mga puwang sa pagitan ng mga character, kung saan ang kaliwang gilid ng unang character ay nakatakda sa zero at ang kanang gilid ng huling character ng isang string ng n character ay nasa index n , halimbawa:

+---+---+---+---+---+ | H | e | l | p | Isang |

+---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1

Ang unang hilera ng mga numero ay nagbibigay ng posisyon ng mga indeks ng hilera mula 0 hanggang 5; ang pangalawang hilera ay naglalarawan ng kaukulang mga negatibong indeks. Ang slice mula sa i hanggang j ay binubuo ng lahat ng character sa pagitan ng kanan at kaliwang gilid, na may label na i at j ayon sa pagkakabanggit. Para sa lahat ng mga index, malaki o katumbas ng zero

, ang haba ng slice ay ang pagkakaiba sa pagitan ng mga indeks, sa kondisyon na ang parehong mga indeks ay nasa hanay. Halimbawa, ang haba ng salita ay 2.

Ang built-in na function na len() ay nagbabalik ng haba ng isang string: >>> s ="supercalifragilisticexpialidocious"

>>> len (mga) 34: Tingnan din Mga uri ng enum Ang mga string ay isang uri ng enumerable na uri at sinusuportahan nila ang mga operasyong pamilyar sa mga uri na iyon. Mga pamamaraan ng string Suporta sa mga string malaking bilang pamamaraan para sa paghahanap at simpleng pagbabago. Pag-format ng mga string Narito kung paano i-format ang mga string gamit ang str.format() function Old-style na string formatting operations Ang mga pagpapatakbo ng pag-format ay tinatawag kung kailan regular na mga string

o Unicode string ay lumilitaw na ang kaliwang operand ng % operator, na tinalakay nang mas detalyado dito.

Tungkol sa Unicode Mula noong bersyon 3.0 ng Python, uri ng string

Ang bentahe ng Unicode set ay nagbibigay ito ng serial number para sa anumang karakter mula sa anumang script na ginamit sa moderno o sinaunang mga teksto. Hanggang ngayon, 256 na numero lang ang available para sa mga character sa script. Karaniwang itinatali ang mga teksto sa isang pahina ng code, na tumugma sa mga serial number at character ng script. Nagdulot ito ng malubhang kalituhan, lalo na tungkol sa internasyonalisasyon produkto ng software. Nilulutas ng Unicode ang mga problemang ito sa pamamagitan ng pagtukoy ng isang solong pahina ng code para sa lahat ng mga script.

Upang magpasok ng isang espesyal na character sa isang string, maaari mong gamitin ang Unicode-Escape encoding. Ang sumusunod na halimbawa ay magpapaliwanag ng lahat:

>>> "Hello \u0020Mundo!""Hello World!"

Ang escape sequence \u0020 ay tumutukoy sa isang Unicode na character na may sequence number na 0x0020 (ang space character).

Ang iba pang mga character ay binibigyang kahulugan gamit ang kanilang mga katumbas na ordinal na halaga sa parehong paraan tulad ng Unicode ordinal na mga numero. Unang 128 character Mga pag-encode ng Unicode ganap na tumutugma sa 128 character ng Latin-1 encoding na ginagamit sa maraming bansa sa Kanluran.

Bilang karagdagan sa mga karaniwang pamamaraan ng pag-encode, ang Python ay nagbibigay ng iba't ibang paraan upang lumikha ng mga string ng Unicode batay sa isang kilalang encoding.

Upang i-convert ang isang Unicode string sa isang pagkakasunud-sunod ng mga byte gamit ang nais na pag-encode, ang mga string object ay nagbibigay ng isang encode() na paraan na kumukuha ng isang parameter, ang pangalan ng encoding. Ibinibigay ang kagustuhan sa pag-encode ng mga pangalang nakasulat maliit na titik.

>>> "Äpfel" .encode ("utf-8") b" \xc3\x84pfel"

Mga listahan

Mayroong maraming magagamit ang Python pinagsama-sama mga uri ng data na ginagamit upang pagsama-samahin ang iba pang mga halaga. Ang pinaka-kakayahang umangkop sa kanila ay ang listahan. Maaari itong ipahayag sa teksto ng programa gamit ang mga halagang pinaghihiwalay ng kuwit ( elemento), nakapaloob sa mga square bracket. Ang mga elemento ng listahan ay maaaring may iba't ibang uri.

>>> a = [ "spam" , "itlog" , 100 , 1234 ] >>> a [ "spam" , "itlog" , 100 , 1234 ]

Tulad ng mga string index, ang mga listahan ng index ay nagsisimula sa zero ang mga listahan ay maaaring putulin, pinagsama-sama (; pinagsama-sama) at iba pa:

>>> a[ 0 ] "spam" >>> a[ 3 ] 1234 >>> a[ -2 ] 100 >>> a[ 1 :-1 ] [ "itlog" , 100 ] >>> a[ : 2 ] + [ "bacon" , 2 * 2 ] [ "spam" , "itlog" , "bacon" , 4 ] >>> 3 * a[ :3 ] + [ "Boo!" ] [ "spam" , "itlog" , 100 , "spam" , "itlog" , 100 , "spam" , "itlog" , 100 , "Boo!" ]

Hindi tulad ng mga string, na hindi nababago, medyo posible na baguhin ang mga indibidwal na elemento ng listahan:

>>> a [ "spam" , "itlog" , 100 , 1234 ] >>> a[ 2 ] = a[ 2 ] + 23 >>> a [ "spam" , "itlog" , 123 , 1234 ]

Posible rin ang pagtalaga sa isang slice, at ang pagkilos na ito ay maaaring baguhin ang laki ng listahan o ganap itong i-clear: 123 , "blech" , "xyzzy" , 1234 ] >>> # Ipasok ang (isang kopya) ng ating sarili sa simula>>> a[ :0 ] = a >>> a [ 123 , "bletch" , "xyzzy" , 1234 , 123 , "bletch" , "xyzzy" , 1234 ] >>> # I-clear ang listahan: palitan ang lahat ng mga halaga walang laman na listahan >>> a[ :] = >>> a

Nalalapat din ang built-in na len() function sa mga listahan:

>>> a = [ "a" , "b" , "c" , "d" 1 ] .dugtungan ( "xtra") >>> p [ 1 , [ 2 , 3 , "xtra" ] , 4 ] > >> q [ 2 , 3 , "xtra" ]

Tandaan na sa huling halimbawa, ang p at q ay talagang tumutukoy sa parehong bagay! Babalik tayo sa semantika ng mga bagay Mamaya.

Mga unang hakbang sa programming

Siyempre, maaaring gamitin ang Python para sa mas kumplikadong mga gawain kaysa sa pagdaragdag ng dalawang numero. Halimbawa, maaari naming i-output ang simula ng Fibonacci sequence tulad nito:

>>> # Fibonacci series: ... # ang kabuuan ng dalawang elemento ay tumutukoy sa susunod na elemento... a , b = 0, 1 >>> habang b< 10: ... print (b) ... a , b = b, a+b ... 1 1 2 3 5 8

Ang halimbawang ito ay nagpapakita sa amin ng ilang mga bagong posibilidad.

• Ang unang linya ay naglalaman ng maramihang takdang-aralin(maramihang pagtatalaga): ang mga variable a at b ay tumatanggap ng mga bagong halaga nang magkatulad - 0 at 1. Ginagamit muli ng huling linya ang paraang ito, na nagpapakita ng katotohanan na ang mga expression sa kanan [ng operator ng pagtatalaga] ay palaging sinusuri bago ang anumang mga pagtatalaga. Ang mga expression na pinaghihiwalay ng kuwit mismo ay sinusuri mula kaliwa hanggang kanan.

• Ang while loop ay isinasagawa hanggang sa kondisyon (dito: b< 10) остается истиной. В Python, также как и в C, любое ненулевое значение является истиной (True); ноль является ложью (False). Условием может быть строка, список или вообще любая последовательность; все, что имеет ненулевую длину, играет роль истины, пустые последовательности - лжи. Использованная в примере проверка - простое условие. Стандартные операции сравнения записываются так же, как и в C: < (меньше чем), >(mas malaki kaysa), == (katumbas),<= (меньше или равно), >= (mas malaki sa o katumbas) at != (hindi katumbas).

• Katawan cycle na naka-highlight indent(naka-indent). Ang indentation ay isang paraan ng pagpapangkat ng mga pahayag sa Python. Ang interactive na mode ng Python (pa!) ay walang anumang matino o maginhawang pasilidad para sa pag-edit ng mga linya ng input, kaya dapat kang gumamit ng mga tab o mga puwang upang i-indent ang bawat linya. Sa pagsasagawa, ang mas kumplikadong Python text ay inihanda sa isang text editor, at karamihan sa mga ito ay may tampok na auto-indent. Kapag natapos mong ipasok ang isang compound expression nang interactive, dapat mo itong kumpletuhin walang laman na linya- tanda ng pagkumpleto (dahil hindi mahulaan ng interpreter kung kailan ka pumasok sa huling linya). Pakitandaan na ang laki ng indentation sa bawat linya ng pangunahing bloke ay dapat na pareho.

• Ang print() function ay nagpi-print ng mga halaga ng mga expression na ipinasa dito. Ang pag-uugali ng function na ito ay naiiba sa normal na expression na output (tulad ng nangyari sa mga halimbawa ng calculator sa itaas) sa paraan na ang mga serye ng mga expression, floating point value, at mga string ay naproseso. Ang mga string ay naka-print nang walang mga panipi at ang mga puwang ay ipinasok sa pagitan ng mga elemento, na nagreresulta sa pinahusay na pag-format ng output - tulad nito:
987

| |

Ang mga komento ay mga linyang umiiral sa program code ngunit hindi pinapansin ng mga compiler at interpreter. Ginagawang mas nababasa ng mga komento ang code sa pamamagitan ng pagpayag sa mga user na karagdagang impormasyon o magdagdag ng paliwanag ng isang partikular na bloke ng code.

Depende sa layunin ng programa, ang mga komento ay maaaring magsilbing mga tala. Gayundin, sa kanilang tulong, maaari mong ipaliwanag sa ibang mga programmer kung ano ang ginagawa nito o ang bahaging iyon ng code ng programa.

Syntax ng Komento

Ang mga komento sa Python ay nagsisimula sa isang hash (# simbolo) na sinusundan ng isang puwang.

Pangkalahatang view ng komento:

# Ito ay isang komento

Ang mga linya ng komento ay hindi naisakatuparan, kaya kapag pinatakbo mo ang programa ay hindi ka makakakita ng anumang katibayan ng mga komento dito. Ang mga komento ay nasa source code para sa kadalian ng pagbabasa ng program code ng ibang mga gumagamit, at hindi para sa pagpapatupad.

Sa pinakasimpleng programa na "Hello, World!" ang isang komento ay maaaring magmukhang ganito:

# I-print ang "Hello, World!" para aliwin
print("Hello, World!")

SA para sa loop, na umuulit sa mga listahan, maaaring may mga komentong tulad nito:

# Tukuyin ang variable ng mga pating bilang isang listahan ng mga string
pating = ["hammerhead", "great white", "dogfish", "frilled", "bulllhead", "requiem"]
# Para sa loop na umuulit sa listahan ng mga pating at nagpi-print ng bawat string item
para sa pating sa mga pating:
print(pating)

Kapag naglalagay ng komento, dapat mong isaalang-alang ang indentation sa code kung saan ito nilayon. Iyon ay, kung ang isang kahulugan ng function ay hindi naka-indent, kung gayon ang komentaryo sa kahulugan na ito ay hindi dapat naka-indent.

Halimbawa, isaalang-alang ang again() function mula sa manual:

...
# Define again() function para tanungin ang user kung gusto nilang gamitin muli ang calculator
def ulit():
# Kumuha ng input mula sa user
calc_again = input("""
Gusto mo bang kalkulahin muli?
Paki-type ang Y para sa OO o N para sa HINDI.
""")
# Kung uri ng user Y, patakbuhin ang function na kalkulahin ().
kung calc_again == "Y":
kalkulahin ()
# Kung nag-type ang user ng N, magpaalam sa user at tapusin ang program
elif calc_again == "N":
print ("Magkita tayo mamaya.")
# Kung nag-type ang user ng isa pang key, patakbuhin muli ang function
iba pa:
muli()

Ang mga komento ay dapat makatulong sa mga programmer na magtrabaho kasama ang code. Kung sa ilang kadahilanan ay hindi ka makapagbigay ng sapat na suporta at napapanahong mga pag-update sa mga komento, mas mabuting huwag nang gamitin ang mga ito. Ang code na walang komento ay mas mahusay kaysa sa code na may maling komento.

Inirerekomenda na isama sa mga komento kung bakit ginagawa ng code ang ginagawa nito (sa halip na kung paano o ano ang ginagawa nito). Sa karamihan ng mga kaso, ang programmer, na pamilyar sa kanyang sarili sa code, ay maaaring matukoy para sa kanyang sarili kung ano ang eksaktong ginagawa ng code at kung paano ito ginagawa.

I-block ang mga komento

Ang mga komento sa pag-block ay maaaring magpaliwanag ng mas kumplikadong code o code na maaaring mahirap para sa mga user na malaman nang mag-isa. Ang nasabing bloke ng komento ay dapat magkaroon ng parehong dami ng indentation gaya ng ipinapaliwanag nitong bloke ng code.

Sa mga block na komento, ang bawat linya ay nagsisimula sa isang hash at isang puwang. Upang hatiin ang isang bloke ng mga komento sa mga talata, maglagay ng hash sa isang bagong linya at iwanang walang laman ang linya.

Ang sumusunod na block comment ay naglalarawan ng mga aksyon ng main() function.

# Ang pangunahing function ay mag-parse ng mga argumento sa pamamagitan ng parser variable. Ang mga ito
# argumento ang tutukuyin ng user sa console. Lilipas ito
# ang salitang argumento na gustong i-parse ng user kasama ang filename na
# user ang gustong gumamit, at magbigay din ng text ng tulong kung ang user ay hindi
# ipasa nang tama ang mga argumento.
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"salita",
help="ang salita na hahanapin sa text file."
parser.add_argument(
"filename",
help="ang landas patungo sa text file na hahanapin"
...

Karaniwang ginagamit ang mga komento sa block kapag kailangan ng code detalyadong paliwanag. Gayunpaman, dapat mong iwasan ang labis na mga komento sa code ng programa.

Mga komento sa linya

Ang mga komento sa linya ay sumusunod sa code (iyon ay, sila ay nasa parehong linya ng mga expression na ipinapaliwanag nila).

Ganito ang hitsura ng komento sa linya:

# Inline na komento tungkol sa code

Ang mga inline na komento ay nagbibigay ng maikling paliwanag para sa isang hindi malinaw na bahagi ng code, ngunit dapat itong gamitin nang may pag-iingat. Kadalasang ginagamit ang mga ito bilang mga maikling tala para sa ibang mga gumagamit.

Halimbawa, kung ipagpalagay mo na hindi alam ng ibang mga developer sa iyong team na ang sumusunod na expression ay gumagawa ng isang kumplikadong numero, maaari kang magdagdag ng komento sa linya:

z = 2.5 + 3j # Lumikha ng isang kumplikadong numero

Gayundin, maaaring ipaliwanag ng isang inline na komento kung bakit ka gumagamit ng isang partikular na elemento dito:

x = 8 # Magsimula ng x gamit ang isang arbitrary na numero

Ang mga komento sa linya ay dapat na bihirang gamitin.

Syntax ng wika sawa ay sa maraming paraan ay katulad ng syntax ng mga wika tulad ng Perl, C at Java, ngunit sa parehong oras mayroon itong isang bilang ng mga pagkakaiba mula sa mga programming language na ito. Sa artikulong ito titingnan natin ang kinakailangan mga pangunahing kaalaman ito programming language.

Unang Python program:

Una, dapat tandaan na sawa maaari kang mag-program sa dalawang mga mode: interactive At scripted

Interactive programming mode:

Nang hindi ipinapasa ang pangalan ng file bilang argumento, tatakbo ito Tagasalin ng Python:

Ipasok ang sumusunod na teksto pagkatapos ng prompt na linya sawa at pindutin ang Enter:

>>> i-print ang "Hello, Python!"

Kung ginawa mo nang tama ang lahat, gagawa ang interpreter ng linya:

Kung nakatanggap ka ng error, tiyaking naisulat mong muli ang code nang tama at gumagamit ka ng bersyon 2.x ng interpreter (para sa bersyon 3.x dapat mong gamitin ang print ("Hello, Python") command)

Script programming mode:

Ilunsad sa command line sawa na may pangalan ng file (tinatawag ding script) bilang isang parameter, magsisimulang isagawa ang code na nakasulat ang file na ito. Matapos makumpleto ang script, ang interpreter ay magiging hindi aktibo muli.

Gumawa tayo ng simpleng script program gamit ang sawa. Buksan ang alinman text editor(Sublime, Notepad++, gedit...), lumikha ng isang file sa loob nito na may pangalang pagsubok at extension .py (lahat ng mga file na naglalaman ng code sa sawa dapat may extension .py) at isulat ang code na pamilyar na sa amin sa file na ito at i-save ang file:

I-print ang "Hello, Python!"

(Ipinapalagay na Tagasalin ng Python naitakda mo ito sa variable ng PATH, iyon ay, sa anumang direktoryo maaari kang magpasok ng python upang ilunsad ang interpreter)

Pagkatapos nito, i-type ang sumusunod na linya sa command prompt at pindutin ang Enter:

Mga Identifier sa Python:

Mga Identifier sa Python ito ay mga pangalan na ginagamit upang italaga ang isang variable, function, klase, module, o iba pang bagay. Ang identifier ay dapat magsimula sa isang titik (a hanggang Z) o isang underscore (_), na sinusundan ng anumang bilang ng mga titik, underscore, at numero (0 hanggang 9).

SA sawa Hindi katanggap-tanggap na gumamit ng bantas o mga espesyal na character gaya ng @, $ o % bilang mga identifier. Bukod, sawa ay case sensitive, iyon ay pusa At Pusa dalawang magkaibang pangalan ito.

Ang Python ay may sumusunod na convention para sa pagbibigay ng pangalan sa mga identifier:

• Nagsisimula ang mga pangalan ng klase sa malaking letra, lahat ng iba pang identifier ay nagsisimula sa maliit na letra.
• Ang paggamit ng underscore bilang unang character ng isang identifier ay nangangahulugan na ang identifier ay pribado (hindi pinapayagang gamitin sa labas ng klase).
• Kung ang isang identifier ay nagsisimula at nagtatapos sa dalawang underscore (halimbawa, __init__) nangangahulugan ito na ito ay isang espesyal na pangalan na tinukoy sa loob ng wika.

Nakareserba (mga keyword) na salita sa Python:

Ang talahanayang ito ay naglalaman ng lahat Mga keyword sa Python.

at	elif	Habang ang mga pahayag	print
bilang	# lumabas sa loop anumang oras	import	itaas
igiit	maliban sa	sa	bumalik
# Operasyon "	exec	ay	subukan
klase	sa wakas	lambda	habang
iba pa	kung	hindi	alin
def	mula sa	o	ani
del	global	pumasa

Ang mga ito nakalaan na salita hindi maaaring gamitin bilang isang variable na pangalan o anumang iba pang identifier. Lahat Mga keyword sa Python binubuo ng maliliit na titik lamang. Kumuha ng listahan mga keyword posible sa interpreter na may utos

Tulong("mga keyword")

Mga linya at indent:

Isa sa mga unang tampok sawa Isang bagay na kapansin-pansin sa mga programmer na nagsisimulang matutunan ang programming language na ito ay hindi ito gumagamit ng mga panaklong upang tukuyin ang mga indibidwal na bloke ng code. Sa halip na sila ang pumasok sawa colon at indent ang ginagamit.

Ang bilang ng mga puwang sa mga indentasyon ay arbitrary at pinili ng lahat sa kanilang sariling pagpapasya, ngunit sa pamamagitan ng kasunduan ito ay katumbas ng apat na puwang. Sa kasong ito, ang indentation ng buong block ay dapat na pareho.

Halimbawa, gagana ang bloke ng code na ito (bagaman hindi mo ito dapat isulat sa ganitong paraan):

Kung Tama: i-print ang "Hi" else: i-print ang "Bye"

At ito ay magdudulot ng error:

Kung Tama: i-print ang "Hi" i-print ang "Bye"

Kaya, sa sawa ilang linya ng code na may pantay na indentasyon bubuo ng hiwalay na bloke ng code. Salamat sa naturang sistema, ang pagiging madaling mabasa ng code ay tumaas nang malaki at ang ugali ng pagsulat nang malinaw at nakabalangkas ay naitanim.

Mga multiline na expression:

Mga expression sa Python, bilang panuntunan, magtatapos sa isang bagong linya. Gayunpaman, sa programming language na ito mayroong isang espesyal na line break character (\), na nagpapahiwatig na ang dulo ng linya ay hindi nagtatapos sa code. Halimbawa:

Kabuuan = item1 + \item2 + \item3

Ang mga expression na nasa loob ng mga panaklong: parisukat (), kulot (( )), o mga panaklong (()) ay hindi nangangailangan ng isang line break. Halimbawa:

Mga Araw = ["Linggo", "Lunes", "Martes", "Miyerkules", "Huwebes", "Biyernes", "Sabado"]

Mga quote sa Python:

SA sawa Maaari kang gumamit ng single ("), double ("), at triple (""" o """) na mga panipi upang tukuyin ang isang uri ng data ng string, at ang string ay dapat magsimula at magtapos sa parehong mga panipi. Ang isang linya na sumasaklaw sa ilang linya ng code ay dapat na napapalibutan ng triple quotes. Halimbawa:

Pangalan = "wasd" paglalarawan = "Ilang teksto" talambuhay = """ Ilang mahabang teksto para sa ilang linya ng code na """