როგორ გავააქტიუროთ ფუნქცია სხვა სკრიპტიდან


პასუხი 1:

თქვენი ორიგინალი კოდია:

def func1 (): a = 8 b = 9def func2 (x, y): z = x + y + a + b დაბრუნება ზa = func2 (4,6)ბეჭდვა (ა)

ამის გაკეთების რამდენიმე გზა არსებობს:

# გამოიყენეთ დაბრუნების მნიშვნელობები # მკაფიოდ თქვით, რომ func2– ზე ზარი შედეგს ეყრდნობა func1- ზე ზარის #def func1 (): a = 8 b = 9 დააბრუნე ა, ბdef func2 (x, y, args): a, b = * args # გახსენით არგუმენტებიდან z = x + y + a + b დაბრუნება ზa = func2 (4,6, args = func1 ())ბეჭდვა (ა)# მაგრამ თქვენ შეგიძლიათ გააკეთოთ: a = func2 (4,6, args = (9,11)) # თქვენ არ გჭირდებათ ფუნქცია თქვენი მონაცემების შესაქმნელად

ან

# პასის ფუნქციები: # ამ გამოსავალში თქვენ აშკარად გამოირჩევით, როდესაც დარეკავთ # func2 რომ მას სჭირდება func1 დარეკვა: func1 დამხმარე ფუნქციააdef func1 (): a = 8 b = 9 დააბრუნე ა, ბdef func2 (x, y, func): a, b = func () z = x + y + a + b დაბრუნება ზa = func2 (4,6, func1)ბეჭდვა (ა)# თუ თქვენ გაქვთ სხვა ფუნქცია, რომელიც წარმოქმნის რამდენიმე მნიშვნელობას # შენც შეგიძლია გაიარო

მე ვიტყოდი, საერთოდ ნუ გამოიყენებთ გლობალებს - ისინი სწრაფად გამოსავალს ჰგვანან, მაგრამ ძალიან ცუდი ჩვევაა.

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


პასუხი 2:

ეს დამოკიდებულია თითოეულ ფაილის კოდზე, მაგრამ პასუხი არსებითად იგივეა:

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

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

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

მჭიდროდ დაკავშირებული მოდულების დირექტორიულ სტრუქტურას პაკეტი ეწოდება.

დაუკავშირებელი მოდულების დირექტორიის სტრუქტურას უწოდებენ… არეულობას.

ნებისმიერ შემთხვევაში, თუ ერთი მოდული, შენახული ფაილში, სახელწოდებით foo.py, შეიცავს ფუნქციას, სახელად ზოლს:

დეფ ბარი (ნივთი 1, ნივთი 2): დააბრუნე "{0}, {1}". ფორმატი (ნივთი 1, ნივთი 2)// ამ მომენტისთვის იგნორირება def yoda_speak (ნივთი 1, ნივთი 2): დააბრუნე "{0}, {1}". ფორმატი (ნივთი 2, ნივთი 1)

… შემდეგ, სხვა ფაილში, შეგიძლიათ იმპორტირება ფუნქციის ზოლი მოდული foo:

foo იმპორტის ზოლიდანნივთი = ბარი ("იმპორტირებული", "ეს")

… ან, შეგიძლიათ მთელი მოდულის foo იმპორტი შეიტანოთ, ყველას ერთდროულად მიუწვდება ხელი მის ყველა ფუნქციაზე, თუ დარწმუნებული ხართ, რომ ყველა მათგანი მოგინდებათ… მანამ, სანამ მათ მათ სახელების სივრცის მიხედვით მიმართავთ (მაგ. Foo.function_name () )

იმპორტი fooboth_things = foo.bar ("ამაზე ფრთხილად", "მაგრამ ამ მოდულის ყველა ფუნქციის იმპორტი შეგიძლიათ") yoda_speak = foo.anti_bar ("ეს არის", "უკან")

პასუხი 3:

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

ფუნქციის დარღვევა (ა): b = 2 * ა my myfunksion (გ): დაბრუნება b * c დაბრუნების myotherfunction

myotherfunction ეფექტურად ინახავს ასლის ასლს, რომელიც გამოიყენებს ყოველ ჯერზე გამოყენებას

myother = ფუნქცია (5)შედეგი = დედა (5)ბეჭდვა (შედეგი)

რომელიც დაბეჭდავს: 50

ადგილობრივი ცვლადი b არის * 2 – ის შედეგი, რაც ჩვენს შემთხვევაში იყო 5. ეს ინახება როგორც მიოპერაციის მითითება, რომელიც არის დაბრუნების მნიშვნელობა

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


პასუხი 4:

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

» მკაფიო გადაწყვეტა, ინფორმაციის გადაცემა მუტაბელში. მე მსგავს რაღაცას ვიყენებ რეკურსიული პროგრამებისთვის, სახელმწიფო ინფორმაციით.»იმპორტის ანაბეჭდიdef f (d: dict) -> არცერთი: print ('ფუნქცია f: არგუმენტის პოპულაცია ადგილობრივ ცვლადებთან') a_local_variable = 'ვ შექმნა მე' d ['a_local_variable_from_elseever'] = a_local_variabledef g (d: dict) -> არცერთი: ბეჭდვა ('FUNCTION g: ARGUMENT- ის გამოყენება ადგილობრივი ცვალებადობით შექმნილი სხვაგან') ბეჭდვა. დაბეჭდვა (დ)def main (): pass_variables_around = {} f (პასის_ ცვლადები_ გარშემო) g (პასის_ ცვლადები_ გარშემო)მთავარი ()

პასუხი 5:
ცვლადი = 0def modify_global (): გლობალური ცვლადი ცვლადი + = 1ბეჭდვითი ცვლადი>>>> 1

გლობალური საკვანძო სიტყვა საშუალებას გვაძლევს გლობალური ცვლადები შეცვალოს ფუნქციაში.

ფუნქციის განსაზღვრა სხვაში არ გადადის იგივე დასახელებული ცვლადების მნიშვნელობას. გაეცანით

9. კლასები - Python 3.7.0 დოკუმენტაცია

9.1 და 9.2 განყოფილებები მოკლედ განმარტავენ, თუ როგორ მუშაობს დასახელების წესი Python- ში.


პასუხი 6:
def func1 (): გლობალური ა, ბ a = 8 b = 9def func2 (x, y): func1 () z = x + y + a + b დაბრუნება ზa = func2 (4, 6)ბეჭდვა (ა)# მე ახალი ვარ პითონში, ამიტომ არ ვარ დარწმუნებული, ეს საუკეთესო გამოსავალია. მაგრამ ეს ერთ-ერთი გამოსავალია.თქვენ უნდა გააკეთოთ a და b ცვლადები გლობალური, მათი დეკლარირებისას, თუ გსურთ გამოიყენოთ ისინი სხვა ფუნქციაში.

პასუხი 7:

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

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


პასუხი 8:

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

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


პასუხი 9:

თქვენს მიერ მოწოდებული კოდი შეცდომებს აგდებს.

რატომ? იმის გამო, თუ როგორ მუშაობს ცვლადი მასშტაბები Python- ში. ფუნქციებში () გამოცხადებული a და b, უბრალოდ მოქმედებს ამ ფუნქციაზე, ეს მათი ფარგლებია.

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

გლობალური xx = 123ბეჭდვა xfunc ()ბეჭდვა xdef func (): x = 124

tl; dr თქვენი კოდი, როგორც არის, არ იმუშავებს.


პასუხი 10:

დიახ, სწორედ ამას ეძებთ. იმედი მაქვს, ეს ეხმარება.

def c (): r = raw_input ("რამე იკითხე?") ... დაბრუნება rდეფ (x): ... გააკეთე რამე ....r = c ()გვ (რ)