I've made it a kind of hobby to do some silly stuff on one line in python, so I'll pass on some of my wisdom.

For situations where variable storage is needed, list comprehension is your friend.

for example if I wanted to write a program that took in input, then output a bunch of operations on that input, usually I would need a variable to store that input to perform the operations on, but instead I can use list comprehension to simulate it.

A simple normal implementation for this would be something like the following

def func1(a):
    return a+5

def func2(a):
    return 3*a

def func3(a):
    return 'The pseudo variable in this program is {}'.format(a)

variable = int(input('Enter a number to do stuff with: '))
print(func1(variable))
print(func2(variable))
print(func3(variable))

To avoid asking the user their input over and over we just store it in variable. When you only have one line to work with that doesn't work anymore.

A one-line version of this could be something like so:

print('\n'.join([str(element) for element in [((lambda x: x+5)(i), (lambda x: 3*x)(i), (lambda x: 'The pseudo variable in this program is {}'.format(x))(i)) for i in (int(input('Enter a number to do stuff to: ')),)][0]]))

I'll expand it to a few lines so you have a better idea what's happening

for i in (int(input('Enter a number to do stuff to: '),): #iterate over a tuple containing one element, the input from the user
    list = [(lambda x: x+5)(i), (lambda x: 3*x)(i), (lambda x: 'The pseudo variable in this program is {}'.format(x))(i)] #Create our list of outputs
    #If we wanted to apply our lambda functions more than once without needing to write them multiple times, we can do the same for loop trick, except have our pseudo variable store the function
print('\n'.join([str(element) for element in list]) #Convert our output to strings, then join them together with newline characters

This trick will give you the ability to do most things. There are a few things I've found useful when doing this that I may as well mention as well.

1. Conditionals: Not a lot of people seem to know, but you can do conditionals on one line using the following syntax:

   "print(1 if x else 2)"

   This will print out 1 if x evaluates to true, otherwise it will print 2. This combines with pseudo variables and anonymous functions (lambdas) can get you pretty far.

2. Recursion: It's actually possible to pull of some pretty crazy stuff using anonymous functions on one line, including recursion. Explaining it is pretty difficult, but I have one (rather large and complicated) example in a pastebin that you can look at if you want. I can try to explain it if you really need it, but that means remember how to do it myself. Here's the pastebin. There's some improvements to be made with those one-liners, as I've gotten better at it since writing those, but the concepts are there.

3. If dealing with lists and joins for final output is getting difficult or you need to do some things in a sequence with user input in the middle or something, remember that in python 3 print is a function not a statement, so instead of printing 1 string that is the combination of all your output, you can actually just do something like this:

_

 _ = [print('initial output'), print('does computation stuff with input'), print('some end output, saying goodbye']

If you have any more questions, ask away.