Code: Alles auswählen
file = open('logfile','r')
laenge = len(file.read())
file.close()
liste = list()Code: Alles auswählen
file = open('logfile','r')
chars = file.read()
file.close()
liste = []
liste.extend(list(chars))
Code: Alles auswählen
def main():
with open('logfile') as one_file:
result = [int(c) for c in one_file.read()]Wenn die Anzahl der Durchläufe bekannt ist, dann verwendet man eine for-Schleife.mobby hat geschrieben:Mit was für einer Schleife kann/sollte ich hier arbeiten?
Code: Alles auswählen
In [17]: [42]*6
Out[17]: [42, 42, 42, 42, 42, 42]Code: Alles auswählen
with open('file','r') as f:
chars = f.read()
liste = []
liste.extend(list(chars))
print len(liste)
Code: Alles auswählen
import os
liste = [1] * os.path.getsize('logfile')Code: Alles auswählen
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time
import os
from contextlib import closing
from itertools import groupby
from threading import Thread
from time import sleep
import MySQLdb as db
import pifacedigitalio as piface
def insert_into_database(timestamp, date, time, amount):
with closing(
db.connect(
host='localhost',
user='',
passwd='',
db='')
) as connection:
connection.cursor().execute(
'INSERT INTO Tabelle(Zeitstempel, Datum, Zeit, Impulsanzahl) VALUES (%s, %s, %s, %s)',
(timestamp, date, time, amount)
)
connection.commit()
def blink_led():
piface.digital_write(0,1)
sleep(0.1)
piface.digital_write(0,0)
def write_leading_edge_count(leading_edges):
intervall = 300
timestamp = int(time.time() / intervall) * intervall
while True:
timestamp += intervall
time.sleep(max(0, timestamp-time.time()))
leading_edge_count = len(leading_edges)
del leading_edges[:]
reset_logfile()
datum = str(time.strftime("%d-%m-%Y"))
uhrzeit = str(time.strftime("%H:%M:%S"))
insert_into_database(timestamp, datum, uhrzeit, leading_edge_count)
def start_writer(leading_edges):
thread = Thread(target=write_leading_edge_count, args=(leading_edges,))
thread.setDaemon(True)
thread.start()
def write_into_logfile(value):
with open('logfile','r') as lf:
lines = lf.readlines()
lines.insert(0,str(value))
with open('logfile' + '.new','w') as lfn:
lfn.writelines(lines)
os.rename('logfile' + '.new', 'logfile')
def read_logfile(liste):
with open('logfile','r') as lf:
chars = lf.read()
liste.extend(list(chars))
def reset_logfile():
with open('logfile','r+') as lf:
lf.truncate()
def iter_values(frequency):
while True:
yield piface.digital_read(0)
sleep(1.0 / frequency)
def iter_changes(frequency):
for value, _ in groupby(iter_values(frequency)):
yield value
def main():
piface.init()
leading_edges = list()
read_logfile(leading_edges)
start_writer(leading_edges)
for value in iter_changes(100):
if value == 1:
leading_edges.append(1)
write_into_logfile(1)
blink_led()
if __name__ == '__main__':
main()Was bietet sich dann an? Eine Variable in der die absolute Anzahl übergeben wird? Und was spricht technisch gegen die Liste?Sirius3 hat geschrieben:Auf jeden Fall mußt Du das Ermitteln der Signale vom Schreiben in die Datei oder Datenbank trennen, also in verschiedenen Threads und über Queues getrennt, nicht Listen, die sind dafür nicht geeignet.
Code: Alles auswählen
from collections import deque
queue = deque[]
queue.append("1")Und wie mach ich das?BlackJack hat geschrieben:Ansonsten kann man auch eine Zahl hernehmen und die am besten in einer Klasse kapseln und die kritischen Abschnitte in den Operationen mit Sperren (z.B. `threading.Lock`) absichern. Die Länge einer Liste zum Zählen von etwas zu verwenden, ist IMHO ein Hack/Missbrauch solange man den Inhalt nicht tatsächlich für irgendwas benötigt.
Code: Alles auswählen
import Queue
leading_edges = Queue.Queue()Code: Alles auswählen
leading_edges.put(1)Code: Alles auswählen
leading_edge_count = leading_edges.qsize()