1. Arguments & Scope

Scope

• Scope in functions
  • Not all objects are accessible everywhere in a script
  • Scope – part of the program where an object or name may be accessible
    1. Global scope – defined in the main body of a script
    2. Local scope – defined inside a function
    3. Built-in-scope – names in the pre-defined built-ins module (such as print and sum)

• Scope and user defined functions (Global vs. local scope)
  1. If function was only defined in the local scope, it will only appear in the local scope but not global scope
  2. Any time we call the name in the global scope of the function, it will assess the name in only global scope
  3. Any time we call the name in the local scope of the function, it will look first in the local scope
  4. If python cannot find the name in the local scope, it will then find the name in the global scope
  5. When reference a name, first the local scope is searched, then the global.
  6. If the name is in neither, then the built-in scope is searched
  7. Within the function definition, use the keyword global followed by the name of the global variable that we wish to access and alter

Nested Functions

• A nested function is a function which is defined within another function, the enclosing function.
  • Python searches the local scope of the function inner, then if it doesn’t find x, it searches the scope of the function outer, which is called an enclosing function because it encloses the function inner
  • If Python can’t find x in the scope of the enclosing function, it will then searches the global scope and then the built-in scope
  • Example 1:

def three_shouts(word1, word2, word3):

"""Returns a tuple of strings concatenated with '!!!' """

def inner(word): # Define inner

"""Returns a string concatenated with '!!!'."""

return word + '!!!'

return (inner(word1), inner(word2), inner(word3)) # Return a tuple of strings

print(three_shouts('a', 'b', 'c'))

• Example 2:

def echo_shout(word):

"""Change the value of a nonlocal variable"""

echo_word = word*2 # Concatenate word with itself

print(echo_word)

def shout(): # Define inner function shout()

"""Alter a variable in the enclosing scope"""

nonlocal echo_word # Use echo_word in nonlocal scope

echo_word = echo_word + "!!!" # Change echo_word to echo_word concatenated with '!!!'

shout() # Call function shout()

print(echo_word)

echo_shout('hello')

Default and flexible arguments

• Default arguement

def power(number, pow=1):

“””Raise number to the power of pow.”””

new_value = number ** pow

return new_value

power(9, 2)

• Flexible arguments: *args (used to pass a variable number of arguments to a function)

def add_all(*args):

“””Sum all values in *args together.”””

sum_all = 0 # Initialize sum

for num in args:

sum_all += num # Accumulate the sum

return sum_all

• Flexible arguments: **kwargs (used to pass a keyworded, variable-length argument list)

def print_all(**kwargs):

“””Print out key-value pairs in **kwargs”””

for key, value in kwargs.items(): # Print out the key-value pairs

print(key + ":" + value)

print_all(name=’a’, job=’b’)

• Example 1:

def shout_echo(word1, echo=1):

"""Concatenate echo copies of word1 and three exclamation marks at the end of the string."""

echo_word = word1 * echo # Concatenate echo copies of word1

shout_word = echo_word + '!!!' # Concatenate '!!!' to echo_word

return shout_word # Return shout_word

no_echo = shout_echo("Hey") # Call shout_echo() with "Hey"

with_echo = shout_echo("Hey", 5) # Call shout_echo() with "Hey" and echo=5

print(no_echo)

print(with_echo)

• Example 2:

def gibberish(*args):

"""Concatenate strings in *args together."""

hodgepodge = "" # Initialize an empty string

for word in args:

hodgepodge += word

return hodgepodge

one_word = gibberish("luke")

many_words = gibberish("luke", "leia", "han", "obi", "darth")

print(one_word)

print(many_words)

• Example 3:

def report_status(**kwargs):

"""Print out the status of a movie character."""

print("\nBEGIN: REPORT\n")

for keys, values in kwargs.items(): # Iterate over the key-value pairs of kwargs

print(keys + ": " + values)

print("\nEND REPORT")

report_status(name="luke",affiliation="jedi",status="m") # First call to report_status()

report_status(name="anakin", affiliation="", status="d") # Second call to report_status()

Function header by supplying the parameter for a DataFrame df

• Example 1

import pandas as PD

tweets_df = pd.read_csv(‘tweets.csv’)

def count_entries(df, col_name='lang'):

"""Return a dictionary with counts of occurrences as value for each key."""

cols_count = {} # Initialize an empty dictionary

col = df[col_name] # Extract column from DataFrame

# Iterate over the column in DataFrame

for entry in col:

if entry in cols_count.keys(): # If entry is in cols_count, add 1

cols_count[entry] += 1

else:

cols_count[entry] = 1

return cols_count

result1 = count_entries(tweets_df, "lang")

result2 = count_entries(tweets_df, source")

print(result1)

print(result2)

• Example 2

import pandas as PD

tweets_df = pd.read_csv(‘tweets.csv’)

def count_entries(df, *args):

"""Return a dictionary with counts of occurrences as value for each key."""

cols_count = {} #Initialize an empty dictionary

for col_name in args: # Iterate over column names in args

col = df[col_name] # Extract column from DataFrame

# Iterate over the column in DataFrame

if entry in cols_count.keys(): # If entry is in cols_count, add 1

cols_count[entry] += 1

else:

cols_count[entry] = 1

return cols_count

result1 = count_entries(tweets_df, "lang")

result2 = count_entries(tweets_df, "lang", "source")

print(result1)

print(result2)