Yes. Iterating over a list is `O(n)` and adding each element to the hash set is `O(1)`, so the total operation is `O(n)`.

&lt;!-- language-all: lang-ts --&gt; 

My app has a NameService which holds the name. 

There are two child components of App, Navbar and TheContent which reference this service. Whenever the name changes in the service, i want it to update in both of the other components. How can i do this?

    import {Component, Injectable} from &#39;angular2/core&#39;

    // Name Service

    @Injectable()
    class NameService {
      name: any;
      constructor() {
        this.name = &quot;Jack&quot;;
      }
      change(){
        this.name = &quot;Jane&quot;;
      }
    }

    // The navbar
    @Component({
      selector: &#39;navbar&#39;,
      template: &#39;&lt;div&gt;This is the navbar, user name is {{name}}.&lt;/div&gt;&#39;
    })
    export class Navbar {
      name: any;
      constructor(nameService: NameService) {
        this.name = nameService.name;
      }
    }

    // The content area
    @Component({
      selector: &#39;thecontent&#39;,
      template: &#39;&lt;div&gt;This is the content area. Hello user {{name}}. &lt;button (click)=changeMyName()&gt;Change the name&lt;/button&gt;&lt;/div&gt;&#39;
    })
    export class TheContent {

      name: any;

      constructor(public nameService: NameService) {
        this.name = nameService.name;
      }
      changeMyName() {
    	   this.nameService.change();
         console.log(this.nameService.name);
      }
    }


    @Component({
      selector: &#39;app&#39;,
      providers: [NameService],
      directives: [TheContent, Navbar],
      template: &#39;&lt;navbar&gt;&lt;/navbar&gt;&lt;thecontent&gt;&lt;/thecontent&gt;&#39;
    })
    export class App {
      constructor(public nameService: NameService) {
      }
    }

updating variable changes in components from a service with angular2

When working with flex align-* properties, what&#39;s the difference between `flex-start` and `baseline`?

The below code snippet gives same output for `align-self: flex-start` and `align-self: baseline`.

In which cases will `align-self: flex-start` and `align-self: baseline` behave differently?

&lt;!-- begin snippet: js hide: true console: false babel: false --&gt;

&lt;!-- language: lang-css --&gt;

    .flex-container {
      color: white;
      display: -webkit-flex;
      display: flex;
      width: 350px;
      height: 200px;
      background-color: yellow;
    }
    .flex-item {
      background-color: green;
      width: 50px;
      min-height: 100px;
      margin: 10px;
    }
    .item1 {
      -webkit-align-self: flex-start;
      align-self: flex-start;
    }
    .item2 {
      -webkit-align-self: flex-end;
      align-self: flex-end;
    }
    .item3 {
      -webkit-align-self: center;
      align-self: center;
    }
    .item4 {
      -webkit-align-self: baseline;
      align-self: baseline;
    }
    .item5 {
      -webkit-align-self: stretch;
      align-self: stretch;
    }

&lt;!-- language: lang-html --&gt;

    &lt;div class=&quot;flex-container&quot;&gt;
      &lt;div class=&quot;flex-item item1&quot;&gt;flex-start&lt;/div&gt;
      &lt;div class=&quot;flex-item item4&quot;&gt;baseline&lt;/div&gt;
      &lt;div class=&quot;flex-item item2&quot;&gt;flex-end&lt;/div&gt;
      &lt;div class=&quot;flex-item item3&quot;&gt;center&lt;/div&gt;
      &lt;div class=&quot;flex-item item5&quot;&gt;stretch&lt;/div&gt;
    &lt;/div&gt;

&lt;!-- end snippet --&gt;



What&#39;s the difference between flex-start and baseline?

I&#39;ve noticed the table of the time complexity of set operations on the python official website. But i just wanna ask what&#39;s the time complexity of converting a list to a set, for instance,

    l = [1, 2, 3, 4, 5]
    s = set(l)

I kind of know that this is actually a hash table, but how exactly does it work? Is it O(n) then?

What is time complexity of a list to set conversion?

I've noticed the table of the time complexity of set operations on the python official website. But i just wanna ask what's the time complexity of converting a list to a set, for instance,
<pre><code class="hljs language-ini">l = [1, 2, 3, 4, 5]
s = set(l)
</code></pre>
I kind of know that this is actually a hash table, but how exactly does it work? Is it O(n) then?

I am trying to understand the **strides** argument in tf.nn.avg_pool, tf.nn.max_pool, tf.nn.conv2d. 

The [documentation][1] repeatedly says 

&gt; strides: A list of ints that has length &gt;= 4. The stride of the sliding window for each dimension of the input tensor.

My questions are:

 1. What do each of the 4+ integers represent?
 2. Why must they have strides\[0\] = strides\[3\] = 1 for convnets?
 3. In [this example][2] we see `tf.reshape(_X,shape=[-1, 28, 28, 1])`. Why -1?

Sadly the examples in the docs for reshape using -1 don&#39;t translate too well to this scenario.

  [1]: https://www.tensorflow.org/versions/master/api_docs/python/nn.html#max_pool
  [2]: https://github.com/aymericdamien/TensorFlow-Examples/blob/master/notebooks/3%20-%20Neural%20Networks/convolutional_network.ipynb

Tensorflow Strides Argument

I have one large click application that I&#39;ve developed, but navigating through the different commands/subcommands is getting rough. How do I organize my commands into separate files? Is it possible to organize commands and their subcommands into separate classes?

Here&#39;s an example of how I would like to separate it:

__init__
--------------

	import click

	@click.group()
	@click.version_option()
	def cli():
		pass #Entry Point


command_cloudflare.py
-----

	@cli.group()
	@click.pass_context
	def cloudflare(ctx):
		pass

	@cloudflare.group(&#39;zone&#39;)
	def cloudflare_zone():
		pass

	@cloudflare_zone.command(&#39;add&#39;)
	@click.option(&#39;--jumpstart&#39;, &#39;-j&#39;, default=True)
	@click.option(&#39;--organization&#39;, &#39;-o&#39;, default=&#39;&#39;)
	@click.argument(&#39;url&#39;)
	@click.pass_obj
	@__cf_error_handler
	def cloudflare_zone_add(ctx, url, jumpstart, organization):
		pass

	@cloudflare.group(&#39;record&#39;)
	def cloudflare_record():
		pass
		
	@cloudflare_record.command(&#39;add&#39;)
	@click.option(&#39;--ttl&#39;, &#39;-t&#39;)
	@click.argument(&#39;domain&#39;)
	@click.argument(&#39;name&#39;)
	@click.argument(&#39;type&#39;)
	@click.argument(&#39;content&#39;)
	@click.pass_obj
	@__cf_error_handler
	def cloudflare_record_add(ctx, domain, name, type, content, ttl):
		pass

	@cloudflare_record.command(&#39;edit&#39;)
	@click.option(&#39;--ttl&#39;, &#39;-t&#39;)
	@click.argument(&#39;domain&#39;)
	@click.argument(&#39;name&#39;)
	@click.argument(&#39;type&#39;)
	@click.argument(&#39;content&#39;)
	@click.pass_obj
	@__cf_error_handler
	def cloudflare_record_edit(ctx, domain):
		pass

command_uptimerobot.py
----------------
	
	@cli.group()
	@click.pass_context
	def uptimerobot(ctx):
		pass

	@uptimerobot.command(&#39;add&#39;)
	@click.option(&#39;--alert&#39;, &#39;-a&#39;, default=True)
	@click.argument(&#39;name&#39;)
	@click.argument(&#39;url&#39;)
	@click.pass_obj
	def uptimerobot_add(ctx, name, url, alert):
		pass

	@uptimerobot.command(&#39;delete&#39;)
	@click.argument(&#39;names&#39;, nargs=-1, required=True)
	@click.pass_obj
	def uptimerobot_delete(ctx, names):
		pass

How can I split my Click commands, each with a set of sub-commands, into multiple files?

I am trying to automate the process of setting up a development environment with pandas package using conda. 

I installed conda, created and activated a dev environment. When I tried to install a package as follows, I noticed that there was a prompt to which a user had to key in Y or N (Proceed ([y]/n)?) for the installation to proceed successfully. 

    $ conda install pandas
    Fetching package metadata: ....
    Solving package specifications: ..................
    Package plan for installation in environment /home/miniconda2/envs/pandas_env:
    
    The following packages will be downloaded:
    
        package                    |            build
        ---------------------------|-----------------
        libgfortran-1.0            |                0         170 KB
        openblas-0.2.14            |                3         3.5 MB
        numpy-1.10.2               |           py27_0         5.9 MB
        pytz-2015.7                |           py27_0         174 KB
        six-1.10.0                 |           py27_0          16 KB
        python-dateutil-2.4.2      |           py27_0         219 KB
        pandas-0.17.1              |      np110py27_0        12.4 MB
        ------------------------------------------------------------
                                               Total:        22.3 MB
    
    The following NEW packages will be INSTALLED:
    
        libgfortran:     1.0-0             
        numpy:           1.10.2-py27_0     
        openblas:        0.2.14-3          
        pandas:          0.17.1-np110py27_0
        python-dateutil: 2.4.2-py27_0      
        pytz:            2015.7-py27_0     
        six:             1.10.0-py27_0     
    
    Proceed ([y]/n)? y
    
    Fetching packages ...
    libgfortran-1. 100% |###################################################################################################################################################################| Time: 0:00:00 457.23 kB/s
    openblas-0.2.1 100% |###################################################################################################################################################################| Time: 0:00:02   1.68 MB/s
    numpy-1.10.2-p 100% |###################################################################################################################################################################| Time: 0:00:02   2.42 MB/s
    pytz-2015.7-py 100% |###################################################################################################################################################################| Time: 0:00:00 388.35 kB/s
    six-1.10.0-py2 100% |###################################################################################################################################################################| Time: 0:00:00 224.69 kB/s
    python-dateuti 100% |###################################################################################################################################################################| Time: 0:00:00 493.15 kB/s
    pandas-0.17.1- 100% |###################################################################################################################################################################| Time: 0:00:04   3.24 MB/s
    Extracting packages ...
    [      COMPLETE      ]|######################################################################################################################################################################################| 100%
    Linking packages ...
    [      COMPLETE      ]|######################################################################################################################################################################################| 100%

How can I override these prompts so that the installation takes place silently? I tried using the -f flag but it does not seem to be existing with the conda install command.

Thanks in advance!

Conda - Silently installing a package

I have trouble properly understanding `numpy.where()` despite reading [the doc](http://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.where.html), [this post](https://stackoverflow.com/questions/5642457/how-does-python-numpy-where-work) and [this other post](https://stackoverflow.com/questions/24219841/numpy-where-on-a-2d-matrix).

Can someone provide step-by-step commented examples with 1D and 2D arrays?

numpy.where() detailed, step-by-step explanation / examples

As a Flask beginner, I can&#39;t understand how `request.args` is used. I read somewhere that it is used to return values of query string (correct me if I&#39;m wrong) and how many parameters `request.args.get()` takes.

I know that when I have to store submitted form data, I can use `fname = request.form.get(&quot;firstname&quot;)`. Here, only one parameter is passed, whereas the code below takes two parameters.
    
    @app.route(&quot;/&quot;)
    def home():
        cnx = db_connect()
        cur = cnx.cursor()
        output = []
    
        page = request.args.get(&#39;page&#39;, 1)
    
        try:
            page = int(page)
            skip = (page-1)*4
        except:
            abort(404)
       
        stmt_select = &quot;select * from posts limit %s, 4;&quot;
        values=[skip]
    
        cur.execute(stmt_select,values)
        x=cur.fetchall()
    
        for row in reversed(x):
            data = {
               &quot;uid&quot;:row[0],
               &quot;pid&quot;:row[1],
               &quot;subject&quot;:row[2],
               &quot;post_content&quot;:row[3],
               &quot;date&quot;:datetime.fromtimestamp(row[4]),
            }
            output.append(data)
        
        next = page + 1
        previous = page-1
        if previous&lt;1:
        previous=1
        return render_template(&quot;home.html&quot;, persons=output, next=next, previous=previous)

Please explain why it takes two parameters, and then what its use is.


In Flask, what is &quot;request.args&quot; and how is it used?

I have the following code:

	[x ** 2 for x in range(10)]
	
When I run it in the Python shell, it returns:

	[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
	
I&#39;ve searched and it seems this is called a **list comprehension** and similarly there seem to be set/dict comprehensions and generator expressions. But how does it work?


What does &quot;list comprehension&quot; and similar mean? How does it work and how can I use it?

Is there any reason why I should prefer `Collections.sort(list)` method over simply calling the `list.sort()`? Internally `Collections.sort` merely calls the `sort` method of the `List` class anyway.

It&#39;s just surprising that almost everyone is telling me to use `Collections.sort`. Why?

Difference between Collections.sort(list) and list.sort(Comparator)

I have a list:

    my_list = [1, 2, 3, 4, 5]

How can I multiply each element in `my_list` by 5? The output should be:

    [5, 10, 15, 20, 25]

How do I multiply each element in a list by a number?

I have two lists of arrays. 

How do I easily compare equality of these *with Java 8 and its features*, without using external libraries? I am looking for a &quot;better&quot; (higher-level, shorter, more efficient) solution than brute-force code like this (untested code, may contain typos etc, not the point of the question):

    boolean compare(List&lt;String[]&gt; list1, List&lt;String[]&gt; list2) 
    {
        // tests for nulls etc omitted
        if(list1.size() != list2.size()) {
           return false;
        }
        for(i=0; i&lt;list1.size(); ++i) {
            if(!Arrays.equals(list1.get(i), list2.get(i))) {
                return false;
            }
        }
        return true;
    }

Or, if there isn&#39;t any nicer way, that&#39;s a valid answer too.

Bonus: If Java 9 offers an even better way what whaterver Java 8 can offer, feel free to mention it as well.

**Edit:** After looking at the comments, and seeing how this question has become moderately hot, I think **the &quot;*better*&quot; should include first checking lengths of all arrays, before checking array contents**, because that has potential to find inequality much quicker, if inner arrays are long.

How to compare equality of lists of arrays with modern Java?

I have a Pandas DataFrame with one column:

    df = pd.DataFrame({&quot;teams&quot;: [[&quot;SF&quot;, &quot;NYG&quot;] for _ in range(7)]})

           teams
    0  [SF, NYG]
    1  [SF, NYG]
    2  [SF, NYG]
    3  [SF, NYG]
    4  [SF, NYG]
    5  [SF, NYG]
    6  [SF, NYG]

How can split this column of lists into two columns?

Desired result:

      team1 team2
    0    SF   NYG
    1    SF   NYG
    2    SF   NYG
    3    SF   NYG
    4    SF   NYG
    5    SF   NYG
    6    SF   NYG



Split a Pandas column of lists into multiple columns

I&#39;m writing a tool in C# to find duplicate images. Currently I create an MD5 checksum of the files and compare those. 

Unfortunately, the images can be:

- Rotated by 90 degrees.
- Have different dimensions (smaller image with same content).
- Have different compression or file types (e.g. jpeg artifacts, see below).

[![higher resolution koala][1]][1][![lower resolution koala][2]][2]

What would be the best approach to solve this problem?

  [1]: http://i.stack.imgur.com/UvKaV.jpg
  [2]: http://i.stack.imgur.com/8lplJ.jpg

Algorithm to compare two images in C#

I&#39;ve read in other posts that this seems to be the best way to combine hash-values. Could somebody please break this down and explain why this is the best way to do it?

    template &lt;class T&gt;
    inline void hash_combine(std::size_t&amp; seed, const T&amp; v)
    {
        std::hash&lt;T&gt; hasher;
        seed ^= hasher(v) + 0x9e3779b9 + (seed&lt;&lt;6) + (seed&gt;&gt;2);
    }

Edit: The other question is only asking for the magic number, but I&#39;d like to get  know about the whole function, not only this part.

C++ - Why is boost::hash_combine the best way to combine hash-values?

How should I escape or cleanse user-provided passwords before I hash them and store them in my database?

When PHP developers consider hashing users&#39; passwords for security purposes, they often tend to think of those passwords like they would any other user-provided data. This subject comes up often in PHP questions related to password storage; the developer often wants to cleanse the password using functions such as `escape_string()`(in various iterations), `htmlspecialchars()`, `addslashes()` and others before hashing it and storing it in the database. 



Cleansing User Passwords

I&#39;ve been playing with Python&#39;s [hash function](https://docs.python.org/3/library/functions.html#hash). For small integers, it appears `hash(n) == n` always. However this does not extend to large numbers:

    &gt;&gt;&gt; hash(2**100) == 2**100
    False

I&#39;m not surprised, I understand hash takes a finite range of values. What is that range?

I tried using [binary search](http://codejamhelpers.readthedocs.io/en/latest/#codejamhelpers.binary_search) to find the smallest number `hash(n) != n`

	&gt;&gt;&gt; import codejamhelpers # pip install codejamhelpers
	&gt;&gt;&gt; help(codejamhelpers.binary_search)
	Help on function binary_search in module codejamhelpers.binary_search:

	binary_search(f, t)
	    Given an increasing function :math:`f`, find the greatest non-negative integer :math:`n` such that :math:`f(n) \le t`. If :math:`f(n) &gt; t` for all :math:`n \ge 0`, return None.

	&gt;&gt;&gt; f = lambda n: int(hash(n) != n)
	&gt;&gt;&gt; n = codejamhelpers.binary_search(f, 0)
    &gt;&gt;&gt; hash(n)
    2305843009213693950
    &gt;&gt;&gt; hash(n+1)
    0

What&#39;s special about 2305843009213693951? I note it&#39;s less than `sys.maxsize == 9223372036854775807`

Edit: I&#39;m using Python 3. I ran the same binary search on Python 2 and got a different result 2147483648, which I note is `sys.maxint+1`

I also played with `[hash(random.random()) for i in range(10**6)]` to estimate the range of hash function. The max is consistently below n above. Comparing the min, it seems Python 3&#39;s hash is always positively valued, whereas Python 2&#39;s hash can take negative values.

When is hash(n) == n in Python?

I recently tried the following commands in Python:

    &gt;&gt;&gt; {lambda x: 1: &#39;a&#39;}
    {&lt;function __main__.&lt;lambda&gt;&gt;: &#39;a&#39;}

    &gt;&gt;&gt; def p(x): return 1
    &gt;&gt;&gt; {p: &#39;a&#39;}
    {&lt;function __main__.p&gt;: &#39;a&#39;}

The success of both `dict` creations indicates that both lambda and regular functions are hashable. (Something like `{[]: &#39;a&#39;}` fails with `TypeError: unhashable type: &#39;list&#39;`).

The hash is apparently not necessarily the ID of the function:

    &gt;&gt;&gt; m = lambda x: 1
    &gt;&gt;&gt; id(m)
    140643045241584
    &gt;&gt;&gt; hash(m)
    8790190327599
    &gt;&gt;&gt; m.__hash__()
    8790190327599

The last command shows that the `__hash__` method is explicitly defined for `lambda`s, i.e., this is not some automagical thing Python computes based on the type.

What is the motivation behind making functions hashable? For a bonus, what is the hash of a function?

Why and how are Python functions hashable?

I was tinkering around with Python&#39;s `set` and `frozenset` collection types.

Initially, I assumed that `frozenset` would provide a better lookup performance than `set`, as its immutable and thus could exploit the structure of the stored items.

However, this does not seem to be the case, regarding the following experiment:

    import random
    import time
    import sys

    def main(n):
        numbers = []
        for _ in xrange(n):
            numbers.append(random.randint(0, sys.maxint))
        set_ = set(numbers)
        frozenset_ = frozenset(set_)

        start = time.time()
        for number in numbers:
            number in set_
        set_duration = time.time() - start

        start = time.time()
        for number in numbers:
            number in frozenset_
        frozenset_duration = time.time() - start

        print &quot;set      : %.3f&quot; % set_duration
        print &quot;frozenset: %.3f&quot; % frozenset_duration


    if __name__ == &quot;__main__&quot;:
        n = int(sys.argv[1])
        main(n)


I executed this code using both CPython and PyPy, which gave the following results:

    &gt; pypy set.py 100000000
    set      : 6.156
    frozenset: 6.166

    &gt; python set.py 100000000
    set      : 16.824
    frozenset: 17.248

It seems that `frozenset` is actually slower regarding the lookup performance, both in CPython and in PyPy. Does anybody have an idea why this is the case? I did not look into the implementations.

Set vs. frozenset performance

In PyCharm, when I write:

    return set([(sy + ady, sx + adx)])

it says *&quot;Function call can be replaced with set literal&quot;* so it replaces it with:

    return {(sy + ady, sx + adx)}

Why is that? A `set()` in Python is not the same as a dictionary `{}`?

And if it wants to optimize this, why is this more effective?

Why is it possible to replace sometimes set() with {}?

How can I convert a Set (eg, {2,4,6}) to an Array [2, 4, 6] in TypeScript without writing a loop explicitly ?

I have tried those following ways, all of them work in JavaScript but none of them work on TypeScript

    [...set] // ERR: &quot;Type &#39;Set&lt;{}&gt;&#39; is not an array type&quot; in typescript
    
    Array.from(set) // ERR: Property &#39;from&#39; does not exist on type &#39;ArrayConstructor&#39;

How can I convert a Set to an Array in TypeScript

How can I use `collect_set` or `collect_list` on a dataframe after `groupby`. for example: `df.groupby(&#39;key&#39;).collect_set(&#39;values&#39;)`. I get an error: `AttributeError: &#39;GroupedData&#39; object has no attribute &#39;collect_set&#39;
`

pyspark collect_set or collect_list with groupby

I can&#39;t understand the logic behind the terms *union types* and *intersection types* in TypeScript.

Pragmatically, if the properties of different types are sets of properties, if I combine them with the `&amp;` operator, the resulting type will be the *union* of the of those sets. Following that logic, I would expect types like this to be called *union types*. If I combine them with `|`, I can only use the common properties of them, the *intersection* of the sets.

[Wikipedia](https://en.wikipedia.org/wiki/Boolean_algebra_(structure)#Examples) seems to back that logic:
&gt; The power set (set of all subsets) of any given nonempty set S forms a Boolean algebra, an algebra of sets, with the two operations ∨ := ∪ (union) and ∧ := ∩ (intersection).

However, according to [typescriptlang.org](https://www.typescriptlang.org/docs/handbook/advanced-types.html#intersection-types), it&#39;s exactly the opposite: `&amp;` is used to produce *intersection types* and `|` is used for *union types*.

I&#39;m sure there is another way of looking at it, but I cannot figure it out.

Naming of TypeScript&#39;s union and intersection types

Started studying about complexity, I&#39;m struggling with this one:

    void what(int n) {
        int i;
        for (i = 1; i &lt;= n; i++) {
            int x = n;
            while (x &gt; 0)
                x -= i;
        }
    }

Well, the first for loop is clearly `O(n)`. The first iteration is `O(n)`, second one is `O(n/2)`.. and like that `log(n)` times I guess?
Which means **`O(n) * O(log(n)) = O(n * log(n)) complexity`**. Did I get this right?

Edit: (not a duplicate) I know what Big O is. I&#39;ve asked the correct evaluation in a specific case. 

What is the time complexity of my function?

I was thinking about sorting algorithms in software, and possible ways one could surmount the `O(nlogn)` roadblock. I don&#39;t think it IS possible to sort faster in a practical sense, so please don&#39;t think that I do.

With that said, it seems with almost all sorting algorithms, the software must know the position of each element. Which makes sense, otherwise, how would it know where to place each element according to some sorting criteria?

But when I crossed this thinking with the real world, a centrifuge has no idea what position each molecule is in when it &#39;sorts&#39; the molecules by density. In fact, it doesn&#39;t care about the position of each molecule. However it can sort trillions upon trillions of items in a relatively short period of time, due to the fact that each molecule follows density and gravitational laws - which got me thinking.

Would it be possible with some overhead on each node (some value or method tacked on to each of the nodes) to &#39;force&#39; the order of the list? Something like a centrifuge, where only each element cares about its relative position in space (in relation to other nodes). Or, does this violate some rule in computation?

I think one of the big points brought up here is the quantum mechanical effects of nature and how they apply in parallel to all particles simultaneously.

Perhaps classical computers inherently restrict sorting to the domain of `O(nlogn)`, where as quantum computers may be able to cross that threshold into `O(logn)` algorithms that act in parallel.

The point that a centrifuge being basically a [parallel bubble sort][1] seems to be correct, which has a time complexity of `O(n)`.

I guess the next thought is that if nature can sort in `O(n)`, why can&#39;t computers?

  [1]: http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/Sorting/bubbleSort.htm


Sorting in Computer Science vs. sorting in the &#39;real&#39; world

My professor just taught us that any operation that halves the length of the input has an O(log(n)) complexity as a thumb rule. Why is it not O(sqrt(n)), aren&#39;t both of them equivalent?

Is complexity O(log(n)) equivalent to O(sqrt(n))?

We all know that the common way of executing a statement a certain number of times in Python is to use a `for` loop.

The general way of doing this is,

    # I am assuming iterated list is redundant.
    # Just the number of execution matters.
    for _ in range(count):
        pass

I believe nobody will argue that the code above is the common implementation, however there is another option. Using the speed of Python list creation by multiplying references.

    # Uncommon way.
    for _ in [0] * count:
        pass

There is also the old `while` way.

    i = 0
    while i &lt; count:
        i += 1

I tested the execution times of these approaches. Here is the code.

    import timeit

    repeat = 10
    total = 10

    setup = &quot;&quot;&quot;
    count = 100000
    &quot;&quot;&quot;

    test1 = &quot;&quot;&quot;
    for _ in range(count):
        pass
    &quot;&quot;&quot;

    test2 = &quot;&quot;&quot;
    for _ in [0] * count:
        pass
    &quot;&quot;&quot;

    test3 = &quot;&quot;&quot;
    i = 0
    while i &lt; count:
        i += 1
    &quot;&quot;&quot;

    print(min(timeit.Timer(test1, setup=setup).repeat(repeat, total)))
    print(min(timeit.Timer(test2, setup=setup).repeat(repeat, total)))
    print(min(timeit.Timer(test3, setup=setup).repeat(repeat, total)))

    # Results
    0.02238852552017738
    0.011760978361696095
    0.06971727824807639

I would not initiate the subject if there was a small difference, however it can be seen that the difference of speed is 100%. Why does not Python encourage such usage if the second method is much more efficient? Is there a better way?

The test is done with **Windows 10** and **Python 3.6**.

Following @Tim Peters&#39; suggestion,

    .
    .
    .
    test4 = &quot;&quot;&quot;
    for _ in itertools.repeat(None, count):
        pass
    &quot;&quot;&quot;
    print(min(timeit.Timer(test1, setup=setup).repeat(repeat, total)))
    print(min(timeit.Timer(test2, setup=setup).repeat(repeat, total)))
    print(min(timeit.Timer(test3, setup=setup).repeat(repeat, total)))
    print(min(timeit.Timer(test4, setup=setup).repeat(repeat, total)))

    # Gives
    0.02306803115612352
    0.013021619340942758
    0.06400113461638746
    0.008105080015739174

Which offers a much better way, and this pretty much answers my question. 

Why is this faster than `range`, since both are generators. Is it because the value never changes?


A better way for a Python &#39;for&#39; loop

I&#39;m pretty new to computer science. In the closing to a lecture, my AP Computer Science teacher mentioned the comparison model for finding a specified value in a sorted array is *big omega (log n)* i.e. **Ω(log n)**, which as I understand it, means it’s impossible to accomplish this task any faster than **O(log n)**. Why is this?

Content Type	Original Author	Original Content on Stackoverflow
Question	lxuechen	View Question on Stackoverflow
Solution 1 - Python	Mad Physicist	View Answer on Stackoverflow

What is time complexity of a list to set conversion?

Python Problem Overview

Python Solutions

Solution 1 - Python

What's the difference between flex-start and baseline?

updating variable changes in components from a service with angular2

Attributions