When populating a slice with length set at runtime, do I absolutely need two loops, one for determining the length and one for populating?

So I have a function that removes punctuation from a string and puts those punctuation characters and their index into two slices:

func removeAndIndexPunctuation(word string) (string, []rune, []int) {
	// Index punctuation
	numberOfPunct := 0
	for _, char := range word {
		if unicode.IsPunct(char) {
			numberOfPunct += 1
		}
	}

	punctuations := make([]rune, numberOfPunct)
	punctuationIndex := make([]int, numberOfPunct)

	x := 0
	for i, char := range word {
		if unicode.IsPunct(char) {
			punctuations[x] = char
			punctuationIndex[x] = i
			x += 1
		}
	}
	
	// Remove all punctuation from word string
	res := r.ReplaceAllString(word, "")
	return res, punctuations, punctuationIndex
}

In order to make and populate the slices I have to run two for loops, one for counting the number of punctuations so I can make the array the correct length and then another that's pretty much the same except now I populate the slices.

In Python though I don't need two for loops since Python supports "dynamic arrays":

def removeAndIndexPunctuation(word):
	punctuations = []
	# Index punctuation
	for i, char in enumerate(word):
		if char in string.punctuation:
			punctuations.append((char, i))
	# Remove all punctuation from word string
	word = word.encode("utf-8").translate(None, string.punctuation).decode("utf-8")
	return word, punctuations

So I just want to make sure, in this case in golang, do I absolutely need two for loops because it doesn't support dynamic arrays or am I missing something? Or in other words, If I'm looping over a set of characters and adding some to an array/slice, do I really need two loops, one for counting the number of characters for setting the length of the slice, and one for populating the slice?

I come from Python and am learning Go.

You don't. Golang slices are dynamic arrays (don't confuse them for the actual arrays). You should (re-)read the excellent golang slice internals blog post about it.

Here is your example rewritten in a more idiomatic way:

func removeAndIndexPunctuation(word string) (string, []rune, []int) {
	var punctuations []rune
	var indexes []int

	for i, char := range word {
		if unicode.IsPunct(char) {
			punctuations = append(punctuations, char)
			indexes = append(indexes, i)
		}
	}

	// Remove all punctuation from word string
	res := r.ReplaceAllString(word, "")
	return res, punctuations, indexes
}

Note that I don't think the use of regex is particularly relevant here. Here is another version using a slice of runes:

func removeAndIndexPunctuation(word string) (string, []rune, []int) {
	var punctuations []rune
	var indexes []int
	var result []rune

	for i, char := range word {
		if unicode.IsPunct(char) {
			punctuations = append(punctuations, char)
			indexes = append(indexes, i)
		} else {
			result = append(result, char)
		}
	}

	return string(result), punctuations, indexes
}