Programmierkonzepte

from random import randint

sum = 0
z = 100000
repeat z:
    n = randint(0, 15)
    if n != 15:
        q = n + 1 # number of questions
    else:
       q = 15
    sum += q   
print("Mean:", sum / z)

Wie du leicht überlegen kannst, beträgt die Information bei W = 32 Zahlen I = 5 bit und bei W = 64 Zahlen I = 6 bit. Es gilt also offenbar 2^I = W oder I = ld(W). Es braucht sich auch nicht um eine Zahl zu handeln, nach der man sucht, sondern es kann sich um irgend einen Zustand handeln, den man aus W (gleichwahrscheinlichen) Zuständen herausfinden muss.

Unter der Information bei Kenntnis eines Zustands aus W gleichwahrscheinlichen Zuständen versteht man

I = ld(W) (ld ist der Logarithmus dualis, Logarithmus zur Basis 2)

from math import log

f = open("letterfreq_de.txt")
s = "{"
for line in f:
    line = line[:-1] # remove trailing \n
    s += line + ", "
f.close()
s = s[:-2]  # remove trailing ,
s += "}"
occurance = eval(s)

while True:
    word = inputString("Enter a word")
    I = 0
    for letter in word.upper():
        p = occurance[letter] / 100
        I -= log(p, 2)
    print(word, "-> I =", round(I, 2), "bit")

Die Daten sind in den Textdateien zeilenweise im Format 'Buchstabe' : Prozentzahl abgespeichert. Als Python-Datenstruktur ist ein Dictionary gut geeignet. Um die Dateiinformation in ein Dictionary umzuwandeln, werden die Zeilen eingelesen und in einen String im üblichen Dictionary-Format {key : value, key : value,...} gepackt. Mit eval() wird dieser String als Programmzeile interpretiert und ein Dictionary erstellt.

Wie du mit deinem Programm herausfinden kannst, ist der Informationsgehalt für Wörter mit seltenen Buchstaben grösser. Der so bestimmte Informationsgehalt hat allerdings nichts damit zu tun, wie wichtig ein bestimmtes Wort in einem bestimmten Zusammenhang für dich sein kann, ob also die Information, die mit diesem Wort verbunden ist, für dich persönlich belanglos oder von entscheidender Bedeutung ist. Ein Mass dafür zu bestimmen liegt weit ausserhalb der Möglichkeiten von heutigen Informationssystemen.

from gamegrid import *
from gpanel import *
from math import log

# =================== class Particle ====================
class Particle(Actor):
    def __init__(self):
        Actor.__init__(self, "sprites/ball_0.gif")
 
    # Called when actor is added to gamegrid
    def reset(self):
        self.isLeft = True
  
    def advance(self, distance):
        pt = self.gameGrid.toPoint(self.getNextMoveLocation())
        dir = self.getDirection()
        # Left/right wall
        if pt.x < 0 or pt.x > w:
            self.setDirection(180 - dir)
        # Top/bottom wall
        if pt.y < 0 or pt.y > h:
            self.setDirection(360 - dir)
        # Separation
        if (pt.y < h // 2 - r or pt.y > h // 2 + r) and \
            pt.x > self.gameGrid.getPgWidth() // 2 - 2 and \
            pt.x < self.gameGrid.getPgWidth() // 2 + 2:
                self.setDirection(180 - dir)

        self.move(distance)
        if self.getX() < w // 2:
            self.isLeft = True
        else:
            self.isLeft = False

    def act(self):
        self.advance(3)
        
    def atLeft(self):
        return self.isLeft

# =================== class CollisionListener =========
class CollisionListener(GGActorCollisionListener):
    # Collision callback: just exchange direction and speed
    def collide(self, a,  b):
        dir1 = a.getDirection()
        dir2 = b.getDirection()
        sd1 = a.getSlowDown()
        sd2 = b.getSlowDown()
        a.setDirection(dir2)
        a.setSlowDown(sd2)
        b.setDirection(dir1)
        b.setSlowDown(sd1)
        return 5  # Wait a moment until collision is rearmed


# =================== Global sections =================
def drawSeparation():
    getBg().setLineWidth(3)
    getBg().drawLine(w // 2, 0, w // 2, h // 2 - r)
    getBg().drawLine(w // 2, h, w // 2, h // 2 + r)

def init():
    collisionListener = CollisionListener()
    for i in range(nbParticles):
        particles[i] = Particle()

        # Put them at random locations, but apart of each other
        ok = False
        while not ok:
            ok = True
            loc = getRandomLocation()
            if loc.x > w / 2 - 20:
                ok = False
            continue

        for k in range(i):
            dx = particles[k].getLocation().x - loc.x
            dy = particles[k].getLocation().y - loc.y
            if dx * dx + dy * dy < 300:
                ok = False
        addActor(particles[i], loc, getRandomDirection())
        delay(100)

        # Select collision area
        particles[i].setCollisionCircle(Point(0, 0), 8)
        # Select collision listener 
        particles[i].addActorCollisionListener(collisionListener)

        # Set speed in groups of 5
        if i < 5:
            particles[i].setSlowDown(2)
        elif i < 10:
            particles[i].setSlowDown(3)
        elif i < 15:
            particles[i].setSlowDown(4)
    
    # Define collision partners
    for i in range(nbParticles):
        for k in range(i + 1, nbParticles):
            particles[i].addCollisionActor(particles[k])

def binomial(n, k):
    if k < 0 or k > n:
        return 0
    if k == 0 or k == n:
        return 1
    k = min(k, n - k) # take advantage of symmetry
    c = 1
    for i in range(k):
        c = c * (n - i) / (i + 1)
    return c
                                    
r = 50  # Radius of hole
w = 400
h = 400
nbParticles = 20
particles = [0] * nbParticles
makeGPanel(Size(600, 300))
window(-6, 66, -2, 22)
title("Entropy")
windowPosition(600, 20)
drawGrid(0, 60, 0, 20)
makeGameGrid(w, h, 1, False)
setSimulationPeriod(10)
addStatusBar(20)
drawSeparation()
setTitle("Entropy")
show()
init()
doRun()

t = 0
while not isDisposed():
    nbLeft = 0
    for particle in particles:
        if particle.atLeft():
            nbLeft += 1
    entropy = round(log(binomial(nbParticles, nbLeft), 2), 1)
    setStatusText("(Left,Right) = (" + str(nbLeft) + "," + 
    str(nbParticles-nbLeft)+ ")"+" Entropie = "+str(entropy)+" bit")
    if t % 60 == 0:
        clear()
        lineWidth(1)
        drawGrid(0, 60, 0, 20)
        lineWidth(3)
        move(0, entropy)
    else:
        draw(t % 60, entropy)
    t += 1
    delay(1000)
dispose() # GPanel

Ein Zustand wird von Aussen gesehen (makroskopisch) durch die Anzahl k der Teilchen im rechten Teil und damit N - k im linken Teil bestimmt. Bei makroskopischer Betrachtung fehlt die genaue Kenntnis, welche k der N als nummeriert gedachten Teilen sind rechts befinden. Gemäss der Kombinatorik gibt es

solche Möglichkeiten. Der Informationsmangel ist daher

bzw. die Entropie

Der zeitliche Verlauf wird in einer GPanel-Grafik aufgetragen. Man sieht deutlich, dass sich die Teilchen im Laufe der Zeit über den ganzen Container verteilen, es aber durchaus sein kann, dass sich wieder alle Teilchen in der linken Hälfte befinden. Die Wahrscheinlichkeit dazu nimmt mit zunehmender Teilchenzahl aber rapide ab. Der 2. Hauptsatz beruht also auf einer statistischen Eigenschaft von Vielteilchensystemen.

Da der umgekehrte Ablauf nicht beobachtet wird, nennt man diese Prozesse irreversibel. Es gibt aber durchaus Prozesse, die von Unordnung zu Ordnung übergeben. Dazu braucht es aber einen "ordnenden Zwang" [mehr... Man spricht auch von einer "Versklavung"].

Beispiele sind:

Die Materie des Kosmos bildet Galaxien, Sterne und Planetensysteme
Das Leben entsteht aus toter Materie
Bei genügend Zwang wird die Unordnung in der Küche, im Schulzimmer kleiner
Beim Abkühlen von Wasserdampf (Gas) entstehen Wolken (Flüssigkeit), dann Eis (Festkörper). Phasenübergänge verändern also die Ordnung
Nach der Pause strömen die Konzertbesucher wieder an ihre Plätze

Bei diesen Prozessen nimmt die Unordnung, also die Entropie ab und ausgehend von einem Chaos werden Strukturen sichtbar.

10.7 INFORMATION & ORDNUNG

EINFÜHRUNG

ZAHLEN-RATESPIEL

MEMO

INFORMATIONSGEHALT EINES WORTS

MEMO

AUFGABEN

ZUSATZSTOFF

DER ZUSAMMENHANG ZWISCHEN UNORDNUNG UND ENTROPIE

MEMO

AUFGABEN