pyo3::types

Struct PyTuple

Source
pub struct PyTuple(/* private fields */);
Expand description

Represents a Python tuple object.

Values of this type are accessed via PyO3’s smart pointers, e.g. as Py<PyTuple> or Bound<'py, PyTuple>.

For APIs available on tuple objects, see the PyTupleMethods trait which is implemented for Bound<'py, PyTuple>.

Implementations§

Source§

impl PyTuple

Source

pub fn new_bound<T, U>( py: Python<'_>, elements: impl IntoIterator<Item = T, IntoIter = U>, ) -> Bound<'_, PyTuple>
where T: ToPyObject, U: ExactSizeIterator<Item = T>,

Constructs a new tuple with the given elements.

If you want to create a PyTuple with elements of different or unknown types, or from an iterable that doesn’t implement ExactSizeIterator, create a Rust tuple with the given elements and convert it at once using into_py.

§Examples
use pyo3::prelude::*;
use pyo3::types::PyTuple;

Python::with_gil(|py| {
    let elements: Vec<i32> = vec![0, 1, 2, 3, 4, 5];
    let tuple = PyTuple::new_bound(py, elements);
    assert_eq!(format!("{:?}", tuple), "(0, 1, 2, 3, 4, 5)");
});
§Panics

This function will panic if element’s ExactSizeIterator implementation is incorrect. All standard library structures implement this trait correctly, if they do, so calling this function using Vec<T> or &[T] will always succeed.

Source

pub fn empty_bound(py: Python<'_>) -> Bound<'_, PyTuple>

Constructs an empty tuple (on the Python side, a singleton object).

Source§

impl PyTuple

Source

pub fn new<T, U>( py: Python<'_>, elements: impl IntoIterator<Item = T, IntoIter = U>, ) -> &PyTuple
where T: ToPyObject, U: ExactSizeIterator<Item = T>,

👎Deprecated since 0.21.0: PyTuple::new will be replaced by PyTuple::new_bound in a future PyO3 version
Available on crate feature gil-refs only.

Deprecated form of PyTuple::new_bound.

Source

pub fn empty(py: Python<'_>) -> &PyTuple

👎Deprecated since 0.21.0: PyTuple::empty will be replaced by PyTuple::empty_bound in a future PyO3 version
Available on crate feature gil-refs only.

Deprecated form of PyTuple::empty_bound.

Source

pub fn len(&self) -> usize

Available on crate feature gil-refs only.

Gets the length of the tuple.

Source

pub fn is_empty(&self) -> bool

Available on crate feature gil-refs only.

Checks if the tuple is empty.

Source

pub fn as_sequence(&self) -> &PySequence

Available on crate feature gil-refs only.

Returns self cast as a PySequence.

Source

pub fn get_slice(&self, low: usize, high: usize) -> &PyTuple

Available on crate feature gil-refs only.

Takes the slice self[low:high] and returns it as a new tuple.

Indices must be nonnegative, and out-of-range indices are clipped to self.len().

Source

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

Available on crate feature gil-refs only.

Gets the tuple item at the specified index.

§Example
use pyo3::{prelude::*, types::PyTuple};

Python::with_gil(|py| -> PyResult<()> {
    let ob = (1, 2, 3).to_object(py);
    let tuple = ob.downcast_bound::<PyTuple>(py).unwrap();
    let obj = tuple.get_item(0);
    assert_eq!(obj.unwrap().extract::<i32>().unwrap(), 1);
    Ok(())
})
Source

pub unsafe fn get_item_unchecked(&self, index: usize) -> &PyAny

Available on crate feature gil-refs and neither Py_LIMITED_API nor PyPy nor GraalPy only.

Gets the tuple item at the specified index. Undefined behavior on bad index. Use with caution.

§Safety

Caller must verify that the index is within the bounds of the tuple.

Source

pub fn as_slice(&self) -> &[&PyAny]

Available on crate feature gil-refs and neither Py_LIMITED_API nor GraalPy only.

Returns self as a slice of objects.

Source

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

Available on crate feature gil-refs only.

Determines if self contains value.

This is equivalent to the Python expression value in self.

Source

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

Available on crate feature gil-refs only.

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

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

Source

pub fn iter(&self) -> PyTupleIterator<'_>

Available on crate feature gil-refs only.

Returns an iterator over the tuple items.

Source

pub fn to_list(&self) -> &PyList

Available on crate feature gil-refs only.

Return a new list containing the contents of this tuple; equivalent to the Python expression list(tuple).

This method is equivalent to self.as_sequence().to_list() and faster than PyList::new(py, self).

Methods from Deref<Target = PyAny>§

Source

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

Available on crate feature gil-refs only.

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.

Source

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

Available on crate feature gil-refs only.

Determines whether this object has the given attribute.

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

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern attr_name.

§Example: intern!ing the attribute name
#[pyfunction]
fn has_version(sys: &Bound<'_, PyModule>) -> PyResult<bool> {
    sys.hasattr(intern!(sys.py(), "version"))
}
Source

pub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>
where N: IntoPy<Py<PyString>>,

Available on crate feature gil-refs only.

Retrieves an attribute value.

This is equivalent to the Python expression self.attr_name.

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern attr_name.

§Example: intern!ing the attribute name
#[pyfunction]
fn version<'py>(sys: &Bound<'py, PyModule>) -> PyResult<Bound<'py, PyAny>> {
    sys.getattr(intern!(sys.py(), "version"))
}
Source

pub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>
where N: IntoPy<Py<PyString>>, V: ToPyObject,

Available on crate feature gil-refs only.

Sets an attribute value.

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

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern name.

§Example: intern!ing the attribute name
#[pyfunction]
fn set_answer(ob: &Bound<'_, PyAny>) -> PyResult<()> {
    ob.setattr(intern!(ob.py(), "answer"), 42)
}
Source

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

Available on crate feature gil-refs only.

Deletes an attribute.

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

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern attr_name.

Source

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

Available on crate feature gil-refs only.

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_bound(py, 0_f64);
    let b = PyFloat::new_bound(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_bound(py, 0_f64);
    let b = PyString::new_bound(py, "zero");
    assert!(a.compare(b).is_err());
    Ok(())
})?;
Source

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

Available on crate feature gil-refs only.

Tests whether two Python objects obey a given CompareOp.

lt, le, eq, ne, gt and ge are the specialized versions of this function.

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

compare_opPython expression
CompareOp::Eqself == other
CompareOp::Neself != other
CompareOp::Ltself < other
CompareOp::Leself <= other
CompareOp::Gtself > other
CompareOp::Geself >= other
§Examples
use pyo3::class::basic::CompareOp;
use pyo3::prelude::*;
use pyo3::types::PyInt;

Python::with_gil(|py| -> PyResult<()> {
    let a: Bound<'_, PyInt> = 0_u8.into_py(py).into_bound(py).downcast_into()?;
    let b: Bound<'_, PyInt> = 42_u8.into_py(py).into_bound(py).downcast_into()?;
    assert!(a.rich_compare(b, CompareOp::Le)?.is_truthy()?);
    Ok(())
})?;
Source

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

Available on crate feature gil-refs only.

Tests whether this object is less than another.

This is equivalent to the Python expression self < other.

Source

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

Available on crate feature gil-refs only.

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

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

Source

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

Available on crate feature gil-refs only.

Tests whether this object is equal to another.

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

Source

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

Available on crate feature gil-refs only.

Tests whether this object is not equal to another.

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

Source

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

Available on crate feature gil-refs only.

Tests whether this object is greater than another.

This is equivalent to the Python expression self > other.

Source

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

Available on crate feature gil-refs only.

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

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

Source

pub fn is_callable(&self) -> bool

Available on crate feature gil-refs only.

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_bound(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.

Source

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

Available on crate feature gil-refs only.

Calls the object.

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

§Examples
use pyo3::prelude::*;
use pyo3::types::PyDict;

const CODE: &str = r#"
def function(*args, **kwargs):
    assert args == ("hello",)
    assert kwargs == {"cruel": "world"}
    return "called with args and kwargs"
"#;

Python::with_gil(|py| {
    let module = PyModule::from_code_bound(py, CODE, "", "")?;
    let fun = module.getattr("function")?;
    let args = ("hello",);
    let kwargs = PyDict::new_bound(py);
    kwargs.set_item("cruel", "world")?;
    let result = fun.call(args, Some(&kwargs))?;
    assert_eq!(result.extract::<String>()?, "called with args and kwargs");
    Ok(())
})
Source

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

Available on crate feature gil-refs only.

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_bound(py, "builtins")?;
    let help = module.getattr("help")?;
    help.call0()?;
    Ok(())
})?;

This is equivalent to the Python expression help().

Source

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

Available on crate feature gil-refs only.

Calls the object with only positional arguments.

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

§Examples
use pyo3::prelude::*;

const CODE: &str = r#"
def function(*args, **kwargs):
    assert args == ("hello",)
    assert kwargs == {}
    return "called with args"
"#;

Python::with_gil(|py| {
    let module = PyModule::from_code_bound(py, CODE, "", "")?;
    let fun = module.getattr("function")?;
    let args = ("hello",);
    let result = fun.call1(args)?;
    assert_eq!(result.extract::<String>()?, "called with args");
    Ok(())
})
Source

pub fn call_method<N, A>( &self, name: N, args: A, kwargs: Option<&PyDict>, ) -> PyResult<&PyAny>
where N: IntoPy<Py<PyString>>, A: IntoPy<Py<PyTuple>>,

Available on crate feature gil-refs only.

Calls a method on the object.

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

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern name.

§Examples
use pyo3::prelude::*;
use pyo3::types::PyDict;

const CODE: &str = r#"
class A:
    def method(self, *args, **kwargs):
        assert args == ("hello",)
        assert kwargs == {"cruel": "world"}
        return "called with args and kwargs"
a = A()
"#;

Python::with_gil(|py| {
    let module = PyModule::from_code_bound(py, CODE, "", "")?;
    let instance = module.getattr("a")?;
    let args = ("hello",);
    let kwargs = PyDict::new_bound(py);
    kwargs.set_item("cruel", "world")?;
    let result = instance.call_method("method", args, Some(&kwargs))?;
    assert_eq!(result.extract::<String>()?, "called with args and kwargs");
    Ok(())
})
Source

pub fn call_method0<N>(&self, name: N) -> PyResult<&PyAny>
where N: IntoPy<Py<PyString>>,

Available on crate feature gil-refs only.

Calls a method on the object without arguments.

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

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern name.

§Examples
use pyo3::prelude::*;

const CODE: &str = r#"
class A:
    def method(self, *args, **kwargs):
        assert args == ()
        assert kwargs == {}
        return "called with no arguments"
a = A()
"#;

Python::with_gil(|py| {
    let module = PyModule::from_code_bound(py, CODE, "", "")?;
    let instance = module.getattr("a")?;
    let result = instance.call_method0("method")?;
    assert_eq!(result.extract::<String>()?, "called with no arguments");
    Ok(())
})
Source

pub fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<&PyAny>
where N: IntoPy<Py<PyString>>, A: IntoPy<Py<PyTuple>>,

Available on crate feature gil-refs only.

Calls a method on the object with only positional arguments.

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

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern name.

§Examples
use pyo3::prelude::*;

const CODE: &str = r#"
class A:
    def method(self, *args, **kwargs):
        assert args == ("hello",)
        assert kwargs == {}
        return "called with args"
a = A()
"#;

Python::with_gil(|py| {
    let module = PyModule::from_code_bound(py, CODE, "", "")?;
    let instance = module.getattr("a")?;
    let args = ("hello",);
    let result = instance.call_method1("method", args)?;
    assert_eq!(result.extract::<String>()?, "called with args");
    Ok(())
})
Source

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

👎Deprecated since 0.21.0: use .is_truthy() instead
Available on crate feature gil-refs only.

Returns whether the object is considered to be true.

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

Source

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

Available on crate feature gil-refs only.

Returns whether the object is considered to be true.

This applies truth value testing equivalent to the Python expression bool(self).

Source

pub fn is_none(&self) -> bool

Available on crate feature gil-refs only.

Returns whether the object is considered to be None.

This is equivalent to the Python expression self is None.

Source

pub fn is_ellipsis(&self) -> bool

👎Deprecated since 0.20.0: use .is(py.Ellipsis()) instead
Available on crate feature gil-refs only.

Returns whether the object is Ellipsis, e.g. ....

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

Source

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

Available on crate feature gil-refs only.

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

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

Source

pub fn get_item<K>(&self, key: K) -> PyResult<&PyAny>
where K: ToPyObject,

Available on crate feature gil-refs only.

Gets an item from the collection.

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

Source

pub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>
where K: ToPyObject, V: ToPyObject,

Available on crate feature gil-refs only.

Sets a collection item value.

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

Source

pub fn del_item<K>(&self, key: K) -> PyResult<()>
where K: ToPyObject,

Available on crate feature gil-refs only.

Deletes an item from the collection.

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

Source

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

Available on crate feature gil-refs only.

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.

Source

pub fn get_type(&self) -> &PyType

Available on crate feature gil-refs only.

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

Source

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

Available on crate feature gil-refs only.

Returns the Python type pointer for this object.

Source

pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>>
where T: PyTypeCheck<AsRefTarget = T>,

Available on crate feature gil-refs only.

Downcast this PyAny to a concrete Python type or pyclass.

Note that you can often avoid downcasting yourself by just specifying the desired type in function or method signatures. However, manual downcasting is sometimes necessary.

For extracting a Rust-only type, see PyAny::extract.

§Example: Downcasting to a specific Python object
use pyo3::prelude::*;
use pyo3::types::{PyDict, PyList};

Python::with_gil(|py| {
    let dict = PyDict::new_bound(py);
    assert!(dict.is_instance_of::<PyAny>());
    let any = dict.as_any();

    assert!(any.downcast::<PyDict>().is_ok());
    assert!(any.downcast::<PyList>().is_err());
});
§Example: Getting a reference to a pyclass

This is useful if you want to mutate a PyObject that might actually be a pyclass.

use pyo3::prelude::*;

#[pyclass]
struct Class {
    i: i32,
}

Python::with_gil(|py| {
    let class = Py::new(py, Class { i: 0 }).unwrap().into_bound(py).into_any();

    let class_bound: &Bound<'_, Class> = class.downcast()?;

    class_bound.borrow_mut().i += 1;

    // Alternatively you can get a `PyRefMut` directly
    let class_ref: PyRefMut<'_, Class> = class.extract()?;
    assert_eq!(class_ref.i, 1);
    Ok(())
})
Source

pub fn downcast_exact<T>(&self) -> Result<&T, PyDowncastError<'_>>
where T: PyTypeInfo<AsRefTarget = T>,

Available on crate feature gil-refs only.

Downcast this PyAny to a concrete Python type or pyclass (but not a subclass of it).

It is almost always better to use PyAny::downcast because it accounts for Python subtyping. Use this method only when you do not want to allow subtypes.

The advantage of this method over PyAny::downcast is that it is faster. The implementation of downcast_exact uses the equivalent of the Python expression type(self) is T, whereas downcast uses isinstance(self, T).

For extracting a Rust-only type, see PyAny::extract.

§Example: Downcasting to a specific Python object but not a subtype
use pyo3::prelude::*;
use pyo3::types::{PyBool, PyLong};

Python::with_gil(|py| {
    let b = PyBool::new_bound(py, true);
    assert!(b.is_instance_of::<PyBool>());
    let any: &Bound<'_, PyAny> = b.as_any();

    // `bool` is a subtype of `int`, so `downcast` will accept a `bool` as an `int`
    // but `downcast_exact` will not.
    assert!(any.downcast::<PyLong>().is_ok());
    assert!(any.downcast_exact::<PyLong>().is_err());

    assert!(any.downcast_exact::<PyBool>().is_ok());
});
Source

pub unsafe fn downcast_unchecked<T>(&self) -> &T
where T: HasPyGilRef<AsRefTarget = T>,

Available on crate feature gil-refs only.

Converts this PyAny to a concrete Python type without checking validity.

§Safety

Callers must ensure that the type is valid or risk type confusion.

Source

pub fn extract<'py, D>(&'py self) -> PyResult<D>
where D: FromPyObjectBound<'py, 'py>,

Available on crate feature gil-refs only.

Extracts some type from the Python object.

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

Source

pub fn get_refcnt(&self) -> isize

Available on crate feature gil-refs only.

Returns the reference count for the Python object.

Source

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

Available on crate feature gil-refs only.

Computes the “repr” representation of self.

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

Source

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

Available on crate feature gil-refs only.

Computes the “str” representation of self.

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

Source

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

Available on crate feature gil-refs only.

Retrieves the hash code of self.

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

Source

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

Available on crate feature gil-refs only.

Returns the length of the sequence or mapping.

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

Source

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

Available on crate feature gil-refs only.

Returns the list of attributes of this object.

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

Source

pub fn is_instance(&self, ty: &PyAny) -> PyResult<bool>

Available on crate feature gil-refs only.

Checks whether this object is an instance of type ty.

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

Source

pub fn is_exact_instance(&self, ty: &PyAny) -> bool

Available on crate feature gil-refs only.

Checks whether this object is an instance of exactly type ty (not a subclass).

This is equivalent to the Python expression type(self) is ty.

Source

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

Available on crate feature gil-refs only.

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.

Source

pub fn is_exact_instance_of<T: PyTypeInfo>(&self) -> bool

Available on crate feature gil-refs only.

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

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

Source

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

Available on crate feature gil-refs only.

Determines if self contains value.

This is equivalent to the Python expression value in self.

Source

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

Available on crate feature gil-refs only.

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

Source

pub fn as_ptr(&self) -> *mut PyObject

Available on crate feature gil-refs only.

Returns the raw FFI pointer represented by self.

§Safety

Callers are responsible for ensuring that the pointer does not outlive self.

The reference is borrowed; callers should not decrease the reference count when they are finished with the pointer.

Source

pub fn into_ptr(&self) -> *mut PyObject

Available on crate feature gil-refs only.

Returns an owned raw FFI pointer represented by self.

§Safety

The reference is owned; when finished the caller should either transfer ownership of the pointer or decrease the reference count (e.g. with pyo3::ffi::Py_DecRef).

Source

pub fn py_super(&self) -> PyResult<&PySuper>

Available on crate feature gil-refs and neither PyPy nor GraalPy only.

Return a proxy object that delegates method calls to a parent or sibling class of type.

This is equivalent to the Python expression super()

Trait Implementations§

Source§

impl AsPyPointer for PyTuple

Source§

fn as_ptr(&self) -> *mut PyObject

Gets the underlying FFI pointer, returns a borrowed pointer.

Source§

impl AsRef<PyAny> for PyTuple

Source§

fn as_ref(&self) -> &PyAny

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

impl Debug for PyTuple

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Deref for PyTuple

Source§

type Target = PyAny

The resulting type after dereferencing.
Source§

fn deref(&self) -> &PyAny

Dereferences the value.
Source§

impl Display for PyTuple

Source§

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

Formats the value using the given formatter. Read more
Source§

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

Source§

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

Converts to this type from the input type.
Source§

impl From<&PyTuple> for Py<PyTuple>

Source§

fn from(other: &PyTuple) -> Self

Converts to this type from the input type.
Source§

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

Source§

fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self>

Extracts Self from the bound smart pointer obj. Read more
Source§

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

Available on crate feature gil-refs only.
Extracts Self from the source GIL Ref obj. Read more
Source§

fn type_input() -> TypeInfo

Available on crate feature experimental-inspect only.
Extracts the type hint information for this type when it appears as an argument. Read more
Source§

impl Index<Range<usize>> for PyTuple

Source§

type Output = PyTuple

The returned type after indexing.
Source§

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

Performs the indexing (container[index]) operation. Read more
Source§

impl Index<RangeFrom<usize>> for PyTuple

Source§

type Output = PyTuple

The returned type after indexing.
Source§

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

Performs the indexing (container[index]) operation. Read more
Source§

impl Index<RangeFull> for PyTuple

Source§

type Output = PyTuple

The returned type after indexing.
Source§

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

Performs the indexing (container[index]) operation. Read more
Source§

impl Index<RangeInclusive<usize>> for PyTuple

Source§

type Output = PyTuple

The returned type after indexing.
Source§

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

Performs the indexing (container[index]) operation. Read more
Source§

impl Index<RangeTo<usize>> for PyTuple

Source§

type Output = PyTuple

The returned type after indexing.
Source§

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

Performs the indexing (container[index]) operation. Read more
Source§

impl Index<RangeToInclusive<usize>> for PyTuple

Source§

type Output = PyTuple

The returned type after indexing.
Source§

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

Performs the indexing (container[index]) operation. Read more
Source§

impl Index<usize> for PyTuple

Source§

type Output = PyAny

The returned type after indexing.
Source§

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

Performs the indexing (container[index]) operation. Read more
Source§

impl<'a> IntoIterator for &'a PyTuple

Available on crate feature gil-refs only.
Source§

type Item = &'a PyAny

The type of the elements being iterated over.
Source§

type IntoIter = PyTupleIterator<'a>

Which kind of iterator are we turning this into?
Source§

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more
Source§

impl IntoPy<Py<PyTuple>> for &PyTuple

Source§

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

Performs the conversion.
Source§

fn type_output() -> TypeInfo

Available on crate feature experimental-inspect only.
Extracts the type hint information for this type when it appears as a return value. Read more
Source§

impl PyNativeType for PyTuple

Source§

type AsRefSource = PyTuple

Available on crate feature gil-refs only.
The form of this which is stored inside a Py<T> smart pointer.
Source§

fn as_borrowed(&self) -> Borrowed<'_, '_, Self::AsRefSource>

Available on crate feature gil-refs only.
Cast &self to a Borrowed smart pointer. Read more
Source§

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

Available on crate feature gil-refs only.
Returns a GIL marker constrained to the lifetime of this type.
Source§

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

Available on crate feature gil-refs only.
Cast &PyAny to &Self without no type checking. Read more
Source§

impl PyTypeInfo for PyTuple

Source§

const NAME: &'static str = "PyTuple"

Available on crate feature gil-refs only.
Class name.
Source§

const MODULE: Option<&'static str> = _

Available on crate feature gil-refs only.
Module name, if any.
Source§

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Available on crate feature gil-refs only.
Returns the PyTypeObject instance for this type.
Source§

fn is_type_of_bound(obj: &Bound<'_, PyAny>) -> bool

Available on crate feature gil-refs only.
Checks if object is an instance of this type or a subclass of this type.
Source§

fn type_object(py: Python<'_>) -> &PyType

👎Deprecated since 0.21.0: PyTypeInfo::type_object will be replaced by PyTypeInfo::type_object_bound in a future PyO3 version
Available on crate feature gil-refs only.
Returns the safe abstraction over the type object.
Source§

fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType>

Available on crate feature gil-refs only.
Returns the safe abstraction over the type object.
Source§

fn is_type_of(object: &PyAny) -> bool

👎Deprecated since 0.21.0: PyTypeInfo::is_type_of will be replaced by PyTypeInfo::is_type_of_bound in a future PyO3 version
Available on crate feature gil-refs only.
Checks if object is an instance of this type or a subclass of this type.
Source§

fn is_exact_type_of(object: &PyAny) -> bool

👎Deprecated since 0.21.0: PyTypeInfo::is_exact_type_of will be replaced by PyTypeInfo::is_exact_type_of_bound in a future PyO3 version
Available on crate feature gil-refs only.
Checks if object is an instance of this type.
Source§

fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool

Available on crate feature gil-refs only.
Checks if object is an instance of this type.
Source§

impl ToPyObject for PyTuple

Source§

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

Converts self into a Python object.
Source§

impl DerefToPyAny for PyTuple

Auto Trait Implementations§

§

impl !Freeze for PyTuple

§

impl !RefUnwindSafe for PyTuple

§

impl !Send for PyTuple

§

impl !Sync for PyTuple

§

impl Unpin for PyTuple

§

impl UnwindSafe for PyTuple

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<'p, T> FromPyPointer<'p> for T
where T: 'p + PyNativeType,

Source§

unsafe fn from_owned_ptr_or_opt( py: Python<'p>, ptr: *mut PyObject, ) -> Option<&'p T>

👎Deprecated since 0.21.0: use Py::from_owned_ptr_or_opt(py, ptr) or Bound::from_owned_ptr_or_opt(py, ptr) instead
Available on crate feature gil-refs only.
Convert from an arbitrary PyObject. Read more
Source§

unsafe fn from_borrowed_ptr_or_opt( _py: Python<'p>, ptr: *mut PyObject, ) -> Option<&'p T>

👎Deprecated since 0.21.0: use Py::from_borrowed_ptr_or_opt(py, ptr) or Bound::from_borrowed_ptr_or_opt(py, ptr) instead
Available on crate feature gil-refs only.
Convert from an arbitrary borrowed PyObject. Read more
Source§

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

👎Deprecated since 0.21.0: use Py::from_owned_ptr(py, ptr) or Bound::from_owned_ptr(py, ptr) instead
Available on crate feature gil-refs only.
Convert from an arbitrary PyObject or panic. Read more
Source§

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

👎Deprecated since 0.21.0: use Py::from_owned_ptr(py, ptr) or Bound::from_owned_ptr(py, ptr) instead
Available on crate feature gil-refs only.
Convert from an arbitrary PyObject or panic. Read more
Source§

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

👎Deprecated since 0.21.0: use Py::from_owned_ptr_or_err(py, ptr) or Bound::from_owned_ptr_or_err(py, ptr) instead
Available on crate feature gil-refs only.
Convert from an arbitrary PyObject. Read more
Source§

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

👎Deprecated since 0.21.0: use Py::from_borrowed_ptr(py, ptr) or Bound::from_borrowed_ptr(py, ptr) instead
Available on crate feature gil-refs only.
Convert from an arbitrary borrowed PyObject. Read more
Source§

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

👎Deprecated since 0.21.0: use Py::from_borrowed_ptr(py, ptr) or Bound::from_borrowed_ptr(py, ptr) instead
Available on crate feature gil-refs only.
Convert from an arbitrary borrowed PyObject. Read more
Source§

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

👎Deprecated since 0.21.0: use Py::from_borrowed_ptr_or_err(py, ptr) or Bound::from_borrowed_ptr_or_err(py, ptr) instead
Available on crate feature gil-refs only.
Convert from an arbitrary borrowed PyObject. Read more
Source§

impl<T> HasPyGilRef for T
where T: PyNativeType,

Source§

type AsRefTarget = T

Available on crate feature gil-refs only.
Utility type to make Py::as_ref work.
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<'v, T> PyTryFrom<'v> for T
where T: PyTypeInfo<AsRefTarget = T> + PyNativeType,

Source§

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

👎Deprecated since 0.21.0: use value.downcast::<T>() instead of T::try_from(value)
Available on crate feature gil-refs only.
Cast from a concrete Python object type to PyObject.
Source§

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

👎Deprecated since 0.21.0: use value.downcast_exact::<T>() instead of T::try_from_exact(value)
Available on crate feature gil-refs only.
Cast from a concrete Python object type to PyObject. With exact type check.
Source§

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

👎Deprecated since 0.21.0: use value.downcast_unchecked::<T>() instead of T::try_from_unchecked(value)
Available on crate feature gil-refs only.
Cast a PyAny to a specific type of PyObject. The caller must have already verified the reference is for this type. Read more
Source§

impl<T> PyTypeCheck for T
where T: PyTypeInfo,

Source§

const NAME: &'static str = const NAME: &'static str = <T as PyTypeInfo>::NAME;

Available on crate feature gil-refs only.
Name of self. This is used in error messages, for example.
Source§

fn type_check(object: &Bound<'_, PyAny>) -> bool

Available on crate feature gil-refs only.
Checks if object is an instance of Self, which may include a subtype. Read more
Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

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

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.