Codex-ის პირველი დავალება: მცირე ცვლილება კოდში

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

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

Codex-ის პირველი დავალება ერთ ქცევას დაუკავშირე

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

OpenAI-ის Codex CLI გზამკვლევის (წყარო 1) მიხედვით, Codex-ს შეუძლია ფაილების წაკითხვა, შეცვლა და ადგილობრივი ბრძანებების გაშვება. ამიტომ სავარჯიშოსთვის ცალკე საქაღალდე გამოიყენე და მნიშვნელოვანი სამუშაო ფაილები იქ არ მოათავსო.

შექმენი ორი ფაილი, tags.py და test_tags.py. გაუშვი დავალება ამ საქაღალდეში გახსნილ Codex-ის პროექტში ან სესიაში. ეს სტატია Codex-ის ინსტალაციას არ განიხილავს; სავარჯიშო უკვე გამართულ გარემოს ეყრდნობა.

მოსალოდნელი შედეგი კოდის შეცვლამდე დაწერე

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

მაგალითად, [' AI ', 'ai', '', 'Codex', 'codex', ' '] უნდა გახდეს ['ai', 'codex']. სწორედ ეს არის დავალების დასრულების ერთ-ერთი შემოწმებადი პირობა.

დუბლიკატები დამუშავების შემდეგ შეადარე. თუ ჯერ საწყის მნიშვნელობებს შეადარებ, ' AI ' და 'ai' განსხვავებული ელემენტები იქნება და ორივე დარჩება.

ხარვეზი პატარა მაგალითით გაიმეორე

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

def normalize_tags(tags):
    return sorted(set(tags))

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

test_tags.py-ში ჩასვი მოთხოვნებზე აგებული ხუთი ტესტი:

import unittest
from tags import normalize_tags


class NormalizeTagsTests(unittest.TestCase):
    def test_normalizes_and_deduplicates(self):
        self.assertEqual(
            normalize_tags([" AI ", "ai", "", "Codex", "codex", "  "]),
            ["ai", "codex"],
        )

    def test_preserves_first_seen_order(self):
        self.assertEqual(normalize_tags(["Codex", "AI", "codex"]),
                         ["codex", "ai"])

    def test_empty_input(self):
        self.assertEqual(normalize_tags([]), [])

    def test_whitespace_only(self):
        self.assertEqual(normalize_tags(["", " ", "\t"]), [])

    def test_rejects_non_string(self):
        with self.assertRaises(TypeError):
            normalize_tags(["ai", 7])

ორივე ფაილის საქაღალდეში გაუშვი:

python3 -m unittest -v test_tags

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

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

Codex-ს მიეცი მიზანი, საზღვრები და შემოწმების ბრძანება

კოდის განმარტებისთვის შეგიძლია ჯერ სთხოვო: „წაიკითხე tags.py და ამიხსენი, რატომ ვერ სრულდება მოთხოვნები. ჯერ ფაილები არ შეცვალო.“ როცა ახსნა გასაგებია, კონკრეტული დავალება მიეცი:

მიზანი: tags.py-ში normalize_tags ფუნქციამ
ნიშნულების სია შეთანხმებული წესებით დაამუშაოს.

ჯერ წაიკითხე tags.py, test_tags.py და შესაბამისი
პროექტის ინსტრუქცია, თუ ასეთი ფაილი არსებობს.
აჩვენე მოკლე გეგმა და ცვლილებამდე დაელოდე ჩემს თანხმობას.

ქცევა:
- გამოიყენე strip() და lower();
- ამოიღე ცარიელი მნიშვნელობები;
- დუბლიკატები დამუშავების შემდეგ შეადარე;
- შეინარჩუნე პირველი გამოჩენის თანმიმდევრობა;
- არასტრიქონულ ელემენტზე წარმოქმენი TypeError.

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

შემოწმება: python3 -m unittest -v test_tags
დასრულებისას აჩვენე შეცვლილი კოდი, გაშვებული ბრძანება,
მისი შედეგი და დარჩენილი შეზღუდვები.
თუ შემოწმება ვერ გაუშვი, მიზეზი ზუსტად მიუთითე.

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

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

წაიკითხე ცვლილება და ტესტები ხელახლა გაუშვი

მოთხოვნების დამაკმაყოფილებელი ერთ-ერთი ვარიანტი ასეთია. გეგმის დამტკიცების შემდეგ tags.py-ის შიგთავსი ამ კოდით შეიძლება შეიცვალოს:

def normalize_tags(tags):
    result = []
    seen = set()
    for tag in tags:
        if not isinstance(tag, str):
            raise TypeError("tags must contain only strings")
        value = tag.strip().lower()
        if value and value not in seen:
            seen.add(value)
            result.append(value)
    return result

seen უკვე დამატებულ მნიშვნელობებს ინახავს, result კი მათ თანმიმდევრობას. ახალი ნიშნული შედეგში მხოლოდ მაშინ ემატება, თუ დამუშავების შემდეგ ცარიელი არ არის და ჯერ არ შეგვხვედრია.

strip() სტრიქონის კიდეებზე არსებულ სიცარიელეებს შლის, ხოლო lower() ასოების ქვედა რეგისტრში გადაყვანას ასრულებს. ეს ქცევა აღწერილია Python-ის სტრიქონების დოკუმენტაციაში (წყარო 5).

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

ცვლილების მიღებამდე შეამოწმე:

• მხოლოდ შეთანხმებული ფაილი შეიცვალა თუ არა;
• ფუნქციის სახელი და შემავალი პარამეტრი შენარჩუნებულია თუ არა;
• ტესტების მოთხოვნები შესუსტებული ხომ არ არის;
• ნამდვილად გაეშვა თუ არა მითითებული ბრძანება;
• ხომ არ დაემატა დავალებისთვის არასაჭირო პაკეტი ან ქსელური მოქმედება.

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

თუ Codex ვერ ამოწმებს შედეგს, დაბრკოლება დააზუსტე

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

თუ კოდი სწორად მუშაობს, მაგრამ ცვლილება ზედმეტად ფართოა, კონკრეტული საზღვარი გაიმეორე: „დატოვე მხოლოდ normalize_tags-ის ცვლილება; სხვა ფაილების გაუმჯობესება ამ დავალებაში არ შედის.“ სხვა ადამიანების ცვლილებების ბრმად გაუქმება არ მოითხოვო.

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

ხშირი კითხვები Codex-ის პირველ დავალებაზე

შემიძლია პირველი დავალება ქართულად დავწერო?

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

პირველი ცდისთვის მთელი აპის შექმნა ჯობს?

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

თუ ტესტები წარმატებით დასრულდა, კოდი ავტომატურად უნდა გამოვაქვეყნო?

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

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

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

წყაროების სრული მისამართები

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

1. OpenAI: Codex CLI: https://learn.chatgpt.com/docs/codex/cli
2. Python: unittest: https://docs.python.org/3/library/unittest.html#command-line-interface
3. OpenAI: Prompting: https://learn.chatgpt.com/docs/prompting
4. OpenAI: Permissions: https://learn.chatgpt.com/docs/permission-modes
5. Python: String methods: https://docs.python.org/3/library/stdtypes.html#str.strip