Das deutsche Python-Forum

Code: Alles auswählen

# -*- coding: utf-8 -*-
import pickle

## Nur Werte filtern, die größer als 0 sind.
def positiv(x): 
    return (x > 0)

## Generierung einer Liste mit 5 Werten - geht das nicht auch hübscher?
liste1=[input()]
liste2=[liste1, input()]
liste3=[liste2, input()]
liste4=[liste3, input()]
liste5=[liste4, input()]

## Speichern der Liste in data.pkl
output = open('data.pkl', 'w')
pickle.dump(liste5, output)
output.close()

## Öffnen der Liste
f = open("data.pkl")
ergebnisse = pickle.load(f)
print ergebnisse

## Ausgabe der positiven Zahlen
positive = filter(positiv, liste5)
print positive

## Anzahl der gezählten Werte
anzahlpositive = len(positive)
print anzahlpositive

Code: Alles auswählen

import time

## Hier der 5-Sekunden Countdown. Hier ist die Verknüpfung von time und input jedoch noch nicht richtig. Die Ausgabe "Zeit abgelaufen" erfolgt nur, wenn 5 Eingaben getätigt wurden.
Messintervall = 5
while Messintervall > 0:
    time.sleep(1)
    x = input()
    Messintervall -=1
print("Zeit abgelaufen", x)

Code: Alles auswählen

[[[[[1], 2], 3], 4], 5]

Code: Alles auswählen

values = list()
for _ in xrange(5):
    values.append(input())

# Oder als "list comprehension":

values = [input() for _ in xrange(5)]

Code: Alles auswählen

# -*- coding: utf-8 -*-

# Nötige Module
import time, thread
Ergebnisse = list()

# Zwischenspeicherung der Daten
def sensor():
    for _ in xrange(5):
        Ergebnisse.append(input())

# Definition der übrigen Funktionen
def positiv(x):
    return x > 0
    print positiv

def negativ(x):
    return x <= 0
    print negativ

def filterung():
    len(filter(positiv, Ergebnisse))
    len(filter(negativ, Ergebnisse))
    if len(filter(positiv, Ergebnisse)) > len(filter(negativ, Ergebnisse)):
        print("Mehr positive Werte")
    elif len(filter(positiv, Ergebnisse)) == len(filter(negativ, Ergebnisse)):
        print("Gleichstand")
    else: print("Mehr negative Werte")

# Programmstart: 2 Sekunden zum Sammeln von Ergebnissen; danach Ausführung des Filters; bei 5 Ergebnissen wird die Liste zurückgesetzt
while 0 == 0:
    thread.start_new_thread(sensor,())
    time.sleep(2)
    thread.start_new_thread(filterung,())
    time.sleep(1)
    if len(Ergebnisse) == 5:
        del Ergebnisse[:]

Code: Alles auswählen

In [24]: 0 == 0
Out[24]: True

Code: Alles auswählen

from threading import Thread
from collections import deque
import logging
import time

def read_sensor(queue):
    while True:
        try:
            queue.append(float(raw_input()))
        except ValueError:
            logging.exception('Lesefehler')

def collect_values(queue):
    return [queue.popleft() for _ in xrange(len(queue))]

def process_values(values):
    negative = sum(value<0 for value in values)
    positive = len(values) - negative
    if negative < positive:
        print "Mehr positive Werte"
    elif negative == positive:
        print "Gleichstand"
    else:
        print "Mehr negative Werte"

def main():
    queue = deque()
    reader = Thread(target=read_sensor, args=(queue,))
    reader.daemon = True
    reader.start()
    while True:
        time.sleep(5)
        process_values(collect_values(queue))
        
if __name__ == '__main__':
    main()

Code: Alles auswählen

def Begrenzungsschleife:
#ret tuple: (Svr, i, impulsbreite)
A0 = read.bus_byte(0x48)
Max0 = A0 + 30
Min0 = A0 - 30

i = 1
while i <= 2000:
Svr = read.bus_byte(0x48)
if Svr > Max0 or Svr < Min0:
Svr = read.bus_byte(0x48)
break
i = i + 1

# Falls Schleife kaputt
if i > 2000:
return

impulsbreite = 1
while impulsbreite <=15:
if read.bus_byte(0x48) > Max0 and Svr < A0:
break
if read.bus_byte(0x48) < Min0 and Svr > A0:
break
impulsbreite = impulsbreite + 1

print (Svr - A0)

Code: Alles auswählen

# -*- coding: utf-8 -*-
from smbus import SMBus
import time

bus = SMBus(1)
A0=bus.read_byte(0x48)
Max0 = A0 + 50
Min0 = A0 - 50


while (0 == 0):
# Ret tuple: (Svr, i, impulsbreite)
    A0=bus.read_byte(0x48)
    Max0 = A0 + 50
    Min0 = A0 - 50

    i = 1
    while i <=2000:
        Svr = bus.read_byte(0x48)
        if Svr > Max0 or Svr < Min0:
            Svr = bus.read_byte(0x48)
            print(Svr-A0)

Code: Alles auswählen

from smbus import SMBus
import time

Startwert = bus.read_byte(0x48)
Obergrenze = Startwert + 30
Untergrenze = Startwert - 30

# Start des Auslesens:
Startwert = bus.read_byte(0x48)
while 0 == 0:
    Zwischenwert = bus.read_byte(0x48)
    if Zwischenwert > Obergrenze or Zwischenwert < Untergrenze:
        print("Sensor ist außerhalb der Schleife")
        break