In some (mostly functional) languages you can do something like this:
type row = list(datum)
or
type row = [datum]
So that we can build things like this:
type row = [datum] type table = [row] type database = [table]
Is there a way to do this in Python? You could do it using classes, but Python has quite some functional aspects so I was wondering if it could be done an easier way.
In Python, you can achieve similar concepts using lists and nested lists. However, Python is dynamically typed, so you won’t explicitly declare types in the same way you might in statically typed languages. Here’s an example using lists to represent a table and a database:
# Single datum datum = 42 # Define a row as a list of datums row = [datum] # Define a table as a list of rows table = [row, [1, 2, 3], ["a", "b", "c"]] # Define a database as a list of tables database = [table, [[4, 5, 6], ["x", "y", "z"]]] # Accessing elements print(database[0]) # Access first table print(database[0][1]) # Access second row in the first table print(database[1][0][2]) # Access third element in the first row of the second table
In this example, table is a list of rows, and database is a list of tables. Each row is a list of datums.
table
database
Python supports more complex data structures like dictionaries, tuples, and namedtuples, which you can use depending on your specific use case. If you need more structure or named fields, classes or data classes may be appropriate.
For example, using namedtuples:
from typing import NamedTuple class Row(NamedTuple): datum: int class Table(NamedTuple): rows: list[Row] class Database(NamedTuple): tables: list[Table] # Example usage: row = Row(datum=42) table = Table(rows=[row, Row(datum=1), Row(datum="a")]) database = Database(tables=[table, Table(rows=[Row(datum=4), Row(datum="x")])]) # Accessing elements print(database.tables[0].rows[1].datum) # Accessing the datum in the second row of the first table
Using classes or data classes provides a more structured approach and allows you to define behaviors and methods associated with each level of your data structure.