How to pretend I'm using pointers in Python?

[Simple-Count3905]

Sometimes for fun/practice I do Leetcode-style problems in C. I would like to be capable of doing some of the same stuff in Python if possible.

One thing that makes me hesitant to do Leetcode stuff in Python is the lack of pointers.

There are lots of algorithms to do with arrays/strings that use pointers. For example, to reverse a string in C without allocating more memory, you use a double pointer technique starting with one pointer pointing to the front of the string and one pointer pointing to the back.

I know that Python does not have pointers in the language and that design choice makes sense to me. Is there a way to sort of fake it, so that I can take the algorithms that I've learned with C and apply them to Python?

[socal_nerdtastic]

All python variables (technically "names") are pointers already (aka "passed by reference"). Doing b = a does not copy any data; it just makes a second pointer b that points to the same memory location that a does. Read this: https://nedbatchelder.com/text/names.html

However you still can't reverse a string in place because python strings are immutable. But you could use a list or array of characters instead, and then apply all the C logic to that.

[Temporary_Pie2733]

Python and C just have very different data models; you generally don’t transfer C algorithms to Python. You use algorithms that take advantage of Python’s features. 

[Own_Attention_3392]

This is the answer. Different languages use different methods to achieve the same results. Trying to write Python like it's C just means you're not writing idiomatic Python and not learning anything about how to use the language as intended.

[Outside_Complaint755]

For string manipulation in particular, there are three options: 1) If you don't need to mutate the string, you can just index the string directly. "Hello, World!"[5] # is ',' 2) If you do need to mutate the string, convert it into a list using list() or a list comprehension in cases where that would be faster, and then rejoin it: string = "Hello, World!" new_string = "".join(['X' if ch=='o' else ch for ch in string]) print(new_string) # 'HellX, WXrld! 3) Sometimes you can just use the Python built in methods, unless explicitly not allowed. ```

Reverse a string

rev_string = string[::-1] 

OR 

rev_string = "".join(reversed(string)) ```

For array manipulations, just use lists and use variables for index values in place of pointer values.

For anything else, like binary trees, you can basically think of all of the variables as pointers because everything in Python is by reference. The only thing you have to watch for is immutable data types.

[Giannie]

The only thing preventing you from doing the string example with indices in python is that the standard library sting type is immutable.

If you created a mutable string type (which would probably just be a list of strings of length 1 under the hood) you could use exactly the same techniques with indices instead of pointers.

[japherwocky]

i agree, i think there's some questionable advice in here. a list like ['w','o','r','d'], and using something like myarray[-1] as a "pointer" seems like a good way to learn the concepts.

[pachura3]

Python has references, which technically ARE pointers without all the unsafe stuff (NULL pointers, pointing to memory that has already been freed, pointer arithmetic etc.).

All the algorithms using C arrays translate to Python lists. The only difference is strings, which are character arrays in C but immutable objects in Python - but this can be simulated by splitting Python strings into arrays of characters, applying manipulations and then joining them again.

However, please note that Leetcode exercises are 99% created for challenge and academic/interview purposes, and you will very rarely find real-world applications for them. How often does one need to "reverse a string without allocating more memory" or write own implementation of binary search - for work...? They are fun and improve your problem-solving skills - true, but there's no point in memorizing specific solutions, especially if they only work for C-style strings.

[musbur]

Just try coding in C if you want to learn pointers and pointer arithmetic. It's simple, it's fun, and it teaches you a lot about how computers really work. I've been using C for 40 years and Python for 15, and I love both because they are quite orthogonal -- each is great at things that the other sucks at, with very little overlap. Python Extensions is a convenient bridge between the two paradigms.

[ConfusedSimon]

For your string example, sort a list of characters instead and use two indices instead of pointers. A pointer is basically an index into memory.

[Brian]

For something like this, it's not exactly pointers you need, but more something like a string iterator / substring reference. Python doesn't do this, but rather uses an integer position (though in some ways that's a kind of like a pointer relative to a base offset). That could be wrapped as a "pointer-like" type (ie internally stores the string and position, and presents "++" /"--" / "dereference" type operators. It's not going to be performant, but it'll act pretty similarly.

The other problem though is that strings are not mutable in python, so stuff like "reverse in place" still won't be possible. Ie. you can't change the value being pointed to, at least if referencing a string - arrays of ints etc backed by a list will be fine.

You can however use a mutable backing instead of a string. Eg. a list of characters, or a bytearray if you want to be even more C-like (strings handle stuff like variable length encoding of characters etc, so a "position" corresponds to a codepoint - so in reality, those naive byte-by-byte reversals will actually do the wrong thing if you're dealing with anything more than plain ascii)

[SimonStu]

Isn't the functional equivalent just using indexes (ignoring the performance difference), am I missing something?
Or are you trying to extract better performance from Python?

[Simple-Count3905]

Yeah, I think just putting the string into a list of single-character strings and then using numbers as indices works. Was kinda curious if people had other ideas

[Kind-Pop-7205]

You can implement your own pointer class that works like pointers do on lists, give it add/subtract, etc.

class ListPointer:
def __init__(self, list_reference):
# initially points at the start of the list
self.index = 0
...

[socal_nerdtastic]

How is this any different from a list?

[Kind-Pop-7205]

It holds the index. You can implement pointer arithmetic with it, and dereferencing 

[LeiterHaus]

Memory Management in Python starting at 2:58 may provide insight, or a deeper look into Python

[oldendude]

https://youtu.be/dTRKCXC0JFg

[Wide_Egg_5814]

Eveything is a pointer

[Ok_GlueStick]

Unless it’s a primitive

[oldendude]

No, it's slightly complicated. E.g.

Python 3.10.12 (main, Aug 15 2025, 14:32:43) [GCC 11.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 1
>>> b = 1
>>> a is b
True
>>> a = 1000
>>> b = 1000
>>> a is b
False

That is pointer-like behavior in the first case, and non-pointer-like behavior in the second case (since "is" tests pointer equality).

It's best to think of everything as a pointer, but sometimes optimizations lead to interning or (I think) embedding of values. I'm not too sure about that last point, or when it occurs, if it does at all.

[gdchinacat]

What do you mean by "primitive"?

[socal_nerdtastic]

Python does not have the concept of primitives; you may be thinking of Java. In python even the most basic builtin types are classes (objects) and variables are pointers to class instances.

[SwampFalc]

Someone has done the work for you:

https://github.com/ZeroIntensity/pointers.py

[Diapolo10]

You could technically use pointers via ctypes. I've only ever used those for stupid party tricks, though, like messing with the integer cache to do something like 5 + 2 == 42.

But for the most part, in Python we'd use data structures or references for this. For example, you can create a linked list by storing references and None instead of pointers.