I&#39;d use `os.path.sep` to make it very clear that it&#39;s the path separator… But consistency is more important, so if one is already being used, use that. Otherwise, pick one and use it all the time.

**Edit**: Just to make sure you&#39;re not reinventing the wheel, though, the `path` module already has `join`, `split`, `dirname`, and `basename` functions… So you should rarely need to use `path.sep`:

    &gt;&gt;&gt; os.path.join(&quot;foo&quot;, &quot;bar&quot;, &quot;baz&quot;)
    &#39;foo/bar/baz&#39;
    &gt;&gt;&gt; os.path.split(_)
    (&#39;foo/bar&#39;, &#39;baz&#39;)

I recommend you use `os.path.sep` for clarity, since it&#39;s a path separator, not an OS separator. If you `import os.path as path` you can call it `path.sep`, which is even better.

If you are using Python 2.7, I suggest using `os.sep` (works) instead of `os.path.sep` (broken) as Jython on Windows has a bug returning a `&quot;/&quot;` slash instead of the required `&quot;\&quot;` backslash.

The following examples could highlight the differences between os.path.join and os.path.sep.join.

```pycon
&gt;&gt;&gt; import os
&gt;&gt;&gt; os.path.join(&quot;output&quot;, &quot;images&quot;, &quot;saved&quot;)
&#39;output/images/saved&#39;
&gt;&gt;&gt; os.path.sep.join([&quot;output&quot;, &quot;images&quot;, &quot;saved&quot;])
&#39;output/images/saved&#39;
```

I guess the os.path.sep.join is more robust and can be used w/o modifications for any os. 

1. As mentioned in the python docs, both `os.path.sep` and `os.sep` return the same output. 

&gt; The character used by the operating system to separate pathname
&gt; components. This is &#39;/&#39; for POSIX and &#39;\\&#39; for Windows.

2. Both of them belongs to the same python class also.

       print(type(os.sep))
       print(type(os.path.sep))

       # Output
       &lt;class &#39;str&#39;&gt;
       &lt;class &#39;str&#39;&gt;

3. Both have them have the same documentation.

       print(os.path.sep.__doc__)
       print(os.sep.__doc__)

       # The outputs of both print statements are the same. 

So, I think after Python2 where we mostly used `os.sep`, in Python3 only the consistency matters as far as their uses are concerned.


I have a [data table][1] in R:

    library(data.table)
    set.seed(1234)
    DT &lt;- data.table(x=rep(c(1,2,3),each=4), y=c(&quot;A&quot;,&quot;B&quot;), v=sample(1:100,12))
    DT
          x y  v
     [1,] 1 A 12
     [2,] 1 B 62
     [3,] 1 A 60
     [4,] 1 B 61
     [5,] 2 A 83
     [6,] 2 B 97
     [7,] 2 A  1
     [8,] 2 B 22
     [9,] 3 A 99
    [10,] 3 B 47
    [11,] 3 A 63
    [12,] 3 B 49
I can easily sum the variable v by the groups in the data.table:

    out &lt;- DT[,list(SUM=sum(v)),by=list(x,y)]
    out
         x  y SUM
    [1,] 1 A  72
    [2,] 1 B 123
    [3,] 2 A  84
    [4,] 2 B 119
    [5,] 3 A 162
    [6,] 3 B  96
However, I would like to have the groups (y) as columns, rather than rows.  I can accomplish this using `reshape`:

    out &lt;- reshape(out,direction=&#39;wide&#39;,idvar=&#39;x&#39;, timevar=&#39;y&#39;)
    out
         x SUM.A SUM.B
    [1,] 1    72   123
    [2,] 2    84   119
    [3,] 3   162    96
Is there a more efficient way to reshape the data after aggregating it?  Is there any way to combine these operations into one step, using the data.table operations?
  [1]: http://cran.r-project.org/web/packages/data.table/index.html




Proper/fastest way to reshape a data.table

I have a library and a console application that uses a library. The library has a folder with source and header files.

My project is in a child/inner directory but that library directory that I want to include is in a parent/upper directory.

My project directory:

    H:\Gmail_04\gsasl-1.0\lib\libgsaslMain

Includes files are here:

    H:\Gmail_04\gsasl-1.0\src

How can I use paths relative to the project directory, to include folders that are in a parent/upper directory?

How to define relative paths in Visual Studio Project?

They are same, but which one should I use?

http://docs.python.org/library/os.html:

&gt; `os.sep`
&gt;
&gt; &gt;The character used by the operating system to separate pathname components. This is &#39;/&#39; for   POSIX and &#39;\\&#39; for Windows. Note that knowing this is not sufficient to be able to parse or concatenate pathnames — use os.path.split() and os.path.join() — but it is occasionally useful. Also available via os.path.

which one should I use: os.sep or os.path.sep?

They are same, but which one should I use?
<a href="http://docs.python.org/library/os.html" target="_blank" rel="noopener noreferrer">http://docs.python.org/library/os.html</a>:
> <code>os.sep</code>
>
> >The character used by the operating system to separate pathname components. This is '/' for POSIX and '\' for Windows. Note that knowing this is not sufficient to be able to parse or concatenate pathnames — use os.path.split() and os.path.join() — but it is occasionally useful. Also available via os.path.

    l = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;, &quot;e&quot;]

I want to convert this list to a dictionary like:

    d = {&quot;a&quot;: &quot;b&quot;, &quot;c&quot;: &quot;d&quot;, &quot;e&quot;: &quot;&quot;}

So basically, the evens will be keys whereas the odds will be values. I know that I can do it in a &quot;non-pythonic&quot; way such as a for loop with if statements but I believe that there should be a more &quot;pythonic&quot; way to accomplish this. So, I appreciate any help :) 

Convert list into a dictionary

As I only now noticed after commenting on [this answer](https://stackoverflow.com/questions/6900955/python-convert-list-to-dictionary/6900977#6900977), slices in Python 3 return shallow copies of whatever they&#39;re slicing rather than views. Why is this still the case? Even leaving aside numpy&#39;s usage of views rather than copies for slicing, the fact that `dict.keys`, `dict.values`, and `dict.items` all return views in Python 3, and that there are many other aspects of Python 3 geared towards greater use of iterators, makes it seem that there would have been a movement towards slices becoming similar. `itertools` does have an `islice` function that makes iterative slices, but that&#39;s more limited than normal slicing and does not provide view functionality along the lines of `dict.keys` or `dict.values`.

As well, the fact that you can use assignment to slices to modify the original list, but slices are themselves copies and not views, is a contradictory aspect of the language and seems like it violates several of the principles illustrated in [the Zen of Python](http://www.python.org/dev/peps/pep-0020/).

That is, the fact you can do

    &gt;&gt;&gt; a = [1, 2, 3, 4, 5]
    &gt;&gt;&gt; a[::2] = [0, 0, 0]
    &gt;&gt;&gt; a
    [0, 2, 0, 4, 0]

But not

    &gt;&gt;&gt; a = [1, 2, 3, 4, 5]
    &gt;&gt;&gt; a[::2][0] = 0
    &gt;&gt;&gt; a
    [0, 2, 3, 4, 5]

or something like

    &gt;&gt;&gt; a = [1, 2, 3, 4, 5]
    &gt;&gt;&gt; b = a[::2]
    &gt;&gt;&gt; b
    view(a[::2] -&gt; [1, 3, 5])   # numpy doesn&#39;t explicitly state that its slices are views, but it would probably be a good idea to do it in some way for regular Python
    &gt;&gt;&gt; b[0] = 0
    &gt;&gt;&gt; b
    view(a[::2] -&gt; [0, 3, 5])
    &gt;&gt;&gt; a
    [0, 2, 3, 4, 5]

Seems somewhat arbitrary/undesirable.

I&#39;m aware of http://www.python.org/dev/peps/pep-3099/ and the part where it says &quot;Slices and extended slices won&#39;t go away (even if the `__getslice__` and `__setslice__` APIs may be replaced) nor will they return views for the standard object types.&quot;, but the linked discussion provides no mention of why the decision about slicing with views was made; in fact, the majority of the comments on that specific suggestion out of the suggestions listed in the original post seemed to be positive.

What prevented something like this from being implemented in Python 3.0, which was specifically designed to not be strictly backwards-compatible with Python 2.x and thus would have been the best time to implement such a change in design, and is there anything that may prevent it in future versions of Python?

Why are slices in Python 3 still copies and not views?

What would be the best way to split a string on the first occurrence of a delimiter?

For example:

    &quot;123mango abcd mango kiwi peach&quot;

splitting on the first `mango` to get:

    &quot;abcd mango kiwi peach&quot;

Splitting on first occurrence

Should I put the shebang in my Python scripts? In what form?

&lt;!-- language: lang-none --&gt;

    #!/usr/bin/env python 

or

&lt;!-- language: lang-none --&gt;

    #!/usr/local/bin/python

Are these equally portable? Which form is used most?

***Note:*** the [tornado](https://github.com/facebook/tornado) project uses the shebang. On the other hand the [Django](https://www.djangoproject.com/) project doesn&#39;t.

Should I put #! (shebang) in Python scripts, and what form should it take?

NumPy proposes a way to get the index of the maximum value of an array via `np.argmax`.

I would like a similar thing, but returning the indexes of the `N` maximum values.

For instance, if I have an array, `[1, 3, 2, 4, 5]`, `function(array, n=3)` would return the indices `[4, 3, 1]` which correspond to the elements `[5, 4, 3]`.


How do I get indices of N maximum values in a NumPy array?

I can take a guess based on the names, but what specifically are wall-clock-time, user-cpu-time, and system-cpu-time in UNIX?

Is user-cpu time the amount of time spent executing user-code while kernel-cpu time the amount of time spent in the kernel due to the need of privileged operations (like IO to disk)?

What unit of time is this measurement in?

And is wall-clock time really the number of seconds the process has spent on the CPU or is the name just misleading?

What specifically are wall-clock-time, user-cpu-time, and system-cpu-time in UNIX?

I want to check the operating system (on the computer where the script runs).

I know I can use `os.system(&#39;uname -o&#39;)` in Linux, but it gives me a message in the console, and I want to write to a variable.

It will be okay if the script can tell if it is Mac, Windows or Linux. How can I check it? 

How do I check the operating system in Python?

I am sorry to ask this question when it has already been asked but I couldn&#39;t get a clarity from them. So I am asking the following related questions to get the difference between system call (mode-switch) and context switch 

- Why is it said that the system call doesn&#39;t require context switch when the context of the 
process making the call has to be saved and then reloaded. Is it just because according to the definition of context switch a switch has to be made to another process.

- What does it mean that when a system call is made the kernel executes in &quot;user context&quot;.


- According to the wikipedia article : [http://en.wikipedia.org/wiki/Context_switch][1]

a context switch is not necessary for system call but it depends on the operating system and a context switch might occur during a system call. I am wondering what would happen in the case when the context switch takes place at the time of system call. Any examples?


  [1]: http://en.wikipedia.org/wiki/Context_switch

System call and context switch

What is the maximum limit to the number of processes possible in a linux system? How can we find it ?

Maximum number of processes in linux

Sorry about the length, it&#39;s kinda necessary.

**Introduction**


I&#39;m developing a remote desktop software (just for fun) in C# 4.0 for Windows Vista/7. I&#39;ve gotten through basic obstacles: I have a robust UDP messaging system, relatively clean program design, I&#39;ve got a mirror driver (the free DFMirage mirror driver from DemoForge) up and running, and I&#39;ve implemented NAT traversal for all NAT types except Symmetric NATs (present in corporate firewall situations).

Regarding screen transfer/sharing, thanks to the mirror driver, I&#39;m automatically notified of changed screen regions and I can simply marshal the mirror driver&#39;s ever-changing screen bitmap to my own bitmap. Then I compress the screen region as a PNG and send it off from the server to my client. Things are looking pretty good, but it&#39;s not fast enough. It&#39;s just as slow as VNC (btw, I don&#39;t use the VNC protocol, just a custom amateur protocol).

From the slowest remote desktop software to the fastest, the list usually begins at all VNC-like implementations, then climbs up to Microsoft Windows Remote Desktop...and then...TeamViewer. Not quite sure about CrossLoop, LogMeIn - I haven&#39;t used them, but TeamViewer is *insanely* fast. It&#39;s quite literally live. I ran a `tree` command on Command Prompt and it updated with 20 ms delay. I can browse the web just a few milliseconds slower than on my laptop. Scrolling code vertically in Visual Studio has 50 ms lag time. Think about how robust TeamViewer&#39;s screen-transfer solution must be to accomplish all this.

VNCs use poll-based hooks for detecting screen change and brute force screen capturing/comparing at their worst. At their best, they use a mirror driver like DFMirage. I&#39;m at this level. And they use something called the RFB protocol.

Microsoft Windows Remote Desktop apparently goes one step higher than VNC. I heard, from somewhere on StackOverflow, that Windows Remote Desktop doesn&#39;t send screen bitmaps, but actual drawing commands. That&#39;s quite brilliant, because it can just send simple text (draw this rectangle at this coordinate and color it with this gradient)! Remote Desktop really is pretty fast - and it&#39;s the standard way of working from home. And it uses something called the RDP protocol.

Now TeamViewer is a complete mystery to me. Apparently, they released their source code for Version 2 (TeamViewer is Version 7 as of February 2012). People have read it and said that Version 2 is useless - that it&#39;s just a few improvements over VNC with automatic NAT traversal. 

But Version 7...it&#39;s ridiculously fast now. I mean, it&#39;s actually faster than Windows Remote Desktop. I&#39;ve streamed DirectX 3D games with TeamViewer (at 1 fps, but Windows Remote Desktop doesn&#39;t even allow DirectX to run).

By the way, TeamViewer does all this *without* a mirror driver. There is an option to install one, and it gets just a bit faster.

**The Question**

**My question is, how is TeamViewer so fast?** It must not be possible. If you&#39;ve got 1920 by 1080 resolution at even 24 bit depth (16 bit depth would be noticeably ugly), thats still 6,220,800 bytes raw. Even using libjpeg-turbo (one of the fastest JPG compression libraries used by large corporations), compressing it down to 30KB (let&#39;s be extremely generous), would take time to route through TeamViewer&#39;s servers (TeamViewer bypasses corporate Symmetric NATs by simply proxying traffic through their servers). And that libjpeg-turbo compression would take time to compress. High-quality JPG compression takes 175 milliseconds for a full 1920 by 1080 screenshot for me. And that number goes up if the host&#39;s computer runs an Atom processor. I simply don&#39;t understand how TeamViewer has optimized their screen transfer so well. Again, small-size images might be highly compressed, but take at least tens of milliseconds to compress. Large-size images take no time to compress, but take a long time to get through. Somehow, TeamViewer completes this entire process to get roughly 20-25 frames per second. I&#39;ve used a network monitor, and TeamViewer is still lagless at speeds of 500 Kbps and 1 Mbps (VNC software lag for a few seconds at that transfer rate). During my `tree` Command Prompt test, TeamViewer was receiving inbound data at a rate of 1 Mbps and still running 5-6 fps. VNC and remote desktop don&#39;t do that. So, how?

The answers will be somewhat complicated and intricate, so *please don&#39;t post your $0.02 if you&#39;re only going to say it&#39;s because they use UDP instead of TCP* (would you believe they actually do use TCP just as successfully though).

I&#39;m hoping there&#39;s a TeamViewer developer somewhere here on StackOverflow.

**Potential Answers**

Will update this once people reply.

1. My thoughts are, first of all, that TeamViewer has very fine network control. For example, they split large packets to just under the MTU size and never waste a trip. They probably have all sorts of fancy hooks to detect screen changes along with extremely fast XOR image comparisons.

Content Type	Original Author	Original Content on Stackoverflow
Question	zhigang	View Question on Stackoverflow
Solution 1 - Python	David Wolever	View Answer on Stackoverflow
Solution 2 - Python	Fred Foo	View Answer on Stackoverflow
Solution 3 - Python	scottwed	View Answer on Stackoverflow
Solution 4 - Python	passion	View Answer on Stackoverflow
Solution 5 - Python	rs_punia	View Answer on Stackoverflow

which one should I use: os.sep or os.path.sep?

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

Solution 3 - Python

Solution 4 - Python

Solution 5 - Python

How to define relative paths in Visual Studio Project?

Proper/fastest way to reshape a data.table

Attributions