আমারও এমন অবস্থা আছে ...
class Outer(object):
def some_method(self):
# do something
class Inner(object):
def __init__(self):
self.Outer.some_method() # <-- this is the line in question
আমি কীভাবে Outerক্লাস থেকে Innerক্লাসের পদ্ধতি অ্যাক্সেস করতে পারি ?
self.<original_parent_name>এবং মূল বর্গ, নতুন বর্গ যে তারা থেকে একটি উপ-শ্রেণী পেতে । আমি আশা করি এটি পড়ার লোকেরা এই কঠিন পরিস্থিতিটি কল্পনা করতে এবং এই জাতীয় প্রশ্নের বিন্দুটি দেখতে পারে।
উত্তর:
নেস্টেড ক্লাসের পদ্ধতিগুলি বাইরের শ্রেণীর উদাহরণ বৈশিষ্টগুলি সরাসরি অ্যাক্সেস করতে পারে না।
মনে রাখবেন যে বাহ্যিক শ্রেণীর উদাহরণ উপস্থিত থাকা সত্ত্বেও এটি অগত্যা নয় যে আপনি অভ্যন্তর শ্রেণীর উদাহরণ তৈরি করেছেন।
প্রকৃতপক্ষে, প্রায়শই এটি নেস্টেড ক্লাসগুলি ব্যবহার করার বিরুদ্ধে সুপারিশ করা হয়, যেহেতু বাসা বাঁধার অভ্যন্তরীণ এবং বাইরের শ্রেণীর মধ্যে কোনও বিশেষ সম্পর্ক বোঝায় না।
আপনি অভ্যন্তর শ্রেণীর উদাহরণ থেকে আউটারের ক্লাস উদাহরণটি অ্যাক্সেস করার চেষ্টা করছেন। সুতরাং কেবলমাত্র অভ্যন্তরীণ উদাহরণটি তৈরি করতে কারখানার পদ্ধতিটি ব্যবহার করুন এবং এতে আউটারের উদাহরণটি পাস করুন।
class Outer(object):
def createInner(self):
return Outer.Inner(self)
class Inner(object):
def __init__(self, outer_instance):
self.outer_instance = outer_instance
self.outer_instance.somemethod()
def inner_method(self):
self.outer_instance.anothermethod()
সম্ভবত আমি পাগল কিন্তু এটি সত্যিই খুব সহজ বলে মনে হচ্ছে - জিনিসটি আপনার অভ্যন্তর শ্রেণিকে বাইরের শ্রেণির কোনও পদ্ধতির অভ্যন্তরে তৈরি করা ...
def do_sthg( self ):
...
def messAround( self ):
outerClassSelf = self
class mooble():
def do_sthg_different( self ):
...
outerClassSelf.do_sthg()
প্লাস ... "স্ব" কেবল কনভেনশন দ্বারা ব্যবহৃত হয়, সুতরাং আপনি এটি করতে পারেন:
def do_sthg( self ):
...
def messAround( outerClassSelf ):
class mooble():
def do_sthg_different( self ):
...
outerClassSelf.do_sthg()
এটি আপত্তি করা যেতে পারে যে আপনি বাইরের শ্রেণীর বাইরে থেকে এই অভ্যন্তর শ্রেণি তৈরি করতে পারবেন না ... তবে এটি সত্য নয়:
class Bumblebee():
def do_sthg( self ):
print "sthg"
def giveMeAnInnerClass( outerClassSelf ):
class mooble():
def do_sthg_different( self ):
print "something diff\n"
outerClassSelf.do_sthg()
return mooble
তারপরে, কোথাও মাইল দূরে:
blob = Bumblebee().giveMeAnInnerClass()()
blob.do_sthg_different()
এমনকি নৌকাকে কিছুটা দূরে ঠেলেও এই অভ্যন্তরীণ বর্গকে প্রসারিত করুন (সুপার পাওয়ার জন্য NB) আপনাকে কাজ করার জন্য mooble এর শ্রেণি স্বাক্ষরকে "শ্রেণি mooble (অবজেক্ট)" এ পরিবর্তন করতে হবে
class InnerBumblebeeWithAddedBounce( Bumblebee().giveMeAnInnerClass() ):
def bounce( self ):
print "bounce"
def do_sthg_different( self ):
super( InnerBumblebeeWithAddedBounce, self ).do_sthg_different()
print "and more different"
ibwab = InnerBumblebeeWithAddedBounce()
ibwab.bounce()
ibwab.do_sthg_different()
পরে
mrh1997 এই কৌশলটি ব্যবহার করে বিতরণ করা অভ্যন্তর শ্রেণীর অ-সাধারণ উত্তরাধিকার সম্পর্কে একটি আকর্ষণীয় বিষয় উত্থাপন করেছে। তবে মনে হয় সমাধানটি বেশ সোজা:
class Fatty():
def do_sthg( self ):
pass
class InnerFatty( object ):
pass
def giveMeAnInnerFattyClass(self):
class ExtendedInnerFatty( Fatty.InnerFatty ):
pass
return ExtendedInnerFatty
fatty1 = Fatty()
fatty2 = Fatty()
innerFattyClass1 = fatty1.giveMeAnInnerFattyClass()
innerFattyClass2 = fatty2.giveMeAnInnerFattyClass()
print ( issubclass( innerFattyClass1, Fatty.InnerFatty ))
print ( issubclass( innerFattyClass2, Fatty.InnerFatty ))
আপনি কি এই জাতীয় বংশবৃদ্ধি না করে উত্তরাধিকার ব্যবহারের অর্থ? আপনি যা করছেন তা পাইথনে বোধগম্যতা তৈরি করে না।
আপনি Outerকেবলমাত্র Outer.some_methodঅভ্যন্তর শ্রেণীর পদ্ধতিগুলির মধ্যে উল্লেখ করে কিছু 'me উদাহরণস্বরূপ, যদি আপনি এটি চেষ্টা করেন:
class Outer(object):
def some_method(self):
# do something
class Inner(object):
def __init__(self):
Outer.some_method()
... কোনও Innerঅবজেক্টের সূচনা করার সময় আপনি একটি টাইপরর পাবেন , কারণ এটির প্রথম আর্গুমেন্ট হিসাবে Outer.some_methodকোনও Outerউদাহরণ পাওয়ার প্রত্যাশা । (উপরের উদাহরণে, আপনি মূলত some_methodশ্রেণীর পদ্ধতি হিসাবে কল করার চেষ্টা করছেন Outer))
আপনি মেটাক্লাস ব্যবহার করে সহজেই বহিরাগত শ্রেণিতে অ্যাক্সেস করতে পারেন: বহিরাগত শ্রেণি তৈরির পরে এটি কোনও শ্রেণীর জন্য এটির জন্য ড্যাট্রিটিউট ডিক্ট (বা আপনার প্রয়োজনীয় কোনও যুক্তি প্রয়োগ করুন - খনি কেবল তুচ্ছ উদাহরণ) এবং সম্পর্কিত মানগুলি সেট করুন:
import six
import inspect
# helper method from `peewee` project to add metaclass
_METACLASS_ = '_metaclass_helper_'
def with_metaclass(meta, base=object):
return meta(_METACLASS_, (base,), {})
class OuterMeta(type):
def __new__(mcs, name, parents, dct):
cls = super(OuterMeta, mcs).__new__(mcs, name, parents, dct)
for klass in dct.values():
if inspect.isclass(klass):
print("Setting outer of '%s' to '%s'" % (klass, cls))
klass.outer = cls
return cls
# @six.add_metaclass(OuterMeta) -- this is alternative to `with_metaclass`
class Outer(with_metaclass(OuterMeta)):
def foo(self):
return "I'm outer class!"
class Inner(object):
outer = None # <-- by default it's None
def bar(self):
return "I'm inner class"
print(Outer.Inner.outer)
>>> <class '__main__.Outer'>
assert isinstance(Outer.Inner.outer(), Outer)
print(Outer().foo())
>>> I'm outer class!
print(Outer.Inner.outer().foo())
>>> I'm outer class!
print(Outer.Inner().outer().foo())
>>> I'm outer class!
print(Outer.Inner().bar())
>>> I'm inner class!
এই পদ্ধতির ব্যবহার করে, আপনি একে অপরের মধ্যে সহজেই দুটি ক্লাস বাঁধতে এবং উল্লেখ করতে পারেন।
এই প্রশ্নের অন্য উত্তর থেকে ভাল ধারণার ভিত্তিতে আমি এর অভ্যন্তর শ্রেণি থেকে একটি বহিরাগত শ্রেণি ব্যবহার করার জন্য কিছু পাইথন কোড তৈরি করেছি । আমি মনে করি এটি সংক্ষিপ্ত, সহজ এবং বুঝতে সহজ।
class higher_level__unknown_irrelevant_name__class:
def __init__(self, ...args...):
...other code...
# Important lines to access sub-classes.
subclasses = self._subclass_container()
self.some_subclass = subclasses["some_subclass"]
del subclasses # Free up variable for other use.
def sub_function(self, ...args...):
...other code...
def _subclass_container(self):
_parent_class = self # Create access to parent class.
class some_subclass:
def __init__(self):
self._parent_class = _parent_class # Easy access from self.
# Optional line, clears variable space, but SHOULD NOT BE USED
# IF THERE ARE MULTIPLE SUBCLASSES as would stop their parent access.
# del _parent_class
class subclass_2:
def __init__(self):
self._parent_class = _parent_class
# Return reference(s) to the subclass(es).
return {"some_subclass": some_subclass, "subclass_2": subclass_2}
প্রধান কোড, "উত্পাদন প্রস্তুত" (কোনও মন্তব্য ছাড়াই)। প্রতিটি বন্ধনীর বন্ধনী (যেমন <x>) প্রতিটি মানকে পছন্দসই মানের সাথে প্রতিস্থাপন করতে ভুলবেন না ।
class <higher_level_class>:
def __init__(self):
subclasses = self._subclass_container()
self.<sub_class> = subclasses[<sub_class, type string>]
del subclasses
def _subclass_container(self):
_parent_class = self
class <sub_class>:
def __init__(self):
self._parent_class = _parent_class
return {<sub_class, type string>: <sub_class>}
_subclass_containerভেরিয়েবল অ্যাক্সেস করার জন্য মোড়ক হিসাবে কাজ করার জন্য একটি ফাংশন তৈরি করুন self, উচ্চ স্তরের শ্রেণীর একটি রেফারেন্স (ফাংশনের অভ্যন্তরে চলমান কোড থেকে)।
নামের একটি ভেরিয়েবল তৈরি করুন _parent_classযা selfএই ফাংশনের ভেরিয়েবলের একটি রেফারেন্স , যা উপ-শ্রেণীর _subclass_containerঅ্যাক্সেস করতে পারে ( selfসাবক্লাসে অন্যান্য ভেরিয়েবলের সাথে নামের দ্বন্দ্ব এড়ায়)।
উপ-শ্রেণি / উপ-শ্রেণিগুলি অভিধান / তালিকা হিসাবে ফিরিয়ে দিন যাতে ফাংশনটিতে কল করা কোডটি _subclass_containerউপ-শ্রেণীর ভিতরে প্রবেশ করতে পারে।
ইন __init__উচ্চ স্তরের শ্রেণী (বা যেখানে প্রয়োজন) ভিতরে ফাংশন, ফাংশন থেকে ফেরত উপ-শ্রেণীর গ্রহণ _subclass_containerপরিবর্তনশীল মধ্যে subclasses।
subclassesউচ্চ স্তরের শ্রেণীর বৈশিষ্ট্যগুলিতে ভেরিয়েবলের মধ্যে সঞ্চিত সাব-ক্লাস নির্ধারণ করুন ।
উচ্চ স্তরের শ্রেণিতে সাব ক্লাসগুলি নির্ধারিত করার জন্য কোড তৈরি করা সহজ এবং অনুলিপি উচ্চতর স্তরের শ্রেণি থেকে প্রাপ্ত ক্লাসগুলিতে তাদের __init__ ফাংশন পরিবর্তিত হয়েছে:
প্রধান কোডে 12 লাইনের আগে সন্নিবেশ করান:
def _subclass_init(self):
তারপরে এই ফাংশন লাইনগুলিতে 5-6 (মূল কোডের) সন্নিবেশ করান এবং 4-7 লাইনগুলি নিম্নলিখিত কোডের সাথে প্রতিস্থাপন করুন:
self._subclass_init(self)
সাবক্লাসের অনেক / অজানা পরিমাণ রয়েছে যখন উচ্চ স্তরের শ্রেণিতে অর্পণ করা সাবক্লাস তৈরি করা।
নিম্নলিখিত কোড সহ লাইন 6 প্রতিস্থাপন করুন:
for subclass_name in list(subclasses.keys()):
setattr(self, subclass_name, subclasses[subclass_name])
"A" ( class a:) নামে একটি শ্রেণি তৈরি করা হয়েছে। এটিতে সাবক্লাস রয়েছে যা এটি (পিতামাতাকে) অ্যাক্সেস করতে হবে। একটি সাবক্লাসকে বলা হয় "x1"। এই সাবক্লাসে কোডটি a.run_func()চালানো হয়।
তারপরে "বি" নামে আরও একটি শ্রেণি তৈরি হয়, এটি "এ" ( ) শ্রেণি থেকে উদ্ভূত হয় class b(a):। এর পরে, কিছু কোড চলে b.x1()(উপ ফাংশনটিকে বি এর "x1", একটি উত্পন্ন উপ-শ্রেণি বলে) runs এই ফাংশনটি রান a.run_func(), ফাংশন ক্লাসের "run_func" "একটি", কলিং না , (যেমন এটি করা উচিত) ফাংশন তার পিতা বা মাতা এর "run_func", "খ" কারণ ফাংশন যা বর্গ সংজ্ঞায়িত করা হয় "একটি" সেট করা হয় উল্লেখ করতে "a" ক্লাসের ফাংশনে, যেমন এটির পিতামাতা।
এটি সমস্যার কারণ হতে পারে (উদাহরণস্বরূপ যদি ফাংশনটি a.run_funcমুছে ফেলা হয়েছে) এবং ক্লাসে কোডটি পুনরায় না লিখে একমাত্র সমাধান হ'ল "এ" শ্রেণি থেকে প্রাপ্ত সমস্ত শ্রেণীর জন্য আপডেট কোড সহ a.x1উপ-শ্রেণীর x1নতুন সংজ্ঞা দেওয়া যা স্পষ্টতই কঠিন এবং মূল্যবান নয় এটা।
আমি দেখেছি এই ।
আপনার প্রশ্নের স্যুট করতে টুইট করা হয়েছে:
class Outer(object):
def some_method(self):
# do something
class _Inner(object):
def __init__(self, outer):
outer.some_method()
def Inner(self):
return _Inner(self)
আমি নিশ্চিত যে আপনি এই বা কোনও কিছুর জন্য কোনও সজ্জা লিখতে পারেন
সম্পর্কিত: পাইথনের অভ্যন্তর শ্রেণীর উদ্দেশ্য কী?
আরেকটি সম্ভাবনা:
class _Outer (object):
# Define your static methods here, e.g.
@staticmethod
def subclassRef ():
return Outer
class Outer (_Outer):
class Inner (object):
def outer (self):
return _Outer
def doSomething (self):
outer = self.outer ()
# Call your static mehthods.
cls = outer.subclassRef ()
return cls ()
বাইরের পদ্ধতিটি একটি স্থির পদ্ধতি হতে পারে যে @ tsnorri এর সমন্বিত চিন্তাভাবনার উপর প্রসারিত :
class Outer(object):
@staticmethod
def some_static_method(self):
# do something
class Inner(object):
def __init__(self):
self.some_static_method() # <-- this will work later
Inner.some_static_method = some_static_method
এখন প্রশ্নযুক্ত লাইনটি আসলে বলা হওয়ার সাথে সাথে কাজ করা উচিত।
উপরের কোডের শেষ লাইনটি অভ্যন্তর শ্রেণিকে একটি স্থির পদ্ধতি দেয় যা আউটার স্ট্যাটিক পদ্ধতির ক্লোন।
এটি দুটি পাইথন বৈশিষ্ট্যের সুবিধা গ্রহণ করে যে ফাংশনগুলি বস্তু এবং স্কোপটি পাঠ্যগত ।
সাধারণত, স্থানীয় সুযোগটি (পাঠ্য) বর্তমান ফাংশনের স্থানীয় নামগুলি উল্লেখ করে।
... বা আমাদের ক্ষেত্রে বর্তমান বর্গ । সুতরাং আউটটার ক্লাসের সংজ্ঞা ( Innerএবং some_static_method) এর "স্থানীয়" অবজেক্টগুলিকে সরাসরি সেই সংজ্ঞার মধ্যে উল্লেখ করা যেতে পারে।
কয়েক বছর পার্টি দেরী .... কিন্তু উপর প্রসারিত করতে @mike rodent'র বিস্ময়কর উত্তর, আমি আমার নিজের উদাহরণ শো নীচে দেওয়া থাকেন ঠিক কিভাবে নমনীয় তার সমাধান এবং কেন এটা করা উচিত (অথবা উচিত আছে হয়েছে) গৃহীত উত্তর.
পাইথন 3.7
class Parent():
def __init__(self, name):
self.name = name
self.children = []
class Inner(object):
pass
def Child(self, name):
parent = self
class Child(Parent.Inner):
def __init__(self, name):
self.name = name
self.parent = parent
parent.children.append(self)
return Child(name)
parent = Parent('Bar')
child1 = parent.Child('Foo')
child2 = parent.Child('World')
print(
# Getting its first childs name
child1.name, # From itself
parent.children[0].name, # From its parent
# Also works with the second child
child2.name,
parent.children[1].name,
# Go nuts if you want
child2.parent.children[0].name,
child1.parent.children[1].name
)
print(
# Getting the parents name
parent.name, # From itself
child1.parent.name, # From its children
child2.parent.name,
# Go nuts again if you want
parent.children[0].parent.name,
parent.children[1].parent.name,
# Or insane
child2.parent.children[0].parent.children[1].parent.name,
child1.parent.children[1].parent.children[0].parent.name
)
# Second parent? No problem
parent2 = Parent('John')
child3 = parent2.Child('Doe')
child4 = parent2.Child('Appleseed')
print(
child3.name, parent2.children[0].name,
child4.name, parent2.children[1].name,
parent2.name # ....
)
আউটপুট:
Foo Foo World World Foo World
Bar Bar Bar Bar Bar Bar Bar
Doe Doe Appleseed Appleseed John
আবার, একটি দুর্দান্ত উত্তর, আপনি মাইকে প্রপস!
এটি খুব সহজ:
class A:
def __init__(self):
pass
def func1(self):
print('class A func1')
class B:
def __init__(self):
a1 = A()
a1.func1()
def func1(self):
print('class B func1')
b = A.B()
b.func1()
ক্লাস এ ফানক 1
ক্লাস বি func1
func1। এবং, সমান মজাদার, আপনি Aনির্মাণকারীর ভিতরে একটি অভ্যন্তর তৈরি করুন B, যা একেবারে Aনির্দিষ্টটির বাইরের শ্রেণীর অবজেক্ট নয় B।