Hoe schrijf ik code van meer dan 1 regel in de Python interpreter?

Voeg een backslash achteraan toe (`## Voeg een backslash achteraan toe ()

De truc is - vergelijkbaar met wat je zou doen in bash, bijvoorbeeld - om een backslash achteraan toe te voegen. Bijvoorbeeld, als ik een 1 wil afdrukken:

charon:~ werner$ python
>>> print 1
1
>>> print \
... 1
1
>>>

Als je een ## Voeg een backslash achteraan toe (## Voeg een backslash achteraan toe ()

De truc is - vergelijkbaar met wat je zou doen in bash, bijvoorbeeld - om een backslash achteraan toe te voegen. Bijvoorbeeld, als ik een 1 wil afdrukken:

charon:~ werner$ python
>>> print 1
1
>>> print \
... 1
1
>>>

Als je een schrijft, zal Python je met ... (vervolgregels) vragen om code in te voeren in de volgende regel, dus om te zeggen.

Kanttekening: Dit is wat er automatisch gebeurt als je een functie of klasse definitie maakt, dus de keren dat je echt een nieuwe regel nodig hebt, dus er is nooit echt een goed gebruik voor, of tenminste geen dat ik weet. Met andere woorden, Python is slim genoeg om te weten dat je vervolg-regels nodig hebt als je een nieuwe functie-definitie of andere soortgelijke constructies invoert (b.v. if:). In deze automatische gevallen, moet u een lege regel invoeren met ## Voeg een backslash achteraan toe (## Voeg een backslash achteraan toe ()

De truc is - vergelijkbaar met wat je zou doen in bash, bijvoorbeeld - om een backslash achteraan toe te voegen. Bijvoorbeeld, als ik een 1 wil afdrukken:

charon:~ werner$ python
>>> print 1
1
>>> print \
... 1
1
>>>

Als je een ## Voeg een backslash achteraan toe (## Voeg een backslash achteraan toe ()

De truc is - vergelijkbaar met wat je zou doen in bash, bijvoorbeeld - om een backslash achteraan toe te voegen. Bijvoorbeeld, als ik een 1 wil afdrukken:

charon:~ werner$ python
>>> print 1
1
>>> print \
... 1
1
>>>

Als je een schrijft, zal Python je met ... (vervolgregels) vragen om code in te voeren in de volgende regel, dus om te zeggen.

Kanttekening: Dit is wat er automatisch gebeurt als je een functie of klasse definitie maakt, dus de keren dat je echt een nieuwe regel nodig hebt, dus er is nooit echt een goed gebruik voor, of tenminste geen dat ik weet. Met andere woorden, Python is slim genoeg om te weten dat je vervolg-regels nodig hebt als je een nieuwe functie-definitie of andere soortgelijke constructies invoert (b.v. if:). In deze automatische gevallen, moet u een lege regel invoeren met om Python te vertellen dat u klaar bent.

Voor al het andere moet je de ene regel na de andere schrijven. De manier waarop een interpreter werkt is dat hij, nou ja, elke regel interpreteert die je hem geeft. Niet meer, niet minder. Het zal alleen “handelen” als het een newline ziet, dus de interpreter vertellen uit te voeren wat je hem gaf. De enkele backslash zal voorkomen dat de interpreter ooit een newline karakter ontvangt (d.w.z. hij zal niet weten dat je op Enter hebt gedrukt), maar hij zal er uiteindelijk wel een ontvangen.

Python’s interpreter heeft geavanceerde mogelijkheden wanneer je GNU readline gebruikt, zoals Emacs of vi-stijl toetsenbindingen om binnen een regel te navigeren (b.v. Ctrl-A). Deze werken echter alleen in de huidige regel. Geschiedenis is er ook, probeer maar eens op ↑ te drukken.

Wat als ik ingewikkelde regels steeds opnieuw wil uitvoeren?

Je wilt waarschijnlijk goede bronbestanden gebruiken als je meer dan een regel code tegelijk wilt uitvoeren.

Of, gebruik Jupyter notebooks , die bieden een geweldige, interactieve manier om Python code te maken met een ingebouwde interpreter. U kunt code schrijven zoals u dat in een broncode-editor zou doen, maar u kunt kiezen welke regels samen worden geïnterpreteerd. U kunt dan selectief alleen delen van de code uitvoeren. Het beste is om gewoon te proberen en te zien of dat in uw workflow past.

Wat dacht je van ;Wat dacht je van ? De puntkomma geeft het einde van een commando aan en de backslash geeft aan dat we verder gaan op de volgende regel. Typ bijvoorbeeldpython` op de opdrachtregel om in de Python interpreter te komen, dan zou

een uitvoer moeten geven van

>>> x=0 ;\
... print(x) ;\
... x=4 ;\
... print(x)

Simpel gezegd, als je wilt leren en meer dan één regel wilt uitvoeren, schrijf je het in een .py bestand.

De trailing backslash methode is goed als je snel een serie commando’s wilt uitvoeren, maar het helpt niet als je aan het leren bent.

Je zult in staat zijn om code beter te ontwikkelen, individuele commando’s te bewerken zonder je zorgen te maken over spelfouten, en stukjes code die je nuttig vindt te hergebruiken als je ze in een klein bestand schrijft.

Ik was net bezig met het antwoord dat je hebt gekregen.Ik bleef experimenteren door verschillende symbolen te gebruiken.Ik heb eindelijk de juiste syntaxis om het te schrijven.Probeer het volgende

print("more string") ; print(3)

dit zal je een resultaat geven

more string

3

zonder enige fout

Ik heb net ‘;’ gebruikt om het in een andere regel te schrijven

Ik hoop dat mijn antwoord je kan helpen

Ik heb zojuist het volgende getypt op mijn shell prompt, en het werkte prima:

$ python
Python 2.7.3 (default, Aug 1 2012, 05:16:07) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> my_age = 35
>>> my_eyes = 'Blue'
>>> print "my age is %d and my eye color is %s" % (my_age, my_eyes)
my age is 35 and my eye color is Blue
>>>

De manier om meer dan één regel code te typen in de interactieve Python interpreter is, nou ja, om meer dan één regel code te typen in de interactieve Python interpreter. Ik zou denken dat dat goed genoeg zou zijn voor jouw doeleinden.

Het is waar dat je een nieuwe prompt krijgt na elke regel, wat betekent dat als twee van je regels code uitvoer produceren, die uitvoer zal worden gescheiden door prompts. Ik denk dat dat is waar je je zorgen over maakt, hoewel het voorbeeld in je vraag dat niet suggereert:

$ python
Python 2.7.3 (default, Aug 1 2012, 05:16:07) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print "first line"
first line
>>> print "second line"
second line
>>>

Als dat een probleem is, kun je je meervoudige statements omsluiten in een (goed ingesprongen!) if statement:

$ python
Python 2.7.3 (default, Aug 1 2012, 05:16:07) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> if 1:
... print "first line"
... print "second line"
... 
first line
second line
>>>

(Ik stel voor, ook al beantwoordt dat je vraag niet, dat als je code schrijft die complex genoeg is om er iets toe te doen, je scripts zou moeten schrijven. Misschien ben je daarmee begonnen in de anderhalf jaar sinds je de vraag stelde).

Verlaat gewoon de commandoregel en open een nieuw editor bestand. Dat wil zeggen, ga naar bestand en open een nieuw bestand. Schrijf zoveel regels code als je wilt.

Bij de drie puntjes moet u op de “tab” toets drukken voordat u het volgende commando invoert. Op die manier kun je zoveel commando’s blijven schrijven. Dus als je op enter drukt na het schrijven van je tweede regel code, laat de interpreter je de derde regel code invoeren… zoals in het Fibonacci voorbeeld hieronder (uit de tutorial):

a,b=0,1 while b<10: … print(b) # Als je direct na de puntjes het print-commando invoert en op het einde op enter drukt, krijg je een inspringfout. In plaats daarvan druk je op de tab na de drie puntjes, dan schrijf je je code en druk je op de enter toets, het zal je de derde regel code laten invoeren en zo verder. Kijk naar onderstaand voorbeeld (uit de tutorial):

a,b=0,1 # Gevolgd door enter toets terwijl b<10: # Gevolgd door enter toets … print(b) # Gevolgd door enter toets. let op de tab na de drie puntjes … a,b=b,a+b # Gevolgd door enter toets …enter toets # Geen commando’s meer om in te voeren

je zult het resultaat zien van het bovenstaande prog