performance tuning - Good coding for a sequence of derivatives

People on this site keep telling me that good MMa practice avoids the use of loops.

The code below calculates the same Table of derivatives two different ways, and the one with the Do loops is much faster. I think the first, slower version is calculating the nth derivative from scratch without using the (n-1)th derivative as a starting point.

Derivative[q_, 1][y][x, v] = D[(D[y[x, v], {x, 2}] + D[y[x, v], x]^2), {x, q}]/2;
ord = 9;

Print[Timing[dgdv1 = Table[D[y[x, v], {v, i}], {i, 0, ord - 1}];]];
dgdv2 = Flatten[{y[x, v], Table[0, {i, 2, ord}]}];
Print[Timing[Do[dgdv2[[i]] = D[dgdv2[[i - 1]], v], {i, 2, ord}];]];

(*{3.931225,Null}

{2.449216,Null} *)

So how can one efficiently calculate the first several derivatives of g[x,v] wrt v without using a loop?
Bonus Question: Is there some even faster way to do this calculation?

OP's EDIT: Some commentors below were confused by the first line of my code, in which I define a derivative relationship for g[x,v]. It's not really relevant to the computation speed issue this Question is about, but here is a link for people who want to learn about defining derivatives.

Answer

ord = 9;

Timing[d1 = Table[D[y[x, v], {v, i}], {i, 0, ord - 1}];][[1]]

(*  2.06537  *)

Rather than using Table, mapping onto a Range is often more efficient

Timing[
  d12 = D[y[x, v], {v, #}] & /@
     Range[0, ord - 1];][[1]]


(*  2.03747  *)

For a fair timing comparison, the initialization of the array should be included in the timing

Timing[
  d2 = Flatten[{y[x, v], Table[0, {i, 2, ord}]}];
  Do[d2[[i]] = D[d2[[i - 1]], v],
   {i, 2, ord}];][[1]]

(*  1.70694  *)

With symbolic operations it can sometimes be faster to Simplify intermediate steps

d22 = Flatten[{y[x, v], Table[0, {i, 2, ord}]}];
Timing[
  Do[d22[[i]] = Simplify[D[d22[[i - 1]], v]],
    {i, 2, ord}];][[1]]

(*  0.307888  *)

However, for this type of problem NestList is faster (and "more Mathematica-like")

Timing[d3 = NestList[D[#, v] &, y[x, v], ord - 1];][[1]]

(*  1.58817  *)

Again using Simplify

Timing[d32 = NestList[Simplify[D[#, v]] &, y[x, v], ord - 1];][[1]]

(*  0.060246  *)

Verifying that all approaches return the same results

d1 == d12 == d2 == d22 == d3 == d32 // Simplify

(*  True  *)