Reveal the secrets of Python features

The Ruby language is very similar to Python, but the overall structure is still not the same. This language has very simple and clear syntax characteristics and is suitable for completing various high-level tasks, it can run in almost all operating systems, so it is favored by programmers.

This is a secure answer, but it cannot be clarified very accurately. Unfortunately, it is difficult for function programmers to have a consistent understanding of what FP is. It seems appropriate to use the story of "blindly touching people" to describe this situation. You can also safely use Python features and "command programming" to perform operations such as C, Pascal, C ++, Java, Perl, Awk, TCL, and most other languages, at least to a large extent.

From a personal perspective, I will roughly depict function programming as having at least the following features. A functional language makes these things simple and makes other things difficult or impossible: a function is the first class object ). That is, every operation that can be performed on "data" can be performed using the function itself, for example, passing a function to another function ).

• Big secrets about Python programs
• How to Use the Python module to parse the configuration file?
• How to Write Python programs better and faster
• Deep Analysis of Python function programming skills
• What are the goals of designing Python?

Recursion is used as the main control structure. In some languages, there are no other "loop" structures. Focus on LISt processing, for example, name Lisp ). Lists are often used together with sublists recursively to replace loops. "Pure" function language can avoid side effects. This does not include the most common mode in the command language, that is, to specify the first, and then specify the other value to the same variable to track the state of the program.

FP does not encourage or prohibit statements at all. Instead, it uses expressions to evaluate values. In other words, the function is added with independent variables ). In pure cases, a program is an expression plus supported definitions ). FP is concerned with computing rather than how to calculate. Many FP use "Higher-Level" functions. In other words, they operate on some functions, and these functions operate on other functions ).

Function programming advocates believe that all these features lead to faster development of less code and fewer errors. Moreover, senior theoretical scientists in computer science, logic, and mathematics have discovered that the formal performance of function languages and programs is much easier than that of command languages and programs. Since Python 1.0, Python has seen most of the FP features listed above. But for most Python features, they are presented in a very mixed language.

Largely because of the OOP feature of Python, you can use the desired part and ignore the rest until you need it later ). Using Python 2.0, the list content adds some great "syntactic whitewashing ". Although the list content does not add any new capabilities, they make many old capabilities look much better.

The basic elements of FP in Python are map (), reduce (), filter (), and operator lambda. In Python 1.x, The apply () function is convenient for directly applying the return values of a function list to another function.

Python 2.0 provides improved syntax for this purpose. It may be surprising, but few of these functions and basic operators are enough to write any Python program. In particular, all flow control statements such as if, elif, else, assert, try, break t, finally, for, break, continue, while, and def can be processed in the function style only using FP functions and operators.

Although it is actually useful to eliminate all the flow control commands in the program, it may only be useful to join the "chaotic Python" competition and code that looks like Lisp, however, it is worthwhile to understand how FP uses functions and recursion to represent stream control.

Lambda Short Circuit in Python

 
 

  
  
  # Normal statement-based flow control   
  
  
          
  
  
          
  
  
          if  
  
  
         <cond1>:   func1()   
  
  
          
  
  
          elif  
  
  
         <cond2>: func2()   
  
  
          
  
  
          else  
  
  
        :         func3()   
  
  
   
  
  
        # Equivalent "short circuit" expression   
  
  
(<cond1>   
  
  
          
  
  
          and  
  
  
         func1())   
  
  
          
  
  
          or  
  
  
         (<cond2>   
  
  
          
  
  
          and  
  
  
         func2())   
  
  
          
  
  
          or  
  
  
         (func3())   
  
  
   
  
  
        # Example "short circuit" expression   
  
  
>>> x = 3   
  
  
>>>