Compare commits
1 Commits
master
...
buildbot-c
| Author | SHA1 | Date |
|---|---|---|
Pablo Galindo
|
69c37a6918 |
|
|
@ -12,7 +12,7 @@ steps:
|
|||
inputs:
|
||||
versionSpec: '>=3.6'
|
||||
|
||||
- script: python -m pip install sphinx==3.2.1 blurb python-docs-theme
|
||||
- script: python -m pip install sphinx==2.2.0 blurb python-docs-theme
|
||||
displayName: 'Install build dependencies'
|
||||
|
||||
- ${{ if ne(parameters.latex, 'true') }}:
|
||||
|
|
@ -31,7 +31,7 @@ steps:
|
|||
- ${{ if eq(parameters.upload, 'true') }}:
|
||||
- task: PublishBuildArtifacts@1
|
||||
displayName: 'Publish docs'
|
||||
|
||||
|
||||
inputs:
|
||||
PathToPublish: '$(build.sourcesDirectory)/Doc/build'
|
||||
ArtifactName: docs
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ Objects/frameobject.c @markshannon
|
|||
Objects/call.c @markshannon
|
||||
Python/ceval.c @markshannon
|
||||
Python/compile.c @markshannon
|
||||
Python/ast_opt.c @isidentical
|
||||
|
||||
# Hashing
|
||||
**/*hashlib* @python/crypto-team @tiran
|
||||
|
|
@ -85,12 +84,6 @@ Include/pytime.h @pganssle @abalkin
|
|||
/Lib/test/test_peg_generator/ @pablogsal @lysnikolaou
|
||||
/Grammar/python.gram @pablogsal @lysnikolaou
|
||||
|
||||
# AST
|
||||
Python/ast.c @isidentical
|
||||
Parser/asdl.py @isidentical
|
||||
Parser/asdl_c.py @isidentical
|
||||
Lib/ast.py @isidentical
|
||||
|
||||
# SQLite 3
|
||||
**/*sqlite* @berkerpeksag
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,3 @@ updates:
|
|||
labels:
|
||||
- "skip issue"
|
||||
- "skip news"
|
||||
target_branch:
|
||||
- "master"
|
||||
- "3.9"
|
||||
- "3.8"
|
||||
|
|
|
|||
|
|
@ -1,19 +0,0 @@
|
|||
{
|
||||
"__comment": "Taken from vscode's vs/workbench/contrib/tasks/common/problemMatcher.ts msCompile rule",
|
||||
"problemMatcher": [
|
||||
{
|
||||
"owner": "msvc-problem-matcher",
|
||||
"pattern": [
|
||||
{
|
||||
"regexp": "^(?:\\s+\\d+\\>)?([^\\s].*)\\((\\d+),?(\\d+)?(?:,\\d+,\\d+)?\\)\\s*:\\s+(error|warning|info)\\s+(\\w{1,2}\\d+)\\s*:\\s*(.*)$",
|
||||
"file": 1,
|
||||
"line": 2,
|
||||
"column": 3,
|
||||
"severity": 4,
|
||||
"code": 5,
|
||||
"message": 6
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
@ -28,7 +28,7 @@ jobs:
|
|||
- name: Check for source changes
|
||||
id: check
|
||||
run: |
|
||||
if [ -z "$GITHUB_BASE_REF" ]; then
|
||||
if [ -z "GITHUB_BASE_REF" ]; then
|
||||
echo '::set-output name=run_tests::true'
|
||||
else
|
||||
git fetch origin $GITHUB_BASE_REF --depth=1
|
||||
|
|
@ -75,8 +75,6 @@ jobs:
|
|||
fi
|
||||
- name: Check exported libpython symbols
|
||||
run: make smelly
|
||||
- name: Check limited ABI symbols
|
||||
run: make check-limited-abi
|
||||
|
||||
build_win32:
|
||||
name: 'Windows (x86)'
|
||||
|
|
@ -99,8 +97,6 @@ jobs:
|
|||
if: needs.check_source.outputs.run_tests == 'true'
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- name: Register MSVC problem matcher
|
||||
run: echo "::add-matcher::.github/problem-matchers/msvc.json"
|
||||
- name: Build CPython
|
||||
run: .\PCbuild\build.bat -e -p x64
|
||||
- name: Display build info
|
||||
|
|
|
|||
|
|
@ -1,19 +0,0 @@
|
|||
name: Mark stale pull requests
|
||||
|
||||
on:
|
||||
schedule:
|
||||
- cron: "0 0 * * *"
|
||||
|
||||
jobs:
|
||||
stale:
|
||||
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/stale@v3
|
||||
with:
|
||||
repo-token: ${{ secrets.GITHUB_TOKEN }}
|
||||
stale-pr-message: 'This PR is stale because it has been open for 30 days with no activity.'
|
||||
stale-pr-label: 'stale'
|
||||
days-before-stale: 30
|
||||
days-before-close: -1
|
||||
|
|
@ -192,8 +192,6 @@ script:
|
|||
- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ./python Tools/scripts/patchcheck.py --travis $TRAVIS_PULL_REQUEST; fi
|
||||
# Check that all symbols exported by libpython start with "Py" or "_Py"
|
||||
- make smelly
|
||||
# Check that all symbols in the limited abi are present
|
||||
- make check-limited-abi
|
||||
# `-r -w` implicitly provided through `make buildbottest`.
|
||||
- |
|
||||
if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
|
||||
|
|
|
|||
|
|
@ -202,7 +202,6 @@ dist:
|
|||
|
||||
check:
|
||||
$(PYTHON) tools/rstlint.py -i tools -i $(VENVDIR) -i README.rst
|
||||
$(PYTHON) tools/rstlint.py ../Misc/NEWS.d/next/
|
||||
|
||||
serve:
|
||||
$(PYTHON) ../Tools/scripts/serve.py build/html
|
||||
|
|
|
|||
|
|
@ -15,7 +15,8 @@ sys.path.append(os.path.abspath('includes'))
|
|||
|
||||
extensions = ['sphinx.ext.coverage', 'sphinx.ext.doctest',
|
||||
'pyspecific', 'c_annotations', 'escape4chm',
|
||||
'asdl_highlight', 'peg_highlight', 'glossary_search']
|
||||
'asdl_highlight', 'peg_highlight']
|
||||
|
||||
|
||||
doctest_global_setup = '''
|
||||
try:
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ Copyright
|
|||
|
||||
Python and this documentation is:
|
||||
|
||||
Copyright © 2001-2021 Python Software Foundation. All rights reserved.
|
||||
Copyright © 2001-2020 Python Software Foundation. All rights reserved.
|
||||
|
||||
Copyright © 2000 BeOpen.com. All rights reserved.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,780 +0,0 @@
|
|||
# File generated by 'make regen-limited-abi'
|
||||
# This is NOT an authoritative list of stable ABI symbols
|
||||
PyArg_Parse
|
||||
PyArg_ParseTuple
|
||||
PyArg_ParseTupleAndKeywords
|
||||
PyArg_UnpackTuple
|
||||
PyArg_VaParse
|
||||
PyArg_VaParseTupleAndKeywords
|
||||
PyArg_ValidateKeywordArguments
|
||||
PyBaseObject_Type
|
||||
PyBool_FromLong
|
||||
PyBool_Type
|
||||
PyByteArrayIter_Type
|
||||
PyByteArray_AsString
|
||||
PyByteArray_Concat
|
||||
PyByteArray_FromObject
|
||||
PyByteArray_FromStringAndSize
|
||||
PyByteArray_Resize
|
||||
PyByteArray_Size
|
||||
PyByteArray_Type
|
||||
PyBytesIter_Type
|
||||
PyBytes_AsString
|
||||
PyBytes_AsStringAndSize
|
||||
PyBytes_Concat
|
||||
PyBytes_ConcatAndDel
|
||||
PyBytes_DecodeEscape
|
||||
PyBytes_FromFormat
|
||||
PyBytes_FromFormatV
|
||||
PyBytes_FromObject
|
||||
PyBytes_FromString
|
||||
PyBytes_FromStringAndSize
|
||||
PyBytes_Repr
|
||||
PyBytes_Size
|
||||
PyBytes_Type
|
||||
PyCFunction_Call
|
||||
PyCFunction_GetFlags
|
||||
PyCFunction_GetFunction
|
||||
PyCFunction_GetSelf
|
||||
PyCFunction_NewEx
|
||||
PyCFunction_Type
|
||||
PyCMethod_New
|
||||
PyCallIter_New
|
||||
PyCallIter_Type
|
||||
PyCallable_Check
|
||||
PyCapsule_GetContext
|
||||
PyCapsule_GetDestructor
|
||||
PyCapsule_GetName
|
||||
PyCapsule_GetPointer
|
||||
PyCapsule_Import
|
||||
PyCapsule_IsValid
|
||||
PyCapsule_New
|
||||
PyCapsule_SetContext
|
||||
PyCapsule_SetDestructor
|
||||
PyCapsule_SetName
|
||||
PyCapsule_SetPointer
|
||||
PyCapsule_Type
|
||||
PyClassMethodDescr_Type
|
||||
PyCodec_BackslashReplaceErrors
|
||||
PyCodec_Decode
|
||||
PyCodec_Decoder
|
||||
PyCodec_Encode
|
||||
PyCodec_Encoder
|
||||
PyCodec_IgnoreErrors
|
||||
PyCodec_IncrementalDecoder
|
||||
PyCodec_IncrementalEncoder
|
||||
PyCodec_KnownEncoding
|
||||
PyCodec_LookupError
|
||||
PyCodec_NameReplaceErrors
|
||||
PyCodec_Register
|
||||
PyCodec_RegisterError
|
||||
PyCodec_ReplaceErrors
|
||||
PyCodec_StreamReader
|
||||
PyCodec_StreamWriter
|
||||
PyCodec_StrictErrors
|
||||
PyCodec_Unregister
|
||||
PyCodec_XMLCharRefReplaceErrors
|
||||
PyComplex_FromDoubles
|
||||
PyComplex_ImagAsDouble
|
||||
PyComplex_RealAsDouble
|
||||
PyComplex_Type
|
||||
PyDescr_NewClassMethod
|
||||
PyDescr_NewGetSet
|
||||
PyDescr_NewMember
|
||||
PyDescr_NewMethod
|
||||
PyDictItems_Type
|
||||
PyDictIterItem_Type
|
||||
PyDictIterKey_Type
|
||||
PyDictIterValue_Type
|
||||
PyDictKeys_Type
|
||||
PyDictProxy_New
|
||||
PyDictProxy_Type
|
||||
PyDictRevIterItem_Type
|
||||
PyDictRevIterKey_Type
|
||||
PyDictRevIterValue_Type
|
||||
PyDictValues_Type
|
||||
PyDict_Clear
|
||||
PyDict_Contains
|
||||
PyDict_Copy
|
||||
PyDict_DelItem
|
||||
PyDict_DelItemString
|
||||
PyDict_GetItem
|
||||
PyDict_GetItemString
|
||||
PyDict_GetItemWithError
|
||||
PyDict_Items
|
||||
PyDict_Keys
|
||||
PyDict_Merge
|
||||
PyDict_MergeFromSeq2
|
||||
PyDict_New
|
||||
PyDict_Next
|
||||
PyDict_SetItem
|
||||
PyDict_SetItemString
|
||||
PyDict_Size
|
||||
PyDict_Type
|
||||
PyDict_Update
|
||||
PyDict_Values
|
||||
PyEllipsis_Type
|
||||
PyEnum_Type
|
||||
PyErr_BadArgument
|
||||
PyErr_BadInternalCall
|
||||
PyErr_CheckSignals
|
||||
PyErr_Clear
|
||||
PyErr_Display
|
||||
PyErr_ExceptionMatches
|
||||
PyErr_Fetch
|
||||
PyErr_Format
|
||||
PyErr_FormatV
|
||||
PyErr_GetExcInfo
|
||||
PyErr_GivenExceptionMatches
|
||||
PyErr_NewException
|
||||
PyErr_NewExceptionWithDoc
|
||||
PyErr_NoMemory
|
||||
PyErr_NormalizeException
|
||||
PyErr_Occurred
|
||||
PyErr_Print
|
||||
PyErr_PrintEx
|
||||
PyErr_ProgramText
|
||||
PyErr_ResourceWarning
|
||||
PyErr_Restore
|
||||
PyErr_SetExcInfo
|
||||
PyErr_SetFromErrno
|
||||
PyErr_SetFromErrnoWithFilename
|
||||
PyErr_SetFromErrnoWithFilenameObject
|
||||
PyErr_SetFromErrnoWithFilenameObjects
|
||||
PyErr_SetImportError
|
||||
PyErr_SetImportErrorSubclass
|
||||
PyErr_SetInterrupt
|
||||
PyErr_SetNone
|
||||
PyErr_SetObject
|
||||
PyErr_SetString
|
||||
PyErr_SyntaxLocation
|
||||
PyErr_SyntaxLocationEx
|
||||
PyErr_WarnEx
|
||||
PyErr_WarnExplicit
|
||||
PyErr_WarnFormat
|
||||
PyErr_WriteUnraisable
|
||||
PyEval_AcquireLock
|
||||
PyEval_AcquireThread
|
||||
PyEval_CallFunction
|
||||
PyEval_CallMethod
|
||||
PyEval_CallObjectWithKeywords
|
||||
PyEval_EvalCode
|
||||
PyEval_EvalCodeEx
|
||||
PyEval_EvalFrame
|
||||
PyEval_EvalFrameEx
|
||||
PyEval_GetBuiltins
|
||||
PyEval_GetFrame
|
||||
PyEval_GetFuncDesc
|
||||
PyEval_GetFuncName
|
||||
PyEval_GetGlobals
|
||||
PyEval_GetLocals
|
||||
PyEval_InitThreads
|
||||
PyEval_ReleaseLock
|
||||
PyEval_ReleaseThread
|
||||
PyEval_RestoreThread
|
||||
PyEval_SaveThread
|
||||
PyEval_ThreadsInitialized
|
||||
PyExc_ArithmeticError
|
||||
PyExc_AssertionError
|
||||
PyExc_AttributeError
|
||||
PyExc_BaseException
|
||||
PyExc_BlockingIOError
|
||||
PyExc_BrokenPipeError
|
||||
PyExc_BufferError
|
||||
PyExc_BytesWarning
|
||||
PyExc_ChildProcessError
|
||||
PyExc_ConnectionAbortedError
|
||||
PyExc_ConnectionError
|
||||
PyExc_ConnectionRefusedError
|
||||
PyExc_ConnectionResetError
|
||||
PyExc_DeprecationWarning
|
||||
PyExc_EOFError
|
||||
PyExc_EnvironmentError
|
||||
PyExc_Exception
|
||||
PyExc_FileExistsError
|
||||
PyExc_FileNotFoundError
|
||||
PyExc_FloatingPointError
|
||||
PyExc_FutureWarning
|
||||
PyExc_GeneratorExit
|
||||
PyExc_IOError
|
||||
PyExc_ImportError
|
||||
PyExc_ImportWarning
|
||||
PyExc_IndentationError
|
||||
PyExc_IndexError
|
||||
PyExc_InterruptedError
|
||||
PyExc_IsADirectoryError
|
||||
PyExc_KeyError
|
||||
PyExc_KeyboardInterrupt
|
||||
PyExc_LookupError
|
||||
PyExc_MemoryError
|
||||
PyExc_ModuleNotFoundError
|
||||
PyExc_NameError
|
||||
PyExc_NotADirectoryError
|
||||
PyExc_NotImplementedError
|
||||
PyExc_OSError
|
||||
PyExc_OverflowError
|
||||
PyExc_PendingDeprecationWarning
|
||||
PyExc_PermissionError
|
||||
PyExc_ProcessLookupError
|
||||
PyExc_RecursionError
|
||||
PyExc_ReferenceError
|
||||
PyExc_ResourceWarning
|
||||
PyExc_RuntimeError
|
||||
PyExc_RuntimeWarning
|
||||
PyExc_StopAsyncIteration
|
||||
PyExc_StopIteration
|
||||
PyExc_SyntaxError
|
||||
PyExc_SyntaxWarning
|
||||
PyExc_SystemError
|
||||
PyExc_SystemExit
|
||||
PyExc_TabError
|
||||
PyExc_TimeoutError
|
||||
PyExc_TypeError
|
||||
PyExc_UnboundLocalError
|
||||
PyExc_UnicodeDecodeError
|
||||
PyExc_UnicodeEncodeError
|
||||
PyExc_UnicodeError
|
||||
PyExc_UnicodeTranslateError
|
||||
PyExc_UnicodeWarning
|
||||
PyExc_UserWarning
|
||||
PyExc_ValueError
|
||||
PyExc_Warning
|
||||
PyExc_ZeroDivisionError
|
||||
PyExceptionClass_Name
|
||||
PyException_GetCause
|
||||
PyException_GetContext
|
||||
PyException_GetTraceback
|
||||
PyException_SetCause
|
||||
PyException_SetContext
|
||||
PyException_SetTraceback
|
||||
PyFile_FromFd
|
||||
PyFile_GetLine
|
||||
PyFile_WriteObject
|
||||
PyFile_WriteString
|
||||
PyFilter_Type
|
||||
PyFloat_AsDouble
|
||||
PyFloat_FromDouble
|
||||
PyFloat_FromString
|
||||
PyFloat_GetInfo
|
||||
PyFloat_GetMax
|
||||
PyFloat_GetMin
|
||||
PyFloat_Type
|
||||
PyFrame_GetCode
|
||||
PyFrame_GetLineNumber
|
||||
PyFrozenSet_New
|
||||
PyFrozenSet_Type
|
||||
PyGC_Collect
|
||||
PyGILState_Ensure
|
||||
PyGILState_GetThisThreadState
|
||||
PyGILState_Release
|
||||
PyGetSetDescr_Type
|
||||
PyImport_AddModule
|
||||
PyImport_AddModuleObject
|
||||
PyImport_AppendInittab
|
||||
PyImport_ExecCodeModule
|
||||
PyImport_ExecCodeModuleEx
|
||||
PyImport_ExecCodeModuleObject
|
||||
PyImport_ExecCodeModuleWithPathnames
|
||||
PyImport_GetImporter
|
||||
PyImport_GetMagicNumber
|
||||
PyImport_GetMagicTag
|
||||
PyImport_GetModule
|
||||
PyImport_GetModuleDict
|
||||
PyImport_Import
|
||||
PyImport_ImportFrozenModule
|
||||
PyImport_ImportFrozenModuleObject
|
||||
PyImport_ImportModule
|
||||
PyImport_ImportModuleLevel
|
||||
PyImport_ImportModuleLevelObject
|
||||
PyImport_ImportModuleNoBlock
|
||||
PyImport_ReloadModule
|
||||
PyIndex_Check
|
||||
PyInterpreterState_Clear
|
||||
PyInterpreterState_Delete
|
||||
PyInterpreterState_Get
|
||||
PyInterpreterState_GetDict
|
||||
PyInterpreterState_GetID
|
||||
PyInterpreterState_New
|
||||
PyIter_Check
|
||||
PyIter_Next
|
||||
PyIter_Send
|
||||
PyListIter_Type
|
||||
PyListRevIter_Type
|
||||
PyList_Append
|
||||
PyList_AsTuple
|
||||
PyList_GetItem
|
||||
PyList_GetSlice
|
||||
PyList_Insert
|
||||
PyList_New
|
||||
PyList_Reverse
|
||||
PyList_SetItem
|
||||
PyList_SetSlice
|
||||
PyList_Size
|
||||
PyList_Sort
|
||||
PyList_Type
|
||||
PyLongRangeIter_Type
|
||||
PyLong_AsDouble
|
||||
PyLong_AsLong
|
||||
PyLong_AsLongAndOverflow
|
||||
PyLong_AsLongLong
|
||||
PyLong_AsLongLongAndOverflow
|
||||
PyLong_AsSize_t
|
||||
PyLong_AsSsize_t
|
||||
PyLong_AsUnsignedLong
|
||||
PyLong_AsUnsignedLongLong
|
||||
PyLong_AsUnsignedLongLongMask
|
||||
PyLong_AsUnsignedLongMask
|
||||
PyLong_AsVoidPtr
|
||||
PyLong_FromDouble
|
||||
PyLong_FromLong
|
||||
PyLong_FromLongLong
|
||||
PyLong_FromSize_t
|
||||
PyLong_FromSsize_t
|
||||
PyLong_FromString
|
||||
PyLong_FromUnsignedLong
|
||||
PyLong_FromUnsignedLongLong
|
||||
PyLong_FromVoidPtr
|
||||
PyLong_GetInfo
|
||||
PyLong_Type
|
||||
PyMap_Type
|
||||
PyMapping_Check
|
||||
PyMapping_GetItemString
|
||||
PyMapping_HasKey
|
||||
PyMapping_HasKeyString
|
||||
PyMapping_Items
|
||||
PyMapping_Keys
|
||||
PyMapping_Length
|
||||
PyMapping_SetItemString
|
||||
PyMapping_Size
|
||||
PyMapping_Values
|
||||
PyMarshal_ReadObjectFromString
|
||||
PyMarshal_WriteLongToFile
|
||||
PyMarshal_WriteObjectToFile
|
||||
PyMarshal_WriteObjectToString
|
||||
PyMem_Free
|
||||
PyMem_Malloc
|
||||
PyMem_Realloc
|
||||
PyMemberDescr_Type
|
||||
PyMember_GetOne
|
||||
PyMember_SetOne
|
||||
PyMemoryView_FromMemory
|
||||
PyMemoryView_FromObject
|
||||
PyMemoryView_GetContiguous
|
||||
PyMemoryView_Type
|
||||
PyMethodDescr_Type
|
||||
PyModuleDef_Init
|
||||
PyModuleDef_Type
|
||||
PyModule_AddFunctions
|
||||
PyModule_AddIntConstant
|
||||
PyModule_AddObject
|
||||
PyModule_AddObjectRef
|
||||
PyModule_AddStringConstant
|
||||
PyModule_AddType
|
||||
PyModule_Create2
|
||||
PyModule_ExecDef
|
||||
PyModule_FromDefAndSpec2
|
||||
PyModule_GetDef
|
||||
PyModule_GetDict
|
||||
PyModule_GetFilename
|
||||
PyModule_GetFilenameObject
|
||||
PyModule_GetName
|
||||
PyModule_GetNameObject
|
||||
PyModule_GetState
|
||||
PyModule_New
|
||||
PyModule_NewObject
|
||||
PyModule_SetDocString
|
||||
PyModule_Type
|
||||
PyNumber_Absolute
|
||||
PyNumber_Add
|
||||
PyNumber_And
|
||||
PyNumber_AsSsize_t
|
||||
PyNumber_Check
|
||||
PyNumber_Divmod
|
||||
PyNumber_Float
|
||||
PyNumber_FloorDivide
|
||||
PyNumber_InPlaceAdd
|
||||
PyNumber_InPlaceAnd
|
||||
PyNumber_InPlaceFloorDivide
|
||||
PyNumber_InPlaceLshift
|
||||
PyNumber_InPlaceMatrixMultiply
|
||||
PyNumber_InPlaceMultiply
|
||||
PyNumber_InPlaceOr
|
||||
PyNumber_InPlacePower
|
||||
PyNumber_InPlaceRemainder
|
||||
PyNumber_InPlaceRshift
|
||||
PyNumber_InPlaceSubtract
|
||||
PyNumber_InPlaceTrueDivide
|
||||
PyNumber_InPlaceXor
|
||||
PyNumber_Index
|
||||
PyNumber_Invert
|
||||
PyNumber_Long
|
||||
PyNumber_Lshift
|
||||
PyNumber_MatrixMultiply
|
||||
PyNumber_Multiply
|
||||
PyNumber_Negative
|
||||
PyNumber_Or
|
||||
PyNumber_Positive
|
||||
PyNumber_Power
|
||||
PyNumber_Remainder
|
||||
PyNumber_Rshift
|
||||
PyNumber_Subtract
|
||||
PyNumber_ToBase
|
||||
PyNumber_TrueDivide
|
||||
PyNumber_Xor
|
||||
PyOS_AfterFork
|
||||
PyOS_AfterFork_Child
|
||||
PyOS_AfterFork_Parent
|
||||
PyOS_BeforeFork
|
||||
PyOS_FSPath
|
||||
PyOS_InterruptOccurred
|
||||
PyOS_double_to_string
|
||||
PyOS_getsig
|
||||
PyOS_mystricmp
|
||||
PyOS_mystrnicmp
|
||||
PyOS_setsig
|
||||
PyOS_snprintf
|
||||
PyOS_string_to_double
|
||||
PyOS_strtol
|
||||
PyOS_strtoul
|
||||
PyOS_vsnprintf
|
||||
PyObject_ASCII
|
||||
PyObject_AsFileDescriptor
|
||||
PyObject_Bytes
|
||||
PyObject_Call
|
||||
PyObject_CallFunction
|
||||
PyObject_CallFunctionObjArgs
|
||||
PyObject_CallMethod
|
||||
PyObject_CallMethodObjArgs
|
||||
PyObject_CallNoArgs
|
||||
PyObject_CallObject
|
||||
PyObject_Calloc
|
||||
PyObject_ClearWeakRefs
|
||||
PyObject_DelItem
|
||||
PyObject_DelItemString
|
||||
PyObject_Dir
|
||||
PyObject_Format
|
||||
PyObject_Free
|
||||
PyObject_GC_Del
|
||||
PyObject_GC_IsFinalized
|
||||
PyObject_GC_IsTracked
|
||||
PyObject_GC_Track
|
||||
PyObject_GC_UnTrack
|
||||
PyObject_GenericGetAttr
|
||||
PyObject_GenericGetDict
|
||||
PyObject_GenericSetAttr
|
||||
PyObject_GenericSetDict
|
||||
PyObject_GetAttr
|
||||
PyObject_GetAttrString
|
||||
PyObject_GetItem
|
||||
PyObject_GetIter
|
||||
PyObject_HasAttr
|
||||
PyObject_HasAttrString
|
||||
PyObject_Hash
|
||||
PyObject_HashNotImplemented
|
||||
PyObject_Init
|
||||
PyObject_InitVar
|
||||
PyObject_IsInstance
|
||||
PyObject_IsSubclass
|
||||
PyObject_IsTrue
|
||||
PyObject_Length
|
||||
PyObject_Malloc
|
||||
PyObject_Not
|
||||
PyObject_Realloc
|
||||
PyObject_Repr
|
||||
PyObject_RichCompare
|
||||
PyObject_RichCompareBool
|
||||
PyObject_SelfIter
|
||||
PyObject_SetAttr
|
||||
PyObject_SetAttrString
|
||||
PyObject_SetItem
|
||||
PyObject_Size
|
||||
PyObject_Str
|
||||
PyObject_Type
|
||||
PyProperty_Type
|
||||
PyRangeIter_Type
|
||||
PyRange_Type
|
||||
PyReversed_Type
|
||||
PySeqIter_New
|
||||
PySeqIter_Type
|
||||
PySequence_Check
|
||||
PySequence_Concat
|
||||
PySequence_Contains
|
||||
PySequence_Count
|
||||
PySequence_DelItem
|
||||
PySequence_DelSlice
|
||||
PySequence_Fast
|
||||
PySequence_GetItem
|
||||
PySequence_GetSlice
|
||||
PySequence_In
|
||||
PySequence_InPlaceConcat
|
||||
PySequence_InPlaceRepeat
|
||||
PySequence_Index
|
||||
PySequence_Length
|
||||
PySequence_List
|
||||
PySequence_Repeat
|
||||
PySequence_SetItem
|
||||
PySequence_SetSlice
|
||||
PySequence_Size
|
||||
PySequence_Tuple
|
||||
PySetIter_Type
|
||||
PySet_Add
|
||||
PySet_Clear
|
||||
PySet_Contains
|
||||
PySet_Discard
|
||||
PySet_New
|
||||
PySet_Pop
|
||||
PySet_Size
|
||||
PySet_Type
|
||||
PySlice_AdjustIndices
|
||||
PySlice_GetIndices
|
||||
PySlice_GetIndicesEx
|
||||
PySlice_New
|
||||
PySlice_Type
|
||||
PySlice_Unpack
|
||||
PyState_AddModule
|
||||
PyState_FindModule
|
||||
PyState_RemoveModule
|
||||
PyStructSequence_GetItem
|
||||
PyStructSequence_New
|
||||
PyStructSequence_NewType
|
||||
PyStructSequence_SetItem
|
||||
PySuper_Type
|
||||
PySys_AddWarnOption
|
||||
PySys_AddWarnOptionUnicode
|
||||
PySys_AddXOption
|
||||
PySys_FormatStderr
|
||||
PySys_FormatStdout
|
||||
PySys_GetObject
|
||||
PySys_GetXOptions
|
||||
PySys_HasWarnOptions
|
||||
PySys_ResetWarnOptions
|
||||
PySys_SetArgv
|
||||
PySys_SetArgvEx
|
||||
PySys_SetObject
|
||||
PySys_SetPath
|
||||
PySys_WriteStderr
|
||||
PySys_WriteStdout
|
||||
PyThreadState_Clear
|
||||
PyThreadState_Delete
|
||||
PyThreadState_Get
|
||||
PyThreadState_GetDict
|
||||
PyThreadState_GetFrame
|
||||
PyThreadState_GetID
|
||||
PyThreadState_GetInterpreter
|
||||
PyThreadState_New
|
||||
PyThreadState_SetAsyncExc
|
||||
PyThreadState_Swap
|
||||
PyThread_GetInfo
|
||||
PyThread_ReInitTLS
|
||||
PyThread_acquire_lock
|
||||
PyThread_acquire_lock_timed
|
||||
PyThread_allocate_lock
|
||||
PyThread_create_key
|
||||
PyThread_delete_key
|
||||
PyThread_delete_key_value
|
||||
PyThread_exit_thread
|
||||
PyThread_free_lock
|
||||
PyThread_get_key_value
|
||||
PyThread_get_stacksize
|
||||
PyThread_get_thread_ident
|
||||
PyThread_get_thread_native_id
|
||||
PyThread_init_thread
|
||||
PyThread_release_lock
|
||||
PyThread_set_key_value
|
||||
PyThread_set_stacksize
|
||||
PyThread_start_new_thread
|
||||
PyThread_tss_alloc
|
||||
PyThread_tss_create
|
||||
PyThread_tss_delete
|
||||
PyThread_tss_free
|
||||
PyThread_tss_get
|
||||
PyThread_tss_is_created
|
||||
PyThread_tss_set
|
||||
PyTraceBack_Here
|
||||
PyTraceBack_Print
|
||||
PyTraceBack_Type
|
||||
PyTupleIter_Type
|
||||
PyTuple_GetItem
|
||||
PyTuple_GetSlice
|
||||
PyTuple_New
|
||||
PyTuple_Pack
|
||||
PyTuple_SetItem
|
||||
PyTuple_Size
|
||||
PyTuple_Type
|
||||
PyType_ClearCache
|
||||
PyType_FromModuleAndSpec
|
||||
PyType_FromSpec
|
||||
PyType_FromSpecWithBases
|
||||
PyType_GenericAlloc
|
||||
PyType_GenericNew
|
||||
PyType_GetFlags
|
||||
PyType_GetModule
|
||||
PyType_GetModuleState
|
||||
PyType_GetSlot
|
||||
PyType_IsSubtype
|
||||
PyType_Modified
|
||||
PyType_Ready
|
||||
PyType_Type
|
||||
PyUnicodeDecodeError_Create
|
||||
PyUnicodeDecodeError_GetEncoding
|
||||
PyUnicodeDecodeError_GetEnd
|
||||
PyUnicodeDecodeError_GetObject
|
||||
PyUnicodeDecodeError_GetReason
|
||||
PyUnicodeDecodeError_GetStart
|
||||
PyUnicodeDecodeError_SetEnd
|
||||
PyUnicodeDecodeError_SetReason
|
||||
PyUnicodeDecodeError_SetStart
|
||||
PyUnicodeEncodeError_GetEncoding
|
||||
PyUnicodeEncodeError_GetEnd
|
||||
PyUnicodeEncodeError_GetObject
|
||||
PyUnicodeEncodeError_GetReason
|
||||
PyUnicodeEncodeError_GetStart
|
||||
PyUnicodeEncodeError_SetEnd
|
||||
PyUnicodeEncodeError_SetReason
|
||||
PyUnicodeEncodeError_SetStart
|
||||
PyUnicodeIter_Type
|
||||
PyUnicodeTranslateError_GetEnd
|
||||
PyUnicodeTranslateError_GetObject
|
||||
PyUnicodeTranslateError_GetReason
|
||||
PyUnicodeTranslateError_GetStart
|
||||
PyUnicodeTranslateError_SetEnd
|
||||
PyUnicodeTranslateError_SetReason
|
||||
PyUnicodeTranslateError_SetStart
|
||||
PyUnicode_Append
|
||||
PyUnicode_AppendAndDel
|
||||
PyUnicode_AsASCIIString
|
||||
PyUnicode_AsCharmapString
|
||||
PyUnicode_AsDecodedObject
|
||||
PyUnicode_AsDecodedUnicode
|
||||
PyUnicode_AsEncodedObject
|
||||
PyUnicode_AsEncodedString
|
||||
PyUnicode_AsEncodedUnicode
|
||||
PyUnicode_AsLatin1String
|
||||
PyUnicode_AsRawUnicodeEscapeString
|
||||
PyUnicode_AsUCS4
|
||||
PyUnicode_AsUCS4Copy
|
||||
PyUnicode_AsUTF16String
|
||||
PyUnicode_AsUTF32String
|
||||
PyUnicode_AsUTF8AndSize
|
||||
PyUnicode_AsUTF8String
|
||||
PyUnicode_AsUnicodeEscapeString
|
||||
PyUnicode_AsWideChar
|
||||
PyUnicode_AsWideCharString
|
||||
PyUnicode_BuildEncodingMap
|
||||
PyUnicode_Compare
|
||||
PyUnicode_CompareWithASCIIString
|
||||
PyUnicode_Concat
|
||||
PyUnicode_Contains
|
||||
PyUnicode_Count
|
||||
PyUnicode_Decode
|
||||
PyUnicode_DecodeASCII
|
||||
PyUnicode_DecodeCharmap
|
||||
PyUnicode_DecodeFSDefault
|
||||
PyUnicode_DecodeFSDefaultAndSize
|
||||
PyUnicode_DecodeLatin1
|
||||
PyUnicode_DecodeLocale
|
||||
PyUnicode_DecodeLocaleAndSize
|
||||
PyUnicode_DecodeRawUnicodeEscape
|
||||
PyUnicode_DecodeUTF16
|
||||
PyUnicode_DecodeUTF16Stateful
|
||||
PyUnicode_DecodeUTF32
|
||||
PyUnicode_DecodeUTF32Stateful
|
||||
PyUnicode_DecodeUTF7
|
||||
PyUnicode_DecodeUTF7Stateful
|
||||
PyUnicode_DecodeUTF8
|
||||
PyUnicode_DecodeUTF8Stateful
|
||||
PyUnicode_DecodeUnicodeEscape
|
||||
PyUnicode_EncodeFSDefault
|
||||
PyUnicode_EncodeLocale
|
||||
PyUnicode_FSConverter
|
||||
PyUnicode_FSDecoder
|
||||
PyUnicode_Find
|
||||
PyUnicode_FindChar
|
||||
PyUnicode_Format
|
||||
PyUnicode_FromEncodedObject
|
||||
PyUnicode_FromFormat
|
||||
PyUnicode_FromFormatV
|
||||
PyUnicode_FromObject
|
||||
PyUnicode_FromOrdinal
|
||||
PyUnicode_FromString
|
||||
PyUnicode_FromStringAndSize
|
||||
PyUnicode_FromWideChar
|
||||
PyUnicode_GetDefaultEncoding
|
||||
PyUnicode_GetLength
|
||||
PyUnicode_GetSize
|
||||
PyUnicode_InternFromString
|
||||
PyUnicode_InternImmortal
|
||||
PyUnicode_InternInPlace
|
||||
PyUnicode_IsIdentifier
|
||||
PyUnicode_Join
|
||||
PyUnicode_Partition
|
||||
PyUnicode_RPartition
|
||||
PyUnicode_RSplit
|
||||
PyUnicode_ReadChar
|
||||
PyUnicode_Replace
|
||||
PyUnicode_Resize
|
||||
PyUnicode_RichCompare
|
||||
PyUnicode_Split
|
||||
PyUnicode_Splitlines
|
||||
PyUnicode_Substring
|
||||
PyUnicode_Tailmatch
|
||||
PyUnicode_Translate
|
||||
PyUnicode_Type
|
||||
PyUnicode_WriteChar
|
||||
PyWeakref_GetObject
|
||||
PyWeakref_NewProxy
|
||||
PyWeakref_NewRef
|
||||
PyWrapperDescr_Type
|
||||
PyWrapper_New
|
||||
PyZip_Type
|
||||
Py_AddPendingCall
|
||||
Py_AtExit
|
||||
Py_BuildValue
|
||||
Py_BytesMain
|
||||
Py_CompileString
|
||||
Py_DecRef
|
||||
Py_DecodeLocale
|
||||
Py_EncodeLocale
|
||||
Py_EndInterpreter
|
||||
Py_EnterRecursiveCall
|
||||
Py_Exit
|
||||
Py_FatalError
|
||||
Py_FileSystemDefaultEncodeErrors
|
||||
Py_FileSystemDefaultEncoding
|
||||
Py_Finalize
|
||||
Py_FinalizeEx
|
||||
Py_FrozenMain
|
||||
Py_GenericAlias
|
||||
Py_GenericAliasType
|
||||
Py_GetBuildInfo
|
||||
Py_GetCompiler
|
||||
Py_GetCopyright
|
||||
Py_GetExecPrefix
|
||||
Py_GetPath
|
||||
Py_GetPlatform
|
||||
Py_GetPrefix
|
||||
Py_GetProgramFullPath
|
||||
Py_GetProgramName
|
||||
Py_GetPythonHome
|
||||
Py_GetRecursionLimit
|
||||
Py_GetVersion
|
||||
Py_HasFileSystemDefaultEncoding
|
||||
Py_IncRef
|
||||
Py_Initialize
|
||||
Py_InitializeEx
|
||||
Py_IsInitialized
|
||||
Py_LeaveRecursiveCall
|
||||
Py_Main
|
||||
Py_MakePendingCalls
|
||||
Py_NewInterpreter
|
||||
Py_NewRef
|
||||
Py_ReprEnter
|
||||
Py_ReprLeave
|
||||
Py_SetPath
|
||||
Py_SetProgramName
|
||||
Py_SetPythonHome
|
||||
Py_SetRecursionLimit
|
||||
Py_SymtableString
|
||||
Py_UTF8Mode
|
||||
Py_VaBuildValue
|
||||
Py_XNewRef
|
||||
|
|
@ -83,7 +83,7 @@ Following is a result of running the code:
|
|||
$ python3 prog.py --help
|
||||
usage: prog.py [-h]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
$ python3 prog.py --verbose
|
||||
usage: prog.py [-h]
|
||||
|
|
@ -130,7 +130,7 @@ And running the code:
|
|||
positional arguments:
|
||||
echo
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
$ python3 prog.py foo
|
||||
foo
|
||||
|
|
@ -172,7 +172,7 @@ And we get:
|
|||
positional arguments:
|
||||
echo echo the string you use here
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
|
||||
Now, how about doing something even more useful::
|
||||
|
|
@ -241,7 +241,7 @@ And the output:
|
|||
$ python3 prog.py --help
|
||||
usage: prog.py [-h] [--verbosity VERBOSITY]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--verbosity VERBOSITY
|
||||
increase output verbosity
|
||||
|
|
@ -289,7 +289,7 @@ And the output:
|
|||
$ python3 prog.py --help
|
||||
usage: prog.py [-h] [--verbose]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--verbose increase output verbosity
|
||||
|
||||
|
|
@ -332,7 +332,7 @@ And here goes:
|
|||
$ python3 prog.py --help
|
||||
usage: prog.py [-h] [-v]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
-v, --verbose increase output verbosity
|
||||
|
||||
|
|
@ -440,7 +440,7 @@ And the output:
|
|||
positional arguments:
|
||||
square display a square of a given number
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
-v {0,1,2}, --verbosity {0,1,2}
|
||||
increase output verbosity
|
||||
|
|
@ -468,8 +468,7 @@ verbosity argument (check the output of ``python --help``)::
|
|||
print(answer)
|
||||
|
||||
We have introduced another action, "count",
|
||||
to count the number of occurrences of specific options.
|
||||
|
||||
to count the number of occurrences of a specific optional arguments:
|
||||
|
||||
.. code-block:: shell-session
|
||||
|
||||
|
|
@ -490,7 +489,7 @@ to count the number of occurrences of specific options.
|
|||
positional arguments:
|
||||
square display a square of a given number
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
-v, --verbosity increase output verbosity
|
||||
$ python3 prog.py 4 -vvv
|
||||
|
|
@ -627,7 +626,7 @@ Output:
|
|||
x the base
|
||||
y the exponent
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
-v, --verbosity
|
||||
$ python3 prog.py 4 2 -v
|
||||
|
|
@ -751,7 +750,7 @@ but not both at the same time:
|
|||
x the base
|
||||
y the exponent
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
-v, --verbose
|
||||
-q, --quiet
|
||||
|
|
|
|||
|
|
@ -934,42 +934,32 @@ here is a pure Python equivalent:
|
|||
if doc is None and fget is not None:
|
||||
doc = fget.__doc__
|
||||
self.__doc__ = doc
|
||||
self._name = ''
|
||||
|
||||
def __set_name__(self, owner, name):
|
||||
self._name = name
|
||||
|
||||
def __get__(self, obj, objtype=None):
|
||||
if obj is None:
|
||||
return self
|
||||
if self.fget is None:
|
||||
raise AttributeError(f'unreadable attribute {self._name}')
|
||||
raise AttributeError("unreadable attribute")
|
||||
return self.fget(obj)
|
||||
|
||||
def __set__(self, obj, value):
|
||||
if self.fset is None:
|
||||
raise AttributeError(f"can't set attribute {self._name}")
|
||||
raise AttributeError("can't set attribute")
|
||||
self.fset(obj, value)
|
||||
|
||||
def __delete__(self, obj):
|
||||
if self.fdel is None:
|
||||
raise AttributeError(f"can't delete attribute {self._name}")
|
||||
raise AttributeError("can't delete attribute")
|
||||
self.fdel(obj)
|
||||
|
||||
def getter(self, fget):
|
||||
prop = type(self)(fget, self.fset, self.fdel, self.__doc__)
|
||||
prop._name = self._name
|
||||
return prop
|
||||
return type(self)(fget, self.fset, self.fdel, self.__doc__)
|
||||
|
||||
def setter(self, fset):
|
||||
prop = type(self)(self.fget, fset, self.fdel, self.__doc__)
|
||||
prop._name = self._name
|
||||
return prop
|
||||
return type(self)(self.fget, fset, self.fdel, self.__doc__)
|
||||
|
||||
def deleter(self, fdel):
|
||||
prop = type(self)(self.fget, self.fset, fdel, self.__doc__)
|
||||
prop._name = self._name
|
||||
return prop
|
||||
return type(self)(self.fget, self.fset, fdel, self.__doc__)
|
||||
|
||||
.. testcode::
|
||||
:hide:
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ be run at the command line and provides useful help messages:
|
|||
positional arguments:
|
||||
N an integer for the accumulator
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--sum sum the integers (default: find the max)
|
||||
|
||||
|
|
@ -217,14 +217,14 @@ The help for this program will display ``myprogram.py`` as the program name
|
|||
$ python myprogram.py --help
|
||||
usage: myprogram.py [-h] [--foo FOO]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo FOO foo help
|
||||
$ cd ..
|
||||
$ python subdir/myprogram.py --help
|
||||
usage: myprogram.py [-h] [--foo FOO]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo FOO foo help
|
||||
|
||||
|
|
@ -235,7 +235,7 @@ To change this default behavior, another value can be supplied using the
|
|||
>>> parser.print_help()
|
||||
usage: myprogram [-h]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
|
||||
Note that the program name, whether determined from ``sys.argv[0]`` or from the
|
||||
|
|
@ -249,7 +249,7 @@ specifier.
|
|||
>>> parser.print_help()
|
||||
usage: myprogram [-h] [--foo FOO]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo FOO foo of the myprogram program
|
||||
|
||||
|
|
@ -269,7 +269,7 @@ arguments it contains::
|
|||
positional arguments:
|
||||
bar bar help
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo [FOO] foo help
|
||||
|
||||
|
|
@ -284,7 +284,7 @@ The default message can be overridden with the ``usage=`` keyword argument::
|
|||
positional arguments:
|
||||
bar bar help
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo [FOO] foo help
|
||||
|
||||
|
|
@ -307,7 +307,7 @@ various arguments::
|
|||
|
||||
A foo that bars
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
|
||||
By default, the description will be line-wrapped so that it fits within the
|
||||
|
|
@ -329,7 +329,7 @@ argument to :class:`ArgumentParser`::
|
|||
|
||||
A foo that bars
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
|
||||
And that's how you'd foo a bar
|
||||
|
|
@ -403,7 +403,7 @@ epilog_ texts in command-line help messages::
|
|||
|
||||
this description was indented weird but that is okay
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
|
||||
likewise for this epilog whose whitespace will be cleaned up and whose words
|
||||
|
|
@ -432,7 +432,7 @@ should not be line-wrapped::
|
|||
exactly the way
|
||||
I want it
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
|
||||
:class:`RawTextHelpFormatter` maintains whitespace for all sorts of help text,
|
||||
|
|
@ -454,7 +454,7 @@ default values to each of the argument help messages::
|
|||
positional arguments:
|
||||
bar BAR! (default: [1, 2, 3])
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo FOO FOO! (default: 42)
|
||||
|
||||
|
|
@ -473,7 +473,7 @@ as the regular formatter does)::
|
|||
positional arguments:
|
||||
float
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo int
|
||||
|
||||
|
|
@ -592,7 +592,7 @@ older arguments with the same option string. To get this behavior, the value
|
|||
>>> parser.print_help()
|
||||
usage: PROG [-h] [-f FOO] [--foo FOO]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
-f FOO old foo help
|
||||
--foo FOO new foo help
|
||||
|
|
@ -623,7 +623,7 @@ help will be printed:
|
|||
$ python myprogram.py --help
|
||||
usage: myprogram.py [-h] [--foo FOO]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo FOO foo help
|
||||
|
||||
|
|
@ -636,7 +636,7 @@ This can be achieved by passing ``False`` as the ``add_help=`` argument to
|
|||
>>> parser.print_help()
|
||||
usage: PROG [--foo FOO]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
--foo FOO foo help
|
||||
|
||||
The help option is typically ``-h/--help``. The exception to this is
|
||||
|
|
@ -649,7 +649,7 @@ the help options::
|
|||
>>> parser.print_help()
|
||||
usage: PROG [+h]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
+h, ++help show this help message and exit
|
||||
|
||||
|
||||
|
|
@ -696,7 +696,7 @@ The add_argument() method
|
|||
* const_ - A constant value required by some action_ and nargs_ selections.
|
||||
|
||||
* default_ - The value produced if the argument is absent from the
|
||||
command line and if it is absent from the namespace object.
|
||||
command line.
|
||||
|
||||
* type_ - The type to which the command-line argument should be converted.
|
||||
|
||||
|
|
@ -1006,14 +1006,6 @@ was not present at the command line::
|
|||
>>> parser.parse_args([])
|
||||
Namespace(foo=42)
|
||||
|
||||
If the target namespace already has an attribute set, the action *default*
|
||||
will not over write it::
|
||||
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('--foo', default=42)
|
||||
>>> parser.parse_args([], namespace=argparse.Namespace(foo=101))
|
||||
Namespace(foo=101)
|
||||
|
||||
If the ``default`` value is a string, the parser parses the value as if it
|
||||
were a command-line argument. In particular, the parser applies any type_
|
||||
conversion argument, if provided, before setting the attribute on the
|
||||
|
|
@ -1050,70 +1042,63 @@ command-line argument was not present::
|
|||
type
|
||||
^^^^
|
||||
|
||||
By default, the parser reads command-line arguments in as simple
|
||||
By default, :class:`ArgumentParser` objects read command-line arguments in as simple
|
||||
strings. However, quite often the command-line string should instead be
|
||||
interpreted as another type, such as a :class:`float` or :class:`int`. The
|
||||
``type`` keyword for :meth:`~ArgumentParser.add_argument` allows any
|
||||
necessary type-checking and type conversions to be performed.
|
||||
interpreted as another type, like a :class:`float` or :class:`int`. The
|
||||
``type`` keyword argument of :meth:`~ArgumentParser.add_argument` allows any
|
||||
necessary type-checking and type conversions to be performed. Common built-in
|
||||
types and functions can be used directly as the value of the ``type`` argument::
|
||||
|
||||
If the type_ keyword is used with the default_ keyword, the type converter
|
||||
is only applied if the default is a string.
|
||||
|
||||
The argument to ``type`` can be any callable that accepts a single string.
|
||||
If the function raises :exc:`ArgumentTypeError`, :exc:`TypeError`, or
|
||||
:exc:`ValueError`, the exception is caught and a nicely formatted error
|
||||
message is displayed. No other exception types are handled.
|
||||
|
||||
Common built-in types and functions can be used as type converters:
|
||||
|
||||
.. testcode::
|
||||
|
||||
import argparse
|
||||
import pathlib
|
||||
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('count', type=int)
|
||||
parser.add_argument('distance', type=float)
|
||||
parser.add_argument('street', type=ascii)
|
||||
parser.add_argument('code_point', type=ord)
|
||||
parser.add_argument('source_file', type=open)
|
||||
parser.add_argument('dest_file', type=argparse.FileType('w', encoding='latin-1'))
|
||||
parser.add_argument('datapath', type=pathlib.Path)
|
||||
|
||||
User defined functions can be used as well:
|
||||
|
||||
.. doctest::
|
||||
|
||||
>>> def hyphenated(string):
|
||||
... return '-'.join([word[:4] for word in string.casefold().split()])
|
||||
...
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> _ = parser.add_argument('short_title', type=hyphenated)
|
||||
>>> parser.parse_args(['"The Tale of Two Cities"'])
|
||||
Namespace(short_title='"the-tale-of-two-citi')
|
||||
>>> parser.add_argument('foo', type=int)
|
||||
>>> parser.add_argument('bar', type=open)
|
||||
>>> parser.parse_args('2 temp.txt'.split())
|
||||
Namespace(bar=<_io.TextIOWrapper name='temp.txt' encoding='UTF-8'>, foo=2)
|
||||
|
||||
The :func:`bool` function is not recommended as a type converter. All it does
|
||||
is convert empty strings to ``False`` and non-empty strings to ``True``.
|
||||
This is usually not what is desired.
|
||||
See the section on the default_ keyword argument for information on when the
|
||||
``type`` argument is applied to default arguments.
|
||||
|
||||
In general, the ``type`` keyword is a convenience that should only be used for
|
||||
simple conversions that can only raise one of the three supported exceptions.
|
||||
Anything with more interesting error-handling or resource management should be
|
||||
done downstream after the arguments are parsed.
|
||||
To ease the use of various types of files, the argparse module provides the
|
||||
factory FileType which takes the ``mode=``, ``bufsize=``, ``encoding=`` and
|
||||
``errors=`` arguments of the :func:`open` function. For example,
|
||||
``FileType('w')`` can be used to create a writable file::
|
||||
|
||||
For example, JSON or YAML conversions have complex error cases that require
|
||||
better reporting than can be given by the ``type`` keyword. An
|
||||
:exc:`~json.JSONDecodeError` would not be well formatted and a
|
||||
:exc:`FileNotFound` exception would not be handled at all.
|
||||
>>> parser = argparse.ArgumentParser()
|
||||
>>> parser.add_argument('bar', type=argparse.FileType('w'))
|
||||
>>> parser.parse_args(['out.txt'])
|
||||
Namespace(bar=<_io.TextIOWrapper name='out.txt' encoding='UTF-8'>)
|
||||
|
||||
Even :class:`~argparse.FileType` has its limitations for use with the ``type``
|
||||
keyword. If one argument uses *FileType* and then a subsequent argument fails,
|
||||
an error is reported but the file is not automatically closed. In this case, it
|
||||
would be better to wait until after the parser has run and then use the
|
||||
:keyword:`with`-statement to manage the files.
|
||||
``type=`` can take any callable that takes a single string argument and returns
|
||||
the converted value::
|
||||
|
||||
For type checkers that simply check against a fixed set of values, consider
|
||||
using the choices_ keyword instead.
|
||||
>>> def perfect_square(string):
|
||||
... value = int(string)
|
||||
... sqrt = math.sqrt(value)
|
||||
... if sqrt != int(sqrt):
|
||||
... msg = "%r is not a perfect square" % string
|
||||
... raise argparse.ArgumentTypeError(msg)
|
||||
... return value
|
||||
...
|
||||
>>> parser = argparse.ArgumentParser(prog='PROG')
|
||||
>>> parser.add_argument('foo', type=perfect_square)
|
||||
>>> parser.parse_args(['9'])
|
||||
Namespace(foo=9)
|
||||
>>> parser.parse_args(['7'])
|
||||
usage: PROG [-h] foo
|
||||
PROG: error: argument foo: '7' is not a perfect square
|
||||
|
||||
The choices_ keyword argument may be more convenient for type checkers that
|
||||
simply check against a range of values::
|
||||
|
||||
>>> parser = argparse.ArgumentParser(prog='PROG')
|
||||
>>> parser.add_argument('foo', type=int, choices=range(5, 10))
|
||||
>>> parser.parse_args(['7'])
|
||||
Namespace(foo=7)
|
||||
>>> parser.parse_args(['11'])
|
||||
usage: PROG [-h] {5,6,7,8,9}
|
||||
PROG: error: argument foo: invalid choice: 11 (choose from 5, 6, 7, 8, 9)
|
||||
|
||||
See the choices_ section for more details.
|
||||
|
||||
|
||||
choices
|
||||
|
|
@ -1152,11 +1137,6 @@ Any container can be passed as the *choices* value, so :class:`list` objects,
|
|||
Use of :class:`enum.Enum` is not recommended because it is difficult to
|
||||
control its appearance in usage, help, and error messages.
|
||||
|
||||
Formatted choices overrides the default *metavar* which is normally derived
|
||||
from *dest*. This is usually what you want because the user never sees the
|
||||
*dest* parameter. If this display isn't desirable (perhaps because there are
|
||||
many choices), just specify an explicit metavar_.
|
||||
|
||||
|
||||
required
|
||||
^^^^^^^^
|
||||
|
|
@ -1203,7 +1183,7 @@ argument::
|
|||
positional arguments:
|
||||
bar one of the bars to be frobbled
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo foo the bars before frobbling
|
||||
|
||||
|
|
@ -1221,7 +1201,7 @@ specifiers include the program name, ``%(prog)s`` and most keyword arguments to
|
|||
positional arguments:
|
||||
bar the bar to frobble (default: 42)
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
|
||||
As the help string supports %-formatting, if you want a literal ``%`` to appear
|
||||
|
|
@ -1235,7 +1215,7 @@ setting the ``help`` value to ``argparse.SUPPRESS``::
|
|||
>>> parser.print_help()
|
||||
usage: frobble [-h]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
|
||||
|
||||
|
|
@ -1262,7 +1242,7 @@ will be referred to as ``FOO``. An example::
|
|||
positional arguments:
|
||||
bar
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo FOO
|
||||
|
||||
|
|
@ -1279,7 +1259,7 @@ An alternative name can be specified with ``metavar``::
|
|||
positional arguments:
|
||||
XXX
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo YYY
|
||||
|
||||
|
|
@ -1297,7 +1277,7 @@ arguments::
|
|||
>>> parser.print_help()
|
||||
usage: PROG [-h] [-x X X] [--foo bar baz]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
-x X X
|
||||
--foo bar baz
|
||||
|
|
@ -1701,7 +1681,7 @@ Sub-commands
|
|||
a a help
|
||||
b b help
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--foo foo help
|
||||
|
||||
|
|
@ -1711,13 +1691,13 @@ Sub-commands
|
|||
positional arguments:
|
||||
bar bar help
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
|
||||
>>> parser.parse_args(['b', '--help'])
|
||||
usage: PROG b [-h] [--baz {X,Y,Z}]
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
--baz {X,Y,Z} baz help
|
||||
|
||||
|
|
@ -1734,7 +1714,7 @@ Sub-commands
|
|||
>>> parser.parse_args(['-h'])
|
||||
usage: [-h] {foo,bar} ...
|
||||
|
||||
options:
|
||||
optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
|
||||
subcommands:
|
||||
|
|
|
|||
|
|
@ -1576,7 +1576,7 @@ and classes for traversing abstract syntax trees:
|
|||
Safely evaluate an expression node or a string containing a Python literal or
|
||||
container display. The string or node provided may only consist of the
|
||||
following Python literal structures: strings, bytes, numbers, tuples, lists,
|
||||
dicts, sets, booleans, ``None`` and ``Ellipsis``.
|
||||
dicts, sets, booleans, and ``None``.
|
||||
|
||||
This can be used for safely evaluating strings containing Python values from
|
||||
untrusted sources without the need to parse the values oneself. It is not
|
||||
|
|
@ -1588,10 +1588,6 @@ and classes for traversing abstract syntax trees:
|
|||
sufficiently large/complex string due to stack depth limitations
|
||||
in Python's AST compiler.
|
||||
|
||||
It can raise :exc:`ValueError`, :exc:`TypeError`, :exc:`SyntaxError`,
|
||||
:exc:`MemoryError` and :exc:`RecursionError` depending on the malformed
|
||||
input.
|
||||
|
||||
.. versionchanged:: 3.2
|
||||
Now allows bytes and set literals.
|
||||
|
||||
|
|
|
|||
|
|
@ -321,7 +321,7 @@ Creating Futures and Tasks
|
|||
|
||||
.. versionadded:: 3.5.2
|
||||
|
||||
.. method:: loop.create_task(coro, *, name=None)
|
||||
.. method:: loop.create_task(coro, \*, name=None)
|
||||
|
||||
Schedule the execution of a :ref:`coroutine`.
|
||||
Return a :class:`Task` object.
|
||||
|
|
@ -356,7 +356,7 @@ Opening network connections
|
|||
^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. coroutinemethod:: loop.create_connection(protocol_factory, \
|
||||
host=None, port=None, *, ssl=None, \
|
||||
host=None, port=None, \*, ssl=None, \
|
||||
family=0, proto=0, flags=0, sock=None, \
|
||||
local_addr=None, server_hostname=None, \
|
||||
ssl_handshake_timeout=None, \
|
||||
|
|
@ -482,7 +482,7 @@ Opening network connections
|
|||
that can be used directly in async/await code.
|
||||
|
||||
.. coroutinemethod:: loop.create_datagram_endpoint(protocol_factory, \
|
||||
local_addr=None, remote_addr=None, *, \
|
||||
local_addr=None, remote_addr=None, \*, \
|
||||
family=0, proto=0, flags=0, \
|
||||
reuse_address=None, reuse_port=None, \
|
||||
allow_broadcast=None, sock=None)
|
||||
|
|
@ -559,7 +559,7 @@ Opening network connections
|
|||
Added support for Windows.
|
||||
|
||||
.. coroutinemethod:: loop.create_unix_connection(protocol_factory, \
|
||||
path=None, *, ssl=None, sock=None, \
|
||||
path=None, \*, ssl=None, sock=None, \
|
||||
server_hostname=None, ssl_handshake_timeout=None)
|
||||
|
||||
Create a Unix connection.
|
||||
|
|
@ -592,7 +592,7 @@ Creating network servers
|
|||
^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. coroutinemethod:: loop.create_server(protocol_factory, \
|
||||
host=None, port=None, *, \
|
||||
host=None, port=None, \*, \
|
||||
family=socket.AF_UNSPEC, \
|
||||
flags=socket.AI_PASSIVE, \
|
||||
sock=None, backlog=100, ssl=None, \
|
||||
|
|
@ -683,7 +683,7 @@ Creating network servers
|
|||
|
||||
|
||||
.. coroutinemethod:: loop.create_unix_server(protocol_factory, path=None, \
|
||||
*, sock=None, backlog=100, ssl=None, \
|
||||
\*, sock=None, backlog=100, ssl=None, \
|
||||
ssl_handshake_timeout=None, start_serving=True)
|
||||
|
||||
Similar to :meth:`loop.create_server` but works with the
|
||||
|
|
@ -708,7 +708,7 @@ Creating network servers
|
|||
The *path* parameter can now be a :class:`~pathlib.Path` object.
|
||||
|
||||
.. coroutinemethod:: loop.connect_accepted_socket(protocol_factory, \
|
||||
sock, *, ssl=None, ssl_handshake_timeout=None)
|
||||
sock, \*, ssl=None, ssl_handshake_timeout=None)
|
||||
|
||||
Wrap an already accepted connection into a transport/protocol pair.
|
||||
|
||||
|
|
@ -773,7 +773,7 @@ TLS Upgrade
|
|||
^^^^^^^^^^^
|
||||
|
||||
.. coroutinemethod:: loop.start_tls(transport, protocol, \
|
||||
sslcontext, *, server_side=False, \
|
||||
sslcontext, \*, server_side=False, \
|
||||
server_hostname=None, ssl_handshake_timeout=None)
|
||||
|
||||
Upgrade an existing transport-based connection to TLS.
|
||||
|
|
@ -806,7 +806,7 @@ TLS Upgrade
|
|||
Watching file descriptors
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. method:: loop.add_reader(fd, callback, *args)
|
||||
.. method:: loop.add_reader(fd, callback, \*args)
|
||||
|
||||
Start monitoring the *fd* file descriptor for read availability and
|
||||
invoke *callback* with the specified arguments once *fd* is available for
|
||||
|
|
@ -816,7 +816,7 @@ Watching file descriptors
|
|||
|
||||
Stop monitoring the *fd* file descriptor for read availability.
|
||||
|
||||
.. method:: loop.add_writer(fd, callback, *args)
|
||||
.. method:: loop.add_writer(fd, callback, \*args)
|
||||
|
||||
Start monitoring the *fd* file descriptor for write availability and
|
||||
invoke *callback* with the specified arguments once *fd* is available for
|
||||
|
|
@ -930,7 +930,7 @@ convenient.
|
|||
:meth:`loop.create_server` and :func:`start_server`.
|
||||
|
||||
.. coroutinemethod:: loop.sock_sendfile(sock, file, offset=0, count=None, \
|
||||
*, fallback=True)
|
||||
\*, fallback=True)
|
||||
|
||||
Send a file using high-performance :mod:`os.sendfile` if possible.
|
||||
Return the total number of bytes sent.
|
||||
|
|
@ -964,7 +964,7 @@ convenient.
|
|||
DNS
|
||||
^^^
|
||||
|
||||
.. coroutinemethod:: loop.getaddrinfo(host, port, *, family=0, \
|
||||
.. coroutinemethod:: loop.getaddrinfo(host, port, \*, family=0, \
|
||||
type=0, proto=0, flags=0)
|
||||
|
||||
Asynchronous version of :meth:`socket.getaddrinfo`.
|
||||
|
|
@ -1029,7 +1029,7 @@ Working with pipes
|
|||
Unix signals
|
||||
^^^^^^^^^^^^
|
||||
|
||||
.. method:: loop.add_signal_handler(signum, callback, *args)
|
||||
.. method:: loop.add_signal_handler(signum, callback, \*args)
|
||||
|
||||
Set *callback* as the handler for the *signum* signal.
|
||||
|
||||
|
|
@ -1064,7 +1064,7 @@ Unix signals
|
|||
Executing code in thread or process pools
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. awaitablemethod:: loop.run_in_executor(executor, func, *args)
|
||||
.. awaitablemethod:: loop.run_in_executor(executor, func, \*args)
|
||||
|
||||
Arrange for *func* to be called in the specified executor.
|
||||
|
||||
|
|
@ -1237,9 +1237,9 @@ async/await code consider using the high-level
|
|||
subprocesses. See :ref:`Subprocess Support on Windows
|
||||
<asyncio-windows-subprocess>` for details.
|
||||
|
||||
.. coroutinemethod:: loop.subprocess_exec(protocol_factory, *args, \
|
||||
.. coroutinemethod:: loop.subprocess_exec(protocol_factory, \*args, \
|
||||
stdin=subprocess.PIPE, stdout=subprocess.PIPE, \
|
||||
stderr=subprocess.PIPE, **kwargs)
|
||||
stderr=subprocess.PIPE, \*\*kwargs)
|
||||
|
||||
Create a subprocess from one or more string arguments specified by
|
||||
*args*.
|
||||
|
|
@ -1319,9 +1319,9 @@ async/await code consider using the high-level
|
|||
conforms to the :class:`asyncio.SubprocessTransport` base class and
|
||||
*protocol* is an object instantiated by the *protocol_factory*.
|
||||
|
||||
.. coroutinemethod:: loop.subprocess_shell(protocol_factory, cmd, *, \
|
||||
.. coroutinemethod:: loop.subprocess_shell(protocol_factory, cmd, \*, \
|
||||
stdin=subprocess.PIPE, stdout=subprocess.PIPE, \
|
||||
stderr=subprocess.PIPE, **kwargs)
|
||||
stderr=subprocess.PIPE, \*\*kwargs)
|
||||
|
||||
Create a subprocess from *cmd*, which can be a :class:`str` or a
|
||||
:class:`bytes` string encoded to the
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ Future Functions
|
|||
.. versionadded:: 3.5
|
||||
|
||||
|
||||
.. function:: ensure_future(obj, *, loop=None)
|
||||
.. function:: ensure_future(obj, \*, loop=None)
|
||||
|
||||
Return:
|
||||
|
||||
|
|
@ -58,7 +58,7 @@ Future Functions
|
|||
The function accepts any :term:`awaitable` object.
|
||||
|
||||
|
||||
.. function:: wrap_future(future, *, loop=None)
|
||||
.. function:: wrap_future(future, \*, loop=None)
|
||||
|
||||
Wrap a :class:`concurrent.futures.Future` object in a
|
||||
:class:`asyncio.Future` object.
|
||||
|
|
@ -67,7 +67,7 @@ Future Functions
|
|||
Future Object
|
||||
=============
|
||||
|
||||
.. class:: Future(*, loop=None)
|
||||
.. class:: Future(\*, loop=None)
|
||||
|
||||
A Future represents an eventual result of an asynchronous
|
||||
operation. Not thread-safe.
|
||||
|
|
|
|||
|
|
@ -159,7 +159,7 @@ implementation used by the asyncio event loop:
|
|||
|
||||
.. class:: AbstractChildWatcher
|
||||
|
||||
.. method:: add_child_handler(pid, callback, *args)
|
||||
.. method:: add_child_handler(pid, callback, \*args)
|
||||
|
||||
Register a new child handler.
|
||||
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ The following top-level asyncio functions can be used to create
|
|||
and work with streams:
|
||||
|
||||
|
||||
.. coroutinefunction:: open_connection(host=None, port=None, *, \
|
||||
.. coroutinefunction:: open_connection(host=None, port=None, \*, \
|
||||
limit=None, ssl=None, family=0, proto=0, \
|
||||
flags=0, sock=None, local_addr=None, \
|
||||
server_hostname=None, ssl_handshake_timeout=None)
|
||||
|
|
@ -71,7 +71,7 @@ and work with streams:
|
|||
The *ssl_handshake_timeout* parameter.
|
||||
|
||||
.. coroutinefunction:: start_server(client_connected_cb, host=None, \
|
||||
port=None, *, limit=None, \
|
||||
port=None, \*, limit=None, \
|
||||
family=socket.AF_UNSPEC, \
|
||||
flags=socket.AI_PASSIVE, sock=None, \
|
||||
backlog=100, ssl=None, reuse_address=None, \
|
||||
|
|
@ -103,7 +103,7 @@ and work with streams:
|
|||
|
||||
.. rubric:: Unix Sockets
|
||||
|
||||
.. coroutinefunction:: open_unix_connection(path=None, *, limit=None, \
|
||||
.. coroutinefunction:: open_unix_connection(path=None, \*, limit=None, \
|
||||
ssl=None, sock=None, server_hostname=None, \
|
||||
ssl_handshake_timeout=None)
|
||||
|
||||
|
|
@ -126,7 +126,7 @@ and work with streams:
|
|||
|
||||
|
||||
.. coroutinefunction:: start_unix_server(client_connected_cb, path=None, \
|
||||
*, limit=None, sock=None, backlog=100, ssl=None, \
|
||||
\*, limit=None, sock=None, backlog=100, ssl=None, \
|
||||
ssl_handshake_timeout=None, start_serving=True)
|
||||
|
||||
Start a Unix socket server.
|
||||
|
|
@ -185,7 +185,7 @@ StreamReader
|
|||
can be read. Use the :attr:`IncompleteReadError.partial`
|
||||
attribute to get the partially read data.
|
||||
|
||||
.. coroutinemethod:: readuntil(separator=b'\n')
|
||||
.. coroutinemethod:: readuntil(separator=b'\\n')
|
||||
|
||||
Read data from the stream until *separator* is found.
|
||||
|
||||
|
|
|
|||
|
|
@ -61,8 +61,8 @@ See also the `Examples`_ subsection.
|
|||
Creating Subprocesses
|
||||
=====================
|
||||
|
||||
.. coroutinefunction:: create_subprocess_exec(program, *args, stdin=None, \
|
||||
stdout=None, stderr=None, limit=None, **kwds)
|
||||
.. coroutinefunction:: create_subprocess_exec(program, \*args, stdin=None, \
|
||||
stdout=None, stderr=None, limit=None, \*\*kwds)
|
||||
|
||||
Create a subprocess.
|
||||
|
||||
|
|
@ -77,7 +77,7 @@ Creating Subprocesses
|
|||
|
||||
|
||||
.. coroutinefunction:: create_subprocess_shell(cmd, stdin=None, \
|
||||
stdout=None, stderr=None, limit=None, **kwds)
|
||||
stdout=None, stderr=None, limit=None, \*\*kwds)
|
||||
|
||||
Run the *cmd* shell command.
|
||||
|
||||
|
|
|
|||
|
|
@ -101,8 +101,8 @@ Event
|
|||
that some event has happened.
|
||||
|
||||
An Event object manages an internal flag that can be set to *true*
|
||||
with the :meth:`~Event.set` method and reset to *false* with the
|
||||
:meth:`clear` method. The :meth:`~Event.wait` method blocks until the
|
||||
with the :meth:`set` method and reset to *false* with the
|
||||
:meth:`clear` method. The :meth:`wait` method blocks until the
|
||||
flag is set to *true*. The flag is set to *false* initially.
|
||||
|
||||
.. _asyncio_example_sync_event:
|
||||
|
|
@ -135,7 +135,7 @@ Event
|
|||
Wait until the event is set.
|
||||
|
||||
If the event is set, return ``True`` immediately.
|
||||
Otherwise block until another task calls :meth:`~Event.set`.
|
||||
Otherwise block until another task calls :meth:`set`.
|
||||
|
||||
.. method:: set()
|
||||
|
||||
|
|
@ -148,8 +148,8 @@ Event
|
|||
|
||||
Clear (unset) the event.
|
||||
|
||||
Tasks awaiting on :meth:`~Event.wait` will now block until the
|
||||
:meth:`~Event.set` method is called again.
|
||||
Tasks awaiting on :meth:`wait` will now block until the
|
||||
:meth:`set` method is called again.
|
||||
|
||||
.. method:: is_set()
|
||||
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@ is :meth:`loop.run_in_executor`.
|
|||
Running an asyncio Program
|
||||
==========================
|
||||
|
||||
.. function:: run(coro, *, debug=False)
|
||||
.. function:: run(coro, \*, debug=False)
|
||||
|
||||
Execute the :term:`coroutine` *coro* and return the result.
|
||||
|
||||
|
|
@ -247,7 +247,7 @@ Running an asyncio Program
|
|||
Creating Tasks
|
||||
==============
|
||||
|
||||
.. function:: create_task(coro, *, name=None)
|
||||
.. function:: create_task(coro, \*, name=None)
|
||||
|
||||
Wrap the *coro* :ref:`coroutine <coroutine>` into a :class:`Task`
|
||||
and schedule its execution. Return the Task object.
|
||||
|
|
@ -316,7 +316,7 @@ Sleeping
|
|||
Running Tasks Concurrently
|
||||
==========================
|
||||
|
||||
.. awaitablefunction:: gather(*aws, return_exceptions=False)
|
||||
.. awaitablefunction:: gather(\*aws, return_exceptions=False)
|
||||
|
||||
Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws*
|
||||
sequence *concurrently*.
|
||||
|
|
@ -488,7 +488,7 @@ Timeouts
|
|||
Waiting Primitives
|
||||
==================
|
||||
|
||||
.. coroutinefunction:: wait(aws, *, timeout=None, return_when=ALL_COMPLETED)
|
||||
.. coroutinefunction:: wait(aws, \*, timeout=None, return_when=ALL_COMPLETED)
|
||||
|
||||
Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws*
|
||||
iterable concurrently and block until the condition specified
|
||||
|
|
@ -573,7 +573,7 @@ Waiting Primitives
|
|||
deprecated.
|
||||
|
||||
|
||||
.. function:: as_completed(aws, *, timeout=None)
|
||||
.. function:: as_completed(aws, \*, timeout=None)
|
||||
|
||||
Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws*
|
||||
iterable concurrently. Return an iterator of coroutines.
|
||||
|
|
@ -593,7 +593,7 @@ Waiting Primitives
|
|||
Running in Threads
|
||||
==================
|
||||
|
||||
.. coroutinefunction:: to_thread(func, /, *args, **kwargs)
|
||||
.. coroutinefunction:: to_thread(func, /, \*args, \*\*kwargs)
|
||||
|
||||
Asynchronously run function *func* in a separate thread.
|
||||
|
||||
|
|
@ -723,7 +723,7 @@ Introspection
|
|||
Task Object
|
||||
===========
|
||||
|
||||
.. class:: Task(coro, *, loop=None, name=None)
|
||||
.. class:: Task(coro, \*, loop=None, name=None)
|
||||
|
||||
A :class:`Future-like <Future>` object that runs a Python
|
||||
:ref:`coroutine <coroutine>`. Not thread-safe.
|
||||
|
|
@ -889,7 +889,7 @@ Task Object
|
|||
See the documentation of :meth:`Future.remove_done_callback`
|
||||
for more details.
|
||||
|
||||
.. method:: get_stack(*, limit=None)
|
||||
.. method:: get_stack(\*, limit=None)
|
||||
|
||||
Return the list of stack frames for this Task.
|
||||
|
||||
|
|
@ -910,7 +910,7 @@ Task Object
|
|||
stack are returned, but the oldest frames of a traceback are
|
||||
returned. (This matches the behavior of the traceback module.)
|
||||
|
||||
.. method:: print_stack(*, limit=None, file=None)
|
||||
.. method:: print_stack(\*, limit=None, file=None)
|
||||
|
||||
Print the stack or traceback for this Task.
|
||||
|
||||
|
|
|
|||
|
|
@ -199,7 +199,7 @@ The modern interface provides:
|
|||
.. versionadded:: 3.4
|
||||
|
||||
|
||||
.. function:: a85decode(b, *, foldspaces=False, adobe=False, ignorechars=b' \t\n\r\v')
|
||||
.. function:: a85decode(b, *, foldspaces=False, adobe=False, ignorechars=b' \\t\\n\\r\\v')
|
||||
|
||||
Decode the Ascii85 encoded :term:`bytes-like object` or ASCII string *b* and
|
||||
return the decoded :class:`bytes`.
|
||||
|
|
|
|||
|
|
@ -148,7 +148,7 @@ runtime.
|
|||
Public functions
|
||||
----------------
|
||||
|
||||
.. function:: compile_dir(dir, maxlevels=sys.getrecursionlimit(), ddir=None, force=False, rx=None, quiet=0, legacy=False, optimize=-1, workers=1, invalidation_mode=None, *, stripdir=None, prependdir=None, limit_sl_dest=None, hardlink_dupes=False)
|
||||
.. function:: compile_dir(dir, maxlevels=sys.getrecursionlimit(), ddir=None, force=False, rx=None, quiet=0, legacy=False, optimize=-1, workers=1, invalidation_mode=None, \*, stripdir=None, prependdir=None, limit_sl_dest=None, hardlink_dupes=False)
|
||||
|
||||
Recursively descend the directory tree named by *dir*, compiling all :file:`.py`
|
||||
files along the way. Return a true value if all the files compiled successfully,
|
||||
|
|
@ -231,7 +231,7 @@ Public functions
|
|||
Added *stripdir*, *prependdir*, *limit_sl_dest* and *hardlink_dupes* arguments.
|
||||
Default value of *maxlevels* was changed from ``10`` to ``sys.getrecursionlimit()``
|
||||
|
||||
.. function:: compile_file(fullname, ddir=None, force=False, rx=None, quiet=0, legacy=False, optimize=-1, invalidation_mode=None, *, stripdir=None, prependdir=None, limit_sl_dest=None, hardlink_dupes=False)
|
||||
.. function:: compile_file(fullname, ddir=None, force=False, rx=None, quiet=0, legacy=False, optimize=-1, invalidation_mode=None, \*, stripdir=None, prependdir=None, limit_sl_dest=None, hardlink_dupes=False)
|
||||
|
||||
Compile the file with path *fullname*. Return a true value if the file
|
||||
compiled successfully, and a false value otherwise.
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ Executor Objects
|
|||
.. versionchanged:: 3.5
|
||||
Added the *chunksize* argument.
|
||||
|
||||
.. method:: shutdown(wait=True, *, cancel_futures=False)
|
||||
.. method:: shutdown(wait=True, \*, cancel_futures=False)
|
||||
|
||||
Signal the executor that it should free any resources that it is using
|
||||
when the currently pending futures are done executing. Calls to
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ See also :pep:`567` for additional details.
|
|||
Context Variables
|
||||
-----------------
|
||||
|
||||
.. class:: ContextVar(name, [*, default])
|
||||
.. class:: ContextVar(name, [\*, default])
|
||||
|
||||
This class is used to declare a new Context Variable, e.g.::
|
||||
|
||||
|
|
@ -146,7 +146,7 @@ Manual Context Management
|
|||
|
||||
Context implements the :class:`collections.abc.Mapping` interface.
|
||||
|
||||
.. method:: run(callable, *args, **kwargs)
|
||||
.. method:: run(callable, \*args, \*\*kwargs)
|
||||
|
||||
Execute ``callable(*args, **kwargs)`` code in the context object
|
||||
the *run* method is called on. Return the result of the execution
|
||||
|
|
|
|||
|
|
@ -2508,7 +2508,7 @@ other data types containing pointer type fields.
|
|||
Arrays and pointers
|
||||
^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. class:: Array(*args)
|
||||
.. class:: Array(\*args)
|
||||
|
||||
Abstract base class for arrays.
|
||||
|
||||
|
|
|
|||
|
|
@ -112,15 +112,14 @@ The module :mod:`curses` defines the following functions:
|
|||
.. function:: color_content(color_number)
|
||||
|
||||
Return the intensity of the red, green, and blue (RGB) components in the color
|
||||
*color_number*, which must be between ``0`` and ``COLORS - 1``. Return a 3-tuple,
|
||||
*color_number*, which must be between ``0`` and :const:`COLORS`. Return a 3-tuple,
|
||||
containing the R,G,B values for the given color, which will be between
|
||||
``0`` (no component) and ``1000`` (maximum amount of component).
|
||||
|
||||
|
||||
.. function:: color_pair(pair_number)
|
||||
.. function:: color_pair(color_number)
|
||||
|
||||
Return the attribute value for displaying text in the specified color pair.
|
||||
Only the first 256 color pairs are supported. This
|
||||
Return the attribute value for displaying text in the specified color. This
|
||||
attribute value can be combined with :const:`A_STANDOUT`, :const:`A_REVERSE`,
|
||||
and the other :const:`A_\*` attributes. :func:`pair_number` is the counterpart
|
||||
to this function.
|
||||
|
|
@ -288,7 +287,7 @@ The module :mod:`curses` defines the following functions:
|
|||
Change the definition of a color, taking the number of the color to be changed
|
||||
followed by three RGB values (for the amounts of red, green, and blue
|
||||
components). The value of *color_number* must be between ``0`` and
|
||||
`COLORS - 1`. Each of *r*, *g*, *b*, must be a value between ``0`` and
|
||||
:const:`COLORS`. Each of *r*, *g*, *b*, must be a value between ``0`` and
|
||||
``1000``. When :func:`init_color` is used, all occurrences of that color on the
|
||||
screen immediately change to the new definition. This function is a no-op on
|
||||
most terminals; it is active only if :func:`can_change_color` returns ``True``.
|
||||
|
|
@ -301,8 +300,7 @@ The module :mod:`curses` defines the following functions:
|
|||
color number. The value of *pair_number* must be between ``1`` and
|
||||
``COLOR_PAIRS - 1`` (the ``0`` color pair is wired to white on black and cannot
|
||||
be changed). The value of *fg* and *bg* arguments must be between ``0`` and
|
||||
``COLORS - 1``, or, after calling :func:`use_default_colors`, ``-1``.
|
||||
If the color-pair was previously initialized, the screen is
|
||||
:const:`COLORS`. If the color-pair was previously initialized, the screen is
|
||||
refreshed and all occurrences of that color-pair are changed to the new
|
||||
definition.
|
||||
|
||||
|
|
@ -452,7 +450,7 @@ The module :mod:`curses` defines the following functions:
|
|||
.. function:: pair_content(pair_number)
|
||||
|
||||
Return a tuple ``(fg, bg)`` containing the colors for the requested color pair.
|
||||
The value of *pair_number* must be between ``0`` and ``COLOR_PAIRS - 1``.
|
||||
The value of *pair_number* must be between ``1`` and ``COLOR_PAIRS - 1``.
|
||||
|
||||
|
||||
.. function:: pair_number(attr)
|
||||
|
|
|
|||
|
|
@ -1219,7 +1219,7 @@ Instance methods:
|
|||
|
||||
.. method:: datetime.replace(year=self.year, month=self.month, day=self.day, \
|
||||
hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, \
|
||||
tzinfo=self.tzinfo, *, fold=0)
|
||||
tzinfo=self.tzinfo, * fold=0)
|
||||
|
||||
Return a datetime with the same attributes, except for those attributes given
|
||||
new values by whichever keyword arguments are specified. Note that
|
||||
|
|
@ -1783,7 +1783,7 @@ Other constructor:
|
|||
Instance methods:
|
||||
|
||||
.. method:: time.replace(hour=self.hour, minute=self.minute, second=self.second, \
|
||||
microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)
|
||||
microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0)
|
||||
|
||||
Return a :class:`.time` with the same value, except for those attributes given
|
||||
new values by whichever keyword arguments are specified. Note that
|
||||
|
|
|
|||
|
|
@ -198,7 +198,7 @@ These do not emulate the native look-and-feel of the platform.
|
|||
A subclass of FileDialog that creates a dialog window for selecting a
|
||||
destination file.
|
||||
|
||||
.. method:: ok_command()
|
||||
.. method:: ok_command()
|
||||
|
||||
Test whether or not the selection points to a valid file that is not a
|
||||
directory. Confirmation is required if an already existing file is
|
||||
|
|
|
|||
|
|
@ -149,7 +149,7 @@ diffs. For comparing directories and files, see also, the :mod:`filecmp` module.
|
|||
contains a good example of its use.
|
||||
|
||||
|
||||
.. function:: context_diff(a, b, fromfile='', tofile='', fromfiledate='', tofiledate='', n=3, lineterm='\n')
|
||||
.. function:: context_diff(a, b, fromfile='', tofile='', fromfiledate='', tofiledate='', n=3, lineterm='\\n')
|
||||
|
||||
Compare *a* and *b* (lists of strings); return a delta (a :term:`generator`
|
||||
generating the delta lines) in context diff format.
|
||||
|
|
@ -279,7 +279,7 @@ diffs. For comparing directories and files, see also, the :mod:`filecmp` module.
|
|||
emu
|
||||
|
||||
|
||||
.. function:: unified_diff(a, b, fromfile='', tofile='', fromfiledate='', tofiledate='', n=3, lineterm='\n')
|
||||
.. function:: unified_diff(a, b, fromfile='', tofile='', fromfiledate='', tofiledate='', n=3, lineterm='\\n')
|
||||
|
||||
Compare *a* and *b* (lists of strings); return a delta (a :term:`generator`
|
||||
generating the delta lines) in unified diff format.
|
||||
|
|
@ -321,7 +321,7 @@ diffs. For comparing directories and files, see also, the :mod:`filecmp` module.
|
|||
|
||||
See :ref:`difflib-interface` for a more detailed example.
|
||||
|
||||
.. function:: diff_bytes(dfunc, a, b, fromfile=b'', tofile=b'', fromfiledate=b'', tofiledate=b'', n=3, lineterm=b'\n')
|
||||
.. function:: diff_bytes(dfunc, a, b, fromfile=b'', tofile=b'', fromfiledate=b'', tofiledate=b'', n=3, lineterm=b'\\n')
|
||||
|
||||
Compare *a* and *b* (lists of bytes objects) using *dfunc*; yield a
|
||||
sequence of delta lines (also bytes) in the format returned by *dfunc*.
|
||||
|
|
|
|||
|
|
@ -708,8 +708,7 @@ iterations of the loop.
|
|||
|
||||
.. opcode:: RERAISE
|
||||
|
||||
Re-raises the exception currently on top of the stack. If oparg is non-zero,
|
||||
restores ``f_lasti`` of the current frame to its value when the exception was raised.
|
||||
Re-raises the exception currently on top of the stack.
|
||||
|
||||
.. versionadded:: 3.9
|
||||
|
||||
|
|
|
|||
|
|
@ -719,51 +719,36 @@ above.
|
|||
An example's doctest directives modify doctest's behavior for that single
|
||||
example. Use ``+`` to enable the named behavior, or ``-`` to disable it.
|
||||
|
||||
For example, this test passes:
|
||||
For example, this test passes::
|
||||
|
||||
.. doctest::
|
||||
:no-trim-doctest-flags:
|
||||
|
||||
>>> print(list(range(20))) # doctest: +NORMALIZE_WHITESPACE
|
||||
>>> print(list(range(20))) # doctest: +NORMALIZE_WHITESPACE
|
||||
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
|
||||
10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
|
||||
|
||||
Without the directive it would fail, both because the actual output doesn't have
|
||||
two blanks before the single-digit list elements, and because the actual output
|
||||
is on a single line. This test also passes, and also requires a directive to do
|
||||
so:
|
||||
so::
|
||||
|
||||
.. doctest::
|
||||
:no-trim-doctest-flags:
|
||||
|
||||
>>> print(list(range(20))) # doctest: +ELLIPSIS
|
||||
>>> print(list(range(20))) # doctest: +ELLIPSIS
|
||||
[0, 1, ..., 18, 19]
|
||||
|
||||
Multiple directives can be used on a single physical line, separated by
|
||||
commas:
|
||||
commas::
|
||||
|
||||
.. doctest::
|
||||
:no-trim-doctest-flags:
|
||||
|
||||
>>> print(list(range(20))) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
|
||||
>>> print(list(range(20))) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
|
||||
[0, 1, ..., 18, 19]
|
||||
|
||||
If multiple directive comments are used for a single example, then they are
|
||||
combined:
|
||||
combined::
|
||||
|
||||
.. doctest::
|
||||
:no-trim-doctest-flags:
|
||||
|
||||
>>> print(list(range(20))) # doctest: +ELLIPSIS
|
||||
... # doctest: +NORMALIZE_WHITESPACE
|
||||
>>> print(list(range(20))) # doctest: +ELLIPSIS
|
||||
... # doctest: +NORMALIZE_WHITESPACE
|
||||
[0, 1, ..., 18, 19]
|
||||
|
||||
As the previous example shows, you can add ``...`` lines to your example
|
||||
containing only directives. This can be useful when an example is too long for
|
||||
a directive to comfortably fit on the same line:
|
||||
|
||||
.. doctest::
|
||||
:no-trim-doctest-flags:
|
||||
a directive to comfortably fit on the same line::
|
||||
|
||||
>>> print(list(range(5)) + list(range(10, 20)) + list(range(30, 40)))
|
||||
... # doctest: +ELLIPSIS
|
||||
|
|
@ -808,23 +793,18 @@ instead. Another is to do ::
|
|||
|
||||
There are others, but you get the idea.
|
||||
|
||||
Another bad idea is to print things that embed an object address, like
|
||||
Another bad idea is to print things that embed an object address, like ::
|
||||
|
||||
.. doctest::
|
||||
|
||||
>>> id(1.0) # certain to fail some of the time # doctest: +SKIP
|
||||
>>> id(1.0) # certain to fail some of the time
|
||||
7948648
|
||||
>>> class C: pass
|
||||
>>> C() # the default repr() for instances embeds an address # doctest: +SKIP
|
||||
<C object at 0x00AC18F0>
|
||||
>>> C() # the default repr() for instances embeds an address
|
||||
<__main__.C instance at 0x00AC18F0>
|
||||
|
||||
The :const:`ELLIPSIS` directive gives a nice approach for the last example:
|
||||
The :const:`ELLIPSIS` directive gives a nice approach for the last example::
|
||||
|
||||
.. doctest::
|
||||
:no-trim-doctest-flags:
|
||||
|
||||
>>> C() # doctest: +ELLIPSIS
|
||||
<C object at 0x...>
|
||||
>>> C() #doctest: +ELLIPSIS
|
||||
<__main__.C instance at 0x...>
|
||||
|
||||
Floating-point numbers are also subject to small output variations across
|
||||
platforms, because Python defers to the platform C library for float formatting,
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ Currently the email package provides only one concrete content manager,
|
|||
decoding the payload to unicode. The default error handler is
|
||||
``replace``.
|
||||
|
||||
.. method:: set_content(msg, <'str'>, subtype="plain", charset='utf-8', \
|
||||
.. method:: set_content(msg, <'str'>, subtype="plain", charset='utf-8' \
|
||||
cte=None, \
|
||||
disposition=None, filename=None, cid=None, \
|
||||
params=None, headers=None)
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ Here is the :class:`Header` class description:
|
|||
if *s* is a byte string.
|
||||
|
||||
|
||||
.. method:: encode(splitchars=';, \t', maxlinelen=None, linesep='\n')
|
||||
.. method:: encode(splitchars=';, \\t', maxlinelen=None, linesep='\\n')
|
||||
|
||||
Encode a message header into an RFC-compliant format, possibly wrapping
|
||||
long lines and encapsulating non-ASCII parts in base64 or quoted-printable
|
||||
|
|
|
|||
|
|
@ -289,7 +289,7 @@ variant, :attr:`~.BaseHeader.max_count` is set to 1.
|
|||
A :class:`ParameterizedMIMEHeader` class that handles the
|
||||
:mailheader:`Content-Disposition` header.
|
||||
|
||||
.. attribute:: content_disposition
|
||||
.. attribute:: content-disposition
|
||||
|
||||
``inline`` and ``attachment`` are the only valid values in common use.
|
||||
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@ added matters. To illustrate::
|
|||
:meth:`register_defect` method.
|
||||
|
||||
|
||||
.. attribute:: mangle_from_
|
||||
.. attribute:: mangle_from\_
|
||||
|
||||
If :const:`True`, lines starting with *"From "* in the body are
|
||||
escaped by putting a ``>`` in front of them. This parameter is used when
|
||||
|
|
|
|||
|
|
@ -61,18 +61,16 @@ helper, :class:`auto`.
|
|||
the bitwise operations without losing their :class:`Flag` membership.
|
||||
|
||||
.. function:: unique
|
||||
:noindex:
|
||||
:noindex:
|
||||
|
||||
Enum class decorator that ensures only one name is bound to any one value.
|
||||
|
||||
.. class:: auto
|
||||
|
||||
Instances are replaced with an appropriate value for Enum members.
|
||||
:class:`StrEnum` defaults to the lower-cased version of the member name,
|
||||
while other Enums default to 1 and increase from there.
|
||||
Instances are replaced with an appropriate value for Enum members. By default, the initial value starts at 1.
|
||||
|
||||
.. versionadded:: 3.6 ``Flag``, ``IntFlag``, ``auto``
|
||||
.. versionadded:: 3.10 ``StrEnum``
|
||||
|
||||
|
||||
Creating an Enum
|
||||
----------------
|
||||
|
|
@ -1166,15 +1164,6 @@ and raise an error if the two do not match::
|
|||
In Python 2 code the :attr:`_order_` attribute is necessary as definition
|
||||
order is lost before it can be recorded.
|
||||
|
||||
|
||||
_Private__names
|
||||
"""""""""""""""
|
||||
|
||||
Private names are not converted to Enum members, but remain normal attributes.
|
||||
|
||||
.. versionchanged:: 3.10
|
||||
|
||||
|
||||
``Enum`` member type
|
||||
""""""""""""""""""""
|
||||
|
||||
|
|
|
|||
|
|
@ -90,13 +90,8 @@ The following exceptions are used mostly as base classes for other exceptions.
|
|||
.. method:: with_traceback(tb)
|
||||
|
||||
This method sets *tb* as the new traceback for the exception and returns
|
||||
the exception object. It was more commonly used before the exception
|
||||
chaining features of :pep:`3134` became available. The following example
|
||||
shows how we can convert an instance of ``SomeException`` into an
|
||||
instance of ``OtherException`` while preserving the traceback. Once
|
||||
raised, the current frame is pushed onto the traceback of the
|
||||
``OtherException``, as would have happened to the traceback of the
|
||||
original ``SomeException`` had we allowed it to propagate to the caller.
|
||||
the exception object. It is usually used in exception handling code like
|
||||
this::
|
||||
|
||||
try:
|
||||
...
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ patterns.
|
|||
|
||||
.. function:: filter(names, pattern)
|
||||
|
||||
Construct a list from those elements of the iterable *names* that match *pattern*. It is the same as
|
||||
Return the subset of the list of *names* that match *pattern*. It is the same as
|
||||
``[n for n in names if fnmatch(n, pattern)]``, but implemented more efficiently.
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -478,15 +478,14 @@ are always available. They are listed here in alphabetical order.
|
|||
dictionaries as global and local namespace. If the *globals* dictionary is
|
||||
present and does not contain a value for the key ``__builtins__``, a
|
||||
reference to the dictionary of the built-in module :mod:`builtins` is
|
||||
inserted under that key before *expression* is parsed. That way you can
|
||||
control what builtins are available to the executed code by inserting your
|
||||
own ``__builtins__`` dictionary into *globals* before passing it to
|
||||
:func:`eval`. If the *locals* dictionary is omitted it defaults to the
|
||||
*globals* dictionary. If both dictionaries are omitted, the expression is
|
||||
executed with the *globals* and *locals* in the environment where
|
||||
:func:`eval` is called. Note, *eval()* does not have access to the
|
||||
:term:`nested scopes <nested scope>` (non-locals) in the enclosing
|
||||
environment.
|
||||
inserted under that key before *expression* is parsed. This means that
|
||||
*expression* normally has full access to the standard :mod:`builtins`
|
||||
module and restricted environments are propagated. If the *locals*
|
||||
dictionary is omitted it defaults to the *globals* dictionary. If both
|
||||
dictionaries are omitted, the expression is executed with the *globals* and
|
||||
*locals* in the environment where :func:`eval` is called. Note, *eval()*
|
||||
does not have access to the :term:`nested scopes <nested scope>` (non-locals) in the
|
||||
enclosing environment.
|
||||
|
||||
The return value is the result of
|
||||
the evaluated expression. Syntax errors are reported as exceptions. Example:
|
||||
|
|
@ -1334,7 +1333,7 @@ are always available. They are listed here in alphabetical order.
|
|||
supported.
|
||||
|
||||
|
||||
.. function:: print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
|
||||
.. function:: print(*objects, sep=' ', end='\\n', file=sys.stdout, flush=False)
|
||||
|
||||
Print *objects* to the text stream *file*, separated by *sep* and followed
|
||||
by *end*. *sep*, *end*, *file* and *flush*, if present, must be given as keyword
|
||||
|
|
|
|||
|
|
@ -62,26 +62,16 @@ The :mod:`functools` module defines the following functions:
|
|||
Example::
|
||||
|
||||
class DataSet:
|
||||
|
||||
def __init__(self, sequence_of_numbers):
|
||||
self._data = tuple(sequence_of_numbers)
|
||||
self._data = sequence_of_numbers
|
||||
|
||||
@cached_property
|
||||
def stdev(self):
|
||||
return statistics.stdev(self._data)
|
||||
|
||||
The mechanics of :func:`cached_property` are somewhat different from
|
||||
:func:`property`. A regular property blocks attribute writes unless a
|
||||
setter is defined. In contrast, a *cached_property* allows writes.
|
||||
|
||||
The *cached_property* decorator only runs on lookups and only when an
|
||||
attribute of the same name doesn't exist. When it does run, the
|
||||
*cached_property* writes to the attribute with the same name. Subsequent
|
||||
attribute reads and writes take precedence over the *cached_property*
|
||||
method and it works like a normal attribute.
|
||||
|
||||
The cached value can be cleared by deleting the attribute. This
|
||||
allows the *cached_property* method to run again.
|
||||
@cached_property
|
||||
def variance(self):
|
||||
return statistics.variance(self._data)
|
||||
|
||||
Note, this decorator interferes with the operation of :pep:`412`
|
||||
key-sharing dictionaries. This means that instance dictionaries
|
||||
|
|
|
|||
|
|
@ -93,7 +93,7 @@ Cookie Objects
|
|||
:meth:`value_decode` are inverses on the range of *value_decode*.
|
||||
|
||||
|
||||
.. method:: BaseCookie.output(attrs=None, header='Set-Cookie:', sep='\r\n')
|
||||
.. method:: BaseCookie.output(attrs=None, header='Set-Cookie:', sep='\\r\\n')
|
||||
|
||||
Return a string representation suitable to be sent as HTTP headers. *attrs* and
|
||||
*header* are sent to each :class:`Morsel`'s :meth:`output` method. *sep* is used
|
||||
|
|
|
|||
|
|
@ -115,9 +115,8 @@ Every distribution includes some metadata, which you can extract using the
|
|||
|
||||
>>> wheel_metadata = metadata('wheel') # doctest: +SKIP
|
||||
|
||||
The keys of the returned data structure, a ``PackageMetadata``,
|
||||
name the metadata keywords, and
|
||||
the values are returned unparsed from the distribution metadata::
|
||||
The keys of the returned data structure [#f1]_ name the metadata keywords, and
|
||||
their values are returned unparsed from the distribution metadata::
|
||||
|
||||
>>> wheel_metadata['Requires-Python'] # doctest: +SKIP
|
||||
'>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*'
|
||||
|
|
@ -207,9 +206,9 @@ Thus, an alternative way to get the version number is through the
|
|||
There are all kinds of additional metadata available on the ``Distribution``
|
||||
instance::
|
||||
|
||||
>>> dist.metadata['Requires-Python'] # doctest: +SKIP
|
||||
>>> d.metadata['Requires-Python'] # doctest: +SKIP
|
||||
'>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*'
|
||||
>>> dist.metadata['License'] # doctest: +SKIP
|
||||
>>> d.metadata['License'] # doctest: +SKIP
|
||||
'MIT'
|
||||
|
||||
The full set of available metadata is not described here. See :pep:`566`
|
||||
|
|
@ -260,3 +259,9 @@ a custom finder, return instances of this derived ``Distribution`` in the
|
|||
|
||||
|
||||
.. rubric:: Footnotes
|
||||
|
||||
.. [#f1] Technically, the returned distribution metadata object is an
|
||||
:class:`email.message.EmailMessage`
|
||||
instance, but this is an implementation detail, and not part of the
|
||||
stable API. You should only use dictionary-like methods and syntax
|
||||
to access the metadata contents.
|
||||
|
|
|
|||
|
|
@ -1138,7 +1138,7 @@ find and load modules.
|
|||
directory for ``''`` (i.e. the empty string).
|
||||
|
||||
|
||||
.. class:: FileFinder(path, *loader_details)
|
||||
.. class:: FileFinder(path, \*loader_details)
|
||||
|
||||
A concrete implementation of :class:`importlib.abc.PathEntryFinder` which
|
||||
caches results from the file system.
|
||||
|
|
@ -1181,7 +1181,7 @@ find and load modules.
|
|||
|
||||
Clear out the internal cache.
|
||||
|
||||
.. classmethod:: path_hook(*loader_details)
|
||||
.. classmethod:: path_hook(\*loader_details)
|
||||
|
||||
A class method which returns a closure for use on :attr:`sys.path_hooks`.
|
||||
An instance of :class:`FileFinder` is returned by the closure using the
|
||||
|
|
|
|||
|
|
@ -556,7 +556,7 @@ The Signature object represents the call signature of a callable object and its
|
|||
return annotation. To retrieve a Signature object, use the :func:`signature`
|
||||
function.
|
||||
|
||||
.. function:: signature(callable, *, follow_wrapped=True, globalns=None, localns=None)
|
||||
.. function:: signature(callable, \*, follow_wrapped=True)
|
||||
|
||||
Return a :class:`Signature` object for the given ``callable``::
|
||||
|
||||
|
|
@ -581,9 +581,6 @@ function.
|
|||
Raises :exc:`ValueError` if no signature can be provided, and
|
||||
:exc:`TypeError` if that type of object is not supported.
|
||||
|
||||
``globalns`` and ``localns`` are passed into
|
||||
:func:`typing.get_type_hints` when resolving the annotations.
|
||||
|
||||
A slash(/) in the signature of a function denotes that the parameters prior
|
||||
to it are positional-only. For more info, see
|
||||
:ref:`the FAQ entry on positional-only parameters <faq-positional-only-arguments>`.
|
||||
|
|
@ -593,23 +590,14 @@ function.
|
|||
``callable`` specifically (``callable.__wrapped__`` will not be used to
|
||||
unwrap decorated callables.)
|
||||
|
||||
.. versionadded:: 3.10
|
||||
``globalns`` and ``localns`` parameters.
|
||||
|
||||
.. note::
|
||||
|
||||
Some callables may not be introspectable in certain implementations of
|
||||
Python. For example, in CPython, some built-in functions defined in
|
||||
C provide no metadata about their arguments.
|
||||
|
||||
.. note::
|
||||
|
||||
Will first try to resolve the annotations, but when it fails and
|
||||
encounters with an error while that operation, the annotations will be
|
||||
returned unchanged (as strings).
|
||||
|
||||
|
||||
.. class:: Signature(parameters=None, *, return_annotation=Signature.empty)
|
||||
.. class:: Signature(parameters=None, \*, return_annotation=Signature.empty)
|
||||
|
||||
A Signature object represents the call signature of a function and its return
|
||||
annotation. For each parameter accepted by the function it stores a
|
||||
|
|
@ -680,12 +668,11 @@ function.
|
|||
>>> str(new_sig)
|
||||
"(a, b) -> 'new return anno'"
|
||||
|
||||
.. classmethod:: Signature.from_callable(obj, *, follow_wrapped=True, globalns=None, localns=None)
|
||||
.. classmethod:: Signature.from_callable(obj, \*, follow_wrapped=True)
|
||||
|
||||
Return a :class:`Signature` (or its subclass) object for a given callable
|
||||
``obj``. Pass ``follow_wrapped=False`` to get a signature of ``obj``
|
||||
without unwrapping its ``__wrapped__`` chain. ``globalns`` and
|
||||
``localns`` will be used as the namespaces when resolving annotations.
|
||||
without unwrapping its ``__wrapped__`` chain.
|
||||
|
||||
This method simplifies subclassing of :class:`Signature`::
|
||||
|
||||
|
|
@ -696,11 +683,8 @@ function.
|
|||
|
||||
.. versionadded:: 3.5
|
||||
|
||||
.. versionadded:: 3.10
|
||||
``globalns`` and ``localns`` parameters.
|
||||
|
||||
|
||||
.. class:: Parameter(name, kind, *, default=Parameter.empty, annotation=Parameter.empty)
|
||||
.. class:: Parameter(name, kind, \*, default=Parameter.empty, annotation=Parameter.empty)
|
||||
|
||||
Parameter objects are *immutable*. Instead of modifying a Parameter object,
|
||||
you can use :meth:`Parameter.replace` to create a modified copy.
|
||||
|
|
|
|||
|
|
@ -964,7 +964,7 @@ Text I/O
|
|||
.. versionadded:: 3.7
|
||||
|
||||
|
||||
.. class:: StringIO(initial_value='', newline='\n')
|
||||
.. class:: StringIO(initial_value='', newline='\\n')
|
||||
|
||||
A text stream using an in-memory text buffer. It inherits
|
||||
:class:`TextIOBase`.
|
||||
|
|
|
|||
|
|
@ -582,7 +582,7 @@ loops that truncate the stream.
|
|||
|
||||
Before :func:`product` runs, it completely consumes the input iterables,
|
||||
keeping pools of values in memory to generate the products. Accordingly,
|
||||
it is only useful with finite inputs.
|
||||
it only useful with finite inputs.
|
||||
|
||||
.. function:: repeat(object[, times])
|
||||
|
||||
|
|
@ -786,18 +786,6 @@ which incur interpreter overhead.
|
|||
def dotproduct(vec1, vec2):
|
||||
return sum(map(operator.mul, vec1, vec2))
|
||||
|
||||
def convolve(signal, kernel):
|
||||
# See: https://betterexplained.com/articles/intuitive-convolution/
|
||||
# convolve(data, [0.25, 0.25, 0.25, 0.25]) --> Moving average (blur)
|
||||
# convolve(data, [1, -1]) --> 1st finite difference (1st derivative)
|
||||
# convolve(data, [1, -2, 1]) --> 2nd finite difference (2nd derivative)
|
||||
kernel = tuple(kernel)[::-1]
|
||||
n = len(kernel)
|
||||
window = collections.deque([0], maxlen=n) * n
|
||||
for x in chain(signal, repeat(0, n-1)):
|
||||
window.append(x)
|
||||
yield sum(map(operator.mul, kernel, window))
|
||||
|
||||
def flatten(list_of_lists):
|
||||
"Flatten one level of nesting"
|
||||
return chain.from_iterable(list_of_lists)
|
||||
|
|
|
|||
|
|
@ -35,45 +35,45 @@ in :mod:`logging` itself) and defining handlers which are declared either in
|
|||
|
||||
.. function:: dictConfig(config)
|
||||
|
||||
Takes the logging configuration from a dictionary. The contents of
|
||||
this dictionary are described in :ref:`logging-config-dictschema`
|
||||
below.
|
||||
Takes the logging configuration from a dictionary. The contents of
|
||||
this dictionary are described in :ref:`logging-config-dictschema`
|
||||
below.
|
||||
|
||||
If an error is encountered during configuration, this function will
|
||||
raise a :exc:`ValueError`, :exc:`TypeError`, :exc:`AttributeError`
|
||||
or :exc:`ImportError` with a suitably descriptive message. The
|
||||
following is a (possibly incomplete) list of conditions which will
|
||||
raise an error:
|
||||
If an error is encountered during configuration, this function will
|
||||
raise a :exc:`ValueError`, :exc:`TypeError`, :exc:`AttributeError`
|
||||
or :exc:`ImportError` with a suitably descriptive message. The
|
||||
following is a (possibly incomplete) list of conditions which will
|
||||
raise an error:
|
||||
|
||||
* A ``level`` which is not a string or which is a string not
|
||||
corresponding to an actual logging level.
|
||||
* A ``propagate`` value which is not a boolean.
|
||||
* An id which does not have a corresponding destination.
|
||||
* A non-existent handler id found during an incremental call.
|
||||
* An invalid logger name.
|
||||
* Inability to resolve to an internal or external object.
|
||||
* A ``level`` which is not a string or which is a string not
|
||||
corresponding to an actual logging level.
|
||||
* A ``propagate`` value which is not a boolean.
|
||||
* An id which does not have a corresponding destination.
|
||||
* A non-existent handler id found during an incremental call.
|
||||
* An invalid logger name.
|
||||
* Inability to resolve to an internal or external object.
|
||||
|
||||
Parsing is performed by the :class:`DictConfigurator` class, whose
|
||||
constructor is passed the dictionary used for configuration, and
|
||||
has a :meth:`configure` method. The :mod:`logging.config` module
|
||||
has a callable attribute :attr:`dictConfigClass`
|
||||
which is initially set to :class:`DictConfigurator`.
|
||||
You can replace the value of :attr:`dictConfigClass` with a
|
||||
suitable implementation of your own.
|
||||
Parsing is performed by the :class:`DictConfigurator` class, whose
|
||||
constructor is passed the dictionary used for configuration, and
|
||||
has a :meth:`configure` method. The :mod:`logging.config` module
|
||||
has a callable attribute :attr:`dictConfigClass`
|
||||
which is initially set to :class:`DictConfigurator`.
|
||||
You can replace the value of :attr:`dictConfigClass` with a
|
||||
suitable implementation of your own.
|
||||
|
||||
:func:`dictConfig` calls :attr:`dictConfigClass` passing
|
||||
the specified dictionary, and then calls the :meth:`configure` method on
|
||||
the returned object to put the configuration into effect::
|
||||
:func:`dictConfig` calls :attr:`dictConfigClass` passing
|
||||
the specified dictionary, and then calls the :meth:`configure` method on
|
||||
the returned object to put the configuration into effect::
|
||||
|
||||
def dictConfig(config):
|
||||
dictConfigClass(config).configure()
|
||||
def dictConfig(config):
|
||||
dictConfigClass(config).configure()
|
||||
|
||||
For example, a subclass of :class:`DictConfigurator` could call
|
||||
``DictConfigurator.__init__()`` in its own :meth:`__init__()`, then
|
||||
set up custom prefixes which would be usable in the subsequent
|
||||
:meth:`configure` call. :attr:`dictConfigClass` would be bound to
|
||||
this new subclass, and then :func:`dictConfig` could be called exactly as
|
||||
in the default, uncustomized state.
|
||||
For example, a subclass of :class:`DictConfigurator` could call
|
||||
``DictConfigurator.__init__()`` in its own :meth:`__init__()`, then
|
||||
set up custom prefixes which would be usable in the subsequent
|
||||
:meth:`configure` call. :attr:`dictConfigClass` would be bound to
|
||||
this new subclass, and then :func:`dictConfig` could be called exactly as
|
||||
in the default, uncustomized state.
|
||||
|
||||
.. versionadded:: 3.2
|
||||
|
||||
|
|
|
|||
|
|
@ -1096,8 +1096,8 @@ functions.
|
|||
suitable value.
|
||||
|
||||
.. versionchanged:: 3.7
|
||||
The *level* parameter was defaulted to level ``CRITICAL``. See
|
||||
:issue:`28524` for more information about this change.
|
||||
The *level* parameter was defaulted to level ``CRITICAL``. See Issue
|
||||
#28524 for more information about this change.
|
||||
|
||||
.. function:: addLevelName(level, levelName)
|
||||
|
||||
|
|
@ -1174,9 +1174,7 @@ functions.
|
|||
| | to ``'a'``. |
|
||||
+--------------+---------------------------------------------+
|
||||
| *format* | Use the specified format string for the |
|
||||
| | handler. Defaults to attributes |
|
||||
| | ``levelname``, ``name`` and ``message`` |
|
||||
| | separated by colons. |
|
||||
| | handler. |
|
||||
+--------------+---------------------------------------------+
|
||||
| *datefmt* | Use the specified date/time format, as |
|
||||
| | accepted by :func:`time.strftime`. |
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ from multiple threads, it is necessary to protect it with a lock.
|
|||
Reading and writing compressed files
|
||||
------------------------------------
|
||||
|
||||
.. function:: open(filename, mode="rb", *, format=None, check=-1, preset=None, filters=None, encoding=None, errors=None, newline=None)
|
||||
.. function:: open(filename, mode="rb", \*, format=None, check=-1, preset=None, filters=None, encoding=None, errors=None, newline=None)
|
||||
|
||||
Open an LZMA-compressed file in binary or text mode, returning a :term:`file
|
||||
object`.
|
||||
|
|
@ -69,7 +69,7 @@ Reading and writing compressed files
|
|||
Accepts a :term:`path-like object`.
|
||||
|
||||
|
||||
.. class:: LZMAFile(filename=None, mode="r", *, format=None, check=-1, preset=None, filters=None)
|
||||
.. class:: LZMAFile(filename=None, mode="r", \*, format=None, check=-1, preset=None, filters=None)
|
||||
|
||||
Open an LZMA-compressed file in binary mode.
|
||||
|
||||
|
|
|
|||
|
|
@ -2661,46 +2661,6 @@ The :mod:`multiprocessing.dummy` module
|
|||
:mod:`multiprocessing.dummy` replicates the API of :mod:`multiprocessing` but is
|
||||
no more than a wrapper around the :mod:`threading` module.
|
||||
|
||||
.. currentmodule:: multiprocessing.pool
|
||||
|
||||
In particular, the ``Pool`` function provided by :mod:`multiprocessing.dummy`
|
||||
returns an instance of :class:`ThreadPool`, which is a subclass of
|
||||
:class:`Pool` that supports all the same method calls but uses a pool of
|
||||
worker threads rather than worker processes.
|
||||
|
||||
|
||||
.. class:: ThreadPool([processes[, initializer[, initargs]]])
|
||||
|
||||
A thread pool object which controls a pool of worker threads to which jobs
|
||||
can be submitted. :class:`ThreadPool` instances are fully interface
|
||||
compatible with :class:`Pool` instances, and their resources must also be
|
||||
properly managed, either by using the pool as a context manager or by
|
||||
calling :meth:`~multiprocessing.pool.Pool.close` and
|
||||
:meth:`~multiprocessing.pool.Pool.terminate` manually.
|
||||
|
||||
*processes* is the number of worker threads to use. If *processes* is
|
||||
``None`` then the number returned by :func:`os.cpu_count` is used.
|
||||
|
||||
If *initializer* is not ``None`` then each worker process will call
|
||||
``initializer(*initargs)`` when it starts.
|
||||
|
||||
Unlike :class:`Pool`, *maxtasksperchild* and *context* cannot be provided.
|
||||
|
||||
.. note::
|
||||
|
||||
A :class:`ThreadPool` shares the same interface as :class:`Pool`, which
|
||||
is designed around a pool of processes and predates the introduction of
|
||||
the :class:`concurrent.futures` module. As such, it inherits some
|
||||
operations that don't make sense for a pool backed by threads, and it
|
||||
has its own type for representing the status of asynchronous jobs,
|
||||
:class:`AsyncResult`, that is not understood by any other libraries.
|
||||
|
||||
Users should generally prefer to use
|
||||
:class:`concurrent.futures.ThreadPoolExecutor`, which has a simpler
|
||||
interface that was designed around threads from the start, and which
|
||||
returns :class:`concurrent.futures.Future` instances that are
|
||||
compatible with many other libraries, including :mod:`asyncio`.
|
||||
|
||||
|
||||
.. _multiprocessing-programming:
|
||||
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ Notes on the availability of these functions:
|
|||
objects, and result in an object of the same type, if a path or file name is
|
||||
returned.
|
||||
|
||||
* On VxWorks, os.popen, os.fork, os.execv and os.spawn*p* are not supported.
|
||||
* On VxWorks, os.fork, os.execv and os.spawn*p* are not supported.
|
||||
|
||||
.. note::
|
||||
|
||||
|
|
@ -1323,12 +1323,12 @@ or `the MSDN <https://msdn.microsoft.com/en-us/library/z0kc8e3z.aspx>`_ on Windo
|
|||
|
||||
.. data:: RWF_APPEND
|
||||
|
||||
Provide a per-write equivalent of the :data:`O_APPEND` :func:`os.open`
|
||||
flag. This flag is meaningful only for :func:`os.pwritev`, and its
|
||||
effect applies only to the data range written by the system call. The
|
||||
*offset* argument does not affect the write operation; the data is always
|
||||
appended to the end of the file. However, if the *offset* argument is
|
||||
``-1``, the current file *offset* is updated.
|
||||
Provide a per-write equivalent of the :data:`O_APPEND` :func:`os.open`
|
||||
flag. This flag is meaningful only for :func:`os.pwritev`, and its
|
||||
effect applies only to the data range written by the system call. The
|
||||
*offset* argument does not affect the write operation; the data is always
|
||||
appended to the end of the file. However, if the *offset* argument is
|
||||
``-1``, the current file *offset* is updated.
|
||||
|
||||
.. availability:: Linux 4.16 and newer.
|
||||
|
||||
|
|
@ -1991,7 +1991,7 @@ features:
|
|||
Accepts a :term:`path-like object`.
|
||||
|
||||
|
||||
.. function:: lstat(path, *, dir_fd=None)
|
||||
.. function:: lstat(path, \*, dir_fd=None)
|
||||
|
||||
Perform the equivalent of an :c:func:`lstat` system call on the given path.
|
||||
Similar to :func:`~os.stat`, but does not follow symbolic links. Return a
|
||||
|
|
@ -2498,7 +2498,7 @@ features:
|
|||
On the first, uncached call, a system call is required on Windows but
|
||||
not on Unix.
|
||||
|
||||
.. method:: is_dir(*, follow_symlinks=True)
|
||||
.. method:: is_dir(\*, follow_symlinks=True)
|
||||
|
||||
Return ``True`` if this entry is a directory or a symbolic link pointing
|
||||
to a directory; return ``False`` if the entry is or points to any other
|
||||
|
|
@ -2522,7 +2522,7 @@ features:
|
|||
This method can raise :exc:`OSError`, such as :exc:`PermissionError`,
|
||||
but :exc:`FileNotFoundError` is caught and not raised.
|
||||
|
||||
.. method:: is_file(*, follow_symlinks=True)
|
||||
.. method:: is_file(\*, follow_symlinks=True)
|
||||
|
||||
Return ``True`` if this entry is a file or a symbolic link pointing to a
|
||||
file; return ``False`` if the entry is or points to a directory or other
|
||||
|
|
@ -2552,7 +2552,7 @@ features:
|
|||
This method can raise :exc:`OSError`, such as :exc:`PermissionError`,
|
||||
but :exc:`FileNotFoundError` is caught and not raised.
|
||||
|
||||
.. method:: stat(*, follow_symlinks=True)
|
||||
.. method:: stat(\*, follow_symlinks=True)
|
||||
|
||||
Return a :class:`stat_result` object for this entry. This method
|
||||
follows symbolic links by default; to stat a symbolic link add the
|
||||
|
|
@ -2584,7 +2584,7 @@ features:
|
|||
for :class:`bytes` paths on Windows.
|
||||
|
||||
|
||||
.. function:: stat(path, *, dir_fd=None, follow_symlinks=True)
|
||||
.. function:: stat(path, \*, dir_fd=None, follow_symlinks=True)
|
||||
|
||||
Get the status of a file or a file descriptor. Perform the equivalent of a
|
||||
:c:func:`stat` system call on the given path. *path* may be specified as
|
||||
|
|
|
|||
|
|
@ -213,7 +213,7 @@ The :mod:`pickle` module provides the following constants:
|
|||
The :mod:`pickle` module provides the following functions to make the pickling
|
||||
process more convenient:
|
||||
|
||||
.. function:: dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None)
|
||||
.. function:: dump(obj, file, protocol=None, \*, fix_imports=True, buffer_callback=None)
|
||||
|
||||
Write the pickled representation of the object *obj* to the open
|
||||
:term:`file object` *file*. This is equivalent to
|
||||
|
|
@ -225,7 +225,7 @@ process more convenient:
|
|||
.. versionchanged:: 3.8
|
||||
The *buffer_callback* argument was added.
|
||||
|
||||
.. function:: dumps(obj, protocol=None, *, fix_imports=True, buffer_callback=None)
|
||||
.. function:: dumps(obj, protocol=None, \*, fix_imports=True, buffer_callback=None)
|
||||
|
||||
Return the pickled representation of the object *obj* as a :class:`bytes` object,
|
||||
instead of writing it to a file.
|
||||
|
|
@ -236,7 +236,7 @@ process more convenient:
|
|||
.. versionchanged:: 3.8
|
||||
The *buffer_callback* argument was added.
|
||||
|
||||
.. function:: load(file, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)
|
||||
.. function:: load(file, \*, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)
|
||||
|
||||
Read the pickled representation of an object from the open :term:`file object`
|
||||
*file* and return the reconstituted object hierarchy specified therein.
|
||||
|
|
@ -252,7 +252,7 @@ process more convenient:
|
|||
.. versionchanged:: 3.8
|
||||
The *buffers* argument was added.
|
||||
|
||||
.. function:: loads(data, /, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)
|
||||
.. function:: loads(data, /, \*, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)
|
||||
|
||||
Return the reconstituted object hierarchy of the pickled representation
|
||||
*data* of an object. *data* must be a :term:`bytes-like object`.
|
||||
|
|
@ -296,7 +296,7 @@ The :mod:`pickle` module defines three exceptions:
|
|||
The :mod:`pickle` module exports three classes, :class:`Pickler`,
|
||||
:class:`Unpickler` and :class:`PickleBuffer`:
|
||||
|
||||
.. class:: Pickler(file, protocol=None, *, fix_imports=True, buffer_callback=None)
|
||||
.. class:: Pickler(file, protocol=None, \*, fix_imports=True, buffer_callback=None)
|
||||
|
||||
This takes a binary file for writing a pickle data stream.
|
||||
|
||||
|
|
@ -391,7 +391,7 @@ The :mod:`pickle` module exports three classes, :class:`Pickler`,
|
|||
Use :func:`pickletools.optimize` if you need more compact pickles.
|
||||
|
||||
|
||||
.. class:: Unpickler(file, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)
|
||||
.. class:: Unpickler(file, \*, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)
|
||||
|
||||
This takes a binary file for reading a pickle data stream.
|
||||
|
||||
|
|
|
|||
|
|
@ -290,4 +290,4 @@ Linux Platforms
|
|||
ids.extend(info["ID_LIKE"].split())
|
||||
return ids
|
||||
|
||||
.. versionadded:: 3.10
|
||||
.. versionadded:: 3.10
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ or :class:`datetime.datetime` objects.
|
|||
|
||||
This module defines the following functions:
|
||||
|
||||
.. function:: load(fp, *, fmt=None, dict_type=dict)
|
||||
.. function:: load(fp, \*, fmt=None, dict_type=dict)
|
||||
|
||||
Read a plist file. *fp* should be a readable and binary file object.
|
||||
Return the unpacked root object (which usually is a
|
||||
|
|
@ -80,7 +80,7 @@ This module defines the following functions:
|
|||
.. versionadded:: 3.4
|
||||
|
||||
|
||||
.. function:: loads(data, *, fmt=None, dict_type=dict)
|
||||
.. function:: loads(data, \*, fmt=None, dict_type=dict)
|
||||
|
||||
Load a plist from a bytes object. See :func:`load` for an explanation of
|
||||
the keyword arguments.
|
||||
|
|
@ -88,7 +88,7 @@ This module defines the following functions:
|
|||
.. versionadded:: 3.4
|
||||
|
||||
|
||||
.. function:: dump(value, fp, *, fmt=FMT_XML, sort_keys=True, skipkeys=False)
|
||||
.. function:: dump(value, fp, \*, fmt=FMT_XML, sort_keys=True, skipkeys=False)
|
||||
|
||||
Write *value* to a plist file. *Fp* should be a writable, binary
|
||||
file object.
|
||||
|
|
@ -116,7 +116,7 @@ This module defines the following functions:
|
|||
.. versionadded:: 3.4
|
||||
|
||||
|
||||
.. function:: dumps(value, *, fmt=FMT_XML, sort_keys=True, skipkeys=False)
|
||||
.. function:: dumps(value, \*, fmt=FMT_XML, sort_keys=True, skipkeys=False)
|
||||
|
||||
Return *value* as a plist-formatted bytes object. See
|
||||
the documentation for :func:`dump` for an explanation of the keyword
|
||||
|
|
|
|||
|
|
@ -525,16 +525,16 @@ Analysis of the profiler data is done using the :class:`~pstats.Stats` class.
|
|||
ordering are identical to the :meth:`~pstats.Stats.print_callers` method.
|
||||
|
||||
|
||||
.. method:: get_stats_profile()
|
||||
.. method:: get_stats_profile()
|
||||
|
||||
This method returns an instance of StatsProfile, which contains a mapping
|
||||
of function names to instances of FunctionProfile. Each FunctionProfile
|
||||
instance holds information related to the function's profile such as how
|
||||
long the function took to run, how many times it was called, etc...
|
||||
|
||||
.. versionadded:: 3.9
|
||||
Added the following dataclasses: StatsProfile, FunctionProfile.
|
||||
Added the following function: get_stats_profile.
|
||||
.. versionadded:: 3.9
|
||||
Added the following dataclasses: StatsProfile, FunctionProfile.
|
||||
Added the following function: get_stats_profile.
|
||||
|
||||
.. _deterministic-profiling:
|
||||
|
||||
|
|
|
|||
|
|
@ -665,14 +665,14 @@ The ``errors`` module has the following attributes:
|
|||
|
||||
.. data:: codes
|
||||
|
||||
A dictionary mapping string descriptions to their error codes.
|
||||
A dictionary mapping numeric error codes to their string descriptions.
|
||||
|
||||
.. versionadded:: 3.2
|
||||
|
||||
|
||||
.. data:: messages
|
||||
|
||||
A dictionary mapping numeric error codes to their string descriptions.
|
||||
A dictionary mapping string descriptions to their error codes.
|
||||
|
||||
.. versionadded:: 3.2
|
||||
|
||||
|
|
|
|||
|
|
@ -135,15 +135,6 @@ Functions for integers
|
|||
values. Formerly it used a style like ``int(random()*n)`` which could produce
|
||||
slightly uneven distributions.
|
||||
|
||||
.. deprecated:: 3.10
|
||||
The automatic conversion of non-integer types to equivalent integers is
|
||||
deprecated. Currently ``randrange(10.0)`` is losslessly converted to
|
||||
``randrange(10)``. In the future, this will raise a :exc:`TypeError`.
|
||||
|
||||
.. deprecated:: 3.10
|
||||
The exception raised for non-integral values such as ``range(10.5)``
|
||||
will be changed from :exc:`ValueError` to :exc:`TypeError`.
|
||||
|
||||
.. function:: randint(a, b)
|
||||
|
||||
Return a random integer *N* such that ``a <= N <= b``. Alias for
|
||||
|
|
@ -151,11 +142,10 @@ Functions for integers
|
|||
|
||||
.. function:: getrandbits(k)
|
||||
|
||||
Returns a non-negative Python integer with *k* random bits. This method
|
||||
is supplied with the MersenneTwister generator and some other generators
|
||||
may also provide it as an optional part of the API. When available,
|
||||
:meth:`getrandbits` enables :meth:`randrange` to handle arbitrarily large
|
||||
ranges.
|
||||
Returns a Python integer with *k* random bits. This method is supplied with
|
||||
the MersenneTwister generator and some other generators may also provide it
|
||||
as an optional part of the API. When available, :meth:`getrandbits` enables
|
||||
:meth:`randrange` to handle arbitrarily large ranges.
|
||||
|
||||
.. versionchanged:: 3.9
|
||||
This method now accepts zero for *k*.
|
||||
|
|
|
|||
|
|
@ -218,7 +218,7 @@ Directory and files operations
|
|||
copy the file more efficiently. See
|
||||
:ref:`shutil-platform-dependent-efficient-copy-operations` section.
|
||||
|
||||
.. function:: ignore_patterns(*patterns)
|
||||
.. function:: ignore_patterns(\*patterns)
|
||||
|
||||
This factory function creates a function that can be used as a callable for
|
||||
:func:`copytree`\'s *ignore* argument, ignoring files and directories that
|
||||
|
|
|
|||
|
|
@ -56,12 +56,12 @@ created. Socket addresses are represented as follows:
|
|||
bytes-like object can be used for either type of address when
|
||||
passing it as an argument.
|
||||
|
||||
.. versionchanged:: 3.3
|
||||
Previously, :const:`AF_UNIX` socket paths were assumed to use UTF-8
|
||||
encoding.
|
||||
.. versionchanged:: 3.3
|
||||
Previously, :const:`AF_UNIX` socket paths were assumed to use UTF-8
|
||||
encoding.
|
||||
|
||||
.. versionchanged:: 3.5
|
||||
Writable :term:`bytes-like object` is now accepted.
|
||||
.. versionchanged:: 3.5
|
||||
Writable :term:`bytes-like object` is now accepted.
|
||||
|
||||
.. _host_port:
|
||||
|
||||
|
|
@ -907,9 +907,11 @@ The :mod:`socket` module also offers various network-related services:
|
|||
where the host byte order is the same as network byte order, this is a no-op;
|
||||
otherwise, it performs a 2-byte swap operation.
|
||||
|
||||
.. versionchanged:: 3.10
|
||||
Raises :exc:`OverflowError` if *x* does not fit in a 16-bit unsigned
|
||||
integer.
|
||||
.. deprecated:: 3.7
|
||||
In case *x* does not fit in 16-bit unsigned integer, but does fit in a
|
||||
positive C int, it is silently truncated to 16-bit unsigned integer.
|
||||
This silent truncation feature is deprecated, and will raise an
|
||||
exception in future versions of Python.
|
||||
|
||||
|
||||
.. function:: htonl(x)
|
||||
|
|
@ -925,9 +927,11 @@ The :mod:`socket` module also offers various network-related services:
|
|||
where the host byte order is the same as network byte order, this is a no-op;
|
||||
otherwise, it performs a 2-byte swap operation.
|
||||
|
||||
.. versionchanged:: 3.10
|
||||
Raises :exc:`OverflowError` if *x* does not fit in a 16-bit unsigned
|
||||
integer.
|
||||
.. deprecated:: 3.7
|
||||
In case *x* does not fit in 16-bit unsigned integer, but does fit in a
|
||||
positive C int, it is silently truncated to 16-bit unsigned integer.
|
||||
This silent truncation feature is deprecated, and will raise an
|
||||
exception in future versions of Python.
|
||||
|
||||
|
||||
.. function:: inet_aton(ip_string)
|
||||
|
|
|
|||
|
|
@ -198,9 +198,7 @@ Module functions and constants
|
|||
|
||||
*detect_types* defaults to 0 (i. e. off, no type detection), you can set it to
|
||||
any combination of :const:`PARSE_DECLTYPES` and :const:`PARSE_COLNAMES` to turn
|
||||
type detection on. Due to SQLite behaviour, types can't be detected for generated
|
||||
fields (for example ``max(data)``), even when *detect_types* parameter is set. In
|
||||
such case, the returned type is :class:`str`.
|
||||
type detection on.
|
||||
|
||||
By default, *check_same_thread* is :const:`True` and only the creating thread may
|
||||
use the connection. If set :const:`False`, the returned connection may be shared
|
||||
|
|
@ -546,7 +544,7 @@ Connection Objects
|
|||
con.close()
|
||||
|
||||
|
||||
.. method:: backup(target, *, pages=-1, progress=None, name="main", sleep=0.250)
|
||||
.. method:: backup(target, *, pages=0, progress=None, name="main", sleep=0.250)
|
||||
|
||||
This method makes a backup of a SQLite database even while it's being accessed
|
||||
by other clients, or concurrently by the same connection. The copy will be
|
||||
|
|
|
|||
|
|
@ -156,11 +156,10 @@ However, for reading convenience, most of the examples show sorted sequences.
|
|||
.. versionadded:: 3.8
|
||||
|
||||
|
||||
.. function:: harmonic_mean(data, weights=None)
|
||||
.. function:: harmonic_mean(data)
|
||||
|
||||
Return the harmonic mean of *data*, a sequence or iterable of
|
||||
real-valued numbers. If *weights* is omitted or *None*, then
|
||||
equal weighting is assumed.
|
||||
real-valued numbers.
|
||||
|
||||
The harmonic mean, sometimes called the subcontrary mean, is the
|
||||
reciprocal of the arithmetic :func:`mean` of the reciprocals of the
|
||||
|
|
@ -180,17 +179,17 @@ However, for reading convenience, most of the examples show sorted sequences.
|
|||
>>> harmonic_mean([40, 60])
|
||||
48.0
|
||||
|
||||
Suppose a car travels 40 km/hr for 5 km, and when traffic clears,
|
||||
speeds-up to 60 km/hr for the remaining 30 km of the journey. What
|
||||
is the average speed?
|
||||
Suppose an investor purchases an equal value of shares in each of
|
||||
three companies, with P/E (price/earning) ratios of 2.5, 3 and 10.
|
||||
What is the average P/E ratio for the investor's portfolio?
|
||||
|
||||
.. doctest::
|
||||
|
||||
>>> harmonic_mean([40, 60], weights=[5, 30])
|
||||
56.0
|
||||
>>> harmonic_mean([2.5, 3, 10]) # For an equal investment portfolio.
|
||||
3.6
|
||||
|
||||
:exc:`StatisticsError` is raised if *data* is empty, any element
|
||||
is less than zero, or if the weighted sum isn't positive.
|
||||
:exc:`StatisticsError` is raised if *data* is empty, or any element
|
||||
is less than zero.
|
||||
|
||||
The current algorithm has an early-out when it encounters a zero
|
||||
in the input. This means that the subsequent inputs are not tested
|
||||
|
|
@ -198,8 +197,6 @@ However, for reading convenience, most of the examples show sorted sequences.
|
|||
|
||||
.. versionadded:: 3.6
|
||||
|
||||
.. versionchanged:: 3.10
|
||||
Added support for *weights*.
|
||||
|
||||
.. function:: median(data)
|
||||
|
||||
|
|
|
|||
|
|
@ -499,7 +499,7 @@ class`. In addition, it provides a few more methods:
|
|||
|
||||
.. versionadded:: 3.10
|
||||
|
||||
.. method:: int.to_bytes(length, byteorder, *, signed=False)
|
||||
.. method:: int.to_bytes(length, byteorder, \*, signed=False)
|
||||
|
||||
Return an array of bytes representing an integer.
|
||||
|
||||
|
|
@ -531,7 +531,7 @@ class`. In addition, it provides a few more methods:
|
|||
|
||||
.. versionadded:: 3.2
|
||||
|
||||
.. classmethod:: int.from_bytes(bytes, byteorder, *, signed=False)
|
||||
.. classmethod:: int.from_bytes(bytes, byteorder, \*, signed=False)
|
||||
|
||||
Return the integer represented by the given array of bytes.
|
||||
|
||||
|
|
@ -4959,11 +4959,6 @@ All parameterized generics implement special read-only attributes.
|
|||
(~T,)
|
||||
|
||||
|
||||
.. note::
|
||||
A ``GenericAlias`` object with :class:`typing.ParamSpec` parameters may not
|
||||
have correct ``__parameters__`` after substitution because
|
||||
:class:`typing.ParamSpec` is intended primarily for static type checking.
|
||||
|
||||
.. seealso::
|
||||
|
||||
* :pep:`585` -- "Type Hinting Generics In Standard Collections"
|
||||
|
|
@ -5358,8 +5353,8 @@ types, where they are relevant. Some of these are not reported by the
|
|||
.. method:: class.__subclasses__
|
||||
|
||||
Each class keeps a list of weak references to its immediate subclasses. This
|
||||
method returns a list of all those references still alive. The list is in
|
||||
definition order. Example::
|
||||
method returns a list of all those references still alive.
|
||||
Example::
|
||||
|
||||
>>> int.__subclasses__()
|
||||
[<class 'bool'>]
|
||||
|
|
|
|||
|
|
@ -514,8 +514,6 @@ The available presentation types for :class:`float` and
|
|||
| | this rounds the number to ``p`` significant digits and |
|
||||
| | then formats the result in either fixed-point format |
|
||||
| | or in scientific notation, depending on its magnitude. |
|
||||
| | A precision of ``0`` is treated as equivalent to a |
|
||||
| | precision of ``1``. |
|
||||
| | |
|
||||
| | The precise rules are as follows: suppose that the |
|
||||
| | result formatted with presentation type ``'e'`` and |
|
||||
|
|
@ -530,19 +528,16 @@ The available presentation types for :class:`float` and
|
|||
| | removed if there are no remaining digits following it, |
|
||||
| | unless the ``'#'`` option is used. |
|
||||
| | |
|
||||
| | With no precision given, uses a precision of ``6`` |
|
||||
| | significant digits for :class:`float`. For |
|
||||
| | :class:`~decimal.Decimal`, the coefficient of the result |
|
||||
| | is formed from the coefficient digits of the value; |
|
||||
| | scientific notation is used for values smaller than |
|
||||
| | ``1e-6`` in absolute value and values where the place |
|
||||
| | value of the least significant digit is larger than 1, |
|
||||
| | and fixed-point notation is used otherwise. |
|
||||
| | |
|
||||
| | Positive and negative infinity, positive and negative |
|
||||
| | zero, and nans, are formatted as ``inf``, ``-inf``, |
|
||||
| | ``0``, ``-0`` and ``nan`` respectively, regardless of |
|
||||
| | the precision. |
|
||||
| | |
|
||||
| | A precision of ``0`` is treated as equivalent to a |
|
||||
| | precision of ``1``. With no precision given, uses a |
|
||||
| | precision of ``6`` significant digits for |
|
||||
| | :class:`float`, and shows all coefficient digits |
|
||||
| | for :class:`~decimal.Decimal`. |
|
||||
+---------+----------------------------------------------------------+
|
||||
| ``'G'`` | General format. Same as ``'g'`` except switches to |
|
||||
| | ``'E'`` if the number gets too large. The |
|
||||
|
|
@ -555,18 +550,12 @@ The available presentation types for :class:`float` and
|
|||
| ``'%'`` | Percentage. Multiplies the number by 100 and displays |
|
||||
| | in fixed (``'f'``) format, followed by a percent sign. |
|
||||
+---------+----------------------------------------------------------+
|
||||
| None | For :class:`float` this is the same as ``'g'``, except |
|
||||
| | that when fixed-point notation is used to format the |
|
||||
| | result, it always includes at least one digit past the |
|
||||
| | decimal point. The precision used is as large as needed |
|
||||
| | to represent the given value faithfully. |
|
||||
| | |
|
||||
| | For :class:`~decimal.Decimal`, this is the same as |
|
||||
| | either ``'g'`` or ``'G'`` depending on the value of |
|
||||
| | ``context.capitals`` for the current decimal context. |
|
||||
| | |
|
||||
| | The overall effect is to match the output of :func:`str` |
|
||||
| | as altered by the other format modifiers. |
|
||||
| None | Similar to ``'g'``, except that fixed-point notation, |
|
||||
| | when used, has at least one digit past the decimal point.|
|
||||
| | The default precision is as high as needed to represent |
|
||||
| | the particular value. The overall effect is to match the |
|
||||
| | output of :func:`str` as altered by the other format |
|
||||
| | modifiers. |
|
||||
+---------+----------------------------------------------------------+
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -339,7 +339,7 @@ functions.
|
|||
stderr=None, preexec_fn=None, close_fds=True, shell=False, \
|
||||
cwd=None, env=None, universal_newlines=None, \
|
||||
startupinfo=None, creationflags=0, restore_signals=True, \
|
||||
start_new_session=False, pass_fds=(), *, group=None, \
|
||||
start_new_session=False, pass_fds=(), \*, group=None, \
|
||||
extra_groups=None, user=None, umask=-1, \
|
||||
encoding=None, errors=None, text=None, pipesize=-1)
|
||||
|
||||
|
|
@ -1187,9 +1187,8 @@ calls these functions.
|
|||
The arguments shown above are merely some common ones.
|
||||
The full function signature is largely the same as that of :func:`run` -
|
||||
most arguments are passed directly through to that interface.
|
||||
One API deviation from :func:`run` behavior exists: passing ``input=None``
|
||||
will behave the same as ``input=b''`` (or ``input=''``, depending on other
|
||||
arguments) rather than using the parent's standard input file handle.
|
||||
However, explicitly passing ``input=None`` to inherit the parent's
|
||||
standard input file handle is not supported.
|
||||
|
||||
By default, this function will return the data as encoded bytes. The actual
|
||||
encoding of the output data may depend on the command being invoked, so the
|
||||
|
|
@ -1282,7 +1281,7 @@ be used directly:
|
|||
|
||||
becomes::
|
||||
|
||||
output = check_output("dmesg | grep hda", shell=True)
|
||||
output=check_output("dmesg | grep hda", shell=True)
|
||||
|
||||
|
||||
Replacing :func:`os.system`
|
||||
|
|
|
|||
|
|
@ -156,12 +156,10 @@ Examining Symbol Tables
|
|||
|
||||
Return ``True`` if the symbol is local to its block.
|
||||
|
||||
.. method:: is_annotated()
|
||||
.. method:: is_annotated()
|
||||
|
||||
Return ``True`` if the symbol is annotated.
|
||||
|
||||
.. versionadded:: 3.6
|
||||
|
||||
.. method:: is_free()
|
||||
|
||||
Return ``True`` if the symbol is referenced in its block, but not assigned
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ can be accessed using :func:`get_config_vars` or :func:`get_config_var`.
|
|||
|
||||
Notice that on Windows, it's a much smaller set.
|
||||
|
||||
.. function:: get_config_vars(*args)
|
||||
.. function:: get_config_vars(\*args)
|
||||
|
||||
With no arguments, return a dictionary of all configuration variables
|
||||
relevant for the current platform.
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ Some facts and figures:
|
|||
Added support for :mod:`lzma` compression.
|
||||
|
||||
|
||||
.. function:: open(name=None, mode='r', fileobj=None, bufsize=10240, **kwargs)
|
||||
.. function:: open(name=None, mode='r', fileobj=None, bufsize=10240, \*\*kwargs)
|
||||
|
||||
Return a :class:`TarFile` object for the pathname *name*. For detailed
|
||||
information on :class:`TarFile` objects and the keyword arguments that are
|
||||
|
|
|
|||
|
|
@ -453,7 +453,7 @@ The :mod:`test.support` module defines the following functions:
|
|||
Define match test with regular expression *patterns*.
|
||||
|
||||
|
||||
.. function:: run_unittest(*classes)
|
||||
.. function:: run_unittest(\*classes)
|
||||
|
||||
Execute :class:`unittest.TestCase` subclasses passed to the function. The
|
||||
function scans the classes for methods starting with the prefix ``test_``
|
||||
|
|
@ -1599,7 +1599,7 @@ The :mod:`test.support.warnings_helper` module provides support for warnings tes
|
|||
.. versionadded:: 3.8
|
||||
|
||||
|
||||
.. function:: check_warnings(*filters, quiet=True)
|
||||
.. function:: check_warnings(\*filters, quiet=True)
|
||||
|
||||
A convenience wrapper for :func:`warnings.catch_warnings()` that makes it
|
||||
easier to test that a warning was correctly raised. It is approximately
|
||||
|
|
|
|||
|
|
@ -91,9 +91,6 @@ The different font weights and slants are:
|
|||
|
||||
Return the names of defined fonts.
|
||||
|
||||
.. function:: nametofont(name, root=None)
|
||||
.. function:: nametofont(name)
|
||||
|
||||
Return a :class:`Font` representation of a tk named font.
|
||||
|
||||
.. versionchanged:: 3.10
|
||||
The *root* parameter was added.
|
||||
Return a :class:`Font` representation of a tk named font.
|
||||
|
|
@ -153,47 +153,47 @@ Programmatic Interface
|
|||
count information. *timing* enables a timestamp relative to when tracing was
|
||||
started to be displayed.
|
||||
|
||||
.. method:: run(cmd)
|
||||
.. method:: run(cmd)
|
||||
|
||||
Execute the command and gather statistics from the execution with
|
||||
the current tracing parameters. *cmd* must be a string or code object,
|
||||
suitable for passing into :func:`exec`.
|
||||
Execute the command and gather statistics from the execution with
|
||||
the current tracing parameters. *cmd* must be a string or code object,
|
||||
suitable for passing into :func:`exec`.
|
||||
|
||||
.. method:: runctx(cmd, globals=None, locals=None)
|
||||
.. method:: runctx(cmd, globals=None, locals=None)
|
||||
|
||||
Execute the command and gather statistics from the execution with the
|
||||
current tracing parameters, in the defined global and local
|
||||
environments. If not defined, *globals* and *locals* default to empty
|
||||
dictionaries.
|
||||
Execute the command and gather statistics from the execution with the
|
||||
current tracing parameters, in the defined global and local
|
||||
environments. If not defined, *globals* and *locals* default to empty
|
||||
dictionaries.
|
||||
|
||||
.. method:: runfunc(func, /, *args, **kwds)
|
||||
.. method:: runfunc(func, /, *args, **kwds)
|
||||
|
||||
Call *func* with the given arguments under control of the :class:`Trace`
|
||||
object with the current tracing parameters.
|
||||
Call *func* with the given arguments under control of the :class:`Trace`
|
||||
object with the current tracing parameters.
|
||||
|
||||
.. method:: results()
|
||||
.. method:: results()
|
||||
|
||||
Return a :class:`CoverageResults` object that contains the cumulative
|
||||
results of all previous calls to ``run``, ``runctx`` and ``runfunc``
|
||||
for the given :class:`Trace` instance. Does not reset the accumulated
|
||||
trace results.
|
||||
Return a :class:`CoverageResults` object that contains the cumulative
|
||||
results of all previous calls to ``run``, ``runctx`` and ``runfunc``
|
||||
for the given :class:`Trace` instance. Does not reset the accumulated
|
||||
trace results.
|
||||
|
||||
.. class:: CoverageResults
|
||||
|
||||
A container for coverage results, created by :meth:`Trace.results`. Should
|
||||
not be created directly by the user.
|
||||
|
||||
.. method:: update(other)
|
||||
.. method:: update(other)
|
||||
|
||||
Merge in data from another :class:`CoverageResults` object.
|
||||
Merge in data from another :class:`CoverageResults` object.
|
||||
|
||||
.. method:: write_results(show_missing=True, summary=False, coverdir=None)
|
||||
.. method:: write_results(show_missing=True, summary=False, coverdir=None)
|
||||
|
||||
Write coverage results. Set *show_missing* to show lines that had no
|
||||
hits. Set *summary* to include in the output the coverage summary per
|
||||
module. *coverdir* specifies the directory into which the coverage
|
||||
result files will be output. If ``None``, the results for each source
|
||||
file are placed in its directory.
|
||||
Write coverage results. Set *show_missing* to show lines that had no
|
||||
hits. Set *summary* to include in the output the coverage summary per
|
||||
module. *coverdir* specifies the directory into which the coverage
|
||||
result files will be output. If ``None``, the results for each source
|
||||
file are placed in its directory.
|
||||
|
||||
A simple example demonstrating the use of the programmatic interface::
|
||||
|
||||
|
|
|
|||
|
|
@ -913,8 +913,8 @@ Color control
|
|||
Set pencolor to the RGB color represented by *r*, *g*, and *b*. Each of
|
||||
*r*, *g*, and *b* must be in the range 0..colormode.
|
||||
|
||||
If turtleshape is a polygon, the outline of that polygon is drawn with the
|
||||
newly set pencolor.
|
||||
If turtleshape is a polygon, the outline of that polygon is drawn with the
|
||||
newly set pencolor.
|
||||
|
||||
.. doctest::
|
||||
:skipif: _tkinter is None
|
||||
|
|
@ -962,8 +962,8 @@ Color control
|
|||
Set fillcolor to the RGB color represented by *r*, *g*, and *b*. Each of
|
||||
*r*, *g*, and *b* must be in the range 0..colormode.
|
||||
|
||||
If turtleshape is a polygon, the interior of that polygon is drawn
|
||||
with the newly set fillcolor.
|
||||
If turtleshape is a polygon, the interior of that polygon is drawn
|
||||
with the newly set fillcolor.
|
||||
|
||||
.. doctest::
|
||||
:skipif: _tkinter is None
|
||||
|
|
@ -1001,8 +1001,8 @@ Color control
|
|||
Equivalent to ``pencolor(colorstring1)`` and ``fillcolor(colorstring2)``
|
||||
and analogously if the other input format is used.
|
||||
|
||||
If turtleshape is a polygon, outline and interior of that polygon is drawn
|
||||
with the newly set colors.
|
||||
If turtleshape is a polygon, outline and interior of that polygon is drawn
|
||||
with the newly set colors.
|
||||
|
||||
.. doctest::
|
||||
:skipif: _tkinter is None
|
||||
|
|
|
|||
|
|
@ -280,10 +280,6 @@ Standard names are defined for the following types:
|
|||
|
||||
.. versionadded:: 3.9
|
||||
|
||||
.. versionchanged:: 3.9.2
|
||||
This type can now be subclassed.
|
||||
|
||||
|
||||
.. data:: Union
|
||||
|
||||
The type of :ref:`union type expressions<types-union>`.
|
||||
|
|
|
|||
|
|
@ -18,8 +18,7 @@
|
|||
--------------
|
||||
|
||||
This module provides runtime support for type hints as specified by
|
||||
:pep:`484`, :pep:`526`, :pep:`544`, :pep:`586`, :pep:`589`, :pep:`591`,
|
||||
:pep:`612` and :pep:`613`.
|
||||
:pep:`484`, :pep:`526`, :pep:`544`, :pep:`586`, :pep:`589`, :pep:`591`, and :pep:`613`.
|
||||
The most fundamental support consists of the types :data:`Any`, :data:`Union`,
|
||||
:data:`Tuple`, :data:`Callable`, :class:`TypeVar`, and
|
||||
:class:`Generic`. For full specification please see :pep:`484`. For
|
||||
|
|
@ -172,22 +171,6 @@ It is possible to declare the return type of a callable without specifying
|
|||
the call signature by substituting a literal ellipsis
|
||||
for the list of arguments in the type hint: ``Callable[..., ReturnType]``.
|
||||
|
||||
Callables which take other callables as arguments may indicate that their
|
||||
parameter types are dependent on each other using :class:`ParamSpec`.
|
||||
Additionally, if that callable adds or removes arguments from other
|
||||
callables, the :data:`Concatenate` operator may be used. They
|
||||
take the form ``Callable[ParamSpecVariable, ReturnType]`` and
|
||||
``Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], ReturnType]``
|
||||
respectively.
|
||||
|
||||
.. versionchanged:: 3.10
|
||||
``Callable`` now supports :class:`ParamSpec` and :data:`Concatenate`.
|
||||
See :pep:`612` for more information.
|
||||
|
||||
.. seealso::
|
||||
The documentation for :class:`ParamSpec` and :class:`Concatenate` provide
|
||||
examples of usage in ``Callable``.
|
||||
|
||||
.. _generics:
|
||||
|
||||
Generics
|
||||
|
|
@ -333,43 +316,6 @@ User defined generic type aliases are also supported. Examples::
|
|||
.. versionchanged:: 3.7
|
||||
:class:`Generic` no longer has a custom metaclass.
|
||||
|
||||
User-defined generics for parameter expressions are also supported via parameter
|
||||
specification variables in the form ``Generic[P]``. The behavior is consistent
|
||||
with type variables' described above as parameter specification variables are
|
||||
treated by the typing module as a specialized type variable. The one exception
|
||||
to this is that a list of types can be used to substitute a :class:`ParamSpec`::
|
||||
|
||||
>>> from typing import Generic, ParamSpec, TypeVar
|
||||
|
||||
>>> T = TypeVar('T')
|
||||
>>> P = ParamSpec('P')
|
||||
|
||||
>>> class Z(Generic[T, P]): ...
|
||||
...
|
||||
>>> Z[int, [dict, float]]
|
||||
__main__.Z[int, (<class 'dict'>, <class 'float'>)]
|
||||
|
||||
|
||||
Furthermore, a generic with only one parameter specification variable will accept
|
||||
parameter lists in the forms ``X[[Type1, Type2, ...]]`` and also
|
||||
``X[Type1, Type2, ...]`` for aesthetic reasons. Internally, the latter is converted
|
||||
to the former and are thus equivalent::
|
||||
|
||||
>>> class X(Generic[P]): ...
|
||||
...
|
||||
>>> X[int, str]
|
||||
__main__.X[(<class 'int'>, <class 'str'>)]
|
||||
>>> X[[int, str]]
|
||||
__main__.X[(<class 'int'>, <class 'str'>)]
|
||||
|
||||
Do note that generics with :class:`ParamSpec` may not have correct
|
||||
``__parameters__`` after substitution in some cases because they
|
||||
are intended primarily for static type checking.
|
||||
|
||||
.. versionchanged:: 3.10
|
||||
:class:`Generic` can now be parameterized over parameter expressions.
|
||||
See :class:`ParamSpec` and :pep:`612` for more details.
|
||||
|
||||
A user-defined generic class can have ABCs as base classes without a metaclass
|
||||
conflict. Generic metaclasses are not supported. The outcome of parameterizing
|
||||
generics is cached, and most types in the typing module are hashable and
|
||||
|
|
@ -656,80 +602,10 @@ These can be used as types in annotations using ``[]``, each having a unique syn
|
|||
``Callable[..., Any]``, and in turn to
|
||||
:class:`collections.abc.Callable`.
|
||||
|
||||
Callables which take other callables as arguments may indicate that their
|
||||
parameter types are dependent on each other using :class:`ParamSpec`.
|
||||
Additionally, if that callable adds or removes arguments from other
|
||||
callables, the :data:`Concatenate` operator may be used. They
|
||||
take the form ``Callable[ParamSpecVariable, ReturnType]`` and
|
||||
``Callable[Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable], ReturnType]``
|
||||
respectively.
|
||||
|
||||
.. deprecated:: 3.9
|
||||
:class:`collections.abc.Callable` now supports ``[]``. See :pep:`585` and
|
||||
:ref:`types-genericalias`.
|
||||
|
||||
.. versionchanged:: 3.10
|
||||
``Callable`` now supports :class:`ParamSpec` and :data:`Concatenate`.
|
||||
See :pep:`612` for more information.
|
||||
|
||||
.. seealso::
|
||||
The documentation for :class:`ParamSpec` and :class:`Concatenate` provide
|
||||
examples of usage with ``Callable``.
|
||||
|
||||
.. data:: Concatenate
|
||||
|
||||
Used with :data:`Callable` and :class:`ParamSpec` to type annotate a higher
|
||||
order callable which adds, removes, or transforms parameters of another
|
||||
callable. Usage is in the form
|
||||
``Concatenate[Arg1Type, Arg2Type, ..., ParamSpecVariable]``. ``Concatenate``
|
||||
is currently only valid when used as the first argument to a :data:`Callable`.
|
||||
The last parameter to ``Concatenate`` must be a :class:`ParamSpec`.
|
||||
|
||||
For example, to annotate a decorator ``with_lock`` which provides a
|
||||
:class:`threading.Lock` to the decorated function, ``Concatenate`` can be
|
||||
used to indicate that ``with_lock`` expects a callable which takes in a
|
||||
``Lock`` as the first argument, and returns a callable with a different type
|
||||
signature. In this case, the :class:`ParamSpec` indicates that the returned
|
||||
callable's parameter types are dependent on the parameter types of the
|
||||
callable being passed in::
|
||||
|
||||
from collections.abc import Callable
|
||||
from threading import Lock
|
||||
from typing import Any, Concatenate, ParamSpec
|
||||
|
||||
P = ParamSpec('P')
|
||||
R = ParamSpec('R')
|
||||
|
||||
# Use this lock to ensure that only one thread is executing a function
|
||||
# at any time.
|
||||
my_lock = Lock()
|
||||
|
||||
def with_lock(f: Callable[Concatenate[Lock, P], R]) -> Callable[P, R]:
|
||||
'''A type-safe decorator which provides a lock.'''
|
||||
global my_lock
|
||||
def inner(*args: P.args, **kwargs: P.kwargs) -> T:
|
||||
# Provide the lock as the first argument.
|
||||
return f(my_lock, *args, **kwargs)
|
||||
return inner
|
||||
|
||||
@with_lock
|
||||
def sum_threadsafe(lock: Lock, numbers: list[float]) -> float:
|
||||
'''Add a list of numbers together in a thread-safe manner.'''
|
||||
with lock:
|
||||
return sum(numbers)
|
||||
|
||||
# We don't need to pass in the lock ourselves thanks to the decorator.
|
||||
sum_threadsafe([1.1, 2.2, 3.3])
|
||||
|
||||
.. versionadded:: 3.10
|
||||
|
||||
.. seealso::
|
||||
|
||||
* :pep:`612` -- Parameter Specification Variables (the PEP which introduced
|
||||
``ParamSpec`` and ``Concatenate``).
|
||||
* :class:`ParamSpec` and :class:`Callable`.
|
||||
|
||||
|
||||
.. class:: Type(Generic[CT_co])
|
||||
|
||||
A variable annotated with ``C`` may accept a value of type ``C``. In
|
||||
|
|
@ -1000,84 +876,6 @@ These are not used in annotations. They are building blocks for creating generic
|
|||
for the type variable must be a subclass of the boundary type,
|
||||
see :pep:`484`.
|
||||
|
||||
.. class:: ParamSpec(name, *, bound=None, covariant=False, contravariant=False)
|
||||
|
||||
Parameter specification variable. A specialized version of
|
||||
:class:`type variables <TypeVar>`.
|
||||
|
||||
Usage::
|
||||
|
||||
P = ParamSpec('P')
|
||||
|
||||
Parameter specification variables exist primarily for the benefit of static
|
||||
type checkers. They are used to forward the parameter types of one
|
||||
callable to another callable -- a pattern commonly found in higher order
|
||||
functions and decorators. They are only valid when used in ``Concatenate``,
|
||||
or as the first argument to ``Callable``, or as parameters for user-defined
|
||||
Generics. See :class:`Generic` for more information on generic types.
|
||||
|
||||
For example, to add basic logging to a function, one can create a decorator
|
||||
``add_logging`` to log function calls. The parameter specification variable
|
||||
tells the type checker that the callable passed into the decorator and the
|
||||
new callable returned by it have inter-dependent type parameters::
|
||||
|
||||
from collections.abc import Callable
|
||||
from typing import TypeVar, ParamSpec
|
||||
import logging
|
||||
|
||||
T = TypeVar('T')
|
||||
P = ParamSpec('P')
|
||||
|
||||
def add_logging(f: Callable[P, T]) -> Callable[P, T]:
|
||||
'''A type-safe decorator to add logging to a function.'''
|
||||
def inner(*args: P.args, **kwargs: P.kwargs) -> T:
|
||||
logging.info(f'{f.__name__} was called')
|
||||
return f(*args, **kwargs)
|
||||
return inner
|
||||
|
||||
@add_logging
|
||||
def add_two(x: float, y: float) -> float:
|
||||
'''Add two numbers together.'''
|
||||
return x + y
|
||||
|
||||
Without ``ParamSpec``, the simplest way to annotate this previously was to
|
||||
use a :class:`TypeVar` with bound ``Callable[..., Any]``. However this
|
||||
causes two problems:
|
||||
|
||||
1. The type checker can't type check the ``inner`` function because
|
||||
``*args`` and ``**kwargs`` have to be typed :data:`Any`.
|
||||
2. :func:`~cast` may be required in the body of the ``add_logging``
|
||||
decorator when returning the ``inner`` function, or the static type
|
||||
checker must be told to ignore the ``return inner``.
|
||||
|
||||
.. attribute:: args
|
||||
.. attribute:: kwargs
|
||||
|
||||
Since ``ParamSpec`` captures both positional and keyword parameters,
|
||||
``P.args`` and ``P.kwargs`` can be used to split a ``ParamSpec`` into its
|
||||
components. ``P.args`` represents the tuple of positional parameters in a
|
||||
given call and should only be used to annotate ``*args``. ``P.kwargs``
|
||||
represents the mapping of keyword parameters to their values in a given call,
|
||||
and should be only be used to annotate ``**kwargs`` or ``**kwds``. Both
|
||||
attributes require the annotated parameter to be in scope.
|
||||
|
||||
Parameter specification variables created with ``covariant=True`` or
|
||||
``contravariant=True`` can be used to declare covariant or contravariant
|
||||
generic types. The ``bound`` argument is also accepted, similar to
|
||||
:class:`TypeVar`. However the actual semantics of these keywords are yet to
|
||||
be decided.
|
||||
|
||||
.. versionadded:: 3.10
|
||||
|
||||
.. note::
|
||||
Only parameter specification variables defined in global scope can
|
||||
be pickled.
|
||||
|
||||
.. seealso::
|
||||
* :pep:`612` -- Parameter Specification Variables (the PEP which introduced
|
||||
``ParamSpec`` and ``Concatenate``).
|
||||
* :class:`Callable` and :class:`Concatenate`.
|
||||
|
||||
.. data:: AnyStr
|
||||
|
||||
``AnyStr`` is a type variable defined as
|
||||
|
|
|
|||
|
|
@ -262,10 +262,9 @@ the *new_callable* argument to :func:`patch`.
|
|||
this is a new Mock (created on first access). See the
|
||||
:attr:`return_value` attribute.
|
||||
|
||||
* *unsafe*: By default, accessing any attribute with name starting with
|
||||
*assert*, *assret*, *asert*, *aseert* or *assrt* will raise an
|
||||
:exc:`AttributeError`. Passing ``unsafe=True`` will allow access to
|
||||
these attributes.
|
||||
* *unsafe*: By default if any attribute starts with *assert* or
|
||||
*assret* will raise an :exc:`AttributeError`. Passing ``unsafe=True``
|
||||
will allow access to these attributes.
|
||||
|
||||
.. versionadded:: 3.5
|
||||
|
||||
|
|
|
|||
|
|
@ -491,7 +491,7 @@ Available Functions
|
|||
Available Context Managers
|
||||
--------------------------
|
||||
|
||||
.. class:: catch_warnings(*, record=False, module=None)
|
||||
.. class:: catch_warnings(\*, record=False, module=None)
|
||||
|
||||
A context manager that copies and, upon exit, restores the warnings filter
|
||||
and the :func:`showwarning` function.
|
||||
|
|
|
|||
|
|
@ -791,7 +791,7 @@ integer handle, and also disconnect the Windows handle from the handle object.
|
|||
|
||||
|
||||
.. method:: PyHKEY.__enter__()
|
||||
PyHKEY.__exit__(*exc_info)
|
||||
PyHKEY.__exit__(\*exc_info)
|
||||
|
||||
The HKEY object implements :meth:`~object.__enter__` and
|
||||
:meth:`~object.__exit__` and thus supports the context protocol for the
|
||||
|
|
|
|||
|
|
@ -174,7 +174,7 @@ module documentation. This section lists the differences between the API and
|
|||
The :meth:`toxml` method now preserves the attribute order specified
|
||||
by the user.
|
||||
|
||||
.. method:: Node.toprettyxml(indent="\t", newl="\n", encoding=None, \
|
||||
.. method:: Node.toprettyxml(indent="\\t", newl="\\n", encoding=None, \
|
||||
standalone=None)
|
||||
|
||||
Return a pretty-printed version of the document. *indent* specifies the
|
||||
|
|
|
|||
|
|
@ -483,7 +483,7 @@ Path Objects
|
|||
Path objects expose the following features of :mod:`pathlib.Path`
|
||||
objects:
|
||||
|
||||
Path objects are traversable using the ``/`` operator or ``joinpath``.
|
||||
Path objects are traversable using the ``/`` operator.
|
||||
|
||||
.. attribute:: Path.name
|
||||
|
||||
|
|
@ -532,19 +532,6 @@ Path objects are traversable using the ``/`` operator or ``joinpath``.
|
|||
|
||||
Read the current file as bytes.
|
||||
|
||||
.. method:: Path.joinpath(*other)
|
||||
|
||||
Return a new Path object with each of the *other* arguments
|
||||
joined. The following are equivalent::
|
||||
|
||||
>>> Path(...).joinpath('child').joinpath('grandchild')
|
||||
>>> Path(...).joinpath('child', 'grandchild')
|
||||
>>> Path(...) / 'child' / 'grandchild'
|
||||
|
||||
.. versionchanged:: 3.10
|
||||
Prior to 3.10, ``joinpath`` was undocumented and accepted
|
||||
exactly one parameter.
|
||||
|
||||
|
||||
.. _pyzipfile-objects:
|
||||
|
||||
|
|
|
|||
|
|
@ -121,7 +121,7 @@ zipimporter Objects
|
|||
.. method:: get_code(fullname)
|
||||
|
||||
Return the code object for the specified module. Raise
|
||||
:exc:`ZipImportError` if the module couldn't be imported.
|
||||
:exc:`ZipImportError` if the module couldn't be found.
|
||||
|
||||
|
||||
.. method:: get_data(pathname)
|
||||
|
|
@ -137,7 +137,7 @@ zipimporter Objects
|
|||
|
||||
Return the value ``__file__`` would be set to if the specified module
|
||||
was imported. Raise :exc:`ZipImportError` if the module couldn't be
|
||||
imported.
|
||||
found.
|
||||
|
||||
.. versionadded:: 3.1
|
||||
|
||||
|
|
@ -159,13 +159,14 @@ zipimporter Objects
|
|||
.. method:: load_module(fullname)
|
||||
|
||||
Load the module specified by *fullname*. *fullname* must be the fully
|
||||
qualified (dotted) module name. Returns the imported module on success,
|
||||
raises :exc:`ZipImportError` on failure.
|
||||
qualified (dotted) module name. It returns the imported module, or raises
|
||||
:exc:`ZipImportError` if it wasn't found.
|
||||
|
||||
.. deprecated:: 3.10
|
||||
|
||||
Use :meth:`exec_module` instead.
|
||||
|
||||
|
||||
.. attribute:: archive
|
||||
|
||||
The file name of the importer's associated ZIP file, without a possible
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ PSF LICENSE AGREEMENT FOR PYTHON |release|
|
|||
analyze, test, perform and/or display publicly, prepare derivative works,
|
||||
distribute, and otherwise use Python |release| alone or in any derivative
|
||||
version, provided, however, that PSF's License Agreement and PSF's notice of
|
||||
copyright, i.e., "Copyright © 2001-2021 Python Software Foundation; All Rights
|
||||
copyright, i.e., "Copyright © 2001-2020 Python Software Foundation; All Rights
|
||||
Reserved" are retained in Python |release| alone or in any derivative version
|
||||
prepared by Licensee.
|
||||
|
||||
|
|
|
|||
|
|
@ -254,8 +254,7 @@ present, must be last; it matches any exception. For an except clause with an
|
|||
expression, that expression is evaluated, and the clause matches the exception
|
||||
if the resulting object is "compatible" with the exception. An object is
|
||||
compatible with an exception if it is the class or a base class of the exception
|
||||
object, or a tuple containing an item that is the class or a base class of
|
||||
the exception object.
|
||||
object or a tuple containing an item compatible with the exception.
|
||||
|
||||
If no except clause matches the exception, the search for an exception handler
|
||||
continues in the surrounding code and on the invocation stack. [#]_
|
||||
|
|
@ -302,27 +301,9 @@ Before an except clause's suite is executed, details about the exception are
|
|||
stored in the :mod:`sys` module and can be accessed via :func:`sys.exc_info`.
|
||||
:func:`sys.exc_info` returns a 3-tuple consisting of the exception class, the
|
||||
exception instance and a traceback object (see section :ref:`types`) identifying
|
||||
the point in the program where the exception occurred. The details about the
|
||||
exception accessed via :func:`sys.exc_info` are restored to their previous values
|
||||
when leaving an exception handler::
|
||||
|
||||
>>> print(sys.exc_info())
|
||||
(None, None, None)
|
||||
>>> try:
|
||||
... raise TypeError
|
||||
... except:
|
||||
... print(sys.exc_info())
|
||||
... try:
|
||||
... raise ValueError
|
||||
... except:
|
||||
... print(sys.exc_info())
|
||||
... print(sys.exc_info())
|
||||
...
|
||||
(<class 'TypeError'>, TypeError(), <traceback object at 0x10efad080>)
|
||||
(<class 'ValueError'>, ValueError(), <traceback object at 0x10efad040>)
|
||||
(<class 'TypeError'>, TypeError(), <traceback object at 0x10efad080>)
|
||||
>>> print(sys.exc_info())
|
||||
(None, None, None)
|
||||
the point in the program where the exception occurred. :func:`sys.exc_info`
|
||||
values are restored to their previous values (before the call) when returning
|
||||
from a function that handled an exception.
|
||||
|
||||
.. index::
|
||||
keyword: else
|
||||
|
|
@ -815,12 +796,12 @@ The :keyword:`!async for` statement
|
|||
.. productionlist:: python-grammar
|
||||
async_for_stmt: "async" `for_stmt`
|
||||
|
||||
An :term:`asynchronous iterable` provides an ``__aiter__`` method that directly
|
||||
returns an :term:`asynchronous iterator`, which can call asynchronous code in
|
||||
its ``__anext__`` method.
|
||||
An :term:`asynchronous iterable` is able to call asynchronous code in its
|
||||
*iter* implementation, and :term:`asynchronous iterator` can call asynchronous
|
||||
code in its *next* method.
|
||||
|
||||
The ``async for`` statement allows convenient iteration over asynchronous
|
||||
iterables.
|
||||
iterators.
|
||||
|
||||
The following code::
|
||||
|
||||
|
|
|
|||
|
|
@ -217,6 +217,7 @@ Ellipsis
|
|||
There are two types of integers:
|
||||
|
||||
Integers (:class:`int`)
|
||||
|
||||
These represent numbers in an unlimited range, subject to available (virtual)
|
||||
memory only. For the purpose of shift and mask operations, a binary
|
||||
representation is assumed, and negative numbers are represented in a variant of
|
||||
|
|
|
|||
|
|
@ -950,7 +950,7 @@ Names listed in a :keyword:`global` statement must not be used in the same code
|
|||
block textually preceding that :keyword:`!global` statement.
|
||||
|
||||
Names listed in a :keyword:`global` statement must not be defined as formal
|
||||
parameters, or as targets in :keyword:`with` statements or :keyword:`except` clauses, or in a :keyword:`for` target list, :keyword:`class`
|
||||
parameters or in a :keyword:`for` loop control target, :keyword:`class`
|
||||
definition, function definition, :keyword:`import` statement, or variable
|
||||
annotation.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,57 +0,0 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
glossary_search.py
|
||||
~~~~~~~~~~~~~~~~
|
||||
|
||||
Feature search results for glossary items prominently.
|
||||
|
||||
:license: Python license.
|
||||
"""
|
||||
from os import path
|
||||
from sphinx.addnodes import glossary
|
||||
from sphinx.util import logging
|
||||
from docutils.nodes import definition_list_item
|
||||
import json
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def process_glossary_nodes(app, doctree, fromdocname):
|
||||
if app.builder.format != 'html':
|
||||
return
|
||||
|
||||
terms = {}
|
||||
|
||||
for node in doctree.traverse(glossary):
|
||||
for glossary_item in node.traverse(definition_list_item):
|
||||
term = glossary_item[0].astext().lower()
|
||||
definition = glossary_item[1]
|
||||
|
||||
rendered = app.builder.render_partial(definition)
|
||||
terms[term] = {
|
||||
'title': glossary_item[0].astext(),
|
||||
'body': rendered['html_body']
|
||||
}
|
||||
|
||||
if hasattr(app.env, 'glossary_terms'):
|
||||
app.env.glossary_terms.update(terms)
|
||||
else:
|
||||
app.env.glossary_terms = terms
|
||||
|
||||
def on_build_finish(app, exc):
|
||||
if not hasattr(app.env, 'glossary_terms'):
|
||||
return
|
||||
if not app.env.glossary_terms:
|
||||
return
|
||||
|
||||
logger.info('Writing glossary.json', color='green')
|
||||
with open(path.join(app.outdir, '_static', 'glossary.json'), 'w') as f:
|
||||
json.dump(app.env.glossary_terms, f)
|
||||
|
||||
|
||||
def setup(app):
|
||||
app.connect('doctree-resolved', process_glossary_nodes)
|
||||
app.connect('build-finished', on_build_finish)
|
||||
|
||||
return {'version': '0.1', 'parallel_read_safe': True}
|
||||
|
|
@ -394,12 +394,7 @@ class DeprecatedRemoved(Directive):
|
|||
translatable=False)
|
||||
node.append(para)
|
||||
env = self.state.document.settings.env
|
||||
# deprecated pre-Sphinx-2 method
|
||||
if hasattr(env, 'note_versionchange'):
|
||||
env.note_versionchange('deprecated', version[0], node, self.lineno)
|
||||
# new method
|
||||
else:
|
||||
env.get_domain('changeset').note_changeset(node)
|
||||
env.get_domain('changeset').note_changeset(node)
|
||||
return [node] + messages
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,6 @@ import os
|
|||
import re
|
||||
import sys
|
||||
import getopt
|
||||
from string import ascii_letters
|
||||
from os.path import join, splitext, abspath, exists
|
||||
from collections import defaultdict
|
||||
|
||||
|
|
@ -129,81 +128,6 @@ def check_leaked_markup(fn, lines):
|
|||
yield lno+1, 'possibly leaked markup: %r' % line
|
||||
|
||||
|
||||
def hide_literal_blocks(lines):
|
||||
"""Tool to remove literal blocks from given lines.
|
||||
|
||||
It yields empty lines in place of blocks, so line numbers are
|
||||
still meaningful.
|
||||
"""
|
||||
in_block = False
|
||||
for line in lines:
|
||||
if line.endswith("::\n"):
|
||||
in_block = True
|
||||
elif in_block:
|
||||
if line == "\n" or line.startswith(" "):
|
||||
line = "\n"
|
||||
else:
|
||||
in_block = False
|
||||
yield line
|
||||
|
||||
|
||||
def type_of_explicit_markup(line):
|
||||
if re.match(fr'\.\. {all_directives}::', line):
|
||||
return 'directive'
|
||||
if re.match(r'\.\. \[[0-9]+\] ', line):
|
||||
return 'footnote'
|
||||
if re.match(r'\.\. \[[^\]]+\] ', line):
|
||||
return 'citation'
|
||||
if re.match(r'\.\. _.*[^_]: ', line):
|
||||
return 'target'
|
||||
if re.match(r'\.\. \|[^\|]*\| ', line):
|
||||
return 'substitution_definition'
|
||||
return 'comment'
|
||||
|
||||
|
||||
def hide_comments(lines):
|
||||
"""Tool to remove comments from given lines.
|
||||
|
||||
It yields empty lines in place of comments, so line numbers are
|
||||
still meaningfull.
|
||||
"""
|
||||
in_multiline_comment = False
|
||||
for line in lines:
|
||||
if line == "..\n":
|
||||
in_multiline_comment = True
|
||||
elif in_multiline_comment:
|
||||
if line == "\n" or line.startswith(" "):
|
||||
line = "\n"
|
||||
else:
|
||||
in_multiline_comment = False
|
||||
if line.startswith(".. ") and type_of_explicit_markup(line) == 'comment':
|
||||
line = "\n"
|
||||
yield line
|
||||
|
||||
|
||||
|
||||
@checker(".rst", severity=2)
|
||||
def check_missing_surrogate_space_on_plural(fn, lines):
|
||||
r"""Check for missing 'backslash-space' between a code sample a letter.
|
||||
|
||||
Good: ``Point``\ s
|
||||
Bad: ``Point``s
|
||||
"""
|
||||
in_code_sample = False
|
||||
check_next_one = False
|
||||
for lno, line in enumerate(hide_comments(hide_literal_blocks(lines))):
|
||||
tokens = line.split("``")
|
||||
for token_no, token in enumerate(tokens):
|
||||
if check_next_one:
|
||||
if token[0] in ascii_letters:
|
||||
yield lno + 1, f"Missing backslash-space between code sample and {token!r}."
|
||||
check_next_one = False
|
||||
if token_no == len(tokens) - 1:
|
||||
continue
|
||||
if in_code_sample:
|
||||
check_next_one = True
|
||||
in_code_sample = not in_code_sample
|
||||
|
||||
def main(argv):
|
||||
usage = '''\
|
||||
Usage: %s [-v] [-f] [-s sev] [-i path]* [path]
|
||||
|
|
|
|||
|
|
@ -168,7 +168,6 @@ library/ipaddress,,::,2001:db00::0/24
|
|||
library/ipaddress,,:db00,2001:db00::0/ffff:ff00::
|
||||
library/ipaddress,,::,2001:db00::0/ffff:ff00::
|
||||
library/itertools,,:step,elements from seq[start:stop:step]
|
||||
library/itertools,,::,kernel = tuple(kernel)[::-1]
|
||||
library/itertools,,:stop,elements from seq[start:stop:step]
|
||||
library/logging.handlers,,:port,host:port
|
||||
library/mmap,,:i2,obj[i1:i2]
|
||||
|
|
|
|||
|
|
|
@ -1,48 +0,0 @@
|
|||
{% extends "!search.html" %}
|
||||
{% block extrahead %}
|
||||
{{ super() }}
|
||||
<script type="text/javascript">
|
||||
var GLOSSARY_PAGE = 'glossary.html';
|
||||
|
||||
jQuery(function() {
|
||||
$.getJSON("_static/glossary.json", function(glossary) {
|
||||
var RESULT_TEMPLATE = '<div style="display: none" class="admonition seealso" id="glossary-result">' +
|
||||
' <p class="topic-title">' +
|
||||
' <a class="glossary-title" href="#"></a>' +
|
||||
' </p>' +
|
||||
' <div class="glossary-body"></div>' +
|
||||
'</div>';
|
||||
$("#search-results").prepend(RESULT_TEMPLATE);
|
||||
|
||||
var params = $.getQueryParameters();
|
||||
if (params.q) {
|
||||
var search_param = params.q[0].toLowerCase();
|
||||
var glossary_item = glossary[search_param];
|
||||
if (glossary_item) {
|
||||
var resultDiv = $("#glossary-result");
|
||||
|
||||
// set up the title text with a link to the glossary page
|
||||
resultDiv.find(".glossary-title").text('Glossary: ' + glossary_item.title);
|
||||
var link_target = search_param.replace(/ /g, '-');
|
||||
resultDiv.find(".glossary-title").attr(
|
||||
'href', GLOSSARY_PAGE + '#term-' + link_target
|
||||
);
|
||||
|
||||
// rewrite any anchor links (to other glossary terms)
|
||||
// to have a full reference to the glossary page
|
||||
var body = $(glossary_item.body).children();
|
||||
body.find("a[href^='#']").each(function() {
|
||||
var current_url = $(this).attr('href');
|
||||
$(this).attr('href', GLOSSARY_PAGE + current_url);
|
||||
});
|
||||
resultDiv.find(".glossary-body").html(body);
|
||||
|
||||
resultDiv.show();
|
||||
} else {
|
||||
$("#glossary-result").hide('');
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
</script>
|
||||
{% endblock %}
|
||||
|
|
@ -281,17 +281,17 @@ chaining exceptions. For example::
|
|||
This can be useful when you are transforming exceptions. For example::
|
||||
|
||||
>>> def func():
|
||||
... raise ConnectionError
|
||||
... raise IOError
|
||||
...
|
||||
>>> try:
|
||||
... func()
|
||||
... except ConnectionError as exc:
|
||||
... except IOError as exc:
|
||||
... raise RuntimeError('Failed to open database') from exc
|
||||
...
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 2, in <module>
|
||||
File "<stdin>", line 2, in func
|
||||
ConnectionError
|
||||
OSError
|
||||
<BLANKLINE>
|
||||
The above exception was the direct cause of the following exception:
|
||||
<BLANKLINE>
|
||||
|
|
@ -300,7 +300,7 @@ This can be useful when you are transforming exceptions. For example::
|
|||
RuntimeError: Failed to open database
|
||||
|
||||
Exception chaining happens automatically when an exception is raised inside an
|
||||
:keyword:`except` or :keyword:`finally` section. This can be
|
||||
:keyword:`except` or :keyword:`finally` section. Exception chaining can be
|
||||
disabled by using ``from None`` idiom:
|
||||
|
||||
>>> try:
|
||||
|
|
|
|||
|
|
@ -23,8 +23,8 @@ available for application-local distributions.
|
|||
|
||||
As specified in :pep:`11`, a Python release only supports a Windows platform
|
||||
while Microsoft considers the platform under extended support. This means that
|
||||
Python |version| supports Windows 8.1 and newer. If you require Windows 7
|
||||
support, please install Python 3.8.
|
||||
Python |version| supports Windows Vista and newer. If you require Windows XP
|
||||
support then please install Python 3.4.
|
||||
|
||||
There are a number of different installers available for Windows, each with
|
||||
certain benefits and downsides.
|
||||
|
|
|
|||
|
|
@ -144,28 +144,6 @@ See :pep:`604` for more details.
|
|||
|
||||
(Contributed by Maggie Moss and Philippe Prados in :issue:`41428`.)
|
||||
|
||||
PEP 612: Parameter Specification Variables
|
||||
------------------------------------------
|
||||
|
||||
Two new options to improve the information provided to static type checkers for
|
||||
:pep:`484`\ 's ``Callable`` have been added to the :mod:`typing` module.
|
||||
|
||||
The first is the parameter specification variable. They are used to forward the
|
||||
parameter types of one callable to another callable -- a pattern commonly
|
||||
found in higher order functions and decorators. Examples of usage can be found
|
||||
in :class:`typing.ParamSpec`. Previously, there was no easy way to type annotate
|
||||
dependency of parameter types in such a precise manner.
|
||||
|
||||
The second option is the new ``Concatenate`` operator. It's used in conjunction
|
||||
with parameter specification variables to type annotate a higher order callable
|
||||
which adds or removes parameters of another callable. Examples of usage can
|
||||
be found in :class:`typing.Concatenate`.
|
||||
|
||||
See :class:`typing.Callable`, :class:`typing.ParamSpec`,
|
||||
:class:`typing.Concatenate` and :pep:`612` for more details.
|
||||
|
||||
(Contributed by Ken Jin in :issue:`41559`.)
|
||||
|
||||
Other Language Changes
|
||||
======================
|
||||
|
||||
|
|
@ -201,21 +179,6 @@ codecs
|
|||
Add a :func:`codecs.unregister` function to unregister a codec search function.
|
||||
(Contributed by Hai Shi in :issue:`41842`.)
|
||||
|
||||
collections.abc
|
||||
---------------
|
||||
|
||||
The ``__args__`` of the :ref:`parameterized generic <types-genericalias>` for
|
||||
:class:`collections.abc.Callable` are now consistent with :data:`typing.Callable`.
|
||||
:class:`collections.abc.Callable` generic now flattens type parameters, similar
|
||||
to what :data:`typing.Callable` currently does. This means that
|
||||
``collections.abc.Callable[[int, str], str]`` will have ``__args__`` of
|
||||
``(int, str, str)``; previously this was ``([int, str], str)``. To allow this
|
||||
change, :class:`types.GenericAlias` can now be subclassed, and a subclass will
|
||||
be returned when subscripting the :class:`collections.abc.Callable` type. Note
|
||||
that a :exc:`TypeError` may be raised for invalid forms of parameterizing
|
||||
:class:`collections.abc.Callable` which may have passed silently in Python 3.9.
|
||||
(Contributed by Ken Jin in :issue:`42195`.)
|
||||
|
||||
contextlib
|
||||
----------
|
||||
|
||||
|
|
@ -260,11 +223,6 @@ inspect
|
|||
When a module does not define ``__loader__``, fall back to ``__spec__.loader``.
|
||||
(Contributed by Brett Cannon in :issue:`42133`.)
|
||||
|
||||
Added *globalns* and *localns* parameters in :func:`~inspect.signature` and
|
||||
:meth:`inspect.Signature.from_callable` to retrieve the annotations in given
|
||||
local and global namespaces.
|
||||
(Contributed by Batuhan Taskaya in :issue:`41960`.)
|
||||
|
||||
linecache
|
||||
---------
|
||||
|
||||
|
|
@ -426,11 +384,9 @@ Optimizations
|
|||
average.
|
||||
(Contributed by Victor Stinner in :issue:`41006`.)
|
||||
|
||||
* The ``LOAD_ATTR`` instruction now uses new "per opcode cache" mechanism. It
|
||||
is about 36% faster now. This makes optimized ``LOAD_ATTR`` instructions the
|
||||
current most performance attribute access method (faster than slots).
|
||||
(Contributed by Pablo Galindo and Yury Selivanov in :issue:`42093`, based on
|
||||
ideas implemented originally in PyPy and MicroPython.)
|
||||
* The ``LOAD_ATTR`` instruction now uses new "per opcode cache" mechanism.
|
||||
It is about 36% faster now. (Contributed by Pablo Galindo and Yury Selivanov
|
||||
in :issue:`42093`, based on ideas implemented originally in PyPy and MicroPython.)
|
||||
|
||||
* When building Python with ``--enable-optimizations`` now
|
||||
``-fno-semantic-interposition`` is added to both the compile and link line.
|
||||
|
|
@ -438,8 +394,7 @@ Optimizations
|
|||
with ``gcc`` by up to 30%. See `this article
|
||||
<https://developers.redhat.com/blog/2020/06/25/red-hat-enterprise-linux-8-2-brings-faster-python-3-8-run-speeds/>`_
|
||||
for more details. (Contributed by Victor Stinner and Pablo Galindo in
|
||||
:issue:`38980`.)
|
||||
|
||||
:issue:`38980`)
|
||||
|
||||
* Function parameters and their annotations are no longer computed at runtime,
|
||||
but rather at compilation time. They are stored as a tuple of strings at the
|
||||
|
|
@ -466,21 +421,6 @@ Deprecated
|
|||
as appropriate to help identify code which needs updating during
|
||||
this transition.
|
||||
|
||||
* The various ``load_module()`` methods of :mod:`importlib` have been
|
||||
documented as deprecated since Python 3.6, but will now also trigger
|
||||
a :exc:`DeprecationWarning`. Use
|
||||
:meth:`~importlib.abc.Loader.exec_module` instead.
|
||||
(Contributed by Brett Cannon in :issue:`26131`.)
|
||||
|
||||
* :meth:`zimport.zipimporter.load_module` has been deprecated in
|
||||
preference for :meth:`~zipimport.zipimporter.exec_module`.
|
||||
(Contributed by Brett Cannon in :issue:`26131`.)
|
||||
|
||||
* The use of :meth:`~importlib.abc.Loader.load_module` by the import
|
||||
system now triggers an :exc:`ImportWarning` as
|
||||
:meth:`~importlib.abc.Loader.exec_module` is preferred.
|
||||
(Contributed by Brett Cannon in :issue:`26131`.)
|
||||
|
||||
* ``sqlite3.OptimizedUnicode`` has been undocumented and obsolete since Python
|
||||
3.3, when it was made an alias to :class:`str`. It is now deprecated,
|
||||
scheduled for removal in Python 3.12.
|
||||
|
|
@ -524,11 +464,6 @@ Removed
|
|||
into their code.
|
||||
(Contributed by Dong-hee Na and Terry J. Reedy in :issue:`42299`.)
|
||||
|
||||
* Removed the :c:func:`PyModule_GetWarningsModule` function that was useless
|
||||
now due to the _warnings module was converted to a builtin module in 2.6.
|
||||
(Contributed by Hai Shi in :issue:`42599`.)
|
||||
|
||||
|
||||
Porting to Python 3.10
|
||||
======================
|
||||
|
||||
|
|
@ -545,28 +480,6 @@ Changes in the Python API
|
|||
have been renamed to *exc*.
|
||||
(Contributed by Zackery Spytz and Matthias Bussonnier in :issue:`26389`.)
|
||||
|
||||
* :mod:`atexit`: At Python exit, if a callback registered with
|
||||
:func:`atexit.register` fails, its exception is now logged. Previously, only
|
||||
some exceptions were logged, and the last exception was always silently
|
||||
ignored.
|
||||
(Contributed by Victor Stinner in :issue:`42639`.)
|
||||
|
||||
* :class:`collections.abc.Callable` generic now flattens type parameters, similar
|
||||
to what :data:`typing.Callable` currently does. This means that
|
||||
``collections.abc.Callable[[int, str], str]`` will have ``__args__`` of
|
||||
``(int, str, str)``; previously this was ``([int, str], str)``. Code which
|
||||
accesses the arguments via :func:`typing.get_args` or ``__args__`` need to account
|
||||
for this change. Furthermore, :exc:`TypeError` may be raised for invalid forms
|
||||
of parameterizing :class:`collections.abc.Callable` which may have passed
|
||||
silently in Python 3.9.
|
||||
(Contributed by Ken Jin in :issue:`42195`.)
|
||||
|
||||
* :meth:`socket.htons` and :meth:`socket.ntohs` now raise :exc:`OverflowError`
|
||||
instead of :exc:`DeprecationWarning` if the given parameter will not fit in
|
||||
a 16-bit unsigned integer.
|
||||
(Contributed by Erlend E. Aasland in :issue:`42393`.)
|
||||
|
||||
|
||||
CPython bytecode changes
|
||||
========================
|
||||
|
||||
|
|
@ -585,12 +498,6 @@ Build Changes
|
|||
* :mod:`sqlite3` requires SQLite 3.7.3 or higher.
|
||||
(Contributed by Sergey Fedoseev and Erlend E. Aasland :issue:`40744`.)
|
||||
|
||||
* The :mod:`atexit` module must now always be built as a built-in module.
|
||||
(Contributed by Victor Stinner in :issue:`42639`.)
|
||||
|
||||
* Added ``--disable-test-modules`` option to the ``configure`` script:
|
||||
don't build nor install test modules.
|
||||
(Contributed by Xavier de Gaye, Thomas Petazzoni and Peixing Xin in :issue:`27640`.)
|
||||
|
||||
|
||||
C API Changes
|
||||
|
|
@ -688,13 +595,6 @@ Porting to Python 3.10
|
|||
:ref:`Python Path Configuration. <init-path-config>`.
|
||||
(Contributed by Victor Stinner in :issue:`42260`.)
|
||||
|
||||
* :c:func:`PyList_SET_ITEM`, :c:func:`PyTuple_SET_ITEM` and
|
||||
:c:func:`PyCell_SET` macros can no longer be used as l-value or r-value.
|
||||
For example, ``x = PyList_SET_ITEM(a, b, c)`` and
|
||||
``PyList_SET_ITEM(a, b, c) = x`` now fail with a compiler error. It prevents
|
||||
bugs like ``if (PyList_SET_ITEM (a, b, c) < 0) ...`` test.
|
||||
(Contributed by Zackery Spytz and Victor Stinner in :issue:`30459`.)
|
||||
|
||||
Deprecated
|
||||
----------
|
||||
|
||||
|
|
|
|||
|
|
@ -1482,37 +1482,4 @@ and to match the behavior of static type checkers specified in the PEP.
|
|||
File "<stdin>", line 1, in <module>
|
||||
TypeError: unhashable type: 'set'
|
||||
|
||||
(Contributed by Yurii Karabas in :issue:`42345`.)
|
||||
|
||||
macOS 11.0 (Big Sur) and Apple Silicon Mac support
|
||||
--------------------------------------------------
|
||||
|
||||
As of 3.9.1, Python now fully supports building and running on macOS 11.0
|
||||
(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. Binaries
|
||||
can also now be built on current versions of macOS to be deployed on a range
|
||||
of older macOS versions (tested to 10.9) while making some newer OS
|
||||
functions and options conditionally available based on the operating system
|
||||
version in use at runtime ("weaklinking").
|
||||
|
||||
(Contributed by Ronald Oussoren and Lawrence D'Anna in :issue:`41100`.)
|
||||
|
||||
Notable changes in Python 3.9.2
|
||||
===============================
|
||||
|
||||
collections.abc
|
||||
---------------
|
||||
|
||||
:class:`collections.abc.Callable` generic now flattens type parameters, similar
|
||||
to what :data:`typing.Callable` currently does. This means that
|
||||
``collections.abc.Callable[[int, str], str]`` will have ``__args__`` of
|
||||
``(int, str, str)``; previously this was ``([int, str], str)``. To allow this
|
||||
change, :class:`types.GenericAlias` can now be subclassed, and a subclass will
|
||||
be returned when subscripting the :class:`collections.abc.Callable` type.
|
||||
Code which accesses the arguments via :func:`typing.get_args` or ``__args__``
|
||||
need to account for this change. A :exc:`DeprecationWarning` may be emitted for
|
||||
invalid forms of parameterizing :class:`collections.abc.Callable` which may have
|
||||
passed silently in Python 3.9.1. This :exc:`DeprecationWarning` will
|
||||
become a :exc:`TypeError` in Python 3.10.
|
||||
(Contributed by Ken Jin in :issue:`42195`.)
|
||||
(Contributed by Yurii Karabas in :issue:`42345`.)
|
||||
|
|
@ -580,23 +580,18 @@ star_targets[expr_ty]:
|
|||
| a=star_target !',' { a }
|
||||
| a=star_target b=(',' c=star_target { c })* [','] {
|
||||
_Py_Tuple(CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, a, b)), Store, EXTRA) }
|
||||
star_targets_list_seq[asdl_expr_seq*]: a[asdl_expr_seq*]=','.star_target+ [','] { a }
|
||||
star_targets_tuple_seq[asdl_expr_seq*]:
|
||||
| a=star_target b=(',' c=star_target { c })+ [','] { (asdl_expr_seq*) _PyPegen_seq_insert_in_front(p, a, b) }
|
||||
| a=star_target ',' { (asdl_expr_seq*) _PyPegen_singleton_seq(p, a) }
|
||||
star_targets_seq[asdl_expr_seq*]: a[asdl_expr_seq*]=','.star_target+ [','] { a }
|
||||
star_target[expr_ty] (memo):
|
||||
| '*' a=(!'*' star_target) {
|
||||
_Py_Starred(CHECK(expr_ty, _PyPegen_set_expr_context(p, a, Store)), Store, EXTRA) }
|
||||
| target_with_star_atom
|
||||
target_with_star_atom[expr_ty] (memo):
|
||||
| a=t_primary '.' b=NAME !t_lookahead { _Py_Attribute(a, b->v.Name.id, Store, EXTRA) }
|
||||
| a=t_primary '[' b=slices ']' !t_lookahead { _Py_Subscript(a, b, Store, EXTRA) }
|
||||
| star_atom
|
||||
star_atom[expr_ty]:
|
||||
| a=NAME { _PyPegen_set_expr_context(p, a, Store) }
|
||||
| '(' a=target_with_star_atom ')' { _PyPegen_set_expr_context(p, a, Store) }
|
||||
| '(' a=[star_targets_tuple_seq] ')' { _Py_Tuple(a, Store, EXTRA) }
|
||||
| '[' a=[star_targets_list_seq] ']' { _Py_List(a, Store, EXTRA) }
|
||||
| '(' a=star_target ')' { _PyPegen_set_expr_context(p, a, Store) }
|
||||
| '(' a=[star_targets_seq] ')' { _Py_Tuple(a, Store, EXTRA) }
|
||||
| '[' a=[star_targets_seq] ']' { _Py_List(a, Store, EXTRA) }
|
||||
|
||||
single_target[expr_ty]:
|
||||
| single_subscript_attribute_target
|
||||
|
|
@ -651,7 +646,7 @@ invalid_arguments:
|
|||
RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "Generator expression must be parenthesized") }
|
||||
| a=args ',' args { _PyPegen_arguments_parsing_error(p, a) }
|
||||
invalid_kwarg:
|
||||
| expression a='=' {
|
||||
| a=expression '=' {
|
||||
RAISE_SYNTAX_ERROR_KNOWN_LOCATION(
|
||||
a, "expression cannot contain assignment, perhaps you meant \"==\"?") }
|
||||
invalid_named_expression:
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
|
||||
/* Bytes object interface */
|
||||
/* Bytes (String) object interface */
|
||||
|
||||
#ifndef Py_BYTESOBJECT_H
|
||||
#define Py_BYTESOBJECT_H
|
||||
|
|
@ -10,20 +10,23 @@ extern "C" {
|
|||
#include <stdarg.h>
|
||||
|
||||
/*
|
||||
Type PyBytesObject represents a byte string. An extra zero byte is
|
||||
Type PyBytesObject represents a character string. An extra zero byte is
|
||||
reserved at the end to ensure it is zero-terminated, but a size is
|
||||
present so strings with null bytes in them can be represented. This
|
||||
is an immutable object type.
|
||||
|
||||
There are functions to create new bytes objects, to test
|
||||
an object for bytes-ness, and to get the
|
||||
byte string value. The latter function returns a null pointer
|
||||
There are functions to create new string objects, to test
|
||||
an object for string-ness, and to get the
|
||||
string value. The latter function returns a null pointer
|
||||
if the object is not of the proper type.
|
||||
There is a variant that takes an explicit size as well as a
|
||||
variant that assumes a zero-terminated string. Note that none of the
|
||||
functions should be applied to NULL pointer.
|
||||
functions should be applied to nil objects.
|
||||
*/
|
||||
|
||||
/* Caching the hash (ob_shash) saves recalculation of a string's hash value.
|
||||
This significantly speeds up dict lookups. */
|
||||
|
||||
PyAPI_DATA(PyTypeObject) PyBytes_Type;
|
||||
PyAPI_DATA(PyTypeObject) PyBytesIter_Type;
|
||||
|
||||
|
|
@ -47,16 +50,26 @@ PyAPI_FUNC(PyObject *) PyBytes_DecodeEscape(const char *, Py_ssize_t,
|
|||
const char *, Py_ssize_t,
|
||||
const char *);
|
||||
|
||||
/* Provides access to the internal data buffer and size of a bytes object.
|
||||
Passing NULL as len parameter will force the string buffer to be
|
||||
0-terminated (passing a string with embedded NUL characters will
|
||||
/* Provides access to the internal data buffer and size of a string
|
||||
object or the default encoded version of a Unicode object. Passing
|
||||
NULL as *len parameter will force the string buffer to be
|
||||
0-terminated (passing a string with embedded NULL characters will
|
||||
cause an exception). */
|
||||
PyAPI_FUNC(int) PyBytes_AsStringAndSize(
|
||||
PyObject *obj, /* bytes object */
|
||||
PyObject *obj, /* string or Unicode object */
|
||||
char **s, /* pointer to buffer variable */
|
||||
Py_ssize_t *len /* pointer to length variable or NULL */
|
||||
Py_ssize_t *len /* pointer to length variable or NULL
|
||||
(only possible for 0-terminated
|
||||
strings) */
|
||||
);
|
||||
|
||||
/* Flags used by string formatting */
|
||||
#define F_LJUST (1<<0)
|
||||
#define F_SIGN (1<<1)
|
||||
#define F_BLANK (1<<2)
|
||||
#define F_ALT (1<<3)
|
||||
#define F_ZERO (1<<4)
|
||||
|
||||
#ifndef Py_LIMITED_API
|
||||
# define Py_CPYTHON_BYTESOBJECT_H
|
||||
# include "cpython/bytesobject.h"
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *);
|
|||
PyAPI_FUNC(int) PyCell_Set(PyObject *, PyObject *);
|
||||
|
||||
#define PyCell_GET(op) (((PyCellObject *)(op))->ob_ref)
|
||||
#define PyCell_SET(op, v) ((void)(((PyCellObject *)(op))->ob_ref = v))
|
||||
#define PyCell_SET(op, v) (((PyCellObject *)(op))->ob_ref = v)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ PyVectorcall_Function(PyObject *callable)
|
|||
{
|
||||
PyTypeObject *tp;
|
||||
Py_ssize_t offset;
|
||||
vectorcallfunc ptr;
|
||||
vectorcallfunc *ptr;
|
||||
|
||||
assert(callable != NULL);
|
||||
tp = Py_TYPE(callable);
|
||||
|
|
@ -73,8 +73,8 @@ PyVectorcall_Function(PyObject *callable)
|
|||
assert(PyCallable_Check(callable));
|
||||
offset = tp->tp_vectorcall_offset;
|
||||
assert(offset > 0);
|
||||
memcpy(&ptr, (char *) callable + offset, sizeof(ptr));
|
||||
return ptr;
|
||||
ptr = (vectorcallfunc *)(((char *)callable) + offset);
|
||||
return *ptr;
|
||||
}
|
||||
|
||||
/* Call the callable object 'callable' with the "vectorcall" calling
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ typedef struct {
|
|||
/* Invariants:
|
||||
* ob_sval contains space for 'ob_size+1' elements.
|
||||
* ob_sval[ob_size] == 0.
|
||||
* ob_shash is the hash of the byte string or -1 if not computed yet.
|
||||
* ob_shash is the hash of the string or -1 if not computed yet.
|
||||
*/
|
||||
} PyBytesObject;
|
||||
|
||||
|
|
|
|||
|
|
@ -95,6 +95,10 @@ PyAPI_FUNC(FILE *) _Py_wfopen(
|
|||
const wchar_t *path,
|
||||
const wchar_t *mode);
|
||||
|
||||
PyAPI_FUNC(FILE*) _Py_fopen(
|
||||
const char *pathname,
|
||||
const char *mode);
|
||||
|
||||
PyAPI_FUNC(FILE*) _Py_fopen_obj(
|
||||
PyObject *path,
|
||||
const char *mode);
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue