¿qué hace la palabra clave "rendimiento"?
<p>¿para qué sirve la palabra clave <code>yield</code> en python? ¿qué hace?</p><p>por ejemplo, estoy tratando de entender este código.<sup><strong> 1 </strong></sup>:</p><pre><code>def \_get\_child\_candidates(self, distance, min\_dist, max\_dist): if self.\_leftchild and distance - max\_dist &lt; self.\_median: yield self.\_leftchild if self.\_rightchild and distance + max\_dist &gt;= self.\_median: yield self.\_rightchild </code></pre><p>y esta es la persona que llama:</p><pre><code>result, candidates = [], [self] while candidates: node = candidates.pop() distance = node.\_get\_dist(obj) if distance &lt;= max\_dist and distance &gt;= min\_dist: result.extend(node.\_values) candidates.extend(node.\_get\_child\_candidates(distance, min\_dist, max\_dist)) return result </code></pre><p>¿qué sucede cuando se llama al método <code>\_get\_child\_candidates</code>? ¿se devuelve una lista? ¿un solo elemento? ¿se llama de nuevo? ¿cuándo se detendrán las llamadas posteriores?</p><hr><p><sub>1. este código fue escrito por jochen schulz (jrschulz), quien hizo una gran biblioteca python para espacios métricos. este es el enlace a la fuente completa: <a href="http://well-adjusted.de/~jrschulz/mspace/">módulo mspace</a> .</sub></p>
<p>para comprender lo que hace <code>yield</code>, debe comprender qué <em>generadores</em> son. y antes de que lleguen los generadores <em>iterables</em>.</p><h2>iterables</h2><p>cuando creas una lista, puedes leer sus artículos uno por uno. la lectura de sus elementos uno por uno se llama iteración:</p><pre><code>&gt;&gt;&gt; mylist = [1, 2, 3] &gt;&gt;&gt; for i in mylist: ... print(i) 1 2 3 </code></pre><p><code>mylist</code> es un <em>iterable</em>. cuando usas una comprensión de lista, creas una lista, y por lo tanto una iterable:</p><pre><code>&gt;&gt;&gt; mylist = [x*x for x in range(3)] &gt;&gt;&gt; for i in mylist: ... print(i) 0 1 4 </code></pre><p>todo lo que puede usar &quot;<code>for... in...</code>&quot; en es iterable; <code>lists</code>, <code>strings</code>, archivos ...</p><p>estos iterables son útiles porque puede leerlos tanto como desee, pero almacena todos los valores en la memoria y esto no siempre es lo que desea cuando tiene muchos valores.</p><h2>generadores</h2><p>los generadores son iteradores, una clase de iterable<strong> solo puedes iterar una vez </strong>. los generadores no almacenan todos los valores en la memoria,<strong> generan los valores sobre la marcha </strong>:</p><pre><code>&gt;&gt;&gt; mygenerator = (x*x for x in range(3)) &gt;&gt;&gt; for i in mygenerator: ... print(i) 0 1 4 </code></pre><p>es igual, excepto que usaste <code>()</code> en lugar de <code>[]</code>. pero, usted<strong> no puede </strong>realizar <code>for i in mygenerator</code> por segunda vez, ya que los generadores solo se pueden usar una vez: calculan 0, luego se olvidan y calculan 1, y terminan de calcular 4, uno por uno.</p><h2>rendimiento</h2><p><code>yield</code> es una palabra clave que se usa como <code>return</code>, excepto que la función devolverá un generador.</p><pre><code>&gt;&gt;&gt; def creategenerator(): ... mylist = range(3) ... for i in mylist: ... yield i*i ... &gt;&gt;&gt; mygenerator = creategenerator() # create a generator &gt;&gt;&gt; print(mygenerator) # mygenerator is an object! &lt;generator object creategenerator at 0xb7555c34&gt; &gt;&gt;&gt; for i in mygenerator: ... print(i) 0 1 4 </code></pre><p>este es un ejemplo inútil, pero es útil cuando sabes que tu función devolverá un gran conjunto de valores que solo necesitarás leer una vez.</p><p>para dominar <code>yield</code>, debe comprender que<strong> cuando llama a la función, el código que ha escrito en el cuerpo de la función no se ejecuta. </strong>la función solo devuelve el objeto generador, esto es un poco complicado :-)</p><p>luego, su código continuará desde donde lo dejó cada vez que <code>for</code> usa el generador.</p><p>ahora la parte difícil:</p><p>la primera vez que <code>for</code> llama al objeto generador creado desde su función, ejecutará el código en su función desde el principio hasta que llegue a <code>yield</code>, luego devolverá el primer valor del bucle. luego, cada una de las otras llamadas ejecutará el bucle que ha escrito en la función una vez más y devolverá el siguiente valor, hasta que no haya ningún valor para devolver.</p><p>el generador se considera vacío una vez que se ejecuta la función, pero ya no golpea <code>yield</code>. puede ser porque el bucle llegó a su fin, o porque ya no satisfaces un <code>"if/else"</code>.</p><hr><h2>tu codigo explicado</h2><p>generador:</p><pre><code># here you create the method of the node object that will return the generator def \_get\_child\_candidates(self, distance, min\_dist, max\_dist): # here is the code that will be called each time you use the generator object: # if there is still a child of the node object on its left # and if distance is ok, return the next child if self.\_leftchild and distance - max\_dist &lt; self.\_median: yield self.\_leftchild # if there is still a child of the node object on its right # and if distance is ok, return the next child if self.\_rightchild and distance + max\_dist &gt;= self.\_median: yield self.\_rightchild # if the function arrives here, the generator will be considered empty # there is no more than two values: the left and the right children </code></pre><p>llamador:</p><pre><code># create an empty list and a list with the current object reference result, candidates = list(), [self] # loop on candidates (they contain only one element at the beginning) while candidates: # get the last candidate and remove it from the list node = candidates.pop() # get the distance between obj and the candidate distance = node.\_get\_dist(obj) # if distance is ok, then you can fill the result if distance &lt;= max\_dist and distance &gt;= min\_dist: result.extend(node.\_values) # add the children of the candidate in the candidates list # so the loop will keep running until it will have looked # at all the children of the children of the children, etc. of the candidate candidates.extend(node.\_get\_child\_candidates(distance, min\_dist, max\_dist)) return result </code></pre><p>este código contiene varias partes inteligentes:</p><ul> <li><p>el bucle se repite en una lista, pero la lista se expande mientras se repite el bucle :-) es una forma concisa de revisar todos estos datos anidados, aunque sea un poco peligroso, ya que puede terminar con un bucle infinito. en este caso, <code>candidates.extend(node.\_get\_child\_candidates(distance, min\_dist, max\_dist))</code> agota todos los valores del generador, pero <code>while</code> sigue creando nuevos objetos generadores que producirán valores diferentes de los anteriores ya que no se aplica en el mismo nodo.</p></li> <li><p>el método <code>extend()</code> es un método de objeto de lista que espera un iterable y agrega sus valores a la lista.</p></li> </ul><p>usualmente le pasamos una lista:</p><pre><code>&gt;&gt;&gt; a = [1, 2] &gt;&gt;&gt; b = [3, 4] &gt;&gt;&gt; a.extend(b) &gt;&gt;&gt; print(a) [1, 2, 3, 4] </code></pre><p>pero en tu código recibe un generador, lo cual es bueno porque:</p><ol> <li>no necesitas leer los valores dos veces.</li> <li>es posible que tenga muchos hijos y no quiera que todos se almacenen en la memoria.</li> </ol><p>y funciona porque a python no le importa si el argumento de un método es una lista o no. python espera iterables por lo que trabajará con cadenas, listas, tuplas y generadores. esto se llama tipificación de pato y es una de las razones por las que python es tan genial. pero esta es otra historia, para otra pregunta ...</p><p>puede detenerse aquí, o leer un poco para ver un uso avanzado de un generador:</p><h2>controlando el agotamiento de un generador.</h2><pre><code>&gt;&gt;&gt; class bank(): # let's create a bank, building atms ... crisis = false ... def create\_atm(self): ... while not self.crisis: ... yield "$100" &gt;&gt;&gt; hsbc = bank() # when everything's ok the atm gives you as much as you want &gt;&gt;&gt; corner\_street\_atm = hsbc.create\_atm() &gt;&gt;&gt; print(corner\_street\_atm.next()) $100 &gt;&gt;&gt; print(corner\_street\_atm.next()) $100 &gt;&gt;&gt; print([corner\_street\_atm.next() for cash in range(5)]) ['$100', '$100', '$100', '$100', '$100'] &gt;&gt;&gt; hsbc.crisis = true # crisis is coming, no more money! &gt;&gt;&gt; print(corner\_street\_atm.next()) &lt;type 'exceptions.stopiteration'&gt; &gt;&gt;&gt; wall\_street\_atm = hsbc.create\_atm() # it's even true for new atms &gt;&gt;&gt; print(wall\_street\_atm.next()) &lt;type 'exceptions.stopiteration'&gt; &gt;&gt;&gt; hsbc.crisis = false # the trouble is, even post-crisis the atm remains empty &gt;&gt;&gt; print(corner\_street\_atm.next()) &lt;type 'exceptions.stopiteration'&gt; &gt;&gt;&gt; brand\_new\_atm = hsbc.create\_atm() # build a new one to get back in business &gt;&gt;&gt; for cash in brand\_new\_atm: ... print cash $100 $100 $100 $100 $100 $100 $100 $100 $100 ... </code></pre><p><strong> nota: </strong>para python 3, use<code>print(corner\_street\_atm.\_\_next\_\_())</code> o <code>print(next(corner\_street\_atm))</code></p><p>puede ser útil para varias cosas como controlar el acceso a un recurso.</p><h2>itertools, tu mejor amigo.</h2><p>el módulo de itertools contiene funciones especiales para manipular iterables. ¿alguna vez desea duplicar un generador? ¿encadenar dos generadores? ¿agrupar valores en una lista anidada con una sola línea? <code>map / zip</code> sin crear otra lista?</p><p>entonces solo <code>import itertools</code>.</p><p>¿un ejemplo? veamos las posibles órdenes de llegada para una carrera de cuatro caballos:</p><pre><code>&gt;&gt;&gt; horses = [1, 2, 3, 4] &gt;&gt;&gt; races = itertools.permutations(horses) &gt;&gt;&gt; print(races) &lt;itertools.permutations object at 0xb754f1dc&gt; &gt;&gt;&gt; print(list(itertools.permutations(horses))) [(1, 2, 3, 4), (1, 2, 4, 3), (1, 3, 2, 4), (1, 3, 4, 2), (1, 4, 2, 3), (1, 4, 3, 2), (2, 1, 3, 4), (2, 1, 4, 3), (2, 3, 1, 4), (2, 3, 4, 1), (2, 4, 1, 3), (2, 4, 3, 1), (3, 1, 2, 4), (3, 1, 4, 2), (3, 2, 1, 4), (3, 2, 4, 1), (3, 4, 1, 2), (3, 4, 2, 1), (4, 1, 2, 3), (4, 1, 3, 2), (4, 2, 1, 3), (4, 2, 3, 1), (4, 3, 1, 2), (4, 3, 2, 1)] </code></pre><h2>entendiendo los mecanismos internos de iteración.</h2><p>la iteración es un proceso que implica iterables (implementación del método <code>\_\_iter\_\_()</code>) e iteradores (implementación del método <code>\_\_next\_\_()</code>). iterables son cualquier objeto de los que puede obtener un iterador. los iteradores son objetos que le permiten iterar en iterables.</p><p>hay más información al respecto en este artículo sobre <a href="http://effbot.org/zone/python-for-statement.htm">cómo funcionan <code>for</code> loops</a> .</p>
<p>la implementación <a href="https://pypi.org/project/markdown/">markdown en python</a> tiene soporte para extensiones, una de las cuales incluye la generación de tabla de contenido. además <a href="http://johnmacfarlane.net/pandoc/">pandoc</a> (que es un marcado de haskell-&gt; pdf tiene soporte para markdown (además de un montón de otros formatos) y puede generar bastante html, latex, pdf, etc.</p> **Compilacion** 

 La llamada a `Expression.Compile` pasa exactamente por el mismo proceso que cualquier otro código .NET que su aplicación contenga en el sentido de que: 

* Se genera el código IL
* El código IL está JIT-ted al código de máquina

 (se omite el paso de análisis porque ya se creó un árbol de expresión y no es necesario generarlo a partir del código de entrada) 

 Puede mirar el [código fuente](http://referencesource.microsoft.com/#System.Core/Microsoft/Scripting/Compiler/LambdaCompiler.cs) del compilador de expresiones para verificar que efectivamente se genera el código IL. 

 **Mejoramiento** 

 Tenga en cuenta que casi toda la optimización realizada por el CLR se realiza en el paso JIT, no desde la compilación del código fuente de C #. Esta optimización también se realizará al compilar el código IL de su delegado lambda a código máquina. 

 **Su ejemplo** 

 En su ejemplo, está comparando manzanas y naranjas. El primer ejemplo es una definición de método, el segundo ejemplo es código de tiempo de ejecución que crea un método, lo compila y lo ejecuta. El tiempo que lleva crear / compilar el método es mucho más largo que ejecutarlo realmente. Sin embargo, puede mantener una instancia del método compilado después de la creación. Cuando haya hecho eso, el rendimiento de su método generado debería ser idéntico al del método C # original. 

 Considere este caso: 


```
private static int AddMethod(int a, int b)
{
    return a + b;
}

Func<int, int, int> add1 = (a, b) => a + b;
Func<int, int, int> add2 = AddMethod;

var x = Expression.Parameter(typeof (int));
var y = Expression.Parameter(typeof (int));
var additionExpr = Expression.Add(x, y);
Func<int, int, int> add3 = 
              Expression.Lambda<Func<int, int, int>>(
                  additionExpr, x, y).Compile();
//the above steps cost a lot of time, relatively.

//performance of these three should be identical
add1(1, 2);
add2(1, 2);
add3(1, 2);

```
  Entonces, la conclusión que se puede sacar es: el código IL es código IL, sin importar cómo se genere, y las expresiones Linq generan código IL. los conectores (también llamados nexos o relaciones) son frases o palabras que se utilizan para conectar o vincular una idea con otra en un texto (oral u escrito). los conectores permiten que el texto tenga una estructura lógica y coherente, y su ausencia o su mala utilización vuelven difícil la comprensión de las ideas.

tipos de conectores con ejemplos:

conectores de causa. determinan causalidad, por ejemplo: dado que, debido a, gracias a, por culpa de, porque, puesto que.

conectores copulativo. unen expresiones, por ejemplo: y, e, ni.

conectores disyuntivos. unen expresiones que plantean dos opciones contrapuestas, por ejemplo: o, u.

conectores de argumentación. se utilizan para explicar un argumento, por ejemplo: a saber, de lo contrario, por otra parte, sobre todo, por último.

conectores de cronología. determinan el orden de las acciones, por ejemplo: en primer lugar, ante todo, finalmente, luego, más tarde.

conectores de consecuencia. determinan consecuencia, por ejemplo: a fin de, de manera que, entonces, por consiguiente, por eso.

conectores de referencia. se utilizan para establecer las relaciones entre conceptos, por ejemplo: de esta manera, en cuanto a, en lo que respecta, respecto de, según.

conectores de resumen. introducen la síntesis de la información, por ejemplo: en pocas palabras, en resumen, resumiendo, para resumir, en concreto.

conectores de temporalidad. indican la temporalidad de la acción, por ejemplo: ahora, antes, apenas, en aquel tiempo, hoy en día, hasta.

conectores de oposición o adversativos. unen partes contrapuestas, por ejemplo: al contrario, aunque, a pesar de, no obstante, pero, sin embargo.

conectores de ilustración o explicativos. introducen la explicación de lo anteriormente dicho, por ejemplo: en otras palabras, por ejemplo, o sea, es decir, así.

conectores de condición. expresan condición, por ejemplo: en caso de que, siempre que, suponiendo que, si, con tal que.

conectores de comparación. introducen una comparación entre los elementos o entre dos oraciones, por ejemplo: más que, menos que, a diferencia de.

conectores concesivos. introducen un condicionamiento que puede ser sorteado o superado, por ejemplo: aunque, a pesar de, pese a.

conectores de lugar. introducen el escenario en el que se desarrolla la acción, por ejemplo: donde, en donde, adonde.

conectores de modo. introducen la manera en la que se lleva a cabo la acción, por ejemplo: según, tal como, así como.

ejemplos de conectores:

a fin de

entonces

a saber

para terminar

por otra parte

en seguida

en concreto

de tal manera que

en cambio

al principio

con la condición de que

por último

con el objeto de

además

primeramente

en cuanto a esto

brevemente

al mismo tiempo

gracias a

una vez

en caso de que

en lo que respecta

por más que

antes

siempre que

en conclusión

de esta manera

ahora

en aquel tiempo

con tal que

acto seguido

en primer lugar

respecto a

finalmente

en nuestros días

a consecuencia de

cuando

sobre todo

desde entonces

érase una vez

primero

en cuanto a

en este caso

por eso

en pocas palabras

aunque

para resumir

a pesar de

resumiendo

por lo tanto

respecto de

segundo

de lo contrario

en aquellos días

hasta

más tarde

es decir

actualmente

una vez que

puesto que

en segundo lugar

desde

suponiendo que

mientras tanto

en otras palabras

tan pronto como

hoy en día

tercero

sin embargo

si

al respecto

pero

al contrario

según

antes que nada

por culpa de

en tercer lugar

de manera que

para

por ejemplo

ya que

como

cuarto

mientras que

de esa manera

o sea

por consiguiente

no obstante

debido a

mientras

en cuarto lugar

así

porque

dado que

por una parte

visto que

ahora que

ejemplos de oraciones con conectores:

pienso, luego existo.

fueron a la fiesta después del examen.

viajaron a méxico durante el receso de vacaciones.

en pocas palabras, es el hombre más afortunado del mundo.

quisieron ayudarlo, aunque no había nada que hacer.

para resumir, todo salió como lo esperaban.

en resumen, nos prohibieron el acceso por dos semanas.

ante todo, pedimos disculpas a los afectados.

apenas consiga un trabajo, comenzaré a ahorrar.

para empezar, quisiera agradecer a los aquí presentes. En una investigación se requiere aplicar el método científico para ordenar, clasificar, sistematizar, procesar, interpretar la información generada producto de la investigación. Por ejemplo si investigas la talla de los pollos en relación a la cantidad de comida en un tiempo determinado, puedes juntar datos de mil pollos, pero así en bruto no te sirve para nada, en cambio si ordenas esos datos, a partir de allí haces gráficas, las puedes interpretar y concluir qué tanto influye la cantidad de alimento en la talla. Entonces, su problema es que confía en posiciones dentro de su XPath. Si bien esto puede estar bien en algunos casos, no está aquí, porque está esperando que el **primer** `td` en un `tr` dado tenga un `div` con la clase. 

 Mirando la fuente en Chrome, muestra que no siempre es así. Puede ver esto comparando el elemento "1" en el calendario, a "2" y "3". Notará que el elemento "1" tiene una serie de elementos a su alrededor, que los demás no. 

 Su consulta XPath original no devuelve un elemento, es por eso que está recibiendo el error. En el caso de que la consulta XPath que proporcione a HtmlAgilityPack no produzca un elemento DOM, devolverá un valor nulo. 

 Ahora, debido a que no ha mostrado su código completo, no sé cómo se está ejecutando este código. Sin embargo, supongo que está intentando recorrer todos los elementos del calendario. En cualquier caso, tiene varias formas de hacer esto, pero le mostraré que con el selector de XPath `descendant` , *puede* agarrar todo el lote de una vez: 


```
//div[@class='kal']//table//descendant::div[@class='cipars']

```
  Esto devolverá *todos* los elementos del calendario (es decir, de 1 a 30). 

 Sin embargo, para obtener todos los elementos en una fila en particular, simplemente puede pegar ese `tr` en la consulta: 


```
//div[@class='kal']//table//tr[3]/descendant::div[@class='cipars']

```
  Esto devolvería 2 a 8 (la segunda fila de elementos del calendario). 

 Para apuntar a uno específico, bueno, tendrá que hacer una suposición sobre el código fuente del sitio web. Parece que cada `div` "cipars" tiene un ancestro de `td` con `datums` clase ... así que para obtener el valor "3" de tu pregunta: 


```
//div[@class='kal']//table//tr[3]//td[@class='datums'][2]/div[@class='cipars']

```
  Esperemos que esto sea suficiente para mostrar al menos el problema. 

 **Editar** 

 Aunque tiene un problema de XPath, también tiene otro problema. 

 El sitio está creado muy extrañamente. El calendario se carga de una manera extraña. Cuando llego a esa URL, el calendario se crea mediante algún Javascript que llama a un servicio web XML (escrito en PHP) que luego calcula la `table` completa que se usará para el calendario. 

 Debido a que esto es Javascript (código del lado del cliente), HtmlAgilityPack no lo ejecutará. Por lo tanto, HtmlAgilityPack ni siquiera "ve" la tabla. Por lo tanto, las consultas en su contra vuelven como "no encontradas" (null). 

 Formas de evitar esto: 1) Use una herramienta que llame a los scripts. Con esto, me refiero a cargar un navegador. Una gran herramienta para usar para esto se llama [Selenium](http://docs.seleniumhq.org/) . Esta será probablemente la mejor solución general porque significa que se llamará a todos los scripts utilizados por el sitio. Aún puede usar XPath con él, por lo que sus consultas no cambiarán. 

 La segunda forma es enviar una solicitud al *mismo* servicio web que la página. Esto es básicamente para obtener de vuelta el *mismo* HTML que la página está recibiendo, y el uso *que* con HtmlAgilityPack. ¿Como hacemos eso? 

 Bueno, usted puede POST fácilmente datos a un servicio web usando C #. Solo por facilidad de uso, he robado el código de [esta pregunta SO](https://stackoverflow.com/questions/4718420/sending-post-data-with-c-sharp) . Con esto, podemos enviar la misma solicitud que la página y recuperar el mismo HTML. 

 Entonces, para enviar algunos datos POST, generamos un método así ... 


```
public static string SendPost(string url, string postData)
{
    string webpageContent = string.Empty;

    byte[] byteArray = Encoding.UTF8.GetBytes(postData);

    HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url);
    webRequest.Method = "POST";
    webRequest.ContentType = "application/x-www-form-urlencoded";
    webRequest.ContentLength = byteArray.Length;

    using (Stream webpageStream = webRequest.GetRequestStream())
    {
        webpageStream.Write(byteArray, 0, byteArray.Length);
    }

    using (HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse())
    {
        using (StreamReader reader = new StreamReader(webResponse.GetResponseStream()))
        {
            webpageContent = reader.ReadToEnd();
        }
    }

    return webpageContent;
}

```
  Podemos llamarlo así: 


```
string responseBody = SendPost("http://lekcijas.va.lv/lekcijas_request.php", "nodala=IT&kurss=1&gads=2013&menesis=9&c_dala=");

```
  ¿Cómo conseguí esto? Bueno, el archivo `php` que estamos llamando es el servicio web que es la página, y los datos POST también lo son. La forma en que descubrí qué datos envía al servicio es mediante la depuración del Javascript (usando la Consola de desarrollador de Chrome), **pero** puede notar que es casi lo mismo que está en la URL. Eso parece ser intencional. 

 El `responseBody` que se devuelve es el **HTML físico** de *solo* la `table` para el calendario. 

 ¿Qué hacemos con eso ahora? Lo cargamos en HtmlAgilityPack, porque puede aceptar HTML puro. 


```
var document = new HtmlDocument();
document.LoadHtml(webpageContent);

```
  Ahora, pegamos ese XPath original en: 


```
var node = document.DocumentNode.SelectSingleNode("//div[@class='kal']//table//tr[3]//td[@class='datums'][2]/div[@class='cipars']");

```
  Ahora, imprimimos lo que esperamos sea "3": 


```
Console.WriteLine(node.InnerText);

```
  Mi salida, ejecutándolo localmente, es de hecho: **3** . 

 Sin embargo, aunque esto le ayude a superar el problema que está teniendo, asumo que el resto del sitio es así. Si este es el caso, es posible que aún puedas solucionarlo utilizando la técnica anterior, pero las herramientas como Selenium se crearon por esta misma razón. hola

progresion aritmetica
progresión aritmética
en matemáticas, una progresión aritmética es una serie de números tales que la diferencia de dos términos sucesivos cualesquiera de la secuencia es una constante, cantidad llamada diferencia de la progresión o simplemente diferencia o incluso "distancia".
por ejemplo, la sucesión 3, 5, 7, 9, 11,... es una progresión aritmética de constante (o diferencia común)
progresión geométrica
una sucesión geométrica está constituida por una secuencia de elementos en la que cada uno de ellos se obtiene multiplicando el anterior por una constante denominada razón o factor de la progresión. se suele reservar el término progresión cuando la secuencia tiene una cantidad finita de términos mientras que se usa sucesión cuando hay una cantidad infinita de términos, si bien, esta distinción no es estricta.
ciencia
el conocimiento científico adquirido a lo largo de la historia de la humanidad ha permitido al hombre realizar hazañas tan prodigiosas como, por ejemplo, llegar a la luna, logros que apenas hace unas décadas antes habrían resultado posibles únicamente en la imaginación.
método científico
el método científico (del griego: -μετά = hacia, a lo largo- -οδός = camino-; y del latín scientia = conocimiento; camino hacia el conocimiento) es un método de investigación usado principalmente en la producción de conocimiento en las ciencias. presenta diversas definiciones debido a la complejidad de una exactitud en su conceptualización: "conjunto de pasos fijados de antemano por una disciplina con el fin de alcanzar conocimientos válidos mediante instrumentos confiables"[cita requerida], "secuencia estándar para formular y responder a una pregunta"[cita requerida], "pauta que permite a los investigadores ir desde el punto a hasta el punto z con la confianza de obtener un conocimiento válido"[cita requerida].
ciencias de la salud
ciencias de la salud es la disciplina que proporciona los conocimientos adecuados para la promoción de la salud y el bienestar... mira el ensayo si lo puedes escirbir del cuento introducción: el párrafo que introduce el tema e indica al  lector el asunto a tratar se llama párrafo introductorio. puede comenzar con una pregunta, una reflexión, una estadística que propicie la discusión del tema y capture el interés del lector. si el ensayo es extenso puede tener varios párrafos en la introducción.
10. desarrollo: los párrafos que desarrollan el tema se  llaman párrafos de desarrollo. la mayor parte de un ensayo está escrito en párrafos de esta categoría. cuando un escritor(a) termina de discutir una idea y va a empezar con otra, frecuentemente utiliza un párrafo corto u oraciones de transición para entrelazar las mismas de forma tal que faciliten la coherencia y unidad de los párrafos.
11. cont. desarrollo: los párrafos que cumplen con esta función  se conocen como párrafo de transición. este se puede referir a lo que se ha dicho y sugerir lo que se dirá.
12. conclusión la aportación y opinión final del escritor(a) se  presenta en la conclusión. es el cierre del ensayo, su aportación. <p>parece que el comando <code>tee</code> hará lo que quieras.</p><p>la clave es usar</p><pre><code>&gt;( ) </code></pre><p>para <a href="http://tldp.org/ldp/abs/html/process-sub.html">sustitución de proceso</a> . con <code>tee</code>, use el siguiente patrón:</p><pre><code>tee &gt;(proc1) &gt;(proc2) &gt;(proc3) | proc4 </code></pre><p>entonces, si desea utilizar la salida de <code>ls</code> como entrada a dos programas <code>grep</code> diferentes, guarde la salida de cada <code>grep</code> en archivos diferentes y canalice todos los resultados a través de <code>less</code>, prueba:</p><pre><code>ls -a | tee &gt;(grep ^[.] &gt; hidden-files) &gt;(grep -v ^[.] &gt; normal-files) | less </code></pre><p>los resultados de la <code>ls -a</code> se "canalizará" en ambos <code>grep</code>s. el archivo <code>hidden-files</code> tendrá el contenido de la salida del primer <code>grep</code>, y <code>normal-files</code> tendrá los resultados del segundo <code>grep</code>. <del>todos los archivos se mostrarán en el localizador <code>less</code>.</del> <strong> [~ # ~] editar [~ # ~] </strong>: lo que ves en <code>less</code> es el <strong> la misma salida exacta </strong> de <code>ls -a</code>, no el resultado de <code>grep</code>s. si desea modificar la salida de <code>ls -a</code> a <code>less</code>, (por ejemplo, cambiando el orden para que los archivos normales se enumeren antes de los ocultos) y luego intente esto:</p><pre><code>ls -a | tee &gt;(grep ^[.]) &gt;(grep -v ^[.]) &gt;/dev/null | less </code></pre><p>sin <code>&gt;/dev/null</code>, la salida de <code>grep</code>s se agregaría a la salida de <code>ls -a</code> en lugar de reemplazarlo.</p><p> <a href="http://linux.byexamples.com/archives/144/redirect-output-to-multiple-processes/">fuente</a> </p> 1.- dividir 189 entre 15
2.- multiplica la medida que quieres obtener, por la cantidad de 1200, en la segunda pregunta, tendrás que dividir
3.-la media es el promedio, si tienes 10 números, súmalos y luego divídelos entre 10, y así obtienes la media, la moda es el número que más se repite en una serie de números hola,

su nombre en inglés es "x-tilde" si tiene el "~" encima.
y si tiene el guión plano "-" se llama "x-barra"

x̃ (x con tilde ~ superior)

- no significa promedio.
- en estadística representa a la media [estadística].
- en matemática equivale a la derivada cuando está sobre una "d"

tiene otros significados, pero creo que con lo comentado es suficiente.

b-)

"los que se enamoran de la práctica sin la teoría
son como los pilotos sin timón ni brújula,
que nunca podrán saber a dónde van."
(leonardo davinci)