Why Pass Functions as arguments?

[muzikman]

I do get it now. The flexibility of the code below. I can pass "any" function that has two parameters. Instead of changing the function arguments. It's just a little difficult to grasp at first. I'm not used to doing it this way.

This is a little off topic but, I think Python needs to restructure their namespacing. Like Javascript. Global, function and block. Just my 2 cents.

Thank you for your example. Yes, I understand it.
If I were to call these functions by name from the calcit function, I would have to change the code in that function. Instead of just assigning the new function outside the main function. Thank you everyone for your help.

It's a level of flexibility.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def multiply(a,b):     return a*b   def addit(a,b):     return a+b   def calcit(func,op1,op2):     return func(op1,op2)   function = multiply a = 5 b = 6 print(calcit(function,a,b)) function = addit print(calcit(function,a,b))

Output:
30
11

[ndc85430]

In other languages, you would pass a function as an argument like so, using brackets around the parameters:

This again is wrong. You aren't passing the function as the argument in that case, but the value that the function returns. The two example pieces of code you gave do different things - the latter does pass the function.

[buran]

I think Python needs to restructure their namespacing. Like Javascript. Global, function and block.

I really don't understand people that come from some other language and want to change things like they are used to and don't care about backward compatibility and the existing code.

Check python scope and namespaces https://docs.python.org/3/tutorial/class...namespaces
Python has so called LEGB rule for scope - local, enclosing, global and built-in.
From the docs:

Although scopes are determined statically, they are used dynamically. At any time during execution, there are 3 or 4 nested scopes whose namespaces are directly accessible:

• the innermost scope, which is searched first, contains the local names
  
• the scopes of any enclosing functions, which are searched starting with the nearest enclosing scope, contains non-local, but also non-global names
  
• the next-to-last scope contains the current module’s global names
  
• the outermost scope (searched last) is the namespace containing built-in names
  

JavaScript has global and local, while block scope is sort of "special" case when using certain keywords.

So basically it's just the block scope that you miss. In both cases it's always the most narrow possible scope being used (i.e. least access)

just my 2 cents....

[muzikman]

I didn't mean to rock the boat, I apologize. As I have mentioned before, learning Python has been a challenge. Some of the features are insanely powerful like List Comprehension. The simplicity of making splicing uniform across multiple data types.

1 2 3

my_string = [1: : 2] my_list = [4:2:-1] my_dict = [ : : -1]

etc.......

That is awesome!

Everywhere I go, people tell me to try and avoid using global and nonlocal variables. I am trying to do that. If you want access to a variable declared in the outter function from the inner, just pass it.

I remember how to use bitwise operators and Python makes it a snap to add, multiply binary.

1	int(5, base=whatever)

is awesome.

I love the fact that you can just type in any number format at the Python prompt: 0xff, 0o4, etc...

My point is, every language has it's pros and cons. Python is here to stay. It is so versatile. You can even build IOS or Android apps if you like.

Anyway, I am starting to really enjoy it. It would definitely be easier if I never learned how to code to begin with.

I do have some issues with it:

1. It lacks "true" abstraction and encapsulation. You cannot create private methods or variables. There are no interfaces, you can't define a class as abstract.

The reason for OOP is basically just to organize code better and sharing classes without the person knowing how the class is written but only how to use it. True encapsulation.

I don't understand all of these magic methods. I never did with PHP or any other scripting language that uses them.

[Serafim]

By using functions as arguments you can make abstractions or generalizations that you can use in a number of situations.
Consider as a "toy example" for sums:
1. the sum of integers from 1 to 10 (1 + 2 + ... + 10) = 55

2. the sum of squares from 1 to 10 (1 + 4 + ... + 100) = 385

3. the sum of the 10 first harmonic numbers = 2.928968...

4. the sum of odd numbers less than 10 (1 + 3 + ... + 9) = 25

if we generalize all this we get a pattern that can be described as
"the sum from a to b of a term taking a certain step". In the first
three cases the step is 1 and in the fourth it is 2.

In python this can be described as:

1 2 3 4 5 6 7 8 9 10 11 12 13

def sum(a, b, term, step):     result = 0     while a <= b:         result += term(a)         a = step(a)     return result   # I also add the step functions def step(y):     return y+1   def step_2(y):     return y+2

Take the sum of integers from 1 to 10:

1 2	print(sum(1, 10, lambda x: x, step)) #I need a function, why not a lambda 55

It might seem too much with a lambda but wait...

Take the sum of the squares of the first 10 integers

1 2	print(sum(1, 10, lambda x: x*x, step)) 385

Take the sum of the 10 first harmonic numbers

1 2	print(sum(1, 10, lambda x: 1/x, step)) 2.9289682539682538

Take the sum of the odd numbers less than 10

1 2	print(sum(1, 10, lambda x: x, step_2)) 25

But we can make more complicated calculations even with this simple generalization, if we consider all kinds of summation of series of numbers, e.g. pi.

pi/8 can be described as the infinite sum from zero and up of 1 / ((4*x+1)*(4*x+3)). We should get a rough approximation with 1000000 terms:

1 2 3 4 5

def pi_term(x):     return 1 / ((4*x+1)*(4*x+3))   print(8 * sum(0.0, 1000000, pi_term, step)) 3.141592153590402

or the series 1/1 + 1/4 + 1/9 ... that gives us pi2/8

1 2	print(sqrt(8 * sum(1.0, 1000000, lambda x: 1/(x*x), step_2))) 3.1415920169700393

As we can see generalizations of this kind allows us to use patterns as functions that we specialize with other functions as arguments.