Lecture3 functions and packages

Main ideas and lessons

Functions in Python

• A function is reusable code that solves a specific task.
• Instead of manually writing the underlying logic (e.g., loops or conditionals), you can call functions.
• Python provides many built-in functions, such as type, max, round, print, and len.

Example: max()

• Purpose: find the maximum value in a list.
• Rather than writing comparisons inside a loop, you can call:
  • max(<list>)
• The lecture describes the internals as a “black box”: you mainly need to know how to call it and what output it returns.

Example: round() and function arguments

• Purpose: round a number.
• Typical form:
  • round(number, n_digits)
    • number: the value to round
    • n_digits: how many digits after the decimal point to keep
• n_digits is optional:
  • If omitted, Python rounds to the nearest integer.
• Key concept emphasized:
  • Inputs to functions are called arguments.
  • The function returns a rounded value (and the returned type/format depends on how you use it).

How to discover whether a function exists / how to use it

• Many common tasks already have built-in functions.
• Use:
  • Python documentation via help(...)
  • or interactive help via ? in notebooks/shell
• The lecture highlights queries like:
  • help(round), help(max), or ?max
• Documentation helps you determine:
  • which parameters are required vs optional
  • common behaviors (e.g., pow requires base/exponent, with an optional modulus)

Other built-in functions and an exercise with sorted()

• Purpose: sort an iterable.
• Example for descending order:
  • sorted(iterable, reverse=True)
• Sorting can use parameters such as:
  • iterable
  • reverse
  • and optionally key (as suggested by documentation structure)

Python objects, methods, and dot notation

• In Python, everything is an object (strings, floats, lists, etc.).

• Each object has a type and comes with methods (a method is a function attached to an object type).

• Methods are called using dot notation:

  • <object>.<method>(...)
• Examples of methods mentioned:
  • For lists: index, count, append, remove, reverse (discussed conceptually)
  • For strings: upper, count, capitalize, replace (shown in examples)
• Important distinction:
  • Some methods change the object (e.g., list append modifies the list).
  • Some methods return a new value without changing the original (common with strings, e.g., upper, replace-style behavior).

Functions vs. methods

• Functions are called by name:
  • max(...), round(...)
• Methods belong to specific objects:
  • "text".upper()
  • my_list.append(x)
• The same method name can exist across types but behave differently, for example:
  • .index(...) works on both strings and lists, but the meaning depends on the object type.

Packages and modules

• Built-in functions/methods aren’t the whole story—Python uses packages.
• Packages are collections/directories of code made up of modules.
• Examples mentioned for data/ML:
  • NumPy (arrays, numeric computing)
  • Matplotlib (visualization)
  • scikit-learn (machine learning)
• Packages are not always installed by default.

Installing packages with pip

• Use pip (Python’s package manager) to install packages.
• Example flow described:
  • Run python3 -m getpip.py
  • Then install via:
    • pip3 install numpy

Importing packages (common patterns)

• Import entire package:
  • import numpy
  • then call: numpy.array(...)
• Import with alias (most common):
  • import numpy as np
  • then call: np.array(...)
• Import a specific function:
  • from numpy import array
  • then call: array(...)

Example: using the math package for circle formulas

• Python doesn’t automatically know constants like pi unless imported.
• Use:
  • import math
  • then math.pi
• Compute:
  • circumference: C = 2 * math.pi * r
  • area: A = math.pi * (r ** 2) (using ** for exponentiation)

Importing submodules

• To access nested functionality:
  • from <package>.<submodule> import <function>
• The lecture references an example using an inverse function from a linear algebra subpackage (conceptual guidance).

---

Methodologies / instructions presented (step-by-step where applicable)

1) Finding max in a list (conceptual method)

• Obtain your data list (e.g., heights).
• Call the built-in function:
  • maximum_value = max(farm)
• Use the returned output as needed.

2) Using round() (argument-based)

• To round to a specified number of decimal places:
  • rounded_value = round(number, n_digits)
• If you omit n_digits:
  • rounded_value = round(number)
  • Python rounds to the nearest integer.

3) Getting function documentation / help

• In Python/Jupyter:
  • help(<function_name>)
  • or ?<function_name> (notebook shorthand)
• Read the documentation to determine:
  • required arguments
  • optional arguments
  • how the return value behaves

4) Sorting two lists together in descending order (exercise procedure)

• Step 1: Merge lists using addition (+)
  • full = first_list + second_list
• Step 2: Sort with sorted(), using descending order
  • full_sorted = sorted(full, reverse=True)
• Step 3: Output
  • print(full_sorted)

5) Using methods via dot notation (general pattern)

• For a string method:
  • <string_object>.<method>(optional_args)
• For a list method:
  • <list_object>.<method>(optional_args)
• Examples (conceptual):
  • sister.upper()
  • farm_list.index(value)
  • farm_list.append(value)

6) Installing and importing a package (workflow described)

• Step 1: Install using pip
  • pip3 install <package_name>
• Step 2: Import in Python code
  • Option A: import <package>
  • Option B: import <package> as <alias>
  • Option C: from <package> import <item>

7) Circle math using math package (exercise procedure)

• Step 1: import math
• Step 2: Use math.pi for π
• Step 3: Compute:
  • circumference: C = 2 * math.pi * r
  • area: A = math.pi * (r ** 2)
• Step 4: Print outputs (possibly combined with strings)

---

Speakers or sources featured (as stated/shown)

• Speaker: Not explicitly named in the subtitles (only “I” / lecture instructor).
• Sources referenced:
  • Python documentation (via help() / notebook ?)
  • AI tools mentioned for finding functions: ChatGPT, Gemini, LM (examples)
  • Python packages listed: NumPy, Matplotlib, scikit-learn, Math (standard library)