_dbus_bindings._BytesBase - pydoc - phpman

Che Dong
Help on class _BytesBase in _dbus_bindings:

_dbus_bindings._BytesBase = class _BytesBase(builtins.bytes)
 |  Base class for bytes subclasses with a ``variant_level`` attribute.
 |  Do not rely on the existence of this class outside dbus-python.
 |
 |  Method resolution order:
 |      _BytesBase
 |      builtins.bytes
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name, /)
 |      Implement delattr(self, name).
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value, /)
 |      Implement setattr(self, name, value).
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.bytes:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return key in self.
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(...)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  capitalize(...)
 |      B.capitalize() -> copy of B
 |
 |      Return a copy of B with only its first character capitalized (ASCII)
 |      and the rest lower-cased.
 |
 |  center(self, width, fillchar=b' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  count(...)
 |      B.count(sub[, start[, end]]) -> int
 |
 |      Return the number of non-overlapping occurrences of subsection sub in
 |      bytes B[start:end].  Optional arguments start and end are interpreted
 |      as in slice notation.
 |
 |  decode(self, /, encoding='utf-8', errors='strict')
 |      Decode the bytes using the codec registered for encoding.
 |
 |      encoding
 |        The encoding with which to decode the bytes.
 |      errors
 |        The error handling scheme to use for the handling of decoding errors.
 |        The default is 'strict' meaning that decoding errors raise a
 |        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
 |        as well as any other name registered with codecs.register_error that
 |        can handle UnicodeDecodeErrors.
 |
 |  endswith(...)
 |      B.endswith(suffix[, start[, end]]) -> bool
 |
 |      Return True if B ends with the specified suffix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      suffix can also be a tuple of bytes to try.
 |
 |  expandtabs(self, /, tabsize=8)
 |      Return a copy where all tab characters are expanded using spaces.
 |
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |
 |  find(...)
 |      B.find(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  hex(...)
 |      Create a string of hexadecimal numbers from a bytes object.
 |
 |        sep
 |          An optional single character or byte to separate hex bytes.
 |        bytes_per_sep
 |          How many bytes between separators.  Positive values count from the
 |          right, negative values count from the left.
 |
 |      Example:
 |      >>> value = b'\xb9\x01\xef'
 |      >>> value.hex()
 |      'b901ef'
 |      >>> value.hex(':')
 |      'b9:01:ef'
 |      >>> value.hex(':', 2)
 |      'b9:01ef'
 |      >>> value.hex(':', -2)
 |      'b901:ef'
 |
 |  index(...)
 |      B.index(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the subsection is not found.
 |
 |  isalnum(...)
 |      B.isalnum() -> bool
 |
 |      Return True if all characters in B are alphanumeric
 |      and there is at least one character in B, False otherwise.
 |
 |  isalpha(...)
 |      B.isalpha() -> bool
 |
 |      Return True if all characters in B are alphabetic
 |      and there is at least one character in B, False otherwise.
 |
 |  isascii(...)
 |      B.isascii() -> bool
 |
 |      Return True if B is empty or all characters in B are ASCII,
 |      False otherwise.
 |
 |  isdigit(...)
 |      B.isdigit() -> bool
 |
 |      Return True if all characters in B are digits
 |      and there is at least one character in B, False otherwise.
 |
 |  islower(...)
 |      B.islower() -> bool
 |
 |      Return True if all cased characters in B are lowercase and there is
 |      at least one cased character in B, False otherwise.
 |
 |  isspace(...)
 |      B.isspace() -> bool
 |
 |      Return True if all characters in B are whitespace
 |      and there is at least one character in B, False otherwise.
 |
 |  istitle(...)
 |      B.istitle() -> bool
 |
 |      Return True if B is a titlecased string and there is at least one
 |      character in B, i.e. uppercase characters may only follow uncased
 |      characters and lowercase characters only cased ones. Return False
 |      otherwise.
 |
 |  isupper(...)
 |      B.isupper() -> bool
 |
 |      Return True if all cased characters in B are uppercase and there is
 |      at least one cased character in B, False otherwise.
 |
 |  join(self, iterable_of_bytes, /)
 |      Concatenate any number of bytes objects.
 |
 |      The bytes whose method is called is inserted in between each pair.
 |
 |      The result is returned as a new bytes object.
 |
 |      Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
 |
 |  ljust(self, width, fillchar=b' ', /)
 |      Return a left-justified string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  lower(...)
 |      B.lower() -> copy of B
 |
 |      Return a copy of B with all ASCII characters converted to lowercase.
 |
 |  lstrip(self, bytes=None, /)
 |      Strip leading bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip leading  ASCII whitespace.
 |
 |  partition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |
 |      This will search for the separator sep in the bytes. If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing the original bytes
 |      object and two empty bytes objects.
 |
 |  removeprefix(self, prefix, /)
 |      Return a bytes object with the given prefix string removed if present.
 |
 |      If the bytes starts with the prefix string, return bytes[len(prefix):].
 |      Otherwise, return a copy of the original bytes.
 |
 |  removesuffix(self, suffix, /)
 |      Return a bytes object with the given suffix string removed if present.
 |
 |      If the bytes ends with the suffix string and that suffix is not empty,
 |      return bytes[:-len(prefix)].  Otherwise, return a copy of the original
 |      bytes.
 |
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |
 |  rfind(...)
 |      B.rfind(sub[, start[, end]]) -> int
 |
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  rindex(...)
 |      B.rindex(sub[, start[, end]]) -> int
 |
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raise ValueError when the subsection is not found.
 |
 |  rjust(self, width, fillchar=b' ', /)
 |      Return a right-justified string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  rpartition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |
 |      This will search for the separator sep in the bytes, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing two empty bytes
 |      objects and the original bytes object.
 |
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |
 |        sep
 |          The delimiter according which to split the bytes.
 |          None (the default value) means split on ASCII whitespace characters
 |          (space, tab, return, newline, formfeed, vertical tab).
 |        maxsplit
 |          Maximum number of splits to do.
 |          -1 (the default value) means no limit.
 |
 |      Splitting is done starting at the end of the bytes and working to the front.
 |
 |  rstrip(self, bytes=None, /)
 |      Strip trailing bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip trailing ASCII whitespace.
 |
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |
 |      sep
 |        The delimiter according which to split the bytes.
 |        None (the default value) means split on ASCII whitespace characters
 |        (space, tab, return, newline, formfeed, vertical tab).
 |      maxsplit
 |        Maximum number of splits to do.
 |        -1 (the default value) means no limit.
 |
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the bytes, breaking at line boundaries.
 |
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |
 |  startswith(...)
 |      B.startswith(prefix[, start[, end]]) -> bool
 |
 |      Return True if B starts with the specified prefix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      prefix can also be a tuple of bytes to try.
 |
 |  strip(self, bytes=None, /)
 |      Strip leading and trailing bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip leading and trailing ASCII whitespace.
 |
 |  swapcase(...)
 |      B.swapcase() -> copy of B
 |
 |      Return a copy of B with uppercase ASCII characters converted
 |      to lowercase ASCII and vice versa.
 |
 |  title(...)
 |      B.title() -> copy of B
 |
 |      Return a titlecased version of B, i.e. ASCII words start with uppercase
 |      characters, all remaining cased characters have lowercase.
 |
 |  translate(self, table, /, delete=b'')
 |      Return a copy with each character mapped by the given translation table.
 |
 |        table
 |          Translation table, which must be a bytes object of length 256.
 |
 |      All characters occurring in the optional argument delete are removed.
 |      The remaining characters are mapped through the given translation table.
 |
 |  upper(...)
 |      B.upper() -> copy of B
 |
 |      Return a copy of B with all ASCII characters converted to uppercase.
 |
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |
 |      The original string is never truncated.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from builtins.bytes:
 |
 |  fromhex(string, /) from builtins.type
 |      Create a bytes object from a string of hexadecimal numbers.
 |
 |      Spaces between two numbers are accepted.
 |      Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.bytes:
 |
 |  maketrans(frm, to, /)
 |      Return a translation table useable for the bytes or bytearray translate method.
 |
 |      The returned table will be one where each byte in frm is mapped to the byte at
 |      the same position in to.
 |
 |      The bytes objects frm and to must be of the same length.