83 bytes

Since $n$ can be as large as ${10}^9$, an $\mathcal{O}(n)$ solution is insufficient. We can optimize it to $\mathcal{O}(\sqrt{n})$ by observing that for every factor $x$ of $n$ such that $x\le \sqrt{n}$, there exists a corresponding factor $\frac{n}{x}$. An example implementation is given below:

n=int(input())
i=1
while i*i<=n:
 if n%i<1:
  print(i)
  if i*i-n:print(n//i)
 i+=1

64 bytes

In our $83$-byte solution, an if statement is used to ensure that no duplicates are printed. Note also that print is repeated twice. We can simplify the logic by instead storing a set of {i,n//i}, and outputting the set with each number on its own line, which can be done with the sep argument. This yields a $74$-byte solution:

n=int(input())
i=1
while i*i<=n:
 if n%i<1:print(*{i,n//i},sep='\n')
 i+=1

We can further shorten this to $69$ bytes by making use of Python's short-circuiting operators. With or, we can cause print to execute only when n%i is falsy, which then allows us to move everything onto one line:

n=int(input())
i=1
while i*i<=n:n%i or print(*{i,n//i},sep='\n');i+=1

There is still more to optimize here. In particular, another $5$-byte save is possible by outputting via map:

n=int(input())
i=1
while i*i<=n:n%i<1in map(print,{i,n//i});i+=1

The mechanics are left as an exercise to the reader (Hint: look up "chained comparison").

54 bytes

Recall back to the naive solution of iterating from $1$ to $n$ to check if it is a divisor. A natural question is, can we optimize this method by pruning specific values that don't need to be checked? Yes in fact, we can!

For the sake of example, take $n=48$. Obviously, we know that $48$ divides $n$ once, and $24$ divides $n$ twice. But what about all the numbers in between? It's obvious that none of the numbers in the range $[25,47]$ need to be checked, since $n$ divided by any of these numbers would result in a value greater than $1$ but less than $2$, which cannot be a whole number. The same argument can be applied starting from $24$. We know that $24$ divides $n$ twice, and $16$ divides $n$ thrice, but since every number in the range $[17,23]$ divides $n$ by a fractional amount between $2$ and $3$, those values can be pruned. These observations prompt the following strategy:

Initialize a variable $x=n$, representing the current divisor to check for. We would like to skip all "unnecessary" values, which can formally be defined as all values $y<x$, such that $\lfloor \frac{n}{x}\rfloor =\lfloor \frac{n}{y}\rfloor$. Therefore, the next "useful" value is the largest $y$ such that $\lfloor \frac{n}{y}\rfloor \ge \lfloor \frac{n}{x}\rfloor +1$, which we can calculate to be $y=\lfloor \frac{n}{\lfloor \frac{n}{x}\rfloor +1}\rfloor$. Implementing this algorithm leads us to the $54$-byte solution:

n=i=int(input())
while i:n%i or print(i);i=n//(n//i+1)

Now, let's try to prove that it has a time complexity of $\mathcal{O}(\sqrt{n})$. Notice that the number of iterations is equivalent to asking for the number of distinct values of $\lfloor \frac{n}{i}\rfloor$, for $1\le i\le n$.

If $i\le \sqrt{n}$, then there can obviously be at most $\sqrt{n}$ distinct values of $\lfloor \frac{n}{i}\rfloor$. If $i>\sqrt{n}$, then it implies that $\lfloor \frac{n}{i}\rfloor <\sqrt{n}$, which also can take on at most $\sqrt{n}$ values. Therefore, the total complexity is $\mathcal{O}(\sqrt{n}+\sqrt{n})=\mathcal{O}(\sqrt{n})$. For reference, the exact number of iterations for any given $n$ is $\lceil 2\times \sqrt{n+1}\rceil -2$.