නව රේඛාවක් හෝ ඉඩක් නොමැතිව මුද්‍රණය කරන්නේ කෙසේද?

මම ඒක ඇතුලට කරන්න කැමතියි python. මෙම උදාහරණයේ දී මා කුමක් කිරීමට කැමති ද?ඇ:

සී හි:

#include <stdio.h>

int main() {
    int i;
    for (i=0; i<10; i++) printf(".");
    return 0;
}

ප්‍රතිදානය:

..........

පයිතන්හි:

>>> for i in range(10): print('.')
.
.
.
.
.
.
.
.
.
.
>>> print('.', '.', '.', '.', '.', '.', '.', '.', '.', '.')
. . . . . . . . . .

පයිතන්හි අවකාශයක් හෝ ඉඩක් printඑකතු කරනු ඇත \n, මම එය වළක්වා ගන්නේ කෙසේද? දැන්, එය උදාහරණයක් පමණි, මට මුලින්ම නූලක් සාදා එය මුද්‍රණය කළ හැකි යැයි මට නොකියන්න. නූල් එකතු කරන්නේ කෙසේදැයි දැන ගැනීමට මම කැමතියි stdout.

පයිතන් 3 හි, ඔබට ශ්‍රිතයේ sep=සහ end=පරාමිතීන් භාවිතා කළ හැකිය print:

නූල් කෙළවරට නව රේඛාවක් එක් නොකිරීමට:

print('.', end='')

ඔබට මුද්‍රණය කිරීමට අවශ්‍ය සියලුම ශ්‍රිත තර්ක අතර ඉඩක් එක් නොකිරීමට:

print('a', 'b', 'c', sep='')

ඔබට ඕනෑම පරාමිතියකට ඕනෑම නූලක් යැවිය හැකි අතර ඔබට පරාමිති දෙකම එකවර භාවිතා කළ හැකිය.

ඔබට බෆරින් කිරීමේ ගැටලුවක් තිබේ නම්, flush=Trueමූල පදය එකතු කිරීමෙන් ඔබට ප්‍රතිදානය ගලා යා හැකිය :

print('.', end='', flush=True)

පයිතන් 2.6 සහ 2.7

Python 2.6 වෙතින් ඔබට මොඩියුලයprint භාවිතා කර Python 3 වෙතින් ශ්‍රිතය ආයාත කළ හැකිය :__future__

from __future__ import print_function

එමඟින් ඔබට ඉහත පයිතන් 3 විසඳුම භාවිතා කිරීමට ඉඩ ලබා දේ.

කෙසේ වෙතත්, පයිතන් 2 වෙතින් ආනයනය කරන flushලද printශ්‍රිතයේ අනුවාදය තුළ මූල පදය නොමැති බව සලකන්න __future__; එය ක්‍රියාත්මක වන්නේ පයිතන් 3 හි පමණි, වඩාත් නිශ්චිතවම 3.3 සහ පසුව. පෙර සංස්කරණ වලදී ඔබට ඇමතුමක් සමඟ අතින් ගලා යා යුතුය sys.stdout.flush(). ඔබ මෙම ආනයනය කරන ගොනුවේ අනෙක් සියලුම මුද්‍රණ ප්‍රකාශ නැවත ලිවීමට සිදුවේ.

නැතහොත් ඔබට භාවිතා කළ හැකිය sys.stdout.write()

import sys
sys.stdout.write('.')

ඔබට ඇමතීමටද අවශ්‍ය විය හැකිය

sys.stdout.flush()

stdoutවහාම විදින බවට සහතික වීම.

ගයිඩෝ වැන් රොසුම් විසින් මෙම සබැඳියේ විස්තර කර ඇති පරිදි එය සරල විය යුතුය:

Re: ac / r නොමැතිව එක් මුද්‍රණයක් කරන්නේ කෙසේද?

http://legacy.python.org/search/hypermail/python-1992/0115.html

යමක් මුද්‍රණය කළ හැකි නමුත් ස්වයංක්‍රීයව කරත්ත ප්‍රතිලාභයක් එයට එකතු කර ගත නොහැකිද?

ඔව්, මුද්‍රණය කිරීමට අවසාන තර්කයෙන් පසුව කොමාව එකතු කරන්න. උදාහරණයක් ලෙස, මෙම ලූපය අවකාශයන් මගින් වෙන් කරන ලද පේළියක 0..9 අංක මුද්‍රණය කරයි. අවසාන නව රේඛාව එක් කරන පරාමිති රහිත “මුද්‍රණය” සැලකිල්ලට ගන්න:

>>> for i in range(10):
...     print i,
... else:
...     print
...
0 1 2 3 4 5 6 7 8 9
>>> 

සටහන: මෙම ප්‍රශ්නයේ මාතෘකාව "පයිතන්හි මුද්‍රණය කරන්නේ කෙසේද?"

මාතෘකාව මත පදනම්ව මිනිසුන් මෙහි පැමිණිය හැකි බැවින්, පයිතන් ද මුද්‍රණ ශෛලියේ ආදේශනයට සහාය දක්වයි:

>>> strings = [ "one", "two", "three" ]
>>>
>>> for i in xrange(3):
...     print "Item %d: %s" % (i, strings[i])
...
Item 0: one
Item 1: two
Item 2: three

තවද, ඔබට අතින් අගයන් ගුණ කළ හැකිය:

>>> print "." * 10
..........

Python2.6 + සඳහා python3- ශෛලියේ මුද්‍රණ ශ්‍රිතය භාවිතා කරන්න (එකම ගොනුවේ දැනට පවතින ඕනෑම යතුරු පද මුද්‍රිත ප්‍රකාශයක් බිඳ දමනු ඇත.)

# for python2 to use the print() function, removing the print keyword
from __future__ import print_function
for x in xrange(10):
    print('.', end='')

ඔබගේ සියලු python2 මුද්‍රණ වචන විනාශ නොකිරීමට, වෙනම printf.pyගොනුවක් සාදන්න

# printf.py

from __future__ import print_function

def printf(str, *args):
    print(str % args, end='')

ඉන්පසු එය ඔබගේ ගොනුවේ භාවිතා කරන්න

from printf import printf
for x in xrange(10):
    printf('.')
print 'done'
#..........done

Printf ශෛලිය පෙන්වන තවත් උදාහරණ

printf('hello %s', 'world')
printf('%i %f', 10, 3.14)
#hello world10 3.140000

එකම පේළියේ මුද්‍රණය කරන්නේ කෙසේද:

import sys
for i in xrange(0,10):
   sys.stdout.write(".")
   sys.stdout.flush()

නව (පයිතන් 3.x හි) printශ්‍රිතයට විකල්ප endපරාමිතියක් ඇත, එය ඔබට අවසන් අක්‍ෂරය වෙනස් කිරීමට ඉඩ දෙයි:

print("HELLO", end="")
print("HELLO")

ප්‍රතිදානය:

හලෝ හලෝ

sepබෙදුම්කරු සඳහා ද තිබේ:

print("HELLO", "HELLO", "HELLO", sep="")

ප්‍රතිදානය:

හලෝ හලෝ හලෝ

ඔබට මෙය පයිතන් 2.x හි භාවිතා කිරීමට අවශ්‍ය නම් ඔබේ ගොනුවේ ආරම්භයේදීම මෙය එක් කරන්න:

from __future__ import print_function

Printf නමින් නව ශ්‍රිතයක් නිර්මාණය කිරීම සඳහා functools.partial භාවිතා කිරීම

>>> import functools

>>> printf = functools.partial(print, end="")

>>> printf("Hello world\n")
Hello world

පෙරනිමි පරාමිතීන් සමඟ ශ්‍රිතයක් එතීමට පහසුම ක්‍රමය.

ඔබට ශ්‍රිතයේ ,අවසානයේ එකතු කළ හැකි printබැවින් එය නව පේළියේ මුද්‍රණය නොවේ.

Python 3+ හි, printශ්‍රිතයකි. ඔබ අමතන විට

print('hello world')

පයිතන් එය පරිවර්තනය කරයි

print('hello world', end='\n')

endඔබට අවශ්‍ය ඕනෑම දෙයකට වෙනස් කළ හැකිය .

print('hello world', end='')
print('hello world', end=' ')

python 2.6+ :

from __future__ import print_function # needs to be first statement in file
print('.', end='')

පයිතන් 3 :

print('.', end='')

python <= 2.5 :

import sys
sys.stdout.write('.')

පයිතන් 2 හි එක් එක් මුද්‍රණයෙන් පසු අමතර ඉඩක් හරි නම්

print '.',

පයිතන් 2 හි නොමඟ යැවීම - වළක්වා ගන්න :

print('.'), # avoid this if you want to remain sane
# this makes it look like print is a function but it is not
# this is the `,` creating a tuple and the parentheses enclose an expression
# to see the problem, try:
print('.', 'x'), # this will print `('.', 'x') `

ඔබට උත්සාහ කළ හැකිය:

import sys
import time
# Keeps the initial message in buffer.
sys.stdout.write("\rfoobar bar black sheep")
sys.stdout.flush()
# Wait 2 seconds
time.sleep(2)
# Replace the message with a new one.
sys.stdout.write("\r"+'hahahahaaa             ')
sys.stdout.flush()
# Finalize the new message by printing a return carriage.
sys.stdout.write('\n')

ඔබට පහත පරිදි python3 හි එය කළ හැකිය:

#!usr/bin/python

i = 0
while i<10 :
    print('.',end='')
    i = i+1

python filename.pyහෝ සමඟ එය ක්‍රියාත්මක කරන්නpython3 filename.py

මට මෑතකදී එකම ගැටලුවක් තිබුණා ..

මම එය විසඳා ගත්තේ:

import sys, os

# reopen stdout with "newline=None".
# in this mode,
# input:  accepts any newline character, outputs as '\n'
# output: '\n' converts to os.linesep

sys.stdout = os.fdopen(sys.stdout.fileno(), "w", newline=None)

for i in range(1,10):
        print(i)

මෙය යුනික්ස් සහ කවුළු යන දෙකෙහිම ක්‍රියා කරයි ... එය මැකෝස් මත පරීක්ෂා කර නොමැත ...

hth

@lenooh මගේ විමසුම තෘප්තිමත් කළේය. 'පයිතන් මර්දනය නව රේඛාව' සෙවීමේදී මම මෙම ලිපිය සොයා ගතිමි. පුට්ටි සඳහා පයිතන් 3.2 සංවර්ධනය කිරීම සඳහා මම රාස්ප්බෙරි පයි හි IDLE3 භාවිතා කරමි. මට අවශ්‍ය වූයේ පුට්ටි විධාන රේඛාවේ ප්‍රගති තීරුවක් නිර්මාණය කිරීමට ය. පිටුව අනුචලනය කිරීම මට අවශ්‍ය නොවීය. වැඩසටහන නතර වී නැති බවත්, දිවා ආහාරය සඳහා විනෝදජනක අනන්ත පුඩුවක් මත යවා නැති බවත් පරිශීලකයාට විහිළු තහළු නොකිරීමට තිරස් රේඛාවක් අවශ්‍ය විය - 'මාව අත්හරින්න, මම හොඳින් සිටිමි, නමුත් මේ සඳහා යම් කාලයක් ගතවනු ඇත. ' අන්තර්ක්‍රියාකාරී පණිවිඩය - පෙළෙහි ප්‍රගති තීරුවක් වැනි.

මෙම print('Skimming for', search_string, '\b! .001', end='')'001' ලකුණු කසා කාල සීමාව දීර්ඝ, ⌫⌫⌫ rubout පසුව කාලයක් ලෙස backspaces තුනක් මුද්රණය කරනු ලබන ඊලඟ තිරය-ලිවීම්, සූදානම් විසින් පණිවිඩය ආරම්භනය. search_stringගිරවුන්ගේ පරිශීලක ආදානයෙන් පසුව , විරාම ලකුණු නිසි පරිදි ස්ථානගත කරමින් වෙනත් ආකාරයකින් බල කරන අවකාශයට පිටුපසට \b!මගේ search_stringපෙළෙහි විශ්මය ජනක ලක්ෂ්‍යය print()කපා දමයි. ඉන් පසුව අවකාශයක් සහ මා අනුකරණය කරන 'ප්‍රගති තීරුවේ' පළමු 'තිත' ඇත. අනවශ්‍ය ලෙස, පණිවුඩය පිටු අංකය සමඟ ප්‍රමුඛ වේ (ප්‍රමුඛ ශුන්‍යයන් සහිත දිග තුනකට සංයුති කර ඇත) ප්‍රගතිය සැකසෙන බව පරිශීලකයාගේ අවධානයට ලක් කිරීම සඳහා වන අතර එමඟින් අප පසුව ගොඩනඟන කාල පරිච්ඡේද ගණන ද පිළිබිඹු වේ. හරි.

import sys

page=1
search_string=input('Search for?',)
print('Skimming for', search_string, '\b! .001', end='')
sys.stdout.flush() # the print function with an end='' won't print unless forced
while page:
    # some stuff…
    # search, scrub, and build bulk output list[], count items,
    # set done flag True
    page=page+1 #done flag set in 'some_stuff'
    sys.stdout.write('\b\b\b.'+format(page, '03')) #<-- here's the progress bar meat
    sys.stdout.flush()
    if done: #( flag alternative to break, exit or quit)
        print('\nSorting', item_count, 'items')
        page=0 # exits the 'while page' loop
list.sort()
for item_count in range(0, items)
    print(list[item_count])
#print footers here
 if not (len(list)==items):
    print('#error_handler')

ප්‍රගති බාර් මස් sys.stdout.write('\b\b\b.'+format(page, '03'))පේළියේ ඇත. පළමුව, වමට මකා දැමීම සඳහා, එය කර්සරය සංඛ්‍යාත්මක අක්ෂර තුනට ඉහළින් '\ b \ b \ b' out රවුට් ලෙස උපස්ථ කර ප්‍රගති තීරුවේ දිගට එකතු කිරීම සඳහා නව කාල පරිච්ඡේදයක් පහත දමයි. ඉන්පසු එය මේ දක්වා ඉදිරියට ගොස් ඇති පිටුවේ ඉලක්කම් තුනක් ලියයි. sys.stdout.write()සම්පූර්ණ බෆරයක් හෝ ප්‍රතිදාන නාලිකාව වැසෙන තෙක් බලා සිටින නිසා sys.stdout.flush(), වහාම ලිවීමට බල කරයි. sys.stdout.flush()අවසන් බවට ඉදිකර ඇත print()සමග අතුරු මාර්ගයක් වන print(txt, end='' ). ඉන්පසු කේතය එහි ලෞකික කාල දැඩි ක්‍රියාකාරකම් හරහා ලූප වන අතර එය ඉලක්කම් තුනක් ආපසු පිසදැමීමට, කාල පරිච්ඡේදයක් එකතු කර නැවත ඉලක්කම් තුනක් ලිවීමට වැඩි වන තෙක් මෙහි නැවත පැමිණෙන තෙක් වැඩි යමක් මුද්‍රණය නොකරයි.

පිසදැමූ සහ නැවත ලිවූ ඉලක්කම් තුන කිසිසේත් අවශ්‍ය නොවේ - එය sys.stdout.write()එදිරිව එදිරිව නිදර්ශනය කරන සමෘධියක් පමණි print(). කාල පරිච්ඡේදයක් සමඟ ඔබට පහසුවෙන්ම ප්‍රමුඛ විය හැකි අතර විසිතුරු බැක්ස්ලෑෂ්-බී ⌫ බැක්ස්පේස් තුන අමතක කරන්න (ඇත්ත වශයෙන්ම ආකෘතිගත පිටු ගණන් ලිවීමද නොකෙරේ) කාල සීමාව එක් වරකට දිගින් දිගට මුද්‍රණය කිරීමෙන් - අවකාශයන් හෝ නව රේඛා නොමැතිව sys.stdout.write('.'); sys.stdout.flush()යුගල.

රාස්ප්බෙරි පයි අයිඩීඑල් 3 පයිතන් කවචය පසුපස අවකාශය ⌫ රබට් ලෙස ගෞරව නොකරන නමුත් ඒ වෙනුවට අවකාශයක් මුද්‍රණය කරමින් පැහැදිලි අතුරු කොටස් ලැයිස්තුවක් නිර්මාණය කරන බව කරුණාවෙන් සලකන්න.

- (o = 8> විස්

ඉහත සියලු පිළිතුරු නිවැරදි බව ඔබට පෙනෙනු ඇත. නමුත් සෑම විටම අවසානයේ "end = '' පරාමිතිය ලිවීමට කෙටිමඟක් සෑදීමට මට අවශ්‍ය විය.

වැනි ශ්‍රිතයක් ඔබට අර්ථ දැක්විය හැකිය

def Print(*args,sep='',end='',file=None,flush=False):
    print(*args,sep=sep,end=end,file=file,flush=flush)

එය සියලු පරාමිති ගණන පිළිගනී. එය පවා ගොනුව, ෆ්ලෂ් වැනි අනෙකුත් සියලුම පරාමිතීන් එකම නමකින් පිළිගනු ඇත.

මෙම පිළිතුරු බොහොමයක් ටිකක් සංකීර්ණ බව පෙනේ. පයිතන් 3.x හි ඔබ මෙය කරන්නේ:

print(<expr>, <expr>, ..., <expr>, end=" ")

අවසානයේ පෙරනිමි අගය වේ "\n". අපි එය හුදෙක් අවකාශයකට වෙනස් කරන්නෙමු, නැතහොත් සාමාන්‍යයෙන් කරන end=""දේ කිරීමට ඔබට (ඉඩක් නැත) භාවිතා කළ හැකිය printf.

ඔබට ලූපය සඳහා යමක් මුද්‍රණය කිරීමට අවශ්‍යයි; නමුත් සෑම විටම එය නව පේළියේ මුද්‍රණය කිරීමට ඔබට අවශ්‍ය නැත .. උදාහරණයක් ලෙස:

 for i in range (0,5):
   print "hi"

 OUTPUT:
    hi
    hi
    hi
    hi
    hi

නමුත් ඔබට එය මේ ආකාරයෙන් මුද්‍රණය කිරීමට අවශ්‍යයි: හායි හායි හායි හායි හරි ???? "හායි" මුද්‍රණයෙන් පසු කොමාව එක් කරන්න

උදාහරණයක්:

for i in range (0,5): print "hi", OUTPUT: hi hi hi hi hi

නැතහොත් මෙවැනි ශ්‍රිතයක් ඇත:

def Print(s):
   return sys.stdout.write(str(s))

එසේනම් දැන්:

for i in range(10): # or `xrange` for python 2 version
   Print(i)

නිමැවුම්:

0123456789

මෙය කිරීමට පොදු ක්‍රම දෙකක් තිබේ:

පයිතන් 3.x හි නව රේඛාවක් නොමැතිව මුද්‍රණය කරන්න

මුද්‍රණ ප්‍රකාශයෙන් පසුව කිසිවක් එකතු නොකර පහත පරිදි භාවිතා end='' කර '\ n' ඉවත් කරන්න :

>>> print('hello')
hello  # appending '\n' automatically
>>> print('world')
world # with previous '\n' world comes down

# solution is:
>>> print('hello', end='');print(' world'); # end with anything like end='-' or end=" " but not '\n'
hello world # it seem correct output

ලූප් හි තවත් උදාහරණයක් :

for i in range(1,10):
    print(i, end='.')

පයිතන් 2.x හි නව රේඛාවක් නොමැතිව මුද්‍රණය කරන්න

පසුපස කොමාව එකතු කිරීමෙන් මුද්‍රණයෙන් පසු නොසලකා හරින්න \n.

>>> print "hello",; print" world"
hello world

ලූප් හි තවත් උදාහරණයක් :

for i in range(1,10):
    print "{} .".format(i),

මෙය ඔබට උපකාරී වේ යැයි සිතමි. ඔබට මෙම සබැඳියට පිවිසිය හැකිය .

 for i in range(0, 5): #setting the value of (i) in the range 0 to 5 
     print(i)

ඉහත කේතය පහත ප්‍රතිදානය ලබා දෙයි:

 0    
 1
 2
 3
 4

නමුත් ඔබට මෙම සියලු ප්‍රතිදානයන් සරල රේඛාවකින් මුද්‍රණය කිරීමට අවශ්‍ය නම් ඔබ කළ යුත්තේ මුද්‍රණය සඳහා end () නම් ගුණාංගයක් එක් කිරීමයි.

 for i in range(0, 5): #setting the value of (i) in the range 0 to 5 
     print(i, end=" ")

ප්‍රතිදානය:

 0 1 2 3 4

අවකාශයක් පමණක් නොව, ඔබේ ප්‍රතිදානය සඳහා වෙනත් අවසානයන් ද එක් කළ හැකිය. උදාහරණයක් වශයෙන්,

 for i in range(0, 5): #setting the value of (i) in the range 0 to 5 
     print(i, end=", ")

ප්‍රතිදානය:

 0, 1, 2, 3, 4, 

මතක තබා ගන්න:

 Note: The [for variable in range(int_1, int_2):] always prints till the variable is 1

 less than it's limit. (1 less than int_2)

for i in xrange(0,10): print '\b.',

මෙය 2.7.8 සහ 2.5.2 (පිළිවෙලින් වියන් හා ඕඑස්එක්ස් පර්යන්තය) යන දෙකෙහිම ක්‍රියාත්මක විය - මොඩියුල ආනයන හෝ කාල ගමන් අවශ්‍ය නොවේ.

... ඔබට කිසිදු පුස්තකාලයක් ආයාත කිරීමට අවශ්‍ය නැත. මකාදැමීමේ අක්‍ෂරය භාවිතා කරන්න:

BS=u'\0008' # the unicode for "delete" character
for i in range(10):print(BS+"."),

මෙය නව රේඛාව සහ අවකාශය ඉවත් කරයි (^ _ ^) *