doc_content stringlengths 1 386k | doc_id stringlengths 5 188 |
|---|---|
oss_audio_device.getfmts()
Return a bitmask of the audio output formats supported by the soundcard. Some of the formats supported by OSS are:
Format Description
AFMT_MU_LAW a logarithmic encoding (used by Sun .au files and /dev/audio)
AFMT_A_LAW a logarithmic encoding
AFMT_IMA_ADPCM a 4:1 compressed format ... | python.library.ossaudiodev#ossaudiodev.oss_audio_device.getfmts |
oss_audio_device.mode
The I/O mode for the file, either "r", "rw", or "w". | python.library.ossaudiodev#ossaudiodev.oss_audio_device.mode |
oss_audio_device.name
String containing the name of the device file. | python.library.ossaudiodev#ossaudiodev.oss_audio_device.name |
oss_audio_device.nonblock()
Put the device into non-blocking mode. Once in non-blocking mode, there is no way to return it to blocking mode. | python.library.ossaudiodev#ossaudiodev.oss_audio_device.nonblock |
oss_audio_device.obufcount()
Returns the number of samples that are in the hardware buffer yet to be played. | python.library.ossaudiodev#ossaudiodev.oss_audio_device.obufcount |
oss_audio_device.obuffree()
Returns the number of samples that could be queued into the hardware buffer to be played without blocking. | python.library.ossaudiodev#ossaudiodev.oss_audio_device.obuffree |
oss_audio_device.post()
Tell the driver that there is likely to be a pause in the output, making it possible for the device to handle the pause more intelligently. You might use this after playing a spot sound effect, before waiting for user input, or before doing disk I/O. | python.library.ossaudiodev#ossaudiodev.oss_audio_device.post |
oss_audio_device.read(size)
Read size bytes from the audio input and return them as a Python string. Unlike most Unix device drivers, OSS audio devices in blocking mode (the default) will block read() until the entire requested amount of data is available. | python.library.ossaudiodev#ossaudiodev.oss_audio_device.read |
oss_audio_device.reset()
Immediately stop playing or recording and return the device to a state where it can accept commands. The OSS documentation recommends closing and re-opening the device after calling reset(). | python.library.ossaudiodev#ossaudiodev.oss_audio_device.reset |
oss_audio_device.setfmt(format)
Try to set the current audio format to format—see getfmts() for a list. Returns the audio format that the device was set to, which may not be the requested format. May also be used to return the current audio format—do this by passing an “audio format” of AFMT_QUERY. | python.library.ossaudiodev#ossaudiodev.oss_audio_device.setfmt |
oss_audio_device.setparameters(format, nchannels, samplerate[, strict=False])
Set the key audio sampling parameters—sample format, number of channels, and sampling rate—in one method call. format, nchannels, and samplerate should be as specified in the setfmt(), channels(), and speed() methods. If strict is true, set... | python.library.ossaudiodev#ossaudiodev.oss_audio_device.setparameters |
oss_audio_device.speed(samplerate)
Try to set the audio sampling rate to samplerate samples per second. Returns the rate actually set. Most sound devices don’t support arbitrary sampling rates. Common rates are:
Rate Description
8000 default rate for /dev/audio
11025 speech recording
22050
44100 CD quali... | python.library.ossaudiodev#ossaudiodev.oss_audio_device.speed |
oss_audio_device.sync()
Wait until the sound device has played every byte in its buffer. (This happens implicitly when the device is closed.) The OSS documentation recommends closing and re-opening the device rather than using sync(). | python.library.ossaudiodev#ossaudiodev.oss_audio_device.sync |
oss_audio_device.write(data)
Write a bytes-like object data to the audio device and return the number of bytes written. If the audio device is in blocking mode (the default), the entire data is always written (again, this is different from usual Unix device semantics). If the device is in non-blocking mode, some data... | python.library.ossaudiodev#ossaudiodev.oss_audio_device.write |
oss_audio_device.writeall(data)
Write a bytes-like object data to the audio device: waits until the audio device is able to accept data, writes as much data as it will accept, and repeats until data has been completely written. If the device is in blocking mode (the default), this has the same effect as write(); writ... | python.library.ossaudiodev#ossaudiodev.oss_audio_device.writeall |
oss_mixer_device.close()
This method closes the open mixer device file. Any further attempts to use the mixer after this file is closed will raise an OSError. | python.library.ossaudiodev#ossaudiodev.oss_mixer_device.close |
oss_mixer_device.controls()
This method returns a bitmask specifying the available mixer controls (“Control” being a specific mixable “channel”, such as SOUND_MIXER_PCM or SOUND_MIXER_SYNTH). This bitmask indicates a subset of all available mixer controls—the SOUND_MIXER_* constants defined at module level. To determ... | python.library.ossaudiodev#ossaudiodev.oss_mixer_device.controls |
oss_mixer_device.fileno()
Returns the file handle number of the open mixer device file. | python.library.ossaudiodev#ossaudiodev.oss_mixer_device.fileno |
oss_mixer_device.get(control)
Returns the volume of a given mixer control. The returned volume is a 2-tuple (left_volume,right_volume). Volumes are specified as numbers from 0 (silent) to 100 (full volume). If the control is monophonic, a 2-tuple is still returned, but both volumes are the same. Raises OSSAudioError ... | python.library.ossaudiodev#ossaudiodev.oss_mixer_device.get |
oss_mixer_device.get_recsrc()
This method returns a bitmask indicating which control(s) are currently being used as a recording source. | python.library.ossaudiodev#ossaudiodev.oss_mixer_device.get_recsrc |
oss_mixer_device.reccontrols()
Returns a bitmask specifying the mixer controls that may be used to record. See the code example for controls() for an example of reading from a bitmask. | python.library.ossaudiodev#ossaudiodev.oss_mixer_device.reccontrols |
oss_mixer_device.set(control, (left, right))
Sets the volume for a given mixer control to (left,right). left and right must be ints and between 0 (silent) and 100 (full volume). On success, the new volume is returned as a 2-tuple. Note that this may not be exactly the same as the volume specified, because of the limi... | python.library.ossaudiodev#ossaudiodev.oss_mixer_device.set |
oss_mixer_device.set_recsrc(bitmask)
Call this function to specify a recording source. Returns a bitmask indicating the new recording source (or sources) if successful; raises OSError if an invalid source was specified. To set the current recording source to the microphone input: mixer.setrecsrc (1 << ossaudiodev.SOU... | python.library.ossaudiodev#ossaudiodev.oss_mixer_device.set_recsrc |
oss_mixer_device.stereocontrols()
Returns a bitmask indicating stereo mixer controls. If a bit is set, the corresponding control is stereo; if it is unset, the control is either monophonic or not supported by the mixer (use in combination with controls() to determine which). See the code example for the controls() fu... | python.library.ossaudiodev#ossaudiodev.oss_mixer_device.stereocontrols |
exception OverflowError
Raised when the result of an arithmetic operation is too large to be represented. This cannot occur for integers (which would rather raise MemoryError than give up). However, for historical reasons, OverflowError is sometimes raised for integers that are outside a required range. Because of th... | python.library.exceptions#OverflowError |
parser — Access Python parse trees The parser module provides an interface to Python’s internal parser and byte-code compiler. The primary purpose for this interface is to allow Python code to edit the parse tree of a Python expression and create executable code from this. This is better than trying to parse and modify... | python.library.parser |
parser.compilest(st, filename='<syntax-tree>')
The Python byte compiler can be invoked on an ST object to produce code objects which can be used as part of a call to the built-in exec() or eval() functions. This function provides the interface to the compiler, passing the internal parse tree from st to the parser, us... | python.library.parser#parser.compilest |
parser.expr(source)
The expr() function parses the parameter source as if it were an input to compile(source, 'file.py', 'eval'). If the parse succeeds, an ST object is created to hold the internal parse tree representation, otherwise an appropriate exception is raised. | python.library.parser#parser.expr |
parser.isexpr(st)
When st represents an 'eval' form, this function returns True, otherwise it returns False. This is useful, since code objects normally cannot be queried for this information using existing built-in functions. Note that the code objects created by compilest() cannot be queried like this either, and a... | python.library.parser#parser.isexpr |
parser.issuite(st)
This function mirrors isexpr() in that it reports whether an ST object represents an 'exec' form, commonly known as a “suite.” It is not safe to assume that this function is equivalent to not isexpr(st), as additional syntactic fragments may be supported in the future. | python.library.parser#parser.issuite |
exception parser.ParserError
Exception raised when a failure occurs within the parser module. This is generally produced for validation failures rather than the built-in SyntaxError raised during normal parsing. The exception argument is either a string describing the reason of the failure or a tuple containing a seq... | python.library.parser#parser.ParserError |
parser.sequence2st(sequence)
This function accepts a parse tree represented as a sequence and builds an internal representation if possible. If it can validate that the tree conforms to the Python grammar and all nodes are valid node types in the host version of Python, an ST object is created from the internal repre... | python.library.parser#parser.sequence2st |
ST.compile(filename='<syntax-tree>')
Same as compilest(st, filename). | python.library.parser#parser.ST.compile |
ST.isexpr()
Same as isexpr(st). | python.library.parser#parser.ST.isexpr |
ST.issuite()
Same as issuite(st). | python.library.parser#parser.ST.issuite |
ST.tolist(line_info=False, col_info=False)
Same as st2list(st, line_info, col_info). | python.library.parser#parser.ST.tolist |
ST.totuple(line_info=False, col_info=False)
Same as st2tuple(st, line_info, col_info). | python.library.parser#parser.ST.totuple |
parser.st2list(st, line_info=False, col_info=False)
This function accepts an ST object from the caller in st and returns a Python list representing the equivalent parse tree. The resulting list representation can be used for inspection or the creation of a new parse tree in list form. This function does not fail so l... | python.library.parser#parser.st2list |
parser.st2tuple(st, line_info=False, col_info=False)
This function accepts an ST object from the caller in st and returns a Python tuple representing the equivalent parse tree. Other than returning a tuple instead of a list, this function is identical to st2list(). If line_info is true, line number information will b... | python.library.parser#parser.st2tuple |
parser.STType
The type of the objects returned by expr(), suite() and sequence2st(). | python.library.parser#parser.STType |
parser.suite(source)
The suite() function parses the parameter source as if it were an input to compile(source, 'file.py', 'exec'). If the parse succeeds, an ST object is created to hold the internal parse tree representation, otherwise an appropriate exception is raised. | python.library.parser#parser.suite |
parser.tuple2st(sequence)
This is the same function as sequence2st(). This entry point is maintained for backward compatibility. | python.library.parser#parser.tuple2st |
pathlib — Object-oriented filesystem paths New in version 3.4. Source code: Lib/pathlib.py This module offers classes representing filesystem paths with semantics appropriate for different operating systems. Path classes are divided between pure paths, which provide purely computational operations without I/O, and co... | python.library.pathlib |
class pathlib.Path(*pathsegments)
A subclass of PurePath, this class represents concrete paths of the system’s path flavour (instantiating it creates either a PosixPath or a WindowsPath): >>> Path('setup.py')
PosixPath('setup.py')
pathsegments is specified similarly to PurePath. | python.library.pathlib#pathlib.Path |
Path.chmod(mode)
Change the file mode and permissions, like os.chmod(): >>> p = Path('setup.py')
>>> p.stat().st_mode
33277
>>> p.chmod(0o444)
>>> p.stat().st_mode
33060 | python.library.pathlib#pathlib.Path.chmod |
classmethod Path.cwd()
Return a new path object representing the current directory (as returned by os.getcwd()): >>> Path.cwd()
PosixPath('/home/antoine/pathlib') | python.library.pathlib#pathlib.Path.cwd |
Path.exists()
Whether the path points to an existing file or directory: >>> Path('.').exists()
True
>>> Path('setup.py').exists()
True
>>> Path('/etc').exists()
True
>>> Path('nonexistentfile').exists()
False
Note If the path points to a symlink, exists() returns whether the symlink points to an existing file or di... | python.library.pathlib#pathlib.Path.exists |
Path.expanduser()
Return a new path with expanded ~ and ~user constructs, as returned by os.path.expanduser(): >>> p = PosixPath('~/films/Monty Python')
>>> p.expanduser()
PosixPath('/home/eric/films/Monty Python')
New in version 3.5. | python.library.pathlib#pathlib.Path.expanduser |
Path.glob(pattern)
Glob the given relative pattern in the directory represented by this path, yielding all matching files (of any kind): >>> sorted(Path('.').glob('*.py'))
[PosixPath('pathlib.py'), PosixPath('setup.py'), PosixPath('test_pathlib.py')]
>>> sorted(Path('.').glob('*/*.py'))
[PosixPath('docs/conf.py')]
T... | python.library.pathlib#pathlib.Path.glob |
Path.group()
Return the name of the group owning the file. KeyError is raised if the file’s gid isn’t found in the system database. | python.library.pathlib#pathlib.Path.group |
classmethod Path.home()
Return a new path object representing the user’s home directory (as returned by os.path.expanduser() with ~ construct): >>> Path.home()
PosixPath('/home/antoine')
New in version 3.5. | python.library.pathlib#pathlib.Path.home |
Path.is_block_device()
Return True if the path points to a block device (or a symbolic link pointing to a block device), False if it points to another kind of file. False is also returned if the path doesn’t exist or is a broken symlink; other errors (such as permission errors) are propagated. | python.library.pathlib#pathlib.Path.is_block_device |
Path.is_char_device()
Return True if the path points to a character device (or a symbolic link pointing to a character device), False if it points to another kind of file. False is also returned if the path doesn’t exist or is a broken symlink; other errors (such as permission errors) are propagated. | python.library.pathlib#pathlib.Path.is_char_device |
Path.is_dir()
Return True if the path points to a directory (or a symbolic link pointing to a directory), False if it points to another kind of file. False is also returned if the path doesn’t exist or is a broken symlink; other errors (such as permission errors) are propagated. | python.library.pathlib#pathlib.Path.is_dir |
Path.is_fifo()
Return True if the path points to a FIFO (or a symbolic link pointing to a FIFO), False if it points to another kind of file. False is also returned if the path doesn’t exist or is a broken symlink; other errors (such as permission errors) are propagated. | python.library.pathlib#pathlib.Path.is_fifo |
Path.is_file()
Return True if the path points to a regular file (or a symbolic link pointing to a regular file), False if it points to another kind of file. False is also returned if the path doesn’t exist or is a broken symlink; other errors (such as permission errors) are propagated. | python.library.pathlib#pathlib.Path.is_file |
Path.is_mount()
Return True if the path is a mount point: a point in a file system where a different file system has been mounted. On POSIX, the function checks whether path’s parent, path/.., is on a different device than path, or whether path/.. and path point to the same i-node on the same device — this should det... | python.library.pathlib#pathlib.Path.is_mount |
Path.is_socket()
Return True if the path points to a Unix socket (or a symbolic link pointing to a Unix socket), False if it points to another kind of file. False is also returned if the path doesn’t exist or is a broken symlink; other errors (such as permission errors) are propagated. | python.library.pathlib#pathlib.Path.is_socket |
Path.is_symlink()
Return True if the path points to a symbolic link, False otherwise. False is also returned if the path doesn’t exist; other errors (such as permission errors) are propagated. | python.library.pathlib#pathlib.Path.is_symlink |
Path.iterdir()
When the path points to a directory, yield path objects of the directory contents: >>> p = Path('docs')
>>> for child in p.iterdir(): child
...
PosixPath('docs/conf.py')
PosixPath('docs/_templates')
PosixPath('docs/make.bat')
PosixPath('docs/index.rst')
PosixPath('docs/_build')
PosixPath('docs/_static'... | python.library.pathlib#pathlib.Path.iterdir |
Path.lchmod(mode)
Like Path.chmod() but, if the path points to a symbolic link, the symbolic link’s mode is changed rather than its target’s. | python.library.pathlib#pathlib.Path.lchmod |
Path.link_to(target)
Make target a hard link to this path. Warning This function does not make this path a hard link to target, despite the implication of the function and argument names. The argument order (target, link) is the reverse of Path.symlink_to(), but matches that of os.link(). New in version 3.8. | python.library.pathlib#pathlib.Path.link_to |
Path.lstat()
Like Path.stat() but, if the path points to a symbolic link, return the symbolic link’s information rather than its target’s. | python.library.pathlib#pathlib.Path.lstat |
Path.mkdir(mode=0o777, parents=False, exist_ok=False)
Create a new directory at this given path. If mode is given, it is combined with the process’ umask value to determine the file mode and access flags. If the path already exists, FileExistsError is raised. If parents is true, any missing parents of this path are c... | python.library.pathlib#pathlib.Path.mkdir |
Path.open(mode='r', buffering=-1, encoding=None, errors=None, newline=None)
Open the file pointed to by the path, like the built-in open() function does: >>> p = Path('setup.py')
>>> with p.open() as f:
... f.readline()
...
'#!/usr/bin/env python3\n' | python.library.pathlib#pathlib.Path.open |
Path.owner()
Return the name of the user owning the file. KeyError is raised if the file’s uid isn’t found in the system database. | python.library.pathlib#pathlib.Path.owner |
Path.readlink()
Return the path to which the symbolic link points (as returned by os.readlink()): >>> p = Path('mylink')
>>> p.symlink_to('setup.py')
>>> p.readlink()
PosixPath('setup.py')
New in version 3.9. | python.library.pathlib#pathlib.Path.readlink |
Path.read_bytes()
Return the binary contents of the pointed-to file as a bytes object: >>> p = Path('my_binary_file')
>>> p.write_bytes(b'Binary file contents')
20
>>> p.read_bytes()
b'Binary file contents'
New in version 3.5. | python.library.pathlib#pathlib.Path.read_bytes |
Path.read_text(encoding=None, errors=None)
Return the decoded contents of the pointed-to file as a string: >>> p = Path('my_text_file')
>>> p.write_text('Text file contents')
18
>>> p.read_text()
'Text file contents'
The file is opened and then closed. The optional parameters have the same meaning as in open(). New... | python.library.pathlib#pathlib.Path.read_text |
Path.rename(target)
Rename this file or directory to the given target, and return a new Path instance pointing to target. On Unix, if target exists and is a file, it will be replaced silently if the user has permission. target can be either a string or another path object: >>> p = Path('foo')
>>> p.open('w').write('s... | python.library.pathlib#pathlib.Path.rename |
Path.replace(target)
Rename this file or directory to the given target, and return a new Path instance pointing to target. If target points to an existing file or directory, it will be unconditionally replaced. The target path may be absolute or relative. Relative paths are interpreted relative to the current working... | python.library.pathlib#pathlib.Path.replace |
Path.resolve(strict=False)
Make the path absolute, resolving any symlinks. A new path object is returned: >>> p = Path()
>>> p
PosixPath('.')
>>> p.resolve()
PosixPath('/home/antoine/pathlib')
“..” components are also eliminated (this is the only method to do so): >>> p = Path('docs/../setup.py')
>>> p.resolve()
Pos... | python.library.pathlib#pathlib.Path.resolve |
Path.rglob(pattern)
This is like calling Path.glob() with “**/” added in front of the given relative pattern: >>> sorted(Path().rglob("*.py"))
[PosixPath('build/lib/pathlib.py'),
PosixPath('docs/conf.py'),
PosixPath('pathlib.py'),
PosixPath('setup.py'),
PosixPath('test_pathlib.py')]
Raises an auditing event path... | python.library.pathlib#pathlib.Path.rglob |
Path.rmdir()
Remove this directory. The directory must be empty. | python.library.pathlib#pathlib.Path.rmdir |
Path.samefile(other_path)
Return whether this path points to the same file as other_path, which can be either a Path object, or a string. The semantics are similar to os.path.samefile() and os.path.samestat(). An OSError can be raised if either file cannot be accessed for some reason. >>> p = Path('spam')
>>> q = Pat... | python.library.pathlib#pathlib.Path.samefile |
Path.stat()
Return a os.stat_result object containing information about this path, like os.stat(). The result is looked up at each call to this method. >>> p = Path('setup.py')
>>> p.stat().st_size
956
>>> p.stat().st_mtime
1327883547.852554 | python.library.pathlib#pathlib.Path.stat |
Path.symlink_to(target, target_is_directory=False)
Make this path a symbolic link to target. Under Windows, target_is_directory must be true (default False) if the link’s target is a directory. Under POSIX, target_is_directory’s value is ignored. >>> p = Path('mylink')
>>> p.symlink_to('setup.py')
>>> p.resolve()
Pos... | python.library.pathlib#pathlib.Path.symlink_to |
Path.touch(mode=0o666, exist_ok=True)
Create a file at this given path. If mode is given, it is combined with the process’ umask value to determine the file mode and access flags. If the file already exists, the function succeeds if exist_ok is true (and its modification time is updated to the current time), otherwis... | python.library.pathlib#pathlib.Path.touch |
Path.unlink(missing_ok=False)
Remove this file or symbolic link. If the path points to a directory, use Path.rmdir() instead. If missing_ok is false (the default), FileNotFoundError is raised if the path does not exist. If missing_ok is true, FileNotFoundError exceptions will be ignored (same behavior as the POSIX rm... | python.library.pathlib#pathlib.Path.unlink |
Path.write_bytes(data)
Open the file pointed to in bytes mode, write data to it, and close the file: >>> p = Path('my_binary_file')
>>> p.write_bytes(b'Binary file contents')
20
>>> p.read_bytes()
b'Binary file contents'
An existing file of the same name is overwritten. New in version 3.5. | python.library.pathlib#pathlib.Path.write_bytes |
Path.write_text(data, encoding=None, errors=None)
Open the file pointed to in text mode, write data to it, and close the file: >>> p = Path('my_text_file')
>>> p.write_text('Text file contents')
18
>>> p.read_text()
'Text file contents'
An existing file of the same name is overwritten. The optional parameters have t... | python.library.pathlib#pathlib.Path.write_text |
class pathlib.PosixPath(*pathsegments)
A subclass of Path and PurePosixPath, this class represents concrete non-Windows filesystem paths: >>> PosixPath('/etc')
PosixPath('/etc')
pathsegments is specified similarly to PurePath. | python.library.pathlib#pathlib.PosixPath |
class pathlib.PurePath(*pathsegments)
A generic class that represents the system’s path flavour (instantiating it creates either a PurePosixPath or a PureWindowsPath): >>> PurePath('setup.py') # Running on a Unix machine
PurePosixPath('setup.py')
Each element of pathsegments can be either a string representing ... | python.library.pathlib#pathlib.PurePath |
PurePath.anchor
The concatenation of the drive and root: >>> PureWindowsPath('c:/Program Files/').anchor
'c:\\'
>>> PureWindowsPath('c:Program Files/').anchor
'c:'
>>> PurePosixPath('/etc').anchor
'/'
>>> PureWindowsPath('//host/share').anchor
'\\\\host\\share\\' | python.library.pathlib#pathlib.PurePath.anchor |
PurePath.as_posix()
Return a string representation of the path with forward slashes (/): >>> p = PureWindowsPath('c:\\windows')
>>> str(p)
'c:\\windows'
>>> p.as_posix()
'c:/windows' | python.library.pathlib#pathlib.PurePath.as_posix |
PurePath.as_uri()
Represent the path as a file URI. ValueError is raised if the path isn’t absolute. >>> p = PurePosixPath('/etc/passwd')
>>> p.as_uri()
'file:///etc/passwd'
>>> p = PureWindowsPath('c:/Windows')
>>> p.as_uri()
'file:///c:/Windows' | python.library.pathlib#pathlib.PurePath.as_uri |
PurePath.drive
A string representing the drive letter or name, if any: >>> PureWindowsPath('c:/Program Files/').drive
'c:'
>>> PureWindowsPath('/Program Files/').drive
''
>>> PurePosixPath('/etc').drive
''
UNC shares are also considered drives: >>> PureWindowsPath('//host/share/foo.txt').drive
'\\\\host\\share' | python.library.pathlib#pathlib.PurePath.drive |
PurePath.is_absolute()
Return whether the path is absolute or not. A path is considered absolute if it has both a root and (if the flavour allows) a drive: >>> PurePosixPath('/a/b').is_absolute()
True
>>> PurePosixPath('a/b').is_absolute()
False
>>> PureWindowsPath('c:/a/b').is_absolute()
True
>>> PureWindowsPath('/... | python.library.pathlib#pathlib.PurePath.is_absolute |
PurePath.is_relative_to(*other)
Return whether or not this path is relative to the other path. >>> p = PurePath('/etc/passwd')
>>> p.is_relative_to('/etc')
True
>>> p.is_relative_to('/usr')
False
New in version 3.9. | python.library.pathlib#pathlib.PurePath.is_relative_to |
PurePath.is_reserved()
With PureWindowsPath, return True if the path is considered reserved under Windows, False otherwise. With PurePosixPath, False is always returned. >>> PureWindowsPath('nul').is_reserved()
True
>>> PurePosixPath('nul').is_reserved()
False
File system calls on reserved paths can fail mysteriousl... | python.library.pathlib#pathlib.PurePath.is_reserved |
PurePath.joinpath(*other)
Calling this method is equivalent to combining the path with each of the other arguments in turn: >>> PurePosixPath('/etc').joinpath('passwd')
PurePosixPath('/etc/passwd')
>>> PurePosixPath('/etc').joinpath(PurePosixPath('passwd'))
PurePosixPath('/etc/passwd')
>>> PurePosixPath('/etc').joinp... | python.library.pathlib#pathlib.PurePath.joinpath |
PurePath.match(pattern)
Match this path against the provided glob-style pattern. Return True if matching is successful, False otherwise. If pattern is relative, the path can be either relative or absolute, and matching is done from the right: >>> PurePath('a/b.py').match('*.py')
True
>>> PurePath('/a/b/c.py').match('... | python.library.pathlib#pathlib.PurePath.match |
PurePath.name
A string representing the final path component, excluding the drive and root, if any: >>> PurePosixPath('my/library/setup.py').name
'setup.py'
UNC drive names are not considered: >>> PureWindowsPath('//some/share/setup.py').name
'setup.py'
>>> PureWindowsPath('//some/share').name
'' | python.library.pathlib#pathlib.PurePath.name |
PurePath.parent
The logical parent of the path: >>> p = PurePosixPath('/a/b/c/d')
>>> p.parent
PurePosixPath('/a/b/c')
You cannot go past an anchor, or empty path: >>> p = PurePosixPath('/')
>>> p.parent
PurePosixPath('/')
>>> p = PurePosixPath('.')
>>> p.parent
PurePosixPath('.')
Note This is a purely lexical ope... | python.library.pathlib#pathlib.PurePath.parent |
PurePath.parents
An immutable sequence providing access to the logical ancestors of the path: >>> p = PureWindowsPath('c:/foo/bar/setup.py')
>>> p.parents[0]
PureWindowsPath('c:/foo/bar')
>>> p.parents[1]
PureWindowsPath('c:/foo')
>>> p.parents[2]
PureWindowsPath('c:/') | python.library.pathlib#pathlib.PurePath.parents |
PurePath.parts
A tuple giving access to the path’s various components: >>> p = PurePath('/usr/bin/python3')
>>> p.parts
('/', 'usr', 'bin', 'python3')
>>> p = PureWindowsPath('c:/Program Files/PSF')
>>> p.parts
('c:\\', 'Program Files', 'PSF')
(note how the drive and local root are regrouped in a single part) | python.library.pathlib#pathlib.PurePath.parts |
PurePath.relative_to(*other)
Compute a version of this path relative to the path represented by other. If it’s impossible, ValueError is raised: >>> p = PurePosixPath('/etc/passwd')
>>> p.relative_to('/')
PurePosixPath('etc/passwd')
>>> p.relative_to('/etc')
PurePosixPath('passwd')
>>> p.relative_to('/usr')
Traceback... | python.library.pathlib#pathlib.PurePath.relative_to |
PurePath.root
A string representing the (local or global) root, if any: >>> PureWindowsPath('c:/Program Files/').root
'\\'
>>> PureWindowsPath('c:Program Files/').root
''
>>> PurePosixPath('/etc').root
'/'
UNC shares always have a root: >>> PureWindowsPath('//host/share').root
'\\' | python.library.pathlib#pathlib.PurePath.root |
PurePath.stem
The final path component, without its suffix: >>> PurePosixPath('my/library.tar.gz').stem
'library.tar'
>>> PurePosixPath('my/library.tar').stem
'library'
>>> PurePosixPath('my/library').stem
'library' | python.library.pathlib#pathlib.PurePath.stem |
PurePath.suffix
The file extension of the final component, if any: >>> PurePosixPath('my/library/setup.py').suffix
'.py'
>>> PurePosixPath('my/library.tar.gz').suffix
'.gz'
>>> PurePosixPath('my/library').suffix
'' | python.library.pathlib#pathlib.PurePath.suffix |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.