I'll just echo the answers already given by others. The syntax introduced in class (?:) does not save the particular text matched by that structural group (and thus it can potentially be ever-so-slightly faster when implemented, but that's not worth considering). The big motivation in using it was making the output of re.findall() make sense to newcomers to regular expressions. I could have spent class time explaining the difference, but it did not seem to have high pedagogical merit compared to the other things we cover in Unit 1, and "escape sequences" had used up most of our "gory details" budget.

If cs262 students go on to use regular expressions on the job or in other projects, they may well find it handy to use the capturing parentheses -- matching and replacing subgroups is a key regular expression power. But we won't need it for this class. However, if you've learned on (?:) it's easy enough to shift gears to () later. Sorry for any confusion!

Take a look at this example:

string = "She said: <strong>Hi!</strong>"

regex1 = r"<\w+>.*</\w+>"
regex2 = r"<\w+>(.*)</\w+>"
regex3 = r"<\w+>(?:.*)</\w+>"

print re.findall(regex1, string)
print re.findall(regex2, string)
print re.findall(regex3, string)

If you run this you will get

['<strong>Hi!</strong>']
['Hi!']
['<strong>Hi!</strong>']

as a result.

So "(...)" and "(?:...)" obviously yield different results.
"(?:...)" is solely intented to use for grouping your regex and will not interfere with the result of the regex. In the above example you can see that the results of regex1 and regex3 are identical.

regex2 on the other hand yields a different result (the contents of the parantheses). So it is clear why the examples from the course did not work this way.

"(...)" are used to create backreferences and are very useful. Consider this example:

string = "<a>foo</a> <b>bar <c>baz</c></b>"
regex4 = r"<(\w+)>(.*)</\1>"   # \1 refers to the first (...) in the regex, \2 to the second, ...

The only difference between the capturing and non-capturing version of the grouping parenthesis is that the capturing version keeps the matched groups for later use while the non-capturing don't. So you could use any of them for the regular expressions in this class and should work, it doesn't matter which.

I think that the non-capturing version is basically a convenient grouping that could be helpful with complex regular expressions with lots of groups, when some are required for later use and others aren't. It could be difficult to track which group number is which. Using the capturing ones for the groups required and the non-capturing version for the rest could improve your group numbering an help a lot on tracking only the interesting groups.

A part from this convenience I have not found anything saying that once is better than the other, for example, regarding performance.

An interesting excerpt from the regular expressions documentation:

Except for the fact that you can’t retrieve the contents of what the group matched, a non-capturing group
behaves exactly the same as a capturing group; you can put anything inside it, repeat it with a repetition
metacharacter such as *, and nest it within other groups (capturing or non-capturing). (?:...) is particularly
useful when modifying an existing pattern, since you can add new groups without changing how all the other
groups are numbered. It should be mentioned that there’s no performance difference in searching between
capturing and non-capturing groups; neither form is any faster than the other.

Look here: http://docs.python.org/library/re.html#regular-expression-syntax
There are both variants explained.

(?...) => A non-capturing version of regular parentheses. Matches whatever regular expression is inside the parentheses, but the substring matched by the group cannot be retrieved after performing a match or referenced later in the pattern.

But so far I do not understand what that really means.

It is just how Python defines grouping in RE.

It makes the intent of the regular expression clearer, and I'd wager it comes with a (likely very small) performance increase; there's no point in keeping a reference to a subexpression if we're not going to need it, and it's much clearer from simply looking at the regex that it's being used only for grouping, and not for capturing. Also (?:) totally looks cooler. :D