Solution to Python Mini-Project

Daniel Morales
May 13, 2020

Contents Outline

Solution to Python Mini-Project

May 13, 2020 55 seconds read

In the previous blog entry, we saw a mini python project in 20 steps, here you can find the solution to the exercise and solve your doubts about it. 


lovely_loveseat_description = """
    Lovely Loveseat. Tufted polyester blend on wood. 32 inches high x 40 inches wide x 30 inches deep. Red or white.
"""

lovely_loveseat_price = 254.00


stylish_settee_description = """
Stylish Settee. Faux leather on birch. 29.50 inches high x 54.75 inches wide x 28 inches deep. Black.
"""

stylish_sette_price = 180.50

luxuriious_lamp_description = """
    Luxurious Lamp. Glass and iron. 36 inches tall. Brown with cream shade.
"""

luxurious_lamp_price = 52.15

sales_tax = .088

customer_one_total = 0
customer_one_itemization = ""

customer_one_total += lovely_loveseat_price
customer_one_itemization += lovely_loveseat_description

customer_one_total += luxurious_lamp_price
customer_one_itemization += luxuriious_lamp_description

customer_one_tax = customer_one_total * sales_tax
customer_one_total += customer_one_tax

print("Customer One Items: " + customer_one_itemization)

print("Customer One Total: " + str(customer_one_total))


## console
Customer One Items: 
    Lovely Loveseat. Tufted polyester blend on wood. 32 inches high x 40 inches wide x 30 inches deep. Red or white.

    Luxurious Lamp. Glass and iron. 36 inches tall. Brown with cream shade.

Customer One Total: 333.09119999999996

Related Posts

How to Use Python Datetimes Correctly?

Why Decorators In Python Are Pure Genius?

3 Python Tricks That Will Improve Your Code

Categories

Data Science Machine Learning Deep learning Flask Deployment Big Data Business Python SQL Programming Libraries Jupyter Numpy News Pandas Matplotlib Visualization

Join Competition

Financial Inclusion in LatAm

Real Estate Price Forecast

Most Related Articles

Python
Programming
Why Decorators In Python Are Pure Genius?

Analyze, test, and re-use your code with little more than an @ symbolIf there’s one thing that makes Python incredibly successful, that would be its readability. Everything else hinges on that: if code is unreadable, it’s hard to maintain. It’s also not beginner-friendly then — a novice getting boggled by unreadable code won’t attempt writing its own one day.Python was already readable and beginner-friendly before decorators came around. But as the language started getting used for more and more things, Python developers felt the need for more and more features, without cluttering the landscape and making code unreadable.Decorators are a prime-time example of a perfectly implemented feature. It does take a while to wrap your head around, but it’s worth it. As you start using them, you’ll notice how they don’t overcomplicate things and make your code neat and snazzy.Before anything else: higher-order functionsIn a nutshell, decorators are a neat way to handle higher-order functions. So let’s look at those first!Functions returning functionsSay you have one function, greet() — it greets whatever object you pass it. And let’s say you have another function, simon() — it inserts “Simon” wherever appropriate. How can we combine the two? Think about it a minute before you look below.def greet(name): return f"Hello, {name}!" def simon(func): return func("Simon") simon(greet)The output is 'Hello, Simon!'. Hope that makes sense to ya!Of course we could have just called greet("Simon"). However, the whole point is that we might want to put “Simon” into many different functions. And if we don’t use “Simon” but something more complicated, we can save a whole lot of lines of code by packing it into a function like simon().Functions inside other functionsWe can also define functions inside other functions. That’s important because decorators will do that, too! Without decorators it looks like this:def respect(maybe): def congrats(): return "Congrats, bro!" def insult(): return "You're silly!" if maybe == "yes": return congrats else: return insultThe function respect() returns a function; respect("yes") returns the congrats function, respect("brother") (or some other argument instead of "brother") returns the insult function. To call the functions, enter respect("yes")() and respect("brother")(), just like a normal function.Also read: Python Books You Must Read in 2020Got it? Then you’re all set for decorators!Code is beautifully nerdy. Image by author.The ABC of Python decoratorsFunctions with an @ symbolLet’s try a combination of the two previous concepts: a function that takes another function and defines a function. Sounds mind-boggling? Consider this:def startstop(func): def wrapper(): print("Starting...") func() print("Finished!") return wrapper def roll(): print("Rolling on the floor laughing XD") roll = startstop(roll)The last line ensures that we don’t need to call startstop(roll)() anymore; roll() will suffice. Do you know what the output of that call is? Try it yourself if you’re unsure!Now, as a very good alternative, we could insert this right after defining startstop():@startstop def roll(): print("Rolling on the floor laughing XD")This does the same, but glues roll() to startstop() at the onset.Added flexibilityWhy is that useful? Doesn’t that consume exactly as many lines of code as before?In this case, yes. But once you’re dealing with slightly more complicated stuff, it gets really useful. For once, you can move all decorators (i.e. the def startstop() part above) into its own module. That is, you write them into a file called decorators.py and write something like this into your main file:from decorators import startstop @startstop def roll(): print("Rolling on the floor laughing XD")In principle, you can do that without using decorators. But this way it makes life easier because you don’t have to deal with nested functions and endless bracket-counting anymore.You can also nest decorators:from decorators import startstop, exectime @exectime @startstop def roll(): print("Rolling on the floor laughing XD")Note that we haven’t defined exectime() yet, but you’ll see it in the next section. It’s a function that can measure how long a process takes in Python.This nesting would be equivalent to a line like this:roll = exectime(startstop(roll))Bracket counting is starting! Imagine you had five or six of those functions nested inside each other. Wouldn’t the decorator notation be much easier to read than this nested mess?You can even use decorators on functions that accept arguments. Now imagine a few arguments in the line above and your chaos would be complete. Decorators make it neat and tidy.Also read: How to Get a Job With PythonFinally, you can even add arguments to your decorators — like @mydecorator(argument). Yeah, you can do all of this without decorators. But then I wish you a lot of fun understanding your decorator-free code when you re-read it in three weeks…Decorators make everything easier. Image by author.Applications: where decorators cut the creamNow that I’ve hopefully convinced you that decorators make your life three times easier, let’s look at some classic examples where decorators are basically indispensable.Measuring execution timeLet’s say we have a function called waste time() and we want to know how long it takes. Well, just use a decorator!import time def measuretime(func): def wrapper(): starttime = time.perf_counter() func() endtime = time.perf_counter() print(f"Time needed: {endtime - starttime} seconds") return wrapper @measuretime def wastetime(): sum([i**2 for i in range(1000000)]) wastetime()A dozen lines of code and we’re done! Plus, you can use measuretime() on as many functions as you want.Slowing code downSometimes you don’t want to execute code immediately but wait a while. That’s where a slow-down decorator comes in handy:import time def sleep(func): def wrapper(): time.sleep(300) return func() return wrapper @sleep def wakeup(): print("Get up! Your break is over.") wakeup()Calling wakeup() makes lets you take a 5-minute break, after which your console reminds you to get back to work.Also read: Building A Linear Regression Model With Python To Predict Retail Customer SpendingTesting and debuggingSay you have a whole lot of different functions that you call at different stages, and you’re losing the overview over what’s being called when. With a simple decorator for every function definition, you can bring more clarity. Like so:def debug(func): def wrapper(): print(f"Calling {func.__name__}") return wrapper @debug def scare(): print("Boo!") scare()There is an a lot more elaborate example here. Note, though, that to understand that example, you’ll have to check how to decorate functions with arguments. Still, it’s worth the read!Reusing codeThis kinda goes without saying. If you’ve defined a function decorator(), you can just sprinkle @decorator everywhere in your code. To be honest, I don’t think it gets any simpler than that!Handling loginsIf you have functionalities that should only be accessed if a user is logged in, that’s also fairly easy with decorators. I’ll refer you to the full example for reference, but the principle is quite simple: first you define a function like login_required(). Before any function definition that needs logging in, you pop @login_required. Simple enough, I’d say.Syntactic sugar — or why Python is so sweetIt’s not like I’m not critical of Python or not using alternative languages where it’s appropriate. But there’s a big allure to Python: it’s so easy to digest, even when you’re not a computer scientist by training and just want to make things work.If C++ is an orange, then Python is a pineapple: similarly nutritious, but three times sweeter. Decorators are just one factor in the mix.But I hope you’ve come to see why it’s such a big sweet-factor. Syntactic sugar to add some pleasure to your life! Without health risks, except for having your eyes glued on a screen.I wish you lots of sweet code!Also Read: How to Use Python Datetimes Correctly?

Python
SQL
Programming
How to Use Python Datetimes Correctly?

Datetime is basically a python object that represents a point in time, like years, days, seconds, milliseconds. This is very useful to create our programs.The datetime module provides classes to manipulate dates and times in a simple and complex way. While date and time arithmetic is supported, the application focuses on the efficient extraction of attributes for formatting and manipulating output

Python
3 Python Tricks That Will Improve Your Code

I’ve been coding in Python for more than 10 years. There was a time when I thought I knew it all, which was a clear sign I was getting complacent.Then I decided to do a bit of research about Python improvements. Those 3.6, 3.7, 3.8 Python versions aren’t there for nothing, right?After going through release notes, I found these neat tricks that I would like to share with you.By reading this article, you’ll learn:How to format big integers more clearlyA better way to work with file pathsThe proper way of string formating1. Formatting big integersUsing Underscores in Numeric Literals. Image by Roman OracFrom Python 3.6 (and onwards) you can use underscores to make numbers easier to read. See PEP 515 for more details.Let’s look at an example:a = 1000000000 # Is variable a billion or 100 millions? # Let's use underscores to make it easier to read a = 1_000_000_000 # You can group numbers as you like b = 1_0_9_0It also works with hexadecimal addresses and grouping bits.# grouping hexadecimal addresses by words addr = 0xCAFE_F00D # grouping bits into nibbles in a binary literal flags = 0b_0011_1111_0100_1110Also read: Why Decorators In Python Are Pure Genius?2. PathlibPhoto by Alice Donovan Rouse on UnsplashWorking with paths can be challenging especially if your code needs to run on multiple operating systems.Luckily for us, Python standard library has pathllib.Let’s look at an example:from pathlib import Path path = Path("some_folder") print(path) # output: some_folder # We can add more subfolders in a readable way path = path / "sub_folder" / "sub_sub_folder" print(path) # output: some_folder/sub_folder/sub_sub_folder # make path absolute print(path.resolve()) # output: /Users/r.orac/some_folder/sub_folter/sub_sub_folderDespite using / sign as the separator to concatenate paths, pathlib makes it operating system agnostic, meaning it will also work on Windows OS.Also read: Using Python And Pandas Datareader to Analyze Financial Data3. Simplify string formattingf-string formatting in Python. Image by Roman OracI’m used to using old school string formatting in Python:person = 'Roman' exercise = 0 print("%d-times %s exercised during corona epidemic" % (exercise, person)) # output # 0-times Roman exercised during corona epidemicUntil recently, I didn’t know there is a better (more modern) way of string formatting in Python.In Python 3.6, PEP 498 introduces Literal String Interpolation, which simplifies the string formatting.We can rewrite the example above to:person = 'roman' exercise = 0 print(f"{exercise}-times {person} exercised during corona epidemic") # output # 0-times Roman exercised during corona epidemicA string prefixed with f is known as fstring.fstrings even support math operations:print(f"{exercise+1}-times {person} exercised during corona epidemic") # Output # '1-times roman exercised during corona epidemic'But I didn’t exercise during the corona epidemic so adding +1 in the fstring would simply be a lie 😂What about formatting float values?f = 0.333333 print(f"this is f={f:.2f} rounded to 2 decimals") # Output this is f=0.33 rounded to 2 decimalsAlso read: How to Use Python Datetimes Correctly?ConclusionThese Python tricks will make your code more concise and will make coding more enjoyable.Many Python developers don’t know about these tricks — you’re not one of them anymore.Before you goFollow me on Twitter, where I regularly tweet about Data Science and Machine Learning.Also read: Understanding Python's Collections Module

Python
Top 10 Python Extensions for Visual Studio Code

In this new post we want to talk about the most useful Python extensions for Visual Studio Code. Visual Studio Code is an integrated development environment created by Microsoft for Windows, Linux and macOS. Among its features are debugging, syntax highlighting, smart code completion, snippets, code refactoring and integrated Git. Users can change the theme, keyboard shortcuts, preferences and install extensions that add additional functionality.Precisely we are going to talk about the extensions you can install for VS. Here is a list of our favorites1- PythonLink: https://github.com/Microsoft/vscode-pythonPython extension for Visual Studio CodeA Visual Studio Code extension with rich support for the Python language (for all actively supported versions of the language: >=3.6), including features such as IntelliSense (Pylance), linting, debugging, code navigation, code formatting, refactoring, variable explorer, test explorer, and more!NOTE: Web support -- e.g., github.dev -- is limited.Installed extensionsThe Python extension will automatically install the Pylance and Jupyter extensions to give you the best experience when working with Python files and Jupyter notebooks. However, Pylance is an optional dependency, which means that the Python extension will remain fully functional if it is not installed. You can also uninstall it at the expense of some features if you are using a different language server.2- Python IndentLink: https://github.com/kbrose/vsc-python-indentIt is used to correct Python indentation in Visual Studio Code. How it worksEvery time you press the Enter key in a Python context, this extension will parse your Python file down to the location of your cursor, and determine exactly how much to indent the next line (or two in the case of hanging indents) and how much to indent nearby lines.There are three main cases when determining the correct indent. Review the documentation here: https://github.com/kbrose/vsc-python-indent3- Python Doctring GeneratorLink: https://github.com/NilsJPWerner/autoDocstringVisual Studio Code extension to quickly generate docstrings for python functions.FeaturesQuickly generate a docstring fragment that can be tabbed.Choose from several types of docstring formats.Infer parameter types via pep484 type hints, default values and var names.Support for args, kwargs, decorators, errors and parameter types.Docstring FormatsGoogle (default)docBlockrNumpySphinxPEP0257 (coming soon)UsageThe cursor must be on the line directly below the definition to generate a complete auto-populated docstring.Press enter after opening the docstring with triple quotes ("""" or ''')Keyboard shortcut: ctrl+shift+2 or cmd+shift+2 for macCan be changed in Preferences -> Keyboard shortcuts -> extension.generateDocstringCommand: Generate DocstringRight-click menu: Generate DocstringAlso read: 4 Must-Know Python Pandas Functions for Time Series Analysis4- Python ExtendedLink: https://github.com/tushortz/vscode-Python-ExtendedPython Extended is a vscode snippet that makes it easy to write Python code by providing completion options along with all arguments.UsageRun vscode and in a python file, type the name of the method to complete and press tab or enter on selection.How to installOpen vscode. Press F1, search for "ext install" followed by the extension name, in this case "ext install Python Extended" without the ">". Or if you prefer ">ext install", press enter, search for "Python Extended".5- Python PreviewLink: https://github.com/dongli0x00/python-previewA Visual Studio Code extension with debug preview support for the Python language.RequirementsInstall a version of Python 3.6 or Python 2.7. Make sure that the location of your Python interpreter is included in your PATH environment variable.It is best to install the Python extension for Python Intellisense.6- AREPL for PythonLink: https://github.com/almenon/arepl-vscodeAREPL automatically evaluates Python code in real time as you type.UsageFirst, make sure you have python 3.7 or higher installed.Open a python file and click on the cat in the top right bar to open AREPL. You can click the cat again to close it.Or run AREPL via the search command: control-shift-por use the shortcuts: control-shift-a (current document) / control-shift-q (new document)FeaturesReal-time evaluation: no need to run - AREPL evaluates your code automatically. You can control this (or even disable it) in the settings.Variable display: The final state of your local variables is displayed in a collapsible JSON format.Error display: The moment you make a mistake an error is displayed with the stack trace.Settings: AREPL offers many settings to suit your user experience. Customize the look and feel, bounce time, python options and much more.Aldo read: 3 Python Tricks That Will Improve Your Code7- Python PathLink: https://github.com/mgesbert/vscode-python-pathThis extension adds a set of tools to help generate internal import statements in a Python project.Features"Copy Python Path" is accessible from:Command lineExplorer context menuEditor context menuEditor title context menu8- Python Test ExplorerLink: https://github.com/kondratyev-nv/vscode-python-test-adapterThis extension allows you to run your Python Unittest, Pytest or Testplan tests with the Test Explorer user interface.How to get startedInstall the extensionConfigure Visual Studio Code to discover your tests (see the Configuration section and the documentation for the test framework of your choice:Unittest documentationPytest documentationTestplan documentationOpen the sidebar of the test viewExecute your tests via the Run icon in the Test ExplorerFeaturesDisplays a Test Explorer in the test view in the VS Code sidebar with all detected tests and suites and their statusConvenient error reporting during test detectionUnittest, Pytest and Testplan debuggingDisplays the log of a failed test when the test is selected in the explorerTest rerun when saving testsSupports multi-root workspacesSupports Unittest, Pytest and Testplan test frameworks and their plugins9- Python SnippetsLink: https://github.com/ylcnfrht/vscode-python-snippet-packA snippet package to make working with Python more productive This snippet package contains all of the following Python methodsall built-in python snippets and contains at least one example for each methodall python string snippets contain at least one example for each methodall python list snippets contain at least one example for each methodall Python set snippets contain at least one example for each methodall Python tuple snippets contain at least one example for each methodall python dictionary snippets contain at least one example for each methodAnd it contains many other code snippets (such as if/else, for, while, while/else, try/catch, file process, andclass snippets and class examples for oop (polymorphism, encapsulation, inheritance, etc.).If you don't use a method don't worry this extension contains a lot of code examples for each python method.This extension is not just a code snippet, it will also be useful for learning the python programming language.You will learn all python methods with a lot of code examples.For example, if you want to use the string replacement method, you just need to use .replace.But if you don't know how to use the replace method then use string.replace =>10- JupyterLink: https://github.com/Microsoft/vscode-jupyterA Visual Studio Code extension that provides basic notebook support for language kernels that are compatible with Jupyter Notebooks today. Many language kernels will work without any modifications. To enable advanced features, modifications to the VS Code language extensions may be necessary.Notebook supportThe Jupyter Extension uses VS code's built-in notebook support. This interface offers a number of advantages to notebook users:Out-of-the-box support for VS Code's wide range of basic code editing functions, such as hot output, search and replace, and code folding.Editor extensions such as VIM, bracket coloring, linters and many more are available while editing a cell.Deep integration with the general workbench and file-based features of VS Code, such as outline view (table of contents), breadcrumbs, and other operations.Fast load times for Jupyter notebook (.ipynb) files. Any notebook file is loaded and rendered as quickly as possible, while execution-related operations are initialized behind the scenes.Includes a notebook diff tool, which makes it easy to compare and visualize differences between code cells, results and metadata.Extensibility beyond what the Jupyter extension provides. Extensions can now add their own specific language or runtime to notebooks, such as the .NET and Gather interactive notebooks.Although the Jupyter extension comes with a comprehensive set of the most commonly used renderers for output, the marketplace supports installable custom renderers to make working with your notebooks even more productive. To get started writing your own, check out the VS Code renderer api documentation.You can also read data science posts in Spanish here.ConclusionThere are many extensions that you can use with your Visual Studio Code, and deciding which one to use will involve testing, reviewing utilities, use cases and so on in order to make your work easier while coding!Also read: Why Decorators In Python Are Pure Genius?

Join our private community in Discord

Keep up to date by participating in our global community of data scientists and AI enthusiasts. We discuss the latest developments in data science competitions, new techniques for solving complex challenges, AI and machine learning models, and much more!

Join our Discord