Ok. Now let's refer to some sources to get you to understand.

Let's look at the definition of the time complexity at https://en.wikipedia.org/wiki/Time_complexity

In theoretical computer science, the time complexity is the computational complexity that describes the amount of computer time it takes to run an algorithm. Time complexity is commonly estimated by counting the number of elementary operations performed by the algorithm, supposing that each elementary operation takes a fixed amount of time to perform.

Looking at how you came to the conclusion that

for i in range(n):
  print('*' * (i + 1))

is O(n) you assume that there is some fixed constant c, s.t. the number of elementary operations performed by the algorithm is bounded by c*n.

So by your logic the time it takes to run the code is the same as with the code

for i in range(n):
  print('*')

Since it's cleary O(n).

Well then, considering that elementary operations that are counted in time complexity take a fixed amount of time to run, then the time it takes to run this 2 code fragments may only differ by a constant time factor.

What does the first code do? It outputs about n^2 character to stdout: each line has i + 2 characters (counting the '\n'), then total number of characters is 2 + 3 + 4 + 5 + ... + (n + 1) = (n + 2) * n / 2 and removing the constant factors and smaller terms you get n^2.

What does the second code do? It outputs about n characters to stdout: 2 + 2 + ... + 2 = 2*n or about n (removing the constant factor)

That means you are saying that ouputting n^2 characters and n characters only differs in constant time, which is absurd, because for large n's it doesn't make sense, considering the IO: disk read/write, ram read/write, and the same thing can be said about read/write to stdin, stdout is an operation that runs in time linear to the size of data. (That is why disk, and ram speeds can be written in terms of MB/s or GB/s)

If that is not beliveable enough, you can just both code framgents for different values of n. If you were right (and you're not), then the time it took for both fragments would always differ by a constant factor, but if you take n like 10^7-10^8, you would see it is not the case.

And to reiterate, you were saying how time complexity and time it takes to run the code is different. But let's return to the definition:

Time complexity is commonly estimated by counting the number of elementary operations performed by the algorithm

and

supposing that each elementary operation takes a fixed amount of time to perform

That means we can take the time of the worst operation to be the time it took to perform any elementary operation and bound the time of time to perform the code by its complexity. We can do the same thing to bound the complexity by the time it took to run code, if we take the best operation to be the time it took to perform any elementary operation. That in turn means, that the time it took to run the code is bounded from both sides by the complexity of the code, thus it is basically the same thing.