Your Private Python Coding Mentor – Actual Python

Set Up Your ChatGPT Coding Mentor

To entry ChatGPT, you solely must create an account with OpenAI. While you first head to chat.openai.com, then you definitely’ll be prompted to both sign up or enroll:

In the event you’ve already performed with ChatGPT earlier than and have an lively account, then sign up and skip to the subsequent part. In any other case, proceed studying for a fast walk-through on signing up for the service.

In the event you don’t have an account with OpenAI but, then click on on Join. You’ll be redirected to a web page that means that you can enroll utilizing your Google or Microsoft account or a private e mail handle:

In the event you select to enroll utilizing your e mail handle, then you definitely’ll must enter a password subsequent. Select a robust password and full the sign-up course of.

You’ll then be redirected to the principle web page of ChatGPT, the place you’ll get to work together with the big language mannequin by a conversational interface the place you enter questions, and the chat offers solutions:

Sooner or later, you may navigate to chat.openai.com to instantly entry this web page because you’ve accomplished the sign-up course of. Once in a while, after your browser session expires, you’ll need to log in once more.

Watch out for Incorrect and Irrelevant Data

Now that you just’ve signed up for ChatGPT, you in all probability need to give it a spin! However earlier than you hit the throttle, it’s necessary to know what sorts of points you may run into. Whereas giant language fashions supply a number of new potentialities for enhancing your research, you might want to keep in mind the possibly destructive results of utilizing ChatGPT as your coding mentor:

• Overreliance: Leaning too closely on ChatGPT for solutions can hinder your individual studying. You construct mind paths by pondering, struggling, checking your understanding, and memorizing data.
• Accuracy: ChatGPT’s responses could usually be inaccurate or irrelevant. It is advisable to fact-check all of its solutions! In any other case, you may study mistaken ideas and unhealthy practices.

On this part and all through the tutorial, you’ll encounter a number of examples of incorrect and irrelevant solutions. Hopefully, these examples will enable you to take into account that even when ChatGPT’s responses appear logical at first sight, they’re not at all times appropriate. Generally the errors in a response are so refined that you just’ll spot them provided that you’re an skilled programmer.

In a basic workflow with ChatGPT, you ask a query within the chat interface, and the underlying language mannequin, GPT-3.5, will create a reply that you just’ll see pop up as a chat response. ChatGPT will even format the replies in helpful methods. For instance, go forward and ask the chat to generate some helpful Python studying materials for you:

You: Please present me a desk with a cheat sheet of Python’s syntax.

While you ask ChatGPT for a desk, then it’ll create Markdown that the chat interface is aware of to show fantastically. As for the content material of that cheat sheet, it’ll decide some of Python’s syntax, and the outcomes may be appropriate and related:

The desk that you just’ll obtain as output will almost certainly be totally different. It may very well be fairly related, but it surely doesn’t need to be. The LLM behind ChatGPT will at all times create a brand new response, predicting the almost certainly subsequent piece of data primarily based on its coaching. However the output isn’t deterministic, and it’s usually even incorrect.

On this case, you bought a listing that incorporates appropriate details about Python, however is that this actually a whole overview of Python’s syntax? ChatGPT kicked issues off with the print() and enter() features, assembled a number of necessary key phrases, and supplied some widespread and a few fairly unusual operators:

Whereas this might symbolize a helpful cheat sheet in some conditions, it’s definitely not full, and it doesn’t say a lot about many facets of Python’s syntax, akin to indentation, string literals, and feedback. The desk doesn’t even present you probably the most related objects. It’s best to at all times remember that ChatGPT-generated content material won’t be full and even completely related.

At its core, the GPT-3.5 language mannequin that powers ChatGPT solely predicts a possible subsequent piece of data given the earlier enter. It does this fairly effectively, however that doesn’t imply that its prediction will probably be appropriate or related. In the event you try the checklist that it produced, then chances are you’ll discover that it will definitely began including lesser-used augmented project operators.

Why did it add them? In the event you look by the desk from prime to backside, you’ll see that loads of the objects can logically comply with one another. For a mannequin that predicts the following token primarily based on the chance of its following the earlier token, this is smart.

Nonetheless, that doesn’t imply that it’s a wide selection. It’s uncertain that any severe Python studying useful resource would make precisely this checklist when handing a Python syntax cheat sheet to their college students. However ChatGPT does—or a minimum of it did on this one particular instance. What output did it create in your case?

As you’ve seen on this part, ChatGPT is a strong text-completion instrument that may give you loads of data rapidly. It might even enable you to with formatting the data in useful methods. Nonetheless, should you ask questions with out a lot consideration and context, then it’s doubtless that you just’ll get incorrect or irrelevant data. That’s why it’s necessary to learn to higher wield this instrument.

Enhance Your Outcomes With Immediate Engineering

You possibly can assume of a giant language mannequin like GPT-3.5 as a really environment friendly text-completion algorithm. The mannequin takes the entire textual content that you just present into consideration after which selects phrase tokens primarily based on their chance of following the prevailing textual content.

As such, the mannequin doesn’t have any understanding of the textual content you present—a minimum of not in a manner that people take into consideration understanding. Conserving that in thoughts will enable you to decipher why a few of the outcomes that you just’ll obtain will probably be helpful, others is likely to be fully off matter, and others may sound related, however will probably be fully made up.

Discovering methods to get higher outcomes from an LLM is rapidly changing into its personal self-discipline that’s referred to as immediate engineering. It focuses on tweaking the way you design the textual content prompts to get the solutions that you just’re in search of.

Whilst you gained’t focus a lot on immediate engineering methods on this tutorial, it’s an necessary matter to learn extra about should you’re hitting a wall when utilizing ChatGPT as your Python coding mentor. Figuring out some elementary prompting approaches will help you get significantly better outcomes.

The principle concepts to remember when you write your prompts are:

• Specificity: Be clear and particular along with your directions.
  • Clear duties or questions will often get higher responses.
  • Longer, extra detailed prompts usually produce higher outcomes.
  • Delimiters will help the mannequin separate conceptual sections of your immediate. For instance, you may encompass Python code with triple backticks (“`).
• Context: Give ample context on what you’re making an attempt to realize and the way.
  • Function prompting will help you give preliminary context on how the mannequin ought to reply to future prompts.
  • Few-shot prompting implies that you’re including examples of your anticipated output to your immediate, which offers context on what sort of response the mannequin ought to produce.
• Reasoning: Instruct the mannequin to construct complicated solutions incrementally as a substitute of pushing for rapid solutions.
  • Spelling out the mandatory steps for finishing the duty helps the mannequin appropriately do duties that might in any other case produce incorrect outcomes.
  • Even with out spelling out the steps your self, you may usually enhance the outcomes by including a sentence that asks the mannequin to sort out the problem step-by-step.
  • When asking the mannequin to evaluate whether or not a supplied enter is appropriate, ask the mannequin to construct its personal answer first earlier than deciding.

To place a few of these ideas into follow, you may broaden the preliminary immediate about your Python cheat sheet. Add a task immediate, write your request in additional element, use delimiters, and provides an instance.

A barely better-engineered dialog in regards to the matter of producing a Python syntax cheat sheet might seem like this:

You: You’re an skilled Python developer with years of expertise writing Python code and instructing Python to different programmers. You may have huge expertise mentoring people who find themselves studying Python. I would like you to be my mentor whereas I study Python myself. In the event you understood, reply with the phrase “Okay”.

---

ChatGPT: Okay, I perceive. I’d be comfortable to assist mentor you as you study Python!

---

You: I’d need to have a concise cheat sheet reference of Python’s syntax that I can print out on a single web page of paper.

Please generate a Markdown formatted desk with Python’s most necessary syntax. The desk ought to checklist variables, conditionals, loops, features, lessons, imports, exception dealing with, Boolean operators, math operators, comparability operators, and comprehensions.

It ought to embody the syntax components, a brief rationalization of it, and a concise instance code snippet that explains it.

For instance, right here’s how the checklist might start:

| Syntax | Instance | Description |
| --- | --- | --- |
| Feedback | `# Remark` | Notes or explanations within the code that aren't executed by the interpreter |

Please proceed this checklist and ensure to indicate an important syntax components. You possibly can combine HTML into the Markdown to enhance the presentation.

---

ChatGPT: Certain, right here’s a cheat sheet with a few of the most necessary syntax in Python:

Syntax	Instance	Description
Variables	x = 5	Assign a worth to a variable
Conditionals	if x == 5:     print("x is 5")	Execute code provided that a situation is met
Loops	for i in vary(5):     print(i)	Execute code repeatedly
Capabilities	def my_func(x, y):     return x + y	Reusable block of code that performs a particular activity
Lessons	class MyClass:     def __init__(self, x):         self.x = x     def my_method(self):         print(self.x)	Blueprint for creating objects with particular attributes and strategies
Imports	import math print(math.sqrt(4))	Use code from one other module or bundle
Exception dealing with	strive:     x = 1 / 0 besides ZeroDivisionError:     print("Can't divide by zero")	Deal with errors that may happen throughout program execution
Boolean operators	and, or, not	Operators that function on boolean values
Math operators	+, -, *, /, //, %, **	Operators that carry out mathematical operations
Comparability operators	==, !=, <, >, <=, >=	Operators that evaluate values
Comprehensions	[i**2 for i in range(5)]	Concise syntax for creating lists, dictionaries, and units

This isn’t an exhaustive checklist, but it surely covers an important syntax components in Python.

The response that you just obtain when crafting a immediate with extra detailed context is considerably extra helpful than the preliminary end result that was primarily based on a single quick query.

ChatGPT is usually a good instrument for studying Python even with out an excessive amount of immediate engineering. Nonetheless, you may enhance your outcomes considerably while you put some extra consideration into the way you write the prompts. Extra context provides you with extra correct responses.

For the remainder of the tutorial, you may try to enhance the responses by making use of the elemental immediate engineering methods that you just realized about on this part.

Debug Your Code With ChatGPT’s Assist

Operating into errors is a traditional and anticipated a part of programming. Error messages are there that will help you work out what went mistaken and provide you with tips about fixing the problem at hand.

In the event you don’t know what to do with the traceback message, then you may usually discover good ideas by an internet search. Nonetheless, it is likely to be onerous to establish what hyperlink is admittedly related to your particular error, particularly should you haven’t had loads of expertise working into that error.

ChatGPT provides a brand new choice to the desk. While you encounter an error in your program, then you may copy each your code and the traceback into the chat interface and ask your ChatGPT coding mentor what to do.

For instance, say you’re drafting a script in your Python REPL the place you need to acquire consumer enter and carry out a calculation with it. However you run into an exception, particularly a TypeError:

>>> current_age = enter("Enter your present age: ")
Enter your present age: 36
>>> print("Subsequent 12 months you may be:", current_age + 1)
Traceback (most up-to-date name final):
  File "<stdin>", line 1, in <module>
TypeError: can solely concatenate str (not "int") to str

In the event you don’t know how you can interpret this traceback message, then you may simply copy all the pieces and ship it as a message to ChatGPT. Your Python coding mentor ChatGPT provides you with an intensive reply that identifies the problem within the code and explains why it’s taking place in clear and concise language. It’ll even provide you with a hard and fast code instance that addresses the bug that you just bumped into:

You:

>>>

>>> current_age = enter("Enter your present age: ")
Enter your present age: 36
>>> print("Subsequent 12 months you may be:", current_age + 1)
Traceback (most up-to-date name final):
  File "<stdin>", line 1, in <module>
TypeError: can solely concatenate str (not "int") to str

---

ChatGPT: The error message you’re seeing is as a result of current_age is being handled as a string, however you’re making an attempt so as to add an integer worth to it. To repair this, you may convert current_age to an integer utilizing the int() perform earlier than doing the addition. Right here’s the corrected code:

current_age = enter("Enter your present age: ")
next_year_age = int(current_age) + 1
print("Subsequent 12 months you may be:", next_year_age)

This may first immediate the consumer to enter their age, after which convert the enter to an integer utilizing int(). Then it provides 1 to the integer worth, and eventually prints the end result as a part of a string utilizing print().

The response that you just acquired from ChatGPT is stable assist for the error that you just ran into. The recommendation on how you can learn Python enter as integers comes near what a coding mentor might need given to you in individual—in the event that they’re a pleasant individual, that’s!

current_age = int(enter("Enter your present age: "))
print("Subsequent 12 months you may be:", current_age + 1)

The LLM behind ChatGPT doesn’t know something about you. It doesn’t even know something in the way in which that people take into consideration data and reasoning. Nonetheless, it was capable of instantly string collectively tokens that make sense, resolve your error, and provide you with personalised assist for the problem in your code.

Now chances are you’ll say that Python already knew what was mistaken on this code snippet and informed you about it utilizing concise language in its error message. However ChatGPT can do greater than clarify traceback messages within the context of your code. It might additionally level out syntax errors—errors that come from writing invalid Python code that Python’s parser can’t perceive.

Possibly you need to use Python as your calculator, and also you try and divide a quantity by one other one:

>>> 3 : 4
  File "<enter>", line 1
    3 : 4
    ^
SyntaxError: unlawful goal for annotation

Hmm … what’s the invalid syntax right here? Are you not remembering your elementary math operations appropriately? Time to ask ChatGPT what went mistaken on this division. Go forward and paste all of the content material of the code block above into the ChatGPT interface, together with the error message. You’ll get a useful rationalization as a solution:

ChatGPT: The error message you acquired signifies that you just tried to make use of an annotation syntax in an invalid manner. In Python, the colon (:) is utilized in a number of contexts, akin to defining perform or class signatures, creating slices of a sequence, or making a dictionary.

Nonetheless, in your code, you’re utilizing a colon between two integers, which isn’t a legitimate syntax in Python. If you wish to specific a ratio or fraction between two numbers, you need to use the division operator (/) as a substitute. For instance:

ratio = 3 / 4
print(ratio) # Output: 0.75

This may divide the integer 3 by the integer 4 and return a floating-point quantity representing the quotient. You possibly can then retailer this worth in a variable or use it instantly in your code.

Once more, your ChatGPT coding mentor identifies the problem in your code, reveals you how you can repair it, and provides a concise rationalization because the cherry on prime. Utilizing ChatGPT to debug a Python SyntaxError additionally works with extra sophisticated code than the one proven above.

In the event you aren’t receiving a end result that appears related to your query, then you may add extra context to the error message that you just’re posting. On this instance, you can add a sentence that clarifies that you just’re making an attempt to do division, akin to I’m making an attempt to divide two numbers and I get this error.

>>> from collections import chainmap
Traceback (most up-to-date name final):
  File "<stdin>", line 1, in <module>
ImportError: can not import title 'chainmap' from 'collections'
⮑ (/Customers/martin/.pyenv/variations/3.11.0/lib/python3.11/collections/__init__.py)

With ideas for a SyntaxError, you noticed that ChatGPT may give you explanations and options for a difficulty the place Python is aware of that one thing went mistaken however can’t inform you a lot about what went mistaken.

However ChatGPT can transcend that, serving to you with errors in your code the place Python doesn’t even know that one thing is mistaken. ChatGPT will help you establish logical errors in your code. Code with logical errors sometimes runs with out issues however doesn’t produce the anticipated output. It may be onerous to search out and repair some of these errors.

Assume that you just’re practising for a Python coding interview. You’re trying to implement a perform that tackles the FizzBuzz problem, the place you come "fizz" for numbers divisible by three, "buzz" for these divisible by 5, and "fizz buzz" for these divisible by each three and 5. You wrote a script that runs and appears to work:

# fizzbuzz.py

def fizzbuzz(quantity):
    if quantity % 3 == 0:
        return "fizz"
    elif quantity % 5 == 0:
        return "buzz"
    elif quantity % 15 == 0:
        return "fizz buzz"
    else:
        return quantity

This will likely look fairly good, however should you’re calling fizzbuzz() with some instance inputs, then you definitely’ll discover that you just’re not constantly getting the output that you just count on:

>>> fizzbuzz(3)
"fizz"
>>> fizzbuzz(5)
"buzz"
>>> fizzbuzz(15)
"fizz"

Why doesn’t fizzbuzz(15) return the anticipated string "fizz buzz"? Go forward and paste the code instance right into a dialog with ChatGPT and see what the language mannequin comes up with:

ChatGPT: The fizzbuzz perform takes an enter quantity and returns “fizz” if the quantity is divisible by 3, “buzz” if the quantity is divisible by 5, “fizz buzz” if the quantity is divisible by 15, and the enter quantity in any other case.

Nonetheless, the present implementation has a bug. The if situation for checking whether or not the quantity is divisible by 15 ought to come earlier than the situations for checking whether or not the quantity is divisible by 3 and 5. It’s because a quantity that’s divisible by 15 can be divisible by 3 and 5, and the present implementation will return “fizz” or “buzz” as a substitute of “fizz buzz” for such numbers.

Right here’s the corrected implementation:

def fizzbuzz(quantity):
    if quantity % 15 == 0:
        return "fizz buzz"
    elif quantity % 3 == 0:
        return "fizz"
    elif quantity % 5 == 0:
        return "buzz"
    else:
        return quantity

With this correction, the perform ought to behave as anticipated.

ChatGPT was capable of spot the logical error in your code. It in all probability succeeded as a result of this can be a widespread programming project that should have many options and explanations within the language corpus that the mannequin was educated on. However FizzBuzz gained’t be the one instance the place ChatGPT’s ideas will probably be in a position that will help you a minimum of get an concept of the place you can look to establish the logical bug that’s hiding in your code.

Pair Program With ChatGPT and Write Higher Code

You’ve realized how ChatGPT will help you debug your code to construct extra sturdy packages. You need to use the instrument for one-off questions like that. However ChatGPT may work alongside you each step of the way in which to enhance the code that you just’ve written and enable you to study higher practices and elegance. You need to use it as should you had been pair programming along with your coding mentor.

On this instance, you’re creating a guess-the-number recreation. You’ve completed implementing the sport, and it really works effectively:

import random

num = random.randint(1, 100)
i = None

whereas i != num:
    i = int(enter("Guess the quantity: "))
    if i < num:
        print("Too low")
    elif i > num:
        print("Too excessive")
    else:
        print("Appropriate!")

With this working code instance, you may head over to ChatGPT and discover out whether or not your private coding mentor has some ideas on how you can enhance this code. You would actually paste the code instance adopted by the query How can I enhance this code? and also you’d in all probability get some helpful ideas.

Nonetheless, on this part, you’ll attempt to be a bit extra particular and point out to ChatGPT what varieties of enhancements you’re in search of. The variables aren’t named very descriptively within the code snippet above. However as many programmers may agree, naming issues may be onerous!

ChatGPT is predicated on a big language mannequin, so naming issues needs to be one of many duties that it’s good at! Strive asking ChatGPT to rename the objects for you:

You:

import random

num = random.randint(1, 100)
i = None

whereas i != num:
    i = int(enter("Guess the quantity: "))
    if i < num:
        print("Too low")
    elif i > num:
        print("Too excessive")
    else:
        print("Appropriate!")

How can I enhance variable naming on this code instance?

---

ChatGPT: The variable num and i are considerably clear of their function. Nonetheless, you can enhance their names to make the code extra readable and self-explanatory. Right here’s an instance:

import random

random_number = random.randint(1, 100)
user_guess = None

whereas user_guess != random_number:
    user_guess = int(enter("Guess the quantity: "))
    if user_guess < random_number:
        print("Too low")
    elif user_guess > random_number:
        print("Too excessive")
    else:
        print("Appropriate!")

On this model, the names random_number and user_guess are extra descriptive and simpler to grasp at first look. They make it clear what values the variables maintain and what they’re used for throughout the code.

Nice! ChatGPT helped you to refactor your code by renaming your variables in a extra descriptive method. As a result of your coding mentor appears to be such a great communicator, you’ll additionally ask them to enhance the consumer messages by asking a follow-up query:

You: May you additionally enhance the messages a consumer will learn when interacting with this program?

---

ChatGPT: Certain! Right here’s an up to date model of the code with extra user-friendly messages:

import random

random_number = random.randint(1, 100)
user_guess = None

whereas user_guess != random_number:
    user_guess = int(enter("Guess a quantity between 1 and 100: "))
    if user_guess < random_number:
        print("Your guess is simply too low. Strive once more!")
    elif user_guess > random_number:
        print("Your guess is simply too excessive. Strive once more!")
    else:
        print("Congratulations, you guessed the quantity appropriately!")

On this up to date model, the consumer is prompted to “Guess a quantity between 1 and 100” to make it clear what vary of values they need to be guessing. The messages for incorrect guesses have additionally been up to date to offer extra particular suggestions.

For instance, if the consumer guesses a quantity that’s too low, this system will print the message “Your guess is simply too low. Strive once more!” Equally, if the consumer guesses a quantity that’s too excessive, this system will print the message “Your guess is simply too excessive. Strive once more!”.

These messages will assist the consumer perceive why their guess was incorrect and the way they will modify their technique for the following guess.

ChatGPT added higher consumer messages to your code, which can make it extra comprehensible. Plus, your recreation could also be much more enjoyable for others to play. Now, what if you wish to reuse this code in a special Python module? A great first step will probably be to refactor the code right into a perform which you could import.

This modification brings a few benefits past making your code extra modular. Total, utilizing features could make your code extra readable, reusable, and arranged. And when you already know how you can write a Python perform, perhaps ChatGPT will help you with this step as effectively:

You: Are you able to refactor the code right into a perform?

---

ChatGPT: Definitely! Right here’s a refactored model of the code as a perform:

import random

def guess_the_number():
    random_number = random.randint(1, 100)
    user_guess = None

    whereas user_guess != random_number:
        user_guess = int(enter("Guess a quantity between 1 and 100: "))
        if user_guess < random_number:
            print("Your guess is simply too low. Strive once more!")
        elif user_guess > random_number:
            print("Your guess is simply too excessive. Strive once more!")
        else:
            print("Congratulations, you guessed the quantity appropriately!")

Now you may name guess_the_number() to begin the sport. The perform generates a random quantity between 1 and 100, prompts the consumer to guess a quantity, and offers suggestions primarily based on whether or not the guess was too low, too excessive, or appropriate.

Utilizing a perform makes it simpler to reuse this code elsewhere in your program, and even in different packages. It additionally makes the code simpler to grasp and modify, because the performance is encapsulated in a single perform with a transparent title.

In the event you use the prompt code, then now you can import your Python program and begin the sport by calling guess_the_number(). Nonetheless, the perform is kind of restricted for the time being. It is likely to be a good suggestion to make it extra versatile by not hard-coding the vary and as a substitute permitting customers so as to add it when calling the perform.

You would ask ChatGPT to make the change for you by typing a particular immediate that makes use of clear language and directions:

You: Please refactor the code in order that 1 and 100 are default arguments. Additionally use an f-string to repair the enter textual content message accordingly.

---

ChatGPT: Certain! Right here’s a refactored model of the code with default arguments and an f-string for the enter immediate:

import random

def guess_the_number(low=1, excessive=100):
    random_number = random.randint(low, excessive)
    user_guess = None

    whereas user_guess != random_number:
        user_guess = int(enter(f"Guess a quantity between {low} and {excessive}: "))
        if user_guess < random_number:
            print("Your guess is simply too low. Strive once more!")
        elif user_guess > random_number:
            print("Your guess is simply too excessive. Strive once more!")
        else:
            print("Congratulations, you guessed the quantity appropriately!")

On this up to date model, low and excessive are added as default arguments to the guess_the_number() perform. The random_number is now generated utilizing these arguments, so you may specify a special vary of numbers when calling the perform.

The enter immediate additionally makes use of an f-string to incorporate the low and excessive values within the message, making it simpler to grasp what vary of values the consumer needs to be guessing.

Now you can name guess_the_number() with out arguments to make use of the default vary of 1 to 100 or specify your individual vary, like guess_the_number(10, 50), to make use of a variety of 10 to 50.

This recreation is coming alongside properly! On this step, you requested fairly a particular query. That is the kind of query that ChatGPT usually works effectively with. However while you’re asking a standard query, you may get good outcomes even should you write an imprecise immediate.

You at the moment aren’t returning a worth from the perform, which implies that you couldn’t hold monitor of guessed numbers should you had been to construct a recreation with a number of rounds. Nonetheless, perhaps you haven’t heard about the Python return assertion, and also you simply know how you can describe the performance that you just’re in search of. So, you go forward and ask ChatGPT what to do by utilizing a basic query:

You: How can I save the randomly generated quantity?

---

ChatGPT: One solution to save the randomly generated quantity is to return it from the guess_the_number() perform. Right here’s an up to date model of the code that does this:

import random

def guess_the_number(low=1, excessive=100):
    random_number = random.randint(low, excessive)
    user_guess = None

    whereas user_guess != random_number:
        user_guess = int(enter(f"Guess a quantity between {low} and {excessive}: "))
        if user_guess < random_number:
            print("Your guess is simply too low. Strive once more!")
        elif user_guess > random_number:
            print("Your guess is simply too excessive. Strive once more!")
        else:
            print("Congratulations, you guessed the quantity appropriately!")

    return random_number

On this up to date model, random_number is returned from the guess_the_number() perform after the consumer guesses the proper quantity. Now you can name the perform like this:

random_number = guess_the_number()
print(f"The randomly generated quantity was {random_number}.")

This may retailer the randomly generated quantity within the random_number variable, and print it out after the consumer has guessed the proper quantity.

Word which you could additionally save the random_number to a file or database if you might want to use it once more later.

Nice! Now you’ll be capable to use the return worth of the perform to maintain monitor of which numbers a consumer guessed, for instance. You didn’t even point out return in your query to ChatGPT! Nonetheless, as a result of this can be a quite common solution to sort out the duty that you just described, ChatGPT went forward and constructed an answer primarily based on returning the worth.

Lastly, it’d be nice so as to add docstrings and sort hinting to your perform as effectively, so that you ask ChatGPT:

You: May you additionally add sort hinting and a docstring to the perform?

---

ChatGPT: Certain, right here’s the up to date code with sort hinting and a docstring:

import random

def guess_the_number(low: int = 1, excessive: int = 100) -> int:
    """
    Performs a guessing recreation the place the consumer should guess a random quantity between
    `low` and `excessive`. Returns the randomly generated quantity.

    Args:
        low (int): The bottom potential quantity within the vary (default 1).
        excessive (int): The best potential quantity within the vary (default 100).

    Returns:
        int: The randomly generated quantity.

    """
    random_number = random.randint(low, excessive)
    user_guess = None

    whereas user_guess != random_number:
        user_guess = int(enter(f"Guess a quantity between {low} and {excessive}: "))
        if user_guess < random_number:
            print("Your guess is simply too low. Strive once more!")
        elif user_guess > random_number:
            print("Your guess is simply too excessive. Strive once more!")
        else:
            print("Congratulations, you guessed the quantity appropriately!")

    return random_number

On this model, we added sort hints to the perform parameters and return worth. We additionally added a docstring that describes what the perform does, what arguments it takes, and what it returns.

Utilizing sort hints and docstrings could make your code extra clear and simpler to grasp, particularly should you’re working with a staff or sharing your code with others.

That appears fairly good! ChatGPT created a Google-style docstring that nearly matches the specification for multiline docstrings, and it added useful sort hints.

Utilizing ChatGPT to doc code is usually a nice assist for builders who don’t wish to write documentation. With ChatGPT, you may enhance the standard and accessibility of your codebase with out spending an excessive amount of time on duties that you just’re much less passionate about.

On this part, you didn’t make many adjustments to your code. Its performance remains to be fairly just like what it was at first. Nonetheless, by prompting your ChatGPT coding mentor for its enter, you discovered methods to enhance and refactor your code towards higher maintainability and reusability.

Immediate ChatGPT for Various Implementations

You’ve already realized which you could’t depend on the accuracy of the output you get out of your ChatGPT Python mentor and that you just at all times must double-check the outcomes. At the beginning, the output of an LLM is a superb instrument for creativity, and there’s lots you may study there.

Your ChatGPT mentor can give you a number of totally different options to an issue. This will broaden your horizons and mean you can discover new approaches to fixing duties. Suppose again to the widespread code interview query about FizzBuzz that you just debugged with ChatGPT in an earlier part:

def fizzbuzz(quantity):
    if quantity % 15 == 0:
        return "fizz buzz"
    elif quantity % 3 == 0:
        return "fizz"
    elif quantity % 5 == 0:
        return "buzz"
    else:
        return quantity

Are you able to consider another methods to resolve this problem? Possibly there are different implementations that you can think about. You would search for different folks’s code on the Web, or you can ask your ChatGPT coding mentor to indicate you another options by inputting the code and typing a query:

You:

def fizzbuzz(quantity):
    if quantity % 15 == 0:
        return "fizz buzz"
    elif quantity % 3 == 0:
        return "fizz"
    elif quantity % 5 == 0:
        return "buzz"
    else:
        return quantity

What are different implementations of this downside?

---

ChatGPT: The FizzBuzz downside is a standard coding train that requires writing a program that prints numbers from 1 to n, however replaces multiples of three with “fizz”, multiples of 5 with “buzz”, and multiples of each 3 and 5 with “fizz buzz”. Listed below are some different implementations of the FizzBuzz downside in Python:

Utilizing a for loop:

def fizzbuzz(n):
    for i in vary(1, n+1):
        if i % 15 == 0:
            print("fizz buzz")
        elif i % 3 == 0:
            print("fizz")
        elif i % 5 == 0:
            print("buzz")
        else:
            print(i)

Utilizing checklist comprehension:

def fizzbuzz(n):
    end result = [
        "fizz buzz"
        if i % 15 == 0
        else "fizz"
        if i % 3 == 0
        else "buzz"
        if i % 5 == 0
        else i
        for i in range(1, n+1)
    ]
    return end result

Utilizing a generator expression:

def fizzbuzz(n):
    return (
        "fizz buzz"
        if i % 15 == 0
        else "fizz"
        if i % 3 == 0
        else "buzz"
        if i % 5 == 0
        else i
        for i in vary(1, n+1)
    )

Utilizing a dictionary to map numbers to their corresponding strings:

def fizzbuzz(n):
    mapping = {3: "fizz", 5: "buzz", 15: "fizz buzz"}
    for i in vary(1, n+1):
        output = ""
        for key in mapping:
            if i % key == 0:
                output += mapping[key]
        if output == "":
            output = i
        print(output)

These are just some examples of how the FizzBuzz downside may be applied in Python. There are a lot of different potential options and variations on this downside.

Immediately, ChatGPT provided you 4 different implementations that declare to resolve the identical activity. You may discover that all the options work on a vary() as a substitute of on a single quantity, like your preliminary instance did.

Whereas the implementations that ChatGPT prompt don’t strictly resolve the identical activity because the code you supplied, they may give you an concept of the way you may need to change or lengthen your authentic code.

The primary suggestion makes use of a for loop to iterate over the vary that ChatGPT launched. Aside from that, there aren’t many adjustments:

def fizzbuzz(n):
    for i in vary(1, n+1):
        if i % 15 == 0:
            print("fizz buzz")
        elif i % 3 == 0:
            print("fizz")
        elif i % 5 == 0:
            print("buzz")
        else:
            print(i)

ChatGPT rewrote the code in order that it now operates on a variety of numbers as a substitute of a single quantity. That is doubtless the extra widespread solution to sort out the FizzBuzz problem. The truth is, should you ask ChatGPT what the principles of FizzBuzz are, then you definitely’ll rapidly see that looping is often part of the problem:

You: What are the principles of FizzBuzz?

---

ChatGPT: FizzBuzz is an easy programming downside that’s usually utilized in job interviews to evaluate a candidate’s means to put in writing primary code. The principles of FizzBuzz are as follows:

1. Print the numbers from 1 to 100.
2. For every quantity that could be a a number of of three, print “Fizz” as a substitute of the quantity.
3. For every quantity that could be a a number of of 5, print “Buzz” as a substitute of the quantity.
4. For every quantity that could be a a number of of each 3 and 5, print “FizzBuzz” as a substitute of the quantity.

So, in brief, this system ought to output a sequence of numbers from 1 to 100, however changing the numbers which might be multiples of three with the phrase “Fizz”, changing the multiples of 5 with the phrase “Buzz”, and changing the multiples of each 3 and 5 with the phrase “FizzBuzz”.

You possibly can at all times get extra context for the duty that you just’re dealing with by asking ChatGPT further questions.

The second and third ideas are related to one another. One solves the duty utilizing a checklist comprehension, whereas the opposite makes use of a generator expression. The code is comparable, however the checklist comprehension executes instantly, whereas the generator expression executes lazily:

# Record comprehension

def fizzbuzz(n):
    end result = [
        "fizz buzz"
        if i % 15 == 0
        else "fizz"
        if i % 3 == 0
        else "buzz"
        if i % 5 == 0
        else i
        for i in range(1, n+1)
    ]
    return end result

# Generator expression

def fizzbuzz(n):
    return (
        "fizz buzz"
        if i % 15 == 0
        else "fizz"
        if i % 3 == 0
        else "buzz"
        if i % 5 == 0
        else i
        for i in vary(1, n+1)
    )

Whereas the code appears to be like related, you may once more see some refined variations. The code for the checklist comprehension introduces an intermediate variable, end result, whereas the instance that solves the problem utilizing a generator expression returns the generator object instantly.

Word that you just’ll additionally need to run the 2 examples in another way due to their totally different analysis strategies. If you wish to strive the examples, then you may obtain the instance code:

Whereas these two one-liner options produce the anticipated outcomes, they’re fairly tough to learn and perceive. Because of this, they’ll even be harder to keep up. ChatGPT confirmed you different options, however that doesn’t imply that it is best to implement them in your codebase.

Lastly, ChatGPT additionally introduced you with a fourth code snippet the place it makes use of a dictionary to map numbers to corresponding strings:

def fizzbuzz(n):
    mapping = {3: "fizz", 5: "buzz", 15: "fizz buzz"}
    for i in vary(1, n+1):
        output = ""
        for key in mapping:
            if i % key == 0:
                output += mapping[key]
        if output == "":
            output = i
        print(output)

Right here it makes an attempt to make use of dictionary lookups to resolve which string to print. Nonetheless, this implementation is each onerous to learn and incorrect. A great way to verify whether or not ChatGPT produced code that solves your problem is to strive it out. While you run the code snippet on a variety of fifteen, then you definitely’ll discover the bug within the code:

>>> fizzbuzz(15)
1
2
fizz
4
buzz
fizz
7
8
fizz
buzz
11
fizz
13
14
fizzbuzzfizz buzz

Whereas the start of the output appears to be like promising, the code produces incorrect outcomes when it encounters a quantity that’s divisible by greater than one of many numbers.

This occurs since you’re iterating over the dictionary keys and making use of the conditional test utilizing the modulo operator on every of the keys. Subsequently, if the present variety of the loop is evenly divisible by greater than one of many numbers, then every of the related strings will make it into output.

ChatGPT isn’t at all times appropriate, but it surely additionally produced a few related ideas that present you different implementations of the FizzBuzz problem. In the event you think about your ChatGPT coding mentor extremely artistic and wildly unaware, then you may respect its ideas whereas additionally remembering to double-check them.

And naturally, it’s also possible to study lots from incorrect and buggy code by, for instance, reasoning why the fourth answer that ChatGPT prompt doesn’t resolve the problem appropriately.

Get Solutions to Your Programming Questions

One other good use case for interacting with ChatGPT as your Python coding mentor is to ask questions that you’ve about basic programming or Python ideas.

For instance, you can ask ChatGPT in regards to the distinction between lists and tuples, two Python knowledge sorts which might be typically complicated for learners who’re new to programming:

You: What’s the distinction between a listing and a tuple in Python?

---

ChatGPT: In Python, each lists and tuples are used to retailer collections of information. Nonetheless, there are some key variations between the 2:

• Mutability: The principle distinction between lists and tuples is that lists are mutable (may be modified), whereas tuples are immutable (can’t be modified). Which means that as soon as a tuple is created, you can not add, take away, or modify any of its components, whereas you are able to do all of this stuff with a listing.

• Syntax: Lists are outlined utilizing sq. brackets [], whereas tuples are outlined utilizing parentheses (). For instance:

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)

• Utilization: Lists are sometimes used when you might want to retailer a group of things that you could be need to modify or rearrange later. Tuples, then again, are used when you might want to retailer a group of things that won’t change, akin to a set of coordinates or a date and time.

• Efficiency: Tuples are usually sooner than lists for accessing components, since they’re saved in reminiscence as a contiguous block. Lists, then again, could must allocate new reminiscence and replica components over in the event that they develop past their preliminary capability.

In abstract, lists are mutable, outlined utilizing sq. brackets, and are used when you might want to retailer a group of things that you could be need to modify or rearrange later. Tuples are immutable, outlined utilizing parentheses, and are used when you might want to retailer a group of things that won’t change.

If this reply nonetheless incorporates too many new phrases for you, then you may proceed to ask ChatGPT clarifying questions. In spite of everything, your coding mentor is conversational! For instance, you can ask comply with up questions akin to:

• What’s the distinction between mutable vs immutable sorts
• Are you able to present me a real-world instance of each a tuple and a listing?
• What are good use circumstances for a tuple?

You may get fairly good solutions to those questions. Nonetheless—as at all times—you might want to take into account that ChatGPT solely strings collectively phrase tokens primarily based on chance, which implies which you could’t depend on the solutions you get. It’s best to at all times test and make sure.

A technique of including credibility to a solution is by checking the supply. Whereas ChatGPT doesn’t but present sources instantly, you may ask it to offer its sources and hyperlinks:

You: Please present some hyperlinks that specify the subject.

Browse the hyperlinks that it provides and ensure the data checks out. Search for respected websites! Identical to you shouldn’t routinely belief the probabilistic token strings that your ChatGPT coding mentor assembles, you additionally shouldn’t belief all of the writing you encounter on the Web. However you’ve in all probability been across the Internet for lengthy sufficient to know that!

Conserving with the subject of hyperlinks, one other wonderful means to make use of your ChatGPT coding mentor while you’re studying about Python is to ask it for hyperlinks to sure elements of Python’s documentation. In the event you’ve struggled with the search characteristic within the Python docs, then you may let ChatGPT handle that for you.

For instance, you may need to acquire a basic understanding of how you can use the __init__.py fileklzzwxh:0077 file –>, however while you use the search in Python’s documentation, you get loads of unrelated outcomes:

It would take you some time to weed your manner by these hyperlinks, and should you learn by the prompt outcomes, you may get extra confused than enlightened. Alternatively, you may ship a immediate to your ChatGPT coding mentor to get a direct hyperlink:

You: Please present me the hyperlink to the Python documentation that explains __init__.py.

---

ChatGPT: Definitely! Here’s a hyperlink to the Python documentation that explains the __init__.py file:

https://docs.python.org/3/tutorial/modules.html#packages

This web page offers an outline of packages in Python and how you can create them, together with the aim and utilization of the __init__.py file.

ChatGPT doesn’t carry out a basic search, however as a substitute generates textual content primarily based on probabilistic proximity. Due to that, it might be able to sort out some data retrieval conditions just like the one proven above higher than a search algorithm.

The LLM behind ChatGPT has been educated on a big corpus of information, and it’s fairly good at answering basic programming questions. To double-check the solutions that you just get, you may ask it to give you hyperlinks to sources, which can mean you can make it possible for the mannequin didn’t hallucinate.

Subsequent Steps

Now that you just’ve labored by some examples of how you need to use ChatGPT to boost your Python studying, listed here are some subsequent steps which you could take along with your ChatGPT coding mentor:

• Immediate ChatGPT for undertaking concepts and implementation suggestions—for instance, which libraries to make use of for a undertaking.
• Construct one of many prompt initiatives by pair programming with ChatGPT—and make it possible for the undertaking works!
• Refactor one in all your present initiatives to enhance code high quality.
• Let ChatGPT write checks on your undertaking code.
• Generate documentation for a undertaking utilizing ChatGPT.

In the event you battle to get helpful solutions from ChatGPT, then you may study prompting as a solution to get higher outcomes.

Generative fashions, akin to GPT-3.5, are instruments that may improve your productiveness and enable you to in your studying journey, identical to a coding mentor does. After all, typing textual content prompts for an LLM is totally different from interacting with a educated and pleasant human mentor like those you meet at Actual Python Workplace Hours.

Nonetheless, there’s one thing to be stated for ChatGPT’s huge supply knowledge that it attracts from. The LLM can be consistently obtainable, whereas a human mentor will solely have a restricted period of time.

On the flip aspect, a human mentor will doubtless be extra demanding. They’ll attempt to just be sure you’re actually studying. As a probability-based text-completion algorithm, ChatGPT can’t do this. Subsequently, your studying progress is much more strongly—and actually—tied to your enter.

Conclusion

Conversing with ChatGPT as your Python coding mentor is like becoming a member of a artistic writing class for programmers. You possibly can acquire concepts, and it will probably enable you to sort out issues from angles that you just haven’t thought of earlier than.

On this tutorial, you’ve realized how you can:

• Get ChatGPT up and working
• Use ChatGPT for code debugging
• Enhance the model and high quality of your code
• Work with ChatGPT on pair programming
• Remedy a coding activity in alternative ways
• Ask programming questions and get solutions

Whereas ChatGPT is usually a useful studying instrument, you at all times want to remain conscious of its limitations. ChatGPT doesn’t assume or assess the standard of the textual content that it produces. It simply strings collectively tokens primarily based on chance. Its solutions may be biased, irrelevant, incorrect, and even fully made up.

That stated, there are at all times helpful and fewer helpful methods to make use of any instrument. You recognize that it’s higher to make use of a hammer for driving in nails than for flipping pancakes. ChatGPT isn’t nice at flipping pancakes both, but it surely’s nonetheless a instrument that you need to use on your Python research. Have you ever discovered different use circumstances for ChatGPT in your each day Python workflow? Let everybody know within the feedback under.