დღეს მე ვისაუბრებ მონაცემთა ტიპზე, როგორიცაა სიები, მათზე ოპერაციები და მეთოდები, სიების გენერატორებისა და სიების გამოყენების შესახებ.

რა არის სიები?

სიები პითონში არის მოწესრიგებული, თვითნებური ტიპის ობიექტების ცვალებადი კოლექციები (მსგავსი მასივი, მაგრამ ტიპები შეიძლება განსხვავდებოდეს).

სიების გამოსაყენებლად, თქვენ უნდა შექმნათ ისინი. სიის შექმნის რამდენიმე გზა არსებობს. მაგალითად, თქვენ შეგიძლიათ დაამუშავოთ ნებისმიერი განმეორებადი ობიექტი (მაგალითად, ) ჩაშენებული ფუნქციით სია:

>>> სია ("სია") ["სია"]

თქვენ ასევე შეგიძლიათ შექმნათ სია სიტყვასიტყვით:

>>> s = # ცარიელი სია >>> l = [ "s" , "p" , [ "isok" ], 2 ] >>> s >>> l ["s", "p", ["isok" "], 2]

როგორც მაგალითზე ხედავთ, სია შეიძლება შეიცავდეს ნებისმიერი ობიექტის ნებისმიერ რაოდენობას (ჩადგმული სიების ჩათვლით), ან არ შეიცავდეს არაფერს.

და სიის შექმნის კიდევ ერთი გზაა სიების გენერატორები. სიის გენერატორი არის ახალი სიის აგების გზა მიმდევრობის თითოეულ ელემენტზე გამოხატვის გამოყენებით. სიის გენერატორები ძალიან ჰგავს მარყუჟს.

>>> c = [ c * 3 c-სთვის "სიაში" ] >>> c ["lll", "iii", "sss", "tttt"]

ასევე შესაძლებელია სიის გენერატორის უფრო რთული დიზაინი:

>>> c = [ c * 3 c-სთვის "სიაში", თუ c != "i" ] >>> c ["lll", "sss", "tttt"] >>> c = [c + d for c "სიაში" თუ c != "i" d-სთვის "სპამში" თუ d != "a" ] >>> c ["ls", "lp", "lm", "ss", "sp", "sm", "ts", "tp", "tm"]

მაგრამ რთულ შემთხვევებში, სიების გენერირებისთვის უმჯობესია გამოიყენოთ რეგულარული for loop.

ჩამოთვალეთ ფუნქციები და მეთოდები

შექმენით შექმნილი, ახლა თქვენ უნდა გააკეთოთ რაღაც სიაში. ძირითადი და სიის მეთოდები ხელმისაწვდომია სიებისთვის.

ცხრილი "სია მეთოდები"

მეთოდი	Რას აკეთებს
სია.დამატება(x)	ამატებს ელემენტს სიის ბოლოს
სია.გაფართოვდეს(L)	აფართოებს სიას L სიის ყველა ელემენტის მიმატებით
სია.ჩასმა(i, x)	აყენებს x მნიშვნელობას i-ე ელემენტზე
სია.ამოღება(x)	შლის სიიდან პირველ ელემენტს, რომელსაც აქვს x მნიშვნელობა. ValueError თუ ასეთი ელემენტი არ არსებობს
სია.პოპ([მე])	შლის i-ე ელემენტს და აბრუნებს მას. თუ ინდექსი არ არის მითითებული, ბოლო ელემენტი ამოღებულია
სია.ინდექსი(x, ])	აბრუნებს პირველი ელემენტის პოზიციას x მნიშვნელობით (ძიება თავიდან ბოლომდე)
სია.თვლა(x)	აბრუნებს ელემენტების რაოდენობას x მნიშვნელობით
სია.დახარისხება()	ახარისხებს სიას ფუნქციის მიხედვით
სია.უკუ()	აფართოებს სიას
სია.ასლი()	სიის არაღრმა ასლი
სია.გასუფთავება()	ასუფთავებს სიას

უნდა აღინიშნოს, რომ სიის მეთოდები, განსხვავებით , ცვლის თავად სიას და, შესაბამისად, შესრულების შედეგი არ საჭიროებს ამ ცვლადზე ჩაწერას.

>>> l = [ 1 , 2 , 3 , 5 , 7 ] >>> ლ . sort() >>> l >>> l = l . sort() >>> print(l) არცერთი

და ბოლოს, სიებთან მუშაობის მაგალითები:

>>> a = [ 66.25 , 333 , 333 , 1 , 1234.5 ] >>> ბეჭდვა (a . count (333), a . count (66.25), a . count ("x")) 2 1 0 >>> ა. ჩასმა (2 , - 1 ) >>> a . დამატება (333 ) >>> ა >>> ა. ინდექსი (333 ) 1 >>> a . ამოღება (333 ) >>> ა >>> ა. reverse() >>>a >>> ა. sort() >>> ა [-1, 1, 66.25, 333, 333, 1234.5]

ზოგჯერ, პროდუქტიულობის გაზრდის მიზნით, სიებს ცვლის ნაკლებად მოქნილი სიებით

წარმოვიდგინოთ სიტუაცია - თქვენ უნდა ამოიღოთ სიის ყველა ელემენტი და მივანიჭოთ თითოეული მათგანი თავის კონკრეტულ ცვლადს. მაგალითად, ჩვენ გვაქვს სია, რომელიც აღწერს ადამიანს და შეიცავს შემდეგ ელემენტებს:

Person_data = ["ჯონ", "სმიტი", 23, "პროგრამისტი"]

მომხმარებლის_სახელი, მომხმარებლის_გვარი, მომხმარებლის_ასაკი, მომხმარებლის_ოკუპაცია = პირის_მონაცემები

ამის შემდეგ, ჩვენ შეგვიძლია გამოვიყენოთ თითოეული შექმნილი ცვლადი ცალკე.

გთხოვთ გაითვალისწინოთ, რომ შექმნილი ცვლადების რაოდენობა უნდა შეესაბამებოდეს სიის ელემენტების რაოდენობას, წინააღმდეგ შემთხვევაში თქვენ მიიღებთ შეცდომას.

როგორ გამოვიყენოთ გენერატორები პითონში.

სიის გენერატორები პითონშიეწოდება ერთხაზოვანი კონსტრუქტები, რომლებიც საშუალებას გაძლევთ შექმნათ ახალი სიები.

სიის გენერატორების სინტაქსია:

# უმარტივესი გენერატორი new_list =

შედეგად, new_list შეიცავს 0-დან 9-მდე რიცხვებს. ნათელია, რომ ასეთი სიის შესაქმნელად არ არის საჭირო გენერატორის გამოყენება. თქვენ უბრალოდ უნდა გამოიყენოთ range() ფუნქცია

# უფრო რთული მაგალითის სიტყვა = "გამარჯობა" new_list =

ახლა new_list ასე გამოიყურება:

["თ", "ე", "ლ", "ლ", "ო"]

თქვენ ასევე შეგიძლიათ ჩასვათ if კონსტრუქცია სიის გენერატორებში:

# შექმენით რიცხვების სია, რომლებიც მრავლდება სამი new_list =

შედეგად ვიღებთ:

დაბოლოს, გენერატორში შეგიძლიათ გამოიყენოთ მრავალი სია და ცვლადი:

# ბარათების დაფის შექმნა სიის გენერატორის გამოყენებით # suits suits = "HDCS" # ranks ranks = "23456789TJQKA" # გემბანის გენერირება =

ჩვენ ვიღებთ შემდეგ შედეგს:

წარმოიდგინეთ, რამდენი დრო დავზოგეთ რამდენიმე მარყუჟის ნაცვლად მხოლოდ ერთი ხაზის დაწერით.

როგორ ამოიღოთ ელემენტები ქვესილებიდან Python-ში.

ასევე, ხშირად იქმნება სიტუაცია, როდესაც აუცილებელია ელემენტების ამოღება სიის ქვესილებიდან.

მაგალითად, ჩვენ გვაქვს შემდეგი სია:

გარე = [, , ]

ამოცანაა შექმნათ ცალკე სია, რომელიც შეიცავს ქვესიტების ყველა ელემენტს ამ სიის. თქვენ შეგიძლიათ შეასრულოთ ეს დავალება იმავე სიის გენერატორის გამოყენებით:

ახალი_სიტი =

ამრიგად, ჩვენ ვიღებთ სიას ყველა ელემენტით:

დღეისთვის სულ ესაა. წარმატებები სწავლაში პითონი!

| |

სიის გაგება საშუალებას გაძლევთ სწრაფად შექმნათ სია არსებული სიებიდან. გენერატორის გამოყენებით, თქვენ შეგიძლიათ შექმნათ სია, რომელიც ეფუძნება განმეორებით მონაცემთა ტიპს (მაგალითად, სტრიქონები ან ტოპები).

შედეგად, ციკლი შექმნის იგივე სიას:

["8", "თ", "ო", "ს", "ტ"]

პირობითი გამონათქვამები სიის გენერატორებში

სიის გენერატორებს შეუძლიათ გამოიყენონ პირობითი გამონათქვამები არსებული სიების ან სხვა თანმიმდევრული მონაცემების ტიპების შესაცვლელად, რაც გამოიწვევს ახალ სიას.

მოდით შევხედოთ გენერატორს if განაცხადით:

fish_tuple = ("blowfish", "clownfish", "catfish", "octopus")
თევზის სია =
ბეჭდვა (fish_list)

სია იყენებს fish_tuple tuple, როგორც ახალი fish_list-ის საფუძველი.

for და in საკვანძო სიტყვები გამოიყენება ისევე, როგორც წინა ზომაში. გარდა ამისა, გენერატორი შეიცავს if განცხადებას, რაც იწვევს სიიდან "რვაფეხას" სტრიქონის გამორიცხვას.

მოიკითხეთ fish_list-ის შინაარსი და დარწმუნდით, რომ ის შეიცავს ყველა fish_tuple ელემენტს, გარდა 'octopus'.

["ბლოუთევზი", "კლოუნთევზი", "კაკა"]

როგორც ხედავთ, პირობითი გამოხატვის გამოყენებით შეგიძლიათ გამორიცხოთ გარკვეული ელემენტი ახალი სიიდან.

ახლა მოდით შევხედოთ სხვა მაგალითს, რომელიც იყენებს მათემატიკის ოპერაციებს, რიცხვებს და დიაპაზონს() მეთოდს.

ბეჭდვა (ნომრების_სიტი)

ასევე წაიკითხეთ:

ახალი ნომერი_სიტი შეიცავს თითოეული ლუწი ელემენტის კვადრატულ მნიშვნელობებს 0-9 დიაპაზონში. შედეგი იქნება ასეთი სია:

მოდით შევხედოთ ამ მაგალითს ეტაპობრივად. თუ x ** 2-ის ნაცვლად x-ისთვის ვიყენებთ მხოლოდ x-ს x-ისთვის, სია ასე გამოიყურება:

ნომრის_ სია =
ბეჭდვა (ნომრების_სიტი)

ამის შემდეგ გენერატორს დაემატა პირობითი გამოხატულება:

ნომრის_ სია =
ბეჭდვა (ნომრების_სიტი)

if განცხადებამ ამოიღო ყველა კენტი რიცხვი სიიდან.

ახლა რჩება მხოლოდ ოპერატორის დამატება, რომელიც ყველა ელემენტს კვადრატში მოათავსებს:

ნომრის_ სია =
ბეჭდვა (ნომრების_სიტი)

ახლა სიის თითოეული ელემენტი იქნება კვადრატში.

თქვენ ასევე შეგიძლიათ გამოიყენოთ ჩასმული if განცხადებები გენერატორებში:

ნომრის_ სია =
ბეჭდვა (ნომრების_სიტი)

სიების გენერატორები Python პროგრამირების ენაზე არის ძლიერი ინსტრუმენტი მონაცემთა მრავალფეროვან კომპლექტებთან მუშაობისთვის. ყველაზე ხშირად, ეს კონსტრუქციები გამოიყენება სიებთან უფრო მოსახერხებელი ურთიერთქმედებისთვის, რაც უზრუნველყოფს არა მხოლოდ მათ შექმნას, არამედ მოდიფიკაციას. იმისდა მიუხედავად, რომ ზოგიერთ შემთხვევაში გენერატორების გარეშე შეგიძლიათ გააკეთოთ, მათი სათანადო გამოყენება მნიშვნელოვნად ამარტივებს რთული ალგორითმების განხორციელებას.

მარტივი თაობა

Ყველაზე მარტივი გზითშექმნა არის მისთვის აუცილებელი მნიშვნელობების ან ობიექტების ჩვეულებრივი მინიჭება. იმ შემთხვევაში, როდესაც თანმიმდევრობის რამდენიმე ელემენტია, ისინი უბრალოდ შეიძლება ჩამოვთვალოთ ერთმანეთის მიყოლებით. მაგრამ თუ მათი რიცხვი ათეულს აჭარბებს, სერიოზულად უნდა იფიქროთ სიების გენერატორის გამოყენებაზე. ეს დიზაინი უზრუნველყოფს მის ავტომატურ შევსებას გარკვეული ინსტრუქციების საფუძველზე.

შემდეგი მაგალითი გვიჩვენებს, თუ როგორ შევქმნათ რიცხვების სია პითონში გენერატორის გამოყენებით. ცვლადი i არის მითითება მონაცემთა ობიექტის მიმდინარე ელემენტზე. დიაპაზონის ფუნქცია აქ იღებს ორ არგუმენტს, რომლებიც ადგენს საზღვრებს მთელი რიცხვების გენერირებული თანმიმდევრობისთვის. ინფორმაცია ეკრანზე გამოჩნდება ბეჭდვის მეთოდის გამოყენებით.

>>> მონაცემები = >>> ბეჭდვა (მონაცემები)

Python 3 სიის გენერატორები არ მუშაობენ მხოლოდ რიცხვითი მნიშვნელობებით. როგორც შემდეგი მაგალითი გვიჩვენებს, შეგიძლიათ გენერატორს არგუმენტად გადასცეთ სტრიქონი ან მასზე მითითება.

>>> მონაცემები = >>> ბეჭდვა(მონაცემები) ["p", "y", "t", "h", "o", "n"]

ამ კოდის შესრულების შედეგად, აშენდება სიმბოლოთა სია, რომლებიც შეიცავს თავდაპირველ სტრიქონს. როგორც წინა მაგალითის შემთხვევაში, თქვენ შეგიძლიათ აჩვენოთ მიღებული მონაცემების ნაკრები ეკრანზე უკვე კარგად ცნობილი ბეჭდვის მეთოდის გამოყენებით.

გენერატორი მდგომარეობით

პითონში სიების გენერირების ერთ-ერთი ყველაზე ხშირად გამოყენებული გზა არის პირობა. წინა მაგალითებმა აჩვენა საკმაოდ ტრივიალური მიდგომა გენერატორის გამოყენებით სიის შევსებისადმი. პითონის ენის კონსტრუქციის მონაცემები საშუალებას გაძლევთ დააყენოთ გარკვეული პირობები ასეთი ოპერაციის შესასრულებლად. მაგალითად, არის დავალება სიაში მხოლოდ ლუწი რიცხვების გადატანა რიცხვითი მნიშვნელობებიადრე შექმნილი დიაპაზონის არჩევიდან.

>>> მონაცემები = >>> ბეჭდვა (მონაცემები)

თამაშში შედის if განცხადება, რასაც მოჰყვება მცირე განცხადება, რომელიც ამბობს, რომ მიმდევრობის თითოეული ელემენტი უნდა აკმაყოფილებდეს გარკვეულ პირობას. ამ შემთხვევაში აუცილებელია 0-ის დაბრუნება მთელი რიცხვის გაყოფის ნაშთის გამოთვლის შედეგად. როგორც ხედავთ, სიაში მოხვდა გამოცდაზე გავლილი ნომრები.

გენერატორი ციკლით

პითონი ასევე საშუალებას გაძლევთ შექმნათ სია მრავალი მარყუჟის გამოყენებით., განათავსეთ ისინი ინიციალიზაციის კვადრატულ ფრჩხილებში. შემდეგი მაგალითი იყენებს ორს კონსტრუქციებისთვის, რომლებიც მონაცვლეობით იმეორებენ i და j ცვლადების მნიშვნელობებს. მათთვის რიცხვითი დიაპაზონი (0-დან 3-მდე), როგორც ადრე, დადგენილია დიაპაზონის მეთოდებით.

>>> მონაცემები = >>> ბეჭდვა (მონაცემები)

ამ კოდის შესრულების შედეგი იქნება i და j ცვლადების მონაცვლეობით გამრავლების საფუძველზე მონაცემთა სიის შექმნა. მარყუჟების წყალობით, მათი მნიშვნელობები ეტაპობრივად იზრდება. ეს ქმნის ცხრა ელემენტის ჩამონათვალს.

წყობილი სიების გენერირება

ზოგჯერ პროგრამისტს სჭირდება ერთზე მეტი განზომილების სიების გამოყენება. მაგალითად, მათემატიკურ მატრიცებთან მუშაობისას შეიძლება საჭირო გახდეს მონაცემთა მრავალგანზომილებიანი ნაკრები. თქვენ ასევე შეგიძლიათ გამოიყენოთ გენერატორები ამის გასაკეთებლად პითონში, უბრალოდ მარყუჟის დაყენებით ერთი სიის შესაქმნელად მეორეში. ჩადგმული სიის ფარგლების შეზღუდვები იქნება კვადრატული ფრჩხილები, როგორც ნაჩვენებია შემდეგ მაგალითში.

>>> მონაცემები = [ j-სთვის დიაპაზონში(0, 3)] >>> ბეჭდვა(მონაცემები) [, , ]

ეს კოდი აჩვენებს, თუ როგორ უნდა შექმნათ ორგანზომილებიანი 3x3 მატრიცა პითონის ორგანზომილებიანი სიის გენერატორის გამოყენებით. ამ რიცხვითი თანმიმდევრობის ელემენტები იყო ციფრული მნიშვნელობები დიაპაზონის მეთოდებიდან, როგორც წინა მაგალითებში. i და j ცვლადები თანდათან იზრდება ციკლებში ერთით და მრავლდება ერთმანეთში. ბეჭდვის ფუნქცია გამოიყენება კომპიუტერის ეკრანზე გენერირებული მონაცემთა ნაკრების ვიზუალურად საჩვენებლად.

ხშირად პითონის წყობილი სიის შექმნისას გამოიყენება ნულების გენერატორის მატრიცა. მაგალითად, მოდით შევქმნათ 3x2 მატრიცა:

>>> მონაცემები = [ y-სთვის დიაპაზონში(3)] >>> ბეჭდვა(მონაცემები) [, , ]

სიის გენერატორი ლამბდასთან ერთად

მოგეხსენებათ, ლამბდა ფუნქციები პითონში არის ოპერაცია, რომელიც აბრუნებს მნიშვნელობას. ამ მექანიზმის უპირატესობა ის არის, რომ მისი გამოყენება შესაძლებელია გამოხატვის შიგნით. ამან შეიძლება მნიშვნელოვნად შეამციროს კოდის რაოდენობა, რომელიც პროგრამისტმა უნდა აკრიფოს, რადგან ამ შემთხვევაში არ არის საჭირო ახალი მეთოდის ცალკე გამოცხადება. სიის გენერატორი ლამბდასთან ერთად Python-ში იძლევა საშუალებას

პითონის ლამბდას ფუნქციები ზოგჯერ გამოიყენება სიების გენერატორებში. შემდეგი მაგალითი შექმნის რიცხვების ახალ თანმიმდევრობას დიაპაზონის მეთოდით. როგორც ადრე, ამ ნაკრების ელემენტი წარმოდგენილია i ცვლადის სახით, რომელსაც თანდათანობით ეძლევა ახალი მნიშვნელობები (0-დან 9-მდე) მარყუჟისთვის. ლამბდა ფუნქცია არგუმენტად იღებს მნიშვნელობას, შემდეგ ამრავლებს მას თავისთავად და აბრუნებს გენერატორს.

>>> მონაცემები = [(ლამბდა i: i*i)(i) i-სთვის დიაპაზონში(0, 10)] >>> ბეჭდვა(მონაცემები)

ეს ქმნის სიას, მონაცემებს, რომელიც შეიცავს 0-დან 9-მდე რიცხვების კვადრატის შედეგებს. ჩვეულებისამებრ, ბეჭდვის ფუნქცია ბეჭდავს ინფორმაციას ეკრანზე.

itertools-ის გამოყენება

პითონში სიის გაფართოებული გენერირების შესასრულებლად გამოიყენება დანამატი ბიბლიოთეკა, სახელწოდებით itertools. მისი დახმარებით თქვენ შეგიძლიათ შექმნათ ღირებულებების ნაკრები გარკვეული წესების მიხედვით. ამ მოდულის ფუნქციების გასააქტიურებლად, თქვენ უნდა დაამატოთ შემდეგი ინსტრუქცია პროგრამის ფაილის დასაწყისში.

itertools-ის იმპორტი

ამ ბიბლიოთეკის შემცველი მეთოდები საშუალებას გაძლევთ შექმნათ სიები გაუმჯობესებული მარყუჟების გამოყენებით. Მაგალითად, მისი დახმარებით თქვენ შეგიძლიათ მარტივად შექმნათ სხვადასხვა მნიშვნელობების კომბინაციები, როგორც სიმბოლური, ასევე რიცხვითი. შემდეგი კოდი არის მარტივი მაგალითისიის გენერირება გამეორების ფუნქციის გამოძახებით.

>>> მონაცემები = >>> ბეჭდვა (მონაცემები)

როგორც შედეგიდან ხედავთ, მეთოდი აბრუნებს იდენტური ობიექტების თანმიმდევრობას (ამ შემთხვევაში, რიცხვი 1), მეორდება 5-ჯერ.

დასკვნა

Მოწინავე ფუნქციონირებაპითონში წარმოდგენილი სიების გენერატორებით, პროგრამისტს საშუალებას აძლევს გაზარდოს მონაცემთა დამუშავების სიჩქარე და ეფექტურობა. განხილული მექანიზმი მოიცავს როგორც ჩვეულებრივი, ისე მრავალგანზომილებიანი სიების შექმნას გარკვეული პირობების საფუძველზე, ასევე მარყუჟების გამოყენებას. ენას ასევე აქვს გენერირების შესაძლებლობა ლამბდა გამონათქვამებისა და ინტერინსტრუმენტების ბიბლიოთეკის გამოყენებით.

პითონი მხარს უჭერს კონცეფციას სახელწოდებით "სიის გაგება" ( სიების გენერატორები).

ეს კონცეფცია საშუალებას გაძლევთ შექმნათ სიები ძალიან ბუნებრივი, მარტივი გზით, როგორც ამას მათემატიკოსები აკეთებენ.

ქვემოთ მოცემულია მათემატიკაში სიების (ან კოლექციების, ან ტოპების, ან ვექტორების) აღწერის საერთო გზები:

S = (x 2: x in (0 ... 9))
V = (1,2,4,8, ..., 2 2)
M = (x | x S-ში და x ლუწი)

თქვენ შეიძლება გახსოვთ მსგავსი რამ სკოლიდან. პითონში შეგიძლიათ დაწეროთ იგივე გამონათქვამები, როგორც მათემატიკოსებს, სპეციალური სინტაქსის დამახსოვრების გარეშე.

როგორ გამოიყურება ჩვენი გამონათქვამები პითონში:

>>> S = >>> V = >>> M = >>> >>> ბეჭდვა S; ბეჭდვა V; დაბეჭდე მ
დარწმუნებული ვარ, გსურთ ნახოთ უფრო რთული მაგალითი. :) ქვემოთ წარმოგიდგენთ მარტივი რიცხვების პოვნის სხვა ხერხს. საინტერესო ის არის, რომ ჩვენ ჯერ ავაშენებთ არამარტივი რიცხვების სიას, პირველი სიის გენერატორის გამოყენებით, შემდეგ კი მეორე სიის გენერატორის, რათა მივიღოთ სიის „შებრუნებული“, რაც არის მარტივი რიცხვები.

>>> noprimes = >>> primes = >>> print primes შენიშვნა: თქვენ შეგიძლიათ ჩართოთ სიების გენერატორები ერთმანეთში, ასე რომ, ჩვენს მაგალითში თქვენ შეგეძლოთ მხოლოდ ერთი გამოთქმით ("noprimes" ცვლადის შესანახად გამოყენების გარეშე შუალედური შედეგები). თუმცა, ჩვენი გამოთქმა იქნება გრძელი და ნაკლებად იკითხება, რაც არ არის რეკომენდებული. რა თქმა უნდა, სიის გენერატორი შეიძლება გამოყენებულ იქნას არა მხოლოდ ციფრებისთვის. სიები შეიძლება შეიცავდეს ნებისმიერი ტიპის ელემენტებს, მათ შორის სტრიქონებს, ხაზოვან სიებს და ფუნქციებს. შეგიძლიათ აურიოთ კიდეც სხვადასხვა სახისერთ სიაში.

შემდეგ მაგალითში ჩვენ საქმე გვაქვს სტრიქონების ჩამონათვალთან და ვაწარმოებთ სიების სიას. თითოეული ჩაშენებული სია შეიცავს ორ სტრიქონს და ერთ რიცხვს.

>>> words = "სწრაფი ყავისფერი მელა გადახტება ზარმაცი ძაღლზე".split() >>> ამობეჭდოთ სიტყვები ["The", "სწრაფი", "ყავისფერი", "მელა", "jumps", "over", "the", "ზარმაცი", "ძაღლი"] >>> პერსონალი = [ w-ისთვის სიტყვებით] >>> i in stuff: ... print i
["THE", "the", 3] ["სწრაფი", "სწრაფი", 5] ["Brown", "Brown", 5] ["FOX", "fox", 3] ["JUMPS", " ხტუნვა", 5] ["OVER", "over", 4] ["THE", "the", 3] ["ზარმაცი", "ზარმაცი", 4] ["DOG", "ძაღლი", 3] > >> stuff = რუკა (ლამბდა w: , სიტყვები) >>> i-სთვის: ... print i ["THE", "the", 3] ["QUICK", "სწრაფი", 5] ["Brown" " ", "ყავისფერი", 5] ["FOX", "მელა", 3] ["JUMPS", "jumps", 5] ["OVER", "over", 4] ["THE", "the" , 3] ["ზარმაცი", "ზარმაცი", 4] ["ძაღლი", "ძაღლი", 3]
ზემოთ მოყვანილი მაგალითი გვიჩვენებს, რომ შეგიძლიათ ჩვენი დავალების განხორციელება ორი გზით - ჯერ სიის გენერატორის გამოყენებით, შემდეგ კი map() და ლამბდა ფუნქციის გამოყენებით. თუმცა, არის შემთხვევები, როდესაც თქვენ არ შეგიძლიათ გამოიყენოთ map() და უნდა გამოიყენოთ სიის გენერატორი და პირიქით. თუ ორივე მეთოდი გამოიყენება, ხშირად უმჯობესია გამოიყენოთ სიის გენერატორი, რადგან ის უმეტეს შემთხვევაში უფრო ეფექტური და იკითხებადია.

თქვენ არ შეგიძლიათ გამოიყენოთ სიის გენერატორები, როდესაც კომპოზიციის მდგომარეობა ძალიან რთულია გამოსახული "for" და "if" განცხადებებით, ან როდესაც მდგომარეობა დინამიურად იცვლება პროგრამის გაშვებისას. ამ შემთხვევაში უმჯობესია გამოიყენოთ map() და/ან filter() შესაბამისი ფუნქციით. რა თქმა უნდა, შეგიძლიათ დააკავშიროთ ისინი სიის გენერატორთან.

ორიგინალური სტატია: