Glanz: aiMOOC über GPT aiMOOC Action erstellt

2026-09-01T05:10:41Z

aiMOOC über GPT aiMOOC Action erstellt

Neue Seite

{{T}}
[[Category:English]]
[[Category:Programming with Python]]

{{BR}}
= Introduction =

'''Programming with Python''' is a university-level aiMOOC about computational thinking, software construction, and problem solving with [[English:Python (programming language)|Python]]. You will learn to design algorithms, express them in readable Python, select suitable data structures, build reusable functions, work with files and modules, test programs, and justify design decisions.

Python is used in education, science, data analysis, automation, web development, and artificial intelligence. Its readable syntax makes it well suited to learning core ideas such as state, control flow, abstraction, data structures, modularity, and testing.

[[File:Python-logo-notext.svg|500px|frameless|center]]

Python was created by [[English:Guido van Rossum|Guido van Rossum]] and is developed by an international community. Language changes are discussed through [[English:Python Enhancement Proposal|Python Enhancement Proposals]].

[[File:Guido van Rossum 2006.jpg|500px|frameless|center]]

{{#ev:youtube|https://www.youtube.com/watch?v=xAcTmDO6NTI|500|center}}

{{BR}}
== Learning Goals ==

By the end of the course, you should be able to write and explain Python programs, use conditionals and loops, define functions, work with lists, tuples, sets, and dictionaries, organize code into modules, read and write files, use classes when appropriate, create automated tests, and improve code for clarity and maintainability.

{{BR}}
= Working Environment and First Programs =

You can use Python interactively, run scripts from a terminal, or work in an integrated development environment. [[English:Jupyter Notebook|Jupyter notebooks]] are common in universities because they combine executable code, explanation, equations, and output in one document.

[[File:Jupyter Notebook.png|500px|frameless|center]]

<syntaxhighlight lang="python">
course = "Programming with Python"
students = 24
message = f"{course}: {students} students"
print(message)
</syntaxhighlight>

A variable name refers to a Python object. Assignment binds a name to a value. Common built-in types include <code>int</code>, <code>float</code>, <code>bool</code>, and <code>str</code>.

{{#ev:youtube|https://www.youtube.com/watch?v=JP7ITIXGpHk|500|center}}

{{BR}}
= Expressions and Decisions =

Expressions produce values. Arithmetic operators include <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>//</code>, and <code>%</code>. The built-in <code>pow</code> function performs exponentiation. Comparison operators produce Boolean values.

<syntaxhighlight lang="python">
temperature = 21.5
is_warm = temperature >= 20.0
print(is_warm)
</syntaxhighlight>

An <code>if</code> statement selects a branch according to a condition.

<syntaxhighlight lang="python">
score = 78

if score >= 90:
grade = "excellent"
elif score >= 60:
grade = "pass"
else:
grade = "revise"

print(grade)
</syntaxhighlight>

{{BR}}
= Loops and Iteration =

A <code>for</code> loop visits items from an iterable. A <code>while</code> loop repeats while a condition remains true. Use the construct that makes the stopping rule easiest to understand.

<syntaxhighlight lang="python">
values = [12, 7, 19, 4]
total = 0

for value in values:
total += value

print(total)
</syntaxhighlight>

[[File:Python Turtle Graphics example.png|500px|frameless|center]]

Turtle graphics can make iteration visible because repeated commands create geometric patterns.

{{#ev:youtube|https://www.youtube.com/watch?v=_b6NgY_pMdw|500|center}}

{{#ev:youtube|https://www.youtube.com/watch?v=-7xg8pGcP6w|500|center}}

{{BR}}
= Functions and Abstraction =

A function groups behavior behind a name and a clear interface. Parameters describe input to the function, while a return value communicates a result to the caller.

<syntaxhighlight lang="python">
def mean(values):
return sum(values) / len(values)

sample = [4.0, 7.5, 9.5]
print(mean(sample))
</syntaxhighlight>

Good functions usually have one coherent responsibility. Their names should communicate intent, and their interfaces should make them easy to test and reuse.

{{BR}}
== Scope and Arguments ==

Names created inside a function are normally local to that function. Arguments can be passed positionally or by keyword. Default parameter values can make interfaces convenient when the meaning remains clear.

<syntaxhighlight lang="python">
def format_measurement(value, unit="m", precision=2):
return f"{value:.{precision}f} {unit}"

print(format_measurement(3.14159))
print(format_measurement(3.14159, unit="cm", precision=1))
</syntaxhighlight>

{{BR}}
= Data Structures =

Choosing a data structure is a design decision. A list is an ordered mutable sequence. A tuple is an ordered sequence often used for fixed groups of values. A set stores unique elements. A dictionary maps keys to values.

<syntaxhighlight lang="python">
student = {
"name": "Amina",
"program": "Computer Science",
"credits": 72
}

modules = ["Algorithms", "Databases", "Statistics"]
skills = {"Python", "Git", "Testing"}

student["credits"] += 6
modules.append("Software Engineering")
skills.add("Documentation")
</syntaxhighlight>

Comprehensions are useful for concise transformations when the result remains readable.

<syntaxhighlight lang="python">
squares = [pow(n, 2) for n in range(10)]
even_squares = [value for value in squares if value % 2 == 0]
</syntaxhighlight>

{{BR}}
= Robust Programs and Exceptions =

Programs should anticipate unusual input and external conditions. Python uses exceptions to signal that normal execution cannot continue in the expected way. You should validate assumptions, keep recovery logic focused, and avoid hiding unexpected situations.

A simple input check can prevent unsuitable values from reaching later calculations:

<syntaxhighlight lang="python">
def is_positive_integer(text):
return text.isdigit() and int(text) > 0

print(is_positive_integer("12"))
print(is_positive_integer("-4"))
</syntaxhighlight>

In larger programs, targeted <code>try</code> and <code>except</code> blocks can be used around operations that may fail for known reasons. The goal is to respond deliberately rather than ignore problems.

{{#ev:youtube|https://www.youtube.com/watch?v=LW7g1169v7w|500|center}}

{{BR}}
= Files and Structured Data =

Programs often exchange information through files. A context manager created with <code>with</code> ensures that a file is closed after use.

<syntaxhighlight lang="python">
from pathlib import Path

path = Path("results.txt")

with path.open("w", encoding="utf-8") as file:
file.write("experiment,score\n")
file.write("alpha,0.82\n")
</syntaxhighlight>

Formats such as CSV and JSON are useful when data needs to be exchanged with other tools.

{{#ev:youtube|https://www.youtube.com/watch?v=KD-Yoel6EVQ|500|center}}

{{BR}}
= Modules, Packages, and Environments =

A module is a Python file that defines reusable code. A package organizes related modules. Imports let you reuse tested components instead of duplicating them.

<syntaxhighlight lang="python">
from statistics import mean, median

values = [2, 3, 5, 8, 13]
print(mean(values))
print(median(values))
</syntaxhighlight>

Third-party packages extend Python. For university projects, use an isolated virtual environment and record project dependencies so that others can reproduce the setup.

<syntaxhighlight lang="text">
python -m venv .venv
python -m pip install package_name
</syntaxhighlight>

{{#ev:youtube|https://www.youtube.com/watch?v=MztLZWibctI|500|center}}

{{BR}}
= Object-Oriented Programming =

A class defines a type, and an instance is a concrete object of that type. Attributes hold state, while methods implement behavior.

<syntaxhighlight lang="python">
class Counter:
def __init__(self, start=0):
self.value = start

def increment(self, step=1):
self.value += step

counter = Counter(10)
counter.increment(3)
print(counter.value)
</syntaxhighlight>

Classes are useful when a problem contains entities with persistent state and related operations. They are not automatically better than functions. Choose the simplest design that models the problem clearly.

{{#ev:youtube|https://www.youtube.com/watch?v=e4fwY9ZsxPw|500|center}}

{{BR}}
= Testing, Debugging, and Code Quality =

Automated tests give evidence that a program behaves as intended for selected cases. Unit tests focus on small units such as functions or methods. Good tests include normal cases and boundary cases.

<syntaxhighlight lang="python">
import unittest

def clamp(value, lower, upper):
return max(lower, min(value, upper))

class ClampTests(unittest.TestCase):
def test_inside_range(self):
self.assertEqual(clamp(5, 0, 10), 5)

def test_above_range(self):
self.assertEqual(clamp(15, 0, 10), 10)
</syntaxhighlight>

Debugging is a process of forming and testing hypotheses about why observed behavior differs from intended behavior. Useful techniques include reproducing a problem with a small example, inspecting values, stepping through code, and adding a regression test after a fix.

[[English:PEP 8|PEP 8]] provides widely used style guidance for Python code. Meaningful names, focused functions, useful documentation, and consistent formatting improve maintainability.

{{#ev:youtube|https://www.youtube.com/watch?v=tIrcxwLqzjQ|500|center}}

{{BR}}
= Python for Data and Scientific Work =

Python has a large ecosystem for scientific and data work. Libraries such as [[English:NumPy|NumPy]], [[English:Pandas|pandas]], [[English:Matplotlib|Matplotlib]], and [[English:SciPy|SciPy]] support numerical arrays, tabular data, visualization, and scientific methods.

[[File:Matplotlib basic v.svg|500px|frameless|center]]

When you visualize data, select a chart type that matches the question. A line plot can show change across an ordered dimension, a scatter plot can show relationships between numerical variables, and a histogram can show a distribution.

{{BR}}
= Performance and Computational Thinking =

Correctness comes before optimization. When performance matters, measure where time or memory is being spent. Algorithm and data-structure choices often matter more than small syntax changes.

Generators and iterators can process values one at a time instead of constructing every result in memory.

<syntaxhighlight lang="python">
def positive_measurements(values):
for value in values:
if value > 0:
yield value

for measurement in positive_measurements([3, -1, 4, 0, 5]):
print(measurement)
</syntaxhighlight>

{{BR}}
= Version Control and Responsible Practice =

Use [[English:Version control|version control]] such as [[English:Git|Git]] to record changes, collaborate, and review contributions. Write commit messages that explain intent and keep credentials out of repositories.

Responsible programming includes respecting software licenses, protecting sensitive data, documenting limitations, checking outputs, and evaluating third-party dependencies before relying on them.

{{BR}}
= Interactive Tasks =

{{BR}}
== Quiz: Test Your Knowledge ==

{{MC}}

'''Which built-in data structure maps unique keys to values?'''
(Dictionary)
(!List)
(!Tuple)
(!String)

{{E}}
<br>

{{MC}}

'''What is the main purpose of a function return statement?'''
(To send a result back to the caller)
(!To import a package)
(!To start a class definition)
(!To install software)

{{E}}
<br>

{{MC}}

'''Which statement selects between alternative branches?'''
(if)
(!import)
(!yield)
(!pass)

{{E}}
<br>

{{MC}}

'''What does a for loop normally do?'''
(Iterates over items from an iterable)
(!Creates a package)
(!Defines a class automatically)
(!Installs a dependency)

{{E}}
<br>

{{MC}}

'''Why is a virtual environment useful?'''
(It isolates project dependencies)
(!It encrypts source code)
(!It replaces all tests)
(!It creates documentation automatically)

{{E}}
<br>

{{MC}}

'''Which structure is designed to store unique elements?'''
(Set)
(!String)
(!Float)
(!Boolean)

{{E}}
<br>

{{MC}}

'''What does a unit test primarily examine?'''
(A small unit of program behavior)
(!Only the graphical interface)
(!Only the operating system)
(!Only network speed)

{{E}}
<br>

{{MC}}

'''What is an instance in object-oriented Python?'''
(A concrete object created from a class)
(!A package index)
(!A Git branch)
(!A source file extension)

{{E}}
<br>

{{MC}}

'''What should you usually do before optimizing code for speed?'''
(Measure where the real bottleneck is)
(!Remove tests)
(!Replace every function with a class)
(!Rewrite every loop recursively)

{{E}}
<br>

{{MC}}

'''Which practice improves maintainability?'''
(Using clear names and focused functions)
(!Duplicating code across files)
(!Hiding project dependencies)
(!Avoiding documentation)

{{E}}
<br>

{{BR}}
== Memory Game ==

<div class="memo-quiz">
{|
|-
| List || Mutable ordered sequence
|-
| Tuple || Ordered sequence commonly used for fixed groups
|-
| Dictionary || Mapping from keys to values
|-
| Set || Collection of unique elements
|-
| Function || Reusable unit of behavior with an interface
|-
| Class || Definition used to create objects
|}
{{E}}
<br>

{{BR}}
== Drag and Drop ==

<div class="lueckentext-quiz">

{| class="wikitable"
! Match the correct terms.
! Topic
|-
| '''Conditional branching'''
| if statement
|-
| '''Iteration over items'''
| for loop
|-
| '''Reusable behavior'''
| function
|-
| '''Key-value storage'''
| dictionary
|-
| '''Automated verification'''
| unit test
|}
{{E}}

<br>
...
<br />

{{BR}}
== Crossword Puzzle ==

<div class="kreuzwort-quiz">
{|
|-
| Iteration || What process repeats operations over successive items?
|-
| Dictionary || Which mapping structure stores values under keys?
|-
| Function || What reusable block of behavior can receive arguments?
|-
| Inheritance || What mechanism derives one class from another?
|-
| Generator || What construct can yield values lazily one at a time?
|-
| Debugging || What process investigates incorrect program behavior?
|}
{{E}}
<br>

{{BR}}
== LearningApps ==

<iframe> https://learningapps.org/index.php?s=Programming+with+Python </iframe>

{{BR}}
== Cloze Text ==

<quiz display=simple>
{'''Complete the text.'''<br>
|type="{}"}
Python uses { indentation } to mark suites of statements in blocks. A function sends a result to its caller with { return }. A mapping from keys to values is called a { dictionary }. A loop processes a sequence of items through { iteration }. Project dependencies can be isolated inside a { virtual environment }. Automated checks of small program units are called { unit tests }. A class is used to create concrete objects called { instances }.
</quiz>

<br>

{{BR}}
= Open-Ended Tasks =

{{BR}}
=== Easy ===
# [[English:Python Code Reading|Python Code Reading]]: Choose a short Python program, annotate each line in plain English, and explain how data changes while the program runs.
# [[English:Small Automation Script|Small Automation Script]]: Write a script that automates a simple study task such as converting units or summarizing a list of values.
# [[English:Algorithm Poster|Algorithm Poster]]: Create an image or poster that compares sequence, selection, and iteration and add one Python example for each.
# [[English:Peer Interview on Programming|Peer Interview on Programming]]: Interview another student about one programming difficulty and write a short reflection on possible strategies.

{{BR}}
=== Standard ===
# [[English:Data Analysis Mini Project|Data Analysis Mini Project]]: Obtain a small open dataset, clean it with Python, compute meaningful summaries, create one visualization, and explain the result.
# [[English:Testing Laboratory|Testing Laboratory]]: Design a function, create tests for normal and boundary cases, then alter the function and observe which tests detect the change.
# [[English:Python Tutorial Video|Python Tutorial Video]]: Produce a short instructional video that teaches one Python concept through a worked example.
# [[English:Code Review Workshop|Code Review Workshop]]: Exchange a program with a peer, review naming, decomposition, documentation, and tests, then revise your own program.

{{BR}}
=== Advanced ===
# [[English:Reproducible Research Workflow|Reproducible Research Workflow]]: Build a small research workflow that reads data, performs an analysis, creates a figure, records dependencies, and can be rerun from a clean environment.
# [[English:Software Architecture Comparison|Software Architecture Comparison]]: Solve the same problem once with functions and once with classes, then compare extensibility, clarity, and testing effort.
# [[English:Performance Experiment|Performance Experiment]]: Form a hypothesis about two data structures or algorithms, design a controlled timing experiment, visualize the measurements, and discuss limitations.
# [[English:Open Source Field Study|Open Source Field Study]]: Visit a public Python repository, study its issues, tests, documentation, and contribution guide, then write an evidence-based report on collaboration practices.

{{:Open Task - Create a MOOC}}

{{BR}}
= Learning Assessment =

# [[English:Program Design Assessment|Program Design Assessment]]: Decompose a real-world problem into functions, choose suitable data structures, implement the solution, and justify your design decisions.
# [[English:Debugging Assessment|Debugging Assessment]]: Analyze a faulty program, reproduce the unwanted behavior, repair it, and add a test that demonstrates the intended result.
# [[English:Data Structure Transfer|Data Structure Transfer]]: Compare two possible representations for the same dataset and explain how each choice changes readability, operations, and performance.
# [[English:Reproducibility Assessment|Reproducibility Assessment]]: Package a small project with clear setup instructions and isolated dependencies so that another student can run it from a clean environment.
# [[English:Object Model Assessment|Object Model Assessment]]: Design a class-based model for a small domain, identify important state and methods, and explain where composition is preferable to inheritance.
# [[English:Critical Code Review|Critical Code Review]]: Review an unfamiliar Python program for correctness, test quality, style, documentation, and maintainability, then prioritize improvements.

<br>
<br>

{{BR}}
= Evidence of Learning =

Evidence of learning includes working Python programs, accurate explanations of control flow and data structures, functions with clear interfaces, appropriate use of modules and files, automated tests, reproducible environments, readable code, reasoned design decisions, visual or written communication of results, and transfer of programming concepts to unfamiliar problems.

Strong evidence also includes your ability to explain trade-offs. You should be able to justify why a data structure, algorithm, interface, testing strategy, or object model was chosen and identify limitations in your solution.

<br>
<br>

{{BR}}
= OERs on the Topic =

The official Python tutorial and standard-library documentation provide authoritative reference material. The Python Packaging User Guide explains virtual environments and packaging. MIT OpenCourseWare and Harvard CS50P provide university-level programming instruction. [[English:PEP 8|PEP 8]] offers widely used style guidance.

<iframe> https://en.m.wikipedia.org/wiki/Python_(programming_language) </iframe>

<br>

{{BR}}
= Linked Learning Areas =

{| align=center
{{:D-Tab}}
'''[[English:Programming with Python|Programming with Python]]'''
# [[English:Python syntax and semantics|Python syntax and semantics]]
# [[English:Control flow|Control flow]]
# [[English:Data structures|Data structures]]
# [[English:Function|Function]]
# [[English:Object-oriented programming|Object-oriented programming]]
# [[English:Software testing|Software testing]]
# [[English:Data science|Data science]]
# [[English:Version control|Version control]]
|}

Programming with Python connects with [[English:Computer science|Computer science]], [[English:Software engineering|Software engineering]], [[English:Algorithms|Algorithms]], [[English:Data science|Data science]], [[English:Artificial intelligence|Artificial intelligence]], [[English:Scientific computing|Scientific computing]], [[English:Statistics|Statistics]], [[English:Cybersecurity|Cybersecurity]], [[English:Web development|Web development]], [[English:Automation|Automation]], and [[English:Reproducible research|Reproducible research]].

{{BR}}
= aiMOOC Projects =
[[Category:English]]
[[Category:Programming with Python]]
[[Category:Higher Education]]
[[Category:Computer Science]]
[[Category:Programming]]
[[Category:Python]]
[[Category:Software Engineering]]
[[Category:Data Science]]
[[Category:AI_MOOC]]
[[Category:GPT aiMOOC]]
{{MT}}

English:Programming with Python - Versionsgeschichte

Glanz: aiMOOC über GPT aiMOOC Action erstellt