Lotto-Programm - Übung, Analyse und Co.

[Graf Wasserrutsche]

Guten Tag zusammen!

Auf der Suche nach einem ersten Projekt was auch mehr oder minder einen Sinn (wenn auch nur einen kleinen) hat bin ich auf die Idee gekommen ein Lotto-Programm zu schreiben. Dies wollte ich mit der Datenbankgrundlage SQLite umsetzen und als spätere GUI wxPyhton verwenden. Hierbei will ich das Vertrautverweden mit den jeweiligen Modulen bzw. API etwas ausbauen.

Bei meinem aktuellen Stand bin ich soweit, dass ich die Lottozahlen 1-6 generiere, die Zusatzzahl und die Superzahl berechne und diese dementsprechend in die SQL-Datenbank einfüge. Ein Export dieser SQL-Datenbank in eine CSV-Datenbank ist auch soweit möglich.

Das ist noch nicht sonderlich viel und jetzt suche ich weitere Ideen bzw. Funktionen die ich mit in das Programm einbauen könnte. Ich dachte an Wahrscheinlichkeitsberechnungen und Statistik-Ausgaben welche Zahlen wieviel und wann am meisten vorkamen. Vielleicht fällt euch noch etwas ein, was man mit einbauen könnte oder mit was für Mitteln man diese Sachen umsetzen kann.

[Leonidas]

Nutzung eines ORMs, sofern nicht schon passiert, Zeichnen von Diagrammen (Verteilungen bieten sich an, um nachzusehen ob die Ergebnisse gleichverteilt sind) mittels matplotlib.

[surfhai]

Hi,

ich hab sowas ähnliches auch schon programmiert, vielleicht kannst du was davon gebrauchen.

Code: Alles auswählen

#!/usr/bin/env python
# coding=utf-8

import random
import locale
  
class Lotto(object):
    '''A class for playing Lotto.'''
    
    def __init__(self):
        self._user_Nums = []
        self._rand_Nums = []
        self._matches = []
        self._counter = 0
        self._times_played = 0
        self._match_chance = {3 : None, \
                              4 : None, \
                              5 : None, \
                              6 : None}
       
       
    def getUserNums(self):
        '''Returns the retrieved user numbers.'''
        return self._user_Nums
   
   
    def getRandNums(self):
        '''Returns the list of random numbers.'''
        return self._rand_Nums
   
   
    def getMatches(self):
        '''Returns a list of the matches.'''
        return self._matches
   
   
    def getChances(self):
        '''Returns the chance for six hits.'''
        return self._match_chance
   
   
    def _DelList(self, x):
        '''Deletes the given list x.'''
        while len(x):
            del x[0]
       
       
    def UserNums(self):
        '''Retrieves the user for six numbers between 1 and 49.'''
       
        if len(self._user_Nums):
            self._DelList(self._user_Nums)
               
        i = 1
       
        while len(self._user_Nums) < 6:
            temp = raw_input(u'%d. Zahl eingeben: ' % i)
           
            try:
                number = int(temp)
               
            except ValueError:
                print u'ValueError: Es ist keine Zahl eingegeben worden.'
                continue
           
            if number in self._user_Nums:
                print u'Zahl ist schon in der Liste'
                continue
           
            elif type(number) != int:
                print u'Zahl wurde nicht in ein integer umgewandelt'
                continue
           
            elif number < 1 or number > 49:
                print u'Zahl zwischen 1 und 49 eingeben'
                continue
           
            self._user_Nums.append(number)
            i += 1
           
        self._user_Nums.sort()
   
   
    def RandNums(self):
        '''Build a list of random numbers between 1 and 49.'''
       
        if len(self._rand_Nums):
            self._DelList(self._rand_Nums)
       
        while len(self._rand_Nums) < 6:
            number = random.randint(1, 49)
           
            if number not in self._rand_Nums:
                self._rand_Nums.append(number)
           
        self._rand_Nums.sort()
        
    
    def _Matches(self):
        ''''''
        
        splitted = []
        count = 0
        
        if len(self._matches) >= 3:
            for number in self._matches:
                i = self._rand_Nums.index(number)
                if len(splitted) == 0:
                    splitted.append([number])
                    continue
                i = len(splitted[count]) - 1
                if self._rand_Nums.index(splitted[count][i]) + 1 == \
                   self._rand_Nums.index(number):
                    splitted[count].append(number)
                else:
                    splitted.append([number])
                    count += 1
        else:
            return None
        
        for newlist in splitted:
            x = len(newlist)
            if x in self._match_chance and self._match_chance[x] == None:
                self._match_chance[x] = self._counter
        
   
    def Compare(self):
        '''Compares the user numbers and the random numbers and save the result.'''
       
        if self._user_Nums < 6 or self._rand_Nums < 6:
            print u'Es wurde noch keine vollständige Zahlenliste erstellt.'
           
        elif self._matches:
            self._DelList(self._matches)
           
        for number in self._user_Nums:
            if number in self._rand_Nums:
                self._matches.append(number)
                
        self._matches.sort()                
        self._Matches()
               
               
    def _calcChances(self):
        '''Calculates the chance of six hits.'''
       
        self._counter = 0
        self._match_chance = {3 : None, \
                              4 : None, \
                              5 : None, \
                              6 : None}
        
        while True:
            self._DelList(self._matches)
            self._counter += 1
            self.RandNums()
            self.Compare()
           
            if not None in self._match_chance.itervalues():
                break
            
            #print_temp = locale.format_string(u'')
            #print_temp = u'\b{0:>11} Durchläufe {1}'.format(\
            #             locale.format('%d', self._counter, grouping = True), \
            #             self._match_chance)
            #print_temp = u'\b{0:>11} Durchläufe'.format(\
            #             locale.format('%d', self._counter, grouping = True))
            print_temp = u'\b{0:>11} Durchläufe'.format(self._counter)
            print print_temp,
           
            if None in self._match_chance.itervalues():
                print u'\b' * 45 * 5,
            else:
                print u'\n',
               
               
               
               
    def PrintResult(self):
        '''Prints the result on the console.'''
       
        print u'\nZufallszahlen:'
       
        for i in range(len(self._rand_Nums)):
            print u'{0}. Zahl: {1}'.format(i + 1, self._rand_Nums[i])
           
        print u'\n{0} Treffer\n'.format(len(self._matches))
       
        for number in self._matches:
            print u'Übereinstimmung an Position {0}: {1}'.format( \
                                                          self._rand_Nums.index(number) + 1, \
                                                          number)
       
       
    def PrintChance(self):
        '''Prints the chance of six hits on the console.'''
        
        print u'\n'
        for i, chance in self._match_chance.iteritems():
            print u'\tChance auf {0} Treffer nach {1} durchläufen.'.format(i, chance),
            print u'\tErfolgschancen: {0}%'.format(100.0 / chance)
        
        #=======================================================================
        # print u'Nach {0} Versuchen hat es geklappt ;)'.format(self._counter)
        # print u'Erfolgschancen: {0:.10f}%'.format(self._chance)
        #=======================================================================
           
           
    def Play(self):
        '''Starts the instance of Lotto.'''
        
        
        while True:
            
            if self._times_played > 0:
                temp = raw_input(u'\nSelbe Zahlen wieder verwenden? [j/N]: ')
                if str.isalpha(temp):
                    abfrage = str.strip(temp).lower()[0]
                else:
                    abfrage = 'n'
                
                if abfrage == 'n':
                    self.UserNums()
            else:
                self.UserNums()
                
            self.RandNums()
            self.Compare()
            self.PrintResult()
           
            temp = raw_input(u'\nErfolgschancen ermitteln? [J/n]: ')
            if str.isalpha(temp):
                abfrage = str.strip(temp).lower()[0]
            else:
                abfrage = 'j'
            
            if abfrage == 'j':
                self._calcChances()
                self.PrintChance()
            
            self._times_played += 1
            
            temp = raw_input(u'\nNochmal spielen? [j/N]: ')
            if str.isalpha(temp):
                abfrage = str.strip(temp).lower()[0]
            else:
                abfrage = 'n'

            if abfrage == 'n':
                break
            
               
 
if __name__ == '__main__':
    
    locale.setlocale(locale.LC_ALL, '') 
   
    Lotto = Lotto()
    Lotto.Play()

[Leonidas]

Also pythonischer Code sieht anders aus...

[BlackJack]

In der Tat.

Die Getter werden noch nicht einmal benutzt!

Und alles ohne nachzudenken in *eine* Klasse gesteckt, von der am Ende ein Exemplar erstellt wird, und eine Methode aufgerufen wird. Methodennamen die nicht sagen was die Methode *tut* sondern eher nach Namen für Werte klingen.

[Dauerbaustelle]

Wozu die ganzen Getter und pseudo-privaten Variablen :-/

[surfhai]

Also pythonischer Code sieht anders aus...

sorry, kann nicht jeder gleich perfekten code schreiben wie du das anscheinend kannst

Und alles ohne nachzudenken in *eine* Klasse gesteckt, von der am Ende ein Exemplar erstellt wird, und eine Methode aufgerufen wird. Methodennamen die nicht sagen was die Methode *tut* sondern eher nach Namen für Werte klingen.

scheinst dir ja schon sehr viele gedanken gemacht zu haben, vielleicht kannst du auch gleich noch schreiben wie es besser gelöst worden wäre.

Wozu die ganzen Getter und pseudo-privaten Variablen :-/

damit jemand die berechtigung hat diese frage zu stellen

Gruß Thorsten

[HerrHagen]

OK, ich werd mal etwas konkreter. Deine Variante die Kugeln zu ziehen ist (für Python) etwas kompliziert. Besser wäre eine solche Variante:

Code: Alles auswählen

>>> kugeln = range(1, 50)  # Kugeln erzeugen
>>> random.shuffle(kugeln)  # mischen
>>> kugeln[:6]  # 6 herausgreifen

Sowas:

Code: Alles auswählen

number < 1 or number > 49

schreibt man in Python besser so:

Code: Alles auswählen

1 <= number <= 49:

Wenn es bei der Umwandlung keine Exception gab, dann ist es auch sicher ein int und braucht nicht noch mal extra geprüft werden.

Code: Alles auswählen

            try:
                number = int(temp)
            ...
            elif type(number) != int:
                print u'Zahl wurde nicht in ein integer umgewandelt'
                continue

Außerdem prüft man den Typ in Python besser so:

Code: Alles auswählen

isinstance(number, int)

Sowas hier:

Code: Alles auswählen

        i = 1
        while len(self._user_Nums) < 6:
            ...
            i += 1

Schreibt man besser als:

Code: Alles auswählen

for counter in range(1, 7):

Allgemein ist dein Code viel zu kompliziert. Irgendwie sieht das ganze wie Enterprise Java-Code aus. Nimm die Getter raus.

MFG HerrHagen

[nemomuk]

Das schlimmste ist doch definitiv das hier:

Code: Alles auswählen

self._user_Nums = []
def getUserNums(self):
    '''Returns the retrieved user numbers.'''
    return self._user_Nums

Code: Alles auswählen

self._match_chance = {3 : None, \
                              4 : None, \
                              5 : None, \
                              6 : None}
print u'Übereinstimmung an Position {0}: {1}'.format( \
                                                          self._rand_Nums.index(number) + 1, \
                                                          number)

[EyDu]

Das schlimmste ist doch definitiv das hier:

Naja:

Code: Alles auswählen

    def _DelList(self, x):
        '''Deletes the given list x.'''
        while len(x):
            del x[0]

@surfhei: Du solltest in der "Play"-Methode deine ganzen Wiederholungen loswerden. Du solltest die Benutzereingabe einmal als Funktion implementieren. Immer wenn du Code kopierst oder gleiches noch einmal schreibst, dann solltest du dir darüber Gedanken machen, ob und wie man es zusammenfassen kann.

Bis dann,
Sebastian