ਮੈਨੂੰ ਇੱਕ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਇੱਕ ਯੂ. ਆਈ. ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰਨ ਲਈ ਗੋਡੋਟ ਵਿੱਚ ਕੋਡ ਦਿਖਾਓ। ਹਰੇਕ ਆਈਟਮ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਵੇਰਵਾ ਹੁੰਦਾ ਹੈ, ਇੱਕਕੀਮਤ, ਅਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਚਿੱਤਰ ਲਈ ਇੱਕ ਸਰੋਤ ਨਾਮ। ", 'ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਇੱਕ ਯੂ. ਆਈ. ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰਨ ਲਈ ਮੈਨੂੰ ਗੋਡੋਟ ਵਿੱਚ ਕੋਡ ਦਿਖਾਓ। ਹਰੇਕ ਆਈਟਮ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਵੇਰਵਾ, ਇੱਕ ਕੀਮਤ,ਅਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਚਿੱਤਰ ਲਈ ਇੱਕ ਸਰੋਤ ਨਾਮ।', ' [\'ਮੈਨੂੰ ਇੱਕ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਇੱਕ ਯੂ. ਆਈ. ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰਨ ਲਈ ਗੋਡੋਟ ਵਿੱਚ ਕੋਡ ਦਿਖਾਓ। ਹਰੇਕ ਆਈਟਮ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਵੇਰਵਾ ਹੁੰਦਾ ਹੈ, ਇੱਕਕੀਮਤ, ਅਤੇ ਇੱਕ ਚਿੱਤਰ ਲਈ ਇੱਕ ਸਰੋਤ ਨਾਮ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਣਾ ਹੈ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਗੋਡੋਟ ਵਿੱਚ ਇੱਕ ਉਦਾਹਰਣ ਕੋਡ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ UI ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਕਿਵੇਂ ਤਿਆਰ ਕਰਨਾ ਹੈ।ਇੱਕ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲਃ \\n "\'ਪਾਈਥਨ \\n #ਨੋਡ ਲਈ ਇੱਕ ਕਲਾਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗੀ \\n ਕਲਾਸItemListNode (Node): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n Node.__init__ (ਸੈਲਫ) \\n self.list_box = NodeListBox.new () \\n self.add_child (self.list_box) \\n\\n #ਲੋਡ ਕਰੋਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾ \\n ਵਾਰ ਜੇਸਨ _ ਡਾਟਾ = ਓਪਨ ("item_list.json"). ਰੀਡ () \\n ਵਾਰ ਆਈਟਮ _ ਲਿਸਟ = json.loads (ਜੇਸਨ _ ਡੇਟਾ) \\n\\n #ਸੂਚੀ ਬਾਕਸ ਨੂੰ ਇਹਨਾਂ ਵਿੱਚੋਂ ਆਈਟਮਾਂ ਨਾਲ ਤਿਆਰ ਕਰੋ।ਆਈਟਮ _ ਲਿਸਟ ਵਿੱਚ ਆਈਟਮ ਲਈ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾਃ \\n ਵਰ ਆਈਟਮ _ ਟੈਕਸਟ = String.new (ਆਈਟਮ ["ਟੈਕਸਟ _ ਵਰਣਨ"]) \\n ਵਰ ਆਈਟਮ _ ਪ੍ਰਾਈਸ = Float.new (ਆਈਟਮ ["ਕੀਮਤ"]) \\n ਵਰ ਆਈਟਮ _ ਚਿੱਤਰ= String.new (ਆਈਟਮ ["ਚਿੱਤਰ _ ਸਰੋਤ _ ਨਾਮ"]) \\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਟੈਕਸਟ = ਆਈਟਮ _ ਟੈਕਸਟ\\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਆਈਕਾਨ =ਆਈਟਮ _ ਚਿੱਤਰ \\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਸੈੱਟ _ ਪ੍ਰਾਈਸ (ਆਈਟਮ _ ਪ੍ਰਾਈਸ) \\n ਆਈਟਮ _ ਇੰਡੈਕਸ + = 1 \\n\\n #UI \\nfunc _ ꯔꯦਡੀ () ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ItemListNode ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ \\n ver item _ list _ node = ItemListNode.new () \\n\\n #ਆਈਟਮ ਲਿਸਟ ਨੋਡ ਨੂੰ ਸੀਨ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ \\nਐਡ _ ਚਾਈਲਡ (ਆਈਟਮ _ ਲਿਸਟ _ ਨੋਡ) \\n\\n #ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡੇਟਾ ਨੂੰ ਲੋਡ ਕਰੋ \\nvar json _ ਡੇਟਾ = ਓਪਨ ("item_list.json"). ਰੀਡ () \\nvar item _ ਲਿਸਟ = json.loads (json _ ਡੇਟਾ) \\n\\n #ਕਾਲ ਕਰੋUI ਨੂੰ ਬਣਾਉਣ ਲਈ ਤਿਆਰ () ਫੰਕਸ਼ਨ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਨੋਡ ਲਈ ਇੱਕ ਕਲਾਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਜੋ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗਾ।ਕਲਾਸ ਦਾ \'_ _ init _ _\' ਢੰਗ, ਅਸੀਂ ਇੱਕ \'ਨੋਡਲਿਸਟਬਾਕਸ\' ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਸ ਨੂੰ ਨੋਡ ਦੇ ਚਾਈਲਡ ਦੇ ਰੂਪ ਵਿੱਚ ਜੋਡ਼ਦੇ ਹਾਂ। ਫਿਰ ਅਸੀਂ ਇੱਕ ਫਾਈਲ ਤੋਂ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾ ਲੋਡ ਕਰਦੇ ਹਾਂ ਜਿਸ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ"ਆਈਟਮ\\\\ _list.json" \'ਓਪਨ\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਅਤੇ ਇਸ ਨੂੰ \'json.loads\' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪਾਰਸ ਕਰੋ।\'ਨੋਡ\', \'ਕ੍ਰਿਪਾ ਕਰਕੇ ਜਾਰੀ ਰੱਖੋ।\'] ', 'ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਇੱਕ ਯੂ. ਆਈ. ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰਨ ਲਈ ਮੈਨੂੰ ਗੋਡੋਟ ਵਿੱਚ ਕੋਡ ਦਿਖਾਓ। ਹਰੇਕ ਆਈਟਮ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਵੇਰਵਾ, ਇੱਕ ਕੀਮਤ,ਅਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਚਿੱਤਰ ਲਈ ਇੱਕ ਸਰੋਤ ਨਾਮ।', ' [\'ਮੈਨੂੰ ਇੱਕ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਇੱਕ ਯੂ. ਆਈ. ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰਨ ਲਈ ਗੋਡੋਟ ਵਿੱਚ ਕੋਡ ਦਿਖਾਓ। ਹਰੇਕ ਆਈਟਮ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਵੇਰਵਾ ਹੁੰਦਾ ਹੈ, ਇੱਕਕੀਮਤ, ਅਤੇ ਇੱਕ ਚਿੱਤਰ ਲਈ ਇੱਕ ਸਰੋਤ ਨਾਮ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਣਾ ਹੈ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਗੋਡੋਟ ਵਿੱਚ ਇੱਕ ਉਦਾਹਰਣ ਕੋਡ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ UI ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਕਿਵੇਂ ਤਿਆਰ ਕਰਨਾ ਹੈ।ਇੱਕ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲਃ \\n "\'ਪਾਈਥਨ \\n #ਨੋਡ ਲਈ ਇੱਕ ਕਲਾਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗੀ \\n ਕਲਾਸItemListNode (Node): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n Node.__init__ (ਸੈਲਫ) \\n self.list_box = NodeListBox.new () \\n self.add_child (self.list_box) \\n\\n #ਲੋਡ ਕਰੋਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾ \\n ਵਾਰ ਜੇਸਨ _ ਡਾਟਾ = ਓਪਨ ("item_list.json"). ਰੀਡ () \\n ਵਾਰ ਆਈਟਮ _ ਲਿਸਟ = json.loads (ਜੇਸਨ _ ਡੇਟਾ) \\n\\n #ਸੂਚੀ ਬਾਕਸ ਨੂੰ ਇਹਨਾਂ ਵਿੱਚੋਂ ਆਈਟਮਾਂ ਨਾਲ ਤਿਆਰ ਕਰੋ।ਆਈਟਮ _ ਲਿਸਟ ਵਿੱਚ ਆਈਟਮ ਲਈ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾਃ \\n ਵਰ ਆਈਟਮ _ ਟੈਕਸਟ = String.new (ਆਈਟਮ ["ਟੈਕਸਟ _ ਵਰਣਨ"]) \\n ਵਰ ਆਈਟਮ _ ਪ੍ਰਾਈਸ = Float.new (ਆਈਟਮ ["ਕੀਮਤ"]) \\n ਵਰ ਆਈਟਮ _ ਚਿੱਤਰ= String.new (ਆਈਟਮ ["ਚਿੱਤਰ _ ਸਰੋਤ _ ਨਾਮ"]) \\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਟੈਕਸਟ = ਆਈਟਮ _ ਟੈਕਸਟ\\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਆਈਕਾਨ =ਆਈਟਮ _ ਚਿੱਤਰ \\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਸੈੱਟ _ ਪ੍ਰਾਈਸ (ਆਈਟਮ _ ਪ੍ਰਾਈਸ) \\n ਆਈਟਮ _ ਇੰਡੈਕਸ + = 1 \\n\\n #UI \\nfunc _ ꯔꯦਡੀ () ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ItemListNode ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ \\n ver item _ list _ node = ItemListNode.new () \\n\\n #ਆਈਟਮ ਲਿਸਟ ਨੋਡ ਨੂੰ ਸੀਨ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ \\nਐਡ _ ਚਾਈਲਡ (ਆਈਟਮ _ ਲਿਸਟ _ ਨੋਡ) \\n\\n #ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡੇਟਾ ਨੂੰ ਲੋਡ ਕਰੋ \\nvar json _ ਡੇਟਾ = ਓਪਨ ("item_list.json"). ਰੀਡ () \\nvar item _ ਲਿਸਟ = json.loads (json _ ਡੇਟਾ) \\n\\n #ਕਾਲ ਕਰੋUI ਨੂੰ ਬਣਾਉਣ ਲਈ ਤਿਆਰ () ਫੰਕਸ਼ਨ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਨੋਡ ਲਈ ਇੱਕ ਕਲਾਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਜੋ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗਾ।ਕਲਾਸ ਦਾ \'_ _ init _ _\' ਢੰਗ, ਅਸੀਂ ਇੱਕ \'ਨੋਡਲਿਸਟਬਾਕਸ\' ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਸ ਨੂੰ ਨੋਡ ਦੇ ਚਾਈਲਡ ਦੇ ਰੂਪ ਵਿੱਚ ਜੋਡ਼ਦੇ ਹਾਂ। ਫਿਰ ਅਸੀਂ ਇੱਕ ਫਾਈਲ ਤੋਂ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾ ਲੋਡ ਕਰਦੇ ਹਾਂ ਜਿਸ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ"ਆਈਟਮ\\\\ _list.json" \'ਓਪਨ\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਅਤੇ ਇਸ ਨੂੰ \'json.loads\' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪਾਰਸ ਕਰੋ।\'ਨੋਡ\', \'ਕ੍ਰਿਪਾ ਕਰਕੇ ਜਾਰੀ ਰੱਖੋ।\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਕੋਡ ਦੀ ਨਿਰੰਤਰਤਾ ਹੈਃ \\n\' \'ਆਈਟਮ _ ਲਿਸਟ ਵਿੱਚ ਆਈਟਮ ਲਈ ਪਾਈਥਨ\\n: \\nਵਰ ਆਈਟਮ _ ਟੈਕਸਟ =String.new (ਆਈਟਮ ["ਟੈਕਸਟ _ ਵਰਣਨ"]) \\n ਵਰ ਆਈਟਮ _ ਕੀਮਤ = Float.new (ਆਈਟਮ ["ਕੀਮਤ"]) \\n ਵਰ ਆਈਟਮ _ ਚਿੱਤਰ = String.new (ਆਈਟਮ ["ਚਿੱਤਰ _ ਸਰੋਤ _ ਨਾਮ"]) \\nitem_list_node.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਟੈਕਸਟ = ਆਈਟਮ _ ਟੈਕਸਟ\\n item_list_node.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਆਈਕਾਨ = ਆਈਟਮ _ ਚਿੱਤਰ\\nitem_list_node.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਸੈਟ _ ਪ੍ਰਾਈਸ (ਆਈਟਮ _ ਪ੍ਰਾਈਸ) \\n ਆਈਟਮ _ ਇੰਡੈਕਸ + = 1\\n\\n #UI \\nfunc _ ꯔꯦਡੀ () ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ItemListNode ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ \\n ver item _ list _ node = ItemListNode.new () \\n\\n #ਆਈਟਮ ਲਿਸਟ ਨੋਡ ਨੂੰ ਸੀਨ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ \\nਐਡ _ ਚਾਈਲਡ (ਆਈਟਮ _ ਲਿਸਟ _ ਨੋਡ) \\n\\n #ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡੇਟਾ ਨੂੰ ਲੋਡ ਕਰੋ \\nvar json _ ਡੇਟਾ = ਓਪਨ ("item_list.json"). ਰੀਡ () \\nvar item _ ਲਿਸਟ = json.loads (json _ ਡੇਟਾ) \\n\\n #ਕਾਲ ਕਰੋUI ਨੂੰ ਬਣਾਉਣ ਲਈ ਤਿਆਰ () ਫੰਕਸ਼ਨ ਇਸ ਕੋਡ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਇੱਕ ਫੰਕਸ਼ਨ \'_ ਤਿਆਰ ()\' ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਜੋ ਸੀਨ ਲੋਡ ਹੋਣ \'ਤੇ ਕਾਲ ਕੀਤਾ ਜਾਵੇਗਾ।\'ਤਿਆਰ ()\' ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ, ਅਸੀਂ \'ItemListNode\' ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਸ ਨੂੰ ਸੀਨ ਵਿੱਚ ਜੋਡ਼ਦੇ ਹਾਂ।"ਆਈਟਮ\\\\ _list.json" ਅਤੇ ਇਸ ਨੂੰ \'json.loads\' ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਾਰਸ ਕਰੋ। ਨਤੀਜੇ ਵਜੋਂ \'ਆਈਟਮ _ ਲਿਸਟ\' ਵੇਰੀਏਬਲ ਸ਼ਬਦਕੋਸ਼ਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਹੈ, ਜਿੱਥੇ ਹਰੇਕ ਸ਼ਬਦਕੋਸ਼ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਸੂਚੀ ਵਿੱਚ ਆਈਟਮ। \\n\\n ਅੰਤ ਵਿੱਚ, ਅਸੀਂ \'ਆਈਟਮ _ ਲਿਸਟ\' ਵੇਰੀਏਬਲ ਵਿੱਚ ਆਈਟਮਾਂ ਨੂੰ ਲੂਪ ਕਰਦੇ ਹਾਂ ਅਤੇ \'ਆਈਟਮ-ਲਿਸਟਨੋਡ\' ਉਦਾਹਰਣ ਦੇ \'ਨੋਡ-ਲਿਸਟਬਾਕਸ\' ਨੂੰ ਇਸ ਨਾਲ ਆਬਾਦ ਕਰਦੇ ਹਾਂ।ਆਈਟਮਾਂ। ਇਸ ਤਰ੍ਹਾਂ, \'ਨੋਡਲਿਸਟਬਾਕਸ\' ਆਈਟਮਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਉਹਨਾਂ ਦੇ ਸਬੰਧਤ ਟੈਕਸਟ ਵਰਣਨ, ਕੀਮਤਾਂ ਅਤੇ ਚਿੱਤਰ ਸਰੋਤਾਂ ਨਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗਾ। \',\' ਮੰਨ ਲਓ।ਹਰੇਕ ਆਈਟਮ ਵਿੱਚ ਇੱਕ ਓ. ਬੀ. ਜੇ. ਫਾਈਲ ਦਾ ਸਰੋਤ ਨਾਮ ਵੀ ਹੁੰਦਾ ਹੈ। ਮੈਨੂੰ ਕੋਡ ਦਿਖਾਓ ਤਾਂ ਜੋ ਉਪਭੋਗਤਾ ਯੂ. ਆਈ. ਵਿੱਚ ਆਈਟਮ ਨੂੰ ਮੌਜੂਦਾ 3ਡੀ ਦ੍ਰਿਸ਼ ਉੱਤੇ ਖਿੱਚ ਅਤੇ ਸੁੱਟ ਸਕੇ।ਆਈਟਮ ਨੂੰ ਤੁਰੰਤ ਕਰਨ ਲਈ. \'] ', 'ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਇੱਕ ਯੂ. ਆਈ. ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰਨ ਲਈ ਮੈਨੂੰ ਗੋਡੋਟ ਵਿੱਚ ਕੋਡ ਦਿਖਾਓ। ਹਰੇਕ ਆਈਟਮ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਵੇਰਵਾ, ਇੱਕ ਕੀਮਤ,ਅਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਚਿੱਤਰ ਲਈ ਇੱਕ ਸਰੋਤ ਨਾਮ।', ' [\'ਮੈਨੂੰ ਇੱਕ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਇੱਕ ਯੂ. ਆਈ. ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰਨ ਲਈ ਗੋਡੋਟ ਵਿੱਚ ਕੋਡ ਦਿਖਾਓ। ਹਰੇਕ ਆਈਟਮ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਵੇਰਵਾ ਹੁੰਦਾ ਹੈ, ਇੱਕਕੀਮਤ, ਅਤੇ ਇੱਕ ਚਿੱਤਰ ਲਈ ਇੱਕ ਸਰੋਤ ਨਾਮ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਣਾ ਹੈ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਗੋਡੋਟ ਵਿੱਚ ਇੱਕ ਉਦਾਹਰਣ ਕੋਡ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ UI ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਕਿਵੇਂ ਤਿਆਰ ਕਰਨਾ ਹੈ।ਇੱਕ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲਃ \\n "\'ਪਾਈਥਨ \\n #ਨੋਡ ਲਈ ਇੱਕ ਕਲਾਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗੀ \\n ਕਲਾਸItemListNode (Node): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ): \\n Node.__init__ (ਸੈਲਫ) \\n self.list_box = NodeListBox.new () \\n self.add_child (self.list_box) \\n\\n #ਲੋਡ ਕਰੋਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾ \\n ਵਾਰ ਜੇਸਨ _ ਡਾਟਾ = ਓਪਨ ("item_list.json"). ਰੀਡ () \\n ਵਾਰ ਆਈਟਮ _ ਲਿਸਟ = json.loads (ਜੇਸਨ _ ਡੇਟਾ) \\n\\n #ਸੂਚੀ ਬਾਕਸ ਨੂੰ ਇਹਨਾਂ ਵਿੱਚੋਂ ਆਈਟਮਾਂ ਨਾਲ ਤਿਆਰ ਕਰੋ।ਆਈਟਮ _ ਲਿਸਟ ਵਿੱਚ ਆਈਟਮ ਲਈ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾਃ \\n ਵਰ ਆਈਟਮ _ ਟੈਕਸਟ = String.new (ਆਈਟਮ ["ਟੈਕਸਟ _ ਵਰਣਨ"]) \\n ਵਰ ਆਈਟਮ _ ਪ੍ਰਾਈਸ = Float.new (ਆਈਟਮ ["ਕੀਮਤ"]) \\n ਵਰ ਆਈਟਮ _ ਚਿੱਤਰ= String.new (ਆਈਟਮ ["ਚਿੱਤਰ _ ਸਰੋਤ _ ਨਾਮ"]) \\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਟੈਕਸਟ = ਆਈਟਮ _ ਟੈਕਸਟ\\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਆਈਕਾਨ =ਆਈਟਮ _ ਚਿੱਤਰ \\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਸੈੱਟ _ ਪ੍ਰਾਈਸ (ਆਈਟਮ _ ਪ੍ਰਾਈਸ) \\n ਆਈਟਮ _ ਇੰਡੈਕਸ + = 1 \\n\\n #UI \\nfunc _ ꯔꯦਡੀ () ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ItemListNode ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਓ \\n ver item _ list _ node = ItemListNode.new () \\n\\n #ਆਈਟਮ ਲਿਸਟ ਨੋਡ ਨੂੰ ਸੀਨ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ \\nਐਡ _ ਚਾਈਲਡ (ਆਈਟਮ _ ਲਿਸਟ _ ਨੋਡ) \\n\\n #ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡੇਟਾ ਨੂੰ ਲੋਡ ਕਰੋ \\nvar json _ ਡੇਟਾ = ਓਪਨ ("item_list.json"). ਰੀਡ () \\nvar item _ ਲਿਸਟ = json.loads (json _ ਡੇਟਾ) \\n\\n #ਕਾਲ ਕਰੋUI ਨੂੰ ਬਣਾਉਣ ਲਈ ਤਿਆਰ () ਫੰਕਸ਼ਨ ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਨੋਡ ਲਈ ਇੱਕ ਕਲਾਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਜੋ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗਾ।ਕਲਾਸ ਦਾ \'_ _ init _ _\' ਢੰਗ, ਅਸੀਂ ਇੱਕ \'ਨੋਡਲਿਸਟਬਾਕਸ\' ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਸ ਨੂੰ ਨੋਡ ਦੇ ਚਾਈਲਡ ਦੇ ਰੂਪ ਵਿੱਚ ਜੋਡ਼ਦੇ ਹਾਂ। ਫਿਰ ਅਸੀਂ ਇੱਕ ਫਾਈਲ ਤੋਂ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾ ਲੋਡ ਕਰਦੇ ਹਾਂ ਜਿਸ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ"ਆਈਟਮ\\\\ _list.json" \'ਓਪਨ\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਅਤੇ ਇਸ ਨੂੰ \'json.loads\' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪਾਰਸ ਕਰੋ।\'ਨੋਡ\', \'ਕ੍ਰਿਪਾ ਕਰਕੇ ਜਾਰੀ ਰੱਖੋ।\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਕੋਡ ਦੀ ਨਿਰੰਤਰਤਾ ਹੈਃ \\n\' \'ਆਈਟਮ _ ਲਿਸਟ ਵਿੱਚ ਆਈਟਮ ਲਈ ਪਾਈਥਨ\\n: \\nਵਰ ਆਈਟਮ _ ਟੈਕਸਟ =String.new (ਆਈਟਮ ["ਟੈਕਸਟ _ ਵਰਣਨ"]) \\n ਵਰ ਆਈਟਮ _ ਕੀਮਤ = Float.new (ਆਈਟਮ ["ਕੀਮਤ"]) \\n ਵਰ ਆਈਟਮ _ ਚਿੱਤਰ = String.new (ਆਈਟਮ ["ਚਿੱਤਰ _ ਸਰੋਤ _ ਨਾਮ"]) \\nitem_list_node.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਟੈਕਸਟ = ਆਈਟਮ _ ਟੈਕਸਟ\\n item_list_node.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਆਈਕਾਨ = ਆਈਟਮ _ ਚਿੱਤਰ\\nitem_list_node.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਸੈਟ _ ਪ੍ਰਾਈਸ (ਆਈਟਮ _ ਪ੍ਰਾਈਸ) \\n ਆਈਟਮ _ ਇੰਡੈਕਸ + = 1\\n\\n #UI \\nfunc _ ꯔꯦਡੀ () ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।ItemListNode ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ \\n ver item _ list _ node = ItemListNode.new () \\n\\n #ਆਈਟਮ ਲਿਸਟ ਨੋਡ ਨੂੰ ਸੀਨ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ \\nਐਡ _ ਚਾਈਲਡ (ਆਈਟਮ _ ਲਿਸਟ _ ਨੋਡ) \\n\\n #ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡੇਟਾ ਨੂੰ ਲੋਡ ਕਰੋ \\nvar json _ ਡੇਟਾ = ਓਪਨ ("item_list.json"). ਰੀਡ () \\nvar item _ ਲਿਸਟ = json.loads (json _ ਡੇਟਾ) \\n\\n #ਕਾਲ ਕਰੋUI ਨੂੰ ਬਣਾਉਣ ਲਈ ਤਿਆਰ () ਫੰਕਸ਼ਨ ਇਸ ਕੋਡ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਇੱਕ ਫੰਕਸ਼ਨ \'_ ਤਿਆਰ ()\' ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਜੋ ਸੀਨ ਲੋਡ ਹੋਣ \'ਤੇ ਕਾਲ ਕੀਤਾ ਜਾਵੇਗਾ।\'ਤਿਆਰ ()\' ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ, ਅਸੀਂ \'ItemListNode\' ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਸ ਨੂੰ ਸੀਨ ਵਿੱਚ ਜੋਡ਼ਦੇ ਹਾਂ।"ਆਈਟਮ\\\\ _list.json" ਅਤੇ ਇਸ ਨੂੰ \'json.loads\' ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਾਰਸ ਕਰੋ। ਨਤੀਜੇ ਵਜੋਂ \'ਆਈਟਮ _ ਲਿਸਟ\' ਵੇਰੀਏਬਲ ਸ਼ਬਦਕੋਸ਼ਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਹੈ, ਜਿੱਥੇ ਹਰੇਕ ਸ਼ਬਦਕੋਸ਼ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।ਸੂਚੀ ਵਿੱਚ ਆਈਟਮ। \\n\\n ਅੰਤ ਵਿੱਚ, ਅਸੀਂ \'ਆਈਟਮ _ ਲਿਸਟ\' ਵੇਰੀਏਬਲ ਵਿੱਚ ਆਈਟਮਾਂ ਨੂੰ ਲੂਪ ਕਰਦੇ ਹਾਂ ਅਤੇ \'ਆਈਟਮ-ਲਿਸਟਨੋਡ\' ਉਦਾਹਰਣ ਦੇ \'ਨੋਡ-ਲਿਸਟਬਾਕਸ\' ਨੂੰ ਇਸ ਨਾਲ ਆਬਾਦ ਕਰਦੇ ਹਾਂ।ਆਈਟਮਾਂ। ਇਸ ਤਰ੍ਹਾਂ, \'ਨੋਡਲਿਸਟਬਾਕਸ\' ਆਈਟਮਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਉਹਨਾਂ ਦੇ ਸਬੰਧਤ ਟੈਕਸਟ ਵਰਣਨ, ਕੀਮਤਾਂ ਅਤੇ ਚਿੱਤਰ ਸਰੋਤਾਂ ਨਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗਾ। \',\' ਮੰਨ ਲਓ।ਹਰੇਕ ਆਈਟਮ ਵਿੱਚ ਇੱਕ ਓ. ਬੀ. ਜੇ. ਫਾਈਲ ਦਾ ਸਰੋਤ ਨਾਮ ਵੀ ਹੁੰਦਾ ਹੈ। ਮੈਨੂੰ ਕੋਡ ਦਿਖਾਓ ਤਾਂ ਜੋ ਉਪਭੋਗਤਾ ਯੂ. ਆਈ. ਵਿੱਚ ਆਈਟਮ ਨੂੰ ਮੌਜੂਦਾ 3ਡੀ ਦ੍ਰਿਸ਼ ਉੱਤੇ ਖਿੱਚ ਅਤੇ ਸੁੱਟ ਸਕੇ।\',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਕੋਡ ਦਾ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤਾ ਸੰਸਕਰਣ ਹੈ ਜੋ ਉਪਭੋਗਤਾ ਨੂੰ ਯੂ. ਆਈ. ਤੋਂ ਕਿਸੇ ਵਸਤੂ ਨੂੰ ਮੌਜੂਦਾ ਉੱਤੇ ਖਿੱਚਣ ਅਤੇ ਸੁੱਟਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਆਬਜੈਕਟ ਨੂੰ ਤੁਰੰਤ ਸਿੱਧ ਕਰਨ ਲਈ 3D ਦ੍ਰਿਸ਼ਃ \\n "\'ਪਾਈਥਨ \\n #ਨੋਡ ਲਈ ਇੱਕ ਕਲਾਸ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗੀ \\n ਕਲਾਸ ਆਈਟਮ ਲਿਸਟ ਨੋਡ (ਨੋਡ): \\n ਡਿਫ_ _ init _ _ (ਸੈਲਫ): \\n Node.__init__ (ਸੈਲਫ) \\n self.list_box = NodeListBox.new () \\n self.add_child (self.list_box) \\n\\n #ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾ ਨੂੰ ਲੋਡ ਕਰੋ \\n ਵਰ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡਾਟਾ =ਖੁੱਲੋ ("item_list.json"). ਪਡ਼੍ਹੋ () \\nਵਰ ਆਈਟਮ _ ਲਿਸਟ = json.loads (jsson _ ਡਾਟਾ) \\n\\n #ਸੂਚੀ ਬਾਕਸ ਨੂੰ ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਡੇਟਾ ਤੋਂ ਆਈਟਮਾਂ ਨਾਲ ਤਿਆਰ ਕਰੋ।ਆਈਟਮ _ ਸੂਚੀਃ \\n ਵਰ ਆਈਟਮ _ ਟੈਕਸਟ = String.new (ਆਈਟਮ ["ਟੈਕਸਟ _ ਵਰਣਨ"]) \\n ਵਰ ਆਈਟਮ _ ਕੀਮਤ = Float.new (ਆਈਟਮ ["ਕੀਮਤ"]) \\n ਵਰ ਆਈਟਮ _ ਚਿੱਤਰ =String.new (ਆਈਟਮ ["ਚਿੱਤਰ _ ਸਰੋਤ _ ਨਾਮ"]) \\n ਵਰ ਆਈਟਮ _ ਓਬਜ = String.new (ਆਈਟਮ ["ਆਬਜੈਕਟ _ ਸਰੋਤ _ ਨਾਮ"]) \\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਟੈਕਸਟ =ਆਈਟਮ _ ਟੈਕਸਟ \\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਆਈਕਾਨ = ਆਈਟਮ _ ਚਿੱਤਰ \\n self.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਸੈੱਟ _ ਕੀਮਤ (ਆਈਟਮ _ ਕੀਮਤ) \\nself.list_box.get_item (ਆਈਟਮ _ ਇੰਡੈਕਸ). ਸੈਟ _ ਡਰੈਗ _ ਡੇਟਾ (ਆਈਟਮ _ ਓ. ਬੀ. ਜੇ.) \\n ਆਈਟਮ _ ਇੰਡੈਕਸ + = 1\\n\\n #ਡਰੈਗ ਅਤੇ ਡਰਾਪ ਫੰਕਸ਼ਨ ਨੂੰ ਲਿਸਟ ਬਾਕਸ ਆਈਟਮਾਂ ਨਾਲ ਜੋਡ਼ੋ \\nself.list_box.connect ("ਡਰੈਗ _ ਡਾਟਾ _ ਰਿਸੀਵਡ", self.handle_drag_drop) \\n\\n ਡਿਫ ਹੈਂਡਲ _ ਡਰੈਗ _ ਡਰਾਪ (ਸੈਲਫ, ਨੋਡ, ਡਾਟਾ): \\n ਵਰ ਓਬਜ _ ਨੇਮ =ਡਾਟਾ ["ਆਬਜੈਕਟ _ ਸਰੋਤ _ ਨਾਮ"] \\n #ਸਰੋਤ ਨਾਮ ਤੋਂ ਆਬਜੈਕਟ ਨੂੰ ਲੋਡ ਕਰੋ \\n ਵਰ ਓ. ਬੀ. ਜੇ. = Node.load (ਓ. ਬੀ. ਜੇ. _ ਨਾਮ) \\n\\n #3ਡੀ ਦ੍ਰਿਸ਼ ਵਿੱਚ ਆਬਜੈਕਟ ਨੂੰ ਤੁਰੰਤ ਕਰੋ \\nਵਾਰ ਦ੍ਰਿਸ਼ = Node.find_scene () \\nਵਰ ਪੇਰੈਂਟ _ ਨੋਡ = scene.get_root () \\n parent_node.add_child (obj) \\n\\n #ਵਸਤੂ ਦੀ ਸਥਿਤੀ ਅਤੇ ਰੋਟੇਸ਼ਨ ਨੂੰ ਸੈੱਟ ਕਰੋ \\nobj.set_position (Vector3.new (0, \',\' ਕ੍ਰਿਪਾ ਕਰਕੇ ਜਾਰੀ ਰੱਖੋ। \') ', 'ਜੇ. ਐੱਸ. ਓ. ਐੱਨ. ਸਰੋਤ ਤੋਂ ਲੋਡ ਕੀਤੀਆਂ ਆਈਟਮਾਂ ਦੀ ਸੂਚੀ ਦੇ ਨਾਲ ਇੱਕ ਯੂ. ਆਈ. ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕਰਨ ਲਈ ਮੈਨੂੰ ਗੋਡੋਟ ਵਿੱਚ ਕੋਡ ਦਿਖਾਓ। ਹਰੇਕ ਆਈਟਮ ਵਿੱਚ ਇੱਕ ਟੈਕਸਟ ਵੇਰਵਾ, ਇੱਕ ਕੀਮਤ,ਅਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਚਿੱਤਰ ਲਈ ਇੱਕ ਸਰੋਤ ਨਾਮ। \n ']