python - একটি ফাংশন গ্লোবাল ভেরিয়েবল ব্যবহার করে




global-variables scope (12)

কিভাবে আমি একটি ফাংশন একটি গ্লোবাল পরিবর্তনশীল তৈরি বা ব্যবহার করতে পারেন?

যদি আমি একটি ফাংশনে গ্লোবাল ভেরিয়েবল তৈরি করি, তবে কিভাবে আমি অন্য ফাংশনে গ্লোবাল ভেরিয়েবল ব্যবহার করতে পারি? গ্লোবাল ভ্যারিয়েবলটিকে ফাংশনটির একটি স্থানীয় ভ্যারিয়েবলে সংরক্ষণ করতে হবে যার অ্যাক্সেস দরকার?


যদি আমি একটি ফাংশনে গ্লোবাল ভেরিয়েবল তৈরি করি, তবে কিভাবে আমি অন্য ফাংশনে ঐ পরিবর্তনশীল ব্যবহার করতে পারি?

আমরা নিম্নলিখিত ফাংশন দিয়ে একটি বিশ্বব্যাপী তৈরি করতে পারেন:

def create_global_variable():
    global global_variable # must declare it to be a global first
    # modifications are thus reflected on the module's global scope
    global_variable = 'Foo' 

একটি ফাংশন লেখা আসলে তার কোড চালানো হয় না। তাই আমরা create_global_variable ফাংশন কল করি:

>>> create_global_variable()

পরিবর্তন ছাড়া globals ব্যবহার করে

আপনি এটি ব্যবহার করতে পারেন, যতক্ষণ আপনি এটির কোনও বস্তু পরিবর্তন করতে প্রত্যাশা করবেন না:

উদাহরণ স্বরূপ,

def use_global_variable():
    return global_variable + '!!!'

এবং এখন আমরা গ্লোবাল পরিবর্তনশীল ব্যবহার করতে পারেন:

>>> use_global_variable()
'Foo!!!'

একটি ফাংশন ভিতরে থেকে বৈশ্বিক পরিবর্তনশীল পরিবর্তন

গ্লোবাল ভ্যারিয়েবলটিকে বিভিন্ন বস্তুর দিকে নির্দেশ করতে, আপনাকে আবার গ্লোবাল কীওয়ার্ড ব্যবহার করতে হবে:

def change_global_variable():
    global global_variable
    global_variable = 'Bar'

নোট করুন যে এই ফাংশনটি লেখার পরে, কোডটি আসলে এটি পরিবর্তন করে চলেছে:

>>> use_global_variable()
'Foo!!!'

তাই ফাংশন কল করার পর:

>>> change_global_variable()

আমরা দেখতে পারি যে বৈশ্বিক পরিবর্তনশীল পরিবর্তন করা হয়েছে। global_variable নাম এখন 'Bar' :

>>> use_global_variable()
'Bar!!!'

নোট করুন যে পাইথনটিতে "বিশ্বব্যাপী" প্রকৃতপক্ষে বিশ্বব্যাপী নয় - এটি শুধুমাত্র মডিউল স্তরের বৈশ্বিক। সুতরাং এটি শুধুমাত্র বিশ্বব্যাপী মডিউলগুলিতে লেখা ফাংশনগুলিতে উপলব্ধ। ফাংশনগুলি যে মডিউলটিতে লেখা আছে তা মনে রাখুন, তাই যখন তারা অন্য মডিউলগুলিতে রপ্তানি হয়, তখনও তারা বিশ্বব্যাপী পরিবর্তনের জন্য তৈরি করা মডিউলে দেখেন।

একই নামের সাথে স্থানীয় ভেরিয়েবল

যদি আপনি একই নামের সাথে একটি স্থানীয় পরিবর্তনশীল তৈরি করেন, এটি একটি বিশ্বব্যাপী পরিবর্তনশীলকে ছায়াচ্ছন্ন করবে:

def use_local_with_same_name_as_global():
    # bad name for a local variable, though.
    global_variable = 'Baz' 
    return global_variable + '!!!'

>>> use_local_with_same_name_as_global()
'Baz!!!'

কিন্তু যে misnamed স্থানীয় পরিবর্তনশীল ব্যবহার করে গ্লোবাল পরিবর্তনশীল পরিবর্তন করে না:

>>> use_global_variable()
'Bar!!!'

উল্লেখ্য, গ্লোবাল ভেরিয়েবলগুলি গ্লবালগুলির মতো একই নামের সাথে ব্যবহার করা উচিত নয়, যদি না আপনি সঠিকভাবে জানেন এবং এটি করার একটি খুব ভাল কারণ না থাকে। আমি এখনো এমন একটি কারণ সম্মুখীন না।


আপনি namespaces ধারণা ধারণা অন্বেষণ করতে পারেন। পাইথন ইন, module বিশ্বব্যাপী তথ্যের জন্য প্রাকৃতিক জায়গা:

প্রতিটি মডিউলটিতে নিজস্ব ব্যক্তিগত প্রতীক টেবিল রয়েছে যা মডিউলে সংজ্ঞায়িত সমস্ত ফাংশন দ্বারা বিশ্বব্যাপী প্রতীক টেবিল হিসাবে ব্যবহৃত হয়। সুতরাং, একটি মডিউল লেখক মডিউলের গ্লোবাল ভেরিয়েবলগুলি ব্যবহারকারীর গ্লোবাল ভেরিয়েবলগুলির সাথে আপত্তিকর সংঘর্ষের বিষয়ে উদ্বেগ ছাড়াই ব্যবহার করতে পারে। অন্যদিকে, যদি আপনি জানেন যে আপনি কী করছেন তা আপনি তার ফাংশন, modname.itemname উল্লেখ করতে ব্যবহৃত একই বিবরণের সাথে একটি মডিউল এর বিশ্বব্যাপী ভেরিয়েবল স্পর্শ করতে পারেন।

গ্লোবাল-ইন-অ-মডিউল এর একটি নির্দিষ্ট ব্যবহার এখানে বর্ণিত হয়েছে - how-do-i-share-global-variables-across-modules এবং সম্পূর্ণতার জন্য এখানে সামগ্রী ভাগ করা হয়:

একক প্রোগ্রামের মধ্যে মডিউল জুড়ে তথ্য ভাগ করার ক্যানোনিকাল উপায়টি বিশেষ কনফিগারেশন মডিউল তৈরি করতে হয় (প্রায়শই কনফিগার বা সিএফজি বলা হয়)। শুধু আপনার অ্যাপ্লিকেশন সব মডিউল মধ্যে কনফিগারেশন মডিউল আমদানি; তারপর মডিউল একটি গ্লোবাল নাম হিসাবে উপলব্ধ হয়ে ওঠে। কারণ প্রতিটি মডিউলের শুধুমাত্র একটি উদাহরণ রয়েছে, মডিউল বস্তুতে যেকোনো পরিবর্তন প্রতিফলিত হয়। উদাহরণ স্বরূপ:

ফাইল: config.py

x = 0   # Default value of the 'x' configuration setting

ফাইল: mod.py

import config
config.x = 1

ফাইল: main.py

import config
import mod
print config.x

আপনি প্রকৃতপক্ষে একটি স্থানীয় পরিবর্তনশীলকে বিশ্বব্যাপী সঞ্চয় করছেন না, কেবলমাত্র সেই একই বস্তুর স্থানীয় রেফারেন্স তৈরি করুন যা আপনার আসল গ্লোবাল রেফারেন্সটি বোঝায়। মনে রাখবেন যে পাইথনটিতে বেশিরভাগই একটি জিনিস যা একটি বস্তুর উল্লেখ করে, এবং স্বাভাবিক ক্রিয়াকলাপে কিছুই নকল হয় না।

কোন পূর্বনির্ধারিত বিশ্বব্যাপী কোন শনাক্তকারীকে উল্লেখ করার জন্য আপনাকে স্পষ্টভাবে উল্লেখ করার প্রয়োজন নেই, তবে সম্ভবত আপনি একটি সনাক্তকারী একটি নতুন স্থানীয় পরিবর্তনশীল হওয়ার পরে স্পষ্টভাবে উল্লেখ করতে হবে (উদাহরণস্বরূপ, 'var' কমান্ডের মতো কিছু জাভাস্ক্রিপ্ট দেখা)। যেহেতু স্থানীয় ভেরিয়েবল কোনও গুরুতর এবং অ-তুচ্ছ সিস্টেমে গ্লোবাল ভেরিয়েবলগুলির চেয়ে বেশি প্রচলিত, তাই পাইথনের সিস্টেম বেশিরভাগ ক্ষেত্রে আরও বেশি জ্ঞান দেয়।

আপনি একটি ভাষা যা অনুমান করার চেষ্টা করতে পারে, একটি বিশ্বব্যাপী পরিবর্তনশীল ব্যবহার করে যদি এটি বিদ্যমান থাকে বা স্থানীয় পরিবর্তনশীল তৈরি না করে। যাইহোক, যে খুব ত্রুটি-প্রবণ হতে হবে। উদাহরণস্বরূপ, অন্য কোনও মডিউল আমদানি করা অযত্নে সেই নামের দ্বারা একটি বিশ্বব্যাপী পরিবর্তনশীল পরিচয় দিতে পারে, আপনার প্রোগ্রামের আচরণ পরিবর্তন করে।


আপনি ব্যবহার করতে চান প্রতিটি ফাংশন গ্লোবাল ভেরিয়েবল রেফারেন্স প্রয়োজন।

নিম্নরূপ:

var = "test"

def printGlobalText():
    global var #wWe are telling to explicitly use the global version
    var = "global from printGlobalText fun."
    print "var from printGlobalText: " + var

def printLocalText():
    #We are NOT telling to explicitly use the global version, so we are creating a local variable
    var = "local version from printLocalText fun"
    print "var from printLocalText: " + var

printGlobalText()
printLocalText()
"""
Output Result:
var from printGlobalText: global from printGlobalText fun.
var from printLocalText: local version from printLocalText
[Finished in 0.1s]
"""

আমি আপনার পরিস্থিতি সঠিকভাবে বুঝতে পারছি, আপনি যা দেখছেন তা হলো পাইথন স্থানীয় (ফাংশন) এবং বিশ্বব্যাপী (মডিউল) নামস্থানগুলি পরিচালনা করে।

বলুন আপনি এই মত একটি মডিউল পেয়েছেন:

# sample.py
myGlobal = 5

def func1():
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()

আপনি 42 টি মুদ্রণ করতে প্রত্যাশিত হতে পারেন, তবে এর পরিবর্তে এটি 5 টি মুদ্রণ করে। ইতিমধ্যে উল্লেখ করা হয়েছে, যদি আপনি func1() একটি ' global ঘোষণা' যোগ করেন তবে func2() 42 টি মুদ্রণ করবে।

def func1():
    global myGlobal
    myGlobal = 42

এখানে যা হচ্ছে তা হল পাইথন অনুমান করেন যে কোনও নাম যে কোনও ফাংশনের মধ্যে যে কোনও জায়গায় নির্ধারিত হয় , সেই ফাংশনে স্থানীয়, যদি না অন্যথায় স্পষ্টভাবে বলা না হয়। যদি এটি শুধুমাত্র একটি নাম থেকে পড়া হয় এবং নামটি স্থানীয়ভাবে বিদ্যমান না থাকে তবে এটি কোনও স্কোপে (যেমন মডিউল এর বিশ্বব্যাপী সুযোগ) নামটি দেখতে চেষ্টা করবে।

যখন আপনি myGlobal নামে 42 টি বরাদ্দ করেন, তাই পাইথন একটি স্থানীয় পরিবর্তনশীল তৈরি করে যা একই নামের গ্লোবাল ভেরিয়েবল ছায়ায়। যে স্থানীয় সুযোগ আউট যায় এবং garbage-collected যখন func1() ফিরে আসে; ইতিমধ্যে, func2() unmodified বিশ্বব্যাপী নাম ছাড়া অন্য কিছু দেখতে পারে না। উল্লেখ্য, এই myGlobal সিদ্ধান্তটি myGlobal সময় সংঘটিত হয়, রানটাইম সময়ে নয় - যদি আপনি func1() বরাদ্দ করার আগে func1() অভ্যন্তরে func1() এর মান পড়তে থাকেন, তবে আপনি একটি UnboundLocalError , কারণ পাইথন ইতিমধ্যেই সিদ্ধান্ত নিয়েছে যে এটি অবশ্যই একটি স্থানীয় পরিবর্তনশীল কিন্তু এটি এখনো এর সাথে যুক্ত কোনো মান ছিল না। কিন্তু ' global ' বিবৃতিটি ব্যবহার করে, আপনি পাইথনকে জানান যে এটি স্থানীয়ভাবে এটির পরিবর্তে নামটির জন্য অন্যত্র দেখতে হবে।

(আমি বিশ্বাস করি যে এই আচরণটি স্থানীয় নামস্থানগুলির একটি অপ্টিমাইজেশনের মাধ্যমে মূলত উৎপন্ন হয় - এই আচরণ ব্যতীত, পাইথন এর ভিএমটি একটি ফাংশনের ভেতরে নতুন নাম দেওয়া হলে প্রতিবার কমপক্ষে তিনটি নাম সন্ধান করতে হবে (এটি নিশ্চিত করা যে নামটি ' টি ইতিমধ্যে মডিউল / বিল্টিন লেভেলে বিদ্যমান), যা উল্লেখযোগ্যভাবে খুব সাধারণ অপারেশনটি হ্রাস করবে।)


আমি এটি যোগ করছি যেহেতু আমি অন্য কোনো উত্তরগুলিতে এটি দেখেছি না এবং এটি অনুরূপ কিছু নিয়ে লড়াই করার জন্য এটি উপকারী হতে পারে। Globals () ফাংশন একটি পরিবর্তনযোগ্য বিশ্বব্যাপী প্রতীক অভিধান প্রদান করে যেখানে আপনি "যাদুকরীভাবে" আপনার অবশিষ্ট কোডের জন্য ডেটা উপলব্ধ করতে পারেন। উদাহরণ স্বরূপ:

from pickle import load
def loaditem(name):
    with open(r"C:\pickle\file\location"+"\{}.dat".format(name), "rb") as openfile:
        globals()[name] = load(openfile)
    return True

এবং

from pickle import dump
def dumpfile(name):
    with open(name+".dat", "wb") as outfile:
        dump(globals()[name], outfile)
    return True

গ্লোবাল নেমস্পেসে থেকে এবং ভেরিয়েবলগুলিকে ডাম্প / লোড করতে দেয়। সুপার সুবিধাজনক, কোন ঝগড়া, কোন ভুল। খুব নিশ্চিত এটা পাইথন 3 শুধুমাত্র।


একটি অ্যাড অন হিসাবে এবং স্থানীয়ভাবে ঘোষণা করা সমস্ত বিশ্বব্যাপী ভেরিয়েবল ধারণ করার জন্য একটি ফাইল ব্যবহার করুন এবং তারপরে 'এভাবে আমদানি করুন':

ফাইল initval.py

Stocksin = 300
Prices = []

ফাইল getstocks.py

import  initval as  iv

Def   getmystocks (): 
     iv.Stocksin  = getstockcount ()


Def getmycharts ():
    For ic in range (0,iv.Stocksin):

.....


একটি বিশ্বব্যাপী অ্যারের স্পষ্ট উপাদানগুলিতে লিখিতভাবে দৃশ্যত বিশ্বব্যাপী ঘোষণার প্রয়োজন নেই, যদিও এটিতে "পাইকারি" লেখার প্রয়োজনীয়তা রয়েছে:

import numpy as np

hostValue = 3.14159
hostArray = np.array([2., 3.])
hostMatrix = np.array([[1.0, 0.0],[ 0.0, 1.0]])

def func1():
    global hostValue    # mandatory, else local.
    hostValue = 2.0

def func2():
    global hostValue    # mandatory, else UnboundLocalError.
    hostValue += 1.0

def func3():
    global hostArray    # mandatory, else local.
    hostArray = np.array([14., 15.])

def func4():            # no need for globals
    hostArray[0] = 123.4

def func5():            # no need for globals
    hostArray[1] += 1.0

def func6():            # no need for globals
    hostMatrix[1][1] = 12.

def func7():            # no need for globals
    hostMatrix[0][0] += 0.33

func1()
print "After func1(), hostValue = ", hostValue
func2()
print "After func2(), hostValue = ", hostValue
func3()
print "After func3(), hostArray = ", hostArray
func4()
print "After func4(), hostArray = ", hostArray
func5()
print "After func5(), hostArray = ", hostArray
func6()
print "After func6(), hostMatrix = \n", hostMatrix
func7()
print "After func7(), hostMatrix = \n", hostMatrix

পাইথন স্থানীয় এবং বিশ্বব্যাপী মধ্যে কোন পরিবর্তনশীল লোকেশন লোড করা উচিত তা নির্ধারণ করার জন্য একটি সহজ হিউরিস্টিক ব্যবহার করে। যদি একটি অ্যাসাইনমেন্টের বাম দিকের দিকে একটি পরিবর্তনশীল নাম প্রদর্শিত হয় তবে বিশ্বব্যাপী ঘোষিত হয় না তবে এটি স্থানীয় বলে মনে করা হয়। যদি এটি একটি অ্যাসাইনমেন্টের বাম দিকে প্রদর্শিত না হয়, এটি বিশ্বব্যাপী বলে মনে করা হয়।

>>> import dis
>>> def foo():
...     global bar
...     baz = 5
...     print bar
...     print baz
...     print quux
... 
>>> dis.disassemble(foo.func_code)
  3           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (baz)

  4           6 LOAD_GLOBAL              0 (bar)
              9 PRINT_ITEM          
             10 PRINT_NEWLINE       

  5          11 LOAD_FAST                0 (baz)
             14 PRINT_ITEM          
             15 PRINT_NEWLINE       

  6          16 LOAD_GLOBAL              1 (quux)
             19 PRINT_ITEM          
             20 PRINT_NEWLINE       
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE        
>>> 

দেখুন কিভাবে baz, foo() এ একটি অ্যাসাইনমেন্ট বাম দিকে প্রদর্শিত হয়, এটি LOAD_FAST পরিবর্তনশীল।


যদি আপনার একই নামের সাথে একটি স্থানীয় পরিবর্তনশীল থাকে তবে আপনি globals() ফাংশনটি ব্যবহার করতে চাইতে পারেন।

globals()['your_global_var'] = 42

সমান্তরাল সঞ্চালন সঙ্গে, গ্লোবাল ভেরিয়েবল কি ঘটছে তা বুঝতে না যদি অপ্রত্যাশিত ফলাফল হতে পারে। এখানে মাল্টিপ্রসেসিংয়ের মধ্যে একটি বিশ্বব্যাপী পরিবর্তনশীল ব্যবহার করার একটি উদাহরণ। আমরা স্পষ্টভাবে দেখতে পারি যে প্রতিটি প্রক্রিয়া পরিবর্তনশীলের নিজস্ব কপি দিয়ে কাজ করে:

import multiprocessing
import os
import random
import sys
import time

def worker(new_value):
    old_value = get_value()
    set_value(random.randint(1, 99))
    print('pid=[{pid}] '
          'old_value=[{old_value:2}] '
          'new_value=[{new_value:2}] '
          'get_value=[{get_value:2}]'.format(
          pid=str(os.getpid()),
          old_value=old_value,
          new_value=new_value,
          get_value=get_value()))

def get_value():
    global global_variable
    return global_variable

def set_value(new_value):
    global global_variable
    global_variable = new_value

global_variable = -1

print('before set_value(), get_value() = [%s]' % get_value())
set_value(new_value=-2)
print('after  set_value(), get_value() = [%s]' % get_value())

processPool = multiprocessing.Pool(processes=5)
processPool.map(func=worker, iterable=range(15))

আউটপুট:

before set_value(), get_value() = [-1]
after  set_value(), get_value() = [-2]
pid=[53970] old_value=[-2] new_value=[ 0] get_value=[23]
pid=[53971] old_value=[-2] new_value=[ 1] get_value=[42]
pid=[53970] old_value=[23] new_value=[ 4] get_value=[50]
pid=[53970] old_value=[50] new_value=[ 6] get_value=[14]
pid=[53971] old_value=[42] new_value=[ 5] get_value=[31]
pid=[53972] old_value=[-2] new_value=[ 2] get_value=[44]
pid=[53973] old_value=[-2] new_value=[ 3] get_value=[94]
pid=[53970] old_value=[14] new_value=[ 7] get_value=[21]
pid=[53971] old_value=[31] new_value=[ 8] get_value=[34]
pid=[53972] old_value=[44] new_value=[ 9] get_value=[59]
pid=[53973] old_value=[94] new_value=[10] get_value=[87]
pid=[53970] old_value=[21] new_value=[11] get_value=[21]
pid=[53971] old_value=[34] new_value=[12] get_value=[82]
pid=[53972] old_value=[59] new_value=[13] get_value=[ 4]
pid=[53973] old_value=[87] new_value=[14] get_value=[70]

হিসাবে এটি উত্তর সক্রিয় সবসময় সহজ।

এখানে একটি main সংজ্ঞাতে এটি দেখাতে একটি সহজ উপায় সহ একটি ছোট নমুনা মডিউল রয়েছে:

def five(enterAnumber,sumation):
    global helper
    helper  = enterAnumber + sumation

def isTheNumber():
    return helper

এখানে কীভাবে একটি main সংজ্ঞাতে এটি দেখা যায়:

import TestPy

def main():
    atest  = TestPy
    atest.five(5,8)
    print(atest.isTheNumber())

if __name__ == '__main__':
    main()

এই সহজ কোড ঠিক মত কাজ করে, এবং এটি কার্যকর হবে। আমি আসা করি এটা সাহায্য করবে.





scope