ວິທີການກະຕຸ້ນການເຮັດວຽກຈາກສະຄິບອື່ນ


ຕອບ 1:

ລະຫັດຕົ້ນສະບັບຂອງທ່ານແມ່ນ:

def func1 (): a = 8 b = 9def func2 (x, y): z = x + y + a + b ກັບຄືນມາ za = func2 (4,6)ພິມ (ກ)

ມີຫລາຍວິທີໃນການເຮັດສິ່ງນີ້:

# ໃຊ້ຄ່າກັບຄືນ # ໃຫ້ຊັດເຈນວ່າການໂທຫາ func2 ແມ່ນຂື້ນກັບຜົນໄດ້ຮັບ # ຂອງການໂທຫາ func1def func1 (): a = 8 b = 9 ກັບຄືນ a, ຂdef func2 (x, y, ໂຕ້ຖຽງ): a, b = * ໂຕ້ຖຽງ # ຍົກເລີກການໂຕ້ຖຽງ z = x + y + a + b ກັບຄືນມາ za = func2 (4,6, args = func1 ())ພິມ (ກ)# ແຕ່ທ່ານສາມາດເຮັດໄດ້: a = func2 (4,6, args = (9,11)) # ທ່ານບໍ່ ຈຳ ເປັນຕ້ອງມີ ໜ້າ ທີ່ສ້າງຂໍ້ມູນຂອງທ່ານ

ຫຼື

# ໜ້າ ທີ່ຜ່ານ: # ໃນການແກ້ໄຂບັນຫານີ້ທ່ານ ກຳ ລັງຈະແຈ້ງໃນເວລາທີ່ທ່ານໂທຫາ # func2 ທີ່ມັນຕ້ອງການເອີ້ນວ່າ func1: func1 ແມ່ນ ໜ້າ ທີ່ຊ່ວຍdef func1 (): a = 8 b = 9 ກັບຄືນ a, ຂdef func2 (x, y, func): a, b = func () z = x + y + a + b ກັບຄືນມາ za = func2 (4,6, func1)ພິມ (ກ)# ຖ້າທ່ານມີ ໜ້າ ທີ່ອື່ນທີ່ສ້າງຄູ່ຄ່າ # ທ່ານສາມາດຜ່ານນັ້ນໄດ້ເຊັ່ນກັນ

ຂ້ອຍອາດຈະເວົ້າວ່າຢ່າໃຊ້ Globals ເລີຍ - ມັນເບິ່ງຄືວ່າເປັນການແກ້ໄຂທີ່ໄວແຕ່ວ່າມັນເປັນນິໄສທີ່ບໍ່ດີທີ່ຈະເຂົ້າໄປ.

Globals ໂດຍນິຍາມ ໝາຍ ເຖິງຂໍ້ມູນກ່ຽວກັບວິທີການເຮັດວຽກຂອງທ່ານທີ່ຢູ່ນອກການໂຕ້ຖຽງກັບ ໜ້າ ທີ່ຂອງທ່ານ, ເຊິ່ງສາມາດເຮັດໃຫ້ການເຮັດວຽກຂອງທ່ານມີຄວາມຫຍຸ້ງຍາກຫຼາຍໃນການທົດສອບ - ຍ້ອນວ່າດຽວນີ້ທ່ານຕ້ອງຜ່ານການໂຕ້ຖຽງກັບ ໜ້າ ທີ່ຂອງທ່ານແລະ ກຳ ນົດຄ່າທົ່ວໂລກທີ່ກ່ຽວຂ້ອງໃນ ລຳ ດັບ ເພື່ອທົດສອບການເຮັດວຽກຂອງທ່ານ (ທ່ານທົດສອບ ໜ້າ ທີ່ຂອງທ່ານ, ບໍ່ແມ່ນທ່ານ). ບາງຄັ້ງເປັນໄປບໍ່ໄດ້ທີ່ຈະ ໜີ ຈາກຂໍ້ມູນທົ່ວໂລກ (ຕົວຢ່າງຖານຂໍ້ມູນ, ເວບໄຊທ໌ພາຍນອກ), ແລະທ່ານຕ້ອງໄດ້ໂດດຜ່ານ hoops ບາງຄັ້ງເພື່ອທົດສອບລະຫັດຂອງທ່ານເມື່ອທ່ານມີຂໍ້ມູນພາຍນອກ - ແຕ່ຢ່າເຮັດໃຫ້ຊີວິດຂອງທ່ານຍາກກວ່າເກົ່າ .


ຕອບ 2:

ນັ້ນແມ່ນຂື້ນກັບລະຫັດໃນແຕ່ລະເອກະສານ, ແຕ່ ຄຳ ຕອບແມ່ນ ສຳ ຄັນຄືກັນ:

ບໍ່ວ່າ ໜ້າ ທີ່ແມ່ນວິທີການຂອງວັດຖຸໃດ ໜຶ່ງ, ຫຼືພຽງແຕ່ເປືອຍກາຍໃນໂມດູນ, ທ່ານສາມາດ ນຳ ເຂົ້າມັນຈາກບ່ອນໃດກໍ່ຕາມທີ່ຖືກປະກາດ, ໄປບ່ອນທີ່ທ່ານຕ້ອງການໃຊ້.

ທ່ານອາດຈະມີເຫດຜົນທີ່ດີໃນການບໍ່ຕິດ ໜ້າ ທີ່ຂອງທ່ານໄວ້ໃນວັດຖຸ, ແຕ່ທ່ານອາດຈະຕ້ອງການກວດສອບເຫດຜົນນັ້ນ. ມີການໂຕ້ຖຽງທີ່ມີເຫດຜົນ ສຳ ລັບແລະຕໍ່ຕ້ານ.

ໃຫ້ໂທຫາເອກະສານຂອງລະຫັດ Python ເປັນ 'ໂມດູນ'. ຄວາມສະດວກ, ໂມດູນ Python ເຮັດໃຫ້ພວກເຮົາມີຊ່ອງຊື່ "ບໍ່ເສຍຄ່າ" ເພື່ອຮັກສາການປະກາດຂອງພວກເຮົາອອກຈາກພື້ນທີ່ທົ່ວໂລກ, ບ່ອນທີ່ພວກມັນອາດຈະປະທະກັບການປະກາດໃນປະຈຸບັນຫຼືອະນາຄົດຢູ່ບ່ອນອື່ນໃນລະຫັດ.

ໂຄງສ້າງຂອງໄດເລກະທໍລີຂອງໂມດູນທີ່ກ່ຽວຂ້ອງຢ່າງໃກ້ຊິດເອີ້ນວ່າຊຸດ.

ໂຄງສ້າງຂອງລະບົບຂອງໂມດູນທີ່ບໍ່ກ່ຽວຂ້ອງຖືກເອີ້ນວ່າ…ສັບສົນ.

ໃນກໍລະນີໃດກໍ່ຕາມ, ຖ້າມີໂມດູນ ໜຶ່ງ, ເກັບຮັກສາໄວ້ໃນແຟ້ມເອກະສານທີ່ເອີ້ນວ່າ foo.py, ມີ ໜ້າ ທີ່ຕັ້ງຊື່ແຖບ:

def bar (thing1, thing2): ກັບຄືນ "{0}, {1}". (ຮູບແບບ 1, ສິ່ງທີ່ 2)// ບໍ່ສົນໃຈເລື່ອງນີ້ ສຳ ລັບດຽວນີ້ def yoda_speak (thing1, thing2): ກັບຄືນ "{0}, {1}". ຮູບແບບ (ສິ່ງທີ່ 2, ສິ່ງທີ່ 1)

…ຫຼັງຈາກນັ້ນ, ໃນເອກະສານອື່ນ, ທ່ານອາດຈະ ນຳ ເຂົ້າແຖບຟັງຊັນຈາກ foo ໂມດູນ:

ຈາກແຖບ foo ນຳ ເຂົ້າສິ່ງ = ແຖບ (“ ນຳ ເຂົ້າ”,“ ນີ້”)

…ຫຼືທ່ານສາມາດ ນຳ ເຂົ້າ foo ໂມດູນທັງ ໝົດ, ທັງ ໝົດ ສາມາດເຂົ້າເຖິງ ໜ້າ ທີ່ຂອງມັນທັງ ໝົດ ໃນເວລາດຽວກັນ, ຖ້າທ່ານແນ່ໃຈວ່າທ່ານຕ້ອງການໃຫ້ພວກເຂົາທັງ ໝົດ …ຕາບໃດທີ່ທ່ານອ້າງອີງໃສ່ຊື່ຂອງພວກມັນ (ຕົວຢ່າງ foo.function_name () ) …

foo ນຳ ເຂົ້າboth_things = foo.bar (“ ລະວັງກັບສິ່ງນີ້”, ແຕ່ວ່າທ່ານສາມາດ ນຳ ເຂົ້າທຸກໆ ໜ້າ ທີ່ໃນໂມດູນນີ້”) yoda_speak = foo.anti_bar ("ນີ້ແມ່ນ", "ຖອຍຫລັງ")

ຕອບ 3:

ມີກໍລະນີທີ່ເຮັດໃນສິ່ງທີ່ທ່ານອະທິບາຍໃນ ຄຳ ຖາມຂອງທ່ານ, ເຖິງແມ່ນວ່າມັນອາດຈະບໍ່ແມ່ນກໍລະນີການ ນຳ ໃຊ້ຂອງທ່ານ. ມັນແມ່ນການປິດ *.

def myfunction (ກ): b = 2 * ກ def myotherfunction (ຄ): ກັບມາ b * c ກັບຄືນ myotherfunction

myotherfunction ກຳ ລັງຮັກສາ ສຳ ເນົາຂອງ, ເຊິ່ງຈະໃຊ້ທຸກໆຄັ້ງທີ່ຖືກຮຽກຮ້ອງ

myother = myfunction (5)ຜົນໄດ້ຮັບ = myother (5)ພິມ (ຜົນໄດ້ຮັບ)

ເຊິ່ງຈະພິມ: 50

ຕົວແປທ້ອງຖິ່ນ b ແມ່ນຜົນຂອງ * 2, ເຊິ່ງໃນກໍລະນີຂອງພວກເຮົາແມ່ນ 5. ອັນນີ້ຖືກເກັບຮັກສາໄວ້ເປັນຂໍ້ອ້າງອີງ ສຳ ລັບ myotherfunction ເຊິ່ງແມ່ນຄ່າກັບຄືນ

ທຸກໆຄັ້ງທີ່ ໜ້າ ທີ່ກັບຄືນມາຖືກຮຽກຮ້ອງ, ມັນຈະຄູນການໂຕ້ຖຽງ c ໂດຍມູນຄ່າຂອງຕົວແປທ້ອງຖິ່ນ b ທີ່ຖືກເກັບໄວ້ເປັນເອກະສານອ້າງອີງ.


ຕອບ 4:

ຂ້ອຍຈະສະ ເໜີ ວິທີອື່ນ, ເຖິງແມ່ນວ່າການໃຊ້ຫ້ອງຮຽນແລະວິທີການແລະຄຸນລັກສະນະຕ່າງໆແມ່ນວິທີການທີ່ຈະໄປ.

'' ' ການແກ້ໄຂຢ່າງຊັດເຈນ, ຖ່າຍທອດຂໍ້ມູນຜ່ານການແລກປ່ຽນເຊິ່ງກັນແລະກັນ. ຂ້ອຍໃຊ້ບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້ ສຳ ລັບໂປແກຼມ recursive ກັບຂໍ້ມູນຂອງລັດ.'' 'pprint ການ ນຳ ເຂົ້າdef f (d: dict) -> ບໍ່ມີ: print ('function f: ການໂຕ້ຖຽງທີ່ເພີ່ມຂື້ນກັບຕົວແປທ້ອງຖິ່ນ') a_local_variable = 'f ສ້າງຂ້ອຍ' d ['a_local_variable_from_elsewhere'] = a_local_variabledef g (d: dict) -> ບໍ່ມີ: ພິມ ('ໜ້າ ທີ່ g: ການ ນຳ ໃຊ້ການໂຕ້ຖຽງກັບສະພາບແວດລ້ອມທີ່ຖືກສ້າງຂື້ນໃນບ່ອນອື່ນ') pprint.pprint (ງ)def ຕົ້ນຕໍ (): pass_variables_around = {} f (pass_variables_around) g (pass_variables_around)ຕົ້ນຕໍ ()

ຕອບ 5:
ຕົວປ່ຽນ = 0def modify_global (): ຕົວແປທົ່ວໂລກ ຕົວແປ + = 1ຕົວແປການພິມ>>>> 1

ຄຳ ສຳ ຄັນທົ່ວໂລກຊ່ວຍໃຫ້ການດັດແປງຕົວແປທົ່ວໂລກຢູ່ໃນທ້ອງຖິ່ນໃນ ໜ້າ ທີ່.

ການ ກຳ ນົດ ໜ້າ ທີ່ຢູ່ພາຍໃນອື່ນບໍ່ໄດ້ສົ່ງຄ່າຂອງຕົວແປທີ່ມີຊື່ດຽວກັນ. ກວດສອບ

9. ຫ້ອງຮຽນ - ເອກະສານ Python 3.7.0

ພາກທີ 9.1 ແລະ 9.2 ສຳ ລັບ ຄຳ ອະທິບາຍສັ້ນໆທີ່ດີກ່ຽວກັບການຕັ້ງຊື່ຂອງ Python.


ຕອບ 6:
def func1 (): ທົ່ວໂລກ a, ຂ a = 8 b = 9def func2 (x, y): func1 () z = x + y + a + b ກັບຄືນມາ za = func2 (4, 6)ພິມ (ກ)# ຂ້ອຍ ໃໝ່ ກັບ python ດັ່ງນັ້ນຂ້ອຍບໍ່ແນ່ໃຈວ່ານີ້ແມ່ນທາງອອກທີ່ດີທີ່ສຸດ. ແຕ່ນີ້ແມ່ນ ໜຶ່ງ ໃນວິທີແກ້ໄຂ.ທ່ານຈໍາເປັນຕ້ອງເຮັດຕົວແປແລະ b ທົ່ວໂລກໃນຂະນະທີ່ປະກາດພວກມັນຖ້າທ່ານຕ້ອງການໃຊ້ມັນໃນ ໜ້າ ທີ່ອື່ນ.

ຕອບ 7:

ຂ້ອຍບໍ່ແນ່ໃຈວ່າຂ້ອຍເຂົ້າໃຈສິ່ງທີ່ເຈົ້າ ໝາຍ ຄວາມວ່າ. ແຕ່ຖ້າທ່ານ ນຳ ເຂົ້າ ໜ້າ ທີ່ຈາກເອກະສານ ໜຶ່ງ ເຂົ້າໄປໃນອີກເອກະສານ ໜຶ່ງ, ຜູ້ ນຳ ເຂົ້າສາມາດສົ່ງຄ່າຕ່າງໆເຂົ້າໃນ ໜ້າ ທີ່ໄດ້ແລະຟັງຊັນກໍ່ສາມາດປັບປຸງຫຍັງໃນເອກະສານຂອງມັນເອງ.

ເຖິງຢ່າງໃດກໍ່ຕາມ, ຖ້າຂ້ອຍເຂົ້າໃຈຢ່າງຖືກຕ້ອງ (ແລະມີແນວໂນ້ມທີ່ຂ້ອຍບໍ່ເຮັດ), ສິ່ງທີ່ເຈົ້າພະຍາຍາມເຮັດແມ່ນ, ໃນຫລາຍໆກໍລະນີ, ການປະຕິບັດການຂຽນໂປແກຼມທີ່ບໍ່ດີ, ອີງໃສ່ໂມດູນທົ່ວໂລກ.


ຕອບ 8:

ໃນຂະນະທີ່ມີວິທີແນ່ນອນ, ຢ່າເຮັດມັນ. ຖ້າທ່ານຕ້ອງການທີ່ຈະດັດແປງຄ່າບາງຢ່າງພາຍໃນ ໜ້າ ທີ່ແລະໃຊ້ຄ່າທີ່ຖືກປັບປ່ຽນເຫລົ່ານັ້ນໃນ ໜ້າ ທີ່ອື່ນ, ໃຫ້ສົ່ງຄ່າທີ່ຖືກດັດແປງໄປໃຊ້ໃນ ໜ້າ ທີ່ ທຳ ອິດໂດຍຜ່ານຕົວ ກຳ ນົດການເອີ້ນແລະຍອມຮັບຄ່າທີ່ຖືກປັບປ່ຽນມາເປັນຄ່າກັບຄືນຂອງ ໜ້າ ທີ່. ສົ່ງຄ່າທີ່ຖືກປັບປ່ຽນມາໃຫ້ໃຊ້ໃນ ໜ້າ ທີ່ສອງແລະຍອມຮັບຄ່າຂອງມັນຄືນ.

ນີ້ແມ່ນການປະຕິບັດທີ່ດີທີ່ສຸດທີ່ຍອມຮັບໂດຍທົ່ວໄປຈາກ Paradigm Functional Programming ທີ່ພະຍາຍາມຫຼຸດຜ່ອນຜົນກະທົບຂ້າງຄຽງທີ່ນ້ອຍທີ່ສຸດ (ຄາດຫວັງວ່າມັນບໍ່ຈະແຈ້ງ) ໃນການໂທຫາ ໜ້າ ທີ່.


ຕອບ 9:

ລະຫັດທີ່ທ່ານໃຫ້ມາແມ່ນຈະຖິ້ມຂໍ້ຜິດພາດ.

ຍ້ອນຫຍັງ? ເນື່ອງຈາກວ່າຂອບເຂດຂອງຕົວແປໃນ Python ເຮັດວຽກໄດ້ແນວໃດ. a ແລະ b, ປະກາດໃນ func (), ພຽງແຕ່ສົ່ງຜົນກະທົບຕໍ່ ໜ້າ ທີ່ນັ້ນ, ນັ້ນແມ່ນຂອບເຂດຂອງພວກມັນ.

ຖ້າທ່ານຕ້ອງການດັດແປງຄຸນຄ່າຂອງຕົວແປທົ່ວໂລກພາຍໃນ ໜ້າ ທີ່, ທ່ານຕ້ອງໃຊ້ ຄຳ ສຳ ຄັນທົ່ວໂລກ:

x ທົ່ວໂລກx = 123ພິມ xfunc ()ພິມ xdef func (): x = 124

tl; dr ລະຫັດຂອງທ່ານ, ຄືກັບວ່າມັນຈະບໍ່ເຮັດວຽກ.


ຕອບ 10:

ແມ່ນແລ້ວ, ນີ້ແມ່ນສິ່ງທີ່ທ່ານ ກຳ ລັງຊອກຫາ. ຫວັງວ່າມັນຈະຊ່ວຍໄດ້.

def c (): r = raw_input ("ຖາມບາງຢ່າງບໍ່?") ... ກັບຄືນ rdef p (x): ... ເຮັດບາງສິ່ງບາງຢ່າງ ….r = c ()p (r)