Das deutsche Python-Forum

Code: Alles auswählen

class Foo:
    def __init__(self, bar, bridge, street):
        self.bar = bar
        self.bridge = bridge
        self.street = street

    def update(self, d: dict):
        for key, value in d.items():
            # print(key)
            setattr(self, key, value)

def main():

    f = Foo('Test-Bar', 'Test-Bridge', 'Test-Street')
    pprint(vars(f))

    d = dict(bar = "new_bar", bridge = "new-bridge")
    f.update(d)
    pprint(vars(f))

if __name__ == '__main__':
    main()

Code: Alles auswählen

from pprint import pprint

class Foo:
    def __init__(self, bar, bridge, street):
        self.bar = bar
        self.bridge = bridge
        self.street = street

def main():
    f = Foo("Test-Bar", "Test-Bridge", "Test-Street")
    pprint(vars(f))
    d = dict(bar="new_bar", bridge="new-bridge")
    f.__dict__.update(d)  # <-------------------
    pprint(vars(f))

if __name__ == "__main__":
    main()

Code: Alles auswählen

#!/usr/bin/env python

class Foo:
    def __init__(self, test_var):
        self.the_only_defined_var_in_this_class = test_var

def main():

    d = dict(variable_1 = 'test', variable_2 = 'foo', variable_3 = 'bar')
    f = Foo('the one and only')

    # connect d to f ????

if __name__ == '__main__':
    main()

Code: Alles auswählen

class Foo:
    def __init__(self, bar, bridge, street):
        self.bar = bar
        self.bridge = bridge
        self.street = street

    def update(self, **changes):
        for key, value in changes.items():
            setattr(self, key, value)


def main():
    foo = Foo('Test-Bar', 'Test-Bridge', 'Test-Street')
    foo.update(bar="new_bar", bridge="new-bridge")
    print(vars(f))

if __name__ == '__main__':
    main()

Code: Alles auswählen

from attrs import evolve, field, frozen


@frozen
class Foo:
    bar = field()
    bridge = field()
    street = field()


def main():
    foo = Foo("Test-Bar", "Test-Bridge", "Test-Street")
    print(foo)

    changes = dict(bar="new_bar", bridge="new-bridge")
    foo = evolve(foo, **changes)
    print(foo)


if __name__ == "__main__":
    main()

Code: Alles auswählen

Foo(bar='Test-Bar', bridge='Test-Bridge', street='Test-Street')
Foo(bar='new_bar', bridge='new-bridge', street='Test-Street')

Code: Alles auswählen

import cattrs
from attrs import evolve, field, frozen


@frozen
class Foo:
    the_only_defined_var_in_this_class = field()
    variable_1 = field(default=None)
    variable_2 = field(default=None)
    variable_3 = field(default=None)


def main():
    changes = dict(variable_1="test", variable_2="foo", variable_3="bar")
    foo = Foo("the one and only")
    print(foo)

    foo = evolve(foo, **changes)
    print(foo)

    # Oder:

    mapping = dict(variable_1="test", variable_2="foo", variable_3="bar")
    mapping["the_only_defined_var_in_this_class"] = "the one and only"
    foo = Foo(**mapping)
    print(foo)

    # Oder:

    mapping = dict(variable_1="test", variable_2="foo", variable_3="bar")
    mapping["the_only_defined_var_in_this_class"] = "the one and only"
    foo = cattrs.structure(mapping, Foo)
    print(foo)


if __name__ == "__main__":
    main()

Code: Alles auswählen

Beispiel csv:

description_1;description_2;bar_description_1
desc_1_test1;desc_2_test1;bdesc_1_test1
desc_1_test2;desc_2_test2;bdesc_1_test2
desc_1_test3;desc_2_test3;bdesc_1_test3
desc_1_test4;desc_2_test4;bdesc_1_test4

Code: Alles auswählen

#!/usr/bin/env/python

import csv

d = dict(foo_var_1 = 'description_1', foo_var_2 = 'description_2',
         bar_var_1 = 'bar_description_1')

class Foo():
    def __init__(self):
        pass

def read_csv_file() -> list:
       with open('test.csv', newline = '', encoding = 'utf-8') as csvfile:
        line = csv.DictReader(csvfile, delimiter=';')
        l = []
        for row in line:
            f = Foo()
            for key, value in d.items():
                setattr(f, key, row[value])
            l.append(f)    
        return l

class Bar():
    def __init__(self):
        pass

def work_with_objects(list_of_foo) -> tuple:
    a_list = []
    b_list = []
    for n in list_of_foo:
        a = Bar()
        b = Bar()
        for key, value in d.items():
            if 'foo' in key:
                setattr(a, key, getattr(n, key))
            if 'bar' in key:
                setattr(b, key, getattr(n, key))
        a_list.append(a)
        b_list.append(b)
    return (a_list, b_list)


def main():
    list_of_foo = read_csv_file()
    works = work_with_objects(list_of_foo)

if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/env python3
import csv

NAME_TO_COLUMN_NAME = {
    "var_1": "description_1",
    "var_2": "description_2",
    "bar_var_1": "bar_description_1",
}


class Foo:
    def __init__(self, var_1, var_2, bar_var_1):
        self.var_1 = var_1
        self.var_2 = var_2
        self.bar_var_1 = bar_var_1


def load_csv_file(filename):
    with open(filename, newline="", encoding="utf-8") as file:
        return [
            Foo(
                **{
                    argument_name: row[column_name]
                    for argument_name, column_name in NAME_TO_COLUMN_NAME.items()
                }
            )
            for row in csv.DictReader(file, delimiter=";")
        ]


def main():
    foos = load_csv_file("test.csv")
    ...


if __name__ == "__main__":
    main()

Code: Alles auswählen

class Foo:
    def __init__(self, var_1, var_2, bar_var_1):
        self.var_1 = var_1
        self.var_2 = var_2
        self.bar_var_1 = bar_var_1

    @classmethod
    def from_row(cls, row):
        cls(
            **{
                argument_name: row[column_name]
                for argument_name, column_name in NAME_TO_COLUMN_NAME.items()
            }
        )


def load_csv_file(filename):
    with open(filename, newline="", encoding="utf-8") as file:
        return list(map(Foo.from_row, csv.DictReader(file, delimiter=";")))

Code: Alles auswählen

#!/usr/bin/env/python

import csv
from pathlib import Path

from attrs import field, frozen
from cattrs import structure

NAMES = ["var_1", "var_2", "bar_var_1"]
CSV_FILE = Path(__file__).parent / "test.csv"


@frozen
class Foo:
    var_1 = field()
    var_2 = field()
    bar_var_1 = field()


def load_csv_file(file):
    with open(file, newline="", encoding="utf-8") as csvfile:
        return [
            structure(dict(zip(NAMES, row.values())), Foo)
            for row in csv.DictReader(csvfile, delimiter=";")
        ]


def main():
    foos = load_csv_file(CSV_FILE)


if __name__ == "__main__":
    main()

Code: Alles auswählen

def load_csv_file(file):
    with open(file, newline="", encoding="utf-8") as csvfile:
        reader = csv.DictReader(csvfile, delimiter=";")
        return structure(list(reader), list[Foo])

Code: Alles auswählen

#!/usr/bin/env python3
from datetime import date
from pathlib import Path
from pprint import pprint

from attrs import define
from cattrs.preconf.json import make_converter

_CONVERTER = make_converter()
JSON_FILE = Path("persons.json")

@define
class Address:
    street: str
    house_no: str
    zip_code: str
    city: str


@define
class Person:
    name: str
    birthday: date
    address: Address


def save_json(
    persons: list[Person],
    json_file: Path,
    encoding: str = "utf-8"
) -> None:
    json_file.write_text(_CONVERTER.dumps(persons), encoding)

def load_json(
    json_file: Path,
    encoding: str = "utf-8"
) -> list[Person]:
    return _CONVERTER.loads(json_file.read_text(encoding), list[Person])


def main():
    address = Address("Spämstraße", "42 B", "01234", "Spämdorf")
    man = Person("Jürgen Müller", date(1957, 5, 2), address)
    woman = Person("Gertrud Müller", date(1957, 7, 18), address)
    save_json([man, woman], JSON_FILE)
    pprint(load_json(JSON_FILE))


if __name__ == "__main__":
    main()