Coin Flip Streaks script
The assignment

Write a program to find out how often a streak of six heads or a streak of six tails comes up in a randomly generated list of heads and tails.

Now this requirement you didn't match, so your program doesn't contain the required functionality, even if it does match the required result.
Note that there is a bit of a problem with the assignment, as you might see a streak of 7 as two streaks of 6, or a streak of 12 as two streaks of 6. I presume, given the assignment, that you may use any streak of 6 or more. This is not what your program currently does, by the way; I presume from the code that a streak of 12 will be seen as two streaks of 6.
[EDIT] Rereading the question, it seems that you do match the assignment, if you assume that the &quot;often&quot; part depends on how often the streak of 6 comes up in the randomly generated distributions, instead of in one distribution. That seems to be the case if I take the rest of the context in, but the assignment isn't stated very clearly.

our program breaks up the experiment into two parts: the first part generates a list of randomly selected 'heads' and 'tails' values, and the second part checks if there is a streak in it.

You fail to meet this requirement: you haven't specified two methods, which is generally the way you would split things up in programming.

Put all of this code in a loop that repeats the experiment 10,000 times so we can find out what percentage of the coin flips contains a streak of six heads or tails in a row.

So if you'd create the method that counts the streaks, and the streak count is higher than 0 then you would increase the counter. You do that perfectly :)
As indicated, you haven't separated it from the main functionality. Worse, you update global variables from a function.
If this course is about structured programming then you might fail even though your application is likely to generate the right answer.
Code review
totalRuns = 0            
streakScore = 0

This is fine, but in that case you need to update them from global code. If not the variables should be local to a function.
def coinFips():

This method name is misspelled. Does the method really only perform coin flips? If so, shouldn't there be a parameter that indicates how many? And return an array of results?
global streakScore,totalRuns

Every time you type global, you should wonder if it really helps design / readability, and refrain from using globals if it does not. I would add a space before totalRuns, but that's kind of personal.
results = ''

Why not use a (character) array instead? That way you can assign it the right size from the start and then fill it by indexing the coin flip...
for i in range(100):

100 is a literal, a so called &quot;magic value&quot;. Here you should use a parameter (or, in other cases, a constant).
# Use regular expressions to check results sting

Another spelling mistake. Spelling mistakes are not terrible, but if you make too many they act as red flags to a reviewer. They are more likely to take a deeper look.
match = re.findall(r'(HHHHHH|TTTTTT)', results)

It will probably not be terribly performant, but it is a nice way to test and easy to program. But note the problem indicated in the first section of the review.
Instead you probably want to use something like ([H]{6,}|[T]{6,}). Also, you'll find that regular expressions are hard to parameterize (what if you want to use 7 or any other number instead of 6?). Some kind of state machine would impress me (even) more.
print(&quot;The Chance of a streak is: {}%&quot;.format(round(streakScore/totalRuns * 100)))

Here too much is happening for me. The calculation should be on it's own line. If your function ends with ))) then your application is getting too much LISP like if you ask me. You can also see that it is getting too cramped because you suddenly don't use spacing around the operator / anymore.

The other lines seem fine to me. There isn't too much happening on them except for the last line - which is good. And the variable naming seems fine too. Spacing and readability are fine. The application code is concise too.
Conclusion: you are well on your way, but the part where you &quot;divide-and-conquer&quot; is lacking. This is not much of a problem in the above code of course, but it may become a problem for larger, more complex systems.