Jump to content

Search the Community

Showing results for tags 'ქართულად'.



More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


Forums

  • ფორუმი
    • ფორუმი
    • ზოგადი დისკუსიები
    • ტუტორიალი/Tutorial
    • მათემატიკა
    • ბიბლიოთეკა
    • კრიპტოგრაფია
    • კიბერ უსაფრთხოება
    • ელექტროინჟინერია
  • პროგრამები
    • დიზანის & 3D მოდელირება
    • პროგრამები/ software
    • დაცვა
  • Visual Studio
    • Visual Studio
    • C#
    • C და C++
    • ASP.NET/WPF/MVC
    • WCF
    • Quick Basic / Visual Basic
  • Web Development
    • HTML & CSS
    • Bootstrap
    • PHP & MySQL
    • Javascript
    • AngularJS
    • სხვადასხვა
    • SEO
    • ძრავების მიმოხილვა
  • Development
    • JAVA
    • Perl
    • Python
    • ბაზები
    • Other
    • Game Developer
    • მობილურის დეველოპერი
  • IT-Support
    • Unix/Linux
    • MS Windows
    • Apple /MAC
    • Android
    • Network
    • კომპიუტერის არქიტექტურა
  • ყიდვა-გაყიდვა/შეკვეთები
    • ყიდვა-გაყიდვა
    • შეკვეთები

Find results in...

Find results that contain...


Date Created

  • Start

    End


Last Updated

  • Start

    End


Filter by number of...

Joined

  • Start

    End


Group


AIM


MSN


Website URL


ICQ


Yahoo


Jabber


Skype


ლოკაცია


ინტერესები

Found 10 results

  1. სათაური: 3D მოდელირება კატეგორია: მოდელირება თარითი: 2016-01-21 ავტორი: GHOST_FATHER 3D მოდელირება
  2. სათაური: ASP.NET MVC კატეგორია: ASP.NET MVC თარითი: 2016-01-21 ავტორი: GHOST_FATHER ASP.NET MVC
  3. GHOST_FATHER

    C++ ქართულად

    C++ ქართულად View File ხელმძღვანელოში გადმოცემულია Microsoft Visual Studio .NET გარემოში პროგრამების შემუშავების საკითხები. დაწვრილებითაა განხილული C++ ენის საფუძვლები, მონაცემთა ტიპები, მმართველი ოპერატორები, სტრუქტურირებული ტიპები. გადმოცემულია ობიექტზე ორიენტირებული დაპროგრამების პრინციპები: ინკაფსულაცია, პოლიმორფიზმი და მემკვიდრეობითობა. განხილულია განსაკუთრებული სიტუაციები, ფაილებთან და კატალოგებთან მუშაობისა და CLI დაპროგრამების საკითხები. წინა გამოცემისაგან განსხვავებით წიგნში დამატებულია მონაცემთა ბაზებთან მუშაობის საკითხები. აღწერილია ADO.NET კლასები, ნაჩვენებია, თუ როგორ უნდა ვიმუშაოთ SQL სერვერზე მოთავსებულ მონაცემთა ბაზასთან C++ პროგრამიდან Active Data Objects ბიბლიოთეკის კლასების გამოყენებით .NET Framework პლატფორმისათვის. წიგნში უხვადაა მაგალითები და ამოცანები ამოხსნებით. განკუთვნილია კომპიუტერული სისტემებისა და ქსელების სპეციალობის ბაკალავრებისა და მაგისტრებისათვის, აგრეთვე, დაპროგრამების შესწავლის ნებისმიერი მსურველისათვის. Submitter GHOST_FATHER Submitted 11/10/2015 Category C++
  4. Tuples უცვლელია Fun fact: The word “tuple” comes from the names given to sequences of numbers of varying lengths: single, double, triple, quadruple, quituple, sextuple, septuple, etc. მხიარული ფაქტი: სიტყვა tuple მოდის ციფრების ცვალებადი სიგრძის სახელებიდან: single, double, triple, quadruple, quituple, sextuple, septuple, და.ა.შ. tuple არის მნიშვნელობათა რიგი - სიის მსგავსად. tuple - ში მოთავსებული მნიშვნელობები შეიძლება იყოს ნებისმიერი ტიპის და ინდექსირებულია მთელი რიცხვებით. მნიშვნელოვანი განსხვავება ისაა, რომ tuple უცვლელია. tuple არის შედარებადი და hashable, ასე რომ შეგვიძლია გავასწოროთ მათი სია და გამოვიყენოთ, როგორც გასაღები მნიშვნელობა პითონის ლექსიკონებში. სინტაქსურად tuple არის მძიმით გამოყოფილი მნიშვნელობათა სია. >>> t = 'a', 'b', 'c', 'd', 'e' მიუხედავად იმისა, რომ აუცილებელი არაა, ადვილად იდენტიფიკაციისთვის რეკომენდირებულია tuple - ს ფრჩხილებში ჩასმა: >>> t = ('a', 'b', 'c', 'd', 'e') ერთ ელემენტიანი tuple - ს გაკეთებისას მძიმის დასმა აუცილებელია: >>> t1 = ('a',) >>> type(t1) <type 'tuple'> მძიმის გარეშე პითონი ('a' - ს) განიხილავს როგორც გამოსახულებას რომელიც წარმოადგენს სტრინგს: >>> t2 = ('a') >>> type(t2) <type 'str'> tuple - ს გაკეთება ასევე შეიძლება ჩაშენებული ფუნქციითაც, რომელიც აკეთებს ცარიელ tuple - ს არგუმენტების გარეშე: >>> t = tuple() >>> print t () არგუმენტი თუ თანრიგია(სტრინგის, სიის ან tuple - ის), tuple - ს გამოძახების შედეგი იქნება tuple თანრიგის ელემენტებით: >>> t = tuple('lupins') >>> print t ('l', 'u', 'p', 'i', 'n', 's') არ გამოიყენო tuple ცვლადის სახელად. სიის უმეტესი ოპერატორები tuple - სთანაც მუშაობს. კვადრატული ფრჩხილის ოპერატორი ელემენტებს აინდექსირებს: >>> t = ('a', 'b', 'c', 'd', 'e') >>> print t[0] 'a' დაჭრის ოპერატორი ელემენტებს ნიშნავს დიაპაზონში: >>> print t[1:3] ('b', 'c') მაგრამ თუ ცდი tuple - ის ელემენტის მოდიფიცირებას, მიღებ შეცდომას: >>> t[0] = 'A' TypeError: object doesn't support item assignment tuple - ის ელემენტის მოდიფიცირება არ შეგიძლია, თუმცა შეგიძლია ერთი tuple - ის მეორეთი ჩანაცვლება: >>> t = ('A',) + t[1:] >>> print t ('A', 'b', 'c', 'd', 'e') 10.2 tuple - ბის შედარება შედარების ოპერატორების მუშაობა tuple -სთან და სხვა თანრიგებთან; პითონი იწყებს პირველი ელემენტის შედარებას ყოველი თანრიგიდან, თუ თანაბარია, გადადის შემდეგ ელემენტზე და.ა.შ. სანამ არ იპოვნის განსხვავებულ ელემენტებს. მომდევნო ელემენტები არ განიხილება(თუნდაც ძალიან დიდი იყოს). >>> (0, 1, 2) < (0, 3, 4) True >>> (0, 1, 2000000) < (0, 3, 4) True sort ფუნქცია მუშაობს იგივენაირად.თავდაპირველად ალაგებს პირველ ელემენტებს მაგრამ ტოლობის შემთხვევაში ალაგებს მეორე ელემენტით და.ა.შ. ეს მახასიათებელი ვარგისია ნიმუშისთვის DSU თანრიგის მოსამართად სიების თუპლების გაკეთებით თანრიგის ელემენტების წინ ერთი ან მეტი sort keys. Sort - დახარისხება tuple - ბის სიისა sort ფუნქციით Undecorate - თანრიგის დახარისხებული ელემენტების არევა. (This feature lends itself to a pattern called DSU for Decorate a sequence by building a list of tuples with one or more sort keys preceding the elements from the sequence, Sort the list of tuples using the Python built-in sort, and Undecorate by extracting the sorted elements of the sequence.) მაგალითად დავუშვათ გაქვს სიტყვების სია და გინდა რომ დაახარისხო კლებადობის მიხედვით: txt = 'but soft what light in yonder window breaks' words = txt.split() t = list() for word in words: t.append((len(word), word)) t.sort(reverse=True) res = list() for length, word in t: res.append(word) print res პირველი მარყუჟი აკეთებს თუპლების სიას, სადაც ყოველი თუპლი არის სიტყვა და ამ სიტყვის სიგრძე. sort ადარებს პირველ ელემენტს, პირველად სიგრძეს და მხოლოდ შემდეგ განიხილავს მეორე ელემენტს to break ties. sort - ის არგუმენტი reverse=True - ით ხარისხდება კლებადობის მიხედვით. მეორე მარყუჟი გადაკვეთს თუპლის სიას და აკეთებს სიტყვების სიას სიგრძის კლებადობის მიხედვით. So among the five character words, დალაგებული ანბანის საპირისპიროდ. ასე რომ ამ სიაში “what” არის “soft” - მდე . პროგრამის ამონაბეჭდი არის შემდეგი: ['yonder', 'window', 'breaks', 'light', 'what', 'soft', 'but', 'in'] რა თქმა უნდა აბზაცის პოეტურობას დარტყმა ადგება, როცა პითონის მარწუხებში ხვდება. Tuple assignment პითონის ენაში ერთ - ერთი უნიკალური სინტაქსური მახასიათებელია ტოლობის მარცხენა მხარეზე თუპლის ქონის უნარი. ეს საშუალებას იძლევა გავუტოლოთ ერთზე მეტი ცვლადი როცა მარცხენა მხარე არის თანრიგი. ამ მაგალითში გვაქვს ორ ელემენტიანი სია(რაც თანრიგია) და თანრიგის პირველ და მეორე ელემენტს ერთი ტოლობით ვუტოლებთ ცვლადებს x - ს და y - ს. >>> m = [ 'have', 'fun' ] >>> x, y = m >>> x 'have' >>> y 'fun' >>> ეს არაა ჯადოქრობა. პითონი პირდაპირ თარგმნის თუპლის გატოლების სინტაქსს შემდეგნაირად: (პითონი სინტაქსს არ თარგმნის სიტყვა-სიტყვით. მაგალითად თუ ცდი ლექსიკონებთან ნახავ, რომ არ იმუშავებს ისე, როგორც ელოდი.) >>> m = [ 'have', 'fun' ] >>> x = m[0] >>> y = m[1] >>> x 'have' >>> y 'fun' >>> როცა ტოლობის მარცხენა მხარეს ვიყენებთ თუპლს, ვტოვებთ ფრჩხილებს, მაგრამ შემდეგი მაგალითი სინტაქსურად იგივეა. >>> m = [ 'have', 'fun' ] >>> (x, y) = m >>> x 'have' >>> y 'fun' >>> ჭკვიანურად შედგენილი თუპლით შესაძლებელია ორი ცვლადის მნიშვნელობა შევცვალოთ ერთ გატოლებაში: >>> a, b = b, a ტოლობის ორივე მხარე არის თუპლი, მაგრამ მარცხენა მხარე არის ცვლადების თუპლი და მარჯვენა მხარე - გამოსახულების. მარჯვენა მხარის ყოველი მნიშვნელობა გატოლებულია მარცხენა მხარის შესაბამის ცვლადთან. მარჯვენა მხარის ყველა გამოსახულება შეფასებულია გატოლებამდე. ტოლობის მარცხენა მხარეს ცვლადების რაოდენობა და ტოლობის მარჯვენა მხარეს მნიშვნელობების რაოდენობა უნდა იყოს ერთი და იგივე. >>> a, b = 1, 2, 3 ValueError: too many values to unpack უფრო ზოგადად, მარჯვენა მხარე შეიძლება იყოს ნებისმიერი ტიპის თანრიგი (სტრინგი, სია ან თუპლი). მაგალითად, მეილის მისამართის მომხმარებლის სახელად და დომაინად დასაყოფად შეგეძლო დაგეწერა: >>> addr = 'monty@python.org' >>> uname, domain = addr.split('@') დაყოფის შემდეგ მნიშვნელობა იქნება ორელემენტიანი სია; პირველი ელემენტი გატოლებულია uname - თან და მეორე - domain. >>> print uname monty >>> print domain python.org ლექსიკონები და თუპლები ლექსიკონებს აქვს მეთოდი items რომელიც აბრუნებს თუპლების სიას, სადაც ყოველი თუპლი არის გასაღები-მნიშვნელობის წყვილი(გმწ). (ეს ქცევა უმნიშვნელოდ განსხვავებულია პითონ 3.0 - ში) >>> d = {'a':10, 'b':1, 'c':22} >>> t = d.items() >>> print t [('a', 10), ('c', 22), ('b', 1)] როგორც ელოდი ელემენტები არ არიან განსაკუთრებული რიგით. მას შემდეგ რაც თუპლების სია არის სია და თუპლები არის შედარებადი, უკვე შეგვიძლია თუპლების სიის დახარისხება. ლექსიკონის თუპლების სიად გარდაქმნა ჩვენთვის არის გზა გასაღების მიხედვით დახარისხებული ლექსიკონის შიგთავსის ამობეჭდვისა: >>> d = {'a':10, 'b':1, 'c':22} >>> t = d.items() >>> t [('a', 10), ('c', 22), ('b', 1)] >>> t.sort() >>> t [('a', 10), ('b', 1), ('c', 22)] ახალი სია დახარისხებულია ანბანის მიხედვით. Multiple assignment with dictionaries items - ის თუპლის და for - ის კომბინირებით შეგიძლია ნახო კოდის კარგი ნიმუში ლექსიკონში ერთი მარყუჟით გასაღების და მნიშვნელობის გადაკვეთისა: for key, val in d.items(): print val, key ამ მარყუჟს აქვს ორი გამეორებადი ცვლადი , items აბრუნებს თუპლის სიას და val, key არის თუპლის დავალება, რომელიც წარმატებით ამეორებს თითოეულ გმწ - ს ლექსიკონში. მარყუჟში ყოველი გამეორებისთვის key და value არის advanced მომდევნო გასაღები/მნიშვნელობის წყვილისთვის ლექსიკონში (still in hash order) მარყუჟის ამონაბეჭდია შემდეგი: 10 a 22 c 1 b Again in hash key order ( ანუ კონკრეტული რიგის გარეშე). თუ გავაერთიანებთ ამ ორ ტექნიკას შეგვეძლება ამოვბეჭდოთ ლექსიკონის შიგთავსი დახარისკებული გმწ - ის მნიშვნელობის მიხედვით. ამის გასაკეთებლად პირველად ვაკეთებთ თუპლების სიას, სადაც თითო თუპლი არის (value, key). items მეთოდი მოგვცემს სიას (key, value) თუპლის, მაგრამ ამჟამად გვინდა დავახარისხოთ მნიშვნელობის მიხედვით. რაკი ერთხელ გავაკეთებთ მნიშვნელობა/გასაღები თუპლის სიას, მერე უკვე მარტივია გავაკეთოთ პირიქით დახარისხებული სია და ამოვბეჭდოთ. >>> d = {'a':10, 'b':1, 'c':22} >>> l = list() >>> for key, val in d.items(): ... l.append( (val, key) ) ... >>> l [(10, 'a'), (22, 'c'), (1, 'b')] >>> l.sort(reverse=True) >>> l [(22, 'c'), (10, 'a'), (1, 'b')] >>> თუპლის სიის ყურადღებით გაკეთებით - რომ ყოველი თუპლის პირველი ელემენტი იყოს მნიშვნელობა, შეგვიძლია დავახარისხოთ თუპლის სია და გამოვიტანოთ ლექსიკონის შიგთავსი მნიშვნელობის მიხედვით დახარისხებული. the most common words. დავუბრუნდეთ ტექსტს წინა მაგალითიდან Romeo and Juliet Act 2, Scene 2 . შეგვიძლია გავზარდოთ ჩვენი პრორამა ისე, რომ ამობეჭდოს 10 ყველაზე ხშირად გამოყენებული სიტყვა: import string fhand = open('romeo-full.txt') counts = dict() for line in fhand: line = line.translate(None, string.punctuation) line = line.lower() words = line.split() for word in words: if word not in counts: counts[word] = 1 else: counts[word] += 1 # Sort the dictionary by value lst = list() for key, val in counts.items(): lst.append( (val, key) ) lst.sort(reverse=True) for key, val in lst[:10] : print key, val პრორამის პირველი ნაწილი, რომელიც კითხულობს ფაილს და ითვლის ლექსიკონს - რომელიც ყოველ სიტყვას მიმართავს სიტყვების მთვლელისკენ; უცვლელია. მაგრამ პროგრამის ბოლოში counts - ის მარტივად ამობეჭდვის ნაცვლად, ვაკეთებთ თუპლების (val, key) სიას და ამ სიას ვასწორებთ კლებადობის მიხედვით. მაშინ, როცა მნიშვნელობა არის პირველი, ეს იქნება გამოყენებული შედარებისთვის და თუ შეგვხვდება ერთზე მეტი თუპლი იგივე მნიშვნელობით, შეადარებს მეორე პარამეტრს(გასაღებს), ასე რომ ერთი და იგივე მნიშვნელობის მქონე თუპლებს დაახარისხებს ანბანის მიხედვით. ბოლოს დავწერეთ for მარყუჟი, რომელიც აკეთებს ბევრ გამეორებას და ბეჭდავს სიაში (პარამეტრით lst[:10]) 10 ყველაზე ხშირად გამოყენებულ სიტყვას. ამონაბეჭდი ახლა უკვე გამოიყურება ისე, როგორც გვინდოდა. 61 i 42 and 40 romeo 34 to 34 the 32 thou 32 juliet 30 that 29 my 24 thee ფაქტი, რომ კომპლექსური მონაცემების გარჩევა და ანალიზი შეიძლება გაკეთდეს ადვილად გასაგები პითონის 19 ხაზიანი პროგრამით არის ერთი მიზეზი თუ რატომაა პითონი კარგი ენა ინფორმაციის მოკვლევისთვის. გამართვა პითონს აქვს ჩაშენებული მარტივი დოკუმენტაცია, რომელიც საკმაოდ გამოსადეგია თუ გჭირდება სწრაფად გაიხსენო რომელიმე კონკრეტული მეთოდის სახელი. ეს დოკუმენტაცია შეიძლება ნახო პითონის ინტერპრეტერში ინტერაქტიულ რეჟიმში. შეგიძლია გამოიძახო დახმარება help() - ის გამოყენებით. >>> help() Welcome to Python 2.6! This is the online help utility. If this is your first time using Python, you should definitely check out the tutorial on the Internet at http://docs.python.org/tutorial/. Enter the name of any module, keyword, or topic to get help on writing Python programs and using Python modules. To quit this help utility and return to the interpreter, just type "quit". To get a list of available modules, keywords, or topics, type "modules", "keywords", or "topics". Each module also comes with a one-line summary of what it does; to list the modules whose summaries contain a given word such as "spam", type "modules spam". help> modules თუ იცი რომელი მოდულის გამოყენება გინდა, შეგიძლია dir() ბრძანებით მოძებნო ამ მოდულის მეთოდები: >>> import re >>> dir(re) [.. 'compile', 'copy_reg', 'error', 'escape', 'findall', 'finditer', 'match', 'purge', 'search', 'split', 'sre_compile', 'sre_parse', 'sub', 'subn', 'sys', 'template'] ასევე შეგიძლია კონკრეტული მეთოდის შესახებ მცირე დოკუმენტაციის მოძებნა dir ბრძანებით. >>> help (re.search) Help on function search in module re: search(pattern, string, flags=0) Scan through string looking for a match to the pattern, returning a match object, or None if no match was found. >>> ჩაშენებული დოკუმენტაცია არ არის ძალიან ვრცელი, მაგრამ შეიძლება იყოს გამოსადეგი როცა გეჩქარება ან არ გაქვს წვდომა ვებ-ბრაუზერთან ან საძიებო სისტემასთან. ლექსიკონი brittle code: კოდი, რომელიც მუშაობს მაშინ, როცა შეტანილი მონაცემები არის კონკრეტულ ფორმატში და მიდრეკილება აქვს გაფუჭებისკენ იმ შემთხვევაში თუ კონკრეტული ფორმატიდან რამე არის გადახრილი. ამას ვეძახით „მყიფე კოდს“ იმიტომ რომ ადვილად ტყდება. greedy matching: The notion რომ “+” და “*” სიმბოლოები რეგულარულ გამოსახულებაში ამთხვევს რაც შეიძლება დიდ სტრინგს.. grep: ბრძანება ხელმისაწვდომია უმეტესობა Unix - ის სისტემებში, რომელიც იკვლევს ტექსტურ ფაილებს და ეძებს ხაზებს, რომელიც ემთხვევა რეგულარულ გამოსახულებებს. ბრძანების სახელი მოდის ”Generalized Regular Expression Parser” - დან. regular expression: ძებნის რთული სტრინგების გამოსასახი ენა.რეგულარული გამოსახულება შეიძლება შეიცავდეს სპეციალურ სიმბოლოებს, რომელიც აჩვენებს, რომ ეძებს დამთხვევებს მხოლოდ ხაზის დასაწყისში ან ბოლოში (ან ბევრი სხვა მსგავსი შესაძლებლობები ) wild card: სპეციალური სიმბოლო, რომელიც ემთხვევა ნებისმიერ სიმბოლოს. რეგულარულ გამოსახულებაში wild card - ის სიმბოლოა წეტილის სიმბოლო. სავარჯიშოები სავარჯიშო 11.1 დაწერე მარტივი პროგრამა, რომელიც მოახდენს grep - ის სიმულაციას Unix - ზე. მომხმარებელს მოსთხოვე შეიყვანოს რეგულარული გამოსახულება და დაითვალოს ხაზები, რომელიც დაემთხვევა რეგულარულ გამოსახულებას. $ python grep.py Enter a regular expression: ˆAuthor mbox.txt had 1798 lines that matched ˆAuthor $ python grep.py Enter a regular expression: ˆXmbox. txt had 14368 lines that matched ˆX- $ python grep.py Enter a regular expression: java$ mbox.txt had 4218 lines that matched java$ სავარჯიშო 11.2 დაწერე პროგრამა შემდეგი ფორმის ხაზების მოსაძებნად: New Revision: 39772 და ყოველი ხაზიდან ამოიღე ციფრები რეგულარული გამოსახულების და findall() მეთოდის გამოყენებით. გამოთვალე ციფრების საშუალო არითმეტიკული და ამობეჭდე. Enter file:mbox.txt 38549.7949721 Enter file:mbox-short.txt 39756.9259259
  5. გამართვა სკრიპტის დასაწერად ტექსტურ რედაქტორს თუ იყენებ, შეიძლება შეგხვდეს პრობლემა სპეისებთან(ჰარი) და ტაბებთან(tabs) . ამ პრობლემის თავიდან ასარიდებელი საუკეთესო გზაა გამოიყენო მხოლოდ ჰარი(არა ტაბები). იმ ტექსტური რედაქტორების უმეტესობამ, რომელმაც იციან პითონი შესახებ, ამას თავისით აკეთებენ. მაგრამ ზოგი არ აკეთებს.ტაბები და ჰარები ჩვეულებრივ არის უხილავი, რაც მათ ხდის ძნელად გასამართს, ასე რომ ცადე იპოვნო ისეთი რედაქტორი, რომელიც შენთვის სწორად დაკბილავს.ასევე, არ დაგავიწყდეს შეინახო პროგრამა სანამ გაუშვებ. ზოგი IDE (დამუშავების ინტეგრირებული გარსი) ამას თავისით აკეთებს, მაგრამ ზოგი - არა. ამ შემთხვევაში პროგრამა რომელსაც უყურებ ტექსტურ რედაქტორში და პროგრამა, რომელიც გაშვებული გაქვს სხვა და სხვაა. გამართვას შეუძლია წაიღოს დიდი დრო თუ არასწორ პროგრამას უშვებ ისევ და ისევ. დარწმუნდი, რომ კოდი რომელსაც უყურებ და კოდი რომელიც გაშვებული გაქვს ერთი და იგივეა. დარწმუნებული თუ არ ხარ, კოდის დასაწყისში დაწერე print 'hello' და თავიდან გაუშვი.hello - ს თუ ვერ დაინახავ, ე.ი. სხვა პროგრამა გაქვს გაშვებული. ლექსიკონი algorithm: პრობლემების კატეგორიის გადასაჭრელი ზოგადი პროცესი.argument: მნიშვნელობა, რომელიც უზრუნველყოფს ფუნქციას, როცა ფუნქცია გამოძახებულია. ეს მნიშვნელობა ენიჭება შესაბამის პარამეტრს ფუნქციაშიbody: ბრძანებათა თანრიგი ფუნქციის განსაზღვრებაში.composition: გამოსახულების გამოყენება როგორც უფრო დიდი გამოსახულების ნაწილის, ან ანგარიშის (ბრძანების - statement.) გამოყენება როგორც უფრო დიდი ანგარიშის (ბრძანების - statement.) ნაწილის.deterministic: ეკუთვნის პროგრამას, რომელიც ერთი და იგივე შენატანის (input) შემთხვევაში აკეთებს იგივეს ყოველ გაშვებაზე.dot notation: მოდულში ფუნქციის გამოსაძახებელი სინტაქსი ზუსტად განსაზღვრული მოდულის სახელით, რომელსაც მოყვება წერტილი და ფუნქციის სახელი.flow of execution: თანრიგი, რომლის მიხედვითაც ანგარიშები ხორციელდება პროგრამის მუშაობის დროს.fruitful function: ფუნქცია, რომელიც აბრუნებს მნიშვნელობას.function: სახელდარქმეული ბრძანებათა რიგი, რომელიც ასრულებს სასარგებლო ოპერაციას. ფუნქციებს შეიძლება ჰქონდეს ან არ ჰქონდეს არგუმენტები და შეიძლება აწარმოებდეს ან არ აწარმოებდეს შედეგს.function call: ბრძანება, რომლითაც ფუნქცია ხორციელდება. ის შედგება ფუნქციის სახელისა და არგუმენტების სიისგან.function definition: ბრძანება, რომელიც აკეთებს ახალ ფუნქციას, უსაზღვრავს სახელს, პარამეტრებს და ბრძანებას რომელსაც ახორციელებს.function object: მნიშვნელობა, რომელიც გააკეთა ფუნქციის განსაზღვრებამ. ფუნქციის სახელი არის ცვლადი რომელიც გზავნის ფუნქციის ობიექტს .header: ფუნქციის განსაზღვრების პირველი ხაზი.import statement: ბრძანება, რომელიც კითხულობს მოდულის ფაილს და აკეთებს მოდულის ობიექტს,module object: მნიშვნელობა, რომელიც გააკეთა import ბრძანებამ, რაც უზრუნველყოფს წვდომას მონაცემებთან და კოდთან, რაც განსაზღვრულია მოდულში.parameter: სახელი, რომელიც გამოიყენება ფუნქციის შიგნით და გზავნის მნიშვნელობას როგორც არგუმენტს.pseudorandom: ეკუთვნის ციფრების თანრიგს, რომელიც ჩანს როგორც შემთხვევითი, მაგრამ არის გენერირებული დეტერმინირებული პროგრამით.return value: ფუნქციის შედეგი. გამოძახებული ფუნქცია თუ გამოყენებულია როგორც გამოსახულება, დაბრუნებული მნიშვნელობა არის გამოსახულების მნიშვნელობა.void function: ფუნქცია რომელიც არ აბრუნებს შედეგს. სავარჯიშოები სავარჯიშო 4.4 რა არის ”def” ქივორდის დანიშნულება პითონში? ა) ესაა სლენგი რაც ნიშნავს "ეს კოდი ძაან მაგარია"ბ) ეს მიანიშნებს ფუნქციის დასაწყისზეგ) ეს მიანიშნებს რომ კოდის დაკბილული ნაწილი გამოიყენება მოგვიანებით.დ) ბ და გ ორივე მართალიაე) არცერთი არაა მართალი. სავარჯიშო 4.5 რას ამობეჭდავს ეს კოდი? def fred(): print "Zap" def jane(): print "ABC" jane()fred()jane() ა) Zap ABC jane fred janeბ) Zap ABC Zapგ) ABC Zap janeდ) ABC Zap ABCე) Zap Zap Zap სავარჯიშო 4.6 გადაწერე გადახდის ანგარიშის კოდი ერთნახევარჯერ მეტი გადახდით გადაცილებულ დროზე და გააკეთე ფუნქცია სახელად computepay რომელიც მიიღებს ორ პარამეტრს (hours და rate). Enter Hours: 45Enter Rate: 10Pay: 475.0 სავარჯიშო 4.7 გადაწერე შეფასების პროგრამა წინა თავიდან , გამოიყენე ფუნქცია -computegrade რომელი მიიღებს ანგარიშს როგორც პარამეტრს და დააბრუნებს შეფასებას როგორც სტრინგს. Score Grade> 0.9 A> 0.8 B> 0.7 C> 0.6 D<= 0.6 F Program Execution: Enter score: 0.95A Enter score: perfectBad score Enter score: 10.0Bad score Enter score: 0.75C Enter score: 0.5F გაუშვი პროგრამა ბევრჯერ და შეამოწმე სხვადასხვა ტიპის მნიშვნელობისთვის.
  6. განხორციელებათა დინება იმისთვის რომ დარწმუნდე ფუნქცია განსაზღვრულია მის პირველ გამოყენებამდე, თქვენ უნდა იცოდეთ თანმიმდევრობა, რომლითაც ბრძანებები შესრულდა, რომელსაც ეძახიან განხორციელებათა დინებას.განხორციელება ყოველთვის იწყება პროგრამის პირველ ბრძანებაში. ბრძანებები სრულდება სათითაოდ, ზემოდან ქვემოთ.ფუნქციის განსაზღვრება პროგრამის განხორციელებათა დინებას არ ცვლის , მაგრამ დაიმახსოვრე, რომ ბრძანებები ფუნქციის შიგნით არ განხორციელდება სანამ ფუნქცია გამოძახებულია.ფუნქციის გამოძახება არის როგორც განხორციელებათა დინებიდან გადახვევა. შემდეგ ბრძანებაზე გადასვლის ნაცვლად, დინება გადადის ფუნქციის სხეულზე და იქ ახორციელებს ყველა ბრძანებას და შემდეგ ბრუნდება იქ სადაც გაჩერდით.ეს ჟღერს საკმაოდ მარტივად, სანამ გაგახსენდება, რომ ერთ ფუნქციას შეუძლია დაუძახოს სხვა ფუნქციას, სანამ ერთი ფუნქციის შუაშია, პროგრამას შეიძლება მოუხდეს განახორციელოს ბრძანება სხვა ფუნქციაში, მაგრამ სანამ ახალი ფუნქცია ხორციელდება, პროგრამას შეიძლება ჰქონდეს გასახორციელებელი კიდევ ახალი ფუნქცია.საბედნიერო პითონი კარგად აკონტროლებს თუ სადაა და ყოველ ჯერზე, როცა ფუნქცია სრულდება, პროგრამა ბრუნდება იქ, სადაც ფუნქციის გამოძახების დროს იყო. პროგრამის ბოლოში როცა გადის - სრულდება.რა არის მორალი ამ ზღაპრის? პროგრამას როცა კითხულობ, ყოველთვის არ გინდა თავიდან ბოლომდე წაკითხვა და ხანდახან უფრო აზრიანია მიჰყვე განხორციელებათა დინებას. 4.9 პარამეტრები და არგუმენტები ზოგიერთ ჩაშენებულ ფუნქციას (რომელიც ვნახეთ) ესაჭიროება არგუმენტები. მაგალითად; როცა იძახებ math.sin, შეგყავს ციფრი როგორც არგუმენტი. ზოგი ფუნქცია იღებს ერთზე მეტ არგუმენტს. math.pow იღებს ორს - ფუძეს და ხარისხის მაჩვენებელს. ფუნქციის შიგნით ეს არგუმენტები გატოლებულია ცვლადებს, რომელსაც ეძახიან პარამეტრებს. აქაა მაგალითი მომხმარებლის გაკეთებული ფუნქციის რომელსაც აქვს არგუმენტი: def print_twice(bruce): print bruce print bruce ეს ფუნქცია არგუმენტს უტოლებს ცვლადს სახელად bruce. როცა ფუნქცია გამოძახებულია, ბეჭდავს პარამეტრის (რაც არ უნდა იყოს )მნიშვნელობას ორჯერ.ეს ფუნქცია მუშაობს ყველა მნიშვნელობასთან რაც შეიძლება რომ დაიბეჭდოს. ჩაშენებულ და მომხმარებლის გაკეთებულ ფუნქციებში იგივე წესებია, ასე რომ შეგიძლია გამოვიყენოთ გამოსახულება როგორც არგუმენტი: არგუმენტი შეფასებულია ფუნქციის გამოძახებამდე, ამ მაგალითში 'Spam '* 4 დაmath.cos(math.pi) გამოანგარიშებულია მხოლოდ ერთხელ. ასევე შეგიძლია გამოიყენო ცვლადი როგორც არგუმენტი >>> michael = 'Eric, the half a bee.'>>> print_twice(michael)Eric, the half a bee.Eric, the half a bee. ცვლადის სახელს, რომელიც არგუმენტის მაგივრად შევიტანეთ (michael)არაფერი აქვს საერთო პარამეტრის სახელთან (bruce). არ აქვს აზრი თუ რა იყო ადრე მნიშვნელობა; აქ print_twice ფუნქციაში ყველაფერს ვეძახით bruce -ს . ნაყოფიერი ფუნქციები და გაბათილებული ფუნქციები ზოგიერთი ფუნქცია რომელსაც ვიყენებთ, როგორიცაა მათ. ფუნქცია აწარმოებს შედეგებს. ასეთ ფუნქციებს ვეძახით ნაყოფიერ ფუნქციას (fruitful functions). სხვა ფუნქციები, მაგალითად print_twice, რაღაცას აკეთებს, მაგრამ არ აბრუნებს მნიშვნელობას. ამათ ეძახიან გაბათილებულ ფუნქციებს (void functions.)როცა იძახებ ნაყოფიერ ფუნქციას, შენ თითქმის ყოველთვის გინდა, რომ შედეგით რამე გააკეთო; მაგალითად შეიძლება გაუტოლო ცვლადს ან გამოიყენო როგორც გამოსახულების ნაწილი: x = math.cos(radians)golden = (math.sqrt(5) + 1) / 2 როცა ფუნქციას დიალოგურ რეჟიმში იძახებ, პითონს შედეგი ეკრანზე გამოაქვს >>> math.sqrt(5)2.2360679774997898 მაგრამ სკრიპტში, ნაყოფიერ ფუნქციას თუ გამოიძახებ და ფუნქციის შედეგს (return value,result)ცვლადში თუ არ შეინახავ, მნიშვნელობა გაქრება ნისლში! math.sqrt(5) ეს სკრიპტი ანგარიშობს კვადრატულ ფესვს ხუთიდან, მაგრამ სანამ შედეგს არ შეინახავს ცვლადში ან ეკრანზე არ გამოიტანს, მანამდე არც ისე გამოსადეგია.გაბათილებულმა ფუნქციამ ეკრანზე შეიძლება რამე გამოიტანოს ან ქონდეს სხვა რამე ეფექტი, მაგრამ არ ექნება დაბრუნებული მნიშვნელობა (return value). თუ ცდი რომ შედეგი ცვლადს გაუტოლო, მიიღებ სპეციალურ მნიშვნელობას სახელად None. >>> result = print_twice('Bing')BingBing>>> print resultNone მნიშვნელობა None არაა იგივე რაც სტრინგი "None", ამას აქვს სპეციალური მნიშვნელობა რომელსაც აქვს თავისი ტიპი: >>> print type(None)<type 'NoneType'> ფუნქციაში შედეგი რომ დააბრუნო , ფუნქციაში ვიყენებთ return ბრძანებას. მაგალითად, შეგვიძლია გავაკეთოთ მარტივი ფუნქცია სახელად addtwo , რომელიც ორ ციფრს ერთმანეთს მიუმატებს და დააბრუნებს შედეგს: def addtwo(a, b): added = a + b return added x = addtwo(3, 5)print x ეს სკრიპტი როცა განხორციელდება, print ბრძანება ამობეჭდავს 8 - ს, იმიტომ რომ addtwo ფუნქცია გამოძახებული იყო არგუმენტებით 3 და 5. ფუნქციის შიგნით პარამეტრები a დაb შესაბამისად იყო 3 და 5 . ფუნქციამ გამოთვალა ჯამი ორი ციფრის და მოათავსა ლოკალურ ფუნქციის ცვლადში სახელად added და გამოიყენა ბრძანება return რომ დათვლილი მნიშვნელობა გაეგზავნა უკან გამოძახების კოდში (back to the calling code)როგორც ფუნქციის შედეგი რომელიც მიენიჭა ცვლადს x და ამოიბეჭდა. რატომ ფუნქციები? ეს შეიძლება არ იყოს ნათელი, თუ რატომაა ღირებული პროგრამის დაყოფა ფუნქციებში. აქაა რამდენიმე მიზეზი: · ახალი ფუნქციის გაკეთება გაძლევს შესაძლებლობას რომ სახელი დაარქვა ბრძანებათა ჯგუფს, რომელიც შენს პროგრამას გახდის უფრო ადვილად წასაკითხს, გასაგებს და გამართულს.· ფუნქციებს შეუძლია განმეორებადი კოდის აღკვეთით პროგრამა გახადოს უფრო პატარა. მოგვიანებით თუ ცვლილებას გააკეთებ, ამის გაკეთება დაგჭირდება ერთ ადგილას.· დიდი პროგრამის ფუნქციებად დაყოფა გაძლევთ საშუალებას რომ გამართოთ ნაწილები სათითაოდ და შემდეგ შეკრათ ერთ მთლიანად.· კარგად გაკეთებული ფუნქციები ხშირად სასარგებლოა ბევრი პროგრამისთვის. რაკი ერთხელ დაწერ და გამართავ, შეგიძლია ბევრჯერ გამოიყენო. წიგნის დანარჩენ ნაწილში ხშირად გამოვიყენებთ ფუნქციის განსაზღვრებას როგორც მაგალითს. ცოდნის ნაწილი ფუნქციის შექმნის და გამოყენების ისაა, რომ ფუნქცია ზუსტად გამოსახავდეს აზრს; როგორიცაა "იპოვნე ყველაზე პატარა მნიშვნელობა მნიშვნელობათა სიაში". მოგვიანებით გაჩვენებთ კოდს, რომელიც პოულობს ყველაზე პატარას მნიშვნელობათა სიაში და წარმოგიდგენთ მას, როგორც ფუნქციას სახელად min, რომელიც იღებს მნიშვნელობათა სიას როგორც არგუმენტს და აბრუნებს უმცირეს მნიშვნელობას ამ სიიდან.
  7. ფუნქციის გამოძახება პროგრამირების ამ კონტექსტში, ფუნქცია არის სახელდარქმეული ბრძანებათა რიგი, რომელიც ასრულებს გამოთვლას. როცა ფუნქციას განსაზღვრავ, მიუთითებ სახელს და ბრძანებათა რიგს. მოგვიანებით შეგიძლია "დაუძახო" ფუნქციას სახელით. ფუნქციის ერთი მაგალითი უკვე ვნახეთ: >>> type(32)<type 'int'> ფუნქციის სახელია type. გამოსახულებას ფრჩხილებში ჰქვია ფუნქციის არგუმენტი. არგუმენტი არის მნიშვნელობა ან ცვლადი, რომელიც შეგვაქვს ფუნქციაში . type ფუნქციის შედეგია არგუმენტის ტიპი. შეიძლება ვთქვათ, რომ ფუნქცია "იღებს" არგუმენტს და "აბრუნებს" შედეგს. ამ შედეგს ეძახიან დაბრუნებულ მნიშვნელობას(return value). ჩაშენებული ფუნქციები პითონი უზრუნველყოფს გარკვეული რაოდენობის მნიშვნელოვან ჩაშენებულ ფუნქციებს,რომელიც შეგვიძლია გამოვიყენოთ ისე, რომ არ უზრუნველვყოთ ფუნქციის განსაზღვრება. პითონის შემქმნელებმა საერთო პრობლემების გადასაჭრელად დაწერეს ფუნქციების კომპლექტი და ჩააშენეს პითონში . max და min ფუნქციები გვაძლევს უდიდეს და უმცირეს მნიშვნელობებს სიაში. შესაბამისად : >>> max('Hello world')'w'>>> min('Hello world')' '>>> max ფუნქცია გვეუბნება რომელია "უდიდესი ასო" სტრინგში (რომელიც თურმე არის ასო'w' ) და min ფუნქცია გვეუბნება რომელია 'უმცირესი ასო' - რომელიც თურმე არის ცარიელი ადგილი (' '). სხვა ყველაზე ჩვეულებრივი ჩაშენებული ფუნქციაა len ფუნქცია, რომელიც გვეუბნება რამდენი ელემენტია არგუმენტში. არგუმენტი თუ სტრინგია, მაშინ გვაჩვენებს რამდენი ასოა სტრინგში. >>> len('Hello world')11>>> ფუნქციები არაა ლიმიტირებული და შეუძლიათ იმუშაონ ნებისმიერი ტიპის მნიშვნელობასთან - რასაც ვნახავთ შემდეგ თავებში. ჩაშენებული ფუნქციის სახელები განიხილე როგორც განსაზღვრული სიტყვები(ე.ი. ცვლადს არ დაარქვა სახლი "max") Type conversion functions. ტიპის გარდაქმნის ფუნქციები პითონი ასევე უზრუნველყოფილია ჩაშენებული ფუნქციებით, რომელიც აკონვერტებს მნიშვნელობის ერთ ტიპს მეორე ტიპად. int ფუნქცია იღებს ნებისმიერ მნიშვნელობას და აკონვერტებს მთელ რიცხვად - თუ შეუძლია. თუ არა და წუწუნებს: >>> int('32')32>>> int('Hello')ValueError: invalid literal for int(): Hello int -ს შეუძლია გადაიყვანოს წილადი მთელ რიცხვში, თუმცა რიცხვს არ ამრგვალებს, უბრალოდ წილადის ნიშანს აცლის: >>> int(3.99999)3>>> int(-2.3)-2 float აკონვერტებს მთელ რიცხვს და სტრინგს წილადად: >>> float(32)32.0>>> float('3.14159')3.14159 str თავის არგუმენტს აკონვერტებს სტრინგად: >>> str(32)'32'>>> str(3.14159)'3.14159' შემთხვევითი ციფრები ერთი და იგივე მონაცემის შეყვანისას პროგრამების უმეტესობა დააგენერირებს ერთნაირ შედეგს. ისინი არიან განსაზღვრული. განსაზღვრა კარგი რამეა, როცა ველოდებით ერთნაირ გამოთვლას, რომ ვაწარმოოთ ერთნაირი შედეგი. ზოგიერთი აპლიკაციისთვის გვინდა , რომ კომპიუტერი იყოს არაპროგნოზირებადი. თამაშები აშკარა მაგალითია, მაგრამ არის სხვებიც.მართლაც, არადეტერმინირებული პროგრამის გაკეთება აღმოჩნდება, რომ არც ისე ადვილია, მაგრამ არსებობს ხერხები, რათა ის მინიმუმ ჩანდეს როგორც არადეტერმინირებული. ერთი ხერხი იყენებს ალგორითმს, რომელიც აგენერირებს ფსევდოშემთხვევით ციფრებს. ფსევდოშემთხვევითი ციფრები არაა მართლა შემთხვევითი, იმიტომ რომ ისინი გენერირებულია განსაზღვრული გამოთვლებით, მაგრამ ერთი შეხედვით მათი გამორჩევა შეუძლებელია ნამდვილად შემთხვევითი ციფრებისგან. random მოდული უზრუნველყოფს ფუნქციას, რომელიც აგენერირებს ფსევდოშემთხვევით ციფრებს (რომელსაც ამას იქით დავუძახებთ "შემთხვევითს" “random”).ფუნქცია random აბრუნებს შემთხვევით წილადებს 0.0 - იდან 1.0- მდე. (0.0 -ის ჩათვლით, მაგრამ 1.0 არ ჩაითვლება). ყოველ ჯერზე, როცა გამოიძახებ random - ს მიიღებ ციფრების გრძელ სერიას. მაგალითი სანახავად გაუშვი ეს მარყუჟი: import randomfor i in range(10): x = random.random() print x ეს პროგრამა აწარმოებს 10 შემთხვევითი ციფრის სიას 0.0 - დან 1.0 -მდე 0.3019270917050.5137870758670.3194704308810.2851459172520.8390690451230.3220270807310.5507221102480.3665916778120.3969814839640.838116437404 სავარჯიშო 4.1 გაუშვი ეს პროგრამა შენს სისტემაში და ნახე რა ციფრებს მიიღებ. გაუშვი ბევრჯერ და ნახე რა ციფრებს მიიღებ. random ფუნქცია არის მხოლოდ ერთი მრავალი ფუნქციიდან, რომელიც უმკლავდება შემთხვევით ნომრებს. randint ფუნქცია იღებს პარამეტრებს low და high და აბრუნებს მთელ რიცხვს low - დან high - მდე (ორივეს ჩათვლით). >>> random.randint(5, 10)5>>> random.randint(5, 10)9 რიგიდან შემთხვევითი ელემენტის ასარჩევად შეგიძლია გამოიყენო choice: >>> t = [1, 2, 3]>>> random.choice(t)2>>> random.choice(t)3 random მოდული ასევე უზრუნველყოფს, რომ უწყვეტად აწარმოოს შემთხვევითი მნიშვნელობები გაუსიდან, ექსპონენტიდან, გამადან და.ა.შ. მათ. ფუნქციები პითონს აქვს math მოდული, რომელშიცაა უმეტესი ნაცნობი მათემატიკური ფუნქციებისა. სანამ დავიწყებთ ამ მოდული გამოყენებას, მანამდე მისი იმპორტირება უნდა მოვახდინოთ. >>> import math ეს ბრძანება ქმნის ობიექტურ მოდულს(module object) სახელად math. თუ ამობეჭდავ ამ მოდულს , ნახავ რაიმე ინფორმაციას ამის შესახებ. >>> print math<module 'math' from '/usr/lib/python2.5/lib-dynload/math.so'> ეს მოდული შეიცავს ფუნქციებს და ცვლადებს, რომელიც განსაზღვრულია ამ მოდულში. ფუნქციაზე წვდომა რომ გქონდეს, უნდა მიუთითო მოდულის და ფუნქციის სახელი - რომელიც ერთმანეთისგან გამოყოფა წერტილით. ამ ფორმატს ეძახიან წერტილით ჩაწერას (dot notation). >>> ratio = signal_power / noise_power>>> decibels = 10 * math.log10(ratio)>>> radians = 0.7>>> height = math.sin(radians) პირველი მაგალითი ანგარიშობს ლოგარითმს 10 ფუძეზე სიგნალი/ხმაურის სიხშირის(computes the logarithm base 10 of the signal-to-noise ratio). მათ. მოდულში ასევეა ფუნქცია log რომელიც ანგარიშობს ლოგარითმის ფუძეს. მეორე მაგალითი პოულობს რადიანების (radians) სინუსს. ცვლადის სახელი მინიშნებაა, რომ sin და სხვა ტრიგონომეტრიული ფუნქციები(cos, tan, და.ა.შ.) არგუმენტებს იღებს რადიანებში. გრადუსები რადიანებში რომ გადაიყვანო, გაყავი 360 -ზე და გაამრავლე 2 π - ზე >>> degrees = 45>>> radians = degrees / 360.0 * 2 * math.pi>>> math.sin(radians)0.707106781187 math.pi არის გამოსახულება pi - სა მათ. მოდულიდან. ცვლადის მნიშვნელობა მიახლოებულია π - სთან 15 ციფრით.ტრიგონომეტრია თუ იცი, შეგეძლო შეგემოწმებინა წინა შედეგი შედარებით: კვადრატული ფესვი ორიდან გაყოფილი ორზე: >>> math.sqrt(2) / 2.00.707106781187 ახალი ფუნქციების დამატება ამდენი ხნის განმავლობაში ვიყენებდით ფუნქციებს რომელიც ჩაშენებულია პითონში, თუმცა შესაძლებელია ახალი ფუნქციების დამატებაც. ფუნქციის განსაზღვრება (function definition) მოითხოვს სპეციალურ სახელს ახალი ფუნქციისთვის და ბრძანებათა რიგს,რომელიც გამოძახებისას განახორციელებს ამ ფუნქციას. რაკი ერთხელ გავაკეთებთ ფუნქციას, შეგვეძლება გამოვიყენოთ მთელ ჩვენ პროგრამაში.აქ არის მაგალითი : def print_lyrics(): print "I'm a lumberjack, and I'm okay." print 'I sleep all night and I work all day.' def არის განსაზღვრული სიტყვა რომელიც მიანიშნებს რომ ესაა ფუნქციის განსაზღვრება (function definition). ფუნქციის სახელია print_lyrics. წესები ფუნქციის სახელისთვის არის იგივე, რაც ცვლადების სახელისთვის: ასოები, ციფრები და ზოგიერთი სასვენი ნიშანი დაშვებულია, მაგრამ სახელის პირველი სიმბოლო არ შეიძლება იყოს ციფრი. არ შეგიძლია გამოიყენო განსაზღვრული სიტყვა როგორც ფუნქციის სახელი. არ უნდა გქონდეს ცვლადი და ფუნქცია ერთი და იგივე სახელით.სახელის შემდეგ ცარიელი ფრჩხილები მიანიშნებს, რომ ფუნქცია არ იღებს არგუმენტებს. მოგვიანებით გავაკეთებთ ფუნქციას, რომელიც იღებს არგუმენტს, როგორც input - ს.ფუნქციის განსაზღვრების პირველ ხაზს ეწოდება სათაური (header); დანარჩენს - სხეული (body). სათაური უნდა დამთავრდეს ორწერტილით და სხეული უნდა იყოს დაკბილული. დაკბილვა ხდება 4 ჰარით (space). სხეული შეიძლება შეიცავდეს განუსაზღვრელი რაოდენობის ბრძანებებს.ამობეჭდვის ბრძანებაში (print) სტრინგი ჩასმულია ბრჭყალებში. ერთმაგი და ორმაგი ბრჭყალები ერთი და იგივე დანიშნულებისაა. უმეტესობა იყენებს ერთმაგ ბრჭყალებს, გარდა შემთხვევებისა, სადაც ერთმაგი ბრჭყალი გამოიყენება სტრინგში შიგნით. ფუნქციის განსაზღვრებას დიალოგურ რეჟიმში თუ დაწერ, მთარგმნელი დაბეჭდავს ელიფსებს (...)რათა გაგაგებინოს რომ განსაზღვრება არაა დასრულებული. >>> def print_lyrics():... print "I'm a lumberjack, and I'm okay."... print 'I sleep all night and I work all day.'...ფუნქციის დასამთავრებლად უნდა დაბეჭდო ერთი ცარიელი ხაზი. (სკრიპტში ამის გაკეთება არაა აუცილებელი).ფუნქციის გაკეთება ასევე აკეთებს ცვლადს იგივე სახელით. >>> print print_lyrics<function print_lyrics at 0xb7e99e9c>>>> print type(print_lyrics)<type 'function'> print_lyrics - ის მნიშვნელობა არის ფუნქციის ობიექტი რასაც აქვს ტიპი 'function'.ფუნქციის გამოძახების სინტაქსი არის იგივე რაც ჩაშენებული ფუნქციის : >>> print_lyrics() I'm a lumberjack, and I'm okay. I sleep all night and I work all day. როცა გააკეთებ ფუნქციას, შეგიძლია გამოიყენო სხვა ფუნქციებში. მაგალითად, წინა ფუნქცია რომ გამოვიყენოთ, უნდა დავწეროთ ახალი ფუნქცია სახელად repeat_lyrics: def repeat_lyrics(): print_lyrics() print_lyrics() და შემდეგ გამოვიძახოთ repeat_lyrics: >>> repeat_lyrics()I'm a lumberjack, and I'm okay.I sleep all night and I work all day.I'm a lumberjack, and I'm okay.I sleep all night and I work all day. განსაზღვრა და გამოყენება წინა ორივე კოდის ფრაგმენტების გაერთიანებით მთლიანი პროგრამა გამოიყურება ასე : def print_lyrics(): print "I'm a lumberjack, and I'm okay." print 'I sleep all night and I work all day.' def repeat_lyrics(): print_lyrics() print_lyrics() repeat_lyrics() პროგრამა შეიცავს ორ ფუნქციას: print_lyrics და repeat_lyrics. ფუნქციები ხორციელდება ისე, როგორც სხვა ბრძანებები, მაგრამ ეფექტი არის რომ შექმნას ფუნქციური ობიექტები. ფუნქციის შიგნით ბრძანებები არ ხორციელდება, სანამ ფუნქცია არის გამოძახებული და ფუნქციის განსაზღვრებას არ აქვს output.როგორც ელოდებოდი, ჯერ უნდა გააკეთო ფუნქცია სანამ შეგეძლება მისი განხორციელება. სხვა სიტყვებით: function definition has to be executed before the first time it is called. სავარჯიშო 4.2 პროგრამის ბოლო ხაზი აიტანე სულ ზემოთ, ასე რომ ფუნქციას გამოიძახებ განსაზღვრებამდე. გაუშვი პროგრამა და ნახე რა შეცდომა მოხდება. სავარჯიშო 4.3 ფუნქციის გამოძახება დააბრუნე თავის ადგილზე და print_lyricsგანსაზღვრება გადაიტანე repeat_lyrics - ის შემდეგ. რა მოხდება როცა პროგრამასგაუშვებ?
  8. გამონაკლის დაჭერა "ცდის" და "გამონაკლისის" გამოყენებით ადრე ვნახეთ კოდის ნაწილი სადაც გამოვიყენეთ raw_input და int ფუნქციები, რომ წაეკითხა და გაესწორებინა მომხმარებლის მიერ შეყვანილი მთელი რიცხვები. ასევე ვნახეთ რაოდენ მუხანათური შეიძლება ეს იყოს: >>> speed = raw_input(prompt)What...is the airspeed velocity of an unladen swallow?What do you mean, an African or a European swallow?>>> int(speed)ValueError: invalid literal for int()>>> როცა ამ ანგარიშს ვახორციელებთ პითონის ინტერპრეტერში, გამოაქვს შეცდომის წერილი და შემდეგ შევრონის პრომპტი. ამ კოდს თუ ჩავსვამთ პითონის სკრიპტში და ეს შეცდომა მოხდება, სკრიპტი მაშინვე გაჩერდება in its tracks with a traceback. აქაა ფარენჰაიტის ცელსიუსში გადასაკონვერტირებელი მარტივი პროგრამა: inp = raw_input('Enter Fahrenheit Temperature:')fahr = float(inp)cel = (fahr - 32.0) * 5.0 / 9.0print cel ამ კოდს თუ გავუშვებთ და შევიტანთ არამართებულ მონაცემს, გამოიტანს არამეგობრულ მესიჯს: python fahren.pyEnter Fahrenheit Temperature:7222.2222222222python fahren.pyEnter Fahrenheit Temperature:fredTraceback (most recent call last):File "fahren.py", line 2, in <module>fahr = float(inp)ValueError: invalid literal for float(): fred აქ არის პირობითი კავშირის განხორციელების სტრუქტურა (“try / except”) ჩაშენებული პითონში რომ „დაიჭიროს" ამ ტიპის მოსალოდნელი და მოულოდნელი შეცდომები. try დაexcept -ის იდეა იმაშია, რომ იცი ზოგიერთ ინსტრუქციას შეიძლება ჰქონდეს პრობლემა და გინდა დაამატო სხვა პირობებიც იმ შემთხვევისთვის თუ შეცდომა მოხდება. ეს დამატებითი პირობები დაიგნორდება შეცდომა თუ არ მოხდება. try და except -ზე შეგიძლია იფიქრო როგორც "დაზღვევის პოლისზე”.ტემპერატურის კონვერტერი შეგვიძლია დავწეროთ ასეც: inp = raw_input('Enter Fahrenheit Temperature:')try: fahr = float(inp) cel = (fahr - 32.0) * 5.0 / 9.0 print celexcept: print 'Please enter a number' პითონი იწყებს try ბლოკის ბრძანებების განხორციელებას. ყველაფერი თუ კარგა წავა,except ბლოკს გამოტოვებს. გამონაკლის თუ მოხდა try ბლოკში, პითონი გამოტოვებს ამ ბლოკს და განახორციელებს except ბლოკის ბრძანებებს. python fahren2.pyEnter Fahrenheit Temperature:7222.2222222222 python fahren2.pyEnter Fahrenheit Temperature:fredPlease enter a number ამას ეძახიან გამონაკლისის დაჭერას try ბრძანების დახმარებით. ამ მაგალითში exceptხაზი ბეჭდავს შეცდომის წერილს. საერთო ჯამში გამონაკლისის დაჭერა გაძლევს პრობლემის მოგვარების ან კიდევ ერთხელ ცდის, ანდაც პროგრამის ელეგანტურად დასრულების შანსს. Short circuit evaluation of logical expressions პითონი როცა ამუშავებს ლოგიკურ გამოსახულებას, როგორიცაა x >= 2 and (x/y) > 2, ანგარიშობს მარცხნიდან მარჯვნივ, and - ის განსაზღვრებიდან გამომდინარე თუ xნაკლებია ორზე, გამოსახულება x >= 2 არის მცდარი ( False) ასე რომ მთლიანი გამოსახულებაც არის False მიუხედავად იმისა (x/y) > 2 მართალი იქნება თუ მცდარი (True თუ False.).პითონი როცა აღმოაჩენს, რომ არაფერია სასარგებლო ლოგიკური გამოსახულების დანარჩენი ნაწილის გამოანგარიშებაში, ჩერდება და როცა ჩერდება, მაშინ გამოსახულების საბოლოო მნიშვნელობა უკვე ცნობილია. ამას ეძახიან short-circuiting (მოკლე ჩართვა).While this may seem like a fine point, the short circuit behavior leads to a clever technique called the guardian pattern.განვიხილოთ შემდეგი კოდი: >>> x = 6>>> y = 2>>> x >= 2 and (x/y) > 2True>>> x = 1>>> y = 0>>> x >= 2 and (x/y) > 2False>>> x = 6>>> y = 0>>> x >= 2 and (x/y) > 2Traceback (most recent call last):File "<stdin>", line 1, in <module>ZeroDivisionError: integer division or modulo by zero>>> მესამე გამოთვლა მცდარია, იმიტომ რომ პითონი ანგარიშობდა (x / y) სადაც y არის ნული, რამაც გამოიწვია შეცდომა შესრულებისას(runtime error). მაგრამ მეორე გამოთვლაში შეცდომას არ გვაჩვენებს, იმიტომ რომ გამოსახულების პირველი ნაწილი მცდარია x >= 2 ამიტომ (x/y) მოკლე ჩართვის წესის გამო არც დაუთვლია და შეცდომაც არ ამოაგდო.შეგვიძლია ავაგოთ ლოგიკური გამოსახულება სტრატეგიულ ადგილას (დაცვითი გამოთვლით)- სანამ გამოთვლაში შეცდომა მოხდება-როგორც აქ ხდება : >>> x = 1>>> y = 0>>> x >= 2 and y != 0 and (x/y) > 2False>>> x = 6>>> y = 0>>> x >= 2 and y != 0 and (x/y) > 2False>>> x >= 2 and (x/y) > 2 and y != 0Traceback (most recent call last):File "<stdin>", line 1, in <module>ZeroDivisionError: integer division or modulo by zero>>> პირველ ლოგიკურ გამოსახულებაში x >= 2 არის მცდარი, ამიტომ გამოთვლა გაჩერდაand-თან. მეორე ლოგიკურ გამოსახულებაში x >= 2 არის True , მაგრამ y != 0 is False ამიტომ (x/y) - დე გამოთვლა არ მიდის.მესამე ლოგიკურ გამოსახულებაში y != 0 არის (x/y) - ის შემდეგ, ამიტომ გამოსახულება სრულდება შეცდომით.მეორე გამოსახულებაში ვამბობთ რომ y != 0 რაც მოქმედებს როგორც დაცვა, რათა დაზღვეული ვიყოთ, რომ შესრულდეს მარტო (x/y) თუ y არ არის ნული. გამართვა პითონის traceback (კუდი) ჩნდება, როცა შეცდომა შეიცავს ბევრ ინფორმაციას, მაგრამ შეიძლება იყოს გადაჭარბებული განსაკუთრებით მაშინ, როცა არის ბევრი frame (ჩარჩო) . ყველაზე გამოსადეგი ნაწილებია: · რა ტიპის შეცდომა იყო და · სად მოხდა შეცდომა. სინტაქსური შეცდომა როგორც წესი ადვილი საპოვნელია, მაგრამ არის ზოგიერთი მომენტი. უხილავი (Whitespace) შეცდომები შეიძლება იყოს ეშმაკური, იმიტომ რომ გამოტოვებული ადგილები და ტაბები (spaces&tabs) უხილავია და ვაიგნორებთ ხოლმე. >>> x = 5 >>> y = 6 File "<stdin>", line 1 y = 6 ˆ SyntaxError: invalid syntax ამ მაგალითში პრობლემაა მეორე ხაზი, სადაც დაკბილულია ერთი გამოტოვებული ადგილით. თუმცა შეცდომის მესიჯი მიგვითითებს y - ზე, რაც დამაბნეველია. ზოგადად, შეცდომის მესიჯები მიანიშნებს სადაა პრობლემა აღმოჩენილი, მაგრამ სინამდვილეში შეცდომა შეიძლება დაშვებული ყოფილიყო კოდის წინა ნაწილში. ასევე ხდება შესრულების (runtime) შეცდომებისას. დავუშვათ ცდილობ დაითვალო სიგნალის და ხმაურის თანაფარდობა დეციბელებში. ფორმულაა SNRdb =10log10(Psignal/Pnoise). პითონში უნდა დაწერო ამის მსგავსი რამე : import math signal_power = 9 noise_power = 10 ratio = signal_power / noise_power decibels = 10 * math.log10(ratio) print decibels მაგრამ როცა გაუშვებ, გამოაგდებს შეცდომის მესიჯს1: Traceback (most recent call last): File "snr.py", line 5, in ? decibels = 10 * math.log10(ratio) OverflowError: math range error შეცდომის წერილი მიუთითებს მეხუთე ხაზზე, თუმცა იქ ყველაფერი სწორადაა. ნამდვილი შეცდომა რომ იპოვნო, სასარგებლო იქნება ამობეჭდო ratio - ს მნიშვნელობა, რომელიც იქნება 0. პრობლემაა მეოთხე ხაზში, იმიტომ რომ ორი მთელი რიცხვის გაყოფით იწარმოება წილადი. ამ პრობლემის გადასაჭრელად საკმარისია ცვლადები გამოვსახოთ წილადში. ზოგადად, შეცდომის წერილები გეუბნება თუ სად აღმოაჩინა შეცდომა, მაგრამ ხშირადაა რომ იქ არ მომხდარა შეცდომა. 1In Python 3.0, you no longer get an error message; the division operator performs floating-point division even with integer operands. ლექსიკონი body: The sequence of statements within a compound statement. boolean expression: გამოსახულება, რომლის მნიშვნელობაც ან მართალია ან მცდარი. branch: პირობით კავშირებში ბრძანებების ერთ-ერთი ალტერნატიული თანმიმდევრობა. chained conditional: პირობითი კავშირი ალტერნატიული ტოტების სერიით. comparison operator: ერთ-ერთი ოპერატორი, რომელიც ადარებს ოპერანდებს: ==, !=,>, <, >=, და <=. conditional statement: ბრძანება, რომელიც აკონტროლებს განხორციელების დინებას - დამოკიდებულს რამე პირობაზე. condition: ლოგიკური გამოსახულება in a conditional statement, რომელიც განსაზღვრავს თუ რომელი ტოტი უნდა განხორციელდეს. compound statement: ბრძანება, რომელიც შედგება სათაურისგან და სხეულისგან. სათაური მთავრდება ორწერტილით (:). სხეული დაკბილულია სათაურთან შეფარდებით. guardian pattern: სადაც ვაწყობთ ლოგიკურ გამოსახულებას დამატებითი შედარებებით, რომ გაგვიჩნდეს უპირატესობა მოკლე ჩართვის ქცევაზე. logical operator: ერთ-ერთი ოპერატორი, რომელიც აერთიანებს ლოგიკურ გამოსახულებებს: and, or, და not. nested conditional: პირობითი კავშირი, რომელიც ჩანს სხვა პირობითი კავშირის ერთ-ერთ ტოტში. traceback: ფუნქციების სია, რომელიც ხორციელდება. ამოიბეჭდება, როცა მოხდება გამონაკლისი. short circuit: როცა პითონი ანგარიშობს გამოსახულების ნახევარს და ჩერდება, იმიტომ რომ პითონმა იცის გამოსახულების საბოლოო მნიშვნელობა და არ სჭირდება გამოსახულების მეორე ნახევრის გამოთვლაც. სავარჯიშოები სავარჯიშო 3.1 Rewrite your pay computation to give the employee 1.5 times the hourly rate for hours worked above 40 hours. Enter Hours: 45Enter Rate: 10Pay: 475.0 სავარჯიშო 3.2 გადაწერე გადასახადის პროგრამა და გამოიყენე try და except, რომ პროგრამამ მოახერხოს დაბეჭდოს ელეგანტური წერილი არა რიცხვითი მონაცემების შეტანის შემთხვევაში. მაგალითი გვაჩვენებს პროგრამის ორ განხორციელებას: Enter Hours: 20Enter Rate: nineError, please enter numeric inputEnter Hours: fortyError, please enter numeric input სავარჯიშო 3.3 დაწერე პროგრამა პრომპტში ანგარიშით 0.0 - დან 1.0 - მდე. ანგარიში თუ არეალს გასცდება ამობეჭდოს შეცდომა. ანგარიში 0.0 - დან 1.0 - მდე თუ იქნება, ამობეჭდოს შეფასება ცხრილის მიხედვით: Score Grade>= 0.9 A>= 0.8 B>= 0.7 C>= 0.6 D< 0.6 F Enter score: 0.95A Enter score: perfectBad score Enter score: 10.0Bad score Enter score: 0.75C Enter score: 0.5Fგაუშვი პროგრამა რამდენჯერმე - როგორც ნაჩვენებია, რომ გამოსცადო სხვა და სხვა შენატანები.
  9. პროგრამის ასაშენებელი ბლოკები შემდგეგ თავებში ჩვენ ვისწავლით უფრო მეტს პითონის ლექსიკონის, წინადადების სტრუქტურის, პარაგრაფის სტრუქტურის და ისტორიის სტრუქტურის შესახებ. ვისწავლით პითონის მძლავრი შესაძლებლობების შესახებ და თუ როგორ დავალაგოთ ეს შესაძლებლობები ისე, რომ გავაკეთოთ სასარგებლო პროგრამა. არის რამდენიმე არც ისე მაღალი დონის აბსტაქტული ნიმუში, რომელსაც გამოვიყენებთ პროგრამის შესადგენად. ეს კონსტრუქციები გამოიყენება არა მარტო პითონში, არამედ მანქანის ენიდან დაწყებული ყველა პროგრამირების ენაში. შეყვანა (ინფორმაციის) input : მონაცემების მიღება "გარედან". ეს შეიძლება იყოს მონაცემების წაკითხვა ფაილიდან ან რაიმე სენსორული მოწყობილობიდან, როგორიცაა მიკროფონი ან ჯი-პი-ესი. შენს საწყის პროგრამებში ინფორმაციის შეყვანა გამოიხატება მომხმარებლის მიერ კლავიატურაზე აკრეფილი მონაცემებით. გამოტანა (ინფორმაციის) output: პროგრამის შედეგის ეკრანზე გამოტანა ან ფაილში შენახვა ან ჩაწერა მოწყობილობისთვის, მაგ: დინამიკისთვის რომ გააჟღეროს მუსიკა ან ლაპარაკი. თანმიმდევრული განხორციელება sequential execution : ბრძანებების რიგ-რიგობით შესრულება - ისე როგორც მითითებულია სკრიპტში. პირობითი განხორციელება conditional execution : შეამოწმოს პირობები და შეასრულოს ან გამოტოვოს ბრძანებები. განმეორებადი განხორციელება repeated execution : ბრძანებ(ებ)ის შეასრულება არაერთხელ - როგორც წესი რამდენიმე ვარიაცია. განმეორებითი გამოყენება reuse : დაწერე ინსტრუქცია ერთხელ, დაარქვი სახელი და შენს პროგრამაში გამოიყენე როცა დაგჭირდება. სიმართლე გითხრა , ეს ყველაფერი ძალიან მარტივი ჩანს, მაგრამ ეს არასდროსაა ესეთი მარტივი. ესაა როგორც თქვა, რომ სეირნობაა ერთი ფეხის გადაბიჯება მეორეს წინ. პროგრამირების ხელოვნება იმაში მდგომარეობს, რომ ეს მთავარი ელემენტები დააწყო ისე, რომ მომხმარებლისთვის გააკეთოს რაიმე სასარგებლო. ზემოთ მოყვანილი სიტყვების დასათვლელი პროგრამა იყენებს ყველა ნიმუშს ერთის გარდა. 1.10 რა შეიძლება გაკეთდეს არასწორად? პითონთან წინა ლაპარაკის დროს როგორც ვნახეთ , ძალიან ზუსტად უნდა დავწეროთ პითონის კოდი. მცირე გადახრა ან შეცდომაც კი პითონს დააბნევს. დამწყები პროგრამისტები ხშირად ფიქრობენ, რომ რადგან პითონი შედომისთვის ადგილს არ ტოვებს, აშკარაა რომ ის უნამუსო ,საძულველი და სასტიკია. რომ პითონს აქვს მათდამი პირადი შუღლი და ამ შუღლის გამო, მათ მიერ შესანიშნავად დაწერილ პროგრამას ასაღებს როგორც ნაგავს მხოლოდ იმიტომ, რომ ისინი დატანჯოს! >>> primt 'Hello world!' File "", line 1 primt 'Hello world!' ˆ SyntaxError: invalid syntax >>> primt 'Hello world' File "", line 1 primt 'Hello world' ˆ SyntaxError: invalid syntax >>> I hate you Python! File "", line 1 I hate you Python! ˆ SyntaxError: invalid syntax >>> if you come out of there, I would teach you a lesson File "", line 1 if you come out of there, I would teach you a lesson ˆ SyntaxError: invalid syntax >>> პითონთან კამათი უსარგებლოა. ის უბრალოდ უემოციო ხელსაწყოა, რომელიც ყოველთვის მზადაა გემსახუროს. შეცდომის მესიჯები არასასიამოვნოდ კი გამოიყურება, მაგრამ ეს მესიჯები ნიშნავს რომ პითონს დახმარება სჭირდება, რომ ვერ გაიგო შენი ნაწერი და გთხოვს უკეთ დაწერო. პითონი ძაღლს ჰგავს. უყვარხარ უპირობოდ, იცის რამდენიმე სიტყვა, გიყურებს სასიამოვნო გამომეტყველებით (>>>) და გელოდება უთხრა ისეთი რამე, რასაც გაიგებს. როცა პითონი ამბობს “SyntaxError:invalid syntax” , ეს უბრალოდ კუდს აქიცინებს და გეუბნება, რომ "რაღაცას ამბობდი, მაგრამ ვერ გავიგე რას გულისხმობდი. ამის მიუხედავად გთხოვ გააგრძელე ჩემთან ლაპარაკი (>>>) . " რაც უფრო გაიზდება შენი გამოცდილება პროგრამირებაში, შეხვდები 3 ძირითად შეცდომას: სინტაქსის შეცდომას Syntax errors : ესაა პირველი შეცდომები, რომელსაც დაუშვებ ; სხვათაშორის ყველაზე ადვილად გამოსწორებადი შეცდომა. Syntax errors ნიშნავს რომ დაარღვიე პითონის "გრამატიკის წესები“. პითონი მიგანიშნებს სტრიქონს და ასოს, სადაც შეცდომაა დაშვებული. სინტაქსის შეცდომაში ცოტათი რთული მხოლოდ ისაა, რომ ხანდახან შეცდომა რომელსაც გამოსწორება სჭირდება დაშვებული იქნა პროგრამის წინა სტრიქონებში და არა მხოლოდ იქ სადაც პითონმა მიგანიშნა. ასე რომ სტრიქონი და ასო რომელზეც პითონი სინტაქსის შეცდომას მიანიშნებს, შეიძლება იყოს საწყისი წერტილი შენი გამოძიების. ლოგიკის შეცდომა Logic errors :ლოგიკის შეცდომაა, როცა სინტაქსი გამართულია, მაგრამ შეცდომაა წესებთან დაკავშირებით ან წესების ურთიერთშეთანხმებასთან დაკავშირებით. ლოგიკის შეცდომის კარგი მაგალითია "დალიე წყალი შენი ბოთლიდან, ჩადე ზურგჩანთაში, გაისეირნე ბიბლიოთეკაში და შემდეგ წყალი უკან ბოთლში დააბრუნე." სემანტიკური შეცდომა Semantic errors: სემანტიკური შეცდომაა როცა ზომების მიღების აღწერა სინტაქსურად სწორია, მაგრამ პროგრამაში დაშვებულია მარტივი შეცდომა. პროგრამა სწორადაა დაწერილი მაგრამ არ აკეთებს იმას რისთვისაც იყო განზრახული. მარტივი მაგალითია ; დავუშვათ მეგობარს ასწავლით გზას "... როცა გზაჯვარედინთან მიხვალ, ბენზინგასამართ სადგურთან მოუხვიე მარცხნივ, გაიარე 1 მილი და წითელ რესტორანს დაინახავ შენგან მარცხნივ." მოგვიანებით მეგობარი გირეკავს და გეუბნება, რომ ისაა ფერმაში და მის უკან ბეღელია და არანაირი ნიშანი არაა, რომ აქ სადმე რესტორანია. შემდეგ შენ ეკითხები "ბენზინგასამართ სადგურთან მარჯვნივ მიუხვიე თუ მარცხნივ?" და ის გპასუხობს, რომ როგორც ასწავლე ისე წავიდა და შენ ამბობ " ძალიან ვწუხვარ, იმიტომ რომ ჩემი ინსტრუქცია სინტაქსურად სწორი იყო, მაგრამ დავუშვი პატარა სემანტიკური შეცდომა." ყველა ტიპის შეცდომის მიუხედავად პითონი ყველანაირად ეცდება გააკეთოს რაც სთხოვეთ. პროგრამის ასაშენებელი ბლოკები შემდგეგ თავებში ჩვენ ვისწავლით უფრო მეტს პითონის ლექსიკონის, წინადადების სტრუქტურის, პარაგრაფის სტრუქტურის და ისტორიის სტრუქტურის შესახებ. ვისწავლით პითონის მძლავრი შესაძლებლობების შესახებ და თუ როგორ დავალაგოთ ეს შესაძლებლობები ისე, რომ გავაკეთოთ სასარგებლო პროგრამა. არის რამდენიმე არც ისე მაღალი დონის აბსტაქტული ნიმუში, რომელსაც გამოვიყენებთ პროგრამის შესადგენად. ეს კონსტრუქციები გამოიყენება არა მარტო პითონში, არამედ მანქანის ენიდან დაწყებული ყველა პროგრამირების ენაში. შეყვანა (ინფორმაციის) input : მონაცემების მიღება "გარედან". ეს შეიძლება იყოს მონაცემების წაკითხვა ფაილიდან ან რაიმე სენსორული მოწყობილობიდან, როგორიცაა მიკროფონი ან ჯი-პი-ესი. შენს საწყის პროგრამებში ინფორმაციის შეყვანა გამოიხატება მომხმარებლის მიერ კლავიატურაზე აკრეფილი მონაცემებით. გამოტანა (ინფორმაციის) output: პროგრამის შედეგის ეკრანზე გამოტანა ან ფაილში შენახვა ან ჩაწერა მოწყობილობისთვის, მაგ: დინამიკისთვის რომ გააჟღეროს მუსიკა ან ლაპარაკი. თანმიმდევრული განხორციელება sequential execution : ბრძანებების რიგ-რიგობით შესრულება - ისე როგორც მითითებულია სკრიპტში. პირობითი განხორციელება conditional execution : შეამოწმოს პირობები და შეასრულოს ან გამოტოვოს ბრძანებები. განმეორებადი განხორციელება repeated execution : ბრძანებ(ებ)ის შეასრულება არაერთხელ - როგორც წესი რამდენიმე ვარიაცია. განმეორებითი გამოყენება reuse : დაწერე ინსტრუქცია ერთხელ, დაარქვი სახელი და შენს პროგრამაში გამოიყენე როცა დაგჭირდება. სიმართლე გითხრა , ეს ყველაფერი ძალიან მარტივი ჩანს, მაგრამ ეს არასდროსაა ესეთი მარტივი. ესაა როგორც თქვა, რომ სეირნობაა ერთი ფეხის გადაბიჯება მეორეს წინ. პროგრამირების ხელოვნება იმაში მდგომარეობს, რომ ეს მთავარი ელემენტები დააწყო ისე, რომ მომხმარებლისთვის გააკეთოს რაიმე სასარგებლო. ზემოთ მოყვანილი სიტყვების დასათვლელი პროგრამა იყენებს ყველა ნიმუშს ერთის გარდა. რა შეიძლება გაკეთდეს არასწორად? პითონთან წინა ლაპარაკის დროს როგორც ვნახეთ , ძალიან ზუსტად უნდა დავწეროთ პითონის კოდი. მცირე გადახრა ან შეცდომაც კი პითონს დააბნევს. დამწყები პროგრამისტები ხშირად ფიქრობენ, რომ რადგან პითონი შედომისთვის ადგილს არ ტოვებს, აშკარაა რომ ის უნამუსო ,საძულველი და სასტიკია. რომ პითონს აქვს მათდამი პირადი შუღლი და ამ შუღლის გამო, მათ მიერ შესანიშნავად დაწერილ პროგრამას ასაღებს როგორც ნაგავს მხოლოდ იმიტომ, რომ ისინი დატანჯოს! >>> primt 'Hello world!' File "<stdin>", line 1 primt 'Hello world!' ˆ SyntaxError: invalid syntax >>> primt 'Hello world' File "<stdin>", line 1 primt 'Hello world' ˆ SyntaxError: invalid syntax >>> I hate you Python! File "<stdin>", line 1 I hate you Python! ˆ SyntaxError: invalid syntax >>> if you come out of there, I would teach you a lesson File "<stdin>", line 1 if you come out of there, I would teach you a lesson ˆ SyntaxError: invalid syntax >>> პითონთან კამათი უსარგებლოა. ის უბრალოდ უემოციო ხელსაწყოა, რომელიც ყოველთვის მზადაა გემსახუროს. შეცდომის მესიჯები არასასიამოვნოდ კი გამოიყურება, მაგრამ ეს მესიჯები ნიშნავს რომ პითონს დახმარება სჭირდება, რომ ვერ გაიგო შენი ნაწერი და გთხოვს უკეთ დაწერო. პითონი ძაღლს ჰგავს. უყვარხარ უპირობოდ, იცის რამდენიმე სიტყვა, გიყურებს სასიამოვნო გამომეტყველებით (>>>) და გელოდება უთხრა ისეთი რამე, რასაც გაიგებს. როცა პითონი ამბობს “SyntaxError:invalid syntax” , ეს უბრალოდ კუდს აქიცინებს და გეუბნება, რომ "რაღაცას ამბობდი, მაგრამ ვერ გავიგე რას გულისხმობდი. ამის მიუხედავად გთხოვ გააგრძელე ჩემთან ლაპარაკი (>>>) . " რაც უფრო გაიზდება შენი გამოცდილება პროგრამირებაში, შეხვდები 3 ძირითად შეცდომას: სინტაქსის შეცდომას Syntax errors : ესაა პირველი შეცდომები, რომელსაც დაუშვებ ; სხვათაშორის ყველაზე ადვილად გამოსწორებადი შეცდომა. Syntax errors ნიშნავს რომ დაარღვიე პითონის "გრამატიკის წესები“. პითონი მიგანიშნებს სტრიქონს და ასოს, სადაც შეცდომაა დაშვებული. სინტაქსის შეცდომაში ცოტათი რთული მხოლოდ ისაა, რომ ხანდახან შეცდომა რომელსაც გამოსწორება სჭირდება დაშვებული იქნა პროგრამის წინა სტრიქონებში და არა მხოლოდ იქ სადაც პითონმა მიგანიშნა. ასე რომ სტრიქონი და ასო რომელზეც პითონი სინტაქსის შეცდომას მიანიშნებს, შეიძლება იყოს საწყისი წერტილი შენი გამოძიების. ლოგიკის შეცდომა Logic errors :ლოგიკის შეცდომაა, როცა სინტაქსი გამართულია, მაგრამ შეცდომაა წესებთან დაკავშირებით ან წესების ურთიერთშეთანხმებასთან დაკავშირებით. ლოგიკის შეცდომის კარგი მაგალითია "დალიე წყალი შენი ბოთლიდან, ჩადე ზურგჩანთაში, გაისეირნე ბიბლიოთეკაში და შემდეგ წყალი უკან ბოთლში დააბრუნე." სემანტიკური შეცდომა Semantic errors: სემანტიკური შეცდომაა როცა ზომების მიღების აღწერა სინტაქსურად სწორია, მაგრამ პროგრამაში დაშვებულია მარტივი შეცდომა. პროგრამა სწორადაა დაწერილი მაგრამ არ აკეთებს იმას რისთვისაც იყო განზრახული. მარტივი მაგალითია ; დავუშვათ მეგობარს ასწავლით გზას "... როცა გზაჯვარედინთან მიხვალ, ბენზინგასამართ სადგურთან მოუხვიე მარცხნივ, გაიარე 1 მილი და წითელ რესტორანს დაინახავ შენგან მარცხნივ." მოგვიანებით მეგობარი გირეკავს და გეუბნება, რომ ისაა ფერმაში და მის უკან ბეღელია და არანაირი ნიშანი არაა, რომ აქ სადმე რესტორანია. შემდეგ შენ ეკითხები "ბენზინგასამართ სადგურთან მარჯვნივ მიუხვიე თუ მარცხნივ?" და ის გპასუხობს, რომ როგორც ასწავლე ისე წავიდა და შენ ამბობ " ძალიან ვწუხვარ, იმიტომ რომ ჩემი ინსტრუქცია სინტაქსურად სწორი იყო, მაგრამ დავუშვი პატარა სემანტიკური შეცდომა." ყველა ტიპის შეცდომის მიუხედავად პითონი ყველანაირად ეცდება გააკეთოს რაც სთხოვეთ. სწავლის მოგზაურობა ისეთი შთაბეჭდილება თუ გექმნება რომ ისე ვერ პროგრესირებ როგორც წარმოგედგინა, არაუშავს. როცა ლაპარაკს სწავლობდი შენთვის პრობლება არ ყოფილა თავიდან რამდენიმე წლის მანძილზე ლაპარაკის მაგივრად თუ სასაცილო ხმებს გამოსცემდი . ყველაფერი კარგად იყო, როცა 6 თვე დაგჭირდა მარტივი სიტყვებიდან მარტივ წინადადებებზე გადასასვლელად და 5-6 წელი წინადადებებიდან - აბზაცებზე და კიდე რამდენიმე წელი, რომ დაგეწერა საინტერეო, სრული ისტორია. ჩვენ გვინდა რომ ვისწავლოთ პითონი ჩქარა, ასე რომ სწავლას დავუთმობთ იგივე დროს მომდევნო რამდენიმე თავი. მაგრამ რადგან ახალ ენას სწავლობ, მიაქვს ბევრი დრო სანამ ბუნებრივად შეიგრძნობ . ეს იწვევს ცოტა დაბნეულობას და კიდევ და კიდევ ვეძებთ პასუხებს თემებში, რომ შევადგინოთ მთლიანი სურათი პატარ-პატარა ფრაგმენტებით. როცა ეს წიგნი დაწერილია ხაზოვნად და თუ კურსს გადიხარ, პროგრესიც იქნება ხაზოვანი სახის . არ იყოყმანო რომ იყო არა-ხაზოვანი მიზნის მისაღწევად. გადახედე წინა და მომდევნო თავებს. იმ მასალის გადახედვა, რომელიც ჯერ არ გისწავლია უფრო მარტივს გახდის პასუხს კითხვაზე "რატომ უნდა ვისწავლო პროგრამირება“. წინა მასალების გაცნობა, წინა სავარჯიშოების გაკეთება გაგაანალიზებინებს, რომ ნამდვილად გისწავლია რაღაც, გისწავლია ისაც კი, რაც ადრე გეჩვენებოდა რომ შეუძლებელია. ჩვეულებრივ, როცა შენ სწავლობ პირველ პროგრამირების ენას, აქაა რამდენიმე მშვენიერი შეძახილი "ჰუჰ", როცა გეგონება რომ უზარმაზარი ლოდი დაამუშავე უროთი და საჭრისით და დაინახე, რომ გაგიკეთებია ლამაზი ქადაკება. რამე თუ ძალიან ძნელად გეჩვენება, არაა აუცილებელი ღამეები ათენო. შეისვენე, გამოიძენე, წაიხემსე, გაანალიზე რაშია პრობლემა და დასვენებული მიუბრუნდი სწავლას. გარწმუნებ, რომ როცა ისწავლი პროგრამირების ცნებებს და გადახედავ ამ წიგნის წინა თავებს, მიხვდები რომ ყველაფერი ძალიან მარტივი იყო. სპეციალური ტერმინოლოგიის ლექსიკონი bug: შეცდომა პროგრამაში CPU: ცენტრალური პროცესორი (ცპ) compile: მაღალი დონის პროგრამული ენიდან დაბალი დონის პროგრამულ ენაზე თარგმნა . high-level language: მაღალი დონის ენა, როგორიცაა პითონი - რომელიც შექმნილია იმისთვის, რომ ადამიანმა ადვილად წეროს და იკითხოს. interactive mode: პითონის მთარგმნელის გამოყენება აქტიურ, დიალოგურ რეჟიმში - ბრძანებების წერა ბრძანებათ ველში (პრომპტ -ში ). interpret: პროგრამის ერთ-ერთ ხაზად განხორციელება low-level language პროგრამირების ენა, რომელიც გაკეთებულია იმისთვის რომ კომპიუტერისთვის იყოს ადვილი განხორციელება. ასევე ეძახიან მანქანის კოდს ან assembly language machine code: დაბალი დონის ენა პროგრამისთვის რომელიც პირდაპირ ხორციელდება ცენტრალური პროცესორის მიერ. main memory: ინახავას პროგრამებს და მონაცმებს სანამ ენერგია მიეწოდება. parse: პროგრამის განხილვა და სინტაქსური სტრუქტურის შემოწმება. portability: პროგრამის შესაძლებლობა რომ იმუშავოს ერთზე მეტ კომპპიუტერზე. print statement: ინსტრუქცია რის გამოც პითონის მთარგმნელს მნიშვნელობა გამოაქვს ეკრანზე. problem solving: პრობლემის ფორმულირების პროცესი, გამოსავლის გამოხატვა და პოვნა. prompt: როცა პროგრამას ეკრანზე გამოაქვს მესიჯი და პაუზდება, რათა მომხმარებელს მიეცეს დაწერის საშუალება. secondary memory: ინახავს პროგრამებს და მონაცემებს მაშინც კი, როცა ენერგია არ მიეწოდება. უფრო ნელი, ვიდრე ძირითადი მეხსიერება. დამატებითი მეხსიერების მაგალითებია USB, მყარი დისკი და.ა.შ. semantics: პროგრამის მნიშვნელობა semantic error: შეცდომა პროგრამაში, რომელიც პროგრამას აკეთებინებს ისეთ რამეს რისთვისაც არაა შექმნილი. source code: პროგრამა მაღალი დონი ენაზე. 1.13 სავარჯიშოები სავარჯიშო 1. 1 რა არის დამატებითი მეხსიერების ფუნქცია კომპიუტერში? ა) ყველა პროგრამის და დათვლების განხორციელება ბ) ინტერნეტში ვებ-გვერდების პოვნა გ) ინფორმაციის ხანგრძლივი შენახვა დ)Take input from the user სავარჯიშო 1.2 რა არის პროგრამა? სავარჯიშო 1.3 რა არის განსხვავება კომპილატორსა და მთარგმნელს შორის? სავარჯიშო 1.4 აქედან რომელი შეიცავს "მანქანის ენას" ა) პითონის მთარგმნელი ბ) კლავიატურა გ) პითონის პროგრამა დ) სიტყვის დამუშავების დოკუმენტი სავარჯიშო 1.5 ამ კოდში რა არის არასწორად? სავარჯიშო 1.6 პითონის ხაზის დამთავრების მერე, კომპიუტერში სად ინახება ისეთი ცვლადი როგორიც "X” არის? x = 123 ა) ცპ - ში ბ) ძირითად მეხსიერებაში გ) დამატებითი მეხსიერებაში დ) შიდა მოწყობილებებში ე) გარე მოწყობილებებში სავარჯიშო 1.7 რას ამობეჭდავს პროგრამა? x = 43 x = x + 1 print x ა) 43 ბ) 44 გ) x + 1 დ) x = x + 1 მათემატიკური შეცდომაა სავარჯიშო 1.8 შეადარე თითოეული ნაწილი ადამიანს. (1) Central processing unit, (2) Main Memory, (3) Secondary Memory, (4) Input Device, and (5) Output Device. მაგალითად : ადამიანში რას შეადარებდი ცპ-ს ? სავარჯიშო 1.9 როგორ გავასწოროთ "სინტაქსური შეცდომა"? წყარო:http://pythongeo.blogspot.com/
  10. ეს არის ჩემს მიერ დასკანერებული, დამუშავებული და PDF ფაილად გაკეთებული 22 გვერდიანი სკანავის #11 პარაგრაფი, კერძოდ 1992 წლის გამოცემის. სკოლაში პროგრამით სტერეომეტრია მიწევს და აქედანაც მინდოდა რომ ამოცენები გამეკეთებინა ქართული ინტერნეტ სივრცე კიდევ მათემატიკისათვის მაინცდამაინც არ იწყხებს თავს, ამიტომ გადავწყვიტე ჩემით მომეგვარებინა პრობლემა... თქვენც გაგიზიარებთ ამ ნაწილს, მაინც მათემატიკის მოყვარული ხალხია აქ ზოგი და თუ უნდა გადაავლოს თვალი :download:
×