trouble understanding None

[Jakle]

I'm trying to write a program (with my very limited knowledge of python)
that will convert text I type into those letters drawn with ascii symbols. I
did 2 letters then went to test it. Here's the code I have so far:

*******************************************
def S():
print " ________ "
print " /--------\ "
print "// \\"
print "|| ^^"
print "|| "
print "\\________ "
print " \--------\ "
print " \\"
print " ||"
print "_ ||"
print "\\________//"
print " \--------/ ",

def T():
print "______________"
print "------ ------"
print " || "
print " || "
print " || "
print " || "
print " || "
print " || "
print " || "
print " || "

print S(), T()
*******************************************

WOW, that came out weird, but if you copy/paste it into idle it looks fine.
That an "S" and a "T". Anyways, The idea is to have a function for each
letter, then use a for loop and a ton of if statements to traverse and print
the letters/functions. I understand that I might be doing too much work to
do this, but I'm trying to practice what I am learning. OK, the test prints
the letters, but also prints "None" at the end of each function. I don't
understand it. I'm reading "How To Think Like A Computer Scientist: Learning
With Python", and it only has one little paragraph about the "None" return
value, and that's only regarding conditional statements. If someone could
throw some wisdom my way I'm be very greatful. Thanks ahead of time.

 

[Ben Finney]

WOW, that came out weird, but if you copy/paste it into idle it looks
fine.

It looks fine in any newsreader and editor that uses a fixed-pitch font.
This is highly recommended, since you know that the spacing of the text
you type will be the same for any other fixed-pitch font (as used by
other people). This can't be said of any proportional font.

 

[Edo]

You should not print the function result, just invoke them.

Ed.

 

[Ben Finney]

def S():
# [print a bunch of stuff]

def T():
# [print a bunch of other stuff]

print S(), T()
*******************************************

OK, the test prints the letters, but also prints "None" at the end of
each function.

That's because you've asked for the following sequence of events:

- Invoke S()...
- which prints a bunch of stuff
- then returns None.
- Print the return value of S().
- Invoke T()...
- which prints a bunch of other stuff
- then returns None.
- Print the return value of T().

If you just want the functions invoked (called) instead of getting their
return value and printing it, then do that.

Define the function:
... print "Bunch of stuff"
...

Print the return result of S(), which necessitates calling the function
and doing whatever is inside it:
Bunch of stuff
None

Call the function, thus doing whatever is inside it, then throw away the
return value:
Bunch of stuff


Please try to get into the practice of reducing the problem you want to
describe to a minimal working example. This often has the side effect
that you understand the problem better, and don't end up needing to
post it. In the cases where that doesn't happen, at least you've got
something that doesn't have irrelevant extra code in it.

 

[Alex Martelli]

Ben Finney wrote:
...

Please try to get into the practice of reducing the problem you want to
describe to a minimal working example. This often has the side effect
that you understand the problem better, and don't end up needing to
post it. In the cases where that doesn't happen, at least you've got
something that doesn't have irrelevant extra code in it.

Excellent advice! For lots more excellent advice on how to best ask
questions on Usenet and technical mailing lists, also see

http://www.catb.org/~esr/faqs/smart-questions.html


Alex

 

[Peter Otten]

I'm trying to write a program (with my very limited knowledge of python)
that will convert text I type into those letters drawn with ascii symbols.
I did 2 letters then went to test it. Here's the code I have so far:
[...]

WOW, that came out weird, but if you copy/paste it into idle it looks
fine. That an "S" and a "T". Anyways, The idea is to have a function for
each letter, then use a for loop and a ton of if statements to traverse
and print the letters/functions. I understand that I might be doing too
much work to do this, but I'm trying to practice what I am learning. OK,
the test prints the letters, but also prints "None" at the end of each
function. I don't understand it. I'm reading "How To Think Like A Computer
Scientist: Learning With Python", and it only has one little paragraph
about the "None" return value, and that's only regarding conditional
statements. If someone could throw some wisdom my way I'm be very
greatful. Thanks ahead of time.

Never put print statements into functions that shall themselves produce a
printable result

Be aware that in order to get a single printable backslash, you have to put
it twice into a string constant:
\

For a learning experience it would probably be best to stick with your
approach and just write

S(); T(); S()

instead of

print S(), T(), S()

The next step would then be to put the functions into a dictionary and look
them up:

d = {"S": S, "T": T}
for c in "some string":
d[c]()

However, you did appeal to the "child in the man", so I put together some
code that does what you want but didn't dare ask
I won't go into the details, but the concept is to store an entire line of
text and translate it into the twelve partial lines of your ascii art
charset. With

print >> obj, "some string"

you can redirect the output to any obj that provides a write(s) method.

Peter


import sys
charset = { "S":
[
" ________ ",
" /--------\ ",
"// \\\\",
"|| ^^",
"|| ",
r"\\________ ",
r" \--------\ ",
" \\\\",
" ||",
"_ ||",
r"\\________//",
r" \--------/ ",
],
"T":
[
"______________",
"------ ------",
" || ",
" || ",
" || ",
" || ",
" || ",
" || ",
" || ",
" || ",
" || ",
" || ",
],
" ":
[" "] * 12
}

class Big:
def __init__(self, charset=charset, height=None, write=None,
defaultchar=" "):
self.charset = charset
if height is None:
height = len(charset.itervalues().next())
self.height = height
self.cache = []
self.defaultchar = charset[defaultchar]
if write is None:
write = sys.stdout.write
self.rawWrite = write

def _writeLine(self):
line = [self.charset.get(c, self.defaultchar) for c in
"".join(self.cache)]
self.cache = []
for row in range(self.height):
self.rawWrite("".join([c[row] for c in line]))
self.rawWrite("\n")

def write(self, s):
while True:
pos = s.find("\n")
if pos == -1:
break
self.cache.append(s[os])
self._writeLine()
s = s[pos+1:]
self.cache.append(s)
def close(self):
self.write("\n")

big = Big()

print >> big, "ST", "TS"
print >> big, "STS"
print >> big, "S\nT\nS"
print >> big, "TS",
big.close()

 

[Andrew Dalke]

Jakle:

I'm trying to write a program (with my very limited knowledge of python)
that will convert text I type into those letters drawn with ascii symbols.

BTW, if you get really into this you might want to take a look
at figlet (http://www.figlet.org/ ) which both does this and provides
fonts for you to do your own ASCII graphics.

Andrew
(e-mail address removed)

 

[Terry Reedy]

import sys
charset = { "S":
[
" ________ ",
" /--------\ ",
"// \\\\",
"|| ^^",
"|| ",
r"\\________ ",
r" \--------\ ",
" \\\\",
" ||",
"_ ||",
r"\\________//",
r" \--------/ ",
],

Unless the OP actually needs a list of lines, I think I would make the
value corresponding to each letter one string with embedded newlines:
bigletter = {
'S': r'''
________
/--------\
// \\
|| ^^
||
\\________
\--------\
\\
||
_ ||
\\________//
\--------/'''

# etc
}
print bigletter['S']

This is very easy to edit (with a fixed pitch editor), aud to use.

print bigletter['S']

________
/--------\
// \\
|| ^^
||
\\________
\--------\
\\
||
_ ||
\\________//
\--------/

The only real problem is (maybe) the extra newline at the beginning of
the file, which makes the first line line-up with the rest. The raw
mode input makes it impossible (as far as I know) to escape it (with
the usual '\', which gets printed instead). So one could either
postprocess the dict to slice all values or delete the initial newline
in the source code after getting the letter right.

Terry J. Reedy

 

[Peter Otten]

Unless the OP actually needs a list of lines, I think I would make the
value corresponding to each letter one string with embedded newlines: [...]
This is very easy to edit (with a fixed pitch editor), aud to use.

Yes, this would be a cleaner approach.

The only real problem is (maybe) the extra newline at the beginning of
the file, which makes the first line line-up with the rest. The raw
mode input makes it impossible (as far as I know) to escape it (with
the usual '\', which gets printed instead). So one could either
postprocess the dict to slice all values or delete the initial newline
in the source code after getting the letter right.

I mixed normal and raw strings because I recalled a problem with backslashes
at the end of a raw string. I've since found out that this applies only to
a single last backslash at the end of the string:
File "<stdin>", line 1
r"\"
^
SyntaxError: EOL while scanning single-quoted string
For my Big writer class , that somewhat extends the original task,
postprocessing would be the way to go, because of other problems:

- every line of a character must be of the same length
- every character must have the same height
- if character definitions with different heights are allowed, additional
information about the baseline is required for the program to decide where
to fill in the blank lines


Peter

 

[Alex Martelli]

Peter Otten wrote:
...

I mixed normal and raw strings because I recalled a problem with
backslashes at the end of a raw string. I've since found out that this
applies only to a single last backslash at the end of the string:

Nope, any ODD number of backslashes at the end (1, 3, 5, 7, ...).


Alex