PySide6.QtCore.QByteArray¶

class QByteArray¶

QByteArray 类提供了一个字节数组。More_…

概要¶

方法¶

def __init__()
def __getitem__()
def __len__()
def __mgetitem__()
def __msetitem__()
def __reduce__()
def __repr__()
def __setitem__()
def __str__()
def append()
def assign()
def at()
def back()
def capacity()
def cbegin()
def cend()
def chop()
def chopped()
def clear()
def compare()
def contains()
def count()
def data()
def endsWith()
def erase()
def fill()
def first()
def front()
def indexOf()
def insert()
def isEmpty()
def isLower()
def isNull()
def isSharedWith()
def isUpper()
def isValidUtf8()
def last()
def lastIndexOf()
def left()
def leftJustified()
def length()
def max_size()
def mid()
def __ne__()
def __add__()
def __iadd__()
def __lt__()
def __le__()
def __eq__()
def __gt__()
def __ge__()
def operator[]()
def percentDecoded()
def prepend()
def push_back()
def push_front()
def remove()
def removeAt()
def removeFirst()
def removeLast()
def repeated()
def replace()
def reserve()
def resize()
def resizeForOverwrite()
def right()
def rightJustified()
def setNum()
def setRawData()
def shrink_to_fit()
def simplified()
def size()
def slice()
def sliced()
def split()
def squeeze()
def startsWith()
def swap()
def toBase64()
def toDouble()
def toFloat()
def toHex()
def toInt()
def toLong()
def toLongLong()
def toLower()
def toPercentEncoding()
def toShort()
def toStdString()
def toUInt()
def toULong()
def toULongLong()
def toUShort()
def toUpper()
def trimmed()
def truncate()

注意

本文档可能包含从C++自动翻译到Python的代码片段。我们始终欢迎对代码片段翻译的贡献。如果您发现翻译问题，您也可以通过在我们的https:/bugreports.qt.io/projects/PYSIDE上创建工单来告知我们。

详细描述¶

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

QByteArray 可以用来存储原始字节（包括‘\0’）和传统的8位‘\0’终止的字符串。使用 QByteArray 比使用 const char * 方便得多。在幕后，它始终确保数据后面有一个‘\0’终止符，并使用隐式共享（写时复制）来减少内存使用并避免不必要的数据复制。

除了QByteArray，Qt还提供了QString类来存储字符串数据。在大多数情况下，QString是您想要使用的类。它将内容理解为Unicode文本（使用UTF-16编码），而QByteArray旨在避免对其存储的字节的编码或语义做出假设（除了少数遗留情况下使用ASCII）。此外，QString在整个Qt API中被广泛使用。QByteArray适用的两个主要情况是当您需要存储原始二进制数据时，以及当内存节省至关重要时（例如，在Qt for Embedded Linux中）。

初始化QByteArray的一种方法是简单地将const char *传递给其构造函数。例如，以下代码创建了一个大小为5的字节数组，包含数据“Hello”：

ba = QByteArray("Hello")

尽管size()是5，字节数组在末尾还保留了一个额外的‘\0’字节，以便如果使用一个要求指向底层数据的指针的函数（例如调用data()），所指向的数据保证是以‘\0’结尾的。

QByteArray 对 const char * 数据进行深拷贝，因此您可以在以后修改它而不会产生副作用。（例如，如果出于性能原因，您不希望进行数据的深拷贝，请改用 fromRawData()。）

另一种方法是使用resize()设置数组的大小，并逐个字节初始化数据。QByteArray使用基于0的索引，就像C++数组一样。要访问特定索引位置的字节，可以使用operator[]()。在非常量字节数组上，operator[]()返回一个字节的引用，可以用于赋值的左侧。例如：

ba = QByteArray()
ba.resize(5)
ba[0] = 0x3c
ba[1] = 0xb8
ba[2] = 0x64
ba[3] = 0x18
ba[4] = 0xca

对于只读访问，另一种语法是使用 at() ：

for i in range(0, ba.size()):
    if ba.at(i) >= 'a' and ba.at(i) <= 'f':
        print("Found character in range [a-f]")

at() 可能比 operator[]() 更快，因为它永远不会导致深拷贝发生。

要一次提取多个字节，请使用 first() 、 last() 或 sliced() 。

一个 QByteArray 可以嵌入‘\0’字节。size() 函数总是返回整个数组的大小，包括嵌入的‘\0’字节，但不包括由 QByteArray 添加的终止‘\0’。例如：

ba1 = QByteArray("ca\0r\0t")
ba1.size() # Returns 2.
ba1.constData() # Returns "ca" with terminating \0.
ba2 = QByteArray("ca\0r\0t", 3)
ba2.size() # Returns 3.
ba2.constData() # Returns "ca\0" with terminating \0.
ba3 = QByteArray("ca\0r\0t", 4)
ba3.size() # Returns 4.
ba3.constData() # Returns "ca\0r" with terminating \0.
cart = {'c', 'a', '\0', 'r', '\0', 't'}
ba4 = QByteArray(QByteArray.fromRawData(cart, 6))
ba4.size() # Returns 6.
ba4.constData() # Returns "ca\0r\0t" without terminating \0.

如果你想获取数据长度，直到但不包括第一个‘\0’字节，可以在字节数组上调用qstrlen()。

在调用resize()之后，新分配的字节具有未定义的值。要将所有字节设置为特定值，请调用fill()。

要获取实际字节的指针，请调用data()或constData()。这些函数返回指向数据开头的指针。保证该指针在调用QByteArray的非const函数之前保持有效。还保证数据以‘\0’字节结尾，除非QByteArray是从raw data创建的。这个‘\0’字节由QByteArray自动提供，并且不计入size()。

QByteArray 提供了以下基本函数来修改字节数据：append()、prepend()、insert()、replace() 和 remove()。例如：

x = QByteArray("and")
x.prepend("rock ") # x == "rock and"
x.append(" roll") # x == "rock and roll"
x.replace(5, 3, "") # x == "rock  roll"

在上面的例子中，replace() 函数的前两个参数是开始替换的位置和应该替换的字节数。

当数据修改函数增加数组的大小时，它们可能会导致为QByteArray对象重新分配内存。当这种情况发生时，QByteArray会扩展得比立即需要的更多，以便为未来的扩展留出空间，而无需重新分配内存，直到数组的大小大幅增加。

insert()、remove()以及当用不同大小的子数组替换时，replace()函数对于大数组可能会很慢（线性时间），因为它们需要将数组中的许多字节在内存中至少移动一个位置。

如果你正在逐步构建一个QByteArray，并且提前知道QByteArray将包含大约多少字节，你可以调用reserve()，要求QByteArray预先分配一定数量的内存。你也可以调用capacity()来找出QByteArray实际分配了多少内存。

请注意，使用非const运算符和函数可能会导致QByteArray对数据进行深度复制，这是由于隐式共享。

QByteArray 提供了 STL风格的迭代器（const_iterator 和 iterator）。实际上，迭代器在使用C++标准库提供的通用算法时非常方便。

注意

迭代器和对单个QByteArray元素的引用存在稳定性问题。当调用QByteArray的修改操作（例如insert()或remove()）时，它们通常会失效。当需要稳定性和类似迭代器的功能时，应使用索引而不是迭代器，因为索引不依赖于QByteArray的内部状态，因此不会失效。

注意

当调用QByteArray的任何非const方法时，不能保证对QByteArray的迭代器以及对其中单个字节的引用仍然有效。在调用非const方法后访问此类迭代器或引用会导致未定义的行为。当需要类似迭代器功能的稳定性时，应使用索引而不是迭代器，因为它们不依赖于QByteArray的内部状态，因此不会失效。

如果你想在QByteArray中找到特定字节或字节序列的所有出现位置，可以使用indexOf()或lastIndexOf()。前者从给定的索引位置开始向前搜索，后者向后搜索。如果找到字节序列，两者都会返回其索引位置；否则，返回-1。例如，下面是一个典型的循环，用于查找特定字符串的所有出现位置：

ba = QByteArray("We must be , very ")
j = 0
while (j = ba.indexOf("<b>", j)) != -1:
    print("Found <b> tag at index position ", j)
    j += 1

如果你只是想检查一个QByteArray是否包含特定的字节序列，请使用contains()。如果你想找出特定字节序列在字节数组中出现的次数，请使用count()。如果你想用另一个值替换所有出现的特定值，请使用两个参数的replace()重载之一。

QByteArray 可以使用重载运算符进行比较，例如 operator<(), operator<=(), operator==(), operator>=() 等。比较完全基于字节的数值，速度非常快，但不符合人类的预期。localeAwareCompare() 是排序用户界面字符串的更好选择。

由于历史原因，QByteArray 区分了空字节数组和空字节数组。一个空字节数组是使用QByteArray的默认构造函数或通过传递(const char *)0给构造函数初始化的字节数组。一个空字节数组是任何大小为0的字节数组。一个空字节数组总是空的，但一个空的字节数组不一定是空的：

QByteArray().isNull() # returns true
QByteArray().isEmpty() # returns true
QByteArray("").isNull() # returns false
QByteArray("").isEmpty() # returns true
QByteArray("abc").isNull() # returns false
QByteArray("abc").isEmpty() # returns false

除了isNull()之外的所有函数都将空字节数组视为与空字节数组相同。例如，data()返回一个有效的指针（不是 nullptr）指向一个‘\0’字节，用于空字节数组，并且QByteArray()与QByteArray（“”）相等。我们建议您始终使用isEmpty()并避免使用isNull()。

最大大小和内存不足情况¶

QByteArray 的最大大小取决于架构。大多数 64 位系统可以分配超过 2 GB 的内存，典型限制为 2^63 字节。实际值还取决于管理数据块所需的开销。因此，您可以预期在 32 位平台上的最大大小为 2 GB 减去开销，而在 64 位平台上的最大大小为 2^63 字节减去开销。可以存储在 QByteArray 中的元素数量就是这个最大大小。

当内存分配失败时，如果应用程序在编译时支持异常，QByteArray 会抛出 std::bad_alloc 异常。在 Qt 容器中，内存不足的情况是唯一会导致 Qt 抛出异常的情况。如果禁用了异常，则内存不足的行为是未定义的。

请注意，操作系统可能会对持有大量分配内存的应用程序施加进一步的限制，特别是对于大的连续内存块。这些考虑因素、此类行为的配置或任何缓解措施都不在QByteArray API的范围内。

C语言环境和ASCII函数¶

QByteArray 通常将数据作为字节处理，不假定任何语义；在假定语义的情况下，它使用C语言环境和ASCII编码。标准Unicode编码由QString支持，其他编码可以通过使用QStringEncoder和QStringDecoder转换为Unicode。对于特定语言环境的文本解释，请使用QLocale或QString。

C 字符串¶

传统的C字符串，也称为以'\0'结尾的字符串，是由一个起始点指定的字节序列，隐式地包括每个字节，直到但不包括第一个'\0'字节。接受这种指针而不带长度的方法会将其解释为这个字节序列。根据构造，这样的序列不能包含'\0'字节。

其他重载接受一个起始指针和字节计数；这些重载使用起始地址后的给定字节数，无论其中是否有‘\0’字节。在某些情况下，如果没有只接受指针的重载，传递长度为-1将导致方法使用指针后的第一个‘\0’字节的偏移量作为长度；只有在方法明确说明这样做时（在这种情况下，它通常是默认参数），才应传递长度为-1。

间距字符¶

一个常见的需求是从字节数组中移除空格字符（'\n', '\t', ' ', 等）。如果你想从QByteArray的两端移除空格，可以使用trimmed()。如果你想在字节数组中将连续的多个空格字符替换为单个空格字符，可以使用simplified()。这些操作仅识别ASCII空格字符。

数字-字符串转换¶

执行数值数据类型和字符串表示之间转换的函数在C语言环境中执行，无论用户的区域设置如何。使用QLocale来执行数字和字符串之间的区域感知转换。

字符大小写¶

在QByteArray中，大写和小写以及不区分大小写的比较概念仅限于ASCII。非ASCII字符被视为无大小写，因为它们的大小写取决于编码。这影响了支持不区分大小写选项或更改其参数大小写的函数。受此影响的函数包括compare()、isLower()、isUpper()、toLower()和toUpper()。

此问题不适用于QString，因为它们使用Unicode表示字符。

另请参阅

QByteArrayView QString QBitArray

class Base64Option¶

(继承自 enum.Flag) 此枚举包含可用于编码和解码 Base64 的选项。Base64 由 RFC 4648 定义，具有以下选项：

常量

描述

QByteArray.Base64Encoding

（默认）常规的Base64字母表，简称为“base64”

QByteArray.Base64UrlEncoding

一种称为“base64url”的替代字母表，它替换了字母表中的两个字符，使其对URL更加友好。

QByteArray.KeepTrailingEquals

（默认）保留编码数据末尾的填充等号，因此数据大小始终是四的倍数。

QByteArray.OmitTrailingEquals

省略在编码数据末尾添加填充等号。

QByteArray.IgnoreBase64DecodingErrors

在解码Base64编码的数据时，忽略输入中的错误；无效字符将被简单地跳过。此枚举值已在Qt 5.15中添加。

QByteArray.AbortOnBase64DecodingErrors

在解码Base64编码的数据时，在第一个解码错误处停止。此枚举值已在Qt 5.15中添加。

常量	描述
QByteArray.Base64Encoding	（默认）常规的Base64字母表，简称为“base64”
QByteArray.Base64UrlEncoding	一种称为“base64url”的替代字母表，它替换了字母表中的两个字符，使其对URL更加友好。
QByteArray.KeepTrailingEquals	（默认）保留编码数据末尾的填充等号，因此数据大小始终是四的倍数。
QByteArray.OmitTrailingEquals	省略在编码数据末尾添加填充等号。
QByteArray.IgnoreBase64DecodingErrors	在解码Base64编码的数据时，忽略输入中的错误；无效字符将被简单地跳过。此枚举值已在Qt 5.15中添加。
QByteArray.AbortOnBase64DecodingErrors	在解码Base64编码的数据时，在第一个解码错误处停止。此枚举值已在Qt 5.15中添加。

fromBase64Encoding() 和 fromBase64() 忽略 KeepTrailingEquals 和 OmitTrailingEquals 选项。如果指定了 IgnoreBase64DecodingErrors 选项，它们不会在缺少尾随等号或等号过多的情况下标记错误。如果指定了 AbortOnBase64DecodingErrors，则输入必须没有填充或具有正确数量的等号。

class Base64DecodingStatus¶

__init__()¶

构造一个空的字节数组。

另请参阅

isEmpty()

__init__(data)

Parameters:: 数据 – PyByteArray

__init__(data)

Parameters:: 数据 – PyBytes

__init__(v)

Parameters:: v – QByteArrayView

__init__(other)

Parameters:: 其他 – QByteArray

构造other的副本。

此操作需要常数时间，因为QByteArray是隐式共享的。这使得从函数返回QByteArray非常快。如果共享实例被修改，它将被复制（写时复制），需要线性时间。

另请参阅

operator=()

__init__(data[, size=-1])

Parameters:

data – 字符串
size – int

构造一个包含数组 data 的前 size 字节的字节数组。

如果 data 为 0，则构造一个空字节数组。

如果 size 为负数，则假定 data 指向一个以‘\0’结尾的字符串，并且其长度是动态确定的。

QByteArray 对字符串数据进行了深度复制。

另请参阅

fromRawData()

__init__(size, c)

Parameters:

size – int
c – 整数

构造一个大小为size的字节数组，每个字节都设置为ch。

另请参阅

fill()

__getitem__()¶

__len__()¶

__mgetitem__()¶

__msetitem__()¶

__reduce__()¶

Return type:: 字符串

__repr__()¶

Return type:: 字符串

__setitem__()¶

__str__()¶

Return type:: 字符串

append(a)¶

Parameters:: a – QByteArrayView
Return type:: QByteArray

这是一个重载函数。

将 data 附加到此字节数组中。

append(c)

Parameters:: c – 整数
Return type:: QByteArray

这是一个重载函数。

将字节 ch 附加到此字节数组中。

append(a)

Parameters:: a – QByteArray
Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

将字节数组 ba 附加到此字节数组的末尾。

示例：

x = QByteArray("free")
y = QByteArray("dom")
x.append(y)
# x == "freedom"

这与insert( size() , ba)相同。

注意：QByteArray 是一个隐式共享类。因此，如果你向一个空的字节数组追加数据，那么字节数组将只共享 ba 中持有的数据。在这种情况下，不会进行数据复制，所需时间为常数时间。如果共享实例被修改，它将被复制（写时复制），所需时间为线性时间。

如果要追加的字节数组不为空，则会执行数据的深拷贝，这需要线性时间。

append() 函数通常非常快（常数时间），因为 QByteArray 在数据末尾预分配了额外的空间，因此它可以在每次增长时无需重新分配整个数组。

另请参阅

operator+=() prepend() insert()

append(s, len)

Parameters:

s – 字符串
len – int

Return type:

QByteArray

这是一个重载函数。

将起始于str的前len个字节附加到此字节数组，并返回对此字节数组的引用。附加的字节可能包括‘\0’字节。

如果 len 为负数，str 将被假定为一个以‘\0’结尾的字符串，并且要复制的长度将使用 qstrlen() 自动确定。

如果 len 为零或 str 为空，则不会向字节数组追加任何内容。确保 len 不长于 str。

append(count, c)

Parameters:

count – int
c – 整数

Return type:

QByteArray

这是一个重载函数。

将字节 ch 的 count 个副本附加到此字节数组，并返回对此字节数组的引用。

如果 count 是负数或零，则不会向字节数组追加任何内容。

assign(v)¶

Parameters:: v – QByteArrayView
Return type:: QByteArray

将此字节数组的内容替换为v的副本，并返回对此字节数组的引用。

这个字节数组的大小将等于v的大小。

此函数仅在v的大小超过此字节数组的容量或此字节数组被共享时分配内存。

assign(n, c)

Parameters:

n – 整数
c – 整数

Return type:

QByteArray

用n个c的副本替换此字节数组的内容，并返回对此字节数组的引用。

这个字节数组的大小将等于n，它必须是非负的。

此函数仅在n超过此字节数组的容量或此字节数组被共享时分配内存。

另请参阅

fill()

at(i)¶

Parameters:: i – 整数
Return type:: 整数

返回字节数组中索引位置 i 处的字节。

i 必须是字节数组中的有效索引位置（即 0 <= i < size()）。

另请参阅

operator[]()

back()¶

Return type:: 整数

返回字节数组中的最后一个字节。与at(size() - 1)相同。

此函数为STL兼容性提供。

警告

在空字节数组上调用此函数会导致未定义行为。

另请参阅

front() at() operator[]()

capacity()¶

Return type:: 整数

返回可以在不强制重新分配的情况下存储在字节数组中的最大字节数。

此函数的唯一目的是提供一种微调QByteArray内存使用的方法。通常情况下，您很少需要调用此函数。如果您想知道字节数组中有多少字节，请调用size()。

注意

一个静态分配的字节数组将报告容量为0，即使它不为空。

注意

在分配的内存块中，空闲空间的位置是未定义的。换句话说，不应假设空闲内存总是位于初始化元素之后。

另请参阅

reserve() squeeze()

cbegin()¶

Return type:: 字符串

返回一个指向字节数组中第一个字节的常量STL风格迭代器。

警告

返回的迭代器在分离或当QByteArray被修改时失效。

另请参阅

begin() cend()

cend()¶

Return type:: 字符串

返回一个指向字节数组中最后一个字节之后的常量的STL风格迭代器。

警告

返回的迭代器在分离或当QByteArray被修改时失效。

另请参阅

cbegin() end()

chop(n)¶

Parameters:: n – 整数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

从字节数组的末尾移除 n 个字节。

如果 n 大于 size()，结果将是一个空的字节数组。

示例：

ba = QByteArray("STARTTLS\r\n")
ba.chop(2) # ba == "STARTTLS"
另请参阅

truncate() resize() first()

chopped(len)¶

Parameters:: len – int
Return type:: QByteArray

clear()¶

清除字节数组的内容并将其置为空。

另请参阅

resize() isNull()

compare(a[, cs=Qt.CaseSensitive])¶

Parameters:

a – QByteArrayView
cs – CaseSensitivity

Return type:

整数

返回一个整数，小于、等于或大于零，取决于此QByteArray在排序时位于QByteArrayView bv之前、相同位置或之后。比较是根据大小写敏感性cs进行的。

另请参阅

operator== Character Case

contains(bv)¶

Parameters:: bv – QByteArrayView
Return type:: 布尔

如果此字节数组包含由bv查看的字节序列的出现，则返回true；否则返回false。

另请参阅

indexOf() count()

contains(c)

Parameters:: c – 整数
Return type:: 布尔

这是一个重载函数。

如果字节数组包含字节 ch，则返回 true；否则返回 false。

count()¶

Return type:: 整数

注意

此函数已弃用。

请使用 size() 或 length() 代替。

这是一个重载函数。

与 size() 相同。

count(bv)

Parameters:: bv – QByteArrayView
Return type:: 整数

返回此字节数组中由bv查看的字节序列的（可能重叠的）出现次数。

另请参阅

contains() indexOf()

count(c)

Parameters:: c – 整数
Return type:: 整数

这是一个重载函数。

返回字节数组中字节 ch 的出现次数。

另请参阅

contains() indexOf()

data()¶

Return type:: 字符串

这是一个重载函数。

endsWith(bv)¶

Parameters:: bv – QByteArrayView
Return type:: 布尔

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

如果此字节数组以bv查看的字节序列结尾，则返回true；否则返回false。

示例：

url = QByteArray("http://qt-project.org/doc/qt-5.0/qtdoc/index.html")
if url.endsWith(".html"):
    ...

另请参阅

startsWith() last()

endsWith(c)

Parameters:: c – 整数
Return type:: 布尔

这是一个重载函数。

如果此字节数组以字节 ch 结尾，则返回 true；否则返回 false。

erase(it)¶

Parameters:: it – str
Return type:: char

这是一个重载函数。

从字节数组中移除由it表示的字符。返回一个指向被擦除字符之后的字符的迭代器。

QByteArray ba = "abcdefg";
auto it = ba.erase(ba.cbegin()); // ba is now "bcdefg" and it points to "b"

erase(first, last)

Parameters:

first – str
last – str

Return type:

char

fill(c[, size=-1])¶

Parameters:

c – 整数
size – int

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

将字节数组中的每个字节设置为ch。如果size与-1（默认值）不同，则字节数组会先调整为size大小。

示例：

ba = QByteArray("Istambul")
ba.fill('o')
# ba == "oooooooo"
ba.fill('X', 2)
# ba == "XX"

另请参阅

resize()

first(n)¶

Parameters:: n – 整数
Return type:: QByteArray

static fromBase64(base64[, options=QByteArray.Base64Option.Base64Encoding])¶

Parameters:

base64 – QByteArray
options – Base64Option 的组合

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回Base64数组base64的解码副本，使用options定义的选项。如果options包含IgnoreBase64DecodingErrors（默认值），则不会检查输入的有效性；输入中的无效字符将被跳过，使解码过程能够继续处理后续字符。如果options包含AbortOnBase64DecodingErrors，则解码将在第一个无效字符处停止。

例如：

text = QByteArray.fromBase64("UXQgaXMgZ3JlYXQh")
text.data() # returns "Qt is great!"
QByteArray.fromBase64("PHA+SGVsbG8/PC9wPg==", QByteArray.Base64Encoding) # returns "<p>Hello?</p>"
QByteArray.fromBase64("PHA-SGVsbG8_PC9wPg==", QByteArray.Base64UrlEncoding) # returns "<p>Hello?</p>"

用于解码Base64编码数据的算法在RFC 4648中定义。

返回解码后的数据，或者，如果传递了AbortOnBase64DecodingErrors选项且输入数据无效，则返回一个空的字节数组。

注意

建议在新代码中使用fromBase64Encoding()函数。

另请参阅

toBase64() fromBase64Encoding()

static fromBase64Encoding(base64[, options=QByteArray.Base64Option.Base64Encoding])¶

Parameters:

base64 – QByteArray
options – Base64Option 的组合

Return type:

FromBase64Result

static fromHex(hexEncoded)¶

Parameters:: hexEncoded – QByteArray
Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回十六进制编码数组hexEncoded的解码副本。输入的有效性不会被检查；输入中的无效字符会被跳过，从而使解码过程能够继续处理后续字符。

例如：

text = QByteArray.fromHex("517420697320677265617421")
text.data() # returns "Qt is great!"

另请参阅

toHex()

static fromPercentEncoding(pctEncoded[, percent='%'])¶

Parameters:

pctEncoded – QByteArray
percent – int

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

从URI/URL风格的百分号编码中解码input。

返回包含解码文本的字节数组。percent参数允许使用不同于‘%’的字符（例如，‘_’或‘=’）作为转义字符。等同于输入。percentDecoded (percent)。

例如：

text = QByteArray.fromPercentEncoding("Qt%20is%20great%33")
qDebug("%s", text.data()) # reports "Qt is great!"

另请参阅

percentDecoded()

static fromRawData(data, size)¶

Parameters:

data – 字符串
size – int

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

构造一个QByteArray，它使用data数组的前size字节。这些字节不会被复制。QByteArray将包含data指针。调用者保证只要这个QByteArray及其任何未修改的副本存在，data就不会被删除或修改。换句话说，因为QByteArray是一个隐式共享类，并且此函数返回的实例包含data指针，所以只要返回的QByteArray及其任何副本存在，调用者就不能删除data或直接修改它。然而，QByteArray并不拥有data的所有权，因此QByteArray的析构函数永远不会删除原始的data，即使最后一个引用data的QByteArray被销毁。

随后尝试修改返回的QByteArray或其任何副本的内容时，将在进行修改之前创建data数组的深拷贝。这确保了原始data数组本身永远不会被QByteArray修改。

这里是一个示例，展示了如何使用QDataStream在内存中的原始数据上读取数据，而无需将原始数据复制到QByteArray中：

 mydata = {
    '\x00', '\x00', '\x03', '\x84', '\x78', '\x9c', '\x3b', '\x76',
    '\xec', '\x18', '\xc3', '\x31', '\x0a', '\xf1', '\xcc', '\x99',
    ...
    '\x6d', '\x5b'

data = QByteArray.fromRawData(mydata, sizeof(mydata))
in = QDataStream(data, QIODevice.ReadOnly)
...

警告

使用fromRawData()创建的字节数组不会以'\0'结尾，除非原始数据在位置size包含一个'\0'字节。虽然这对于QDataStream或像indexOf()这样的函数没有影响，但将字节数组传递给期望以'\0'结尾的const char *函数将会失败。

另请参阅

setRawData() data() constData()

static fromStdString(s)¶

Parameters:: s – 字符串
Return type:: QByteArray

返回一个作为QByteArray的str字符串的副本。

另请参阅

toStdString() fromStdString()

front()¶

Return type:: 整数

返回字节数组中的第一个字节。与at(0)相同。

此函数为STL兼容性提供。

警告

在空字节数组上调用此函数会导致未定义行为。

另请参阅

back() at() operator[]()

indexOf(bv[, from=0])¶

Parameters:

bv – QByteArrayView
from – 整数

Return type:

整数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回在此字节数组中，从索引位置 from 开始向前搜索，首次出现的由 bv 查看的字节序列的起始索引位置。如果未找到匹配项，则返回 -1。

示例：

x = QByteArray("sticky question")
y = QByteArrayView("sti")
x.indexOf(y) # returns 0
x.indexOf(y, 1) # returns 10
x.indexOf(y, 10) # returns 10
x.indexOf(y, 11) # returns -1

另请参阅

lastIndexOf() contains() count()

indexOf(c[, from=0])

Parameters:

c – 整数
from – 整数

Return type:

整数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

这是一个重载函数。

返回此字节数组中第一次出现的字节ch的起始索引位置，从索引位置from开始向前搜索。如果未找到匹配项，则返回-1。

示例：

ba = QByteArray("ABCBA")
ba.indexOf("B") # returns 1
ba.indexOf("B", 1) # returns 1
ba.indexOf("B", 2) # returns 3
ba.indexOf("X") # returns -1

另请参阅

lastIndexOf() contains()

insert(i, data)¶

Parameters:

i – 整数
data – QByteArrayView

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

在索引位置 i 插入 data 并返回对此字节数组的引用。

示例：

ba = QByteArray("Meal")
ba.insert(1, QByteArrayView("ontr"))
# ba == "Montreal"

对于大型字节数组，此操作可能会很慢（线性时间），因为它需要将索引i及以上的所有字节在内存中至少移动一个位置。

这个数组会增长以适应插入。如果 i 超出了数组的末尾，数组首先会用空格字符扩展以到达这个 i。

另请参阅

append() prepend() replace() remove()

insert(i, c)

Parameters:

i – 整数
c – 整数

Return type:

QByteArray

这是一个重载函数。

在字节数组的索引位置 i 插入字节 ch。

这个数组会增长以适应插入。如果 i 超出了数组的末尾，数组首先会用空格字符扩展到这个 i。

insert(i, data)

Parameters:

i – 整数
data – QByteArray

Return type:

QByteArray

在索引位置 i 插入 data 并返回对此字节数组的引用。

这个数组会增长以适应插入。如果i超出了数组的末尾，数组首先会用空格字符扩展以达到这个i。

另请参阅

append() prepend() replace() remove()

insert(i, s)

Parameters:

i – 整数
s – 字符串

Return type:

QByteArray

在索引位置 i 插入 s 并返回对此字节数组的引用。

这个数组会增长以适应插入。如果 i 超出了数组的末尾，数组首先会用空格字符扩展以到达这个 i。

该函数等同于 insert(i, QByteArrayView(s))

另请参阅

append() prepend() replace() remove()

insert(i, s, len)

Parameters:

i – 整数
s – 字符串
len – int

Return type:

QByteArray

这是一个重载函数。

在字节数组的位置 i 处插入从 data 开始的 len 字节。

这个数组会增长以适应插入。如果 i 超出了数组的末尾，数组首先会用空格字符扩展以到达这个 i。

insert(i, count, c)

Parameters:

i – 整数
count – int
c – 整数

Return type:

QByteArray

这是一个重载函数。

在字节数组的索引位置 i 插入 count 个字节 ch 的副本。

这个数组会增长以适应插入。如果 i 超出了数组的末尾，数组首先会用空格字符扩展以到达这个 i。

isEmpty()¶

Return type:: 布尔

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

如果字节数组的大小为0，则返回true；否则返回false。

示例：

QByteArray().isEmpty() # returns true
QByteArray("").isEmpty() # returns true
QByteArray("abc").isEmpty() # returns false

另请参阅

size()

isLower()¶

Return type:: 布尔

如果此字节数组为小写，则返回true，即如果它与toLower()折叠相同。

请注意，这并不意味着字节数组只包含小写字母；仅表示它不包含ASCII大写字母。

另请参阅

isUpper() toLower()

isNull()¶

Return type:: 布尔

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

如果这个字节数组为空，则返回true；否则返回false。

示例：

QByteArray().isNull() # returns true
QByteArray("").isNull() # returns false
QByteArray("abc").isNull() # returns false

由于历史原因，Qt 在空字节数组和空字节数组之间做出了区分。对于大多数应用程序来说，重要的是字节数组是否包含任何数据，这可以使用 isEmpty() 来确定。

另请参阅

isEmpty()

isSharedWith(other)¶

Parameters:: 其他 – QByteArray
Return type:: 布尔

isUpper()¶

Return type:: 布尔

如果此字节数组为大写，则返回true，即如果它与toUpper()折叠相同。

请注意，这并不意味着字节数组仅包含大写字母；仅表示它不包含ASCII小写字母。

另请参阅

isLower() toUpper()

isValidUtf8()¶

Return type:: 布尔

如果此字节数组包含有效的UTF-8编码数据，则返回true，否则返回false。

last(n)¶

Parameters:: n – 整数
Return type:: QByteArray

lastIndexOf(bv)¶

Parameters:: bv – QByteArrayView
Return type:: 整数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

这是一个重载函数。

返回此字节数组中由bv查看的字节序列最后一次出现的起始索引位置，从字节数组的末尾向后搜索。如果未找到匹配项，则返回-1。

示例：

x = QByteArray("crazy azimuths")
y = QByteArrayView("az")
x.lastIndexOf(y) # returns 6
x.lastIndexOf(y, 6) # returns 6
x.lastIndexOf(y, 5) # returns 2
x.lastIndexOf(y, 1) # returns -1

另请参阅

indexOf() contains() count()

lastIndexOf(bv, from)

Parameters:

bv – QByteArrayView
from – 整数

Return type:

整数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回此字节数组中由bv查看的字节序列最后一次出现的起始索引位置，从索引位置from向后搜索。

如果 from 是 -1，搜索从最后一个字符开始；如果是 -2，则从倒数第二个字符开始，依此类推。

如果没有找到匹配项，则返回-1。

示例：

x = QByteArray("crazy azimuths")
y = QByteArrayView("az")
x.lastIndexOf(y) # returns 6
x.lastIndexOf(y, 6) # returns 6
x.lastIndexOf(y, 5) # returns 2
x.lastIndexOf(y, 1) # returns -1

注意

当搜索长度为0的bv时，通过负的from将数据末尾的匹配排除在搜索之外，即使-1通常被认为是从字节数组的末尾开始搜索：末尾的匹配是在最后一个字符之后，因此被排除在外。要包含这样的最终空匹配，要么为from提供一个正值，要么完全省略from参数。

另请参阅

indexOf() contains() count()

lastIndexOf(c[, from=-1])

Parameters:

c – 整数
from – 整数

Return type:

整数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

这是一个重载函数。

返回此字节数组中最后一次出现的字节ch的起始索引位置，从索引位置from向后搜索。如果from为-1（默认值），则搜索从最后一个字节开始（在索引size() - 1处）。如果未找到匹配项，则返回-1。

示例：

ba = QByteArray("ABCBA")
ba.lastIndexOf("B") # returns 3
ba.lastIndexOf("B", 3) # returns 3
ba.lastIndexOf("B", 2) # returns 1
ba.lastIndexOf("X") # returns -1

另请参阅

indexOf() contains()

left(n)¶

Parameters:: n – 整数
Return type:: QByteArray

leftJustified(width[, fill=' '[, truncate=false]])¶

Parameters:

width – int
fill – int
truncate – 布尔值

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回一个大小为width的字节数组，该数组包含用fill字节填充的此字节数组。

如果 truncate 为 false 并且字节数组的 size() 大于 width，则返回的字节数组是该字节数组的副本。

如果 truncate 为真且字节数组的 size() 大于 width，则移除字节数组副本中位置 width 之后的任何字节，并返回该副本。

示例：

x = QByteArray("apple")
y = x.leftJustified(8, '.') # y == "apple..."

另请参阅

rightJustified()

length()¶

Return type:: 整数

与 size() 相同。

static maxSize()¶

Return type:: 整数

max_size()¶

Return type:: 整数

mid(index[, len=-1])¶

Parameters:

index – 整数
len – int

Return type:

QByteArray

static number(n[, base=10])¶

Parameters:

n – 整数
base – int

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回一个表示整个数字 n 的字节数组作为文本。

返回一个包含表示n的字符串的字节数组，使用指定的base（默认为十）。支持2到36的基数，对于超过9的数字使用字母表示：A表示十，B表示十一，依此类推。

示例：

n = 63
QByteArray.number(n) # returns "63"
QByteArray.number(n, 16) # returns "3f"
QByteArray.number(n, 16).toUpper() # returns "3F"

注意

数字的格式未本地化；无论用户的区域设置如何，都使用默认的C区域设置。使用QLocale来执行数字和字符串之间的区域感知转换。

另请参阅

setNum() toInt()

static number(n[, base=10])

Parameters:

n – 整数
base – int

Return type:

QByteArray

这是一个重载函数。

另请参阅

toLongLong()

static number(n[, format='g'[, precision=6]])

Parameters:

n – 浮点数
format – int
precision – int

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

这是一个重载函数。

返回一个表示浮点数 n 为文本的字节数组。

返回一个包含表示n的字符串的字节数组，具有给定的format和precision，其含义与number(double, char, int)相同。例如：

ba = QByteArray.number(12.3456, 'E', 3)
# ba == 1.235E+01
另请参阅

toDouble() FloatingPointPrecisionOption

__ne__(arg__1)¶

Parameters:: arg__1 – PyUnicode

__ne__(rhs)

Parameters:: rhs – QByteArray
Return type:: 布尔

这是一个重载函数。

如果字节数组 lhs 不等于字节数组 rhs，则返回 true；否则返回 false。

另请参阅

compare()

__ne__(lhs)

Parameters:: lhs – QByteArrayView
Return type:: 布尔

__ne__(rhs)

Parameters:: rhs – QByteArrayView
Return type:: 布尔

__ne__(lhs)

Parameters:: lhs – QChar
Return type:: 布尔

__ne__(rhs)

Parameters:: rhs – QChar
Return type:: 布尔

__ne__(lhs)

Parameters:: lhs – QLatin1String
Return type:: 布尔

__ne__(rhs)

Parameters:: rhs – QLatin1String
Return type:: 布尔

__ne__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__ne__(rhs)

Parameters:: rhs – 字符串
Return type:: 布尔

__ne__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__ne__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__add__(arg__1)¶

Parameters:: arg__1 – PyByteArray
Return type:: QByteArray

__add__(arg__1)

Parameters:: arg__1 – PyByteArray
Return type:: QByteArray

__add__(arg__1)

Parameters:: arg__1 – PyBytes

__add__(a2)

Parameters:: a2 – 整数
Return type:: QByteArray

这是一个重载函数。

返回一个字节数组，该数组是连接字节数组a1和字节a2的结果。

__add__(rhs)

Parameters:: rhs – 整数
Return type:: QByteArray

这是一个重载函数。

返回一个字节数组，该数组是连接字节数组a1和字节a2的结果。

__add__(a2)

Parameters:: a2 – QByteArray
Return type:: QByteArray

返回一个字节数组，该数组是连接字节数组 a1 和字节数组 a2 的结果。

另请参阅

operator+=()

__add__(rhs)

Parameters:: rhs – QByteArray
Return type:: QByteArray

返回一个字节数组，该数组是字节数组a1和字节数组a2连接的结果。

另请参阅

operator+=()

__add__(s)

Parameters:: s – 字符串
Return type:: 字符串

__add__(s)

Parameters:: s – 字符串
Return type:: 字符串

__add__(rhs)

Parameters:: rhs – str
Return type:: QByteArray

这是一个重载函数。

返回一个字节数组，该数组是连接字节数组 a1 和以 '\0' 结尾的字符串 a2 的结果。

__iadd__(arg__1)¶

Parameters:: arg__1 – PyByteArray
Return type:: QByteArray

__iadd__(a)

Parameters:: a – QByteArrayView
Return type:: QByteArray

__iadd__(c)

Parameters:: c – 整数
Return type:: QByteArray

这是一个重载函数。

将字节 ch 附加到此字节数组的末尾，并返回对此字节数组的引用。

__iadd__(a)

Parameters:: a – QByteArray
Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

将字节数组 ba 附加到此字节数组的末尾，并返回对此字节数组的引用。

示例：

x = QByteArray("free")
y = QByteArray("dom")
x += y
# x == "freedom"

如果要追加的字节数组不为空，则会执行数据的深拷贝，这需要线性时间。

此操作通常不会受到分配开销的影响，因为QByteArray在数据末尾预分配了额外的空间，以便在每次追加操作时无需重新分配即可增长。

另请参阅

append() prepend()

__lt__(arg__1)¶

Parameters:: arg__1 – PyUnicode

__lt__(rhs)

Parameters:: rhs – QByteArray
Return type:: 布尔

这是一个重载函数。

如果字节数组 lhs 在字典序上小于字节数组 rhs，则返回 true；否则返回 false。

另请参阅

compare()

__lt__(lhs)

Parameters:: lhs – QByteArrayView
Return type:: 布尔

__lt__(rhs)

Parameters:: rhs – QByteArrayView
Return type:: 布尔

__lt__(lhs)

Parameters:: lhs – QChar
Return type:: 布尔

__lt__(rhs)

Parameters:: rhs – QChar
Return type:: 布尔

__lt__(lhs)

Parameters:: lhs – QLatin1String
Return type:: 布尔

__lt__(rhs)

Parameters:: rhs – QLatin1String
Return type:: 布尔

__lt__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__lt__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__lt__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__lt__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__lt__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__le__(arg__1)¶

Parameters:: arg__1 – PyUnicode

__le__(rhs)

Parameters:: rhs – QByteArray
Return type:: 布尔

这是一个重载函数。

如果字节数组 lhs 在字典序上小于或等于字节数组 rhs，则返回 true；否则返回 false。

另请参阅

compare()

__le__(lhs)

Parameters:: lhs – QByteArrayView
Return type:: 布尔

__le__(rhs)

Parameters:: rhs – QByteArrayView
Return type:: 布尔

__le__(lhs)

Parameters:: lhs – QChar
Return type:: 布尔

__le__(rhs)

Parameters:: rhs – QChar
Return type:: 布尔

__le__(lhs)

Parameters:: lhs – QLatin1String
Return type:: 布尔

__le__(rhs)

Parameters:: rhs – QLatin1String
Return type:: 布尔

__le__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__le__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__le__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__le__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__eq__(arg__1)¶

Parameters:: arg__1 – PyUnicode

__eq__(rhs)

Parameters:: rhs – QByteArray
Return type:: 布尔

这是一个重载函数。

如果字节数组 lhs 等于字节数组 rhs，则返回 true；否则返回 false。

另请参阅

compare()

__eq__(lhs)

Parameters:: lhs – QByteArrayView
Return type:: 布尔

__eq__(rhs)

Parameters:: rhs – QByteArrayView
Return type:: 布尔

__eq__(lhs)

Parameters:: lhs – QChar
Return type:: 布尔

__eq__(rhs)

Parameters:: rhs – QChar
Return type:: 布尔

__eq__(lhs)

Parameters:: lhs – QLatin1String
Return type:: 布尔

__eq__(rhs)

Parameters:: rhs – QLatin1String
Return type:: 布尔

__eq__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__eq__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__eq__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__eq__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__gt__(arg__1)¶

Parameters:: arg__1 – PyUnicode

__gt__(rhs)

Parameters:: rhs – QByteArray
Return type:: 布尔

这是一个重载函数。

如果字节数组 lhs 在字典序上大于字节数组 rhs，则返回 true；否则返回 false。

另请参阅

compare()

__gt__(lhs)

Parameters:: lhs – QByteArrayView
Return type:: 布尔

__gt__(rhs)

Parameters:: rhs – QByteArrayView
Return type:: 布尔

__gt__(lhs)

Parameters:: lhs – QChar
Return type:: 布尔

__gt__(rhs)

Parameters:: rhs – QChar
Return type:: 布尔

__gt__(lhs)

Parameters:: lhs – QLatin1String
Return type:: 布尔

__gt__(rhs)

Parameters:: rhs – QLatin1String
Return type:: 布尔

__gt__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__gt__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__gt__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__gt__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__ge__(arg__1)¶

Parameters:: arg__1 – PyUnicode

__ge__(rhs)

Parameters:: rhs – QByteArray
Return type:: 布尔

这是一个重载函数。

如果字节数组 lhs 在字典顺序上大于或等于字节数组 rhs，则返回 true；否则返回 false。

另请参阅

compare()

__ge__(lhs)

Parameters:: lhs – QByteArrayView
Return type:: 布尔

__ge__(rhs)

Parameters:: rhs – QByteArrayView
Return type:: 布尔

__ge__(lhs)

Parameters:: lhs – QChar
Return type:: 布尔

__ge__(rhs)

Parameters:: rhs – QChar
Return type:: 布尔

__ge__(lhs)

Parameters:: lhs – QLatin1String
Return type:: 布尔

__ge__(rhs)

Parameters:: rhs – QLatin1String
Return type:: 布尔

__ge__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__ge__(rhs)

Parameters:: rhs – str
Return type:: 布尔

__ge__(lhs)

Parameters:: lhs – 字符串
Return type:: 布尔

__ge__(rhs)

Parameters:: rhs – str
Return type:: 布尔

operator(i)¶

Parameters:: i – 整数
Return type:: 整数

这是一个重载函数。

与 at(i) 相同。

percentDecoded([percent='%'])¶

Parameters:: 百分比 – 整数
Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

解码URI/URL风格的百分号编码。

返回一个包含解码文本的字节数组。percent参数允许使用不同于‘%’的字符（例如，‘_’或‘=’）作为转义字符。

例如：

encoded = QByteArray("Qt%20is%20great%33")
decoded = encoded.percentDecoded() # Set to "Qt is great!"

注意

给定无效的输入（例如包含序列“%G5”的字符串，这不是一个有效的十六进制数字），输出也将无效。例如：序列“%G5”可能被解码为‘W’。

另请参阅

toPercentEncoding() fromPercentEncoding()

prepend(a)¶

Parameters:: a – QByteArrayView
Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

将字节数组视图 ba 前置到此字节数组，并返回对此字节数组的引用。

此操作通常非常快（常数时间），因为QByteArray在数据开头预分配了额外的空间，因此它可以在每次增长时无需重新分配整个数组。

示例：

x = QByteArray("ship")
y = QByteArray("air")
x.prepend(y)
# x == "airship"

这与 insert(0, ba) 相同。

另请参阅

append() insert()

prepend(c)

Parameters:: c – 整数
Return type:: QByteArray

这是一个重载函数。

将字节 ch 添加到这个字节数组的前面。

prepend(a)

Parameters:: a – QByteArray
Return type:: QByteArray

这是一个重载函数。

将 ba 前置到此字节数组中。

prepend(s, len)

Parameters:

s – 字符串
len – int

Return type:

QByteArray

这是一个重载函数。

将起始于str的len字节预置到此字节数组中。预置的字节可能包含‘\0’字节。

prepend(count, c)

Parameters:

count – int
c – 整数

Return type:

QByteArray

这是一个重载函数。

将 count 个字节 ch 添加到这个字节数组的前面。

push_back(a)¶

Parameters:: a – QByteArrayView

这是一个重载函数。

与 append(str) 相同。

push_front(a)¶

Parameters:: a – QByteArrayView

这是一个重载函数。

与prepend(str)相同。

remove(index, len)¶

Parameters:

index – 整数
len – int

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

从数组中移除从索引位置 pos 开始的 len 字节，并返回对数组的引用。

如果pos超出范围，则不会发生任何变化。如果pos有效，但pos + len大于数组的大小，则数组将在位置pos处被截断。

示例：

ba = QByteArray("Montreal")
ba.remove(1, 4)
# ba == "Meal"

元素移除将保留数组的容量，不会减少分配的内存量。要在最后一次更改数组大小后释放额外的容量并尽可能释放内存，请在最后一次更改数组大小后调用squeeze()。

另请参阅

insert() replace() squeeze()

removeAt(pos)¶

Parameters:: pos – 整数
Return type:: QByteArray

移除索引 pos 处的字符。如果 pos 超出范围（即 pos >= size()），此函数不执行任何操作。

另请参阅

remove()

removeFirst()¶

Return type:: QByteArray

移除这个字节数组中的第一个字符。如果字节数组为空，此函数不执行任何操作。

另请参阅

remove()

removeLast()¶

Return type:: QByteArray

移除这个字节数组中的最后一个字符。如果字节数组为空，此函数不执行任何操作。

另请参阅

remove()

repeated(times)¶

Parameters:: times – int
Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回此字节数组重复指定次数的副本。

如果 times 小于 1，则返回一个空的字节数组。

示例：

ba = QByteArray("ab")
ba.repeated(4) # returns "abababab"

replace(before, after)¶

Parameters:

之前 – QByteArrayView
after – QByteArrayView

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

这是一个重载函数。

将每次出现的字节数组 before 替换为字节数组 after。

示例：

ba = QByteArray("colour behaviour flavour neighbour")
ba.replace(QByteArray("ou"), QByteArray("o"))
# ba == "color behavior flavor neighbor"

replace(before, after)

Parameters:

before – int
after – QByteArrayView

Return type:

QByteArray

这是一个重载函数。

将每次出现的字节 before 替换为字节数组 after。

replace(before, after)

Parameters:

before – int
after – int

Return type:

QByteArray

这是一个重载函数。

将每个出现的字节 before 替换为字节 after。

replace(index, len, s)

Parameters:

index – 整数
len – int
s – QByteArrayView

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

从索引位置 pos 开始，用字节数组 after 替换 len 字节，并返回对此字节数组的引用。

示例：

x = QByteArray("Say yes!")
y = QByteArray("no")
x.replace(4, 3, y)
# x == "Say no!"

另请参阅

insert() remove()

replace(before, bsize, after, asize)

Parameters:

before – str
bsize – int
after – str
asize – int

Return type:

QByteArray

这是一个重载函数。

将每个从before开始的bsize字节替换为从after开始的asize字节。由于字符串的大小由bsize和asize给出，它们可能包含‘\0’字节，并且不需要以‘\0’结尾。

replace(index, len, s, alen)

Parameters:

index – 整数
len – int
s – 字符串
alen – int

Return type:

QByteArray

这是一个重载函数。

从索引位置 pos 开始，用从位置 after 开始的 alen 字节替换 len 字节。插入的字节可能包括‘\0’字节。

reserve(size)¶

Parameters:: size – int

尝试为至少 size 字节分配内存。

如果你提前知道字节数组的大小，你可以调用这个函数，如果你经常调用resize()，你可能会获得更好的性能。

如果不确定需要多少空间，通常最好使用一个上限作为size，或者对最可能的大小进行高估，如果严格的上限比这个大得多的话。如果size被低估了，一旦超过预留的大小，数组将根据需要增长，这可能导致比您的最佳高估更大的分配，并且会减慢触发它的操作。

警告

reserve() 保留内存但不改变字节数组的大小。访问超出字节数组末尾的数据是未定义行为。如果你需要访问超出数组当前末尾的内存，请使用 resize() 。

此函数的唯一目的是提供一种微调QByteArray内存使用的方法。通常情况下，您很少需要调用此函数。

另请参阅

squeeze() capacity()

resize(size)¶

Parameters:: size – int

将字节数组的大小设置为size字节。

如果 size 大于当前大小，字节数组将被扩展为 size 字节，额外的字节将添加到末尾。新添加的字节是未初始化的。

如果 size 小于当前大小，则位置 size 之后的字节将从字节数组中排除。

注意

虽然 resize() 会在需要时增加容量，但它从不减少容量。要释放多余的容量，请使用 squeeze() 。

另请参阅

size() truncate() squeeze()

resize(size, c)

Parameters:

size – int
c – 整数

将字节数组的大小设置为newSize字节。

如果 newSize 大于当前大小，字节数组将被扩展为 newSize 字节，额外的字节将添加到末尾。新字节被初始化为 c。

如果 newSize 小于当前大小，则位置 newSize 之后的字节将从字节数组中排除。

注意

虽然 resize() 会在需要时增加容量，但它从不减少容量。要释放多余的容量，请使用 squeeze() 。

另请参阅

size() truncate() squeeze()

resizeForOverwrite(size)¶

Parameters:: size – int

将字节数组调整为size字节。如果字节数组的大小增加，新的字节将未初始化。

行为与resize(size)相同。

另请参阅

resize()

right(n)¶

Parameters:: n – 整数
Return type:: QByteArray

rightJustified(width[, fill=' '[, truncate=false]])¶

Parameters:

width – int
fill – int
truncate – 布尔值

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回一个大小为width的字节数组，该数组包含fill字节，后跟此字节数组。

如果 truncate 为 false 并且字节数组的大小超过 width，则返回的字节数组是该字节数组的副本。

如果 truncate 为 true 并且字节数组的大小超过 width，则结果字节数组将在位置 width 处被截断。

示例：

x = QByteArray("apple")
y = x.rightJustified(8, '.') # y == "...apple"

另请参阅

leftJustified()

setNum(n[, base=10])¶

Parameters:

n – 整数
base – int

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

将整数 n 表示为文本。

将此字节数组设置为表示n的字符串，基数为base（默认为十），并返回对此字节数组的引用。支持2到36的基数，使用字母表示超过9的数字；A表示十，B表示十一，依此类推。

示例：

ba = QByteArray()
n = 63
ba.setNum(n) # ba == "63"
ba.setNum(n, 16) # ba == "3f"

注意

数字的格式未本地化；无论用户的区域设置如何，都使用默认的C区域设置。使用QLocale来执行数字和字符串之间的区域感知转换。

另请参阅

number() toInt()

setNum(n[, base=10])

Parameters:

n – 整数
base – int

Return type:

QByteArray

这是一个重载函数。

另请参阅

toLongLong()

setNum(n[, format='g'[, precision=6]])

Parameters:

n – 浮点数
format – int
precision – int

Return type:

QByteArray

这是一个重载函数。

将浮点数 n 表示为文本。

将此字节数组设置为表示n的字符串，使用给定的format和precision（与number(double, char, int)的含义相同），并返回对此字节数组的引用。

另请参阅

toDouble() FloatingPointPrecisionOption

setRawData(a, n)¶

Parameters:

a – str
n – 整数

Return type:

QByteArray

重置QByteArray以使用data数组的前size字节。这些字节不会被复制。QByteArray将包含data指针。调用者保证只要这个QByteArray及其任何未修改的副本存在，data就不会被删除或修改。

此函数可以代替fromRawData()来重用现有的QByteArray对象，以节省内存重新分配。

另请参阅

fromRawData() data() constData()

shrink_to_fit()¶

此函数为STL兼容性提供。它等同于squeeze()。

simplified()¶

Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回此字节数组的副本，该副本已从开头和结尾删除空格字符，并且其中每个内部空格字符序列都被替换为单个空格。

间距字符是标准C++ isspace() 函数在C语言环境中返回 true 的字符；这些字符包括ASCII字符制表符‘\t’、换行符‘\n’、回车符‘\r’、垂直制表符‘\v’、换页符‘\f’和空格‘ ‘。

示例：

ba = QByteArray(" lots\t of\nwhitespace\r\n ")
ba = ba.simplified()
# ba == "lots of whitespace"
另请参阅

trimmed() SpecialCharacter Spacing Characters

size()¶

Return type:: 整数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回此字节数组中的字节数。

字节数组中的最后一个字节位于位置 size() - 1。此外，QByteArray 确保位置 size() 处的字节始终为 ‘\0’，因此您可以使用 data() 和 constData() 的返回值作为期望以 ‘\0’ 结尾的字符串的函数的参数。如果 QByteArray 对象是从不包括尾随 ‘\0’ 终止字节的 raw data 创建的，那么 QByteArray 不会自动添加它，除非创建了 deep copy。

示例：

ba = QByteArray("Hello")
n = ba.size() # n == 5
ba.data()[0] # returns 'H'
ba.data()[4] # returns 'o'
ba.data()[5] # returns '\0'

另请参阅

isEmpty() resize()

slice(pos)¶

Parameters:: pos – 整数
Return type:: QByteArray

这是一个重载函数。

修改此字节数组以从位置 pos 开始，延伸到其末尾，并返回对此字节数组的引用。

注意

如果 pos < 0 或 pos > size()，则行为未定义。

另请参阅

sliced() first() last() chopped() chop() truncate()

slice(pos, n)

Parameters:

pos – 整数
n – 整数

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

修改此字节数组以从位置 pos 开始，扩展 n 个字节，并返回对此字节数组的引用。

注意

如果 pos < 0, n < 0, 或者 pos + n > size()，则行为未定义。

示例：

x = "Five pineapples"_ba
x.slice(5) # x == "pineapples"
x.slice(4, 3) # x == "app"
另请参阅

sliced() first() last() chopped() chop() truncate()

sliced(pos)¶

Parameters:: pos – 整数
Return type:: QByteArray

sliced(pos, n)

Parameters:

pos – 整数
n – 整数

Return type:

QByteArray

split(sep)¶

Parameters:: sep – 整数
Return type:: .list of QByteArray

将字节数组在sep出现的地方分割成子数组，并返回这些数组的列表。如果sep在字节数组中没有匹配到任何地方，split() 返回包含此字节数组的单元素列表。

squeeze()¶

释放不需要用于存储数组数据的内存。

此函数的唯一目的是提供一种微调QByteArray内存使用的方法。通常情况下，您很少需要调用此函数。

另请参阅

reserve() capacity()

startsWith(bv)¶

Parameters:: bv – QByteArrayView
Return type:: 布尔

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

如果此字节数组以bv所查看的字节序列开头，则返回true；否则返回false。

示例：

url = QByteArray("ftp://ftp.qt-project.org/")
if url.startsWith("ftp:"):
    ...

另请参阅

endsWith() first()

startsWith(c)

Parameters:: c – 整数
Return type:: 布尔

这是一个重载函数。

如果此字节数组以字节 ch 开头，则返回 true；否则返回 false。

swap(other)¶

Parameters:: 其他 – QByteArray

将此字节数组与other字节数组交换。此操作非常快速且永远不会失败。

toBase64([options=QByteArray.Base64Option.Base64Encoding])¶

Parameters:: options – Base64Option 的组合
Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回字节数组的副本，使用选项 options 进行编码。

text = QByteArray("Qt is great!")
text.toBase64() # returns "UXQgaXMgZ3JlYXQh"
text = QByteArray("")
text.toBase64(QByteArray.Base64Encoding | QByteArray.OmitTrailingEquals) # returns "PHA+SGVsbG8/PC9wPg"
text.toBase64(QByteArray.Base64Encoding) # returns "PHA+SGVsbG8/PC9wPg=="
text.toBase64(QByteArray.Base64UrlEncoding) # returns "PHA-SGVsbG8_PC9wPg=="
text.toBase64(QByteArray.Base64UrlEncoding | QByteArray.OmitTrailingEquals) # returns "PHA-SGVsbG8_PC9wPg"

用于编码Base64数据的算法在RFC 4648中定义。

另请参阅

fromBase64()

toDouble()¶

Return type:: 浮点数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回转换为double值的字节数组。

如果转换溢出则返回无穷大，如果由于其他原因（例如下溢）导致转换失败则返回0.0。

如果 ok 不是 None，则通过将 *``ok`` 设置为 false 来报告失败，通过将 *``ok`` 设置为 true 来报告成功。

string = QByteArray("1234.56")
ok = bool()
a = string.toDouble(ok) # a == 1234.56, ok == true
string = "1234.56 Volt"
a = str.toDouble(ok) # a == 0, ok == false

警告

QByteArray 内容可能只包含有效的数字字符，包括正负号、科学计数法中使用的字符 e 和小数点。包含单位或额外字符会导致转换错误。

注意

数字的转换是在默认的C语言环境中执行的，不考虑用户的语言环境。使用QLocale来执行数字和字符串之间的本地化转换。

此函数忽略前导和尾随的空白字符。

另请参阅

number()

toFloat()¶

Return type:: 浮点数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回转换为float值的字节数组。

如果转换溢出则返回无穷大，如果由于其他原因（例如下溢）导致转换失败则返回0.0。

如果 ok 不是 None，则通过将 *``ok`` 设置为 false 来报告失败，通过将 *``ok`` 设置为 true 来报告成功。

string = QByteArray("1234.56")
ok = bool()
a = string.toFloat(ok) # a == 1234.56, ok == true
string = "1234.56 Volt"
a = str.toFloat(ok) # a == 0, ok == false

警告

QByteArray 内容可能只包含有效的数字字符，包括正负号、科学计数法中使用的字符 e 和小数点。包含单位或额外字符会导致转换错误。

注意

数字的转换是在默认的C语言环境中执行的，不考虑用户的语言环境。使用QLocale来执行数字和字符串之间的本地化转换。

此函数忽略前导和尾随的空白字符。

另请参阅

number()

toHex([separator='\0'])¶

Parameters:: separator – 整数
Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回字节数组的十六进制编码副本。

十六进制编码使用数字0-9和字母a-f。

如果 separator 不是 ‘\0’，则分隔符字符会插入到十六进制字节之间。

示例：

macAddress = QByteArray.fromHex("123456abcdef")
macAddress.toHex(':') # returns "12:34:56:ab:cd:ef"
macAddress.toHex(0) # returns "123456abcdef"

另请参阅

fromHex()

toInt([base=10])¶

Parameters:: base – 整数
Return type:: 整数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回将字节数组转换为int的结果，使用基数base，默认为十。支持基数0和2到36，使用字母表示超过9的数字；A表示十，B表示十一，依此类推。

如果 base 为 0，则根据以下规则自动确定基数：如果字节数组以“0x”开头，则假定为十六进制（基数 16）；否则，如果以“0b”开头，则假定为二进制（基数 2）；否则，如果以“0”开头，则假定为八进制（基数 8）；否则假定为十进制。

如果转换失败，返回0。

如果 ok 不是 None，则通过将 *``ok`` 设置为 false 来报告失败，通过将 *``ok`` 设置为 true 来报告成功。

str = QByteArray("FF")
ok = bool()
hex = str.toInt(ok, 16) # hex == 255, ok == true
dec = str.toInt(ok, 10) # dec == 0, ok == false

注意

数字的转换是在默认的C语言环境中执行的，不考虑用户的语言环境。使用QLocale来执行数字和字符串之间的本地化转换。

注意

对“0b”前缀的支持在Qt 6.4中已添加。

另请参阅

number()

toLong([base=10])¶

Parameters:: base – 整数
Return type:: 整数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回将字节数组转换为long整数的结果，默认使用基数base为10。支持基数0和2到36，对于超过9的数字使用字母表示；A表示10，B表示11，依此类推。

如果转换失败，返回0。

如果 ok 不是 None，则通过将 *``ok`` 设置为 false 来报告失败，通过将 *``ok`` 设置为 true 来报告成功。

str = QByteArray("FF")
ok = bool()
hex = str.toLong(ok, 16) # hex == 255, ok == true
dec = str.toLong(ok, 10) # dec == 0, ok == false

注意

数字的转换是在默认的C语言环境中执行的，不考虑用户的语言环境。使用QLocale来执行数字和字符串之间的本地化转换。

注意

对“0b”前缀的支持在Qt 6.4中已添加。

另请参阅

number()

toLongLong([base=10])¶

Parameters:: base – 整数
Return type:: 整数

返回将字节数组转换为long long的结果，使用基数base，默认基数为10。支持基数0和2到36，对于超过9的数字使用字母表示；A表示10，B表示11，依此类推。

如果转换失败，返回0。

如果 ok 不是 None，则通过将 *``ok`` 设置为 false 来报告失败，通过将 *``ok`` 设置为 true 来报告成功。

注意

数字的转换是在默认的C语言环境中执行的，不考虑用户的语言环境。使用QLocale来执行数字和字符串之间的本地化转换。

注意

对“0b”前缀的支持在Qt 6.4中已添加。

另请参阅

number()

toLower()¶

Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回字节数组的副本，其中每个ASCII大写字母转换为小写字母。

示例：

x = QByteArray("Qt by THE QT COMPANY")
y = x.toLower()
# y == "qt by the qt company"

另请参阅

isLower() toUpper() Character Case

toPercentEncoding([exclude=QByteArray()[, include=QByteArray()[, percent='%']]])¶

Parameters:

exclude – QByteArray
include – QByteArray
percent – int

Return type:

QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回此字节数组的URI/URL风格的百分号编码副本。percent参数允许您用另一个字符覆盖默认的‘%’字符。

默认情况下，此函数将编码所有不属于以下内容的字节：

ALPHA（“a”到“z”和“A”到“Z”）/ DIGIT（0到9）/ “-” / “.” / “_” / “~”

为了防止字节被编码，请将它们传递给exclude。为了强制字节被编码，请将它们传递给include。percent字符总是被编码。

示例：

QByteArray text = "{a fishy string?}"
QByteArray ba = text.toPercentEncoding("{}", "s")
qDebug("%s", ba.constData())
# prints "{a fi%73hy %73tring%3F}"

十六进制编码使用数字0-9和大写字母A-F。

另请参阅

fromPercentEncoding() toPercentEncoding()

toShort([base=10])¶

Parameters:: base – 整数
Return type:: 整数

返回将字节数组转换为short的值，使用基数base，默认基数为10。支持基数0和2到36，对于超过9的数字使用字母表示；A表示10，B表示11，依此类推。

如果转换失败，返回0。

如果 ok 不是 None，则通过将 *``ok`` 设置为 false 来报告失败，通过将 *``ok`` 设置为 true 来报告成功。

注意

数字的转换是在默认的C语言环境中执行的，不考虑用户的语言环境。使用QLocale来执行数字和字符串之间的本地化转换。

注意

对“0b”前缀的支持在Qt 6.4中已添加。

另请参阅

number()

toStdString()¶

Return type:: 字符串

返回一个包含此QByteArray中数据的std::string对象。

此运算符主要用于将QByteArray传递给接受std::string对象的函数。

另请参阅

fromStdString() toStdString()

toUInt([base=10])¶

Parameters:: base – 整数
Return type:: 整数

返回将字节数组转换为unsigned int的结果，使用基数base，默认基数为十。支持基数0和2到36，使用字母表示超过9的数字；A表示十，B表示十一，依此类推。

如果转换失败，返回0。

如果 ok 不是 None，则通过将 *``ok`` 设置为 false 来报告失败，通过将 *``ok`` 设置为 true 来报告成功。

注意

数字的转换是在默认的C语言环境中执行的，不考虑用户的语言环境。使用QLocale来执行数字和字符串之间的本地化转换。

注意

对“0b”前缀的支持在Qt 6.4中已添加。

另请参阅

number()

toULong([base=10])¶

Parameters:: base – 整数
Return type:: 整数

返回将字节数组转换为unsigned long int的结果，使用基数base，默认基数为10。支持基数0和2到36，使用字母表示超过9的数字；A表示10，B表示11，依此类推。

如果转换失败，返回0。

如果 ok 不是 None，则通过将 *``ok`` 设置为 false 来报告失败，通过将 *``ok`` 设置为 true 来报告成功。

注意

数字的转换是在默认的C语言环境中执行的，不考虑用户的语言环境。使用QLocale来执行数字和字符串之间的本地化转换。

注意

对“0b”前缀的支持在Qt 6.4中已添加。

另请参阅

number()

toULongLong([base=10])¶

Parameters:: base – 整数
Return type:: 整数

返回将字节数组转换为unsigned long long的结果，使用基数base，默认值为10。支持基数0和2到36，使用字母表示超过9的数字；A表示10，B表示11，依此类推。

如果转换失败，返回0。

如果 ok 不是 None，则通过将 *``ok`` 设置为 false 来报告失败，通过将 *``ok`` 设置为 true 来报告成功。

注意

数字的转换是在默认的C语言环境中执行的，不考虑用户的语言环境。使用QLocale来执行数字和字符串之间的本地化转换。

注意

对“0b”前缀的支持在Qt 6.4中已添加。

另请参阅

number()

toUShort([base=10])¶

Parameters:: base – 整数
Return type:: 整数

返回将字节数组转换为unsigned short的结果，使用基数base，默认为十。支持基数0和2到36，使用字母表示超过9的数字；A表示十，B表示十一，依此类推。

如果转换失败，返回0。

如果 ok 不是 None，则通过将 *``ok`` 设置为 false 来报告失败，通过将 *``ok`` 设置为 true 来报告成功。

注意

数字的转换是在默认的C语言环境中执行的，不考虑用户的语言环境。使用QLocale来执行数字和字符串之间的本地化转换。

注意

对“0b”前缀的支持在Qt 6.4中已添加。

另请参阅

number()

toUpper()¶

Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回字节数组的副本，其中每个ASCII小写字母转换为大写。

示例：

x = QByteArray("Qt by THE QT COMPANY")
y = x.toUpper()
# y == "QT BY THE QT COMPANY"

另请参阅

isUpper() toLower() Character Case

trimmed()¶

Return type:: QByteArray

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

返回此字节数组的副本，其中已移除开头和结尾的空白字符。

示例：

ba = QByteArray(" lots\t of\nwhitespace\r\n ")
ba = ba.trimmed()
# ba == "lots\t of\nwhitespace"

与simplified()不同，trimmed()保持内部间距不变。

另请参阅

simplified() SpecialCharacter Spacing Characters

truncate(pos)¶

Parameters:: pos – 整数

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

在索引位置 pos 处截断字节数组。

如果 pos 超出数组的末尾，则不会发生任何操作。

示例：

ba = QByteArray("Stockholm")
ba.truncate(5) # ba == "Stock"
另请参阅

chop() resize() first()

class FromBase64Result¶

FromBase64Result 类保存了对 fromBase64Encoding 调用的结果。更多_…

概要¶

方法¶

def __ne__()
def __mul__()
def __eq__()
def swap()

注意

详细描述¶

警告

本节包含从C++自动翻译到Python的代码片段，可能包含错误。

此类的对象可用于检查转换是否成功，如果成功，则检索解码的QByteArray。为FromBase64Result定义的转换运算符使其使用变得简单直接：

def process():
if auto result = QByteArray.fromBase64Encoding(encodedData):
    process(result)

或者，可以直接访问转换状态和解码数据：

result = QByteArray.fromBase64Encoding(encodedData)
if result.decodingStatus == QByteArray.Base64DecodingStatus.Ok:
    process(result.decoded)

另请参阅

fromBase64

PySide6.QtCore.QByteArray.FromBase64Result.decoded¶

PySide6.QtCore.QByteArray.FromBase64Result.decodingStatus¶

__ne__(rhs)¶

Parameters:: rhs – FromBase64Result
Return type:: 布尔

如果 lhs 和 rhs 不同，则返回 true，否则返回 false。

__mul__()¶

Return type:: QByteArray

返回解码后的字节数组。

__eq__(rhs)¶

Parameters:: rhs – FromBase64Result
Return type:: 布尔

如果 lhs 和 rhs 相等，则返回 true，否则返回 false。

lhs 和 rhs 相等当且仅当它们包含相同的解码状态，并且如果状态为 QByteArray::Base64DecodingStatus::Ok，当且仅当它们包含相同的解码数据。

swap(other)¶

Parameters:: 其他 – FromBase64Result