Python equivalent for perl references

Question

I am python beginner, so far I have read that python does not have references, if this is true what is the equivalent of following perl code in python?

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;

my @grps = qw/grp1:1:2:3 grp2:1:2:3 grp3:1:2:3/;

# CREATES AN ARRAY OF REFERENCES TO ARRAYS - AoR2A
my @agrps;
foreach (@grps){
  push @agrps, [split(":")];
}

# CREATES AN HASH OF REFERENCES TO ARRAYS (REFERENCES ARE THE SAME AS THEY ARE IN AoR2A ABOVE)
my %hgrps;
foreach (@agrps){
   $hgrps{"$_->[0]"} = $_;
}

# THE ELEMENTS CAN BE THEN ACCESSED EITHER VIA ARRAY OR HASH SYNTAX
$hgrps{"grp3"}->[3] = "NEW VALUE 3rd INDEX";
$agrps[2]->[2] = "NEW VALUE 2nd INDEX";

print Dumper @agrps;
print "\n";
print Dumper %hgrps;

The output of above script is following:

$VAR1 = [
          'grp1',
          '1',
          '2',
          '3'
        ];
$VAR2 = [
          'grp2',
          '1',
          '2',
          '3'
        ];
$VAR3 = [
          'grp3',
          '1',
          'NEW VALUE 2nd INDEX',
          'NEW VALUE 3rd INDEX'
        ];

$VAR1 = 'grp3';
$VAR2 = [
          'grp3',
          '1',
          'NEW VALUE 2nd INDEX',
          'NEW VALUE 3rd INDEX'
        ];
$VAR3 = 'grp1';
$VAR4 = [
          'grp1',
          '1',
          '2',
          '3'
        ];
$VAR5 = 'grp2';
$VAR6 = [
          'grp2',
          '1',
          '2',
          '3'
        ];

Answer 1

Perl needs references for two reasons:

1. Complex (i.e. nested) data structures in a backwards compatible way. E.g. $hash{entry} = @array would have to keep assigning the array size to that entry, so using an array reference was an escape to use nested data structures: $hash{entry} = \@array.

   This problem does not exist in Python. Arrays and other data structures already are reference types, not value types.

2. Indirection. For example in Perl we can do

   my $x = 1;
   my $ref = \$x; 
   $$ref = 42;
   # ($x == 42) is true
   

   This can be faked to a certain degree using arrays, the important part is not to use value types. For example we'd need two levels to change some value through a reference.

   x = [1]
   ref = [x]
   ref[0][0] = 42
   # (x is [42]) is True
   

   We need only one level if we just need a pointer that can refer to different things.

   It might be more readable if you use a Ref class:

   class Ref(object):
       def __init__(self, val):
           self.val = val
   
   ref = Ref(1)
   ref.val = 42
   

As your problem is centered around nested data structures, a translation of your code to Python would not require any “array references”. Plain lists will do.

grps = [...]
argps = list()
hrgps = dict()
for entry in grps:
    fields = entry.split(":") # split returns a list
    argps.append(fields)
    hrgps[fields[0]] = fields