IntegerArray speichern und wieder einlesen

[Kalli Hofmann]

Bin am verzweifeln, die Lösung ist bestimmt einfach, aber ich kriegs nicht hin. Folgendes:
Ich habe ein Array z.B folgender Art:

lowPrimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79,
83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167,
173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263,
269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367,
373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587,
593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683,
691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,
821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929,
937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009]

Ich will das Array in eine Datei namens "LowPrimes.txt" speichern und bei Bedarf wieder in
die ArrayVariable "lowPrimes" laden. Irgendjemand eine Idee ?
Gruß Kalli

[Kalli Hofmann]

Wär ich nur bei Delphi geblieben

[Kebap]

Willkommen bei Python und im Forum!

Wir nennen das einfach Liste und nicht Array (gibt es aber auch).

Du kannst Objekte direkt speichern und laden mit dem Modul pickle.

In diesem Falle würde ich aber zu einem strukturierten Datenformat raten, bspw Json.

Gibt es irgendeinen bestimmten Grund, wieso es eine TXT Datei sein soll?

[Kalli Hofmann]

Ne, das muß keine Textdatei sein. pickle und Json hab ich probiert. Mit Json hab ich es
fertiggebracht zu speichern, aber nicht wieder ordnungsgemäß in die Listenvariable "lowPrimes"
zurückzuimportieren.
Irgendwelche codeschnipsel Tipps ?
Danke Kalli

[Kalli Hofmann]

Noch ne Frage. Wie groß kann ich so eine Datei gestalten bzw. Wieviel Listeneinträge "verträgt" mein "lowPrimes" ?
Danke im Voraus .... Kalli :K

[BlackJack]

@Kalli Hofmann: Es gibt keine Listenvariable `lowPrimes`. Das ist ein Name. Den kannst Du an eine Liste binden, oder auch an jedes andere Objekt.

Der Name wird nicht mitgespeichert, nur der Wert. Du musst also nach dem laden den geladenen Wert an einen Namen binden.

Wie gross das werden kann hängt von Deinem Rechner ab.

[Kalli Hofmann]

Habs jetzt .... Danke an alle. Ich poste nochmal den Code, damit alle was davon haben. Gruß Kalli

Code: Alles auswählen

import json

lowPrimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79,
                  83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167,
                  173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263,
                  269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367,
                  373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
                  467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587,
                  593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683,
                  691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,
                  821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929,
                  937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009] 
                  
print(lowPrimes)

with open('LowPrimes.txt', 'w') as outfile: json.dump(lowPrimes, outfile)

print()
lowPrimes = []
print(lowPrimes)
print()

with open('LowPrimes.txt', 'r') as infile: lowPrimes = json.load(infile)

print(lowPrimes)

Items = len(lowPrimes)

print()
print("Anzahl Einträge: " + str(Items))
print(lowPrimes[0])
print(lowPrimes[Items-1])

[BlackJack]

@Kalli Hofmann: Jetzt unbedingt den Style Guide for Python Code lesen, damit diese Pascal-Schreibweise von Namen aufhört.

Das ``Items - 1`` in der letzten Zeile würde man in Python so nicht schreiben, sondern einfach nur -1 als Index.

Und ``+`` und `str()` um Zeichenketten mit Werten zu verbinden ist auch eher BASIC als Python. Entweder lässt man das Leerzeichen nach dem Doppelpunkt im ersten Argument von dem `print()` weg und gibt `Items` als zweites Argument, oder man verwendet die `format()`-Methode auf Zeichenketten. Beides ohne den `str()`-Aufruf.

[nezzcarth]

Ergänzend zu dem, was die anderen schrieben:

Wär ich nur bei Delphi geblieben

Wobei das ja in der Regel nichts ist, was die jeweilige Sprache selbst mitbringt, sondern i.d.R. durch eine (Standard)bibliothek zur Verfügung gestellt wird. Die Verwendung von Pickle oder Json ist natürlich sehr komfortabel, weil man da im Prinzip nichts selbst machen muss. Im konkreten Fall könnte man aber auch die Zahlen einfach mit Bordmitteln zeilenweise in eine Textdatei schreiben und wieder auslesen; das wär' unwesentlich mehr Aufwand und ggf. eine einfache Übung, um sich mit dem Ein- und Auslesen von Dateien unter Python zu befassen.

[pyHoax]

Wär ich nur bei Delphi geblieben

Da hab ich auch meinen Senf.
Ich hab am dem Tag mir ein C++ Buch gekauft und gebüffelt, als ich feststellte das alles was ich mit Kylix unter Linux machen kann der wine Bibliothek verdanke.
Wenn Borland es nicht mal schaft eine API die im Bereich GUI mit qt sogar nativ für Linux implementiert ist mit einen compiler zu vereinen..

Delphie ist einfach als Platform so was von gestorben und pascal, modula & co einfach nur retro.

[Kebap]

Die Verwendung von Pickle oder Json ist natürlich sehr komfortabel, weil man da im Prinzip nichts selbst machen muss. Im konkreten Fall könnte man aber auch die Zahlen einfach mit Bordmitteln zeilenweise in eine Textdatei schreiben und wieder auslesen; das wär' unwesentlich mehr Aufwand und ggf. eine einfache Übung, um sich mit dem Ein- und Auslesen von Dateien unter Python zu befassen.

Stimmt. Dateien und Schleifen funktionieren unter Python aber auch mit Bordmitteln recht komfortabel. Schwieriger könnte es da werden, die "Denke" aus anderen Sprachen abzulegen und sich auf die neuen Möglichkeiten einzustimmen.

Je nachdem, wo die Zahlenliste herstammt, und was damit sonst noch so angestellt werden soll, gibt es aber bestimmt sowieso noch ein paar offene Baustellen, auf denen man herumspielen kann.

[BlackJack]

Klar ist Pascal retro, aber retro ist doch gerade angesagt.
[codebox=delphi file=Unbenannt.pas]program Primes;

type
TPrimeIdx = 0..168;
TPrimes = array[TPrimeIdx] of Word;

const
primesFilename = 'test.txt';
lowPrimes: TPrimes = (
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,
331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,
421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607,
613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,
821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009);

var
loadedPrimes: TPrimes;

procedure PrintPrimes(var primes: TPrimes);
var
i: TPrimeIdx;
begin
for i := Low(primes) to High(primes) do Write(primes, ' ');
WriteLn();
end;

procedure SavePrimes(fileName: String; var primes: TPrimes);
var
i: TPrimeIdx;
f: Text;
begin
Assign(f, fileName);
Rewrite(f);
for i := Low(primes) to High(primes) do WriteLn(f, primes);
Close(f);
end;

procedure LoadPrimes(fileName: String; var primes: TPrimes);
var
i: TPrimeIdx;
f: Text;
begin
Assign(f, fileName);
Reset(f);
for i := Low(primes) to High(primes) do ReadLn(f, primes);
Close(f);
end;

begin
PrintPrimes(lowPrimes);
SavePrimes(primesFilename, lowPrimes);
PrintPrimes(loadedPrimes);
LoadPrimes(primesFilename, loadedPrimes);
PrintPrimes(loadedPrimes);
WriteLn('Anzahl: ', Length(lowPrimes));
WriteLn(lowPrimes[Low(lowPrimes)], ' ', lowPrimes[High(lowPrimes)]);
end.[/code]

Andererseits…

Code: Alles auswählen

#!/usr/bin/env python
from __future__ import absolute_import, division, print_function
from itertools import imap

PRIMES_FILENAME = 'test.txt'


def save_primes(filename, primes):
    with open(filename, 'w') as primes_file:
        primes_file.writelines(imap('{}\n'.format, primes))


def load_primes(filename):
    with open(filename, 'r') as primes_file:
        return map(int, primes_file)


def main():
    low_primes = [
        2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
        67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137,
        139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
        223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283,
        293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379,
        383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461,
        463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563,
        569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643,
        647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739,
        743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829,
        839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937,
        941, 947, 953, 967, 971, 977, 983, 991, 997, 1009,
    ]
    print(low_primes)
    save_primes(PRIMES_FILENAME, low_primes)
    low_primes = None
    print(low_primes)
    low_primes = load_primes(PRIMES_FILENAME)
    print(low_primes)
    print('Anzahl:', len(low_primes))
    print(low_primes[0], low_primes[-1])


if __name__ == '__main__':
    main()

Ich glaube nicht das Delphi (oder FreePascal/Lazarus) wirklich schon tot sind. Programmiersprachen die mal viel benutzt wurden, sind nie so wirklich tot zu kriegen, weil es immer irgendwelche obskure Individualsoftware gibt, die noch weitergepflegt werden muss. Und damit auch ein Bedarf an Programmierern besteht. Sofern die Sprache dann nicht *völlig* überholt ist, fangen diese Programmierer dann auch hier und da mal ein neues Projekt damit an.

Es gibt auf jeden Fall schlimmeres als Pascal- oder Delphi-Projekte dort draussen was noch ”lebt” und ab und zu gewartet und erweitert werden will…

[Kalli Hofmann]

Tja, für normale Anwendungen war ich mit Delphi recht zufrieden. Ich bin 54 Jahre und habe mal mit Basic auf einer Triumph Adler Maschine mit CPM mal angefangen und über Turbo Pascal zu Delphi gekommen. Immer mal wieder ein Proggie konstruiert für den Eigenbedarf und alle laufen super stabil. Als Hobbycoder waren mir die Restriktionen für mein Hobbyprojekt (Mersenne Primzahl Faktorensuche) in Delphi a bissel eng. Ich befasse mich erst sei 4 Wochen mit Python und ich muß sagen: ich bin begeistert. Vielen Dank für eure Ausführungen. Ganz lieben Dank an Black Jack, der sich sogar die Mühe gemacht hat, das ganze sogar in delphi zu schreiben ...... gut zu wissen das du das auch kannst.
Hier mal mein Code, damit ihr wisst mit was ich mich befasse.
Auf dieser Seite könnt ihr vergleichen :http://www.mersenne.ca/exponent/5977753
Und hier der Code:

Code: Alles auswählen

from sys import stdout
from math import sqrt, log
import os, sys
import time
import random

# Primality Testing with the Rabin-Miller Algorithm
# http://inventwithpython.com/hacking (BSD Licensed)

def RabinMiller(num):
     s = num - 1
     t = 0
     while s % 2 == 0:
         s = s // 2  # keep halving s while it is even (and use t
         t += 1      # to count how many times we halve s)

     for trials in range(5): # try to falsify num's primality 5 times
         a = random.randrange(2, num - 1)
         v = pow(a, s, num)
         if v != 1: # this test does not apply if v is 1.
             i = 0
             while v != (num - 1):
                 if i == t - 1:
                     return False
                 else:
                     i = i + 1
                     v = (v ** 2) % num
     return True

def isPrime(num):        # Return True if num is a prime number. This function does a quicker
                         # prime number check before calling rabinMiller().
     if (num < 2):
         return False    # 0, 1, and negative numbers are not prime
                         # About 1/3 of the time we can quickly determine if num is not prime
                         # by dividing by the first few dozen prime numbers. This is quicker
                         # than rabinMiller(), but unlike rabinMiller() is not guaranteed to
                         # prove that a number is prime.
     lowPrimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79,
                  83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167,
                  173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263,
                  269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367,
                  373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
                  467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587,
                  593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683,
                  691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,
                  821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929,
                  937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033,
                  1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123,
                  1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231,
                  1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321,
                  1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451,
                  1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549,
                  1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627,
                  1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747,
                  1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871,
                  1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987,
                  1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083,
                  2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203,
                  2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297,
                  2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393,
                  2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531,
                  2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657,
                  2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729,
                  2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837,
                  2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957,
                  2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079,
                  3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209,
                  3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323,
                  3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449,
                  3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541,
                  3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643,
                  3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767,
                  3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881,
                  3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003,
                  4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111,
                  4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231,
                  4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349,
                  4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481,
                  4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597,
                  4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721,
                  4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831,
                  4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967,
                  4969, 4973, 4987, 4993, 4999] 
                  
     if num in lowPrimes:
         return True

     for prime in lowPrimes:  # See if any of the low prime numbers can divide num
         if (num % prime == 0):
             return False

     return RabinMiller(num)  # If all else fails, call rabinMiller() to determine if num is a prime.





Exponent = 5977753
Anfang   = 2      #pow(2,73) // Exponent
Ende     = pow(2,74) // Exponent
if Anfang % 2 != 0: Anfang -= 1 

lastCharakter = str(Exponent)[-1]
if lastCharakter == '3' : kk = 2
if lastCharakter == '9' : kk = 4
if lastCharakter == '1' : kk = 6
if lastCharakter == '7' : kk = 8

counter = 1
ZeitSumme = 0.000
k = Anfang
ZeitStart = time.time()

while k < Ende:
      if (((k + 4) % 8) != 0) and (((k + kk) % 10) != 0):
          p = (Exponent * k) + 1
          z = pow(2,Exponent,p)
          if counter  % 1500000 == 0:
              ZeitStop = time.time()    
              print ("Faktor No.: " + str(k) + " = " + str(p) + "  ergibt Rest  " + str(z-1) + 
                     "    \t" + "Sek./Iter.: %15.12f  " % ((ZeitSumme + (ZeitStop - ZeitStart)) / counter) + str(counter))
              counter = 1       
              ZeitStart = time.time()
          if z == 1 and isPrime(p):
              print ()   
              print ("Faktor No.: " + str(k) + " = " + str(p) + "  ergibt Rest  " + str(z-1))
              fertig = input("Return --> weiter")
              print ()
          counter += 1         
      k += 2