# pyo3::types::PyByteArray - Rust
Represents a Python `bytearray`.
Keywords: rust, rustlang, rust-lang, PyByteArray

# Struct pyo3::types::PyByteArray [−] [src]

    #[repr(transparent)]pub struct PyByteArray(_);

Represents a Python `bytearray`.

## Implementations

### `impl PyByteArray` [src]

#### `pub fn new<'p>(py: Python<'p>, src: &[u8]) -> &'p PyByteArray` [src]

Creates a new Python bytearray object.

The byte string is initialized by copying the data from the `&[u8]`.

#### `pub fn new_with<F>(
py: Python<'_>,
len: usize,
init: F
) -> PyResult<&PyByteArray> where
F: FnOnce(&mut [u8]) -> PyResult<()>,` [src]

Creates a new Python `bytearray` object with an `init` closure to write its contents. Before calling `init` the bytearray is zero-initialised.

- If Python raises a MemoryError on the allocation, `new_with` will return it inside `Err`.
- If `init` returns `Err(e)`, `new_with` will return `Err(e)`.
- If `init` returns `Ok(())`, `new_with` will return `Ok(&PyByteArray)`.

# Example

    use pyo3::{prelude::*, types::PyByteArray};
    Python::with_gil(|py| -> PyResult<()> {
        let py_bytearray = PyByteArray::new_with(py, 10, |bytes: &mut [u8]| {
            bytes.copy_from_slice(b"Hello Rust");
            Ok(())
        })?;
        let bytearray: &[u8] = unsafe { py_bytearray.as_bytes() };
        assert_eq!(bytearray, b"Hello Rust");
        Ok(())
    });

#### `pub fn from<'p, I>(py: Python<'p>, src: &'p I) -> PyResult<&'p PyByteArray> where
I: AsPyPointer,` [src]

Creates a new Python bytearray object from another PyObject that implements the buffer protocol.

#### `pub fn len(&self) -> usize` [src]

Gets the length of the bytearray.

#### `pub fn is_empty(&self) -> bool` [src]

Checks if the bytearray is empty.

#### `pub fn data(&self) -> *mut u8` [src]

Get the start of the buffer containing the contents of the bytearray.

Note that this bytearray object is both shared and mutable, and the backing buffer may be reallocated if the bytearray is resized. This can occur from Python code as well as from Rust via PyByteArray::resize.

As a result, the returned pointer should be dereferenced only if since calling this method no Python code has executed, PyByteArray::resize has not been called.

#### `pub unsafe fn as_bytes(&self) -> &[u8]` [src]

Get the contents of this buffer as a slice.

# Safety

This bytearray must not be resized or edited while holding the slice.

## Safety Detail

This method is equivalent to `std::slice::from_raw_parts(self.data(), self.len())`, and so all the safety notes of `std::slice::from_raw_parts` apply here.

In particular, note that this bytearray object is both shared and mutable, and the backing buffer may be reallocated if the bytearray is resized. Mutations can occur from Python code as well as from Rust, via PyByteArray::as_bytes_mut and PyByteArray::resize.

Extreme care should be exercised when using this slice, as the Rust compiler will make optimizations based on the assumption the contents of this slice cannot change. This can easily lead to undefined behavior.

As a result, this slice should only be used for short-lived operations to read this bytearray without executing any Python code, such as copying into a Vec.

#### `pub unsafe fn as_bytes_mut(&self) -> &mut [u8]` [src]

Get the contents of this buffer as a mutable slice.

# Safety

This slice should only be used for short-lived operations that write to this bytearray without executing any Python code. See the safety note for PyByteArray::as_bytes.

#### `pub fn to_vec(&self) -> Vec<u8>` [src]

Copies the contents of the bytearray to a Rust vector.

# Example

    let bytearray = PyByteArray::new(py, b"Hello World.");
    let mut copied_message = bytearray.to_vec();
    assert_eq!(b"Hello World.", copied_message.as_slice());

    copied_message[11] = b'!';
    assert_eq!(b"Hello World!", copied_message.as_slice());

    let locals = [("bytearray", bytearray)].into_py_dict(py);
    py.run("assert bytearray == b'Hello World.'", None, Some(locals)).unwrap();

#### `pub fn resize(&self, len: usize) -> PyResult<()>` [src]

Resizes the bytearray object to the new length `len`.

Note that this will invalidate any pointers obtained by PyByteArray::data, as well as any (unsafe) slices obtained from PyByteArray::as_bytes and PyByteArray::as_bytes_mut.

## Methods from Deref<Target = PyAny>

#### `pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>> where
T: PyTryFrom<'py>,` [src]

Convert this PyAny to a concrete Python type.

#### `pub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool> where
N: ToPyObject,` [src]

Determines whether this object has the given attribute.

This is equivalent to the Python expression `hasattr(self, attr_name)`.

#### `pub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny> where
N: ToPyObject,` [src]

Retrieves an attribute value.

This is equivalent to the Python expression `self.attr_name`.

#### `pub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()> where
N: ToBorrowedObject,
V: ToBorrowedObject,` [src]

Sets an attribute value.

This is equivalent to the Python expression `self.attr_name = value`.

#### `pub fn delattr<N>(&self, attr_name: N) -> PyResult<()> where
N: ToPyObject,` [src]

Deletes an attribute.

This is equivalent to the Python expression `del self.attr_name`.

#### `pub fn compare<O>(&self, other: O) -> PyResult<Ordering> where
O: ToPyObject,` [src]

Compares two Python objects.

This is equivalent to:

    if self == other:
        return Equal
    elif a < b:
        return Less
    elif a > b:
        return Greater
    else:
        raise TypeError("PyAny::compare(): All comparisons returned false")

#### `pub fn rich_compare<O>(
&self,
other: O,
compare_op: CompareOp
) -> PyResult<&PyAny> where
O: ToPyObject,` [src]

Compares two Python objects.

Depending on the value of `compare_op`, this is equivalent to one of the following Python expressions:

- CompareOp::Eq: `self == other`
- CompareOp::Ne: `self != other`
- CompareOp::Lt: `self < other`
- CompareOp::Le: `self <= other`
- CompareOp::Gt: `self > other`
- CompareOp::Ge: `self >= other`

#### `pub fn is_callable(&self) -> bool` [src]

Determines whether this object is callable.

#### `pub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>` [src]

Calls the object.

This is equivalent to the Python expression `self(*args, **kwargs)`.

#### `pub fn call0(&self) -> PyResult<&PyAny>` [src]

Calls the object without arguments.

This is equivalent to the Python expression `self()`.

#### `pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>` [src]

Calls the object with only positional arguments.

This is equivalent to the Python expression `self(*args)`.

#### `pub fn call_method(
&self,
name: &str,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>` [src]

Calls a method on the object.

This is equivalent to the Python expression `self.name(*args, **kwargs)`.

# Example

    use pyo3::types::IntoPyDict;

    let gil = Python::acquire_gil();
    let py = gil.python();
    let list = vec![3, 6, 5, 4, 7].to_object(py);
    let dict = vec![("reverse", true)].into_py_dict(py);
    list.call_method(py, "sort", (), Some(dict)).unwrap();
    assert_eq!(list.extract::<Vec<i32>>(py).unwrap(), vec![7, 6, 5, 4, 3]);

    let new_element = 1.to_object(py);
    list.call_method(py, "append", (new_element,), None).unwrap();
    assert_eq!(list.extract::<Vec<i32>>(py).unwrap(), vec![7, 6, 5, 4, 3, 1]);

#### `pub fn call_method0(&self, name: &str) -> PyResult<&PyAny>` [src]

Calls a method on the object without arguments.

This is equivalent to the Python expression `self.name()`.

#### `pub fn call_method1(
&self,
name: &str,
args: impl IntoPy<Py<PyTuple>>
) -> PyResult<&PyAny>` [src]

Calls a method on the object with only positional arguments.

This is equivalent to the Python expression `self.name(*args)`.

#### `pub fn is_true(&self) -> PyResult<bool>` [src]

Returns whether the object is considered to be true.

This is equivalent to the Python expression `bool(self)`.

#### `pub fn is_none(&self) -> bool` [src]

Returns whether the object is considered to be None.

This is equivalent to the Python expression `self is None`.

#### `pub fn is_empty(&self) -> PyResult<bool>` [src]

Returns true if the sequence or mapping has a length of 0.

This is equivalent to the Python expression `len(self) == 0`.

#### `pub fn get_item<K>(&self, key: K) -> PyResult<&PyAny> where
K: ToBorrowedObject,` [src]

Gets an item from the collection.

This is equivalent to the Python expression `self[key]`.

#### `pub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()> where
K: ToBorrowedObject,
V: ToBorrowedObject,` [src]

Sets a collection item value.

This is equivalent to the Python expression `self[key] = value`.

#### `pub fn del_item<K>(&self, key: K) -> PyResult<()> where
K: ToBorrowedObject,` [src]

Deletes an item from the collection.

This is equivalent to the Python expression `del self[key]`.

#### `pub fn iter(&self) -> PyResult<&PyIterator>` [src]

Takes an object and returns an iterator for it.

This is typically a new iterator but if the argument is an iterator, this returns itself.

#### `pub fn get_type(&self) -> &PyType` [src]

Returns the Python type object for this object’s type.

#### `pub fn get_type_ptr(&self) -> *mut PyTypeObject` [src]

Returns the Python type pointer for this object.

#### `pub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'_>> where
D: PyTryFrom<'a>,` [src]

Casts the PyObject to a concrete Python object type.

This can cast only to native Python types, not types implemented in Rust.

#### `pub fn extract<'a, D>(&'a self) -> PyResult<D> where
D: FromPyObject<'a>,` [src]

Extracts some type from the Python object.

This is a wrapper function around `FromPyObject::extract()`.

#### `pub fn get_refcnt(&self) -> isize` [src]

Returns the reference count for the Python object.

#### `pub fn repr(&self) -> PyResult<&PyString>` [src]

Computes the “repr” representation of self.

This is equivalent to the Python expression `repr(self)`.

#### `pub fn str(&self) -> PyResult<&PyString>` [src]

Computes the “str” representation of self.

This is equivalent to the Python expression `str(self)`.

#### `pub fn hash(&self) -> PyResult<isize>` [src]

Retrieves the hash code of self.

This is equivalent to the Python expression `hash(self)`.

#### `pub fn len(&self) -> PyResult<usize>` [src]

Returns the length of the sequence or mapping.

This is equivalent to the Python expression `len(self)`.

#### `pub fn dir(&self) -> &PyList` [src]

Returns the list of attributes of this object.

This is equivalent to the Python expression `dir(self)`.

#### `pub fn is_instance<T: PyTypeObject>(&self) -> PyResult<bool>` [src]

Checks whether this object is an instance of type `T`.

This is equivalent to the Python expression `isinstance(self, T)`.

## Trait Implementations

### `impl AsPyPointer for PyByteArray` [src]

#### `fn as_ptr(&self) -> *mut PyObject` [src]

Gets the underlying FFI pointer, returns a borrowed pointer.

### `impl AsRef<PyAny> for PyByteArray` [src]

#### `fn as_ref(&self) -> &PyAny` [src]

Performs the conversion.

### `impl Debug for PyByteArray` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>` [src]

Formats the value using the given formatter. Read more

### `impl Deref for PyByteArray` [src]

#### `type Target = PyAny`

The resulting type after dereferencing.

#### `fn deref(&self) -> &PyAny` [src]

Dereferences the value.

### `impl Display for PyByteArray` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>` [src]

Formats the value using the given formatter. Read more

### `impl From<&'_ PyByteArray> for Py<PyByteArray>` [src]

#### `fn from(other: &PyByteArray) -> Self` [src]

Performs the conversion.

### `impl<'a> From<&'a PyByteArray> for &'a PyAny` [src]

#### `fn from(ob: &'a PyByteArray) -> Self` [src]

Performs the conversion.

### `impl<'py> FromPyObject<'py> for &'py PyByteArray` [src]

#### `fn extract(obj: &'py PyAny) -> PyResult<Self>` [src]

Extracts `Self` from the source `PyObject`.

### `impl IntoPy<Py<PyByteArray>> for &PyByteArray` [src]

#### `fn into_py(self, py: Python<'_>) -> Py<PyByteArray>` [src]

Performs the conversion.

### `impl PartialEq<PyByteArray> for PyByteArray` [src]

#### `fn eq(&self, o: &PyByteArray) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use]pub fn ne(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests for `!=`.

### `impl PyLayout<PyByteArray> for PyObject` [src]

#### `const IS_NATIVE_TYPE: bool` [src]

#### `fn get_super(&mut self) -> Option<&mut T::BaseLayout>` [src]

#### `fn py_init(&mut self, _value: T)` [src]

#### `unsafe fn py_drop(&mut self, _py: Python<'_>)` [src]

### `impl PyNativeType for PyByteArray` [src]

#### `fn py(&self) -> Python<'_>` [src]

#### `unsafe fn unchecked_downcast(obj: &PyAny) -> &Self` [src]

Cast `&PyAny` to `&Self` without no type checking. Read more

### `impl PyTypeInfo for PyByteArray` [src]

#### `type Type = ()`

Type of objects to store in PyObject struct

#### `type BaseType = PyAny`

Base class

#### `type Layout = PyObject`

Layout

#### `type BaseLayout = PyObject`

Layout of Basetype.

#### `type Initializer = PyNativeTypeInitializer<Self>`

Initializer for layout

#### `type AsRefTarget = Self`

Utility type to make Py::as_ref work

#### `const NAME: &'static str` [src]

Class name

#### `const MODULE: Option<&'static str>` [src]

Module name, if any

#### `fn type_object_raw(_py: Python<'_>) -> *mut PyTypeObject` [src]

PyTypeObject instance for this type.

#### `fn is_type_of(ptr: &PyAny) -> bool` [src]

Checks if `object` is an instance of this type or a subclass of this type.

#### `const DESCRIPTION: &'static str` [src]

Class doc string

#### `const FLAGS: usize` [src]

Type flags (ie PY_TYPE_FLAG_GC, PY_TYPE_FLAG_WEAKREF)

#### `fn is_exact_type_of(object: &PyAny) -> bool` [src]

Checks if `object` is an instance of this type.

### `impl ToPyObject for PyByteArray` [src]

#### `fn to_object(&self, py: Python<'_>) -> PyObject` [src]

Converts self into a Python object.

## Auto Trait Implementations

### `impl !RefUnwindSafe for PyByteArray`

### `impl !Send for PyByteArray`

### `impl !Sync for PyByteArray`

### `impl Unpin for PyByteArray`

### `impl UnwindSafe for PyByteArray`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<'p, T> FromPyPointer<'p> for T where
T: 'p + PyNativeType,` [src]

#### `pub unsafe fn from_owned_ptr_or_opt(Python<'p>, *mut PyObject) -> Option<&'p T>` [src]

Convert from an arbitrary `PyObject`. Read more

#### `pub unsafe fn from_borrowed_ptr_or_opt(
Python<'p>,
*mut PyObject
) -> Option<&'p T>` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

#### `unsafe fn from_owned_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self` [src]

Convert from an arbitrary `PyObject` or panic. Read more

#### `unsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self` [src]

Convert from an arbitrary `PyObject` or panic. Read more

#### `unsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>` [src]

Convert from an arbitrary `PyObject`. Read more

#### `unsafe fn from_borrowed_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

#### `unsafe fn from_borrowed_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

#### `unsafe fn from_borrowed_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>` [src]

Convert from an arbitrary borrowed `PyObject`. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<'v, T> PyTryFrom<'v> for T where
T: PyTypeInfo + PyNativeType,` [src]

#### `pub fn try_from<V>(V) -> Result<&'v T, PyDowncastError<'v>> where
V: Into<&'v PyAny>,` [src]

Cast from a concrete Python object type to PyObject.

#### `pub fn try_from_exact<V>(V) -> Result<&'v T, PyDowncastError<'v>> where
V: Into<&'v PyAny>,` [src]

Cast from a concrete Python object type to PyObject. With exact type check.

#### `pub unsafe fn try_from_unchecked<V>(V) -> &'v T where
V: Into<&'v PyAny>,` [src]

Cast a PyAny to a specific type of PyObject. The caller must have already verified the reference is for this type. Read more

### `impl<T> PyTypeObject for T where
T: PyTypeInfo,` [src]

#### `pub fn type_object(Python<'_>) -> &PyType` [src]

Returns the safe abstraction over the type object.

### `impl<T> ToBorrowedObject for T where
T: ToPyObject,` [src]

#### `fn with_borrowed_ptr<F, R>(&self, py: Python<'_>, f: F) -> R where
F: FnOnce(*mut PyObject) -> R,` [src]

Converts self into a Python object and calls the specified closure on the native FFI pointer underlying the Python object. Read more

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `pub default fn to_string(&self) -> String` [src]

Converts the given value to a `String`. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.