Using D to find a symbolic derivative

There is no need to play around with ReplaceAll, Rule, Block, Module or whatever using D, since you have an oparator Derivative really fulfilling your needs while you need not bother if the arguments were defined, so I recommend it to find symbolic derivatives of your function. Remember of shorthands f', f'' to represent first and second derivatives of one-variable functions, e.g. Cos' returns the result as a pure function : -Sin[#1] &, so Derivative acts as an operator on functions, but you can still evaluate it for an argument or even more - you can find n-th indefinite integral of the original function if you evaluate Derivative[-n][f], e.g. :

FullForm /@ {f', f'''[x], f''}
Derivative[-5][Cos][x]
Derivative[-3][#^2 - 2 # + 1 &][x]

{Derivative[1][f], Derivative[3][f][x], Derivative[2][f]}     
Sin[x]
x^3/6 - x^4/12 + x^5/60

Use it this way to find the first derivative of L with respect to s :

Derivative[1, 0, 0, 0][L][s, L0, L1, a]

 -(L0/(a (1 + s/a)^2))

Derivative[1, 0, 0, 0][L][t, x, y, z] // Simplify

 -((x z)/(t + z)^2)

a = 0.04; L1 = 1; L0 = 1;
Derivative[1, 0, 0, 0][L][s, L0, L1, a]

-(25./(1 + 25. s)^2)

let's define something more general, e.g. d'Alembertian of a function f :

dAl[f_][t_, x_, y_, z_] :=  Derivative[2, 0, 0, 0][f][t, x, y, z]
                          - Derivative[0, 2, 0, 0][f][t, x, y, z] 
                          - Derivative[0, 0, 2, 0][f][t, x, y, z] 
                          - Derivative[0, 0, 0, 2][f][t, x, y, z]

for your function this yields :

dAl[L][t, x, y, z]
% // Simplify

and

dAl[L][s, L0, L1, a] // Simplify

(1250. + 31250. s)/(1. + 25. s)^3

If you need to work with a set of variables symbolically, but you also need to substitute in values for them occasionally, a good approach is to use a rule list:

values = {a -> 0.04, L1 = 1, L0 -> 1}

If the symbols have no values assigned, you can use them normally in symbolic calculations:

L[s_, L0_, L1_, a_] := L1 + L0/(1 + s/a)

D[L[s, L0, L1, a], s]

(* ==>  -(L0/(a (1 + s/a)^2)) *)

When you need to substitute in numerical values, use ReplaceAll:

D[L[s, L0, L1, a], s] /. values

(* ==> -(25./(1 + 25. s)^2) *)

I wrote a bit more about using parameter list (rule lists) in this answer.

While the answer of Szabolcs is clearly the best alternative, if you have already assigned values to the variables and clearing them for some reason is no viable option, you can use

Block[{s, L0, L1, a}, Hold@Evaluate@D[L[s, L0, L1, a], s]]

Unlike Module, Block doesn't introduce new variable names but temporarily removes the values of those given. Hold prevents Mathematica from inserting the values after return (otherwise you'd get the numerical value of the derivative for the assigned values; if that's what you want, just omit the Hold@Evaluate@), and Evaluate ensures that the expression is evaluated inside the Block despite of the Hold.