staging.inyokaproject.org

Deshalb schrieb ich nicht "Beispiel", sondern "Stil" ("passt nicht zu meiner Ideologie"). C habe ich wegen dem relativ minimalistischen Ansatz genannt, wobei die Funktionen aus string.h hier wahrscheinlich auch schon "zu viel" anbieten. 😉

Ein gaaanz leicht "over engineer"tes, aber flexibles Beispiel, wie es in C aussehen könnte:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include <iso646.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    unsigned int length;
    char* digits;
} Counter;

void Counter_init(Counter *counter, unsigned int length)
{
    counter->length = length;
    counter->digits = malloc(length + 1);
    memset(counter->digits, '0', length);
    counter->digits[length] = '\0';
}

void Counter_destroy(Counter *counter)
{
    counter->length = 0;
    free(counter->digits);
    counter->digits = NULL;
}

_Bool Counter_increase(Counter *counter)
{
    int i = counter->length;
    _Bool carry = true;
    
    while (carry and i--) {
        carry = counter->digits[i] == '9';
        if (carry) {
            counter->digits[i] = '0';
        } else {
            counter->digits[i]++;
        }
    }
    return not (i == -1 and carry);
}

int main(void)
{
    Counter counter;
    
    Counter_init(&counter, 4);
    do {
        puts(counter.digits);
    } while (Counter_increase(&counter));
    
    Counter_destroy(&counter);
    return 0;
}

☺

ich will ja nicht meckern, aber mittlerweile gehts weit weg von dem eigentlich thema!!

@Marc Naja über Flexibilität lässt sich streiten. So wie ich dein Code lese ist er auch viel zu unflexibel, da er das System "Basis 10" vorgibt, noch besser wäre man könnte die einzelnen Stellen des zahlensystem definieren. Und da du schon C schriebst obwohl es nichts mit dem Theme zu tun hatte, mache ich das mal mit Perl.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#!/usr/bin/env perl
# Core Modules
use strict;
use warnings;
use utf8;
use open ':encoding(UTF-8)';
use open ':std';

sub generate_counter {
    my ( $length, $chars ) = @_;
    my @status = ( 0 ) x $length;
    $status[-1]=-1;
    my @chars = split //, $chars;
    
    my $increment = sub {
        my ( $status ) = @_;
        # increment last
        $status->[-1]++;
        
        # look at every position from behind
        for my $pos ( reverse 0 .. $#$status ) {
            # if it is over range
            if ( $status->[$pos] >= @chars ) {
                # if we are at the first position, then we are done
                if ( $pos == 0 ) {
                    # reinitialize counter
                    @status = ( 0 ) x $length;
                    $status[-1] = -1;
                    # return false - iterator returnd all permutations
                    return undef;
                }
                else {
                    # increase position befor our position
                    $status->[$pos-1]++;
                    # start counting for this position from start
                    $status->[$pos]=0;
                }
            }
        }
        
        # return true if counter could increase
        return 1;
    };
    
    # return a subroutine that counts through all
    return sub {
        # if we could increment
        if ( $increment->(\@status) ) {
            # return the string
            return join '', map { $chars[$_] } @status;
        }
        # otherwise we are at end
        else {
            return undef;
        }
    }
}

sub binary_counter {
    my ( $length ) = @_;
    return generate_counter($length, '01');
}

# Base 3 Counting
my $c1 = generate_counter(3, '012');
while ( my $str = $c1->() ) {
    print $str, "\n";
}

# Base 2 - Binary Counting
my $c2 = binary_counter(4);
while ( my $str = $c2->() ) {
    print $str, "\n";
}

# A new counting system
my $c3 = generate_counter(2, 'qwe');
while ( my $str = $c3->() ) {
    print $str, "\n";
}

Das würde dann letztendlich soetwas ausgeben

000
001
002
010
011
012
020
021
022
100
101
102
110
111
112
120
121
122
200
201
202
210
211
212
220
221
222
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
qq
qw
qe
wq
ww
we
eq
ew
ee

@christian1722: Vielleicht solltest du ins Python Forum auswandern. Da gibt es vermutlich auch keinen persönlichen Mentor und auch der Ton ist etwas rauer, dafür quatscht aber nicht ständig jemand dazwischen, das eine andere Programmiersprache besser wäre. 😉

@gkuhl: Aber Off-Topic-Beispiele in anderen, teilweise "exotischen" Sprachen gibt's da auch manchmal. 😀

okay!

ich habe aus eigener not mal nen Wecker geschrieben... (weil mein hardware-wecker kaputt gegangen ist...)

und naja ich hatte internet sperre... also musste ich mir son programmier lern buch durchlesen... ich hatte ja auch genug zeit...

nun...

ich glaube ich hab das jetzt mit den klassen und methoden verstanden...

der wecker ist im anhang... ("wecka.py")

er gibt jedoch noch keinen ton aus, da ich nicht wusste wie das gehen soll...

und naja dieses "entfernen" hätte man denke ich viel unumständlicher machen können... mir viel nur halt nichts ein...

naja das mit der ton ausgabe hab ich dann halt anders gelößt... und zwar mit der im anhang befindlichen datei "wecker.sh"

@christian1722: Das mit den Klassen und Methoden hast Du ganz bestimmt nicht verstanden. Die Klasse macht gar keinen Sinn, und die Methoden sind auch nur von der Syntax her solche. Wie Du sie einsetzt sind es nicht einmal Funktionen sondern einfach nur Namen für ein Stück Quelltext, damit man den wie früher in BASIC mit einem GOTO erreichen kann.

Schreib das am besten noch einmal ohne diese sinnlose Klasse und mit echten Funktionen.  Dafür solltest Du die global-Anweisung komplett aus Deinem Python-Wortschatz streichen. Und auch am besten allen Quelltext von der Modulebene in Funktionen verschwinden lassen. Üblich ist der Name main() für die Hauptfunktion, die von der Modulebene aus aufgerufen wird.

Quelltext, der so aussieht, als wenn er durch Kopieren und Einfügen entstanden ist und nur geringfügig immer an den selben Stellen verändert wurde, lässt sich mit einer for-Schleife kürzer schreiben.

Namen sollen dem Leser helfen den Quelltext zu verstehen, und möglichst nicht neue Fragen aufwerfen. Was bedeutet zentf!?

Was soll das else bei der while-Schleife?

zentf=Zu ENTFernen

und das else: istda, das is da das mit dem ton ausgeben reinpacken kann...

und nein ich habe nicht copy and past angewandt...

und ja ich hab mich auch gefragt, warum ich das nicht mit ner normalen funktion gemacht habe wenn überhaupt...

Auf die Bedeutung von zentf kommt man ja in 100 Jahren nicht. Und Du selbst, wenn Du nach ein oder zwei Jahren mal wieder in den Quelltext schaust auch nicht.

Das mit dem else würde zwar funktionieren, da aber kein break innerhalb der Schleife vorkommt, würde der else-Zweig grundsätzlich immer nach Abarbeitung der Schleife ausgeführt. Also sollte man das besser nach der Schleife hinschreiben. Ich wage mal zu behaupten, Du hast nicht verstanden wozu else bei Schleifen da ist. Das Konstrukt ist sowieso ein wenig merkwürdig.

Du hast also wirklich so oft replace eingetippt? Respekt. Aber auch dauernd das gleiche tippen statt es zu kopieren, ist kein so guter Stil.

ach das... nein ich dachte du beziehst das auf aus dem internet kopieren und da einfügen...

naja da wusste ich nich wie ich das anders machen kann...

mir ist klar das das unproduktiv ist...

habe aber weder in ABOB nich im openbook für pyhton was anders gefunden...

Du hättest vielleicht mal in die Dokumentation schauen sollen. Dort gibt es auch ein Tutorial, das sehr zu empfehlen ist. Hier mal ein Beispiel wie man einen Wecker mit Python realisieren kann:

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

import time
import subprocess

def alarm_clock(hour, minute, precision = 10 ):
    while True:
        now = time.localtime()
        if now.tm_hour >= hour and now.tm_min >= minute:
            return True
        time.sleep(precision)

def main():
    hour = int(raw_input('Stunde: '))
    minute = int(raw_input('Minute: '))
    alarm_clock(hour, minute)
    subprocess.Popen(['vlc', './Music', '--loop', '--volume', '1024','--random'])

if __name__ == '__main__':
    main()

Grüße
Gerrit

@gkuhl: Bei alarm_clock() hätte es ein einfaches return getan. Denn so gibt die Funktion immer True zurück, was deswegen sowieso niemand jemals überprüfen würde.

@BlackJack: Stimmt. Ich hatte aber überlegt ob man die Funktion nicht noch erweitern könnnte. Z.B. kann man überprüfen, ob hour und minute überhaupt eine gültige Uhrzeit beschreiben, und wenn das nicht der Fall, gibt man False zurück. Und dann würde das True auch Sinn machen.

@gkuhl: Bei unsinnigen Eingabwerten würde ich lieber eine Ausnahme auslösen. Ein ValueError käme mir da so in den Sinn. Bei Fehlerrückgabewerten wären wir ja schon wieder beim C-Stil. ☺