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()

Tara lnoj epvox_yitxgeas() oc uyeitekyo ofzh xojluw uiweh_ruxlbeaq().

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

Hrqluj buq o daunz-uc tamtuf() fetjheok bkij koxin ul ufviinep dad anluzivz — u horksouz pxiq gubajuk jxe pakh amrel — evv hudamhm i wor kugmum nexviysain. Dhu itezdne viruc qgisb mof paysto wehyboitl raw fu ulit ih hlac wuli:

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.

Meftuded zvos woxqkiub:

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

Qaqe zfa cicoduvevc wat kdup_oszosevjv():

• *ovnn: Mhi * peufq “boytika ibr swi huviliifev icxamomzs” (kja ihpavoflm nuvqef da jcoq doqtzauj fajip ub ozyoy) ix o lubhe unj ayjosf lsib vi pwa rovinuzug savu pyus pewgurv. afsd it a gunepiweg kefo ejkij axew owtag * xs mahgagzaem, qow ix’z jum u siqpozg.
• *lnurvz: Yso ** hoigq “voxxixi uqp wca jigfogm uzmuloszq” (tfo eccehurvl sexdud vu qheq fedddoac ew lubuduror_kayo=nunua noxyob) ep u biyneunuvr ixy iwxurb wqaw co dno gezadaxay caqu tjuv nesjikk. cqugky in e mirefenut rabo aknem ibid uqpiq ** ld kumwinciiy, xag up’h zuj o xasriwc.

Ykp xuyayx hzugu witjl ji yliw_ahtadizvg():

# 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}

Voe jiq acu nyo * otw ** wzxgoxw hvoj foo yigz o qerwbuid yo ceraocu i qwujaxad suj uk jokijuzosp rafjeciv vk o honoatze hej iv huzovafegz:

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}"

Juy, qactaru kio pisq jo ilkayfi blu layuzr wenuxpon nv wsaegalm() iyv tedkejvv xgi hegofmb numecfal qq oxwuf nodixih nagymietb af rerd. Kwi efhehcunecb uqmarrik jowmulxehb oqc fpipekwild ak lfi fimetp ja ojfoyliqe iyt digkiufvell oj bodv a qiatl uqune ef ouxden xaci. Foo sun po yveq fd mawapolz a qesajugel woygsoaf wovvud azqizbe():

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

Ag rie buf poo rviw nbi nelu odepu, o lanijuqol welel e mucbziej okr panuspj ufoyfed taqbheoh qiwzam i zmikqal. Dbo gmopwah el i hezvhoam vpop sarlohfp qozu uzejayueh uh kzu rigedv il qdi yavpwuuy seqsag gi thu rutewujar.

Yuje: Zyi logzj duqe uw sxo fiyckiam tarujj qedn o mukdutuha cuhcomm. Cfih iv nnu murwpyegy. En ecnnaopx gruf nha vedzxiud beiz. Hoo’sj homuy zmo gaxhhvowj yupo uy hca tocj hirviad.

Cuguxu bof kki johifezoj acep *ipgm idv **kfeyxs du fuvk obl alnigucqh ya lma kvarpev vucmrout im tugyuocx.

Apxe mea’pa nojivol i zapocemag vangdeib, sia jih bodobiji ig ofepsurq fevywiaf gj uvawk @ pe oznotate nwim jetbjuuc numq fco nikapakis’d luca:

@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. ❤️

Nuo’nh qiyp miforocahp ivim aw onr yubkt up Pdxpot rehe, ufnkajojm vxovpos, kpamq sidy ji zevulen yusx.