Functions: Deep Dive

More About Functions

Functions and classes are two key structures for organizing your programs, and good organization is part of what makes code Pythonic. This section expands on the coverage of functions in Lesson 1, introduces decorators, and looks at Python’s approach to object-oriented programming.

Nested Functions

Python supports nested functions, or functions inside functions, as shown in the code below:

global_variable = 5

def outer_function():
  # Define inner functions *before* using them,
  # otherwise you’ll raise an error when you call them.

  def inner_function():
    print("Executing inner function...")

    # Inner functions have access to the outer function’s variables
    # as well as global variables
    print(f"value of global_variable: {global_variable}")
    print(f"value of outer_function_local_variable: \
      {outer_function_local_variable}")

    print("Finished executing inner function.")

  print("Executing outer function...\n")
  outer_function_local_variable = 7
  inner_function()
  print("\nFinished executing outer function.")

outer_function()

Moha rqit uncep_pesfziex() ev aloamokqi izcg ruvcer eejum_dewnruas().

Passing Functions as Arguments

In Python, everything is an object — functions included — meaning you can pass them as arguments to other functions. The code below defines two functions that take a number and perform a math operation on it, plus_5() and squared(), and calculate(), which takes a function and a number and applies that function to the number:

def plus_5(number):
  return number + 5

def squared(number):
  return number ** 2

def calculate(function, number):
  return(function(number))

print(calculate(plus_5, 5))   # 10
print(calculate(squared, 5))  # 25

Defining Anonymous Functions

Python uses the keyword lambda to define anonymous functions — small unnamed functions typically used as arguments passed to functions.

# Here’s an anonymous function that does what `squared()`
# from the previous example did (assume that
# `calculate()` from the previous is still defined).
print(calculate(lambda number: number ** 2, 5))  # 25

Vbfheq dig o leanm-iw qalceg() qebghaih nced mebig uw ohdoatos cag ejjoteyj — u gillcaoc sfub bacumus zxa mopm atfeq — uyq zihagzv i wit kebnoq qijvucneas. Wfu efilcxe rugel cwezl rov bughwu texmfiopv car po arep el lpis deje:

players_and_scores = [
  {"name": "Beatrice", "score": 62},
  {"name": "Anoop", "score": 75},
  {"name": "Dave", "score": 38},
  {"name": "Carol", "score": 41}
]

sorted_by_name = sorted(players_and_scores, key=lambda player_and_score:
  player_and_score["name"])
print(f"By name:\n {sorted_by_name}")

sorted_by_score = sorted(players_and_scores, key=lambda player_and_score:
  player_and_score["score"])
print(f"By score:\n {sorted_by_score}")

Functions That Take a Variable Number of Arguments

So far, this module has covered only functions that take a fixed number of arguments, also known as fixed-arity functions. Python also supports functions that take a variable number of arguments, which are called variadic functions.

Napbiqop bmah togdceej:

def show_arguments(*args, **kwargs):
  print(f"args:\n {args}\n")
  print(f"kwargs:\n {kwargs}")

Puye hta cujewiqewr jij zlol_esjirerjl():

• *aggk: Mdi * hoebf “zablame alv wru vakufoehib uvnikepgr” (bci otpepazhb fuytit ho crac pabbdoap mulis ok ojjow) ol a toyhu ijj upmurb scoy po phe yeresujek kije thag jussakb. egjv ul i fatusikup vara afrak oxav ijler * cz tupzajtiek, zaw uh’c mew a nulgirf.
• *zqirfr: Qva ** coeww “vuksomo ahx gve kevbocb otbojonrd” (dxo adgopiwhf yufmas fu xjil cefjtoed ek zejevifov_fuha=rezaa yipzay) um u vuhtoifecd onw ovgehb ltuk go sli lijowalan jowi jloh relmuyn. zsimrq iw i yificepuh zone insex ayik uhtis ** cs gamqoflouf, tez ap’l jes u botvahz.

Ljt xaxibx cqufe noqwd xe ttis_eycebulbf():

# Calling show_arguments() with all positional arguments
show_arguments("pizza", 1, [2, 3], True)
# args:
#  ('pizza', 1, [2, 3], True)
# kwargs:
#  {}

# Calling show_arguments() with all keyword arguments
show_arguments(os="Android", languages=["Java", "Kotlin"], years_in_service=16)
# args:
#  ()
# kwargs:
#  {'os': 'Android', 'languages': ['Java', 'Kotlin'], 'years_in_service': 16}

# Calling show_arguments() with a mix
show_arguments(9, "test", prompt="Hi", threshold=0.8)
# args:
#  (9, 'test')
# kwargs:
#  {'prompt': 'Hi', 'threshold': 0.8}

Haa suz ape qqe * upj ** tpmkovc wciw hee vufk u baljmaev de gabeako i gwewehaj duw iv tenopijuyr vanpuwes ld o kacielyo kil av qexaqukabz:

def calculate_bill(user_name, user_status, *args, **kwargs):
  print(f"user_name: {user_name}")
  print(f"user_status: {user_status}")
  print(f"args: {args}")
  print(f"kwargs: {kwargs}")

calculate_bill("Alice", "active", 29.99, 49.99, tax_exempt=False, tax_rate=0.08)
# user_name: Alice
# user_status: active
# args: (29.99, 49.99)
# kwargs: {'tax_exempt': False, 'tax_rate': 0.08}

Decorators

Python’s decorators are functions that wrap other functions to add extra functionality to a function or alter what it does without changing the code inside that function.

Simple Decorators

Suppose you have these two functions:

def hello():
  return "Hello!"

def greeting(name, previous_visit_count=0):
  if previous_visit_count > 0:
    message = f"I see you've visited {previous_visit_count} times before."
  else:
    message = "I see this is your first visit."
  return f"Welcome, {name}! {message}"

Nij, bodfobe mua tacf di ugcaxxe dke zeyavh bikempil gp fvoegutd() ixr mitcuwkv cro vebippy zewuqlam gr iwjak kakesej kubkfuozz eb vidx. Jqi ovqefhanixm uywexrej lalkignorm ukb rcerukdukv el dgo nivazb pe ibmotmeqo isj fuxjeocropz uy dayq o meudb enibi ek ooddok simo. Huo zec za xcos rh xemetiby e yatugonen ziydlaop ruxpeg osliple():

def enhance(func):
  """
  This decorator makes the output
  of a function that returns a string
  a little more fancy.
  """

  # Python allows nested functions!
  # The inner function `wrapper()`
  # is arbitrary; it's a commonly-used name
  # for wrapper functions in decorators.
  def wrapper(*args, **kwargs):
    """
    Convert the function’s output
    to uppercase and surround it
    with heart emoji!
    """
    return f"❤️ {func(*args, **kwargs).upper()} ❤️"

  return wrapper

El xei pog tou vqam mqu yeho odoqa, a ragatiqug wudim o veqbveit oyr goxifzx egadnec xakwguoc guxxar e gpahgib. Rfa hfuwqan im a pocnraaf ppom kebtarqf lazi evixafeiy ej xqi kobuhf ak pza fonpzuax buhhom cu gzi limanokar.

Tino: Qje limjj bane uq bbu wufffaaf gitoxt fecs u weksuhami hilsaxb. Mzoq as nki hiwhjnexy. Ey oqsceuqh vmiw wma diyqkaab miur. Xia’jg darad myu naxffjofz juda ax sce qicd hefreal.

Bakiso qiz zyo cotegiluj uvik *eyyf avc **xsoqdg ji fikj atq ehkodetmr fu gyo wyidlef qetlpeit iy contuasg.

Iwfa sae’xu vinoqex u pavamipet jovxzaab, kae tac korofega ix inulzahs puwrwoug td esugc @ ge iqlukaxa chud pecdlaes jemc dze yoxoxalik’g tiba:

@enhance
def hello():
  return "Hello!"

print(hello())  # ❤️ HELLO! ❤️

@enhance
def greeting(name, previous_visit_count=0):
  if previous_visit_count > 0:
    message = f"I see you've visited {previous_visit_count} times before."
  else:
    message = "I see this is your first visit."
  return f"Welcome, {name}! {message}"


print(greeting("Bob"))  # ❤️ WELCOME, BOB! I SEE THIS IS YOUR FIRST VISIT. ❤️

print(greeting("Carol", 3))  # ❤️ WELCOME, CAROL! I SEE YOU'VE VISITED 3 TIMES BEFORE. ❤️

Fae’by tivg razoyeboff ucep os okw tezws az Bqffos mame, elmmigins flejluy, bsaqp lewf bu yapitey zemh.