Home/how

WikiQuora Latest Questions

W3spoint99
  • 0
W3spoint99Begginer
Asked: January 6, 2025In:
  • 0

Is there an easy way to delete an element from an array using PHP, such that foreach ($array) no longer includes that element? I thought that setting it to null would do it, but apparently it does not work.

arraydeleteelementhowphpunset
  1. Saralyn
    Saralyn Begginer

    There are different ways to delete an array element, where some are more useful for some specific tasks than others. Deleting a Single Array Element If you want to delete just one single array element you can use unset() and alternatively array_splice(). By key or by value? If you know the value andRead more

    There are different ways to delete an array element, where some are more useful for some specific tasks than others.

    Deleting a Single Array Element

    If you want to delete just one single array element you can use unset() and alternatively array_splice().

    By key or by value?

    If you know the value and don’t know the key to delete the element you can use array_search() to get the key. This only works if the element doesn’t occur more than once, since array_search() returns the first hit only.

    unset() Expression

    Note: When you use unset() the array keys won’t change. If you want to reindex the keys you can use array_values() after unset(), which will convert all keys to numerically enumerated keys starting from 0 (the array remains a list).

    Example Code:

    $array = [0 => "a", 1 => "b", 2 => "c"];
unset($array[1]);
          // ↑ Key of element to delete

    Example Output:

    [
    [0] => a
    [2] => c
]

    array_splice() Function

    If you use array_splice() the (integer) keys will automatically be reindex-ed, but the associative (string) keys won’t change — as opposed to array_values() after unset(), which will convert all keys to numerical keys.

    Note: array_splice() needs the offset, not the key, as the second parameter; offset = array_flip(array_keys(array))[key].

    Example Code:

    $array = [0 => "a", 1 => "b", 2 => "c"];
array_splice($array, 1, 1);
                  // ↑ Offset of element to delete

    Example Output:

    [
    [0] => a
    [1] => c
]

    array_splice(), same as unset(), take the array by reference. You don’t assign the return values back to the array.

    Deleting Multiple Array Elements

    If you want to delete multiple array elements and don’t want to call unset() or array_splice() multiple times you can use the functions array_diff() or array_diff_key() depending on whether you know the values or the keys of the elements to remove from the array.

    array_diff() Function

    If you know the values of the array elements which you want to delete, then you can use array_diff(). As before with unset() it won’t change the keys of the array.

    Example Code:

    $array = [0 => "a", 1 => "b", 2 => "c", 3 => "c"];
$array = array_diff($array, ["a", "c"]);
                         // └────────┘
                         // Array values to delete

    Example Output:

    [
    [1] => b
]

    array_diff_key() Function

    If you know the keys of the elements which you want to delete, then you want to use array_diff_key(). You have to make sure you pass the keys as keys in the second parameter and not as values. Keys won’t reindex.

    Example Code:

    $array = [0 => "a", 1 => "b", 2 => "c"];
$array = array_diff_key($array, [0 => "xy", "2" => "xy"]);
                              // ↑           ↑
                              // Array keys of elements to delete

    Example Output:

    [
    [1] => b
]

    If you want to use unset() or array_splice() to delete multiple elements with the same value you can use array_keys() to get all the keys for a specific value and then delete all elements.

    array_filter() Function

    If you want to delete all elements with a specific value in the array you can use array_filter().

    Example Code:

    $array = [0 => "a", 1 => "b", 2 => "c"];
$array = array_filter($array, static function ($element) {
    return $element !== "b";
    //                   ↑
    // Array value which you want to delete
});

    Example Output:

    [
    [0] => a
    [2] => c
]
    See less
W3spoint99
  • 0
W3spoint99Begginer
Asked: December 26, 2024In:
  • 0

Having spent a decent amount of time watching both the r and pandas tags on SO, the impression that I get is that pandas questions are less likely to contain reproducible data. This is ...

examplehowpandaspython
  1. Saralyn
    Saralyn Begginer

    The Good: Do include a small example DataFrame, either as runnable code: In [1]: df = pd.DataFrame([[1, 2], [1, 3], [4, 6]], columns=['A', 'B']) or make it "copy and pasteable" using pd.read_clipboard(sep=r'\s\s+'). In [2]: df Out[2]: A B 0 1 2 1 1 3 2 4 6 Test it yourself to make sure it works andRead more

    The Good:

    • Do include a small example DataFrame, either as runnable code: 
      In [1]: df = pd.DataFrame([[1, 2], [1, 3], [4, 6]], columns=['A', 'B'])

      or make it “copy and pasteable” using pd.read_clipboard(sep=r'\s\s+').

      In [2]: df
Out[2]:
   A  B
0  1  2
1  1  3
2  4  6

      Test it yourself to make sure it works and reproduces the issue.

      • You can format the text for Stack Overflow by highlighting and using Ctrl+K (or prepend four spaces to each line), or place three backticks (“`) above and below your code with your code unindented.
      • I really do mean small. The vast majority of example DataFrames could be fewer than 6 rows,[citation needed] and I bet I can do it in 5. Can you reproduce the error with df = df.head()? If not, fiddle around to see if you can make up a small DataFrame which exhibits the issue you are facing.

        But every rule has an exception, the obvious one being for performance issues (in which case definitely use %timeit and possibly %prun to profile your code), where you should generate:

        df = pd.DataFrame(np.random.randn(100000000, 10))

        Consider using np.random.seed so we have the exact same frame. Having said that, “make this code fast for me” is not strictly on topic for the site.

      • For getting runnable code, df.to_dict is often useful, with the different orient options for different cases. In the example above, I could have grabbed the data and columns from df.to_dict('split').
    • Write out the outcome you desire (similarly to above) 
      In [3]: iwantthis
Out[3]:
   A  B
0  1  5
1  4  6

      Explain where the numbers come from:

      The 5 is the sum of the B column for the rows where A is 1.

    • Do show the code you’ve tried: 
      In [4]: df.groupby('A').sum()
Out[4]:
   B
A
1  5
4  6

      But say what’s incorrect:

      The A column is in the index rather than a column.

    • Do show you’ve done some research (search the documentation, search Stack Overflow), and give a summary:

      The docstring for sum simply states “Compute sum of group values”

      The groupby documentation doesn’t give any examples for this.

      Aside: the answer here is to use df.groupby('A', as_index=False).sum().

    • If it’s relevant that you have Timestamp columns, e.g. you’re resampling or something, then be explicit and apply pd.to_datetime to them for good measure. 
      df['date'] = pd.to_datetime(df['date']) # this column ought to be date.

      Sometimes this is the issue itself: they were strings.

    The Bad:

    • Don’t include a MultiIndex, which we can’t copy and paste (see above). This is kind of a grievance with Pandas’ default display, but nonetheless annoying: 
      In [11]: df
Out[11]:
     C
A B
1 2  3
  2  6

      The correct way is to include an ordinary DataFrame with a set_index call:

      In [12]: df = pd.DataFrame([[1, 2, 3], [1, 2, 6]], columns=['A', 'B', 'C'])

In [13]: df = df.set_index(['A', 'B'])

In [14]: df
Out[14]:
     C
A B
1 2  3
  2  6
    • Do provide insight to what it is when giving the outcome you want: 
         B
A
1  1
5  0

      Be specific about how you got the numbers (what are they)… double check they’re correct.

    • If your code throws an error, do include the entire stack trace. This can be edited out later if it’s too noisy. Show the line number and the corresponding line of your code which it’s raising against.
    • Pandas 2.0 introduced a number of changes, and Pandas 1.0 before that, so if you’re getting unexpected output, include the version: 
      pd.__version__

      On that note, you might also want to include the version of Python, your OS, and any other libraries. You could use pd.show_versions() or the session_info package (which shows loaded libraries and Jupyter/IPython environment).

    The Ugly:

    • Don’t link to a CSV file we don’t have access to (and ideally don’t link to an external source at all). 
      df = pd.read_csv('my_secret_file.csv') # ideally with lots of parsing options

      Most data is proprietary, we get that. Make up similar data and see if you can reproduce the problem (something small).

    • Don’t explain the situation vaguely in words, like you have a DataFrame which is “large”, mention some of the column names in passing (be sure not to mention their dtypes). Try and go into lots of detail about something which is completely meaningless without seeing the actual context. Presumably no one is even going to read to the end of this paragraph.

      Essays are bad; it’s easier with small examples.

    • Don’t include 10+ (100+??) lines of data munging before getting to your actual question.

      Please, we see enough of this in our day jobs. We want to help, but not like this…. Cut the intro, and just show the relevant DataFrames (or small versions of them) in the step which is causing you trouble.

    See less
W3spoint99
  • 0
W3spoint99Begginer
Asked: December 26, 2024In:
  • 0

How does Python’s slice notation (Slicing) work? That is: when I write code like a[x:y:z], a[:], a[::2] etc., how can I understand which elements end up in the slice?

howpythonsequenceslice
  1. Saralyn
    Saralyn Begginer
    This answer was edited.

    The syntax is: a[start:stop] # items start through stop-1 a[start:] # items start through the rest of the array a[:stop] # items from the beginning through stop-1 a[:] # a copy of the whole array There is also the step value, which can be used with any of the above: a[start:stop:step] # start througRead more

    The syntax is:

    a[start:stop]  # items start through stop-1
a[start:]      # items start through the rest of the array
a[:stop]       # items from the beginning through stop-1
a[:]           # a copy of the whole array

    There is also the step value, which can be used with any of the above:

    a[start:stop:step] # start through not past stop, by step

    The key point to remember is that the :stop value represents the first value that is not in the selected slice. So, the difference between stop and start is the number of elements selected (if step is 1, the default).

    The other feature is that start or stop may be a negative number, which means it counts from the end of the array instead of the beginning. So:

    a[-1]    # last item in the array
a[-2:]   # last two items in the array
a[:-2]   # everything except the last two items

    Similarly, step may be a negative number:

    a[::-1]    # all items in the array, reversed
a[1::-1]   # the first two items, reversed
a[:-3:-1]  # the last two items, reversed
a[-3::-1]  # everything except the last two items, reversed

    Python is kind to the programmer if there are fewer items than you ask for. For example, if you ask for a[:-2] and a only contains one element, you get an empty list instead of an error. Sometimes you would prefer the error, so you have to be aware that this may happen.

    Relationship with the slice object

    A slice object can represent a slicing operation, i.e.:

    a[start:stop:step]

    is equivalent to:

    a[slice(start, stop, step)]

    Slice objects also behave slightly differently depending on the number of arguments, similar to range(), i.e. both slice(stop) and slice(start, stop[, step]) are supported. To skip specifying a given argument, one might use None, so that e.g. a[start:] is equivalent to a[slice(start, None)] or a[::-1] is equivalent to a[slice(None, None, -1)].

    While the :-based notation is very helpful for simple slicing, the explicit use of slice() objects simplifies the programmatic generation of slicing.

    See less