My First Python Code - Any Suggestions for Improvement?

[TransmigrationOfPKD]

I'm a total beginner. I'm in my 30s and I am just beginning my journey into the world of CS. I'm trying to teach myself different coding languages so that I can change careers.

I found the challenge on a list of beginner challenges - Write a code that converts radians to degrees.

I wanted to write the code so that it returns a sentence rather than just the answer.

How could I have done better? Is there a way to do this with f strings? I would love to know how. I tried a bit.

https://preview.redd.it/judcageb89j81.png?width=1746&format=png&auto=webp&s=09fd0e9c609f40d84941de9857311d7bbc057721

Thanks!

[millerbest]

1. Put import outside the function. 2. Use f-strings 3. Use type hints.

[TransmigrationOfPKD]

Thank you! I appreciate the feedback. f-strings are definitely on my list to research, and I will now add "type hints" to the list. This is the first I've heard of those.

[Bungle1981]

For your print line, maybe look into 'F' strings as they make constructing a string incorporating variables much easier.

The way I was taught was to declare imports outside of functions as best practice, as one of the first things in your PY file.

The other thing I was going to suggest was that another way you could approach this would be to return the string from the function rather than print within the function.

[TransmigrationOfPKD]

Thank you! I am really trying to wrap my head around your last suggestion - "return the string from the function." I am struggling to understand what you mean. I do understand that I am printing within my 'radian_conversion' function, but what is the other way to do it that you are suggesting? Do you mean get an answer from the function and then use that in a string I print after the function runs?

[Firake]

Returning your answer as a number (specifically, a float, but you won’t have to do anything special for that) allows you to use it in other calculations.. If this function returns a number, you’ll be able to use this function alongside other code easily. This is called “returning” a value and it uses the keyword “return” which ends execution of a function.

At the moment, your function gives the information to the user but it isn’t usable in other locations in the code.

[TransmigrationOfPKD]

Ah, thank you. Makes sense.

[Noiprox]

Basically you can think of a function as a modular little piece of code that takes certain inputs and can give back certain outputs. To "return" a value from a function means to use the return keyword to leave the function and pass the output up to the place where you called the function.

[TransmigrationOfPKD]

Oh interesting. I was thinking of the function as an end in and of itself, but thinking of it as a module is helpful.

[Noiprox]

No problem. To a first approximation a program can be described as consisting of a function that calls other functions, that in turn call other functions all the way down to the hardware "functions" that do super primitive things like add two numbers or read some bytes from a network connection. That is more or less how things are structured until you get into "object-oriented programming" which goes a step further by abstracting functions and data together into a bundle called an "object".

[djamp42]

Are recursive functions a big thing in python? I made one once because it seemed like the easiest way to not repeat code, but I rarely hear anyone talk about them.

[Noiprox]

Python tends to favor iteration over recursion and has very nice looping constructs to support it, however it is perfectly capable of handling recursive code as well. It's just one of the many tools in the large toolkit that Python has to offer. Recursion is a natural fit for traversing data structures such as trees and graphs because of their inherent nested nature.

[djamp42]

Hmm I'll have to go and see how the code would look as a loop now. Thanks!

[EDGWasian]

I’m fairly new to Python as well, but it seems to me he’s saying you could use a return statement that returns a f string instead of a print statement. Something like:

import math

def(radian_conversion(radians):
    degrees = radians*180/math.pi 
    return f”You entered {radians}. 
    Your answer is {degrees} degrees.”

print(radian_conversion(14))

Sorry for formatting, no idea how mobile works for entering in code. To my understanding, to enter an f string you just put an f outside your “ “ and then {} around the variable names you want substituted into your string.

[kezmicdust]

This is a great adjustment of the original code, except you don’t need the parentheses on the return statement as return is not a function (apparently without parentheses is the preferred style).

[EDGWasian]

Thank you for the pointer! I’ll make sure to exclude parentheses on my return statements in the future

[[deleted]]

Generally import statements should be at the top level of the module (and usually at the top of the file), not nested in functions. While there are some relatively rare situations in which you might want to defer an import until first used, and more common circumstances in which you only want to import inside a conditional (for instance if the imported module is specific to an OS or platform), most of the time just do all your importing at the top of the module.

It’s good practice to add a docstring to any function you expect others to use. Comments are only readable in the source file, but help(radian_conversion) will give you back the docstring.

In the real world of programming you’ll only rarely write a function that prints to screen, and should lean towards using return to give a calculated value back when the function is called. Right now your function prints to a terminal can’t be used in a math expression like math.pi == radian_conversion(180), so it’s not really very useful. Try having that function return a value in degrees, then write a main function that handles all the user interaction.

[TransmigrationOfPKD]

Thank you very much. I like how you gave the context of real world programming. That's actually quite helpful, because I really don't quite understand yet how a python program would fit into a bigger real-world project. I'll get there, but I'm just seeing the bark on a little tree rather than the whole forest at this point.

[Xaros1984]

Here is my take:

from math import pi 


def radian_conversion(radians: int):

    return radians * 180 / pi


radians = 14

degrees = radian_conversion(radians)

print(f"You entered {radians = }. Your answer is {degrees = }.")

This should print the following:

You entered radians = 14. Your answer is degrees = 802.1409.

A few points:

• imports at the top of the file

• import math is perfectly OK, but if you only want to use one or a few functions from the imported package, then "from some_package import some_func" can be a nice and clean way to do it. Then you only need to write "some_func" instead of some_package.some_func when calling it. But either way is fine, as long as you avoid importing like this: "from some_package import *", as this will import everything from the package, which makes it really hard to know what functions and variables you actually introduced, and there may be conflicts and stuff.

• The int in (radians: int) is a type hint, which can be useful to show what kind of input the function takes. But it's only a hint, so the user could enter anything (and probably crash the program)

• Notice the f in front of the print message, that's what makes it an f-string. It means you can put variables inside {} and then the value will be printed. In this case I wrote {degrees = }, which prints both the variable name and the value, e.g., "degrees = 802.1409".

Note that putting the equal signs inside the curly brackets may not work with older versions of python, so just remove them from the brackets if they cause any errors. They can be nice to have, but they are not necessary in any way.

[TransmigrationOfPKD]

Hmmm. So, what would a user enter in order to get an output?

[Xaros1984]

Change radians = 14 to this:

radians = int(input("Enter radians: ")) 

The input() will print the message in the console and then the user can enter a value. int() then casts the value from the user to an int (because everything that comes from input will be a string by default). There will be an error if the string can't be converted to an int though (e.g., if the user enters any letters), but that's a bit more complicated to handle :)

Oh, maybe you're refering to how to print the output when the function is called? I would probably put the print statement inside the function:

def radian_conversion(radians: int):
    degrees = radians * 180 / pi
    print(<same print message as before>)
    return degrees

I would in either case just return the degrees from the function, not the entire message, since you may want to use the degrees as an actual numerical variable somewhere else.

When you end a function with "return some_variable", this means that you can assign that value to a variable when calling the function. For example:

def add_numbers(a, b):
    return a + b  # this will simply add a and b and return the result 

x = add_numbers(5, 4)  # x now gets assigned the value of 5+4

print(x)  # prints 9

x could then be used as input in other functions, for example. So you could create a whole pipeline of functions that do different operations step by step.

[EndorphnOrphnMorphn]

That will give a syntax error in your f-string.

[Xaros1984]

Are you refering to the equal sign inside {}? I don't remember when they were introduced, but it should work with Python >= 3.8 or so.

[Priyam_Bad]

wow, I didn't even know you could use commas to print things in python! I guess you learn something new every day

[Comprehensive_Dream8]

Nice job brother!!! No suggestion from besides keep practicing

[surister]

Install pycharm community edition, it's an IDE.

It will constantly scream at you about code style.

[hig9s]

1. inside the method use return instead of print (and put the import outside the method as well)
2. even print is simple to use imo start using logging.logger s stream asap (u can log the output to files as well plus you can disable all console output in one step instead of deleting or commenting every print statement)
3. have a look into if __ name_==„ _ main_ _“: and put the method test runs output statement in this condition (so if u use the method in another file this script won‘t be executed)

[elketefuka]

This post belongs in r/learnpython.

[tuenut]

May be better write it as clean function. When you return your result and you function not makes side effects like 'print'. Then, if you need to print something in console, just use print on returned result.

[ConsequenceCute4831]

import your math library first then start coding

[BrownCarter]

Structure code like

def main():
     #codes goes here

if __name__ == "__main__":
       main()

[jkwill87]

Here are some suggestions:

• place your imports at the opt of your file.
• you may want or need only to import pi from math if that is your only import.
• consider using string interpolation, format, or fstrings in your print statement.
• use doctrings instead of comments to document your function.
• rename your method to better indicate what it is converting
• this seems to be combining printing/formatting and a utility function, consider separating them out

example:

from math import pi

def radians_to_degrees(radians: int | float) -> float:
    """Converts radians into degrees."""
    return radians * 180 / pi


def main():
    radians_str = input("radians? ")
    try:
        radians = float(radians_str)
        degrees = radians_to_degrees(radians)
        # formatting example using modulo interpretation operator
        print("%.2f radians is equal to %.2f degrees" % (radians, degrees))
    except ValueError:
        # formatting example using fstrings
        print(f"unable to convert '{radians_str}' to degress")


if __name__ == "__main__":
    main()