Python-Programmierung: Teil 1 – Hallo Welt

Die interaktive Shell

$ python

>>> print("Hallo Python!")

>>> 3+7 
10 
>>> 7*10 
70 
>>> 3-7 
-4 
>>> 8/4 
2 
>>>8/3
2

>>> 8/3.0

Hallo Welt

#!/usr/bin/env python
# -*- coding: utf-8 -*-

print("Hallo Welt!")

$ chmod +x hello_world.py

$ ./hello_world.py

$ python hello_world.py

Hallo Welt!

Das erste „nützliche“ Programm

#!/usr/bin/env python
# -*- coding: utf-8 -*-

name = raw_input("Hallo! Wie heisst du? ")
name_with_borders = "= {0} =".format(name)
line = "=" * len(name_with_borders)

print(line)
print(name_with_borders)
print(line)

Hallo! Wie heisst du? Margot
==========
= Margot =
==========

Zeichenketten

name = "Bernd"
name = 'Bernd'

message = "Ich heisse "Bernd"!"

message = "Ich heisse 'Bernd'!"

message = 'Ich heisse "Bernd"!'

print("""Hier kann ich " und ' nach Belieben einsetzen!
Ausserdem sind sogar Zeilenumbrueche moeglich!""")

message = "Ich heisse \"Bernd\"!"

>>> print("Ein \nZeilenumbruch") 
Ein 
Zeilenumbruch 

Zeichenketten näher betrachtet

>>> text1 = "HALLO!!!" 
>>> text2 = text1.lower() 
>>> print(text1)
'HALLO!!!' 
>>> print(text2)
'hallo!!!' 

>>> text = "HALLO!!!" 
>>> text = text.lower() 
>>> print(text)
'hallo!!!' 

>>> "Ich finde Python doof".replace("doof", "super") 
'Ich finde Python super' 

Richtig einrücken

zaehler = 1
solange zahler <= 5 wiederhole:
gib zaehler auf dem Bildschirm aus
erhoehe zaehler um 1
gib "fertig" auf dem Bildschirm aus

zaehler = 1
solange zahler <= 5 wiederhole:
    gib zaehler auf dem Bildschirm aus
    erhoehe zaehler um 1
gib "fertig" auf dem Bildschirm aus

for-Schleife

#!/usr/bin/env python
# -*- coding: utf-8 -*-

for i in range(0, 10):
    print(i)
print("Fertig")

0
1
2
3
4
5
6
7
8
9
Fertig

Python-Programmierung: Teil 2 – Tiefere Einblicke

Korrekturen und Ergänzungen

u"Ich bin ein Unicode-String"
unicode("Auch ich werde eine Unicode-Zeichenkette")
"Bei Python-Versionen < 3 bin ich ein normaler Byte-String"

>>> print("Hallo Welt")

>>> print "Hallo Welt"

Operatoren

if-Anweisung

number = 5
if number > 3:
    print u"Zahl groesser als 3"

number = 20
if number > 10 and number < 40:
    print u"Zahl liegt zwischen 10 und 40"

good_looking = False
rich = True
if good_looking == True or rich == True:
    print u"Heirate mich!"

if good_looking or rich:
    print u"Heirate mich!"

if number < 10:
    print u"Kleiner 10"
elif number < 20:
    print u"Kleiner 20"
else:
    print u"Groesser oder gleich 20"

while-Schleife

while True:
    raw_input(u"Wie war Ihr Name noch gleich?")

names = []
running = True
while running:
    user_input = unicode(raw_input(u"Geben Sie einen Namen ein oder 'exit' zum Beenden > "))
    if user_input == u"exit":
        running = False
    else:
        names.append(user_input)
print u"Sie haben folgende Namen eingegeben:"
print names

Zwischenfazit: Kontrollstrukturen

• Jede Kontrollstruktur besteht aus einem Kopf, der die Ausführungsbedingungen definiert und einem Rumpf, der ausgeführt werden soll.
• Der Kopf einer Kontrollstruktur wird immer mit einem Doppelpunkt abgeschlossen.
• Der Rumpf einer Kontrollstruktur muss immer um eine Ebene eingerückt werden.
• Die Einrückungen müssen immer gleichmäßig sein.

if username == u"Bernd":
    if password == u"xy":
        print u"Alles ok"
    else:
        print u"Password falsch"
else:
    print u"Benutzername falsch"

Listen

>>> persons = []
>>> type(persons)
<type 'list'>
>>> persons = list()
>>> type(persons)
<type 'list'>
>>>persons = [u"Peter", u"Hermann", u"Simon"]

>>> persons = [u"Peter", u"Hermann", u"Simon"]
>>> persons.append(u"Carla")
>>> persons.append(u"Hermann")
>>> persons
[u'Peter', u'Hermann', u'Simon', u'Carla', u'Hermann']
>>> persons.remove(u"Hermann")
>>> persons
[u'Peter', u'Simon', u'Carla', u'Hermann']

>>> persons = [u"Peter", u"Hermann", u"Hermann"]
>>> while u"Hermann" in persons:
>>>     persons.remove(u"Hermann")
>>> print persons
['Peter']

>>> persons = [u"Peter", u"Hermann", u"Simon"]
>>> persons.append(u"Carla")
>>> persons.remove(u"Hermann")
>>> print persons
[u'Peter', u'Simon', u'Carla']
>>> persons.remove(u"Heidi")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

if u"Heidi" in persons:
    persons.remove(u"Heidi")

Listen-Indizes

>>> letters = [u"a", u"b", u"c"]
>>> letters[1]
u"b"

>>> letters[-3]
u"a"

Weitere Listen-Methoden

>>> letters = [u"a", u"c", u"e"]
>>> letters.insert(1, u"b")
>>> letters
[u"a", u"b", u"c", u"e"]
>>> letters.insert(3, u"d")
>>> letters
[u"a", u"b", u"c", u"d", u"e"]
>>> letters.pop()
u"e"
>>> letters
[u"a", u"b", u"c", u"d"]
>>> letters.pop(2)
u"c"
>>> letters
[u"a", u"b", u"d"]

Slicing

[von:bis]

>>> li = [u"a", u"b", u"c", u"d", u"e"]
>>> li[0:3]
[u"a", u"b", u"c"]
>>> li[2:5]
[u"c", u"d", u"e"]

>>> li[0:-1]
[u"a", u"b", u"c", u"d"]
>>> li[0:-2]
[u"a", u"b", u"c" ]
>>> li[1:-2]
[u"b", u"c"]

Abkürzen erlaubt

>>> li = [u"a", u"b", u"c", u"d", u"e"]
>>> li[:3]

>>> li[2:]
[u"c", u"d", u"e"]

>>> li[:]

Listen durch Slices verändern

>>> li = [u"a", u"b", u"c"]
>>> li[2] = u"e"
>>> li
[u'a', u'b', u'e']
>>> li[2:2] = [u"c", u"d"]
>>> li
[u'a', u'b', u'c', u'd', u'e']
>>> li[3:] = [1, 2, 3]
>>> li
[u'a', u'b', u'c', 1, 2, 3]

Ein kleines Beispiel

#!/usr/bin/env python
# coding: utf-8

allowed_tries = 5
counter = 1

users = [u"Karl", u"Willi", u"Joe"]
passwords = [u"karl123", u"willi456", u"joe789"]

while counter <= allowed_tries:
    username = unicode(raw_input(u"Bitte geben sie ihren Benutzernamen ein: "))
    password = unicode(raw_input(u"Bitte geben sie ihr Passwort ein: "))

    if not username in users:
        print u"Dieser Benutzer existiert nicht!"
    else:
        idx = users.index(username)
        if passwords[idx] == password:
            print u"Erfolgreich eingeloggt!"
            break
        else:
            print u"Sie haben ein falches Passwort eingegeben"

    counter += 1

    if counter > allowed_tries:
        print u"Sie haben es zu oft versucht!"

Python-Programmierung: Teil 3 – Funktionen und Module

Substitution von Zeichenketten

>>> message = u"Hallo {0}, du hast {1} Euro im Portemonnaie.".format(u"Karl", 10)
>>> print message
Hallo Karl, du hast 10 Euro im Portemonnaie.

>>> names = [u"Karl", u"Bernd", u"Hannes", u"Ina" ]
>>> for name in names:
...    print u"'{0}' hat {1} Buchstaben".format(name, len(name))

'Karl' hat 4 Buchstaben
'Bernd' hat 5 Buchstaben
'Hannes' hat 6 Buchstaben
'Ina' hat 3 Buchstaben

>>> for name in names:
...    print u"'{username}' \
...    hat {namelength} \
...    Buchstaben".format(\
...    username=name, \
...    namelength=len(name))

>>> print u"{0} mag Klammern wie \
... { oder }".format(u"Bernd")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: u' oder '

>>> print u"{0} mag Klammern wie {{ oder }}".format(u"Bernd")
Bernd mag Klammern wie { oder }

Dictionaries

>>> persons = dict()

>>> persons = {}

>>> persons = {u"Peter":18, \
... u"Ilse":87, u"Juergen":33, \
... u"Jutta":25}

>>> print persons[u"Peter"]
18

>>> if u"Hans" in persons:
...     print persons[u"Hans"]
... else:
...     print u"Der Eintrag Hans \
...     ist nicht vorhanden"

>>> print persons.get(u"Hans", 15)
15
>>> print persons.get(u"Peter", 5)
18

>>> print persons.get(u"Anke")
None

>>> persons[u"Peter"] = 99
>>> print persons[u"Peter"]
99
>>> persons[u"Hans"] = 15
>>> print persons[u"Hans"]
15

>>> addresses = {
...     u"Peter":{u"street":"Musterstr. 16", u"mobile":"0151/123 456"},
...     u"Jutta":{u"street":"Beispielstr. 99", u"mobile":"0151/33 44 55"},
... }

>>> print addresses[u"Peter"]

{u'mobile': '0151/123 456', u'street': 'Musterstr. 16'}

>>> print addresses[u"Peter"][u"street"]
Musterstr. 16

>>> peters_data = addresses[u"Peter"]
>>> type(peters_data)
<type 'dict'>
>>> peters_data[u"street"]
'Musterstr. 16'

>>> print addresses[u"Peter"][u"street"]

{u"street":u"Musterstr. 16", u"mobile":"0151/123 456"}[u"street"]

Funktionen

def say_hallo():
    print u"Hallo"

def boxify(text):
    text_with_borders = u"= {0} =".format(text)
    line = len(text_with_borders) * u"="

    output = u"{0}\n{1}\n{2}".format(line, text_with_borders, line)
    return output

>>> print boxify(u"Mein Haus, mein Garten, meine Box")
=====================================
= Mein Haus, mein Garten, meine Box =
=====================================

def test():
    print u"Hallo!"
    return
    print u"Dies ist ein Test"

print u"start"
test()
print u"ende"

start
Hallo!
ende

def say_something(what, who=u"Karl"):
    print u"{0} sagt: '{1}'".format(who, what)

say_something(u"Hi")
say_something(u"Tach auch", u"Bernd")

Karl sagt: 'Hi'
Bernd sagt: 'Tach auch'

def say_something(who="Karl", what):
   ...

Parameter an Funktionen übergeben

def print_a_lot(name, country, street, adress, mobile, age, sex, hobbies):
    print u"{name} stammt aus {country} ...".format(name=name, country=country)

print_a_lot(name=u"Bernd", age=18, sex=u"m", street=u"Musterstrasse", adress=18, country=u"Deutschland", mobile=u"0151-123456789", hobbies=u"lesen")

def print_info(name, country=None, street=None, adress=None, mobile=None, age=None, sex=None, hobbies=None):
    if age:
        print u"Hallo {0}! Du bist {1} Jahre alt!".format(name, age)
    else:
        print u"Hallo {0}".format(name)

print_info(u"Jutta", age=25)

>>> from operator import add
>>> add(1, 3)
4
>>> plus = add
>>> plus
<built-in function add>
>>> plus(1, 3)
4

Module

import os

counter = 0

files = os.listdir(".")
for entry in files:
    if os.path.isfile(entry):
        counter += 1

print u"Es gibt {0} Dateien in diesem Verzeichnis".format(counter)

from os import listdir

files = listdir(".")

Was es nicht alles gibt

Module selbst gemacht

#! /usr/bin/env python
# -*- coding: utf-8 -*-

def boxify(text):
    text_with_borders = u"= {0} =".format(text)
    line = len(text_with_borders) * u"="

    output = u"{0}\n{1}\n{2}".format(line, text_with_borders, line)
    return output

#! /usr/bin/env python
# -*- coding: utf-8 -*-

import box

name = unicode(raw_input(u"Bitte Namen eingeben: "))
print box.boxify(name)

Einschränkungen und Erweiterungen

Praktisches Beispiel: Der Taschenrechner

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from operator import add, sub, mul, div

def info(*args):
    print "Moegliche Befehle:"
    print ",".join(dispatch)
    print "Syntax: BEFEHL [PARAM_A PARAM_B]"

dispatch = {
    u"help": info,
    u"add": add,
    u"sub": sub,
    u"mul": mul,
    u"div": div,
    u"addiere": add,
    u"plus": add
}

def parser():
    while True:
        user_command = unicode(raw_input("calc: "))
        tokens = user_command.split()
        command = tokens[0]
        arg_a, arg_b = None, None
        if len(tokens) > 1:
            arg_a = int(tokens[1])
            arg_b = int(tokens[2])
        print tokens
        if command == u"quit":
            return
        elif command in dispatch:
            result = dispatch[command](arg_a, arg_b)
            print ">>> {0}".format(result)
        else:
            print "Unbekanntes Kommando '{0}'".format(command)
            print "Tippe 'help' fuer Hilfe."

if __name__ == "__main__":
    parser()

add 3 7

result = dispatch[command](arg_a, arg_b)

if command == "add" or command == "addiere" or command == "plus":
    result = arg_a + arg_b
elif command == "sub":
    result = arg_a - arg_b
elif command == "div":
    result = arg_a / arg_b
elif command == "mul":
    result = arg_a * arg_b
elif command == "info":
    info()
elif command == "quit":
    return
else:
    print "Unbekanntes Kommando '{0}'".format(command)
    print "Tippe 'help' fuer Hilfe."
    
print ">>> {0}".format(result)

Python-Programmierung: Teil 4 – Klassenunterschiede

Objektorientierte Programmierung

• Länge
• Gewicht
• Geschwindigkeit
• Beschleunigung
• Farbe

class Car(object):
    def __init__(self, speed=0, max_speed=140, acceleration=5, color="grey"):
        self.speed = speed
        self.max_speed = max_speed
        self.acceleration = acceleration
        self.color = color
    
    def brake(self):
        self.speed -= self.acceleration
        print "Current Speed: {0}".format(self.speed)
        
    def accelerate(self):
        self.speed += self.acceleration
        print "Current Speed: {0}".format(self.speed)
        
    def honk(self):
        print "Tuuuuut Tuuuut"

Klassen in Python

Klassen zum Leben erwecken

>>> car1 = Car()
>>> car2 = Car(speed=50)
>>> car1.speed
0
>>> car2.speed
50
>>> car1.accelerate()
Current Speed: 5
>>> car1.accelerate()
Current Speed: 10
>>> car2.brake()
Current Speed: 45
>>> car1.honk()
Tuuuuut Tuuuut

>>> ferrari = Car(max_speed=280, acceleration=10, color="red")
>>> trabbi = Car(max_speed=70, acceleration=2, color="blue")

Vererbung

class Racer(Car):
    def __init__(self, color="red"):
        Car.__init__(self, speed=0, max_speed=400, acceleration=10, color=color)
        self.current_gear = 0
        
    def honk(self):
        print "Tuuuuut Tuuuut Tuuuut"
        
    def shift_up(self):
        self.current_gear += 1
        print "Current gear: {0}".format(self.current_gear)
    
    def shift_down(self):
        self.current_gear -= 1
        print "Current gear: {0}".format(self.current_gear)

>>> ferrari = Racer()
>>> ferrari.honk()
Tuuuuut Tuuuut Tuuuut
>>> ferrari.shift_up()
Current gear: 1
>>> ferrari.accelerate()
Current Speed: 10
>>> ferrari.accelerate()
Current Speed: 20
>>> ferrari.shift_up()
Current gear: 2

Klassen im Einsatz

Alles ist eine Klasse

class BoxiCode(unicode):
    def boxify(self):
        text_with_borders = u"= {0} =".format(self)
        line = len(text_with_borders) * u"="
    
        output = u"{0}\n{1}\n{2}".format(line, text_with_borders, line)
        return output

>>> unicode("Hallo")
u'hallo'

>>> u"Hallo"
u'Hallo'

>>> s=BoxiCode("Hallo Welt")
>>> s
u'Hallo Welt'
>>> s.lower()
u'hallo welt'
>>> print s.boxify()
==============
= Hallo Welt =
==============

class SuperInt(int):
    def iseven(self):
        return self % 2 == 0

>>> x = SuperInt(15)
>>> y = SuperInt(16)
>>> x.iseven()
False
>>> y.iseven()
True
>>> z = x+y
>>> z.iseven()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'iseven'

Die Sache mit den Unterstrichen

Zwei Unterstriche vor und nach dem Methodennamen (__foo__)

x = MeineKlasse()
x + 3

x = MeineKlasse()
x.__add__(3)

x = MeineKlasse()
x["test"]

x = MeineKlasse()
x.__getitem__("test")

Einfacher Unterstrich vor Attributen (self._foo)

Doppelter Unterstrich vor Attributen, höchstens ein Unterstrich danach (self.__foo_ bzw. self.__foo)

class Test(object):
    def __init__(self):
        self._privat = "hallo"
        self.__sehrprivat = "welt"

class Test2(Test):
    def __init__(self):
        Test.__init__(self)
        self.__sehrprivat = "noch ein test"
        
        print self._Test__sehrprivat
        print self._Test2__sehrprivat

>>> x = Test2()
welt
noch ein test
>>> x.__dict__
{'_Test2__sehrprivat': 'noch ein test', '_Test__sehrprivat': 'welt', '_privat': 'hallo'}

Bemerkungen und Ausblick

Python-Programmierung: Teil 5 – In medias res

Fehlerbehandlung

>>> names = [u"Peter", u"Isabell"]
>>> names.remove(u"Karla")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

try:
    names.remove(u"Karla")
except ValueError:
    print "Eintrag nicht in der Liste"

try:
    names.remove(u"Karla")
except (SyntaxError, ValueError) as error:
    print u"Folgender Fehler ist aufgetreten {0}".format(error)

>>> error = ValueError("Hilfe")
>>> str(error)
'Hilfe'

else und finally

l = [u"Peter", u"Isabell"]
try:
    names.remove(u"Karla")
except ValueError:
    print "Karla war gar nicht in der Liste."
else:
    print "Karla wurde aus der Liste entfernt."
finally:
    print "Mir doch egal, ob Karla in der Liste war oder nicht!"

Karla war gar nicht in der Liste.
Mir doch egal, ob Karla in der Liste war oder nicht!

Karla wurde aus der Liste entfernt.
Mir doch egal, ob Karla in der Liste war oder nicht!

Ästhetik des Scheiterns

def innen():
    return int("asd")

def mitte():
    return innen()

def aussen():
    return mitte()

print aussen()

# ein Dictionary
persons = {u"Peter": "m", u"Karla": "w"}

# irgend wo spaeter im Code
if u"Peter" in persons:
    gender = persons[u"Peter"]

try:
    gender = persons[u"Peter"]
except KeyError:
    pass

Musikverwaltung

ID-Tags lesen

#!/usr/bin/env python
# coding:utf-8

import os
import sys
from mutagen.easyid3 import EasyID3
import mutagen.mp3
import mutagen.oggvorbis

from mutagen.easyid3 import EasyID3

def get_infos(path):

    path = path.decode("utf-8")
    
    if path.lower().endswith(".mp3"):
        audio = mutagen.mp3.MP3(path, ID3=EasyID3)
    else:
        audio = mutagen.oggvorbis.OggVorbis(path)
    
    length = audio.info.length

    infos = {"path":path, "length":length}
    for tag in ["title", "artist", "album"]:
        content =  audio.get(tag, [None])[0]
        infos[tag] = content
    
    return infos

{"path":path, "length":audio.info.length}
...
infos[tag] = audio.get(tag, [None])[0]

Verzeichnis rekursiv auslesen

def read_recursively(path):

audio_infos = []
counter = 0
error_counter = 0
    
for root, dirs, files in os.walk(path):
    for fl in files:
        if fl.lower().endswith(".mp3") or fl.lower().endswith(".ogg"):
            path = os.path.join(root, fl)
            try:
                infos = get_infos(path)
            except (UnicodeDecodeError, mutagen.mp3.HeaderNotFoundError, mutagen.id3.error) as inst:
                print u"\n\nSKIPPING reading this file:"
                print path
                print u"ERROR: {0}\n".format(inst)
                error_counter +=1
            else:
                audio_infos.append(infos)
                counter +=1
        print "\rScanning: {0} Files ok, {1} Files broken".format(counter, error_counter),
print 
return audio_infos

print ("\rScanning: {0} MP3s ok, {1} MP3s broken".format(counter, error_counter), end="")

Kleiner Test

if __name__ == "__main__":
    try:
        path = sys.argv[1]
    except IndexError:
        print "Usage:"
        print "readmp3s.py DIRECTORY"
    else:
        mp3s = read_recursively(path)

Python-Programmierung: Teil 6 – Datenbank für die Musikverwaltung

Die Datenbank

Die neuen Importe

import sqlite3

import subprocess
from optparse import OptionParser

import codecs
from textwrap import dedent
from random import shuffle

Die Datenbankanbindung

Das Schlüsselwort with

handler = open("datei.txt", "r")
try:
    print handler.read()
finally:
    handler.close()

with open("datei.txt", "r") as handler:
    print handler.read()

Der Cursor

class Cursor(object):
    def __init__(self, connection):
        self.connection = connection

    def __enter__(self):
        self.cursor = self.connection.cursor()
        return self.cursor

    def __exit__(self, type, value, traceback):
        self.cursor.close()

with Cursor(connection) as cursor:
    cursor.machetwas()

cursor = connection.cursor()
try:
    cursor.machetwas()
finally:
    cursor.close()

Die Datenbankklasse

class DatabaseConnector(object):

    def __enter__(self):
        path = os.path.dirname(os.path.abspath((__file__)))
        self.db_path = os.path.join(path, "music.db")
        if not os.path.exists(self.db_path):
            self.create_database()
        self.connection = sqlite3.connect(self.db_path)
        self.connection.row_factory = sqlite3.Row
        return self

    def __exit__(self, type, value, traceback):
        self.connection.close()

    def create_database(self):
        sql = u"""
            CREATE TABLE IF NOT EXISTS mp3s (
                id INTEGER PRIMARY KEY,
                artist STRING,
                title STRING,
                album STRING,
                length INT,
                path STRING UNIQUE
            )"""
        connection = sqlite3.connect(self.db_path)
        with Cursor(connection) as cursor:
            cursor.execute(sql)
        connection.close()

    def search(self, search):
        search = u"        search = search.replace(" ", "        print search
        sql = u"""
            select *
            from mp3s
            where   artist like ? or
                    album like ? or
                    title like ?
        """
        with Cursor(self.connection) as cursor:
            return cursor.execute(sql, (search, )*3).fetchall()

    def get_all_songs(self):
        with  Cursor(self.connection) as cursor:
            return cursor.execute("SELECT * FROM mp3s").fetchall()

    def insert_songs(self, songs):
        print "Inserting MP3s"
        sql = u"""INSERT OR IGNORE INTO mp3s (
            artist,
            title,
            album,
            length,
            path
        ) VALUES (
            :artist,
            :title,
            :album,
            :length,
            :path
        )
        """
        with Cursor(self.connection) as cursor:
            cursor.executemany(sql, songs)
        self.connection.commit()

    def count(self):
        sql = "select count(id) from mp3s"
        with Cursor(self.connection) as cursor:
            return cursor.execute(sql).fetchone()[0]

os.path.dirname(os.path.abspath((__file__)))

self.connection = sqlite3.connect(self.db_path)

self.connection.row_factory = sqlite3.Row

cursor.executemany(sql, songs)

[
 ("Kuenstler", "Titel", "Album", "Laenge", "Pfad"),
 ("Kuenstler", "Titel", "Album", "Laenge", "Pfad"),
 ...
]

connection.commit()

Wiedergabelisten erstellen

def generate_extended_playlist(songs):
    playlist = [u"#EXTM3U\n"]
    for id, artist, title, album, length, path in songs:
        playlist.append("#EXTINF:{0},{1} - {2}\n".format(int(length), artist,
                        title))
        playlist.append("{0}\n".format(path))
    return u"".join(playlist)

def generate_simple_playlist(songs):
    return u"\n".join(hit["path"] for hit in songs)

def dump(playlist, path, encoding="utf-8"):
    with codecs.open(path, "w", encoding=encoding) as fh:
        fh.write(playlist)

return u"\n".join(hit["path"] for hit in songs)

paths = []
for hit in songs:
    paths.append(hit["song"])
return u"\n".join(paths)

playlist = [u"#EXTM3U\n"]

Startbedingungen

if __name__ == "__main__":
    ...

if __name__ == "__main__":
    parser = OptionParser()
    parser.add_option("-s", "--scan", dest="add", help="add_directory",
            metavar="DIR")
    parser.add_option("-f", "--find", dest="search",
            help="Search database for tags", metavar="TERM")
    parser.add_option("--shuffle", dest="shuffle", metavar="INT", type="int",
            help="Takes randomly INT various songs from database")
    parser.add_option("-p", "--playlist", dest="playlist", metavar="FILE",
            help="Write the search results to a playlist (requires -s)")
    parser.add_option("-t", "--totem", dest="totem", action="store_true",
            help="Play the search result (requires -s)")
    parser.epilog = dedent("""
            'musikverwaltung' is a simple commandline music database. You are
            only able to add directories and search for tags.
            """)

    options, args = parser.parse_args()

    if not (options.search or options.shuffle) and \
            (options.playlist or options.totem):
        parser.error(dedent("""
            Writing / Playing playlists is only possible after a search.
            Use -f / --find plus searchterm"""))

    with DatabaseConnector() as database:
        if options.add:
            songs = read_recursively(options.add)
            database.insert_songs(songs)
            print
            print "Number of MP3s in your database: {0}".format(
                    database.count())
        elif options.search or options.shuffle:
            if options.search:
                searchterm = options.search.decode("utf-8")
                print
                songs = database.search(searchterm)
            else:
                songs = database.get_all_songs()
                shuffle(songs)
                songs = songs[:options.shuffle]
            if songs:
                print generate_simple_playlist(songs)
                if options.playlist:
                    if not options.playlist.lower().endswith(".m3u"):
                        options.playlist += ".m3u"
                    dump(generate_extended_playlist(songs), options.playlist)
                if options.totem:
                    command = ["totem", "--enqueue"]
                    for song in songs:
                        command.append(song["path"])
                    subprocess.Popen(command)
            else:
                print u"No results found for '{0}'".format(searchterm)
        else:
            parser.print_help()

options, args = parser.parse_args()

if not (options.search or options.shuffle) ...

with DatabaseConnector() as database:

elif options.search or options.shuffle:

songs = songs[:options.shuffle]

SELECT * FROM mp3s ORDER BY RANDOM() LIMIT 20

["totem", "--enqueue", "song1.mp3", "song2.mp3"]

$ totem --enqueue song1.mp3 song2.mp3

Kleine Aufgabe

Schlusswort

Impressum ISSN 1867-7991
freiesMagazin erscheint als PDF und HTML einmal monatlich.
Kontakt
	E-Mail
	Postanschrift	freiesMagazin
		c/o Dominik Wagenführ
		Beethovenstr. 9/1
		71277 Rutesheim
	Webpräsenz	http://www.freiesmagazin.de/

Erscheinungsdatum: 17. April 2011
Redaktion
	Frank Brungräber	Thorsten Schmidt
	Dominik Wagenführ (Verantwortlicher Redakteur)
Satz und Layout
	Ralf Damaschke	Yannic Haupenthal
	Nico Maikowski	Matthias Sitte
Korrektur
	Daniel Braun	Stefan Fangmeier
	Mathias Menzer	Karsten Schuldt
	Stephan Walter
Veranstaltungen
	Ronny Fischer
Logo-Design
	Arne Weinberg (GNU FDL)

Dieses Magazin wurde mit LaTeX erstellt. Mit vollem Namen gekennzeichnete Beiträge geben nicht notwendigerweise die Meinung der Redaktion wieder. Wenn Sie freiesMagazin ausdrucken möchten, dann denken Sie bitte an die Umwelt und drucken Sie nur im Notfall. Die Bäume werden es Ihnen danken. ;-)

Soweit nicht anders angegeben, stehen alle Artikel, Beiträge und Bilder in freiesMagazin unter der Creative-Commons-Lizenz CC-BY-SA 3.0 Unported. Das Copyright liegt beim jeweiligen Autor. freiesMagazin unterliegt als Gesamtwerk ebenso der Creative-Commons-Lizenz CC-BY-SA 3.0 Unported mit Ausnahme der Inhalte, die unter einer anderen Lizenz hierin veröffentlicht werden. Das Copyright liegt bei Dominik Wagenführ. Es wird erlaubt, das Werk/die Werke unter den Bestimmungen der Creative-Commons-Lizenz zu kopieren, zu verteilen und/oder zu modifizieren. Das freiesMagazin-Logo wurde von Arne Weinberg erstellt und unterliegt der GFDL. Die xkcd-Comics stehen separat unter der Creative-Commons-Lizenz CC-BY-NC 2.5 Generic. Das Copyright liegt bei Randall Munroe.

Zum Index

---