2 Fehlermeldungen

Bykl · Mittwoch 16. Januar 2019, 09:22

Wenn ich den Schlussteil meines Programmes so habe .....

import matplotlib.pyplot as plt                
Quadrate = range(1,60)# x-werte
plt.figure(figsize=(20,6), dpi=80)
plt.axis( [1,60,1,20] )
plt.grid(True)
plt.xlabel('Quadrate')
plt.ylabel('PZuX')
plt.plot(Quadrate, PZuX,
         Quadrate, PZiiI,)
plt.show()

erscheint dies:

raise ValueError("x and y must have same first dimension, but "
--> 242 "have shapes {} and {}".format(x.shape, y.shape))
ValueError: x and y must have same first dimension, but have shapes (59,) and (57,)

wenn ich "List" bei der X-Achse Zuweisung einsetzte, ....

Code: Alles auswählen

Quadrate = list(range(1,60))

....erscheint dies:

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-49-becb1525f940> in <module>()
53
54 import matplotlib.pyplot as plt
---> 55 Quadrate = list(range(1,60))
56 plt.figure(figsize=(20,6), dpi=80)
57 plt.axis( [1,60,1,20] )
TypeError: 'list' object is not callable

A: Was meint das?
B: was ist zu tun?

Danke für die konkrete Hilfe!

ArtooDetoo · Mittwoch 16. Januar 2019, 09:30

Hi Bykl,

könntest du bitte den vollständigen Code posten? Wo werden z. B. PZuX oder PZiiI definiert?

__blackjack__ · Mittwoch 16. Januar 2019, 09:35

@Bykl: Aus dem `range`-Objekt eine Liste zu machen wird nichts daran ändern, dass es 59 Elemente enthält und damit entweder nicht zu `PZuX` oder zu `PZiiI` (tolle Namen übrigens

) passen, was immer noch nur 57 Elemente enthält.

Beim zweiten A: Listenobjekte kann man nicht aufrufen:

Code: Alles auswählen

In [1]: [1, 2, 3](42)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-1-67af170f93ff> in <module>()
----> 1 [1, 2, 3](42)

TypeError: 'list' object is not callable

B: Es ist halt eine blöde Idee den Namen `list` für etwas anderes als die eingebaute Funktion mit diesem Namen zu verwenden. Einfach bleiben lassen, dann kann man auch weiterhin die Funktion verwenden.

Bykl · Mittwoch 16. Januar 2019, 15:31

Code: Alles auswählen

>>> from sympy import sieve
>>> from sympy import primepi 
>>> from colorama import Fore 
>>> import math 
>>> from mpmath import * 
PZuX = [] 
PZiiI = [] 
FrPL = [] 
uNPZ = [] 
bruch1=0 
bruch2=0 
ln1=0 
ln2=0 
iln1=0 
iln2=0 
lnErg=0 
iLogErg=0 
iLog = []
Ln = [] 
for x in range (3,61,1): duf=(x/15*8)
PZuX.append(primepi(x)-primepi(2))
PZiiI.append(primepi((x+1)*(x+1))-primepi(x*x))
FrPL.append(duf)
uNPZ.append((duf)-(primepi((x+1)*(x+1))-primepi(x*x)))
for i in sieve.primerange (7,x): 

    bruch1 = int((math.pow(x,2))/(i)) # obere Intervallgrenze - höhere Zahl 961/7
    bruch2 = int((math.pow(x,2))/(i+1)) # untere Intervallgrenze - kleinere Zahl 900 / 8
    ln1=int(1/math.log(bruch1)*bruch1) # oberer Ln-Wert (Anzahl PZ im Intervall)
    ln2=int(1/math.log(bruch2)*bruch2) # unterer Ln-Wert (Anzahl PZ im Intervall)
    iln1=int(li(bruch1)) # oberer iL-Wert (Anzahl PZ im Intervall)
    iln2=int(li(bruch2)) # unterer iL-Wert (Anzahl PZ im Intervall)
    print(Fore.RED,"x",Fore.BLACK,x,
           Fore.RED,"i",Fore.BLACK,i,
           Fore.RED,"bru1",Fore.BLACK,bruch1,
           Fore.RED,"bru2",Fore.BLACK,bruch2,
           Fore.RED,"Dfbr",Fore.BLUE,bruch1-bruch2,
           Fore.RED,"ln1", Fore.BLACK,ln1, 
           Fore.RED,"ln2", Fore.BLACK,ln2, 
           Fore.RED,"DfLn",Fore.BLUE,ln1-ln2,
           Fore.RED,"SuDLn",Fore.GREEN,LnErg,
           Fore.RED,"iln1",Fore.BLACK,iln1,
           Fore.RED,"iln2",Fore.BLACK,iln2,
           Fore.RED,"DfiL",Fore.BLUE,iln1-iln2,
           Fore.RED,"SuDiL",Fore.GREEN,iLogErg)
    iLogErg=iLogErg+(int(iln2-iln1)) # Grosse Teiler PZ in den Teilerbreichen. Log. integralis
    lnErg=lnErg+(int(ln1-ln2)) # Grosse Teiler PZ in den Teilerbreichen. Log. naturalis


print(Fore.RED, "x",Fore.BLACK,x,
      Fore.RED, "PZ<x",Fore.BLACK,(primepi(x)-primepi(2)), # PZ kleiner als x
      Fore.RED, "3+5zZ",Fore.BLACK, int(duf), # 8/15-tel - Anteil von 3 und 5
      Fore.RED, "zZOTLn",Fore.BLACK,lnErg, # PZ unter den oberen Teilern, ln ermittelt          
      Fore.RED, "PzuOT",Fore.BLUE,x-((primepi(x)-primepi(2))+lnErg),
      Fore.RED, "gezPZiI.",Fore.BLACK,primepi((x+1)*(x+1))-primepi(x*x),
      Fore.RED, "DffLn.",Fore.BLACK,x-int(duf+lnErg)-(primepi((x+1)*(x+1))-primepi(x*x)),
      Fore.RED, "zZOTiL",Fore.BLACK,iLogErg,
      Fore.RED, "beriL",Fore.BLUE,x-int(duf+iLogErg),
      Fore.RED, "DffiL.",Fore.BLACK,(x-int(duf+iLogErg))-primepi((x+1)*(x+1))-primepi(x*x))
iLog.append(iLogErg)
Ln.append(lnErg)
lnErg=0
iLogErg=0
import matplotlib.pyplot as plt
Quadrate = range(1,60) 
plt.figure(figsize=(20,6), dpi=80) 
plt.axis( [1,60,1,20] ) 
plt.grid(True)
plt.xlabel('Quadrate') 
plt.ylabel('PZuX') 
plt.plot(Quadrate, PZuX, Quadrate, PZiiI,)
    # Quadrate, uNPZ,
     #Quadrate, iLog)
plt.show()

Er ist nicht ganz heil, bestimmte Werte können nicht stimmen ....

__blackjack__ · Mittwoch 16. Januar 2019, 15:38

Ui, noch mehr Namen die mit dem Passworgenerator erstellt wurden. Die sind aber alle ein bisschen zu kurz um sicher zu sein.

ArtooDetoo · Mittwoch 16. Januar 2019, 16:16

Beim Füllen der Listen "PZuX" und "PZiiI" gehst du von 3 bis 61, bei "Quadrate" von 1 bis 60. Macht das Sinn?

__blackjack__ · Mittwoch 16. Januar 2019, 17:29

@ArtooDetoo: Wo siehst Du das? Ich sehe bei beiden Listen nur *ein* *einziges* `append()` *ausserhalb* einer Schleife. Der Schleifenkörper der Schleife davor ist der einzelne Ausdruck nach dem Doppelpunkt. Es kann also auch nicht sein, dass bei den beiden Zeilen danach einfach nur die Einrückung fehlt.

Mit den >>> bei den ersten Zeilen sieht mir das insgesamt aber auch danach aus, dass das nicht der Code ist, der tatsächlich verwendet wird.

ArtooDetoo · Donnerstag 17. Januar 2019, 19:58

Ich halte es für wahrscheinlicher, dass die Zeilen (auf welche Weise auch immer) hier falsch eingerückt sind und eigentlich zur Schleife gehören sollten. Vielleicht kann der TO da etwas zu sagen.

Bykl · Donnerstag 17. Januar 2019, 21:33

Danke für die Tips. Jetzt Habich nur noch das Problem, daß die Legende nicht erscheint ..... ich mach ja erst seit ein paar Wochen Python. Das gravierendste Problem bei dieser Sprache scheint mir das Einrücken zu sein.....

Code: Alles auswählen

>>> from sympy import sieve
>>> from sympy import primepi 
>>> from colorama import Fore 
>>> import math 
>>> from mpmath import * 
PZuX = [] 
PZiiI = [] 
FrPL = [] 
uNPZ = [] 
bruch1=0 
bruch2=0 
ln1=0 
ln2=0 
iln1=0 
iln2=0
pzgez=0
pzgezS=0
lnErg=0
duf=0
dufln=0
dufil=0
iLogErg=0 
ILog = []
Ln = []
PZiD =[]
PZgez =[]
for x in range (0,130,1): 
    duf = int (x/15*8)                      #Anzahl der durch 3 und 5 teilbaren Zahlen im Intervall
    frpl=(x-duf)                            #Anzahl Freie Plätze - Alle Zahlen 1mod3 und 2mod3, können PZ, aber auch zZ sein.
    pzkx=primepi(x)-primepi(2)              #PZ kleiner als x
    pziiI=primepi((x+1)*(x+1))-primepi(x*x) #Anzahl PZ im interq. Intervall also zwischen x^2 und (x+1)^2
    unpz=(duf)-pziiI                        #Anzahl zZ im interq. Intervall (gezählt mit primepi)
    pzid=int(primepi((x*x)/7)-primepi(x))/2 #halbe Anzahl der PZ zwischen xQ/7 und x
    PZiD.append(pzid)
    PZuX.append(pzkx) 
    PZiiI.append(pziiI) 
    FrPL.append(frpl) 
    uNPZ.append(unpz)
    for i in sieve.primerange (7,x): 
        bruch1 = int((math.pow(x,2))/(i))   #obere Intervallgrenze - höhere Zahl 961/7
        bruch2 = int((math.pow(x,2))/(i+1)) #untere Intervallgrenze - kleinere Zahl 900 / 8
        ln1=int(1/math.log(bruch1)*bruch1)  #oberer Ln-Wert (Anzahl PZ im Intervall)
        ln2=int(1/math.log(bruch2)*bruch2)  #unterer Ln-Wert (Anzahl PZ im Intervall)
        iln1=int(li(bruch1))                #oberer iL-Wert (Anzahl PZ im Intervall)
        iln2=int(li(bruch2))#unterer iL-Wert (Anzahl PZ im Intervall)
        pzgezS=primepi(bruch1)-primepi(bruch2)
        iLogErg=iLogErg+(int(iln1-iln2))    #Grosse Teiler PZ in den Teilerbreichen. Log. integralis
        lnErg=lnErg+(int(ln1-ln2))          #Grosse Teiler PZ in den Teilerbreichen. Log. naturalis
        pzgez=pzgez+pzgezS
        dufln=int(duf+lnErg)                #duf + Ln-Abschätzung
        dufil=int(duf+iLogErg)              #duf + logi-Abschätzung
        
           #print(Fore.RED,"x",Fore.BLACK,x,
           #Fore.RED,"i",Fore.BLACK,i,
           #Fore.RED,"bru1",Fore.BLACK,bruch1,
           #Fore.RED,"bru2",Fore.BLACK,bruch2,
           #Fore.RED,"Dfbr",Fore.BLUE,bruch1-bruch2,
           #Fore.RED,"ln1", Fore.BLACK,ln1, 
           #Fore.RED,"ln2", Fore.BLACK,ln2, 
           #Fore.RED,"DfLn",Fore.BLUE,ln1-ln2,
           #Fore.RED,"SuDLn",Fore.GREEN,LnErg,
           #Fore.RED,"iln1",Fore.BLACK,iln1,
           #Fore.RED,"iln2",Fore.BLACK,iln2,
           #Fore.RED,"DfiL",Fore.BLUE,iln1-iln2,
           #Fore.RED,"SuDiL",Fore.GREEN,iLogErg)
    PZgez.append(pzgez)   
    ILog.append(iLogErg)
    Ln.append(lnErg)   
    #print(ILog)
    #print(Ln)
    #print(Fore.RED, "x",Fore.BLACK,x,
     #     Fore.RED, "PZ<x",Fore.BLACK,pzkx, # PZ kleiner als x
      #    Fore.RED, "35zZ",Fore.BLACK,duf, # 8/15-tel - Anteil von 3 und 5
       #   Fore.RED, "gezPZiI.",Fore.BLACK,pziiI,
        #  Fore.RED, "LnErg",Fore.BLACK,lnErg, # PZ unter den oberen Teilern, ln ermittelt          
         # Fore.RED, "DfLngz.",Fore.BLACK,pziiI-(x-dufln),
          #Fore.RED, "X-35+lnErg",Fore.BLUE,x-(dufln),
          #Fore.RED, "iLogErg",Fore.BLACK,iLogErg,
          #Fore.RED, "X-35+iLogErg",Fore.BLUE,x-(dufil),
          #Fore.RED, "DfiLgz.",Fore.BLACK,(x-dufil)-pziiI)
    pzgez=0
    lnErg=0
    iLogErg=0
            
import matplotlib.pyplot as plt
Quadrate = range(0,130) 
plt.figure(figsize=(20,6), dpi=80) 
plt.axis( [0,130,-10,100] ) 
plt.grid(True)
plt.title('Vergleich Ln & Li')
plt.xlabel('x = n') 
plt.ylabel('y = Anzahl PZ unter x')
plt.legend(loc= 'upper left', frameon=True)
plt.plot(Quadrate, PZuX, color='blue', linewidth=1, linestyle='-', label=r'PZ>x')
plt.plot(Quadrate, PZiiI, color='red',  linewidth=1, linestyle='-', label=r'PZ im interq. Intervall')
plt.plot(Quadrate, PZiD, color='green',  linewidth=1, linestyle='-', label=r'zZ im interq. Intervall')
plt.plot(Quadrate, Ln, color='black',  linewidth=1, linestyle='-', label=r'PZ in Bruch -Log. nat') 
plt.plot(Quadrate, ILog, color='cyan',  linewidth=1, linestyle='-', label=r'PZ in Bruch -Log. integr.')
plt.plot(Quadrate, PZgez, color='magenta',  linewidth=1, linestyle='-', label=r'PZ in Schnipseln gezählt')
plt.show()

__blackjack__ · Donnerstag 17. Januar 2019, 21:45

@Bykl: Einrücken ist kein Problem. Das macht man in jeder mir bekannten Sprache. Bei Python *muss* man halt. Aber wer das in anderen Sprachen nicht macht, dessen Programme möchte halt auch keiner lesen, verstehen, oder warten müssen.