python-como la comprensión de listas en java
dado que java no permite pasar métodos como parámetros, ¿qué truco de hacer que se utiliza para implementar python como la comprensión de listas en java ? tengo una lista (arraylist) de las cadenas. necesito transformar a cada elemento mediante el uso de una función de manera que puedo obtener otra lista. tengo varias funciones que toma una cadena como entrada y devuelve otra cadena como de salida. ¿cómo puedo hacer que un método genérico que se da la lista y la función como parámetros para que yo pueda obtener una lista con cada elemento de procesado. no es posible en el sentido literal de la palabra, pero ¿qué truco debo usar ? la otra opción es escribir una nueva función para cada una de las más pequeñas de la cadena de procesamiento de la función que simplemente se repite a lo largo de toda la lista, que es un poco no tan fresco.
básicamente, se crea una función de interfaz:public interface func { public out apply(in in); } y, a continuación, pasar una subclase anónima a través de su método.su método se podría aplicar la función a cada elemento en el lugar:public static void applytolistinplace(list list, func f) { listiterator itr = list.listiterator(); while (itr.hasnext()) { t output = f.apply(itr.next()); itr.set(output); } } // ... list mylist = ...; applytolistinplace(mylist, new func() { public string apply(string in) { return in.tolowercase(); } }); o crear un nuevo list (básicamente la creación de una asignación de la lista de entrada a la de salida de la lista):public static list map(list in, func f) { list out = new arraylist(in.size()); for (in inobj : in) { out.add(f.apply(inobj)); } return out; } // ... list mylist = ...; list lowercased = map(mylist, new func() { public string apply(string in) { return in.tolowercase(); } }); que uno es preferible depende de su caso de uso. si la lista es muy grande, en lugar de la solución puede ser la única solución viable; si usted desea aplicar a muchas funciones diferentes a la misma lista original para hacer muchas otras listas, usted va a querer la map versión.
bueno en mi caso estoy terminando la ingenieria pero en mi carrera haces 2 estadias. cuando sali de tecnico tuve que ir a una empresa que desarrollaba software y obiamente me las vi duras por que usaban muchos frameworks (importante practicarlos muchas empresas los muy en cuenta) que no conocia de java y para el colmo no era bueno programando pero si algo aprendi fue lo siguiente. 

1. estudia (lee manuales, practica sus ejemplos, analiza el codigo y berifica linea por linea que paso o como lo obtuvo la maquina, si existe alguna propiedad que no entiendas, buscala. realiza anotaciones en tu codigo para que recuerdes como es la sintaxis o que hace cada linea hasta que te acostumbres. describe tus metodos y clases). 

2. no todo es programación. recuerda que muchas empresas realizan productos o servicios que estan relacionados con otros a su vez y que ya estan hechos cuando tu llegas, por lo que debes adaptarte al flujo que toman. debes analizarlo muy buen preguntar preguntar y preguntar lo que haga falta para que lo comprendas y por nada del mundo te quedes 1 hora estancado en algo por no preguntar. 

3.bases de datos. aprendelas muy bien por que las vas a necesitar igual y aveces se pasa de largo. 

4.orientate. debes saber bien el enfoque al que pretendes trabajar en el futuro (desarrollador web, aplicaciones moviles, juegos,realidad virtual, etc). y dar un porcentaje mas de tu tiempo a ese sector, recuerda "el que mucho abarca poco aprieta". 

5. frameworks. como dije antes muchas empresas usan muchos frameworks ya que lo que se espera es optimizar los procesos por lo que debes de aprender los mas utilizados o famosos (como jquery en javascrip, bootstrap, spring en java, hibernate para bases de datos, zk en aplicaciones web, etc).

6. ide. aprende los mas famosos, nunca sabes que entorno de desarrollo encontraras en tu estación de trabajo (eclipse, netbeans, visual studio, sublime text, android studio, etc). y no siempre podras cambiarlo por que tu usas y desconocerlos puede causarte atrasos.

bueno eso es lo que puedo decirte, pero en general cuando le agarras la onda y le pierdes el miedo veras que todo se te va a ir asiendo costumbre. buen dia. se denomina caja de herramientas normalmente en programas, mas que nada de diseño grafico.
 en la caja de herramientas de photoshop por ejemplo estan el pincel, la goma de borrar, podes trazar lineas y demas.
 cada programa tiene distintas cosas en sus cajas de herramientas, pero basicamente la idea de caja de herramientas es eso, son las herramientas que te permiten trabajar con el programa.

espero haberte aclarado tu duda.

exitos para visualizarlo como tal solo lo e visto en addons de producción avanzada. en sap lo puedes visualizar solo en el reporte de listas de materiales.

en ordenes de fabricación, sap solo visualiza a nivel stock, debes crear la orden de fabricación de forma independiente y una vez que la generes el s… Si te explicas, el problema es que la función se tendría que aplicar a cada ciertos rangos y dependiendo de los datos en las celdas se podrá o no sumar.  
No entiendo por qué pones datos en esta forma, lo siento un poco desordenado. Para cuestiones de análisis es mejor que los datos estén continuos. Si lo que tienes son grupos de datos puedes utilizar la función =Sumar. Si() o =Contar. Si().  
Cualquier cosa me mandas un ejemplo de tu archivo y trato de orientarte. <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> En pocas palabras: LINQ to Entities no conoce la conversión de su tipo de ID a una cadena. 

 ¿Cuál es el tipo de `c.ID` ? ¿Hay alguna razón por la que sea un tipo para ID, pero otro para `ReferenzId` ? Si es posible, conviértalos en el mismo tipo, en cuyo punto ya no tendrá más problemas. No sé si hay otras formas de realizar conversiones en LINQ a Entidades (puede haber), pero la alineación de los tipos sería más clara. 

 Por cierto, esto realmente parece que es una combinación: 


```
var query = from c in db.Customers
            join a in db.Addresses on c.Id equals a.ReferenzId into addresses
            select new { Id = c.Id, Addresses = addresses };

```
  EDITAR: Para responder a su comentario: `ToString` aparece en IntelliSense porque el compilador no tiene una idea real de lo que va a significar su consulta ni de cómo se traducirá. Es perfectamente válido C #, y puede generar un árbol de expresiones válido. Es solo que EF no sabe cómo convertir ese árbol de expresiones en SQL. 

 Puede *intentar* usar `Convert.ToString(c.Id)` lugar de simplemente llamar a `c.Id.ToString()` ... <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> Permítanme comenzar replanteando la pregunta de una manera más concisa. 


>  Una expresión lambda se puede convertir a la `Expression<T>` donde `T` es un tipo de delegado compatible con la expresión lambda. `Expression<T>` se deriva de `LambdaExpression` . ¿Por qué entonces no podemos convertir una expresión lambda directamente a `LambdaExpression` ? 
> 
> 

 La razón es: porque esta es una de las situaciones raras en C # donde la información de tipo fluye desde el *tipo de objetivo de asignación* al *tipo de cosa que se asigna* . El compilador debe conocer el tipo de delegado al convertir un lambda; **el compilador de C # no deduce el tipo de delegado de la lambda, sino que verifica que la lambda es compatible con el tipo de delegado dado** . 

 Ahora, ¿podríamos haber diseñado e implementado un sistema en el que si la información de tipo no estuviera presente y el objetivo de conversión fuera `LambdaExpression` , se realizaría una estimación razonable? Por supuesto. No había nada que nos detuviera más que nadie que deseara o necesitara esa característica. 

 Pero la respuesta a la pregunta "¿por qué no existe esta característica?" Siempre es lo mismo. **No estamos obligados a dar una razón para no implementar una función** . Nadie solicitó esa característica, nadie la diseñó, la implementó, probó ni la envió a los clientes. Por lo tanto, ninguna característica. 

 Más bien, las características no existentes requieren que un defensor empiece a convertirlas en características existentes. Si esta es una función que desea o necesita, tómela en el foro de github y defienda la función. O implementarlo usted mismo; El compilador es de código abierto. Funcionaria con la fórmula concatenar, pero así la estas usando mal.  
Tendrías que en la columna c, concatenar a y b, y luego en otra celda:  
la formula =CONTAR.SI(C:C;"A0").  
La otra, para no concatenar en la columna C, seria hacer una fórmula personalizada.  
Si te interesa así, te digo como hacerla, si no sabes claro.  
Carlos Leal Los ejemplos que otros han dado no funcionarán en Entity Framework hoy, porque no se pueden combinar enumeración de clientes y servidores en las entidades LINQ 2. 

 En su lugar, necesita construir una expresión OR, manualmente. 

 Ejecuto una serie de [consejos](http://blogs.msdn.com/alexj/archive/2009/03/26/index-of-tips.aspx) de [EF](http://blogs.msdn.com/alexj/archive/2009/03/26/index-of-tips.aspx) y [este consejo](http://blogs.msdn.com/alexj/archive/2009/03/26/tip-8-writing-where-in-style-queries-using-linq-to-entities.aspx) te muestra cómo construir una expresión OR. 

 Espero que esto ayude 

 Alex