Is there a good way to merge two objects in Python? Like a built-in method or fundamental library call?

Right now I have this, but it seems like something that shouldn&#39;t have to be done manually:

    def add_obj(obj, add_obj):
 
        for property in add_obj:
            obj[property] = add_obj[property]

Note: By &quot;object&quot;, I mean a &quot;dictionary&quot;: `obj = {}`

Merge two objects in Python

When looping recursively through folders with files containing spaces the shell script I use is of this form, copied from the [internet][1]:

        while IFS= read -r -d $&#39;\0&#39; file; do
          dosomethingwith &quot;$file&quot;        # do something with each file
        done &lt; &lt;(find /bar -name *foo* -print0)

I think I understand the IFS bit, but I don&#39;t understand what the &#39;`&lt; &lt;(...)`&#39; characters mean. Obviously there&#39;s some sort of piping going on here.

It&#39;s very hard to Google &quot;&lt; &lt;&quot; or &quot;&lt;(&quot;, you see. I tried &quot;angle bracket parenthesis&quot; and &quot;less-than parenthesis&quot; but didn&#39;t find anything.



  [1]: http://mywiki.wooledge.org/BashFAQ/020

What does &quot;&lt; &lt;(command args)&quot; mean in the shell?

There are two R directories on my computer:  
one is `/home/R-2.15.2`,the other is `/home/R-2.15.1`,  
when I input `R` , I can start R, now I want to know which R is running: 2.15.1 or 2.15.2?  

Which version of R is running in my computer?

Python&#39;s [`sum()`][1] function returns the sum of numbers in an iterable.

    sum([3,4,5]) == 3 + 4 + 5 == 12

I&#39;m looking for the function that returns the product instead.

    somelib.somefunc([3,4,5]) == 3 * 4 * 5 == 60

I&#39;m pretty sure such a function exists, but I can&#39;t find it.


  [1]: http://docs.python.org/library/functions.html#sum

What&#39;s the function like sum() but for multiplication? product()?

I came across a `#define` in which they use `__builtin_expect`.

[The documentation][1] says:

&gt; ### Built-in Function: `long __builtin_expect (long exp, long c)`  
 
&gt; You may use `__builtin_expect` to provide the compiler with branch
&gt; prediction information. In general, you should prefer to use actual
&gt; profile feedback for this (`-fprofile-arcs`), as programmers are
&gt; notoriously bad at predicting how their programs actually perform.
&gt; However, there are applications in which this data is hard to collect.
&gt; 
&gt; 
&gt; The return value is the value of `exp`, which should be an integral
&gt; expression. The semantics of the built-in are that it is expected that
&gt; `exp == c`. For example: 
&gt; 
&gt;           if (__builtin_expect (x, 0))
&gt;             foo ();
&gt;
&gt;  would indicate that we do not expect to call `foo`, since we expect `x` to be zero.

So why not directly use: 
    
    if (x)
        foo ();

instead of the complicated syntax with `__builtin_expect`?

  [1]: https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html#index-g_t_005f_005fbuiltin_005fexpect-4159


What is the advantage of GCC&#39;s __builtin_expect in if else statements?

Each time I use pushd or popd, it print the stack to standard output. How not to do so?

I don&#39;t want to do `pushd &gt; /dev/null` each time because I have a lot of scripts calling each other.

Maybe a nice override will do it, but I&#39;ll need to override these builtins only in my scripts, and then restore the correct behavior.

Don&#39;t display pushd/popd stack across several bash scripts (quiet pushd/popd)

I tried to find a built-in for geometric mean but couldn&#39;t.

(Obviously a built-in isn&#39;t going to save me any time while working in the shell, nor do I suspect there&#39;s any difference in accuracy; for scripts I try to use built-ins as often as possible, where the (cumulative) performance gain is often noticeable.

In case there isn&#39;t one (which I doubt is the case) here&#39;s mine. 


    gm_mean = function(a){prod(a)^(1/length(a))}

Geometric Mean: is there a built-in?

I am in a situation where I want to use mutable versions of things like Integer. Do I have to use these classes (below) or does Java have something built in?

http://www.java2s.com/Code/Java/Data-Type/Amutableintwrapper.htm 

Does Java have mutable types for Integer, Float, Double, Long?

I wrote this simple function:


    def padded_hex(i, l):
        given_int = i
        given_len = l
    
        hex_result = hex(given_int)[2:] # remove &#39;0x&#39; from beginning of str
        num_hex_chars = len(hex_result)
        extra_zeros = &#39;0&#39; * (given_len - num_hex_chars) # may not get used..
    
        return (&#39;0x&#39; + hex_result if num_hex_chars == given_len else
                &#39;?&#39; * given_len if num_hex_chars &gt; given_len else
                &#39;0x&#39; + extra_zeros + hex_result if num_hex_chars &lt; given_len else
                None)

Examples:

    padded_hex(42,4) # result &#39;0x002a&#39;
    hex(15) # result &#39;0xf&#39;
    padded_hex(15,1) # result &#39;0xf&#39;

Whilst this is clear enough for me and fits my use case (a simple test tool for a simple printer) I can&#39;t help thinking there&#39;s a lot of room for improvement and this could be squashed down to something very concise.

What other approaches are there to this problem?

Decorating Hex function to pad zeros

I know that `include`, `isset`, `require`, `print`, `echo`, and some others are not functions but language constructs.

Some of these language constructs need parentheses, others don&#39;t.

    require &#39;file.php&#39;;
    isset($x);

Some have a return value, others do not.

    print &#39;foo&#39;; //1
    echo  &#39;foo&#39;; //no return value

So what is the **internal** difference between a language construct and a built-in function?

What is the difference between a language construct and a &quot;built-in&quot; function in PHP?

Suppose I&#39;m using R&#39;s interactive console, and I&#39;ve just done something like this:

    long_running_command()

That long-running command returns a value, and I&#39;ve just realized that I wanted to assign that value to a variable instead of discard it. So how can I get that value without running the command again? Is there a command like this?

    result = get_last_return_value()



How to assign the result of the previous expression to a variable?

What is the purpose of a command that does nothing, being little more than a comment leader, but is actually a shell builtin in and of itself?

It&#39;s slower than inserting a comment into your scripts by about 40% per call, which probably varies greatly depending on the size of the comment. The only possible reasons I can see for it are these:

    # poor man&#39;s delay function
    for ((x=0;x&lt;100000;++x)) ; do : ; done

    # inserting comments into string of commands
    command ; command ; : we need a comment in here for some reason ; command

    # an alias for `true&#39;
    while : ; do command ; done

I guess what I&#39;m really looking for is what historical application it might have had.

What is the purpose of the : (colon) GNU Bash builtin?

It&#39;s frustrating when I do something like `man bindkey` and i get:

&lt;pre&gt;
BUILTIN(1)                BSD General Commands Manual               BUILTIN(1)

NAME
     builtin, !, %, ., :, @, {, }, alias, alloc, bg, bind, bindkey, break, breaksw, builtins, case, cd, chdir, command,
     complete, continue, default, dirs, do, done, echo, echotc, elif, else, end, endif, endsw, esac, eval, exec, exit,
     export, false, fc, fg, filetest, fi, for, foreach, getopts, glob, goto, hash, hashstat, history, hup, if, jobid,
     jobs, kill, limit, local, log, login, logout, ls-F, nice, nohup, notify, onintr, popd, printenv, pushd, pwd, read,
     readonly, rehash, repeat, return, sched, set, setenv, settc, setty, setvar, shift, source, stop, suspend, switch,
     telltc, test, then, time, times, trap, true, type, ulimit, umask, unalias, uncomplete, unhash, unlimit, unset,
     unsetenv, until, wait, where, which, while -- shell built-in commands

SYNOPSIS
     builtin [-options] [args ...]

DESCRIPTION
     Shell builtin commands are commands that can be executed within the running shell&#39;s process.  Note that, in the
&lt;/pre&gt;

Is there an easy way to access the documentation for such commands?


How can I read documentation about built in zsh commands?

What could the following line possibly mean?

    my $x = shift;


What does shift() do in Perl?

Seeing Alexandre C&#39;s [reply][1] in the other topic, I&#39;m curious to know that if there is any performance difference with the built-in types: 

&gt; `char` vs `short` vs `int` vs. `float`
&gt; vs. `double`.

Usually we don&#39;t consider such performance difference (if any) in our real life projects, but I would like to know this for educational purpose. The general questions can be asked is:

- Is there any performance difference between integral arithmetics and floating-point arithmetic?

- Which is faster? What is the reason for being faster? Please explain this.


[1]:https://stackoverflow.com/questions/5069319/predefinition-of-often-used-values-in-computations-does-it-change-anything/5069349#5069349

Performance of built-in types : char vs short vs int vs. float vs. double

Which one is more efficient using `math.pow` or the `**` operator? When should I use one over the other?

So far I know that `x**y` can return an `int` or a `float` if you use a decimal
the function `pow` will return a float

    import math
    
    print( math.pow(10, 2) )
    
    print( 10. ** 2 )



Exponentials in python: x**y vs math.pow(x, y)

How to find if a value exists in an array and then remove it? After removing I need the sequential index order.

Are there any PHP built-in array functions for doing this? 

How to find a value in an array and remove it by using PHP array functions?

In Python there is a built-in function called `dir`.  This is used to get a list of all the attributes for an object.

I understand what it does, but I am confused about why it is called `dir`.  How is this name related to getting the attributes from an object?

Why is &#39;dir()&#39; named &#39;dir&#39; in python?

... the `is` keyword that can be used for equality in strings.

    &gt;&gt;&gt; s = &#39;str&#39;
    &gt;&gt;&gt; s is &#39;str&#39;
    True
    &gt;&gt;&gt; s is &#39;st&#39;
    False

I tried both `__is__()` and `__eq__()` but they didn&#39;t work.

    &gt;&gt;&gt; class MyString:
    ...   def __init__(self):
    ...     self.s = &#39;string&#39;
    ...   def __is__(self, s):
    ...     return self.s == s
    ...
    &gt;&gt;&gt;
    &gt;&gt;&gt;
    &gt;&gt;&gt; m = MyString()
    &gt;&gt;&gt; m is &#39;ss&#39;
    False
    &gt;&gt;&gt; m is &#39;string&#39; # &lt;--- Expected to work
    False
    &gt;&gt;&gt;
    &gt;&gt;&gt; class MyString:
    ...   def __init__(self):
    ...     self.s = &#39;string&#39;
    ...   def __eq__(self, s):
    ...     return self.s == s
    ...
    &gt;&gt;&gt;
    &gt;&gt;&gt; m = MyString()
    &gt;&gt;&gt; m is &#39;ss&#39;
    False
    &gt;&gt;&gt; m is &#39;string&#39; # &lt;--- Expected to work, but again failed
    False
    &gt;&gt;&gt;

How is the &#39;is&#39; keyword implemented in Python?

How can I extract the extension of a file given a file path as a character?  I know I can do this via regular expression `regexpr(&quot;\\.([[:alnum:]]+)$&quot;, x)`, but wondering if there&#39;s a built-in function to deal with this?

Extract file extension from file path

It is possible for a GCC plugin to add a new builtin function? If so, how to do it properly?

GCC version is 5.3 (or newer). The code is compiled and processed by the plugin written in C.

It is mentioned in the [rationale for GCC plugins at gcc-melt.org](http://starynkevitch.net/Basile/gcc-melt/) that this is doable but I cannot see how.

As far as I can see in the sources of GCC, the builtins are created using `add_builtin_function()` from [gcc/langhooks.c](https://github.com/gcc-mirror/gcc/blob/gcc-5-branch/gcc/langhooks.c#L605):

    tree
    add_builtin_function (const char *name,
          tree type,
          int function_code,
          enum built_in_class cl,
          const char *library_name,
          tree attrs)

It is more or less clear which values the arguments of this function should have, except for `function_code`, a unique numeric ID of the function.

Looks like (see `add_builtin_function_common()`), a value from `enum built_in_function` is expected there but a GCC plugin cannot change that enum.

One cannot pass any random value greater than `END_BUILTINS` as `function_code` either, it seems. `builtin_decl_implicit()` and `builtin_decl_explicit()` would have a failed assertion in that case.

So, what is the proper way to add a builtin in a GCC plugin (without using MELT and such, just GCC plugin API)?

**Update**
I looked again at the implementation of `add_builtin_function_common()` and of `langhooks.builtin_function()` for C as well as at how these are used in GCC. It seems that 0 is acceptable as `function_code` in some cases. You cannot use `builtin_decl_implicit()` then but you can save the DECL returned by `add_builtin_function()` and use it later.

Looks like the only event when I can try to create built-ins that way is PLUGIN_START_UNIT (otherwise GCC may crash due to `external_scope` variable being NULL).

I tried the following at that stage (`fntype` was created before):

    decl = add_builtin_function (
        &quot;my_helper&quot;, fntype,
        0 /* function_code */,
        BUILT_IN_NORMAL /* enum built_in_class cl */,
        NULL /* library_name */,
        NULL_TREE /* attrs */)

`my_helper` was defined in a different C source file compiled and linked with the main source file. Then I used decl to insert the calls to that function into other functions (`gimple_build_call`) during my GIMPLE pass.

GCC output no errors and indeed inserted the call to `my_helper` but as a call to an ordinary function. I actually needed a builtin to avoid a call but rather insert the body of the function.

On the other hand, `tsan0` pass, which executes right after my pass, inserts the calls of builtin functions just like one would expect: there is no explicit call as a result, just the body of the function is inserted. Its builtins, however, are defined by GCC itself rather than by the plugins.

So I suppose my builtin still needs something to be a valid builtin, but I do not know what it is. What could that be?


How to add a builtin function in a GCC plugin?

Python has a built in function `sum`, which is effectively equivalent to:

    def sum2(iterable, start=0):
        return start + reduce(operator.add, iterable)

for all types of parameters except strings. It works for numbers and lists, for example:

     sum([1,2,3], 0) = sum2([1,2,3],0) = 6    #Note: 0 is the default value for start, but I include it for clarity
     sum({888:1}, 0) = sum2({888:1},0) = 888

Why were strings specially left out?

     sum( [&#39;foo&#39;,&#39;bar&#39;], &#39;&#39;) # TypeError: sum() can&#39;t sum strings [use &#39;&#39;.join(seq) instead]
     sum2([&#39;foo&#39;,&#39;bar&#39;], &#39;&#39;) = &#39;foobar&#39;


I seem to remember discussions in the Python list for the reason, so an explanation or a link to a thread explaining it would be fine.

**Edit**: I am aware that the standard way is to do `&quot;&quot;.join`. My question is why the option of using sum for strings was banned, and no banning was there for, say, lists.

**Edit 2**: Although I believe this is not needed given all the good answers I got, the question is: *Why does sum work on an iterable containing numbers or an iterable containing lists but not an iterable containing strings?*

Python sum, why not strings?

When I try to use the `read` command in Bash like this:

    echo hello | read str
    echo $str

Nothing echoed, while I think `str` should contain the string `hello`. Can anybody please help me understand this behavior?

All Built In Solutions on Gang of Coders

Total of 23 Built In Solutions

Merge two objects in Python

What does "< <(command args)" mean in the shell?

Which version of R is running in my computer?

What's the function like sum() but for multiplication? product()?

What is the advantage of GCC's __builtin_expect in if else statements?

Don't display pushd/popd stack across several bash scripts (quiet pushd/popd)