Addition Zahlen 1-100 mit while-Schleife

[gisapppython]

vielen Dank für die KOSTENLOSE Hilfe. Denke ich kriege es jetzt hin.

[jerch]

@gisapppython:
Zur Übung - versuch es doch mal mit der Fakultät

[gisapppython]

ja mir ging es jetzt erstmal darum die Aufgabe zu lösen und die jetzt nachzuvollziehen. Parallel fange ich mit Grundlagen an und arbeite mich voran. Am Ende muss/will ich es selbst hinkriegen, logisch

[__deets__]

Der TE hat eines mit Bestimmtheit gelernt - nichts zu investieren schadet nicht. Ein Schubs in die richtige richtung ist das erarbeiten einer Problemvorstellung & das Verbinden von Einzelteilen zu einem größeren. Dann macht es Klick.

Du hast eine schlüsselfertige Lösung für alles geliefert. Keine eigene Leistung, kein lernen. Dafür braucht man kein Pädagogikstudium um sich das klar zu machen.

[DeaD_EyE]

Viel einfacher, entspricht aber nicht der Vorgabe des Lösungswegs.
Zuerst sollte man Iteration in Python verstehen, bevor man sowas macht:

Code: Alles auswählen

sum(range(1, 101))

Noch eine Frage. Was ist denn eine Zählschleife? Gibt es da irgendeine feste Definition?
In Python würde ich sagen 'for i in range(start, end):' sei eine Zählschleife.

Vielleicht meinen die ja sowas hässliches:

Code: Alles auswählen

result = 0
n = 1
while n < 101:
    result += n
    n += 1
print(result)

So würde man das in Python machen:

Code: Alles auswählen

result = 0
for number in range(1, 101):
    result += number
print(result)

Mit sum():

Code: Alles auswählen

iterable = range(1, 101)
result = sum(iterable)
print(result)

Oder halt wie ganz zum Anfang:

Code: Alles auswählen

result = sum(range(1, 101))

den OP spreche ich gar nicht an, da er das wahrscheinlich nicht lesen wird

Man sollte aber erst die Schleifen verstehen, wie man sie in C implementiert, um gewisse Bascis zu beherrschen. In Python gilt es dann, diese Basics wieder schnell zu vergessen und so mit der Sprache zu arbeiten, wie es vorgesehen ist. Dort würde man z.B. die Aufgabe nicht wie in C implementieren, was unter Umständen sogar unlesbarer und langsamer ist. Wenn man z.B. eine Liste mit einem vorangestellten Index auszugeben, sieht man z.B. oft dieses nicht Pythonische Beispiel:

Code: Alles auswählen

objekte = ['Boot', 'Haus', 'Stuhl']
i = 0
n = 1
while i < len(objekte):
    print(n, objekte[i])
    n += 1
    i += 1

Das ganze nochmal wie es in Python schreiben würde:

Code: Alles auswählen

objekte = ['Boot', 'Haus', 'Stuhl']
for lineno, objekt in enumerate(objekte, start=1):
    print(lineno, objekt)

Da haben sich gleich mehrere Sachen geändert. Wir sind die temporären Variablen für den Index und die Zeilennummer außerhalb der Schleife losgeworden. Anstatt die Elemente im Objekt objekte über deren Index anzusprechen, wird mit for über jedes Element in der Liste iteriert und der Variable objekt zugewiesen. Die Funktion enumerate ist sowas wie ein Zähler, der ein anderes Objekt umschließt. Bei einer iteration wird der Zählerstand und ein Element des Objektes ausgegeben. Die Variable start gibt an, wo der counter anfängt.

[BlackJack]

@DeaD_EyE: Wieso um alles in der Welt sollte man erst Schleifen verstehen wie sie man sie in C schreiben würde? Python ist nicht C. $GOTT sei Dank! Genau diesen Unsinn muss man Leuten die von Sprachen mit vielen Indexzugriffen kommen, erst wieder abgewöhnen, also warum erst beibringen? Dann könnte man auch argumentieren, dass man eigentlich erst Schleifen in Maschinensprache verstehen müsste um gewisse Grundlagen zu beherrschen.

Zumal ich auch in C keine zwei Laufvariablen verwenden würde die sich um einen konstanten Wert unterscheiden aber ansonsten ”parallel” laufen.
[codebox=c file=Unbenannt.c]#include <stdint.h>
#include <stdio.h>

#define OBJECT_COUNT 3

int main(void)
{
uint8_t i;
char *objects[OBJECT_COUNT] = {"Boot", "Haus", "Stuhl"};

for (i = 0; i < OBJECT_COUNT; ++i) {
printf("%u %s\n", i + 1, objects);
}

return 0;
}[/code]

QBASIC ist ausserdem viel schöner
[codebox=qbasic file=Unbenannt.txt]CONST N=100

' Summe der Zahlen 1 bis N mit einer WHILE-Schleife.
sum=0
i=1
WHILE i<N+1
sum=sum+i
i=i+1
WEND
PRINT sum

' Summe der Zahlen 1 bis N mit einer FOR-Schleife.
sum=0
FOR i=1 TO N
sum=sum+i
NEXT
PRINT sum

' Die effiziente Art nach Gauss.
PRINT (N^2+N)/2[/code]

Zusätzlich mit der effizienten Lösung ohne Schleife.

[jerch]

Dieser Thread hat eine gewissene Anschaulichkeit in puncto Vermittlung pädagogischer Ziele. Zum Glück ist er zumindest dafür gut

[pixewakb]

Dieser Thread hat eine gewissene Anschaulichkeit in puncto Vermittlung pädagogischer Ziele. Zum Glück ist er zumindest dafür gut

Du meinst in der Kategorie, wie man es besser nicht machen sollte?

[bwbg]

@BlackJack: Danke für den Gauss

[DeaD_EyE]

BlackJack, ich sehe das etwas anderes. Man muss ja nicht in C programmieren können.
Die Konzepte empfinde ich aber für sehr wichtig. Ihr denkt da halt anders drüber.


Wir hatten heute einen jugendlichen zu Besuch, der mal in unseren Beruf reinschnuppern wollte.
Um ihn zu beschäftigen habe ich ihm ein SPS-Rack hingestellt und kurz die Grundelemente erklärt.
Als wir dann zum SR/RS-FlipFlop kamen, war es einfacher die Setz- und Rücksetzdomianz anhand AWL zu verdeutlichen.
AWL = Anweisungsliste.

Rücksetzdominaz

Code: Alles auswählen

U E0.0
S M0.0
U E0.1
R M0.0

Setzdominaz

Code: Alles auswählen

U E0.0
R M0.0
U E0.1
S M0.0

Fazit: Der letzte ist Dominant.

Wir programmieren aber nicht in AWL. Das wäre für die Studenten und Auszubildenden zu LowLevel.
Gewisse Vorgänge lassen sich damit aber sehr einfach erklären.

[BlackJack]

@DeaD_EyE: Das ist halt immer auch so ein bisschen die Frage wie man sich dem Programmieren nähert. Von der Problemseite her oder von der Maschinenseite her. Python ist halt deutlich näher an Lisp als an C, so dass man von C einen weiteren Weg hat. Python hat keine Zählschleife wie ``for`` in C, die muss man sich mit ``while`` schreiben wenn man Iteratoren vermeiden möchte. ``for`` braucht immer einen Iterator und iterieren über Zahlen um die für Indexzugriffe zu verwenden ist unnötig indirekt. Das zu zeigen ist zu zeigen wie man es in Python *nicht* macht.