1Mbc Wochenwiki [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
===== 1Mbc Wochenwiki =====

[[gf_informatik:1m|Informatik Dossier 1M]]

++++Code senden via Teams – bitte beachten:| 
  - Als **Screenshot** (nur vom Code, nicht vom gesamten Screen) --> Snipping Tool (Windows) / cmd+shift+4 (Mac)
  - Der Code enthält zuoberst eine Kommentarzeile, die die Aufgabe angbit (z.B. #Aufgabe G3)
  - Zustäzlich zum Screenshot folgende Nachricht:
    * Falls der Code funktioniert: "Code funktioniert"
    * Falls nicht: Kurz beschreiben, was genau nicht funktioniert / wo welche Fehlermeldung kommt. 
++++

=== Woche 35 (2023-06-26) ===
  * Mittwoch:
    * Funktion decimal\_to\_binary (Hausaufgaben) besprechen.
    * {{ gf_informatik:gfif_zahlensysteme_dossier_hof.pdf |Zahlensysteme}}: Wieso das Binärsystem?
    * Binäre Addition.
  * Freitag: Kein Unterricht (Klassenkonferenzen).
  * Schöne Sommerferien!


=== Woche 34 (2023-06-19) ===
  * Mittwoch:
    * Prüfung vom letzten Mittwoch besprechen.
    * Funktion binary\_to\_decimal (Hausaufgaben) besprechen.
    * {{ gf_informatik:gfif_zahlensysteme_dossier_hof.pdf |Zahlensysteme}}: Bytes und Bits.
    * Strings und Integer, Strings umdrehen.
  * Freitag (Fernunterricht):
    * Zahlensysteme: Bytes und Bits.
    * Zahlensysteme: Dezimal in Binär wandeln: Restwertalgorithmus anwenden und programmieren.
  * HA: Aufgabe 3.4 bis 3.6 lösen. Screenshot zu 3.6 senden. Siehe auch [[gf_informatik:zahlensysteme:binary_collection|Binärzahlen mit Python.]]

=== Woche 33 (2023-06-12) ===
  * Mittwoch: Prüfung zu Listen, For-Schleifen, suchen und sortieren. 
  * Freitag:
    * Einstieg in Zahlensysteme. Arbeit mit {{ gf_informatik:gfif_zahlensysteme_dossier_hof.pdf |Dossier}} auf Papier.
  * HA: Aufgabe 2.1 bis 3.3 im Dossier lösen. Screenshot von eigener Lösung zu Aufgabe 3.3 senden. Siehe auch [[gf_informatik:zahlensysteme:binary_collection|Binärzahlen mit Python.]]


++++PRÜFUNG am 14.06.23 – Infos:|  
== Lernziele ==
  * Funktionen im Griff haben. Siehe Lernziele zur [[gf_informatik:1mbc_2022#woche_22_2023-03-06|Prüfung über Funktionen]].
  * Listen und for-Schleifen verstehen: 
    * leere Listen erstellen, Funktionen ''append, pop, insert, len'' sinnvoll verwenden.
    * Via eckige Klammern bestimmte Elemente einer Liste auslesen oder verändern.
    * Mit der for-Schleife die Elemente einer Liste durchgehen (direkte for-Schleife).
    * Mit der for-Schleife und der range-Funktion die Positionen einer Liste durchgehen (indirekte for-Schleife).
    * Die direkte und die indirekte for-Schleife sinnvoll anwenden. 
    * Die range-Funktion auch mit mehreren Argumenten anwenden.
    * Mit for- oder while-Schleifen die Elemente einer Liste durchgehen und nach Kriterien prüfen, um Fragen zu beantworten: Beispiele:
      * Summe aller Elemente, die restlos duch 4 und restlos durch 3 teilbar sind.
      * Anzahl Elemente zwischen x und y.
      * etc. 
  * Lineare und binäre Suche verstehen:
    * Das Vorgehen einer Suche in einem Dataset aus zwei oder mehreren Listen verstehen. 
    * Algorithmus für die lineare Suche programmieren – inkl. Rückgabe von None, falls nichts gefunden.
    * Algorithmus für die binäre Suche verstehen, Teile davon programmieren.
  * Sortieren:
    * Algorithmus für Selection Sort verstehen, Teile davon programmieren.
    * Wichtigste Eigenschaften von Sortier-Algorithmen nennen.

== Lernressourcen ==
  * Theorie und Aufgaben zu [[gf_informatik:programmieren_iii|Listen und for-Schleifen]], zu [[gf_informatik:suchen_und_sortieren_2023|linearer Suche]], zu [[gf_informatik:suchen_und_sortieren_2023:binaersuche|binärer Suche]] und zu [[gf_informatik:suchen_und_sortieren:sortieren|Sortieren]], nur Selection Sort.
  * [[gf_informatik:programmieren_repetitionsdossier#grundlagen_ii|Repetitionsdossier]], Aufgaben 2.25 bis 2.39 (auch 2.1 ... 2.21, falls nicht schon gemacht)
  * ChatGPT fragen: "Kannst du mir Übungsaufgaben zum Thema ... stellen?".

++++
=== Woche 32 (2023-06-05) ===
  * Mittwoch: 
    * Hausaufgaben besprechen.
    * [[gf_informatik::suchen_und_sortieren:sortieren#aufgabe_c3selection_sort_anwenden|Aufgabe C3 ]]lösen.
    * [[gf_informatik::suchen_und_sortieren:selection_sort|Selection Sort (in-place) programmieren]].
  * Freitag:
    * Lernziele durchgehen: Alles klar?
    * Letze Prüfung anschauen.
    * Üben mit Repetitionsaufgaben.
    * Hinweise zu ChatGPT.
  * HA: Auf Prüfung lernen. Mit den Lernzielen oben.


=== Woche 31 (2023-05-29) ===
  * Mittwoch: 
    * Selection Sort: [[gf_informatik::suchen_und_sortieren:sortieren#teil_2python|Aufgabe 2 Teil 2 (ohne in-place)]]  besprechen.
    * Wissen prüfen auf isTest: Funktionen.
  * Freitag:
    * Wissenstest zu Funkionen besprechen.
    * Nächste Prüfung: Lernziele anschauen. Unterschied direkte und indirekte For-Schleife besprechen.
    * ChatGPT ausprobieren: Frage ChatGPT nach einer python-Programmieraufgabe zu einem bestimmtem Thema. Falls dir die Aufgabe zu schwierig/einfach ist, verlange nach einer einfacheren/schwierigeren. Bitte ChatGPT dann, dass es deinen Code korrigiert.
    * [[gf_informatik::suchen_und_sortieren:selection_sort|Selection Sort (in-place) programmieren]].
  * HA: Erstelle eine neue Datei und schreibe mehreren Funktionen: Die erste Funktion generiert eine Liste mit beliebig vielen Zufallszahlen zwischen 1 und 99. Die anderen Funktionen dienen dazu, die Liste zu sortieren --> Selection Sort. Der Code soll zuerst eine unsortierte Liste mit 10 Zahlen ausgeben. Dann soll er dieselbe Liste sortiert ausgeben. Screenshot senden.

<nodisp 1>
++++Lösung|
<code python>
import random

def zufallszahlen(n):
	zahlen = []
	for i in range(n):
		zahlen.append(random.randint(0,99))
	return zahlen

def find_min(li):
	min_index = 0
	for j in range(len(li)):
		if li[j] < li[min_index]:
			min_index = j
	return min_index

def pop_min(li):
	min_index = find_min(li)
	return li.pop(min_index)

def selection_sort(li):
	sortierte_liste = []
	while len(li) > 0:
		kleinstes_element = pop_min(li)
		sortierte_liste.append(kleinstes_element)
	return sortierte_liste

meine_zahlen = zufallszahlen(20)
print(meine_zahlen)
print(selection_sort(meine_zahlen))
</code>
++++
</nodisp>




=== Woche 30 (2023-05-22) ===
  * Mittwoch: 
    * Prüfung zu Listen, for-Schleifen und linearer Suche besprechen.
  * Freitag:
    * [[gf_informatik:suchen_und_sortieren_2023:binaersuche|Binäre Suche]]: Aufgabe B5 und B6 lösen und besprechen. 
    * Schnelle: B7 lösen.
    * Einstieg in [[gf_informatik::suchen_und_sortieren:sortieren|Sortieren]]
  * HA: [[gf_informatik::suchen_und_sortieren:sortieren#teil_2python|Aufgabe 2 Teil 2 (ohne in-place)]] lösen:
    * Schritt für Schritt durchgehen: Jeweils zuerst selbst codieren und bei Bedarf nachschauen.
    * Komplette Funktion ''selection_sort(l)'' erstellen und mit einer selbst erstellten Liste testen. Screenshot vom Code senden, der die Funktion und den Test der Funktion enthält. Hinweise oben beachten.

=== Woche 29 (2023-05-15) ===
  * Mittwoch: 
    * [[gf_informatik:suchen_und_sortieren_2023:binaersuche|Binäre Suche]], Aufgabe B3 besprechen.
    * Aufgaben B4, B5, B6. Wer schnell ist: B7.
  * Freitag fällt aus (Auffahrtsbrücke)
  * HA: Aufgaben B4 und B5 lösen. Screenshot senden. Beachte Hinweise oben.


=== Woche 28 (2023-05-08) ===
  * Mittwoch: 
    * Prüfung zu Listen, For-Schleifen, lineare Suche
  * Freitag:
    * Einsteig in [[gf_informatik:suchen_und_sortieren_2023:binaersuche|binäre Suche ]], Aufgaben B1, B2
  * HA: 20 Min. ungestörte, ablenkungsfreie Zeit für Aufgabe B3 nehmen und //eigenen// Code-Versuch für Bereich "Dein Code hier!" erstellen. Screenshot von diesem Code-Abschnitt senden. Siehe Hinweise oben.


++++PRÜFUNG am 10.05.23 – Infos:|  
== Lernziele ==
  * Funktionen im Griff haben. Siehe Lernziele zur [[gf_informatik:1mbc_2022#woche_22_2023-03-06|Prüfung über Funktionen]].
  * Listen und for-Schleifen verstehen: 
    * leere Listen erstellen, Funktionen ''append, pop, insert, len'' sinnvoll verwenden.
    * Via eckige Klammern bestimmte Elemente einer Liste auslesen oder verändern.
    * Mit der for-Schleife die Elemente einer Liste durchgehen.
    * Die for-Schleife in Kombination mit der range-Funktion sinnvoll verwenden. (Die range-Funktion auch mit mehreren Argumenten sinnvoll verwenden).
  * Lineare Suche verstehen:
    * Funktionsweise der linearen Suchen mit zwei oder mehreren Listen verstehen.
    * Mit for- oder while-Schleifen die Elemente einer Liste durchgehen und die Positionen bestimmter Elemente ermitteln.
    * Mit for- oder while-Schleifen Elemtene zählen, die bestimmten Kriterien entsprechen.


== Lernressourcen ==
  * Theorie und Aufgaben zu [[gf_informatik:programmieren_iii|Listen und for-Schleifen]]
  * Theorie und Aufgaben zu [[gf_informatik:suchen_und_sortieren_2023|linearer Suche]]
  * [[gf_informatik:programmieren_repetitionsdossier#grundlagen_ii|Repetitionsdossier]], Aufgaben 2.1 bis 2.21 (vorzugsweise solche mit Listen oder for-Schleifen)
   
++++
=== Woche 27 (2023-05-01) ===
  * Mittwoch: 
    * Probeprüfung in isTest (mit SEB), danach Besprechung.
    * Besprechung [[gf_informatik:suchen_und_sortieren_2023|Suchen und Sortieren]], Aufgaben A3 bis A6
    * Evtl. üben für Prüfung mit [[gf_informatik:programmieren_repetitionsdossier#grundlagen_ii|Repetitionsdossier]], Aufgaben 2.1 bis 2.21 
  * Freitag:
    * Üben für Prüfung mit [[gf_informatik:programmieren_repetitionsdossier#grundlagen_ii|Repetitionsdossier]], Aufgaben 2.1 bis 2.21
    * Quizfrage, siehe unten. 
  * HA: Auf Prüfung lernen. Siehe oben.  

++++ Quizfrage|
Wenn du alle Einträge der Liste towns (in der Datei plz_data.py), deren Position in der Liste ein Vielfaches von 7 oder ein Vielfaches von 11 ist, zusammenhängen würdest: Wie viele Zeichen enthielte dieser Text dann? Leerzeichen innerhalb der Einträge wie z.B. in "St. Gallen" werden mitgezählt – zwischen zwei zusammgehängten Einträgen gibt es kein Leerzeichen.

++++
=== Woche 26 (2023-04-24) ===
  * Mittwoch: 
    * [[gf_informatik:suchen_und_sortieren_2023|Suchen und Sortieren]], Aufgaben A3 bis A6
  * Freitag:
    * Listen postleitzahlen, ortschaften und kantone anschauen.
    * [[gf_informatik:suchen_und_sortieren_2023|Suchen und Sortieren]], Aufgaben A3 bis A6
    * Evtl. Einsteig in [[gf_informatik:suchen_und_sortieren_2023:binaersuche|Binäre Suche]]
  * HA: [[gf_informatik:suchen_und_sortieren_2023|Suchen und Sortieren]], Aufgaben A3 bis A6. Screenshot des eigenen Codes zu einer der Aufgaben schicken, am besten zur schwierigsten. Siehe Hinweise oben.

\\

=== Woche 25 (2023-04-17) ===
  * Mittwoch: 
    * Rückblick: For-Schleife und Listen
    * Weiter mit Aufgabe Geburtsdatums-Suche (siehe unten).
    * Hausaufgabe auf Freitag: Aufgabe Geburtsdatums-Suche lösen!
  * Freitag:
    * Aufgabe Geburtsdatums-Suche besprechen.
    * Einstieg in [[gf_informatik:suchen_und_sortieren_2023|Suchen und Sortieren]], Aufgaben A1, A2, A3.
  * HA: Aufgaben A2, A3: 1-3. Screenshot des eigenen Codes zu einer der Aufgaben schicken, am besten zur schwierigsten. Siehe Hinweise oben.

\\

=== Woche 24 (2023-03-20) ===
  * Mittwoch: 
    * Besprechung Aufgabe [[gf_informatik:programmieren_iii#aufgabe_h5|H5]]
    * Aufgabe "Anzahl Viefache".
    * Besprechung Aufgaben [[gf_informatik:programmieren_iii#aufgabe_i1|I1, I2]]
    * Weiter mit Aufgaben I3, I4, I5.
  * Freitag: 
    * Aufgaben [[gf_informatik:programmieren_iii#aufgabe_i4|I4 bis I6]] oder [[gf_informatik:programmieren_zusatzaufgaben#lotto|Zusatzaufgaben Lotto oder Zahlenraten]]
    * Lineare Suche: Aufgabe Geburtsdatums-Suche

++++ Aufgabe Anzahl Vielfache|
  - Erstelle eine Funktion //anz\_vielfache(L,x)//. Dieser übergibt man eine Liste und eine Zahl. Sie gibt zurück, wieviele Elemente der Liste ein Vielfaches von x sind.
  - Tipp: Eine zahl a ist ein Vieflaches von x, wenn die Rechnung ''a % x'' 0 ergibt.
  - Kopiere folgende Listen in deinen Code (unterhalb oder oberhalb der Funktions-Definition)
    - ''A = [3,1,5,4,9,4,8,3,1,2,4,9]''
    - ''B = [17,3,6,12,18,20,15,3,4,16,42,28]''
  - Teste die Funktion:
    - Der Aufruf ''print anz\_vielfache(A, 3)'' sollte 4 ausgeben. 
    - Der Aufruf ''print anz\_vielfache(B, 3)'' sollte 7 ausgeben.
    - Der Aufruf ''print anz\_vielfache(B, 4)'' sollte 5 ausgeben.
++++

== Aufgabe Geburtsdatums-Suche ==
Schreibe eine Funktion //geburri\_suche(name)//. Dieser übergibst du den Vornamen einer Schüler:in deiner Klasse und die Funktion gibt das Geburtsdatum dieser Schüler:in zurück. Zum Beispiel sollte der Aufruf ''geburri\_suche('Karl')'' das Datum 05.05.1818 zurückgeben (wenn Karl Marx in unserer Klasse wäre).
Das funktioniert so: 
  * Du brauchst zwei Listen (du findest sie unten): Eine Liste mit den Namen, die andere mit den Geburtsdaten. Beide Listen haben übereinstimmende Reihenfolgen: Der dritte Name in der Namensliste und das dritte Datum in der Geburtsdatumsliste gehören zusammen.
  * Deine Funktion muss also den **Index** (die Position) des gesuchten Namens in der Namensliste finden.
  * Dann muss sie das Datum, das unter diesem Index in der Geburtsdatumsliste steht, zurückgeben.


Folgende Listen für unsere Klassen:
++++ 1Mb|
<code python>
einsmb_namen = ['Abduraman','Lucia','Jannis','Samuel', 
                'Joel','Theodor','Lisa','Catalina', 
                'Josephine','Laura','Maria','Rebaz', 
                'Elena','Emily','Nino','Lea', 
                'Alperen','Thao My']

einsmb_daten = ['22.08.2007','14.08.2007','31.10.2007','05.02.2008',
                '23.05.2008','29.11.2007','14.12.2007','25.12.2007', 
                '22.04.2008','14.06.2008','14.06.2007','25.01.2006', 
                '06.03.2008','30.09.2007','27.01.2008','11.11.2007', 
                '01.03.2008','08.05.2008']
</code>
++++
++++ 1Mc|
<code python>
einsmc_namen = ['Lijana','Arathi','Mats','Edward',
                'Romy','Viola','Julian','Stella',
                'Fabia','Mengia','Noah','Simea',
                'Vivienne','Timotej','Pavithiran','Nuel',
                'Mailo','Selina','Yannic','Sophie']
                
einsmc_daten = ['02.09.2007','04.12.2007','06.10.2008','07.08.2006',
                '03.10.2007','11.09.2007','20.11.2006','13.09.2007',
                '22.07.2007','25.06.2008','28.11.2005','18.10.2007',
                '21.03.2009','18.10.2006','17.04.2008','21.12.2007',
                '29.05.2007','07.07.2007','20.02.2008','02.08.2007']
</code>
++++
\\

=== Woche 23 (2023-03-13) ===
  * Mittwoch: Bespechung der Prüfung: Aufgaben in 2er- oder 3er-Gruppen lösen und vorstellen:
    * 1Mb – Aufgabe 2: Lucia, Janis, Samuel, Josephine, Laura, Nino
    * 1Mb – Aufgabe 4a: Catalina, Rebaz, Elena
    * 1Mb – Aufgabe 4b: Emily, Thao My
    * 1Mb – Aufgabe 5: Joël, Theodor, Alperen
    * 1Mb – Zusatzaufgabe Lotto: Lea, Lisa
    * 1Mc – Aufgabe 2: Lijana, Mats, Romy, Viola, Julian, Fabia
    * 1Mc – Aufgabe 4a: Mengia, Vivienne, Simea, Timo, Pavi, Nuel
    * 1Mc – Aufgabe 4b: Arathi, Stella, Mailo
    * 1Mc – Aufgabe 5: Sophie, Yannic
    * 1Mc - Aufgabe 2, 4: Edward, Noah
    * 1Mc – Zusatzaufgabe Lotto: Selina
  * Freitag: 
    * [[gf_informatik:programmieren_iii|Listen]]: Aufgaben (H4), H5, (H6). 
    * For-Schleifen: Theorie und Aufgaben I1...I3.
  * **Hausaufgaben:** H5...I2 fertigstellen. Screenshot des eigenen Codes zu einer der Aufgaben schicken, am besten zur schwierigsten. Siehe Hinweise oben. Bis kommenden Dienstag.


\\
=== Woche 22 (2023-03-06) ===
  * Mittwoch: **Prüfung über Funktionen**. Am PC mit TigerJython, ohne Hilfsmittel. **Laptop mit vollem Akku / Ladegerät dabei!**
    * Lernziele: 
      * Funktionen (mit und ohne Rückgabewert, mit und ohne Argumente) korrekt definieren und aufrufen können.
      * Den Sinn bzw. Vorteil von Funktionnen verstehen.
      * Einfache Algorithmen in Funktionen verpacken können: Argumente für Eingaben, Rückgabewert für Ausgaben, dazwischen eine (sich wiederholende) Abfolge von Verarbeitungsschritten.
    * Lernressourcen: 
      * Theorie und Aufgaben zu [[gf_informatik:funktionen|Funktionen]] (Ohne Aufgabe GA6).
      * Häufige Missverständnisse oder [[gf_informatik:funktionen:problems|Probleme mit Funktionen]]
      * Repetitionsaufgaben [[gf_informatik::programmieren_repetitionsdossier#grundlagen_ii|Repetitionsaufgaben]] 2.2, 2.3, 2.5, 2.6, 2.7 und 2.8 (mit Liste)
  * Freitag: 
    * Weiter mit [[gf_informatik:programmieren_iii|Listen]]
    * Einführung ''for-Schleife''
    * Aufgaben H3, H4, H5
  * **Hausaufgaben**: 
    * Aufgaben H1 bis H4 fertig.
    * Screenshot des eigenen Codes zu einer der Aufgaben schicken, am besten zur schwierigsten. Siehe Hinweise oben.

\\

=== Woche 21 (2023-02-27) ===
  * Mittwoch: Weiter mit [[gf_informatik:programmieren_iii|Listen]], Vorbereitung für die Prüfung (siehe oben).
  * Freitag: entfällt (Aufnahmeprüfungen). 
  * **Hausaufgaben**: Keine --> Üben für Prüfung.

\\


=== Woche 20 (2023-02-20) ===
  * Mittwoch: [[gf_informatik:funktionen|Funktionen]] mit Algorithmen: Aufgaben GA3, GA4 und evtl. GA5. 
  * Freitag: Einführung in [[gf_informatik:programmieren_iii|Listen]], Aufgabe H1. 
  * **Hausaufgaben**:
    * GA4, GA5 und H1 lösen. Für GA5 max. 20 Minuten investieren.
    * Screenshot des eigenen Codes zu einer der Aufgaben schicken, am besten zur schwierigsten. Siehe Hinweise oben.
    * Freiwillig: GA6 lösen.

\\

=== Woche 19 (2023-02-13) ===
  * Mittwoch: [[gf_informatik:funktionen|Funktionen]] mit und ohne Rückgabewerte: Aufgaben G5...G7. 
  * Freitag: [[gf_informatik:funktionen|Funktionen]] mit Algorithmen: Aufgaben GA1...GA6. 
  * **Hausaufgaben**:
    * Lösung zu Aufgabe GA1 nachvollziehen versuchen. 
    * Bis und mit Aufgabe GA3 lösen.
    * Screenshot des eigenen Codes zu einer der Aufgaben schicken, am besten zur schwierigsten. Siehe Hinweise oben.

\\

=== Woche 18 (2023-02-6) ===
  * Mittwoch: fällt aus.
  * Freitag: Einführung in [[gf_informatik:funktionen|Funktionen]]. 
  * **Hausaufgaben**:
    * Aufgaben G1 bis G5 lösen. 
    * Screenshot von Code zu einer der Aufgaben schicken. Am besten zur schwierigsten.

\\

++++ Herbstsemester 2022-23:|

=== Thymio programmieren in der Semesterschlusswoche (2023-01-25) ===

[[semesterschlusswoche:thymio|Thymio programmieren.]]

\\


=== Woche 17 (2023-01-16) ===
  * Lektion 1: Prüfung besprechen und verbessern, Zusatzaufgaben lösen.
  * Lektion 2: Einführung in [[gf_informatik:funktionen|Funktionen]]. 
\\

=== Woche 16 (2023-01-09) ===
  * Wiederholung, Vertiefung, Prüfungsvorbereitung: Siehe Angaben zur Prüfung unten.
  * Prüfung Programmieren 2.

\\

=== Woche 15 (2022-12-19) ===
  * Wiederholung, Vertiefung, Prüfungsvorbereitung: Siehe Angaben zur Prüfung unten.

\\

=== Prüfung am 11.01.2023 ===
  * **Am PC mit TigerJython und teilweise auf Papier.**
  * **Lernziele:** Du kannst Programmieraufgaben mittels der bekannten Befehle, Funktionen, Verzweigungen und Schleifen lösen. Dazu kannst du:
    * Variablen korrekt verwenden.
    * If-Verzweigungen korrekt verwenden; die strukturellen Unterschiede zwischen if-(elif)-else-Kombinationen verstehen. 
    * Python-Codes als Struktogramme darstellen und ausgehend von Stroktogrammen Python-Codes erstellen. 
    * While-Schleifen korrekt verwenden.
    * Verstehen, wann eine While-Schleife anstelle einer if-Verzweigung sinnvoll ist. 
    * Logischen Operatoren ''and'' und ''or'' korrekt verwenden, um mehrere Bedingungen miteinander zu verknüpfen (in If-Verzweigung oder in While-Schleife). 
    * Funktionen ''input()'' und ''print()'' korrekt verwenden.
    * Formatierte Ausgabe mittels der Funktion ''format()'' korrekt verwenden.
  * **Lernressourcen:**
    * Wiki: [[gf_informatik:programmieren_ii|Von Struktogrammen zu Python]] und [[gf_informatik:programmieren_ii:variablen_verzweigungen_schleifen|Programmieren2]]. Hier sind die [[gf_informatik:programmieren_ii_loesungen|Lösungen zu den Aufgaben D, E und F]].
    * [[gf_informatik:programmieren_ii:Problems|Programmier-Probleme 1 bis 5 ]]
    * {{ :gf_informatik:programmieren_2_gra.pdf |Programmieren2 – Folien}}
  * **Üben, üben, üben:**
    * [[gf_informatik:programmieren_repetitionsdossier|Programmieren Repetitionsdossier]]
      * Informationen am Anfang der Seite lesen!
      * Aufgaben 1.2, 1.3, 1.8, 1.10, 1.11
    * Zusatzaufgaben [[gf_informatik::programmieren_zusatzaufgaben#begruessung|Begrüssung]] und [[gf_informatik::programmieren_zusatzaufgaben#taschenrechner|Taschenrechner]]
      * Auch hier: Keine Musterlösungen. Sende deine Lösungen per Teams an deine Lehrperson, um eine Rückmeldung zu erhalten. Gib in einem Kommentar oberhalb der Aufgabe an, um welche Aufgabe es sich handelt, z.B. # Aufgabe 1.7. Gib weiter an, ob der Code funktioniert, resp. beschreibe den auftretenden Fehler.


\\
=== Woche 14 (2022-12–12) ===
  * Ankündigung: **Prüfung** am 11.01.2023 zu Variablen, Verzweigungen, While-Schleife und Funktionen. Am PC mit TigerJython.
  * Lektion 1:
    * Besprechung Hausaufgaben (E3), F3.
    * Programmieren 2: [[gf_informatik:programmieren_ii:Problems|Programmier-Probleme 1 bis 5 ]]
  * Letkion 2: Programmieren 2: ...
    * Programmieren 2: [[gf_informatik:programmieren_ii:variablen_verzweigungen_schleifen#aufgaben_f|While-Schleife: Aufgaben (F4 und) F5]]
    * [[gf_informatik:programmieren_zusatzaufgaben#taschenrechner|Zusatzaufgabe Taschenrechner]]
  * **Hausaufgaben:** 
    * Bis und mit Aufgaben F5
    * Zusatzaufgabe Taschenrechner (freiwillig).

\\
=== Woche 13 (2022-12–05) ===
  * Lektion 1: Programmieren 2: [[gf_informatik:programmieren_ii:variablen_verzweigungen_schleifen#logikif-else|Verzweigungen, Vergleichsoperatoren]].
  * Letkion 2: Programmieren 2: [[gf_informatik:programmieren_ii:variablen_verzweigungen_schleifen#while-schleife|While-Schleife]]
  * **Hausaufgaben:** Aufgaben E1...E3 und F1...F3 lösen. Freiwillig: F4 und F5.

\\

=== Woche 12 (2022-11-28) ===
  * Lektion 1: Programmieren 2: [[gf_informatik:programmieren_ii:variablen_verzweigungen_schleifen|Variablen und Mathematik]].
  * Letkion 2: Programmieren 2: [[gf_informatik:programmieren_ii:variablen_verzweigungen_schleifen#aufgaben_d|Aufgaben D1...D5]] und [[gf_informatik:programmieren_zusatzaufgaben#begruessung|Zusatzaufgabe "Begrüssung"]] lösen.
  * **Hausaufgaben:** [[gf_informatik:programmieren_ii:variablen_verzweigungen_schleifen#aufgaben_d|Aufgaben D1...D5]] und [[gf_informatik:programmieren_zusatzaufgaben#begruessung|Zusatzaufgabe "Begrüssung"]] lösen.

\\
=== Woche 11 (2022-11-21) ===
  * Lektion 1: Prüfung
  * Letkion 2: Besprechung Prüfung und Einführung [[gf_informatik:programmieren_ii|Programmieren 2]].

  * **Hausaufgaben:** Schreibe folgende beiden Algorithmen in python (mit TigerJython) und teste sie. Siehe [[gf_informatik:programmieren_ii|Wiki]] für Hilfe.

{{:gf_informatik:pasted:20221123-070213.png?160|}}
{{:gf_informatik:pasted:20221123-070332.png?400|}}

\\

=== Prüfung am 16.11.2022 ===
Prüfung auf Papier. Kugelschreiber, Taschenrechner, Lineal und evtl. farbige Stifte mitnehmen. Als Lernressource dient das Wiki. Die Lernziele sind:
  * TurtleGraphics: 
    * Einfache Turtle-Programme schreiben,
    * vorgegebene Grafiken nachzeichnen und
    * repeat verwenden können.
  * Algorithmen:
    * Merkmale von Algorithmenn nennen (siehe Definition), 
    * Verschiedene Darstellungformen für Algorithmen (Flussdiagramm, Text, Struktogramm) beherrschen; von einer Darstellungsform in eine andere übersetzen können.
    * Die drei Elemente-Arten von Struktogrammen (Befehl, Schleife, Verzweigung) richtig verwenden können.
    * Verstehen, was eine Variable ist und wie Variablen verwendet werden. 
    * Zuweisungsoperator ''='' und Vergleichsoperator ''=='' voneinander unterscheiden können.
    * Notation für die Ein- und Ausgabe von Werten (z.B. ''x = [Eingabe]\(Zahl)'' oder ''Ausgabe x'') richtig verwenden. 
    * Die Funktion eines Algorithmus (mittels Evaluation) herausfinden und beschreiben können.
    * Aufgrund einer vorgegeben Funktion einfache Algorthmen in From von Struktogrammen erstellen können.

{{ :gf_informatik:algorithmen_1_gra.pdf | Folien Algorithmen}} 

\\
=== Woche 9 (2022-11-07) ===
  * Lektion 1: 
    * Algorithmen: Besprechung Aufgaben C. 
    * Vorbereitung Informatik-Biber mit [[https://www.informatik-biber.ch/documents/2021/Informatik-Biber-2021-Schuljahre9-10-mitLoesungen.pdf|Aufgaben und Lösungen 2021]]
  * Lektion 2: Informatik-Biber: [[https://wettbewerb.informatik-biber.ch/index.php?action=login|zum Login]].

== Hausaufgaben auf nächste Woche ==
  * Aufgabe C2-iii lösen. 
  * Auf die Prüfung lernen! Siehe Lernziele oben unter "Infos".

\\

=== Woche 8 (2022-10-31) ===
  * Lektion 1: [[gf_informatik:algorithmen_i#eingabe_und_ausgabe_in_struktogrammen|Algorithmen 1 – Ein- und Ausgabe]].
  * Lektion 2: [[gf_informatik:algorithmen_i#eingabe_und_ausgabe_in_struktogrammen|Algorithmen 1 – Ein- und Ausgabe]].

== Hausaufgaben auf nächste Woche ==
  * Bis und mit C2-ii lösen. Struktogramme und Evaluationstabellen präsentieren können.

\\
=== Woche 7 (2022-10-24) ===
  * Lektion 1: [[gf_informatik:algorithmen_i|Algorithmen 1 – Einführung]].
  * Lektion 2: [[gf_informatik:algorithmen_i#struktogramme|Algorithmen 1 – Struktogramme]].

== Hausaufgaben auf nächste Woche ==
  * [[gf_informatik:algorithmen_i#aufgaben_b|Aufgaben B]] lösen: Bis und mit B3-2.

\\

=== Woche 6 (2022-09-26) ===
  * Lektion 1: [[gf_informatik:programmieren_i#kreisbogen|Kreisbogen mit TurtleGraphics]].
  * Lektion 2: [[gf_informatik:programmieren_i##farben_optional|Farben mit TurtleGraphics]].

== Hausaufgaben auf nächste Woche ==
  * Keine. -> Schöne Herbstferien.

\\


=== Woche 5 (2022-09-19) ===
  * Lektion 1: Besprechung der Prüfung. [[gf_informatik:programmieren_i|Programmieren mit TurtleGraphics]].
  * Lektion 2: Weiter mit TurtleGraphics.

== Hausaufgaben auf nächste Woche ==
  * Löse Aufgaben A1...A4.

\\

   
=== Prüfung am 14.09.2022 ===
Prüfung auf Papier; Kugelschreiber, Taschenrechner und evtl. farbige Stifte mitnehmen. Als Lernressourcen dienen das Wiki und das selbst erstellte Blockschaltbild vom eigenen PC. Die Lernziele sind:
  * Ein Blockschaltbild vom Innern des eigenen Laptops zeichnen können – inklusive:
    * der Bauteile auf dem Mainboard (wie CPU, RAM, SSD etc.), 
    * der Anschlüsse/Schnittstellen (wie USB-C, WLAN, HDMI etc.), 
    * der Ein- und Ausgabegeräte und
    * der richtigen Verbindungen in richtiger Dicke und Pfeilrichtung.
  * Die Bauteile eines Computers sowie die Anschlüsse/Schnittstellen an ihrem Aussehen erkennen und korrekt benennen können.
  * Für die wichtigsten Anschlüsse/Schnittstellen (USB/USB-C; HDMI/(Mini-)Display-Port; Ethernet/WLAN; Bluetooth; Audio) ein mögliches Gerät nennen können, das über die jeweilige Schnittstelle mit dem Computer verbunden wird.
  * Die Funktionen der wichtigsten Bauteile in einem Computer (CPU, Arbeits- und Festspeicher, Southbridge, Mainboard) beschreiben können.
  * Erklären können, was neben passenden Steckern und Kabel nötig ist, damit die Datenübertragung über eine Schnittstelle funktioniert.
  * Mehrere Unterschiede zwischen verschiedenen Speicherarten nennen können. Also zwischen Arbeits- und Festspeicher, aber auch zwischen den Festspeichertypen SSD und HDD.
  * Mit Speicher- und Dateigrössen rechnen können, also:
    * wissen, wie viele Bits ein Byte hat und 
    * wie viele Bytes in einem Kilo-, Mega-, Giga- oder Terabyte sind.
  * Die typischen Speichergrössen von Arbeits- und Festspeichern in heutigen Laptops kennen.
    * Arbeitsspeicher: 4...16 GB
    * Festspeicher: 256 GB bis 2 TB
\\

=== Woche 4 (2022-09-12) ===

  * Lektion 1: Blockschaltbilder besprechen, Mit Speichern rechnen, Prüfungsvorbereitung.
  * Lektion 2: Prüfung.

== Aufträge im Unterricht ==

  - Rechnen mit Speichergrössen: Beantworte folgende Fragen: Dazu musst du jeweils heraufinden, wie viel Speicherplatz die einzelnen Dateien benötigen und dann rechnen:
    - Wie viele leere Worddokumente benötigen gleich viel Platz wie ein Foto, das mit der Kamera deines Smartphones aufgenommen wurde?
    - Wie viele solche Fotos (von der Smartphone-Kamera) haben in deinem Arbeitsspeicher (RAM) Platz?
    - Wie viele solche Fotos (von der Smartphone-Kamera) haben in deinem Festspeicher (SSD) Platz?
    - Wie viele Netflix-Filme à 4 GB haben auf deinem Festspeicher Platz?

== Keine Hausaufgaben auf nächste Woche. ==


\\
=== Woche 3 (2022-09-05) ===
  * Lektion 1:
    * Anschlüsse/Schnittstellen, Bauteile eines PCs.

== Aufträge im Unterricht ==
  - Stelle Auftrag 1 von letzter Woche (Das Blockschaltbild deines Computers) fertig. Du solltest dein Blockschaltbild kommende Woche der Klasse präsentieren können.

== Hausaufgaben auf nächste Woche ==
  - Blockschaltbild fertigstellen. Du solltest dein Blockschaltbild kommende Woche der Klasse präsentieren können.
  - Prüfungsvorbereitung, siehe Lernziele oben.

\\ 


=== Woche 2 (2022-08-29) ===
  * Lektion 1:
    * Computer-Hardware: Im Innern eines PCs.
  * Lektion 2:
    * Computer-Hardware: Bauteile eines PCs.

\\
== Aufträge im Unterricht ==
  - Zeichne ein Blockschaltbild vom inneren Aufbau **deines Laptops**. Als Vorbild dient dir [[gf_informatik:hardware_ia#entwicklungsschritt_1northbridge_faellt_weg|dieses Bild vom inneren Aufbau in neueren Computern]] (Oder das darunter, falls du ein Tablet oder einen neueren Apple-Laptop hast).
    - Informiere dich zuerst über die wichtigsten Bauteile in deinem Laptop. Diese Infos findest du unter "System" (Windows) oder unter "Über diesen Mac" (Mac OSX). Einzelne Infos musst evtl. im Internet recherchieren. 
      - Prozessor (CPU): Name (zum Beispiel "Intel I5")? Taktrate (in GHz)? Anzahl CPU- und evtl GPU-Kerne?
      - Arbeitsspeicher (RAM) und Festspeicher (SSD): Wie gross (in GB)?
      - Evlt. Infos zur GPU/Grafikkarte (falls vorhanden).
      - Anschlüsse: Schaue dir die Seiten des Laptops an und finde für jeden Anschluss heraus, wie er heisst und wozu er da ist (was du daran anschliessen könntest).
      - Display: Wie gross ist die Auflösung (in Pixel Breite mal Länge).
    - Jetzt erstellst du ein schönes, möglichst grosses Blockschaltbild, das genügend Raum lässt, damit du die zusammengesuchten Infos zu den Blöcken hinschreiben kannst. Zeichne auch die Eingangsgeräte (Tastatur, Touchpad, Stift, Kamera) und Ausgangsgeräte (Display, Lautsprecher) ein.
    - Schreibe zu jeder Komponente auf dem Mainboard kurz in eigenen Worten, welche Funktion sie hat.
  - Lese den Abschnitt [[gf_informatik:hardware_ia#anschluesse_schnittstellen|Anschlüsse / Schnittstellen]] für dich und tausche dich danach mit deiner Nachbar:in aus: Prüft, ob ihr es gleich veranden habt; fragt nach, wenn ihr unsicher seid. Und Überlegt:
    - Welche Anschlüsse/Schnittstellen befinden sich an und in euren Laptops?
    - Welches ist die Schnittstelle, die ihr am häufigsten benutzt? Und am zweithäufgisten?
\\
== Hausaufgaben auf nächste Woche ==
  - Unten ist ein Bild eines Mainboards verlinkt: Lade das Bild herunter und Beschrifte die Bauteile 1 bis 8.
  - Unten ist das Bild eines geöffneten Desktop-PCs verlinkt:
    - Lade das Bild herunter und Beschrifte die Bauteile 1 bis 6 und...
    - ...ordne die Bauteile 1 bis 6 den Orten A bis E zu (an einen Ort kommen zwei Bauteile hin).

{{:gf_informatik:gfif_hardware_puzzle-mainboard.png?linkonly| Mainboard}}

{{:gf_informatik:gfif_hardware_puzzle-pc.png?linkonly| Desktop-PC}}

<nodisp1>
++++Lösung:|

{{:gf_informatik:gfif_hardware_puzzle-mainboard_solution.png?400|}}

{{:gf_informatik:gfif_hardware_puzzle-pc_solution2.png?400|}}

++++
</nodisp>
\\
=== Woche 1 (2022-08-22) ===
  * Lektion 1:
    * Einführung in den Informatik-Unterricht.
    * Umfrage Informatikkenntnisse.
    * Computer-Hardware: Was ist ein Computer?
  * Lektion 2:
    * Computer-Hardware: Von-Neumann-Architektur. 
    * Computer-Hardware: Im Innern eines PCs.

== Aufträge im Unterricht ==
  - Im Wiki siehst du ein Bild von der Von-Neumann-Architektur. Auch dein Smartphone ist ein Computer, der nach dieser Archtiektur aufgebaut ist. 
    - Liste Bauteile auf, die sich in oder an deinem Smartphone befinden. Du kannst natürlich nicht hineinblicken, aber überlegen: Was mache ich alles mit meinem Smartphone? Was für Bauteile müssen wohl vorhanden sein, damit das funktioniert. Deine Liste muss weder vollständig noch richtig sein: Liste auf, was dir in den Sinn kommt.
    - Zeichne eine schematische Darstellung deines Smartphones nach der Von-Neumann-Architektur: In der Mitte ein Rechteck/Quadrat für die CPU; dann links davon zeichnest du Bauteile, die zur Eingabe von Daten dienen und rechts von der CPU alle Bauteile, die zur Ausgabe von Daten dienen. Bauteile, die in beide Richtungen Daten mit der CPU austauschen, kannst du oberhalb oder unterhalb der CPU aufmalen. Alle Bauteile kannst du als Rechtecke oder Kreise malen. Deine Zeichnung muss nicht besonders genau oder richtig sein – sie sollte aber möglichst viele Bauteile enthalten.

\\

== Hausaufgaben auf nächste Woche ==
  - Zeichne ein Blockschaltbild((Also eine schematische Darstellung aus Blöcken (Rechtecken) und Linien, die sie verbinden.)) vom Innern eines PCs **von Hand**. Dieses Bild soll ähnlich dem sein, dass du auf dem Wiki findest. **Zeichne es aber nicht einfach ab**, sondern versuche, möglichst viel "aus dem Kopf" zu zeichnen. Dazu gehst du so vor:
    - Schau dir das Bild auf dem Wiki gut an: Beachte die einzelnen Blöcken, wie sie zusammenhängen und überlege, warum sie wohl so zusammenhängen.
    - Jetzt schliesst du die Wikiseite mit dem Bild.
    - Nimm ein (digitales) weisses Blatt Papier und beginne mittels folgender Hinweise zu zeichnen:
      - In der Mitte (eher oben) liegt die CPU.
      - Von der Unterkante der CPU gehts über den sehr breiten Front Side Bus zur Northbridge.
      - Wiederum unterhalb der Northbridge liegt die Southbridge. Die beiden Brücken verbindet ein mittelbreiter Bus. 
      - An die Northbridge sind über mittelbreite Busse datenintensive Module/Schnittstellen angeschlossen: RAM und GPU/Grafikgeräte.
      - An die Southbridge sind über weniger breite Busse wengier datenintensive Module (Tastatur, Maus) und Schnittstellen (USB-, LAN-, Audio-Inputs/Outputs, WLAN etc.) angeschlossen.
  - Sende ein Bild/Foto deiner Zeichnung via Teams an die Lehrperson. Erlaubte Formate: PNG, PDF, JPG.

++++