OLD anonymous-functions (lambdas) concept exercise

[BethanyG]

This issue describes how to implement the anonymous-functions (lambdas) concept exercise for the python track.

Getting started

Please please please read the docs before starting. Posting PRs without reading these docs will be a lot more frustrating for you during the review cycle, and exhaust Exercism's maintainers' time. So, before diving into the implementation, please read up on the following documents:

• Contributing to Exercism | Exercism and GitHub | Contributor Pull Request Guide
• What are those Weird Task Tags about?
• Building Language Tracks: An Overview
• What are Concepts?
• Concept Exercise Specifications
• Concept Specifications
• Exercism Formatting and Style Guide
• Exercism Markdown Specification
• Reputation

Goal

This concept exercise is meant to teach an understanding/creation/use of lambda or anonymous functions in python.

Learning objectives

• Understand what an anonymous function is, and how to create one
  • The syntax of creating a lambda
  • Using different function argument flavors with lambda
• Understand the differences between lambdas and Pythons "regular" functions
• Understand what problems are solved by using a lambda
• The pitfalls of lambdas, and when to avoid them
• Using lambdas as key functions in other situations such as sort() , sorted(), min(), and max()
• Applying arguments to a lambda via IIFE (immediately invoked function expression)
• Anti-patterns when using lambdas

Out of scope

• comprehensions
• comprehensions in lambdas
• using a decorator on a lambda
• functools (this will get its own exercise)
• generators
• map(), filter(), and reduce() (these will get their own exercise)
• using an assignment expression or "walrus" operator (:=) in a lambda

Concepts

• anonymous-functions
• lambdas
• functions,
• higher-order functions
• functions as arguments
• functions as returns
• nested funcitons

Prerequisites

These are the concepts/concept exercises the student needs to complete/understand before solving this concept exercise.

• basics
• booleans
• comparisons
• dicts
• dict-methods
• functions
• function-arguments
• higher-order functions
• iteration
• lists
• list-methods
• numbers
• sequences
• sets
• strings
• string-methods
• tuples

Resources to refer to

• Python Docs: Defining Functions

• Python Docs Tutorial: Lambda Expressions

• Functions as Objects in Python

• Composing Programs: Higher-Order Functions

• Learn by Example: Python Lambda Function

• Real Python: How to Use Python Lambda Fuctions

• Trey Hunner: Overusing Lambda expressions in Python

• Hints

  For more information on writing hints see hints

  • You can refer to one or more of the resources linked above, or analogous resources from a trusted source. We prefer using links within the Python Docs as the primary go-to, but other resources listed above are also good. Please try to avoid paid or subscription-based links if possible.

• links.json

  For more information, see concept links file

  • The same resources listed in this issue can be used as a starting point for the concepts/links.json file, if it doesn't already exist.
  • If there are particularly good/interesting information sources for this concept that extend or supplement the concept exercise material & the resources already listed -- please add them to the links.json document.

Concept Description

Please see the following for more details on these files: concepts & concept exercises

• Concept about.md

  Concept file/issue: anonymous-functions directory with stubbed files -- Content is TBD and should be completed as part of this exercise creation. Anonymous-functions concept write-ups and associated files can be included in the PR for this issue, or as a separate PR linked to this issue.

  For more information, see Concept about.md

  • This file provides information about this concept for a student who has completed the corresponding concept exercise. It is intended as a reference for continued learning.

• Concept introduction.md

  For more information, see Concept introduction.md

  • This can also be a summary/paraphrase of the document listed above, and will provide a brief introduction of the concept for a student who has not yet completed the concept exercise. It should contain a good summation of the concept, but not go into lots of detail.

• Exercise introduction.md

  For more information, see Exercise introduction.md

  • This should also summarize/paraphrase the above document, but with enough information and examples for the student to complete the tasks outlined in this concept exercise.

Test-runner

No changes required to the Python Test Runner at this time.

Representer

No changes required to the Python Representer at this time.

Analyzer

No changes required to the Python Analyzer at this time.

Exercise Metadata - Track

For more information on concept exercises and formatting for the Python track config.json , please see concept exercise metadata. The track config.json file can be found in the root of this Python repo.

You can use the below for the exercise UUID. You can also generate a new one via exercism configlet, uuidgenerator.net, or any other favorite method. The UUID must be a valid V4 UUID.

• concepts should be filled in from the Concepts section in this issue
• prerequisites should be filled in from the Prerequisites section in this issue

Exercise Metadata Files Under .meta/config.json

For more information on exercise .meta/ files and formatting, see concept exercise metadata files

• .meta/config.json - see this link for the fields and formatting of this file.

• .meta/design.md - see this link for the formatting of this file. Please use the Goal, Learning Objectives,Concepts, Prerequisites and , Out of Scope sections from this issue.

Implementation Notes

• Code in the .meta/examplar.py file should only use syntax & concepts introduced in this exercise or one of its prerequisite exercises. We run all our examplar.py files through PyLint, but do not require module docstrings. We do require function docstrings similar to PEP257. See this concept exercise exemplar.py for an example.

• Please do not use comprehensions, generator expressions, or other syntax not previously covered. Please also follow PEP8 guidelines.

• In General, tests should be written using unittest.TestCase and the test file should be named <EXERCISE-NAME>_test.py.

  • All asserts should contain a "user friendly" failure message (these will display on the website).
  • We use a PyTest custom mark to link test cases to exercise task numbers.
  • We also use unittest.subtest to parameterize test input where/when needed. Here is an example testfile that shows all three of these in action.

• While we do use PyTest as our test runner and for some implementation tests, please check with a maintainer before using a PyTest test method, fixture, or feature.

• Our markdown and JSON files are checked against prettier . We recommend setting prettier up locally and running it prior to submitting your PR to avoid any CI errors.

Help

If you have any questions while implementing the exercise, please post the questions as comments in this issue, or contact one of the maintainers on our Slack channel.

[Steffan153]

I'd like to work on this. Thanks!

Btw, I noticed we already have an exercise for this: https://github.com/exercism/elixir/tree/main/exercises/concept/secrets It's in combination with bit manipulation tho (which should also be taught in Python). So should I use that or make a new one?

[BethanyG]

Hi @Steffan153 - Happy to have you work on it! 🎉 Unfortunately, bit manipulation is not a prerequisite for this exercise, and this is probably not the place to introduce it. We have an exercise planned, but it's not on our priority list right now. You are more than welcome to fork the Elixir exercise and adapt it -- but I think we need to leave the bit manipulation out.

Also -- be warned: unlike functional-first programming languages, Python's lambdas are quite limited. They can only contain code that is computable as a single expression, and be written on a single line. They can't contain statements.

It is customary to only use them in very constrained situations -- most often as sort keys, or as arguments to map(), filter() and functools.reduce(). They also execute in their own frame, which makes error handling and stack traces more effort, and often slows code execution if you're not careful. But I'll stop now ... and let you do the write-up! 😉 😜

The documentation links at the top are up-to-date, but the ones in the body are not. I will update those shortly. Let me know here (or in our Slack channel if you are there) if you have any questions or issues.

[Steffan153]

Is there a link to the exercise? Also, I think the Secrets exercise will work fine, we just need to remove the 2 bitwise functions.

[BethanyG]

Apologies - I wasn't very clear in my language above (I corrected it). I meant that you are more than welcome to adapt the Elixir exercise. We don't have anything (yet) for bitwise operators/manipulation.

Please keep in mind that one of the major uses of lambda in Python is as a key expression for things like sort(), sorted(), min() and max() -- so you'll want to add those use cases in, but yes -- I think Secrets is a good place to start. 😄

[Steffan153]

BTW, are you sure the top links are 7p to date? Some of them 404 on me.

[BethanyG]

Looks like they moved tasks under product 😱 It should be updated now...and the others all work for me. LMK if you find anything else, tho. 😄

Alternatively, if the website links don't work for some reason, the same documents can be found under our exercism docs repo.

[github-actions[bot]]

This issue has been automatically marked as abandoned 🏚 because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[github-actions[bot]]

This issue has been automatically marked as abandoned 🏚 because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[BethanyG]

Closed in favor of #3105 & #3106.