[PYTHON 2.7] Selezione tupla verticalmente

[TommyB1992]

Immaginando che io voglia selezionare il primo valore di ogni tupla per fare una comparazione senza ciclare la tupla:

Codice: Seleziona tutto

"""
t =
(
  (
    (195, 195, 195), (195, 195, 195), (34, 177, 76)
  ), 

  (
    (255, 255, 255), (63, 72, 204), (34, 177, 76)
  ),

  (
    (0, 0, 0), (255, 255, 255), (34, 177, 76)
  )
)

c = (195, 255, 000)
"""

if c == t[:3][0][0]: # <--- implementazione sicuramente errata
  pass

Attualmente risolvo ciclando ma se potessi fare una comparazione sicuramente ottimizzerei, grazie
p.s. ovviamente è un esempio, spesso ho tuple di lunghezze che non conosco che infatti ciclo grazie a len(...), quindi non credo che concatenare la tupla sia la soluzione



/////////////////////////////////////////////////////////////////////////

Codice: Seleziona tutto

    def main(self):
        os.chdir(self.__scanDir)

        while True:
            files = filter(os.path.isfile, os.listdir(self.__scanDir))
            files = [os.path.join(self.__scanDir, f) for f in files]
            files.sort()
            
            for file in files:
                try:
                    im  = Image.open(file)
                    self.__px = im.load()
                    self.__width, self.__height = im.size[:2]
                    
                    self.__convertPixels()
                    
    # [...]
    
    def __convertPixels(self):
        self.__pixels = tuple(
            tuple(
                tuple(self.__px[i,ii][:3]) for ii in xrange(self.__height)
            ) for i in xrange(self.__width)
        )
    ## End def __convertPixels
    
    def __readTableInfo(self, left, top, right, bottom, toFind):
        info = self._simplePixelMatch(
            left = left, top = top, right = right, bottom = bottom, toFind = toFind
        )
        if isinstance(info, list) and toFind == info:
            return "".join(str(l) for l in info)
    ## End def __readTableInfo
    
    def _simplePixelMatch(self, **kwargs):
        readed = []
        for i in xrange(kwargs["left"], kwargs["right"]):
            for ii in xrange(kwargs["top"], kwargs["bottom"]):
                for k, char in enumerate(Table.chars):
                    # Check if is outer of range of pixels
                    if (ii + len(char)) > kwargs["bottom"]:
                        continue
                
                    c = 0
                    for pixels in char:
                        if pixels != self.__pixels[i][ii + c]:
                            break

                        c += 1
                        if c == len(char):
                            readed.append(k)

                            if len(readed) == kwargs["toFind"]:
                                return readed
    ## End def _hardPixelMatch

main: ciclo i file che ho in una directory (che sono solo .png), converto il formato di PIL (PixelAccess) in Tuple con __convertPixels.

Con _simplePixelMatch ciclo i pixel in verticale confrontandola con delle mie tuple che contengono i medesimi pixel, esempio:

Immagine:
+-------+--------------+
| 0,0,0 | 255,255,255 |
| 255,0,0| 0,255,0 |
+-------+--------------+

Mia Tupla:
(0,0,0,),(255,0,0)

Se trova le tuple in "orizzontale" termina il ciclo e restituisce quello che deve restituire.
Ora il punto è: posso evitare il ciclo? Ma appunto fare in qualche modo una comparazione?

[crap0101]

ora non ne sono sicurissimo, però controlla che PIL non abbia già qualche funzione che fa un lavoro del genere... in alternativa, se devi fare operazioni del genere su matrix e simili, con numpy è sicuramente più comodo.

[TommyB1992]

ora non ne sono sicurissimo, però controlla che PIL non abbia già qualche funzione che fa un lavoro del genere... in alternativa, se devi fare operazioni del genere su matrix e simili, con numpy è sicuramente più comodo.

vero, ma numpy è troppo lento (più veloce delle array base ma le tuple mi hanno dato un incremento prestazionale del 50%, infatti inizialmente prevedeva il suo utilizzo)
Perciò mi interessa questa soluzione su tuple