Read bills from a bills.csv file

Question

I wrote the following code to read out a bill from a file and then putting it into a bills-list.

The bill contains: "company", "customer", Year, Month, Day, Amount, "credit/debit"

Is there a nicer way using list comprehension to make this code look better?

def read_bills(file = "bills.csv"):
    """Read bills from the file system 'bills.csv'"""
    # Create a list in which each bill is entered.
    bills = []
    for line in open(file):
        bill = line.strip().split(',')
        for i in range(len(bill)):
            if i > 1 and i < 5:
                bill[i] = int(bill[i].strip())
            elif i == 5:
                bill[i] = float(bill[i].strip())
            else:
                bill[i] = bill[i].strip()
        bills.append(bill)
    return bills

Answer 1

The least appealing, most tedious part of the current code is the conditional logic to handle data conversion. Since you're dealing with a limited number of columns, you can use a data structure to eliminate the conditionals. (In my experience, smarter or more convenient/suitable data structures are often the most powerful devices to simplify algorithmic logic.) For example, to parse a single line, one could write something like this:

def parse_line(line):
    types = (str, str, int, int, int, float, str)
    raw_vals = [val.strip() for val in line.strip().split(',')]
    return [f(val) for val, f in zip(raw_vals, types)]

And if that line-parsing function existed, the overall bill-parsing function would be pretty trivial:

def read_bills(file_path):
    with open(file_path) as fh:
        return [parse_line(line) for line in fh]

Don't overlook the implicit suggestion here: separate the detailed logic (line parsing) from larger orchestration (opening a file and processing it line by line). The latter can usually be quite simple, hardly worth testing or worrying about too much, while the former often requires more effort to ensure correctness. Reducing the footprint of the code requiring in-depth testing is usually a good move to make.

Answer 2

Overlapping somewhat with @FMc:

• Probably should avoid making a bills list; just use a generator
• Use the built-in csv and dataclass modules to make your life easier
• Prefer a deserialization routine that uses column names instead of column indices.
• I see that you're using float for your billed amount but this is not appropriate. For monetary numerics use Decimal unless you have a very good reason.
• Make an actual date object out of your date fields.

Suggested

from csv import DictReader
from dataclasses import dataclass
from datetime import date
from decimal import Decimal
from typing import Any, TextIO, Iterator


@dataclass
class BillLine:
    company: str
    customer: str
    when: date
    amount: Decimal

    @classmethod
    def from_dict(cls, data: dict[str, Any]) -> 'BillLine':
        when = date(
            int(data['Year']),
            int(data['Month']),
            int(data['Day']),
        )

        amount = Decimal(data['Amount'])
        if amount < 0:
            raise ValueError('Negative amount disallowed; use "debit"')

        credit = data['credit/debit']
        if credit == 'debit':
            amount = -amount
        elif credit != 'credit':
            raise ValueError(f'"{credit}" is an unrecognized credit state')

        return cls(
            company=data['company'],
            customer=data['customer'],
            when=when, amount=amount,
        )

    @classmethod
    def from_csv(cls, file: TextIO) -> Iterator['BillLine']:
        csv = DictReader(file)
        for record in csv:
            yield cls.from_dict(record)


def test() -> None:
    with open('bills.csv', newline='') as file:
        records = tuple(BillLine.from_csv(file))


if __name__ == '__main__':
    test()