Beste antwoord
** Allereerst **:
64-bits Python kan alleen worden geïnstalleerd op 64-bits systemen, die alleen op 64-bits computers kunnen worden geïnstalleerd.
** Tweede ding: **
Zeggen dat computer / programma n-bit is, betekent niet dat het variabelen van de grootte n gebruikt. Het betekent dat het kan tot 2 ^ n geheugenblokken adresseren (meestal bytes). Dit is de reden waarom Windows XP of enig ander 32-bits besturingssysteem niet meer dan ongeveer 3,5 GB RAM kan gebruiken. Laten we het maar eens berekenen: we hebben 32 binaire bits, dus we kunnen maximaal 2 ^ 32 bytes adresseren. 2 ^ 32 = 4294967296 [bytes] = 4096 [MB] = 4 [GB]. Zoals u kunt zien, zou het systeem theoretisch tot 4GB aan werkgeheugen moeten adresseren. Dit “ontbrekende” deel van ongeveer 0,5 [GB] wordt gebruikt om het geheugen van PCI (AGP, USB enz.) Apparaten aan te spreken. Met een 64-bits systeem kunnen we maximaal 16777216 [TB] geheugen adresseren. Best gaaf, hè?
** tl; dr **
Programmas worden uitgevoerd met een 32-bits exemplaar van python kan (idealiter) 4 [GB] geheugen gebruiken, wat meestal voldoende is, maar soms problemen kan veroorzaken. Aan de andere kant kan een 64-bits instantie van python (dus programmas worden er ook mee uitgevoerd) een onbeperkte * hoeveelheid geheugen adresseren en gebruiken, wat prettig is. Maar nogmaals, op het antwoord van Adam Jorgensen: hetzelfde programma dat wordt uitgevoerd op 32- en 64-bits python zal dezelfde hoeveelheid geheugen gebruiken, zolang het maar minder is dan ongeveer 4 [GB]. Het zou niet langzamer zijn op 64-bits python ook.
* het is niet helemaal waar. Zie Tweede ding als je interesse hebt.
Hoop dat het helpt. 🙂
Antwoord
Je vraag toont een gebrek aan begrip van wat er aan de hand is, dus ik ga de tijd nemen om dit allemaal in detail te bespreken.
In de eerste regel schrijf je for loop in range(1, 11). De naam loop heeft helemaal geen zin. De hele constructie is een lus , dat wil zeggen dat u de getallen van 1 tot 10 maar één keer doorloopt. Door wat u hebt geschreven, lijkt het alsof u 10 keer herhaalt, wat niet waar is. Dus hoewel uw code correct is, geeft de naam van de variabele aan dat u wat er aan de hand is.
for number in range(1, 11):
print(number)
Dat hele ding (die twee volledige regels code) is de for loop. Een for loop.
Ik don ” Om een aantal redenen begrijp ik niet wat u wilt bereiken met de while -lus. Ten eerste, als je alle getallen wilt herhalen en de gebruiker de mogelijkheid wilt geven om na elk getal uit de lus te breken, kun je dat eenvoudig doen met een for-lus.
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
Je kunt het afdrukken van range(1, 11) repareren door het in list() te plaatsen, maar dat lijkt nog steeds niet te zijn wat je wilt. Ik neem aan dat je hetzelfde wilt doen als in de for-lus, namelijk elk nummer afdrukken, maar een optie geven om na elk nummer uit de lus te breken. Waarom zou je anders een lus hebben, om hetzelfde steeds opnieuw af te drukken? opnieuw?
Als je geen for-lus wilt gebruiken, kun je zoiets gebruiken als:
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
of
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
Let op het gebruik van iter. range(1, 11) is niet een iterator , maar een iterable , wat betekent dat een object een iterator kan produceren. Dit is een heel subtiel maar belangrijk onderscheid. Een list is een iterabele, maar geen iterator. Een iterator bevat de status, wat betekent dat het onthoudt welke waarde vervolgens moet worden geproduceerd. Dat kun je niet doen met een lijst, maar je kunt een lijst wel in een iterator veranderen.
Bijvoorbeeld:
>>> 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)
Als je wilt weten hoe het” onder de motorkap “werkt, laten we” eens kijken naar de volgende voorbeelden:
>>> 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 is een iterator , aangezien het de status behoudt (het onthoudt waar het zich als het ware bevindt). In het bijzonder is er een \_\_next\_\_() -methode gedefinieerd. Het kan op elk moment de volgende waarde produceren. Het is ook een itereerbaar , aangezien het de \_\_iter\_\_( ) heeft methode gedefinieerd.
Een generator is een iterator die lui waarden produceert, bijvoorbeeld:
def counter(current=1):
while True:
yield current
current += 1
En ja, generatoren hebben dus de status:
>>> my\_counter = counter()
>>> next(my\_counter)
1
>>> next(my\_counter)
2
>>> next(my\_counter)
3
Wat nu interessant is, is dat range niet een generator , in tegenstelling tot wat vaak wordt gedacht. range is een itereerbaar , maar geen iterator , en dus zeker geen generator . Dit lijkt misschien vervelend, maar er zijn enkele goede redenen hiervoor (extra attributen zoals start, stop en step, onveranderlijkheid (kan” niet worden gewijzigd; om iets vast te houden, moet het veranderlijk zijn)). Het is natuurlijk mogelijk om range te implementeren als een 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]
Ik hoop dat ik “genoeg achtergrondinformatie heb gegeven om uw probleem te begrijpen, in plaats van het alleen maar te corrigeren.