सूची और वापस करने के लिए tuple कन्वर्ट

Question

मैं वर्तमान में pygame में एक गेम के लिए एक मैप एडिटर पर काम कर रहा हूं, टाइल मैप्स का उपयोग कर रहा हूं। स्तर निम्न संरचना में ब्लॉकों से बना है (हालांकि बहुत बड़ा):

level1 = (
         (1,1,1,1,1,1)
         (1,0,0,0,0,1)
         (1,0,0,0,0,1)
         (1,0,0,0,0,1)
         (1,0,0,0,0,1)
         (1,1,1,1,1,1))

जहाँ "1" एक ब्लॉक है जो एक दीवार है और "0" एक ब्लॉक है जो खाली हवा है।

निम्नलिखित कोड मूल रूप से ब्लॉक प्रकार के परिवर्तन को संभालने वाला है:

clicked = pygame.mouse.get_pressed()
if clicked[0] == 1:
    currLevel[((mousey+cameraY)/60)][((mousex+cameraX)/60)] = 1

लेकिन चूंकि स्तर एक टुपल में संग्रहीत है, इसलिए मैं विभिन्न ब्लॉकों के मूल्यों को बदलने में असमर्थ हूं। मैं एक आसान तरीके से स्तर में विभिन्न मूल्यों को बदलने के बारे में कैसे जाना है?

Comments

टपल का उपयोग न करें, बस शुरुआत से ही एक सूची का उपयोग करें। यदि आपका स्तर बहुत बड़ा है, तो यह वास्तव में आपके कोड को धीमा कर सकता है, यदि आपको उन्हें परिवर्तित करते रहना है

— जमैलाक

कैसे शुरू से ही tuples के बजाय सूचियों के साथ जाने के बारे में?

— Krzysztof Bujniewicz

@ user2133308 केवल एक संगतता नोट btw, आपको पूर्णांक विभाजन का उपयोग //सिर्फ /इसलिए करना चाहिए क्योंकि पायथन 3 में, /फ्लोटिंग पॉइंट डिवीजन का प्रदर्शन करेगा और अपने कोड को स्क्रू करेगा।

— जामिलाक

Answer 1

सूची में tuple परिवर्तित करें:

>>> t = ('my', 'name', 'is', 'mr', 'tuple')
>>> t
('my', 'name', 'is', 'mr', 'tuple')
>>> list(t)
['my', 'name', 'is', 'mr', 'tuple']

सूची को tuple में बदलें:

>>> l = ['my', 'name', 'is', 'mr', 'list']
>>> l
['my', 'name', 'is', 'mr', 'list']
>>> tuple(l)
('my', 'name', 'is', 'mr', 'list')

Comments

यह मेरे लिए काम नहीं कर रहा है। यदि मैं t to list () में पास करके tuple t को एक सूची में बदलने के लिए पहले ब्लॉक में कोड चलाता हूं, तो मुझे एक त्रुटि संदेश मिलता है: "*** तर्क में त्रुटि: '(t)'" यह प्रतीत होता है मुझे केवल डिबगिंग करते समय। अभी भी उलझन में।

— जिमी

@ जिमी इसलिए कि सूची एक डिबगर कमांड है, p list(...)इसके बजाय चलाएँ ।

— मोरिट्ज़

Answer 2

आपके पास टुपल्स का एक समूह है।
प्रत्येक टपल को सूची में बदलने के लिए:

[list(i) for i in level] # list of lists

--- *

map(list, level)

---

और आपके द्वारा संपादन किए जाने के बाद, बस उन्हें वापस रूपांतरित करें:

tuple(tuple(i) for i in edited) # tuple of tuples

--- या * (साभार @jamylak)

tuple(itertools.imap(tuple, edited))

---

तुम भी एक संख्यात्मक सरणी का उपयोग कर सकते हैं:

>>> a = numpy.array(level1)
>>> a
array([[1, 1, 1, 1, 1, 1],
       [1, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 1],
       [1, 1, 1, 1, 1, 1]])

जोड़ तोड़ के लिए:

if clicked[0] == 1:
    x = (mousey + cameraY) // 60 # For readability
    y = (mousex + cameraX) // 60 # For readability
    a[x][y] = 1

Comments

NumPy पायथन के साथ वैज्ञानिक कंप्यूटिंग के लिए मौलिक पैकेज है। NumPy की मुख्य वस्तु सजातीय बहुआयामी सरणी है। यह तत्वों की एक तालिका है (आमतौर पर संख्याएं), एक ही प्रकार के सभी, सकारात्मक पूर्णांकों के एक गुच्छे द्वारा अनुक्रमित।

— प्रद्दुन्सग

Answer 3

आपके पास सूचियों की एक सूची हो सकती है। अपने tuple के tuple को सूचियों की सूची में बदलें।

level1 = [list(row) for row in level1]

या

level1 = map(list, level1)

और तदनुसार उन्हें संशोधित करें।

लेकिन एक सुन्न सरणी कूलर है।

Answer 4

ट्यूपल्स को सूची में बदलने के लिए

(दिए गए प्रश्न में टुपल्स के बीच कमांड गायब थे, यह त्रुटि संदेश को रोकने के लिए जोड़ा गया था)

विधि 1:

level1 = (
     (1,1,1,1,1,1),
     (1,0,0,0,0,1),
     (1,0,0,0,0,1),
     (1,0,0,0,0,1),
     (1,0,0,0,0,1),
     (1,1,1,1,1,1))

level1 = [list(row) for row in level1]

print(level1)

विधि 2:

level1 = map(list,level1)

print(list(level1))

विधि 1 ने --- 0.0019991397857666016 सेकंड --- लिया

विधि 2 ने --- 0.0010001659393310547 सेकंड लिया ---

Answer 5

आप इसके प्रकार को टपल से सूची में परिवर्तित करने का प्रयास क्यों नहीं करते हैं और इसके विपरीत।

level1 = (
     (1,1,1,1,1,1)
     (1,0,0,0,0,1)
     (1,0,0,0,0,1)
     (1,0,0,0,0,1)
     (1,0,0,0,0,1)
     (1,1,1,1,1,1))

print(level1)

level1 = list(level1)

print(level1)

level1 = tuple(level1)

print(level1)

Answer 6

दोनों उत्तर अच्छे हैं, लेकिन थोड़ी सलाह:

टुपल्स अपरिवर्तनीय हैं, जिसका अर्थ है कि उन्हें बदला नहीं जा सकता है। इसलिए यदि आपको डेटा में हेरफेर करने की आवश्यकता है, तो डेटा को किसी सूची में संग्रहीत करना बेहतर है, यह अनावश्यक ओवरहेड को कम करेगा।

अपने मामले में डेटा को एक सूची में निकालें, जैसा कि यूमिरो द्वारा दिखाया गया है, और संशोधित करने के बाद स्कूलबॉय द्वारा दिए गए उत्तर के समान संरचना का एक समान टपल बनाएं।

जैसा कि सुन्न सरणी का उपयोग करने का सुझाव दिया गया है, एक बेहतर विकल्प है

Comments

आपको इस उत्तर में भी लिखना चाहिए, जो numpyइस प्रकार के डेटा के साथ काम करने का सबसे तेज़ समाधान प्रदान करेगा।

— जामिलक

बेशक जब आप डेटा में हेरफेर कर रहे हों तब भी आप ट्यूप जैसे अपरिवर्तनीय डेटा संरचनाओं का उपयोग कर सकते हैं। कार्यात्मक प्रोग्रामिंग का पूरा आधार और वह सब जो डेटा की दृढ़ता पर निर्भर करता है। लेकिन निश्चित रूप से, पायथन भूमि में आप जनता के साथ जाना चाहते हैं और स्वतंत्र रूप से उत्परिवर्तित कर सकते हैं ...

— nperson325681

Answer 7

टपल और बैक की सूची नीचे दी गई है

import ast, sys
input_str = sys.stdin.read()
input_tuple = ast.literal_eval(input_str)

l = list(input_tuple)
l.append('Python')
#print(l)
tuple_2 = tuple(l)

# Make sure to name the final tuple 'tuple_2'
print(tuple_2)

Answer 8

यदि आप सूचियों की सूची के बजाय सिर्फ एक सूची का उपयोग करते हैं, तो आप नाटकीय रूप से अपने सामान को गति दे सकते हैं। यह केवल तभी संभव है जब आपकी सभी आंतरिक सूचियाँ एक ही आकार की हों (जो आपके उदाहरण में सत्य हो, इसलिए मैं यह मानती हूँ)।

WIDTH = 6
level1 = [ 1,1,1,1,1,1,
           1,0,0,0,0,1,
           1,0,0,0,0,1,
           1,0,0,0,0,1,
           1,0,0,0,0,1,
           1,1,1,1,1,1 ]
print level1[x + y*WIDTH]  # print value at (x,y)

और आप और भी तेज़ हो सकते हैं अगर आपने सूची के बजाय बिटफ़ील्ड का उपयोग किया:

WIDTH = 8  # better align your width to bytes, eases things later
level1 = 0xFC84848484FC  # bit field representation of the level
print "1" if level1 & mask(x, y) else "0"  # print bit at (x, y)
level1 |= mask(x, y)  # set bit at (x, y)
level1 &= ~mask(x, y)  # clear bit at (x, y)

साथ में

def mask(x, y):
  return 1 << (WIDTH-x + y*WIDTH)

लेकिन यह तभी काम कर रहा है जब आपके खेतों में सिर्फ 0 या 1 ही हो। यदि आपको अधिक मानों की आवश्यकता है, तो आपको कई बिट्स को संयोजित करना होगा जो समस्या को और अधिक जटिल बना देगा।