Læsning af CSV-filer i Python

I denne vejledning lærer vi at læse CSV-filer med forskellige formater i Python ved hjælp af eksempler.

Vi vil udelukkende bruge det csvmodul, der er indbygget i Python, til denne opgave. Men først skal vi importere modulet som:

 import csv

Vi har allerede dækket det grundlæggende om, hvordan man bruger csvmodulet til at læse og skrive i CSV-filer. Hvis du ikke har nogen idé om at bruge csvmodulet, skal du tjekke vores tutorial om Python CSV: Læs og skriv CSV-filer

Grundlæggende brug af csv.reader ()

Lad os se på et grundlæggende eksempel på at bruge csv.reader()til at opdatere din eksisterende viden.

Eksempel 1: Læs CSV-filer med csv.reader ()

Antag, at vi har en CSV-fil med følgende poster:

 SN, Navn, Bidrag 1, Linus Torvalds, Linux Kernel 2, Tim Berners-Lee, World Wide Web 3, Guido van Rossum, Python Programming

Vi kan læse indholdet af filen med følgende program:

 import csv with open('innovators.csv', 'r') as file: reader = csv.reader(file) for row in reader: print(row)

Produktion 

 ('SN', 'Name', 'Contribution') ('1', 'Linus Torvalds', 'Linux Kernel') ('2', 'Tim Berners-Lee', 'World Wide Web') ('3' , 'Guido van Rossum', 'Python Programming')

Her har vi åbnet filen innovators.csv i læsningstilstand ved hjælp af open()funktionen.

For at lære mere om åbning af filer i Python, besøg: Python File Input / Output

Derefter csv.reader()bruges den til at læse filen, som returnerer et iterabelt readerobjekt.

Den readerObjektet derefter gentages ved hjælp af en forløkke til at udskrive indholdet af hver række.

Nu vil vi se på CSV-filer med forskellige formater. Vi vil så lære at tilpasse csv.reader()funktionen til at læse dem.

CSV-filer med brugerdefinerede afgrænsere

Som standard bruges et komma som en afgrænser i en CSV-fil. Nogle CSV-filer kan dog bruge andre afgrænsere end komma. Få populære er |og .

Antag, at innovators.csv- filen i eksempel 1 brugte fanen som en afgrænser. For at læse filen kan vi videregive en ekstra delimiterparameter til csv.reader()funktionen.

Lad os tage et eksempel.

Eksempel 2: Læs CSV-fil med tabulatorafgrænser

 import csv with open('innovators.csv', 'r') as file: reader = csv.reader(file, delimiter = ' ') for row in reader: print(row)

Produktion 

 ('SN', 'Name', 'Contribution') ('1', 'Linus Torvalds', 'Linux Kernel') ('2', 'Tim Berners-Lee', 'World Wide Web') ('3' , 'Guido van Rossum', 'Python Programming')

Som vi kan se, delimiter = ' 'hjælper den valgfri parameter med at specificere det readerobjekt, som CSV-filen, vi læser fra, har faner som en afgrænser.

CSV-filer med indledende mellemrum

Nogle CSV-filer kan have mellemrumstegn efter en afgrænser. Når vi bruger standardfunktionen csv.reader()til at læse disse CSV-filer, får vi også mellemrum i output.

For at fjerne disse indledende mellemrum skal vi sende en ekstra parameter kaldet skipinitialspace. Lad os se på et eksempel:

Eksempel 3: Læs CSV-filer med indledende mellemrum

Antag, at vi har en CSV-fil, der hedder people.csv med følgende indhold:

 SN, Navn, By 1, John, Washington 2, Eric, Los Angeles 3, Brad, Texas

Vi kan læse CSV-filen som følger:

 import csv with open('people.csv', 'r') as csvfile: reader = csv.reader(csvfile, skipinitialspace=True) for row in reader: print(row)

Produktion 

 ('SN', 'Navn', 'By') ('1', 'John', 'Washington') ('2', 'Eric', 'Los Angeles') ('3', 'Brad', ' Texas ')

Programmet ligner andre eksempler, men har en yderligere skipinitialspaceparameter, der er indstillet til Sand.

Dette gør det muligt for readerobjektet at vide, at posterne har indledende hvidt mellemrum. Som et resultat fjernes de oprindelige mellemrum, der var til stede efter en afgrænser.

CSV-filer med citater

Nogle CSV-filer kan have citater omkring hver eller nogle af posterne.

Lad os tage quotes.csv som et eksempel med følgende poster:

 "SN", "Navn", "Citater" 1, Buddha, "Hvad vi synes, vi bliver" 2, Mark Twain, "Beklager aldrig noget, der fik dig til at smile" 3, Oscar Wilde, "Vær dig selv, alle andre er allerede taget"

Brug csv.reader()i minimal tilstand resulterer i output med anførselstegn.

For at fjerne dem skal vi bruge en anden valgfri parameter kaldet quoting.

Lad os se på et eksempel på, hvordan man læser ovenstående program.

Eksempel 4: Læs CSV-filer med anførselstegn

 import csv with open('person1.csv', 'r') as file: reader = csv.reader(file, quoting=csv.QUOTE_ALL, skipinitialspace=True) for row in reader: print(row)

Produktion 

 ('SN', 'Name', 'Quotes') ('1', 'Buddha', 'What we think we become') ('2', 'Mark Twain', 'Never regret anything that made you smile') ('3', 'Oscar Wilde', 'Be yourself everyone else is already taken')

As you can see, we have passed csv.QUOTE_ALL to the quoting parameter. It is a constant defined by the csv module.

csv.QUOTE_ALL specifies the reader object that all the values in the CSV file are present inside quotation marks.

There are 3 other predefined constants you can pass to the quoting parameter:

  • csv.QUOTE_MINIMAL - Specifies reader object that CSV file has quotes around those entries which contain special characters such as delimiter, quotechar or any of the characters in lineterminator.
  • csv.QUOTE_NONNUMERIC - Specifies the reader object that the CSV file has quotes around the non-numeric entries.
  • csv.QUOTE_NONE - Specifies the reader object that none of the entries have quotes around them.

Dialects in CSV module

Notice in Example 4 that we have passed multiple parameters (quoting and skipinitialspace) to the csv.reader() function.

This practice is acceptable when dealing with one or two files. But it will make the code more redundant and ugly once we start working with multiple CSV files with similar formats.

As a solution to this, the csv module offers dialect as an optional parameter.

Dialect helps in grouping together many specific formatting patterns like delimiter, skipinitialspace, quoting, escapechar into a single dialect name.

It can then be passed as a parameter to multiple writer or reader instances.

Example 5: Read CSV files using dialect

Suppose we have a CSV file (office.csv) with the following content:

 "ID"| "Name"| "Email" "A878"| "Alfonso K. Hamby"| "[email protected]" "F854"| "Susanne Briard"| "[email protected]" "E833"| "Katja Mauer"| "[email protected]"

The CSV file has initial spaces, quotes around each entry, and uses a | delimiter.

Instead of passing three individual formatting patterns, let's look at how to use dialects to read this file.

 import csv csv.register_dialect('myDialect', delimiter='|', skipinitialspace=True, quoting=csv.QUOTE_ALL) with open('office.csv', 'r') as csvfile: reader = csv.reader(csvfile, dialect='myDialect') for row in reader: print(row)

Output 

 ('ID', 'Name', 'Email') ("A878", 'Alfonso K. Hamby', '[email protected]') ("F854", 'Susanne Briard', '[email protected]') ("E833", 'Katja Mauer', '[email protected]')

From this example, we can see that the csv.register_dialect() function is used to define a custom dialect. It has the following syntax:

 csv.register_dialect(name(, dialect(, **fmtparams)))

The custom dialect requires a name in the form of a string. Other specifications can be done either by passing a sub-class of Dialect class, or by individual formatting patterns as shown in the example.

While creating the reader object, we pass dialect='myDialect' to specify that the reader instance must use that particular dialect.

The advantage of using dialect is that it makes the program more modular. Notice that we can reuse 'myDialect' to open other files without having to re-specify the CSV format.

Read CSV files with csv.DictReader()

The objects of a csv.DictReader() class can be used to read a CSV file as a dictionary.

Example 6: Python csv.DictReader()

Suppose we have a CSV file (people.csv) with the following entries:

Name Age Profession
Jack 23 Doctor
Miller 22 Engineer

Let's see how csv.DictReader() can be used.

 import csv with open("people.csv", 'r') as file: csv_file = csv.DictReader(file) for row in csv_file: print(dict(row))

Output 

 ('Name': 'Jack', ' Age': ' 23', ' Profession': ' Doctor') ('Name': 'Miller', ' Age': ' 22', ' Profession': ' Engineer')

As we can see, the entries of the first row are the dictionary keys. And, the entries in the other rows are the dictionary values.

Here, csv_file is a csv.DictReader() object. The object can be iterated over using a for loop. The csv.DictReader() returned an OrderedDict type for each row. That's why we used dict() to convert each row to a dictionary.

Notice that we have explicitly used the dict() method to create dictionaries inside the for loop.

 print(dict(row))

Note: Starting from Python 3.8, csv.DictReader() returns a dictionary for each row, and we do not need to use dict() explicitly.

The full syntax of the csv.DictReader() class is:

 csv.DictReader(file, fieldnames=None, restkey=None, restval=None, dialect='excel', *args, **kwds)

To learn more about it in detail, visit: Python csv.DictReader() class

Using csv.Sniffer class

The Sniffer class is used to deduce the format of a CSV file.

The Sniffer class offers two methods:

  • sniff(sample, delimiters=None) - This function analyses a given sample of the CSV text and returns a Dialect subclass that contains all the parameters deduced.

An optional delimiters parameter can be passed as a string containing possible valid delimiter characters.

  • has_header(sample) - This function returns True or False based on analyzing whether the sample CSV has the first row as column headers.

Let's look at an example of using these functions:

Example 7: Using csv.Sniffer() to deduce the dialect of CSV files

Suppose we have a CSV file (office.csv) with the following content:

 "ID"| "Name"| "Email" A878| "Alfonso K. Hamby"| "[email protected]" F854| "Susanne Briard"| "[email protected]" E833| "Katja Mauer"| "[email protected]"

Let's look at how we can deduce the format of this file using csv.Sniffer() class:

 import csv with open('office.csv', 'r') as csvfile: sample = csvfile.read(64) has_header = csv.Sniffer().has_header(sample) print(has_header) deduced_dialect = csv.Sniffer().sniff(sample) with open('office.csv', 'r') as csvfile: reader = csv.reader(csvfile, deduced_dialect) for row in reader: print(row)

Output 

 True ('ID', 'Name', 'Email') ('A878', 'Alfonso K. Hamby', '[email protected]') ('F854', 'Susanne Briard', '[email protected]') ('E833', 'Katja Mauer', '[email protected]')

As you can see, we read only 64 characters of office.csv and stored it in the sample variable.

This sample was then passed as a parameter to the Sniffer().has_header() function. It deduced that the first row must have column headers. Thus, it returned True which was then printed out.

Tilsvarende blev prøve også videregivet til Sniffer().sniff()funktionen. Det returnerede alle de deducerede parametre som en Dialectunderklasse, som derefter blev gemt i variablen deduced_dialect.

Senere åbnede vi CSV-filen igen og sendte deduced_dialectvariablen som parameter til csv.reader().

Det var korrekt stand til at forudsige delimiter, quotingog skipinitialspaceparametre i office.csv fil uden os udtrykkeligt at nævne dem.

Bemærk: Csv-modulet kan også bruges til andre filtypenavne (som: .txt ), så længe deres indhold er i korrekt struktur.

Anbefalet læsning: Skriv til CSV-filer i Python

Interessante artikler...