Python -- How do you view output that doesn't fit the screen?

I should say I'm looking for a solution to the problem of viewing output that does not fit on your screen. For example, range(100) will show the last 30ish lines in your terminal of 30 height.

I am only looking to be nudged in the right direction and am curious how you guys have approached this problem.

What have you done when you run into a situation where you wish you could conveniently scroll through some large output?

Best Answer

Use the scrollback buffer on your terminal.

If you're using GNU Screen, it can be set with defscrollback 1000 or any other number in HOME/.screenrc.

Use Ctrl-a, [ to enter copy mode

j -    Move the cursor down by one line
k -    Move the cursor up by one line
C-u -  Scrolls a half page up.
C-b -  Scrolls a full page up.
C-d -  Scrolls a half page down.
C-f -  Scrolls the full page down.
G -    Moves to the specified line 

The best part is ? for reverse search, / for forward search while in copy mode.

Super convenient.

Thank you!

Original question:

What is the python equivalent of the bash less command?

LongString | less 

Is there something like that for python? I find myself thinking I could use it fairly often but just move on and find some other solution.

By "long things" I mean anything that generates more output lines than my screen. 1000 print messages, a dictionary, a large string, range(1000), etc.

My googlefu has failed.

just for fun :o)

Original version for Python2:

class Less(object):
    def __init__(self, num_lines):
        self.num_lines = num_lines
    def __ror__(self, other):
        s = str(other).split("\n")
        for i in range(0, len(s), self.num_lines):
            print "\n".join(s[i: i + self.num_lines])
            raw_input("Press <Enter> for more")

less = Less(num_lines=30)  
"\n".join(map(str, range(100))) | less

a Python3 version:

class Less(object):
    def __init__(self, num_lines):
        self.num_lines = num_lines
    def __ror__(self, other):
        s = str(other).split("\n")
        for i in range(0, len(s), self.num_lines):
            print(*s[i: i + self.num_lines], sep="\n")
            input("Press <Enter> for more")

less = Less(num_lines=30)  
"\n".join(map(str, range(100))) | less

If you want to do this for an interactive python session, you should use a terminal emulation that allows you to scroll back up. I believe most of them do.

If you're using an actual terminal, or if you don't have a choice of terminal emulators, perhaps you can use GNU screen.

(If you're using Windows, you can change the screen buffer size to allow scrolling back up to 9999 lines).

And if you need this for the output of your program, you can try to use the curses module to implement scrolling yourself.

Yes, there is a way and it is quite trivial, that's why not specifically described. Say you have long list and want to see just the beginning:

>>> lst = range(1000)   # let's make list of thousand elements
>>> lst[:100]           # i want to see just the first 100
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> lst[100:201]        # ok, now the 2nd hundred 
[100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200]
>>> lst[-100:]          # and now just the last 100, pretty please?
[900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999]

The same [] slicing works the same for strings. For dictionary you can cheat somehow, like using str() to convert it to string and then display with the same slicing :-)

Say you're writing a program in Python and all it does is pretty print some stuff. The output is in prettiest_print_ever. You already do weird tricks importing fcntl, termios, struct and friends to get the terminal size so that you can use the full width of the terminal (if any); that also gives you the screen height, so it makes sense to use it. (That also means you've long given up any pretenses of cross-platform compatibility, too.)

Sure, you can reinvent the wheel, or you can rely on less like other programs do (e.g. git diff). This should be the outline of a solution:

def smart_print(prettiest_print_ever, terminal_height = 80):
  if len(prettiest_print_ever.splitlines()) <= terminal_height:
    #Python 3: make sure you write bytes!
    sys.stdout.buffer.write(prettiest_print_ever.encode("utf-8"))
  else
    less = subprocess.Popen("less", stdin=subprocess.PIPE)
    less.stdin.write(prettiest_print_ever.encode("utf-8"))
    less.stdin.close()
    less.wait()

If you work in ipython you can issue shell commands within your interactive python session. That means that you just do

In [1]: less myfile.txt

I also really like being able to arrow up and down to get previous commands and getting the output from previous commands by doing something like

In [33]: print cos(Out[7]*pi/180)

There's one fundamental difference between less run in a shell, and Python: Python is a programming language, less is a program.

Bash is aware of what the linecount is in the console, and less can query that (and a number of other things), Python on its own can't be, it's a language and it's agnostic to its environment (that's left to libraries).

On top of that, less obeys some of its own standards. Careted lines get moved to top, it feeds to termcap, it's conceptually part of the OS tools, and it's meant to send to output even if it hasn't finished reading the file.

You can write less in Python if you want, or run it from inside a python script, but its functionality is more (and too specific) than a single method of file should contain.

if your data is json serilizable then you can try

import simplejson
print simplejson.dumps({'shipping-line': {'price': '0.00', 'code': 'Local Pickup (Portland, OR)', 'title': 'Local Pickup (Portland, OR)'}}, indent=4)

Output will be look something like

{
    "shipping-line": {
        "price": "0.00", 
        "code": "Local Pickup (Portland, OR)", 
        "title": "Local Pickup (Portland, OR)"
    }
}

this is specifically used to debug and to see the actual content......in well readble format..

EDIT:

if your screen is limited to 25 lines..........

import simplejson
data = simplejson.dumps({'shipping-line': {'price': '0.00', 'code': 'Local Pickup (Portland, OR)', 'title': 'Local Pickup (Portland, OR)'}}, indent=4)

cnt = 0

for line in data.split('\n'):
    cnt+=1
    print line
    raw_input() if cnt%25==0 else None

It's easy to write your own:

def less(s, line_count = 5):
    lines = []
    for i, line in enumerate(s.split('\n'), 1):
        lines.append(line)
        if (i % line_count) == 0:
            yield '\n'.join(lines)
            lines = []

    if lines:
        yield '\n'.join(lines)

What have you done when you run into a situation where you wish you could conveniently > scroll through some large output?

1. Don't create large output. Use functions to summarize or show selected details.

2. Simplify the application to avoid creating large output in the first place.

3. Focus what I'm looking at to avoid large output.

4. Generally avoid large output.

It seems simpler to avoid large output than to fuss around trying to display something I never cared about in the first place.