Importing modules is a critical skill when learning Python. To keep the language lightweight and fast, only a small core is available by default in any given Python script — you as the author are expected to then import whatever else is needed.

There are three main commands when adding modules to your Python code: import, from, and as.

We’ll go over each of these, but first let’s define what it is we’re actually importing.

What Can You Import?

The terminology can get confusing, especially when learning from multiple sources, so here’s a quick list of what can be imported and what they’re called.

• Module: simply a file with a .py extension.

• Package: a directory containing an __init__.py file and normally other modules.

• Built-in Module: A module that is natively installed with Python.

• Object: Anything inside a module/package that can be referenced such as a class, function, or variable.

Don’t get too caught up in the terminology. Just know that we’ll predominately be importing built-in modules or downloaded packages. Since object is such a multipurpose term, I’ll refer to them as components.

To download and install packages, use pip. This command line tool installs publicly available Python packages. For the examples below, we’ll only use built-in modules to ensure you can follow along.

How To Import in Python

Okay, now for the good stuff.

As mentioned earlier, there are three commands that can be used when loading modules into your code. Of the three, only import is absolutely required; the other two are optional depending on circumstance.

We’ll start with the simplest command, importing an entire module.

import math
print(math.ceil(3.4)) # 4
print(math.floor(3.4)) # 3

Just the command import and the module name? Super easy. Remember, if you’re importing a module that is not native to Python core installation, then ensure it has been properly downloaded.

Now, while this command is very straightforward, it isn’t very efficient. We may only need a small portion of the module, in fact that is often the case.

To be more specific, we’ll use the from command to specify our module, then the import command to explicitly list the components we need.

from math import ceil, floor
print(ceil(3.4)) # 4
print(floor(3.4)) # 3

So now we’re more efficient in terms of what we’re importing, but you may want to simplify the reference or provide context to a component…this is where the as command comes into play.

To locally rename a component, follow up the import command with as and specify the new name. Now we can more clearly reference the component in our local namespace.

from datetime import datetime as dt
print(dt.now()) # 2020-03-29 01:43:03.170480

Conclusion

A well planned import should only bring in what is needed. Taking a few seconds to plan this out will save you time in the long run. Modifying imports for existing code most likely mean updating references and statements in the body of your program as well.

There is more to mastering Python module imports, but this will get you started and cover 90% of your import commands.

Short for comma-separated values, CSV files are a fading relic of a simpler time. Yet, they are still a necessity and admittedly can be quite convenient.

The challenge in working with CSV files is that our data is often stored in a different format internally within Python memory. Python dictionaries are one of these common structures.

It’s possible to write your own custom CSV export script; however, for simple exports this is not necessary. The csv library that is native to Python and only needs a simple import has a class called DictWriter, which will allow you to export dictionary data to CSV in five lines of code.

We’ll start with a working solution and then circle back through all the specifics of using DictWriter.

Our Sample Script

Let’s use some data generated from the site Mockaroo. We’ll use their default setup minus ip address for a total of five fields. After setting the format to JSON and the number of rows to 3, here’s the output stored to a variable named data:

data = [{
  "id": 1,
  "first_name": "Giuditta",
  "last_name": "Garland",
  "email": "ggarland0@blogspot.com",
  "gender": "Female"
}, {
  "id": 2,
  "first_name": "Ginger",
  "last_name": "Franzewitch",
  "email": "gfranzewitch1@furl.net",
  "gender": "Male"
}, {
  "id": 3,
  "first_name": "Ellwood",
  "last_name": "Shanahan",
  "email": "eshanahan2@ebay.com",
  "gender": "Male"
}]

Now, above our variable definition we’ll add an import statement.

import csv

Below the variable definition we’ll write the commands to export as CSV.

with open("data.csv", "w", newline="") as csv_file:
  cols = ["id","first_name","last_name","email","gender"] 
  writer = csv.DictWriter(csv_file, fieldnames=cols)
  writer.writeheader()
  writer.writerows(data)

That’s it. Five lines, as promised. Run the script from your command-line and you should see a file named data.csv in the same directory.

Solution Breakdown

Okay, let’s break down exactly what happened with this concise script.

Check out A Beginner’s Guide to Importing in Python for more information on importing libraries.

Since the solution is so brief, here is a line-by-line breakdown.

1. We open a file called test.csv with the w attribute for writing and set the newline character equal to an empty string — this prevents compatibility issues on various operating systems. The created file pointer is stored in the variable csv_file.

2. Next, we set the order that we want the fields exported in our CSV file. In the example, the fields remain in the same order as the dictionary, but they can be rearranged as desired.

3. We create an instance of the DictWriter class and store it in writer. The class requires both a CSV file pointer and our fields passed to the fieldnames attribute.

4. The .writeheader() method takes the list stored in fieldnames and writes it to the CSV file.

5. The .writerows() method takes our variable data and writes each item in the list as a row in the CSV file.

Frequently Asked Questions & Troubleshooting

At this point you should be ready to try out DictWriter on your own. But just in case things don’t go smoothly, here are the answers to some common pitfalls that you may encounter.

What if I miss a key in the fieldnames?

Missing a key in the fieldnames list that is passed to DictWriter can result in an exception being thrown. If we take our solution code and remove id from the list, here is what happens:

with open("data.csv", "w", newline="") as csv_file:
  cols = ["first_name","last_name","email","gender"] 
  writer = csv.DictWriter(csv_file, fieldnames=cols)
  writer.writeheader()
  writer.writerows(data)
# ValueError: dict contains fields not in fieldnames: 'id'

There are two ways to resolve this. Either add the key to fieldnames or change the behavior by setting the extrasactionvalue to ignore when creating our DictWriter object.

with open("data.csv", "w", newline="") as csv_file:
  cols = ["first_name","last_name","email","gender"] 
  writer = csv.DictWriter(csv_file,
                          fieldnames=cols,
                          extrasaction='ignore')
  writer.writeheader()
  writer.writerows(data)

What if my dictionary has nested data?

When your dictionary has a nested structure, the value is stringified to preserve a flat file structure.

If we modify our sample data to include a list of job titles and re-run the script, you can expect the following output.

# Sample Data
{
  "id": 3,
  "first_name": "Jon",
  "last_name": "Smith",
  "email": "jsmith@wisc.edu",
  "gender": "Male",
  "jobs": ["Advisor", "Pharmacist"]
}
# Output
id, first_name, last_name, email, gender, jobs
3, Jon, Smith, jsmith@wisc.edu, Male, ["Advisor", "Pharmacist"]

What if a field is not in the dictionary?

When a key is specified in the fieldnames that does not exist in the dictionary, it will be written as an empty string by default. If you wish to set a different default value, use the restval attribute when creating the DictWriter object.

writer = csv.DictWriter(csv_file,
                        fieldnames=["id","first_name", "car"],
                        restval='MISSING',
                        extrasaction='ignore')

The above code snippet asks for the fields id, first_name, and car while setting the restval equal to “MISSING”. Let’s see how our sample data would turn out.

# Sample Data
{
  "id": 3,
  "first_name": "Jon",
  "last_name": "Smith",
  "email": "jsmith@wisc.edu",
  "gender": "Male",
  "jobs": ["Advisor", "Pharmacist"]
}
# Output
id, first_name, car
3, Jon, MISSING

Thanks for reading. Please share this if you found it helpful and visit our archives for more content.

Share

Checking for a substring seems like a fairly straightforward task…

Yet, as with many things programming, there are considerations that can easily be overlooked as well as multiple ways to solve the same issue.

In JavaScript, there are two built-in functions — .indexOf() and .includes() — that accomplish the task at hand.

The .indexOf() Method

This method is the most universally available (and thus, reliable) technique to search for a substring.

Using indexOf() is going to return the index where the substring begins. As indexes begin at 0, the method will return -1 if the substring is not found.

We can make a very simple function to take this return value and interpret it as a true or false to explicitly answer the question: “Is the substring present?”

function foundSubstring(haystack,needle) {
   if(haystack.indexOf(needle) >= 0) {
      return true;
   } else {
      return false;
}
var text = "Hello World";
console.log(foundSubstring(text,"llo")) // true

The .includes() Method

This method more directly answers the question as it returns a true or false. The result is an implementation that reads more clearly.

let text = "Hello World";
console.log(text.includes("llo")); // true

The challenge with using this method is that it is not universally supported. Released in ECMAScript6, .includes() is widely available but not universally so.

If you are writing command-line Python scripts, then you will need to request input from the user at some point. In Python, the mechanism for requesting command-line values is the input() function.

Let’s go over how to use input() and make sure you’re prepared to avoid three common pitfalls.

The input() Function

Fortunately for new Python enthusiasts, the input() function is straightforward, accepting only one optional argument. The single argument is the text that will be shown on the command-line as the terminal waits for the user’s input. As the user, you can type in your value and submit by pressing ENTER.

input("Enter your name: ")

Now, the code we have above is incomplete because we aren’t storing the user’s value. We can fix that by assigning the return of input() to a variable.

name = input("What is your name: ")
print(name)

That’s really all there is to using the input() function. While the function itself is very simple, there is nuance in implementing input() in a script so that it does not become a liability.

Below are three common pitfalls that new coders fall into. Fortunately for you, we’ll avoid them by reading ahead.

1. Requesting Numeric Input

We asked the user for a text value in our earlier example, but what happens when we need a numeric value?

price = input("Enter the price: ")
total = price * 1.06

print("The total price is", total)

2. User Input Causing Value Errors

Setting a proper data type is only one step to properly implementing user input. Let’s say we want user input but the value that is actually entered causes an error. What do we do?

total = float(input("How much did you pay? "))
units = int(input("How many did you purchase? "))

print("The unit price is", total/units)

Before dismissing the sequence in the screenshot, always remember how easy it is to make a typing mistake. We strive to code in a way that is error-proof.

Use try/except statements to solve for erroneous values.

try:
  total = float(input("How much did you pay? "))
  units = int(input("How many did you purchase? "))
  print("The unit price is", total/units)
except Exception as e:
  print("Error:", e)

A try/except statement will attempt to execute all commands in the try block. If an exception is encountered, then the except block will be executed. Aside from being able to report on the exception, the biggest advantage here is that your script will not stop executing from the error.

3. Continually Requesting User Input

We’ve learned how to convert our user input as well as account for erroneous values. But when we receive a bad input, most likely you’ll want to re-prompt the user.

The input() function does not have a built-in “retry” mechanism, so we will use a while loop to continually request user input until it is valid. There are many different ways to implement a while loop for continuous user input. We’ll use an infinite while loop with a break statement as a generic solution.

total = float(input("How much did you pay? "))
while True:
  try:
    units = int(input("How many did you purchase? "))
    if(units > 0):
      break
    else:
      print("Invalid input")
  except Exception as e:
    print("Error:",e)
print("The unit price is", total/units)

In the code example above, we‘ve put all our strategies together. We convert our input to an integer, which is wrapped by a try/except which is wrapped by an infinite while loop.

It is easy to start using the input() function, but there are many potential traps since user input is always uncertain. However, with the three tips we shared, you’re prepared to venture out into the wild.

PEP — short for Python Enhancement Proposal — is a list of documents that either propose new features or conventions for the language. One of these, PEP 8, is a living document of style conventions for writing Python.

Before we get too deep, your code will still work if you don’t adhere to PEP 8 guidelines. However, since the majority of the Python community follows these rules, adopting them will improve your reading speed; plus you should find they make it easier to read your own code.

Guido van Rossum — the author of Python — proposed PEP 8 explicitly to improve the readability of code and create a consistent experience. A key insight of his was that code is read much more often than it is written. Thus, readability counts.

https://www.python.org/dev/peps/pep-0008

Below are four quick summaries of PEP 8 topics intended to give you actionable next steps in your Python code.

Naming Conventions

If you take away nothing else from this guide, the naming conventions you use will play a tremendous role in how well or poorly your code reads. It is also the single easiest improvement you can make.

• For variables, use lowercase letters and underscores to separate words.

• For functions, use lowercase letters and underscores to separate words.

• For classes, capitalize the first letter of each word — called CapWords or CamelCase.

• For constants, use all capital letters and underscores to separate words.

• Avoid using overly abbreviated names such as fn; write out first_name instead.

• Never use lowercase ‘L’, uppercase ‘O’, or uppercase ‘I’ as variable names, they are too easily confused with a 1 or 0.

Indentation

Since Python uses indentation in lieu of curly braces to denote block ownership, it is critical to have clean and consistent indentation style. Guidelines are not overly strict, often giving multiple options; however, the critical takeaway is to pick a convention and stick with it.

PEP 8 clearly puts a stop to the spaces vs tabs argument, recommending four spaces instead of a tab character.

Let’s go through some of the main conventions and their competitors.

Opening Delimiter vs Hanging Indent

For longer lists of values, either indent based on the opening delimiter or use a hanging indent. When using hanging indents, no values should exist on the first line and the indentation is one level deeper if there is an ensuing block.

# Opening Delimiter
result = my_function(first_argument, second_argument,
                    third_argument, fourth_argument)
# Hanging Indent
result = my_function(
    first_argument, second_argument,
    third_argument, fourth_argument)
def my_function(
        first_argument, second_argument,
        third_argument, fourth_argument):
    print(first_argument)

Whitespace or First Character Alignment

For multiline constructs, the closing symbol can be aligned with the used whitespace or with the first character of the statement.

# Whitespace alignment
my_list = [
    1, 2, 3,
    4, 5, 6,
    ]

# First Character Alignment
my_list = [
    1, 2, 3,
    4, 5, 6,
]

Whitespace and Line Breaks

PEP 8 has pretty strict guidelines on when to split long lines and add whitespace. Don’t stress over being perfect here, there are tools to format your code if/when you get that serious. Use the following as a starting point, but most importantly: stay consistent.

• Use two blank lines for top-level function/class definitions and one blank line for method definitions.

• Optionally use a blank line to separate logical steps in longer sequences.

• Avoid excessive whitespace immediately inside of parenthesis, brackets, or braces. bad_spacing = { 1 }

• Use whitespace around assignment and logical operators.

• Use whitespace to communicate order of operations. x = 2*y + 2*z

• Keep lines under 79 characters — this is intended to minimize line-wrapping on side-by-side windows.

Single Quotes or Double Quotes

Both single and double quotes are used when defining string values. Additionally, triple quotes are used for multiline strings. Python does not advocate for single or double quotes, but does provide usage guidelines.

• Use double quotes for strings with an apostrophe.

• Use single quotes for strings with quotation marks.

• Always use double quotes for multiline strings.

Do not let these guidelines get in the way of learning Python. However, just like anything else, it’s easier to learn something right the first time compared to breaking a bad habit.

View comments

We have a passion for introducing people of all ages and backgrounds who want to learn to code.

Whether you’re a student, small business owner, or just a curious individual, we don’t assume you have a math background and computer science degree.

Sign up now so you don’t miss the first issue.

Subscribe now

In the meantime, tell your friends!