როგორ შევქმნათ while მარყუჟი პითონში: 9 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:16

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

ცოტა ხნის მარყუჟი არის შესანიშნავი ინსტრუმენტი, რომელიც საშუალებას გაძლევთ ეფექტურად გადახედოთ პროგრამის განხორციელების პროცესს, ხოლო თქვენი კოდი იყოს სუფთა და ლაკონური. ქვემოთ მოყვანილი ნაბიჯები გაჩვენებთ თუ როგორ უნდა შექმნათ მარყუჟი პითონში სიის გადასაადგილებლად. ეს სავარჯიშო განკუთვნილია დამწყებთათვის, რომლებსაც აქვთ გარკვეული ცოდნა მასივების შესახებ, რომელსაც პითონში "სიებს" უწოდებენ. ამ 15 წუთიანი სავარჯიშოსთვის ჩვენ დავათვალიერებთ რიცხვების ჩამონათვალს და თითოეული რიცხვის მნიშვნელობას გავზრდით ხუთჯერ. მაგალითად, თუ სიას აქვს რიცხვები [1, 2, 4, 7], მარყუჟი წარმოქმნის ახალ ჩამონათვალს, რომელიც შეიცავს რიცხვებს [6, 7, 9, 12].

მარაგები

პითონი 3 (გადმოსაწერად დააჭირეთ ბმულს)

ნაბიჯი 1: განსაზღვრეთ ფუნქცია

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

def addFive (lst):

ნაბიჯი 2: დაიწყეთ ცარიელი სია

შემდეგი, ჩვენ უნდა დავიწყოთ ცარიელი სია, რომელსაც ჩვენ გამოვიყენებთ ახალი სიის შესაქმნელად, რომელსაც ექნება გაზრდილი რიცხვითი მნიშვნელობები [6, 7, 9, 12] ფუნქციის დასრულების შემდეგ. ღირებულებების ახალ სიაში განთავსება საშუალებას მოგვცემს შევინარჩუნოთ ორიგინალური სია უცვლელი.

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

def addFive (lst):

nlst =

ნაბიჯი 3: დააყენეთ ცვლადი "ინდექსი" რიცხვ 0 -ზე

ჩვენ უნდა დავაყენოთ ცვლადი ინდექსი, რომელიც უდრის რიცხვს 0. ეს განცხადება ადგენს სიის საწყის ინდექსს, რომელიც არის ინდექსი 0. მოგვიანებით, ჩვენ გავზრდით ინდექსს 1 -ით, ხოლო მარყუჟს გადავეცი დარჩენილი ინდექსები. იხილეთ ქვემოთ მოყვანილი მაგალითი ინდექსის ცვლადის დასადგენად.

def addFive (lst):

nlst = ინდექსი = 0

ნაბიჯი 4: დაიწყეთ მარყუჟის განცხადება

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

def addFive (lst):

nlst = ინდექსი = 0 ხოლო ინდექსი <len (lst):

მოდით დავანახოთ ეს პირობითი განცხადება. განცხადება ნათქვამია შემდეგნაირად:”მაშინ როდესაც ინდექსი ნაკლებია სიის სიგრძეზე. რა " სიის სიგრძე [1, 2, 4, 7] უდრის 4 -ს, რადგან სიაში არის 4 რიცხვითი ელემენტი. ვინაიდან სიის ინდექსი იწყება 0 ნომრით, ბოლო ინდექსი ყოველთვის იქნება სიის სიგრძე მინუს 1. ჩვენს სიაში მაგალითში [1, 2, 4, 7], სიის ბოლო ინდექსი ტოლია 4 - 1, რაც უდრის 3. ამიტომ, ინდექსი 3 არის სიის ბოლო ინდექსი.

იხილეთ ზემოთ დიაგრამა მაგალითისთვის, თუ როგორ შეესაბამება ინდექსები სიაში არსებულ ელემენტებს. ინდექსი 0 ინახავს ნომერს 1, ინდექსი 1 იკავებს რიცხვს 2, ინდექსი 2 ფლობს 4 ნომერს, ხოლო ინდექსი 3 ფლობს 7 რიცხვს.

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

ნაბიჯი 5: დაამატეთ დანართის მეთოდი

ახლა დროა შევქმნათ მარყუჟის სხეული. სხეულის ნაბიჯებისთვის, იფიქრეთ იმაზე, თუ რა უნდა გააკეთოთ მხოლოდ პირველი ინდექსისთვის. ჩვენი while მარყუჟი გაართმევს ნაბიჯებს დარჩენილი ინდექსებისთვის. სიის პირველ ინდექსში (ინდექსი 0) [1, 2, 4, 7], ჩვენ გვინდა ავიღოთ ნომერი 1 და დავამატოთ 5 მას, შემდეგ კი ახალი რიცხვი დავამატოთ ცარიელ სიაში nlst.

ცარიელ სიაში ელემენტის დასამატებლად, ჩვენ უნდა დავამატოთ ელემენტი სიაში დანართის მეთოდის გამოყენებით. დანართის მეთოდის გამოსაყენებლად, ჩვენ ვწერთ nlst.append () - ს, როგორც ეს მოცემულია ქვემოთ მოცემულ მაგალითში, დარწმუნდით, რომ განათავსეთ ფრჩხილები მეთოდის ზარის ბოლოს. შემდეგ ფრჩხილის შიგნით, ჩვენ ვამატებთ კოდს, რომელიც განახორციელებს მიმდინარე რიცხვითი ელემენტის დამატებას პლუს 5 (ანუ 1 + 5 = 6).

def addFive (lst):

nlst = index = 0 ხოლო index <len (lst): nlst.append ()

ნაბიჯი 6: ჩადეთ მათემატიკის გამოხატვის დანართი შიგნით

რიცხვის ამჟამინდელი ელემენტის მისაღებად, ჩვენ შევეხებით სიის ელემენტს მისი ინდექსის გამოყენებით:

lst [0] = 1

lst [1] = 2

lst [2] = 4

lst [3] = 7

ამრიგად, მარყუჟის დროს სიის პირველ ელემენტზე წვდომისათვის კოდი იქნება lst [ინდექსი], რადგან დასაწყისში ჩვენ ცვლადის ინდექსს ვდებთ 0. ელემენტზე 5 -ის დასამატებლად ჩვენ ვასრულებთ დამატებას lst [ინდექსი] + 5. პირველი ინდექსისთვის (ინდექსი 0), ეს გამოიღებს 1 + 5 -ს, რაც უდრის 6 -ს.

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

def addFive (lst):

nlst = index = 0 ხოლო index <len (lst): nlst.append (lst [index] + 5)

ნაბიჯი 7: "ინდექსის" ცვლადის გაზრდა 1 -ით

შემდეგი ხაზი მარტივია. მას შემდეგ რაც ახალი რიცხვი გამოითვლება 0 ინდექსისთვის, ჩვენ გვსურს იგივე გამოთვლა ყველა სხვა ინდექსისთვის. საბედნიეროდ, while მარყუჟი ამუშავებს ნაბიჯებს არაერთხელ, სანამ არ მივაღწევთ ბოლო ინდექსს! ახლა, ჩვენ უბრალოდ უნდა დავრწმუნდეთ, რომ მარყუჟი ირჩევს და გამოითვლის შემდეგ ინდექსს ყოველ ჯერზე, როდესაც ეს კეთდება მიმდინარე ინდექსით.

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

def addFive (lst):

nlst = index = 0 while index <len (lst): nlst.append (lst [index] + 5) index = index + 1

ნაბიჯი 8: დაამატეთ დაბრუნების განცხადება

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

def addFive (lst):

nlst = index = 0 ხოლო index <len (lst): nlst.append (lst [index] + 5) index = index + 1 return nlst

ნაბიჯი 9: შეამოწმეთ while მარყუჟის ფუნქცია

ახლა ჩვენ უბრალოდ უნდა შევამოწმოთ ჩვენი while მარყუჟის ფუნქცია რომ ნახოთ მუშაობს თუ არა. პირველი, შეინახეთ თქვენი პითონის ფაილი თქვენს კომპიუტერში, შემდეგ დააჭირეთ კლავიატურაზე F5 პროგრამის გასაშვებად. შემდეგი, ჩაწერეთ განცხადებები ქვემოთ მოყვანილ მაგალითში (განცხადებები, რომლებიც არის ისრების გვერდით). დააჭირეთ Enter თითოეული განცხადების შემდეგ შედეგების სანახავად.

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

>> a = [1, 2, 4, 7]

>> b = addFive (a) >>> b [6, 7, 9, 12] >>> a [1, 2, 4, 7]

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

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