პითონის ოპერაციები if true false-ით. ლოგიკური ოპერატორები პითონში. ლოგიკური ოპერატორების გამოყენება ნაკადის გასაკონტროლებლად
|
ოპერატორი |
აღწერა |
მაგალითები |
|
ლოგიკური ოპერატორი "AND". პირობა იქნება ჭეშმარიტი, თუ ორივე ოპერანდი მართალია. |
True და True უდრის True. True და False ტოლია მცდარი. მცდარი და ჭეშმარიტი ტოლია მცდარი. მცდარი და ყალბი ტოლია ყალბი. |
|
|
ლოგიკური ოპერატორი "OR". თუ ოპერანდებიდან ერთი მაინც არის ჭეშმარიტი, მაშინ მთელი გამოხატულება იქნება ჭეშმარიტი. |
True ან True უდრის True. True ან False უდრის True. False ან True უდრის True. False ან False უდრის ყალბს. |
|
|
ლოგიკური ოპერატორი "NOT". აბრუნებს ოპერანდის ლოგიკურ მნიშვნელობას. |
არა ჭეშმარიტი ტოლია მცდარი. არა მცდარი უდრის True. |
პითონი.
ფილიალების ოპერატორები. პირობითი ოპერატორი.მრავალჯერადი შერჩევის ოპერატორი.
ციკლების ორგანიზების სტრუქტურები.
ფილიალის ოპერატორი (პირობითი განცხადება, პირობითი განცხადება) - ოპერატორი, პროგრამირების ენის კონსტრუქცია, რომელიც უზრუნველყოფს გარკვეული ბრძანების (ბრძანებების ნაკრების) შესრულებას მხოლოდ იმ შემთხვევაში, თუ გარკვეული ლოგიკური გამოთქმა არის ჭეშმარიტი, ან რამდენიმე ბრძანებიდან ერთ-ერთის (ბრძანებების კომპლექტი) შესრულებას გარკვეული მნიშვნელობიდან გამომდინარე. გამოხატულება.ფილიალის ოპერატორი თუ .... სხვა
პირობითი ოპერატორი ახორციელებს გარკვეული ბრძანებების შესრულებას, იმ პირობით, რომ ზოგიერთი
ლოგიკური გამოხატულება
(პირობა) აფასებს ჭეშმარიტად. უმეტეს პროგრამირების ენებში, პირობითი განცხადება იწყება საკვანძო სიტყვით if
მრავალჯერადი შერჩევის ოპერატორი
მრავალჯერადი შერჩევის ინსტრუქცია საშუალებას გაძლევთ შეასრულოთ პროგრამის სხვადასხვა ნაწილი, ზოგიერთი მთელი რიცხვი ცვლადის elif-ის მნიშვნელობიდან გამომდინარე.
ხოლო და მარყუჟებისთვის
while განცხადება იძლევა უნივერსალური მარყუჟების ორგანიზების საშუალებას;
for განაცხადი შექმნილია ელემენტების თანმიმდევრობით გადაკვეთისთვის და შესასრულებლად
პროგრამის კოდის ბლოკი თითოეული მათგანისთვის.
14. პითონი. ტოპები, ლექსიკონები, სიები. ნაჭრები
ტუპლი არსებითად უცვლელი სიაა.
რატომ გვჭირდება ტუპლები, თუ ჩვენ გვაქვს სიები?
("თ", "ე", "ლ", "ლ", "ო", ",", "", "ვ", "ო", "რ", "ლ", "დ", "! ")
ლექსიკონები პითონში- თვითნებური ობიექტების უწესრიგო კოლექციები გასაღებით წვდომით. მათ ზოგჯერ ასევე უწოდებენ ასოციაციურ მასივებს ან ჰეშ ცხრილებს.
ლექსიკონის მეთოდები
კარნახობს.გარკვევა() - ასუფთავებს ლექსიკონს.
კარნახობს.ასლი() - აბრუნებს ლექსიკონის ასლს.
კლასის მეთოდი კარნახობს.კლავიშებიდან(seq[, value]) - ქმნის ლექსიკონს კლავიშებით seq და value value (არცერთი ნაგულისხმევად).
უკარნახოს.მიიღოს(key[, ნაგულისხმევი]) - აბრუნებს გასაღების მნიშვნელობას, მაგრამ თუ ის არ არსებობს, ის არ აყენებს გამონაკლისს, მაგრამ აბრუნებს ნაგულისხმევს (ნაგულისხმევი არის None).
კარნახობს.ნივთები() - აბრუნებს (გასაღები, მნიშვნელობა) წყვილებს.
კარნახობს.გასაღებები() - აბრუნებს კლავიშებს ლექსიკონში.
კარნახობს.პოპ(key[, ნაგულისხმევი]) - შლის გასაღები და აბრუნებს მნიშვნელობას. თუ გასაღები არ არის, აბრუნებს ნაგულისხმევს (ნაგულისხმევად აგდებს გამონაკლისს).
კარნახობს.popitem() - შლის და აბრუნებს (გასაღები, მნიშვნელობა) წყვილს. თუ ლექსიკონი ცარიელია, გამონაკლისს აგდებს KeyError. გახსოვდეთ, რომ ლექსიკონები უწესრიგოა.
dict.setdefault(key[, ნაგულისხმევი]) - აბრუნებს გასაღების მნიშვნელობას, მაგრამ თუ ის არ არსებობს, ის არ აგდებს გამონაკლისს, არამედ ქმნის გასაღებს ნაგულისხმევი მნიშვნელობით (None by default).
dict.განახლება() - განაახლებს ლექსიკონს სხვა წყვილების დამატებით (გასაღები, მნიშვნელობა). არსებული გასაღებები გადაწერილია. აბრუნებს None (არ არის ახალი ლექსიკონი!).
კარნახობს.ღირებულებები() - აბრუნებს მნიშვნელობებს ლექსიკონში.
რა არის სიები?
სიები პითონში არის მოწესრიგებული, თვითნებური ტიპის ობიექტების ცვალებადი კოლექციები (მსგავსი მასივი, მაგრამ ტიპები შეიძლება განსხვავდებოდეს).
სიების გამოსაყენებლად, თქვენ უნდა შექმნათ ისინი. სიის შექმნის რამდენიმე გზა არსებობს. მაგალითად, შეგიძლიათ დაამუშავოთ ნებისმიერი განმეორებადი ობიექტი (როგორიცაა სტრიქონი) ჩაშენებული სიით: ფუნქცია.
ცხრილი "სია მეთოდები"
მეთოდი რას აკეთებს
list.append(x) ანიჭებს ელემენტს სიის ბოლოს
list.extend(L) აფართოებს სიას L სიის ყველა ელემენტის მიმატებით
list.insert(i, x) აყენებს x მნიშვნელობას i-ე ელემენტზე
list.remove(x) შლის სიიდან პირველ ელემენტს, რომელსაც აქვს x მნიშვნელობა
list.pop([i]) შლის i-ე ელემენტს და აბრუნებს მას. თუ ინდექსი არ არის მითითებული, ბოლო ელემენტი ამოღებულია
list.index(x, ]) აბრუნებს პირველი ელემენტის პოზიციას თავიდან ბოლომდე x მნიშვნელობით
list.count(x) აბრუნებს ელემენტების რაოდენობას x მნიშვნელობით
list.sort() ახარისხებს სიას ფუნქციის საფუძველზე
list.reverse() აბრუნებს სიას
list.copy() სიის არაღრმა ასლი (ახალი პითონ 3.3-ში)
list.clear() ასუფთავებს სიას (ახალი პითონ 3.3-ში)
ნაჭრები
პითონში, ინდექსების გარდა, არის ნაჭრებიც.
ელემენტი - იღებს ნაჭერს START ნომრიდან STOP-მდე (მისი გარეშე), STEP ნაბიჯით. ნაგულისხმევად, START = 0, STOP = ობიექტის სიგრძე, STEP = 1. შესაბამისად, ზოგიერთი (და შესაძლოა ყველა) პარამეტრი შეიძლება გამოტოვდეს.
>>> a =
ასევე, ყველა ეს პარამეტრი შეიძლება იყოს უარყოფითი:
>>> a =
>>> a[::-1]
>>> a[-2::-1]
>>>ა
ბოლო მაგალითმა გამოიწვია ცარიელი სია, დაწყებიდან< STOP, а STEP отрицательный. То же самое произойдёт, если диапазон значений окажется за пределами объекта:
>>> a =
>>>ა
ასევე, ნაჭრების გამოყენებით, შეგიძლიათ არა მხოლოდ ელემენტების ამოღება, არამედ ელემენტების დამატება და ამოღება (რა თქმა უნდა, მხოლოდ ცვალებადი მიმდევრებისთვის).
>>> a =
>>> a =
26 10.2017
ზოგიერთი ოპერაცია საჭიროა გარკვეულ რიცხვებთან ან ფუნქციებთან ურთიერთობისთვის. ვთქვათ შეკრება, გამოკლება, გამრავლება, გაყოფა. მაგალითად არითმეტიკული ფესვიდა ექსპონენტაცია. პითონის ოპერატორებს აქვთ მნიშვნელოვანი. მათ გარეშე არ იქნებოდა პროგრამა. და ჩამოვთვალოთ ყველაფერი არსებული ოპერატორები, მონიშნულია მთელი განყოფილება.
ამ სტატიიდან თქვენ შეიტყობთ:
გამარჯობა ყველას, მკითხველს, სტუმრებს და მეგობრებს, თქვენთან ერთად არის გრიდინ სემიონი. ცოტა ხნის წინ ცოტა დავხარჯე ანონიმური გამოკითხვათქვენს აბონენტებს შორის. ჩემს მონაცემთა ბაზაში 35 ადამიანია დარეგისტრირებული. წერილების მხოლოდ ნახევარი იყო წაკითხული და გამოკითხვას მხოლოდ სამი ადამიანი გამოეხმაურა. მაგრამ იცით, ჩემთვის ეს ძალიან დიდი შედეგი. სასიამოვნოა, როცა ერთ ადგილას არ დგახარ.
მე რეალურად ბევრი იდეა და აზრი მაქვს ბლოგის განვითარებაზე. მე დიდი ხანია ვგეგმავ გავხსნა განყოფილება ხელნაკეთი პროდუქტების შესახებ, რომელიც დაფუძნებულია PLC-ზე და Raspberry PI-ზე. მე მინდა განვათავსო არა მარტო ჩემი პროექტები საიტზე. მაგრამ ასევე სხვა ავტორების პროექტები, აუცილებლად ფულადი ჯილდოსა და სოციალური მედიის პირდაპირი ბმულისთვის. ქსელები.
ასევე გავხსნი შემდეგ განყოფილებებს:
- სიახლეები რობოტიკის სფეროში;
- კვადკოპტერები;
- ბიბლიოთეკები;
- რობოტის მექანიკა;
კონკურსები, კონკურსები... ყველას უყვარს პრიზები, ბონუსები და საჩუქრები. მეც მიყვარს, თუმცა ჯერ არსად მიმიღია მონაწილეობა. მსგავსი შემთხვევა აქამდე არ მომხდარა. აუცილებლად მოვაწყობ კონკურსებს.
მე ჯერ კიდევ ვერ გავუმკლავდები პირველ პუნქტს. ხარისხიანი სტატიების წერას დრო სჭირდება. ჯერ არ არის შესაძლებელი ყველაფრის ოპტიმიზაცია და დროულად შესრულება.
ფაქტიურად ბევრი მრავალფეროვანი თემაა. თემა ძალიან მრავალმხრივი და ვრცელია. ნელ-ნელა დავფარავთ. და ამოიღეთ იგი პრაქტიკული მაგალითები. მე უფრო პრაქტიკოსი ვარ.
იცით, ძალიან სასიამოვნოა, რომ ჩემი რესურსი უსარგებლო არ არის. ძალიან სასიამოვნო გრძნობაა იმის ცოდნა, რომ ვინმეს სარგებელი მოუტანე. ეს არის ძალიან მოტივირებული იმისთვის, რომ იმუშაოთ საიტზე და გააგრძელოთ. ასევე მადლობა მეგობრებო. ვცდილობ, რომ საიტი აქტუალური იყოს რამდენიმე წლის განმავლობაში.
რა არის ოპერატორი?
ოპერატორები გაგებულია, როგორც სპეციალური რუკების და მოქმედებების რიცხვებით ან ფუნქციის სხვა ფუნქციასთან ასოცირება. ლაპარაკი მარტივი ენითგამოთქმაში 4+5 =9. ციფრებს უწოდებენ ოპერანდებს, ხოლო "+" და "=" არის ოპერატორები. აბა, რაღაც ამდაგვარი.
ენაში მათი რამდენიმე სახეობაა. ისე, როგორც ნებისმიერ სხვა ენაზე.
- არითმეტიკული ოპერატორები;
- შედარების ოპერატორები (შედარების ან ურთიერთობის ოპერატორები);
- დავალების ოპერატორები;
- ლოგიკური ოპერატორები;
- ბიტიური ოპერატორები;
- წევრობის ოპერატორები;
- პირადობის ოპერატორები.
არითმეტიკული ოპერატორები
| ოპერატორი | აღწერა | მაგალითები |
|---|---|---|
| + | დამატება - აჯამებს მნიშვნელობებს ოპერატორის მარცხნივ და მარჯვნივ | 15 + 5 შედეგი 20-ში 20 + -3 შედეგი 17-ში 13.4 + 7 შედეგი 20.4-ში |
| — | გამოკლება - აკლებს მარჯვენა ოპერანდს მარცხენა ოპერანდს | 15-5 შედეგი არის 10 20 - -3 შედეგი იქნება 23 13.4 - 7 შედეგი იქნება 6.4 |
| * | გამრავლება - ამრავლებს ოპერანდებს | 5*5 შედეგი არის 25 7 * 3.2 შედეგი იქნება 22.4 - 3 * 12 შედეგი იქნება -36 |
| / | Division - ყოფს მარცხენა ოპერანდს მარჯვენა ოპერანდზე | 15/5 შედეგი იქნება 3 5/2 იწვევს 2-ს (პითონ 2.x-ში ორი მთელი რიცხვის გაყოფა იწვევს მთელ რიცხვს) 5.0 / 2 შედეგი იქნება 2.5 („სწორი“ შედეგის მისაღებად მინიმუმ ერთი ოპერანდი უნდა იყოს float) |
| % | Modulo Division - ყოფს მარცხენა ოპერანდს მარჯვენა ოპერანდზე და აბრუნებს ნარჩენს. | 6% 2 შედეგი იქნება 0 7% 2 შედეგი იქნება 1 13.2% 5 3.2-ის შედეგად |
| ** | ექსპონენტაცია - ამაღლებს მარცხენა ოპერანდს მარჯვენა ოპერანდის ხარისხამდე | 5 ** 2 შედეგი არის 25 2 ** 3 შედეგი არის 8 - 3 ** 2 შედეგი იქნება -9 |
| // | მთელი დაყოფა - გაყოფა, რომელიც მხოლოდ ბრუნდება მთელი ნაწილიშედეგი. ათწილადის შემდეგ ნაწილი უგულვებელყოფილია. | 12 // 5 შედეგი იქნება 2 4 // 3 გამოიწვევს 1-ს 25 // 6 შედეგი არის 4 |
შედარება ოპერატორები
| ოპერატორი | აღწერა | მაგალითები |
|---|---|---|
| == | ამოწმებს არის თუ არა ორივე ოპერანდი თანაბარი. თუ კი, მაშინ პირობა ხდება ჭეშმარიტი. | 5 == 5 გამოიწვევს True-ს True == False შედეგი იქნება False "hello" == "გამარჯობა" შედეგი იქნება True |
| != | 12 != 5 შედეგი იქნება True False != False შედეგი იქნება False "hi" != "Hi" შედეგი იქნება True |
|
| <> | ამოწმებს არის თუ არა ორივე ოპერანდი თანაბარი. თუ არა, მაშინ პირობა ხდება ჭეშმარიტი. | 12 <>5 გამოიწვევს True-ს. ოპერატორს ჰგავს!= |
| > | ამოწმებს არის თუ არა მარცხენა ოპერანდის მნიშვნელობა მარჯვენა ოპერანდის მნიშვნელობაზე მეტი. თუ კი, მაშინ პირობა ხდება ჭეშმარიტი. | 5 > 2 გამოიწვევს True-ს. True > False გამოიწვევს True-ს. "A" > "B" გამოიწვევს False-ს. |
| < | ამოწმებს არის თუ არა მარცხენა ოპერანდის მნიშვნელობა მარჯვენა ოპერანდის მნიშვნელობაზე ნაკლები. თუ კი, მაშინ პირობა ხდება ჭეშმარიტი. | 3 < 5 в результате будет True. მართალია< False в результате будет False. "A"< «B» в результате будет True. |
| >= | ამოწმებს არის თუ არა მარცხენა ოპერანდის მნიშვნელობა მარჯვენა ოპერანდის მნიშვნელობაზე მეტი ან ტოლი. თუ კი, მაშინ პირობა ხდება ჭეშმარიტი. | 1 >= 1 გამოიწვევს True-ს. 23 >= 3.2 შედეგი იქნება True. "C" >= "D" გამოიწვევს False-ს. |
| <= | ამოწმებს, არის თუ არა მარცხენა ოპერანდის მნიშვნელობა მარჯვენა ოპერანდის მნიშვნელობაზე ნაკლები ან ტოლი. თუ კი, მაშინ პირობა ხდება ჭეშმარიტი. | 4 <= 5 в результате будет True. 0 <= 0.0 в результате будет True. — 0.001 <= -36 в результате будет False. |
დავალების ოპერატორები
| ოპერატორი | აღწერა | მაგალითები |
|---|---|---|
| = | ანიჭებს მარჯვენა ოპერანდის მნიშვნელობას მარცხენას. | c = 23 მიანიჭებს მნიშვნელობას 23 c ცვლადს |
| += | ამატებს მარჯვენა ოპერანდის მნიშვნელობას მარცხენა ოპერანდს და ანიჭებს ამ ჯამს მარცხენა ოპერანდს. | c = 5 a = 2 c += a უდრის: c = c + a. c იქნება 7-ის ტოლი |
| -= | გამოკლებს მარჯვენა ოპერანდის მნიშვნელობას მარცხენა ოპერანდს და შედეგს ანიჭებს მარცხენა ოპერანდს. | c = 5 a = 2 c -= a უდრის: c = c - a. c უდრის 3-ს |
| *= | ამრავლებს მარჯვენა ოპერანდს მარცხენა ოპერანდზე და შედეგს ანიჭებს მარცხენა ოპერანდს. | c = 5 a = 2 c *= a უდრის: c = c * a. c იქნება 10-ის ტოლი |
| /= | ყოფს მარცხენა ოპერანდს მარჯვენა ოპერანდზე და შედეგს ანიჭებს მარცხენა ოპერანდს. | c = 10 a = 2 c / = a უდრის: c = c / a. c იქნება 5-ის ტოლი |
| %= | ყოფს ოპერანდებს მოდულს და ანიჭებს შედეგს მარცხნივ. | c = 5 a = 2 c % = a უდრის: c = c % a. c იქნება 1-ის ტოლი |
| **= | ამაღლებს მარცხენა ოპერანდს მარჯვენა ოპერანდამდე და შედეგს ანიჭებს მარცხენა ოპერანდს. | c = 3 a = 2 c ** = a უდრის: c = c ** a. c უდრის 9-ს |
| //= | ასრულებს მარცხენა ოპერანდის მთელი რიცხვის დაყოფას მარჯვენა ოპერანდზე და შედეგს ანიჭებს მარცხენა ოპერანდს. | c = 11 a = 2 c //= a უდრის: c = c // a. c იქნება 5-ის ტოლი |
ბიტიური ოპერატორები
მათთვის, ვისაც არ უსწავლია კომპიუტერული მეცნიერების კურსები. წარმოვიდგინოთ, რომ გვაქვს ორი რიცხვი a=60 და b=13. ბინარში ისინი ასე გამოიყურებიან: a=0011 1100 და b=0000 1101.
რა შეგიძლიათ გააკეთოთ მათთან საბოლოოდ?
| ოპერატორი | აღწერა | მაგალითები |
|---|---|---|
| & | ორობითი AND ოპერატორი აკოპირებს ბიტს შედეგზე მხოლოდ იმ შემთხვევაში, თუ ბიტი ორივე ოპერანდშია. | (a & b) მოგვცემს 12-ს, რომელიც ბინარულად გამოიყურება 0000 1100 |
| | | ორობითი "OR" ოპერატორი კოპირებს ცოტას, თუ ის იმყოფება მინიმუმ ერთ ოპერანდში. | (a | b) მოგვცემს 61-ს, ორობით 0011 1101-ში |
| ^ | ორობითი "Exclusive OR" ოპერატორი აკოპირებს ბიტს მხოლოდ იმ შემთხვევაში, თუ ბიტი არის ერთ-ერთ ოპერანდში, მაგრამ არა ორივეში. | (a^b) მოგვცემს 49-ს, ორობით 0011 0001-ში |
| ~ | ორობითი დამატებითი ოპერატორი. ის არის უნარი (ანუ სჭირდება მხოლოდ ერთი ოპერანდი) და ცვლის ბიტებს საპირისპიროდ, სადაც იყო ერთი, რომ გახდეს ნული და პირიქით. | (~a) გამოიწვევს -61, რომელიც ორობითად გამოიყურება 1100 0011. |
| << | ბიტური გადაადგილება მარცხნივ. მარცხენა ოპერანდის მნიშვნელობა „გადაინაცვლებს“ მარცხნივ მარჯვენა ოპერანდში მითითებული ბიტების რაოდენობის მიხედვით. | ა<< 2 в результате даст 240, в двоичном формате 1111 0000 |
| >> | ბიტალურად გადაიტანეთ მარჯვნივ. მარცხენა ოპერანდის მნიშვნელობა მარჯვენა ოპერანდში მითითებული ბიტების რაოდენობის მიხედვით „გადაინაცვლებს“ მარჯვნივ. | a >> 2 იძლევა 15-ს, ბინარულ 0000 1111-ში |
ლოგიკური ოპერატორები
წევრობის ოპერატორები
ეს ოპერატორები საჭიროა კომპოზიტებში ცალკეული ელემენტების შესამოწმებლად (სტრიქონები, ტოპები, სიები და ლექსიკონები)
პირადობის ოპერატორები
ოპერატორის უპირატესობა
| ოპერატორი | აღწერა |
|---|---|
| ** | ექსპონენტაცია |
| ~ + — | დამატებითი ოპერატორი |
| * / % // | გამრავლება, გაყოფა, მოდულო გაყოფა, მთელი რიცხვის გაყოფა. |
| + — | შეკრება და გამოკლება. |
| >> << | ბიტით გადაინაცვლეთ მარჯვნივ და ბიტით გადაინაცვლეთ მარცხნივ. |
| & | ორობითი "მე". |
| ^ | | ორობითი "ექსკლუზიური OR" და ორობითი "OR" |
| <= < > >= | შედარება ოპერატორები |
| <> == != | თანასწორობის ოპერატორები |
| = %= /= //= -= += *= **= | დავალების ოპერატორები |
| არ არის | პირადობის ოპერატორები |
| არაში | წევრობის ოპერატორები |
| არა ან და | ლოგიკური ოპერატორები |
აქ არის ოპერატორების მცირე ჩამონათვალი. დაე, ეს გვერდი იყოს შენიშვნა თქვენთვის პროგრამირებისას პითონის ენა.
ცოტა ხნის წინ ვიყიდე წიგნი I.V. პეტროვა ”პროგრამირებადი კონტროლერები შიგნით ავტომატური სისტემები" რადგან, როგორც ჩანს, ბევრს ვწერ, მაგრამ მაინც არ ვგრძნობ თავს პროფესიონალად:
ერთხელ ვიყავი დანებებისა და ჩემი პროექტის დატოვების ზღვარზე. რაღაცის გაკეთების მოტივაციას ვეძებდი. აზრს ვეძებდი ჩემს ყველა მოქმედებაში, ვფიქრობდი, რა მომცემს საბოლოოდ შედეგს? და ისევ ვეძებდი მოტივაციას...
რატომ ვაკეთებ ამას, ახლა ისევ სულელურად ვაჭერ კლავიატურას და ვუყურებ მონიტორს. და ისევ დავწერე სტატია, ვწერდი ამ სტრიქონებს, ხანდახან არ ვიცოდი რატომ და რატომ, სად მიმიყვანს ეს საბოლოოდ?
დიახ, მიჭირს, დიახ, ბევრ რამეში ვახერხებ. მაგრამ ჩვენ უნდა ვებრძოლოთ ამას.
თქვენ იცით, თქვენ უნდა მიიღოთ მღელვარება იმით, რასაც აკეთებთ, ჩვენ მაინც მხოლოდ ერთხელ ვცხოვრობთ.
კიდევ ერთხელ მოტივაციის შესახებ, ნახეთ რას ამბობს ჯორჯ კარლინი ამის შესახებ, ბოდიში უხამსობისთვის.
პატივისცემით, გრიდინ სემიონი
თითოეულ ოპერაციას აქვს საკუთარი ოპერატორი. უნიარში და ორობითი ოპერაციებივრცელდება ძირითადი ოპერატორები(შეკრება, გამოკლება, უარყოფა, ერთიანი პლუსი, ერთიანი მინუსი, მინიჭება). Trinary-ს აქვს სამი არგუმენტი: if პირობა, გამოხატულება, თუ პირობა == true, და გამოხატულება, თუ პირობა == false.
შემდეგი მაგალითი დაგეხმარებათ გაიგოთ რა არის ოპერატორი.
A = b + c
c ემატება b ცვლადს და შედეგი ენიჭება a ცვლადს. მთელი მაგალითი მთლიანობაში a = b + c არის გამოხატულება. ცვლადები, რომლებიც მასში ჩნდება, არის ოპერანდები. შესრულებული ოპერაცია არის დამატება და ამისათვის გამოყენებული ოპერატორი არის "+".
პითონის არითმეტიკული ოპერატორები
Python უზრუნველყოფს უზარმაზარი თანხაბიბლიოთეკები გადაწყვეტისთვის გამოთვლითი ამოცანები. დიდი ნაკრებიმეთოდები Python-ს Matlab-სა და Octave-ს თანაბარ მდგომარეობაში აყენებს. არითმეტიკული მოქმედებებივრცელდება შედარებით მთელ რიცხვებზე აკრიფეთ int, რეალური ტიპიმცურავი, რთული კომპლექსი.
თუ მხოლოდ მთელი რიცხვები გამოიყენება ოპერაციის არგუმენტებად, შედეგი ასევე იქნება მთელი რიცხვი. ოპერაციები მცურავი წერტილის რიცხვებს შორის გამოიწვევს მთელ რიცხვს და წილადს. ერთადერთი ოპერაცია, რომელშიც მთელი რიცხვების ურთიერთქმედება წარმოქმნის წილადს, არის გაყოფა.
ყველა შესაძლო არითმეტიკული ოპერაცია მოცემულია ცხრილში.
ერთი ნომრის მეორეზე დამატება ხორციელდება დამატებითი ოპერატორის მიერ. გამოკლება ხდება გამოკლების გამოყენებით. ერთი რიცხვის მეორეზე გამრავლება ხდება გამრავლებით. ექსპონენტაცია ხდება ექსპონენტის გამოყენებით. განყოფილება გამოიყენება გაყოფისთვის.
მოდული (%) ოპერატორი აბრუნებს ნარჩენს, როდესაც მარცხენა ოპერანდი იყოფა მარჯვენა ოპერანდზე. თუ ცვლადი a = 10, ცვლადი b = 20, მაშინ b%a == 0. რა არის გაყოფის ოპერატორი ნაშთით, ადვილად გასაგებია შემდეგი მაგალითის გამოყენებით. თუ 9/2 == 4.5, მაშინ 9//2 აბრუნებს 4-ის შედეგს. გაყოფა სართულის გაყოფით (//) აბრუნებს მთელ რიცხვს მარცხენა ოპერანდის მარჯვენა ოპერანდზე გაყოფის ოპერაციიდან.
ნებისმიერი ოპერაციები ხორციელდება უშუალოდ თავად ნომრებით ან ცვლადებით, რომლებსაც ისინი ენიჭებათ რიცხვითი მნიშვნელობები. შედეგი შეიძლება იყოს სხვა ცვლადი ან ერთ-ერთი არსებული.
ერთად მთელი და რეალური რიცხვებიპითონში არის რთული რიცხვები. ისინი შედგება რეალური და წარმოსახვითი ნაწილისგან. დაწერილია c = a+bj სახით, სადაც a არის რეალური ნაწილი,
C.real() #a
ბ - წარმოსახვითი.
C.imag() #ბ
რთული რიცხვებით არითმეტიკულ მოქმედებებს აქვთ იგივე თვისებები, რაც რეალურ რიცხვებს. რთული რიცხვების გამოყენება შეიძლება წარმოდგენილი იყოს მართკუთხა კოორდინატთა სისტემით სიბრტყეზე. X ღერძისა და Y ღერძის გადაკვეთის a წერტილი შეესაბამება რთული რიცხვი x + yi. ამრიგად, X-ღერძი შეიცავს რეალურ რიცხვებს, ხოლო ვერტიკალური Y-ღერძი შეიცავს წარმოსახვით რიცხვებს.
შედარება
ოპერატორები პითონში გამოიყენება ცვლადების შესადარებლად. გარდა სტანდარტებისა, რომლებიც ცნობილია მათემატიკური ამოცანები, არის მნიშვნელობისა და ტიპის შემოწმება, ასევე უთანასწორობის შემოწმება.
შედარების ოპერაციები ხორციელდება x b სახით, სადაც x არის შედარების ოპერატორი.
პროგრამირებაში „=“ ოპერატორი განსხვავებულად მუშაობს, ვიდრე მათემატიკაში. თითოეული არგუმენტის შესაბამის მნიშვნელობას განსაზღვრავს „==“ ოპერატორი, მაგრამ „=“ მხოლოდ მნიშვნელობას ანიჭებს. !=-ის გამოყენებით ამოწმებს ცვლადების უტოლობას. ეს ოპერატორი შეიძლება შეიცვალოს როგორც "<>”, რომელიც არ არის სტანდარტული ოპერატორი სხვა ენებზე, როგორიცაა C, Java ან Javascript.
დავალება
პითონის განცხადებები ცვლადს მნიშვნელობას ანიჭებს.
დავალება პროგრამირების ერთ-ერთი ცენტრალური კონსტრუქციაა. მისი დახმარებით ცვლადებს ეძლევათ გარკვეული მნიშვნელობები, რომლებიც შეიძლება შეიცვალოს პროგრამის მსვლელობისას.
მუშაობის ალგორითმი:
- მარცხენა ღირებულების გაანგარიშება;
- მარჯვენა ხელის ღირებულების გაანგარიშება;
- ერთი მნიშვნელობის მეორისთვის მინიჭება - ტიპებს შორის კონფლიქტის შემთხვევაში, ისინი უნდა გადაიტანონ;
- დააბრუნეთ ოპერაციის შედეგი - ჭეშმარიტი ან მცდარი.
და მათემატიკური ოპერაციები მუშაობს ამ პრინციპის მიხედვით:
a x b, სადაც x არის ოპერატორი, ნიშნავს, რომ a = a x b. ამრიგად, a += b ამბობს, რომ a ცვლადის მნიშვნელობა ემატება b ცვლადის მნიშვნელობას და მათი შედეგი ენიჭება a ცვლადს. იგივე ხდება სხვა მაგალითებზეც. მაგალითად, a **= b არის გაშიფრული, როგორც a = a ** b, ანუ, a ამაღლებულია b-ის ხარისხზე, შედეგი საბოლოოდ ენიჭება a-ს.
პირობები
მდგომარეობის ტესტირება ხდება პითონის სამჯერადი ოპერატორის გამოყენებით.
იგი შედგება ორი ან სამი ნაწილისგან:
- if - შესამოწმებელი გამოხატულება;
- elif - არჩევითი ინსტრუქცია (მსგავსი if else ან elseif);
- სხვა არის მთავარი ინსტრუქცია.
გამოთქმა შეიძლება განისაზღვროს ერთ სტრიქონში.
A = Y თუ X სხვა Z
სხვა და სხვა ნაწილების გაუქმება შესაძლებელია, გამოთქმა ასე გამოიყურება:
თუ 1: ბეჭდვა ("გამარჯობა 1")
პითონში არის შესვენების განცხადებებიდა გააგრძელე. Break წყვეტს კოდის შესრულებას ყველა დონეზე. Continue აჩერებს მიმდინარე გამეორებას და აგრძელებს შესრულებას შემდეგი წერტილიდან.
ბიტალურად
ასეთი პითონის ოპერატორები თავიანთ ოპერანდებს განმარტავენ, როგორც ნულების და ერთების თანმიმდევრობას.
ისინი ციფრებს იყენებენ ორობითი წარმოდგენა, დააბრუნეთ შედეგი 32-ბიტიანი რიცხვის სახით.
a = 0 #a = 1 #a = 2 #a = 3 #a = 255 #
ბინარში უარყოფითი რიცხვი მიიღება ბიტის შებრუნებით და 1-ის მიმატებით.
314 #-314 #+ 1 =
განსხვავება >> b-სა და a >>> b-ს შორის არის ის, რომ მარჯვენა მნიშვნელობების გადატანისა და გაუქმებისას, პირველი ბიტების ასლები ემატება მარცხნივ.
9 #9 >> 2 #-9 #-9 >> 2 #
მაგრამ >>> b-ით მარცხენა მნიშვნელობები შეივსება ნულებით.
9 #-9 >>> 2 #
ლოგიკური
სულ სამი ლოგიკური ოპერატორია.
- და - აბრუნებს ჭეშმარიტებას, თუ a == b == x;
- ან - აბრუნებს true არის a == x ან b == x;
- not - აბრუნებს false-ს, თუ a == b == x.
კუთვნილება
წევრობის ოპერატორი ამოწმებს თუ არა ცვლადი ნაწილიგარკვეული თანმიმდევრობა.
- a b-ში აბრუნებს true, თუ ის აღმოაჩენს ცვლადს a-ს მიმდევრობით b;
- a not in b აბრუნებს ჭეშმარიტს, თუ ის ვერ პოულობს a ცვლადს b მიმდევრობაში.
იდენტობა
- a არის b აბრუნებს true, თუ ცვლადები მარჯვნივ და მარცხნივ მიუთითებს იმავე ობიექტზე;
- a არ არის b აბრუნებს true თუ ცვლადები არ მიუთითებენ იმავე ობიექტზე.
პრიორიტეტები
სია შეიცავს ოპერატორებს და გამონათქვამებს, რომლებიც დალაგებულია შესრულების პრიორიტეტების მიხედვით ყველაზე დაბალიდან ყველაზე მაღალი.
ოპერატორები პითონში და მათი შესრულების პრიორიტეტი:
- ლამბდა გამონათქვამები.
- პითონი.
- ლოგიკური OR.
- ბული ი.
- ლოგიკური არა.
- პირადობის ოპერატორები, წევრობა, დავალების ოპერატორები.
- ბიტი ან.
- ბიტალურად არა.
- ბიტოვი ი.
- ბიტი ოპერატორიბიტის ცვლა.
- შეკრება და გამოკლება.
- გამრავლება და გაყოფა, გაყოფისა და მთელი რიცხვების ნაშთის მიღების ოპერაციის ჩათვლით.
- ბიტალურად არა.
- ექსპონენტაცია.
- მასივის ელემენტზე წვდომა ინდექსით, დაჭრა, კლასის ობიექტზე წვდომა, ფუნქციის გამოძახება არგუმენტებით.
სიის პირველი ელემენტი არის ლამბდა გამოხატვა. ლამბდა გამოხატვა გამოიყენება ანონიმური ფუნქციების შესაქმნელად. ლამბდა ისე იქცევა ნორმალური ფუნქცია, და გამოცხადებულია ფორმაში
დეფ
ლამბდა გამოხატვის შემდეგ არის პითონის სამჯერადი ოპერატორის მიერ შესრულებული ოპერაციები.
სიის ბოლოს არის მასივების და ფუნქციების მანიპულირების მეთოდები. მასივის ელემენტზე წვდომა ინდექსით ასე გამოიყურება:
ამ შემთხვევაში, a არის მასივი, i არის ელემენტის ინდექსი.
დაჭრა ნიშნავს მასივის სრული ასლის ან სიის წევრების შერჩევითი თანმიმდევრობის გადაცემას. სასურველი მნიშვნელობების დიაპაზონი მითითებულია. როგორც არგუმენტები, x არის საწყისი, y არის დასასრული და z არის მასივის ელემენტების გავლის საფეხური ყოველი გამეორებისას. ნაგულისხმევად X აღნიშნავს სიის დასაწყისს, y დასასრულს და z უდრის ერთს. თუ თქვენ მიუთითებთ z როგორც უარყოფითი რიცხვი, სიის მნიშვნელობები გადაეცემა საპირისპირო მიზნითბოლოდან დასაწყისამდე.
- თარგმანი
სტატიის ეს ნაწილი მოიცავს ხრიკებს, რომ აირჩიოთ ორი მნიშვნელობიდან ერთ-ერთი ლოგიკური მდგომარეობაფუნქციის არგუმენტების თვითნებური რაოდენობის გადაცემა და მიღება და შეცდომის საერთო წყაროა ის ფაქტი, რომ ფუნქციის არგუმენტების ნაგულისხმევი მნიშვნელობები ფასდება მხოლოდ ერთხელ.
4. მნიშვნელობების შერჩევა
4.1. სწორი გზა
2.5 ვერსიიდან, პითონი მხარს უჭერს "value_if_true" სინტაქსს თუტესტი სხვამნიშვნელობა_თუ_მცდარი". ამ გზით თქვენ შეგიძლიათ აირჩიოთ ორ მნიშვნელობას შორის უცნაური სინტაქსის გამოყენების გარეშე და დეტალური განმარტებები:ტესტი = მართალია # ტესტი = მცდარი შედეგი = "ტესტი მართალია" თუ სხვა ტესტი "ტესტი მცდარია" # შედეგი = "ტესტი მართალია"
ვაი, მაინც ცოტა მახინჯია. თქვენ ასევე შეგიძლიათ გამოიყენოთ რამდენიმე ეს კონსტრუქცია ერთ ხაზზე:
test1 = False test2 = True შედეგი = "Test1 is True" თუ test1 else "Test1 is False, test2 is True" თუ test2 else "Test1 და Test2 ორივე მცდარია"
პირველი if/else შესრულებულია პირველი და თუ test1 = false, მეორე if/else შესრულებულია. თქვენ შეგიძლიათ გააკეთოთ უფრო რთული საქმეები, განსაკუთრებით თუ იყენებთ ფრჩხილებს.
ეს მეთოდი საკმაოდ ახალია და მის მიმართ არაერთგვაროვანი გრძნობები მაქვს. ეს კარგი, სუფთა დიზაინია და მომწონს... მაგრამ მაინც მახინჯია, განსაკუთრებით მაშინ, როცა მრავალჯერადი წყობილი კონსტრუქცია გამოიყენება. რა თქმა უნდა, მნიშვნელობების შერჩევის ყველა ხრიკის სინტაქსი მახინჯია. მე მაქვს ქვემოთ მოცემული და/ან მეთოდისთვის რბილი წერტილი, ახლა მე ეს ინტუიციურად მიმაჩნია, ახლა მესმის, როგორ მუშაობს. უფრო მეტიც, ის არანაკლებ ეფექტურია, ვიდრე "სწორი" მეთოდი.
მიუხედავად იმისა, რომ inline if/else ახალია, მეტი სწორი გზა, თქვენ მაინც უნდა შეამოწმოთ შემდეგი პუნქტები. მაშინაც კი, თუ თქვენ აპირებთ Python 2.5-ის გამოყენებას, თქვენ ნახავთ ამ ტექნიკას ძველ კოდში. რა თქმა უნდა, თუ საჭიროა ჩამორჩენილი თავსებადობა, ნამდვილად უკეთესი იქნება მათი გადახედვა.
4.2. ხრიკი და/ან
"და" და "ან" პითონში - რთული არსებები. გამოყენება და მრავალ გამონათქვამზე უბრალოდ არ აბრუნებს True ან False. ის აბრუნებს პირველ ცრუ გამონათქვამს, ან ბოლო გამონათქვამებს, თუ ისინი ყველა მართალია. შედეგი ისეთივეა, როგორც მოსალოდნელია: თუ ყველა გამონათქვამი არის true, ბოლო, რომელიც არის true, ბრუნდება; თუ რომელიმე მათგანი false-ია, ის ბრუნდება და გარდაიქმნება False-ში ლოგიკური მნიშვნელობის ტესტირებისას.ანალოგიურად, ან ოპერაცია აბრუნებს პირველ ნამდვილ მნიშვნელობას, ან უკანასკნელს, თუ არცერთი არ არის ჭეშმარიტი.
ეს არ გამოგადგებათ, თუ უბრალოდ ამოწმებთ გამოხატვის ლოგიკურ მნიშვნელობას. მაგრამ თქვენ შეგიძლიათ გამოიყენოთ და და ან სხვა მიზნებისთვის. ჩემი საყვარელი გზა არის მნიშვნელობის შერჩევა სტილში, რომელიც მსგავსია C სამეული ოპერატორის "test? value_if_true: value_if_false":
test = True # test = False შედეგი = ტესტი და "Test is True" ან "Test is False" # now result = "ტესტი მართალია"
როგორ მუშაობს ეს? თუ test=true, და ოპერატორი გამოტოვებს მას და აბრუნებს მისთვის მიცემულ მეორე (ბოლო) მნიშვნელობას: "Test is True" ან"ტესტი მცდარია". შემდეგი, ან დააბრუნებს პირველ ჭეშმარიტ გამონათქვამს, ანუ "ტესტი მართალია".
თუ test=false და აბრუნებს ტესტს, ეს ტოვებს ტესტს ან"ტესტი მცდარია". იმის გამო, რომ test=false, ან გამოტოვებს და დააბრუნებს მეორე გამოთქმას, "ტესტი მცდარია".
გაფრთხილება, ფრთხილად იყავით საშუალო მნიშვნელობასთან ("if_true"). თუ ის ყალბია, გამონათქვამი ან ყოველთვის გამოტოვებს მას და დააბრუნებს ბოლო მნიშვნელობას ("if_false"), ტესტის მნიშვნელობის მიუხედავად.
ამ მეთოდის გამოყენების შემდეგ, სწორი გზა (ნაწილი 4.1) ნაკლებად ინტუიციური მეჩვენება. თუ არ გჭირდებათ უკანა თავსებადობა, სცადეთ ორივე მეთოდი და ნახეთ რომელი მოგწონთ საუკეთესოდ. თუ ვერ გადაწყვეტთ, გამოიყენეთ სწორი.
რა თქმა უნდა, თუ თქვენ გჭირდებათ თავსებადობა წინა ვერსიებიპითონი, "სწორი" გზა არ იმუშავებს. ამ შემთხვევაში და/ან - საუკეთესო არჩევანიუმეტეს სიტუაციებში.
4.3. მართალია/მცდარი, როგორც ინდექსები
ორ მნიშვნელობას შორის არჩევის კიდევ ერთი გზაა სიის ინდექსებად True და False გამოყენება, იმის გათვალისწინებით, რომ False == 0 და True == 1:test = True # test = False შედეგი = ["ტესტი მცდარია", "ტესტი მართალია"] # now result = "ტესტი მართალია"
ეს მეთოდი უფრო გულწრფელია და value_if_true არ უნდა იყოს ჭეშმარიტი. თუმცა მას აქვს მნიშვნელოვანი ნაკლი: სიის ორივე ელემენტი ფასდება ტესტირებამდე. სიმებიანი და სხვებისთვის მარტივი ელემენტებიეს არ არის პრობლემა. მაგრამ თუ თითოეული მათგანი მოითხოვს დიდ გამოთვლებს ან I/O ოპერაციებს, ორივე გამოხატვის შეფასება მიუღებელია. ამიტომ მირჩევნია რეგულარული მშენებლობა ან/და.
ასევე გაითვალისწინეთ, რომ ეს მეთოდი მუშაობს მხოლოდ მაშინ, როდესაც დარწმუნებული ხართ, რომ ეს ტესტია ლოგიკური მნიშვნელობა, და არა რაიმე ობიექტი. წინააღმდეგ შემთხვევაში, თქვენ უნდა დაწეროთ bool(test) ტესტის ნაცვლად, რომ სწორად იმუშაოს.
5. ფუნქციები
5.1. არგუმენტების ნაგულისხმევი მნიშვნელობები ფასდება მხოლოდ ერთხელ
დავიწყოთ ეს განყოფილება გაფრთხილებით. ამ პრობლემამ არაერთხელ დააბნია ბევრი პროგრამისტი, მათ შორის მეც, მას შემდეგაც კი, რაც პრობლემა გავარკვიე. შეცდომის დაშვება მარტივია ნაგულისხმევი მნიშვნელობების გამოყენებით:def ფუნქცია(item, stuff =): stuff.append(item) print stuff function(1) # prints "" function(2) # prints "" !!!
არგუმენტების ნაგულისხმევი მნიშვნელობები ფასდება მხოლოდ ერთხელ, ფუნქციის განსაზღვრის დროს. Python უბრალოდ ანიჭებს ამ მნიშვნელობას სასურველ ცვლადს ყოველ ჯერზე ფუნქციის გამოძახებისას. თუმცა, ის არ ამოწმებს შეიცვალა თუ არა ეს მნიშვნელობა. ასე რომ, თუ შეცვლით, ცვლილება ძალაში შევა ფუნქციის მომავალ ზარებში. წინა მაგალითში, როდესაც ჩვენ დავამატეთ მნიშვნელობა პერსონალის სიას, ჩვენ სამუდამოდ შევცვალეთ მისი ნაგულისხმევი მნიშვნელობა. როდესაც ფუნქციის ხელახლა გამოძახებას ველოდებით ნაგულისხმევ მნიშვნელობას, ვიღებთ შეცვლილს.
გამოსავალი: არ გამოიყენოთ ცვალებადი ობიექტები ნაგულისხმევ მნიშვნელობებად. თქვენ შეგიძლიათ დატოვოთ ყველაფერი ისე, როგორც არის, თუ არ შეცვლით მათ, მაგრამ ეს ცუდი იდეა. აი, როგორ უნდა დაიწეროს წინა მაგალითი:
def ფუნქცია(item, stuff = None): if stuff is None: stuff = stuff.append(item) print stuff function(1) # prints "" function(2) # prints "" როგორც მოსალოდნელია
არცერთი არ არის უცვლელი (ჩვენ არ ვცდილობთ მის შეცვლას მაინც), ასე რომ, ჩვენ დაცული ვართ ნაგულისხმევი მნიშვნელობის მოულოდნელი ცვლილებისგან.
მეორე მხარეს, ჭკვიანი პროგრამისტიეს ალბათ გადააქცევს ხრიკს სტატიკური ცვლადების გამოყენებისთვის, როგორიცაა C.
5.1.1. ჩვენ ვაიძულებთ ნაგულისხმევი მნიშვნელობების გამოთვლას ყოველ ჯერზე
თუ არ გსურთ თქვენი ფუნქციის კოდში ზედმეტი არეულობის დამატება, შეგიძლიათ თარჯიმანს ხელახლა გამოთვალოს არგუმენტების მნიშვნელობები ყოველი ზარის წინ. შემდეგი დეკორატორი აკეთებს ამას:ასლის იმპორტიდან deepcopy def resetDefaults(f): ნაგულისხმევი = f.func_defaults def resetter(*args, **kwds): f.func_defaults = deepcopy(defaults) აბრუნებს f(*args, **kwds) resetter.__name__ = f. __name__ დაბრუნების გადატვირთვა
უბრალოდ გამოიყენეთ ეს დეკორატორი ფუნქციაზე, რომ მიიღოთ მოსალოდნელი შედეგი:
@resetDefaults # ასე ვიყენებთ დეკორატორის def ფუნქციას(item, stuff =): stuff.append(item) print stuff function(1) # prints "" function(2) # prints "" როგორც მოსალოდნელი იყო
5.2. არგუმენტების ცვლადი რაოდენობა
პითონი საშუალებას გაძლევთ გამოიყენოთ არგუმენტების თვითნებური რაოდენობა ფუნქციებში. ჯერ განსაზღვრულია საჭირო არგუმენტები (ასეთის არსებობის შემთხვევაში), შემდეგ უნდა იყოს მითითებული ცვლადი ვარსკვლავით. პითონი მას მიანიჭებს დარჩენილი (უსახელო) არგუმენტების სიის მნიშვნელობას:def do_something(a, b, c, *args): print a, b, c, args do_something(1,2,3,4,5,6,7,8,9) # ბეჭდავს "1, 2, 3, (4, 5, 6, 7, 8, 9)"
რატომ არის ეს საჭირო? მაგალითად, ფუნქციამ უნდა მიიღოს რამდენიმე ელემენტი და იგივე გააკეთოს მათთან (მაგალითად, დამატება). შეგიძლიათ აიძულოთ მომხმარებელი გადასცეს სია ფუნქციას: sum_all(). ან შეგიძლიათ დაუშვათ არგუმენტების თვითნებური რაოდენობის გადაცემა, შემდეგ მიიღებთ უფრო სუფთა კოდს: sum_all(1,2,3).
ფუნქციასაც შეიძლება ჰქონდეს ცვლადი ნომერიდასახელებული არგუმენტები. ყველა სხვა არგუმენტის განსაზღვრის შემდეგ, მიუთითეთ ცვლადი „**“-ით დასაწყისში. Python მიანიჭებს ამ ცვლადს მიღებული დასახელებული არგუმენტების ლექსიკონს, საჭიროების გამოკლებით:
def do_something_else(a, b, c, *args, **kwargs): ამობეჭდვა a, b, c, args, kwargs do_something_else(1,2,3,4,5,6,7,8,9, დროის ამოწურვა=1.5 ) # გამომავალი "1, 2, 3, (4, 5, 6, 7, 8, 9), ("ტაიმი": 1.5)"
რატომ აკეთებ ამას? მე ვფიქრობ, რომ ყველაზე გავრცელებული მიზეზი არის ის, რომ ფუნქცია არის სხვა ფუნქციის (ან ფუნქციების) შეფუთვა და გამოუყენებელი დასახელებული არგუმენტები შეიძლება გადაეცეს სხვა ფუნქციას (იხ. სექცია 5.3).
5.2.1. დაზუსტება
დასახელებული არგუმენტების და მათ შემდეგ რეგულარული არგუმენტების თვითნებური რაოდენობის გამოყენება, როგორც ჩანს, შეუძლებელია, რადგან დასახელებული არგუმენტები უნდა განისაზღვროს "*" პარამეტრამდე. მაგალითად, წარმოიდგინეთ ფუნქცია:def do_something(a, b, c, actual_print = True, *args): if actual_print: print a, b, c, args
ჩვენ გვაქვს პრობლემა: ჩვენ ვერ შევძლებთ რეალურად_print გადავიტანოთ დასახელებულ არგუმენტად, თუ რამდენიმე უსახელო არგუმენტის გადაცემა დაგვჭირდება. ორივე შემდეგი ვარიანტი გამოიწვევს შეცდომას:
do_something(1, 2, 3, 4, 5, actual_print = True) # fact_print ჯერ დაყენებულია 4-ზე (ნახე რატომ?) და შემდეგ # overrided, გაზრდის TypeError-ს ("მიიღეს მრავალი მნიშვნელობა საკვანძო სიტყვის არგუმენტისთვის") do_something( 1, 2, 3, fact_print = True, 4, 5, 6) # დასახელებული არგუმენტები არ შეიძლება უსწრებდეს ჩვეულებრივს. ხდება სინტაქსის შეცდომა. ამ სიტუაციაში რეალურად_ბეჭდვის დაყენების ერთადერთი გზა არის მისი რეგულარული არგუმენტად გადაცემა: do_something(1, 2, 3, True, 4, 5, 6) # შედეგი: "1, 2, 3, (4, 5, 6 )"
ამ სიტუაციაში fact_print-ის დაყენების ერთადერთი გზა არის მისი ჩვეულებრივი არგუმენტის გადაცემა:
do_something(1, 2, 3, True, 4, 5, 6) # შედეგი: "1, 2, 3, (4, 5, 6)"
5.3. სიის ან ლექსიკონის გადაცემა მრავალი არგუმენტის სახით
ვინაიდან თქვენ შეგიძლიათ მიიღოთ მიღებული არგუმენტები სიის ან ლექსიკონის სახით, გასაკვირი არ არის, რომ თქვენ ასევე შეგიძლიათ გადასცეთ ფუნქციის არგუმენტები სიიდან ან ლექსიკონიდან. სინტაქსი ზუსტად იგივეა, რაც წინა აბზაცში, თქვენ უნდა დააყენოთ ვარსკვლავი სიის წინ:args = pow(*args) # აბრუნებს pow(5,2), ანუ 25
ხოლო ლექსიკონისთვის (რომელიც უფრო ხშირად გამოიყენება) თქვენ უნდა დააყენოთ ორი ვარსკვლავი:
def do_something(actually_do_something=True, print_a_bunch_of_numbers=False): if actually_do_something: print "რაღაც ყოფილა done" # if print_a_bunch_of_numbers: print range(10) kwargs = ("actually_do_do_something": True, "print_a_bunch_of_numbers": True) do_something(**kwargs) # ბეჭდავს "რაღაც გაკეთდა", შემდეგ ""
ისტორიული შენიშვნა: Python-ში 2.3 ვერსიამდე, ამ მიზნით გამოიყენებოდა ჩაშენებული ფუნქცია application (ფუნქცია, arg_list, საკვანძო სიტყვა_arg_dict).
ხშირად შიგნით რეალური ცხოვრებაჩვენ ვეთანხმებით ან უარვყოფთ განცხადებას. მაგალითად, თუ ისინი გეტყვიან, რომ 3 და 5 რიცხვების ჯამი 7-ზე მეტია, თქვენ დაეთანხმებით და იტყვით: „დიახ, ეს მართალია“. თუ ვინმე ამტკიცებს, რომ სამი და ხუთის ჯამი შვიდზე ნაკლებია, მაშინ ასეთ განცხადებას მცდარად ჩათვლით.
ასეთი ფრაზები მხოლოდ ორ შესაძლო პასუხს გვთავაზობს - ან "დიახ", როდესაც განცხადება ფასდება როგორც ჭეშმარიტი, ან "არა", როდესაც განცხადება შეფასებულია როგორც მცდარი, მცდარი. პროგრამირებასა და მათემატიკაში, თუ გამოხატვის შეფასების შედეგი შეიძლება იყოს მხოლოდ ჭეშმარიტი ან მცდარი, მაშინ ასეთ გამონათქვამს ლოგიკური ეწოდება.
მაგალითად, გამონათქვამი 4 > 5 არის ლოგიკური გამოხატულება, რადგან მისი შედეგი არის ჭეშმარიტი ან მცდარი. გამოთქმა 4 + 5 არ არის ლოგიკური გამოხატულება, რადგან მისი შედეგი არის რიცხვი.
წინა გაკვეთილზე გავეცანით სამი სახის მონაცემს - მთელ და ნამდვილ რიცხვებს, ასევე სტრიქონებს. დღეს გაგაცნობთ მეოთხეს - ლოგიკური ტიპიმონაცემები(ბულის ტიპი). მას ასევე უწოდებენ ლოგიკურს. ამ ტიპს აქვს მხოლოდ ორი შესაძლო მნიშვნელობა: მართალია(მართალია) და ყალბი(ტყუილი).
>>> a = მართალია
>>> ტიპი (a)
აქ ცვლადი a მინიჭებულია ღირებულება True, რის შემდეგაც გამოყენებით ჩაშენებული პითონის ფუნქციები type() ამოწმებს მის ტიპს. თარჯიმანი იტყობინება, რომ ეს არის bool კლასის ცვლადი. "კლასი" და "მონაცემთა ტიპი" ცნებები ამ შემთხვევაშიერთი და იგივე. ცვლადი b ასევე ასოცირდება ლოგიკურ მნიშვნელობასთან.
პროგრამირებისას, False ჩვეულებრივ ტოლდება ნულთან და True ერთთან. ამის დასადასტურებლად, შეგიძლიათ გადაიყვანოთ ლოგიკური მნიშვნელობა მთელი ტიპი:
>>> int (მართალია) 1 >>> int (მცდარი) 0
საპირისპიროც შესაძლებელია. თქვენ შეგიძლიათ გადაიყვანოთ ნებისმიერი მნიშვნელობა ლოგიკურ ტიპად:
>>> bool (3.4)მართალია >>> ბული (-150 )მართალია >>> bool (0)ყალბი >>> bool (" ")მართალია >>> bool ("" )ყალბი
და აქ მოქმედებს წესი: ყველაფერი, რაც არ არის 0 და არა სიცარიელე, მართალია.
ლოგიკური ოპერატორები
ბუნებრივ ენაზე საუბრისას (მაგალითად, რუსული), ჩვენ აღვნიშნავთ შედარებებს სიტყვებთან "თანაბარი", "მეტი", "ნაკლები". პროგრამირების ენების გამოყენება სპეციალური ნიშნები, მსგავსი თემები, რომლებიც გამოიყენება მათემატიკაში: > (მეტი),< (меньше), >= (უფრო მეტი ან ტოლი),<= (меньше или равно), == (равно), != (не равно).
არ აურიოთ დავალების ოპერაცია, რომელიც წარმოდგენილია პითონში ერთი "ტოლი" ნიშნით, შედარების ოპერაციასთან (ორი "ტოლი" ნიშანი). მინიჭება და შედარება სხვადასხვა ოპერაციებია.
>>> a = 10 >>> b = 5 >>> a + b > 14მართალია >>> ა< 14 - b ყალბი >>> ა<= b + 5 მართალია >>> a != ბმართალია >>> a == ბყალბი >>> c = a == ბ >>> a, b, c(10, 5, მცდარი)
IN ამ მაგალითშიგამოხატულება გ = a == ბშედგება ორი ქვეგამოთქმისგან. პირველ რიგში, ხდება a და b ცვლადების შედარება (==). ლოგიკური ოპერაციის შედეგი შემდეგ ენიჭება c ცვლადს. გამოთქმა ა ,ბ,გუბრალოდ აჩვენებს ცვლადების მნიშვნელობებს ეკრანზე.
რთული ლოგიკური გამონათქვამები
ლოგიკური გამონათქვამები, როგორიცაა kByte >= 1023, მარტივია, რადგან ისინი მხოლოდ ერთს ასრულებენ ლოგიკური ოპერაცია. თუმცა, პრაქტიკაში ხშირად ჩნდება უფრო რთული გამონათქვამების საჭიროება. შეგიძლიათ მიიღოთ პასუხი "დიახ" ან "არა" ორი მარტივი გამოთქმის შედეგიდან გამომდინარე. მაგალითად, „გარეთ თოვს ან წვიმს“, „ახალი ამბების ცვლადი 12-ზე მეტია და 20-ზე ნაკლები“.
ასეთ შემთხვევებში გამოიყენეთ სპეციალური ოპერატორებიორი ან მეტი მარტივი ლოგიკური გამონათქვამის გაერთიანება. ფართოდ გამოიყენება ორი ოპერატორი - ე.წ. ლოგიკური AND ( და) და ან ( ან).
და, აუცილებელია, რომ ორივე მარტივი გამონათქვამის შედეგები დააკავშიროს ამ ოპერატორს, მართალი იყო. თუ მინიმუმ ერთ შემთხვევაში შედეგი არის False, მაშინ მთელი რთული გამოხატულება იქნება მცდარი.
ოპერატორის გამოყენებისას True-ს მისაღებად ან, აუცილებელია, რომ შედეგი მინიმუმ ერთი მარტივი გამოხატულებაკომპლექსის ნაწილი მართალი იყო. ოპერატორის შემთხვევაში ანრთული გამოთქმა ხდება მცდარი მხოლოდ მაშინ, როდესაც მასში შემავალი ორივე მარტივი გამონათქვამი მცდარია.
ვთქვათ x ცვლადს მიენიჭა მნიშვნელობა 8 (x = 8), ცვლადს y მიენიჭა 13 (y = 13). ლოგიკური გამოხატულება y< 15 and x >8 შესრულდება შემდეგნაირად. გამოთქმა y შესრულდება ჯერ< 15 . Его результатом будет True. Затем выполнится выражение x >8. მისი შედეგი იქნება ყალბი. შემდეგ გამოთქმა შემცირდება True-ზე და False-ზე, რომელიც დააბრუნებს False-ს.
>>> x = 8 >>> y = 13 >>> y< 15 and x > 8 ყალბი
თუ გამოთქმას დავწერთ ასე: x > 8 და y< 15 , то оно также вернуло бы False. Однако сравнение y < 15 не выполнялось бы интерпретатором, так как его незачем выполнять. Ведь первое простое логическое выражение (x >8) უკვე დააბრუნა ყალბი, რაც იმ შემთხვევაში და ოპერატორი, მთელ გამოთქმას ტყუილად აქცევს.
ან ოპერატორის შემთხვევაში, მეორე მარტივი გამონათქვამი შემოწმებულია, თუ პირველი დააბრუნებს false, და არ ტესტირება, თუ პირველი უკვე დააბრუნებს true. ვინაიდან მთელი გამოთქმის სიმართლისთვის საკმარისია ერთი True, არ აქვს მნიშვნელობა რომელ მხარეს არის ან ის არის.
>>> y< 15 or x > 8 მართალია
პითონში ასევე არის ერთიანი ლოგიკური ოპერატორი არა, ანუ უარყოფა. ის სიმართლეს აქცევს სიცრუედ და სიცრუეს ჭეშმარიტებად. ის უნივერსალურია, რადგან მის შემდეგ ერთ გამონათქვამს ეხება და არა მის მარჯვნივ და მარცხნივ, როგორც ორობითი და და ან-ის შემთხვევაში.