Python print() question

The python print command supports a key parameter for suppressing lf/cr so that consecutive print statements print to the same line; as shown in the first snippet of code.

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

prints this:

hello* world

I would like to pass a string to a function and have it print to the same line or not according to the presence or otherwise of the key parameter.

Unfortunately the print command does not recognize the key parameter if it is embedded in a passed string. See below for example

x = 'hello' + ',' + 'end="*"'
print(x)

prints this:

hello,end="*"

I have tried a variety of variations including str(), and eval() and am currently looking into exec() but so far with no success.
Can anyone help please?

I am not quite sure what you are trying to do. The named parameter called “end” is a parameter, not part of the string to be printed, so it is not surprising that it does not work embedded in the string. Your example

x = 'hello' + ',' + 'end="*"'
print(x)

is effectively the same as

print('hello,end="*"')

so you should expect that result. The named parameter “end” has to be a separate parameter to the print function.

As far as I understand your question, you want to be able to pass a string to a function, and have it print a newline at the end, or not, depending on some criterion?

What about

def report(a, same_line=False)
    if same_line:
        print(a, end='')
    else:
        print(a)

Then you can do

report("Stay on the same line after this", True)
report("This will have a line break after")

The “same_line” parameter would be optional and defaults to False.

(Not tested.)

If that is not what you are trying to do, could you explain more fully?

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

Tested :-)

Another solution is to have all your prints use end=’’ and pass the newlines explicitly in the strings where needed.
e.g.

string = "hello\nworld\n"
print(string, end='')

Having reread my post I can see it could have been better framed. Sorry for that.

What I want to do is to pass the print parameters to a function and have the function print the passed string and if present respect any key parameters.

Something like this:

# function with arg and *kwargs   NOT WORKING

def cat_print(args*, **kwargs):
    pstr = ""
    for a in args:
        pstr += a

    for key, value in kwargs.items():
        kstr = key + '= "' + str(value) + '"'

  print(pstr, eval(kstr))


  printv("A  ", "B ", "C ", end="")
  printv("D ", "E ", "F ") 

I hoped to persuade the print object to accept a variable containing a keyword pair.
Perhaps it would be better to generate the print statement in the function and execute it?

So you want to create a function, e.g., “cat_print” which can take a variable number of unnamed arguments which will be concatenated into a single string. And that string will then be printed by the normal “print” function with any named arguments to cat_print passed through to print unaltered?

Firstly, have you tried

print("A", "B", "C", sep='', end='')

Because setting “sep” (the separator) will stop the arguments being separated by spaces, if that is what you are wanting. At the moment your proposed cat_print is pretty much the same as print with sep=’’.

So you want to create a function, e.g., “cat_print” which can take a variable number of unnamed arguments which will be concatenated into a single string. And that string will then be printed by the normal “print” function with any named arguments to cat_print passed through to print unaltered?

Yes that sums it up nicely. The print needs to be in a function because it logs to a file depending on the state of a debug flag. I don’t want to clutter my code with conditional debug stuff.

So the problem is how to execute a print statement in a function using passed parameters.

There is no problem with the strings, but I don’t know how to send keyword args to print() short of generating the print() statement on-the-fly and then using exec() to run it.

Understand that this is a Python-specific question, which has no RISC OS-dependant components in it. As such, there is a wealth of information on the web about how to handle keyword arguments – searching for ‘how to pass keyword arguments in python’ will give you a selection of answers. Try https://stackoverflow.com/questions/42724242/how-can-i-pass-keyword-arguments-as-parameters-to-a-function for an explicit answer.

However, to answer the question directly…

You’ve already understood that you need to gather the keyword arguments in a kwargs parameter. When you use **kwargs in the function arguments, this populates kwargs with the keyword arguments as a dictionary. You can see this if you print the name of the class. This means you can manipulate those keyword parameters just as you would any other dictionary.

To see this:

>>> def foo(**kwargs):
...     print("kwargs is a {}".format(kwargs.__class__.__name__))
... 
>>> foo(mykeyword=1)
kwargs is a dict

If I’ve understood correctly you’re just wanting to take the non-keyword arguments that you’ve been given and print them, with similar semantics to the print function’s keyword arguments. Matthew’s given you a perfect way to do it with the separator. But let’s just say that you want to make the sep='' implicit, rather than explicit – so that you can do your cat_print("a", "b", "c", end='') and have the string “abc” come out.

You might do it like this:

def cat_print(*args, **kwargs):
    kwargs['sep'] = ''
    print(*args, **kwargs)

When the args variable is specified as *args<code> in the function arguments, it is populated as a tuple of the non-keyword arguments. That is, <code>kwargs gets the keyword arguments as a dictionary, and args gets the non-keyword arguments as a tuple.

When you call a function with a tuple prefixed by a *, eg *args it turns the tuple back into non-keyword arguments.

In the same way, if you call a function with a dictionary prefixed by a **, eg **kwargs it turns the dictionary back into keyword arguments.

Between the function entry and the call of the function, we can change the arguments (or we could even create a whole other dictionary to use). In this case, the sep keyword argument is being forced to be empty, which causes the following print to use no separator.

At the command line:

>>> def cat_print(*args, **kwargs):
...     kwargs['sep'] = ''
...     print(*args, **kwargs)
... 
>>> cat_print("a", "b", "c")
abc
>>> cat_print("a", "b", "c", end="<EOL>")
abc<EOL>>>>

The print needs to be in a function because it logs to a file depending on the state of a debug flag. I don’t want to clutter my code with conditional debug stuff.

It would have been really helpful to have had that little piece of information at the outset, because it would have very much helped us understand what you were actually aiming for! Thank you to Charles for the very helpful reply. I had been going to write a bit more, but I was having trouble Googling to find out how to pass *args and **kwargs on to another function within the function. I did not realise how simple it was.

Thanks Charles I will study your reply and implement it as best I can.

Thanks Matthew also.

with regard to:

It would have been really helpful to have had that little piece of information at the outset,

I did say in the second sentence in the original post:

I would like to pass a string to a function and have it print to the same line or not according to the presence or otherwise of the key parameter.
Unfortunately the print command does not recognize the key parameter if it is embedded in a passed string. See below for example

I know you said that, but as you did not explain the purpose of the function, it was harder to understand why you wanted to do this, rather than just use print direct. I know that your description was literally correct, but a bit more context often helps. There might have been a really excellent logging function that someone might have recommended instead, for example. (There are several Python logging tools.)

We got there in the end, anyway!

If you are logging to a file from Python use the standard logging module, rather than reinventing the wheel.