Das deutsche Python-Forum

Code: Alles auswählen

min([(i,x) for (i,x) in enumerate(l) if x>0], key=operator.itemgetter(1))

Code: Alles auswählen

>>> alt = [0.0, 0.0, 80.0, 120.0, -40.0, 0.0]
>>> neu = sorted(list(set(alt)))
>>> mini = neu[0] if abs(neu[0])>0.001 else neu[1]
>>> print mini
-40.0

Code: Alles auswählen

# Bestimmung der Nachbarfelder

# 0  4  8  12  16
# 1  5  9  13  17
# 2  6  10 14  18
# 3  7  11 15  19

spaltenzahl = 5
zeilenzahl = 4
position = 10   # Nummer im Feld

spalten = range(spaltenzahl)
zeilen = range(zeilenzahl)
spalte = position // zeilenzahl
zeile = position % zeilenzahl
k = spalte & 1 # unterschiedlicher Versatz bei gerader/ungerader Spalte

n = position-1 if zeile-1 in zeilen else None
s = position+1 if zeile+1 in zeilen else None
if spalte+1 in spalten:
    no = (spalte+1)*zeilenzahl+zeile+k-1 if zeile+k-1 in zeilen else None
    so = (spalte+1)*zeilenzahl+zeile+k if zeile+k in zeilen else None
else:
    no, so = None, None
if spalte-1 in spalten:
    sw = (spalte-1)*zeilenzahl+zeile+k if zeile+k in zeilen else None
    nw = (spalte-1)*zeilenzahl+zeile+k-1 if zeile+k-1 in zeilen else None
else:
    sw, nw = None, None

nachbarn = [n,no,so,s,sw,nw]
print nachbarn

Code: Alles auswählen

0,0      0,2      0,4      0,6 ...
     0,1      0,3      0,5 ...
1,0      1,2      1,4     1,6 ...
     1,1      1,3     1,5 ...
2,0      2,2      2,4     2,6 ...
.
.
.
.

Code: Alles auswählen

sqrt((mfnx-mfax)**2+(mfny-mfay)**2)

Code: Alles auswählen

"%.2f" % 1.234567

Code: Alles auswählen

# -*- coding: utf-8 -*-
""" Modul zur Berechnung von Hexfeldobjekten"""

from math import sqrt

hexdic = {} # Dictionary (x,y) : x1,y1 ... x6,y6
nachbardic = {} # Dictionary Nachbarfelder

laenge = 20.0
spielreihen = 42
ungerade_spalten = 17
gerade_spalten = ungerade_spalten - 1


""" Funktion zur Berechnung der X,Y Koordinaten """

def berechne_felder (xpos, ypos) :

    x1 = xpos
    y1 = ypos
    x2 = x1 + laenge
    y2 = y1
    x3 = x2 + (laenge/2.0)
    y3 = y2 + ((laenge * sqrt(3.0)/2.0))
    x4 = x2
    y4 = (sqrt(3.0) * laenge) + y2
    x5 = x1
    y5 = y4
    x6 = x1 - (laenge / 2.0)
    y6 = y3
    mittex = round((x1 + laenge /2.0),2)
    mittey = round ((y3),2)
    mitte  = (mittex, mittey)
    
    return x1,y1,x2,y2,x3,y3,x4,y4,x5,y5,x6,y6,mitte

 
""" Funktion zur Erstellung von Listen und Dictionarys der
    gesamten Spielflaeche """

def erstelle_hexfeldobjekte (spielreihen, ungerade_spalten):

    gerade_spalten = ungerade_spalten-1
    xpos = xorg = 20
    ypos = yorg = 10
    xoffset = laenge * 1.5
    yoffset = sqrt(3) * laenge

    for reihe in range(spielreihen):

        if reihe %2 == 0:

            for feld in range (ungerade_spalten) :

                feldid = (reihe+1,feld+1)
                hexdic[feldid] = berechne_felder (xpos, ypos)
                xpos = xpos + xoffset * 2
            xpos = xorg + xoffset
            ypos = ypos + yoffset / 2

        else :

            for feld in range (gerade_spalten) :

                feldid = (reihe+1,feld+1)
                hexdic[feldid] = berechne_felder (xpos, ypos)
                xpos = xpos + xoffset * 2
            xpos = xorg
            ypos = ypos + yoffset / 2
    

""" Funktion zur Berechnung der Nachbarfelder eines Feldes aller Hexagone """

def berechne_nachbarfelder (hexdic):

    """      _0_
          5 /   \1
          4 \___/2
              3                                     
    """

    zek = hexdic.keys() # zwischenergebnis keys
    zew = []            # zwischenergebnis werte

    for x in zek :
        nf00 = x[0]-2
        nf01 = x[1]
        nf10 = x[0]-1
        nf11 = x[1] + (1 - (x[0]%2))
        nf20 = x[0]+1
        nf21 = x[1] + (1 - (x[0]%2))
        nf30 = x[0]+2
        nf31 = x[1]
        nf40 = x[0]+1
        nf41 = x[1] - (x[0]%2)
        nf50 = x[0]-1
        nf51 = x[1] - ((x[0]%2)*1)

        zew = [(nf00,nf01),(nf10,nf11),(nf20,nf21),(nf30,nf31),(nf40,nf41),(nf50,nf51)]
           
        count = 0

        for z in zew :
            if zew [count][0] < 1  or zew [count][1] < 1 : zew [count] = (0,0)
            if zew [count][0] > spielreihen or zew [count][1] > ungerade_spalten : zew [count] = (0,0)

            count += 1

        nachbardic [x] = zew


""" Funktion zur Berechnung der Entfernung Luftlinie Feldmitten """

def abstand_luft (feldalt, feldneu) :

    mfax = hexdic [feldalt] [12] [0] # steht fuer mitte feld alt x
    mfay = hexdic [feldalt] [12] [1] # steht fuer mitte feld alt y
    mfnx = hexdic [feldneu] [12] [0] # steht fuer mitte feld neu x
    mfny = hexdic [feldneu] [12] [1] # steht fuer mitte feld neu y

    abstand = round(sqrt (abs((abs(mfnx-mfax))**2)-((abs(mfny-mfay))**2)),2)
    
    return abstand


""" Funktion zur Berechnung des kürzesten Nachbarfeldes zum Ziel """
""" ruft Funktion abstand_luft auf"""

def abstand_felder (feldalt, feldneu) :

    back = []                       # liste rueckgabewerte entfernungen
    felder_ziel = []                # liste mit den Feldern zum Zielfeld

    print feldalt, feldneu

    for i in nachbardic[feldalt] :

        print i[0], i[1]
           
        if i[0] < 1.0 or i[1] < 1.0 : back.append (0.0)

        else : back.append (abstand_luft (i, (feldneu)))

    print back
   

  

        
    

            
            

Code: Alles auswählen

from funktionen import *

erstelle_hexfeldobjekte (spielreihen, ungerade_spalten)
berechne_nachbarfelder(hexdic)
#print hexdic
#print nachbardic
print nachbardic [1,1]
#print nachbardic [2,1]
#print nachbardic [3,1]
print hexdic[1,1][12]
#print hexdic[2,1][12]
#abstand_luft((1,1),(3,3))
abstand_felder ((1,1),(2,1))

Code: Alles auswählen

math.hypot(mfnx-mfax, mfny-mfay)