Struct pyo3::types::PySequence

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

Represents a reference to a Python object supporting the sequence protocol.

Implementations

impl PySequence

pub fn len(&self) -> PyResult<usize>

Returns the number of objects in sequence.

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

pub fn is_empty(&self) -> PyResult<bool>

Returns whether the sequence is empty.

pub fn concat(&self, other: &PySequence) -> PyResult<&PySequence>

Returns the concatenation of self and other.

This is equivalent to the Python expression self + other.

pub fn repeat(&self, count: usize) -> PyResult<&PySequence>

Returns the result of repeating a sequence object count times.

This is equivalent to the Python expression self * count.

pub fn in_place_concat(&self, other: &PySequence) -> PyResult<&PySequence>

Concatenates self and other, in place if possible.

This is equivalent to the Python expression self.__iadd__(other).

The Python statement self += other is syntactic sugar for self = self.__iadd__(other). __iadd__ should modify and return self if possible, but create and return a new object if not.

pub fn in_place_repeat(&self, count: usize) -> PyResult<&PySequence>

Repeats the sequence object count times and updates self, if possible.

This is equivalent to the Python expression self.__imul__(other).

The Python statement self *= other is syntactic sugar for self = self.__imul__(other). __imul__ should modify and return self if possible, but create and return a new object if not.

pub fn get_item(&self, index: usize) -> PyResult<&PyAny>

Returns the indexth element of the Sequence.

This is equivalent to the Python expression self[index] without support of negative indices.

pub fn get_slice(&self, begin: usize, end: usize) -> PyResult<&PySequence>

Returns the slice of sequence object between begin and end.

This is equivalent to the Python expression self[begin:end].

pub fn set_item<I>(&self, i: usize, item: I) -> PyResult<()> where
    I: ToBorrowedObject, 

Assigns object item to the ith element of self.

This is equivalent to the Python statement self[i] = v.

pub fn del_item(&self, i: usize) -> PyResult<()>

Deletes the ith element of self.

This is equivalent to the Python statement del self[i].

pub fn set_slice(&self, i1: usize, i2: usize, v: &PyAny) -> PyResult<()>

Assigns the sequence v to the slice of self from i1 to i2.

This is equivalent to the Python statement self[i1:i2] = v.

pub fn del_slice(&self, i1: usize, i2: usize) -> PyResult<()>

Deletes the slice from i1 to i2 from self.

This is equivalent to the Python statement del self[i1:i2].

pub fn count<V>(&self, value: V) -> PyResult<usize> where
    V: ToBorrowedObject, 

Available on non-PyPy only.

Returns the number of occurrences of value in self, that is, return the number of keys for which self[key] == value.

pub fn contains<V>(&self, value: V) -> PyResult<bool> where
    V: ToBorrowedObject, 

Determines if self contains value.

This is equivalent to the Python expression value in self.

pub fn index<V>(&self, value: V) -> PyResult<usize> where
    V: ToBorrowedObject, 

Returns the first index i for which self[i] == value.

This is equivalent to the Python expression self.index(value).

pub fn list(&self) -> PyResult<&PyList>

Returns a fresh list based on the Sequence.

pub fn tuple(&self) -> PyResult<&PyTuple>

Returns a fresh tuple based on the Sequence.

Methods from Deref<Target = PyAny>

pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>> where
    for<'py> T: PyTryFrom<'py>, 

Converts this PyAny to a concrete Python type.

Examples

use pyo3::prelude::*;
use pyo3::types::{PyAny, PyDict, PyList};

Python::with_gil(|py| {
    let dict = PyDict::new(py);
    assert!(dict.is_instance_of::<PyAny>().unwrap());
    let any: &PyAny = dict.as_ref();
    assert!(any.downcast::<PyDict>().is_ok());
    assert!(any.downcast::<PyList>().is_err());
});

pub fn is<T: AsPyPointer>(&self, other: &T) -> bool

Returns whether self and other point to the same object. To compare the equality of two objects (the == operator), use eq.

This is equivalent to the Python expression self is other.

pub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool> where
    N: ToPyObject, 

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, 

Retrieves an attribute value.

This is equivalent to the Python expression self.attr_name.

If calling this method becomes performance-critical, the intern! macro can be used to intern attr_name, thereby avoiding repeated temporary allocations of Python strings.

Example: intern!ing the attribute name

#[pyfunction]
fn version(sys: &PyModule) -> PyResult<&PyAny> {
    sys.getattr(intern!(sys.py(), "version"))
}

pub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()> where
    N: ToBorrowedObject,
    V: ToBorrowedObject, 

Sets an attribute value.

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

If calling this method becomes performance-critical, the intern! macro can be used to intern attr_name, thereby avoiding repeated temporary allocations of Python strings.

Example: intern!ing the attribute name

#[pyfunction]
fn set_answer(ob: &PyAny) -> PyResult<()> {
    ob.setattr(intern!(ob.py(), "answer"), 42)
}

pub fn delattr<N>(&self, attr_name: N) -> PyResult<()> where
    N: ToPyObject, 

Deletes an attribute.

This is equivalent to the Python statement del self.attr_name.

pub fn compare<O>(&self, other: O) -> PyResult<Ordering> where
    O: ToPyObject, 

Returns an Ordering between self and other.

This is equivalent to the following Python code:

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

Examples

use pyo3::prelude::*;
use pyo3::types::PyFloat;
use std::cmp::Ordering;

Python::with_gil(|py| -> PyResult<()> {
    let a = PyFloat::new(py, 0_f64);
    let b = PyFloat::new(py, 42_f64);
    assert_eq!(a.compare(b)?, Ordering::Less);
    Ok(())
})?;

It will return PyErr for values that cannot be compared:

use pyo3::prelude::*;
use pyo3::types::{PyFloat, PyString};

Python::with_gil(|py| -> PyResult<()> {
    let a = PyFloat::new(py, 0_f64);
    let b = PyString::new(py, "zero");
    assert!(a.compare(b).is_err());
    Ok(())
})?;

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

Tests whether two Python objects obey a given CompareOp.

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

compare_op	Python expression
CompareOp::Eq	self == other
CompareOp::Ne	self != other
CompareOp::Lt	self < other
CompareOp::Le	self <= other
CompareOp::Gt	self > other
CompareOp::Ge	self >= other

Examples

use pyo3::class::basic::CompareOp;
use pyo3::prelude::*;
use pyo3::types::PyInt;

Python::with_gil(|py| -> PyResult<()> {
    let a: &PyInt = 0_u8.into_py(py).into_ref(py).downcast()?;
    let b: &PyInt = 42_u8.into_py(py).into_ref(py).downcast()?;
    assert!(a.rich_compare(b, CompareOp::Le)?.is_true()?);
    Ok(())
})?;

pub fn lt<O>(&self, other: O) -> PyResult<bool> where
    O: ToPyObject, 

Tests whether this object is less than another.

This is equivalent to the Python expression self < other.

pub fn le<O>(&self, other: O) -> PyResult<bool> where
    O: ToPyObject, 

Tests whether this object is less than or equal to another.

This is equivalent to the Python expression self <= other.

pub fn eq<O>(&self, other: O) -> PyResult<bool> where
    O: ToPyObject, 

Tests whether this object is equal to another.

This is equivalent to the Python expression self == other.

pub fn ne<O>(&self, other: O) -> PyResult<bool> where
    O: ToPyObject, 

Tests whether this object is not equal to another.

This is equivalent to the Python expression self != other.

pub fn gt<O>(&self, other: O) -> PyResult<bool> where
    O: ToPyObject, 

Tests whether this object is greater than another.

This is equivalent to the Python expression self > other.

pub fn ge<O>(&self, other: O) -> PyResult<bool> where
    O: ToPyObject, 

Tests whether this object is greater than or equal to another.

This is equivalent to the Python expression self >= other.

pub fn is_callable(&self) -> bool

Determines whether this object appears callable.

This is equivalent to Python’s callable() function.

Examples

use pyo3::prelude::*;

Python::with_gil(|py| -> PyResult<()> {
    let builtins = PyModule::import(py, "builtins")?;
    let print = builtins.getattr("print")?;
    assert!(print.is_callable());
    Ok(())
})?;

This is equivalent to the Python statement assert callable(print).

Note that unless an API needs to distinguish between callable and non-callable objects, there is no point in checking for callability. Instead, it is better to just do the call and handle potential exceptions.

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

Calls the object.

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

pub fn call0(&self) -> PyResult<&PyAny>

Calls the object without arguments.

This is equivalent to the Python expression self().

Examples

use pyo3::prelude::*;

Python::with_gil(|py| -> PyResult<()> {
    let module = PyModule::import(py, "builtins")?;
    let help = module.getattr("help")?;
    help.call0()?;
    Ok(())
})?;

This is equivalent to the Python expression help().

pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>

Calls the object with only positional arguments.

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

Examples

use pyo3::prelude::*;

Python::with_gil(|py| -> PyResult<()> {
    let module = PyModule::import(py, "operator")?;
    let add = module.getattr("add")?;
    let args = (1, 2);
    let value = add.call1(args)?;
    assert_eq!(value.extract::<i32>()?, 3);
    Ok(())
})?;

This is equivalent to the following Python code:

from operator import add

value = add(1,2)
assert value == 3

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

Calls a method on the object.

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

Examples

use pyo3::prelude::*;
use pyo3::types::{IntoPyDict, PyList};

Python::with_gil(|py| -> PyResult<()> {
    let list = PyList::new(py, vec![3, 6, 5, 4, 7]);
    let kwargs = vec![("reverse", true)].into_py_dict(py);

    list.call_method("sort", (), Some(kwargs))?;
    assert_eq!(list.extract::<Vec<i32>>()?, vec![7, 6, 5, 4, 3]);
    Ok(())
})?;

This is equivalent to the following Python code:

my_list = [3, 6, 5, 4, 7]
my_list.sort(reverse = True)
assert my_list == [7, 6, 5, 4, 3]

pub fn call_method0(&self, name: &str) -> PyResult<&PyAny>

Calls a method on the object without arguments.

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

Examples

use pyo3::prelude::*;
use pyo3::types::PyFloat;
use std::f64::consts::PI;

Python::with_gil(|py| -> PyResult<()> {
    let pi = PyFloat::new(py, PI);
    let ratio = pi.call_method0("as_integer_ratio")?;
    let (a, b) = ratio.extract::<(u64, u64)>()?;
    assert_eq!(a, 884_279_719_003_555);
    assert_eq!(b, 281_474_976_710_656);
    Ok(())
})?;

This is equivalent to the following Python code:

import math

a, b = math.pi.as_integer_ratio()

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

Calls a method on the object with only positional arguments.

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

Examples

use pyo3::prelude::*;
use pyo3::types::PyList;

Python::with_gil(|py| -> PyResult<()> {
    let list = PyList::new(py, vec![1, 3, 4]);
    list.call_method1("insert", (1, 2))?;
    assert_eq!(list.extract::<Vec<u8>>()?, [1, 2, 3, 4]);
    Ok(())
})?;

This is equivalent to the following Python code:

list_ = [1,3,4]
list_.insert(1,2)
assert list_ == [1,2,3,4]

pub fn is_true(&self) -> PyResult<bool>

Returns whether the object is considered to be true.

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

pub fn is_none(&self) -> bool

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>

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, 

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, 

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, 

Deletes an item from the collection.

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

pub fn iter(&self) -> PyResult<&PyIterator>

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

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

pub fn get_type_ptr(&self) -> *mut PyTypeObject

Returns the Python type pointer for this object.

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

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>, 

Extracts some type from the Python object.

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

pub fn get_refcnt(&self) -> isize

Returns the reference count for the Python object.

pub fn repr(&self) -> PyResult<&PyString>

Computes the “repr” representation of self.

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

pub fn str(&self) -> PyResult<&PyString>

Computes the “str” representation of self.

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

pub fn hash(&self) -> PyResult<isize>

Retrieves the hash code of self.

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

pub fn len(&self) -> PyResult<usize>

Returns the length of the sequence or mapping.

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

pub fn dir(&self) -> &PyList

Returns the list of attributes of this object.

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

pub fn is_instance(&self, typ: &PyType) -> PyResult<bool>

Checks whether this object is an instance of type typ.

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

pub fn is_instance_of<T: PyTypeObject>(&self) -> PyResult<bool>

Checks whether this object is an instance of type T.

This is equivalent to the Python expression isinstance(self, T), if the type T is known at compile time.

pub fn contains<V>(&self, value: V) -> PyResult<bool> where
    V: ToBorrowedObject, 

Determines if self contains value.

This is equivalent to the Python expression value in self.

pub fn py(&self) -> Python<'_>

Returns a GIL marker constrained to the lifetime of this type.

Trait Implementations

impl AsPyPointer for PySequence

fn as_ptr(&self) -> *mut PyObject

Gets the underlying FFI pointer, returns a borrowed pointer.

impl AsRef<PyAny> for PySequence

fn as_ref(&self) -> &PyAny

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for PySequence

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Deref for PySequence

type Target = PyAny

The resulting type after dereferencing.

fn deref(&self) -> &PyAny

Dereferences the value.

impl Display for PySequence

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> From<&'a PySequence> for &'a PyAny

fn from(ob: &'a PySequence) -> Self

Converts to this type from the input type.

impl From<&PySequence> for Py<PySequence>

fn from(other: &PySequence) -> Self

Converts to this type from the input type.

impl<'py> FromPyObject<'py> for &'py PySequence

fn extract(obj: &'py PyAny) -> PyResult<Self>

Extracts Self from the source PyObject.

impl Index<Range<usize>> for PySequence

type Output = PySequence

The returned type after indexing.

fn index(&self, _: Range<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeFrom<usize>> for PySequence

type Output = PySequence

The returned type after indexing.

fn index(&self, _: RangeFrom<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeFull> for PySequence

type Output = PySequence

The returned type after indexing.

fn index(&self, _: RangeFull) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeInclusive<usize>> for PySequence

type Output = PySequence

The returned type after indexing.

fn index(&self, range: RangeInclusive<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeTo<usize>> for PySequence

type Output = PySequence

The returned type after indexing.

fn index(&self, _: RangeTo<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<RangeToInclusive<usize>> for PySequence

type Output = PySequence

The returned type after indexing.

fn index(&self, _: RangeToInclusive<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<usize> for PySequence

type Output = PyAny

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IntoPy<Py<PySequence>> for &PySequence

fn into_py(self, py: Python<'_>) -> Py<PySequence>

Performs the conversion.

impl PyNativeType for PySequence

fn py(&self) -> Python<'_>

Returns a GIL marker constrained to the lifetime of this type.

unsafe fn unchecked_downcast(obj: &PyAny) -> &Self

Cast &PyAny to &Self without no type checking.

impl<'v> PyTryFrom<'v> for PySequence

fn try_from<V: Into<&'v PyAny>>(
    value: V
) -> Result<&'v PySequence, PyDowncastError<'v>>

Cast from a concrete Python object type to PyObject.

fn try_from_exact<V: Into<&'v PyAny>>(
    value: V
) -> Result<&'v PySequence, PyDowncastError<'v>>

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

unsafe fn try_from_unchecked<V: Into<&'v PyAny>>(value: V) -> &'v PySequence

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

impl ToPyObject for PySequence

fn to_object(&self, py: Python<'_>) -> PyObject

Converts self into a Python object.