返回顶部

class QByteArray#

类 QByteArray 提供了一个字节数组。详情...

概要

方法

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

静态函数#

定义 fromBase64()
定义 fromBase64Encoding()
定义 fromHex()
定义 fromPercentEncoding()
定义 fromRawData()
定义 fromStdString()
定义 number()

注意

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

详细描述#

警告

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

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

除了 QByteArray 之外，Qt 还提供了 QString 类来存储字符串数据。对于大多数情况，您应该使用 QString 类。它将内容理解为 Unicode 文本（使用 UTF-16 编码），而 QByteArray 则旨在避免对其存储的字节的编码或语义的假设（除了少数使用 ASCII 的遗留情况）。此外，QString 在整个 Qt API 中都被使用。在以下两种情况下使用 QByteArray 是合适的：您需要存储原始二进制数据，或者当内存保护至关重要时（例如，使用嵌入式 Linux 的 Qt）。

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

ba = QByteArray("Hello")

尽管 size() 是 5，但字节数组在末尾还维护一个额外的 '\0' 字节，因此如果使用一个请求到基础数据指针的函数（例如调用 data()），则指向的数据保证以 '\0' 结尾。

QByteArray 将对 const char * 数据执行深度复制，因此您可以在稍后修改它而不用担心副作用。（如果出于性能原因，您不想对数据进行深度复制，请改用 fromRawData()。）

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

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()可能比操作符[]()更快，因为它永远不会引起隐式共享发生。

要一次提取多个字节，请使用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 创建的。由 QByteArray 自动提供的这个 '0' 字节不计入 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 will 扩大到它所立即需要的空间以上，以便在没有重新分配直到数组大小显著增加之前还能够进一步扩展。

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 = j + 1

如果您只想检查 QByteArray 是否包含特定字节序列，请使用 contains() . 如果您想知道特定字节序列在字节数组中出现的次数，请使用 count() . 如果您想将特定值的所有出现替换为另一个值，请使用其中两个参数的重载函数 replace() .

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

由于历史原因，QByteArray 之间有一个区别：null 字节数组和空字节数组。一个“null”字节数组是一个使用 QByteArray 的默认构造函数初始化的字节数组，或者通过将 (const char *)0 传递给构造函数来初始化。一个“empty”字节数组是指具有大小 0 的任何字节数组。null 字节数组始终为空，但空字节数组不一定是 null。

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() 之外的所有函数都将 null 字节数组视为与空字节数组相同。例如，data() 返回一个有效的指针（不是 nullptr）指向 null 字节数组的 '\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 locale和ASCII函数#

QByteArray 通常将数据作为字节处理，不假设任何语义；在它假设语义的地方，它使用 C locale和ASCII 编码。标准Unicode编码由 QString 支持，其他编码可以使用 QStringEncoder 和 QStringDecoder 来转换为Unicode。对于文本的locale特定解释，请使用 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

(默认) 保留编码数据末尾的尾随等号填充，所以数据大小总是4的倍数。

QByteArray.OmitTrailingEquals

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

QByteArray.IgnoreBase64DecodingErrors

解码Base64编码的数据时，忽略输入错误；无效字符将被简单跳过。本枚举值自Qt 5.15版开始添加。

QByteArray.AbortOnBase64DecodingErrors

解码Base64编码的数据时，在第一个解码错误处停止。本枚举值自Qt 5.15版开始添加。

常量	描述
QByteArray.Base64Encoding	(默认) 常规Base64字母表，称为“base64”
QByteArray.Base64UrlEncoding	一个备选字母表，称为“base64url”，它更换了字母表中的两个字符，使其对URL更友好。
QByteArray.KeepTrailingEquals	(默认) 保留编码数据末尾的尾随等号填充，所以数据大小总是4的倍数。
QByteArray.OmitTrailingEquals	编码数据末尾省略添加了填充等号。
QByteArray.IgnoreBase64DecodingErrors	解码Base64编码的数据时，忽略输入错误；无效字符将被简单跳过。本枚举值自Qt 5.15版开始添加。
QByteArray.AbortOnBase64DecodingErrors	解码Base64编码的数据时，在第一个解码错误处停止。本枚举值自Qt 5.15版开始添加。

fromBase64Encoding() 和 fromBase64() 忽略 KeepTrailingEquals 和 OmitTrailingEquals 选项。如果指定了 IgnoreBase64DecodingErrors 选项，则不会标记可能的错误，例如如果尾部缺少等号或等号过多。相反，如果指定了 AbortOnBase64DecodingErrors，则输入必须没有填充或拥有正确数量的等号。

class Base64DecodingStatus#

__init__(arg__1)#

参数：: arg__1 – PyByteArray

__init__()

构造一个空的字节数组。

另请参阅

isEmpty()

__init__(size, c)

参数：

size – int
c – int

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

另请参阅

fill()

__init__(arg__1[, size=-1])

参数：

arg__1 – str
size – int

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

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

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

QByteArray 对字符串数据进行了深拷贝。

另请参阅

fromRawData()

__init__(arg__1)

参数：: arg__1 – PyBytes

__init__(arg__1)

参数：: arg__1 – QByteArray

构造一个 other 的副本。

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

另请参阅

operator=()

__getitem__()#

__len__()#

__mgetitem__()#

__msetitem__()#

__reduce__()#

返回类型:: 对象

__repr__()#

返回类型:: 对象

__setitem__()#

__str__()#

返回类型:: 对象

append(s, len)#

参数：

s – 字符串
len – 整数

返回类型:

QByteArray

这是一个重载函数。

将 str 中的前 len 个字节追加到此字节数组中，并返回对此字节数组的引用。追加的字节可能包括 '\0' 字节。

如果 len 为负，则假定 str 是 '\0' 结束的字符串，并使用 qstrlen() 自动确定要复制的长度。

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

append(count, c)

参数：

count – 整数
c – int

返回类型:

QByteArray

这是一个重载函数。

将字节 ch 的计数副本来追加到此字节数组中，并返回对此字节数组的引用。

如果 count 为负数或零，则不会将任何内容添加到字节数组中。

append(a)

参数：: a – QByteArray
返回类型:: 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(c)

参数：: c – int
返回类型:: QByteArray

这是一个重载函数。

将字节数据 ch 添加到字节数组。

append(a)

参数：: a – QByteArrayView
返回类型:: QByteArray

这是一个重载函数。

将数据 data 添加到字节数组。

assign(v)#

参数：: v – QByteArrayView
返回类型:: QByteArray

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

字节数组的长度将与 v 的长度相等。

此函数仅当 v 的长度超过字节数组的容量或字节数组是共享的时候才会分配内存。

assign(n, c)

参数：

n – int
c – int

返回类型:

QByteArray

用“n”个“c”的内容替换这个字节数组的内容，并返回对这个字节数组的引用。

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

如果“n”超过这个字节数组的容量或这个字节数组是共享的，这个函数将只分配内存。

另请参阅

fill()

at(i)#

参数：: i – int
返回类型:: int

返回字节数组中索引位置为“i”的字节。

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

另请参阅

operator[]()

back()#

返回类型:: int

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

此函数提供以支持STL兼容性。

警告

对一个空字节数组调用此函数构成未定义的行为。

另请参阅

front() at() operator[]()

capacity()#

返回类型:: int

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

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

注意

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

注意

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

另请参阅

reserve() squeeze()

cbegin()#

返回类型:: str

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

警告

返回的迭代器在断开连接或当 QByteArray 被修改时失效。

另请参阅

begin() cend()

cend()#

返回类型:: str

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

警告

返回的迭代器在断开连接或当 QByteArray 被修改时失效。

另请参阅

cbegin() end()

chop(n)#

参数：: n – int

警告

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

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

如果 n 大于 size() , 那么结果是一个空的白字节数组。

示例

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

truncate() resize() first()

chopped(len)#

参数：: len – 整数
返回类型:: QByteArray

clear()#

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

另请参阅

resize() isNull()

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

参数：

a – QByteArrayView
cs – CaseSensitivity

返回类型:

int

根据此 QByteArray 是否在 QByteArrayView bv 之前、相同位置或在之后排序，返回小于、等于或大于零的整数。比较按照敏感程度 cs 进行。

另请参阅

operator== 字符大小

contains(bv)#

参数：: bv – QByteArrayView
返回类型:: bool

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

另请参阅

indexOf() count()

contains(c)

参数：: c – int
返回类型:: bool

这是一个重载函数。

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

count()#

返回类型:: int

注意

此函数已弃用。

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

这是一个重载函数。

与 size() 相同。

count(bv)

参数：: bv – QByteArrayView
返回类型:: int

返回此字节数组中由 bv 观看的字节序列（可能重叠）的实例数量。

另请参阅

contains() indexOf()

count(c)

参数：: c – int
返回类型:: int

这是一个重载函数。

返回字节数组中字节 ch 的实例数量。

另请参阅

contains() indexOf()

data()#

返回类型:: str

这是一个重载函数。

endsWith(bv)#

参数：: bv – QByteArrayView
返回类型:: bool

警告

本节包含自动从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)

参数：: c – int
返回类型:: bool

这是一个重载函数。

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

erase(first, last)#

参数：

first – 字符串
last – 字符串

返回类型:

char

erase(it)

参数：: it – 字符串
返回类型:: char

从字节数组中删除由 it 表示的字符。返回指向删除字符后立即的字符的迭代器。

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

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

参数：

c – int
size – int

返回类型:

QByteArray

警告

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

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

示例

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

另请参阅

resize()

first(n)#

参数：: n – int
返回类型:: QByteArray

静态fromBase64(base64[, options=QByteArray.Base64Option.Base64Encoding])#

参数：

base64 – QByteArray
options – Base64Option 的组合

返回类型:

QByteArray

警告

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

使用定义在 options 中的选项，返回 base64 数组的解码副本。如果 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 定义。

返回解码的数据，或者如果传入 options 的 AbortOnBase64DecodingErrors 选项并传入无效的输入数据，返回空字节数组。

注意

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

另请参阅

toBase64() fromBase64Encoding()

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

参数：

base64 – QByteArray
options – Base64Option 的组合

返回类型:

从Base64结果

static fromHex(hexEncoded)#

参数：: hexEncoded – QByteArray
返回类型:: QByteArray

警告

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

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

例如

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

另请参阅

toHex()

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

参数：

pctEncoded – QByteArray
percent – int

返回类型:

QByteArray

警告

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

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

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

例如

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

另请参阅

percentDecoded()

静态 fromRawData(data, size)#

参数：

data – 字符串
size – int

返回类型:

QByteArray

警告

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

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

如果尝试修改由此返回的 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)#

参数：: s – 字符串
返回类型:: QByteArray

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

另请参阅

toStdString() fromStdString()

front()#

返回类型:: int

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

此函数提供以支持STL兼容性。

警告

对一个空字节数组调用此函数构成未定义的行为。

另请参阅

back() at() operator[]()

indexOf(bv[, from=0])#

参数：

bv – QByteArrayView
from – int

返回类型:

int

警告

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

返回这个字节数组中由bv查看的连续字节的起始索引位置，从索引位置from向前搜索。如果没有找到匹配项，返回-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])

参数：

c – int
from – int

返回类型:

int

警告

本节包含自动从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, s, len)#

参数：

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

返回类型:

QByteArray

这是一个重载函数。

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

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

insert(i, count, c)

参数：

i – int
count – 整数
c – int

返回类型:

QByteArray

这是一个重载函数。

在字节数组的第 i 位置插入 count 个字节 ch 的拷贝。

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

insert(i, s)

参数：

i – int
s – 字符串

返回类型:

QByteArray

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

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

此函数等价于 insert(i, QByteArrayView(s))

另请参阅

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

insert(i, data)

参数：

i – int
data – QByteArray

返回类型:

QByteArray

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

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

另请参阅

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

insert(i, c)

参数：

i – int
c – int

返回类型:

QByteArray

这是一个重载函数。

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

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

insert(i, data)

参数：

i – int
data – QByteArrayView

返回类型:

QByteArray

警告

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

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

示例

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

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

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

另请参阅

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

isEmpty()#

返回类型:: bool

警告

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

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

示例

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

另请参阅

size()

isLower()#

返回类型:: bool

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

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

另请参阅

isUpper() toLower()

isNull()#

返回类型:: bool

警告

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

如果此字节数组为空；否则返回 false。

示例

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

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

另请参阅

isEmpty()

isSharedWith(other)#

参数：: other – QByteArray
返回类型:: bool

isUpper()#

返回类型:: bool

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

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

另请参阅

isLower() toUpper()

isValidUtf8()#

返回类型:: bool

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

last(n)#

参数：: n – int
返回类型:: QByteArray

lastIndexOf(bv, from)#

参数：

bv – QByteArrayView
from – int

返回类型:

int

警告

本节包含自动从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，即使通常会认为从字节数组的末尾搜索，搜索也会排除数据的末尾的匹配项。匹配项位于最后一个字符之后，因此被排除。要包括这样的最终空匹配项，可以为from提供正值，或者完全省略from参数。

另请参阅

indexOf() contains() count()

lastIndexOf(c[, from=-1])

参数：

c – int
from – int

返回类型:

int

警告

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

这是一个重载函数。

返回从头到指定位置的%bytearray}s中字节ch最后一个出现的位置。如果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()

lastIndexOf(bv)

参数：: bv – QByteArrayView
返回类型:: int

警告

本节包含自动从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()

left(n)#

参数：: n – int
返回类型:: QByteArray

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

参数：

width – int
fill – int
truncate – bool

返回类型:

QByteArray

警告

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

返回一个大小为width的字节数组，其中包含用fill字节填充的当前字节数组。

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

如果truncate为true且字节数组的size()大于width，则从位置width之后的所有字节将移除，并且返回该副本。

示例

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

另请参阅

rightJustified()

length()#

返回类型:: int

与 size() 相同。

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

参数：

index – int
len – 整数

返回类型:

QByteArray

static number(arg__1[, base=10])#

参数：

arg__1 – int
base – int

返回类型:

QByteArray

这是一个重载函数。

另请参阅

toLongLong()

static number(arg__1[, base=10])

参数：

arg__1 – int
base – int

返回类型:

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()

静态 number(arg__1[, format='g'[, precision=6]])

参数：

arg__1 – float
format – int
precision – int

返回类型:

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)#

参数：: arg__1 – PyUnicode

__ne__(a2)

参数：: a2 – QByteArray
返回类型:: bool

这是一个重载函数。

如果字节数组 a1 与字节数组 a2 不相等，则返回 true；否则返回 false。

另请参阅

compare()

__ne__(s2)

参数：: – str
返回类型:: bool

如果此字节数组不等于字符串 str 的 UTF-8 编码，则返回 true；否则返回 false。

比较是区分大小写的。

您可以在编译应用程序时通过定义 QT_NO_CAST_FROM_ASCII 来禁用此运算符。然后，如果要在比较之前将字节数组转换为 QString，则需要显式调用 fromUtf8()、fromLatin1() 或 fromLocal8Bit()。

__add__(rhs)#

参数：: rhs – str
返回类型:: QByteArray

这是一个重载函数。

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

__add__(s)

参数：: s – 字符串
返回类型:: str

__add__(s)

参数：: s – 字符串
返回类型:: str

__add__(rhs)

参数：: rhs – QByteArray
返回类型:: QByteArray

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

另请参阅

operator+=()

__add__(a2)

参数：: a2 – QByteArray
返回类型:: QByteArray

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

另请参阅

operator+=()

__add__(a2)

参数：: a2 – 整数
返回类型:: QByteArray

这是一个重载函数。

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

__add__(rhs)

参数：: rhs – 整数
返回类型:: QByteArray

这是一个重载函数。

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

__add__(arg__1)

参数：: arg__1 – PyByteArray
返回类型:: QByteArray

__add__(arg__1)

参数：: arg__1 – PyBytes

__add__(arg__1)

参数：: arg__1 – PyByteArray
返回类型:: QByteArray

__iadd__(arg__1)#

参数：: arg__1 – PyByteArray
返回类型:: QByteArray

__iadd__(a)

参数：: a – QByteArrayView
返回类型:: QByteArray

__iadd__(c)

参数：: c – int
返回类型:: QByteArray

这是一个重载函数。

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

__iadd__(a)

参数：: a – QByteArray
返回类型:: QByteArray

警告

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

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

示例

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

如果被添加的字节数组不为空，将执行数据深度复制，耗时线性时间。

此操作通常不会受到分配开销的影响，因为 QByteArray 会在数据末尾预分配额外的空间，以便它可以在无需重新分配的情况下增长。

另请参阅

append() prepend()

__lt__(arg__1)#

参数：: arg__1 – PyUnicode

__lt__(a2)

参数：: a2 – QByteArray
返回类型:: bool

这是一个重载函数。

如果字节数组 a1 在词典上小于字节数组 a2，则返回 true；否则返回 false。

另请参阅

compare()

__lt__(s2)

参数：: – str
返回类型:: bool

如果此字节数组在词典上小于字符串 str 的 UTF-8 编码，则返回 true；否则返回 false。

比较是区分大小写的。

__lt__(a2)

参数：: a2 – 字符串
返回类型:: bool

这是一个重载函数。

如果字节数组 a1 在词典上小于以‘\0’结尾的字符串 a2，则返回 true；否则返回 false。

另请参阅

compare()

__le__(arg__1)#

参数：: arg__1 – PyUnicode

__le__(s2)

参数：: – str
返回类型:: bool

如果此字节数组在字典顺序上小于或等于字符串的UTF-8编码，返回 true；否则返回 false。

比较是区分大小写的。

__le__(a2)

参数：: a2 – QByteArray
返回类型:: bool

这是一个重载函数。

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

另请参阅

compare()

__eq__(arg__1)#

参数：: arg__1 – PyUnicode

__eq__(a2)

参数：: a2 – QByteArray
返回类型:: bool

这是一个重载函数。

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

另请参阅

compare()

__eq__(s2)

参数：: – str
返回类型:: bool

如果此字节数组等于字符串的UTF-8编码，返回 true；否则返回 false。

比较是区分大小写的。

__gt__(arg__1)#

参数：: arg__1 – PyUnicode

__gt__(a2)

参数：: a2 – QByteArray
返回类型:: bool

这是一个重载函数。

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

另请参阅

compare()

__gt__(s2)

参数：: – str
返回类型:: bool

如果此字节数组在字典顺序上大于字符串的UTF-8编码，返回 true；否则返回 false。

比较是区分大小写的。

__ge__(arg__1)#

参数：: arg__1 – PyUnicode

__ge__(s2)

参数：: – str
返回类型:: bool

如果此字节数组大于或等于字符串的UTF-8编码，返回 true；否则返回 false。

比较是区分大小写的。

__ge__(a2)

参数：: a2 – QByteArray
返回类型:: bool

这是一个重载函数。

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

另请参阅

compare()

操作符(i)#

参数：: i – int
返回类型:: int

这是一个重载函数。

等同于 at(i).

percentDecoded([percent='%'])#

参数：: percent – int
返回类型:: 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)#

参数：: a – QByteArrayView
返回类型:: QByteArray

警告

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

将字节数组视图 ba 插入此字节数组之前，并返回对此字节数组的引用。

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

示例

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

这等同于 insert(0, ba).

另请参阅

append() insert()

prepend(c)

参数：: c – int
返回类型:: QByteArray

这是一个重载函数。

将字节数据 ch 插入到该字节数组之前。

prepend(a)

参数：: a – QByteArray
返回类型:: QByteArray

这是一个重载函数。

将 ba 插入到该字节数组之前。

prepend(s, len)

参数：

s – 字符串
len – 整数

返回类型:

QByteArray

这是一个重载函数。

从 str 的起始处插入 len 字节到这个字节数组。预插入的字节可以包括‘\0’字节。

prepend(count, c)

参数：

count – 整数
c – int

返回类型:

QByteArray

这是一个重载函数。

从字节集数组的开头添加多个（count次）字节ch。

push_back(a)

参数：: a – QByteArrayView

这是一个重载函数。

等同于 append(str)。

push_front(a)

参数：: a – QByteArrayView

这是一个重载函数。

等同于 prepend(str)。

remove(index, len)

参数：

index – int
len – 整数

返回类型:

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)

参数：: pos – int
返回类型:: QByteArray

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

另请参阅

remove()

removeFirst()

返回类型:: QByteArray

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

另请参阅

remove()

removeLast()

返回类型:: QByteArray

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

另请参阅

remove()

repeated(times)

参数：: times – 整数
返回类型:: QByteArray

警告

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

返回当前字节数组的副本，并重复指定的次数。

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

示例

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

replace(index, len, s, alen) #

参数：

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

返回类型:

QByteArray

这是一个重载函数。

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

replace(index, len, s)

参数：

index – int
len – 整数
s – QByteArrayView

返回类型:

QByteArray

警告

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

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

示例

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

另请参阅

insert() remove()

replace(before, after)

参数：

before – 整数
after – 整数

返回类型:

QByteArray

这是一个重载函数。

替换所有 before 字节为 after 字节。

replace(before, after)

参数：

before – 整数
after – QByteArrayView

返回类型:

QByteArray

这是一个重载函数。

替换所有 before 字节为 after 字节数组。

replace(before, bsize, after, asize)

参数：

before – 字符串
bsize – 整数
after – 字符串
asize – 整数

返回类型:

QByteArray

这是一个重载函数。

替换从 before 开始的 bsize 个字节，用从 after 开始的 asize 个字节替换。由于字符串的大小由 bsize 和 asize 给出，它们可以包含 '\0' 字节，并且不需要以 '\0' 终止。

replace(before, after)

参数：

before – QByteArrayView
after – QByteArrayView

返回类型:

QByteArray

警告

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

这是一个重载函数。

替换所有 before 字节数组，替换为 after 字节数组。

示例

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

reserve(size)#

参数：: size – int

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

如果您提前知道字节数组的长度，可以调用此函数；如果经常调用 resize()，则可以获得更好的性能。

如果在确定需要多少空间时存在疑虑，通常最好使用上限作为 size，或者在严格的上限远大于此的情况下，使用一个较高的可能大小估计。如果 size 是一个低估值，那么在预留的空间超出后，数组将会根据需要增长，这可能导致分配比最佳高估更大的空间，并且会减慢触发它的操作。

警告

reserve() 预留内存但不改变字节数组的长度。访问字节数组末尾之外的数据是未定义行为。如果您需要访问当前数组的末尾之外的内存，请使用 resize()。

此函数的唯一目的是提供一个方法来调整 QByteArray 的内存使用。通常，您很少需要调用此函数。

另请参阅

squeeze() capacity()

resize(size)#

参数：: size – int

将字节数组的长度设置为 size 个字节。

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

如果 size 小于当前大小，则超过 size 位置的字节将不包括在字节数组中。

注意

resize() 在需要时将增加容量，但永远不会减少容量。要卸载多余的容量，请使用 squeeze()。

另请参阅

size() truncate() squeeze()

resize(size, c)

参数：

size – int
c – int

将字节数组的尺寸设置为 newSize 字节。

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

如果 newSize 小于当前尺寸，超过 newSize 位置的字节将不会被包含在字节数组中。

注意

虽然 resize() 在需要时会增长容量，但它永远不会缩小容量。为了去除多余的容量，请使用 squeeze()。

另请参阅

size() truncate() squeeze()

right(n)#

参数：: n – int
返回类型:: QByteArray

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

参数：

width – int
fill – int
truncate – bool

返回类型:

QByteArray

警告

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

返回一个尺寸为 width 的字节数组，该数组包含 fill 字节和随后跟随的这个字节数组。

如果 truncate 为 false，且字节数组的尺寸超过 width，则返回的字节数组是此字节数组的副本。

如果 truncate 为 true，且字节数组的尺寸超过 width，则结果字节数组将在 width 位置截断。

示例

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

另请参阅

leftJustified()

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

参数：

arg__1 – float
format – int
precision – int

返回类型:

QByteArray

这是一个重载函数。

将浮点数 n 表示为文本。

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

另请参阅

toDouble() FloatingPointPrecisionOption

setNum(arg__1[, base=10])

参数：

arg__1 – int
base – int

返回类型:

QByteArray

警告

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

将整数 n 表示为文本。

将字节数组设置为表示基线性（默认为十进制）的字符中 n 的字符串，并返回对字节数组的引用。支持从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(arg__1[, base=10])

参数：

arg__1 – int
base – int

返回类型:

QByteArray

这是一个重载函数。

另请参阅

toLongLong()

setRawData(a, n)#

参数：

a – 字符串
n – int

返回类型:

QByteArray

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

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

另请参阅

fromRawData() data() constData()

shrink_to_fit()#

此函数提供以与 STL 兼容。它与 squeeze() 相等。

simplified()#

返回类型:: QByteArray

警告

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

返回一个副本字节序列，其中删除了首尾的空白字符，内部空白字符的每个序列都替换为一个空格。

空白字符是在 C 环境中标准 C++ isspace() 函数返回 true 的那些；这些是 ASCII 字符制表符‘\t’，换行符‘\n’，回车符‘\r’，垂直制表符‘\v’，表单馈送‘\f’和空白‘ ‘。

示例

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

trimmed() 特殊字符 空白字符 Characters

size()#

返回类型:: int

警告

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

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

字节数组的最后一个字节位于位置 size() - 1。此外，QByteArray 确保位置 size() 处的字节始终为 '0'，这样您就可以使用 data() 和 constData() 的返回值作为期望 '\0' 终止字符串的函数的参数。如果 QByteArray 对象是从不包含尾随 '\0' 终止字节的原始数据创建的，那么如果不需要创建深拷贝，QByteArray 不会自动添加。

示例

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()

sliced(pos)#

参数：: pos – int
返回类型:: QByteArray

sliced(pos, n)

参数：

pos – int
n – int

返回类型:

QByteArray

split(sep)#

参数：: sep – int
返回类型:: 列表 QByteArray

在 sep 出现的每个位置将字节数组拆分为子数组，并返回这些数组的列表。如果字节数组中不存在与 sep 匹配的内容，则 split() 返回包含此字节数组的单元素列表。

squeeze()#

释放存储数组数据不需要的任何内存。

此函数的唯一目的是提供一个方法来调整 QByteArray 的内存使用。通常，您很少需要调用此函数。

另请参阅

reserve() capacity()

startsWith(c)#

参数：: c – int
返回类型:: bool

这是一个重载函数。

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

startsWith(bv)

参数：: bv – QByteArrayView
返回类型:: bool

警告

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

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

示例

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

另请参阅

endsWith() first()

swap(other)#

参数：: other – QByteArray

交换 other 字节数组与这个字节数组。这个操作非常快且决不会失败。

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

参数：: options – Base64Option 的组合
返回类型:: 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()#

返回类型:: 浮点数

警告

本节包含自动从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()#

返回类型:: 浮点数

警告

本节包含自动从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'])#

参数：: separator – int
返回类型:: 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])#

参数：: base – int
返回类型:: int

警告

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

使用基数base将字节数组转换为整数，默认基数为10。支持基数为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])#

参数：: base – int
返回类型:: int

警告

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

使用基数base将字节数组转换为长整数，默认基数为10。支持基数为0和2至36，使用字母表示9以上的数字；A表示十，B表示十一，依此类推。

转换失败时返回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])#

参数：: base – int
返回类型:: int

使用基数base将字节数组转换为长长整数，默认基数为10。支持基数为0和2至36，使用字母表示9以上的数字；A表示十，B表示十一，依此类推。

转换失败时返回0。

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

注意

数字转换是在默认的 C 区域设置中执行的，而不考虑用户的区域设置。使用 QLocale 来执行数字和字符串之间的区域感知转换。

注意

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

另请参阅

number()

toLower()#

返回类型:: QByteArray

警告

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

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

示例

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

isLower() toUpper() 字符大小写

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

参数：

exclude – QByteArray
包含 – QByteArray
percent – int

返回类型:

QByteArray

警告

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

返回此字节数组的URI/URL风格的编码副本。通过参数`percent`，您可以覆盖默认的`%`字符。

默认情况下，此函数将对以下字符之外的任何字符进行编码：

字母（"a" 到 "z" 和 "A" 到 "Z"） / 数字（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])#

参数：: base – int
返回类型:: int

将字节数组转换为基本数为short的值，默认为十进制。支持0和2通过36作为基数，使用字母表示10以上的数字；A表示十，B表示十一，以此类推。

转换失败时返回0。

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

注意

数字转换是在默认的 C 区域设置中执行的，而不考虑用户的区域设置。使用 QLocale 来执行数字和字符串之间的区域感知转换。

注意

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

另请参阅

number()

toStdString()#

返回类型:: str

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

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

另请参阅

fromStdString() toStdString()

toUInt([base=10])#

参数：: base – int
返回类型:: int

将字节数组转换为基本数为`unsigned int`的值，默认为十进制。支持0和2到36作为基数，使用字母表示10以上的数字；A为十，B为十一，依此类推。

转换失败时返回0。

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

注意

数字转换是在默认的 C 区域设置中执行的，而不考虑用户的区域设置。使用 QLocale 来执行数字和字符串之间的区域感知转换。

注意

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

另请参阅

number()

toULong([base=10])#

参数：: base – int
返回类型:: int

将字节数组转换为基本数为`unsigned long int`的值，默认为十进制。支持0和2到36作为基数，使用字母表示10以上的数字；A为十，B为十一，依此类推。

转换失败时返回0。

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

注意

数字转换是在默认的 C 区域设置中执行的，而不考虑用户的区域设置。使用 QLocale 来执行数字和字符串之间的区域感知转换。

注意

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

另请参阅

number()

toULongLong([base=10])#

参数：: base – int
返回类型:: int

返回使用基数 base 转换的字节数组，默认基数为十。支持的基数有 0、2 到 36，对于 9 以上的数字使用字母，其中 A 为十，B 为十一，依此类推。

转换失败时返回0。

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

注意

数字转换是在默认的 C 区域设置中执行的，而不考虑用户的区域设置。使用 QLocale 来执行数字和字符串之间的区域感知转换。

注意

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

另请参阅

number()

toUShort([base=10])#

参数：: base – int
返回类型:: int

返回使用基数 base 转换的字节数组，默认基数为十。支持的基数有 0、2 到 36，对于 9 以上的数字使用字母，其中 A 为十，B 为十一，依此类推。

转换失败时返回0。

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

注意

数字转换是在默认的 C 区域设置中执行的，而不考虑用户的区域设置。使用 QLocale 来执行数字和字符串之间的区域感知转换。

注意

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

另请参阅

number()

toUpper()#

返回类型:: QByteArray

警告

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

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

示例

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

isUpper() toLower() 字符大小写

trimmed()#

返回类型:: QByteArray

警告

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

返回一个副本字节数组，从开头和结尾删除了空格字符。

示例

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

与 simplified() 不同，trimmed() 不改变内部空格。

另请参阅

simplified() 特殊字符 空白字符

truncate(pos)#

参数：: pos – int

警告

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

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

如果 pos 超出数组末尾，则不执行任何操作。

示例

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

chop() resize() first()