[მუსიკის დაკვრა]
EZRA Zigmond: Hi, ყველას.
მადლობა გამოდის დღეს.
ეს სემინარი "Python Web Apps ერთად Flask ".
>> ასე რომ, მე იქნება საუბარი ცოტა შესახებ, თუ რატომ
დაგვჭირდება გამოიყენოთ Flask რათა ვებ apps Python, როგორც ეწინააღმდეგებოდა
ზოგიერთი სხვა ფარგლებში out არსებობს, ისევე, Django, რომელიც არის ყველაზე ცნობილი.
ქვესათაური "და peewee ", რომელიც არის ის,
ჩვენ ვაპირებთ, რომ გაიგო, თუ როგორ ურთიერთქმედება SQL მონაცემთა ბაზებთან.
რაც ეს ნამდვილად კარგია.
>> ასე რომ, აქ მხოლოდ სწრაფი rundown რაც მე მინდა წასვლა.
ასე რომ, პირველი, მხოლოდ ერთი slide რომ იქნება quickstart,
რომელიც, თუ როგორ უნდა ყველაფერს შეიქმნა თქვენს კომპიუტერში.
მე ვაპირებ უნდა დემონსტრირებას ამ ჩემს ადგილობრივი Mac მანქანა,
მხოლოდ იმიტომ, რომ იქ, სადაც მე ვაკეთებ ამ ადრე, მე ყველაზე კომფორტულად,
მაგრამ ეს ნამდვილად შესაძლებელია CD50 IDE.
>> ასე რომ, მას შემდეგ, რაც მე მინდა, დანერგვა რა Flask არის,
და დარწმუნება იმაში, თუ რატომ უნდა გამოიყენოს იგი, პირველ რიგში.
ამის შემდეგ, მე მივცემ სწრაფი მაგალითად, თუ რა თქვენ
გავაკეთებ Flask, სწრაფი მაგალითად რა შეგიძლიათ გააკეთოთ peewee,
და მერე გაჩვენებთ უფრო სრული მაგალითად განცხადება
რომ ერთად, რომ ჩვენ შეგიძლიათ გავლა ერთად.
>> და ბოლოს, ამ ბოლო slide, მაქვს
გარკვეული რესურსები, რომ გადავხედავთ შემოსული დამატებითი ინფორმაცია.
ეს არ არის სრული სამეურვეო თუ როგორ გამოიყენოთ Flask.
და მე იმედი მაქვს, რომ დატოვოს გარკვეული დრო შეკითხვებს.
ვინმეს თვალს ადგილობრივად, მხოლოდ როგორიცაა, ყვირილი შუა
თუ თქვენ გაქვთ რაიმე შეკითხვები.
>> ასე რომ, სწრაფი ინსტალაცია პერსონალი, თუ გვინდა, რომ დაიცვას გასწვრივ,
ან თუ გსურთ, რომ ამ up საკუთარი მანქანა,
მე ვაპირებ იყოს გამოყენებით Python 2.7.10.
Flask აკეთებს მუშაობა Python 3, მაგრამ მე მინდა,
გამოყენებით Python 2, იმიტომ, რომ იქ ზოგიერთი Python პაკეტი, რომელიც
არ მუშაობს 3 ჯერ.
თუ თქვენ არ pip დაყენებული, რომელიც არის Python პაკეტი მენეჯერი,
მე ვფიქრობ, რომ თუ თქვენი პითონი არის მეტია ან ტოლია 2.7.9,
თქვენ გაქვთ დაყენებული უკვე, ეს სუპერ მარტივი ინსტალაცია ამ პაკეტების.
>> შეგიძლიათ გააკეთოთ pip ინსტალაცია კოლბაში, pip დააყენოთ peewee,
როგორც წესი, თქვენ უნდა აწარმოებს sudo მხოლოდ ისე, რომ უფლებები შეიმუშაოს.
და, თუ თქვენ იყენებთ super ძველი ვერსია Python,
ვურჩევ განახლება თქვენი Python, ან გამოყენებით EasyInstall დააყენოთ pip.
ასე რომ, მომდევნო კითხვაზე, თუ რა არის Flask?
და ვფიქრობ, პირველი გონივრული შეკითხვა მე გვაინტერესებდა
დიდი ხნის განმავლობაში, რა არის ვებ app?
იმის გამო, რომ ის სიტყვა, რომელიც მე ვფიქრობ დააგდეს გარშემო ბევრი
რომ მე არ ვიცი.
და მე ვფიქრობ, რომ საუკეთესო მაგალითად, თუ რა ვებ app არის,
ნამდვილად არის CS50 ფინანსთა, სადაც ეს ნამდვილად არ არის მხოლოდ ნახვა,
მაგრამ ეს არის ის, რაც თქვენ შეიძლება სახის ურთიერთქმედება.
არსებობს მომხმარებლის ანგარიშები და ყველა სახის სხვადასხვა რამ.
ასე რომ, სადაც ზუსტად თქვენ მიაპყროს ხაზს რა არის ნახვა,
და რა არის web app, არის ერთგვარი თვითნებური, მაგრამ ვფიქრობ, იდეა,
ეს რაღაც უფრო მეტია, ვიდრე ნახვა და ეს არის სასარგებლო პროგრამა.
>> ასე რომ, Flask არის ჩარჩო მიღების ვებ apps გამოყენებით Python.
და იმედია, წლის ბოლოსთვის ეს, მე დაგარწმუნებთ
რომ თქვენ შეიძლება რეალურად რაღაც დავწერო მოსწონს CS50 ფინანსთა გამოყენებით Python, რომელიც მე
როგორც ბევრი უკეთესია, ვიდრე PHP, პირადად.
>> ასე რომ, Flask არის, ისინი უწოდებენ microframework, რომლითაც,
ისინი გულისხმობენ, რომ ეს ძალიან მარტივი, მაგრამ გააფართოვოთ.
ასე რომ, ეს უბრალოდ, რა გჭირდებათ, მაგრამ თუ გსურთ მეტი ფუნქციები,
ეს არის მარტივი მოუტანს მათ.
მაგრამ მხოლოდ იმიტომ, რომ ეს არის microframework, არ
ნიშნავს იმას, რომ ეს მხოლოდ მცირე პროექტები.
მაქვს ბმული აქ რომ ამბობს რომ ობამამ Flask 2012 წელს
მისი კამპანია ნახვა, რომელიც, იმედია,
არის რაღაც მხარდაჭერა.
მაგრამ, რაც მე ნამდვილად მომწონს შესახებ Flask
ის, რომ ეს ნამდვილად არ ნებისმიერი სახის გადაწყვეტილებებს თქვენთვის.
მხოლოდ იმიტომ, რომ ჩვენ ვსაუბრობთ ვებ apps,
მე უნდა შეადაროთ იგი Ruby on რელსები და Django, რომლებიც
დიდი ფარგლებში, მაგრამ ისინი ორივე ვარაუდები
იმაზე, თუ როგორ გსურთ ურთიერთქმედება მონაცემთა ბაზები,
როგორ გსურთ წარუდგინოს თქვენი რაოდენობა, და ისინი აუცილებლად
კარგი ასპექტები, რომ.
>> მაგალითად, Ruby ლიანდაგზე აქვს ამ აქტიური ჩანაწერი სისტემა,
რომელიც არის მართლაც ლამაზი გზა ურთიერთქმედება მონაცემები,
მაგრამ თუ გსურთ გამოიყენოთ Ruby on რელსები, თქვენ ერთგვარი მიბმული რომ.
მაგრამ Flask, როგორც მე აგიხსნით peewee,
თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი სახის მონაცემთა ბაზის გსურთ,
და თქვენ შეგიძლიათ უბრალოდ გაიყვანოს, რომ როგორც გაგრძელების შევიდა Flask.
>> ასე რომ, რატომ მე ნამდვილად ისევე როგორც Flask, ის არის, რომ ეს
არ ვარაუდები თქვენთვის საფუძველზე რამ, რაც არ უნდა ნამდვილად.
>> ასე რომ, რატომ უნდა გამოიყენოთ Flask?
უპირატესობა, ეს მხოლოდ მართლაც ძირითადი მახასიათებლები
ჩაშენებული, რომ თქვენ გჭირდებათ.
ასე რომ, თქვენ არ უნდა ფიქრი გაგება მთელი bunch რამ
რომ თქვენ ნამდვილად არ გვჭირდება.
თქვენ არ უნდა ფიქრი შესახებ შეწყვეტით თვისებები
რომ თქვენ ნამდვილად არ გვჭირდება.
>> და, როგორც ზემოთ აღვნიშნე, ეს სუპერ ადვილად დაამატოთ გაგრძელება რამ
რომ თქვენ გჭირდებათ.
ზოგიერთი მათგანი, Flask აქვს საკუთარი მხარდაჭერა.
ასე რომ რაღაც მოუწოდა Flask admin, რომელიც ასახავს, ​​რომ admin
პანელი, რომელიც Django უზრუნველყოფს, რომელიც გაძლევთ ლამაზი ვიზუალური გზა
მართვის თქვენი ნახვა.
თუმცა ისევ და ისევ, თუ თქვენ მიღების რაღაც მარტივი,
ალბათ, არ უნდა დიდი admin პანელი, ასე რომ მე ვფიქრობ, რომ სუპერ ლამაზი.
და უარყოფითი მხარეები არიან, რომ თქვენ გაქვთ ნაკლები ძალა იმ ყუთში.
ასე რომ, როდესაც თქვენ გახსენით Flask, და თქვენს Python პროგრამა,
თქვენ უბრალოდ აკრიფოთ Flask იმპორტის *, ან რასაც,
თქვენ ზუსტად არ მიიღოს ყველა თვისებები დაგვჭირდება.
ასე რომ, თქვენ უნდა უფრო მკაფიოდ მიუთითეთ თვისებები გსურთ.
ასე რომ, ერთი მინუსი, მაგრამ მე ვფიქრობ, რომ მშენებლობის პატარა ვებ
პროგრამები, როგორიცაა მე ვაპირებ აჩვენებს თქვენ, რომ ნამდვილად არ არის პრობლემა.
და რა არის ბოლო რამ არის უნდა ითქვას, რომ, რომელიც ტექსტის არასწორი ფრაგმენტი,
არის, რომ არსებობს ნაკლებად სტანდარტიზებული კონვენციების, თუ როგორ გამოიყენოთ Flask,
მხოლოდ იმიტომ, რომ არ არის, როგორც ბევრი ადამიანი, რომ გამოიყენოს იგი პროფესიონალურად
შედარებით Django.
ასე რომ, თუ გადავხედავთ რაღაც, "როგორ გავაკეთო X" Django,
თქვენ ალბათ ის.
>> არსებობს კარგი დიზაინი ნიმუში შეგიძლიათ გამოიყენოთ,
მაგრამ Flask, ეს ერთგვარი წასვლა საკუთარი გზა,
მხოლოდ იმიტომ, რომ ეს არის საკმაოდ პატარა ბიბლიოთეკა.
ასე რომ, ეს არის ის, უარყოფითი მხარეები, მაგრამ მე ვფიქრობ,
რომ ჯერ კიდევ კარგი ბიბლიოთეკა გამოიყენოს.
>> მოდით უბრალოდ ხტომა მარჯვენა Flask.
ეს არის ნამდვილად არ აპირებს იყოს სრული tutorial,
მაგრამ ის, რომ გადმოგცეთ იდეა როგორ სტრუქტურირებაზე რამ,
და ასე კომფორტისთვის აპირებს და ეძებს დოკუმენტაცია
და მოძიებაში მეტი.
>> ასე რომ, ნება მომეცით გახსნა მართლაც მარტივი მაგალითი, პირველ რიგში,
და აჩვენებს, თუ რა, რომ ჰგავს, და მაშინ ჩვენ გამოგიგზავნით
მოხსნა მას ცოტა მეტი.
>> ასე რომ, ეს აქ, ნება მომეცით მას გაშვებული.
ასე რომ, ახლა მე მაქვს ჩემი პროგრამა გაშვებული.
მე ვაპირებ გახსენით Safari, და ის გაშვებული ჩემს ადგილობრივი მასპინძელი.
ასე რომ მე უბრალოდ აპირებს ეს დიდია.
მაგრამ localhost: 5000
>> ასე რომ, ახლა, ყველა ეს იმას არის, როდესაც თქვენ ეწვევა ნახვა,
იგი ბეჭდავს out "Hello Flask" რომელიც არ არის სუპერ სასარგებლო
მაგრამ მე ვფიქრობ, რომ ეს არის მაგარი, რომ ამ პატარა ფაილი აქ,
ჩვენ გვაქვს ვებ სერვერზე გაშვებული რომ არის ბეჭდვის out რაღაც.
ასე რომ, მოდით რეალურად შევხედოთ კოდს მეორე,
და შესვენება მას ცოტა.
ზომა კარგი ყველას აქ?
>> ასე რომ, იმედია, თქვენ გარკვეულწილად კომფორტული გამოყენებით Python.
მე ვთქვათ, რომ ჩვენ შეგვიძლია შევხედოთ პითონის და წაიკითხა მეშვეობით.
თუ თქვენ გაქვთ რაიმე შეკითხვები არაფერი, მე ასევე შეგიძლიათ წასვლა მეტი რომ.
>> ასე რომ, პირველი ხაზი არის, Flask, ჩვენ იმპორტი, Flask კაპიტალის "F"
რომელიც არის ერთგვარი ყველა ძირითადი მახასიათებლები, რომელიც გჭირდებათ.
როდესაც თქვენ წერა ფაილი და გამოყენებით Flask,
თქვენ აპირებს გსურთ იმპორტი, რომელიც, მხოლოდ იმიტომ, რომ ყველა ძირითადი რამ.
შემდეგი რამ, რასაც ჩვენ ვაკეთებთ, რომ ჩვენ დარეკეთ ამ ფუნქციის Flask, უბრალოდ
შექმნათ app ობიექტი, და თქვენ ყოველთვის მინდა, რომ.
>> და მაშინ, jumping ქვემოთ ქვედა სწრაფად, ეს ნაწილი აქ არის,
"if_name _ ==" _ main_ ", რომელიც ერთგვარი Python კონვენციას.
ასე რომ, ეს იქნება მხოლოდ შეასრულოს თუ გაუშვით ეს ფაილი პირდაპირ გამოყენებით Python.
ამის შემდეგ, ჩვენ მოვუწოდებთ app.run, რომელიც რეალურად დაიწყოს app აპირებს.
>> ასე რომ, მთავარი სტრუქტურა, რომელიც თქვენ ნებისმიერ Flask განცხადება,
არის, რომ თქვენ გაქვთ ეს app = Flask (_NAME_), და შემდეგ app.run.
>> ასე რომ, ორი რამ, რომ მე მაქვს აქ, არის ის, რაც ჩვენ მოვუწოდებთ მარშრუტები.
ასე რომ, მოდით ვისაუბროთ routing ცოტა მეტი.
მე დაბრუნდეს slide.
>> ასე რომ, ყველაზე ფუნდამენტური კონცეფცია Flask არის routing.
და ეს არის იდეა, რომ თქვენ დაავალოს ფუნქციების Python
კონკრეტული მისამართები თქვენს ვებ გვერდზე.
ასე რომ, როდესაც თქვენ გსურთ რათა შეიქმნას ახალი მარშრუტი,
თქვენ იყენებთ ამ @ app.route ფუნქცია დეკორატორი.
ასე რომ, თუ თქვენ ხართ უცხო ერთად ფუნქცია დეკორატიული in Python,
ეს არის ამ კონცეფციას, რომ გაძლევთ ფუნქცია
და გარს იგი რაღაც.
>> ასე რომ, რეალურად, რა ეს დეკორატორი აკეთებს, არის, რომ ის ფუნქცია ქვემოთ,
და დასძენს მეტი ინფორმაცია მას, მაგრამ რა Flask რეალურად
იმას, რომ მოხდეს არ არის სუპერ მნიშვნელოვანია, მაგრამ, რაც მთავარია,
რომ ადრე მარშრუტი, დააყენა ამ @ app.route და შემდეგ
მისამართი მარშრუტი, ასე რომ ხაზი არის ის, რაც ჩვენ
დაინახა, როცა ჩვენ უბრალოდ გახსენით ვებ-გვერდზე.
ასე რომ, მთავარი.
უბრალოდ slash მარშრუტი.
და მაშინ თქვენ გაქვთ ამ ფუნქციის.
სახელი ფუნქცია შეიძლება იყოს, რაც თქვენ გსურთ.
ეს არ უნდა აუცილებლად უნდა გავაკეთოთ მარშრუტი.
და შემდეგ, რაც ფუნქცია დაბრუნებას,
ფუნქცია უნდა დაბრუნდეს სიმებიანი.
და ეს ტექსტი შეიძლება შეიცავს HTML ან არაფერი,
და ეს არის რეალურად რა მიიღებს დაბრუნდა თქვენს ბრაუზერში, როგორც HTML,
და ეს გაუწევს რომ.
>> ასე რომ, ეს არის იგივე კოდი რაც იყო, მაგალითად,
რომ მე უბრალოდ გაიქცა, ასე რომ, როდესაც ჩვენ ეწვევა ხაზი, ის მოუწოდებს Hello World ფუნქცია, რომელიც
მხოლოდ ბრუნდება სიმებიანი, Hello Flask, და რომ იღებს ბეჭდვითი ეკრანზე.
>> ასე რომ, კიდევ ერთი მაგალითია, რაც არის, როდესაც თქვენ ეწვევა / hello,
იგი ბეჭდავს out გაუმარჯოს სიტყვა, რომელიც უნდა ვთქვათ, Hello World,
მაგრამ მოდით ვიტყვი, რომ იყო გამიზნული.
მოდით გაიყვანოს, რომ რეალური სწრაფი.
>> ასე რომ, თუ წასვლა localhost / hello, იგი ახლა ბეჭდვა რაღაც.
ასე რომ, უბრალოდ სწრაფი მაგალითია, თუ როგორ თქვენ შეგიძლიათ შექმნათ ორი სხვადასხვა მარშრუტები.
>> ასე რომ, ჯერჯერობით, ეს არ არის სუპერ სასარგებლო, არ არის მთელი ბევრი შეგიძლიათ გააკეთოთ,
თქვენ შეიძლება უბრალოდ, რომ ყველა ერთად განსხვავებული HTML გვერდების,
და როდესაც თქვენ ეწვევა კონკრეტული გვერდი ეს მხოლოდ ტვირთავს გვერდზე.
მოდით ვნახოთ, კიდევ რამდენიმე სასარგებლო რამ შეგიძლიათ გააკეთოთ.
ასე რომ, ერთი რამ, რომ თქვენ შეიძლება ჰქონდეს შენიშნა, რომ, მაგალითად, მე გამოყვანილია
up, ის არის, რომ მე app.run (გამართვის = True).
ასე რომ, რაც ამ გამართვის არგუმენტი არ არის,
რომ, როდესაც თქვენ აწარმოებს თქვენს სერვერზე, როდესაც თქვენ თქვენი განცხადება,
თუ შეცვლის ფაილი, ის იქნება ავტომატურად განაახლეთ სერვერზე.
>> ასე რომ, თქვენ არ რეალურად უნდა გადატვირთვა Python, რომელიც სუპერ სასარგებლო.
მე შემიძლია, რომ.
ნება მომეცით გაიყვანოს ჩემი კოდი ერთად typo მასში,
და ვიტყვი, რომ შეცდომას ჩაიდო იქ განზრახ for სასწავლო მიზნებისათვის.
მოდით დავამატოთ ეს უკან.
ასე რომ, ახლა ამბობს, Hello World.
მე, იხსნის მას.
და თუ ჩვენ უკან დახევის up ტერმინალში, თქვენ
ამბობენ, რომ ეს გადატვირთვა, იმიტომ, რომ ეს გამოვლინდა ცვლილება,
და ახლა, როდესაც ჩვენ განაახლეთ ეს გვერდი იგი ბეჭდვა სწორი რამ.
>> ასე გამართვის სუპერ სასარგებლო, რომ.
გარდა ამისა, თუ თქვენ გაქვთ რაიმე ერთგვარი ავარიის, ასე რომ
ნება მომეცით ამ განაცხადის ავარიის მიერ, რომელსაც ეს არ დაბრუნების სიმებიანი.
ასე რომ, მოდით უბრალოდ, დაბრუნდეს არა რაიმე მიზეზის გამო.
და მაშინ, როდესაც ვარ ამ გვერდი, ის მხოლოდ ავარიის,
მაგრამ სერვერი არ მხოლოდ ავარიული, ეს რეალურად გაძლევთ სუპერ სასარგებლო უკან
კვალი, რომ ყველაფერი წავიდა არასწორი.
და რა არის მართლაც კარგია, ის არის, რომ ნებისმიერ ნაბიჯს ამ უკან კვალი,
შეიძლება გაიხსნას ინტერაქტიული ჭურვი აქ, და ერთგვარი ბეჭდვა რა
ცვლადები გსურთ შევხედოთ.
>> და ასე გამართვის მართლაც სასარგებლო მჭიდროდაა
რა ხდება თქვენი სერვერზე, ვიდრე უბრალოდ ხედავს
რაღაც PHP მოსწონს 500 შიდა სერვერის შეცდომა, რომელიც სუპერ აზრი არ აქვს.
ერთი რამ უნდა იცოდეს, არის რომ თუ თქვენ დააყენა თქვენი app ონლაინ
ასე რომ, ეს ჩანს, რომ საჯარო, თქვენ არასდროს სურს დატოვოს გამართვის რეჟიმი,
იმიტომ, რომ ხალხს არ შეუძლია რეალურად გამოყენება, რომ კონსოლი, რომ მე
აჩვენა, რომ თქვენ შეასრულოს თვითნებური კოდი.
>> ასე რომ, ისინი შეგიძლიათ ამობეჭდოთ, როგორც ნებისმიერი საიდუმლო კოდები თქვენ იქ,
მათ შეუძლიათ გამოიყურება ზუსტად როგორ თქვენი ვებ საიტი მუშაობს.
ასე რომ, ეს მართლაც სასარგებლო ტესტირება, მაგრამ ყოველთვის
დარწმუნდით, რომ ის ადრე თქვენ გამოაქვეყნოს რამე ონლაინ რეჟიმში.
>> ასე რომ, როდესაც თქვენ იყენებთ რაღაც როგორც PHP, არსებობს მოსაზრება,
რომ თქვენ ვერ გაივლის შორის ინფორმაციის ვებ გვერდები
გამოსული ინფორმაცია, ფაქტობრივად, URL, რომელიც ოჯახის მოთხოვნით,
მაგრამ Flask, შეგიძლიათ რეალურად ამის რაიმე სახის როგორც, რომ,
მქონე მარშრუტი, რომელსაც აქვს ცვლადი როგორც ნაწილი.
>> ასე რომ, თუ გადავხედავთ ამ მაგალითად ეკრანზე აქ,
ჩვენ მარშრუტი, რომელიც არის ('/ hello / "), ასე რომ, თუ თქვენ ეწვევა
/ hello / რაღაც, რაღაც აპირებს რეალურად მიიღონ filled
სახელითა ცვლადი.
და შენიშნავს, რომ ფუნქცია რომ მოდის, რომ მარშრუტი
უნდა მიიღოს პარამეტრი ასახელებს, რომ ის, ფაქტობრივად,
მისაღებად შევიდა ფუნქცია.
>> და მაშინ, ერთხელ თქვენ შიგნით რომ ფუნქცია,
შეგიძლიათ მკურნალობა, რომ მოსწონს ნორმალური Python ცვლადი,
და ასე შემდეგ, ეს იქნება ბეჭდვა Hello, და ეს
შეავსეთ სახელი გამოყენებით ზოგიერთი სიმებიანი გაფორმებით.
>> ასე რომ დაამატოთ ცვლადი ნაწილები მარშრუტიზაციის, თქვენ იყენებთ კუთხური ფრჩხილი მარკირება.
და სურვილისამებრ, შეგიძლიათ გამოიყენოთ რასაც კონვერტორი.
ასე რომ, თუ თქვენ დააყენა ამ ანოტაცია ერთად მსხვილი ნაწლავის,
თქვენ შეგიძლიათ მიუთითოთ, რომ ეს int, ან float, ან გზა,
და ეს ავტომატურად გარდაქმნას, რომ.
ასევე შეგიძლიათ გააკეთოთ კონვერტაციის ფარგლებში Python ფუნქცია,
მხოლოდ გამოყენებით მსახიობი, მაგრამ ზოგჯერ, თუ გსურთ, რათა უზრუნველყოს, რომ ეს არის int,
შეგიძლიათ დააყენა, რომ კონვერტაციის წესი არსებობს.
>> მოდით დახევის up მაგალითად ზოგიერთი ცვლადის წესები.
ასე რომ, აქ, ეს იგივე ძირითადი სტრუქტურა ეხლა Flask იმპორტი
კოლბაში, app = Flask (_NAME_) და მაშინ ის გაშვებული ბოლოს.
ჩვენ გვყავს ამ ორი განსხვავებული ცვლადი მარშრუტების აქ.
და პირველი არის ერთი, რომ მე აჩვენა
სლაიდ, რომლის თანახმად, ეს მხოლოდ იღებს სიმებიანი სახელი
და ეს იქნება ამობეჭდოთ Hello, სახელი.
>> და მაშინ, მეორე ერთი იყენებს კონვერტაციის.
ასე რომ, ეს ავტომატურად გარდაქმნას მას to int, და შემდეგ ორჯერ int,
და ბეჭდვა, რომ გარეთ.
და ჩვენ არ რაიმე სახის კონვერტაციის ფარგლებში
იმიტომ, რომ Flask ზრუნავს, რომ.
მოდით ამ გაშვებული.
როდესაც თქვენ გაქვთ Flask განაცხადის გაშვებული,
თქვენ შეგიძლიათ კონტროლი-C გარეთ შეჩერება სერვერზე გაშვებული.
და მერე მიიღებს ცვლადები.
>> ასე რომ, მოდით წავიდეთ localhost / hello / ეზრა და იმედია, ეს იქნება მიესალმები ჩემთვის.
>> ასე რომ აიღო ჩემი სახელით, ცვლადი მარშრუტი, და აღივსო იგი აქ.
ასე რომ, მე ასევე ნახოთ სწრაფი მაგალითია გაორმაგება.
ასე რომ, თუ წასვლა / ორმაგი / 3, ეს იქნება ამობეჭდოთ 6.
ასე რომ, ეს იზრუნა კონვერტაციის ჩვენთვის.
>> ასე, რომ თქვენ ასევე შეგიძლიათ ეს გააკეთოთ ერთად float, და რაღაც განსაკუთრებული,
თუ თქვენ უნდა მიუთითოთ რაღაც გზა, რომელიც საშუალებას მას მიიღოს slashes,
მაგრამ ეს არ უნდა, როგორც წესი, უნდა იყოს საკითხი.
აქამდე ჩვენ, ჯერ კიდევ აქვს ახლახანს დაბრუნებული
სტრიქონები, რომელიც არ არის ძალიან საინტერესო.
>> ჩვენ შეგვიძლია რეალურად დაბრუნებას ლიტერატურული HTML სიმებიანი.
ასე რომ, კოდი შეგვიძლია ჩადეთ რამე როგორც ბ-tag, რათა ის თამამი,
მაგრამ ყველაზე დროს, თქვენ რეალურად არ სურს
უნდა იყოს წერილობით HTML კოდი თქვენი Python კოდი.
იგი იღებს ნამდვილად ბინძურ, და ეს არ არის კარგი დრო.
>> Flask საშუალებას გვაძლევს გამოყოფა გარეთ HTML შევიდა რასაც თარგი,
და ასე რომ, თუ თქვენ ფიქრი თვალსაზრისით MVC მოდელი
რომ თქვენ იცნობს, იმედია, სამუშაო
ერთად CS50 ფინანსთა ცოტა, შეგიძლიათ წარმოიდგინოთ, რომ პითონი ფაილი
როგორც უფრო Controller, სადაც ისინი ურთიერთქმედებენ რასაც
მონაცემთა მოდელი ალბათ.
>> და მაშინ ისინი დარეკვით out ნახვა და ინფორმაციას აწვდიდნენ, რომ ნახვა
შეავსოთ ინფორმაცია HTML, რომ მას სჭირდება.
და რაც ჩვენ მოვუწოდებთ მათ, ნახვები არიან Templates კლასში.
>> ასე რომ, Flask იყენებს სხვა Python მოდული, რომ ეს ავტომატურად
ინსტალაცია, როდესაც თქვენ პიპ ინსტალაცია Flask მოუწოდა Jinja, რომელიც
გაძლევთ დაამატოთ ეს ანოტაციები, რომ HTML
რომ ხედავთ ეკრანზე, რომელიც საშუალებას დააყენა რამ, როგორიცაა პირობით,
და მარყუჟების შევიდა HTML.
>> ასე რომ, ეს გამოიყურება ცოტა როგორიცაა, თუ როგორ შეიძლება გამოიყენოთ PHP ფარგლებში HTML ფაილი,
მაგრამ ეს მხოლოდ მაშინ, როდესაც Flask სერვერზე ემსახურება up HTML ფაილი,
იგი აწარმოებს ამ templating ძრავა და გარჩევის გზით ამ და შეავსოთ რამ.
ასე რომ, Flask აქვს render_template ფუნქცია რომ თქვენ ხედავთ ბოლოში აქ.
ასე რომ, როდესაც თქვენ ეწვევა ამ გვერდზე, გაუწიოს ამ hello.html თარგი,
და შემდეგ შეავსოთ ამ HTML გვერდი.
მოდით უბრალოდ გაუშვით ეს რეალური სწრაფი და ნახოთ, თუ რას ჰგავს,
და მერე გავლა ცოტა უფრო დეტალურად.
ასე რომ, თქვენი შაბლონები ვაპირებთ წავიდეს თარგები საქაღალდეში.
ეს ავტომატურად გამოიყურება ფარგლებში Templates საქაღალდე, რომ თარგი.
მოდით გახსნა ამ მდე.
ასე რომ, მე აწარმოებს templating მაგალითად.
>> ასე რომ, თუ მე წასვლა / hello / ეზრა, მას ამ საშინელი,
აუტანელ სტრიქონი აქვს, რომ მე დააყენა.
ძალიან კარგია, ძალიან დინამიური.
მე დიდი გულშემატკივარი.
მაგრამ რა მოხდება თუ მე უბრალოდ წასვლა, / მიესალმები?
ასე რომ, ეს უბრალოდ ამბობს, Hello World.
მე არ გაიაროს ეს სახელი და აავსო იგი ავტომატურად.
მოდით ვნახოთ, როგორ გააკეთა, რომ, და როგორ ჩვენ შეგვიძლია თავი დაეღწია, რომ სტრიქონი იქნებ.
>> ასე რომ, აქ, ეს არის ერთგვარი საინტერესო მაგალითია,
თუ იცნობს, თუ როგორ შეცვლა საკომიტეტო მუშაობა ენაზე.
ამბობენ, რომ ეს არის ერთგვარი მოსწონს, რომ ერთგვარი დაცემა მეშვეობით,
სადაც თქვენ რეალურად ერთვის ორი სხვადასხვა მარშრუტების იგივე ფუნქცია.
ასე რომ, ჩვენ ვანიჭებთ / მიესალმები მარშრუტი და მოხსენებაში / hello / სახელი მარშრუტი Hello,
და ჩვენ დააკონკრეტა using-- Python გაძლევთ დააკონკრეტა, რა ფუნქცია არგუმენტი
ასე რომ, თუ არ არსებობს სახელი, ამიტომ თუ ჩვენ უბრალოდ / hello,
ეს ავტომატურად გავფილტროთ რომ სახელი უდრის არა.
>> ასე რომ, ჩვენ გამოიტანოს თარგი სახელი = სახელი,
ასე რომ გაივლის სახელით პარამეტრი უდრის ამ სახელის ფუნქციის პარამეტრი,
შევიდა თარგი.
ეს ჯერ კიდევ არ აგიხსნათ, თუ როგორ არის გადამწყვეტი თუ არა ბეჭდვა Hello World,
ბეჭდვა და ჩემი სახელი.
ასე რომ, მოდით რეალურად შევხედოთ შევიდა თარგი თავად,
და ვხედავ, სადაც რომ მოდის.
>> ასე რომ, ამ თარგი, ჩვენ რეალურად გვაქვს პირობითი ლოგიკა,
რომელიც ზოგიერთი ადამიანი ამტკიცებენ, რომ თქვენ ნამდვილად
არ უნდა ბევრი პირობითი ლოგიკა თქვენი თარგი თავად.
ეს უნდა იყოს უფრო ფარგლებში კონტროლერი, მაგრამ ეს მაგალითი
ეს არის ის, საკმაოდ მცირე.
ასე რომ, აქ, ჩვენ შეამოწმოს, თუ სახელი, ამიტომ თუ სახელი არ არის ტოლი არა,
თუ სახელი არის რეალურად გავიდა, მაშინ ჩვენ
მიესალმები, სახელი ერთად ზედა და სტრიქონი,
ეს ყველაფერი ნორმალური HTML, წინააღმდეგ შემთხვევაში, ჩვენ ბეჭდვა Hello, World უბრალოდ ნორმალურად.
ასე რომ, რამდენიმე რამ შეამჩნია აქ შესახებ, თუ როგორ ფორმატის templating,
ის არის, რომ ყველა ეს პირობითი განცხადებები,
ერთგვარი, როგორიც ჩვენ PHP ეს მაშინ, როდესაც გსურთ ჩადეთ ზოგიერთი PHP,
თქვენ იყენებთ ნაკლებია, ვიდრე კითხვა გასვლის შემდეგ, ეს ერთგვარი ანალოგიური აქ
ერთად {%.
>> ასე რომ, ჩვენ გვაქვს ჩვენი პირობითი კოდი.
და მაშინ, როდესაც თქვენ ნამდვილად გსურთ ფაქტიურად შეაფასოს რაღაც, და ბეჭდვითი
ის, რომ ეკრანზე, თქვენ გამოიყენოთ ორმაგი აფრთხილებს.
ასე რომ, აქ არის ორმაგი braces, და მაშინ ჩვენ დააკონკრეტა სახელი,
ასე რომ, შიგნით რომ, ის შეაფასებს ცვლადის სახელი, რომელიც
მიღებულ იქნა საწყისი გაწევა თარგი ფუნქცია,
ვიდრე უბრალოდ ბეჭდვა გარეთ, თუ ჩვენ მოიშორეს ამ,
ეს იქნებოდა უბრალოდ ამობეჭდოთ სიტყვა "სახელი".
ასე, რომ რაღაც უნდა ფრთხილად.
>> ასე რომ, კიდევ ერთი რამ შეტყობინება, რომ, როდესაც ჩვენ
გსურთ გამოიყენოთ render_template ფუნქცია,
ჩვენ რეალურად უნდა იმპორტი ეს მკაფიოდ ეხლა Flask.
ეს არის მაგალითი იმისა, modularity of Flask,
რომ თქვენ არ უნდა იმპორტი რამ, რომ თქვენ არ უნდა.
შეგიძლიათ უბრალოდ მოყვანას ფუნქციები, თქვენ რეალურად
უნდა, რომელიც ზოგჯერ კარგია, ასე რომ თქვენ არ
უნდა ჰქონდეს ყველა ეს ფუნქციები სხდომაზე გარშემო, რომ თქვენ არ იყენებთ,
არამედ, თუ თქვენ დაგავიწყდებათ, რომ თქვენ უნდა იმპორტი render_template,
თქვენ ალბათ კიდევ გაფრთხილება რომ ნება თქვენ იცით, რომ.
ასე რომ, ეს არის templating.
>> ასე რომ, ჩვენ ნაჩვენები, თუ როგორ უნდა რათა მარტივი ვებ გვერდები,
და დაამატოთ ცოტა მეტი ლოგიკა ეს, იმ თვალსაზრისით, ცვლადი routing.
იგი საშუალებას გაძლევთ ამის გაკეთება სხვადასხვა ნივთები საფუძველზე რა URL მიდიხარ, და ასევე მაშინ, მისცეს
HTML, ცოტა უფრო მეტი აზრი თვალსაზრისით, თუ როგორ გსურთ გაწევა რამ.
თქვენ არ უნდა დააყენოს ყველა თქვენი HTML თქვენს Python,
მაგრამ საკმაოდ ბევრი ყველა ვებ პროგრამა,
თქვენ აპირებს მინდა გარკვეული მონაცემთა მოდელი უკავშირდება მას.
>> ასე რომ, ტრადიციულად, ამ შემთხვევაში იყოს რაღაც SQL მონაცემთა ბაზაში.
და თქვენ შეგიძლიათ ურთიერთქმედება უშუალოდ SQL.
Python აქვს, მე ვფიქრობ, რომ ის მოუწოდა.
SQLite 3.
თქვენ არ შეგიძლიათ უბრალოდ იმპორტი SQLite 3 და შეასრულოს SQL პირდაპირ,
მაგრამ მე არ ვიცი თქვენს შესახებ, მაგრამ მე ნამდვილად არ მინდა, უბრალოდ,
წერა SQL queries.
ეს ტენდენცია ნამდვილად ხანგრძლივი და რთული.
>> ასე რომ, ის, რომ მე მინდა, არის ის, რაც არის
ცნობილია, როგორც ORM, რომელიც არის ობიექტის რელატიური რუკების.
და წერტილი წარმოადგენს ობიექტის რელატიური რუკების,
ის არის, რომ არსებობს ორი განსხვავებული გზები შეგიძლიათ ვიფიქროთ ბაზაში.
>> ასე, მაგალითად, რომ პროფესორი Malan, როგორც წესი,
იყენებს კლასში, არის Excel მაგიდა, სადაც თქვენ გაქვთ ეს რიგები და ამ სვეტების,
და რომ ის ნამდვილად სასარგებლო როგორ არის ის წარმოდგენილია SQL
და როგორ ურთიერთქმედებენ, მაგრამ კიდევ ერთი გზა, რომ ეს რეალურად
სასარგებლო ვიფიქროთ, რომ ზოგჯერ, თვალსაზრისით კლასები და ობიექტები.
>> ასე რომ, ნაცვლად აზროვნება თითოეული მაგიდა, რომელსაც
ამ რიგის, რომ გარკვეული ინფორმაცია, შეგიძლიათ რეალურად
ვფიქრობ, რომ ეს უკვე თითოეულ მაგიდაზე არის კლასის,
და მაშინ ყველა ინსტანციაში კლასი აქვს გარკვეული თვისებები.
ასე რომ, ამ მაგალითად, შემთხვევები კლასში არის რიგები მაგიდა,
და შემდეგ ყოველ ქონებას იყოს სვეტი მაგიდასთან.
>> ასე რომ, ORM, რომ მე მიყვარს გამოიყენოს ეწოდება peewee.
ეს მართლაც მცირე, სახის, როგორიცაა Flask.
მე ვფიქრობ, რომ ისინი კარგად ერთად, მაგრამ არსებობს ბევრი სხვა ORMs
რომელიც შეგიძლიათ გამოიყენოთ.
უფრო პოპულარული არის ცნობილია, როგორც SQLAlchemy,
და მე არ მახსოვს, რატომ მე თავდაპირველად აირჩია peewee მეტი SQLAlchemy,
ან მინდა გითხრათ, თუ რატომ ვფიქრობ, რომ ერთ-ერთი საუკეთესო,
მაგრამ ჩვენ მხოლოდ აპირებს გამოიყენოს ეს ერთი იმიტომ, რომ მე ვიცი, როგორ გამოიყენოს იგი.
>> ასე რომ, ერთი კითხვაზე, თუ რატომ უნდა გადაიტვირთოთ გამოყენებით ORM,
ნაცვლად მხოლოდ პირდაპირ წერილობით SQL შეკითხვებს?
და მე ვფიქრობ, რომ საუკეთესო შემთხვევაში, არის, რომ თქვენ არ რეალურად
უნდა დაწეროთ SQL queries.
ეს ბევრად უფრო ადვილია, როგორც მე გაჩვენებთ, რომ რამ, როგორიცაა, შერჩევა, ჩასმა,
წაშლა, განსაკუთრებით შექმნის მაგიდები.
ეს ბევრად უფრო ადვილია, წერენ კლასის სტრუქტურა,
ვიდრე სტრუქტურირებაზე შექმნა მაგიდის განაცხადი, მაგრამ ერთი რამ
უნდა იცოდეს, ის არის, რომ რომ ORM ყველანაირად შეეცდება
გაერკვნენ, თუ რა ყველაზე ეფექტური SQL query იქნება,
მაგრამ ზოგჯერ იღებს ეს არასწორია.
>> მით უმეტეს, თუ თქვენ მუშაობის დიდი მონაცემთა ბაზა,
თქვენ შეამჩნევთ, რომ შეკითხვაზე რომ უნდა იყოს გაშვებული სწრაფად,
რეალურად იღებენ აღარ.
და თუ გადავხედავთ ქვეშ hood როგორ რომ ORM არის წერით რომ შევიდა SQL,
ეს შეიძლება იყოს თავისსავე ნამდვილად სასაცილოა,
მხოლოდ იმიტომ, რომ ეს ერთგვარი ჟესტებით თქვენი ზრახვები არასწორია.
და, არ ყოფილა ჯერ, სადაც მე მქონდა override, და უბრალოდ
შეასრულოს საკუთარი SQL queries, უბრალოდ იმიტომ, რომ ეს იყო parsing უცნაური გზა.
ასე რომ, არსებობს ოვერჰედის, მხოლოდ გზა
რომ იგი ადგენს თქვენი განცხადებები ქვემოთ შევიდა SQL.
>> ასე რომ, მოდით შევხედოთ სუპერ სწრაფად მარტივი მაგალითია მონაცემთა მოდელი
რომ თქვენ შეიძლება გამოიყენოთ.
ასე რომ, ეს არის პითონში, და ასე პირველი, რაც თქვენ გჭირდებათ რომ გააკეთოთ, არის
peewee იმპორტის *.
ასე რომ, განსხვავებით Flask, სადაც თქვენ უნდა ყველა ამ ინდივიდუალური მოდულები,
და გსურთ იმპორტი Flask და დაწერა თარგი, და სხვები
რომ ვნახავთ, მოგვიანებით, peewee, შეგიძლიათ უბრალოდ იმპორტი ყველაფერი,
იმიტომ, რომ ეს არის საკმაოდ პატარა ბიბლიოთეკა.
>> ასე რომ, პირველი, რაც თქვენ გსურთ, არის რეალურად ამ მონაცემთა ბაზის შესაქმნელად ობიექტი.
ასე რომ, თქვენ db = SqliteDatabase, და შემდეგ სახელი თქვენს მონაცემთა ბაზაში.
და ეს რეალურად მონაცემთა ბაზის შექმნა ობიექტი
რომ თქვენ შეგიძლიათ ურთიერთქმედება, ერთად peewee.
>> და მაშინ, ჩვენ გვაქვს ფაქტობრივი მოდელი, რომელიც ჩვენ გვინდა შევქმნათ.
ასე რომ, მაგიდაზე ჩვენ გვინდა შევქმნათ.
ასე რომ, ფარგლებში peewee, თითოეული კლასის აქვს საკუთარი მაგიდა თქვენს მონაცემთა ბაზაში.
ასე რომ, ყველა კლასების მემკვიდრეობით ბაზის მოდელი,
და კაპიტალის M მოდელი ის, რაც განსაზღვრულია peewee.
>> ასე რომ, ყველა თქვენი მოდელები უნდა მემკვიდრეობით, როგორც მათი უმაღლესი სუპერკლასმა,
ისინი უნდა მემკვიდრეობით მიიღებს მოდელი, მაგრამ რა არის მართლაც მაგარი,
არის, რომ თქვენ შეგიძლიათ რეალურად თქვენი მოდელები მემკვიდრეობით ერთმანეთს.
და ბევრი დრო, თქვენი მონაცემთა მოდელები არ არის აუცილებელი
მიიღოს ლამაზი მემკვიდრეობა იერარქიაში, მაგრამ ჯერ სადაც ისინი, ეს მართლაც კარგია,
იმიტომ, რომ თქვენ გაქვთ მოდელი თანდაყოლილი ერთმანეთს.
>> ასე რომ, ჩვენ განსაზღვრული ამ კლასში "სტუდენტი", რომელიც მემკვიდრეობით მოდელი,
და მას აქვს სამი თვისებები.
მას აქვს პირადობის მოწმობა, რომელიც PrimaryKeyField, რომელიც
არის ის, რომ გათვალისწინებული მიერ peewee, სახელი არის CharField,
და კლასის არის IntegerField.
ასე რომ, ეს შეიძლება იყოს ან არ იყოს როგორ CS50 რეალურად ინახავს ყველა
სტუდენტთა შეფასება.
ეს არ არის, მაგრამ ეს როგორ მინდა ამის გაკეთება.
>> და მაშინ მას აქვს, შიგნით ამ კლასში, და ეს
არის რაღაც შეგიძლიათ გააკეთოთ Python, შეგიძლიათ წყობილი კლასი.
და ეს არის რაღაც რომ საჭირო peewee.
ასე რომ, ამ კლასში Meta, თქვენ უნდა დააკონკრეტა, რომ მონაცემთა ბაზა
თანაბარი ობიექტი რომელიც ჩვენ შევქმენით ზემოთ.
და ეს ამბობს რა ფაილი არის ამ მაგიდასთან რეალურად უნდა შეიცავს.
ასე რომ, ეს არის ის, რაც თქვენ უნდა უნდა გავაკეთოთ ფარგლებში ყველა თქვენი მოდელები.
თქვენ უბრალოდ უნდა მიუთითოთ ამ Meta კლასის
რომ მონაცემთა ბაზაში უდრის ბ.
ასე რომ, რაც მე, როგორც წესი, ამის გაკეთება, თუ მაქვს bunch სხვადასხვა მოდელები,
ის არის, რომ მე მაქვს ერთი ბაზა მოდელი, რომელიც მე, როგორც წესი
უბრალოდ მოვუწოდებ "ბაზის მოდელი" რომ აქვს Meta კლასი,
და ის ადგენს მონაცემთა ბაზის ტოლია ბ.
და მაშინ ყველა ჩემს მომდევნო მოდელები დაიმკვიდრებს, რომ ბაზის კლასი.
და მერე არ უნდა ფიქრი შესახებ შექმნის Meta კლასის.
>> ასე რომ, როდესაც ეს რეალურად იღებს შედგენილი ქვემოთ შევიდა SQL განაცხადი,
როგორც ჩანს, ეს ძალიან რამ ქვემოთ აქ, "შექმნა მაგიდა სტუდენტი ID რიცხვი,
" რა მნიშვნელობა აქვს.
>> და მე ვფიქრობ, რომ ეს არის მოკლე, ამ SQL query უფლება აქ,
მაგრამ თუ გადავხედავთ ამ დონის აქ ხედავთ ზუსტად რა ხდება.
თქვენ ხედავთ, რა სახის სფეროებში არსებობს, რასაც ისინი უწოდებენ,
და ასე, მე ვფიქრობ, რომ შევხედავთ ამ პითონში
კიდევ ბევრი იკითხება, ვიდრე ცდილობს დაწეროს ამ SQL შეკითხვაზე.
>> ასე რომ, იმისათვის, რომ რეალურად გამოიყენოს მონაცემთა ბაზის,
ჩვენ დაკავშირება ფარგლებში Python.
ასე რომ, მე, როგორც წესი, დაწეროს ფუნქცია უწოდა initialize_db, რომ ორი რამ.
იგი იღებს მონაცემთა ბაზაში ობიექტის db და ეს
აკავშირებს ის, რაც მხოლოდ ხსნის მონაკვეთზე მონაცემთა ბაზაში.
თუ თქვენ მხოლოდ გაშვებული, თუმცა ნახვა თქვენს მანქანა,
ეს არ არის სუპერ დიდი გარიგება ფიქრი დამაკავშირებელი და გაწყვეტის,
მაგრამ თუ თქვენ გაშვებული ეს საიტი, თქვენ
გვინდა დავრწმუნდეთ, რომ, როდესაც შესახებ აკავშირებს, როცა ისინი დახურვა გარეთ
ნახვა, ისინი გაწყვეტა, ასე რომ თქვენ არ გაქვთ რამოდენიმე ადამიანი უკავშირდება
თქვენს მონაცემთა ბაზაში ერთდროულად.
>> და მაშინ, როდესაც თქვენ დაკავშირება მონაცემთა ბაზა,
მინდა მოვუწოდო db.create_tables, და სიაში მოდელები რა გსურთ
შევქმნათ მაგიდები.
ასე რომ, აქ, მე უბრალოდ მინდა შექმნა იგი ამ სტუდენტი.
და მაშინ, რა მნიშვნელოვანია, არის ის, რომ დააკონკრეტა უსაფრთხო = True საუკეთესო დრო.
ასე რომ, რა ეს განცხადება გავაკეთებ, არის ის, რომ
ქმნის მაგიდები სტუდენტის მოდელი, მაგრამ მხოლოდ
თუ მაგიდა არ აქვს შეიქმნა უკვე.
ეს არის ის, რაც უსაფრთხო განსაზღვრავს.
ასე რომ, ეს არ ჩაანაცვლებს თქვენი არსებული მაგიდა,
ეს მხოლოდ შექმნათ ახალი მაგიდა, თუ არ არის ერთი არსებობს.
ასე რომ, შეგიძლიათ უბრალოდ შექმნათ მაგიდები ერთდროულად გამოყენებით SQL.
და მაშინ აქვს, რომ მონაცემთა ბაზაში სხდომა იქ, და შემდეგ დაკავშირება ყოველ ჯერზე,
მაგრამ ეს, როგორც წესი, ლამაზი, უბრალოდ, დააყენა ამ create_tables ზარი,
ასე რომ, თუ თქვენ ოდესმე წაშალოთ თქვენი მონაცემთა ბაზის როდესაც თქვენ აწარმოებს თქვენი ვებ
app ერთხელ, ის ხელახლა იგი.
>> ასე რომ, უბრალოდ დარწმუნდით, რომ უსაფრთხო არ არის მითითებული, რომ იყოს ჭეშმარიტი,
ან თქვენ ნახავთ თქვენი მონაცემები მხოლოდ მიღების კი- ყოველ ჯერზე.
და მაშინ, შეგიძლიათ უბრალოდ ვუწოდებთ initialize_db დამყარება
კავშირი და შექმნას მაგიდები საჭიროების შემთხვევაში.
>> ასე რომ, ყველაზე გავრცელებული რამ რომ თქვენ გსურთ,
ან ერთ-ერთი ყველაზე გავრცელებული რამ, რეალურად ჩადეთ რამ
თქვენს მონაცემთა ბაზაში.
ასე რომ, ვიდრე დაწერა ჩასმა
განცხადება ყველა ღირებულებების მითითებული,
თქვენ შეგიძლიათ რეალურად დარეკეთ ფუნქცია სტუდენტი კლასში.
ასე რომ, როდესაც თქვენ შექმნით კლასის რომ მემკვიდრეობით მოდელი,
მას ამ შექმნის საშუალებას.
>> ასე რომ, თქვენ კლასის name.create, და თქვენ მიერ მითითებული პარამეტრების
რომ გსურთ გაივლის.
ასე რომ, თუ გსურთ რომ დაამატოთ რამდენიმე სტუდენტები ჩვენი CS50 grade წიგნაკი მაგალითად,
მე ამას დავით, რომელსაც აქვს ძალიან კარგი ხარისხის, მას აქვს 95.
და თავს, რომელიც არ აკეთებს ასე კარგად CS50, მაქვს 50.
ასე რომ, ლამაზი რამ შესახებ ის, რაც ამ შექმნის ფუნქცია აქვს,
ის არის, რომ ის დააბრუნებს მაგალითად, ან ზედიზედ, რომ ეს ის ფარგლებში მაგიდა,
და ასე შემდეგ, თქვენ შესანახად, რომ ცვლადი, და მუშაობა მოგვიანებით.
თქვენ შეგიძლიათ შეცვალოთ გარშემო, რომელიც მე ნახოთ მაგალითია.
>> გაითვალისწინეთ, რომ მე არ უნდა მიუთითოთ ID,
იმიტომ, რომ მას შემდეგ, რაც არის PrimaryKeyField, ეს ავტომატურად
იყოს იგი, თუ არ კონკრეტდება.
და, ფაქტობრივად, ალბათ, არ უნდა მიუთითოთ ის,
რადგან თქვენ შემთხვევით clobber სხვისი პირადობის მოწმობა.
და თქვენ გინდათ დარწმუნებული ვარ, რომ ეს არის უნიკალური.
>> ასე რომ, რეალურად, ყველაზე საერთო, რაც თქვენ გსურთ,
ალბათ აირჩიოთ out მონაცემთა ბაზის ერთხელ თქვენ
აქვს ბევრი ინფორმაცია არსებობს.
ასე რომ, თუ გსურთ მიიღოთ ყველაფერი, ასე ეკვივალენტს აირჩიეთ ვარსკვლავი
ეხლა სტუდენტები განცხადებით, იქნებოდა მხოლოდ student.select.
და რომ მოგცემთ უკან მასივი ყველა სტუდენტი აპროტესტებს, რომ ეს
რომ თქვენ გადაურბინოთ გსურთ.
თქვენ შეგიძლიათ მიიღოთ რამ გარეთ.
და ყველაზე მეტი დრო, თქვენ უბრალოდ არ მინდა ამის გაკეთება აირჩიეთ
თქვენ ნამდვილად გინდათ დააკონკრეტა რაღაც.
ასე რომ, თქვენ შეგიძლიათ ჯაჭვის ერთად ამ ფუნქციას,
როგორიცაა, თუ როგორ იქნება ჯაჭვი ერთად განცხადებები SQL.
ასე რომ შეგიძლიათ გააკეთოთ student.select (). სადაც ამ მაგალითს.
და მაშინ, თქვენ შეგიძლიათ განსაზღვროს პირობები,
უბრალოდ გამოყენებით ნორმალური Python Booleans, რათა შეამოწმოს ნივთები.
>> ასე რომ, ამ შემთხვევაში, თქვენ გინდათ ზღუდავს, რაც თქვენ შერჩევის,
სადაც student.grade უდრის 50, და student.name ტოლია ეზრა,
ისე, რომ მხოლოდ ჩემთვის გარეთ.
და შენიშნავს, ერთი ნამდვილად დახვეწილი რამ აქ არის
რომ, თუ გსურთ მიუთითოთ და / და ან და / ან,
პითონში, თქვენ ჩვეულებრივ გამოყენება, მე ვფიქრობ, რომ სიტყვა "და" რეალურად,
მაგრამ აქ თქვენ გამოიყენოს ერთჯერადი ampersand, რომელიც ჩვეულებრივ bitwise ოპერატორი,
მაგრამ ამ განსაკუთრებულ შემთხვევაში, უბრალოდ გზა peewee აკეთებს,
თქვენ გამოიყენოს ერთჯერადი ampersand უნდა მიუთითოთ "და".
ის, რომ რაღაც მე აირია ბევრი,
მაგრამ ეს არ ამუშავება რომ ბევრი რამ პრაქტიკაში.
>> და მაშინ, ერთხელ თქვენ გაქვთ ყველა სტუდენტები out მონაცემთა ბაზა,
ერთხელ თქვენ გააკეთეთ თქვენ აირჩიეთ და თქვენი აცვიათ ან რასაც,
თქვენ შეგიძლიათ გამოიყენოთ foreach loop, ისევე, როგორც ჩვეულებრივი Python,
ნებისმიერი სახის iterator ან რაიმე სახის მასივი.
ასე, რომ თქვენ შეგიძლიათ გააკეთოთ, s ამ student.select (). whe
ხელახალი (Student.grade <75), და ეს ნება გადაურბინოთ თითოეული სტუდენტი მაგიდასთან
რომლის grade ნაკლებია, ვიდრე 75, რომელიც ამ შემთხვევაში, ჯერ კიდევ მხოლოდ ჩემთვის.
და მაშინ შეიძლება რაღაც ფარგლებში რომ loop, როგორც გამომიგზავნოთ ელ
და მეუბნებოდა, რომ რეალურად ჩართოთ ჩემი პრობლემა კომპლექტი.
>> ასე რომ, კიდევ ერთი რამ თქვენ შეგიძლიათ გავაკეთოთ, არის ის, რომ ეს მართლაც ადვილი
განაახლოთ რიგები მაგიდასთან.
ასე რომ, გახსოვდეთ უკან აქ, თქვენი როცა შეიყვანეს,
მე მივიღე ღირებულება, რომელიც იყო დაბრუნდა student.create,
და მე გადასცა სახელი უწოდა ეზრა.
და ახლა, თქვენ შეგიძლიათ შეცვალოთ ღირებულებების, რომ მაგალითად,
ისევე, როგორც თქვენ ამას ნორმალური კლასის Python.
>> ასე რომ, შეგიძლიათ ezra.grade = 95 და რომ განაახლებს ადგილობრივი ასლი,
მაგრამ თუ თქვენ ნამდვილად გსურთ ჩაიდინოს, რომ ცვლილება მონაცემთა ბაზა,
თქვენ უნდა მოვუწოდებთ ezra.save, ასე რომ თქვენ მოუწოდა .გადარჩენის მეთოდი
on მაგალითად.
>> და ახლა, მე წარმატებით შეიცვალა ჩემს grade მონაცემთა ბაზაში.
ასე რომ, ვთქვათ, რომ მე დაიჭირეს იცვლება ჩემი grade მონაცემთა ბაზაში.
პროფესორი Malan ალბათ აპირებს რომ გსურთ წაშალოთ ჩემს კლასში,
და ასე რომ თქვენ შეგიძლიათ დარეკოთ .წაშლა მაგალითად მეთოდი მხოლოდ იმ რამ.
>> ასე რომ, თუ მინდოდა წასვლა ისევ ამ loop აქ,
და ფაქტობრივად, ნაცვლად გაგზავნის წერილებს ყველა
სტუდენტების რომლის grade ნაკლებია 75-ზე, თქვენ სურდა წაშლა,
ამ მარყუჟის თქვენ ვერ დარეკეთ s.delete მაგალითად.
და ძალიან ბოლო, რაც თქვენ გსურთ, არის, როდესაც თქვენ დაამყარონ კავშირი,
და თქვენ კეთდება თქვენი სამუშაო, მინდა მოვუწოდო db.close,
სადაც db არის, რომ მონაცემთა ბაზაში წინააღმდეგი, რომ ჩვენ გვქონდა ადრე.
თქვენ გვინდა დავრწმუნდეთ, რომ ყველაფერი ხდება დახურული გარეთ.
>> ზემოთ.
ასე რომ, ახლა მე მაქვს მაგალითად განცხადება.
მე ერთგვარი წინასწარ დამზადებული ყველაფერი მხოლოდ ისე, რომ არ იქნება ნებისმიერი ცოცხალი კოდირების
შეცდომები, მაგრამ ჩვენ შეგვიძლია გავლა და ვნახოთ, თუ როგორ დააყენა Flask
და Peewee ერთად, და მარტივი app.
მე მას CS50 წარმოსთქვა, და ეს ერთგვარი მარტივი წაკითხვა პლატფორმა.
>> ასე რომ, პირველი, მე აწარმოებს და ნახოთ, თუ რას ჰგავს,
და მაშინ ჩვენ შეგვიძლია უფრო შევიდა კოდი.
Okay, ასე რომ, მოდით უბრალოდ გაუშვით ეს.
ზემოთ, მე ეს ცოტა პატარა.
ეს არ არის ძალიან ლამაზი, მხოლოდ იმიტომ, მე არ მიიღოს ბევრი CSS,
მაგრამ, რაც არ არის, რომ მას აქვს ამ მონაცემთა ბაზაში დღიურში შეტყობინება,
და ის გადის ყველა მათ, და ეს იქნება მათთვის
გვერდზე, რათა ყველაზე ბოლო.
ასე რომ, ეს არის რამოდენიმე ფორუმზე რომ მქონდა შენახული მონაცემთა ბაზაში.
>> ასე რომ, თუ ჩვენ გვინდა, რომ შევქმნათ ახალი პოსტი, ჩვენ შეგვიძლია წავიდეთ დამატება New Post,
და ჩვენ შეგვიძლია შევა სათაური პოსტი, ასე რომ რაღაც, CS50 სემინარი.
Wow, ნამდვილად მოსარგებლე სემინარი.
>> ზემოთ.
შემდეგ დააჭერთ ჩანაწერი, და ეს გადამისამართება თქვენ უკან მთავარ გვერდზე,
და მაშინ დაინახავთ, რომ უახლესი პოსტი დაემატა.
ჩვენ ჯერ კიდევ გვაქვს ყველა პირობა არსებობს.
ასე რომ, ახლა, მოდით, ნაბიჯ მეშვეობით ყველა კოდი და ვნახოთ, როგორ ხორციელდება.
>> ასე რომ, ვფიქრობ, პირველი, რაც მოდით შევხედოთ, ფაქტიურად მოდელები.
ბევრი დრო, როდესაც თქვენ დიზაინისა რაღაც,
გსურთ ვფიქრობ, პირველ რიგში, თუ როგორ თქვენ აპირებს წარმოადგენს თქვენი მონაცემები,
და შემდეგ შეიმუშაოს რამ გარშემო, რომ ასე რომ ყველაფერი აზრი.
და ეს არის რეალურად რამდენად მე ეს გააკეთა, როდესაც მე ვაკეთებდი ეს,
დავჯექი და ვიფიქრე, რა მინდა ამ პოსტის.
>> ასე რომ, აქ, ჩვენ გვაქვს იგივე სტრუქტურა რომ მე ხსენებას ადრე,
სადაც ჩვენ db = Sqldatabase ("posts.db").
სინამდვილეში, ალბათ, არ მინდა მძიმე კოდი თქვენს სახელის ბაზაში.
ეს ალბათ უნდა პარამეტრი რომ ინახება სადღაც, იქნებ
ამ კონფიგურაციის ფაილი, მაგრამ მცირე მაგალითი, როგორც ეს,
ეს ნორმალურია, მძიმე კოდი, რომ.
>> ასე რომ, ახლა ჩვენ გვაქვს ეს Post კლასი, რომელიც მემკვიდრეობით ბაზის მოდელი.
და მას აქვს, კიდევ ერთხელ, ID = PrimaryKeyField.
სინამდვილეში, თუ თქვენ არ დააკონკრეტა, თუ რეალურად მოიშორეს ამ,
მაშინ Peewee ჩვენ იზრუნებს ავტომატურად ქმნის, რომ ID სფეროში,
და ეს ავტომატურად რათა ის PrimaryKey, რომელიც
მე ვფიქრობ, რომ მართლაც ლამაზი, რადგან, როგორც წესი, რომ რაღაც გსურთ აქვს,
მაგრამ მე მინდა, რომ ეს სპეციალურად, უბრალოდ, ასე მახსოვს, რომ ის არსებობს.
მაგრამ თუ თქვენ არ დააკონკრეტა, რომ, რომ იქნება იქ ავტომატურად.
>> ასე რომ, მე მაქვს თარიღი, რომელიც არის DateTimeField და ყველა
ამ სხვადასხვა სფეროებში, თუ შევხედოთ peewee დოკუმენტაცია,
ეს მოგცემთ ჩამონათვალი სხვადასხვა სახის სფეროებში, რომელიც შეგიძლიათ გამოიყენოთ.
უმეტესწილად, ეს არის ანალოგიური რა თქვენ ხედავთ SQL.
ასე რომ, არსებობს CharField, რომელიც VarCharFields, textfields,
რომლებიც ძალიან დიდი ხნის განმავლობაში ტექსტები, როგორიც დღიურში
პოტენციურად, DateTimeFields, DoubleFields, FloatFields,
ყველა რამ, როგორიცაა, რომ.
>> და თქვენ შეგიძლიათ გაიაროს სხვა არგუმენტები ის, რაც მე არ დააკონკრეტა აქ.
ამბობენ, მაგალითად, თქვენ არ სურს საშუალებას ორი პოსტი აქვს იგივე სათაური,
თქვენ ვერ დააკონკრეტა რაღაც უნიკალური = მართალია,
და ეს მხოლოდ დამატებითი პარამეტრი სფეროში, რომ როდესაც იგი ადგენს, რომ ქვემოთ
შევიდა SQL, ის დააკონკრეტა, ის, რომ უნდა იყოს უნიკალური.
ასევე შეგიძლიათ მიუთითოთ რაღაც არ null და ყველა სხვა რამ,
თქვენ ჩვეულებრივ აკეთებთ SQL.
ასე რომ, ეს არის საკმაოდ მარტივი მოდელი, რომელსაც აქვს თარიღი.
გაითვალისწინეთ, აქ ფარგლებში DateTimeField, მე მითითებული, რა რა არის.
მე მითითებული, რომ იყოს datetime.datetime.now,
იმის გამო, რომ გზა, რომელიც ეს იღებს შეფასებას,
ის რეალურად აფასებს datetime.now როდესაც
იგი იღებს ჩასმული შევიდა მონაცემთა ბაზაში.
>> მე ვფიქრობ, რომ, მე უნდა გადამოწმება ამ,
მაგრამ თუ თქვენ არ რაღაც, მაშინ ეს რეალურად შეაფასოს, რომ ერთხელ,
და შემდეგ წამების ყოველთვის იქნება იგივე.
ასე რომ, მხოლოდ იმ შემთხვევაში, თუ თქვენ აკეთებთ რაღაც ერთად datetimes, double გამშვები
რომ ის შეფასებისას, როდესაც რეალურად იღებს შეიყვანეს, ანდა
თქვენ შეიძლება დაბნეული.
>> სათაური მხოლოდ CharField, რომელიც არ
უფრო მეტი არგუმენტი თქვენ ვერ გაივლის სასურველი ზუსტად რამდენ ხანს
გვინდა, რომ იყოს, მაგრამ აქ, ეს ნამდვილად არ აქვს.
და ტექსტი იქნება ტექსტის მთელი ჩანაწერი,
და ეს იქნება TextField მხოლოდ იმიტომ, რომ გსურთ
დაუშვებს, რომ საკმაოდ ხანგრძლივი string.
>> მაშინ ამ Meta ქვეკლასით, რომ მხოლოდ
მიუთითებს, რომ ჩვენ გვინდა, რომ მონაცემთა ბაზაში სადაც ეს არის რეალურად გაიხსნა დაყოფილია
იყოს db ობიექტი, რომელიც ჩვენ გვაქვს აქ.
და ბოლოს, რაც უნდა აქ, უბრალოდ, ამ ფუნქციის
რომ ჩვენ ვაპირებთ გამოიყენოთ ჩვენი მთავარი app
ვრთავ მონაცემთა ბაზის დაკავშირება იგი, და მაშინ უნდა შეიქმნას Post მაგიდასთან.
>> ახლა, მოდით შევხედოთ მთავარი app თავად.
ასე რომ, ეს ერთ-ერთი საკმაოდ ცოტა აღარ, ვიდრე
რომ ჩვენ ვნახეთ ადრე, მაგრამ იმედია, არ არის ძალიან ცუდი.
ნება მიბოძეთ, ვრცელდება ამ out.
კარგი.
>> ასე რომ, შეამჩნია და ზედა მე იმპორტირებული მთელი bunch სხვა რამ
საწყისი Flask რომ ჩვენ არ გვაქვს ნამდვილად მინახავს ადრე.
და იმედია, ჩვენ შეგვიძლია გავლა თითოეული ამ ერთი
და გაიგო ცოტა მეტი მათ, დალაგებულია მაგალითად.
ასე რომ, ჩვენ გვაქვს Flask, და render_template,
რაც ჩვენ ვნახეთ ადრე, ამ მოთხოვნის ობიექტი,
რომელიც მოვა, როდესაც ჩვენ შევხედავთ, როგორ ფორმა, რომელიც მე გვიჩვენებს რეალურად
მუშაობს.
გადამისამართება, რომელიც საშუალებას გაძლევთ გადამისამართება უკან შექმნა New Post
თავში ორიგინალური გვერდი, და შემდეგ URL, რომელიც არის ის, რომ გაძლევთ
გაერკვნენ, სადაც საქართველოს საიტზე კონკრეტულ გვერდზე არის.
>> ასე რომ, მომდევნო რამ გავაკეთო, არის მე იმპორტი
ყველა ინფორმაციას მოდელები ფაილი რომ ჩვენ ვუყურებთ.
და, yeah.
>> ასე რომ, რაღაც ახალი, რომ მოდის მაშინ, როდესაც თქვენ საქმე,
განსაკუთრებით მონაცემთა ბაზები, არის, რომ თქვენ შეგიძლიათ მიუთითოთ
ფუნქცია, რომელიც იღებს მოუწოდა, სანამ ყველა მოთხოვნას, და ფუნქცია, რომელიც იღებს
მოუწოდა მას შემდეგ, რაც ყველა მოთხოვნას, ამ ფუნქცია დეკორატორი app.before მოთხოვნით.
>> ასე რომ, ეს იქნება შესრულებული იქ, სადაც ეს ფუნქცია.
ეს არ უნდა იყოს წინაშე წარსდგება მოთხოვნით,
მაგრამ, როგორც წესი, რომ რაღაც საღად მოაზროვნე ეძახით.
თქვენ შეგიძლიათ მიუთითოთ რასაც ფუნქცია გსურთ მიიღოთ უწოდებენ იქ,
ასე რომ, მე მითითებული ამ initialize_db ფუნქცია, რომელიც ჩვენ გვქონდა უკან მოდელები
ფაილი, ასე რომ, სანამ ყველა მოთხოვნა, თქვენ მინდა დაკავშირება მონაცემთა ბაზაში.
>> არსებობს ორი განსხვავებული გზა შეგიძლიათ გააკეთოთ ეს.
თქვენ შეგიძლიათ ამისapp., I მჯერა, რომ ეს after_request.
და განსხვავება after_request და teardown_request,
ის არის, რომ after_request მოხდება მხოლოდ იმ შემთხვევაში, თუ მოთხოვნა რეალურად იყო ძალაში.
ასე რომ, მხოლოდ იმ შემთხვევაში თუ მოთხოვნა იყო წარმატებული,
თუ არაფერი არ მოხდა ისე, მაგრამ teardown_request
ხდება იმ შემთხვევაში, წარმატებული მოთხოვნა, ან იმ შემთხვევაში, თუ შეცდომა.
>> ასე რომ, როგორც წესი, გინდათ გამოიყენოთ teardown_request,
თუ გსურთ ამის გაკეთება რაღაც, განსაკუთრებით სხვადასხვა
იმ შემთხვევაში, თუ შეცდომა.
მაგრამ მხოლოდ დახურვის მონაცემთა ბაზა, თუ არა გაამართლებს და თუ ეს ვერ მოხერხდა,
ვაკეთებთ გსურთ შეუსაბამობა მონაცემთა ბაზიდან.
ასე რომ, მას უწოდებენ, db.close წლის db ობიექტი.
>> გაითვალისწინეთ, რომ teardown_request იღებს გამონაკლისი.
ასე, რომ თქვენ შეგიძლიათ შეამოწმოთ თუ არსებობს, ფაქტობრივად, შეცდომა, როდესაც ის დახურვის,
მაგრამ აქ, იმედია, არ არის მთელი ბევრი შეცდომები,
ასე რომ, ჩვენ მხოლოდ ერთგვარი იგნორირება, რომ.
>> Okay, და დანარჩენი, ეს არ არის ძალიან ცუდი.
ასე რომ, როდესაც ჩვენ მთავარ გვერდზე, ჩვენ გაწეული ამ home.html თარგი
რომ გაიხსნება.
უღელტეხილზე პოსტ ტოლია, და ის, რაც ამ
არ არის, უნდა გვახსოვდეს, რომ ამ პოსტის მოდელი, ასე რომ, ჩვენ აირჩიეთ ყველა შეტყობინება,
და მერე მეორე, რაც შეგიძლიათ გააკეთოთ, თქვენ შეგიძლიათ მიუთითოთ სადაც პუნქტი,
თქვენ შეგიძლიათ მიუთითოთ შეკვეთა და ამიტომ ჩვენ
ყველა შეტყობინება, რომ მისაღებად შერჩეული, და შემდეგ
ჩვენ შეუკვეთოთ მათ მიერ post.date.descending.
და რომ არ აკონკრეტებს, როდესაც ისინი რეალურად გამოვა,
ყველაზე ბოლო ერთი იქნება ძალიან პირველი.
>> და მაშინ, ჩვენ გაიაროს, რომ შევიდა home.html template,
ასე რომ, მოდით რეალურად ქმნის რომ თარგი მართლაც სწრაფი,
და შევხედოთ, თუ როგორ, რომელიც მუშაობს.
და ეს არ არის დიდი HTML, მაგრამ იმედია, ჩვენ შეგვიძლია ფოკუსირება Python.
>> ასე რომ, არსებობს ბმული ახალი Post, და ეს განსაზღვრავს მარშრუტი
ფარგლებში Flask, რომ ჩვენ განსაზღვრა, რომელიც სწორედ აქ.
ეს არის ახალი პოსტი მარშრუტი, და ჩვენ დააკონკრეტა, რომ აქ.
და ისე, რომ ბმული, რომელიც მაშინ წავიდეთ რომ მარშრუტი ფარგლებში Flask სერვერზე.
>> უფრო საინტერესოა, ეს არის ამისთვის loop აქ.
ასე რომ, ჩვენ დააკონკრეტა, რომ ამ პოსტი პარამეტრი, რომელიც
მიღებულ იქნა შევიდა render_template ფუნქცია,
ყველა ჩანაწერი პოსტი ობიექტი, რომელიც იღებს გავიდა.
ჩვენ გვინდა, რომ ამობეჭდოთ პოსტ სათაური, H1,
და შემდეგ ქვემოთ, ჩვენ გვინდა, რომ ამობეჭდოთ პოსტი ტექსტის ფარგლებში პარაგრაფი.
>> აქ, ჩვენ შეგვიძლია რეალურად მოვუწოდებთ Python ფუნქცია,
ასე რომ ჩვენ შეგვიძლია მოვუწოდებთ strftime, ST-RF-time, და თქვენ ვერ გაივლის სტრიქონში
რომ გსურთ ბეჭდვა მონაცემებით გარეთ.
ასე რომ, ეს არის საკმაოდ ლამაზი, რომ თქვენ სინამდვილეში ეს Python ფუნქცია
შიგნიდან აქ.
თქვენ არ უნდა გავაკეთოთ გაფორმებით კონტროლერი მხარეს, რადგან რეალურად,
ფორმატირება თარიღი არის ის, რომ გსურთ გაუმკლავდეთ ფარგლებში ნახვა.
>> ყველა ამ პროცენტი რამ არ არის სუპერ მნიშვნელოვანია.
თუ გადავხედავთ up დოკუმენტაცია იმ strftime ფუნქცია Python,
იგი მიუთითებს, რომ ყველა ეს რამ, მაგრამ ის
როგორ, როდესაც ჩვენ ეძებდნენ სახლში გვერდი აქ,
ის ფორმატში ამ ლამაზი თარიღი და ის განსაზღვრავს AM და PM,
თუმცა, როგორც წესი, თუ ჩვენ არ აქვს ამ აქ,
თქვენ ალბათ კიდევ რაღაც ნაგავი თარიღი რომ არ გამოიყურება ძალიან კარგი.
და მაშინ ჩვენ დააკონკრეტა post.text და შემეძლო
არ დააყენა რამდენიმე ხაზის წყვეტები აქ, უბრალოდ
იმისათვის, რომ გარკვეული ფართების შორის ყოველი ჩანაწერი.
>> ასე რომ, მე ვფიქრობ, რომ ყველაზე მნიშვნელოვანი რაც ამ მაგალითად,
არის, რომ თქვენ შეგიძლიათ გამოიყენოთ ამ loop.
და ეს არის ანალოგიური რამ შეგიძლიათ გააკეთოთ PHP.
თქვენ შეგიძლიათ iterate მეშვეობით, ყველაფერს იღებს გავიდა,
და ასე, ნაცვლად, რომელმაც უნდა გააკეთოს ასლი / პასტა, ასლი / პასტა ყველა HTML,
თქვენ უბრალოდ უნდა დაწერა ერთხელ და შემდეგ თქვენ შეგიძლიათ iterate ყველა პოსტი.
>> და ეს არის რაღაც საერთო, რომ გსურთ
უნდა გავაკეთოთ, როდესაც თქვენ გაქვთ ბევრი მონაცემები, ის არის, რომ ყველაფერი თქვენს მონაცემებს,
გსურთ გააკეთოთ მსგავსი რამ.
და მაშინ, მხოლოდ მახსოვს, რომ როდესაც თქვენ მინდა ამობეჭდოთ რაღაც მკაფიოდ
ამ HTML, თქვენ იყენებთ ორმაგი braces აქ,
მაგრამ მაშინ, როდესაც გსურთ მიუთითოთ გარკვეული ინფორმაცია მდგომარეობაში,
ან დაახლოებით ამისთვის მარყუჟის, თქვენ გამოიყენოთ პროცენტი bracket.
>> ასე რომ, ბრუნდება Python კოდი, ასე რომ განმარტავს
რა ხდება მთავარი მარშრუტი, როდესაც ჩვენ მივდივართ იქ,
ეს მხოლოდ აჩვენებს ყველა შეტყობინება, მაგრამ მაშინ კითხვა
არის, როგორ უნდა რეალურად მიიღონ შეტყობინება შევიდა მონაცემთა ბაზა, რომელიც
არის ცოტა უფრო საინტერესო.
>> ასე რომ, როდესაც თქვენ დააჭირეთ ახალი Post ბმული, რომელიც ჩვენ ვნახეთ, აქ
ეს გადამისამართებების თქვენ ამ ფორმით.
და ეს მხოლოდ მარტივი ზარი render_template ფუნქცია, რომელიც შემდეგ
გადის ახალი ჩანაწერი HTML ფორმა.
მოდით შევხედოთ, რომ.
ასე რომ, ეს არის საკმაოდ მარტივია.
მას გააჩნია მარტივი HTML ფორმა, რომელიც გამოიყურება ცოტა ნაცნობი,
საფუძველზე ფორმები CS50 ფინანსთა.
ასე რომ, ჩვენ დააკონკრეტა აქ, აქცია.
და აქ, თუ თქვენ სამუშაო PHP, ჩვეულებრივ,
იქნება რაღაც, create.php, მაგრამ აქ
ჩვენ რეალურად დააკონკრეტა მარშრუტი ფარგლებში Flask სერვერზე.
ასე რომ, ეს მარშრუტი შეესაბამება რომ შექმნა მარშრუტი
რომ ჩვენ გვაქვს აქ, ჩვენ წასვლას მეორე.
>> ასე რომ, ჩვენ დააკონკრეტა, რომ ეს პოსტი მეთოდი,
იმიტომ, რომ ჩვენ გვინდა, რომ გაგზავნის ამ ფორმით მონაცემები და, როგორც წესი,
როდესაც თქვენ გაგზავნის მონაცემების ფორმა, დაგვჭირდება გამოიყენოთ ჩანაწერის მოთხოვნა,
უბრალოდ, ასე რომ თქვენ არ დასრულდება მდე ეს დიდი, unwieldy URL.
მაგრამ თქვენ შეიძლება ასევე გამოიყენოს GET თხოვნა, და გაიაროს ეს ცვლადი routing,
მაგრამ ფორმები, ეს არის ლამაზი პოსტი მოთხოვნის აქ.
და ასე შემდეგ, ისევე, როგორც თქვენ ყველაფერს გააკეთებს, HTML და PHP,
თქვენ შეგიძლიათ მიუთითოთ ამ ტექსტის საშუალებებით, და თქვენ შეგიძლიათ მიუთითოთ სახელი, მათ შორის,
და ეს არის სახელი, რომელიც გავიდა შევიდა თხოვნა ობიექტის ფარგლებში Flask.
>> და მაშინ ჩვენ წარუდგინოს ღილაკს, რომელიც ამბობს Post.
და აქ, პოსტი სახელი ღილაკს, იმიტომ, რომ ეს დღიურში,
მაგრამ აქ, პოსტი მოთხოვნა მეთოდი.
ასე რომ, ეს არის იგივე სიტყვა მაგრამ რეალურად უკავშირდება.
ჰო
>> ბრუნდება, პითონში, როდესაც ჩვენ მოუწოდა შექმნა მეთოდი,
შეამჩნია აქ, რომ თქვენ რეალურად დააკონკრეტა ფარგლებში მარშრუტი
მოთხოვნის მეთოდები რომ გსურთ მიიღოს,
და აქ, მე დააკონკრეტა, რომ მე მხოლოდ სურს მიიღოს საფოსტო მეთოდი.
ასე რომ, თუ მე რეალურად ცდილობენ ეწვევა გვერდი პირდაპირ, რომელიც გამოყენებით GET თხოვნა,
ის მეუბნებოდა "მეთოდი არ არის ნებადართული."
>> ასე რომ, თქვენ გაქვთ გვერდები, სახის, როგორიცაა ამ შექმნათ გვერდი, რომელიც მე მხოლოდ
ნამდვილად გამოყენებით, როგორც გზა სახით უნდა წარედგინოს,
თქვენ შეგიძლიათ მიუთითოთ, რომ თქვენ არ მინდა ადამიანი შეძლებს იქ
პირდაპირ GET თხოვნა, ან თუ არ მინდა,
რატომღაც, საფოსტო მოთხოვნით, შეიძლება მხოლოდ მიუთითოთ აქ,
მაგრამ ამ მაგალითად, ჩვენ, უბრალოდ, გსურთ პოსტ მოთხოვნის გასვლა.
>> ასე რომ, როდესაც create_post ეწოდება, როდესაც ჩვენ ეწვევა, რომ მეშვეობით Post მოთხოვნით,
როდესაც თქვენ წავიდეს კონკრეტული მარშრუტი, რომ ამ მოთხოვნის ობიექტი,
და ჩვენ გვქონდა იმპორტი მოითხოვს ძალიან ზევით,
მაგრამ იქ ეს თხოვნა ობიექტი, რომელიც იღებს გავიდა,
და თქვენ შეგიძლიათ თქვათ სახით მონაცემები, რომელიც ავტომატურად აივსოს
როდესაც თქვენ თხოვნით ფორმა.
>> და მაშინ, რა, ვფიქრობ, მართლაც მაგარი, არის
რომ ფორმა ობიექტი გავიდა წელს, მხოლოდ Python ლექსიკონი, რომელიც
შეიცავს თუ access-- ასე რომ, აქ, ნება ჩემთვის დახევის up HTML შემდეგი მას, უბრალოდ
ასე რომ თქვენ შეგიძლიათ აქვს, რომ როგორც მინიშნება, დიახ, ასე
სახელები, რომ ჩვენ დააკონკრეტა აქ სხვადასხვა სფეროებში, ასე რომ
სათაური და ტექსტი, ჩვენ მაშინ უბრალოდ გამოიყენოთ იმ მეტი აქ
როგორც მაჩვენებლები ფორმის მონაცემები.
ასე რომ, სუპერ მოსახერხებელი.
>> ასე რომ, ჩვენ მოვუწოდებთ post.create, რომელიც შევქმნით და ავტომატურად ჩადეთ
ახალი პოსტის ობიექტი მონაცემთა ბაზაში.
და მე ვფიქრობ, რომ ეს შექმნა ფუნქცია აქ არის ნამდვილად მაგარი მაგალითია, თუ როგორ
ძლიერი Flask არის და მუშაობა ამ, იმიტომ, რომ თუ თქვენ აკეთებთ რაღაც
PHP, თქვენ შეიძლება უნდა ბევრი დადასტურება,
თქვენ უნდა მაშინ შექმნას მონაცემთა ბაზის დაკავშირებით,
თქვენ უნდა მაშინ შეასრულოს SQL query,
მაგრამ აქ ჩვენ მხოლოდ ამ ლამაზი post.create, რომელიც შეგვიძლია მაშინ მხოლოდ
ინფორმაციის მისაღებად out მოთხოვნის ობიექტი,
და შემდეგ გაივლის იგი ახალი პოსტი, რომ ჩვენ შექმნის.
>> და მაშინ, ძალიან ბოლო რაც ჩვენ გვინდა გავაკეთოთ,
არის გადამისამართება შესახებ უკან სახლში.
ასე რომ, ჩვენ გამოიყენოს ეს Flask გადამისამართება ფუნქცია.
ხოლო ის, რაც ჩვენ არ უნახავს ადრე იყო ამ URL ფუნქცია.
ასე რომ, URL for ფუნქცია საშუალებას თქვენ გაივლის რეალურად სახელი
ფუნქცია თქვენი პითონში, ვიდრე კონკრეტული მარშრუტი
რომ დროს.
>> ასე რომ, მე შეიძლება ისევე ადვილად გადამისამართება მომხმარებლის სლეში,
რომელიც იქნებოდა ის სახლში, მაგრამ გამოყენებით URL ფუნქცია არის ლამაზი,
იმიტომ, რომ თუ შეცვლის ადგილმდებარეობა, სადაც ყველაფერი,
ასე ვთქვათ, რომ შევცვალო სახლში უნდა იყოს / home ნაცვლად,
ეს მაინც შემდეგ დაბრუნდნენ / სახლში, იმიტომ, რომ რეალურად მიდის და გამოიყურება
სახელი ფუნქცია, და ეს მოგცემთ უკან URL რომ.
>> ასე რომ, ერთგვარი on ვარაუდი, რომ თქვენ
უფრო სავარაუდოა, რომ შეიცვალოს, სადაც ყველაფერი არიან, ვიდრე სახელები ფუნქციები.
თქვენ შეგიძლიათ გამოიყენოთ ეს ნამდვილად ლამაზი URL ფუნქცია.
და კიდევ ერთი რამ უნდა იცოდეს რომ არის ცოტა სახიფათო,
არის, რომ თქვენ ფიქრობთ, რომ თქვენ შეიძლება მხოლოდ დარეკეთ გადამისამართება წლის URL for,
მაგრამ რეალურად ყველა მარშრუტები გვაქვს დაბრუნებას გარკვეული ტექსტი და HTML,
ასე რომ თქვენ რეალურად უნდა დაბრუნდეს გადამისამართება ზარი.
წინააღმდეგ შემთხვევაში, თქვენ კიდევ რაღაც არასწორი შესახებ არ დაბრუნების სიმებიანი,
რადგან ყველა ეს უნდა დაბრუნდეს HTML, თქვენ ნამდვილად გსურთ გაწევა.
>> ასე რომ, როდესაც თქვენ მოვუწოდებთ გადამისამართება, ეს გადამისამართებების თქვენს გვერდზე,
მაგრამ ეს რეალურად დააბრუნებს HTML თქვენ უნდა შეასრულოს, რომ გადამისამართება.
დაბრუნება მთავარ გვერდზე.
ასე რომ, ჩვენ ამ ორი განსხვავებული შეხედულებები.
ჩვენ გვაქვს სახლში ხედი.
ან, ვფიქრობ, მე უნდა ვთქვა, თარგები.
ჩვენ ამ ორი თარგები, მთავარი თარგი, რომლის
აჩვენებს ყველა ჩვენი პოსტი, და მაშინ ჩვენ გვაქვს ეს რეკლამა რამ,
და როდესაც თქვენ დააჭირეთ ჩანაწერი, ის მიდის ახალი მარშრუტი ფარგლებში Flask,
მაგრამ, რომ მარშრუტი არ არის აუცილებელი აქვს შესაბამისი თარგი.
თქვენ არ უნდა დაინახოს არაფერი, მაგრამ მაინც
გვაქვს ეს მუშაობა მიმდინარეობს კულუარებში.
და შემდეგ თქვენ მიიღებთ გადამისამართება უკან მთავარ გვერდზე.
და აუცილებლად, ადვილი მუშაობა ზოგიერთ გავალამაზოთ CSS შევიდა თარგი
და ეს გამოიყურება ბევრი გავალამაზოთ, მაგრამ ყველა ძირითადი ლოგიკა
არის იქ Python.
>> რაიმე შეკითხვები, რომ მაგალითად?
მე ვიცი, არსებობს ბევრი სხვადასხვა რამ ხდება იქ,
ბევრი რამ ჩვენ არ უნახავს ადრე, მაგრამ მსგავსი არაფერი.
ჰო.
>> აუდიტორია 1: თქვენ უნდა გავაკეთოთ რამე სპეციალური scrub მონაცემები, რომ ის
ფლანგიდან ფორმა?
მე დავინახე, უბრალოდ განაცხადა, "შექმნა",
EZRA Zigmond: ჰო, ისე, რომ ფაქტობრივად, ეს არის ძალიან კარგი წერტილი.
ასე რომ კითხვა იყო, თქვენ უნდა შეამოწმოს და დარწმუნდით
რომ მონაცემები სწორი, და რაიმე სახის scrubbing
დარწმუნდით, რომ იგი მოქმედებს, იმიტომ, რომ, როგორც ხედავთ აქ,
მე არ აკეთებს, რომ.
მოდით ვნახოთ, რა მოხდება თუ მე პოსტი რაღაც ცარიელი.
ასე რომ, ეს, ფაქტობრივად, მხოლოდ მიიღოს ცარიელი პოსტი და შეავსოთ წამების.
>> ასე რომ, რეალურად, თქვენ, ალბათ, მინდა, რომ რამე მსგავსი,
იქნებ მიუთითოთ თუ სათაური ტოლია ცარიელი სიმებიანი, მაშინ არ გააკეთებს.
ან, მხოლოდ ამის გაკეთება, თუ სათაური არ არის ტოლი ცარიელი.
ასე რომ, ეს ფაქტობრივად არ ავტომატურად იზრუნოს, რომ scrubbing
თქვენ, ასე რომ თქვენ კვლავ უნდა გავაკეთოთ, რომ.
ჰო, კარგი კითხვა.
>> აუდიტორია 2: აქვს თუ არა მას scrub გაგრძელებაა ინექცია?
იცი?
>> EZRA Zigmond: იმედია, peewee აკეთებს, რომ.
მე ვფიქრობ, რომ რა თქმა უნდა, საკმაოდ ცუდი ბიბლიოთეკა, თუ იგი არ გაგვაჩნია.
მე არ ვიცი ზუსტად.
მე უნდა შევხედოთ შეკითხვის რომ ეს გამომუშავებული.
მე ვფიქრობ, რომ თუ მე აკრეფილი დღიურში, რომ ერთგვარი ჩანდა
მოსწონს SQL ინექცია თავდასხმა, მსგავსი რამ, თუ ეს
ჰგავს დაგავიწყდათ სფეროში ან რამე, თქვენ შეიძლება რაიმე ამის მსგავსი.
>> მე ვფიქრობ, რომ ჯერ კიდევ მიიღეთ ფაქტიურად განთავსებული,
მაგრამ მე ვფიქრობ, რომ peewee არ გააკეთებს გარკვეული scrubbing მონაცემები
სანამ რეალურად ახორციელებს მას.
>> აუდიტორია 1: ეს ტექსტი ველი შექმნილია მიიღოს ჩვეულებრივი ტექსტური, არა?
>> EZRA Zigmond: ჰო, ეს არის.
ჰო.
ასე რომ, ვფიქრობ, რომ ყველა, ეს არის სწორი საქციელი, რომ ყველაფერს გააკეთებს, რომ
მაგრამ მე ვფიქრობ, რომ peewee იმედია არ აკეთებს
გარკვეული დაცვა მათი ბოლომდე.
და თუ სურდა ორმაგი შემოწმება, რომ იქ
გზები, როდესაც თქვენ გენერირება შეკითხვაზე.
ასე რომ თქვენ არ უნდა შეასრულოს ის პირდაპირ.
მე უნდა მიიღოს შევხედოთ დოკუმენტაცია,
მაგრამ თქვენ შეგიძლიათ რეალურად ნახოთ SQL, რომ იგი გამოიმუშავებს,
და შევხედოთ, რომ, და დარწმუნებული ვარ, რომ ის აფარებს რამ.
>> კიდევ ერთი მიზეზი, თუ რატომ შეიძლება გვინდა შევხედოთ SQL
რომ peewee არის outputting, არის თუ რამ ჩანს, აპირებს მართლაც ნელა,
შეგიძლიათ შევხედოთ და ვნახოთ, რა არის რეალურად აკეთებს, იმიტომ რომ ზოგჯერ
ადვილია შემთხვევით რჩეულებში ამ, ისე დაწერა,
თქვენ შეგიძლიათ შემთხვევით გაქვთ ეს აირჩიეთ მთელი მონაცემთა ბაზის პირველი,
და შემდეგ გააკეთოს გარკვეული ოპერაციის რომ, როდესაც თქვენ ნამდვილად
იმას ნიშნავდა, რომ აირჩიოთ subset.
>> ასე რომ, თუ რამ არ არის საკმაოდ აპირებს მარჯვენა,
კარგია, რომ შევხედოთ მოთხოვნით რომელიც, ფაქტობრივად, არც გამომუშავებული.
ჰო.
>> აუდიტორია 2: როცა პირველად დაიწყო, დააყენა პორტში 5000.
>> EZRA Zigmond: ჰო.
აუდიტორია 2: ნაგულისხმები ერთად peewee, ან, რომ რაღაც შეიძლება შეიცვალოს?
EZRA Zigmond: დიახ, ასე რომ პორტი იყოს ერთად Flask.
თუ თქვენ გაუშვით გარეშე სასურველი არაფერი,
ეს ავტომატურად გაგვაჩნია.
მე მჯერა, მე უნდა გადამოწმება ამ,
მაგრამ თქვენ შეგიძლიათ მიუთითოთ, რომ app.run, მე ვფიქრობ, რომ თქვენ შეგიძლიათ ამის გაკეთება რაღაც,
port = 8080.
მოდით მივცეთ, რომ ცდილობენ რეალური სწრაფი.
ჰო, ასე რომ თქვენ შეგიძლიათ მიუთითოთ port = 8080, და მას მიიღებს, რომ იქ,
რომელიც მე ვფიქრობ, თუ უნდოდა, რომ აწარმოებს წლის IDE, მე არ სცადა ეს,
მაგრამ მე ვფიქრობ, რომ თუ გაიქცა ის პორტში 8080,
თქვენ ალბათ შეძლებს სერვერს,
ისევე, როგორც თქვენ იყო იმ ნახვა.
>> ჰო, მაგრამ ეს ადვილი უნდა შეიცვალოს, რომ თუ
ნებისმიერი სახის, როგორიცაა port-საექსპედიტორო რამ, რომ თქვენ უნდა გავაკეთოთ.
>> ნებისმიერი სხვა კითხვები?
ჰო?
აუდიტორია 1: ასე რომ, ვნახე თქვენი მოდელები, რომ, როგორც თქვენ აღნიშნეთ,
თქვენ უნდა მიუთითოთ მონაცემთა ბაზის თითოეული ობიექტი.
ხომ არ იცით, აკეთებს რომ ძალიან ადვილია, თუ თქვენ
აქვს უამრავი SQLite მონაცემთა ბაზები, რომ თქვენ გსურთ გამოიყენოთ ერთი web app,
რომ თქვენ შეგიძლიათ მხოლოდ მიუთითოთ bunch სხვადასხვა პირობა თქვენი მოდელი?
>> EZRA Zigmond: ჰო, ნება მომეცით გახსნა რომ რეალური სწრაფი.
ასე რომ, თქვენ ამბობთ, თუ გსურთ აქვს bunch სხვადასხვა რაღაც, შესაძლოა,
მინდა და სტუდენტები, გარკვეული მიზეზი, რაღაც რომ?
ჰო, მე ვფიქრობ, რომ თქვენ კვლავ, თითოეული მოდელი
უნდა ჯერ კიდევ აქვს მხოლოდ მონაცემთა ბაზის ენიჭება მას,
მაგრამ თუ სურდა აქვს სხვადასხვა მოდელები, რომ
განსხვავებული მონაცემთა ბაზის ობიექტები დანიშნული იგი, თქვენ შეიძლება აუცილებლად გავაკეთებთ.
ასე რომ, თუ შეიქმნა ახალი, რაღაც მსგავსი,
და ახლა ეს არის სტუდენტი, გამოიყურება უცნაური, როგორც დღიურში,
მე ვერ დააკონკრეტა, რომ მონაცემთა ბაზის ტოლია db_2 აქ.
ასე რომ, მე ვფიქრობ, რომ მთავარი გზა შეგიძლიათ გააკეთოთ, რომ.
>> ზემოთ.
ნებისმიერი სხვა კითხვები?
>> ასე რომ მხოლოდ დასრულდება up პატარა ცოტა, აქ არის გარკვეული რესურსები,
და ეს სლაიდები დაიდება ონლაინ ასე რომ თქვენ შეგიძლიათ რეალურად მიიღონ ამ კავშირების.
საუკეთესო რესურსი ნამდვილად დოკუმენტაცია Flask
და Peewee თავს.
ისინი დაწერილი ნამდვილად კარგად, მე ვფიქრობ.
ასე რომ, Flask ნახვა აქ არის, და მათ აქვთ quickstart სამეურვეო
გავლა მსგავსი რამ, რაც მე დადიოდა,
მაგრამ თუ გსურთ რაიმე მიმოხილვა ერთი რამ, რომ მივედი,
ან თქვენ ეგონა, რომ მე ავუხსენი, რაღაც გაუგებარია გზა,
ისინი ყველაფერს აქვს მსგავსი მაგალითები არსებობს.
>> Peewee აქვს დოკუმენტაცია და მათ აქვთ quickstart tutorial
რომ მიდის მეტი ძირითადი პარამეტრების რომ თქვენ სურს გამოიყენოს.
ასე რომ, რაც მე ისაუბრა უნიკალური და სასურველი დეფოლტის,
სხვადასხვა სახის სფეროებში, თქვენ შეგიძლიათ გამოიყენოთ, იმ იქნებოდა იქ.
>> გარდა ამისა, თუ თქვენ გაქვთ კითხვები peewee,
და თქვენ პოსტი მათ Stackoverflow, ბიჭი, რომელმაც peewee რეალურად
მიდის და პასუხობს იმ ხანდახან.
თუ თქვენ გაქვთ კითხვა, იმედია მან გექნებათ პასუხის გაცემა,
იმიტომ, რომ მან დაწერა მთელი რამ.
მე ვფიქრობ, რომ ყველაფერი მინდოდა დასაფარავად.
მადლობა გამოდის.