2010-11-17 09:47

የካርታ፣ ዚፕ እና ላምዳ ተግባራት (በነገራችን ላይ “ከፍተኛ-ትዕዛዝ ተግባራት” ወይም “አንደኛ-ክፍል-ተግባራት” ይባላሉ) የተለያዩ የዳታ ማጭበርበሮችን በቀላሉ እንዲፈጽሙ ያስችሉዎታል፣ ይህም በ“መደበኛ” ውስጥ ትንሽ ተጨማሪ ኮድ መጻፍ ይጠይቃል። ” የሥርዓት ዘይቤ። ከዚህ በታች የተፃፈው ነገር ሁሉ ተግባራዊ ፕሮግራሚንግ የሚባለውን ያመለክታል፣ ዝርዝሮችን ይፈልጉ።

የተግባር ካርታ፣ ዚፕ እና ላምዳ በምሳሌዎች።

አንድ ቀላል ተግባር ዝርዝር a = እና ዝርዝር b = ተመሳሳይ ርዝመት ነው እና እነሱን ጥንድ አድርጎ ማዋሃድ ያስፈልግዎታል. ተግባሩን በመጠቀም - ልክ እንደ ቅርፊት pears ቀላል ነው። ዚፕ :

a = [1፣ 2] b = [3፣4] ዚፕ ማተም (ሀ፣ ለ) [(1፣ 3)፣ (2፣ 4)]

ወይም በሦስት እጥፍ:

ሀ = [ 1 ፣ 2 ] ለ = [ 3 ፣ 4 ] ሐ = [5 ፣ 6] ዚፕ ማተም (a ፣ b ፣ c) [(1 ፣ 3 ፣ 5) ፣ (2 ፣ 4 ፣ 6)]

ወይም በአጠቃላይ

ዝርዝር = [a, b, c] ዚፕ ማተም (* ዝርዝር) [(1, 3, 5), (2, 4, 6)]

ከዝርዝሩ በፊት ያለው ኮከብ * የክርክር ዝርዝር እየተላለፈ መሆኑን የሚያመለክት ይመስላል፣ ማለትም. ድርጊት ሀ፣ b፣ c i.e ከማለፍ ጋር እኩል ነው። እንዲያውም ይቻላል ዚፕ ማተም(*)ውጤቱ አይለወጥም.

def f (x): መመለስ x * x ቁጥሮች = [1, 2, 3] ለቁጥር በቁጥር: f (ቁጥር) ያትሙ

የዝርዝር ግንዛቤዎችን ያጠና የበለጠ ልምድ ያለው ኖብ፡-

def f (x): መመለስ x * x ህትመት [f (ቁጥር) በቁጥር በቁጥር]

ፕሮግራም አውጪው ቀላል ያደርገዋል፡-

def f (x): መመለስ x * x የህትመት ካርታ (f, ቁጥሮች)

እና እውነተኛ-medskills ጠላፊው እንደሚከተለው ያደርገዋል (በእርግጥ ተግባሩ እንደ ላምዳ ሊፃፍ የሚችል ከሆነ፣ ተግባሩ ሁልጊዜ እንደ ላምዳ ለመፃፍ ቀላል አይሆንም)።

የህትመት ካርታ (ላምዳ x : x * x ፣ ቁጥሮች)

የመጨረሻው ግቤት በጣም ብቃት ያለው አቀራረብ ምሳሌ ነው. እውነታው ግን አንድ ሰው ኮድን እንደ ግጥም ሲጽፍ, በተመስጦ (በሌላ አነጋገር "በዱር ብስጭት" ተብሎ ሊጠራ ይችላል), የአጻጻፍ ፍጥነት እጅግ በጣም አስፈላጊ ነው (ይህ የአክብሮት ፍቅር መነሻ ነው). ከብዙ ገንቢዎች ለቀላል የጽሑፍ አርታኢዎች vim, emacs, sublimetext grow) , እና የ Python ጥንካሬ በትክክል የተፈጠረው ኮድ መጠን ነው - በጣም የታመቀ ነው. አንድ መስመር መጻፍ በተፈጥሮ ከ 7 ፈጣን ነው, እና አጭር ኮድ ለማንበብ ቀላል ነው, ነገር ግን እንደዚህ አይነት ኮድ መጻፍ የተወሰነ ችሎታ ይጠይቃል. የሳንቲሙ ሌላኛው ጎን አንዳንድ ጊዜ በዚህ “የዱር ብስጭት” ውስጥ ሙሉ በሙሉ የተወሳሰቡ ድርጊቶች ቅደም ተከተሎች በአንድ መስመር ተጽፈዋል ፣ ስለሆነም እዚያ ምን እየተፈጠረ እንዳለ እና በመጨረሻ ምን እንደሚከሰት ለመረዳት በጣም ከባድ ነው።

ከምሳሌው መረዳት እንደሚቻለው ካርታተግባርን ወደ ዝርዝር ይተገብራል እና ውጤቱን ይመልሳል ፣ እንደገና በዝርዝር መልክ። ብዙ ዝርዝሮችን ማለፍ ይችላሉ ፣ ከዚያ ተግባሩ (የመጀመሪያው ግቤት ነው) ብዙ ነጋሪ እሴቶችን መውሰድ አለበት (በተላለፉት ዝርዝሮች ብዛት መሠረት) ካርታ).

def f (x, y): መመለስ x * y a = [1, 3, 4] b = [3, 4, 5] የህትመት ካርታ (f, a, b) [3, 12, 20]

አሪፍ ነው አይደል?

ነገር ግን, ዝርዝሮቹ የተለያየ ርዝመት ያላቸው ከሆነ, ማለትም. አንዱ ከሌላው ያነሰ ነው, ከዚያም በሚፈለገው ርዝመት በምንም ዋጋዎች ይሸፈናል. ከዝርዝሩ ከተወገደ ለየመጨረሻው ዋጋ - ምሳሌው አይሰራም, ምክንያቱም ተግባር f ውስጥ ቁጥርን በምንም ለማባዛት ይሞክራል ፣ እና Python ይህንን አይፈቅድም ፣ በነገራችን ላይ ከ php በጥሩ ሁኔታ የሚለየው ፣ በተመሳሳይ ሁኔታ ውስጥ መስራቱን ይቀጥላል። ስለዚህ, ተግባር f በቂ ከሆነ, የሚተላለፉትን እሴቶች መፈተሽ ጥሩ ይሆናል. ለምሳሌ;

ተግባሩ በምንም ከተተካ, ከዚያ ካርታጋር ተመሳሳይ ስለ ይሰራል ዚፕ, ነገር ግን የተላለፉ ዝርዝሮች የተለያየ ርዝመት ያላቸው ከሆነ, ውጤቱ ይጻፋል ምንም - በነገራችን ላይ, በአንዳንድ ሁኔታዎች በጣም ተገቢ ነው.

a = [1, 3, 4] b = [3, 4] የህትመት ካርታ (ምንም, ሀ, ለ) [(1, 3), (3, 4), (4, ምንም)]

አሁን ስለ lambda ተግባራት በ python. def func_name():... ሳይጠቀሙ አንድን ተግባር መግለፅ ሲፈልጉ ጥቅም ላይ ይውላሉ፣ ምክንያቱም ብዙ ጊዜ (እንደ ቀደሙት ምሳሌዎች) ተግባሩ በጣም ትንሽ ስለሆነ ለብቻው መግለጽ ምንም ፋይዳ የለውም (ተጨማሪ የኮድ መስመሮች ተነባቢነትን ይጎዳል)። ). ስለዚህ ተግባሩ "በቦታው" ሊገለጽ ይችላል. ረ = ላምዳ x፡ x* xእንደነገረን - x ይቀበላል ፣ x * x ይመልሳል

ስለዚህ፣ መደበኛ የፓይዘን መሳሪያዎችን በመጠቀም፣ በጣም ውስብስብ የሆኑ ድርጊቶችን በአንድ መስመር መፃፍ ይችላሉ። ለምሳሌ ተግባሩ፡-

def f (x ፣ y): ከሆነ (y == የለም): y = 1 መመለስ x * y

እንደሚከተለው ሊወከል ይችላል፡-

lambda x ፣ y: x * (y ካልሆነ ሌላ የለም 1)

አሁን በርዝመት የተደረደሩ ዝርዝሮችን ማለፍ ጥሩ ይሆናል - ሌን(ሀ) > (ለ) - ልክ እንደ ሼል በርበሬ ቀላል - ተግባሩን እንጠቀምበት። ተደርድሯል :

የተደረደሩ ([a፣ b]፣ key = lambda x: len (x)፣ በግልባጭ = እውነት)

ተግባር ተደርድሯልየእሴቶችን ዝርዝር ይወስዳል (= [,]) እና በ ቁልፍ- በተግባሩ len (x) የተሰጠ - የዝርዝሩን ርዝመት የሚመልስ ፣ በሚወርድ ቅደም ተከተል እንመድባለን (ተቃራኒ=እውነት)

በመጨረሻ ፣ አጠቃላይ ክዋኔው እንደሚከተለው ተጽፏል-

ካርታ (ላምዳ x፣ y: x * (y ከሆነ y ካልሆነ ሌላ የለም 1)፣ * የተደረደሩ ([a፣ b]፣ key = lambda x: len (x), በግልባጭ = እውነት))

ዝርዝሮች a እና b የተለያየ ርዝመት ያላቸው እና በማንኛውም ቅደም ተከተል ሊተላለፉ ይችላሉ. የላምዳ አገላለጾች በጣም ውስብስብ ያልሆኑ ተግባራትን ከዚያም ወደ ሌሎች ተግባራት የሚተላለፉትን ለመለየት ይጠቅማሉ።

3.2.3 የመዝገበ-ቃላት ግንዛቤዎች

መዝገበ-ቃላት አለን ይበሉ የነሱ ቁልፎች ቁምፊዎች እና የየትኛው ካርታ እሴቶች በአንዳንድ ፅሁፎች ውስጥ ቁምፊው ለሚታየው ጊዜ ብዛት። መዝገበ ቃላቱ በአሁኑ ጊዜ በትልቁ እና በትናንሽ ሆሄያት መካከል ያለውን ልዩነት ይለያል።

የላይኛ እና የበታች ሆሄያት ክስተቶች የተጣመሩበት መዝገበ ቃላት እንፈልጋለን።

dct = ( "ሀ"፡ 10፣ "ለ"፡ 34፣ "ሀ"፡ 7፣ "ዘ"፡ 3 ) ድግግሞሽ = ( k. ዝቅ () : dct. ማግኘት ( k. ዝቅ () , 0 ) + dct. ማግኘት ( k . የላይኛው () , 0 ) ለ k በ dct. ቁልፎች()) የህትመት ድግግሞሽ #("a": 17, "z": 3, "b": 34)

ፓይዘን “ላምዳ” የሚባል ግንባታን በመጠቀም በሂደት ጊዜ የማይታወቁ ተግባራትን (ማለትም ከስም ጋር የማይገናኙ ተግባራትን) መፍጠርን ይደግፋል። ይህ በተግባራዊ ፕሮግራሚንግ ቋንቋዎች ውስጥ ካለው ላምዳ ጋር ተመሳሳይ አይደለም፣ ነገር ግን በፓይዘን ውስጥ በደንብ የተዋሃደ እና ብዙ ጊዜ እንደ ማጣሪያ () ፣ ካርታ () እና መቀነስ () ካሉ የተለመዱ ተግባራዊ ፅንሰ-ሀሳቦች ጋር አብሮ ጥቅም ላይ የሚውል በጣም ኃይለኛ ፅንሰ-ሀሳብ ነው።

በንግግር መልክ የማይታወቁ ተግባራት ላምዳ በመጠቀም ሊፈጠሩ ይችላሉ
መግለጫ፡-

args በነጠላ ሰረዞች የተከፋፈሉ የነጋዴዎች ዝርዝር ነው፣ እና አገላለጽ እነዚያን ነጋሪ እሴቶች የሚያካትት አገላለጽ ነው። ይህ የኮድ ቁራጭ በመደበኛ ተግባር ፍቺ እና በላምዳ ተግባር መካከል ያለውን ልዩነት ያሳያል፡-

ዲፍ ተግባር (x): መመለስ x * x የህትመት ተግባር (2) #4 #-----------------------# ተግባር = lambda x: x * x የህትመት ተግባር (2) #4

እንደሚመለከቱት, ሁለቱም ተግባራት () በትክክል ተመሳሳይ ናቸው እና በተመሳሳይ መንገድ ጥቅም ላይ ሊውሉ ይችላሉ. የላምዳ ፍቺው "መመለሻ" መግለጫን እንደማያጠቃልል ልብ ይበሉ - ሁልጊዜ የሚመለስ አገላለጽ ይዟል. እንዲሁም የላምዳ ፍቺን አንድ ተግባር በሚጠበቀው ቦታ ላይ ማስቀመጥ እንደሚችሉ ልብ ይበሉ, እና ጨርሶ ለተለዋዋጭ መመደብ የለብዎትም.

የሚከተሉት የኮድ ቁርጥራጮች የላምዳ ተግባራትን አጠቃቀም ያሳያሉ።

ጭማሪ (n) ተመላሽ ላምዳ x: x + n የህትመት ጭማሪ(2) # በ 0x022B9530> የህትመት ጭማሪ (2) (20) #22

ከላይ ያለው ኮድ በመብረር ላይ የማይታወቅ ተግባር የሚፈጥር እና የሚመልሰው የተግባር ጭማሪን ይገልጻል። የተመለሰው ተግባር ሲፈጠር በተጠቀሰው እሴት ነጋሪነቱን ይጨምራል።

አሁን ብዙ የተለያዩ የመጨመሪያ ተግባራትን መፍጠር እና ለተለዋዋጮች መመደብ ይችላሉ, ከዚያም እርስ በእርሳቸው ነጻ ሆነው ይጠቀሙባቸው. የመጨረሻው መግለጫ እንደሚያሳየው ተግባሩን በየትኛውም ቦታ መመደብ እንኳን አያስፈልግዎትም - ወዲያውኑ ሊጠቀሙበት እና በማይፈለግበት ጊዜ ሊረሱት ይችላሉ።

ጥ3. ላምዳ ምን ይጠቅማል?
መልስ.
መልሱ፡-

• ላምዳ አንፈልግም ፣ ያለ እሱ በትክክል ልንስማማ እንችላለን። ግን...
• ምቹ የሆኑ አንዳንድ ሁኔታዎች አሉ - ኮድን መፃፍ ትንሽ ቀላል ያደርገዋል ፣ እና የጽሑፍ ኮድ ትንሽ ያጸዳል።

ጥ 4. ምን ዓይነት ሁኔታዎች?

ደህና ፣ ቀላል የአንድ ጊዜ ተግባር የምንፈልግባቸው ሁኔታዎች አንድ ጊዜ ብቻ ጥቅም ላይ የሚውል ተግባር።

በተለምዶ ተግባራት የሚፈጠሩት ከሁለት አላማዎች ለአንዱ ነው፡ (ሀ) የኮድ ማባዛትን ለመቀነስ ወይም (ለ) ኮድን ለማስተካከል።

• አፕሊኬሽንዎ በተለያዩ ቦታዎች የተባዙ የኮድ ቁርጥራጮችን ከያዘ፣ የዚያን ኮድ አንድ ቅጂ ወደ ተግባር ማስገባት፣ ተግባሩን ስም መስጠት እና ከዚያ - ያንን የተግባር ስም በመጠቀም - በኮድዎ ውስጥ ካሉ የተለያዩ ቦታዎች ይደውሉ።
• አንድ በደንብ የተገለጸ ኦፕሬሽን የሚያከናውን የኮድ ቅንጥብ ካለህ - ነገር ግን በእርግጥ ረጅም እና ግርዶሽ ከሆነ እና የፕሮግራምህን ተነባቢ ፍሰት የሚያቋርጥ ከሆነ - ያንን ረጅም gnarly ኮድ አውጥተህ ብቻውን ወደ ተግባር ማስገባት ትችላለህ።

ግን አንድ ጊዜ ብቻ ጥቅም ላይ የሚውል ተግባር መፍጠር ያስፈልግዎታል - ከ ይባላል አንድ ብቻበማመልከቻዎ ውስጥ ያስቀምጡ. ደህና, በመጀመሪያ, ተግባሩን ስም መስጠት አያስፈልግዎትም. "ስም-አልባ" ሊሆን ይችላል. እና ሊጠቀሙበት በሚፈልጉት ቦታ ላይ በትክክል ሊገልጹት ይችላሉ. ላምዳ የሚጠቅመው እዚያ ነው።

በተለምዶ፣ lambda እንደ መደርደር ወይም የውሂብ ቅነሳ በመሳሰሉ ሌሎች ኦፕሬሽን አውድ ውስጥ ጥቅም ላይ ይውላል፡-

ስሞች = ["ዴቪድ ቤዝሌይ"፣ "ብራያን ጆንስ"፣ "ሬይመንድ ሄቲንግተር"፣ "Ned Batchelder"] የህትመት የተደረደሩ (ስሞች፣ ቁልፍ = ላምዳ ስም፡ ስም። የተከፋፈለ () [- 1] . ዝቅተኛ ()) # ["Ned Batchelder"፣ "ዴቪድ ቤዝሊ"፣ "ሬይመንድ ሄቲንግተር"፣ "ብራያን ጆንስ"]

ምንም እንኳን ላምዳ ቀላል ተግባርን እንዲገልጹ ቢፈቅድም, አጠቃቀሙ በጣም የተገደበ ነው. ውስጥ
በተለይም አንድ አገላለጽ ብቻ ሊገለጽ ይችላል, ውጤቱም መመለሻ ነው
ዋጋ. ይህ ማለት ብዙ መግለጫዎችን፣ ሁኔታዊ ሁኔታዎችን፣ መደጋገምን እና ልዩ አያያዝን ጨምሮ ሌሎች የቋንቋ ባህሪያት ሊካተቱ አይችሉም።
ላምዳ ሳይጠቀሙ ብዙ የፓይዘን ኮድ በደስታ መጻፍ ይችላሉ። ሆኖም፣
አንድ ሰው ብዙ ጥቃቅን በሚጽፍባቸው ፕሮግራሞች ውስጥ አልፎ አልፎ ያጋጥምዎታል
የተለያዩ አገላለጾችን የሚገመግሙ ተግባራት ወይም ተጠቃሚዎች እንዲያቀርቡ በሚያስፈልጋቸው ፕሮግራሞች ውስጥ
የመልሶ መደወያ ተግባራት.

lambdaን በመጠቀም የማይታወቅ ተግባርን ገልጸዋል፣ነገር ግን እሱንም መያዝ ያስፈልግዎታል
ትርጉም በሚሰጥበት ጊዜ የአንዳንድ ተለዋዋጮች እሴቶች።

>>> x = 10 >>> a = lambda y: x + y >>> x = 20 >>> ለ = ላምዳ የ: x + y

አሁን አንድ ጥያቄ እራስዎን ይጠይቁ. የ(10) እና b(10) እሴቶች ምንድናቸው? እርስዎ ካሰቡ
ውጤቶቹ 20 እና 30 ሊሆኑ ይችላሉ፣ ተሳስተዋል፡

እዚህ ያለው ችግር በላምዳ አገላለጽ ውስጥ ጥቅም ላይ የዋለው የ x ዋጋ ነፃ ተለዋዋጭ ነው።
ይህ በሂደት ላይ የሚታሰር እንጂ የፍቺ ጊዜ አይደለም። ስለዚህ, በላምዳ ውስጥ ያለው የ x ዋጋ
አገላለጾች የ x ተለዋዋጭ ዋጋ በአፈፃፀም ጊዜ የሚከሰት ምንም አይነት ነው።
ለምሳሌ፡-

በፍቺው ነጥብ ላይ አንድ እሴት ለመያዝ የማይታወቅ ተግባር ከፈለጉ
ያቆዩት ፣ እሴቱን እንደ ነባሪ እሴት ያካትቱ ፣ እንደዚህ

እዚህ ላይ የሚስተዋለው ችግር በዚያ በኮድ ውስጥ የመውጣት አዝማሚያ ያለው ነገር ነው።
ላምዳ ተግባራትን በመጠቀም ትንሽ ብልህ ለመሆን ይሞክራል። ለምሳሌ፡-
የላምዳ አገላለጾችን ዝርዝር የዝርዝር ግንዛቤን በመጠቀም ወይም በአንድ ዓይነት ሉፕ መፍጠር እና የ lambda ተግባራት ትርጉም በሚሰጥበት ጊዜ የመድገም ተለዋዋጭን እንዲያስታውስ መጠበቅ። ለምሳሌ፡-

>>> funcs = [ lambda x: x + n ለ n በክልል (5) ]

• ትርጉም

ስለ ተግባራዊ ፕሮግራሞች ሲናገሩ ሰዎች ብዙውን ጊዜ "ተግባራዊ" ባህሪያትን መጣል ይጀምራሉ. የማይለወጥ ውሂብ፣ የአንደኛ ደረጃ ተግባራት እና የጅራት ድግግሞሽ ማመቻቸት። እነዚህ ተግባራዊ ፕሮግራሞችን ለመጻፍ የሚረዱ የቋንቋ ባህሪያት ናቸው. እነሱ የካርታ ስራን, ካሪንግ እና ከፍተኛ የትዕዛዝ ተግባራትን ይጠቅሳሉ. እነዚህ ተግባራዊ ኮድ ለመጻፍ የሚያገለግሉ የፕሮግራም አወጣጥ ዘዴዎች ናቸው። ትይዩነትን፣ ሰነፍ ግምገማን እና ቆራጥነትን ይጠቅሳሉ። እነዚህ የተግባር ፕሮግራሞች ጥቅሞች ናቸው.

አስቆጥረው። የተግባር ኮድ በአንድ ንብረት ተለይቷል፡ አለመኖር የጎንዮሽ ጉዳቶች. ከአሁኑ ተግባር ውጭ በመረጃ ላይ አይመሰረትም, እና ከተግባሩ ውጭ ያለውን ውሂብ አይለውጥም. ሁሉም ሌሎች "ንብረቶች" ከዚህ ሊወሰዱ ይችላሉ.

የማይሰራ ተግባር;

A = 0 def increment1(): ሁለንተናዊ a a += 1

ተግባራዊ ባህሪ፡

ጭማሪ2(a)፡ አንድ + 1 ይመልሱ

በዝርዝሩ ውስጥ ከመድገም ይልቅ ካርታ ይጠቀሙ እና ይቀንሱ

ካርታ

ተግባር እና የውሂብ ስብስብ ይቀበላል። አዲስ ስብስብ ይፈጥራል፣ በእያንዳንዱ የውሂብ ቦታ ላይ ያለውን ተግባር ያከናውናል፣ እና የመመለሻ እሴቱን ወደ አዲሱ ስብስብ ይጨምራል። አዲስ ስብስብ ይመልሳል።

የስም ዝርዝርን የሚወስድ እና የርዝመቶችን ዝርዝር የሚመልስ ቀላል ካርታ፡-

የስም_ርዝመቶች = ካርታ (ሌን፣ ["ማሻ"፣ "ፔትያ"፣ "ቫሳያ"]) የህትመት ስም_ርዝመቶች # =>

ይህ ካርታ እያንዳንዱን አካል ያካክላል፡-

ካሬዎች = ካርታ (ላምዳ x: x * x, ) የህትመት ካሬዎች # =>

የተሰየመ ተግባርን አይቀበልም፣ ነገር ግን ስም-አልባ በላምዳ የተገለጸውን ይወስዳል። የላምዳ መለኪያዎች ከኮሎን ግራ በኩል ይገለፃሉ። የተግባሩ አካል በቀኝ በኩል ነው. ውጤቱም በተዘዋዋሪ ተመልሷል.

በሚከተለው ምሳሌ ውስጥ ያለው የማይሰራ ኮድ የስም ዝርዝር ይይዛል እና በዘፈቀደ ቅጽል ስሞች ይተካቸዋል.

የዘፈቀደ ስሞችን አስመጣ = ["ማሻ"፣ "ፔትያ"፣ "ቫሳ"] code_names = ["Shpuntik", "Vintik", "Funtik"] ለ i በክልል (ሌን(ስሞች)): ስሞች[i] = በዘፈቀደ። ምርጫ(የኮድ_ስሞች) የህትመት ስሞች # => ["Shpuntik", "Vintik", "Shpuntik"]

ስልተ ቀመር ለተለያዩ ሚስጥራዊ ወኪሎች ተመሳሳይ ቅጽል ስሞችን ሊሰጥ ይችላል። ይህ በሚስጥር ተልዕኮ ወቅት ችግር እንደማይፈጥር ተስፋ እናድርግ።

ይህንን ካርታ በመጠቀም እንደገና እንፃፍ፡-

የዘፈቀደ ስሞችን አስመጣ = ["ማሻ"፣ "ፔትያ"፣ "ቫሳ"] secret_names = ካርታ(lambda x: random.choice(["Shpuntik", "Vintik", "Funtik"), ስሞች)

መልመጃ 1. ካርታ በመጠቀም የሚከተለውን ኮድ እንደገና ለመጻፍ ይሞክሩ። የእውነተኛ ስሞችን ዝርዝር ወስዶ ይበልጥ አስተማማኝ ዘዴን በመጠቀም በቅጽል ስሞች ይተካቸዋል.

ስሞች = ["ማሻ"፣ "ፔትያ"፣ "ቫሳያ"] ለ i በክልል(ሌን(ስሞች))፡ ስሞች[i] = hash(ስሞች[i]) የህትመት ስሞች # =>

የኔ መፍትሄ፡-

ስሞች = ["ማሻ", "ፔትያ", "ቫሳያ"] ሚስጥራዊ_ስሞች = ካርታ (ሃሽ, ስሞች)

ቀንስ

ቅነሳ ተግባር እና የንጥሎች ስብስብ ይወስዳል። ሁሉንም እቃዎች በማጣመር የተገኘውን እሴት ይመልሳል።

ቀላል የመቀነስ ምሳሌ. በአንድ ስብስብ ውስጥ ያሉትን ሁሉንም እቃዎች ድምር ይመልሳል፡-

ድምር = መቀነስ (lambda a, x: a + x, ) የህትመት ድምር # => 10

X የአሁኑ ንጥል ነው, እና ባትሪ ነው. ይህ ባለፈው ነጥብ ላይ ላምዳውን በማስፈጸም የተመለሰው ዋጋ ነው. ይቀንሱ () ሁሉንም እሴቶች ይደግማል እና ለእያንዳንዱ አሁን ባሉት እሴቶች a እና x ላይ ላምዳ ይሠራል እና ውጤቱን ለሚቀጥለው ድግግሞሽ ይመልሳል።

በመጀመሪያው ድግግሞሽ ውስጥ ያለው ዋጋ ስንት ነው? ከክምችቱ የመጀመሪያ አካል ጋር እኩል ነው, እና መቀነስ () ከሁለተኛው አካል መስራት ይጀምራል. ያም ማለት የመጀመሪያው x ከስብስቡ ሁለተኛ ንጥል ጋር እኩል ይሆናል.

የሚከተለው ምሳሌ በሕብረቁምፊዎች ዝርዝር ውስጥ "ካፒቴን" የሚለው ቃል ምን ያህል ጊዜ እንደሚታይ ይቆጠራል።

ዓረፍተ ነገሮች = ["ካፒቴን ጃክ ስፓሮው", "የባህር ካፒቴን", "ጀልባዎ ዝግጁ ነው, ካፒቴን"] cap_count = 0 በአረፍተ ነገር ውስጥ ለዓረፍተ ነገር: cap_count += sentence.count("captain") print cap_count # => 3

ቅነሳን በመጠቀም ተመሳሳይ ኮድ:

ዓረፍተ ነገሮች = ["ካፒቴን ጃክ ድንቢጥ", "የባህር ካፒቴን", "ጀልባዎ ዝግጁ ነው, ካፒቴን"] cap_count = ይቀንሱ (lambda a, x: a + x.count("captain"), sentences, 0)

የመነሻ ዋጋ ከየት ነው የሚመጣው? በመጀመሪያው መስመር ውስጥ ካለው ድግግሞሽ ብዛት ሊሰላ አይችልም. ስለዚህ, የመቀነስ () ተግባር እንደ ሦስተኛው መከራከሪያ ተሰጥቷል.

ለምን ካርታ እና መቀነስ የተሻሉ ናቸው?

በመጀመሪያ ፣ ብዙውን ጊዜ በአንድ መስመር ላይ ይጣጣማሉ።

በሁለተኛ ደረጃ, የመድገም አስፈላጊ ክፍሎች - ስብስብ, ቀዶ ጥገና እና የመመለሻ እሴት - ሁልጊዜም በተመሳሳይ ቦታ ላይ ናቸው, ካርታ እና ይቀንሱ.

ሦስተኛ፣ በ loop ውስጥ ያለው ኮድ ቀደም ሲል የተገለጹ ተለዋዋጮችን ዋጋ ሊለውጥ ወይም ከእሱ በኋላ ኮድን ሊነካ ይችላል። በስምምነት፣ ካርታ እና መቀነስ ተግባራዊ ናቸው።

በአራተኛ ደረጃ, ካርታ እና ቅነሳ የመጀመሪያ ደረጃ ስራዎች ናቸው. loops መስመርን በመስመር ከማንበብ ይልቅ አንባቢ ካርታን እንዲገነዘብ እና ውስብስብ ስልተ ቀመሮችን እንዲቀንስ ይቀላል።

አምስተኛ፣ የእነዚህን ተግባራት ጠቃሚ፣ በትንሹ የተሻሻለ ባህሪን የሚፈቅዱ ብዙ ጓደኞች አሏቸው። ለምሳሌ፣ ማጣሪያ፣ ሁሉም፣ ማንኛውም እና ያግኙ።

መልመጃ 2ካርታውን በመጠቀም የሚከተለውን ኮድ እንደገና ይፃፉ ፣ ይቀንሱ እና ያጣሩ። ማጣሪያ አንድ ተግባር እና ስብስብ ይቀበላል። ተግባሩ እውነት የሚመለስባቸውን የእነዚያን ነገሮች ስብስብ ይመልሳል።

ሰዎች = [("ስም"፡ "ማሻ"፣ "ቁመት"፡ 160)፣ ("ቁመት"፡ "ሳሻ"፣ "ቁመት"፡ 80)፣ ("ስም"፡ "ፓሻ")] height_total = 0 height_count = 0 በሰዎች ውስጥ: "ቁመት" በአካል ከሆነ: ቁመት_ጠቅላላ += ሰው["ቁመት"] ቁመት_ቁጥር += 1 ቁመት_ቁጥር > 0: አማካኝ_ቁመት = ቁመት_ጠቅላላ / ቁመት_ቁጥር ማተም አማካይ_ቁመት # => 120

የኔ መፍትሄ፡-

ሰዎች = [("ስም"፡ "ማሻ"፣ "ቁመት"፡ 160)፣ ("ቁመት"፡ "ሳሻ"፣ "ቁመት"፡ 80)፣ ("ስም"፡ "ፓሻ")) ከፍታዎች = ካርታ(lambda) x: x["ቁመት"]፣ ማጣሪያ (ላምዳ x: "ቁመት" በ x፣ ሰዎች)) ሌንስ ከሆነ (ቁመቶች) > 0: ከኦፕሬተር ማስመጣት አማካኝ_ቁመት = መቀነስ(መደመር፣ ከፍታ) / ሌንስ(ቁመቶች) ከሆነ

በግዴታ ሳይሆን በአዋጅ ጻፍ።

የሚከተለው ፕሮግራም የሶስት መኪና ውድድርን ይመስላል። በእያንዳንዱ ጊዜ መኪናው ወደ ፊት እየሄደ ነው ወይም አይደለም. በእያንዳንዱ ጊዜ ፕሮግራሙ በመኪናዎች የተጓዙትን ርቀት ያሳያል. ከአምስት ጊዜ በኋላ ውድድሩ ያበቃል.

የውጤት ምሳሌዎች፡-

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

የፕሮግራም ጽሑፍ፡-

በዘፈቀደ የማስመጣት የዘፈቀደ ጊዜ = 5 የመኪና_ቦታዎች = ጊዜ፡ # የመቀነስ ጊዜ -= 1 ማተም "" ለ i በክልል (ሌን(የመኪና_ቦታ)): # መኪና በዘፈቀደ ከሆነ () > 0.3: የመኪና_ቦታዎች[i] += 1 ማንቀሳቀስ # የመኪና ህትመት ይሳሉ "-" * የመኪና_ቦታዎች[i]

ኮዱ የግድ ነው። የተግባር ሥሪት ገላጭ ይሆናል - ምን መደረግ እንዳለበት ይገልፃል እንጂ እንዴት መደረግ እንዳለበት አይደለም።

ተግባራቶቹን በመጠቀም

ኮድን ወደ ተግባራት በማስገባት ገላጭነት ማግኘት ይቻላል፡-

በዘፈቀደ የማስመጣት የዘፈቀደ def move_cars()፡ ለ i፣ _ በቁጥር (የመኪና_ቦታዎች)፡ በዘፈቀደ ከሆነ () > 0.3፡ የመኪና_ቦታዎች[i] += 1 def draw_car(የመኪና_ቦታ): አትም "-" * የመኪና_ቦታ def ሩጫ_የዘር_ደረጃ(): ሁለንተናዊ የጊዜ ሰአት -= 1 የሚንቀሳቀሱ መኪናዎች() ዲፍ መሳል(): አትም "" ለመኪና_ቦታ በመኪና_ቦታዎች፡ መሳል_መኪና(የመኪና_ቦታ) ጊዜ = 5 የመኪና_ቦታዎች = ሲቆይ፡ ሩጫ_ደረጃ_የዘር() መሳል()

ፕሮግራሙን ለመረዳት አንባቢው ዋናውን ዑደት ይመለከታል. “የቀረው ጊዜ ካለ ውድድሩን አንድ ደረጃ አልፈን ውጤቱን እናሳያለን። ጊዜውን እንደገና እንፈትሽ። አንባቢው የሩጫው ደረጃ እንዴት እንደሚሰራ መረዳት ከፈለገ, ኮዱን በተናጠል ማንበብ ይችላሉ.

ምንም አስተያየቶች አያስፈልግም, ኮዱ እራሱን ያብራራል.

ኮድን ወደ ተግባራት መስበር ኮዱን የበለጠ ለማንበብ ያደርገዋል። ይህ ዘዴ ተግባራትን ይጠቀማል, ነገር ግን እንደ ንዑስ ክፍሎች ብቻ ነው. ኮዱን አሽገውታል፣ ግን ተግባራዊ አያደርጉትም። ተግባራት በዙሪያቸው ያለውን ኮድ ይነካሉ እና እሴቶችን ከመመለስ ይልቅ ዓለም አቀፍ ተለዋዋጮችን ይለውጣሉ። አንባቢው ተለዋዋጭ ካጋጠመው ከየት እንደመጣ መፈለግ አለባቸው.

እዚህ ተግባራዊ ስሪትይህ ፕሮግራም:

በዘፈቀደ የማስመጣት የዘፈቀደ def move_cars(የመኪና_ቦታዎች)፡ የመመለሻ ካርታ (ላምዳ x፡ x + 1 በዘፈቀደ ከሆነ ()> 0.3 ሌላ x፣ የመኪና_ቦታዎች) የመኪና ውፅዓት_መኪና(የመኪና ቦታ)፡ መመለስ "-" * የመኪና_ቦታ def ሩጫ_የዘር(ግዛት)፡ መመለስ "ጊዜ": ሁኔታ["ጊዜ"] - 1, "የመኪና_ቦታዎች": move_cars (ግዛት ["የመኪና_ቦታዎች")) ዳይ ስዕል (ግዛት): አትም "" አትም "\n".ይቀላቀሉ (ካርታ (የውጤት_መኪና, ግዛት[) "የመኪና_ቦታዎች"])) ውድድር (ግዛት)፡ ይሳሉ (ግዛት) ግዛት ከሆነ["ጊዜ"]፡ ዘር (የሩጫ_የሩጫ_እርምጃ(ግዛት)) ዘር (("ጊዜ"፡ 5፣ "የመኪና_ቦታዎች"፡)))

ኮዱ አሁን ወደ ተግባራዊ ተግባራት ተከፋፍሏል። የዚህ ሶስት ምልክቶች አሉ። የመጀመሪያው የጋራ ተለዋዋጮች የሉም. ጊዜ እና የመኪና_ቦታዎች በቀጥታ ወደ ዘር () ይተላለፋሉ። ሁለተኛ, ተግባራት መለኪያዎችን ይወስዳሉ. በሶስተኛ ደረጃ, ተለዋዋጮች በ ውስጥ ተግባራት አይለወጡም, ሁሉም እሴቶች ይመለሳሉ. የሩጫ_ስቴፕ_ኦፍ_ዘር() ቀጣዩን ደረጃ ባከናወነ ቁጥር ወደሚቀጥለው ይተላለፋል።

ሁለት ተግባራት እዚህ አሉ ዜሮ() እና አንድ():

ዜሮ(ዎች): ከ s = "0": መመለስ s def one(ዎች): ከሆነ s == "1": መመለስ s

ዜሮ() ገመዱን ይወስዳል። የመጀመሪያው ቁምፊ 0 ከሆነ፣ ከዚያ የቀረውን ሕብረቁምፊ ይመልሳል። ካልሆነ, ከዚያ የለም. የመጀመሪያው ቁምፊ 1 ከሆነ አንድ() እንዲሁ ያደርጋል።

የ rule_sequence() ተግባርን እናስብ። ሕብረቁምፊ እና ደንብ ተግባራት ዝርዝር ይወስዳል, ተግባራት ዜሮ እና አንድ ያቀፈ. የመጀመሪያውን ህግ ይጠራል, ሕብረቁምፊውን በማለፍ. ምንም ካልተመለሰ፣ የተመለሰውን እሴት ወስዶ ቀጣዩን ደንብ ይደውሉ። እና ሌሎችም። ምንም ካልተመለሰ፣ ደንብ_ተከታታይ() ይቆማል እና ምንም አይመለስም። አለበለዚያ - የመጨረሻው ህግ ትርጉም.

የግቤት እና የውጤት ውሂብ ምሳሌዎች፡-

ደንብ_ተከታታይ አትም

የ rule_sequence() አስፈላጊ ስሪት

የደንብ_ተከታታይ(ሮች፣ ደንቦች)፡ ደንብ በህግ፡ s = ደንብ(ዎች) ከሆነ s == የለም፡ መመለሻን ሰበር

መልመጃ 3. ይህ ኮድ loop ይጠቀማል። ድግግሞሹን በመጠቀም በአዋጅ እንደገና ይፃፉት።

የኔ መፍትሄ፡-

የደንብ_ተከታታይ(ዎች፣ህጎች)፡ ከሆነ s == ምንም ወይም ደንብ የለም፡ መመለስ s ሌላ፡ ደንብ_ቅደም ተከተል(ህጎች(ዎች) ህጎች) መመለስ

የቧንቧ መስመሮችን ይጠቀሙ

አሁን የቧንቧ መስመር ተብሎ የሚጠራውን ዘዴ በመጠቀም ሌላ ዓይነት loop እንጽፈው።

ቀጣዩ ዙር የአንዳንድ ቡድኖችን ስም፣ የተሳሳተ የትውልድ አገር እና ሁኔታ የያዙ መዝገበ ቃላትን ይቀይራል።

ባንዶች = [("ስም": "የፀሐይ መጥለቅ መበላሸት", "ሀገር": "ዩኬ", "ገባሪ": ውሸት), ("ስም": "ሴቶች", "ሀገር": "ጀርመን", "ገባሪ": ሐሰት ), ("ስም": "አንድ ብር ሜትር ጽዮን", "ሀገር": "ስፔን", "ገባሪ": እውነት)] def format_bands (ባንዶች): ለባንድ በባንዶች: ባንድ["ሀገር"] = "ካናዳ " band["ስም"] = ባንድ ["ስም"]። ተካ("""") ባንድ["ስም"] = ባንድ["ስም]]።ርዕስ() format_bands(bands) print bands # => [("ስም"፡ "የፀሐይ መጥለቅ መጥፋት"፣ "ገባሪ"፡ ሐሰት፣ "ሀገር"፡ "ካናዳ")፣ # ("ስም"፡ "ሴቶች"፣ "ገባሪ"፡ ሐሰት፣ "ሀገር"፡ "ካናዳ" ) , # ("ስም": "አንድ ሲልቨር ፅዮን", "ገባሪ": እውነት, "ሀገር": "ካናዳ")]

የተግባር ስም "ቅርጸት" በጣም አጠቃላይ ነው። በአጠቃላይ, ኮዱ አንዳንድ አሳሳቢ ጉዳዮችን ያስከትላል. በአንድ ዑደት ውስጥ ሦስት የተለያዩ ነገሮች ይከሰታሉ. የ"ሀገር" ቁልፍ ዋጋ ወደ "ካናዳ" ተቀይሯል። ነጥቦቹ ይወገዳሉ እና የስሙ የመጀመሪያ ፊደል ወደ ካፒታል ተቀይሯል. ኮዱ ምን ማድረግ እንዳለበት ለመረዳት አስቸጋሪ ነው፣ እና እንደሚሰራም ለማወቅ አስቸጋሪ ነው። ለመጠቀም፣ ለመሞከር እና ለማመሳሰል አስቸጋሪ ነው።

አወዳድር፡

የቧንቧ መስመር_እያንዳንዳቸውን ያትሙ (ባንዶች ፣)

ቀላል ነው። በሰንሰለት የታሰሩ በመሆናቸው የረዳት ተግባራት የሚሰሩ ይመስላሉ። የቀደመው ውጤት የሚቀጥለው ግቤት ነው። ለመፈተሽ፣ እንደገና ለመጠቀም፣ ለማጽደቅ እና ለማመሳሰል ቀላል ናቸው።

Pipeline_እያንዳንዱ () በቡድኖቹ ውስጥ አንድ በአንድ ይደግማል እና እንደ set_canada_as_country() ወደ ልወጣ ተግባራት ያስተላልፋል። ተግባሩን ለሁሉም ቡድኖች ከተጠቀምን በኋላ pipeline_each() ዝርዝራቸውን አውጥቶ ወደሚቀጥለው ያስተላልፋል።

የለውጥ ተግባራትን እንመልከት።

Def assoc(_d፣ key፣ value): ከቅጂ አስመጣ ጥልቅ ቅጂ d = ጥልቅ ቅጂ(_d) d = እሴት ተመላሽ d def set_canada_as_country(band): ተመላሽ assoc(ባንድ፣ "ሀገር"፣ "ካናዳ") def strip_punctuation_from_name(band): መልስ assoc(ባንድ፣ "ስም"፣ባንድ ["ስም")] ተካ("፣ "")) አቢይ ስሞች(ባንድ) መመለስ፡ assoc(ባንድ፣ "ስም"፣ ባንድ ["ስም")] ርዕስ("ስም")። ))

እያንዳንዳቸው የቡድን ቁልፍን ከአዲስ እሴት ጋር ያዛምዳሉ። ዋናውን ውሂብ ሳይቀይሩ ይህን ማድረግ ከባድ ነው፣ ስለዚህ ይህንን በ assoc() እንፈታዋለን። ያለፈውን መዝገበ ቃላት ቅጂ ለመፍጠር ጥልቅ ቅጂ () ይጠቀማል። እያንዳንዱ ተግባር ቅጂውን ይለውጣል እና ቅጂውን ይመልሳል።

ሁሉም ነገር ጥሩ ይመስላል። ዋናው መረጃ ከለውጦች የተጠበቀ ነው። ነገር ግን በኮዱ ውስጥ ለውሂብ ለውጦች ሁለት ሊሆኑ የሚችሉ ቦታዎች አሉ። በ strip_punctuation_from_name() ውስጥ ነጥብ የሌለው ስም የሚፈጠረው በዋናው ስም ምትክ() በመደወል ነው። አቢይ_ስሞች() በርዕስ() እና ላይ የተመሰረተ የመጀመሪያ አቢይ ሆሄ ስም ይፈጥራል የመጀመሪያ ስም. መተካቱ እና ሰዓቱ የማይሰራ ከሆነ፣ strip_punctuation_from_name() እና አቢይ_ስሞች() አይሰሩም።

እንደ እድል ሆኖ, እነሱ ተግባራዊ ናቸው. በፓይዘን ውስጥ፣ ሕብረቁምፊዎች የማይለወጡ ናቸው። እነዚህ ተግባራት ከሕብረቁምፊዎች ቅጂዎች ጋር ይሰራሉ. ኡፍ እግዚአብሔር ይመስገን።

በፓይዘን ውስጥ በሕብረቁምፊዎች እና መዝገበ-ቃላት መካከል ያለው ልዩነት (ተለዋዋጭ ተፈጥሮአቸው) እንደ ክሎጁር ያሉ የቋንቋዎች ጥቅሞችን ያሳያል። እዚያም ፕሮግራሚው ውሂቡን ይቀይር እንደሆነ ማሰብ የለበትም. አይለወጥም።

መልመጃ 4. የቧንቧ መስመር_እያንዳንዱን ተግባር ለመስራት ይሞክሩ። የሥራውን ቅደም ተከተል ያስቡ. ቡድኖች በድርድር ውስጥ ናቸው፣ አንድ በአንድ ወደ መጀመሪያው የልወጣ ተግባር ተላልፈዋል። ከዚያም የተገኘው ድርድር አንድ ቁራጭ በአንድ ጊዜ ወደ ሁለተኛው ተግባር ይተላለፋል, ወዘተ.

የኔ መፍትሄ፡-

def pipeline_እያንዳንዱ(ውሂብ፣ fns)፡ መመለስ መቀነስ(lambda a፣ x: map(x, a)፣ fns፣ data)

ሦስቱም የለውጥ ተግባራት ለቡድኑ አንድ የተወሰነ መስክ እንዲቀይሩ ያስከትላሉ. ጥሪ () ለዚህ ረቂቅ ለመፍጠር ጥቅም ላይ ሊውል ይችላል። አንድ ተግባር እና የሚተገበርበትን ቁልፍ ይቀበላል.

Set_canada_as_country = ጥሪ(lambda x: "ካናዳ"፣ "ሀገር") strip_punctuation_from_name = ጥሪ(lambda x: x.replace(".", "")፣ "ስም") አቢይ ስሞች = ጥሪ(str.title፣ "ስም") የቧንቧ መስመር_እያንዳንዳቸው (ባንዶች ፣) ማተም

ወይም፣ ተነባቢነትን መስዋዕት ማድረግ፡-

የቧንቧ መስመር_እያንዳንዳቸውን ያትሙ (ባንዶች ፣)

የጥሪ ኮድ()

Def assoc(_d፣ key፣ value): ከቅጂ አስመጪ ጥልቅ ቅጂ d = ጥልቅ ቅጂ(_d) d = እሴት ተመላሽ d def ጥሪ(fn፣ key): def apply_fn(መዝገብ): መመለሻ assoc(መዝገብ፣ ቁልፍ፣ fn(መዝገብ. አግኝ (ቁልፍ))) መመለስ apply_fn

እዚህ ምን እየሆነ ነው?

አንድ። ጥሪ ከፍተኛ የትዕዛዝ ተግባር ነው, ምክንያቱም እንደ ክርክር ሌላ ተግባር ወስዶ ተግባሩን ይመልሳል።

ሁለት። apply_fn () ከመቀየሪያ ተግባራት ጋር ተመሳሳይ ነው። መግቢያ (ቡድን) ያገኛል። የዋጋ መዝገብን ይመለከታል። ጥሪዎች fn. ውጤቱን ወደ መዝገቡ ቅጂ መድቦ ይመልሳል።

ሶስት። እራሱን መጥራት ምንም አያደርግም። apply_fn () ሁሉንም ስራ ይሰራል። በ pipeline_እያንዳንዱ() ምሳሌ፣ apply_fn() አንድ ምሳሌ "ሀገር" ወደ "ካናዳ" ያስቀምጣል። ሌላኛው ደግሞ የመጀመሪያውን ፊደል አቢይ ያደርገዋል.

አራት. የአፕሊኬሽን_fn() ምሳሌን ሲፈጽሙ fn እና ቁልፍ ተግባራቶቹ በወሰን ውስጥ አይገኙም። እነዚህ ለማመልከት_fn() ወይም የአካባቢ ተለዋዋጮች ነጋሪ እሴቶች አይደሉም። ግን ለእነሱ መዳረሻ ይኖራል. አንድ ተግባር ሲገለጽ የሚዘጋውን ተለዋዋጮች ማጣቀሻዎችን ይይዛል - ከተግባሩ ውጭ የተገለጹ እና በውስጥ ጥቅም ላይ የዋሉ። አንድ ተግባር በሚሰራበት ጊዜ ተለዋዋጮች በአገር ውስጥ፣ ከዚያም በክርክር መካከል እና ከዚያም በመዘጋቶች መካከል ተለዋዋጮች ይፈለጋሉ። እዚያም fn እና ቁልፍ ያገኛሉ.

አምስት። በጥሪው ውስጥ ስለቡድኖች የተጠቀሰ ነገር የለም. ይህ የሆነበት ምክንያት ምንም አይነት ይዘታቸው ምንም ይሁን ምን ጥሪ ማንኛውንም የቧንቧ መስመሮች ለመፍጠር ጥቅም ላይ ሊውል ስለሚችል ነው. የተግባር ፕሮግራሚንግ በተለይ ቤተመጻሕፍት ይገነባል። አጠቃላይ ተግባራት, ለቅንብሮች እና እንደገና ጥቅም ላይ ለማዋል ተስማሚ.

በደንብ ተሰራ። መዘጋት፣ ከፍተኛ የትዕዛዝ ተግባራት እና ወሰን - ሁሉም በጥቂት አንቀጾች ውስጥ። እንዲሁም ሻይ እና ኩኪዎችን መጠጣት ይችላሉ.

አንድ ተጨማሪ የቡድን ውሂብ ሂደት ይቀራል። ከስም እና ከአገር በስተቀር ሁሉንም ነገር አስወግድ። የማውጣት_ስም_እና_አገር() ተግባር፡-

Def extract_name_and_country(band): plucked_band = () የተነጠቀ_ባንድ ["ስም"] = ባንድ["ስም"] የተነጠቀ_ባንድ ["ሀገር"] = ባንድ["ሀገር"] የተነጠቀ_ባንድ የህትመት ቧንቧ መስመር_እያንዳንዱ(ባንዶች፣ ) # => [(" name": "የፀሐይ መጥለቅ ረብሻ", "ሀገር": "ካናዳ"), # ("ስም": "ሴቶች", "ሀገር": "ካናዳ"), # ("ስም": "አንድ ሲልቨር ተራራ ጽዮን", " ሀገር": "ካናዳ")]

የማውጣት_ስም_እና_ሀገር() ፕልክ() በሚባል አጠቃላይ ቅጽ ሊጻፍ ይችላል። እንደሚከተለው ጥቅም ላይ ይውላል.

የቧንቧ መስመር_እያንዳንዳቸውን ያትሙ (ባንዶች ፣)])

መልመጃ 5. ፕሌክ ከመዝገቦች ለማውጣት የቁልፎችን ዝርዝር ይቀበላል። ለመጻፍ ይሞክሩ። ይህ ከፍተኛ የትዕዛዝ ተግባር ይሆናል።

የፓይዘን ቋንቋ በ Google ፕሮግራመሮች እና በሃከር አርታኢዎች መካከል በተመሳሳይ ጊዜ ተወዳጅ የሆነው በከንቱ አይደለም :). ይህ በእውነት ኃይለኛ ቋንቋ በርካታ ምሳሌዎችን በመከተል ኮድ እንዲጽፉ ያስችልዎታል, እና ዛሬ በመካከላቸው ያለው ልዩነት ምን እንደሆነ እና የትኛውን መከተል የተሻለ እንደሆነ ለማወቅ እንሞክራለን.

ምን ተምሳሌቶች?! ኮድ እናድርግ!

የሆነ ነገር መፃፍ ሲፈልጉ፣ ምናልባት የሚያስጨንቁት የመጨረሻው ነገር የትኛውን የፕሮግራም አወጣጥ ሁኔታ መምረጥ ነው። ይልቁንስ ወይ በጣም ተስማሚ የሆነውን ቋንቋ መርጠዋል፣ ወይም ወዲያውኑ በሚወዱት፣ በተመረጡት እና በአመታት ውስጥ የተረጋገጠ ኮድ ማድረግ ይጀምሩ። እውነት ነው፣ ርዕዮተ ዓለም ምሁራን ስለ ርዕዮተ ዓለም ያስቡ፣ የእኛ ሥራ ፕሮግራም ማድረግ ነው :) ነገር ግን፣ ፕሮግራሚንግ በሚያደርጉበት ጊዜ፣ የግድ የሆነ አይነት ምሳሌ መከተል አለብዎት። አንድ ምሳሌ እንመልከት። አንድ ቀላል ነገር ለመጻፍ እንሞክር ... መልካም, ለምሳሌ, የክበብ ቦታን እናሰላለን.

እንደሚከተለው ሊጽፉት ይችላሉ፡-

የክበብ አካባቢ (አማራጭ አንድ)

ድርብ ቦታ_ክበብ (ድርብ r) (
መመለስ M_PI*pow(r,2);
}
int ዋና()
ድርብ r = 5;
ኮት<< "Площадь: "<< area_of_circle(r)<< endl;
}

ወይም ይህን ማድረግ ይችላሉ:

የክበብ አካባቢ (አማራጭ ሁለት)

ክፍል ክበብ (
ድርብ r;
ይፋዊ፡
ክብ (ድርብ r) (ይህ->r = r;)
ድርብ አካባቢ () (M_PI * pow (ይህ->r,2) መመለስ;)
ባዶ የህትመት_አካባቢ()
ኮት<< "Площадь: "<< this->አካባቢ()<< endl;
}
};
int ዋና () ((አዲስ ክበብ(5))->የህትመት_አካባቢ();)

በተለየ መንገድ ሊከናወን ይችላል ... ነገር ግን ምንም ያህል ቢሞክሩ, ኮዱ የግድ አስፈላጊ ይሆናል (እንደ መጀመሪያው ሁኔታ) ወይም ነገር-ተኮር (እንደ ሁለተኛው).
ይህ በምናብ እጥረት ምክንያት አይደለም፣ ነገር ግን በቀላሉ C++ ለእነዚህ ተምሳሌቶች የተዘጋጀ ስለሆነ ነው።

እና በጣም ጥሩው (ወይም በጣም መጥፎው ፣ በእጆችዎ ቀጥተኛነት ላይ በመመስረት) ሊያደርጉት የሚችሉት ብዙ ምሳሌዎችን መቀላቀል ነው።

ምሳሌዎች

እንደገመቱት ፣ ብዙ ምሳሌዎችን በመከተል በተመሳሳይ ቋንቋ መጻፍ ይችላሉ ፣ አንዳንዴም ብዙ በአንድ ጊዜ። ዋና ወኪሎቻቸውን እንመልከታቸው, ምክንያቱም ያለዚህ እውቀት እራስዎን እንደ ባለሙያ ኮዴር አድርገው መቁጠር አይችሉም, እና በቡድን ውስጥ ስለመሥራት ሊረሱ ይችላሉ.

አስፈላጊ ፕሮግራሚንግ

"መጀመሪያ ይህንን እናደርጋለን ፣ ከዚያ ይህን ፣ ከዚያ ይህን እናደርጋለን"

ቋንቋዎች: ሁሉም ማለት ይቻላል

አንድ ምሳሌ ለማንኛውም ፕሮግራመር በፍጹም ሊረዳ የሚችል፡ “አንድ ሰው ለማሽን መመሪያዎችን ይሰጣል።
ሁሉም ሰው የፕሮግራም አወጣጥን መማር/መረዳት የሚጀምረው ከአስፈላጊው ምሳሌ ነው።

ተግባራዊ ፕሮግራሚንግ

"አገላለጹን እናሰላለን እና ውጤቱን ለሌላ ነገር እንጠቀማለን."

ቋንቋዎች፡ Haskell፣ Erlang፣ F#

ለጀማሪ ፕሮግራመር በፍጹም ለመረዳት የማይቻል ምሳሌ። የግዛቶችን ቅደም ተከተል (እንደ አስፈላጊው ምሳሌ) ሳይሆን የድርጊቶችን ቅደም ተከተል እንገልፃለን።

ነገር-ተኮር ፕሮግራሚንግ

በእውነታው ዓለም ውስጥ ያሉ ግንኙነቶችን በማስመሰል በእቃዎች መካከል መልዕክቶችን እንለዋወጣለን።

ቋንቋዎች: ሁሉም ማለት ይቻላል

በመምጣቱ፣ በነገሮች ላይ ያተኮረ ዘይቤ በጥብቅ ወደ ህይወታችን ገብቷል።
ሁሉም ማለት ይቻላል ዘመናዊ የንግድ ሂደቶች በ OOP ላይ የተገነቡ ናቸው።

ሎጂክ ፕሮግራሚንግ

"መፍትሄ በማፈላለግ ጥያቄውን እንመልሳለን."

ቋንቋዎች፡ ፕሮሎግ

አመክንዮ ፕሮግራሚንግ በጣም የተለየ ነገር ነው ፣ ግን በተመሳሳይ ጊዜ አስደሳች እና ሊታወቅ የሚችል።
ቀላል ምሳሌ በቂ ይሆናል፡-

(ደንቦቹን ያዘጋጁ)
ጠንቋይ (X)<= burns(X) and female(X).
ይቃጠላል (X)<= wooden(X).
እንጨት (X)<= floats(X).
ተንሳፋፊ (X)<= sameweight(duck, X).
(አስተያየቶችን አዘጋጅ)
ሴት (ሴት ልጅ).
ተመሳሳይ ክብደት (ዳክዬ ፣ ልጃገረድ)።
(ጥያቄ ጠይቅ)
? ጠንቋይ (ሴት ልጅ).

እያንዳንዱ ፕሮግራመር በትርጉም የግድ አስፈላጊ እና ነገር-ተኮር ፕሮግራሚንግ ጠንቅቆ ቢያውቅም፣ በንፁህ መልኩ ተግባራዊ ፕሮግራሚንግ ብዙም አናገኝም።

ተግባራዊ ፕሮግራሚንግ ከአስፈላጊ ፕሮግራሚንግ ጋር ተቃርኖ ነው።

አስፈላጊ ፕሮግራሚንግ በፕሮግራሙ ሁኔታ ላይ ተከታታይ ለውጦችን ያካትታል, እና ተለዋዋጮች ይህንን ሁኔታ ለማከማቸት ጥቅም ላይ ይውላሉ.

ተግባራዊ ፕሮግራም, በተቃራኒው, በመረጃ ላይ የእርምጃዎች ቅደም ተከተል ያካትታል. ይህ ከሂሳብ ጋር ተመሳሳይ ነው - ረ (x) ፎርሙላውን በቦርዱ ላይ ለረጅም ጊዜ እንጽፋለን እና ከዚያ x ን በመተካት ውጤቱን እናገኛለን።

እና አጠቃላይ የተግባር ፕሮግራሚንግ ነጥብ እዚህ ቀመሩ በኤክስ ላይ የምንተገበር መሳሪያ ነው።

ባለ ሁለት ፊት ፓይቶን

ከተግባር የተሻለ ንድፈ ሃሳብ የለምና አንድ ነገር አስቀድመን እንፃፍ። በተሻለ ሁኔታ, በ Python ውስጥ ይፃፉት :).
የ"ውሂብ" አደራደር አባሎችን የካሬዎችን ድምር በግዴታ እና በተግባራዊ እናሰላል።

አስፈላጊ Python

ውሂብ = [...]
ድምር = 0
ለኤለመንት በ:
ድምር += ንጥረ ነገር ** 2
የህትመት ድምር

ተግባራዊ Python

ውሂብ = [...]
ካሬ = ላምዳ x: x**2
ድምር = lambda x,y: x+y
የህትመት ቅነሳ (ድምር፣ ካርታ(ካሬ፣ ውሂብ))

ሁለቱም ምሳሌዎች በፓይዘን ውስጥ ናቸው፣ ምንም እንኳን በተግባራዊ ቋንቋዎች ዝርዝር ውስጥ ባላካተትኩትም። ሙሉ በሙሉ የሚሰራ ቋንቋ የተለየ እና አልፎ አልፎ ጥቅም ላይ የሚውል ነገር ስለሆነ ይህ ድንገተኛ አይደለም። የመጀመሪያው የተግባር ቋንቋ ሊፕ ነበር፣ ነገር ግን ሙሉ በሙሉ የሚሰራ አልነበረም (ግራ የሚያጋባ፣ አይደል?)። ሙሉ ለሙሉ ተግባራዊ የሆኑ ቋንቋዎች ለሁሉም አይነት ሳይንሳዊ አፕሊኬሽኖች ጥቅም ላይ ይውላሉ እና እስካሁን ድረስ በስፋት ጥቅም ላይ አልዋሉም.

ነገር ግን "ተግባራቶች" እራሳቸው ካልተስፋፋ, የተወሰኑ ሀሳቦች ከነሱ ወደ ስክሪፕት (እና ብቻ ሳይሆን) የፕሮግራም ቋንቋዎች ተሰደዋል.
ሙሉ በሙሉ የሚሰራ ኮድ መጻፍ አስፈላጊ አይደለም ፣ አስፈላጊ የሆነውን ኮድ በተግባራዊ አካላት ማስጌጥ በቂ ነው።

Python በተግባር

የ FP ፅንሰ-ሀሳቦች በፓይዘን ውስጥ ከቅንጅት በላይ መተግበሩን ያሳያል። እስቲ ጠለቅ ብለን እንያቸው።

? - ስሌት

Lambda calculus ተግባራት እንደ ክርክር እና ሌሎች ተግባራትን መመለስ እንደሚችሉ የሚያመለክት የሂሳብ ጽንሰ-ሀሳብ ነው.
እንደነዚህ ያሉ ተግባራት የከፍተኛ ትዕዛዞች ተግባራት ተብለው ይጠራሉ. ?-calculus በሁለት ክንዋኔዎች ላይ የተመሰረተ ነው፡ አተገባበር እና ረቂቅ።
ቀደም ባለው ዝርዝር ውስጥ የማመልከቻውን ምሳሌ ሰጥቻለሁ። ካርታው እና የመቀነስ ተግባራት “የሚተገበሩ” ወይም የሚተገበሩት ተግባር ለእያንዳንዱ የዝርዝሩ አካል (ለካርታ) ወይም ለእያንዳንዱ ተከታታይ ጥንድ ዝርዝር ንጥረ ነገሮች (ለመቀነስ) እንደ ሙግት የተላለፉት ተመሳሳይ ከፍተኛ-ትዕዛዝ ተግባራት ናቸው።

ረቂቅን በተመለከተ, ሌላኛው መንገድ ነው-ተግባራቶች በክርክርዎቻቸው ላይ በመመስረት አዲስ ተግባራትን ይፈጥራሉ.

Lambda ረቂቅ

def add(n):
ላምዳዳ x: x + n ተመለስ

ይጨምራል =

እዚህ የተግባር ዝርዝር ፈጠርን, እያንዳንዱም የተወሰነ ቁጥር ወደ ክርክሩ ይጨምራል.
ይህ ትንሽ ምሳሌ በተጨማሪ ሁለት ተጨማሪ አስደሳች የተግባር ፕሮግራሚንግ ትርጉሞችን ይዟል - መዘጋት እና ማረም።

መዘጋት በሌላ ተግባር ውስጣዊ ሁኔታ ላይ የሚመረኮዝ የአንድ ተግባር ፍቺ ነው። በእኛ ምሳሌ ይህ lambda x ነው. በዚህ ዘዴ, በአለምአቀፍ ደረጃ ተለዋዋጭዎችን ከመጠቀም ጋር ተመሳሳይ የሆነ ነገር እናደርጋለን.

መሸከም ጥንድ ክርክሮችን የሚወስድ ተግባር ወደ አንድ በአንድ ክርክሮችን ወደ ሚወስድ ተግባር መለወጥ ነው። በምሳሌው ውስጥ ያደረግነው ይህ ነው ፣ እኛ ብቻ እንደዚህ ያሉ ተግባራትን አቀናጅተናል።

በዚህ መንገድ ከተለዋዋጮች ጋር ብቻ ሳይሆን ከተግባሮች ጋር የሚሰራ ኮድ መፃፍ እንችላለን, ይህም ጥቂት ተጨማሪ "የነጻነት ደረጃዎች" ይሰጠናል.

ንጹህ ተግባራት እና ሰነፍ አቀናባሪ

አስፈላጊ ተግባራት ውጫዊ (ዓለም አቀፋዊ) ተለዋዋጮችን ሊለውጡ ይችላሉ ፣ ይህ ማለት አንድ ተግባር ለተመሳሳይ ነጋሪ እሴት በተለያዩ የፕሮግራም አፈፃፀም ደረጃዎች የተለያዩ እሴቶችን መመለስ ይችላል።

እንዲህ ዓይነቱ መግለጫ ለተግባራዊው ዘይቤ ፈጽሞ ተስማሚ አይደለም. እዚህ፣ ተግባራቶቹ እንደ ሒሳባዊ ተደርገው ይወሰዳሉ፣ በክርክር እና በሌሎች ተግባራት ላይ ብቻ ተመስርተው፣ ለዚህም ነው “ንጹሕ ተግባራት” የሚል ቅጽል ስም የተሰጣቸው።

አስቀድመን እንዳወቅነው በተግባራዊ ፓራዳይም ውስጥ እንደፈለጋችሁት ተግባራትን መጣል ትችላላችሁ። ነገር ግን "ንጹህ ተግባራት" ስንጽፍ የበለጠ ጥቅም እናገኛለን. ንጹህ ተግባር የጎንዮሽ ጉዳቶች የሌሉበት ተግባር ነው, ይህም ማለት በአካባቢው ላይ የተመካ አይደለም እና ሁኔታውን አይለውጥም.

ንጹህ ተግባራትን መጠቀም ብዙ ጥቅሞችን ይሰጠናል-

• በመጀመሪያ ፣ ተግባራቶቹ በአካባቢ ተለዋዋጮች ላይ ካልተመሰረቱ ፣ከእነዚህ ተመሳሳይ ተለዋዋጮች ካልተፈለጉ እሴቶች ጋር የተዛመዱ ስህተቶችን ብዛት እንቀንሳለን። ከስህተቶች ብዛት ጋር, ፕሮግራሙን ለማረም የሚወስደውን ጊዜ እንቀንሳለን, እና እንደዚህ አይነት ተግባራትን ለማረም በጣም ቀላል ነው.
• በሁለተኛ ደረጃ, ተግባሮቹ እራሳቸውን የቻሉ ከሆነ, ማጠናከሪያው ለመንቀሳቀስ ቦታ አለው. አንድ ተግባር በክርክር ላይ ብቻ የሚመረኮዝ ከሆነ, አንድ ጊዜ ብቻ ሊገመገም ይችላል. በሚቀጥለው ጊዜ የተሸጎጠውን እሴት መጠቀም ይችላሉ። እንዲሁም ተግባሮቹ እርስ በእርሳቸው የማይመኩ ከሆነ, ሊለዋወጡ እና እንዲያውም በራስ-ሰር ሊመሳሰሉ ይችላሉ.

አፈጻጸሙን ለመጨመር FP እንዲሁ ሰነፍ ግምገማን ይጠቀማል። አስገራሚ ምሳሌ፡-

የህትመት ርዝመት()

በንድፈ ሀሳብ፣ በውጤቱ ላይ በዜሮ ስህተት መከፋፈል ማግኘት አለብን። ነገር ግን ሰነፍ የፓይዘን ማቀናበሪያ እንዲያደርግ ስላልተጠየቀ የዝርዝሩን እያንዳንዱን ንጥረ ነገር በቀላሉ አያሰላም። የዝርዝር ርዝመት ያስፈልጋል - እባክዎን!
ተመሳሳይ መርሆዎች ለሌሎች የቋንቋ ግንባታዎች ይሠራሉ.

በውጤቱም, የፕሮግራም አድራጊው ብቻ ሳይሆን አቀናባሪው በርካታ "የነጻነት ደረጃዎች" ይቀበላል.

መግለጫዎችን እና ሁኔታዊ መግለጫዎችን ይዘርዝሩ

ሕይወት (እና ፕሮግራሚንግ) ለናንተ ማር እንዳይመስላችሁ፣ የፓይዘን አዘጋጆች ልዩ የሆነ “ጣፋጭ” አገባብ ይዘው መጡ፣ ቡርዥው “ሲንታክቲክ ስኳር” ብሎ ይጠራዋል።
ሁኔታዊ መግለጫዎችን እና loopsን እንዲያስወግዱ ይፈቅድልዎታል ... ጥሩ, ካላስወገዱ, ከዚያም በእርግጠኝነት በትንሹ ይቀንሱዋቸው.

በመርህ ደረጃ, በቀድሞው ምሳሌ ውስጥ አስቀድመው አይተውታል - ይጨምራል = . እዚህ ወዲያውኑ ዝርዝሩን በተግባራዊ እሴቶች እንፈጥራለን እና እንጀምራለን. ምቹ ፣ ትክክል?
እንደ እና እና ወይም ኦፕሬተሮች ያለ ነገር አለ፣ ይህም እንደ ኢሊፍ-ሌላ ያሉ አስቸጋሪ ግንባታዎችን እንዲያደርጉ ያስችልዎታል።

ስለዚህ፣ የ Python Toolkitን በመጠቀም፣ አስቸጋሪ የሆነ አስፈላጊ የሆነ ኮድ ወደ ውብ ተግባራዊነት መቀየር ይችላሉ።

አስፈላጊ ኮድ

ኤል=
ለ x በ xrange(10):
x % 2 == 0 ከሆነ፡
x*2>=50 ከሆነ፡
L.append(x)
ሌላ፡
L.append(-x)
ማተም L

የተግባር ኮድ

ማተም

ውጤቶች

ቀደም ሲል እንደተረዱት, የተግባር ዘይቤን ሙሉ በሙሉ መከተል አስፈላጊ አይደለም; ሆኖም፣ ስለ አስፈላጊው ሁኔታ መነጋገር ቀጠልኩ... እና ስለ OOP እና FP ምንም አልተናገርኩም።

ደህና፣ OOP፣ በእውነቱ፣ ለአስፈላጊው ፓራዲግም ተጨማሪ ነው፣ እና ከአይፒ ወደ OOP ከተንቀሳቀሱ፣ ቀጣዩ እርምጃ FP ወደ OOP መተግበር ነው። በማጠቃለያው ስለ ረቂቅነት ደረጃ ጥቂት ቃላትን እናገራለሁ. ስለዚህ, ከፍ ባለ መጠን, የተሻለ ይሆናል, እና ይህን ደረጃ የሚሰጠን የ OOP እና FP ጥምረት ነው.

ሲዲ

በዲስክ ላይ ለዊንዶውስ ተጠቃሚዎች አዲስ የ Python ስርጭቶችን አስቀምጫለሁ. የሊኑክስ ሰዎች እርዳታ አያስፈልጋቸውም :).

WWW

የበለጠ ለማወቅ ለሚፈልጉ አንዳንድ ጥሩ ምንጮች፡-

መረጃ

Pythonን ካልወደዱ፣ አይጨነቁ - ተግባራዊ የሆኑ የፕሮግራም አወጣጥ ሃሳቦችን በሌሎች ከፍተኛ ደረጃ ቋንቋዎች በተሳካ ሁኔታ መተግበር ይችላሉ።

በፕሮግራም አወጣጥ ውስጥ በርካታ ምሳሌዎች አሉ፡ ለምሳሌ፡ OOP፡ ተግባራዊ፡ አስገዳጅ፡ ሎጂካዊ እና ብዙዎቹ። ስለ ተግባራዊ ፕሮግራሞች እንነጋገራለን.

በፓይዘን ውስጥ ሙሉ ለሙሉ የተግባር ፕሮግራሚንግ ቅድመ-ሁኔታዎች፡- ከፍተኛ ደረጃ ያላቸው ተግባራት፣ የተገነቡ የዝርዝር ማቀነባበሪያ መሳሪያዎች፣ ድግግሞሽ እና ሰነፍ ስሌቶችን የማደራጀት ችሎታ ናቸው።

ዛሬ ከቀላል አካላት ጋር እናውቃቸዋለን, እና ውስብስብ ንድፎች በሌሎች ትምህርቶች ውስጥ ይሆናሉ.

ቲዎሪ በንድፈ ሀሳብ

እንደ OOP እና ተግባራዊ ፕሮግራሚንግ፣ ትርጓሜዎችን ለማስወገድ እንሞክራለን። አሁንም ግልጽ የሆነ ፍቺ መስጠት አስቸጋሪ ነው, ስለዚህ እዚህ ግልጽ ፍቺ አይኖርም. ቢሆንም! ለተግባራዊ ቋንቋ ምኞቶችን እናሳይ፡-

• ከፍተኛ ትዕዛዝ ተግባራት
• ንጹህ ተግባራት
• የማይለወጥ ውሂብ

ይህ ሙሉ ዝርዝር አይደለም, ነገር ግን ይህ እንኳን "ቆንጆ" ለማድረግ በቂ ነው. አንባቢው የበለጠ ከፈለገ፣ የተዘረጋ ዝርዝር ይኸውና፡-

• ከፍተኛ ትዕዛዝ ተግባራት
• ንጹህ ተግባራት
• የማይለወጥ ውሂብ
• ይዘጋል።
• ስንፍና
• የጅራት ድግግሞሽ
• የአልጀብራ ውሂብ ዓይነቶች
• ስርዓተ-ጥለት ማዛመድ

እነዚህን ሁሉ ነጥቦች ቀስ በቀስ እና በፓይዘን ውስጥ እንዴት እንደምንጠቀምባቸው እንመልከታቸው።

እና ዛሬ, በአጭሩ, በመጀመሪያው ዝርዝር ውስጥ ምን አለ.

ንጹህ ተግባራት

ንጹህ ተግባራት ምንም የሚታዩ የጎንዮሽ ጉዳቶችን አያመጡም, ውጤቱን ብቻ ይመልሱ. ዓለም አቀፋዊ ተለዋዋጮችን አይቀይሩም, ምንም ነገር አይልኩም ወይም አይታተሙ, እቃዎችን አይነኩ, ወዘተ. እነሱ ውሂብ ይቀበላሉ, አንድ ነገር ያሰላሉ, ክርክሮችን ብቻ ግምት ውስጥ በማስገባት አዲስ ውሂብ ይመለሳሉ.

• ኮድ ለማንበብ እና ለመረዳት ቀላል
• ለመፈተሽ ቀላል ("ሁኔታዎችን መፍጠር አያስፈልግም)
• የበለጠ አስተማማኝ ምክንያቱም በ "የአየር ሁኔታ" እና በአካባቢው ሁኔታ ላይ የተመካ አይደለም, በክርክር ላይ ብቻ
• በትይዩ ማስኬድ ይቻላል፣ ውጤቱም መሸጎጫ ይችላል።

የማይለወጥ ውሂብ

የማይለወጡ የመረጃ አወቃቀሮች ሊለወጡ የማይችሉ ስብስቦች ናቸው። ቁጥሮችን መውደድ ማለት ይቻላል። ቁጥሩ አሁን አለ፣ ሊቀየር አይችልም። ልክ እንደዚሁ፣ የማይለወጥ ድርድር የተፈጠረበት መንገድ ነው እና ሁልጊዜም እንደዛ ይሆናል። ኤለመንት ማከል ከፈለጉ አዲስ ድርድር መፍጠር ይኖርብዎታል።

የማይለዋወጥ መዋቅሮች ጥቅሞች:

• በክር መካከል ማጣቀሻን ደህንነቱ በተጠበቀ ሁኔታ ያጋሩ
• ለመፈተሽ ቀላል
• የሕይወት ዑደት ለመከታተል ቀላል (ከመረጃ ፍሰት ጋር ይዛመዳል)

ከፍተኛ ትዕዛዝ ተግባራት

ሌላ ተግባር እንደ ክርክር የሚወስድ እና/ወይም ሌላ ተግባር የሚመልስ ተግባር ይባላል ከፍተኛ ትዕዛዝ ተግባር:

Def f(x)፡ መመለስ x + 3 def g (ተግባር፣ x)፡ የመመለሻ ተግባር(x) * ተግባር(x) ማተም(g(f፣ 7))

ንድፈ ሃሳቡን ካጤንን፣ ከቀላል ወደ ውስብስብ ወደ ልምምድ መሄድ እንጀምር።

ዝርዝር ማካተት ወይም ዝርዝር ጄኔሬተር

የኮድ መስመሮችን ቁጥር ለመቀነስ የሚረዳውን አንድ የቋንቋ ንድፍ እንይ። ይህንን ግንባታ በመጠቀም የፓይዘን ፕሮግራመርን ደረጃ መወሰን የተለመደ ነገር አይደለም።

የናሙና ኮድ፡

ለ x በ xrange (5፣ 10): x % 2 = 0 ከሆነ: x = * 2 ሌላ: x += 1

እንደዚህ ያለ ሁኔታ ያለው ዑደት የተለመደ አይደለም. አሁን እነዚህን 5 መስመሮች ወደ አንድ ለመቀየር እንሞክር፡-

>>>

መጥፎ አይደለም, 5 መስመሮች ወይም 1. ከዚህም በላይ ገላጭነት ጨምሯል እና እንደዚህ አይነት ኮድ ለመረዳት ቀላል ነው - አንድ አስተያየት ብቻ ሊጨመር ይችላል.

በአጠቃላይ ይህ ንድፍ እንደሚከተለው ነው.

ኮዱ ጨርሶ የማይነበብ ከሆነ እንዲህ ዓይነቱን ንድፍ መተው የተሻለ እንደሆነ መረዳት ጠቃሚ ነው.

ስም-አልባ ተግባራት ወይም ላምዳ

የኮዱን መጠን መቀነስ እንቀጥላለን.

Def calc(x፣ y)፡ ተመለስ x**2+y**2

ተግባሩ አጭር ነው, እና ቢያንስ 2 መስመሮች ባክነዋል. እንደነዚህ ያሉ ጥቃቅን ተግባራትን ማሳጠር ይቻላል? ወይም ምናልባት እንደ ተግባራት ላይሆን ይችላል? ከሁሉም በላይ, ሁልጊዜ በሞጁል ውስጥ አላስፈላጊ ተግባራትን መፍጠር አይፈልጉም. እና ተግባሩ አንድ መስመርን ከወሰደ ፣ ከዚያ የበለጠ። ስለዚህ በፕሮግራሚንግ ቋንቋዎች ስም የሌላቸው የማይታወቁ ተግባራት አሉ.

በፓይዘን ውስጥ የማይታወቁ ተግባራት የሚተገበሩት lambda calculus በመጠቀም ነው እና እንደ lambda አገላለጾች ይመስላሉ፡

>>> lambda x, y: x**2 + y**2 በ 0x7fb6e34ce5f0>

ለፕሮግራመር, እነዚህ ተመሳሳይ ተግባራት ናቸው እና ከእነሱ ጋር መስራት ይችላሉ.

የማይታወቁ ተግባራትን ብዙ ጊዜ ለመድረስ ለተለዋዋጭ እንመድባቸዋለን እና ለጥቅማችን እንጠቀምባቸዋለን።

>>> (ላምዳ x፣ y: x**2 + y**2)(1, 4) 17 >>> >>> func = lambda x, y: x**2 + y**2 >>> ተዝናና (1፣ 4) 17

Lambda ተግባራት እንደ ሙግት ሊሆኑ ይችላሉ. ለሌሎች ላምዳዎች እንኳን:

ማባዣ = ላምዳ n፡ lambda k፡ n*k

lambda በመጠቀም

ተግባራትን ያለ ስም እንዴት መፍጠር እንደሚቻል ተምረናል, አሁን ግን የት እንደሚጠቀሙባቸው እናገኛለን. መደበኛው ቤተ-መጽሐፍት አንድን ተግባር እንደ ክርክር ሊወስዱ የሚችሉ በርካታ ተግባራትን ያቀርባል - ካርታ () ፣ ማጣሪያ () ፣ ይቀንሱ () ፣ ይተግብሩ ()።

ካርታ()

የካርታ() ተግባር የተሰጠውን ተግባር በመጠቀም አንድ ወይም ብዙ ቅደም ተከተሎችን ያስኬዳል።

>>> ዝርዝር1 = >>> ዝርዝር2 = [-1, 1, -5, 4, 6] >>> ዝርዝር (ካርታ (ላምዳ x, y: x*y, ዝርዝር1, ዝርዝር2)) [-7, 2, -15፣40፣72]

ከዝርዝሩ ጀነሬተር ጋር ቀደም ብለን እናውቀዋለን፣ የዝርዝሩ ርዝመት ተመሳሳይ ከሆነ እንጠቀምበት፡-

>>> [-7, 2, -15, 40, 72]

ስለዚህ ፣ የዝርዝር ማካተቶችን መጠቀም አጭር ነው ፣ ግን ላምዳዎች የበለጠ ተለዋዋጭ ናቸው። እንቀጥል።

ማጣሪያ()

የማጣሪያ () ተግባር የአንድን ቅደም ተከተል ዋጋዎች ለማጣራት ያስችልዎታል. የውጤቱ ዝርዝር የንጥሉ የተግባር ዋጋ እውነት የሆነባቸውን እሴቶች ብቻ ይዟል፡-

>>> ቁጥሮች = >>> ዝርዝር (ማጣሪያ(lambda x: x< 5, numbers)) # В результат попадают только те элементы x, для которых x < 5 истинно

ከዝርዝር መግለጫዎች ጋር ተመሳሳይ ነገር፡-

>>> ቁጥሮች = >>>

መቀነስ()

በዝርዝሩ ውስጥ የሰንሰለት ስሌቶችን ለማደራጀት የመቀነስ () ተግባርን መጠቀም ይችላሉ። ለምሳሌ፣ የዝርዝር አካላት ምርት በዚህ መንገድ ሊሰላ ይችላል (Python 2)፡-

>>> ቁጥሮች = >>> ይቀንሱ(lambda res, x: res*x, ቁጥሮች, 1) 720

ስሌቶች በሚከተለው ቅደም ተከተል ይከናወናሉ.

((((1*2)*3)*4)*5)*6

የጥሪ ሰንሰለቱ የተገናኘው መካከለኛ ውጤትን በመጠቀም ነው። ዝርዝሩ ባዶ ከሆነ, ሶስተኛው መለኪያ በቀላሉ ጥቅም ላይ ይውላል (ከዜሮ ምክንያቶች ምርት ውስጥ, ይህ 1 ነው):

>>> ቀንስ (lambda res, x: res*x,, 1) 1

እርግጥ ነው መካከለኛ ውጤትየግድ ቁጥር አይደለም. ይህ ዝርዝርን ጨምሮ ማንኛውም ሌላ የውሂብ አይነት ሊሆን ይችላል. የሚከተለው ምሳሌ የዝርዝሩን ተቃራኒ ያሳያል፡-

>>> ቀንስ(lambda res, x: [x]+res, , )

Python በጣም ለተለመዱት ስራዎች አብሮ የተሰሩ ተግባራት አሉት፡

>> ቁጥሮች = >>> ድምር (ቁጥሮች) 15 >>> ዝርዝር (የተገለበጡ (ቁጥሮች))

Python 3 አብሮ የተሰራ የመቀነስ() ተግባር የለውም፣ ነገር ግን በfunctools ሞዱል ውስጥ ይገኛል።

ማመልከት()

ዝርዝር እና መዝገበ ቃላት በቅደም ተከተል በተሰጡት የአቀማመጥ እና የተሰየሙ ነጋሪ እሴቶች ላይ ሌላ ተግባር የመተግበር ተግባር (Python 2)

>>> def f (x, y, z, a= የለም, b= የለም): ... x, y, z, a, b ... >>> ማተም (f, , ("a":) 4፣ “ለ”፡ 5)) 1 2 3 4 5

በ Python 3 ውስጥ፣ ከተግባር() ተግባር ይልቅ ልዩ አገባብ መጠቀም አለቦት።

>>> def f (x, y, z, a= የለም, b= የለም): ... ማተም (x, y, z, a, b) ... >>> f (*, **(" ሀ"፡ 4፣ "ለ"፡ 5)) 1 2 3 4 5

በዚህ አብሮ በተሰራ ተግባር ግምገማውን እንጨርሰው። መደበኛ ቤተ-መጽሐፍትእና ለዛሬ ወደ መጨረሻው ተግባራዊ አካሄድ እንሂድ።

ይዘጋል።

በሌሎች ተግባራት ውስጥ የተገለጹ ተግባራት መዘጋት ናቸው። ይህ ለምን አስፈለገ? ለማስረዳት አንድ ምሳሌ እንመልከት፡-

ኮድ (ምናባዊ)፡-

የማጣራት ሂደት (ኤለመንት፣ አይነት_ማጣሪያ፣ የሁሉም_ዳታ_መጠን)፡ ማጣሪያዎች = አጣራ(ሁሉም_የውሂብ_መጠን፣ አይነት_ማጣሪያ)።ማግኘት_all() በማጣሪያዎች ውስጥ ለማጣራት፡ element = filt.filter(element) def main(): data = DataStorage () get_all_data () for x በውሂብ፡ ማቀናበር (x፣ "ሁሉም"፣ ሌንስ (ውሂብ))

በኮዱ ውስጥ ሊያስተውሉት የሚችሉት ነገር: በዚህ ኮድ ውስጥ በቋሚነት በቋሚነት የሚኖሩ (ማለትም, ተመሳሳይ) ተለዋዋጮች አሉ, ግን በተመሳሳይ ጊዜ ብዙ ጊዜ እንጭናለን ወይም እንጀምራለን. በውጤቱም, ተለዋዋጭ ጅምር በዚህ ሂደት ውስጥ የአንበሳውን ድርሻ እንደሚወስድ እንረዳለን; የትርፍ አጠቃቀም መዘጋትን ለመቀነስ።

መዝጊያው ተለዋዋጮችን አንድ ጊዜ ያስጀምራል, ከዚያም ያለክፍያ ጥቅም ላይ ሊውል ይችላል.

መዝጊያዎችን እንዴት መፍጠር እንደሚቻል እንማር፡-

Def multiplier(n): "multiplier(n) በ n የሚባዛ ተግባር ይመልሳል" def mul(k)፡ ተመለስ n*k መመለስ mul # ተመሳሳይ ውጤት በ# ማባዣ = lambda n: lambda k: n* k mul2 = ማባዣ (2) # mul2 - ተግባር በ 2 ተባዝቷል ፣ ለምሳሌ mul2(5) == 10

ማጠቃለያ

በትምህርቱ ውስጥ የ FP መሰረታዊ ፅንሰ-ሀሳቦችን ተመልክተናል, እንዲሁም በሚቀጥሉት ትምህርቶች ውስጥ የሚብራሩ የአሰራር ዘዴዎችን ዝርዝር አዘጋጅተናል. እንደ ዝርዝር ማካተት (ዝርዝር ጀነሬተር) ፣ ላዳ ተግባራት እና አጠቃቀማቸው ያሉ የኮዱን መጠን መቀነስ ስለሚቻልባቸው መንገዶች ተነጋገርን እና በመጨረሻም ስለ መዘጋት እና ምን እንደሚፈልጉ ጥቂት ቃላቶች ነበሩ ።