Spaces:
Running on Zero
Running on Zero
File size: 112,062 Bytes
9273228 | 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 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 | # What\'s New In Python 3.8
> \* Anyone can add text to this document. Do not spend very much time on the wording of your changes, because your text will probably get rewritten to some degree.
>
> \* The maintainer will go through Misc/NEWS periodically and add changes; it\'s therefore more important to add your changes to Misc/NEWS than to this file.
>
> \* This is not a complete list of every single change; completeness is the purpose of Misc/NEWS. Some changes I consider too small or esoteric to include. If such a change is added to the text, I\'ll just remove it. (This is another reason you shouldn\'t spend too much time on writing your addition.)
>
> \* If you want to draw your new text to the attention of the maintainer, add \'XXX\' to the beginning of the paragraph or section.
>
> \* It\'s OK to just add a fragmentary note about a change. For example: \"XXX Describe the transmogrify() function added to the socket module.\" The maintainer will research the change and write the necessary text.
>
> \* You can comment out your additions if you like, but it\'s not necessary (especially when a final release is some months away).
>
> \* Credit the author of a patch or bugfix. Just the name is sufficient; the e-mail address isn\'t necessary.
>
> - It\'s helpful to add the bug/patch number as a comment:
>
> XXX Describe the transmogrify() function added to the socket module. (Contributed by P.Y. Developer in `12345`{.interpreted-text role="issue"}.)
>
> This saves the maintainer the effort of going through the Git log when researching a change.
Editor
: Raymond Hettinger
This article explains the new features in Python 3.8, compared to 3.7. Python 3.8 was released on October 14, 2019. For full details, see the `changelog <changelog>`{.interpreted-text role="ref"}.
::: testsetup
from datetime import date from math import cos, radians from unicodedata import normalize import re import math
:::
## Summary \-- Release highlights
## New Features
### Assignment expressions
There is new syntax `:=` that assigns values to variables as part of a larger expression. It is affectionately known as \"the walrus operator\" due to its resemblance to [the eyes and tusks of a walrus](https://en.wikipedia.org/wiki/Walrus#/media/File:Pacific_Walrus_-_Bull_(8247646168).jpg).
In this example, the assignment expression helps avoid calling `len`{.interpreted-text role="func"} twice:
if (n := len(a)) > 10:
print(f"List is too long ({n} elements, expected <= 10)")
A similar benefit arises during regular expression matching where match objects are needed twice, once to test whether a match occurred and another to extract a subgroup:
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
discount = float(mo.group(1)) / 100.0
The operator is also useful with while-loops that compute a value to test loop termination and then need that same value again in the body of the loop:
# Loop over fixed length blocks
while (block := f.read(256)) != '':
process(block)
Another motivating use case arises in list comprehensions where a value computed in a filtering condition is also needed in the expression body:
[clean_name.title() for name in names
if (clean_name := normalize('NFC', name)) in allowed_names]
Try to limit use of the walrus operator to clean cases that reduce complexity and improve readability.
See `572`{.interpreted-text role="pep"} for a full description.
(Contributed by Emily Morehouse in `35224`{.interpreted-text role="issue"}.)
### Positional-only parameters
There is a new function parameter syntax `/` to indicate that some function parameters must be specified positionally and cannot be used as keyword arguments. This is the same notation shown by `help()` for C functions annotated with Larry Hastings\' [Argument Clinic](https://devguide.python.org/development-tools/clinic/) tool.
In the following example, parameters *a* and *b* are positional-only, while *c* or *d* can be positional or keyword, and *e* or *f* are required to be keywords:
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
The following is a valid call:
f(10, 20, 30, d=40, e=50, f=60)
However, these are invalid calls:
f(10, b=20, c=30, d=40, e=50, f=60) # b cannot be a keyword argument
f(10, 20, 30, 40, 50, f=60) # e must be a keyword argument
One use case for this notation is that it allows pure Python functions to fully emulate behaviors of existing C coded functions. For example, the built-in `divmod`{.interpreted-text role="func"} function does not accept keyword arguments:
def divmod(a, b, /):
"Emulate the built in divmod() function"
return (a // b, a % b)
Another use case is to preclude keyword arguments when the parameter name is not helpful. For example, the builtin `len`{.interpreted-text role="func"} function has the signature `len(obj, /)`. This precludes awkward calls such as:
len(obj='hello') # The "obj" keyword argument impairs readability
A further benefit of marking a parameter as positional-only is that it allows the parameter name to be changed in the future without risk of breaking client code. For example, in the `statistics`{.interpreted-text role="mod"} module, the parameter name *dist* may be changed in the future. This was made possible with the following function specification:
def quantiles(dist, /, *, n=4, method='exclusive')
...
Since the parameters to the left of `/` are not exposed as possible keywords, the parameters names remain available for use in `**kwargs`:
>>> def f(a, b, /, **kwargs):
... print(a, b, kwargs)
...
>>> f(10, 20, a=1, b=2, c=3) # a and b are used in two ways
10 20 {'a': 1, 'b': 2, 'c': 3}
This greatly simplifies the implementation of functions and methods that need to accept arbitrary keyword arguments. For example, here is an excerpt from code in the `collections`{.interpreted-text role="mod"} module:
class Counter(dict):
def __init__(self, iterable=None, /, **kwds):
# Note "iterable" is a possible keyword argument
See `570`{.interpreted-text role="pep"} for a full description.
(Contributed by Pablo Galindo in `36540`{.interpreted-text role="issue"}.)
### Parallel filesystem cache for compiled bytecode files
The new `PYTHONPYCACHEPREFIX`{.interpreted-text role="envvar"} setting (also available as `-X`{.interpreted-text role="option"} `pycache_prefix`) configures the implicit bytecode cache to use a separate parallel filesystem tree, rather than the default `__pycache__` subdirectories within each source directory.
The location of the cache is reported in `sys.pycache_prefix`{.interpreted-text role="data"} (`None`{.interpreted-text role="const"} indicates the default location in `__pycache__` subdirectories).
(Contributed by Carl Meyer in `33499`{.interpreted-text role="issue"}.)
### Debug build uses the same ABI as release build
Python now uses the same ABI whether it\'s built in release or debug mode. On Unix, when Python is built in debug mode, it is now possible to load C extensions built in release mode and C extensions built using the stable ABI.
Release builds and `debug builds <debug-build>`{.interpreted-text role="ref"} are now ABI compatible: defining the `Py_DEBUG` macro no longer implies the `Py_TRACE_REFS` macro, which introduces the only ABI incompatibility. The `Py_TRACE_REFS` macro, which adds the `sys.getobjects`{.interpreted-text role="func"} function and the `PYTHONDUMPREFS`{.interpreted-text role="envvar"} environment variable, can be set using the new `./configure
--with-trace-refs <--with-trace-refs>`{.interpreted-text role="option"} build option. (Contributed by Victor Stinner in `36465`{.interpreted-text role="issue"}.)
On Unix, C extensions are no longer linked to libpython except on Android and Cygwin. It is now possible for a statically linked Python to load a C extension built using a shared library Python. (Contributed by Victor Stinner in `21536`{.interpreted-text role="issue"}.)
On Unix, when Python is built in debug mode, import now also looks for C extensions compiled in release mode and for C extensions compiled with the stable ABI. (Contributed by Victor Stinner in `36722`{.interpreted-text role="issue"}.)
To embed Python into an application, a new `--embed` option must be passed to `python3-config --libs --embed` to get `-lpython3.8` (link the application to libpython). To support both 3.8 and older, try `python3-config --libs --embed` first and fallback to `python3-config --libs` (without `--embed`) if the previous command fails.
Add a pkg-config `python-3.8-embed` module to embed Python into an application: `pkg-config python-3.8-embed --libs` includes `-lpython3.8`. To support both 3.8 and older, try `pkg-config python-X.Y-embed --libs` first and fallback to `pkg-config python-X.Y --libs` (without `--embed`) if the previous command fails (replace `X.Y` with the Python version).
On the other hand, `pkg-config python3.8 --libs` no longer contains `-lpython3.8`. C extensions must not be linked to libpython (except on Android and Cygwin, whose cases are handled by the script); this change is backward incompatible on purpose. (Contributed by Victor Stinner in `36721`{.interpreted-text role="issue"}.)
### f-strings support `=` for self-documenting expressions and debugging {#bpo-36817-whatsnew}
Added an `=` specifier to `f-string`{.interpreted-text role="term"}s. An f-string such as `f'{expr=}'` will expand to the text of the expression, an equal sign, then the representation of the evaluated expression. For example:
> \>\>\> user = \'eric_idle\' \>\>\> member_since = date(1975, 7, 31) \>\>\> f\'{user=} {member_since=}\' \"user=\'eric_idle\' member_since=datetime.date(1975, 7, 31)\"
The usual `f-string format specifiers <f-strings>`{.interpreted-text role="ref"} allow more control over how the result of the expression is displayed:
>>> delta = date.today() - member_since
>>> f'{user=!s} {delta.days=:,d}'
'user=eric_idle delta.days=16,075'
The `=` specifier will display the whole expression so that calculations can be shown:
>>> print(f'{theta=} {cos(radians(theta))=:.3f}')
theta=30 cos(radians(theta))=0.866
(Contributed by Eric V. Smith and Larry Hastings in `36817`{.interpreted-text role="issue"}.)
### PEP 578: Python Runtime Audit Hooks
The PEP adds an Audit Hook and Verified Open Hook. Both are available from Python and native code, allowing applications and frameworks written in pure Python code to take advantage of extra notifications, while also allowing embedders or system administrators to deploy builds of Python where auditing is always enabled.
See `578`{.interpreted-text role="pep"} for full details.
### PEP 587: Python Initialization Configuration
The `587`{.interpreted-text role="pep"} adds a new C API to configure the Python Initialization providing finer control on the whole configuration and better error reporting.
New structures:
- `PyConfig`{.interpreted-text role="c:type"}
- `PyPreConfig`{.interpreted-text role="c:type"}
- `PyStatus`{.interpreted-text role="c:type"}
- `PyWideStringList`{.interpreted-text role="c:type"}
New functions:
- `PyConfig_Clear`{.interpreted-text role="c:func"}
- `PyConfig_InitIsolatedConfig`{.interpreted-text role="c:func"}
- `PyConfig_InitPythonConfig`{.interpreted-text role="c:func"}
- `PyConfig_Read`{.interpreted-text role="c:func"}
- `PyConfig_SetArgv`{.interpreted-text role="c:func"}
- `PyConfig_SetBytesArgv`{.interpreted-text role="c:func"}
- `PyConfig_SetBytesString`{.interpreted-text role="c:func"}
- `PyConfig_SetString`{.interpreted-text role="c:func"}
- `PyPreConfig_InitIsolatedConfig`{.interpreted-text role="c:func"}
- `PyPreConfig_InitPythonConfig`{.interpreted-text role="c:func"}
- `PyStatus_Error`{.interpreted-text role="c:func"}
- `PyStatus_Exception`{.interpreted-text role="c:func"}
- `PyStatus_Exit`{.interpreted-text role="c:func"}
- `PyStatus_IsError`{.interpreted-text role="c:func"}
- `PyStatus_IsExit`{.interpreted-text role="c:func"}
- `PyStatus_NoMemory`{.interpreted-text role="c:func"}
- `PyStatus_Ok`{.interpreted-text role="c:func"}
- `PyWideStringList_Append`{.interpreted-text role="c:func"}
- `PyWideStringList_Insert`{.interpreted-text role="c:func"}
- `Py_BytesMain`{.interpreted-text role="c:func"}
- `Py_ExitStatusException`{.interpreted-text role="c:func"}
- `Py_InitializeFromConfig`{.interpreted-text role="c:func"}
- `Py_PreInitialize`{.interpreted-text role="c:func"}
- `Py_PreInitializeFromArgs`{.interpreted-text role="c:func"}
- `Py_PreInitializeFromBytesArgs`{.interpreted-text role="c:func"}
- `Py_RunMain`{.interpreted-text role="c:func"}
This PEP also adds `_PyRuntimeState.preconfig` (`PyPreConfig`{.interpreted-text role="c:type"} type) and `PyInterpreterState.config` (`PyConfig`{.interpreted-text role="c:type"} type) fields to these internal structures. `PyInterpreterState.config` becomes the new reference configuration, replacing global configuration variables and other private variables.
See `Python Initialization Configuration <init-config>`{.interpreted-text role="ref"} for the documentation.
See `587`{.interpreted-text role="pep"} for a full description.
(Contributed by Victor Stinner in `36763`{.interpreted-text role="issue"}.)
### PEP 590: Vectorcall: a fast calling protocol for CPython
`vectorcall`{.interpreted-text role="ref"} is added to the Python/C API. It is meant to formalize existing optimizations which were already done for various classes. Any `static type <static-types>`{.interpreted-text role="ref"} implementing a callable can use this protocol.
This is currently provisional. The aim is to make it fully public in Python 3.9.
See `590`{.interpreted-text role="pep"} for a full description.
(Contributed by Jeroen Demeyer, Mark Shannon and Petr Viktorin in `36974`{.interpreted-text role="issue"}.)
### Pickle protocol 5 with out-of-band data buffers
When `pickle`{.interpreted-text role="mod"} is used to transfer large data between Python processes in order to take advantage of multi-core or multi-machine processing, it is important to optimize the transfer by reducing memory copies, and possibly by applying custom techniques such as data-dependent compression.
The `pickle`{.interpreted-text role="mod"} protocol 5 introduces support for out-of-band buffers where `3118`{.interpreted-text role="pep"}-compatible data can be transmitted separately from the main pickle stream, at the discretion of the communication layer.
See `574`{.interpreted-text role="pep"} for a full description.
(Contributed by Antoine Pitrou in `36785`{.interpreted-text role="issue"}.)
## Other Language Changes
- A `continue`{.interpreted-text role="keyword"} statement was illegal in the `finally`{.interpreted-text role="keyword"} clause due to a problem with the implementation. In Python 3.8 this restriction was lifted. (Contributed by Serhiy Storchaka in `32489`{.interpreted-text role="issue"}.)
- The `bool`{.interpreted-text role="class"}, `int`{.interpreted-text role="class"}, and `fractions.Fraction`{.interpreted-text role="class"} types now have an `~int.as_integer_ratio`{.interpreted-text role="meth"} method like that found in `float`{.interpreted-text role="class"} and `decimal.Decimal`{.interpreted-text role="class"}. This minor API extension makes it possible to write `numerator, denominator = x.as_integer_ratio()` and have it work across multiple numeric types. (Contributed by Lisa Roach in `33073`{.interpreted-text role="issue"} and Raymond Hettinger in `37819`{.interpreted-text role="issue"}.)
- Constructors of `int`{.interpreted-text role="class"}, `float`{.interpreted-text role="class"} and `complex`{.interpreted-text role="class"} will now use the `~object.__index__`{.interpreted-text role="meth"} special method, if available and the corresponding method `~object.__int__`{.interpreted-text role="meth"}, `~object.__float__`{.interpreted-text role="meth"} or `~object.__complex__`{.interpreted-text role="meth"} is not available. (Contributed by Serhiy Storchaka in `20092`{.interpreted-text role="issue"}.)
- Added support of `\\N\\{{name}\\}`{.interpreted-text role="samp"} escapes in `regular expressions <re>`{.interpreted-text role="mod"}:
>>> notice = 'Copyright © 2019'
>>> copyright_year_pattern = re.compile(r'\N{copyright sign}\s*(\d{4})')
>>> int(copyright_year_pattern.search(notice).group(1))
2019
(Contributed by Jonathan Eunice and Serhiy Storchaka in `30688`{.interpreted-text role="issue"}.)
- Dict and dictviews are now iterable in reversed insertion order using `reversed`{.interpreted-text role="func"}. (Contributed by Rémi Lapeyre in `33462`{.interpreted-text role="issue"}.)
- The syntax allowed for keyword names in function calls was further restricted. In particular, `f((keyword)=arg)` is no longer allowed. It was never intended to permit more than a bare name on the left-hand side of a keyword argument assignment term. (Contributed by Benjamin Peterson in `34641`{.interpreted-text role="issue"}.)
- Generalized iterable unpacking in `yield`{.interpreted-text role="keyword"} and `return`{.interpreted-text role="keyword"} statements no longer requires enclosing parentheses. This brings the *yield* and *return* syntax into better agreement with normal assignment syntax:
>>> def parse(family):
... lastname, *members = family.split()
... return lastname.upper(), *members
...
>>> parse('simpsons homer marge bart lisa maggie')
('SIMPSONS', 'homer', 'marge', 'bart', 'lisa', 'maggie')
(Contributed by David Cuthbert and Jordan Chapman in `32117`{.interpreted-text role="issue"}.)
- When a comma is missed in code such as `[(10, 20) (30, 40)]`, the compiler displays a `SyntaxWarning`{.interpreted-text role="exc"} with a helpful suggestion. This improves on just having a `TypeError`{.interpreted-text role="exc"} indicating that the first tuple was not callable. (Contributed by Serhiy Storchaka in `15248`{.interpreted-text role="issue"}.)
- Arithmetic operations between subclasses of `datetime.date`{.interpreted-text role="class"} or `datetime.datetime`{.interpreted-text role="class"} and `datetime.timedelta`{.interpreted-text role="class"} objects now return an instance of the subclass, rather than the base class. This also affects the return type of operations whose implementation (directly or indirectly) uses `datetime.timedelta`{.interpreted-text role="class"} arithmetic, such as `~datetime.datetime.astimezone`{.interpreted-text role="meth"}. (Contributed by Paul Ganssle in `32417`{.interpreted-text role="issue"}.)
- When the Python interpreter is interrupted by Ctrl-C (SIGINT) and the resulting `KeyboardInterrupt`{.interpreted-text role="exc"} exception is not caught, the Python process now exits via a SIGINT signal or with the correct exit code such that the calling process can detect that it died due to a Ctrl-C. Shells on POSIX and Windows use this to properly terminate scripts in interactive sessions. (Contributed by Google via Gregory P. Smith in `1054041`{.interpreted-text role="issue"}.)
- Some advanced styles of programming require updating the `types.CodeType`{.interpreted-text role="class"} object for an existing function. Since code objects are immutable, a new code object needs to be created, one that is modeled on the existing code object. With 19 parameters, this was somewhat tedious. Now, the new `replace()` method makes it possible to create a clone with a few altered parameters.
Here\'s an example that alters the `statistics.mean`{.interpreted-text role="func"} function to prevent the *data* parameter from being used as a keyword argument:
>>> from statistics import mean
>>> mean(data=[10, 20, 90])
40
>>> mean.__code__ = mean.__code__.replace(co_posonlyargcount=1)
>>> mean(data=[10, 20, 90])
Traceback (most recent call last):
...
TypeError: mean() got some positional-only arguments passed as keyword arguments: 'data'
(Contributed by Victor Stinner in `37032`{.interpreted-text role="issue"}.)
- For integers, the three-argument form of the `pow`{.interpreted-text role="func"} function now permits the exponent to be negative in the case where the base is relatively prime to the modulus. It then computes a modular inverse to the base when the exponent is `-1`, and a suitable power of that inverse for other negative exponents. For example, to compute the [modular multiplicative inverse](https://en.wikipedia.org/wiki/Modular_multiplicative_inverse) of 38 modulo 137, write:
>>> pow(38, -1, 137)
119
>>> 119 * 38 % 137
1
Modular inverses arise in the solution of [linear Diophantine equations](https://en.wikipedia.org/wiki/Diophantine_equation). For example, to find integer solutions for `4258𝑥 + 147𝑦 = 369`, first rewrite as `4258𝑥 ≡ 369 (mod 147)` then solve:
> \>\>\> x = 369 \* pow(4258, -1, 147) % 147 \>\>\> y = (4258 \* x - 369) // -147 \>\>\> 4258 \* x + 147 \* y 369
(Contributed by Mark Dickinson in `36027`{.interpreted-text role="issue"}.)
- Dict comprehensions have been synced-up with dict literals so that the key is computed first and the value second:
>>> # Dict comprehension
>>> cast = {input('role? '): input('actor? ') for i in range(2)}
role? King Arthur
actor? Chapman
role? Black Knight
actor? Cleese
>>> # Dict literal
>>> cast = {input('role? '): input('actor? ')}
role? Sir Robin
actor? Eric Idle
The guaranteed execution order is helpful with assignment expressions because variables assigned in the key expression will be available in the value expression:
>>> names = ['Martin von Löwis', 'Łukasz Langa', 'Walter Dörwald']
>>> {(n := normalize('NFC', name)).casefold() : n for name in names}
{'martin von löwis': 'Martin von Löwis',
'łukasz langa': 'Łukasz Langa',
'walter dörwald': 'Walter Dörwald'}
(Contributed by Jörn Heissler in `35224`{.interpreted-text role="issue"}.)
- The `object.__reduce__`{.interpreted-text role="meth"} method can now return a tuple from two to six elements long. Formerly, five was the limit. The new, optional sixth element is a callable with a `(obj, state)` signature. This allows the direct control over the state-updating behavior of a specific object. If not *None*, this callable will have priority over the object\'s `~object.__setstate__`{.interpreted-text role="meth"} method. (Contributed by Pierre Glaser and Olivier Grisel in `35900`{.interpreted-text role="issue"}.)
## New Modules
- The new `importlib.metadata`{.interpreted-text role="mod"} module provides (provisional) support for reading metadata from third-party packages. For example, it can extract an installed package\'s version number, list of entry points, and more:
>>> # Note following example requires that the popular "requests"
>>> # package has been installed.
>>>
>>> from importlib.metadata import version, requires, files
>>> version('requests')
'2.22.0'
>>> list(requires('requests'))
['chardet (<3.1.0,>=3.0.2)']
>>> list(files('requests'))[:5]
[PackagePath('requests-2.22.0.dist-info/INSTALLER'),
PackagePath('requests-2.22.0.dist-info/LICENSE'),
PackagePath('requests-2.22.0.dist-info/METADATA'),
PackagePath('requests-2.22.0.dist-info/RECORD'),
PackagePath('requests-2.22.0.dist-info/WHEEL')]
(Contributed by Barry Warsaw and Jason R. Coombs in `34632`{.interpreted-text role="issue"}.)
## Improved Modules
### ast
AST nodes now have `end_lineno` and `end_col_offset` attributes, which give the precise location of the end of the node. (This only applies to nodes that have `lineno` and `col_offset` attributes.)
New function `ast.get_source_segment`{.interpreted-text role="func"} returns the source code for a specific AST node.
(Contributed by Ivan Levkivskyi in `33416`{.interpreted-text role="issue"}.)
The `ast.parse`{.interpreted-text role="func"} function has some new flags:
- `type_comments=True` causes it to return the text of `484`{.interpreted-text role="pep"} and `526`{.interpreted-text role="pep"} type comments associated with certain AST nodes;
- `mode='func_type'` can be used to parse `484`{.interpreted-text role="pep"} \"signature type comments\" (returned for function definition AST nodes);
- `feature_version=(3, N)` allows specifying an earlier Python 3 version. For example, `feature_version=(3, 4)` will treat `async`{.interpreted-text role="keyword"} and `await`{.interpreted-text role="keyword"} as non-reserved words.
(Contributed by Guido van Rossum in `35766`{.interpreted-text role="issue"}.)
### asyncio
`asyncio.run`{.interpreted-text role="func"} has graduated from the provisional to stable API. This function can be used to execute a `coroutine`{.interpreted-text role="term"} and return the result while automatically managing the event loop. For example:
import asyncio
async def main():
await asyncio.sleep(0)
return 42
asyncio.run(main())
This is *roughly* equivalent to:
import asyncio
async def main():
await asyncio.sleep(0)
return 42
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
loop.run_until_complete(main())
finally:
asyncio.set_event_loop(None)
loop.close()
The actual implementation is significantly more complex. Thus, `asyncio.run`{.interpreted-text role="func"} should be the preferred way of running asyncio programs.
(Contributed by Yury Selivanov in `32314`{.interpreted-text role="issue"}.)
Running `python -m asyncio` launches a natively async REPL. This allows rapid experimentation with code that has a top-level `await`{.interpreted-text role="keyword"}. There is no longer a need to directly call `asyncio.run()` which would spawn a new event loop on every invocation:
``` none
$ python -m asyncio
asyncio REPL 3.8.0
Use "await" directly instead of "asyncio.run()".
Type "help", "copyright", "credits" or "license" for more information.
>>> import asyncio
>>> await asyncio.sleep(10, result='hello')
hello
```
(Contributed by Yury Selivanov in `37028`{.interpreted-text role="issue"}.)
The exception `asyncio.CancelledError`{.interpreted-text role="class"} now inherits from `BaseException`{.interpreted-text role="class"} rather than `Exception`{.interpreted-text role="class"} and no longer inherits from `concurrent.futures.CancelledError`{.interpreted-text role="class"}. (Contributed by Yury Selivanov in `32528`{.interpreted-text role="issue"}.)
On Windows, the default event loop is now `~asyncio.ProactorEventLoop`{.interpreted-text role="class"}. (Contributed by Victor Stinner in `34687`{.interpreted-text role="issue"}.)
`~asyncio.ProactorEventLoop`{.interpreted-text role="class"} now also supports UDP. (Contributed by Adam Meily and Andrew Svetlov in `29883`{.interpreted-text role="issue"}.)
`~asyncio.ProactorEventLoop`{.interpreted-text role="class"} can now be interrupted by `KeyboardInterrupt`{.interpreted-text role="exc"} (\"CTRL+C\"). (Contributed by Vladimir Matveev in `23057`{.interpreted-text role="issue"}.)
Added `asyncio.Task.get_coro`{.interpreted-text role="meth"} for getting the wrapped coroutine within an `asyncio.Task`{.interpreted-text role="class"}. (Contributed by Alex Grönholm in `36999`{.interpreted-text role="issue"}.)
Asyncio tasks can now be named, either by passing the `name` keyword argument to `asyncio.create_task`{.interpreted-text role="func"} or the `~asyncio.loop.create_task`{.interpreted-text role="meth"} event loop method, or by calling the `~asyncio.Task.set_name`{.interpreted-text role="meth"} method on the task object. The task name is visible in the `repr()` output of `asyncio.Task`{.interpreted-text role="class"} and can also be retrieved using the `~asyncio.Task.get_name`{.interpreted-text role="meth"} method. (Contributed by Alex Grönholm in `34270`{.interpreted-text role="issue"}.)
Added support for [Happy Eyeballs](https://en.wikipedia.org/wiki/Happy_Eyeballs) to `asyncio.loop.create_connection`{.interpreted-text role="func"}. To specify the behavior, two new parameters have been added: *happy_eyeballs_delay* and *interleave*. The Happy Eyeballs algorithm improves responsiveness in applications that support IPv4 and IPv6 by attempting to simultaneously connect using both. (Contributed by twisteroid ambassador in `33530`{.interpreted-text role="issue"}.)
### builtins
The `compile`{.interpreted-text role="func"} built-in has been improved to accept the `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT` flag. With this new flag passed, `compile`{.interpreted-text role="func"} will allow top-level `await`, `async for` and `async with` constructs that are usually considered invalid syntax. Asynchronous code object marked with the `CO_COROUTINE` flag may then be returned. (Contributed by Matthias Bussonnier in `34616`{.interpreted-text role="issue"})
### collections
The `~collections.somenamedtuple._asdict`{.interpreted-text role="meth"} method for `collections.namedtuple`{.interpreted-text role="func"} now returns a `dict`{.interpreted-text role="class"} instead of a `collections.OrderedDict`{.interpreted-text role="class"}. This works because regular dicts have guaranteed ordering since Python 3.7. If the extra features of `OrderedDict`{.interpreted-text role="class"} are required, the suggested remediation is to cast the result to the desired type: `OrderedDict(nt._asdict())`. (Contributed by Raymond Hettinger in `35864`{.interpreted-text role="issue"}.)
### cProfile
The `cProfile.Profile <profile.Profile>`{.interpreted-text role="class"} class can now be used as a context manager. Profile a block of code by running:
import cProfile
with cProfile.Profile() as profiler:
# code to be profiled
...
(Contributed by Scott Sanderson in `29235`{.interpreted-text role="issue"}.)
### csv
The `csv.DictReader`{.interpreted-text role="class"} now returns instances of `dict`{.interpreted-text role="class"} instead of a `collections.OrderedDict`{.interpreted-text role="class"}. The tool is now faster and uses less memory while still preserving the field order. (Contributed by Michael Selik in `34003`{.interpreted-text role="issue"}.)
### curses
Added a new variable holding structured version information for the underlying ncurses library: `~curses.ncurses_version`{.interpreted-text role="data"}. (Contributed by Serhiy Storchaka in `31680`{.interpreted-text role="issue"}.)
### ctypes
On Windows, `~ctypes.CDLL`{.interpreted-text role="class"} and subclasses now accept a *winmode* parameter to specify flags for the underlying `LoadLibraryEx` call. The default flags are set to only load DLL dependencies from trusted locations, including the path where the DLL is stored (if a full or partial path is used to load the initial DLL) and paths added by `~os.add_dll_directory`{.interpreted-text role="func"}. (Contributed by Steve Dower in `36085`{.interpreted-text role="issue"}.)
### datetime
Added new alternate constructors `datetime.date.fromisocalendar`{.interpreted-text role="meth"} and `datetime.datetime.fromisocalendar`{.interpreted-text role="meth"}, which construct `~datetime.date`{.interpreted-text role="class"} and `~datetime.datetime`{.interpreted-text role="class"} objects respectively from ISO year, week number, and weekday; these are the inverse of each class\'s `isocalendar` method. (Contributed by Paul Ganssle in `36004`{.interpreted-text role="issue"}.)
### functools
`functools.lru_cache`{.interpreted-text role="func"} can now be used as a straight decorator rather than as a function returning a decorator. So both of these are now supported:
@lru_cache
def f(x):
...
@lru_cache(maxsize=256)
def f(x):
...
(Contributed by Raymond Hettinger in `36772`{.interpreted-text role="issue"}.)
Added a new `functools.cached_property`{.interpreted-text role="func"} decorator, for computed properties cached for the life of the instance. :
import functools
import statistics
class Dataset:
def __init__(self, sequence_of_numbers):
self.data = sequence_of_numbers
@functools.cached_property
def variance(self):
return statistics.variance(self.data)
(Contributed by Carl Meyer in `21145`{.interpreted-text role="issue"})
Added a new `functools.singledispatchmethod`{.interpreted-text role="func"} decorator that converts methods into `generic functions <generic function>`{.interpreted-text role="term"} using `single dispatch`{.interpreted-text role="term"}:
from functools import singledispatchmethod
from contextlib import suppress
class TaskManager:
def __init__(self, tasks):
self.tasks = list(tasks)
@singledispatchmethod
def discard(self, value):
with suppress(ValueError):
self.tasks.remove(value)
@discard.register(list)
def _(self, tasks):
targets = set(tasks)
self.tasks = [x for x in self.tasks if x not in targets]
(Contributed by Ethan Smith in `32380`{.interpreted-text role="issue"})
### gc
`~gc.get_objects`{.interpreted-text role="func"} can now receive an optional *generation* parameter indicating a generation to get objects from. (Contributed by Pablo Galindo in `36016`{.interpreted-text role="issue"}.)
### gettext
Added `~gettext.pgettext`{.interpreted-text role="func"} and its variants. (Contributed by Franz Glasner, Éric Araujo, and Cheryl Sabella in `2504`{.interpreted-text role="issue"}.)
### gzip
Added the *mtime* parameter to `gzip.compress`{.interpreted-text role="func"} for reproducible output. (Contributed by Guo Ci Teo in `34898`{.interpreted-text role="issue"}.)
A `~gzip.BadGzipFile`{.interpreted-text role="exc"} exception is now raised instead of `OSError`{.interpreted-text role="exc"} for certain types of invalid or corrupt gzip files. (Contributed by Filip Gruszczyński, Michele Orrù, and Zackery Spytz in `6584`{.interpreted-text role="issue"}.)
### IDLE and idlelib
Output over N lines (50 by default) is squeezed down to a button. N can be changed in the PyShell section of the General page of the Settings dialog. Fewer, but possibly extra long, lines can be squeezed by right clicking on the output. Squeezed output can be expanded in place by double-clicking the button or into the clipboard or a separate window by right-clicking the button. (Contributed by Tal Einat in `1529353`{.interpreted-text role="issue"}.)
Add \"Run Customized\" to the Run menu to run a module with customized settings. Any command line arguments entered are added to sys.argv. They also re-appear in the box for the next customized run. One can also suppress the normal Shell main module restart. (Contributed by Cheryl Sabella, Terry Jan Reedy, and others in `5680`{.interpreted-text role="issue"} and `37627`{.interpreted-text role="issue"}.)
Added optional line numbers for IDLE editor windows. Windows open without line numbers unless set otherwise in the General tab of the configuration dialog. Line numbers for an existing window are shown and hidden in the Options menu. (Contributed by Tal Einat and Saimadhav Heblikar in `17535`{.interpreted-text role="issue"}.)
OS native encoding is now used for converting between Python strings and Tcl objects. This allows IDLE to work with emoji and other non-BMP characters. These characters can be displayed or copied and pasted to or from the clipboard. Converting strings from Tcl to Python and back now never fails. (Many people worked on this for eight years but the problem was finally solved by Serhiy Storchaka in `13153`{.interpreted-text role="issue"}.)
New in 3.8.1:
Add option to toggle cursor blink off. (Contributed by Zackery Spytz in `4603`{.interpreted-text role="issue"}.)
Escape key now closes IDLE completion windows. (Contributed by Johnny Najera in `38944`{.interpreted-text role="issue"}.)
The changes above have been backported to 3.7 maintenance releases.
Add keywords to module name completion list. (Contributed by Terry J. Reedy in `37765`{.interpreted-text role="issue"}.)
### inspect
The `inspect.getdoc`{.interpreted-text role="func"} function can now find docstrings for `__slots__` if that attribute is a `dict`{.interpreted-text role="class"} where the values are docstrings. This provides documentation options similar to what we already have for `property`{.interpreted-text role="func"}, `classmethod`{.interpreted-text role="func"}, and `staticmethod`{.interpreted-text role="func"}:
class AudioClip:
__slots__ = {'bit_rate': 'expressed in kilohertz to one decimal place',
'duration': 'in seconds, rounded up to an integer'}
def __init__(self, bit_rate, duration):
self.bit_rate = round(bit_rate / 1000.0, 1)
self.duration = ceil(duration)
(Contributed by Raymond Hettinger in `36326`{.interpreted-text role="issue"}.)
### io
In development mode (`-X`{.interpreted-text role="option"} `env`) and in `debug build <debug-build>`{.interpreted-text role="ref"}, the `io.IOBase`{.interpreted-text role="class"} finalizer now logs the exception if the `close()` method fails. The exception is ignored silently by default in release build. (Contributed by Victor Stinner in `18748`{.interpreted-text role="issue"}.)
### itertools
The `itertools.accumulate`{.interpreted-text role="func"} function added an option *initial* keyword argument to specify an initial value:
>>> from itertools import accumulate
>>> list(accumulate([10, 5, 30, 15], initial=1000))
[1000, 1010, 1015, 1045, 1060]
(Contributed by Lisa Roach in `34659`{.interpreted-text role="issue"}.)
### json.tool
Add option `--json-lines` to parse every input line as a separate JSON object. (Contributed by Weipeng Hong in `31553`{.interpreted-text role="issue"}.)
### logging
Added a *force* keyword argument to `logging.basicConfig`{.interpreted-text role="func"}. When set to true, any existing handlers attached to the root logger are removed and closed before carrying out the configuration specified by the other arguments.
This solves a long-standing problem. Once a logger or *basicConfig()* had been called, subsequent calls to *basicConfig()* were silently ignored. This made it difficult to update, experiment with, or teach the various logging configuration options using the interactive prompt or a Jupyter notebook.
(Suggested by Raymond Hettinger, implemented by Donghee Na, and reviewed by Vinay Sajip in `33897`{.interpreted-text role="issue"}.)
### math
Added new function `math.dist`{.interpreted-text role="func"} for computing Euclidean distance between two points. (Contributed by Raymond Hettinger in `33089`{.interpreted-text role="issue"}.)
Expanded the `math.hypot`{.interpreted-text role="func"} function to handle multiple dimensions. Formerly, it only supported the 2-D case. (Contributed by Raymond Hettinger in `33089`{.interpreted-text role="issue"}.)
Added new function, `math.prod`{.interpreted-text role="func"}, as analogous function to `sum`{.interpreted-text role="func"} that returns the product of a \'start\' value (default: 1) times an iterable of numbers:
>>> prior = 0.8
>>> likelihoods = [0.625, 0.84, 0.30]
>>> math.prod(likelihoods, start=prior)
0.126
(Contributed by Pablo Galindo in `35606`{.interpreted-text role="issue"}.)
Added two new combinatoric functions `math.perm`{.interpreted-text role="func"} and `math.comb`{.interpreted-text role="func"}:
>>> math.perm(10, 3) # Permutations of 10 things taken 3 at a time
720
>>> math.comb(10, 3) # Combinations of 10 things taken 3 at a time
120
(Contributed by Yash Aggarwal, Keller Fuchs, Serhiy Storchaka, and Raymond Hettinger in `37128`{.interpreted-text role="issue"}, `37178`{.interpreted-text role="issue"}, and `35431`{.interpreted-text role="issue"}.)
Added a new function `math.isqrt`{.interpreted-text role="func"} for computing accurate integer square roots without conversion to floating point. The new function supports arbitrarily large integers. It is faster than `floor(sqrt(n))` but slower than `math.sqrt`{.interpreted-text role="func"}:
>>> r = 650320427
>>> s = r ** 2
>>> isqrt(s - 1) # correct
650320426
>>> floor(sqrt(s - 1)) # incorrect
650320427
(Contributed by Mark Dickinson in `36887`{.interpreted-text role="issue"}.)
The function `math.factorial`{.interpreted-text role="func"} no longer accepts arguments that are not int-like. (Contributed by Pablo Galindo in `33083`{.interpreted-text role="issue"}.)
### mmap
The `mmap.mmap`{.interpreted-text role="class"} class now has an `~mmap.mmap.madvise`{.interpreted-text role="meth"} method to access the `madvise()` system call. (Contributed by Zackery Spytz in `32941`{.interpreted-text role="issue"}.)
### multiprocessing
Added new `multiprocessing.shared_memory`{.interpreted-text role="mod"} module. (Contributed by Davin Potts in `35813`{.interpreted-text role="issue"}.)
On macOS, the *spawn* start method is now used by default. (Contributed by Victor Stinner in `33725`{.interpreted-text role="issue"}.)
### os
Added new function `~os.add_dll_directory`{.interpreted-text role="func"} on Windows for providing additional search paths for native dependencies when importing extension modules or loading DLLs using `ctypes`{.interpreted-text role="mod"}. (Contributed by Steve Dower in `36085`{.interpreted-text role="issue"}.)
A new `os.memfd_create`{.interpreted-text role="func"} function was added to wrap the `memfd_create()` syscall. (Contributed by Zackery Spytz and Christian Heimes in `26836`{.interpreted-text role="issue"}.)
On Windows, much of the manual logic for handling reparse points (including symlinks and directory junctions) has been delegated to the operating system. Specifically, `os.stat`{.interpreted-text role="func"} will now traverse anything supported by the operating system, while `os.lstat`{.interpreted-text role="func"} will only open reparse points that identify as \"name surrogates\" while others are opened as for `os.stat`{.interpreted-text role="func"}. In all cases, `os.stat_result.st_mode`{.interpreted-text role="attr"} will only have `S_IFLNK` set for symbolic links and not other kinds of reparse points. To identify other kinds of reparse point, check the new `os.stat_result.st_reparse_tag`{.interpreted-text role="attr"} attribute.
On Windows, `os.readlink`{.interpreted-text role="func"} is now able to read directory junctions. Note that `~os.path.islink`{.interpreted-text role="func"} will return `False` for directory junctions, and so code that checks `islink` first will continue to treat junctions as directories, while code that handles errors from `os.readlink`{.interpreted-text role="func"} may now treat junctions as links.
(Contributed by Steve Dower in `37834`{.interpreted-text role="issue"}.)
### os.path
`os.path`{.interpreted-text role="mod"} functions that return a boolean result like `~os.path.exists`{.interpreted-text role="func"}, `~os.path.lexists`{.interpreted-text role="func"}, `~os.path.isdir`{.interpreted-text role="func"}, `~os.path.isfile`{.interpreted-text role="func"}, `~os.path.islink`{.interpreted-text role="func"}, and `~os.path.ismount`{.interpreted-text role="func"} now return `False` instead of raising `ValueError`{.interpreted-text role="exc"} or its subclasses `UnicodeEncodeError`{.interpreted-text role="exc"} and `UnicodeDecodeError`{.interpreted-text role="exc"} for paths that contain characters or bytes unrepresentable at the OS level. (Contributed by Serhiy Storchaka in `33721`{.interpreted-text role="issue"}.)
`~os.path.expanduser`{.interpreted-text role="func"} on Windows now prefers the `USERPROFILE`{.interpreted-text role="envvar"} environment variable and does not use `HOME`{.interpreted-text role="envvar"}, which is not normally set for regular user accounts. (Contributed by Anthony Sottile in `36264`{.interpreted-text role="issue"}.)
`~os.path.isdir`{.interpreted-text role="func"} on Windows no longer returns `True` for a link to a non-existent directory.
`~os.path.realpath`{.interpreted-text role="func"} on Windows now resolves reparse points, including symlinks and directory junctions.
(Contributed by Steve Dower in `37834`{.interpreted-text role="issue"}.)
### pathlib
`pathlib.Path`{.interpreted-text role="mod"} methods that return a boolean result like `~pathlib.Path.exists`{.interpreted-text role="meth"}, `~pathlib.Path.is_dir`{.interpreted-text role="meth"}, `~pathlib.Path.is_file`{.interpreted-text role="meth"}, `~pathlib.Path.is_mount`{.interpreted-text role="meth"}, `~pathlib.Path.is_symlink`{.interpreted-text role="meth"}, `~pathlib.Path.is_block_device`{.interpreted-text role="meth"}, `~pathlib.Path.is_char_device`{.interpreted-text role="meth"}, `~pathlib.Path.is_fifo`{.interpreted-text role="meth"}, `~pathlib.Path.is_socket`{.interpreted-text role="meth"} now return `False` instead of raising `ValueError`{.interpreted-text role="exc"} or its subclass `UnicodeEncodeError`{.interpreted-text role="exc"} for paths that contain characters unrepresentable at the OS level. (Contributed by Serhiy Storchaka in `33721`{.interpreted-text role="issue"}.)
Added `!pathlib.Path.link_to`{.interpreted-text role="meth"} which creates a hard link pointing to a path. (Contributed by Joannah Nanjekye in `26978`{.interpreted-text role="issue"}) Note that `link_to` was deprecated in 3.10 and removed in 3.12 in favor of a `hardlink_to` method added in 3.10 which matches the semantics of the existing `symlink_to` method.
### pickle
`pickle`{.interpreted-text role="mod"} extensions subclassing the C-optimized `~pickle.Pickler`{.interpreted-text role="class"} can now override the pickling logic of functions and classes by defining the special `~pickle.Pickler.reducer_override`{.interpreted-text role="meth"} method. (Contributed by Pierre Glaser and Olivier Grisel in `35900`{.interpreted-text role="issue"}.)
### plistlib
Added new `plistlib.UID`{.interpreted-text role="class"} and enabled support for reading and writing NSKeyedArchiver-encoded binary plists. (Contributed by Jon Janzen in `26707`{.interpreted-text role="issue"}.)
### pprint
The `pprint`{.interpreted-text role="mod"} module added a *sort_dicts* parameter to several functions. By default, those functions continue to sort dictionaries before rendering or printing. However, if *sort_dicts* is set to false, the dictionaries retain the order that keys were inserted. This can be useful for comparison to JSON inputs during debugging.
In addition, there is a convenience new function, `pprint.pp`{.interpreted-text role="func"} that is like `pprint.pprint`{.interpreted-text role="func"} but with *sort_dicts* defaulting to `False`:
>>> from pprint import pprint, pp
>>> d = dict(source='input.txt', operation='filter', destination='output.txt')
>>> pp(d, width=40) # Original order
{'source': 'input.txt',
'operation': 'filter',
'destination': 'output.txt'}
>>> pprint(d, width=40) # Keys sorted alphabetically
{'destination': 'output.txt',
'operation': 'filter',
'source': 'input.txt'}
(Contributed by Rémi Lapeyre in `30670`{.interpreted-text role="issue"}.)
### py_compile
`py_compile.compile`{.interpreted-text role="func"} now supports silent mode. (Contributed by Joannah Nanjekye in `22640`{.interpreted-text role="issue"}.)
### shlex
The new `shlex.join`{.interpreted-text role="func"} function acts as the inverse of `shlex.split`{.interpreted-text role="func"}. (Contributed by Bo Bayles in `32102`{.interpreted-text role="issue"}.)
### shutil
`shutil.copytree`{.interpreted-text role="func"} now accepts a new `dirs_exist_ok` keyword argument. (Contributed by Josh Bronson in `20849`{.interpreted-text role="issue"}.)
`shutil.make_archive`{.interpreted-text role="func"} now defaults to the modern pax (POSIX.1-2001) format for new archives to improve portability and standards conformance, inherited from the corresponding change to the `tarfile`{.interpreted-text role="mod"} module. (Contributed by C.A.M. Gerlach in `30661`{.interpreted-text role="issue"}.)
`shutil.rmtree`{.interpreted-text role="func"} on Windows now removes directory junctions without recursively removing their contents first. (Contributed by Steve Dower in `37834`{.interpreted-text role="issue"}.)
### socket
Added `~socket.create_server`{.interpreted-text role="meth"} and `~socket.has_dualstack_ipv6`{.interpreted-text role="meth"} convenience functions to automate the necessary tasks usually involved when creating a server socket, including accepting both IPv4 and IPv6 connections on the same socket. (Contributed by Giampaolo Rodolà in `17561`{.interpreted-text role="issue"}.)
The `socket.if_nameindex`{.interpreted-text role="func"}, `socket.if_nametoindex`{.interpreted-text role="func"}, and `socket.if_indextoname`{.interpreted-text role="func"} functions have been implemented on Windows. (Contributed by Zackery Spytz in `37007`{.interpreted-text role="issue"}.)
### ssl
Added `~ssl.SSLContext.post_handshake_auth`{.interpreted-text role="attr"} to enable and `~ssl.SSLSocket.verify_client_post_handshake`{.interpreted-text role="meth"} to initiate TLS 1.3 post-handshake authentication. (Contributed by Christian Heimes in `34670`{.interpreted-text role="issue"}.)
### statistics
Added `statistics.fmean`{.interpreted-text role="func"} as a faster, floating-point variant of `statistics.mean`{.interpreted-text role="func"}. (Contributed by Raymond Hettinger and Steven D\'Aprano in `35904`{.interpreted-text role="issue"}.)
Added `statistics.geometric_mean`{.interpreted-text role="func"} (Contributed by Raymond Hettinger in `27181`{.interpreted-text role="issue"}.)
Added `statistics.multimode`{.interpreted-text role="func"} that returns a list of the most common values. (Contributed by Raymond Hettinger in `35892`{.interpreted-text role="issue"}.)
Added `statistics.quantiles`{.interpreted-text role="func"} that divides data or a distribution in to equiprobable intervals (e.g. quartiles, deciles, or percentiles). (Contributed by Raymond Hettinger in `36546`{.interpreted-text role="issue"}.)
Added `statistics.NormalDist`{.interpreted-text role="class"}, a tool for creating and manipulating normal distributions of a random variable. (Contributed by Raymond Hettinger in `36018`{.interpreted-text role="issue"}.)
>>> temperature_feb = NormalDist.from_samples([4, 12, -3, 2, 7, 14])
>>> temperature_feb.mean
6.0
>>> temperature_feb.stdev
6.356099432828281
>>> temperature_feb.cdf(3) # Chance of being under 3 degrees
0.3184678262814532
>>> # Relative chance of being 7 degrees versus 10 degrees
>>> temperature_feb.pdf(7) / temperature_feb.pdf(10)
1.2039930378537762
>>> el_niño = NormalDist(4, 2.5)
>>> temperature_feb += el_niño # Add in a climate effect
>>> temperature_feb
NormalDist(mu=10.0, sigma=6.830080526611674)
>>> temperature_feb * (9/5) + 32 # Convert to Fahrenheit
NormalDist(mu=50.0, sigma=12.294144947901014)
>>> temperature_feb.samples(3) # Generate random samples
[7.672102882379219, 12.000027119750287, 4.647488369766392]
### sys
Add new `sys.unraisablehook`{.interpreted-text role="func"} function which can be overridden to control how \"unraisable exceptions\" are handled. It is called when an exception has occurred but there is no way for Python to handle it. For example, when a destructor raises an exception or during garbage collection (`gc.collect`{.interpreted-text role="func"}). (Contributed by Victor Stinner in `36829`{.interpreted-text role="issue"}.)
### tarfile
The `tarfile`{.interpreted-text role="mod"} module now defaults to the modern pax (POSIX.1-2001) format for new archives, instead of the previous GNU-specific one. This improves cross-platform portability with a consistent encoding (UTF-8) in a standardized and extensible format, and offers several other benefits. (Contributed by C.A.M. Gerlach in `36268`{.interpreted-text role="issue"}.)
### threading
Add a new `threading.excepthook`{.interpreted-text role="func"} function which handles uncaught `threading.Thread.run`{.interpreted-text role="meth"} exception. It can be overridden to control how uncaught `threading.Thread.run`{.interpreted-text role="meth"} exceptions are handled. (Contributed by Victor Stinner in `1230540`{.interpreted-text role="issue"}.)
Add a new `threading.get_native_id`{.interpreted-text role="func"} function and a `~threading.Thread.native_id`{.interpreted-text role="data"} attribute to the `threading.Thread`{.interpreted-text role="class"} class. These return the native integral Thread ID of the current thread assigned by the kernel. This feature is only available on certain platforms, see `get_native_id <threading.get_native_id>`{.interpreted-text role="func"} for more information. (Contributed by Jake Tesler in `36084`{.interpreted-text role="issue"}.)
### tokenize
The `tokenize`{.interpreted-text role="mod"} module now implicitly emits a `NEWLINE` token when provided with input that does not have a trailing new line. This behavior now matches what the C tokenizer does internally. (Contributed by Ammar Askar in `33899`{.interpreted-text role="issue"}.)
### tkinter
Added methods `!selection_from`{.interpreted-text role="meth"}, `!selection_present`{.interpreted-text role="meth"}, `!selection_range`{.interpreted-text role="meth"} and `!selection_to`{.interpreted-text role="meth"} in the `!tkinter.Spinbox`{.interpreted-text role="class"} class. (Contributed by Juliette Monsel in `34829`{.interpreted-text role="issue"}.)
Added method `!moveto`{.interpreted-text role="meth"} in the `!tkinter.Canvas`{.interpreted-text role="class"} class. (Contributed by Juliette Monsel in `23831`{.interpreted-text role="issue"}.)
The `!tkinter.PhotoImage`{.interpreted-text role="class"} class now has `!transparency_get`{.interpreted-text role="meth"} and `!transparency_set`{.interpreted-text role="meth"} methods. (Contributed by Zackery Spytz in `25451`{.interpreted-text role="issue"}.)
### time
Added new clock `~time.CLOCK_UPTIME_RAW`{.interpreted-text role="const"} for macOS 10.12. (Contributed by Joannah Nanjekye in `35702`{.interpreted-text role="issue"}.)
### typing
The `typing`{.interpreted-text role="mod"} module incorporates several new features:
- A dictionary type with per-key types. See `589`{.interpreted-text role="pep"} and `typing.TypedDict`{.interpreted-text role="class"}. TypedDict uses only string keys. By default, every key is required to be present. Specify \"total=False\" to allow keys to be optional:
class Location(TypedDict, total=False):
lat_long: tuple
grid_square: str
xy_coordinate: tuple
- Literal types. See `586`{.interpreted-text role="pep"} and `typing.Literal`{.interpreted-text role="class"}. Literal types indicate that a parameter or return value is constrained to one or more specific literal values:
def get_status(port: int) -> Literal['connected', 'disconnected']:
...
- \"Final\" variables, functions, methods and classes. See `591`{.interpreted-text role="pep"}, `typing.Final`{.interpreted-text role="class"} and `typing.final`{.interpreted-text role="func"}. The final qualifier instructs a static type checker to restrict subclassing, overriding, or reassignment:
pi: Final[float] = 3.1415926536
- Protocol definitions. See `544`{.interpreted-text role="pep"}, `typing.Protocol`{.interpreted-text role="class"} and `typing.runtime_checkable`{.interpreted-text role="func"}. Simple ABCs like `typing.SupportsInt`{.interpreted-text role="class"} are now `Protocol` subclasses.
- New protocol class `typing.SupportsIndex`{.interpreted-text role="class"}.
- New functions `typing.get_origin`{.interpreted-text role="func"} and `typing.get_args`{.interpreted-text role="func"}.
### unicodedata
The `unicodedata`{.interpreted-text role="mod"} module has been upgraded to use the [Unicode 12.1.0](https://blog.unicode.org/2019/05/unicode-12-1-en.html) release.
New function `~unicodedata.is_normalized`{.interpreted-text role="func"} can be used to verify a string is in a specific normal form, often much faster than by actually normalizing the string. (Contributed by Max Belanger, David Euresti, and Greg Price in `32285`{.interpreted-text role="issue"} and `37966`{.interpreted-text role="issue"}).
### unittest
Added `~unittest.mock.AsyncMock`{.interpreted-text role="class"} to support an asynchronous version of `~unittest.mock.Mock`{.interpreted-text role="class"}. Appropriate new assert functions for testing have been added as well. (Contributed by Lisa Roach in `26467`{.interpreted-text role="issue"}).
Added `~unittest.addModuleCleanup`{.interpreted-text role="func"} and `~unittest.TestCase.addClassCleanup`{.interpreted-text role="meth"} to unittest to support cleanups for `~unittest.setUpModule`{.interpreted-text role="func"} and `~unittest.TestCase.setUpClass`{.interpreted-text role="meth"}. (Contributed by Lisa Roach in `24412`{.interpreted-text role="issue"}.)
Several mock assert functions now also print a list of actual calls upon failure. (Contributed by Petter Strandmark in `35047`{.interpreted-text role="issue"}.)
`unittest`{.interpreted-text role="mod"} module gained support for coroutines to be used as test cases with `unittest.IsolatedAsyncioTestCase`{.interpreted-text role="class"}. (Contributed by Andrew Svetlov in `32972`{.interpreted-text role="issue"}.)
Example:
import unittest
class TestRequest(unittest.IsolatedAsyncioTestCase):
async def asyncSetUp(self):
self.connection = await AsyncConnection()
async def test_get(self):
response = await self.connection.get("https://example.com")
self.assertEqual(response.status_code, 200)
async def asyncTearDown(self):
await self.connection.close()
if __name__ == "__main__":
unittest.main()
### venv
`venv`{.interpreted-text role="mod"} now includes an `Activate.ps1` script on all platforms for activating virtual environments under PowerShell Core 6.1. (Contributed by Brett Cannon in `32718`{.interpreted-text role="issue"}.)
### weakref
The proxy objects returned by `weakref.proxy`{.interpreted-text role="func"} now support the matrix multiplication operators `@` and `@=` in addition to the other numeric operators. (Contributed by Mark Dickinson in `36669`{.interpreted-text role="issue"}.)
### xml
As mitigation against DTD and external entity retrieval, the `xml.dom.minidom`{.interpreted-text role="mod"} and `xml.sax`{.interpreted-text role="mod"} modules no longer process external entities by default. (Contributed by Christian Heimes in `17239`{.interpreted-text role="issue"}.)
The `.find*()` methods in the `xml.etree.ElementTree`{.interpreted-text role="mod"} module support wildcard searches like `{*}tag` which ignores the namespace and `{namespace}*` which returns all tags in the given namespace. (Contributed by Stefan Behnel in `28238`{.interpreted-text role="issue"}.)
The `xml.etree.ElementTree`{.interpreted-text role="mod"} module provides a new function `~xml.etree.ElementTree.canonicalize`{.interpreted-text role="func"} that implements C14N 2.0. (Contributed by Stefan Behnel in `13611`{.interpreted-text role="issue"}.)
The target object of `xml.etree.ElementTree.XMLParser`{.interpreted-text role="class"} can receive namespace declaration events through the new callback methods `start_ns()` and `end_ns()`. Additionally, the `xml.etree.ElementTree.TreeBuilder`{.interpreted-text role="class"} target can be configured to process events about comments and processing instructions to include them in the generated tree. (Contributed by Stefan Behnel in `36676`{.interpreted-text role="issue"} and `36673`{.interpreted-text role="issue"}.)
### xmlrpc
`xmlrpc.client.ServerProxy`{.interpreted-text role="class"} now supports an optional *headers* keyword argument for a sequence of HTTP headers to be sent with each request. Among other things, this makes it possible to upgrade from default basic authentication to faster session authentication. (Contributed by Cédric Krier in `35153`{.interpreted-text role="issue"}.)
## Optimizations
- The `subprocess`{.interpreted-text role="mod"} module can now use the `os.posix_spawn`{.interpreted-text role="func"} function in some cases for better performance. Currently, it is only used on macOS and Linux (using glibc 2.24 or newer) if all these conditions are met:
- *close_fds* is false;
- *preexec_fn*, *pass_fds*, *cwd* and *start_new_session* parameters are not set;
- the *executable* path contains a directory.
(Contributed by Joannah Nanjekye and Victor Stinner in `35537`{.interpreted-text role="issue"}.)
- `shutil.copyfile`{.interpreted-text role="func"}, `shutil.copy`{.interpreted-text role="func"}, `shutil.copy2`{.interpreted-text role="func"}, `shutil.copytree`{.interpreted-text role="func"} and `shutil.move`{.interpreted-text role="func"} use platform-specific \"fast-copy\" syscalls on Linux and macOS in order to copy the file more efficiently. \"fast-copy\" means that the copying operation occurs within the kernel, avoiding the use of userspace buffers in Python as in \"`outfd.write(infd.read())`\". On Windows `shutil.copyfile`{.interpreted-text role="func"} uses a bigger default buffer size (1 MiB instead of 16 KiB) and a `memoryview`{.interpreted-text role="func"}-based variant of `shutil.copyfileobj`{.interpreted-text role="func"} is used. The speedup for copying a 512 MiB file within the same partition is about +26% on Linux, +50% on macOS and +40% on Windows. Also, much less CPU cycles are consumed. See `shutil-platform-dependent-efficient-copy-operations`{.interpreted-text role="ref"} section. (Contributed by Giampaolo Rodolà in `33671`{.interpreted-text role="issue"}.)
- `shutil.copytree`{.interpreted-text role="func"} uses `os.scandir`{.interpreted-text role="func"} function and all copy functions depending from it use cached `os.stat`{.interpreted-text role="func"} values. The speedup for copying a directory with 8000 files is around +9% on Linux, +20% on Windows and +30% on a Windows SMB share. Also the number of `os.stat`{.interpreted-text role="func"} syscalls is reduced by 38% making `shutil.copytree`{.interpreted-text role="func"} especially faster on network filesystems. (Contributed by Giampaolo Rodolà in `33695`{.interpreted-text role="issue"}.)
- The default protocol in the `pickle`{.interpreted-text role="mod"} module is now Protocol 4, first introduced in Python 3.4. It offers better performance and smaller size compared to Protocol 3 available since Python 3.0.
- Removed one `Py_ssize_t`{.interpreted-text role="c:type"} member from `PyGC_Head`. All GC tracked objects (e.g. tuple, list, dict) size is reduced 4 or 8 bytes. (Contributed by Inada Naoki in `33597`{.interpreted-text role="issue"}.)
- `uuid.UUID`{.interpreted-text role="class"} now uses `__slots__` to reduce its memory footprint. (Contributed by Wouter Bolsterlee and Tal Einat in `30977`{.interpreted-text role="issue"})
- Improved performance of `operator.itemgetter`{.interpreted-text role="func"} by 33%. Optimized argument handling and added a fast path for the common case of a single non-negative integer index into a tuple (which is the typical use case in the standard library). (Contributed by Raymond Hettinger in `35664`{.interpreted-text role="issue"}.)
- Sped-up field lookups in `collections.namedtuple`{.interpreted-text role="func"}. They are now more than two times faster, making them the fastest form of instance variable lookup in Python. (Contributed by Raymond Hettinger, Pablo Galindo, and Joe Jevnik, Serhiy Storchaka in `32492`{.interpreted-text role="issue"}.)
- The `list`{.interpreted-text role="class"} constructor does not overallocate the internal item buffer if the input iterable has a known length (the input implements `__len__`). This makes the created list 12% smaller on average. (Contributed by Raymond Hettinger and Pablo Galindo in `33234`{.interpreted-text role="issue"}.)
- Doubled the speed of class variable writes. When a non-dunder attribute was updated, there was an unnecessary call to update slots. (Contributed by Stefan Behnel, Pablo Galindo Salgado, Raymond Hettinger, Neil Schemenauer, and Serhiy Storchaka in `36012`{.interpreted-text role="issue"}.)
- Reduced an overhead of converting arguments passed to many builtin functions and methods. This sped up calling some simple builtin functions and methods up to 20\--50%. (Contributed by Serhiy Storchaka in `23867`{.interpreted-text role="issue"}, `35582`{.interpreted-text role="issue"} and `36127`{.interpreted-text role="issue"}.)
- `LOAD_GLOBAL` instruction now uses new \"per opcode cache\" mechanism. It is about 40% faster now. (Contributed by Yury Selivanov and Inada Naoki in `26219`{.interpreted-text role="issue"}.)
## Build and C API Changes
- Default `sys.abiflags`{.interpreted-text role="data"} became an empty string: the `m` flag for pymalloc became useless (builds with and without pymalloc are ABI compatible) and so has been removed. (Contributed by Victor Stinner in `36707`{.interpreted-text role="issue"}.)
Example of changes:
- Only `python3.8` program is installed, `python3.8m` program is gone.
- Only `python3.8-config` script is installed, `python3.8m-config` script is gone.
- The `m` flag has been removed from the suffix of dynamic library filenames: extension modules in the standard library as well as those produced and installed by third-party packages, like those downloaded from PyPI. On Linux, for example, the Python 3.7 suffix `.cpython-37m-x86_64-linux-gnu.so` became `.cpython-38-x86_64-linux-gnu.so` in Python 3.8.
- The header files have been reorganized to better separate the different kinds of APIs:
- `Include/*.h` should be the portable public stable C API.
- `Include/cpython/*.h` should be the unstable C API specific to CPython; public API, with some private API prefixed by `_Py` or `_PY`.
- `Include/internal/*.h` is the private internal C API very specific to CPython. This API comes with no backward compatibility warranty and should not be used outside CPython. It is only exposed for very specific needs like debuggers and profiles which has to access to CPython internals without calling functions. This API is now installed by `make install`.
(Contributed by Victor Stinner in `35134`{.interpreted-text role="issue"} and `35081`{.interpreted-text role="issue"}, work initiated by Eric Snow in Python 3.7.)
- Some macros have been converted to static inline functions: parameter types and return type are well defined, they don\'t have issues specific to macros, variables have a local scopes. Examples:
- `Py_INCREF`{.interpreted-text role="c:func"}, `Py_DECREF`{.interpreted-text role="c:func"}
- `Py_XINCREF`{.interpreted-text role="c:func"}, `Py_XDECREF`{.interpreted-text role="c:func"}
- `!PyObject_INIT`{.interpreted-text role="c:macro"}, `!PyObject_INIT_VAR`{.interpreted-text role="c:macro"}
- Private functions: `!_PyObject_GC_TRACK`{.interpreted-text role="c:func"}, `!_PyObject_GC_UNTRACK`{.interpreted-text role="c:func"}, `!_Py_Dealloc`{.interpreted-text role="c:func"}
(Contributed by Victor Stinner in `35059`{.interpreted-text role="issue"}.)
- The `!PyByteArray_Init`{.interpreted-text role="c:func"} and `!PyByteArray_Fini`{.interpreted-text role="c:func"} functions have been removed. They did nothing since Python 2.7.4 and Python 3.2.0, were excluded from the limited API (stable ABI), and were not documented. (Contributed by Victor Stinner in `35713`{.interpreted-text role="issue"}.)
- The result of `PyExceptionClass_Name`{.interpreted-text role="c:func"} is now of type `const char *` rather of `char *`. (Contributed by Serhiy Storchaka in `33818`{.interpreted-text role="issue"}.)
- The duality of `Modules/Setup.dist` and `Modules/Setup` has been removed. Previously, when updating the CPython source tree, one had to manually copy `Modules/Setup.dist` (inside the source tree) to `Modules/Setup` (inside the build tree) in order to reflect any changes upstream. This was of a small benefit to packagers at the expense of a frequent annoyance to developers following CPython development, as forgetting to copy the file could produce build failures.
Now the build system always reads from `Modules/Setup` inside the source tree. People who want to customize that file are encouraged to maintain their changes in a git fork of CPython or as patch files, as they would do for any other change to the source tree.
(Contributed by Antoine Pitrou in `32430`{.interpreted-text role="issue"}.)
- Functions that convert Python number to C integer like `PyLong_AsLong`{.interpreted-text role="c:func"} and argument parsing functions like `PyArg_ParseTuple`{.interpreted-text role="c:func"} with integer converting format units like `'i'` will now use the `~object.__index__`{.interpreted-text role="meth"} special method instead of `~object.__int__`{.interpreted-text role="meth"}, if available. The deprecation warning will be emitted for objects with the `__int__()` method but without the `__index__()` method (like `~decimal.Decimal`{.interpreted-text role="class"} and `~fractions.Fraction`{.interpreted-text role="class"}). `PyNumber_Check`{.interpreted-text role="c:func"} will now return `1` for objects implementing `__index__()`. `PyNumber_Long`{.interpreted-text role="c:func"}, `PyNumber_Float`{.interpreted-text role="c:func"} and `PyFloat_AsDouble`{.interpreted-text role="c:func"} also now use the `__index__()` method if available. (Contributed by Serhiy Storchaka in `36048`{.interpreted-text role="issue"} and `20092`{.interpreted-text role="issue"}.)
- Heap-allocated type objects will now increase their reference count in `PyObject_Init`{.interpreted-text role="c:func"} (and its parallel macro `PyObject_INIT`) instead of in `PyType_GenericAlloc`{.interpreted-text role="c:func"}. Types that modify instance allocation or deallocation may need to be adjusted. (Contributed by Eddie Elizondo in `35810`{.interpreted-text role="issue"}.)
- The new function `!PyCode_NewWithPosOnlyArgs`{.interpreted-text role="c:func"} allows to create code objects like `!PyCode_New`{.interpreted-text role="c:func"}, but with an extra *posonlyargcount* parameter for indicating the number of positional-only arguments. (Contributed by Pablo Galindo in `37221`{.interpreted-text role="issue"}.)
- `!Py_SetPath`{.interpreted-text role="c:func"} now sets `sys.executable`{.interpreted-text role="data"} to the program full path (`!Py_GetProgramFullPath`{.interpreted-text role="c:func"}) rather than to the program name (`!Py_GetProgramName`{.interpreted-text role="c:func"}). (Contributed by Victor Stinner in `38234`{.interpreted-text role="issue"}.)
## Deprecated
- The distutils `bdist_wininst` command is now deprecated, use `bdist_wheel` (wheel packages) instead. (Contributed by Victor Stinner in `37481`{.interpreted-text role="issue"}.)
- Deprecated methods `getchildren()` and `getiterator()` in the `~xml.etree.ElementTree`{.interpreted-text role="mod"} module now emit a `DeprecationWarning`{.interpreted-text role="exc"} instead of `PendingDeprecationWarning`{.interpreted-text role="exc"}. They will be removed in Python 3.9. (Contributed by Serhiy Storchaka in `29209`{.interpreted-text role="issue"}.)
- Passing an object that is not an instance of `concurrent.futures.ThreadPoolExecutor`{.interpreted-text role="class"} to `loop.set_default_executor() <asyncio.loop.set_default_executor>`{.interpreted-text role="meth"} is deprecated and will be prohibited in Python 3.9. (Contributed by Elvis Pranskevichus in `34075`{.interpreted-text role="issue"}.)
- The `~object.__getitem__`{.interpreted-text role="meth"} methods of `xml.dom.pulldom.DOMEventStream`{.interpreted-text role="class"}, `wsgiref.util.FileWrapper`{.interpreted-text role="class"} and `fileinput.FileInput`{.interpreted-text role="class"} have been deprecated.
Implementations of these methods have been ignoring their *index* parameter, and returning the next item instead. (Contributed by Berker Peksag in `9372`{.interpreted-text role="issue"}.)
- The `typing.NamedTuple`{.interpreted-text role="class"} class has deprecated the `_field_types` attribute in favor of the `__annotations__` attribute which has the same information. (Contributed by Raymond Hettinger in `36320`{.interpreted-text role="issue"}.)
- `ast`{.interpreted-text role="mod"} classes `Num`, `Str`, `Bytes`, `NameConstant` and `Ellipsis` are considered deprecated and will be removed in future Python versions. `~ast.Constant`{.interpreted-text role="class"} should be used instead. (Contributed by Serhiy Storchaka in `32892`{.interpreted-text role="issue"}.)
- `ast.NodeVisitor`{.interpreted-text role="class"} methods `visit_Num()`, `visit_Str()`, `visit_Bytes()`, `visit_NameConstant()` and `visit_Ellipsis()` are deprecated now and will not be called in future Python versions. Add the `~ast.NodeVisitor.visit_Constant`{.interpreted-text role="meth"} method to handle all constant nodes. (Contributed by Serhiy Storchaka in `36917`{.interpreted-text role="issue"}.)
- The `!asyncio.coroutine`{.interpreted-text role="deco"} `decorator`{.interpreted-text role="term"} is deprecated and will be removed in version 3.10. Instead of `@asyncio.coroutine`, use `async def`{.interpreted-text role="keyword"} instead. (Contributed by Andrew Svetlov in `36921`{.interpreted-text role="issue"}.)
- In `asyncio`{.interpreted-text role="mod"}, the explicit passing of a *loop* argument has been deprecated and will be removed in version 3.10 for the following: `asyncio.sleep`{.interpreted-text role="func"}, `asyncio.gather`{.interpreted-text role="func"}, `asyncio.shield`{.interpreted-text role="func"}, `asyncio.wait_for`{.interpreted-text role="func"}, `asyncio.wait`{.interpreted-text role="func"}, `asyncio.as_completed`{.interpreted-text role="func"}, `asyncio.Task`{.interpreted-text role="class"}, `asyncio.Lock`{.interpreted-text role="class"}, `asyncio.Event`{.interpreted-text role="class"}, `asyncio.Condition`{.interpreted-text role="class"}, `asyncio.Semaphore`{.interpreted-text role="class"}, `asyncio.BoundedSemaphore`{.interpreted-text role="class"}, `asyncio.Queue`{.interpreted-text role="class"}, `asyncio.create_subprocess_exec`{.interpreted-text role="func"}, and `asyncio.create_subprocess_shell`{.interpreted-text role="func"}.
- The explicit passing of coroutine objects to `asyncio.wait`{.interpreted-text role="func"} has been deprecated and will be removed in version 3.11. (Contributed by Yury Selivanov in `34790`{.interpreted-text role="issue"}.)
- The following functions and methods are deprecated in the `gettext`{.interpreted-text role="mod"} module: `!lgettext`{.interpreted-text role="func"}, `!ldgettext`{.interpreted-text role="func"}, `!lngettext`{.interpreted-text role="func"} and `!ldngettext`{.interpreted-text role="func"}. They return encoded bytes, and it\'s possible that you will get unexpected Unicode-related exceptions if there are encoding problems with the translated strings. It\'s much better to use alternatives which return Unicode strings in Python 3. These functions have been broken for a long time.
Function `!bind_textdomain_codeset`{.interpreted-text role="func"}, methods `!NullTranslations.output_charset`{.interpreted-text role="meth"} and `!NullTranslations.set_output_charset`{.interpreted-text role="meth"}, and the *codeset* parameter of functions `~gettext.translation`{.interpreted-text role="func"} and `~gettext.install`{.interpreted-text role="func"} are also deprecated, since they are only used for the `l*gettext()` functions. (Contributed by Serhiy Storchaka in `33710`{.interpreted-text role="issue"}.)
- The `!isAlive`{.interpreted-text role="meth"} method of `threading.Thread`{.interpreted-text role="class"} has been deprecated. (Contributed by Donghee Na in `35283`{.interpreted-text role="issue"}.)
- Many builtin and extension functions that take integer arguments will now emit a deprecation warning for `~decimal.Decimal`{.interpreted-text role="class"}s, `~fractions.Fraction`{.interpreted-text role="class"}s and any other objects that can be converted to integers only with a loss (e.g. that have the `~object.__int__`{.interpreted-text role="meth"} method but do not have the `~object.__index__`{.interpreted-text role="meth"} method). In future version they will be errors. (Contributed by Serhiy Storchaka in `36048`{.interpreted-text role="issue"}.)
- Deprecated passing the following arguments as keyword arguments:
- *func* in `functools.partialmethod`{.interpreted-text role="func"}, `weakref.finalize`{.interpreted-text role="func"}, `profile.Profile.runcall`{.interpreted-text role="meth"}, `!cProfile.Profile.runcall`{.interpreted-text role="meth"}, `bdb.Bdb.runcall`{.interpreted-text role="meth"}, `trace.Trace.runfunc`{.interpreted-text role="meth"} and `curses.wrapper`{.interpreted-text role="func"}.
- *function* in `unittest.TestCase.addCleanup`{.interpreted-text role="meth"}.
- *fn* in the `~concurrent.futures.Executor.submit`{.interpreted-text role="meth"} method of `concurrent.futures.ThreadPoolExecutor`{.interpreted-text role="class"} and `concurrent.futures.ProcessPoolExecutor`{.interpreted-text role="class"}.
- *callback* in `contextlib.ExitStack.callback`{.interpreted-text role="meth"}, `!contextlib.AsyncExitStack.callback`{.interpreted-text role="meth"} and `contextlib.AsyncExitStack.push_async_callback`{.interpreted-text role="meth"}.
- *c* and *typeid* in the `!create`{.interpreted-text role="meth"} method of `!multiprocessing.managers.Server`{.interpreted-text role="class"} and `!multiprocessing.managers.SharedMemoryServer`{.interpreted-text role="class"}.
- *obj* in `weakref.finalize`{.interpreted-text role="func"}.
In future releases of Python, they will be `positional-only
<positional-only_parameter>`{.interpreted-text role="ref"}. (Contributed by Serhiy Storchaka in `36492`{.interpreted-text role="issue"}.)
## API and Feature Removals
The following features and APIs have been removed from Python 3.8:
- Starting with Python 3.3, importing ABCs from `collections`{.interpreted-text role="mod"} was deprecated, and importing should be done from `collections.abc`{.interpreted-text role="mod"}. Being able to import from collections was marked for removal in 3.8, but has been delayed to 3.9. (See `81134`{.interpreted-text role="gh"}.)
- The `!macpath`{.interpreted-text role="mod"} module, deprecated in Python 3.7, has been removed. (Contributed by Victor Stinner in `35471`{.interpreted-text role="issue"}.)
- The function `!platform.popen`{.interpreted-text role="func"} has been removed, after having been deprecated since Python 3.3: use `os.popen`{.interpreted-text role="func"} instead. (Contributed by Victor Stinner in `35345`{.interpreted-text role="issue"}.)
- The function `!time.clock`{.interpreted-text role="func"} has been removed, after having been deprecated since Python 3.3: use `time.perf_counter`{.interpreted-text role="func"} or `time.process_time`{.interpreted-text role="func"} instead, depending on your requirements, to have well-defined behavior. (Contributed by Matthias Bussonnier in `36895`{.interpreted-text role="issue"}.)
- The `pyvenv` script has been removed in favor of `python3.8 -m venv` to help eliminate confusion as to what Python interpreter the `pyvenv` script is tied to. (Contributed by Brett Cannon in `25427`{.interpreted-text role="issue"}.)
- `parse_qs`, `parse_qsl`, and `escape` are removed from the `!cgi`{.interpreted-text role="mod"} module. They are deprecated in Python 3.2 or older. They should be imported from the `urllib.parse` and `html` modules instead.
- `filemode` function is removed from the `tarfile`{.interpreted-text role="mod"} module. It is not documented and deprecated since Python 3.3.
- The `~xml.etree.ElementTree.XMLParser`{.interpreted-text role="class"} constructor no longer accepts the *html* argument. It never had an effect and was deprecated in Python 3.4. All other parameters are now `keyword-only <keyword-only_parameter>`{.interpreted-text role="ref"}. (Contributed by Serhiy Storchaka in `29209`{.interpreted-text role="issue"}.)
- Removed the `doctype()` method of `~xml.etree.ElementTree.XMLParser`{.interpreted-text role="class"}. (Contributed by Serhiy Storchaka in `29209`{.interpreted-text role="issue"}.)
- \"unicode_internal\" codec is removed. (Contributed by Inada Naoki in `36297`{.interpreted-text role="issue"}.)
- The `Cache` and `Statement` objects of the `sqlite3`{.interpreted-text role="mod"} module are not exposed to the user. (Contributed by Aviv Palivoda in `30262`{.interpreted-text role="issue"}.)
- The `bufsize` keyword argument of `fileinput.input`{.interpreted-text role="func"} and `fileinput.FileInput`{.interpreted-text role="func"} which was ignored and deprecated since Python 3.6 has been removed. `36952`{.interpreted-text role="issue"} (Contributed by Matthias Bussonnier.)
- The functions `!sys.set_coroutine_wrapper`{.interpreted-text role="func"} and `!sys.get_coroutine_wrapper`{.interpreted-text role="func"} deprecated in Python 3.7 have been removed; `36933`{.interpreted-text role="issue"} (Contributed by Matthias Bussonnier.)
## Porting to Python 3.8
This section lists previously described changes and other bugfixes that may require changes to your code.
### Changes in Python behavior
- Yield expressions (both `yield` and `yield from` clauses) are now disallowed in comprehensions and generator expressions (aside from the iterable expression in the leftmost `!for`{.interpreted-text role="keyword"} clause). (Contributed by Serhiy Storchaka in `10544`{.interpreted-text role="issue"}.)
- The compiler now produces a `SyntaxWarning`{.interpreted-text role="exc"} when identity checks (`is` and `is not`) are used with certain types of literals (e.g. strings, numbers). These can often work by accident in CPython, but are not guaranteed by the language spec. The warning advises users to use equality tests (`==` and `!=`) instead. (Contributed by Serhiy Storchaka in `34850`{.interpreted-text role="issue"}.)
- The CPython interpreter can swallow exceptions in some circumstances. In Python 3.8 this happens in fewer cases. In particular, exceptions raised when getting the attribute from the type dictionary are no longer ignored. (Contributed by Serhiy Storchaka in `35459`{.interpreted-text role="issue"}.)
- Removed `__str__` implementations from builtin types `bool`{.interpreted-text role="class"}, `int`{.interpreted-text role="class"}, `float`{.interpreted-text role="class"}, `complex`{.interpreted-text role="class"} and few classes from the standard library. They now inherit `__str__()` from `object`{.interpreted-text role="class"}. As result, defining the `__repr__()` method in the subclass of these classes will affect their string representation. (Contributed by Serhiy Storchaka in `36793`{.interpreted-text role="issue"}.)
- On AIX, `sys.platform`{.interpreted-text role="data"} doesn\'t contain the major version anymore. It is always `'aix'`, instead of `'aix3'` .. `'aix7'`. Since older Python versions include the version number, so it is recommended to always use `sys.platform.startswith('aix')`. (Contributed by M. Felt in `36588`{.interpreted-text role="issue"}.)
- `!PyEval_AcquireLock`{.interpreted-text role="c:func"} and `!PyEval_AcquireThread`{.interpreted-text role="c:func"} now terminate the current thread if called while the interpreter is finalizing, making them consistent with `PyEval_RestoreThread`{.interpreted-text role="c:func"}, `Py_END_ALLOW_THREADS`{.interpreted-text role="c:func"}, and `PyGILState_Ensure`{.interpreted-text role="c:func"}. If this behavior is not desired, guard the call by checking `!_Py_IsFinalizing`{.interpreted-text role="c:func"} or `sys.is_finalizing`{.interpreted-text role="func"}. (Contributed by Joannah Nanjekye in `36475`{.interpreted-text role="issue"}.)
### Changes in the Python API
- The `os.getcwdb`{.interpreted-text role="func"} function now uses the UTF-8 encoding on Windows, rather than the ANSI code page: see `529`{.interpreted-text role="pep"} for the rationale. The function is no longer deprecated on Windows. (Contributed by Victor Stinner in `37412`{.interpreted-text role="issue"}.)
- `subprocess.Popen`{.interpreted-text role="class"} can now use `os.posix_spawn`{.interpreted-text role="func"} in some cases for better performance. On Windows Subsystem for Linux and QEMU User Emulation, the `~subprocess.Popen`{.interpreted-text role="class"} constructor using `os.posix_spawn`{.interpreted-text role="func"} no longer raises an exception on errors like \"missing program\". Instead the child process fails with a non-zero `~subprocess.Popen.returncode`{.interpreted-text role="attr"}. (Contributed by Joannah Nanjekye and Victor Stinner in `35537`{.interpreted-text role="issue"}.)
- The *preexec_fn* argument of \* `subprocess.Popen`{.interpreted-text role="class"} is no longer compatible with subinterpreters. The use of the parameter in a subinterpreter now raises `RuntimeError`{.interpreted-text role="exc"}. (Contributed by Eric Snow in `34651`{.interpreted-text role="issue"}, modified by Christian Heimes in `37951`{.interpreted-text role="issue"}.)
- The `imaplib.IMAP4.logout`{.interpreted-text role="meth"} method no longer silently ignores arbitrary exceptions. (Contributed by Victor Stinner in `36348`{.interpreted-text role="issue"}.)
- The function `!platform.popen`{.interpreted-text role="func"} has been removed, after having been deprecated since Python 3.3: use `os.popen`{.interpreted-text role="func"} instead. (Contributed by Victor Stinner in `35345`{.interpreted-text role="issue"}.)
- The `statistics.mode`{.interpreted-text role="func"} function no longer raises an exception when given multimodal data. Instead, it returns the first mode encountered in the input data. (Contributed by Raymond Hettinger in `35892`{.interpreted-text role="issue"}.)
- The `~tkinter.ttk.Treeview.selection`{.interpreted-text role="meth"} method of the `tkinter.ttk.Treeview`{.interpreted-text role="class"} class no longer takes arguments. Using it with arguments for changing the selection was deprecated in Python 3.6. Use specialized methods like `~tkinter.ttk.Treeview.selection_set`{.interpreted-text role="meth"} for changing the selection. (Contributed by Serhiy Storchaka in `31508`{.interpreted-text role="issue"}.)
- The `~xml.dom.minidom.Node.writexml`{.interpreted-text role="meth"}, `~xml.dom.minidom.Node.toxml`{.interpreted-text role="meth"} and `~xml.dom.minidom.Node.toprettyxml`{.interpreted-text role="meth"} methods of `xml.dom.minidom`{.interpreted-text role="mod"} and the `~xml.etree.ElementTree.ElementTree.write`{.interpreted-text role="meth"} method of `xml.etree.ElementTree`{.interpreted-text role="mod"} now preserve the attribute order specified by the user. (Contributed by Diego Rojas and Raymond Hettinger in `34160`{.interpreted-text role="issue"}.)
- A `dbm.dumb`{.interpreted-text role="mod"} database opened with flags `'r'` is now read-only. `dbm.dumb.open`{.interpreted-text role="func"} with flags `'r'` and `'w'` no longer creates a database if it does not exist. (Contributed by Serhiy Storchaka in `32749`{.interpreted-text role="issue"}.)
- The `doctype()` method defined in a subclass of `~xml.etree.ElementTree.XMLParser`{.interpreted-text role="class"} will no longer be called and will emit a `RuntimeWarning`{.interpreted-text role="exc"} instead of a `DeprecationWarning`{.interpreted-text role="exc"}. Define the `doctype() <xml.etree.ElementTree.TreeBuilder.doctype>`{.interpreted-text role="meth"} method on a target for handling an XML doctype declaration. (Contributed by Serhiy Storchaka in `29209`{.interpreted-text role="issue"}.)
- A `RuntimeError`{.interpreted-text role="exc"} is now raised when the custom metaclass doesn\'t provide the `__classcell__` entry in the namespace passed to `type.__new__`. A `DeprecationWarning`{.interpreted-text role="exc"} was emitted in Python 3.6\--3.7. (Contributed by Serhiy Storchaka in `23722`{.interpreted-text role="issue"}.)
- The `cProfile.Profile <profile.Profile>`{.interpreted-text role="class"} class can now be used as a context manager. (Contributed by Scott Sanderson in `29235`{.interpreted-text role="issue"}.)
- `shutil.copyfile`{.interpreted-text role="func"}, `shutil.copy`{.interpreted-text role="func"}, `shutil.copy2`{.interpreted-text role="func"}, `shutil.copytree`{.interpreted-text role="func"} and `shutil.move`{.interpreted-text role="func"} use platform-specific \"fast-copy\" syscalls (see `shutil-platform-dependent-efficient-copy-operations`{.interpreted-text role="ref"} section).
- `shutil.copyfile`{.interpreted-text role="func"} default buffer size on Windows was changed from 16 KiB to 1 MiB.
- The `PyGC_Head` struct has changed completely. All code that touched the struct member should be rewritten. (See `33597`{.interpreted-text role="issue"}.)
- The `PyInterpreterState`{.interpreted-text role="c:type"} struct has been moved into the \"internal\" header files (specifically Include/internal/pycore_pystate.h). An opaque `PyInterpreterState` is still available as part of the public API (and stable ABI). The docs indicate that none of the struct\'s fields are public, so we hope no one has been using them. However, if you do rely on one or more of those private fields and have no alternative then please open a BPO issue. We\'ll work on helping you adjust (possibly including adding accessor functions to the public API). (See `35886`{.interpreted-text role="issue"}.)
- The `mmap.flush() <mmap.mmap.flush>`{.interpreted-text role="meth"} method now returns `None` on success and raises an exception on error under all platforms. Previously, its behavior was platform-dependent: a nonzero value was returned on success; zero was returned on error under Windows. A zero value was returned on success; an exception was raised on error under Unix. (Contributed by Berker Peksag in `2122`{.interpreted-text role="issue"}.)
- `xml.dom.minidom`{.interpreted-text role="mod"} and `xml.sax`{.interpreted-text role="mod"} modules no longer process external entities by default. (Contributed by Christian Heimes in `17239`{.interpreted-text role="issue"}.)
- Deleting a key from a read-only `dbm`{.interpreted-text role="mod"} database (`dbm.dumb`{.interpreted-text role="mod"}, `dbm.gnu`{.interpreted-text role="mod"} or `dbm.ndbm`{.interpreted-text role="mod"}) raises `!error`{.interpreted-text role="attr"} (`dbm.dumb.error`{.interpreted-text role="exc"}, `dbm.gnu.error`{.interpreted-text role="exc"} or `dbm.ndbm.error`{.interpreted-text role="exc"}) instead of `KeyError`{.interpreted-text role="exc"}. (Contributed by Xiang Zhang in `33106`{.interpreted-text role="issue"}.)
- Simplified AST for literals. All constants will be represented as `ast.Constant`{.interpreted-text role="class"} instances. Instantiating old classes `Num`, `Str`, `Bytes`, `NameConstant` and `Ellipsis` will return an instance of `Constant`. (Contributed by Serhiy Storchaka in `32892`{.interpreted-text role="issue"}.)
- `~os.path.expanduser`{.interpreted-text role="func"} on Windows now prefers the `USERPROFILE`{.interpreted-text role="envvar"} environment variable and does not use `HOME`{.interpreted-text role="envvar"}, which is not normally set for regular user accounts. (Contributed by Anthony Sottile in `36264`{.interpreted-text role="issue"}.)
- The exception `asyncio.CancelledError`{.interpreted-text role="class"} now inherits from `BaseException`{.interpreted-text role="class"} rather than `Exception`{.interpreted-text role="class"} and no longer inherits from `concurrent.futures.CancelledError`{.interpreted-text role="class"}. (Contributed by Yury Selivanov in `32528`{.interpreted-text role="issue"}.)
- The function `asyncio.wait_for`{.interpreted-text role="func"} now correctly waits for cancellation when using an instance of `asyncio.Task`{.interpreted-text role="class"}. Previously, upon reaching *timeout*, it was cancelled and immediately returned. (Contributed by Elvis Pranskevichus in `32751`{.interpreted-text role="issue"}.)
- The function `asyncio.BaseTransport.get_extra_info`{.interpreted-text role="func"} now returns a safe to use socket object when \'socket\' is passed to the *name* parameter. (Contributed by Yury Selivanov in `37027`{.interpreted-text role="issue"}.)
- `asyncio.BufferedProtocol`{.interpreted-text role="class"} has graduated to the stable API.
::: {#bpo-36085-whatsnew}
- DLL dependencies for extension modules and DLLs loaded with `ctypes`{.interpreted-text role="mod"} on Windows are now resolved more securely. Only the system paths, the directory containing the DLL or PYD file, and directories added with `~os.add_dll_directory`{.interpreted-text role="func"} are searched for load-time dependencies. Specifically, `PATH`{.interpreted-text role="envvar"} and the current working directory are no longer used, and modifications to these will no longer have any effect on normal DLL resolution. If your application relies on these mechanisms, you should check for `~os.add_dll_directory`{.interpreted-text role="func"} and if it exists, use it to add your DLLs directory while loading your library. Note that Windows 7 users will need to ensure that Windows Update KB2533623 has been installed (this is also verified by the installer). (Contributed by Steve Dower in `36085`{.interpreted-text role="issue"}.)
- The header files and functions related to pgen have been removed after its replacement by a pure Python implementation. (Contributed by Pablo Galindo in `36623`{.interpreted-text role="issue"}.)
- `types.CodeType`{.interpreted-text role="class"} has a new parameter in the second position of the constructor (*posonlyargcount*) to support positional-only arguments defined in `570`{.interpreted-text role="pep"}. The first argument (*argcount*) now represents the total number of positional arguments (including positional-only arguments). The new `replace()` method of `types.CodeType`{.interpreted-text role="class"} can be used to make the code future-proof.
- The parameter `digestmod` for `hmac.new`{.interpreted-text role="func"} no longer uses the MD5 digest by default.
:::
### Changes in the C API
- The `PyCompilerFlags`{.interpreted-text role="c:struct"} structure got a new *cf_feature_version* field. It should be initialized to `PY_MINOR_VERSION`. The field is ignored by default, and is used if and only if `PyCF_ONLY_AST` flag is set in *cf_flags*. (Contributed by Guido van Rossum in `35766`{.interpreted-text role="issue"}.)
- The `!PyEval_ReInitThreads`{.interpreted-text role="c:func"} function has been removed from the C API. It should not be called explicitly: use `PyOS_AfterFork_Child`{.interpreted-text role="c:func"} instead. (Contributed by Victor Stinner in `36728`{.interpreted-text role="issue"}.)
- On Unix, C extensions are no longer linked to libpython except on Android and Cygwin. When Python is embedded, `libpython` must not be loaded with `RTLD_LOCAL`, but `RTLD_GLOBAL` instead. Previously, using `RTLD_LOCAL`, it was already not possible to load C extensions which were not linked to `libpython`, like C extensions of the standard library built by the `*shared*` section of `Modules/Setup`. (Contributed by Victor Stinner in `21536`{.interpreted-text role="issue"}.)
- Use of `#` variants of formats in parsing or building value (e.g. `PyArg_ParseTuple`{.interpreted-text role="c:func"}, `Py_BuildValue`{.interpreted-text role="c:func"}, `PyObject_CallFunction`{.interpreted-text role="c:func"}, etc.) without `PY_SSIZE_T_CLEAN` defined raises `DeprecationWarning` now. It will be removed in 3.10 or 4.0. Read `arg-parsing`{.interpreted-text role="ref"} for detail. (Contributed by Inada Naoki in `36381`{.interpreted-text role="issue"}.)
- Instances of heap-allocated types (such as those created with `PyType_FromSpec`{.interpreted-text role="c:func"}) hold a reference to their type object. Increasing the reference count of these type objects has been moved from `PyType_GenericAlloc`{.interpreted-text role="c:func"} to the more low-level functions, `PyObject_Init`{.interpreted-text role="c:func"} and `!PyObject_INIT`{.interpreted-text role="c:macro"}. This makes types created through `PyType_FromSpec`{.interpreted-text role="c:func"} behave like other classes in managed code.
`Statically allocated types <static-types>`{.interpreted-text role="ref"} are not affected.
For the vast majority of cases, there should be no side effect. However, types that manually increase the reference count after allocating an instance (perhaps to work around the bug) may now become immortal. To avoid this, these classes need to call Py_DECREF on the type object during instance deallocation.
To correctly port these types into 3.8, please apply the following changes:
- Remove `Py_INCREF`{.interpreted-text role="c:macro"} on the type object after allocating an instance - if any. This may happen after calling `PyObject_New`{.interpreted-text role="c:macro"}, `PyObject_NewVar`{.interpreted-text role="c:macro"}, `PyObject_GC_New`{.interpreted-text role="c:func"}, `PyObject_GC_NewVar`{.interpreted-text role="c:func"}, or any other custom allocator that uses `PyObject_Init`{.interpreted-text role="c:func"} or `!PyObject_INIT`{.interpreted-text role="c:macro"}.
Example:
``` c
static foo_struct *
foo_new(PyObject *type) {
foo_struct *foo = PyObject_GC_New(foo_struct, (PyTypeObject *) type);
if (foo == NULL)
return NULL;
#if PY_VERSION_HEX < 0x03080000
// Workaround for Python issue 35810; no longer necessary in Python 3.8
PY_INCREF(type)
#endif
return foo;
}
```
- Ensure that all custom `tp_dealloc` functions of heap-allocated types decrease the type\'s reference count.
Example:
``` c
static void
foo_dealloc(foo_struct *instance) {
PyObject *type = Py_TYPE(instance);
PyObject_GC_Del(instance);
#if PY_VERSION_HEX >= 0x03080000
// This was not needed before Python 3.8 (Python issue 35810)
Py_DECREF(type);
#endif
}
```
(Contributed by Eddie Elizondo in `35810`{.interpreted-text role="issue"}.)
- The `Py_DEPRECATED()`{.interpreted-text role="c:macro"} macro has been implemented for MSVC. The macro now must be placed before the symbol name.
Example:
``` c
Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void);
```
(Contributed by Zackery Spytz in `33407`{.interpreted-text role="issue"}.)
- The interpreter does not pretend to support binary compatibility of extension types across feature releases, anymore. A `PyTypeObject`{.interpreted-text role="c:type"} exported by a third-party extension module is supposed to have all the slots expected in the current Python version, including `~PyTypeObject.tp_finalize`{.interpreted-text role="c:member"} (`Py_TPFLAGS_HAVE_FINALIZE`{.interpreted-text role="c:macro"} is not checked anymore before reading `~PyTypeObject.tp_finalize`{.interpreted-text role="c:member"}).
(Contributed by Antoine Pitrou in `32388`{.interpreted-text role="issue"}.)
- The functions `!PyNode_AddChild`{.interpreted-text role="c:func"} and `!PyParser_AddToken`{.interpreted-text role="c:func"} now accept two additional `int` arguments *end_lineno* and *end_col_offset*.
- The `libpython38.a`{.interpreted-text role="file"} file to allow MinGW tools to link directly against `python38.dll`{.interpreted-text role="file"} is no longer included in the regular Windows distribution. If you require this file, it may be generated with the `gendef` and `dlltool` tools, which are part of the MinGW binutils package:
``` shell
gendef - python38.dll > tmp.def
dlltool --dllname python38.dll --def tmp.def --output-lib libpython38.a
```
The location of an installed `pythonXY.dll`{.interpreted-text role="file"} will depend on the installation options and the version and language of Windows. See `using-on-windows`{.interpreted-text role="ref"} for more information. The resulting library should be placed in the same directory as `pythonXY.lib`{.interpreted-text role="file"}, which is generally the `libs`{.interpreted-text role="file"} directory under your Python installation.
(Contributed by Steve Dower in `37351`{.interpreted-text role="issue"}.)
### CPython bytecode changes
- The interpreter loop has been simplified by moving the logic of unrolling the stack of blocks into the compiler. The compiler emits now explicit instructions for adjusting the stack of values and calling the cleaning-up code for `break`{.interpreted-text role="keyword"}, `continue`{.interpreted-text role="keyword"} and `return`{.interpreted-text role="keyword"}.
Removed opcodes `!BREAK_LOOP`{.interpreted-text role="opcode"}, `!CONTINUE_LOOP`{.interpreted-text role="opcode"}, `!SETUP_LOOP`{.interpreted-text role="opcode"} and `!SETUP_EXCEPT`{.interpreted-text role="opcode"}. Added new opcodes `!ROT_FOUR`{.interpreted-text role="opcode"}, `!BEGIN_FINALLY`{.interpreted-text role="opcode"}, `!CALL_FINALLY`{.interpreted-text role="opcode"} and `!POP_FINALLY`{.interpreted-text role="opcode"}. Changed the behavior of `!END_FINALLY`{.interpreted-text role="opcode"} and `!WITH_CLEANUP_START`{.interpreted-text role="opcode"}.
(Contributed by Mark Shannon, Antoine Pitrou and Serhiy Storchaka in `17611`{.interpreted-text role="issue"}.)
- Added new opcode `END_ASYNC_FOR`{.interpreted-text role="opcode"} for handling exceptions raised when awaiting a next item in an `async for`{.interpreted-text role="keyword"} loop. (Contributed by Serhiy Storchaka in `33041`{.interpreted-text role="issue"}.)
- The `MAP_ADD`{.interpreted-text role="opcode"} now expects the value as the first element in the stack and the key as the second element. This change was made so the key is always evaluated before the value in dictionary comprehensions, as proposed by `572`{.interpreted-text role="pep"}. (Contributed by Jörn Heissler in `35224`{.interpreted-text role="issue"}.)
### Demos and Tools
Added a benchmark script for timing various ways to access variables: `Tools/scripts/var_access_benchmark.py`. (Contributed by Raymond Hettinger in `35884`{.interpreted-text role="issue"}.)
Here\'s a summary of performance improvements since Python 3.3:
``` none
Python version 3.3 3.4 3.5 3.6 3.7 3.8
-------------- --- --- --- --- --- ---
Variable and attribute read access:
read_local 4.0 7.1 7.1 5.4 5.1 3.9
read_nonlocal 5.3 7.1 8.1 5.8 5.4 4.4
read_global 13.3 15.5 19.0 14.3 13.6 7.6
read_builtin 20.0 21.1 21.6 18.5 19.0 7.5
read_classvar_from_class 20.5 25.6 26.5 20.7 19.5 18.4
read_classvar_from_instance 18.5 22.8 23.5 18.8 17.1 16.4
read_instancevar 26.8 32.4 33.1 28.0 26.3 25.4
read_instancevar_slots 23.7 27.8 31.3 20.8 20.8 20.2
read_namedtuple 68.5 73.8 57.5 45.0 46.8 18.4
read_boundmethod 29.8 37.6 37.9 29.6 26.9 27.7
Variable and attribute write access:
write_local 4.6 8.7 9.3 5.5 5.3 4.3
write_nonlocal 7.3 10.5 11.1 5.6 5.5 4.7
write_global 15.9 19.7 21.2 18.0 18.0 15.8
write_classvar 81.9 92.9 96.0 104.6 102.1 39.2
write_instancevar 36.4 44.6 45.8 40.0 38.9 35.5
write_instancevar_slots 28.7 35.6 36.1 27.3 26.6 25.7
Data structure read access:
read_list 19.2 24.2 24.5 20.8 20.8 19.0
read_deque 19.9 24.7 25.5 20.2 20.6 19.8
read_dict 19.7 24.3 25.7 22.3 23.0 21.0
read_strdict 17.9 22.6 24.3 19.5 21.2 18.9
Data structure write access:
write_list 21.2 27.1 28.5 22.5 21.6 20.0
write_deque 23.8 28.7 30.1 22.7 21.8 23.5
write_dict 25.9 31.4 33.3 29.3 29.2 24.7
write_strdict 22.9 28.4 29.9 27.5 25.2 23.1
Stack (or queue) operations:
list_append_pop 144.2 93.4 112.7 75.4 74.2 50.8
deque_append_pop 30.4 43.5 57.0 49.4 49.2 42.5
deque_append_popleft 30.8 43.7 57.3 49.7 49.7 42.8
Timing loop:
loop_overhead 0.3 0.5 0.6 0.4 0.3 0.3
```
The benchmarks were measured on an [Intel® Core™ i7-4960HQ processor](https://ark.intel.com/content/www/us/en/ark/products/76088/intel-core-i7-4960hq-processor-6m-cache-up-to-3-80-ghz.html) running the macOS 64-bit builds found at [python.org](https://www.python.org/downloads/macos/). The benchmark script displays timings in nanoseconds.
## Notable changes in Python 3.8.1
Due to significant security concerns, the *reuse_address* parameter of `asyncio.loop.create_datagram_endpoint`{.interpreted-text role="meth"} is no longer supported. This is because of the behavior of the socket option `SO_REUSEADDR` in UDP. For more details, see the documentation for `loop.create_datagram_endpoint()`. (Contributed by Kyle Stanley, Antoine Pitrou, and Yury Selivanov in `37228`{.interpreted-text role="issue"}.)
## Notable changes in Python 3.8.2
Fixed a regression with the `ignore` callback of `shutil.copytree`{.interpreted-text role="func"}. The argument types are now str and List\[str\] again. (Contributed by Manuel Barkhau and Giampaolo Rodola in `83571`{.interpreted-text role="gh"}.)
## Notable changes in Python 3.8.3
The constant values of future flags in the `__future__`{.interpreted-text role="mod"} module are updated in order to prevent collision with compiler flags. Previously `PyCF_ALLOW_TOP_LEVEL_AWAIT` was clashing with `CO_FUTURE_DIVISION`. (Contributed by Batuhan Taskaya in `83743`{.interpreted-text role="gh"})
## Notable changes in Python 3.8.8
Earlier Python versions allowed using both `;` and `&` as query parameter separators in `urllib.parse.parse_qs`{.interpreted-text role="func"} and `urllib.parse.parse_qsl`{.interpreted-text role="func"}. Due to security concerns, and to conform with newer W3C recommendations, this has been changed to allow only a single separator key, with `&` as the default. This change also affects `!cgi.parse`{.interpreted-text role="func"} and `!cgi.parse_multipart`{.interpreted-text role="func"} as they use the affected functions internally. For more details, please see their respective documentation. (Contributed by Adam Goldschmidt, Senthil Kumaran and Ken Jin in `42967`{.interpreted-text role="issue"}.)
## Notable changes in Python 3.8.9
A security fix alters the `ftplib.FTP`{.interpreted-text role="class"} behavior to not trust the IPv4 address sent from the remote server when setting up a passive data channel. We reuse the ftp server IP address instead. For unusual code requiring the old behavior, set a `trust_server_pasv_ipv4_address` attribute on your FTP instance to `True`. (See `87451`{.interpreted-text role="gh"})
## Notable changes in Python 3.8.10
### macOS 11.0 (Big Sur) and Apple Silicon Mac support
As of 3.8.10, Python now supports building and running on macOS 11 (Big Sur) and on Apple Silicon Macs (based on the `ARM64` architecture). A new universal build variant, `universal2`, is now available to natively support both `ARM64` and `Intel 64` in one set of executables. Note that support for \"weaklinking\", building binaries targeted for newer versions of macOS that will also run correctly on older versions by testing at runtime for missing features, is not included in this backport from Python 3.9; to support a range of macOS versions, continue to target for and build on the oldest version in the range.
(Originally contributed by Ronald Oussoren and Lawrence D\'Anna in `85272`{.interpreted-text role="gh"}, with fixes by FX Coudert and Eli Rykoff, and backported to 3.8 by Maxime Bélanger and Ned Deily)
## Notable changes in Python 3.8.10
### urllib.parse
The presence of newline or tab characters in parts of a URL allows for some forms of attacks. Following the WHATWG specification that updates `3986`{.interpreted-text role="rfc"}, ASCII newline `\n`, `\r` and tab `\t` characters are stripped from the URL by the parser in `urllib.parse`{.interpreted-text role="mod"} preventing such attacks. The removal characters are controlled by a new module level variable `urllib.parse._UNSAFE_URL_BYTES_TO_REMOVE`. (See `43882`{.interpreted-text role="issue"})
## Notable changes in Python 3.8.12
### Changes in the Python API
Starting with Python 3.8.12 the `ipaddress`{.interpreted-text role="mod"} module no longer accepts any leading zeros in IPv4 address strings. Leading zeros are ambiguous and interpreted as octal notation by some libraries. For example the legacy function `socket.inet_aton`{.interpreted-text role="func"} treats leading zeros as octal notation. glibc implementation of modern `~socket.inet_pton`{.interpreted-text role="func"} does not accept any leading zeros.
(Originally contributed by Christian Heimes in `36384`{.interpreted-text role="issue"}, and backported to 3.8 by Achraf Merzouki.)
## Notable security feature in 3.8.14
Converting between `int`{.interpreted-text role="class"} and `str`{.interpreted-text role="class"} in bases other than 2 (binary), 4, 8 (octal), 16 (hexadecimal), or 32 such as base 10 (decimal) now raises a `ValueError`{.interpreted-text role="exc"} if the number of digits in string form is above a limit to avoid potential denial of service attacks due to the algorithmic complexity. This is a mitigation for `2020-10735`{.interpreted-text role="cve"}. This limit can be configured or disabled by environment variable, command line flag, or `sys`{.interpreted-text role="mod"} APIs. See the `integer string conversion
length limitation <int_max_str_digits>`{.interpreted-text role="ref"} documentation. The default limit is 4300 digits in string form.
## Notable changes in 3.8.17
### tarfile
- The extraction methods in `tarfile`{.interpreted-text role="mod"}, and `shutil.unpack_archive`{.interpreted-text role="func"}, have a new a *filter* argument that allows limiting tar features than may be surprising or dangerous, such as creating files outside the destination directory. See `tarfile-extraction-filter`{.interpreted-text role="ref"} for details. In Python 3.12, use without the *filter* argument will show a `DeprecationWarning`{.interpreted-text role="exc"}. In Python 3.14, the default will switch to `'data'`. (Contributed by Petr Viktorin in `706`{.interpreted-text role="pep"}.)
|