Python Module Import: Single-line vs Multi-line

Solution 1:

There is no difference at all. They both function exactly the same.

However, from a stylistic perspective, one might be more preferable than the other. And on that note, the PEP-8 for imports says that you should compress from module import name1, name2 onto a single line and leave import module1 on multiple lines:

Yes: import os
     import sys

No:  import sys, os

Ok: from subprocess import Popen, PIPE

In response to @teewuane's comment (repeated here in case the comment gets deleted):

@inspectorG4dget What if you have to import several functions from one module and it ends up making that line longer than 80 char? I know that the 80 char thing is "when it makes the code more readable" but I am still wondering if there is a more tidy way to do this. And I don't want to do from foo import * even though I am basically importing everything.

The issue here is that doing something like the following could exceed the 80 char limit:

from module import func1, func2, func3, func4, func5

To this, I have two responses (I don't see PEP8 being overly clear about this):

Break it up into two imports:

from module import func1, func2, func3
from module import func4, func5

Doing this has the disadvantage that if module is removed from the codebase or otherwise refactored, then both import lines will need to be deleted. This could prove to be painful

Split the line:

To mitigate the above concern, it may be wiser to do

from module import func1, func2, func3, \
     func4, func5

This would result in an error if the second line is not deleted along with the first, while still maintaining the singular import statement

Solution 2:

To add to some of the questions raised from inspectorG4dget's answer, you can also use tuples to do multi-line imports when folder structures start getting deeply nested or you have modules with obtuse names.

from some.module.submodule.that_has_long_names import (
    first_item,
    second_item,
    more_imported_items_with_really_enormously_long_names_that_might_be_too_descriptive,
    that_would_certainly_not_fit,
    on_one_line,
)

This also works, though I'm not a fan of this style:

from module import (a_ton, of, modules, that_seem, to_keep, needing,
                    to_be, added, to_the_list, of_required_items)

Solution 3:

I would suggest not to follow PEP-8 blindly. When you have about half screen worth of imports, things start becoming uncomfortable and PEP-8 is then in conflicts with PEP-20 readability guidelines.

My preference is,

1. Put all built-in imports on one line such as sys, os, time etc.
2. For other imports, use one line per package (not module)

Above gives you good balance because the reader can still quickly glance the dependencies while achieving reasonable compactness.

For example,

My Preference

# one line per package

import os, json, time, sys, math
import numpy as np
import torch, torch.nn as nn, torch.autograd, torch.nn.functional as F
from torchvision models, transforms

PEP-8 Recommandation

# one line per module or from ... import statement

import os
import json
import time
import sys
import math

import numpy as np

import torch
from torch import nn as nn, autograd, nn.functional as F
from torchvision import models, transforms

Solution 4:

Imports should usually be on separate lines as per PEP 8 guidelines.

# Wrong Use
import os, sys
# Correct Use
import os
import sys

For more import based PEP 8 violations and fixes please check this out https://ayush-raj-blogs.hashnode.dev/making-clean-pr-for-open-source-contributors-pep-8-style.