Panimula sa Python- Lahat ng Kailangan Mong Malaman Tungkol sa Python

Saklaw ng blog na ito ang lahat ng pangunahing pag-program ng sawa at bibigyan ka ng isang kumpletong pagpapakilala sa sawa kasama ang mga pangunahing tampok at pakinabang.

Ang industriya ng IT ay umuusbong kasama ang artipisyal na katalinuhan, pag-aaral ng makina at mga aplikasyon ng agham data. Gamit ang mga bagong application ng edad, demand para sa a nadagdagan din. Ang kadalian ng pag-access at pagiging madaling mabasa ay gumawa ng sawa ng isa sa pinakapopular na wika sa pagprograma sa kasalukuyan. Ngayon na ang oras upang lumipat sa sawa at ilabas ang walang katapusang mga posibilidad na kasama ng programa ng python. Ang artikulong ito sa Panimula sa sawa ay gagabay sa iyo sa mga pangunahing kaalaman at pangunahing konsepto sa pag-program ng sawa.

Sa artikulong ito, bibigyan kita ng isang pagpapakilala sa sawa. Ang mga sumusunod ay ang mga paksang saklaw sa blog na ito:





Panimula Sa Python

Ang Python ay isang pangkalahatang layunin na wika ng pagprograma. Napakadaling matutunan, madaling syntax at kakayahang mabasa ay isa sa mga kadahilanan kung bakit lumilipat ang mga developer sa sawa mula sa iba pang mga wika sa programa.

Maaari naming gamitin ang sawa bilang oriented ng object at oriented na pamamaraan na wika din. Ito ay bukas na mapagkukunan at mayroong toneladang mga aklatan para sa iba't ibang pagpapatupad.



tampok-pagpapakilala sa sawa-edureka

Ang Python ay isang mataas na antas na naisalin na wika, na pinakaangkop sa pagsulat ng mga script ng python para sa awtomatiko at muling paggamit ng code.

Ito ay nilikha noong 1991 ni Guido Van Rossum. Ang pinagmulan ng pangalan nito ay inspirasyon ng serye ng komedya na tinawag na 'Monty python'.



Ang pagtatrabaho sa sawa ay nagbibigay sa amin ng walang katapusang mga posibilidad. Pwede natin gamitin , pagkatuto ng makina , Artipisyal na katalinuhan , , atbp.

Upang makapagtrabaho sa anumang wika ng pagprograma, dapat pamilyar ka sa isang IDE. Mahahanap mo ang pag-set up para sa isang IDE para sa sawa, sa 'python.org' at mai-install ito sa iyong system. Ang pag-install ay tila madali at may IDLE para sa pagsusulat ng mga programa sa sawa.

Matapos mong mai-install ang sawa sa iyong system, handa ka nang magsulat ng mga programa sa wika ng programa ng sawa.

Hinahayaan nating magsimula sa pagpapakilala na ito sa sawa ng mga keyword at identifier.

Mga Keyword at Identifier

Ang mga keyword ay walang iba kundi ang mga espesyal na pangalan na mayroon na sa sawa. Maaari naming gamitin ang mga keyword na ito para sa tukoy na pag-andar habang nagsusulat ng isang programa ng sawa.

Ang sumusunod ay ang listahan ng lahat ng mga keyword na mayroon kami sa sawa:

i-import ang keyword keyword.kwlist #ito ay makukuha sa iyo ang listahan ng lahat ng mga keyword sa sawa. keyword.iskeyword ('subukan') #mababalik ito totoo, kung ang nabanggit na pangalan ay isang keyword.

Ang mga identifier ay mga pangalan na tinukoy ng gumagamit na ginagamit namin upang kumatawan sa mga variable, klase, pag-andar, modyul atbp.

pangalan = 'edureka' my_identifier = pangalan

Mga variable at Uri ng Data

Ang mga variable ay tulad ng isang lokasyon ng memorya kung saan maaari kang mag-imbak ng isang halaga. Ang halagang ito, maaari o hindi maaaring magbago sa hinaharap.

x = 10 y = 20 pangalan = 'edureka'

Sa magdeklara ng variable sa sawa, magtatalaga ka lamang ng halaga dito. Walang mga karagdagang utos na kinakailangan upang ideklara ang isang variable sa sawa.

Mga Uri ng Data sa Python

  1. Numero
  2. String
  3. Listahan
  4. Diksyonaryo
  5. Itakda
  6. Tulak

Numero

Ang mga numero o uri ng data na bilang ay ginagamit para sa mga halagang bilang. Mayroon kaming 4 na uri ng mga bilang ng data na bilang.

Ginagamit ang mga #integer upang ideklara ang buong mga numero. x = 10 y = 20 #float data uri ay ginagamit upang ideklara ang mga halaga ng decimal point x = 10.25 y = 20.342 #complex na mga numero na nagpapahiwatig ng mga haka-haka na halaga x = 10 + 15j # boolean ay ginagamit upang makakuha ng kategorya ng output num = x<5 #the output will be either true or false here. 

String

Ginagamit ang uri ng string data upang kumatawan sa mga character o alpabeto. Maaari kang magdeklara ng isang string gamit ang solong 'o dobleng mga quote na' '.

pangalan = 'edureka' course = 'python'

Upang ma-access ang mga halaga sa isang string, maaari kaming gumamit ng mga index.

pangalanan [2] # ang output ay ang mga alpabeto sa partikular na index.

Listahan

Ang listahan sa sawa ay tulad ng isang koleksyon kung saan maaari kang mag-imbak ng iba't ibang mga halaga. Hindi ito kailangang maging pare-pareho at maaaring magkaroon ng magkakaibang mga halaga.

Ang mga listahan ay na-index at maaaring magkaroon ng mga duplicate na halaga rin. Upang ideklara ang isang listahan, kailangan mong gumamit ng mga square bracket.

my_list = [10, 20, 30, 40, 50, 60, 'edureka', 'python'] print (my_list)

Upang ma-access ang mga halaga sa isang listahan na ginagamit namin ang mga index, ang sumusunod ay ilang pagpapatakbo na maaari mong gampanan sa isang listahan:

  • idugtong
  • malinaw
  • kopya
  • bilangin
  • magpahaba
  • isingit
  • pop
  • baligtarin
  • tanggalin
  • pag-uri-uriin

Ang sumusunod ay isang code para sa ilang mga pagpapatakbo na gumagamit ng isang listahan:

a = [10,20,30,40,50] #append ay idaragdag ang halaga sa dulo ng listahan a.append ('edureka') #insert ay idaragdag ang halaga sa tinukoy na index a.insert (2, ' edureka ') #reverse ay ibabalik ang listahan a.reverse () print (a) #the output will be [' edureka ', 50, 40, 30,' edureka ', 20, 10]

Diksyonaryo

Ang isang diksyunaryo ay hindi naayos at nababago, ginagamit namin ang mga pangunahing halaga ng mga pares sa isang diksyunaryo. Dahil natatangi ang mga susi maaari naming gamitin ang mga ito bilang mga index upang ma-access ang mga halaga mula sa isang diksyunaryo.

Ang mga sumusunod ay ang mga pagpapatakbo na maaari mong gampanan sa isang diksyunaryo:

  • malinaw
  • kopya
  • mula sa mga asno
  • kumuha ka
  • mga item
  • mga susi
  • pop
  • getitem
  • setdefault
  • pag-update
  • halaga
my_dictionary = {'key1': 'edureka', 2: 'python'} mydictionary ['key1'] # Makukuha nito ang halagang 'edureka'. ang parehong layunin ay maaaring matupad sa pamamagitan ng makakuha (). my_dictionary.get (2) # Makukuha nito ang halagang 'python'.

Tulak

Ang Tuple ay isa pang koleksyon na naiutos at hindi mababago. Idineklara namin ang mga tuple sa sawa na may mga bilog na braket.Ang mga sumusunod ay ang mga pagpapatakbo na maaari mong gampanan sa isang tuple:

  • bilangin
  • indeks
mytuple = (10,20,30,40,50,50,50,60) mytuple.count (40) # Makukuha nito ang bilang ng mga duplicate na halaga. mytuple.index (20) # Makukuha nito ang index para sa vale 20.

Itakda

Ang isang hanay ay isang koleksyon na kung saan ay hindi naayos at hindi nai-unexed. Ang isang set ay walang anumang mga duplicate na halaga rin. Ang sumusunod ay ilang mga pagpapatakbo na maaari mong gampanan sa isang hanay:

  • idagdag
  • kopya
  • malinaw
  • pagkakaiba
  • pagkakaiba_update
  • itapon
  • interseksyon
  • intersection_update
  • unyon
  • pag-update
myset = {10, 20,30,40,50,60,50,60,50,60} print (myset) #tindi magkakaroon ng mga duplicate na halaga sa output

Sa anumang wika ng pagprograma, ang konsepto ng mga operator ay may mahalagang bahagi.Tingnan natin ang mga operator sa sawa.

Mga Operator

Ang mga operator sa sawa ay ginagamit upang magsagawa ng mga operasyon sa pagitan ng dalawang halaga o variable. Ang mga sumusunod ay ang iba't ibang mga uri ng mga operator na mayroon kami sa sawa:

  • Mga Operator ng Arithmetic
  • Mga Lohikal na Operator
  • Mga Operator ng Asignatura
  • Mga Operator ng Paghahambing
  • Mga Operator ng Pagkakasapi
  • Mga Operator ng Pagkakakilanlan
  • Mga Bitwise Operator

Mga Operator ng Arithmetic

Ginagamit ang mga operator ng arithmetic upang magsagawa ng mga pagpapatakbo ng arithmetic sa pagitan ng dalawang halaga o variable.

#arithmetic operator mga halimbawa x + y x - y x ** y

Mga Operator ng Asignatura

Ginagamit ang mga operator ng pagtatalaga upang magtalaga ng mga halaga sa isang variable.

Mga Lohikal na Operator

Ginagamit ang mga lohikal na operator upang ihambing ang mga kondisyong pahayag sa sawa.

Mga Operator ng Paghahambing

Ginagamit ang mga operator ng paghahambing upang ihambing ang dalawang halaga.

Mga Operator ng Pagkakasapi

Ginagamit ang mga operator ng membership upang suriin kung ang isang pagkakasunud-sunod ay naroroon sa isang bagay.

Mga Operator ng Pagkakakilanlan

Ginagamit ang mga operator ng pagkakakilanlan upang ihambing ang dalawang bagay.

Mga Bitwise Operator

Ginagamit ang mga bitwise operator upang ihambing ang mga halagang binary.

Ngayon na naintindihan namin ang mga operator sa sawa, hinayaan maunawaan ang konsepto ng mga loop sa sawa at kung bakit gumagamit kami ng mga loop.

Mga Loops Sa Python

Pinapayagan kami ng isang loop na magpatupad ng isang pangkat ng mga pahayag nang maraming beses. Maintindihan , hinahayaan kumuha ng isang halimbawa.

Ipagpalagay na nais mong i-print ang kabuuan ng lahat ng kahit na mga numero hanggang sa 1000. Kung isulat mo ang lohika para sa gawaing ito nang hindi gumagamit ng mga loop, ito ay magiging isang mahaba at nakapapagod na gawain.

Ngunit kung gumagamit kami ng isang loop, maaari naming isulat ang lohika upang hanapin ang pantay na numero, magbigay ng isang kundisyon na umulit hanggang umabot sa 1000 ang numero at mai-print ang kabuuan ng lahat ng mga numero. Bawasan nito ang pagiging kumplikado ng code at gagawin din itong mabasa.

Mayroong mga sumusunod na uri ng mga loop sa python:

  1. para sa loop
  2. habang loop
  3. naka-pugad na mga loop

Para sa Loop

SAGinagamit ang 'for loop' upang maisagawa ang mga pahayag nang isang beses sa bawat pag-ulit. Alam na natin ang bilang ng mga pag-ulit na naisasagawa.

Ang isang para sa loop ay may dalawang mga bloke, ang isa ay kung saan tinukoy namin ang mga kundisyon at pagkatapos ay mayroon kaming katawan kung saan tinukoy ang mga pahayag na naisagawa sa bawat pag-ulit.

para sa x sa saklaw (10): print (x)

Habang Loop

Ang habang loop ay nagpapatupad ng mga pahayag hangga't ang kondisyon ay totoo. Tinutukoy namin ang kundisyon sa simula ng loop at sa lalong madaling mali ang kundisyon, titigil ang pagpapatupad.

ako = 1 habang ako<6: print(i) i += 1 #the output will be numbers from 1-5. 

Pugad ng Loops

Ang mga pugad na mga loop ay kombinasyon ng mga loop. Kung isasama namin ang isang habang loop sa isang para sa loop o vis-a-vis.

Sumusunodang ilang mga halimbawa ng mga pugad na mga loop:

para sa saklaw (1,6): para sa j sa saklaw (i): print (i, end = ') print () # ang output ay magiging 1 22 333 4444 55555

Mga Pahayag na Kundisyon at Pagkontrol

Sinusuportahan ng mga kondisyon na pahayag sa sawa ang karaniwang lohika sa mga lohikal na pahayag na mayroon kami sa sawa.

Sumusunoday ang mga kondisyong pahayag na mayroon kami sa sawa:

  1. kung
  2. elif
  3. iba pa

kung pahayag

x = 10 kung x> 5: i-print ('mas malaki')

Ang kung pahayagSinusubukan ang kundisyon, kung ang kondisyon ay totoo, isinasagawa nito ang mga pahayag sa kung block.

pahayag ng elif

x = 10 kung x> 5: i-print ('mas malaki') elif x == 5: i-print ('pantay') #else statement x = 10 kung x> 5: i-print ('mas malaki') elif x == 5: i-print ('pantay') pa: i-print ('mas maliit')

Kapag parehokung at mga pahayag ng elif ay hindi totoo, ang pagpapatupad ay lilipat sa ibang pahayag.

Mga pahayag sa pagkontrol

Kontrolinginagamit ang mga pahayag upang makontrol ang daloy ng pagpapatupad sa programa.

Sumusunoday ang mga pahayag sa pagkontrol na mayroon kami sa sawa:

  1. pahinga
  2. magpatuloy
  3. pumasa

pahinga

pangalan = 'edureka' para sa val sa pangalan: kung val == 'r': masira ang pag-print (i) #ang output ay e d u

Titigil ang pagpapatupad sa sandaling masira ang mga engkwentro ng loop.

Magpatuloy

pangalan = 'edureka' para sa val sa pangalan: kung val == 'r': ipagpatuloy ang pag-print (i) #ang output ay e d u e k a

Kapag nagpatuloy ang mga nakatagpo ng loop, ang kasalukuyang pag-ulit ay nilaktawan at ang natitirang mga pag-ulit ay naisagawa.

Pumasa

pangalan = 'edureka' para sa val sa pangalan: kung val == 'r': ipasa ang print (i) #ang output ay e d u r e k a

Ang pass statement ay isang null na operasyon. Nangangahulugan ito na ang utos ay kinakailangan ng syntactically ngunit hindi mo nais na magpatupad ng anumang utos o code.

Ngayon na tapos na kami sa iba't ibang mga uri ng mga loop na mayroon kami sa sawa, hinahayaan na maunawaan ang konsepto ng mga pagpapaandar sa sawa.

Mga pagpapaandar

Ang isang pag-andar sa sawa ay isang bloke ng code na kung saan tatawagin ito. Maaari naming ipasa ang mga parameter sa mga pag-andar din. Upang maunawaan ang konsepto ng mga pagpapaandar, hinahayaan na kumuha ng isang halimbawa.

Ipagpalagay na nais mong kalkulahin ang factorial ng isang numero. Maaari mo itong gawin sa pamamagitan lamang ng pagpapatupad ng lohika upang makalkula ang isang factorial. Ngunit paano kung kailangan mong gawin ito ng sampung beses sa isang araw, ang pagsusulat ng parehong lohika nang paulit-ulit ay magiging isang mahabang gawain.

Sa halip, kung ano ang maaari mong gawin ay, isulat ang lohika sa isang pagpapaandar. Tumawag sa pagpapaandar na iyon sa tuwing kailangan mo upang kalkulahin ang factorial. Bawasan nito ang pagiging kumplikado ng iyong code at mai-save din ang iyong oras.

Paano Lumikha ng isang Pag-andar?

# ginagamit namin ang def keyword upang magdeklara ng isang function def function_name (): #expression print ('abc')

Paano Tumawag sa isang Pag-andar?

def my_func (): i-print ('nilikha ang function') #this is a function call my_func ()

Mga Parameter ng Pag-andar

Kaya natinipasa ang mga halaga sa isang pagpapaandar gamit ang mga parameter. Maaari din tayong gumamit ng mga default na halaga para sa isang parameter sa isang pagpapaandar din.

def my_func (name = 'edureka'): i-print (pangalan) #default na parameter my_func () #userdefined parameter my_func ('python')

Pag-andar ng Lambda

Ang isang lambda function ay maaaring tumagal ng maraming bilang ng mga parameter, ngunit mayroong isang catch. Maaari lamang magkaroon ng isang pagpapahayag.

# lambda argument: expression lambda a, b: a ** b print (x (2,8)) #ang resulta ay magiging exponentiation ng 2 at 8.

Ngayon na naintindihan na natin ang mga tawag sa pag-andar, mga parameter at kung bakit namin ginagamit ang mga ito, tingnan natin ang mga klase at bagay sa sawa.

Mga Klase at Bagay

Ano ang Mga Klase?

Ang mga klase ay tulad ng isang blueprint para sa paglikha ng mga bagay. Maaari kaming mag-imbak ng iba't ibang mga pamamaraan / pag-andar sa isang klase.

class classname: def functionname (): print (expression)

Ano ang Mga Bagay?

Lumilikha kami ng mga bagay upang tawagan ang mga pamamaraan sa isang klase, o upang ma-access ang mga katangian ng isang klase.

class myclass: def func (): print ('my function') #lumilikhaisang object ob1 = myclass () ob.func ()

__init__ pagpapaandar

Ito ay isang built-in na function na kung saan ay tinatawag kapag ang isang klase ay sinimulan. Ang lahat ng mga klase ay may __init__ function. Ginagamit namin ang __init__ function upang magtalaga ng mga halaga sa mga bagay o iba pang mga operasyon na kinakailangan kapag ang isang bagay ay nilikha.

class myclass: def __init __ (self, name): self.name = name ob1 = myclass ('edureka') ob1.name #the output will be- edureka

Ngayon na naintindihan na namin ang konsepto ng mga klase at bagay, hinayaan ang pagtingin sa ilang mga konsepto ng oops na mayroon kami sa sawa.

Mga Konsepto ng OOPs

Ang Python ay maaaring magamit bilang isang object na nakatuon sa wika ng programa. Samakatuwid, maaari naming gamitin ang mga sumusunod na konsepto sa sawa:

  1. Abstraction
  2. Encapsulasyon
  3. Mana
  4. Polymorphism

Abstraction

Ang abstraction ng data ay tumutukoy sa pagpapakita lamang ng mga kinakailangang detalye at pagtatago ng mga gawain sa background. Ang abstraction ay sawa ay katulad ng anumang iba pang mga wika ng programa.

Tulad ng pag-print namin ng isang pahayag, hindi namin alam kung ano ang nangyayari sa likuran.

Encapsulasyon

Ang Encapsulation ay ang proseso ng pagbabalot ng data. Sa sawa, ang mga klase ay maaaring isang halimbawa ng encapsulation kung saan ang mga pagpapaandar ng miyembro at variable atbp ay nakabalot sa isang klase.

Mana

Ang mana ay isang konsepto na nakatuon sa object kung saan ang isang bata na klase ay nagmamana ng lahat ng mga pag-aari mula sa isang magulang na klase. Ang mga sumusunod ay ang mga uri ng mana na mayroon kami sa sawa:

  1. Single na Mana
  2. Maramihang Mana
  3. Mana ng Multilevel

Single na Mana

Sa iisang pamana mayroon lamang isang klase ng bata na nagmamana ng mga pag-aari mula sa isang magulang na klase.

kalamangan ng overloading ng pamamaraan sa java
magulang ng klase: def printname (pangalan): print (pangalan) klase ng bata (magulang): pumasa sa ob1 = bata ('edureka') ob1.printname

Maramihang Mana

Sa maraming mana, mayroon kaming dalawang klase ng magulang at isang klase ng bata na nagmamana ng mga pag-aari mula sa parehong mga magulang na klase.

Mana ng Multilevel

Sa multilevel na pamana, mayroon kaming isang klase ng bata na nagmamana ng mga pag-aari mula sa isang magulang na klase. Ang parehong klase ng bata ay gumaganap bilang isang magulang na klase para sa isa pang klase ng bata.

Polymorphism

Ang Polymorphism ay ang proseso kung saan maaaring magamit ang isang bagay sa maraming anyo. Ang pinakakaraniwang halimbawa ay kapag ginamit ang sanggunian ng klase ng magulang upang mag-refer sa isang object ng klase ng bata.

Naintindihan namin ang mga konsepto ng oops na mayroon kami sa sawa, hinayaan maunawaan ang mga konsepto ng mga pagbubukod at paghawak ng pagbubukod sa sawa.

Natatanging Pangangasiwa

Kapag nagsusulat kami ng isang programa, kung nangyayari ang isang error ay titigil ang programa. Ngunit maaari naming hawakan ang mga error / pagbubukod na ito gamit ang subukan, maliban, sa wakas mga bloke sa sawa.

Kailannangyayari ang error, ang programa ay hindi titigil at ipatupad ang maliban sa block.

subukan: i-print (x) maliban sa: i-print ('pagbubukod')

Sa wakas

Kapag tinukoy namin ang isang wakas na block. Isasagawa ito kahit na mayroong isang error o hindi naitaas ng pagsubok maliban sa pag-block.

subukan: i-print (x) maliban sa: i-print ('pagbubukod') sa wakas: i-print ('ito ay naisakatuparan pa rin')

Ngayon na naintindihan namin ang mga konsepto ng pagbubukod sa pagbubukod. Hayaang tingnan ang mga konsepto ng paghawak ng file sa sawa.

Paghawak ng File

Ang paghawak ng file ay isang mahalagang konsepto ng wika ng pag-program ng sawa. Ang Python ay may iba't ibang mga pag-andar upang lumikha, magbasa, magsulat, magtanggal o mag-update ng isang file.

Lumilikha ng isang File

import os f = bukas ('lokasyon ng file')

Pagbasa ng isang File

f = buksan ('lokasyon ng file', 'r') i-print (f.read ()) f.close ()

Magdagdag ng isang File

f = open ('filelocation', 'a') f.write ('the content') f.close () f = open ('filelocation', 'w') f.write ('ito ay magsusulat ng file') f.close ()

Tanggalin ang isang file

i-import ang os os.remove ('lokasyon ng file')

Ito ang lahat ng mga pagpapaandar na maaari nating maisagawa sa paghawak ng file sa sawa.

Inaasahan kong ang blog na ito sa pagpapakilala sa sawa ay nakatulong sa iyo na malaman ang lahat ng pangunahing konsepto na kinakailangan upang makapagsimula sa wika ng python program.

Ito ay magiging madaling gamiting kapag nagtatrabaho ka sa wika ng programa ng python, dahil ito ang batayan ng pag-aaral sa anumang wika ng programa. Kapag na-master mo ang mga pangunahing konsepto sa sawa, maaari mong simulan ang iyong hangarin na maging isang developer ng sawa. Upang malaman ang higit pa tungkol sa wika ng programa sa python sa lalim maaari mong para sa live na pagsasanay sa online na sawa na may 24/7 na suporta at buhay na pag-access.

Mayroon bang mga query? maaari mong banggitin ang mga ito sa mga komento at babalikan ka namin.