_Python_ Functions _and_ Libraries_.pptx

Python: Functions and Libraries
Eng. Mohamed Gamal,
Research Assistant, Center for Photonics and Smart Materials, Zewail City

Outline
❖ Python Functions
➢ Basic Syntax, Definitions, and Calling
➢ Function Parameters
➢ Anonymous (Lambda) Functions
➢ Recursion and Nested Functions
❖ Python Libraries
➢ Standard Libraries
➢ Numpy
➢ Pandas
➢ Matplotlib
➢ Scikit-learn
➢ Tensorflow
➢ Keras
➢ Pytorch
➢ OpenAI Gym

Functions: Definition
❏ A function is a block of organized, reusable code that is used to perform a
single, related action.
❏ Functions provides better modularity for your application and a high
degree of code reusing.
❏ As you already know, Python gives you many built-in functions like print()
etc. but you can also create your own functions.
❏ These functions are called user-defined functions.

Python Functions: Basic Syntax
❏ In Python, a function is defined using the def keyword, followed by the function name,
parentheses (), and a colon :. The function body is indented to indicate the code block that
the function executes. Here's the basic syntax of a Python function:
❏ function_name is the name of the function, which should be descriptive and meaningful.
❏ arguments are the inputs to the function, which can be optional or required.
❏ return is a keyword that specifies the output of the function, which can be a value or a
collection of values.

Python Functions: Calling
❖ Function calling is an essential aspect of Python programming and has several benefits,
including:
➢ Code reusability: Functions allow you to reuse code by defining a block of code that
can be called multiple times from within your program. This reduces the amount of
code you need to write and makes your code more modular and maintainable.
➢ Abstraction: Functions provide a level of abstraction that allows you to focus on the
logic or purpose of the function without worrying about the implementation details.
This makes your code more readable and easier to understand.

❖ Function calling is an essential aspect of Python programming and has several
benefits, including:
➢ Encapsulation: Functions allow you to encapsulate a particular piece of
functionality or logic into a single unit. This helps to separate concerns in
your code and makes it easier to debug and maintain.
➢ Scalability: Functions allow you to break down complex problems into
smaller, more manageable pieces. This makes it easier to scale your code as
your program grows in complexity.

❖ To call a function in Python, you need to follow these steps:
➢ Define the function: Define the function by using the
def keyword followed by the function name,
parentheses, and a colon. The function code should be
indented beneath the function definition line.

❖ To call a function in Python, you need to follow these steps:
➢ Call the function: To call the function, simply type the
function name followed by parentheses and any
required arguments.

❏ This would output the following:

Functions Parameters
❖ Function parameters in Python are variables that are defined in the function header and are used to pass
values or data to the function when it is called, allowing for more flexible and dynamic behavior of the
function.
❖ In Python, a function can take zero or more parameters. When a function is called, the values passed to
the function are referred to as arguments.
❖ There are two types of function parameters in Python: positional parameters and keyword parameters.
❖ In addition to these two types of parameters, Python also allows for default parameter values. Default
values are specified in the function header and are used if no value is passed for that parameter when the
function is called.

Functions Parameters: Positional Parameters
❖ In Python, positional parameters are function parameters that are passed to the function in the
order they are defined in the function header. When you call a function with positional
parameters, the values are assigned to the parameters in the order they appear in the function
definition.
➢ Here's an example of a function with two positional parameters:
❖ In this function, x and y are positional parameters. When you call the add() function, you need to
pass two arguments in the order they appear in the function definition

❖ In this example, the values 3 and 5 are assigned to x and y
respectively. The function then returns the sum of x and y, which is
8.
❖ You can also pass positional parameters as variables:

In addition to the basic functionality of positional parameters in Python, there are a few more
things to keep in mind:
❖ The number of arguments must match the number of parameters: When calling a
function with positional parameters, the number of arguments passed to the function
must match the number of parameters defined in the function header. If you pass too
many or too few arguments, you will get a TypeError.
❖ Positional parameters can have default values: You can also give a positional parameter a
default value. If the parameter is not passed when calling the function, the default value
will be used instead. For example:

❖ The order of positional parameters matters: The order in
which you define positional parameters matters. When
you call a function with positional parameters, the values
are assigned to the parameters in the order they appear
in the function definition. For example:

Functions Parameters: Keyword Parameters
❖ In Python, keyword parameters are function parameters that are passed to the function using their
names. When calling a function with keyword parameters, the order of the arguments does not matter, as
each argument is associated with a specific parameter name.
➢ Here's an example of a function that takes two keyword parameters
➢ In this function, name and message are keyword parameters. When you call the greet() function with
keyword parameters, you specify the parameter name followed by the corresponding argument
value, separated by an equal sign:

Functions Parameters: Keyword Parameters
❖ To call the function, we use the following format:
● Keyword parameters are particularly useful when a function has many
parameters or when the order of the parameters is not obvious. By using
keyword parameters, you can make your function calls more clear and readable.
● Keyword parameters can have default values same as positional parameters.

Anonymous Functions
❖ In Python, an anonymous function is a function that is defined without a name.
❖ Anonymous functions are also known as lambda functions because they are defined
using the lambda keyword.
❖ Lambda functions are useful for writing small, one-time-use functions that do not need
to be named or defined separately.
❖ They are particularly useful when you need to pass a function as an argument to another
function. Instead of defining a separate function, you can define a lambda function on
the fly and pass it directly to the other function.

Anonymous Functions
❖ You can call a lambda function just like any other function:
❖ Lambda functions can also be used with built-in functions like
map() and filter(). For example, the following code uses a
lambda function with map() to square each element in a list:

Anonymous Functions: Properties
❖ Lambda functions can take any number of arguments: Lambda functions can take
any number of arguments, including zero arguments. The syntax for a lambda
function with zero arguments is simply lambda: expression.
❖ Lambda functions can have default values: You can give a lambda function default
values for its arguments just like you would with a regular function.
❖ Lambda functions can be used as anonymous functions: Because lambda functions
do not have a name, they are often used as anonymous functions. For example, you
might use a lambda function as a key function when sorting a list of dictionaries:

Recursion
❖ Recursion is a technique in computer programming where a function calls itself to solve a
problem. In Python, you can write recursive functions to solve problems that can be broken
down into smaller subproblems.
❖ It's important to note that recursive functions can be memory-intensive, particularly if the
recursion depth is very deep. Python has a maximum recursion depth of 3000 by default, so if
your program requires deeper recursion, you may need to increase this limit using the
sys.setrecursionlimit() function.

Recursion
❖ Recursion can be used to solve many types of problems: Recursion can be used
to solve a wide variety of problems, including searching, sorting, and tree
traversal. Recursive algorithms can be elegant and easy to understand, but they
can also be less efficient than iterative algorithms for some types of problems.
❖ Recursion requires a base case: A base case is the condition that causes the
recursion to stop. Without a base case, the recursion will continue indefinitely,
eventually causing a stack overflow error. In the factorial() example, the base case
is n=0.
❖ Recursion involves a function calling itself: In a recursive function, the function
calls itself with a smaller or simpler version of the input. In the factorial()
example, the function calls itself with the argument n-1.

Nested Functions
❖ In Python, it's possible to define functions inside other functions. These are called
nested functions or inner functions.
❖ Nested functions are useful for creating helper functions that are only used within
a larger function, and for creating closures, which are functions that can access
variables in their parent function's scope.

Nested Functions
❖ Nested functions can also be used to create closures. A closure is a function that
"remembers" the values of variables in its parent function's scope, even after the
parent function has returned. Here's an example of a closure:

Nested Functions: Decorators
❖ Nested functions can access variables from their parent function's scope.
❖ Nested functions can be used to create decorator functions.
❖ A decorator function is a function that takes another function as an argument and
returns a new function that adds some additional functionality to the original
function.

Nested Functions: Factory Functions
❖ Nested functions can be used to create factory functions: A factory function is a
function that returns another function. Factory functions can be created using
nested functions. Here's an example:

Python Libraries: Standard Libraries
❖ Python comes with a variety of standard libraries that are included with the
language. These libraries provide a wide range of functionality, from working with
files and directories, to networking, to cryptography, and much more.

Python Libraries: os
❖ The os library in Python provides a way to interact with the operating system,
such as creating and removing directories, listing directory contents, and getting
information about files. Here are some commonly used functions in the os library:
➢ os.getcwd(): Returns the current working directory.
➢ os.chdir(path): Changes the current working directory to the directory
specified by path.
➢ os.listdir(path): Returns a list of files and directories in the directory specified
by path.
➢ os.mkdir(path, mode=0o777): Creates a new directory with the specified path
and permissions specified by mode.

Python Libraries: sys
❖ The sys module in Python provides access to some variables used or maintained
by the interpreter, as well as functions that interact with the Python runtime
environment. Here are some commonly used functions and variables in the sys
module:
➢ sys.argv: A list of command line arguments passed to the Python script.
sys.argv[0] is usually the name of the script itself.
➢ sys.exit([arg]): Exits the Python interpreter with an optional exit status arg. If
arg is omitted, the exit status is zero.
➢ sys.platform: A string identifying the operating system platform that Python
is running on, such as "win32", "linux", or "darwin".
➢ sys.version: A string containing the version number and build information of
the Python interpreter.

Python Libraries: sys
❖ In this code, we first use the
sys.version variable to display the
version of Python running. We then
use the sys.argv variable to display
the command line arguments passed
to the script. The sys.maxsize variable
returns the maximum integer value
that can be used as an index in a list.
Finally, we use the sys.stderr.write()
function to display a warning
message to the standard error
stream.

Python Libraries: math
❖ The math module in Python provides a collection of mathematical functions that
operate on numerical data. Here are some commonly used functions in the math
module:
➢ math.sqrt(x): Returns the square root of x.
➢ math.pow(x, y): Returns x raised to the power of y.
➢ math.exp(x): Returns the exponential of x, e^x.
➢ math.log(x[, base]): Returns the natural logarithm of x if base is not specified.
If base is specified, returns the logarithm of x with respect to base.
➢ math.sin(x), math.cos(x), math.tan(x): Returns the sine, cosine, and tangent
of x, respectively.
➢ math.asin(x), math.acos(x), math.atan(x): Returns the inverse sine, inverse
cosine, and inverse tangent of x, respectively.

Python Libraries: math
❖ In this code, we first use the
math.sqrt() function to calculate the
square root of the number 16. We
then use the math.pi constant to get
the value of pi. The math.sqrt()
function returns a floating-point
number that represents the square
root of the input number. The math.pi
constant returns the value of pi as a
floating-point number.

Python Libraries: random
❖ The random module in Python provides functions for generating random
numbers and sequences. Here are some commonly used functions in the random
module:
➢ random.random(): Returns a random floating-point number between 0.0 and
1.0 (inclusive).
➢ random.randint(a, b): Returns a random integer between a and b (inclusive).
➢ random.randrange(start, stop[, step]): Returns a random integer from the
range start (inclusive) to stop (exclusive), with an optional step size.
➢ random.choice(seq): Returns a random element from the sequence seq.
➢ random.shuffle(seq): Shuffles the sequence seq in place.
➢ random.sample(population, k): Returns a random sample of k elements from
the population population, without replacement.

Python Libraries: random
❖ we first use the random.random()
function to generate a random number
between 0 and 1. We then use the
random.shuffle() function to shuffle a
list of numbers. Finally, we use the
random.choice() function to make a
random choice from a sequence of
colors. The random.random() function
returns a floating-point number
between 0 and 1. The random.shuffle()
function shuffles the elements of the
input list in place. The random.choice()
function returns a randomly selected
item from the input sequence.

Python Libraries: re
❖ The re module in Python provides support for regular expressions, which are a
powerful and flexible way to search for and manipulate text. Here are some
commonly used functions in the re module:
➢ re.search(pattern, string[, flags]): Searches for the first occurrence of pattern
in string, and returns a match object if found. flags can be used to modify the
behavior of the search.
➢ re.match(pattern, string[, flags]): Searches for pattern at the beginning of
string, and returns a match object if found. flags can be used to modify the
behavior of the search.
➢ re.findall(pattern, string[, flags]): Searches for all non-overlapping
occurrences of pattern in string, and returns a list of matching strings.

Python Libraries: re
❖ we first use the re.search() function to
search for the pattern "fox" in the string
"The quick brown fox jumps over the
lazy dog.". If the pattern is found, we
print the matched text using the
match.group() method. If the pattern is
not found, we print a message saying
so. We then use the re.sub() function to
replace the pattern "fox" with the
replacement string "cat" in the same
input string. The re.sub() function
returns a new string with the pattern
replaced by the replacement string.

Python Libraries: json
❖ The json module in Python provides functions for encoding and decoding JSON
(JavaScript Object Notation) data. JSON is a lightweight data interchange format
that is easy for humans to read and write, and easy for machines to parse and
generate. Here are some commonly used functions in the json module:
➢ json.dump(obj, fp[, *, skipkeys=False, ensure_ascii=True, check_circular=True,
allow_nan=True, cls=None, indent=None, separators=None, default=None,
sort_keys=False, **kw]): Serializes obj to a JSON formatted str, writing it to a
file-like object fp.
➢ json.load(fp[, *, cls=None, object_hook=None, parse_float=None,
parse_int=None, parse_constant=None, object_pairs_hook=None, **kw]):
Deserializes a JSON formatted str to a Python object from an input file-like

❖ JSON is a lightweight and easy-to-read data interchange format that is widely
supported by many programming languages, making it a popular choice for data
exchange between different systems and applications.
❖ JSON can represent complex data structures, including arrays, objects, and nested
data, making it a flexible and powerful format for data storage and exchange.
❖ JSON is human-readable and easy to parse, making it useful for debugging and
troubleshooting data exchange issues.
❖ JSON is often used in web development, where it is a popular format for REST APIs
(Application Programming Interfaces) and AJAX (Asynchronous JavaScript and XML)
requests. JSON data can be easily parsed and manipulated using JavaScript, making it a
natural fit for web development.

❖ we use the json.dumps() function to
encode a Python dictionary called data
as a JSON string. The resulting JSON
string is stored in the variable
json_data. We then use the json.loads()
function to decode a JSON string called
json_str into a Python dictionary. The
resulting dictionary is stored in the
variable decoded_data. The
json.dumps() function returns a JSON
string representing the input Python
object. The json.loads() function parses
a JSON string and returns a Python
object.

Python Libraries: csv
❖ The csv module in Python provides functions for working with CSV (Comma-
Separated Values) files, which are a common file format for storing and
exchanging tabular data. Here are some commonly used functions in the csv
module:
➢ csv.reader(csvfile[, dialect='excel', **fmtparams]): Returns a reader object
that can be used to iterate over the rows in a CSV file.
➢ csv.writer(csvfile[, dialect='excel', **fmtparams]): Returns a writer object that
can be used to write rows to a CSV file.
➢ csv.DictReader(csvfile[, fieldnames=None, restkey=None, restval=None,
dialect='excel', **fmtparams]): Returns a dictionary-reader object that can be
used to iterate over the rows in a CSV file, where the keys of each dictionary
are the column headers.

Python Libraries: csv
❖ we use the csv.writer() function to write
a list of lists (representing CSV data) to a
file called "data.csv". We use the with
statement to automatically close the file
after writing to it. We then use the
csv.reader() function to read the CSV
data from the file "data.csv". We iterate
over the rows of the CSV data and print
each row. The csv.writer() function
writes CSV data to a file in a specified
format. The csv.reader() function reads
CSV data from a file and returns an
iterator over the rows.

Python Libraries: datetime
❖ The datetime module in Python provides classes and functions for working with
dates and times. Here are some commonly used classes and functions in the
datetime module:
➢ date: Represents a date (year, month, day) and provides methods for
manipulating and formatting dates.
➢ time: Represents a time (hour, minute, second, microsecond) and provides
methods for manipulating and formatting times.
➢ datetime: Represents a date and time and provides methods for
manipulating and formatting dates and times.
➢ timedelta: Represents a duration or difference between two dates or times,
and provides methods for performing arithmetic with durations.

Python Libraries: datetime
❖ we first use the datetime.datetime.now()
function to create a datetime object
representing the current date and time.
We then use the strftime() method to
format the datetime object as a string in
the format "YYYY-MM-DD HH:MM:SS". We
then use the datetime.datetime() function
to create a datetime object representing a
specific date and time (December 31, 2022
at 11:59:59 PM). Finally, we use the
timedelta() function to create a timedelta
of one day, and add it to the datetime
object to get a new datetime object
representing January 1, 2023 at 11:59:59
PM.

External Libraries: Numpy
❖ The numpy library (short for "Numerical Python") is a popular Python library for
numerical computing and data analysis. Here are some commonly used features
and functions in the numpy library:
➢ numpy.array: Creates a new ndarray object from a Python list or tuple.
➢ numpy.arange: Creates a new ndarray object with a sequence of evenly
spaced values within a specified range.
➢ numpy.linspace: Creates a new ndarray object with a sequence of evenly
spaced values within a specified range, with a specified number of elements.
➢ numpy.eye: Creates a new ndarray object with the identity matrix.
➢ numpy.random.rand: Creates a new ndarray object with random values
between 0 and 1.
➢ numpy.reshape: Reshapes the dimensions of an ndarray object.

External Libraries: Numpy
❖ we first use the numpy.array() function to
create a 1D array and a 2D array. We then
use the shape attribute to get the shape of
the 2D array and the indexing operator to
access a specific element of the array. We
then use the + operator to add two arrays
together and the numpy.mean() function
to calculate the mean of an array.

External Libraries: pandas
❖ The pandas library is a popular Python library for data manipulation and analysis. It
provides data structures and functions for working with structured data, such as tables
and time series. Here are some commonly used classes and functions in the pandas
library:
➢ Series: Represents a one-dimensional array with labeled indices. It is similar to a
Python dictionary, but with optimized performance for numerical operations.
➢ DataFrame: Represents a two-dimensional table with labeled rows and columns. It
is similar to a spreadsheet or SQL table, but with advanced indexing and slicing
capabilities.
➢ read_csv: Reads a CSV (Comma-Separated Values) file into a DataFrame object.
➢ to_csv: Writes a DataFrame object to a CSV file.
➢ head: Returns the first n rows of a DataFrame object.
➢ tail: Returns the last n rows of a DataFrame object.

External Libraries: Pandas
❖ we use the pandas.read_csv() function to
read data from a CSV file into a DataFrame
object called df. We then use the indexing
operator to select rows based on a
condition (in this case, selecting rows
where the "Age" column is greater than
30). We use the sort_values() method to
sort the data frame by the "Name" column
in ascending order. Finally, we use the
groupby() method to group the dataframe
by the "City" column and calculate the
mean of the "Age" column for each group.

External Libraries: matplotlib
❖ matplotlib is a popular Python library for creating data visualizations. It provides a wide
range of functions for creating various types of plots and charts, such as line plots,
scatter plots, bar charts, histograms, and more. Here are some commonly used
features and functions in the matplotlib library:
➢ pyplot: Provides a simple interface for creating and customizing plots and charts.
➢ figure: Creates a new figure for a plot or chart.
➢ subplot: Creates a new subplot within a figure.
➢ plot: Creates a line plot or scatter plot.
➢ scatter: Creates a scatter plot.
➢ bar: Creates a bar chart.
➢ hist: Creates a histogram.
➢ boxplot: Creates a box plot.
➢ set_xlabel/set_ylabel: Sets the labels for the x-axis and y-axis.

External Libraries: matplotlib
❖ we first use the numpy.arange() function to
create an array of x-values ranging from 0
to 10 with a step size of 0.1, and then use
the numpy.sin() function to create an array
of y-values representing the sine function
of the x-values. We then use the
matplotlib.pyplot.plot() function to create a
line plot of the data. We use the xlabel(),
ylabel(), and title() functions to add labels
and a title to the plot. Finally, we use the
show() function to display the plot.

External Libraries: Scikit-learn
❖ Scikit-learn (also known as sklearn) is a popular Python library for machine learning. It
provides a wide range of algorithms and functions for various machine learning tasks, such
as classification, regression, clustering, and dimensionality reduction. Here are some
commonly used features and functions in the scikit-learn library:
➢ Dataset loading utilities: Provides functions for loading and working with popular
datasets, such as the Iris dataset and the MNIST dataset.
➢ Preprocessing: Provides functions for preprocessing data, such as scaling,
normalization, and feature selection.
➢ Supervised learning algorithms: Provides a wide range of algorithms for supervised
learning, such as linear regression, logistic regression, decision trees, random forests,
and neural networks.
➢ Unsupervised learning algorithms: Provides a wide range of algorithms for
unsupervised learning, such as k-means clustering, hierarchical clustering, and principal
component analysis (PCA).

External Libraries: Tensorflow
❖ TensorFlow is an open-source machine learning library developed by Google. It is designed to
build and train machine learning models for a wide range of applications, including image
and speech recognition, natural language processing, and reinforcement learning.
TensorFlow provides a powerful and flexible platform for building and deploying machine
learning models, with support for both low-level operations and high-level abstractions.
➢ Computation graphs: TensorFlow uses computation graphs to represent machine
learning models as a series of mathematical operations. This allows for efficient
computation on both CPUs and GPUs, and makes it easy to optimize and parallelize the
model.
➢ Automatic differentiation: TensorFlow provides an automatic differentiation feature,
which allows for efficient computation of gradients for backpropagation-based
optimization algorithms.
➢ High-level APIs: TensorFlow provides high-level APIs (such as Keras and Estimators) for
building and training machine learning models, which can simplify the model-building
process for beginners.

External Libraries: Keras
❖ Keras is a high-level neural network API written in Python that runs on top of TensorFlow (as well
as other backends such as Theano and Microsoft Cognitive Toolkit). It was developed with a focus
on enabling fast experimentation with deep neural networks, with the goal of making it easy to
go from idea to result as smoothly as possible.
➢ Modular design: Keras provides a modular design that allows users to easily mix and match
different layers and activation functions to create custom neural network architectures.
➢ Built-in layers and activation functions: Keras provides a range of built-in layers and
activation functions for building custom models, including convolutional layers, recurrent
layers, and fully connected layers.
➢ Customizable loss functions and metrics: Keras allows users to define custom loss functions
and metrics for training and evaluating their models.
➢ Preprocessing and data augmentation: Keras provides a range of utilities for preprocessing
and augmenting data, including image preprocessing and sequence padding.
➢ Model saving and loading: Keras provides utilities for saving and loading trained models,
which can be useful for deploying models in production environments.

External Libraries: Pytorch
❖ PyTorch is an open-source machine learning library developed by Facebook. It provides a
flexible and efficient platform for building and training machine learning models, with
support for both CPU and GPU computation. PyTorch is known for its dynamic computational
graph, which allows for more flexible and efficient computation compared to static
computational graphs used in other libraries like TensorFlow.
➢ Dynamic computational graph: PyTorch uses a dynamic computational graph to
represent machine learning models as a series of mathematical operations. This allows
for more flexible and efficient computation compared to static computational graphs
used in other libraries like TensorFlow.
➢ Automatic differentiation: PyTorch provides an automatic differentiation feature, which
allows for efficient computation of gradients for backpropagation-based optimization
algorithms.
➢ GPU acceleration: PyTorch provides support for GPU acceleration, which can greatly
accelerate the training of large-scale models.

External Libraries: OpenAI Gym
❖ OpenAI Gym is an open-source toolkit for developing and comparing reinforcement learning
algorithms. It provides a wide range of environments for training and testing reinforcement
learning agents, including classic control problems, Atari games, and robotics simulations.
OpenAI Gym is designed to be easy to use, with a simple and consistent interface that allows
for rapid experimentation and prototyping.
➢ A wide range of environments: OpenAI Gym provides a wide range of environments for
training and testing reinforcement learning agents, including classic control problems,
Atari games, and robotics simulations.
➢ Customizable environments: OpenAI Gym allows users to create their own custom
environments, which can be used to test and train reinforcement learning agents on
specific tasks.
➢ Integration with other machine learning libraries: OpenAI Gym integrates with other
popular machine learning libraries, such as TensorFlow and PyTorch, which allows for
seamless integration with other machine learning workflows.

Activity I (2 hrs)
❏ In this link: https://colab.research.google.com/, familiarize yourself with
Google Colab (an open source python compiler created by Google).
❏ Write and run every example code we covered up till now in the training.
❏ Run the pre-existing more complicated code on the website and
examine those codes to better understand them (Classify IMDB movie
reviews as either positive or negative.)

_Python_ Functions _and_ Libraries_.pptx

More Related Content

Similar to _Python_ Functions _and_ Libraries_.pptx

Recently uploaded

_Python_ Functions _and_ Libraries_.pptx