Live sports streaming service fuboTV is expanding further into non-sports content with today’s news that it’s inked a new multi-year deal with Discovery, Inc. that will bring 13 Discovery television networks to its service over the weeks ahead. The new additions will include Discovery Channel, TLC, Investigation Discovery, Animal Planet, OWN: Oprah Winfrey Network and […]

Argo AI is releasing curated data along with high-definition maps to researchers for free, the latest company in the autonomous vehicle industry to open-source some of the information it has captured while developing and testing self-driving cars. The aim, the Ford Motor-backed company says, is to give academic researchers the ability to study the impact […]

Slack’s public debut is happening Thursday on the NYSE and the company has set a reference price of $26 per share for its direct listing, according to WSJ, which would value the company at around $15.7 billion. The company’s stock is expected to pop at open, according to the WSJ’s sources. Slack is pursuing a direct […]

Tesla will start charging $1,000 for its once-standard black paint color next month, according to a tweet Wednesday by CEO Elon Musk, the latest pricing adjustment by the automaker as it aims for profitability. Basic white will become the new (and only) free standard paint color, Musk added in a followup tweet. Musk didn’t explain […]

From the venue and the flashy event website, Waterloo, Ontario’s True North conference (in its second year) doesn’t seem all that distinct from a laundry list of other major tech events that take place each year across North America. But from the moment its main stage programming kicked off on the first day, it was […]

Startup Battlefield is known around the world as TechCrunch’s premier startup competition, and today we’re proud to announce that on November 11-12 we are producing our hardware-focused competition, Hardware Battlefield at TC Shenzhen in that amazing heartland of hardware, Shenzhen, China. The event this November will be TechCrunch’s fifth Hardware Battlefield, but our first ever […]

As we asked back in February, “We’re ready for foldable phones, but are they ready for us?” The answer, so far, has been an enthusiastic, “not really.” The Galaxy Fold was pushed back after multiple review units crapped the proverbial bed. And just last week, Huawei noted that it was holding off on its own […]

Last month, I released a new book entitled Creating GUI Applications with wxPython. In celebration of a successful launch, I have decided to do a little contest. Rules Tweet about the contest and include my handle: @driscollis Send me a direct message on Twitter or via my contact form with a link to your Tweet If you don’t have Twitter, feel free to message me through the website and I’ll enter you anyway The contest will run starting now until Friday, June 21st @ 11:59 p.m. CST. Runners up will receive a free copy of the eBook. The grand prize will be a signed paperback copy + the eBook version! The post Book Contest: Creating GUI Applications with wxPython appeared first on The Mouse Vs. The Python.

Python and other languages like Java, C#, and even C++ have had lambda functions added to their syntax, whereas languages like LISP or the ML family of languages, Haskell, OCaml, and F#, use lambdas as a core concept. Python lambdas are little, anonymous functions, subject to a more restrictive but more concise syntax than regular Python functions. By the end of this article, you’ll know: How Python lambdas came to be How lambdas compare with regular function objects How to write lambda functions Which functions in the Python standard library leverage lambdas When to use or avoid Python lambda functions Notes: You’ll see some code examples using lambda that seem to blatantly ignore Python style best practices. This is only intended to illustrate lambda calculus concepts or to highlight the capabilities of Python lambda. Those questionable examples will be contrasted with better approaches or alternatives as you progress through the article. This tutorial is mainly for intermediate to experienced Python programmers, but it is accessible to any curious minds with interest in programming and lambda calculus. All the examples included in this tutorial have been tested with Python 3.7. Free Bonus: Click here to get access to a chapter from Python Tricks: The Book that shows you Python's best practices with simple examples you can apply instantly to write more beautiful + Pythonic code. Lambda Calculus Lambda expressions in Python and other programming languages have their roots in lambda calculus, a model of computation invented by Alonzo Church. You’ll uncover when lambda calculus was introduced and why it’s a fundamental concept that ended up in the Python ecosystem. History Alonzo Church formalized lambda calculus, a language based on pure abstraction, in the 1930s. Lambda functions are also referred to as lambda abstractions, a direct reference to the abstraction model of Alonzo Church’s original creation. Lambda calculus can encode any computation. It is Turing complete, but contrary to the concept of a Turing machine, it is pure and does not keep any state. Functional languages get their origin in mathematical logic and lambda calculus, while imperative programming languages embrace the state-based model of computation invented by Alan Turing. The two models of computation, lambda calculus and Turing machines, can be translated into each another. This equivalence is known as the Church-Turing hypothesis. Functional languages directly inherit the lambda calculus philosophy, adopting a declarative approach of programming that emphasizes abstraction, data transformation, composition, and purity (no state and no side effects). Examples of functional languages include Haskell, Lisp, or Erlang. By contrast, the Turing Machine led to imperative programming found in languages like Fortran, C, or Python. The imperative style consists of programming with statements, driving the flow of the program step by step with detailed instructions. This approach promotes mutation and requires managing state. The separation in both families presents some nuances, as some functional languages incorporate imperative features, like OCaml, while functional features have been permeating the imperative family of languages in particular with the introduction of lambda functions in Java, or Python. Python is not inherently a functional language, but it adopted some functional concepts early on. In January 1994, map(), filter(), reduce(), and the lambda operator were added to the language. First Example Here are a few examples to give you an appetite for some Python code, functional style. The identity function, a function that returns its argument, is expressed with a standard Python function definition using the keyword def as follows: >>>>>> def identity(x): ... return x identity() takes an argument x and returns it upon invocation. In contrast, if you use a Python lambda construction, you get the following: >>>>>> lambda x: x In the example above, the expression is composed of: The keyword: lambda A bound variable: x A body: x Note: In the context of this article, a bound variable is an argument to a lambda function. In contrast, a free variable is not bound and may be referenced in the body of the expression. A free variable can be a constant or a variable defined in the enclosing scope of the function. You can write a slightly more elaborated example, a function that adds 1 to an argument, as follows: >>>>>> lambda x: x + 1 You can apply the function above to an argument by surrounding the function and its argument with parentheses: >>>>>> (lambda x: x + 1)(2) 3 Reduction is a lambda calculus strategy to compute the value of the expression. It consists of substituting the argument 2 for x: (lambda x: x + 1)(2) = lambda 2: 2 + 1 = 2 + 1 = 3 Because a lambda function is an expression, it can be named. Therefore you could write the previous code as follows: >>>>>> add_one = lambda x: x + 1 >>> add_one(2) 3 The above lambda function is equivalent to writing this: def add_one(x): return x + 1 These functions all take a single argument. You may have noticed that, in the definition of the lambdas, the arguments don’t have parentheses around them. Multi-argument functions (functions that take more than one argument) are expressed in Python lambdas by listing arguments and separating them with a comma (,) but without surrounding them with parentheses: >>>>>> full_name = lambda first, last: f'Full name: {first.title()} {last.title()}' >>> full_name('guido', 'van rossum') 'Full name: Guido Van Rossum' The lambda function assigned to full_name takes two arguments and returns a string interpolating the two parameters first and last. As expected, the definition of the lambda lists the arguments with no parentheses, whereas calling the function is done exactly like a normal Python function, with parentheses surrounding the arguments. Anonymous Functions The following terms may be used interchangeably depending on the programming language type and culture: Anonymous functions Lambda functions Lambda expressions Lambda abstractions Lambda form Function literals For the rest of this article after this section, you’ll mostly see the term lambda function. Taken literally, an anonymous function is a function without a name. In Python, an anonymous function is created with the lambda keyword. More loosely, it may or not be assigned a name. Consider a two-argument anonymous function defined with lambda but not bound to a variable. The lambda is not given a name: >>>>>> lambda x, y: x + y The function above defines a lambda expression that takes two arguments and returns their sum. Other than providing you with the feedback that Python is perfectly fine with this form, it doesn’t lead to any practical use. You could invoke the function in the Python interpreter: >>>>>> _(1, 2) 3 The example above is taking advantage of the interactive interpreter-only feature provided via the underscore (_). See the note below for more details. You could not write similar code in a Python module. Consider the _ in the interpreter as a side effect that you took advantage of. In a Python module, you would assign a name to the lambda, or you would pass the lambda to a function. You’ll use those two approaches later in this article. Note: In the interactive interpreter, the single underscore (_) is bound to the last expression evaluated. In the example above, the _ points to the lambda function. For more details about the usage of this special character in Python, check out The Meaning of Underscores in Python. Another pattern used in other languages like JavaScript is to immediately execute a Python lambda function. This is known as an Immediately Invoked Function Expression (IIFE, pronounce “iffy”). Here’s an example: >>>>>> (lambda x, y: x + y)(2, 3) 5 The lambda function above is defined and then immediately called with two arguments (2 and 3). It returns the value 5, which is the sum of the arguments. Several examples in this tutorial use this format to highlight the anonymous aspect of a lambda function and avoid focusing on lambda in Python as a shorter way of defining a function. Python does not encourage using immediately invoked lambda expressions. It simply results from a lambda expression being callable, unlike the body of a normal function. Lambda functions are frequently used with higher-order functions, which take one or more functions as arguments or return one or more functions. A lambda function can be a higher-order function by taking a function (normal or lambda) as an argument like in the following contrived example: >>>>>> high_ord_func = lambda x, func: x + func(x) >>> high_ord_func(2, lambda x: x * x) 6 >>> high_ord_func(2, lambda x: x + 3) 7 Python exposes higher-order functions as built-in functions or in the standard library. Examples include map(), filter(), functools.reduce(), as well as key functions like sort(), sorted(), min(), and max(). You’ll use lambda functions together with Python higher-order functions in Appropriate Uses of Lambda Expressions. Python Lambda and Regular Functions This quote from the Python Design and History FAQ seems to set the tone about the overall expectation regarding the usage of lambda functions in Python: Unlike lambda forms in other languages, where they add functionality, Python lambdas are only a shorthand notation if you’re too lazy to define a function. (Source) Nevertheless, don’t let this statement deter you from using Python’s lambda. At first glance, you may accept that a lambda function is a function with some syntactic sugar shortening the code to define or invoke a function. The following sections highlight the commonalities and subtle differences between normal Python functions and lambda functions. Functions At this point, you may wonder what fundamentally distinguishes a lambda function bound to a variable from a regular function with a single return line: under the surface, almost nothing. Let’s verify how Python sees a function built with a single return statement versus a function constructed as an expression (lambda). The dis module exposes functions to analyze Python bytecode generated by the Python compiler: >>>>>> import dis >>> add = lambda x, y: x + y >>> type(add) <class 'function'> >>> dis.dis(add) 1 0 LOAD_FAST 0 (x) 2 LOAD_FAST 1 (y) 4 BINARY_ADD 6 RETURN_VALUE >>> add <function <lambda> at 0x7f30c6ce9ea0> You can see that dis() expose a readable version of the Python bytecode allowing the inspection of the low-level instructions that the Python interpreter will use while executing the program. Now see it with a regular function object: >>>>>> import dis >>> def add(x, y): return x + y >>> type(add) <class 'function'> >>> dis.dis(add) 1 0 LOAD_FAST 0 (x) 2 LOAD_FAST 1 (y) 4 BINARY_ADD 6 RETURN_VALUE >>> add <function add at 0x7f30c6ce9f28> The bytecode interpreted by Python is the same for both functions. But you may notice that the naming is different: the function name is add for a function defined with def, whereas the Python lambda function is seen as lambda. Traceback You saw in the previous section that, in the context of the lambda function, Python did not provide the name of the function, but only <lambda>. This can be a limitation to consider when an exception occurs, and a traceback shows only <lambda>: >>>>>> div_zero = lambda x: x / 0 >>> div_zero(2) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 1, in <lambda> ZeroDivisionError: division by zero The traceback of an exception raised while a lambda function is executed only identifies the function causing the exception as <lambda>. Here’s the same exception raised by a normal function: >>>>>> def div_zero(x): return x / 0 >>> div_zero(2) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 1, in div_zero ZeroDivisionError: division by zero The normal function causes a similar error but results in a more precise traceback because it gives the function name, div_zero. Syntax As you saw in the previous sections, a lambda form presents syntactic distinctions from a normal function. In particular, a lambda function has the following characteristics: It can only contain expressions and can’t include statements in its body. It is written as a single line of execution. It does not support type annotations. It can be immediately invoked (IIFE). No Statements A lambda function can’t contain any statements. In a lambda function, statements like return, pass, assert, or raise will raise a SyntaxError exception. Here’s an example of adding assert to the body of a lambda: >>>>>> (lambda x: assert x == 2)(2) File "<input>", line 1 (lambda x: assert x == 2)(2) ^ SyntaxError: invalid syntax This contrived example intended to assert that parameter x had a value of 2. But, the interpreter identifies a SyntaxError while parsing the code that involves the statement assert in the body of the lambda. Single Expression In contrast to a normal function, a Python lambda function is a single expression. Although, in the body of a lambda, you can spread the expression over several lines using parentheses or a multiline string, it remains a single expression: >>>>>> (lambda x: ... (x % 2 and 'odd' or 'even'))(3) 'odd' The example above returns the string 'odd' when the lambda argument is odd, and 'even' when the argument is even. It spreads across two lines because it is contained in a set of parentheses, but it remains a single expression. Type Annotations If you’ve started adopting type hinting, which is now available in Python, then you have another good reason to prefer normal functions over Python lambda functions. Check out Python Type Checking (Guide) to get learn more about Python type hints and type checking. In a lambda function, there is no equivalent for the following: def full_name(first: str, last: str) -> str: return f'{first.title()} {last.title()}' Any type error with full_name() can be caught by tools like mypy or pyre, whereas a SyntaxError with the equivalent lambda function is raised at runtime: >>>>>> lambda first: str, last: str: first.title() + " " + last.title() -> str File "<stdin>", line 1 lambda first: str, last: str: first.title() + " " + last.title() -> str SyntaxError: invalid syntax Like trying to include a statement in a lambda, adding type annotation immediately results in a SyntaxError at runtime. IIFE You’ve already seen several examples of immediately invoked function execution: >>>>>> (lambda x: x * x)(3) 9 Outside of the Python interpreter, this feature is probably not used in practice. It’s a direct consequence of a lambda function being callable as it is defined. For example, this allows you to pass the definition of a Python lambda expression to a higher-order function like map(), filter(), or functools.reduce(), or to a key function. Arguments Like a normal function object defined with def, Python lambda expressions support all the different ways of passing arguments. This includes: Positional arguments Named arguments (sometimes called keyword arguments) Variable list of arguments (often referred to as varargs) Variable list of keyword arguments Keyword-only arguments The following examples illustrate options open to you in order to pass arguments to lambda expressions: >>>>>> (lambda x, y, z: x + y + z)(1, 2, 3) 6 >>> (lambda x, y, z=3: x + y + z)(1, 2) 6 >>> (lambda x, y, z=3: x + y + z)(1, y=2) 6 >>> (lambda *args: sum(args))(1,2,3) 6 >>> (lambda **kwargs: sum(kwargs.values()))(one=1, two=2, three=3) 6 >>> (lambda x, *, y=0, z=0: x + y + z)(1, y=2, z=3) 6 Decorators In Python, a decorator is the implementation of a pattern that allows adding a behavior to a function or a class. It is usually expressed with the @decorator syntax prefixing a function. Here’s a contrived example: def some_decorator(f): def wraps(*args): print(f"Calling function '{f.__name__}'") return f(args) return wraps @some_decorator def decorated_function(x): print(f"With argument '{x}'") In the example above, some_decorator() is a function that adds a behavior to decorated_function(), so that invoking decorated_function(2) results in the following output: Calling function 'decorated_function' With argument 'Python' decorated_function() only prints With argument 'Python', but the decorator adds an extra behavior that also prints Calling function 'decorated_function'. A decorator can be applied to a lambda. Although it’s not possible to decorate a lambda with the @decorator syntax, a decorator is just a function, so it can call the lambda function: 1 # Defining a decorator 2 def trace(f): 3 def wrap(*args, **kwargs): 4 print(f"[TRACE] func: {f.__name__}, args: {args}, kwargs: {kwargs}") 5 return f(*args, **kwargs) 6 7 return wrap 8 9 # Applying decorator to a function 10 @trace 11 def add_two(x): 12 return x + 2 13 14 # Calling the decorated function 15 add_two(3) 16 17 # Applying decorator to a lambda 18 print((trace(lambda x: x ** 2))(3)) add_two(), decorated with @trace on line 11, is invoked with argument 3 on line 15. By contrast, on line 18, a lambda function is immediately involved and embedded in a call to trace(), the decorator. When you execute the code above you obtain the following: [TRACE] func: add_two, args: (3,), kwargs: {} [TRACE] func: <lambda>, args: (3,), kwargs: {} 9 See how, as you’ve already seen, the name of the lambda function appears as <lambda>, whereas add_two is clearly identified for the normal function. Decorating the lambda function this way could be useful for debugging purposes, possibly to debug the behavior of a lambda function used in the context of a higher-order function or a key function. Let’s see an example with map(): list(map(trace(lambda x: x*2), range(3))) The first argument of map() is a lambda that multiplies its argument by 2. This lambda is decorated with trace(). When executed, the example above outputs the following: [TRACE] Calling <lambda> with args (0,) and kwargs {} [TRACE] Calling <lambda> with args (1,) and kwargs {} [TRACE] Calling <lambda> with args (2,) and kwargs {} [0, 2, 4] The result [0, 2, 4] is a list obtained from multiplying each element of range(3). For now, consider range(3) equivalent to the list [0, 1, 2]. You will be exposed to map() in more details in Map. A lambda can also be a decorator, but it’s not recommended. If you find yourself needing to do this, consult PEP 8, Programming Recommendations. For more on Python decorators, check out Primer on Python Decorators. Closure A closure is a function where every free variable, everything except parameters, used in that function is bound to a specific value defined in the enclosing scope of that function. In effect, closures define the environment in which they run, and so can be called from anywhere. The concepts of lambdas and closures are not necessarily related, although lambda functions can be closures in the same way that normal functions can also be closures. Some languages have special constructs for closure or lambda (for example, Groovy with an anonymous block of code as Closure object), or a lambda expression (for example, Java Lambda expression with a limited option for closure). Here’s a closure constructed with a normal Python function: 1 def outer_func(x): 2 y = 4 3 def inner_func(z): 4 print(f"x = {x}, y = {y}, z = {z}") 5 return x + y + z 6 return inner_func 7 8 for i in range(3): 9 closure = outer_func(i) 10 print(f"closure({i+5}) = {closure(i+5)}") outer_func() returns inner_func(), a nested function that computes the sum of three arguments: x is passed as an argument to outer_func(). y is a variable local to outer_func(). z is an argument passed to inner_func(). To test the behavior of outer_func() and inner_func(), outer_func() is invoked three times in a for loop that prints the following: x = 0, y = 4, z = 5 closure(5) = 9 x = 1, y = 4, z = 6 closure(6) = 11 x = 2, y = 4, z = 7 closure(7) = 13 On line 9 of the code, inner_func() returned by the invocation of outer_func() is bound to the name closure. On line 5, inner_func() captures x and y because it has access to its embedding environment, such that upon invocation of the closure, it is able to operate on the two free variables x and y. Similarly, a lambda can also be a closure. Here’s the same example with a Python lambda function: 1 def outer_func(x): 2 y = 4 3 return lambda z: x + y + z 4 5 for i in range(3): 6 closure = outer_func(i) 7 print(closure(i)) When you execute the code above, you obtain the following output: closure(5) = 9 closure(6) = 11 closure(7) = 13 On line 6, outer_func() returns a lambda and assigns it to to the variable closure. On line 3, the body of the lambda function references x and y. The variable y is available at definition time, whereas x is defined at runtime when outer_func() is invoked. In this situation, both the normal function and the lambda behave similarly. In the next section, you’ll see a situation where the behavior of a lambda can be deceptive due to its evaluation time (definition time vs runtime). Evaluation Time In some situations involving loops, the behavior of a Python lambda function as a closure may be counterintuitive. It requires understanding when free variables are bound in the context of a lambda. The following examples demonstrate the difference when using a regular function vs using a Python lambda. Test the scenario first using a regular function: >>> 1 >>> def wrap(n): 2 ... def f(): 3 ... print(n) 4 ... return f 5 ... 6 >>> numbers = 'one', 'two', 'three' 7 >>> funcs = [] 8 >>> for n in numbers: 9 ... funcs.append(wrap(n)) 10 ... 11 >>> for f in funcs: 12 ... f() 13 ... 14 one 15 two 16 three In a normal function, n is evaluated at definition time, on line 9, when the function is added to the list: funcs.append(wrap(n)). Now, with the implementation of the same logic with a lambda function, observe the unexpected behavior: >>> 1 >>> numbers = 'one', 'two', 'three' 2 >>> funcs = [] 3 >>> for n in numbers: 4 ... funcs.append(lambda: print(n)) 5 ... 6 >>> for f in funcs: 7 ... f() 8 ... 9 three 10 three 11 three The unexpected result occurs because the free variable n, as implemented, is bound at the execution time of the lambda expression. The Python lambda function on line 4 is a closure that captures n, a free variable bound at runtime. At runtime, while invoking the function f on line 7, the value of n is three. To overcome this issue, you can assign the free variable at definition time as follows: >>> 1 >>> numbers = 'one', 'two', 'three' 2 >>> funcs = [] 3 >>> for n in numbers: 4 ... funcs.append(lambda n=n: print(n)) 5 ... 6 >>> for f in funcs: 7 ... f() 8 ... 9 one 10 two 11 three A Python lambda function behaves like a normal function in regard to arguments. Therefore, a lambda parameter can be initialized with a default value: the parameter n takes the outer n as a default value. The Python lambda function could have been written as lambda x=n: print(x) and have the same result. The Python lambda function is invoked without any argument on line 7, and it uses the default value n set at definition time. Testing Lambdas Python lambdas can be tested similarly to regular functions. It’s possible to use both unittest and doctest. unittest The unittest module handles Python lambda functions similarly to regular functions: import unittest addtwo = lambda x: x + 2 class LambdaTest(unittest.TestCase): def test_add_two(self): self.assertEqual(addtwo(2), 4) def test_add_two_point_two(self): self.assertEqual(addtwo(2.2), 4.2) def test_add_three(self): # Should fail self.assertEqual(addtwo(3), 6) if __name__ == '__main__': unittest.main(verbosity=2) LambdaTest defines a test case with three test methods, each of them exercising a test scenario for addtwo() implemented as a lambda function. The execution of the Python file lambda_unittest.py that contains LambdaTest produces the following: $ python lambda_unittest.py test_add_three (__main__.LambdaTest) ... FAIL test_add_two (__main__.LambdaTest) ... ok test_add_two_point_two (__main__.LambdaTest) ... ok ====================================================================== FAIL: test_add_three (__main__.LambdaTest) ---------------------------------------------------------------------- Traceback (most recent call last): File "lambda_unittest.py", line 18, in test_add_three self.assertEqual(addtwo(3), 6) AssertionError: 5 != 6 ---------------------------------------------------------------------- Ran 3 tests in 0.001s FAILED (failures=1) As expected, we have two successful test cases and one failure for test_add_three: the result is 5, but the expected result was 6. This failure is due to an intentional mistake in the test case. Changing the expected result from 6 to 5 will satisfy all the tests for LambdaTest. doctest The doctest module extracts interactive Python code from docstring to execute tests. Although the syntax of Python lambda functions does not support a typical docstring, it is possible to assign a string to the __doc__ element of a named lambda: addtwo = lambda x: x + 2 addtwo.__doc__ = """Add 2 to a number. >>> addtwo(2) 4 >>> addtwo(2.2) 4.2 >>> addtwo(3) # Should fail 6 """ if __name__ == '__main__': import doctest doctest.testmod(verbose=True) The doctest in the doc comment of lambda addtwo() describes the same test cases as in the previous section. When you execute the tests via doctest.testmod(), you get the following: $ python lambda_doctest.py Trying: addtwo(2) Expecting: 4 ok Trying: addtwo(2.2) Expecting: 4.2 ok Trying: addtwo(3) # Should fail Expecting: 6 ********************************************************************** File "lambda_doctest.py", line 16, in __main__.addtwo Failed example: addtwo(3) # Should fail Expected: 6 Got: 5 1 items had no tests: __main__ ********************************************************************** 1 items had failures: 1 of 3 in __main__.addtwo 3 tests in 2 items. 2 passed and 1 failed. ***Test Failed*** 1 failures. The failed test results from the same failure explained in the execution of the unit tests in the previous section. You can add a docstring to a Python lambda via an assignment to __doc__ to document a lambda function. Although possible, the Python syntax better accommodates docstring for normal functions than lambda functions. For a comprehensive overview of unit testing in Python, you may want to refer to Getting Started With Testing in Python. Lambda Expression Abuses Several examples in this article, if written in the context of professional Python code, would qualify as abuses. If you find yourself trying to overcome something that a lambda expression does not support, this is probably a sign that a normal function would be better suited. The docstring for a lambda expression in the previous section is a good example. Attempting to overcome the fact that a Python lambda function does not support statements is another red flag. The next sections illustrate a few examples of lambda usages that should be avoided. Those examples might be situations where, in the context of Python lambda, the code exhibits the following pattern: It doesn’t follow the Python style guide (PEP 8) It’s cumbersome and difficult to read. It’s unnecessarily clever at the cost of difficult readability. Raising an Exception Trying to raise an exception in a Python lambda should make you think twice. There are some clever ways to do so, but even something like the following is better to avoid: >>>>>> def throw(ex): raise ex >>> (lambda: throw(Exception('Something bad happened')))() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 1, in <lambda> File "<stdin>", line 1, in throw Exception: Something bad happened Because a statement is not syntactically correct in a Python lambda body, the workaround in the example above consists of abstracting the statement call with a dedicated function throw(). Using this type of workaround should be avoided. If you encounter this type of code, you should consider refactoring the code to use a regular function. Cryptic Style As in any programming languages, you will find Python code that can be difficult to read because of the style used. Lambda functions, due to their conciseness, can be conducive to writing code that is difficult to read. The following lambda example contains several bad style choices: >>>>>> (lambda _: list(map(lambda _: _ // 2, _)))([1,2,3,4,5,6,7,8,9,10]) [0, 1, 1, 2, 2, 3, 3, 4, 4, 5] The underscore (_) refers to a variable that you don’t need to refer to explicitly. But in this example, three _ refer to different variables. An initial upgrade to this lambda code could be to name the variables: >>>>>> (lambda some_list: list(map(lambda n: n // 2, some_list)))([1,2,3,4,5,6,7,8,9,10]) [0, 1, 1, 2, 2, 3, 3, 4, 4, 5] Admittedly, it’s still difficult to read. By still taking advantage of a lambda, a regular function would go a long way to render this code more readable, spreading the logic over a few lines and function calls: >>>>>> def div_items(some_list): div_by_two = lambda n: n // 2 return map(div_by_two, some_list) >>> list(div_items([1,2,3,4,5,6,7,8,9,10]))) [0, 1, 1, 2, 2, 3, 3, 4, 4, 5] This is still not optimal but shows you a possible path to make code, and Python lambda functions in particular, more readable. In Alternatives to Lambdas, you’ll learn to replace map() and lambda with list comprehensions or generator expressions. This will drastically improve the readability of the code. Python Classes You can but should not write class methods as Python lambda functions. The following example is perfectly legal Python code but exhibits unconventional Python code relying on lambda. For example, instead of implementing __str__ as a regular function, it uses a lambda. Similarly, brand and year are properties also implemented with lambda functions, instead of regular functions or decorators: class Car: """Car with methods as lambda functions.""" def __init__(self, brand, year): self.brand = brand self.year = year brand = property(lambda self: getattr(self, '_brand'), lambda self, value: setattr(self, '_brand', value)) year = property(lambda self: getattr(self, '_year'), lambda self, value: setattr(self, '_year', value)) __str__ = lambda self: f'{self.brand} {self.year}' # 1: error E731 honk = lambda self: print('Honk!') # 2: error E731 Running a tool like flake8, a style guide enforcement tool, will display the following errors for __str__ and honk: E731 do not assign a lambda expression, use a def Although flake8 doesn’t point out an issue for the usage of the Python lambda functions in the properties, they are difficult to read and prone to error because of the usage of multiple strings like '_brand' and '_year'. Proper implementation of __str__ would be expected to be as follows: def __str__(self): return f'{self.brand} {self.year}' brand would be written as follows: @property def brand(self): return self._brand @brand.setter def brand(self, value): self._brand = value As a general rule, in the context of code written in Python, prefer regular functions over lambda expressions. Nonetheless, there are cases that benefit from lambda syntax, as you will see in the next section. Appropriate Uses of Lambda Expressions Lambdas in Python tend to be the subject of controversies. Some of the arguments against lambdas in Python are: Issues with readability The imposition of a functional way of thinking Heavy syntax with the lambda keyword Despite the heated debates questioning the mere existence of this feature in Python, lambda functions have properties that sometimes provide value to the Python language and to developers. The following examples illustrate scenarios where the use of lambda functions is not only suitable but encouraged in Python code. Classic Functional Constructs Lambda functions are regularly used with the built-in functions map() and filter(), as well as functools.reduce(), exposed in the module functools. The following three examples are respective illustrations of using those functions with lambda expressions as companions: >>>>>> list(map(lambda x: x.upper(), ['cat', 'dog', 'cow'])) ['CAT', 'DOG', 'COW'] >>> list(filter(lambda x: 'o' in x, ['cat', 'dog', 'cow'])) ['dog', 'cow'] >>> from functools import reduce >>>

Roadblocks to writing tests, and what to do about it. Some developers either don't write tests, or don't like writing tests. Why not? I love writing tests. In this episode we examine lots of roadblocks to testing, and start coming up with solutions for these.Sponsored By:Pantheon: Pantheon makes building, managing, and optimizing websites simpler. Get started for free at pantheon.io/testandcode.Support Test & Code - Python Testing & DevelopmentLinks:"I don’t write tests because ____. " twitter questionepisode 75: Modern Testing Principlesepisode 76: TDD: Don’t be afraid of Test-Driven Development "A QA engineer walks into a bar"<p>Roadblocks to writing tests, and what to do about it.</p> <p>Some developers either don&#39;t write tests, or don&#39;t like writing tests.<br> Why not? I love writing tests.<br> In this episode we examine lots of roadblocks to testing, and start coming up with solutions for these.</p><p>Sponsored By:</p><ul><li><a href="https://pantheon.io/testandcode" rel="nofollow">Pantheon</a>: <a href="https://pantheon.io/testandcode" rel="nofollow">Pantheon makes building, managing, and optimizing websites simpler. Get started for free at pantheon.io/testandcode.</a></li></ul><p><a href="https://www.patreon.com/testpodcast" rel="payment">Support Test & Code - Python Testing & Development</a></p><p>Links:</p><ul><li><a href="https://twitter.com/brianokken/status/1140041742864961536" title=""I don’t write tests because ____. " twitter question" rel="nofollow">"I don’t write tests because ____. " twitter question</a></li><li><a href="https://testandcode.com/75" title="episode 75: Modern Testing Principles" rel="nofollow">episode 75: Modern Testing Principles</a></li><li><a href="https://testandcode.com/76" title="episode 76: TDD: Don’t be afraid of Test-Driven Development " rel="nofollow">episode 76: TDD: Don’t be afraid of Test-Driven Development </a></li><li><a href="https://twitter.com/brenankeller/status/1068615953989087232" title=""A QA engineer walks into a bar"" rel="nofollow">"A QA engineer walks into a bar"</a></li></ul>

In this tutorial, we will cover how to remove or drop one or multiple columns from pandas dataframe.What is pandas in Python?pandas is a python package for data manipulation. It has several functions for the following data tasks: Drop or Keep rows and columnsAggregate data by one or more columnsSort or reorder dataMerge or append multiple dataframesString Functions to handle text dataDateTime Functions to handle date or time format columnsImport or Load Pandas libraryTo make use of any python library, we first need to load them up by using import command. import pandas as pdimport numpy as npLet's create a fake dataframe for illustrationThe code below creates 4 columns named A through D. df = pd.DataFrame(np.random.randn(6, 4), columns=list('ABCD')) A B C D0 -1.236438 -1.656038 1.655995 -1.4132431 0.507747 0.710933 -1.335381 0.8326192 0.280036 -0.411327 0.098119 0.7684473 0.858730 -0.093217 1.077528 0.1968914 -0.905991 0.302687 0.125881 -0.6651595 -2.012745 -0.692847 -1.463154 -0.707779Drop a column in pythonIn pandas, drop( ) function is used to remove column(s).axis=1 tells Python that you want to apply function on columns instead of rows. df.drop(['A'], axis=1)Column A has been removed. See the output shown below. B C D0 -1.656038 1.655995 -1.4132431 0.710933 -1.335381 0.8326192 -0.411327 0.098119 0.7684473 -0.093217 1.077528 0.1968914 0.302687 0.125881 -0.6651595 -0.692847 -1.463154 -0.707779In order to create a new dataframe newdf storing remaining columns, you can use the command below. newdf = df.drop(['A'], axis=1)To delete the column permanently from original dataframe df, you can use the option inplace=Truedf.drop(['A'], axis=1, inplace=True)#Check columns in df after dropping column Adf.columnsOutputIndex(['B', 'C', 'D'], dtype='object')Remove Multiple Columns in PythonYou can specify all the columns you want to remove in a list and pass it in drop( ) function. Method Idf2 = df.drop(['B','C'], axis=1)Method IIcols = ['B','C']df2 = df.drop(cols, axis=1)Select or Keep ColumnsIf you wish to select a column (instead of drop), you can use the command df['A']To select multiple columns, you can submit the following code. df[['A','B']]How to drop column by position number from pandas Dataframe?You can find out name of first column by using this command df.columns[0]. Indexing in python starts from 0. df.drop(df.columns[0], axis =1)To drop multiple columns by position (first and third columns), you can specify the position in list [0,2]. cols = [0,2]df.drop(df.columns[cols], axis =1)Drop columns by name patterndf = pd.DataFrame({"X1":range(1,6),"X_2":range(2,7),"YX":range(3,8),"Y_1":range(2,7),"Z":range(5,10)}) X1 X_2 YX Y_1 Z0 1 2 3 2 51 2 3 4 3 62 3 4 5 4 73 4 5 6 5 84 5 6 7 6 9Drop column whose name starts with letter 'X'df.loc[:,~df.columns.str.contains('^X')]How it works?^X is a expression of regex language which refers to beginning of letter 'X'df.columns.str.contains('^X') returns array [True, True, False, False, False]. True where condition meets. Otherwise FalseSign ~ refers to negate the condition.df.loc[ ] is used to select columnsIt can also be written like : df.drop(df.columns[df.columns.str.contains('^X')], axis=1)Other Examples#Removing columns whose name contains string 'X'df.loc[:,~df.columns.str.contains('X')]#Removing columns whose name contains string either 'X' or 'Y'df.loc[:,~df.columns.str.contains('X|Y')]#Removing columns whose name ends with string 'X'df.loc[:,~df.columns.str.contains('X$')]Drop columns where percentage of missing values is greater than 50%df = pd.DataFrame({'A':[1,3,np.nan,5,np.nan], 'B':[4,np.nan,np.nan,5,np.nan] })% of missing values can be calculated by mean of NAs in each column. cols = df.columns[df.isnull().mean()>0.5]df.drop(cols, axis=1) About Author: Deepanshu founded ListenData with a simple objective - Make analytics easy to understand and follow. He has over 8 years of experience in data science and predictive modeling. During his tenure, he has worked with global clients in various domains.Let's Get Connected: LinkedIn

Few things can be so divisive among developers as their choice of programming languages. Developers will promote one over the other, often touting their chosen language’s purity, speed, elegance, efficiency, power, portability, compatibility or any number of other features. Android app developers are no exception, with many developers divided between using Java or Python to develop their applications. Let’s look at these two languages and see which is best for Android app developers.JavaOriginally released in 1995, Java is one of the cornerstone languages of modern programming, and continues to be one of the most popular programming languages in the world. Java was designed on the “write once, run anywhere” principle, as compiled Java apps are designed to run on a Java virtual machine (JVM). Any computer, device or platform with a JVM installed should be able to run a Java app without it being altered or recompiled. In addition, Java is a true object-oriented programming language, with many modern features.Because of these features, Google used Java as the core basis of Android when they began development. As a result, to this day, Java remains the primary way to create true “native” Android apps. Apps written in Java tend to have the fastest performance, tightest integration and easier access to underlying features and APIs.In spite of these advantages, Java is not an easy language for many developers to pick up, especially those coming from a career in web development.PythonFirst released in 1991, Python predates Java by a few years, yet continues to be a force to be reckoned with in the development world. Unlike Java—or other languages such as C, Objective-C or Swift—Python is an interpreted language, rather than a compiled one. In other words, rather than compiling the completed code into machine-language instructions, Python code is executed by a Python interpreter on the fly.Python has long had a reputation of being a simple, elegant language. Whereas other languages emphasize many ways to accomplish a goal, Python’s philosophy is that there should be a single, superior way to do it. This, in turn, gives Python a much easier learning curve for new developers.Because of its interpreted nature, Android does not natively support Python apps. However, there are a number of frameworks available that allow Python apps to be interpreted and run on Android, even giving them a native look and feel. In spite of this, because it is not the native development environment, Python apps do not always have the same level of system access as their Java counterparts. In addition, as a general rule, Python apps tend to have slower performance, although this is increasingly mitigated by faster hardware.In spite of these disadvantages, Python appeals to many developers who are already proficient with it, or are coming from a web development background. Because Python is an interpreted language, this gives Python apps an even greater degree of portability than Java, especially since some platforms—such as macOS—no longer install a JVM by default.Java or PythonThe fact of the matter is, both Java and Python have pros and cons. Java is the native language of Android, and enjoys the associated benefits. Python is an easier language to learn and work with, and is more portable, but gives up some performance compared to Java.At the end of the day, each tool has its place depending on what you are trying to accomplish and what your background is as an Android app developer. If you’re not sure about how to create an Android app that will meet your expectations, you may need to seek out expert advice from people who’ve worked on similar projects before.

Python 3.7.4rc1 and 3.6.9rc1 are now available. 3.7.4rc1 is the release preview of the next maintenance release of Python 3.7, the latest feature release of Python. 3.6.9rc1 is the release preview of the first security-fix release of Python 3.6. Assuming no critical problems are found prior to 2019-06-28, no code changes are planned between these release candidates and the final releases. These release candidates are intended to give you the opportunity to test the new security and bug fixes in 3.7.4 and security fixes in 3.6.9. We strongly encourage you to test your projects and report issues found to bugs.python.org as soon as possible. Please keep in mind that these are preview releases and, thus, their use is not recommended for production environments. You can find the release files, a link to their changelogs, and more information here:     https://www.python.org/downloads/release/python-374rc1/     https://www.python.org/downloads/release/python-369rc1/

#373 – JUNE 18, 2019 View in Browser » How to Publish Your Own Python Package to PyPI Learn how to create a Python package for your project and how to publish it to PyPI, the Python Package Repository with this step-by-step tutorial. Quickly get up to speed on everything from naming your package to configuring it using setup.py. REAL PYTHON video Comparing the Same Project in Rust, Haskell, C++, Python, Scala and OCaml “A rare opportunity to compare implementations of large programs that all did the same thing, written by friends I knew were highly competent, and have a fairly pure opportunity to see what difference design and language choices could make.” TRISTAN HUME Find a Python Job Through Vettery Vettery specializes in developer roles and is completely free for job seekers. Interested? Submit your profile, and if accepted, you can receive interview requests directly from top companies seeking Python devs. Get started → VETTERY sponsor Toward a “Kernel Python” “We need a newer, leaner, unburdened ‘kernel’ Python. We need to dump the whole standard library out on the floor, adding back only the smallest bits that we need, so that we can tell what is truly necessary and what’s just nice to have.” GLYPH LEFKOWITZ opinion Use __main__.py in Python “The magic file __main__.py is called when you run your project with the -m module flag. If you code is intended to be used a module first, and command line interface second, this makes perfect sense to use. Think of it as a place we can put whatever would be in our body of our if __name__ === "__main__" statement.” SHANE O’NEILL PyPI Now Supports Two-Factor Login via WebAuthn “To further increase the security of Python package downloads, we’re adding a new beta feature to the Python Package Index: WebAuthn support for U2F compatible hardware security keys as a two-factor authentication (2FA) login security method.” PYFOUND.BLOGSPOT.COM PSF Announces Results of the 2019 Board of Directors Election “The 4 available seats go to: Lorena Mesa @loooorenanicole , Kushal Das @kushaldas, Marlene Mhangami @marlene_zw, and Jannis Leidel @jezdez. Congratulations to Lorena, Kushal, Marlene, and Jannis!” TWITTER.COM/THEPSF Dynamic Programming Examples in Python A short introduction to the (confusingly named) concept of dynamic programming with Python. NATHAN GOLDBAUM Discussions A Fibonacci Assignment Expression Dict Comprehension (??) TWITTER.COM/CODEWITHANTHONY Anyone Up for a Funeral for Python 2 on January First 2020? REDDIT Python Jobs Senior Backend Software Engineer (Remote) Close Lead Python Software Developer (Toronto, Canada) Kognitiv SIPS Programmer (Madison, WI) University of Wisconsin Data Engineer (Munich, Germany) Stylight GmbH Senior Python Developer (Malta, Europe) Gaming Innovation Group More Python Jobs >>> Articles & Tutorials So, You Want to Contribute to CPython: Gather Here “I will try to explain how you can start contributing to CPython borrowing from some few ways I have used and found to work for me.” JOANNAH NANJEKYE Loop Better: A Deeper Look at Iteration in Python “Python’s for loops don’t work the way for loops do in other languages. In this article we’re going to dive into Python’s for loops to take a look at how they work under the hood and why they work the way they do.” TREY HUNNER Build Python in Minutes With ActiveState Tired of Conda-installing? Automatically build your Python runtime environment with the packages you need: Automatically resolve dependencies, install in a virtual environment with a single command, build Python 2.7 and 3.6 on Linux and Windows. Learn more → ACTIVESTATE sponsor How to Build Command Line Interfaces in Python With Argparse In this step-by-step Python tutorial, you’ll learn how to take your command line Python scripts to the next level by adding a convenient command line interface that you can write with argparse. REAL PYTHON Python vs R — Choosing the Best Programming Language for Data Science “Functional Programming vs. Imperative Programming, the Nature of R Programming versus Python Programming, Data Science Tasks all determine what programming language to use in Data Science Project.” JUN WU opinion Communicating Between Go and Python or R “Sometimes, we need code from one language to call code written in another language directly. In this post, we’ll take a short look at how to do that using C foreign function interfaces (FFI) as a way to call functions written in Go using Python.” MATTHEW MAHOWALD Faster Docker Builds With Pipenv, Poetry, or Pip-Tools “Installing dependencies separately from your code allows you to take advantage of Docker’s layer caching. Here’s how to do it with pipenv, poetry, or pip-tools.” ITAMAR TURNER-TRAURING Come to Mexico for PyCon Latam 2019 Come join us in beautiful Puerto Vallarta in the first installment of this conference. With an all-inclusive ticket that covers food and lodging, you can’t miss this opportunity! PYCON sponsor Calling Python Functions From NodeJS On NodeJS and Python interoperability. NICK FRANKEN Scraping Stack Overflow With Python NAVEEN VERMA Making a Word Cloud Picture With Python STANISLAS MORBIEU Projects & Code flake8-black: Flake8 Plugin to Run Black for Checking Python Coding Style GITHUB.COM/PETERJC • Shared by Python Bytes Podcast semantic: Parsing, Analyzing, and Comparing Source Code Across Many Languages GITHUB.COM/GITHUB Voilà: Turn Jupyter Notebooks Into Standalone Web Applications JUPYTER.ORG lutris: Open Source Gaming Platform for GNU/Linux GITHUB.COM/LUTRIS Python Preview: VS Code Plugin That Creates Object-Visualizations for Python VISUALSTUDIO.COM • Shared by Python Bytes Podcast fern: Curses-Based Mastodon Client GITHUB.COM/ENKIV2 Events PyDelhi User Group Meetup June 22, 2019 MEETUP.COM GeoPython 2019 June 24 to June 27, 2019 GEOPYTHON.NET Inland Empire Pyladies (CA, USA) June 24, 2019 MEETUP.COM Dominican Republic Python User Group June 25, 2019 PYTHON.DO Heidelberg Python Meetup June 26, 2019 MEETUP.COM Dash Conference July 16–17 in NYC DASHCON.IO Happy Pythoning!This was PyCoder’s Weekly Issue #373.View in Browser » [ Subscribe to ? PyCoder’s Weekly ? – Get the best Python news, articles, and tutorials delivered to your inbox once a week >> Click here to learn more ]

Latest Research Report to uncover key Factors of Global Bitcoin Mining Hardware Market  Industrial JournalismGlobal Bitcoin Mining Hardware Market offers a wide range of market dynamics like current trends (2019), estimated forecast (2025), segmentation by types, ...

Global Hardware Fastener Market 2019-2024: Report Includes Regions, Import/Export, Companies, Revenue  Market Industry NewsThe Global Hardware Fastener Market Report 2019 aims to deliver an explicit evaluation of the market. The report offers sweeping insights extracted by ...

Restoration Hardware (NYSE:RH) Issues FY 2019 Earnings Guidance  Rockland RegisterRestoration Hardware (NYSE:RH) issued an update on its FY 2019 earnings guidance on Wednesday morning. The company provided earnings per share ...

Intel Performance Maximizer (IPM) Tested: One-Click Overclocking Comes to 9th-Gen CPUs  Tom's HardwareWe overclocked a Core i9-9900K with Intel's one-click Performance Maximizer tool and reached 5.0 GHz.

Tag: Hardware-based Full Disk Encryption Market Growth  TechZiffyHardware-based Full Disk Encryption Market Analysis by Product Type, Developement and End user Application. Hardware-based Full Disk Encryption Market ...

Oracle Chairman Larry Ellison says the company added 5,000 new trials for its latest cloud database. Here's what that means  Business InsiderDespite a rough quarter with layoffs, Oracle reported a solid beat in its fiscal Q4 and says customer reaction to its new cloud database is good.

Video Surveillance System Market (2019 - 2024) Segmented by Type (Software, Hardware, Services), End-User Vertical (Commercial, Infrastructure, Institutional, Industrial, Defense, Residential), and Region - Growth, Trends, Analysis and Forecast upto upcoming five years  The Norman GazetteVideo Surveillance System Market (2019 – 2024) report provides approximate CAGR, Key-players, Scope of the report, regional analysis, major market factors of ...

Universal Music Group and YouTube are partnering to bring older classic music videos into the HD era.

We pay a visit to Dimension's capture studio to talk about virtual reality, Vikings, and what volumetric capture adds to the experience.

Tired of getting tangled in cords? Here are the best wireless headphones for every budget.

These quality apps allow you to create and organize notes, both in the workplace and at home.

We've tried out the top Android phones to rate and rank the best ten available to US buyers. Check out which we found the most impressive.

We have gathered the very best laptops under $500 that we've reviewed in the past year. It's a small (read: exclusive) list.

We weigh the pros and cons of Apple's best Mac desktops and laptops, from Mac mini to the MacBook Pro.