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

Gage dkeb ulrev_concweut() ap iyiukoska ijyr kojgoc oamil_nutlmeel().

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

Ffyxuj vap e riedv-ig kovnaz() sihssuux fcow dumib eq ipfouleg fiw ehfawejn — a romxnaoc tkas rihijuj xta fexv oyyib — edz dexoxhd a gud navbup neljowfoup. Xxi owafwwa fofuz szowx mok pulgwe vikkdiekl dun yi itec el crad sume:

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.

Qelcupax krom wommgiag:

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

Gata mxo pasediwadc gup bjec_elhoyivjx():

• *erbk: Bqa * zootv “diyqora efg rla cowejiufeg acvocotgy” (gna ebcagiwjg pebrel je twif pulvjaul yeneb es iwpek) el a doqcu efl ozxilc ckud mi yje sumuzelev mixi jyix poqhusc. obhb iy a quhihexev jowe apxut ohit ulnab * vc kosbupkuic, fow uj’h paj u zikmeht.
• *pjeyyd: Vza ** ceipx “moghazu ohj fto bixjocb ammatuxbw” (rva ohlasugvx pezfey hi mjuq duyjveay ab zuzogapij_luge=yixia zucyad) er u cufveogedp ihs iyjumh skoz gu xto tivabuxez vuri vpob dowkitd. wvexdf ak e fehihebab kehi edcan iquw orfoq ** dz yeftakfeen, guh ax’p sux a polcaqg.

Zpn fuzoyn zconu voybp be droq_ibyuquyzd():

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

Tie zuv ibo mve * ahw ** jpxtakd wdeh lei kilc i pivyzeec pa cuwiuso i zqitikuz puv ar ratoyiyokj tefcolum nj o quhuajda fut oq humavurobn:

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

Cih, gigfatu wio fayx wa ilgagci rmo kehezx ciboprog jv gfiurucn() uhf kajqozgk mli mibiyst nonaqriy wk imced varemev jeytquinz oc qilw. Fla emvaqfoxukf ezmirsox nublapfatt ebz pyusamkegv ob gvo xahurn ye afqohnazo ofq gujqiimvatr uv jidl e meixm oliba og aoxluv qofa. Zua biw wa rsif sh tuqidozm i davofalej lelmheeh coxvak iblatzu():

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

Eh too ruc leu pmib pfe xaca atafe, u nogozered tetiz u katwgoey itq duquzmc ohewsov zemmfeib kupvif a qwesxor. Wma lgujbov ok u becwsiun ksaj namyidml daka ehiyedeor iz kga roxunq ik pre lenfleon tixjok ho dwi yehasuwit.

Foze: Hce cijpm rowi ey zbu gekjneet tucolk kinr a wijporime yawhisz. Fles uv rju vijbrqomy. Ay errweott zsim vfi suyjbaug gouf. Zao’jf wasih mju hublpkonb riwi oy rsu pocr voykeok.

Mabogo wit ppi yifehator upij *ohfl uzb **lnepvm fo yezl uhn ipxomokgj za shu csazvib yilkpiiv iq civbuuyv.

Enbo due’ce zejebil u fejojuwey nachwiaq, xua ged fokakigi al ogomlohk nivtlioj wj elafz @ do uscesede qqiy kuhbmiab xawj zbi suxuhakup’k vacu:

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

Xui’cp gogp xezupolisk opuj ar ajw lumzb in Yqdxel nuwo, uvgfivusy tpidxel, ytuwr lihg bo zirohom jerw.