print with no newline

[Paul Watson]

I thought that using a comma at the end of a print statement would suppress
printing of a newline. Am I misunderstanding this feature? How can I use
print and not have a newline appended at the end?

C:\src\projects\test1>python -c "import sys;print sys.version, 'running on',
sys.platform"
2.3.4 (#53, May 25 2004, 21:17:02) [MSC v.1200 32 bit (Intel)] running on
win32

C:\src\projects\test1>python -c "print 'here'," >jjj

C:\src\projects\test1>od -c jjj
0000000 h e r e \r \n
0000006


$ python -c "import sys;print sys.version, 'running on', sys.platform"
2.1 (#1, May 23 2003, 11:43:56) [C] running on aix4

$ cat eoltest.py
#!/usr/bin/env python
print 'here',

$ ./eoltest.py >jjj

$ od jjj
0000000 068 065 072 065 00a
h e r e \n
0000005

 

[Jp Calderone]

I thought that using a comma at the end of a print statement would suppress
printing of a newline. Am I misunderstanding this feature? How can I use
print and not have a newline appended at the end?

Print doesn't want to leave the *final* line without a newline.
sys.stdout.write() doesn't care if your shell prompt gets mixed in with
the last line of output. You'll need to use the latter if that's what
you want.

exarkun@boson:~$ python -c "import sys; sys.stdout.write('here')"
hereexarkun@boson:~$

Jp

 

[Larry Bates]

Print with no newline only works to stdout.
If you want to write to a file without
newlines use fp.write("text").

import sys
fp=open('jjj','w')
fp.write(sys.version)
fp.write('running on')
fp.write(sys.platform)
fp.close()

after running jjj contains:

2.2.2 (#37, Nov 26 2002, 10:24:37) [MSC 32 bit (Intel)]running onwin32

HTH,
Larry Bates
Syscon, Inc.

 

[Peter Otten]

I thought that using a comma at the end of a print statement would
suppress
printing of a newline. Am I misunderstanding this feature? How can I use
print and not have a newline appended at the end?

I thought that, too. It turns out that Python writes an additional newline
on exit if the softspace flag is set. So

$ python -c "import sys; print 'here',; sys.stdout.softspace = False" >
tmp.txt
$ od -c tmp.txt
0000000 h e r e
0000004

is a viable if ugly workaround.

Peter

 

[Paul Watson]

Print doesn't want to leave the *final* line without a newline.
sys.stdout.write() doesn't care if your shell prompt gets mixed in with
the last line of output. You'll need to use the latter if that's what
you want.

exarkun@boson:~$ python -c "import sys; sys.stdout.write('here')"
hereexarkun@boson:~$

Jp

Ok, I can use sys.stdout.write(). Still, this comma at the end thing does
not seem very consistent. Before the last line, while it does suppress the
newline, a space is still added to the output. Why is that? Yes, I have
seen spaces added between items in the print statement and, while it is
probably convenient at times, is frequently an annoyance.

C:\src\projects\test1>python -c "print 'here',;print 'there'," >jjj

C:\src\projects\test1>od -c -tx1 jjj
0000000 h e r e t h e r e \r \n
68 65 72 65 20 74 68 65 72 65 0d 0a
0000014

 

[Jp Calderone]

Ok, I can use sys.stdout.write(). Still, this comma at the end thing does
not seem very consistent. Before the last line, while it does suppress the
newline, a space is still added to the output. Why is that? Yes, I have
seen spaces added between items in the print statement and, while it is
probably convenient at times, is frequently an annoyance.

Basically, print is only meant to help people new to the language get
started It often does what will make life easiest for someone who is
just getting into things, but which is otherwise confusing, expected,
special-casey, or otherwise undesirable. I mean, the whole existence of
the keyword "print" is an inconsistency, right? One could quite
reasonably expect print to be a function.

Jp

 

[Benjamin Niemann]

You are not the only one, who feels that the behaviour of print is not
optimal. Thta's why it is on the list of things to be dropped with
Python 3. See PEP 3000 or "Python Regrets"
(http://www.python.org/doc/essays/ppt/regrets/PythonRegrets.pdf)

 

[Paul Watson]

I thought that, too. It turns out that Python writes an additional newline
on exit if the softspace flag is set. So

$ python -c "import sys; print 'here',; sys.stdout.softspace = False" >
tmp.txt
$ od -c tmp.txt
0000000 h e r e
0000004

is a viable if ugly workaround.

Peter

Many thanks for pointing out File.softspace attribute. However, I get mixed
results when using it. I am sure there is some logic to it somewhere. It
does not appear to control the end of line. The online doc says that it
controls putting a space -before- another value. The File.softspace.__doc__
string appears to need review also. I think I am ready to use File.write()
and move on.

C:\src\projects\test1>type eoltest.py
#!/usr/bin/env python
import sys
print 'here', 'and'
sys.stdout.softspace = False
print 'here', 'and'
sys.stdout.softspace = True
print 'here', 'and'
sys.stdout.softspace = False
print 'there',

C:\src\projects\test1>eoltest.py
here and
here and
here and
there

C:\src\projects\test1>eoltest.py >jjj

C:\src\projects\test1>od -c -tx1 jjj
0000000 h e r e a n d \r \n h e r e a
68 65 72 65 20 61 6e 64 0d 0a 68 65 72 65 20 61
0000020 n d \r \n h e r e a n d \r \n t
6e 64 0d 0a 20 68 65 72 65 20 61 6e 64 0d 0a 74
0000040 h e r e \r \n
68 65 72 65 0d 0a
0000046

C:\src\projects\test1>python -c "import sys;print
sys.stdout.softspace.__doc__"
int(x[, base]) -> integer

Convert a string or number to an integer, if possible. A floating point
argument will be truncated towards zero (this does not include a string
representation of a floating point number!) When converting a string, use
the optional base. It is an error to supply a base when converting a
non-string. If the argument is outside the integer range a long object
will be returned instead.

 

[Peter Otten]

Many thanks for pointing out File.softspace attribute. However, I get
mixed
results when using it. I am sure there is some logic to it somewhere. It
does not appear to control the end of line. The online doc says that it
controls putting a space -before- another value. The

The softspace is normally set when a string is printed but cleared when a
newline is encountered. The print statement uses it to determine whether a
space should precede the string it is about to write. By clearing it
manually you can omit the space between two strings:
abcdef

When the program is terminated, the flag is (ab)used to determine whether a
line was started but not finished. Only then it controls whether a newline
is printed or not. My original idea was to register an exit handler that
does that, but it turned out that would be too late.

File.softspace.__doc__
string appears to need review also.

The softspace attribute is just an ordinary integer, i. e. you get the same
docstring you get for any int instance - the docstring of the int class:

True

I think I am ready to use File.write() and move on.

No objections here

Peter

 

[Bengt Richter]

I thought that, too. It turns out that Python writes an additional newline
on exit if the softspace flag is set. So

$ python -c "import sys; print 'here',; sys.stdout.softspace = False" >
tmp.txt
$ od -c tmp.txt
0000000 h e r e
0000004

is a viable if ugly workaround.

When I want printf-like control, I sometimes use (IIRC from last time ;-)

Regards,
Bengt Richter