QByteArray¶
The
QByteArray
class provides an array of bytes. More…
Synopsis¶
Functions¶
def
__add__
(, a2)def
__add__
(, a2)def
__add__
(arg__1)def
__add__
(arg__1)def
__add__
(arg__1)def
__eq__
(, a2)def
__eq__
(, rhs)def
__eq__
(arg__1)def
__eq__
(lhs)def
__ge__
(, a2)def
__ge__
(, rhs)def
__ge__
(arg__1)def
__ge__
(lhs)def
__getitem__
()def
__gt__
(, a2)def
__gt__
(, rhs)def
__gt__
(arg__1)def
__gt__
(lhs)def
__iadd__
(a)def
__iadd__
(arg__1)def
__iadd__
(c)def
__le__
(, a2)def
__le__
(, rhs)def
__le__
(arg__1)def
__le__
(lhs)def
__len__
()def
__lt__
(, a2)def
__lt__
(, a2)def
__lt__
(, rhs)def
__lt__
(arg__1)def
__lt__
(lhs)def
__mgetitem__
()def
__msetitem__
()def
__ne__
(, a2)def
__ne__
(, rhs)def
__ne__
(arg__1)def
__ne__
(lhs)def
__reduce__
()def
__repr__
()def
__setitem__
()def
__str__
()def
append
(a)def
append
(c)def
append
(count, c)def
at
(i)def
back
()def
capacity
()def
cbegin
()def
cend
()def
chop
(n)def
chopped
(len)def
clear
()def
compare
(a[, cs=Qt.CaseSensitive])def
compare
(c[, cs=Qt.CaseSensitive])def
contains
(a)def
contains
(c)def
count
()def
count
(a)def
count
(c)def
data
()def
endsWith
(a)def
endsWith
(c)def
fill
(c[, size=-1])def
front
()def
indexOf
(a[, from=0])def
insert
(i, a)def
insert
(i, count, c)def
isEmpty
()def
isLower
()def
isNull
()def
isSharedWith
(other)def
isUpper
()def
lastIndexOf
(a[, from=-1])def
left
(len)def
leftJustified
(width[, fill=’ ‘[, truncate=false]])def
length
()def
mid
(index[, len=-1])def
operator=
(str)def
prepend
(a)def
prepend
(c)def
prepend
(count, c)def
remove
(index, len)def
repeated
(times)def
replace
(before, after)def
replace
(before, after)def
replace
(before, after)def
replace
(before, after)def
replace
(index, len, s)def
reserve
(size)def
resize
(size)def
right
(len)def
rightJustified
(width[, fill=’ ‘[, truncate=false]])def
setNum
(arg__1[, base=10])def
setNum
(arg__1[, base=10])def
setNum
(arg__1[, f=’g’[, prec=6]])def
setRawData
(a, n)def
shrink_to_fit
()def
simplified
()def
size
()def
split
(sep)def
squeeze
()def
startsWith
(a)def
startsWith
(c)def
swap
(other)def
toBase64
()def
toBase64
(options)def
toDouble
()def
toFloat
()def
toHex
()def
toHex
(separator)def
toInt
([, base=10])def
toLong
([, base=10])def
toLongLong
([, base=10])def
toLower
()def
toPercentEncoding
([exclude=QByteArray()[, include=QByteArray()[, percent=’%’]]])def
toShort
([, base=10])def
toUInt
([, base=10])def
toULong
([, base=10])def
toULongLong
([, base=10])def
toUShort
([, base=10])def
toUpper
()def
trimmed
()def
truncate
(pos)
Static functions¶
def
fromBase64
(base64)def
fromBase64
(base64, options)def
fromHex
(hexEncoded)def
fromPercentEncoding
(pctEncoded[, percent=’%’])def
fromRawData
(arg__1)def
number
(arg__1[, base=10])def
number
(arg__1[, base=10])def
number
(arg__1[, f=’g’[, prec=6]])
Detailed Description¶
QByteArray
can be used to store both raw bytes (including ‘\0’s) and traditional 8-bit ‘\0’-terminated strings. UsingQByteArray
is much more convenient than usingconst char *
. Behind the scenes, it always ensures that the data is followed by a ‘\0’ terminator, and uses implicit sharing (copy-on-write) to reduce memory usage and avoid needless copying of data.In addition to
QByteArray
, Qt also provides theQString
class to store string data. For most purposes,QString
is the class you want to use. It stores 16-bit Unicode characters, making it easy to store non-ASCII/non-Latin-1 characters in your application. Furthermore,QString
is used throughout in the Qt API. The two main cases whereQByteArray
is appropriate are when you need to store raw binary data, and when memory conservation is critical (e.g., with Qt for Embedded Linux).One way to initialize a
QByteArray
is simply to pass aconst char *
to its constructor. For example, the following code creates a byte array of size 5 containing the data “Hello”:ba = QByteArray("Hello")Although the
size()
is 5, the byte array also maintains an extra ‘\0’ character at the end so that if a function is used that asks for a pointer to the underlying data (e.g. a call todata()
), the data pointed to is guaranteed to be ‘\0’-terminated.
QByteArray
makes a deep copy of theconst char *
data, so you can modify it later without experiencing side effects. (If for performance reasons you don’t want to take a deep copy of the character data, usefromRawData()
instead.)Another approach is to set the size of the array using
resize()
and to initialize the data byte per byte.QByteArray
uses 0-based indexes, just like C++ arrays. To access the byte at a particular index position, you can use operator[](). On non-const byte arrays, operator[]() returns a reference to a byte that can be used on the left side of an assignment. For example:ba = QByteArray() ba.resize(5) ba[0] = 'H' ba[1] = 'e' ba[2] = 'l' ba[3] = 'l' ba[4] = 'o'For read-only access, an alternative syntax is to use
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()
can be faster than operator[](), because it never causes a deep copy to occur.To extract many bytes at a time, use
left()
,right()
, ormid()
.A
QByteArray
can embed ‘\0’ bytes. Thesize()
function always returns the size of the whole array, including embedded ‘\0’ bytes, but excluding the terminating ‘\0’ added byQByteArray
. For example:QByteArray ba1("ca\0r\0t"); ba1.size(); // Returns 2. ba1.constData(); // Returns "ca" with terminating \0. QByteArray ba2("ca\0r\0t", 3); ba2.size(); // Returns 3. ba2.constData(); // Returns "ca\0" with terminating \0. QByteArray ba3("ca\0r\0t", 4); ba3.size(); // Returns 4. ba3.constData(); // Returns "ca\0r" with terminating \0. const char cart[] = {'c', 'a', '\0', 'r', '\0', 't'}; QByteArray ba4(QByteArray::fromRawData(cart, 6)); ba4.size(); // Returns 6. ba4.constData(); // Returns "ca\0r\0t" without terminating \0.If you want to obtain the length of the data up to and excluding the first ‘\0’ character, call
qstrlen()
on the byte array.After a call to
resize()
, newly allocated bytes have undefined values. To set all the bytes to a particular value, callfill()
.To obtain a pointer to the actual character data, call
data()
orconstData()
. These functions return a pointer to the beginning of the data. The pointer is guaranteed to remain valid until a non-const function is called on theQByteArray
. It is also guaranteed that the data ends with a ‘\0’ byte unless theQByteArray
was created from araw data
. This ‘\0’ byte is automatically provided byQByteArray
and is not counted insize()
.
QByteArray
provides the following basic functions for modifying the byte data:append()
,prepend()
,insert()
,replace()
, andremove()
. For example:x = QByteArray("and") x.prepend("rock ") # x == "rock and" x.append(" roll") # x == "rock and roll" x.replace(5, 3, "&") # x == "rock & roll"The
replace()
andremove()
functions’ first two arguments are the position from which to start erasing and the number of bytes that should be erased.When you
append()
data to a non-empty array, the array will be reallocated and the new data copied to it. You can avoid this behavior by callingreserve()
, which preallocates a certain amount of memory. You can also callcapacity()
to find out how much memoryQByteArray
actually allocated. Data appended to an empty array is not copied.A frequent requirement is to remove whitespace characters from a byte array (‘\n’, ‘\t’, ‘ ‘, etc.). If you want to remove whitespace from both ends of a
QByteArray
, usetrimmed()
. If you want to remove whitespace from both ends and replace multiple consecutive whitespaces with a single space character within the byte array, usesimplified()
.If you want to find all occurrences of a particular character or substring in a
QByteArray
, useindexOf()
orlastIndexOf()
. The former searches forward starting from a given index position, the latter searches backward. Both return the index position of the character or substring if they find it; otherwise, they return -1. For example, here’s a typical loop that finds all occurrences of a particular substring:ba = QByteArray("We must be <b>bold</b>, very <b>bold</b>") j = 0 while (j = ba.indexOf("<b>", j)) != -1: print "Found <b> tag at index position %d" % j ++jIf you simply want to check whether a
QByteArray
contains a particular character or substring, usecontains()
. If you want to find out how many times a particular character or substring occurs in the byte array, usecount()
. If you want to replace all occurrences of a particular value with another, use one of the two-parameterreplace()
overloads.
QByteArray
s can be compared using overloaded operators such as operator<(), operator<=(), operator==(), operator>=(), and so on. The comparison is based exclusively on the numeric values of the characters and is very fast, but is not what a human would expect.localeAwareCompare()
is a better choice for sorting user-interface strings.For historical reasons,
QByteArray
distinguishes between a null byte array and an empty byte array. A null byte array is a byte array that is initialized usingQByteArray
‘s default constructor or by passing (const char *)0 to the constructor. An empty byte array is any byte array with size 0. A null byte array is always empty, but an empty byte array isn’t necessarily 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 falseAll functions except
isNull()
treat null byte arrays the same as empty byte arrays. For example,data()
returns a pointer to a ‘\0’ character for a null byte array (not a null pointer), andQByteArray()
compares equal toQByteArray
(“”). We recommend that you always useisEmpty()
and avoidisNull()
.
Notes on Locale¶
Number-String Conversions¶
Functions that perform conversions between numeric data types and strings are performed in the C locale, irrespective of the user’s locale settings. Use
QString
to perform locale-aware conversions between numbers and strings.
8-bit Character Comparisons¶
In
QByteArray
, the notion of uppercase and lowercase and of which character is greater than or less than another character is locale dependent. This affects functions that support a case insensitive option or that compare or lowercase or uppercase their arguments. Case insensitive operations and comparisons will be accurate if both strings contain only ASCII characters. (If$LC_CTYPE
is set, most Unix systems do “the right thing”.) Functions that this affects includecontains()
,indexOf()
,lastIndexOf()
, operator<(), operator<=(), operator>(), operator>=(),isLower()
,isUpper()
,toLower()
andtoUpper()
.This issue does not apply to
QString
s since they represent characters using Unicode.See also
QString
QBitArray
-
class
QByteArray
¶ QByteArray(arg__1)
QByteArray(arg__1)
QByteArray(arg__1)
QByteArray(size, c)
- param size
int
- param arg__1
PyByteArray
- param c
char
Constructs an empty byte array.
See also
Constructs a byte array of size
size
with every byte set to characterch
.See also
-
PySide2.QtCore.QByteArray.
Base64Option
¶ This enum contains the options available for encoding and decoding Base64. Base64 is defined by RFC 4648 , with the following options:
Constant
Description
QByteArray.Base64Encoding
(default) The regular Base64 alphabet, called simply “base64”
QByteArray.Base64UrlEncoding
An alternate alphabet, called “base64url”, which replaces two characters in the alphabet to be more friendly to URLs.
QByteArray.KeepTrailingEquals
(default) Keeps the trailing padding equal signs at the end of the encoded data, so the data is always a size multiple of four.
QByteArray.OmitTrailingEquals
Omits adding the padding equal signs at the end of the encoded data.
fromBase64()
ignores the and options and will not flag errors in case they are missing or if there are too many of them.
New in version 5.2.
-
PySide2.QtCore.QByteArray.
__getitem__
()¶
-
PySide2.QtCore.QByteArray.
__len__
()¶
-
PySide2.QtCore.QByteArray.
__mgetitem__
()¶
-
PySide2.QtCore.QByteArray.
__msetitem__
()¶
-
PySide2.QtCore.QByteArray.
__reduce__
()¶ - Return type
PyObject
-
PySide2.QtCore.QByteArray.
__repr__
()¶ - Return type
PyObject
-
PySide2.QtCore.QByteArray.
__setitem__
()¶
-
PySide2.QtCore.QByteArray.
__str__
()¶ - Return type
PyObject
-
PySide2.QtCore.QByteArray.
append
(c)¶ - Parameters
c –
char
- Return type
This is an overloaded function.
Appends the character
ch
to this byte array.
-
PySide2.QtCore.QByteArray.
append
(a) - Parameters
a –
QByteArray
- Return type
-
PySide2.QtCore.QByteArray.
append
(count, c) - Parameters
count –
int
c –
char
- Return type
This is an overloaded function.
Appends
count
copies of characterch
to this byte array and returns a reference to this byte array.If
count
is negative or zero nothing is appended to the byte array.
-
PySide2.QtCore.QByteArray.
at
(i)¶ - Parameters
i –
int
- Return type
char
Returns the character at index position
i
in the byte array.i
must be a valid index position in the byte array (i.e., 0 <=i
<size()
).See also
operator[]()
-
PySide2.QtCore.QByteArray.
back
()¶ - Return type
char
Returns the last character in the byte array. Same as
at(size() - 1)
.This function is provided for STL compatibility.
Warning
Calling this function on an empty byte array constitutes undefined behavior.
-
PySide2.QtCore.QByteArray.
capacity
()¶ - Return type
int
Returns the maximum number of bytes that can be stored in the byte array without forcing a reallocation.
The sole purpose of this function is to provide a means of fine tuning
QByteArray
‘s memory usage. In general, you will rarely ever need to call this function. If you want to know how many bytes are in the byte array, callsize()
.
-
PySide2.QtCore.QByteArray.
cbegin
()¶ - Return type
str
Returns a const STL-style iterator pointing to the first character in the byte-array.
See also
begin()
cend()
-
PySide2.QtCore.QByteArray.
cend
()¶ - Return type
str
Returns a const STL-style iterator pointing to the imaginary character after the last character in the list.
See also
cbegin()
end()
-
PySide2.QtCore.QByteArray.
chop
(n)¶ - Parameters
n –
int
Removes
n
bytes from the end of the byte array.If
n
is greater thansize()
, the result is an empty byte array.Example:
ba = QByteArray("STARTTLS\r\n") ba.chop(2) # ba == "STARTTLS"
See also
-
PySide2.QtCore.QByteArray.
chopped
(len)¶ - Parameters
len –
int
- Return type
Returns a byte array that contains the leftmost
size()
-len
bytes of this byte array.Note
The behavior is undefined if
len
is negative or greater thansize()
.See also
-
PySide2.QtCore.QByteArray.
clear
()¶ Clears the contents of the byte array and makes it null.
-
PySide2.QtCore.QByteArray.
compare
(a[, cs=Qt.CaseSensitive])¶ - Parameters
a –
QByteArray
cs –
CaseSensitivity
- Return type
int
-
PySide2.QtCore.QByteArray.
compare
(c[, cs=Qt.CaseSensitive]) - Parameters
c – str
cs –
CaseSensitivity
- Return type
int
Returns an integer less than, equal to, or greater than zero depending on whether this
QByteArray
sorts before, at the same position, or after the string pointed to byc
. The comparison is performed according to case sensitivitycs
.See also
operator==
-
PySide2.QtCore.QByteArray.
contains
(c)¶ - Parameters
c –
char
- Return type
bool
This is an overloaded function.
Returns
true
if the byte array contains the characterch
; otherwise returnsfalse
.
-
PySide2.QtCore.QByteArray.
contains
(a) - Parameters
a –
QByteArray
- Return type
bool
-
PySide2.QtCore.QByteArray.
count
(c) - Parameters
c –
char
- Return type
int
This is an overloaded function.
Returns the number of occurrences of character
ch
in the byte array.See also
-
PySide2.QtCore.QByteArray.
count
(a) - Parameters
a –
QByteArray
- Return type
int
-
PySide2.QtCore.QByteArray.
data
()¶ - Return type
str
This is an overloaded function.
-
PySide2.QtCore.QByteArray.
endsWith
(c)¶ - Parameters
c –
char
- Return type
bool
This is an overloaded function.
Returns
true
if this byte array ends with characterch
; otherwise returnsfalse
.
-
PySide2.QtCore.QByteArray.
endsWith
(a) - Parameters
a –
QByteArray
- Return type
bool
-
PySide2.QtCore.QByteArray.
fill
(c[, size=-1])¶ - Parameters
c –
char
size –
int
- Return type
Sets every byte in the byte array to character
ch
. Ifsize
is different from -1 (the default), the byte array is resized to sizesize
beforehand.Example:
ba = QByteArray("Istambul") ba.fill('o') # ba == "oooooooo" ba.fill('X', 2) # ba == "XX"
See also
-
static
PySide2.QtCore.QByteArray.
fromBase64
(base64)¶ - Parameters
base64 –
QByteArray
- Return type
Returns a decoded copy of the Base64 array
base64
. Input is not checked for validity; invalid characters in the input are skipped, enabling the decoding process to continue with subsequent characters.For example:
text = QByteArray.fromBase64("UXQgaXMgZ3JlYXQh") text.data() # returns "Qt is great!"
The algorithm used to decode Base64-encoded data is defined in RFC 4648 .
See also
-
static
PySide2.QtCore.QByteArray.
fromBase64
(base64, options) - Parameters
base64 –
QByteArray
options –
Base64Options
- Return type
This is an overloaded function.
Returns a decoded copy of the Base64 array
base64
, using the alphabet defined byoptions
. Input is not checked for validity; invalid characters in the input are skipped, enabling the decoding process to continue with subsequent characters.For example:
QByteArray::fromBase64("PHA+SGVsbG8/PC9wPg==", QByteArray::Base64Encoding); // returns "<p>Hello?</p>" QByteArray::fromBase64("PHA-SGVsbG8_PC9wPg==", QByteArray::Base64UrlEncoding); // returns "<p>Hello?</p>"
The algorithm used to decode Base64-encoded data is defined in RFC 4648 .
See also
-
static
PySide2.QtCore.QByteArray.
fromHex
(hexEncoded)¶ - Parameters
hexEncoded –
QByteArray
- Return type
Returns a decoded copy of the hex encoded array
hexEncoded
. Input is not checked for validity; invalid characters in the input are skipped, enabling the decoding process to continue with subsequent characters.For example:
text = QByteArray.fromHex("517420697320677265617421") text.data() # returns "Qt is great!"
See also
-
static
PySide2.QtCore.QByteArray.
fromPercentEncoding
(pctEncoded[, percent='%'])¶ - Parameters
pctEncoded –
QByteArray
percent –
char
- Return type
Returns a decoded copy of the URI/URL-style percent-encoded
input
. Thepercent
parameter allows you to replace the ‘%’ character for another (for instance, ‘_’ or ‘=’).For example:
QByteArray text = QByteArray::fromPercentEncoding("Qt%20is%20great%33"); text.data(); // returns "Qt is great!"
Note
Given invalid input (such as a string containing the sequence “%G5”, which is not a valid hexadecimal number) the output will be invalid as well. As an example: the sequence “%G5” could be decoded to ‘W’.
See also
-
static
PySide2.QtCore.QByteArray.
fromRawData
(arg__1)¶ - Parameters
arg__1 – str
- Return type
Constructs a
QByteArray
that uses the firstsize
bytes of thedata
array. The bytes are not copied. TheQByteArray
will contain thedata
pointer. The caller guarantees thatdata
will not be deleted or modified as long as thisQByteArray
and any copies of it exist that have not been modified. In other words, becauseQByteArray
is an implicitly shared class and the instance returned by this function contains thedata
pointer, the caller must not deletedata
or modify it directly as long as the returnedQByteArray
and any copies exist. However,QByteArray
does not take ownership ofdata
, so theQByteArray
destructor will never delete the rawdata
, even when the lastQByteArray
referring todata
is destroyed.A subsequent attempt to modify the contents of the returned
QByteArray
or any copy made from it will cause it to create a deep copy of thedata
array before doing the modification. This ensures that the rawdata
array itself will never be modified byQByteArray
.Here is an example of how to read data using a
QDataStream
on raw data in memory without copying the raw data into aQByteArray
:mydata = '\x00\x00\x03\x84\x78\x9c\x3b\x76'\ '\xec\x18\xc3\x31\x0a\xf1\xcc\x99'\ ... '\x6d\x5b' data = QByteArray.fromRawData(mydata) in_ = QDataStream(data, QIODevice.ReadOnly) ...
Warning
A byte array created with is not null-terminated, unless the raw data contains a 0 character at position
size
. While that does not matter forQDataStream
or functions likeindexOf()
, passing the byte array to a function accepting aconst char *
expected to be ‘\0’-terminated will fail.See also
setRawData()
data()
constData()
-
PySide2.QtCore.QByteArray.
front
()¶ - Return type
char
Returns the first character in the byte array. Same as
at(0)
.This function is provided for STL compatibility.
Warning
Calling this function on an empty byte array constitutes undefined behavior.
-
PySide2.QtCore.QByteArray.
indexOf
(a[, from=0])¶ - Parameters
a –
QByteArray
from –
int
- Return type
int
-
PySide2.QtCore.QByteArray.
insert
(i, a)¶ - Parameters
i –
int
a –
QByteArray
- Return type
-
PySide2.QtCore.QByteArray.
insert
(i, count, c) - Parameters
i –
int
count –
int
c –
char
- Return type
This is an overloaded function.
Inserts
count
copies of characterch
at index positioni
in the byte array.If
i
is greater thansize()
, the array is first extended usingresize()
.
-
PySide2.QtCore.QByteArray.
isEmpty
()¶ - Return type
bool
Returns
true
if the byte array has size 0; otherwise returnsfalse
.Example:
QByteArray().isEmpty() # returns true QByteArray("").isEmpty() # returns true QByteArray("abc").isEmpty() # returns false
See also
-
PySide2.QtCore.QByteArray.
isLower
()¶ - Return type
bool
Returns
true
if this byte array contains only lowercase letters, otherwise returnsfalse
. The byte array is interpreted as a Latin-1 encoded string.
-
PySide2.QtCore.QByteArray.
isNull
()¶ - Return type
bool
Returns
true
if this byte array is null; otherwise returnsfalse
.Example:
QByteArray().isNull() # returns true QByteArray("").isNull() # returns false QByteArray("abc").isNull() # returns false
Qt makes a distinction between null byte arrays and empty byte arrays for historical reasons. For most applications, what matters is whether or not a byte array contains any data, and this can be determined using
isEmpty()
.See also
- Parameters
other –
QByteArray
- Return type
bool
-
PySide2.QtCore.QByteArray.
isUpper
()¶ - Return type
bool
Returns
true
if this byte array contains only uppercase letters, otherwise returnsfalse
. The byte array is interpreted as a Latin-1 encoded string.
-
PySide2.QtCore.QByteArray.
lastIndexOf
(a[, from=-1])¶ - Parameters
a –
QByteArray
from –
int
- Return type
int
-
PySide2.QtCore.QByteArray.
left
(len)¶ - Parameters
len –
int
- Return type
Returns a byte array that contains the leftmost
len
bytes of this byte array.The entire byte array is returned if
len
is greater thansize()
.Example:
x = QByteArray("Pineapple") y = x.left(4) # y == "Pine"
See also
-
PySide2.QtCore.QByteArray.
leftJustified
(width[, fill=' '[, truncate=false]])¶ - Parameters
width –
int
fill –
char
truncate –
bool
- Return type
Returns a byte array of size
width
that contains this byte array padded by thefill
character.If
truncate
is false and thesize()
of the byte array is more thanwidth
, then the returned byte array is a copy of this byte array.If
truncate
is true and thesize()
of the byte array is more thanwidth
, then any bytes in a copy of the byte array after positionwidth
are removed, and the copy is returned.Example:
x = QByteArray("apple") y = x.leftJustified(8, '.') # y == "apple..."
See also
-
PySide2.QtCore.QByteArray.
mid
(index[, len=-1])¶ - Parameters
index –
int
len –
int
- Return type
Returns a byte array containing
len
bytes from this byte array, starting at positionpos
.If
len
is -1 (the default), orpos
+len
>=size()
, returns a byte array containing all bytes starting at positionpos
until the end of the byte array.Example:
x = QByteArray("Five pineapples") y = x.mid(5, 4) # y == "pine" z = x.mid(5) # z == "pineapples"
See also
-
static
PySide2.QtCore.QByteArray.
number
(arg__1[, f='g'[, prec=6]])¶ - Parameters
arg__1 –
double
f –
char
prec –
int
- Return type
This is an overloaded function.
Returns a byte array that contains the printed value of
n
, formatted in formatf
with precisionprec
.Argument
n
is formatted according to thef
format specified, which isg
by default, and can be any of the following:Format
Meaning
e
format as [-]9.9e[+|-]999
E
format as [-]9.9E[+|-]999
f
format as [-]9.9
g
use
e
orf
format, whichever is the most conciseG
use
E
orf
format, whichever is the most conciseWith ‘e’, ‘E’, and ‘f’,
prec
is the number of digits after the decimal point. With ‘g’ and ‘G’,prec
is the maximum number of significant digits (trailing zeroes are omitted).ba = QByteArray.number(12.3456, 'E', 3) # ba == 1.235E+01
Note
The format of the number is not localized; the default C locale is used irrespective of the user’s locale.
See also
-
static
PySide2.QtCore.QByteArray.
number
(arg__1[, base=10]) - Parameters
arg__1 –
int
base –
int
- Return type
Returns a byte array containing the string equivalent of the number
n
to basebase
(10 by default). Thebase
can be any value between 2 and 36.Example:
n = 63; QByteArray.number(n) # returns "63" QByteArray.number(n, 16) # returns "3f" QByteArray.number(n, 16).toUpper() # returns "3F"
Note
The format of the number is not localized; the default C locale is used irrespective of the user’s locale.
-
static
PySide2.QtCore.QByteArray.
number
(arg__1[, base=10]) - Parameters
arg__1 –
qlonglong
base –
int
- Return type
This is an overloaded function.
See also
-
PySide2.QtCore.QByteArray.
__ne__
(arg__1)¶ - Parameters
arg__1 –
PyUnicode
-
PySide2.QtCore.QByteArray.
__ne__
(a2) - Parameters
a2 –
QByteArray
- Return type
bool
-
PySide2.QtCore.QByteArray.
__ne__
(lhs) - Parameters
lhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__ne__
(rhs) - Parameters
rhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__add__
(a2)¶ - Parameters
a2 –
QByteArray
- Return type
-
PySide2.QtCore.QByteArray.
__add__
(a2) - Parameters
a2 –
char
- Return type
-
PySide2.QtCore.QByteArray.
__add__
(arg__1) - Parameters
arg__1 –
PyBytes
-
PySide2.QtCore.QByteArray.
__add__
(arg__1) - Parameters
arg__1 –
PyByteArray
- Return type
-
PySide2.QtCore.QByteArray.
__add__
(arg__1) - Parameters
arg__1 –
PyByteArray
- Return type
-
PySide2.QtCore.QByteArray.
__iadd__
(arg__1)¶ - Parameters
arg__1 –
PyByteArray
- Return type
-
PySide2.QtCore.QByteArray.
__iadd__
(c) - Parameters
c –
char
- Return type
This is an overloaded function.
Appends the character
ch
onto the end of this byte array and returns a reference to this byte array.
-
PySide2.QtCore.QByteArray.
__iadd__
(a) - Parameters
a –
QByteArray
- Return type
-
PySide2.QtCore.QByteArray.
__lt__
(a2)¶ - Parameters
a2 – str
- Return type
bool
-
PySide2.QtCore.QByteArray.
__lt__
(rhs) - Parameters
rhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__lt__
(a2) - Parameters
a2 –
QByteArray
- Return type
bool
-
PySide2.QtCore.QByteArray.
__lt__
(arg__1) - Parameters
arg__1 –
PyUnicode
-
PySide2.QtCore.QByteArray.
__lt__
(lhs) - Parameters
lhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__le__
(rhs)¶ - Parameters
rhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__le__
(lhs) - Parameters
lhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__le__
(a2) - Parameters
a2 –
QByteArray
- Return type
bool
-
PySide2.QtCore.QByteArray.
__le__
(arg__1) - Parameters
arg__1 –
PyUnicode
-
PySide2.QtCore.QByteArray.operator=(str)
- Parameters
str – str
- Return type
This is an overloaded function.
Assigns
str
to this byte array.
-
PySide2.QtCore.QByteArray.
__eq__
(rhs)¶ - Parameters
rhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__eq__
(lhs) - Parameters
lhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__eq__
(a2) - Parameters
a2 –
QByteArray
- Return type
bool
-
PySide2.QtCore.QByteArray.
__eq__
(arg__1) - Parameters
arg__1 –
PyUnicode
-
PySide2.QtCore.QByteArray.
__gt__
(arg__1)¶ - Parameters
arg__1 –
PyUnicode
-
PySide2.QtCore.QByteArray.
__gt__
(a2) - Parameters
a2 –
QByteArray
- Return type
bool
-
PySide2.QtCore.QByteArray.
__gt__
(lhs) - Parameters
lhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__gt__
(rhs) - Parameters
rhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__ge__
(arg__1)¶ - Parameters
arg__1 –
PyUnicode
-
PySide2.QtCore.QByteArray.
__ge__
(rhs) - Parameters
rhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
__ge__
(a2) - Parameters
a2 –
QByteArray
- Return type
bool
-
PySide2.QtCore.QByteArray.
__ge__
(lhs) - Parameters
lhs –
QStringRef
- Return type
bool
-
PySide2.QtCore.QByteArray.
prepend
(c)¶ - Parameters
c –
char
- Return type
This is an overloaded function.
Prepends the character
ch
to this byte array.
-
PySide2.QtCore.QByteArray.
prepend
(a) - Parameters
a –
QByteArray
- Return type
-
PySide2.QtCore.QByteArray.
prepend
(count, c) - Parameters
count –
int
c –
char
- Return type
This is an overloaded function.
Prepends
count
copies of characterch
to this byte array.
-
PySide2.QtCore.QByteArray.
remove
(index, len)¶ - Parameters
index –
int
len –
int
- Return type
Removes
len
bytes from the array, starting at index positionpos
, and returns a reference to the array.If
pos
is out of range, nothing happens. Ifpos
is valid, butpos
+len
is larger than the size of the array, the array is truncated at positionpos
.Example:
ba = QByteArray("Montreal") ba.remove(1, 4) # ba == "Meal"
-
PySide2.QtCore.QByteArray.
repeated
(times)¶ - Parameters
times –
int
- Return type
Returns a copy of this byte array repeated the specified number of
times
.If
times
is less than 1, an empty byte array is returned.Example:
QByteArray ba("ab"); ba.repeated(4); // returns "abababab"
-
PySide2.QtCore.QByteArray.
replace
(index, len, s)¶ - Parameters
index –
int
len –
int
s –
QByteArray
- Return type
-
PySide2.QtCore.QByteArray.
replace
(before, after) - Parameters
before – unicode
after –
QByteArray
- Return type
-
PySide2.QtCore.QByteArray.
replace
(before, after) - Parameters
before –
char
after –
char
- Return type
This is an overloaded function.
Replaces every occurrence of the character
before
with the characterafter
.
-
PySide2.QtCore.QByteArray.
replace
(before, after) - Parameters
before –
char
after –
QByteArray
- Return type
-
PySide2.QtCore.QByteArray.
replace
(before, after) - Parameters
before –
QByteArray
after –
QByteArray
- Return type
-
PySide2.QtCore.QByteArray.
reserve
(size)¶ - Parameters
size –
int
Attempts to allocate memory for at least
size
bytes. If you know in advance how large the byte array will be, you can call this function, and if you callresize()
often you are likely to get better performance. Ifsize
is an underestimate, the worst that will happen is that theQByteArray
will be a bit slower.The sole purpose of this function is to provide a means of fine tuning
QByteArray
‘s memory usage. In general, you will rarely ever need to call this function. If you want to change the size of the byte array, callresize()
.See also
-
PySide2.QtCore.QByteArray.
resize
(size)¶ - Parameters
size –
int
Sets the size of the byte array to
size
bytes.If
size
is greater than the current size, the byte array is extended to make itsize
bytes with the extra bytes added to the end. The new bytes are uninitialized.If
size
is less than the current size, bytes are removed from the end.See also
-
PySide2.QtCore.QByteArray.
right
(len)¶ - Parameters
len –
int
- Return type
Returns a byte array that contains the rightmost
len
bytes of this byte array.The entire byte array is returned if
len
is greater thansize()
.Example:
x = QByteArray("Pineapple") y = x.right(5) # y == "apple"
See also
-
PySide2.QtCore.QByteArray.
rightJustified
(width[, fill=' '[, truncate=false]])¶ - Parameters
width –
int
fill –
char
truncate –
bool
- Return type
Returns a byte array of size
width
that contains thefill
character followed by this byte array.If
truncate
is false and the size of the byte array is more thanwidth
, then the returned byte array is a copy of this byte array.If
truncate
is true and the size of the byte array is more thanwidth
, then the resulting byte array is truncated at positionwidth
.Example:
x = QByteArray("apple") y = x.rightJustified(8, '.') # y == "...apple"
See also
-
PySide2.QtCore.QByteArray.
setNum
(arg__1[, base=10])¶ - Parameters
arg__1 –
qlonglong
base –
int
- Return type
This is an overloaded function.
See also
-
PySide2.QtCore.QByteArray.
setNum
(arg__1[, base=10]) - Parameters
arg__1 –
int
base –
int
- Return type
Sets the byte array to the printed value of
n
in basebase
(10 by default) and returns a reference to the byte array. Thebase
can be any value between 2 and 36. For bases other than 10, n is treated as an unsigned integer.Example:
ba = QByteArray() n = 63 ba.setNum(n) # ba == "63" ba.setNum(n, 16) # ba == "3f"
Note
The format of the number is not localized; the default C locale is used irrespective of the user’s locale.
-
PySide2.QtCore.QByteArray.
setNum
(arg__1[, f='g'[, prec=6]]) - Parameters
arg__1 –
double
f –
char
prec –
int
- Return type
This is an overloaded function.
Sets the byte array to the printed value of
n
, formatted in formatf
with precisionprec
, and returns a reference to the byte array.The format
f
can be any of the following:Format
Meaning
e
format as [-]9.9e[+|-]999
E
format as [-]9.9E[+|-]999
f
format as [-]9.9
g
use
e
orf
format, whichever is the most conciseG
use
E
orf
format, whichever is the most conciseWith ‘e’, ‘E’, and ‘f’,
prec
is the number of digits after the decimal point. With ‘g’ and ‘G’,prec
is the maximum number of significant digits (trailing zeroes are omitted).Note
The format of the number is not localized; the default C locale is used irrespective of the user’s locale.
See also
-
PySide2.QtCore.QByteArray.
setRawData
(a, n)¶ - Parameters
a – str
n –
uint
- Return type
Resets the
QByteArray
to use the firstsize
bytes of thedata
array. The bytes are not copied. TheQByteArray
will contain thedata
pointer. The caller guarantees thatdata
will not be deleted or modified as long as thisQByteArray
and any copies of it exist that have not been modified.This function can be used instead of
fromRawData()
to re-use existingQByteArray
objects to save memory re-allocations.See also
fromRawData()
data()
constData()
-
PySide2.QtCore.QByteArray.
shrink_to_fit
()¶ This function is provided for STL compatibility. It is equivalent to
squeeze()
.
-
PySide2.QtCore.QByteArray.
simplified
()¶ - Return type
Returns a byte array that has whitespace removed from the start and the end, and which has each sequence of internal whitespace replaced with a single space.
Whitespace means any character for which the standard C++
isspace()
function returnstrue
in the C locale. This includes the ASCII isspace() function returnstrue
in the C locale. This includes the ASCII characters ‘\t’, ‘\n’, ‘\v’, ‘\f’, ‘\r’, and ‘ ‘.Example:
ba = QByteArray(" lots\t of\nwhitespace\r\n ") ba = ba.simplified() # ba == "lots of whitespace";
See also
-
PySide2.QtCore.QByteArray.
size
()¶ - Return type
int
Returns the number of bytes in this byte array.
The last byte in the byte array is at position - 1. In addition,
QByteArray
ensures that the byte at position is always ‘\0’, so that you can use the return value ofdata()
andconstData()
as arguments to functions that expect ‘\0’-terminated strings. If theQByteArray
object was created from araw data
that didn’t include the trailing null-termination character thenQByteArray
doesn’t add it automaticall unless the deep copy is created.Example:
ba = QByteArray("Hello") n = ba.size() # n == 5 ba.data()[0] # returns 'H' ba.data()[4] # returns 'o'
-
PySide2.QtCore.QByteArray.
split
(sep)¶ - Parameters
sep –
char
- Return type
Splits the byte array into subarrays wherever
sep
occurs, and returns the list of those arrays. Ifsep
does not match anywhere in the byte array, returns a single-element list containing this byte array.
-
PySide2.QtCore.QByteArray.
squeeze
()¶ Releases any memory not required to store the array’s data.
The sole purpose of this function is to provide a means of fine tuning
QByteArray
‘s memory usage. In general, you will rarely ever need to call this function.See also
-
PySide2.QtCore.QByteArray.
startsWith
(c)¶ - Parameters
c –
char
- Return type
bool
This is an overloaded function.
Returns
true
if this byte array starts with characterch
; otherwise returnsfalse
.
-
PySide2.QtCore.QByteArray.
startsWith
(a) - Parameters
a –
QByteArray
- Return type
bool
-
PySide2.QtCore.QByteArray.
swap
(other)¶ - Parameters
other –
QByteArray
Swaps byte array
other
with this byte array. This operation is very fast and never fails.
-
PySide2.QtCore.QByteArray.
toBase64
()¶ - Return type
Returns a copy of the byte array, encoded as Base64.
text = QByteArray("Qt is great!") text.toBase64() # returns "UXQgaXMgZ3JlYXQh"
The algorithm used to encode Base64-encoded data is defined in RFC 4648 .
See also
-
PySide2.QtCore.QByteArray.
toBase64
(options) - Parameters
options –
Base64Options
- Return type
This is an overloaded function.
Returns a copy of the byte array, encoded using the options
options
.QByteArray text("<p>Hello?</p>"); 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"
The algorithm used to encode Base64-encoded data is defined in RFC 4648 .
See also
-
PySide2.QtCore.QByteArray.
toDouble
()¶ - Return type
double
Returns the byte array converted to a
double
value.Returns an infinity if the conversion overflows or 0.0 if the conversion fails for other reasons (e.g. underflow).
If
ok
is notnullptr
, failure is reported by setting *``ok`` tofalse
, and success by setting *``ok`` totrue
.string = QByteArray("1234.56") (a, ok) = string.toDouble() # a == 1234.56, ok == true
Warning
The
QByteArray
content may only contain valid numerical characters which includes the plus/minus sign, the character e used in scientific notation, and the decimal point. Including the unit or additional characters leads to a conversion error.Note
The conversion of the number is performed in the default C locale, irrespective of the user’s locale.
This function ignores leading and trailing whitespace.
See also
-
PySide2.QtCore.QByteArray.
toFloat
()¶ - Return type
float
Returns the byte array converted to a
float
value.Returns an infinity if the conversion overflows or 0.0 if the conversion fails for other reasons (e.g. underflow).
If
ok
is notnullptr
, failure is reported by setting *``ok`` tofalse
, and success by setting *``ok`` totrue
.QByteArray string("1234.56"); bool ok; float a = string.toFloat(&ok); // a == 1234.56, ok == true string = "1234.56 Volt"; a = str.toFloat(&ok); // a == 0, ok == false
Warning
The
QByteArray
content may only contain valid numerical characters which includes the plus/minus sign, the character e used in scientific notation, and the decimal point. Including the unit or additional characters leads to a conversion error.Note
The conversion of the number is performed in the default C locale, irrespective of the user’s locale.
This function ignores leading and trailing whitespace.
See also
-
PySide2.QtCore.QByteArray.
toHex
()¶ - Return type
Returns a hex encoded copy of the byte array. The hex encoding uses the numbers 0-9 and the letters a-f.
See also
-
PySide2.QtCore.QByteArray.
toHex
(separator) - Parameters
separator –
char
- Return type
This is an overloaded function.
Returns a hex encoded copy of the byte array. The hex encoding uses the numbers 0-9 and the letters a-f.
If
separator
is not ‘\0’, the separator character is inserted between the hex bytes.Example:
QByteArray macAddress = QByteArray::fromHex("123456abcdef"); macAddress.toHex(':'); // returns "12:34:56:ab:cd:ef" macAddress.toHex(0); // returns "123456abcdef"
See also
-
PySide2.QtCore.QByteArray.
toInt
([base=10])¶ - Parameters
base –
int
- Return type
int
Returns the byte array converted to an
int
using basebase
, which is 10 by default and must be between 2 and 36, or 0.If
base
is 0, the base is determined automatically using the following rules: If the byte array begins with “0x”, it is assumed to be hexadecimal; if it begins with “0”, it is assumed to be octal; otherwise it is assumed to be decimal.Returns 0 if the conversion fails.
If
ok
is notnullptr
, failure is reported by setting *``ok`` tofalse
, and success by setting *``ok`` totrue
.string = QByteArray("FF") (hex, ok) = string.toInt(16) # hex == 255, ok == true (dec, ok) = string.toInt(10) # dec == 0, ok == false
Note
The conversion of the number is performed in the default C locale, irrespective of the user’s locale.
See also
-
PySide2.QtCore.QByteArray.
toLong
([base=10])¶ - Parameters
base –
int
- Return type
long
Returns the byte array converted to a
long
int using basebase
, which is 10 by default and must be between 2 and 36, or 0.If
base
is 0, the base is determined automatically using the following rules: If the byte array begins with “0x”, it is assumed to be hexadecimal; if it begins with “0”, it is assumed to be octal; otherwise it is assumed to be decimal.Returns 0 if the conversion fails.
If
ok
is notnullptr
, failure is reported by setting *``ok`` tofalse
, and success by setting *``ok`` totrue
.string = QByteArray("FF") (hex, ok) = str.toLong(16); # hex == 255, ok == true (dec, ok) = str.toLong(10); # dec == 0, ok == false
Note
The conversion of the number is performed in the default C locale, irrespective of the user’s locale.
See also
-
PySide2.QtCore.QByteArray.
toLongLong
([base=10])¶ - Parameters
base –
int
- Return type
qlonglong
Returns the byte array converted to a
long long
using basebase
, which is 10 by default and must be between 2 and 36, or 0.If
base
is 0, the base is determined automatically using the following rules: If the byte array begins with “0x”, it is assumed to be hexadecimal; if it begins with “0”, it is assumed to be octal; otherwise it is assumed to be decimal.Returns 0 if the conversion fails.
If
ok
is notnullptr
, failure is reported by setting *``ok`` tofalse
, and success by setting *``ok`` totrue
.Note
The conversion of the number is performed in the default C locale, irrespective of the user’s locale.
See also
-
PySide2.QtCore.QByteArray.
toLower
()¶ - Return type
Returns a lowercase copy of the byte array. The bytearray is interpreted as a Latin-1 encoded string.
Example:
x = QByteArray("Qt by THE QT COMPANY") y = x.toLower() # y == "qt by the qt company"
-
PySide2.QtCore.QByteArray.
toPercentEncoding
([exclude=QByteArray()[, include=QByteArray()[, percent='%']]])¶ - Parameters
exclude –
QByteArray
include –
QByteArray
percent –
char
- Return type
Returns a URI/URL-style percent-encoded copy of this byte array. The
percent
parameter allows you to override the default ‘%’ character for another.By default, this function will encode all characters that are not one of the following:
ALPHA (“a” to “z” and “A” to “Z”) / DIGIT (0 to 9) / “-” / “.” / “_” / “~”
To prevent characters from being encoded pass them to
exclude
. To force characters to be encoded pass them toinclude
. Thepercent
character is always encoded.Example:
QByteArray text = "{a fishy string?}"; QByteArray ba = text.toPercentEncoding("{}", "s"); qDebug(ba.constData()); // prints "{a fi%73hy %73tring%3F}"
The hex encoding uses the numbers 0-9 and the uppercase letters A-F.
See also
-
PySide2.QtCore.QByteArray.
toShort
([base=10])¶ - Parameters
base –
int
- Return type
short
Returns the byte array converted to a
short
using basebase
, which is 10 by default and must be between 2 and 36, or 0.If
base
is 0, the base is determined automatically using the following rules: If the byte array begins with “0x”, it is assumed to be hexadecimal; if it begins with “0”, it is assumed to be octal; otherwise it is assumed to be decimal.Returns 0 if the conversion fails.
If
ok
is notnullptr
, failure is reported by setting *``ok`` tofalse
, and success by setting *``ok`` totrue
.Note
The conversion of the number is performed in the default C locale, irrespective of the user’s locale.
See also
-
PySide2.QtCore.QByteArray.
toUInt
([base=10])¶ - Parameters
base –
int
- Return type
uint
Returns the byte array converted to an
unsigned int
using basebase
, which is 10 by default and must be between 2 and 36, or 0.If
base
is 0, the base is determined automatically using the following rules: If the byte array begins with “0x”, it is assumed to be hexadecimal; if it begins with “0”, it is assumed to be octal; otherwise it is assumed to be decimal.Returns 0 if the conversion fails.
If
ok
is notnullptr
, failure is reported by setting *``ok`` tofalse
, and success by setting *``ok`` totrue
.Note
The conversion of the number is performed in the default C locale, irrespective of the user’s locale.
See also
-
PySide2.QtCore.QByteArray.
toULong
([base=10])¶ - Parameters
base –
int
- Return type
ulong
Returns the byte array converted to an
unsigned long int
using basebase
, which is 10 by default and must be between 2 and 36, or 0.If
base
is 0, the base is determined automatically using the following rules: If the byte array begins with “0x”, it is assumed to be hexadecimal; if it begins with “0”, it is assumed to be octal; otherwise it is assumed to be decimal.Returns 0 if the conversion fails.
If
ok
is notnullptr
, failure is reported by setting *``ok`` tofalse
, and success by setting *``ok`` totrue
.Note
The conversion of the number is performed in the default C locale, irrespective of the user’s locale.
See also
-
PySide2.QtCore.QByteArray.
toULongLong
([base=10])¶ - Parameters
base –
int
- Return type
qulonglong
Returns the byte array converted to an
unsigned long long
using basebase
, which is 10 by default and must be between 2 and 36, or 0.If
base
is 0, the base is determined automatically using the following rules: If the byte array begins with “0x”, it is assumed to be hexadecimal; if it begins with “0”, it is assumed to be octal; otherwise it is assumed to be decimal.Returns 0 if the conversion fails.
If
ok
is notnullptr
, failure is reported by setting *``ok`` tofalse
, and success by setting *``ok`` totrue
.Note
The conversion of the number is performed in the default C locale, irrespective of the user’s locale.
See also
-
PySide2.QtCore.QByteArray.
toUShort
([base=10])¶ - Parameters
base –
int
- Return type
ushort
Returns the byte array converted to an
unsigned short
using basebase
, which is 10 by default and must be between 2 and 36, or 0.If
base
is 0, the base is determined automatically using the following rules: If the byte array begins with “0x”, it is assumed to be hexadecimal; if it begins with “0”, it is assumed to be octal; otherwise it is assumed to be decimal.Returns 0 if the conversion fails.
If
ok
is notnullptr
, failure is reported by setting *``ok`` tofalse
, and success by setting *``ok`` totrue
.Note
The conversion of the number is performed in the default C locale, irrespective of the user’s locale.
See also
-
PySide2.QtCore.QByteArray.
toUpper
()¶ - Return type
Returns an uppercase copy of the byte array. The bytearray is interpreted as a Latin-1 encoded string.
Example:
x = QByteArray("Qt by THE QT COMPANY") y = x.toUpper() # y == "QT BY THE QT COMPANY"
-
PySide2.QtCore.QByteArray.
trimmed
()¶ - Return type
Returns a byte array that has whitespace removed from the start and the end.
Whitespace means any character for which the standard C++
isspace()
function returnstrue
in the C locale. This includes the ASCII characters ‘\t’, ‘\n’, ‘\v’, ‘\f’, ‘\r’, and ‘ ‘.Example:
ba = QByteArray(" lots\t of\nwhitespace\r\n "); ba = ba.trimmed(); # ba == "lots\t of\nwhitespace";
Unlike
simplified()
, leaves internal whitespace alone.See also
-
PySide2.QtCore.QByteArray.
truncate
(pos)¶ - Parameters
pos –
int
Truncates the byte array at index position
pos
.If
pos
is beyond the end of the array, nothing happens.Example:
ba = QByteArray("Stockholm") ba.truncate(5) # ba == "Stock"
© 2018 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.