Class 12 Computer Science | Python Functions | UNIT 1 | NCERT | CBSE | ONE SHOT 2024-25

Key Concepts

• Functions: Reusable blocks of code that perform specific tasks.
• Built-in Functions: Pre-defined functions in Python (e.g., print(), min(), max(), len(), range()).
• User-Defined Functions: Functions created by the user to perform specific tasks.
• def Keyword: Used to define a user-defined function.
• Parameters: Input variables defined in the function definition.
• Arguments: Actual values passed to the function when it is called.
• Default Parameters: Parameters with pre-defined values that are used if no argument is provided during the function call.
• Positional Parameters: Arguments are assigned to parameters based on their position in the function call.

Built-in Functions

• Definition: Functions that are pre-defined in Python and readily available for use.
• Examples:
  • print(): Displays output on the screen. Anything within the quotation marks is printed as is.
  • min(): Returns the minimum value from a given set of numbers.
    • Example: min(69, 96, 0, -120) returns -120.
  • max(): Returns the maximum value from a given set of numbers.
  • len(): Returns the length of a string.
    • Example: len("YouthF") returns 7.
  • range(): Generates a sequence of numbers. Requires a starting point and an ending point (exclusive).
    • Example: range(1, 11) generates numbers from 1 to 10. (Note: Requires knowledge of loops to fully understand).

User-Defined Functions

• Definition: Functions created by the user to perform specific tasks.
• Purpose: To avoid code repetition and improve code organization.
• Syntax:
  • Use the def keyword followed by the function name, parentheses (), and a colon :.
  • The function body is indented.
• Example:

  def calc_sum():
      a = 5
      b = 10
      sum = a + b
      print(sum)
  

• Calling a Function: Simply write the function name followed by parentheses.
  • Example: calc_sum() will execute the code within the calc_sum function.
• Benefits:
  • Reduces code duplication.
  • Improves code readability and maintainability.
  • Allows for modular programming.

Parameters and Arguments

• Parameters:
  • Defined in the function definition within the parentheses.
  • Represent the input values that the function expects.
  • Also known as "formal parameters."
• Arguments:
  • Passed to the function when it is called.
  • Provide the actual values for the parameters.
  • Also known as "actual parameters."
• Example:

  def cube(a):  # 'a' is a parameter
      print(a * a * a)
  
  cube(2)  # '2' is an argument
  

• Key Difference: Parameters are placeholders in the function definition, while arguments are the actual values passed during the function call.

Types of Parameters

• Default Parameters:
  • Parameters that have a default value assigned in the function definition.
  • If no argument is provided for a default parameter during the function call, the default value is used.
  • Example:

    def cube(a=1):
        print(a * a * a)
    
    cube()  # Output: 1 (uses default value of a=1)
    cube(5) # Output: 125 (uses provided value of a=5)
    

• Positional Parameters:
  • Arguments are assigned to parameters based on their position in the function call.
  • The order of arguments matters.
  • Example:

    def calculate_difference(a, b):
        print(a - b)
    
    calculate_difference(5, 10)  # Output: -5
    

  • To override positional assignment, you can explicitly specify the parameter name during the function call.

    def calculate_difference(a, b):
        print(a - b)
    
    calculate_difference(b=5, a=10)  # Output: 5
    

Synthesis/Conclusion

The video provides a foundational understanding of functions in Python, covering built-in functions, user-defined functions, parameters, and arguments. It emphasizes the importance of functions for code reusability and organization. The explanation of default and positional parameters offers practical ways to control function behavior and argument assignment. The key takeaway is that functions are essential building blocks for creating modular and efficient Python programs.