Bästa svaret
** Första sak **:
64-bitars Python kan endast installeras på 64-bitars system, som endast kan installeras på 64-bitars dator.
** Andra sak: **
Att säga att dator / program är n-bit betyder inte att det använder variabler i storlek n. Det betyder att det kan adressera upp till 2 ^ n minnesstycken (vanligtvis byte). Det är därför som Windows XP eller något annat 32-bitars operativsystem inte kan använda mer än cirka 3,5 GB ram. Låt oss beräkna det: vi har 32 binära bitar, så att vi kan adressera upp till 2 ^ 32 byte. 2 ^ 32 = 4294967296 [byte] = 4096 [MB] = 4 [GB]. Som du kan se bör teoretiskt systemet adressera upp till 4 GB ram. Denna ”saknade” del av cirka 0,5 [GB] används för att adressera minne (PCI, AGP, USB etc.). Med 64-bitars system kan vi adressera upp till 16777216 [TB] minne. Ganska coolt, va?
** tl; dr **
Program körs med 32-bitars instans av python kan använda upp till (helst) 4 [GB] minne, vilket vanligtvis räcker, men ibland kan det orsaka problem. På andra sätt kan 64-bitars instans av python (så att program körs med den också) adressera och använda obegränsad * mängd minne, vilket är trevligt. Men igen, till Adam Jorgensens svar: samma program som körs på 32 och 64 bitars python kommer att använda samma mängd minne, så länge det skulle vara mindre än cirka 4 [GB]. Det skulle inte vara långsammare på 64-bitars. python också.
* det är inte helt sant. Se andra om du är intresserad.
Hoppas det hjälper. 🙂
Svar
Din fråga visar en bristande förståelse från vad som händer, så jag tar mig tid att prata om det här i detalj.
I första raden skriver du for loop in range(1, 11). Namnet loop är inte alls meningsfullt. Hela konstruktionen är en slinga , dvs du slingrar bara en gång genom siffrorna 1 till 10. Det du skrev gör att det verkar som om du slingrar 10 gånger, vilket inte är sant. Så medan din kod är korrekt indikerar variabelns namn bristande förståelse för vad som händer.
for number in range(1, 11):
print(number)
Hela saken (de två hela raderna med kod) är for loop. En for loop.
Jag don ” t förstår vad du vill uppnå med while -slingan av flera anledningar. För det första, om du vill itera igenom alla siffror och ge användaren möjlighet att bryta sig ur slingan efter varje nummer, kan du helt enkelt göra det med en for-loop.
for number in range(1, 11):
print(number)
user\_input = input("Do you want to break? (Y/N)")
if user\_input.lower().startswith("y"): #allow for variations and upper/lower case
break
Du kan fixa utskriften av range(1, 11) genom att sätta in den i list(), men det verkar fortfarande inte vara vad du vill ha. Jag antar att du vill göra samma sak som i for-slingan, nämligen att skriva ut varje nummer, men att ge en möjlighet att bryta ur slingan efter varje nummer. Varför skulle du annars ha en loop, att skriva ut samma sak om och om igen igen?
Om du inte vill använda en for-loop kan du använda något som:
current = 1
while True:
print(current)
current += 1
user\_input = input("Do you want to break? (Y/N)")
if user\_input.lower().startswith("y") or current == 10:
break
eller
numbers = iter(range(1, 11))
while True:
current = next(numbers)
print(current)
user\_input = input("Do you want to break? (Y/N)")
if user\_input.lower().startswith("y") or current == 10: #avoid StopIteration
break
Observera användningen av iter. range(1, 11) är inte och iterator , men en iterabel , vilket betyder ett objekt som kan producera en iterator . Detta är en mycket subtil men viktig skillnad. En list är en iterabel men inte en iterator. En iterator håller tillstånd, vilket betyder att den kommer ihåg vilket värde som ska produceras nästa. Du kan inte göra det med en lista, men du kan göra en lista till en iterator.
Till exempel:
>>> my\_list = [1, 2, 3, 4, 5]
>>> my\_list\_iterator = iter(my\_list)
>>> first\_value = next(my\_list\_iterator)
>>>
>>> first\_value
1
>>> second\_value = next(my\_list\_iterator)
>>> second\_value
2
>>> type(my\_list)
>>> type(my\_list\_iterator)
Om du vill veta hur det fungerar” under huven ”, låt oss titta på följande exempel:
>>> class Counter:
... def \_\_init\_\_(self, start=1):
... self.current = start
... def \_\_next\_\_(self):
... value = self.current
... self.current += 1
... return value
... def \_\_iter\_\_(self):
... return self
...
>>> my\_counter = Counter()
>>> next(my\_counter)
1
>>> next(my\_counter)
2
>>> next(my\_counter)
3
my\_counter är en iterator , eftersom den håller tillstånd (den kommer ihåg var den är, så att säga). Specifikt har den en \_\_next\_\_() -metod definierad. Det kan producera nästa värde när som helst. Det är också en iterabel , eftersom den har \_\_iter\_\_( ) metod definierad.
En generator är en iterator som lat producerar värden, till exempel:
def counter(current=1):
while True:
yield current
current += 1
Och ja, generatorer har alltså tillstånd:
>>> my\_counter = counter()
>>> next(my\_counter)
1
>>> next(my\_counter)
2
>>> next(my\_counter)
3
Det som är intressant nu är att range är inte en generator , i motsats till vad många tror. range är en iterabel , men inte en iterator , och därmed definitivt inte en generator . Det här kan verka irriterande, men det finns några goda skäl till detta (extra attribut som start, stop och step, oföränderlighet (kan inte ändras; för att något ska hålla tillstånd, måste det vara mutabelt)). Det är naturligtvis möjligt att implementera range generator:
>>> def my\_range\_generator(start, stop, step=1):
... current = start
... while current
... yield current
... current += step
...
>>> test\_range = my\_range\_generator(1, 11, 2)
>>> list(test\_range)
[1, 3, 5, 7, 9]
Jag hoppas att jag har fått tillräckligt med bakgrund för att börja förstå ditt problem snarare än att bara rätta till det.