{{ message }}
-
Notifications
You must be signed in to change notification settings - Fork 4
Expand file tree
/
Copy pathdataclasses.po
More file actions
1096 lines (931 loc) · 35.5 KB
/
Copy pathdataclasses.po
File metadata and controls
1096 lines (931 loc) · 35.5 KB
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.
#
# Translators:
# python-doc bot, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-05 16:26+0000\n"
"PO-Revision-Date: 2025-09-16 00:01+0000\n"
"Last-Translator: python-doc bot, 2025\n"
"Language-Team: Russian (https://app.transifex.com/python-doc/teams/5390/"
"ru/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ru\n"
"Plural-Forms: nplurals=4; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && "
"n%10<=4 && (n%100<12 || n%100>14) ? 1 : n%10==0 || (n%10>=5 && n%10<=9) || "
"(n%100>=11 && n%100<=14)? 2 : 3);\n"
msgid ":mod:`!dataclasses` --- Data Classes"
msgstr ""
msgid "**Source code:** :source:`Lib/dataclasses.py`"
msgstr ""
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 ""
msgid ""
"The member variables to use in these generated methods are defined using :"
"pep:`526` type annotations. For example, this code::"
msgstr ""
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 ""
msgid "will add, among other things, a :meth:`!__init__` that looks like::"
msgstr ""
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 ""
msgid ""
"Note that this method is automatically added to the class: it is not "
"directly specified in the :class:`!InventoryItem` definition shown above."
msgstr ""
msgid "Module contents"
msgstr ""
msgid ""
"This function is a :term:`decorator` that is used to add generated :term:"
"`special methods <special method>` to classes, as described below."
msgstr ""
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 ""
msgid ""
"The order of the fields in all of the generated methods is the order in "
"which they appear in the class definition."
msgstr ""
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 ""
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 ""
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 ""
msgid "The parameters to ``@dataclass`` are:"
msgstr ""
msgid ""
"*init*: If true (the default), a :meth:`~object.__init__` method will be "
"generated."
msgstr ""
msgid ""
"If the class already defines :meth:`!__init__`, this parameter is ignored."
msgstr ""
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 ""
msgid ""
"If the class already defines :meth:`!__repr__`, this parameter is ignored."
msgstr ""
msgid ""
"*eq*: If true (the default), an :meth:`~object.__eq__` method will be "
"generated."
msgstr ""
msgid ""
"This method compares the class by comparing each field in order. Both "
"instances in the comparison must be of the identical type."
msgstr ""
msgid ""
"If the class already defines :meth:`!__eq__`, this parameter is ignored."
msgstr ""
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 ""
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 ""
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 ""
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 ""
msgid ""
"If the class already defines any of :meth:`!__lt__`, :meth:`!__le__`, :meth:"
"`!__gt__`, or :meth:`!__ge__`, then :exc:`TypeError` is raised."
msgstr ""
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 ""
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 ""
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 ""
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 ""
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 ""
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 ""
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 ""
msgid ""
"If :meth:`~object.__setattr__` or :meth:`~object.__delattr__` is defined in "
"the class and *frozen* is true, then :exc:`TypeError` is raised."
msgstr ""
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 ""
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 ""
msgid "Keyword-only fields are not included in :attr:`!__match_args__`."
msgstr ""
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 ""
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 ""
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 ""
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 ""
msgid ""
"``field``\\s may optionally specify a default value, using normal Python "
"syntax::"
msgstr ""
msgid ""
"@dataclass\n"
"class C:\n"
" a: int # 'a' has no default value\n"
" b: int = 0 # assign a default value for 'b'"
msgstr ""
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 ""
msgid "def __init__(self, a: int, b: int = 0):"
msgstr ""
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 ""
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 ""
msgid ""
"@dataclass\n"
"class C:\n"
" mylist: list[int] = field(default_factory=list)\n"
"\n"
"c = C()\n"
"c.mylist += [1, 2, 3]"
msgstr ""
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 ""
msgid "The parameters to :func:`!field` are:"
msgstr ""
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 ""
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 ""
msgid ""
"*init*: If true (the default), this field is included as a parameter to the "
"generated :meth:`~object.__init__` method."
msgstr ""
msgid ""
"*repr*: If true (the default), this field is included in the string returned "
"by the generated :meth:`~object.__repr__` method."
msgstr ""
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 ""
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 ""
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 ""
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 ""
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 ""
msgid "Keyword-only fields are also not included in :attr:`!__match_args__`."
msgstr ""
msgid "*doc*: optional docstring for this field."
msgstr ""
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 ""
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 ""
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 ""
msgid ""
"If *metadata* is ``None``, use an empty :class:`frozendict`, instead of a :"
"func:`~types.MappingProxyType` of an empty :class:`dict`."
msgstr ""
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 ""
msgid ":attr:`!name`: The name of the field."
msgstr ""
msgid ":attr:`!type`: The type of the field."
msgstr ""
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 ""
msgid ""
"Other attributes may exist, but they are private and must not be inspected "
"or relied on."
msgstr ""
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 ""
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 ""
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 ""
msgid "Example of using :func:`!asdict` on nested dataclasses::"
msgstr ""
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 ""
msgid "To create a shallow copy, the following workaround may be used::"
msgstr ""
msgid "{field.name: getattr(obj, field.name) for field in fields(obj)}"
msgstr ""
msgid ""
":func:`!asdict` raises :exc:`TypeError` if *obj* is not a dataclass instance."
msgstr ""
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 ""
msgid "Continuing from the previous example::"
msgstr ""
msgid ""
"assert astuple(p) == (10, 20)\n"
"assert astuple(c) == ([(0, 0), (10, 4)],)"
msgstr ""
msgid "tuple(getattr(obj, field.name) for field in dataclasses.fields(obj))"
msgstr ""
msgid ""
":func:`!astuple` raises :exc:`TypeError` if *obj* is not a dataclass "
"instance."
msgstr ""
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 ""
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 ""
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 ""
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 ""
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 ""
msgid "Is equivalent to::"
msgstr ""
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 ""
msgid "Added the *decorator* parameter."
msgstr ""
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 ""
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 ""
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 ""
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 ""
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 ""
msgid ""
"Dataclass instances are also supported by generic function :func:`copy."
"replace`."
msgstr ""
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 ""
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 ""
msgid ""
"def is_dataclass_instance(obj):\n"
" return is_dataclass(obj) and not isinstance(obj, type)"
msgstr ""
msgid ""
"A :class:`sentinel` object signifying a missing default or *default_factory*."
msgstr ""
msgid ":const:`!MISSING` is now a :class:`sentinel` object."
msgstr ""
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 ""
msgid ""
"In this example, the fields ``y`` and ``z`` will be marked as keyword-only "
"fields::"
msgstr ""
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 ""
msgid ""
"In a single dataclass, it is an error to specify more than one field whose "
"type is :const:`!KW_ONLY`."
msgstr ""
msgid ":const:`!KW_ONLY` is now a :class:`sentinel` object."
msgstr ""
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 ""
msgid "Post-init processing"
msgstr ""
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 ""
msgid ""
"Among other uses, this allows for initializing field values that depend on "
"one or more other fields. For example::"
msgstr ""
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 ""
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 ""
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 ""
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 ""
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 ""
msgid "Class variables"
msgstr ""
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 ""
msgid "Init-only variables"
msgstr ""
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 ""
msgid ""
"For example, suppose a field will be initialized from a database, if a value "
"is not provided when creating the class::"
msgstr ""
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 ""
msgid ""
"In this case, :func:`fields` will return :class:`Field` objects for :attr:`!"
"i` and :attr:`!j`, but not for :attr:`!database`."
msgstr ""
msgid "Frozen instances"
msgstr ""
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 ""
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 ""
msgid "Inheritance"
msgstr ""
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 ""
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 ""
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 ""
msgid ""
"The generated :meth:`~object.__init__` method for :class:`!C` will look "
"like::"
msgstr ""
msgid "def __init__(self, x: int = 15, y: int = 0, z: int = 10):"
msgstr ""
msgid "Re-ordering of keyword-only parameters in :meth:`!__init__`"
msgstr ""
msgid ""
"After the parameters needed for :meth:`~object.__init__` are computed, any "
"keyword-only parameters are moved to come after all regular (non-keyword-"
"only) parameters. This is a requirement of how keyword-only parameters are "
"implemented in Python: they must come after non-keyword-only parameters."
msgstr ""
msgid ""
"In this example, :attr:`!Base.y`, :attr:`!Base.w`, and :attr:`!D.t` are "
"keyword-only fields, and :attr:`!Base.x` and :attr:`!D.z` are regular "
"fields::"
msgstr ""
msgid ""
"@dataclass\n"
"class Base:\n"
" x: Any = 15.0\n"
" _: KW_ONLY\n"
" y: int = 0\n"
" w: int = 1\n"
"\n"
"@dataclass\n"
"class D(Base):\n"
" z: int = 10\n"
" t: int = field(kw_only=True, default=0)"
msgstr ""
msgid "The generated :meth:`!__init__` method for :class:`!D` will look like::"
msgstr ""
msgid ""
"def __init__(self, x: Any = 15.0, z: int = 10, *, y: int = 0, w: int = 1, t: "
"int = 0):"
msgstr ""
msgid ""
"Note that the parameters have been re-ordered from how they appear in the "
"list of fields: parameters derived from regular fields are followed by "
"parameters derived from keyword-only fields."
msgstr ""
msgid ""
"The relative ordering of keyword-only parameters is maintained in the re-"
"ordered :meth:`!__init__` parameter list."
msgstr ""
msgid "Default factory functions"
msgstr ""
msgid ""
"If a :func:`field` specifies a *default_factory*, it is called with zero "
"arguments when a default value for the field is needed. For example, to "
"create a new instance of a list, use::"
msgstr ""
msgid "mylist: list = field(default_factory=list)"
msgstr ""
msgid ""
"If a field is excluded from :meth:`~object.__init__` (using ``init=False``) "
"and the field also specifies *default_factory*, then the default factory "
"function will always be called from the generated :meth:`!__init__` "
"function. This happens because there is no other way to give the field an "
"initial value."
msgstr ""
msgid "Mutable default values"
msgstr ""
msgid ""
"Python stores default member variable values in class attributes. Consider "
"this example, not using dataclasses::"
msgstr ""
msgid ""
"class C:\n"
" x = []\n"
" def add(self, element):\n"
" self.x.append(element)\n"
"\n"
"o1 = C()\n"
"o2 = C()\n"
"o1.add(1)\n"
"o2.add(2)\n"
"assert o1.x == [1, 2]\n"
"assert o1.x is o2.x"
msgstr ""
msgid ""
"Note that the two instances of class :class:`!C` share the same class "
"variable :attr:`!x`, as expected."
msgstr ""
msgid "Using dataclasses, *if* this code was valid::"
msgstr ""
msgid ""
"@dataclass\n"
"class D:\n"
" x: list = [] # This code raises ValueError\n"
" def add(self, element):\n"
" self.x.append(element)"
msgstr ""
msgid "it would generate code similar to::"
msgstr ""
msgid ""
"class D:\n"
" x = []\n"
" def __init__(self, x=x):\n"
" self.x = x\n"
" def add(self, element):\n"
" self.x.append(element)\n"
"\n"
You can’t perform that action at this time.