Question

I want delete the array from list of arrays in that way

#!/usr/bin/perl

print "Content-type:text/html\n\n";
use LWP::Simple;

getprint("http://DOMAIN/");

I want remove an element

i = np.array([1,2])
facets = [np.array([1,2]),np.array([3,4])]

but obtain an error:

facets.remove(np.array(i[0],i[1]))

Is there a way to solve that problem?

Answer 1

Consider the following example:

/** Represents a partially applied, curried function `F` which is of the form `... X => A`,
  * where X is the type of the first argument after (partial) application.
  * Provides methods for manipulating functions `F` around this argument.
  * @tparam F type of the manipulated function in a curried form (non-empty sequence of single argument lists)
  * @tparam C[G] result of mapping partial result `(X=>A)` of function `F` to `G`.
  * @tparam X type of the argument represented by this instance
  * @tparam A result type of function F partially applied up to and including argument X
  */
abstract class Curry[F, C[G], X, A](private[funny] val f :F) { prev =>
    /** Result of partial application of this function F up to and including parameter `X`. */
    type Applied = A
    /** Replace X=>A with G as the result type of F. */
    type Composed[G] = C[G]
    /** A function which takes argument `W` instead of `X` at this position. */
    type Mapped[W] = Composed[W=>A]


    /** Provide a fixed value for this argument, removing it from the argument list.
      * For example, the result of `Curry{a :Any => b :Byte => c :Char => s"&dollar;a&dollar;b&dollar;c" }().set(1.toByte)`
      * (after inlining) would be a function `{a :Any => c :Char => s"&dollar;a&dollar;{1.toByte}&dollar;c" }`.
      */
    def set(x :X) :Composed[A] = applied[A](_(x))

    /** Change the type of this argument by mapping intended argument type `W` to `X` before applying `f`.
      * For example, given a function `f :F &lt;:&lt; D=>O=>X=>A` and `x :W=>X`, the result is `{d :D => o :O => w :W => f(d)(o)(x(w)) }`.
      */
    def map[W](x :W=>X) :Composed[W=>A] = applied[W=>A]{ r :(X=>A) => (w :W) => r(x(w)) }

    /** Map the result of partial application of this function up to argument `X` (not including).
      * For example, if `F =:= K=>L=>X=>A`, the result is a function `{k :K => l :L => map(f(k)(l)) }`.
      * @param map function taking the result of applying F up until argument `X`.
      * @return resul
      */
    def applied[G](map :((X => A) => G)) :Composed[G]

    /** If the result of this partial application is a function `A &lt;:&lt; Y=>Z`, swap the order of arguments
      * in function `F` from `=>X=>Y=>` to `=>Y=>X=>`.
      */
    def transpose[Y, Z](implicit ev :A<:<(Y=>Z)) :Composed[Y=>X=>Z] = applied[Y=>X=>Z] {
        r :(X=>A) => y :Y => x :X => ev(r(x))(y)
    }


    /** Skip to the next argument, i.e return an instance operating on the result of applying this function to argument `X`. */
    def apply[Y, Z]()(implicit ev :this.type<:<Curry[F, C, X, Y=>Z])  = new NextArg[F, C, X, Y, Z](ev(this))

    /** Skip to the next argument, i.e return an instance operating on the result of applying this function to argument `X`.
      * Same as `apply()`, but forces an implicit conversion from function types which `apply` wouldn't.
      */
    def __[Y, Z](implicit ev :this.type<:<Curry[F, C, X, Y=>Z])  = new NextArg[F, C, X, Y, Z](ev(this))
}


/** Operations on curried functions. */
object Curry {
    type Self[G] = G
    type Compose[C[G], X] = { type L[G] = C[X=>G] }

    /** Extension methods for modifying curried functions at their first argument (and a source for advancing to subsequent arguments. */
    @inline def apply[A, B](f :A=>B) :Arg0[A, B] = new Arg0(f)

    /** Implicit conversion providing extension methods on curried function types. Same as `apply`, but doesn't pollute namespace as much. */
    @inline implicit def ImplicitCurry[A, B](f :A=>B) :Arg0[A, B] = new Arg0(f)

    /** Operations on the first argument of this function. */
    class Arg0[X, Y](x :X=>Y) extends Curry[X=>Y, Self, X, Y](x) {

        def applied[G](map: (X=>Y) => G) :G = map(f)
    }

    class NextArg[F, C[G], X, Y, A](val prev :Curry[F, C, X, Y=>A]) extends Curry[F, (C Compose X)#L, Y, A](prev.f) {

        override def applied[G](map: (Y => A) => G): prev.Composed[X => G] =
            prev.applied[X=>G] { g :(X=>Y=>A) => x :X => map(g(x)) }
    }
}


def f :Byte=>Short=>Int=>Long=>String = ???

import Curry.ImplicitCurry

f.set(1.toByte) :(Short=>Int=>Long=>String)
f.map((_:String).toByte) :(String=>Short=>Int=>Long=>String)
f.__.set(1.toShort) :(Byte=>Int=>Long=>String)
Curry(f)().map((_:String).toShort) : (Byte=>String=>Int=>Long=>String)

This code does something like:

Iterate through the elements of ls = [1, 2, 3, 1] ls.remove(1).
Check whether each element is equal to ls.
If it does, it pops that element, and breaks iteration.

In step 2, your code is trying to compare two numpy arrays like 1. The problem is that numpy returns an array of truth values for this comparison.

array1 == array2

So, you're going to have to implement your own remove-like method.

>>> np.array([1,2]) == np.array([1,3])
array([ True, False], dtype=bool)

Usage:

def remove_from_array(base_array, test_array):
    for index in range(len(base_array)):
        if np.array_equal(base_array[index], test_array):
            base_array.pop(index)
            break
    raise ValueError('remove_from_array(array, x): x not in array')

Answer 2

The easiest way is to use Option Explicit Sub LoopExample() Dim rownumber, colnumber As Integer ' Step 1: start a loop from a desired position For rownumber = 30 To 3000 For colnumber = 30 To 3000 ' Step 2: check that the cell is not empty If IsEmpty(Cells(rownumber, colnumber).Value) = False Then ' Step 3: change all "Cat" texts to "Dog" If Cells(rownumber, colnumber).Value = "Cat" Then Cells(rownumber, colnumber).Value = "Dog" ' Step 4: if the cell value is numeric... ElseIf IsNumeric(Cells(rownumber, colnumber).Value) Then ' ...check another thing and execute something accordingly If (Cells(rownumber, colnumber).Value) / 2 < 0.5 Then Cells(rownumber, colnumber) = Round(Cells(rownumber, colnumber).Value, 4) Else Cells(rownumber, colnumber) = Round(Cells(rownumber, colnumber).Value, 1) End If End If End If Next colnumber Next rownumber End Sub to compare the list element-by-element to the element you want to remove and return all that do not match. Note that this removes all elements of your list that match the array you want to remove.

all()

Answer 3

Try below :

fh.write(asbytes(format % tuple(row) + newline))

This worked for me as follows :

facets.remove(np.array(i[0],i[1]))

Delete array from list of arrays Python

3 个答案: