FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
python-docs-de/library/dataclasses.po at refs/heads/3.15 · python/python-docs-de · GitHub
python
python-docs-de
Repository navigation
Code
Issues
Pull requests
2
(2)
Actions
Security and quality
Insights
Expand file tree
Breadcrumbs
python-docs-de
/
library
/
dataclasses.po
Copy path
More file actions
More file actions
Latest commit
History
History
History
1253 lines (1088 loc) · 41.3 KB
Breadcrumbs
python-docs-de
/
library
/
dataclasses.po
Copy path
File metadata and controls
1253 lines (1088 loc) · 41.3 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#
SOME DESCRIPTIVE TITLE.
#
Copyright (C) 2001 Python Software Foundation
#
This file is distributed under the same license as the Python package.
#
FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"
Project-Id-Version
:
Python 3.15\n
"
"
Report-Msgid-Bugs-To
:
\n
"
"
POT-Creation-Date
:
2026-08-22 12:07+0200\n
"
"
PO-Revision-Date
:
2025-09-16 00:01+0000\n
"
"
Language-Team
:
German (https://app.transifex.com/python-doc/teams/5390/de/)\n
"
"
Language
:
de\n
"
"
MIME-Version
:
1.0\n
"
"
Content-Type
:
text/plain; charset=UTF-8\n
"
"
Content-Transfer-Encoding
:
8bit\n
"
"
Plural-Forms
:
nplurals=2; plural=(n != 1);\n
"
#:
../../library/dataclasses.rst:2
msgid
":mod:`!dataclasses` --- Data Classes"
msgstr
""
#:
../../library/dataclasses.rst:7
msgid
"**Source code:** :source:`Lib/dataclasses.py`"
msgstr
""
#:
../../library/dataclasses.rst:11
msgid
""
"This module provides a decorator and functions for automatically adding "
"generated :term:`special methods <special method>` such as :meth:`~object."
"__init__` and :meth:`~object.__repr__` to user-defined classes. It was "
"originally described in :pep:`557`."
msgstr
""
#:
../../library/dataclasses.rst:16
msgid
""
"The member variables to use in these generated methods are defined using :"
"pep:`526` type annotations. For example, this code::"
msgstr
""
#:
../../library/dataclasses.rst:19
msgid
""
"from dataclasses import dataclass\n"
"\n"
"@dataclass\n"
"class InventoryItem:\n"
"
\"\"\"
Class for keeping track of an item in inventory.
\"\"\"
\n"
" name: str\n"
" unit_price: float\n"
" quantity_on_hand: int = 0\n"
"\n"
" def total_cost(self) -> float:\n"
" return self.unit_price * self.quantity_on_hand"
msgstr
""
#:
../../library/dataclasses.rst:31
msgid
"will add, among other things, a :meth:`!__init__` that looks like::"
msgstr
""
#:
../../library/dataclasses.rst:33
msgid
""
"def __init__(self, name: str, unit_price: float, quantity_on_hand: int = "
"0):\n"
" self.name = name\n"
" self.unit_price = unit_price\n"
" self.quantity_on_hand = quantity_on_hand"
msgstr
""
#:
../../library/dataclasses.rst:38
msgid
""
"Note that this method is automatically added to the class: it is not "
"directly specified in the :class:`!InventoryItem` definition shown above."
msgstr
""
#:
../../library/dataclasses.rst:44
msgid
"Module contents"
msgstr
""
#:
../../library/dataclasses.rst:48
msgid
""
"This function is a :term:`decorator` that is used to add generated :term:"
"`special methods <special method>` to classes, as described below."
msgstr
""
#:
../../library/dataclasses.rst:51
msgid
""
"The ``@dataclass`` decorator examines the class to find ``field``
\\
s. A "
"``field`` is defined as a class variable that has a :term:`type annotation "
"<variable annotation>`. With two exceptions described below, nothing in "
"``@dataclass`` examines the type specified in the variable annotation."
msgstr
""
#:
../../library/dataclasses.rst:57
msgid
""
"The order of the fields in all of the generated methods is the order in "
"which they appear in the class definition."
msgstr
""
#:
../../library/dataclasses.rst:60
msgid
""
"The ``@dataclass`` decorator will add various
\"
dunder
\"
methods to the "
"class, described below. If any of the added methods already exist in the "
"class, the behavior depends on the parameter, as documented below. The "
"decorator returns the same class that it is called on; no new class is "
"created."
msgstr
""
#:
../../library/dataclasses.rst:66
msgid
""
"If ``@dataclass`` is used just as a simple decorator with no parameters, it "
"acts as if it has the default values documented in this signature. That is, "
"these three uses of ``@dataclass`` are equivalent::"
msgstr
""
#:
../../library/dataclasses.rst:71
msgid
""
"@dataclass\n"
"class C:\n"
" ...\n"
"\n"
"@dataclass()\n"
"class C:\n"
" ...\n"
"\n"
"@dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, "
"frozen=False,\n"
" match_args=True, kw_only=False, slots=False, weakref_slot=False)\n"
"class C:\n"
" ..."
msgstr
""
#:
../../library/dataclasses.rst:84
msgid
"The parameters to ``@dataclass`` are:"
msgstr
""
#:
../../library/dataclasses.rst:86
msgid
""
"*init*: If true (the default), a :meth:`~object.__init__` method will be "
"generated."
msgstr
""
#:
../../library/dataclasses.rst:89
msgid
""
"If the class already defines :meth:`!__init__`, this parameter is ignored."
msgstr
""
#:
../../library/dataclasses.rst:92
msgid
""
"*repr*: If true (the default), a :meth:`~object.__repr__` method will be "
"generated. The generated repr string will have the class name and the name "
"and repr of each field, in the order they are defined in the class. Fields "
"that are marked as being excluded from the repr are not included. For "
"example: ``InventoryItem(name='widget', unit_price=3.0, "
"quantity_on_hand=10)``."
msgstr
""
#:
../../library/dataclasses.rst:99
msgid
""
"If the class already defines :meth:`!__repr__`, this parameter is ignored."
msgstr
""
#:
../../library/dataclasses.rst:102
msgid
""
"*eq*: If true (the default), an :meth:`~object.__eq__` method will be "
"generated."
msgstr
""
#:
../../library/dataclasses.rst:105
msgid
""
"This method compares the class by comparing each field in order. Both "
"instances in the comparison must be of the identical type."
msgstr
""
#:
../../library/dataclasses.rst:108
msgid
""
"If the class already defines :meth:`!__eq__`, this parameter is ignored."
msgstr
""
#:
../../library/dataclasses.rst:110
msgid
""
"The generated ``__eq__`` method now compares each field individually (for "
"example, ``self.a == other.a and self.b == other.b``), rather than comparing "
"tuples of fields as in previous versions."
msgstr
""
#:
../../library/dataclasses.rst:115
msgid
""
"This change makes the comparison faster but it may alter results in cases "
"where attributes compare equal by identity but not by value (such as "
"``float('nan')``)."
msgstr
""
#:
../../library/dataclasses.rst:119
msgid
""
"In Python 3.12 and earlier, the comparison was performed by creating tuples "
"of the fields and comparing them (for example, ``(self.a, self.b) == (other."
"a, other.b)``)."
msgstr
""
#:
../../library/dataclasses.rst:123
msgid
""
"*order*: If true (the default is ``False``), :meth:`~object.__lt__`, :meth:"
"`~object.__le__`, :meth:`~object.__gt__`, and :meth:`~object.__ge__` methods "
"will be generated. These compare the class as if it were a tuple of its "
"fields, in order. Both instances in the comparison must be of the identical "
"type. If *order* is true and *eq* is false, a :exc:`ValueError` is raised."
msgstr
""
#:
../../library/dataclasses.rst:130
msgid
""
"If the class already defines any of :meth:`!__lt__`, :meth:`!__le__`, :meth:"
"`!__gt__`, or :meth:`!__ge__`, then :exc:`TypeError` is raised."
msgstr
""
#:
../../library/dataclasses.rst:134
msgid
""
"*unsafe_hash*: If true, force ``dataclasses`` to create a :meth:`~object."
"__hash__` method, even though it may not be safe to do so. Otherwise, "
"generate a :meth:`~object.__hash__` method according to how *eq* and "
"*frozen* are set. The default value is ``False``."
msgstr
""
#:
../../library/dataclasses.rst:140
msgid
""
":meth:`!__hash__` is used by built-in :meth:`hash`, and when objects are "
"added to hashed collections such as dictionaries and sets. Having a :meth:`!"
"__hash__` implies that instances of the class are immutable. Mutability is a "
"complicated property that depends on the programmer's intent, the existence "
"and behavior of :meth:`!__eq__`, and the values of the *eq* and *frozen* "
"flags in the ``@dataclass`` decorator."
msgstr
""
#:
../../library/dataclasses.rst:147
msgid
""
"By default, ``@dataclass`` will not implicitly add a :meth:`~object."
"__hash__` method unless it is safe to do so. Neither will it add or change "
"an existing explicitly defined :meth:`!__hash__` method. Setting the class "
"attribute ``__hash__ = None`` has a specific meaning to Python, as described "
"in the :meth:`!__hash__` documentation."
msgstr
""
#:
../../library/dataclasses.rst:153
msgid
""
"If :meth:`!__hash__` is not explicitly defined, or if it is set to ``None``, "
"then ``@dataclass`` *may* add an implicit :meth:`!__hash__` method. Although "
"not recommended, you can force ``@dataclass`` to create a :meth:`!__hash__` "
"method with ``unsafe_hash=True``. This might be the case if your class is "
"logically immutable but can still be mutated. This is a specialized use case "
"and should be considered carefully."
msgstr
""
#:
../../library/dataclasses.rst:160
msgid
""
"Here are the rules governing implicit creation of a :meth:`!__hash__` "
"method. Note that you cannot both have an explicit :meth:`!__hash__` method "
"in your dataclass and set ``unsafe_hash=True``; this will result in a :exc:"
"`TypeError`."
msgstr
""
#:
../../library/dataclasses.rst:165
msgid
""
"If *eq* and *frozen* are both true, by default ``@dataclass`` will generate "
"a :meth:`!__hash__` method for you. If *eq* is true and *frozen* is false, :"
"meth:`!__hash__` will be set to ``None``, marking it unhashable (which it "
"is, since it is mutable). If *eq* is false, :meth:`!__hash__` will be left "
"untouched meaning the :meth:`!__hash__` method of the superclass will be "
"used (if the superclass is :class:`object`, this means it will fall back to "
"id-based hashing)."
msgstr
""
#:
../../library/dataclasses.rst:173
msgid
""
"*frozen*: If true (the default is ``False``), assigning to fields will "
"generate an exception. This emulates read-only frozen instances. See the :"
"ref:`discussion <dataclasses-frozen>` below."
msgstr
""
#:
../../library/dataclasses.rst:177
msgid
""
"If :meth:`~object.__setattr__` or :meth:`~object.__delattr__` is defined in "
"the class and *frozen* is true, then :exc:`TypeError` is raised."
msgstr
""
#:
../../library/dataclasses.rst:180
msgid
""
"*match_args*: If true (the default is ``True``), the :attr:`~object."
"__match_args__` tuple will be created from the list of non keyword-only "
"parameters to the generated :meth:`~object.__init__` method (even if :meth:`!"
"__init__` is not generated, see above). If false, or if :attr:`!"
"__match_args__` is already defined in the class, then :attr:`!"
"__match_args__` will not be generated."
msgstr
""
#:
../../library/dataclasses.rst:189
msgid
""
"*kw_only*: If true (the default value is ``False``), then all fields will be "
"marked as keyword-only. If a field is marked as keyword-only, then the only "
"effect is that the :meth:`~object.__init__` parameter generated from a "
"keyword-only field must be specified with a keyword when :meth:`!__init__` "
"is called. See the :term:`parameter` glossary entry for details. Also see "
"the :const:`KW_ONLY` section."
msgstr
""
#:
../../library/dataclasses.rst:197
msgid
"Keyword-only fields are not included in :attr:`!__match_args__`."
msgstr
""
#:
../../library/dataclasses.rst:201
msgid
""
"*slots*: If true (the default is ``False``), :attr:`~object.__slots__` "
"attribute will be generated and new class will be returned instead of the "
"original one. If :attr:`!__slots__` is already defined in the class, then :"
"exc:`TypeError` is raised."
msgstr
""
#:
../../library/dataclasses.rst:207
msgid
""
"Passing parameters to a base class :meth:`~object.__init_subclass__` when "
"using ``slots=True`` will result in a :exc:`TypeError`. Either use "
"``__init_subclass__`` with no parameters or use default values as a "
"workaround. See :gh:`91126` for full details."
msgstr
""
#:
../../library/dataclasses.rst:215
msgid
""
"If a field name is already included in the :attr:`!__slots__` of a base "
"class, it will not be included in the generated :attr:`!__slots__` to "
"prevent :ref:`overriding them <datamodel-note-slots>`. Therefore, do not "
"use :attr:`!__slots__` to retrieve the field names of a dataclass. Use :func:"
"`fields` instead. To be able to determine inherited slots, base class :attr:"
"`!__slots__` may be any iterable, but *not* an iterator."
msgstr
""
#:
../../library/dataclasses.rst:225
msgid
""
"*weakref_slot*: If true (the default is ``False``), add a slot named "
"
\"
__weakref__
\"
, which is required to make an instance :func:`weakref-able "
"<weakref.ref>`. It is an error to specify ``weakref_slot=True`` without also "
"specifying ``slots=True``."
msgstr
""
#:
../../library/dataclasses.rst:233
msgid
""
"``field``
\\
s may optionally specify a default value, using normal Python "
"syntax::"
msgstr
""
#:
../../library/dataclasses.rst:236
msgid
""
"@dataclass\n"
"class C:\n"
" a: int # 'a' has no default value\n"
" b: int = 0 # assign a default value for 'b'"
msgstr
""
#:
../../library/dataclasses.rst:241
msgid
""
"In this example, both :attr:`!a` and :attr:`!b` will be included in the "
"added :meth:`~object.__init__` method, which will be defined as::"
msgstr
""
#:
../../library/dataclasses.rst:244
msgid
"def __init__(self, a: int, b: int = 0):"
msgstr
""
#:
../../library/dataclasses.rst:246
msgid
""
":exc:`TypeError` will be raised if a field without a default value follows a "
"field with a default value. This is true whether this occurs in a single "
"class, or as a result of class inheritance."
msgstr
""
#:
../../library/dataclasses.rst:252
msgid
""
"For common and simple use cases, no other functionality is required. There "
"are, however, some dataclass features that require additional per-field "
"information. To satisfy this need for additional information, you can "
"replace the default field value with a call to the provided :func:`!field` "
"function. For example::"
msgstr
""
#:
../../library/dataclasses.rst:258
msgid
""
"@dataclass\n"
"class C:\n"
" mylist: list[int] = field(default_factory=list)\n"
"\n"
"c = C()\n"
"c.mylist += [1, 2, 3]"
msgstr
""
#:
../../library/dataclasses.rst:265
msgid
""
"As shown above, the :const:`MISSING` value is a :class:`sentinel` object "
"used to detect if some parameters are provided by the user. This sentinel is "
"used because ``None`` is a valid value for some parameters with a distinct "
"meaning. No code should directly use the :const:`MISSING` value."
msgstr
""
#:
../../library/dataclasses.rst:270
msgid
"The parameters to :func:`!field` are:"
msgstr
""
#:
../../library/dataclasses.rst:272
msgid
""
"*default*: If provided, this will be the default value for this field. This "
"is needed because the :func:`!field` call itself replaces the normal "
"position of the default value."
msgstr
""
#:
../../library/dataclasses.rst:276
msgid
""
"*default_factory*: If provided, it must be a zero-argument callable that "
"will be called when a default value is needed for this field. Among other "
"purposes, this can be used to specify fields with mutable default values, as "
"discussed below. It is an error to specify both *default* and "
"*default_factory*."
msgstr
""
#:
../../library/dataclasses.rst:282
msgid
""
"*init*: If true (the default), this field is included as a parameter to the "
"generated :meth:`~object.__init__` method."
msgstr
""
#:
../../library/dataclasses.rst:285
msgid
""
"*repr*: If true (the default), this field is included in the string returned "
"by the generated :meth:`~object.__repr__` method."
msgstr
""
#:
../../library/dataclasses.rst:288
msgid
""
"*hash*: This can be a bool or ``None``. If true, this field is included in "
"the generated :meth:`~object.__hash__` method. If false, this field is "
"excluded from the generated :meth:`~object.__hash__`. If ``None`` (the "
"default), use the value of *compare*: this would normally be the expected "
"behavior, since a field should be included in the hash if it's used for "
"comparisons. Setting this value to anything other than ``None`` is "
"discouraged."
msgstr
""
#:
../../library/dataclasses.rst:296
msgid
""
"One possible reason to set ``hash=False`` but ``compare=True`` would be if a "
"field is expensive to compute a hash value for, that field is needed for "
"equality testing, and there are other fields that contribute to the type's "
"hash value. Even if a field is excluded from the hash, it will still be "
"used for comparisons."
msgstr
""
#:
../../library/dataclasses.rst:302
msgid
""
"*compare*: If true (the default), this field is included in the generated "
"equality and comparison methods (:meth:`~object.__eq__`, :meth:`~object."
"__gt__`, et al.)."
msgstr
""
#:
../../library/dataclasses.rst:306
msgid
""
"*metadata*: This can be a mapping or ``None``. ``None`` is treated as an "
"empty dict. This value is wrapped in :func:`~types.MappingProxyType` to "
"make it read-only, and exposed on the :class:`Field` object. It is not used "
"at all by Data Classes, and is provided as a third-party extension "
"mechanism. Multiple third-parties can each have their own key, to use as a "
"namespace in the metadata."
msgstr
""
#:
../../library/dataclasses.rst:314
msgid
""
"*kw_only*: If true, this field will be marked as keyword-only. This is used "
"when the generated :meth:`~object.__init__` method's parameters are computed."
msgstr
""
#:
../../library/dataclasses.rst:318
msgid
"Keyword-only fields are also not included in :attr:`!__match_args__`."
msgstr
""
#:
../../library/dataclasses.rst:322
msgid
"*doc*: optional docstring for this field."
msgstr
""
#:
../../library/dataclasses.rst:326
msgid
""
"If the default value of a field is specified by a call to :func:`!field`, "
"then the class attribute for this field will be replaced by the specified "
"*default* value. If *default* is not provided, then the class attribute "
"will be deleted. The intent is that after the :deco:`dataclass` decorator "
"runs, the class attributes will all contain the default values for the "
"fields, just as if the default value itself were specified. For example, "
"after::"
msgstr
""
#:
../../library/dataclasses.rst:335
msgid
""
"@dataclass\n"
"class C:\n"
" x: int\n"
" y: int = field(repr=False)\n"
" z: int = field(repr=False, default=10)\n"
" t: int = 20"
msgstr
""
#:
../../library/dataclasses.rst:342
msgid
""
"The class attribute :attr:`!C.z` will be ``10``, the class attribute :attr:`!"
"C.t` will be ``20``, and the class attributes :attr:`!C.x` and :attr:`!C.y` "
"will not be set."
msgstr
""
#:
../../library/dataclasses.rst:346
msgid
""
"If *metadata* is ``None``, use an empty :class:`frozendict`, instead of a :"
"func:`~types.MappingProxyType` of an empty :class:`dict`."
msgstr
""
#:
../../library/dataclasses.rst:352
msgid
""
":class:`!Field` objects describe each defined field. These objects are "
"created internally, and are returned by the :func:`fields` module-level "
"method (see below). Users should never instantiate a :class:`!Field` object "
"directly. Its documented attributes are:"
msgstr
""
#:
../../library/dataclasses.rst:357
msgid
":attr:`!name`: The name of the field."
msgstr
""
#:
../../library/dataclasses.rst:358
msgid
":attr:`!type`: The type of the field."
msgstr
""
#:
../../library/dataclasses.rst:359
msgid
""
":attr:`!default`, :attr:`!default_factory`, :attr:`!init`, :attr:`!repr`, :"
"attr:`!hash`, :attr:`!compare`, :attr:`!metadata`, and :attr:`!kw_only` have "
"the identical meaning and values as they do in the :func:`field` function."
msgstr
""
#:
../../library/dataclasses.rst:363
msgid
""
"Other attributes may exist, but they are private and must not be inspected "
"or relied on."
msgstr
""
#:
../../library/dataclasses.rst:368
msgid
""
"``InitVar[T]`` type annotations describe variables that are :ref:`init-only "
"<dataclasses-init-only-variables>`. Fields annotated with :class:`!InitVar` "
"are considered pseudo-fields, and thus are neither returned by the :func:"
"`fields` function nor used in any way except adding them as parameters to :"
"meth:`~object.__init__` and an optional :meth:`__post_init__`."
msgstr
""
#:
../../library/dataclasses.rst:377
msgid
""
"Returns a tuple of :class:`Field` objects that define the fields for this "
"dataclass. Accepts either a dataclass, or an instance of a dataclass. "
"Raises :exc:`TypeError` if not passed a dataclass or instance of one. Does "
"not return pseudo-fields which are ``ClassVar`` or ``InitVar``."
msgstr
""
#:
../../library/dataclasses.rst:384
msgid
""
"Converts the dataclass *obj* to a dict (by using the factory function "
"*dict_factory*). Each dataclass is converted to a dict of its fields, as "
"``name: value`` pairs. dataclasses, dicts, frozendicts, lists, and tuples "
"are recursed into. Other objects are copied with :func:`copy.deepcopy`."
msgstr
""
#:
../../library/dataclasses.rst:390
msgid
"Example of using :func:`!asdict` on nested dataclasses::"
msgstr
""
#:
../../library/dataclasses.rst:392
msgid
""
"@dataclass\n"
"class Point:\n"
" x: int\n"
" y: int\n"
"\n"
"@dataclass\n"
"class C:\n"
" mylist: list[Point]\n"
"\n"
"p = Point(10, 20)\n"
"assert asdict(p) == {'x': 10, 'y': 20}\n"
"\n"
"c = C([Point(0, 0), Point(10, 4)])\n"
"assert asdict(c) == {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}"
msgstr
""
#:
../../library/dataclasses.rst:407
../../library/dataclasses.rst:427
msgid
"To create a shallow copy, the following workaround may be used::"
msgstr
""
#:
../../library/dataclasses.rst:409
msgid
"{field.name: getattr(obj, field.name) for field in fields(obj)}"
msgstr
""
#:
../../library/dataclasses.rst:411
msgid
""
":func:`!asdict` raises :exc:`TypeError` if *obj* is not a dataclass instance."
msgstr
""
#:
../../library/dataclasses.rst:416
msgid
""
"Converts the dataclass *obj* to a tuple (by using the factory function "
"*tuple_factory*). Each dataclass is converted to a tuple of its field "
"values. dataclasses, dicts, frozendicts, lists, and tuples are recursed "
"into. Other objects are copied with :func:`copy.deepcopy`."
msgstr
""
#:
../../library/dataclasses.rst:422
msgid
"Continuing from the previous example::"
msgstr
""
#:
../../library/dataclasses.rst:424
msgid
""
"assert astuple(p) == (10, 20)\n"
"assert astuple(c) == ([(0, 0), (10, 4)],)"
msgstr
""
#:
../../library/dataclasses.rst:429
msgid
"tuple(getattr(obj, field.name) for field in dataclasses.fields(obj))"
msgstr
""
#:
../../library/dataclasses.rst:431
msgid
""
":func:`!astuple` raises :exc:`TypeError` if *obj* is not a dataclass "
"instance."
msgstr
""
#:
../../library/dataclasses.rst:436
msgid
""
"Creates a new dataclass with name *cls_name*, fields as defined in *fields*, "
"base classes as given in *bases*, and initialized with a namespace as given "
"in *namespace*. *fields* is an iterable whose elements are each either "
"``name``, ``(name, type)``, or ``(name, type, Field)``. If just ``name`` is "
"supplied, :data:`typing.Any` is used for ``type``. The values of *init*, "
"*repr*, *eq*, *order*, *unsafe_hash*, *frozen*, *match_args*, *kw_only*, "
"*slots*, and *weakref_slot* have the same meaning as they do in :deco:"
"`dataclass`."
msgstr
""
#:
../../library/dataclasses.rst:446
msgid
""
"If *module* is defined, the :attr:`!__module__` attribute of the dataclass "
"is set to that value. By default, it is set to the module name of the caller."
msgstr
""
#:
../../library/dataclasses.rst:450
msgid
""
"The *decorator* parameter is a callable that will be used to create the "
"dataclass. It should take the class object as a first argument and the same "
"keyword arguments as :deco:`dataclass`. By default, the :deco:`dataclass` "
"function is used."
msgstr
""
#:
../../library/dataclasses.rst:455
msgid
""
"This function is not strictly required, because any Python mechanism for "
"creating a new class with :attr:`~object.__annotations__` can then apply "
"the :deco:`dataclass` function to convert that class to a dataclass. This "
"function is provided as a convenience. For example::"
msgstr
""
#:
../../library/dataclasses.rst:461
msgid
""
"C = make_dataclass('C',\n"
" [('x', int),\n"
" 'y',\n"
" ('z', int, field(default=5))],\n"
" namespace={'add_one': lambda self: self.x + 1})"
msgstr
""
#:
../../library/dataclasses.rst:467
msgid
"Is equivalent to::"
msgstr
""
#:
../../library/dataclasses.rst:469
msgid
""
"@dataclass\n"
"class C:\n"
" x: int\n"
" y: 'typing.Any'\n"
" z: int = 5\n"
"\n"
" def add_one(self):\n"
" return self.x + 1"
msgstr
""
#:
../../library/dataclasses.rst:478
msgid
"Added the *decorator* parameter."
msgstr
""
#:
../../library/dataclasses.rst:483
msgid
""
"Creates a new object of the same type as *obj*, replacing fields with values "
"from *changes*. If *obj* is not a Data Class, raises :exc:`TypeError`. If "
"keys in *changes* are not field names of the given dataclass, raises :exc:"
"`TypeError`."
msgstr
""
#:
../../library/dataclasses.rst:488
msgid
""
"The newly returned object is created by calling the :meth:`~object.__init__` "
"method of the dataclass. This ensures that :meth:`__post_init__`, if "
"present, is also called."
msgstr
""
#:
../../library/dataclasses.rst:492
msgid
""
"Init-only variables without default values, if any exist, must be specified "
"on the call to :func:`!replace` so that they can be passed to :meth:`!"
"__init__` and :meth:`__post_init__`."
msgstr
""
#:
../../library/dataclasses.rst:496
msgid
""
"It is an error for *changes* to contain any fields that are defined as "
"having ``init=False``. A :exc:`ValueError` will be raised in this case."
msgstr
""
#:
../../library/dataclasses.rst:500
msgid
""
"Be forewarned about how ``init=False`` fields work during a call to :func:`!"
"replace`. They are not copied from the source object, but rather are "
"initialized in :meth:`__post_init__`, if they're initialized at all. It is "
"expected that ``init=False`` fields will be rarely and judiciously used. If "
"they are used, it might be wise to have alternate class constructors, or "
"perhaps a custom :func:`!replace` (or similarly named) method which handles "
"instance copying."
msgstr
""
#:
../../library/dataclasses.rst:509
msgid
""
"Dataclass instances are also supported by generic function :func:`copy."
"replace`."
msgstr
""
#:
../../library/dataclasses.rst:513
msgid
""
"Return ``True`` if its parameter is a dataclass (including subclasses of a "
"dataclass, but not including :ref:`generic aliases <types-genericalias>`) or "
"an instance of one, otherwise return ``False``."
msgstr
""
#:
../../library/dataclasses.rst:517
msgid
""
"If you need to know if a class is an instance of a dataclass (and not a "
"dataclass itself), then add a further check for ``not isinstance(obj, "
"type)``::"
msgstr
""
#:
../../library/dataclasses.rst:521
msgid
""
"def is_dataclass_instance(obj):\n"
" return is_dataclass(obj) and not isinstance(obj, type)"
msgstr
""
#:
../../library/dataclasses.rst:526
msgid
""
"A :class:`sentinel` object signifying a missing default or *default_factory*."
msgstr
""
#:
../../library/dataclasses.rst:528
msgid
":const:`!MISSING` is now a :class:`sentinel` object."
msgstr
""
#:
../../library/dataclasses.rst:533
msgid
""
"A :class:`sentinel` object used as a type annotation. Any fields after a "
"pseudo-field with the type of :const:`!KW_ONLY` are marked as keyword-only "
"fields. Note that a pseudo-field of type :const:`!KW_ONLY` is otherwise "
"completely ignored. This includes the name of such a field. By convention, "
"a name of ``_`` is used for a :const:`!KW_ONLY` field. Keyword-only fields "
"signify :meth:`~object.__init__` parameters that must be specified as "
"keywords when the class is instantiated."
msgstr
""
#:
../../library/dataclasses.rst:542
msgid
""
"In this example, the fields ``y`` and ``z`` will be marked as keyword-only "
"fields::"
msgstr
""
#:
../../library/dataclasses.rst:544
msgid
""
"@dataclass\n"
"class Point:\n"
" x: float\n"
" _: KW_ONLY\n"
" y: float\n"
" z: float\n"
"\n"
"p = Point(0, y=1.5, z=2.0)"
msgstr
""
#:
../../library/dataclasses.rst:553
msgid
""
"In a single dataclass, it is an error to specify more than one field whose "
"type is :const:`!KW_ONLY`."
msgstr
""
#:
../../library/dataclasses.rst:558
msgid
":const:`!KW_ONLY` is now a :class:`sentinel` object."
msgstr
""
#:
../../library/dataclasses.rst:563
msgid
""
"Raised when an implicitly defined :meth:`~object.__setattr__` or :meth:"
"`~object.__delattr__` is called on a dataclass which was defined with "
"``frozen=True``. It is a subclass of :exc:`AttributeError`."
msgstr
""
#:
../../library/dataclasses.rst:570
msgid
"Post-init processing"
msgstr
""
#:
../../library/dataclasses.rst:574
msgid
""
"When defined on the class, it will be called by the generated :meth:`~object."
"__init__`, normally as :meth:`!self.__post_init__`. However, if any "
"``InitVar`` fields are defined, they will also be passed to :meth:`!"
"__post_init__` in the order they were defined in the class. If no :meth:`!"
"__init__` method is generated, then :meth:`!__post_init__` will not "
"automatically be called."
msgstr
""
#:
../../library/dataclasses.rst:581
msgid
""
"Among other uses, this allows for initializing field values that depend on "
"one or more other fields. For example::"
msgstr
""
#:
../../library/dataclasses.rst:584
msgid
""
"@dataclass\n"
"class C:\n"
" a: float\n"
" b: float\n"
" c: float = field(init=False)\n"
"\n"
" def __post_init__(self):\n"
" self.c = self.a + self.b"
msgstr
""
#:
../../library/dataclasses.rst:593
msgid
""
"The :meth:`~object.__init__` method generated by :deco:`dataclass` does not "
"call base class :meth:`!__init__` methods. If the base class has an :meth:`!"
"__init__` method that has to be called, it is common to call this method in "
"a :meth:`__post_init__` method::"
msgstr
""
#:
../../library/dataclasses.rst:598
msgid
""
"class Rectangle:\n"
" def __init__(self, height, width):\n"
" self.height = height\n"
" self.width = width\n"
"\n"
"@dataclass\n"
"class Square(Rectangle):\n"
" side: float\n"
"\n"
" def __post_init__(self):\n"
" super().__init__(self.side, self.side)"
msgstr
""
#:
../../library/dataclasses.rst:610
msgid
""
"Note, however, that in general the dataclass-generated :meth:`!__init__` "
"methods don't need to be called, since the derived dataclass will take care "
"of initializing all fields of any base class that is a dataclass itself."
msgstr
""
#:
../../library/dataclasses.rst:614
msgid
""
"See the section below on init-only variables for ways to pass parameters to :"
"meth:`!__post_init__`. Also see the warning about how :func:`replace` "
"handles ``init=False`` fields."
msgstr
""
#:
../../library/dataclasses.rst:621
msgid
"Class variables"
msgstr
""
#:
../../library/dataclasses.rst:623
msgid
""
"One of the few places where :deco:`dataclass` actually inspects the type of "
"a field is to determine if a field is a class variable as defined in :pep:"
"`526`. It does this by checking if the type of the field is :data:`typing."
"ClassVar`. If a field is a ``ClassVar``, it is excluded from consideration "
"as a field and is ignored by the dataclass mechanisms. Such ``ClassVar`` "
"pseudo-fields are not returned by the module-level :func:`fields` function."
msgstr
""
#:
../../library/dataclasses.rst:634
msgid
"Init-only variables"
msgstr
""
#:
../../library/dataclasses.rst:636
msgid
""
"Another place where :deco:`dataclass` inspects a type annotation is to "
"determine if a field is an init-only variable. It does this by seeing if "
"the type of a field is of type :class:`InitVar`. If a field is an :class:"
"`InitVar`, it is considered a pseudo-field called an init-only field. As it "
"is not a true field, it is not returned by the module-level :func:`fields` "
"function. Init-only fields are added as parameters to the generated :meth:"
"`~object.__init__` method, and are passed to the optional :meth:"
"`__post_init__` method. They are not otherwise used by dataclasses."
msgstr
""
#:
../../library/dataclasses.rst:646
msgid
""
"For example, suppose a field will be initialized from a database, if a value "
"is not provided when creating the class::"
msgstr
""
#:
../../library/dataclasses.rst:649
msgid
""
"@dataclass\n"
"class C:\n"
" i: int\n"
" j: int | None = None\n"
" database: InitVar[DatabaseType | None] = None\n"
"\n"
" def __post_init__(self, database):\n"
" if self.j is None and database is not None:\n"
" self.j = database.lookup('j')\n"
"\n"
"c = C(10, database=my_database)"
msgstr
""
#:
../../library/dataclasses.rst:661
msgid
""
"In this case, :func:`fields` will return :class:`Field` objects for :attr:`!"
"i` and :attr:`!j`, but not for :attr:`!database`."
msgstr
""
#:
../../library/dataclasses.rst:667
msgid
"Frozen instances"
msgstr
""
#:
../../library/dataclasses.rst:669
msgid
""
"It is not possible to create truly immutable Python objects. However, by "
"passing ``frozen=True`` to the :deco:`dataclass` decorator you can emulate "
"immutability. In that case, dataclasses will add :meth:`~object."
"__setattr__` and :meth:`~object.__delattr__` methods to the class. These "
"methods will raise a :exc:`FrozenInstanceError` when invoked."
msgstr
""
#:
../../library/dataclasses.rst:675
msgid
""
"There is a tiny performance penalty when using ``frozen=True``: :meth:"
"`~object.__init__` cannot use simple assignment to initialize fields, and "
"must use :meth:`!object.__setattr__`."
msgstr
""
#:
../../library/dataclasses.rst:684
msgid
"Inheritance"
msgstr
"Vererbung"
#:
../../library/dataclasses.rst:686
msgid
""
"When the dataclass is being created by the :deco:`dataclass` decorator, it "
"looks through all of the class's base classes in reverse MRO (that is, "
"starting at :class:`object`) and, for each dataclass that it finds, adds the "
"fields from that base class to an ordered mapping of fields. After all of "
"the base class fields are added, it adds its own fields to the ordered "
"mapping. All of the generated methods will use this combined, calculated "
"ordered mapping of fields. Because the fields are in insertion order, "
"derived classes override base classes. An example::"
msgstr
""
#:
../../library/dataclasses.rst:696
msgid
""
"@dataclass\n"
"class Base:\n"
" x: Any = 15.0\n"
" y: int = 0\n"
"\n"
"@dataclass\n"
"class C(Base):\n"
" z: int = 10\n"
" x: int = 15"
msgstr
""
#:
../../library/dataclasses.rst:706
msgid
""
"The final list of fields is, in order, :attr:`!x`, :attr:`!y`, :attr:`!z`. "
"The final type of :attr:`!x` is :class:`int`, as specified in class :class:`!"
"C`."
msgstr
""
#:
../../library/dataclasses.rst:709
msgid
""
View remainder of file in raw view
Back
|
FazBrowse Home
|
New Git URL