Getting Started with Claude Code: A Simple Tutorial

Okay, here’s a comprehensive article, approximately 5000 words in length, covering “Getting Started with Claude Code: A Simple Tutorial”:

Getting Started with Claude Code: A Simple Tutorial

This tutorial provides a comprehensive introduction to Anthropic’s Claude, focusing specifically on using it for coding tasks. We’ll cover everything from basic setup to more advanced coding examples, exploring how Claude can assist you in various programming scenarios. We’ll assume minimal prior experience with large language models (LLMs) but some basic programming familiarity will be helpful.

Table of Contents

Introduction to Claude and its Coding Capabilities
- What is Claude?
- Why Use Claude for Coding?
- Understanding Claude’s Strengths and Limitations
- Comparing Claude to Other Coding Assistants (e.g., GitHub Copilot, ChatGPT)
Accessing Claude
- Anthropic’s Website and API Access
- Using the Claude API (Python Example)
- Setting Up Your API Key and Environment
- Third-Party Platforms (e.g., Poe, Slack integration)
Basic Prompt Engineering for Coding
- The Importance of Clear Instructions
- Specifying Programming Languages
- Providing Context and Examples
- Using Keywords Effectively (e.g., “function,” “class,” “algorithm”)
- Iterative Prompting: Refining Your Requests
Common Coding Tasks with Claude
- Code Generation:
  - Generating Functions and Methods
  - Creating Classes and Data Structures
  - Writing Complete Scripts (e.g., data processing, web scraping)
  - Generating Code Snippets for Specific Tasks
  - Creating Boilerplate Code
- Code Explanation:
  - Understanding Existing Code
  - Explaining Complex Algorithms
  - Getting Line-by-Line Explanations
  - Identifying Potential Issues in Code
- Code Completion:
  - Predicting the Next Line of Code
  - Suggesting Variable Names and Function Calls
  - Completing Code Blocks (e.g., loops, conditional statements)
- Code Debugging:
  - Identifying Syntax Errors
  - Finding Logical Errors
  - Suggesting Fixes for Bugs
  - Explaining Error Messages
- Code Refactoring:
  - Improving Code Readability
  - Optimizing Code Performance
  - Suggesting Better Variable Names and Function Names
  - Simplifying Complex Code Structures
- Code Translation:
  - Converting Code from One Language to Another (e.g., Python to JavaScript)
  - Understanding the Nuances of Language Conversion
- Documentation Generation:
  - Creating Docstrings for Functions and Classes
  - Generating README Files
  - Writing Comments within Code
- Unit Test Generation:
  - Creating Unit Tests for Functions and Methods
  - Ensuring Code Coverage
  - Understanding Different Testing Frameworks
Advanced Coding Techniques with Claude
- Handling Multiple Files and Dependencies:
  - Instructing Claude on Project Structure
  - Providing Context from Different Files
  - Managing Imports and External Libraries
- Working with Specific Libraries and Frameworks:
  - Specifying the Library/Framework in Your Prompt
  - Providing Documentation Links (if necessary)
  - Asking for Examples Using Specific Library Functions
- Implementing Design Patterns:
  - Describing the Desired Design Pattern
  - Asking Claude to Generate Code Based on the Pattern
  - Understanding the Trade-offs of Different Patterns
- Generating Code for Different Paradigms:
  - Object-Oriented Programming (OOP)
  - Functional Programming
  - Procedural Programming
- Few-Shot Learning:
  - Give 2 or 3 working examples for Claude to follow.
Best Practices and Tips
- Reviewing and Testing Claude’s Output
- Understanding the Limitations of AI-Generated Code
- Combining Claude with Other Development Tools
- Staying Updated with Claude’s Capabilities
- Providing Feedback to Anthropic
Example Projects
- Project 1: A Simple Web Scraper (Python)
  - Prompt Design
  - Code Generation and Explanation
  - Debugging and Refinement
- Project 2: A Basic Data Analysis Script (Python with Pandas)
  - Prompt Design
  - Code Generation and Explanation
  - Handling Data Cleaning
- Project 3: A Simple To-Do List Application (JavaScript)
  - Prompt Design
  - Code Generation (HTML, CSS, JavaScript)
  - Adding Functionality Iteratively
Conclusion: The Future of Coding with AI
- Summary of what we learned
- Wrap up

1. Introduction to Claude and its Coding Capabilities

What is Claude?

Claude is a large language model (LLM) developed by Anthropic, a company focused on AI safety and research. LLMs are AI systems trained on massive amounts of text data, enabling them to understand and generate human-like text. Claude is designed to be helpful, harmless, and honest. It excels at tasks involving natural language processing, including text generation, summarization, translation, and, importantly for this tutorial, code generation and analysis. Claude is constantly being improved, with newer versions offering enhanced capabilities.
Why Use Claude for Coding?

Claude can significantly enhance your coding workflow in several ways:
- Increased Productivity: Automate repetitive coding tasks, generate boilerplate code, and quickly find solutions to common problems.
- Faster Learning: Explore new programming languages and libraries by asking Claude to explain concepts and provide code examples.
- Improved Code Quality: Get suggestions for code refactoring, identify potential bugs, and generate unit tests.
- Reduced Development Time: Focus on the core logic of your projects while Claude handles the more tedious aspects of coding.
- Enhanced Creativity: Use Claude to explore different approaches to problem-solving and generate innovative code solutions.
Understanding Claude’s Strengths and Limitations

Strengths:
- Strong Natural Language Understanding: Claude excels at understanding complex instructions and generating coherent, well-structured code.
- Broad Knowledge Base: Trained on a vast dataset, Claude has knowledge of numerous programming languages, libraries, and frameworks.
- Excellent Code Explanation: Claude can provide clear and concise explanations of code snippets, algorithms, and programming concepts.
- Contextual Awareness: Claude can maintain context over multiple turns of a conversation, allowing for iterative code development.
- Focus on Safety: Anthropic prioritizes safety, making Claude less likely to generate harmful or misleading code (though vigilance is always required).
Limitations:
- Not a Replacement for Human Programmers: Claude is a tool to assist, not replace, developers. It requires human oversight and review.
- Potential for Errors: Like all LLMs, Claude can sometimes generate incorrect or nonsensical code. Always test and verify its output.
- Limited “Real-World” Understanding: Claude doesn’t have a physical presence or the ability to interact with the real world directly. This can limit its ability to handle tasks requiring real-world knowledge or physical interaction.
- Dependency on Training Data: Claude’s knowledge is based on the data it was trained on. It may not be up-to-date with the very latest libraries or frameworks.
- Can Be Verbose: Sometimes Claude generates more code than necessary, requiring you to trim it down.
- Struggles with Novel Problems: Claude performs best on problems similar to those it has seen during training. Completely novel or highly specialized tasks can be challenging.
Comparing Claude to Other Coding Assistants (e.g., GitHub Copilot, ChatGPT)
- GitHub Copilot: Primarily an in-editor code completion tool. It excels at suggesting code snippets and completing lines of code based on the current context. It’s deeply integrated with IDEs like VS Code. Copilot is often more focused on speed and immediate suggestions.
- ChatGPT: A general-purpose LLM from OpenAI. It can be used for coding, but it’s not specifically designed for it. It might require more detailed prompting than Claude for coding tasks. ChatGPT is strong in conversational abilities.
- Claude: Strikes a balance between Copilot’s code completion and ChatGPT’s conversational abilities. It’s strong in both code generation and explanation, making it suitable for a wider range of coding tasks. Claude’s focus on safety and helpfulness can be a significant advantage.
In general, Claude is a strong all-around choice for coding assistance, particularly when you need both code generation and explanation. Copilot is best for rapid in-editor code completion, while ChatGPT is a more general-purpose tool.

2. Accessing Claude

Anthropic’s Website and API Access

The primary way to access Claude is through Anthropic’s API. This allows you to integrate Claude into your own applications and workflows. Anthropic also provides a web interface for testing and experimentation, though it may have usage limits.
Using the Claude API (Python Example)

Here’s a basic example of how to use the Claude API with Python. You’ll need to install the anthropic Python package:

bash pip install anthropic

Then, you can use the following code (replace YOUR_API_KEY with your actual API key):

“`python
import anthropic

client = anthropic.Anthropic(api_key=”YOUR_API_KEY”)

MODEL_NAME = “claude-3-opus-20240229” # Or another suitable model, like claude-3-sonnet-20240229

response = client.messages.create(
model=MODEL_NAME,
max_tokens=1024,
messages=[
{
“role”: “user”,
“content”: “Write a Python function that calculates the factorial of a number.”,
}
]
)

print(response.content[0].text)
“`

This code does the following:
1. Imports the anthropic library: Makes the necessary functions available.
2. Creates an Anthropic client: Initializes the client with your API key.
3. Sets the MODEL_NAME: This specifies which version of Claude you want to use. claude-3-opus-20240229 is a powerful option, but check Anthropic’s documentation for the latest models and their capabilities. claude-3-sonnet-20240229 is another, faster, cheaper option.
4. Sends a request to the API: The client.messages.create method sends your prompt to Claude.
  - model: The model name you selected.
  - max_tokens: The maximum number of tokens (words or parts of words) to generate in the response.
  - messages: A list of messages in the conversation. Each message has a role (“user” or “assistant”) and content (the text of the message).
5. Prints the response: The generated code is extracted from the response and printed.
Setting Up Your API Key and Environment
1. Obtain an API Key: You’ll need to sign up for an API key on the Anthropic website (console.anthropic.com). This usually involves creating an account and potentially joining a waitlist.
2. Set an Environment Variable: It’s best practice to store your API key as an environment variable rather than hardcoding it directly into your scripts. This improves security. Here’s how to do it:
  - Linux/macOS:
    bash export ANTHROPIC_API_KEY=your_api_key_here
  - Windows (Command Prompt):
    set ANTHROPIC_API_KEY=your_api_key_here
  - Windows (PowerShell):
    $env:ANTHROPIC_API_KEY = "your_api_key_here"
    To make this permanent, you’d add the appropriate command to your shell’s configuration file (e.g., .bashrc, .zshrc, or your PowerShell profile).
3. Modify the Python code: If using environment variables, modify your Python code to fetch the API key from there:
  “`python
  import anthropic
  import os
  
  client = anthropic.Anthropic(api_key=os.environ[“ANTHROPIC_API_KEY”])
  
  … rest of your code …
  
  “`
Third-Party Platforms (e.g., Poe, Slack integration)

Several platforms offer access to Claude without requiring direct API interaction:
- Poe (poe.com): A platform created by Quora that allows you to interact with various LLMs, including Claude. It provides a user-friendly interface and often offers free tiers or subscriptions.
- Slack Integration: Anthropic provides a Slack app that allows you to interact with Claude directly within your Slack workspace. This is convenient for team collaboration and quick questions. Search for “Claude” in the Slack App Directory.
- Other Integrations: Various other tools and platforms are integrating Claude, so it’s worth exploring options that fit your workflow.
These platforms can be a good starting point for experimenting with Claude before diving into API usage. However, for full control and customization, using the API directly is recommended.

3. Basic Prompt Engineering for Coding

The Importance of Clear Instructions

The quality of Claude’s output is directly related to the clarity of your input. Ambiguous or poorly worded prompts will likely lead to unsatisfactory results. Think of Claude as a highly skilled but very literal programmer – you need to provide precise instructions.
Specifying Programming Languages

Always explicitly state the programming language you want Claude to use. For example:
- Bad: “Write a function to sort a list.”
- Good: “Write a Python function to sort a list using the merge sort algorithm.”
- Good: “Write a Javascript function to sort a list.”
Providing Context and Examples

The more context you provide, the better Claude can understand your needs. This includes:
- Input Data: Describe the type and format of the input data your code will process.
- Desired Output: Clearly state the expected output or behavior of your code.
- Specific Requirements: Mention any specific constraints, libraries, or algorithms you want to use.
- Examples: Including input/output examples can be extremely helpful. This is often called “few-shot learning.”
Example:

`` "Write a Python function calledparse_data` that takes a string as input. The string will be in the format ‘key1:value1,key2:value2,…’. The function should parse this string and return a dictionary where the keys are the key strings and the values are the corresponding value strings.

Example input: ‘name:John Doe,age:30,city:New York’
Expected output: {‘name’: ‘John Doe’, ‘age’: ’30’, ‘city’: ‘New York’}
”
“`
Using Keywords Effectively (e.g., “function,” “class,” “algorithm”)

Use programming-specific keywords to guide Claude:
- function: Indicates you want a function definition.
- class: Indicates you want a class definition.
- algorithm: Suggests you’re looking for a specific algorithm implementation.
- loop: Indicates you need a loop (e.g., for loop, while loop).
- conditional: Indicates you need a conditional statement (e.g., if, else).
- recursive: Indicates you want a recursive function.
Iterative Prompting: Refining Your Requests

Don’t expect to get perfect code on the first try. Iterative prompting is key:
1. Start with a clear prompt.
2. Review Claude’s output.
3. If necessary, refine your prompt:
  - Correct any misunderstandings.
  - Provide additional context.
  - Specify constraints more clearly.
  - Ask for specific changes or improvements.
4. Repeat steps 2 and 3 until you’re satisfied with the result.
Example:
- Prompt 1: “Write a Python function to find the largest number in a list.”
- Claude’s Output: (Provides a basic function)
- Prompt 2: “Modify the function to also return the index of the largest number.”
- Claude’s Output: (Provides the updated function)
- Prompt 3: “Can you refactor this function to use a single loop?”
- Claude’s output: (Refactors code)
This iterative process allows you to guide Claude towards the exact solution you need.

4. Common Coding Tasks with Claude

This section provides practical examples of how to use Claude for various coding tasks. We’ll cover code generation, explanation, completion, debugging, refactoring, translation, documentation, and unit testing.

Code Generation:
- Generating Functions and Methods:
  
  User: Write a Python function called `calculate_area` that takes the length and width of a rectangle as arguments and returns its area.
  
  Claude:python
  def calculate_area(length, width):
  “””Calculates the area of a rectangle.
  
  Args:
  length: The length of the rectangle.
  width: The width of the rectangle.
  
  Returns:
  The area of the rectangle.
  “””
  return length * width
- Creating Classes and Data Structures:
  
  User: Create a Python class called `Dog` with attributes for name, breed, and age. Include a method called `bark` that prints "Woof!".
  
  Claude:python
  class Dog:
  “””Represents a dog.”””
```
def __init__(self, name, breed, age):
    """Initializes a Dog object.

    Args:
        name: The dog's name.
        breed: The dog's breed.
        age: The dog's age.
    """
    self.name = name
    self.breed = breed
    self.age = age

def bark(self):
    """Makes the dog bark."""
    print("Woof!")
```
- Writing Complete Scripts (e.g., data processing, web scraping):
  
  User: Write a Python script that reads data from a CSV file called 'data.csv', calculates the average of the values in the 'price' column, and prints the result.
  Claude:python
  import csv
  
  def calculate_average_price(filename):
  “””Calculates the average price from a CSV file.
```
Args:
    filename: The name of the CSV file.

Returns:
    The average price, or None if an error occurs.
"""
try:
    with open(filename, 'r') as file:
        reader = csv.DictReader(file)
        total_price = 0
        count = 0
        for row in reader:
            try:
                total_price += float(row['price'])
                count += 1
            except (ValueError, KeyError):
                print(f"Skipping row due to invalid data: {row}")
                continue # Skip to the next row

        if count > 0:
          return total_price / count
        else:
          print("No valid price data found.")
          return None
except FileNotFoundError:
    print(f"Error: File '{filename}' not found.")
    return None
except Exception as e:
    print("Error during processing: {e}")
    return None
```
  if name == ‘main‘:
  average_price = calculate_average_price(‘data.csv’)
  if average_price:
  print(f”The average price is: {average_price}”)
  
  * Generating Code Snippets for Specific Tasks:
  User: Give me a Python code snippet to reverse a string.
  
  Claude:python
  def reverse_string(s):
  “””Reverses a string.
  
  Args:
  s: The string to reverse.
  
  Returns:
  The reversed string.
  “””
  return s[::-1]
  
  Example usage
  
  my_string = “hello”
  reversed_string = reverse_string(my_string)
  print(reversed_string) # Output: olleh
  
  * Creating Boilerplate Code:
  
  User: Create boilerplate code for a Flask web application in Python.
  Claude:python
  from flask import Flask
  
  app = Flask(name)
  
  @app.route(“/”)
  def hello_world():
  return “Hello, World!”
  
  if name == “main“:
  app.run(debug=True)
  
  * Code Explanation:
- Understanding Existing Code:
  
  “`
  User: Explain this Python code:
  
  python def mystery_function(n): if n <= 1: return n else: return mystery_function(n-1) + mystery_function(n-2)
  “`
  
  `` Claude: This Python code defines a recursive function calledmystery_function`. Let’s break it down:
  1. def mystery_function(n):: This line defines a function named mystery_function that takes a single argument, n, which is expected to be an integer.
  2. if n <= 1:: This is the base case for the recursion. If n is less than or equal to 1, the function simply returns n.
  3. return n: If the base case is met, the function returns the value of n.
  4. else:: If n is greater than 1, the code execution goes to the else block.
  5. return mystery_function(n-1) + mystery_function(n-2): This is the recursive step. The function calls itself twice:
    - mystery_function(n-1): Calls the function with n decreased by 1.
    - mystery_function(n-2): Calls the function with n decreased by 2.
      The results of these two recursive calls are added together, and the sum is returned.
  This function calculates the nth Fibonacci number. The Fibonacci sequence starts with 0 and 1, and each subsequent number is the sum of the two preceding numbers (e.g., 0, 1, 1, 2, 3, 5, 8, …).
  “`
- Explaining Complex Algorithms:
  User: Explain the quicksort algorithm.
  “`
  Claude:
  Quicksort is a highly efficient, comparison-based sorting algorithm. It follows a divide-and-conquer strategy. Here’s a breakdown:
  1. Choose a Pivot: Select an element from the array to serve as the “pivot.” There are various strategies for choosing the pivot (e.g., first element, last element, random element, median-of-three). The choice of pivot can affect performance.
  2. Partitioning: Rearrange the array so that:
    - All elements less than the pivot come before the pivot.
    - All elements greater than the pivot come after the pivot.
    - The pivot is in its final sorted position.
    After partitioning, the pivot element is in its correct, final sorted place.
  3. Recursive Calls: Recursively apply steps 1 and 2 to the sub-arrays:
    - The sub-array of elements less than the pivot.
    - The sub-array of elements greater than the pivot.
  4. Base Case: The recursion stops when a sub-array has zero or one element, as these are already sorted.
  Example (Illustrative):
  
  Let’s say we have the array: [5, 2, 8, 1, 9, 4, 7, 3, 6]
  1. Pivot (e.g., first element): 5
  2. Partitioning:
    - Elements less than 5: [2, 1, 4, 3]
    - Pivot: 5
    - Elements greater than 5: [8, 9, 7, 6]
      Rearranged array: [2, 1, 4, 3, 5, 8, 9, 7, 6] (5 is now in its final sorted position)
  3. Recursive Calls:
    - Quicksort [2, 1, 4, 3]
    - Quicksort [8, 9, 7, 6]
  4. This process continues recursively until all sub-arrays are sorted.
  Key Features:
  - In-place: Quicksort typically operates directly on the input array, requiring minimal extra memory (though the recursive calls use stack space).
  - Average Time Complexity: O(n log n): On average, quicksort is very efficient.
  - Worst-Case Time Complexity: O(n^2): This occurs when the pivot selection consistently results in highly unbalanced partitions (e.g., already sorted array with the first element as the pivot). Good pivot selection strategies mitigate this.
  - Not Stable: The relative order of equal elements is not necessarily preserved.
    “`
- Getting Line-by-Line Explanations:
  User: Explain this Python code line by line:python
  def process_data(data):
  result = []
  for item in data:
  if item > 10:
  result.append(item * 2)
  return result
  “`
  
  Claude:python
  def process_data(data):
  `` * **Line 1:** Defines a function namedprocess_datathat takes one argument,data.data` is expected to be an iterable (like a list).
  
  python result = []
  * Line 2: Initializes an empty list called result. This list will store the processed data.
  
  python for item in data:
  * Line 3: Starts a for loop that iterates through each item in the input data.
  
  python if item > 10:
  * Line 4: Inside the loop, this line checks if the current item is greater than 10.
  
  python result.append(item * 2)
  * Line 5: If the condition in line 4 is true (i.e., item is greater than 10), this line appends the value of item multiplied by 2 to the result list.
  
  python return result
  * Line 6: After the loop has finished processing all items in data, this line returns the result list, which now contains the processed values.
  
  In summary, this function takes a list of numbers, filters out numbers less than or equal to 10, multiplies the remaining numbers by 2, and returns a new list containing the results.
  “`
- Identifying Potential Issues in Code:
  
  “`
  User: Is there anything wrong with this code?
  
  python def divide(x, y): return x / y
  “`
  
  `` Claude: Yes, there's a potential issue with this code: it doesn't handle division by zero. Ifyis 0, the code will raise aZeroDivisionError`.
  
  Here’s how you can improve it:
  
  python def divide(x, y): if y == 0: return "Cannot divide by zero" # Or raise an exception, or return None, etc. else: return x / y
  
  This improved version checks for division by zero and returns an appropriate message (or you could choose to raise a custom exception or return None, depending on how you want to handle the error). It’s crucial to handle potential errors like this to make your code more robust.
  “`
Code Completion:
- Predicting the Next Line of Code:
  
  (You would typically use Claude’s API in a suitable development environment for real-time code completion. Here’s a conceptual example.)
  
  “`
  User: I’m writing a Python function to calculate the sum of a list. I’ve written this so far:
  
  python def calculate_sum(numbers): total = 0 for number in numbers:
  
  What should the next line be?
  
  Claude:
  python total += number
  “`
- Suggesting Variable Names and Function Calls:
  (Conceptual example)
  User: I am writing code to create a file.
  Claude:python
  my_file = open(“new_file.txt”, “w”)
- Completing Code Blocks (e.g., loops, conditional statements):
  (Conceptual example)
  User: Complete this python code:python
  if x> 5:
  
  Claude:
  python if x > 5: print("x is greater than 5")
  “`
Code Debugging:
- Identifying Syntax Errors:
  
  “`
  User: Why does this code give me a syntax error?
  
  python def my_function(x, y) return x + y
  “`
  
  `` Claude: You're missing a colon (:`) at the end of the function definition line. Here’s the corrected code:
  
  python def my_function(x, y): # Added the colon here return x + y
  
  In Python, function definitions, loops, conditional statements, and class definitions all require a colon at the end of the introductory line.
  “`
- Finding Logical Errors:
  
  “`
  User: This code is supposed to find the largest number in a list, but it’s not working correctly. What’s wrong?
  
  python def find_largest(numbers): largest = 0 for number in numbers: if number < largest: # Incorrect comparison largest = number return largest
  “`
  
  `` Claude: The problem is in theifstatement. You're checking ifnumberis *less than*largest, but you should be checking if it's *greater than*largest. Also, initializinglargestto 0 will cause problems if all numbers in the list are negative. You should initializelargest` with the first element of the list (or with negative infinity, if you want to handle empty lists).
  
  Here’s the corrected code:
  
  “`python
  def find_largest(numbers):
  if not numbers: # Handle empty list case
  return None # Or raise an exception
```
largest = numbers[0] # Initialize largest to the first element
for number in numbers:
    if number > largest:  # Corrected comparison
        largest = number
return largest
```
  “`
  
  This version first handles the case where the input list is empty. Then it sets largest the the first value of the list. Then it correctly compares number with largest.
  “`
- Suggesting Fixes for Bugs:
  (See the logical error example above – Claude not only identifies the error but also suggests a fix).
- Explaining Error Messages:
  
  User: I got this error message: "TypeError: 'int' object is not iterable". What does it mean?
  
  `` Claude: The error message "TypeError: 'int' object is not iterable" means you're trying to use an integer (int`) in a place where Python expects an iterable object. An iterable object is something you can loop over, like a list, tuple, string, or dictionary.
  
  Common Causes:
  - Using for loop with an integer:
    
    python x = 5 for i in x: # This will cause the error print(i)
    
    You can’t directly loop over an integer. If you intended to loop a certain number of times, use range(x).
  - Passing an integer to a function that expects an iterable:
    
    “`python
    def my_function(data):
    for item in data:
    print(item)
    
    my_function(10) # This will cause the error
    “`
    
    You need to pass a list, tuple, or another iterable to my_function.
  - Unpacking an integer
    python x = 5 a,b = x # This will cause an error
    To fix this error, you need to identify where you’re using an integer as if it were an iterable and change it to an appropriate iterable object (or change the logic of your code).
    “`
  - Code Refactoring:
- Improving Code Readability:
  
  “`
  User: Can you make this code more readable?
  
  python def f(a,b): if a>b: return a else: return b
  “`
  
  “`
  Claude:
  Yes, here’s a more readable version of that code, along with explanations:
  
  “`python
  def find_larger_number(first_number, second_number):
  “””Returns the larger of two numbers.
```
Args:
    first_number: The first number.
    second_number: The second number.

Returns:
    The larger of the two input numbers.
"""
if first_number > second_number:
    return first_number
else:
    return second_number
```
  Alternatively, using the built-in max function:
  
  def find_larger_number_v2(first_number, second_number):
  “””Returns the larger of two numbers

… rest of your code …

Example usage

Alternatively, using the built-in max function:

Leave a Comment Cancel Reply