Untitled

Functions, Scoping, and abstraction

• Unit-2 covers functions, scoping and abstraction.
• The content includes declaring, defining, and invoking functions.
• The content includes function specification, function arguments, local vs global variables.
• Function arguments are keyword, default, positional, and variable-length.

Types of Functions

• There are three types of functions in Python: Built-in functions, User-Defined Functions (UDFs), and Anonymous functions.
• Built-in functions include help() to ask for help, min() to get the minimum value, and print() to print an object to the terminal.
• User-Defined Functions (UDFs) are functions that users create.
• Anonymous functions are also called lambda functions because they are not declared with the standard def keyword.

Declaring, Defining, and Invoking a Function

• Four steps to defining a function in Python:
• Use the keyword def to declare the function and follow this up with the function name.
• Add parameters to the function: they should be within the parentheses of the function and end the line with a colon.
• Add statements that the functions should execute.
• End function with a return statement if the function should output something; without it, the function will return an object None.

Syntax of a Python Function

• def name_of_function(parameters ):
• Use a docstring to describe the function i.e. """Python Programming"""

Declaring and Defining a User-Defined Function

• A function defined as def square( num ): returns the square of the number passed to it as an argument.
• The return keyword returns the value of the function, i.e. return num**2
• Once a function's framework is complete, it can be called from anywhere in the program.

Function Arguments

• Types of arguments that call a function: Default arguments, Keyword arguments, Required arguments, and Variable-length arguments.

Default Arguments

• A parameter with a default value if no value is supplied for the argument when the function is called.
• For example:

def function(num1, num2 = 40 ):
	print("num1 is: ", num1)
	print("num2 is: ", num2)
## Calling the function and passing only one argument
function(10)

Keyword Arguments

• Function calls use parameter labels to identify the parameter's value.
• For example:

def function(num1, num2 ):
  print("num1 is: ", num1)
  print("num2 is: ", num2)

function( num2 = 50, num1 = 30)

Required Arguments

• These arguments are given to a function in a pre-defined positional sequence during a call.
• The count of required arguments in the method call must equal the count provided while defining the function.
• Omitting an argument will cause a syntax error.

Variable-Length Arguments

• Special characters in Python functions pass as many arguments as are needed.
• *args are non-keyword arguments.
• **kwargs are keyword arguments.
• Example:

def sum(*args):
	resultfinal = 0
	#beginning of for loop
	for arg in args:
		resultfinal = resultfinal + arg  
	return resultfinal
#printing the values
print(sum(10, 20)) # 30
print(sum(10, 20, 30)) # 60
print(sum(10, 20, 2)) #32    

Lambda Functions

• Lambda Functions in Python are anonymous functions, implying they don't have a name.
• Use the lambda keyword in Python to define an unnamed function.
• Syntax lambda arguments: expression
• Example

add = lambda num: num + 4
print(add(6))

• A lambda function in code such as lambda num: num+4 has "num" as the parameter and "num +4" as the computed and returned equation.
• It generates a nameless function object that can be associated with an identifier to refer to it as a standard function.

Local and Global Variables

• Global variables are not defined inside any function, gives them a global scope.
• Local variables which are defined inside a function and scope is limited to that function only.
• Local variables are accessible only inside the function in which it was initialized.
• Global variables are accessible throughout the program including inside every function.
• Example of a local variable:

def f():
	# local variable
	s = "Python Programming"
	print(s)
## Driver code
f()

• Example of a global variable:

## This function uses global variable s
def f():
	print("Inside Function", s)
## Global scope
s = "Python Programming"
f()
print("Outside Function", s)

Immutable Data Types

• Cannot be changed once declared and consist of Numbers, Strings, and Tuples.
• Python has four types of number literals: Integer, Long Integer, Floating number, and Complex.
• Python automatically converts one number type to another in the declaration.
• Example:

p=10 # Int
py="Python" # String
per=101.20 # Float

• Immutable data structures are useful when preventing multiple people from modifying a piece of data in parallel programming.
• Tuples are read-only collections of Python objects separated by commas that are similar to lists in terms of indexing, repetition, and nested objects.
• Example:

t = ( 0, 1, 2, 3, 4, 5) # Tuple 
t[0]=3 # Invalid
Output: TypeError: 'tuple' object does not support item assignment

Strings

• Python strings - collections of characters, surrounded by single, double, or triple quotes.
• Strings are stored internally as a manipulated character combination of 0's and 1's.
• Each string character is encoded using the ASCII or Unicode standard.
• Slice operator [] accesses the individual characters of the string.
• The : (colon) accesses substrings in the string.
• Examples:

str = "HELLO"
str[0:2] = 'HE' # Returns a string slice

• A string can only be replaced entirely due to being immutable in Python.
• del str removes the string.

String operators

• + is a concatenation operator used to join the strings together.
• * is a repetition operator is used to concatenate multiple copies of the string.
• [] - The slice operator is used to access the substrings
• [:] - The range slice operator is used to access the characters from the specified range.
• in - Membership operator, tests if substring is present in string.
• not in - Membership operator, tests if substring is not present in string.
• r/R - Designates a string as a “raw string”, useful for file paths.
• % - Performs string formatting (like sprintf in C).

String Functions

• pf.find(str) - finds first matching string
• pf.replace(old, new) - replaces old sub string with new
• split1.split(delimeter) - splits string based on the delimeter
• sc.count(substring) - counts the occurances of a substring
• sc.upper() - converts to all uppercase
• max(s), min(s) - returns the maximum/minimum character respectively

Mutable Data Types

• Lists, Dictionaries, and Sets can be changed anytime.

Lists

• Mutable Python data type defined within square brackets []
• Operations applied on lists: Concatenation, repetition, slicing, append, extend and insert.

List Functions

• Concatenation adds two or more lists/elements together.
• Repetition is used to duplicate a list a given number of times.
• Slicing is same as tuples except it applies to lists.
• Append is used to add a value to a list.
• Extend is function of concatenation.
• Insert includes the use of index value for insertion.

Dictionaries

• Mutable, consists of group values within a {}-curly braces
• Contains 2 elements of key, and value.
• Dictionary functions include:
  • emptyDictionary - No value inside the dictionary
  • Integer Key - Dictionary includes only integer keys
  • Mixed Key - Dictionary includes a mix of keys
  • Pairing - Sequence where each item has a pair
• Use of len() returns output in numeric as the number of elements in Dictionary.
• Use of value() return all the values inside the dictionary.
• Use of key() finds the key to the dictionary.

Sets

• Sets are mutable and hold unordered collections of unique items within curly braces {}.
• Sets don't define key-value pairs for elements.
• Functions for sets include creating a set.
• Use of Union returns a value from both sets.
• Use of Intersection returns the common elements from both sets.
• Use of Difference omits all common values from both sets and returns only that value which is unique and written in the first set.

Variable Length Keyword Arguments

• Can use multiple keywords as arguments
• For example

def my_func(**kwargs):
  for k,v in kwargs.items():
    print("%s=%s"%(k,v))

my_func(a_key="Let",b_key="us",c_key="study")