Por alguna razon no logro completar el desafio :
Cada .nav-link debe tener un texto que corresponda con el texto del header de su section relacionado (por ejemplo, si tienes un section/header “Hello world”, tu #navbar debe tener un .nav-link que tenga el texto “Hello world”).
Estan literalmente copiados del header al .nav-link
Les comparto mi codigo:
<!DOCTYPE html>
<html>
<head>
<title>Documentación Tecnica</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<main id="main-doc">
<nav id="navbar">
<header>Python</header>
<ul>
<li><a class="nav-link" href="#Funciones_en_Python">Funciones en Python</a></li>
<li><a class="nav-link" href="#Pasando_argumentos_de_entrada">Pasando Argumento de Entrada</a></li>
<li><a class="nav-link" href="#por_posicion">por Posición</a></li>
<li><a class="nav-link" href="#por_nombre">por Nombre</a></li>
<li><a class="nav-link" href="#por_defecto">por Defecto</a></li>
<li><a class="nav-link" href="#longitud_variable">por longitud </a></li>
</ul>
</nav>
<section class="main-section" id="Funciones_en_Python">
<header>Funciones en Python</header>
<div>
<p>
Anteriormente hemos usado funciones nativas que vienen con Python como len() para calcular la longitud de una lista, pero al igual que en otros lenguajes de programación, también podemos definir <strong>nuestras propias funciones</strong>. Para ello hacemos uso de def.
</p>
<ul>
<li><a class="link" href="#">Funciones en Python</a></li>
<li><a class="link" href="#">Pasando Argumento de Entrada</a></li>
<li><a class="link" href="#">Argumentos por Posición</a></li>
<li><a class="link" href="#">Argumentos por Nombre</a></li>
<li><a class="link" href="#">Argumentos por Defecto</a></li>
<li><a class="link" href="#">Argumentos por longitud </a></li>
</ul>
<code>
<span class="impGreen">def</span> <span class="impBlue">nombre_funcion</span>(argumentos):
código
<span class="impGreen">return</span> retorno
</code>
<p>
Cualquier función tendrá un <strong>nombre</strong>, unos <strong>argumentos de entrada</strong>, un <strong>código</strong> a ejecutar y unos <strong>parámetros de salida</strong>. Al igual que las funciones matemáticas, en programación nos permiten realizar diferentes operaciones con la entrada, para entregar una determinada salida que dependerá del código que escribamos dentro. Por lo tanto, es totalmente análogo al clásico y=f(x) de las matemáticas.
</p>
<code>
<span>def</span> <span>f</span>(x):
<span>return</span> <span>2</span><span>*</span>x
y = f(3)
print(y) # 6
</code>
<p>
Algo que diferencia en cierto modo las funciones en el mundo de la programación, es que no sólo realizan una operación con sus entradas, sino que también parten de los siguientes principios:
</p>
<ul>
<li><p>
El principio de <strong>reusabilidad</strong>, que nos dice que si por ejemplo tenemos un fragmento de código usado en muchos sitios, la mejor solución sería pasarlo a una función. Esto nos evitaría tener código repetido, y que modificarlo fuera más fácil, ya que bastaría con cambiar la función una vez.
</p></li>
<li><p>
Y el principio de <strong>modularidad</strong>, que defiende que en vez de escribir largos trozos de código, es mejor crear módulos o funciones que agrupen ciertos fragmentos de código en funcionalidades específicas, haciendo que el código resultante sea más fácil de leer.
</p></li>
</ul>
</div>
</section>
<section class="main-section" id="Pasando_argumentos_de_entrada">
<header>Pasando argumentos de entrada</header>
<div>
<p>
Empecemos por la función más sencilla de todas. Una función sin parámetros de entrada ni parámetros de salida.
</p>
<code>
def di_hola():
print("Hola")
</code>
<p>
Hemos declarado o definido la función. El siguiente paso es llamarla con di_hola(). Si lo realizamos veremos que se imprime Hola.
</p>
<code>
di_hola() # Hola
</code>
<p>
Vamos a complicar un poco las cosas pasando un argumento de entrada. Ahora si pasamos como entrada un nombre, se imprimirá Hola y el nombre.
</p>
<code>
def di_hola(nombre):
print("Hola", nombre)
di_hola("Juan")
# Hola Juan
</code>
<p>
Python permite pasar argumentos también de otras formas. A continuación las explicamos todas.
</p>
</div>
</section>
<section class="main-section" id="por_posicion">
<header>por posicion</header>
<div>
<p>
Los argumentos por posición o posicionales son la forma más básica e intuitiva de pasar parámetros. Si tenemos una función resta() que acepta dos parámetros, se puede llamar como se muestra a continuación.
</p>
<code>
def resta(a, b):
return a-b
resta(5, 3) # 2
</code>
<p>
Al tratarse de parámetros posicionales, se interpretará que el primer número es la a y el segundo la b. El número de parámetros es fijo, por lo que si intentamos llamar a la función con solo uno, dará error.
</p>
<code>
#resta(1) # Error! TypeError
</code>
<p>
Tampoco es posible usar mas argumentos de los tiene la función definidos, ya que no sabría que hacer con ellos. Por lo tanto si lo intentamos, Python nos dirá que toma 2 posicionales y estamos pasando 3, lo que no es posible.
</p>
<code>
#TypeError: resta() takes 2 positional arguments but 3 were given
#resta(5,4,3) # Error
</code>
</div>
</section>
<section class="main-section" id="por_nombre">
<header>por nombre</header>
<div>
<p>
Otra forma de llamar a una función, es usando el nombre del argumento con = y su valor. El siguiente código hace lo mismo que el código anterior, con la diferencia de que los argumentos no son posicionales.
</p>
<code>
resta(a=3, b=5) # -2
</code>
<p>
Al indicar en la llamada a la función el nombre de la variable y el valor, el orden ya no importa, y se podría llamar de la siguiente forma.
</p>
<code>
resta(b=5, a=3) # -2
</code>
<p>
Como es de esperar, si indicamos un argumento que no ha sido definido como parámetro de entrada, tendremos un error.
</p>
<code>
#resta() got an unexpected keyword argument 'c'
#resta(b=5, c=3) # Error!
</code>
</div>
</section>
<section class="main-section" id="por_defecto">
<header>por defecto</header>
<div>
<p>
Tal vez queramos tener una función con algún parámetro opcional, que pueda ser usado o no dependiendo de diferentes circunstancias. Para ello, lo que podemos hacer es asignar un valor por defecto a la función. En el siguiente caso c valdría cero salvo que se indique lo contrario.
</p>
<code>
def suma(a, b, c=0):
return a+b+c
suma(5,5,3) # 13
</code>
<p>
Dado que el parámetro c tiene un valor por defecto, la función puede ser llamada sin ese valor.
</p>
<code>
suma(4,3) # 7
</code>
<p>
Podemos incluso asignar un valor por defecto a todos los parámetros, por lo que se podría llamar a la función sin ningún argumento de entrada.
</p>
<code>
def suma(a=3, b=5, c=0):
return a+b+c
suma() # 8
</code>
<p>
Las siguientes llamadas a la función también son válidas
</p>
<code>
suma(1) # 6
suma(4,5) # 9
suma(5,3,2) # 10
</code>
<p>
O haciendo uso de lo que hemos visto antes y usando los nombres de los argumentos.
</p>
<code>
suma(a=5, b=3) #8
</code>
</div>
</section>
<section class="main-section" id="longitud_variable">
<header>longitud variable</header>
<div>
<p>
En el ejemplo con argumentos por defecto, hemos visto que la función puede ser llamada con diferente número de argumentos de entrada, pero esto no es realmente una función con argumentos de longitud variable, ya que existe un número máximo.
</p>
<p>
Imaginemos que queremos una función suma() como la de antes, pero en este caso necesitamos que sume todos los números de entrada que se le pasen, sin importar si son 3 o 100. Una primera forma de hacerlo sería con una lista.
</p>
<code>
def suma(numeros):
total = 0
for n in numeros:
total += n
return total
suma([1,3,5,4]) # 13
</code>
<p>
La forma es válida y cumple nuestro requisito, pero realmente no estamos trabajando con argumentos de longitud variable. En realidad tenemos un solo argumento que es una lista de números.
</p>
<p>
Por suerte, Python tiene una herramienta muy potente. Si declaramos un argumento con *, esto hará que el argumento que se pase sea empaquetado en una tupla de manera automática. No confundir * con los punteros en otros lenguajes de programación, no tiene nada que ver.
</p>
<code>
def suma(*numeros):
print(type(numeros))
# <class 'tuple'>
total = 0
for n in numeros:
total += n
return total
suma(1, 3, 5, 4) # 13
</code>
<p>
El resultado es igual que el anterior, y podemos ver como efectivamente numeros es de la clase tuple. También podemos hacer otras llamadas con diferente número de argumentos
</p>
<code>
suma(6) # 6
suma(6, 4, 10) # 20
suma(6, 4, 10, 20, 4, 6, 7) # 57
</code>
<p>
Usando doble ** es posible también tener como parámetro de entrada una lista de elementos almacenados en forma de clave y valor. En este caso podemos iterar los valores haciendo uso de items().
</p>
<code>
def suma(**kwargs):
suma = 0;
for key, value in kwargs.items():
print(key, value)
suma += value
return suma
suma(a=5, b=20, c=23) # 48
</code>
<p>
De igual manera, podemos pasar un diccionario como parámetro de entrada.
</p>
<code>
def suma(**kwargs):
suma = 0
for key, value in kwargs.items():
print(key, value)
suma += value
return suma
di = {'a': 10, 'b':20}
suma(**di) # 30
</code>
</div>
</section>
</main>
</body>
</html>
'''
**Información de tu navegador:**
El agente de usuario es: <code>Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36</code>
**Desafío:** Proyectos de diseño web responsivo - Construye una página de documentación técnica
**Enlaza al desafío:**
https://www.freecodecamp.org/espanol/learn/responsive-web-design/responsive-web-design-projects/build-a-technical-documentation-page