Definition of pure function is that for a given input, pure function ALWAYS produces the same output.

Example of pure function: f(x) = 3*x

Example of impure function: f(x) = random(1, 10)

Pure functions (as follows from their definition) do not produce side-effects and they are also state-less. To manage state and side-effects some tricky patterns are used (the most famous one being monad).

1st class citizenship usually means that FP language implements following things:

• higher-order functions — functions can be passed as args to other functions (similar to variables)
• currying and partial application
• techniques for function composition (threading, piping, again currying and partial application, etc.)

Python supports higher-order function out-of-the-box, and currying together with partial application is supported via functools library.

More sofisticated techniques (like piping) are available through 3rd-party functional libs (like «returns»).

FP languages use specially designed data structures, that store immutable structures efficiently. For example, given very large array (of million elements), if you modify just one value — you can create new variable that links to all previous elements, and just adds one more link to new element. Since original variable is immutable too, new variable will too be always immutable.

Python example: tuples data structure is immutable.

Example of APL syntax:

1
2
3
4

⎕IO ← 0
]box on -s=min
]rows on
assert←{⍺←'assertion failure' ⋄ 0∊⍵:⍺ ⎕signal 8 ⋄ shy←0}

(source: https://xpqz.github.io/learnapl/aplway.html)

APL features are just predefined operations (functions) on arrays and other structures.

This is where python’s map, reduce, filter and list comprehensions really belong.

In general it is common in FP first to build transformation (smth like nested functions calls), and apply this transformation only when needed.

It’s worth underlining that it is not merely a programming style (to call functions as late as possible), it is overall language behaviour.

Generators is example of lazy evaluation in Python.

In FP languages it is common to have pattern matching already at arguments level. So, it is possible to define (not just call!) function like: f([x, 0]) = ... ; (f[0, y]) = ...

There just two ways you can call list [x, y] as argument of function in Python: f(x, y) = ... or f(lst) = .... Since 3.10 you can pattern match inside body of the function, still it is not what is meant by «real» pattern matching.

Anonymous function is usually just a some kind of syntactic sugar, that reduces boilerplate for creating one-shot functions.

It is common in FP languages to rely on them for readability of the code, for functions composition, etc.

Python lambda is anonymous function