Yes there is such a built-in function: [`os.path.join`](http://docs.python.org/library/os.path.html#os.path.join).

    &gt;&gt;&gt; import os.path
    &gt;&gt;&gt; os.path.join(&#39;/my/root/directory&#39;, &#39;in&#39;, &#39;here&#39;)
    &#39;/my/root/directory/in/here&#39;



You want the path.join() function from os.path.

    &gt;&gt;&gt; from os import path
    &gt;&gt;&gt; path.join(&#39;foo&#39;, &#39;bar&#39;)
    &#39;foo/bar&#39;

This builds your path with os.sep (instead of the less portable `&#39;/&#39;`) and does it more efficiently (in general) than using `+`.

However, this won&#39;t actually create the path. For that, you have to do something like what you do in your question. You could write something like:

    start_path = &#39;/my/root/directory&#39;
    final_path = os.join(start_path, *list_of_vars)
    if not os.path.isdir(final_path):
        os.makedirs (final_path)

You can also use an object-oriented path with [`pathlib`](https://docs.python.org/3/library/pathlib.html) (available as a standard library as of Python 3.4):

```python
from pathlib import Path

start_path = Path(&#39;/my/root/directory&#39;)
final_path = start_path / &#39;in&#39; / &#39;here&#39;
```

I need to load a table with a large amount of test data. This is to be used for testing performance and scaling.

How can I easily create 100,000 rows of random/junk data for my database table?

Fill database tables with a large amount of test data

Note that I&#39;m asking about something that will call a callback function more often than once every 15 ms using something like `System.Threading.Timer`.  I&#39;m not asking about how to accurately time a piece of code using something like `System.Diagnostics.Stopwatch` or even `QueryPerformanceCounter`.

Also, I&#39;ve read the related questions:

https://stackoverflow.com/questions/448761/accurate-windows-timer-system-timers-timer-is-limited-to-15-msec

https://stackoverflow.com/questions/163022/high-resolution-timer-in-net

Neither of which supplies a useful answer to my question.

In addition, the recommended MSDN article, [Implement a Continuously Updating, High-Resolution Time Provider for Windows][1], is about timing things rather than providing a continuous stream of ticks.

With that said. . .

There&#39;s a whole lot of bad information out there about the .NET timer objects.  For example, `System.Timers.Timer` is billed as &quot;a high performance timer optimized for server applications.&quot;  And `System.Threading.Timer` is somehow considered a second class citizen.  The conventional wisdom is that `System.Threading.Timer` is a wrapper around Windows [Timer Queue Timers][2] and that `System.Timers.Timer` is something else entirely.

The reality is much different.  `System.Timers.Timer` is just a thin component wrapper around `System.Threading.Timer` (just use Reflector or ILDASM to peek inside `System.Timers.Timer` and you&#39;ll see the reference to `System.Threading.Timer`), and has some code that will provide automatic thread synchronization so you don&#39;t have to do it.  

`System.Threading.Timer`, as it turns out *is not* a wrapper for the Timer Queue Timers.  At least not in the 2.0 runtime, which was used from .NET 2.0 through .NET 3.5.  A few minutes with the Shared Source CLI shows that the runtime implements its own timer queue that is similar to the Timer Queue Timers, but never actually calls the Win32 functions.

It appears that the .NET 4.0 runtime also implements its own timer queue.  My test program (see below) provides similar results under .NET 4.0 as it does under .NET 3.5.  I&#39;ve created my own managed wrapper for the Timer Queue Timers and proved that I can get 1 ms resolution (with quite good accuracy), so I consider it unlikely that I&#39;m reading the CLI source wrong.

I have two questions:

First, what causes the runtime&#39;s implementation of the timer queue to be so slow?  I can&#39;t get better than 15 ms resolution, and accuracy seems to be in the range of -1 to +30 ms.  That is, if I ask for 24 ms, I&#39;ll get ticks anywhere from 23 to 54 ms apart.  I suppose I could spend some more time with the CLI source to track down the answer, but thought somebody here might know.

Second, and I realize that this is harder to answer, why not use the Timer Queue Timers?  I realize that .NET 1.x had to run on Win9x, which didn&#39;t have those APIs, but they&#39;ve existed since Windows 2000, which if I remember correctly was the minimum requirement for .NET 2.0.  Is it because the CLI had to run on non-Windows boxes?

My timers test program:

    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Threading;
    
    namespace TimerTest
    {
        class Program
        {
            const int TickFrequency = 5;
            const int TestDuration = 15000;   // 15 seconds
    
            static void Main(string[] args)
            {
                // Create a list to hold the tick times
                // The list is pre-allocated to prevent list resizing
                // from slowing down the test.
                List&lt;double&gt; tickTimes = new List&lt;double&gt;(2 * TestDuration / TickFrequency);
    
                // Start a stopwatch so we can keep track of how long this takes.
                Stopwatch Elapsed = Stopwatch.StartNew();
    
                // Create a timer that saves the elapsed time at each tick
                Timer ticker = new Timer((s) =&gt;
                    {
                        tickTimes.Add(Elapsed.ElapsedMilliseconds);
                    }, null, 0, TickFrequency);
    
                // Wait for the test to complete
                Thread.Sleep(TestDuration);
    
                // Destroy the timer and stop the stopwatch
                ticker.Dispose();
                Elapsed.Stop();
    
                // Now let&#39;s analyze the results
                Console.WriteLine(&quot;{0:N0} ticks in {1:N0} milliseconds&quot;, tickTimes.Count, Elapsed.ElapsedMilliseconds);
                Console.WriteLine(&quot;Average tick frequency = {0:N2} ms&quot;, (double)Elapsed.ElapsedMilliseconds / tickTimes.Count);
    
                // Compute min and max deviation from requested frequency
                double minDiff = double.MaxValue;
                double maxDiff = double.MinValue;
                for (int i = 1; i &lt; tickTimes.Count; ++i)
                {
                    double diff = (tickTimes[i] - tickTimes[i - 1]) - TickFrequency;
                    minDiff = Math.Min(diff, minDiff);
                    maxDiff = Math.Max(diff, maxDiff);
                }
    
                Console.WriteLine(&quot;min diff = {0:N4} ms&quot;, minDiff);
                Console.WriteLine(&quot;max diff = {0:N4} ms&quot;, maxDiff);
    
                Console.WriteLine(&quot;Test complete.  Press Enter.&quot;);
                Console.ReadLine();
            }
        }
    }


  [1]: http://msdn.microsoft.com/en-us/magazine/cc163996.aspx
  [2]: http://msdn.microsoft.com/en-us/library/ms686796(v=VS.85).aspx


Why are .NET timers limited to 15 ms resolution?

I am looking for some advice as to the best way to generate a file path using variables, currently my code looks similar to the following:

    path = /my/root/directory
    for x in list_of_vars:
            if os.path.isdir(path + &#39;/&#39; + x):  # line A
                print(x + &#39; exists.&#39;)
            else:
                os.mkdir(path + &#39;/&#39; + x)       # line B
                print(x + &#39; created.&#39;)

For lines A and B as shown above, is there a better way to create a file path as this will become longer the deeper I delve into the directory tree?

I envisage an existing built-in method to be used as follows:

    create_path(path, &#39;in&#39;, &#39;here&#39;)

producing a path of the form `/my/root/directory/in/here`

If there is no built in function I will just write myself one.

Thank you for any input.


Create file path from variables

I am looking for some advice as to the best way to generate a file path using variables, currently my code looks similar to the following:
<pre><code class="hljs language-lua">path = /my/root/directory
for x in list_of_vars:
 if os.path.isdir(path + '/' + x): # line A
 print(x + ' exists.')
 else:
 os.mkdir(path + '/' + x) # line B
 print(x + ' created.')
</code></pre>
For lines A and B as shown above, is there a better way to create a file path as this will become longer the deeper I delve into the directory tree?
I envisage an existing built-in method to be used as follows:
<pre><code class="hljs language-lua">create_path(path, 'in', 'here')
</code></pre>
producing a path of the form <code>/my/root/directory/in/here</code>
If there is no built in function I will just write myself one.
Thank you for any input.

I know that it is not allowed to remove elements while iterating a list, but is it allowed to add elements to a python list while iterating. Here is an example:

        for a in myarr:
          if somecond(a):
              myarr.append(newObj())

 
I have tried this in my code and it seems to work fine, however I don&#39;t know if it&#39;s because I am just lucky and that it will break at some point in the future?

EDIT: I prefer not to copy the list since &quot;myarr&quot; is huge, and therefore it would be too slow. Also I need to check the appended objects with &quot;somecond()&quot;.

EDIT: At some point &quot;somecond(a)&quot; will be false, so there can not be an infinite loop.

EDIT: Someone asked about the &quot;somecond()&quot; function. Each object in myarr has a size, and each time &quot;somecond(a)&quot; is true and a new object is appended to the list, the new object will have a size smaller than a. &quot;somecond()&quot; has an epsilon for how small objects can be and if they are too small it will return &quot;false&quot;

Python: Adding element to list while iterating

Is it possible to call a function without first fully defining it? When attempting this I get the error: &quot;*function_name* is not defined&quot;. I am coming from a C++ background so this issue stumps me. 

Declaring the function before works:

    def Kerma():
            return &quot;energy / mass&quot;    
    
    print Kerma()

However, attempting to call the function without first defining it gives trouble:

    print Kerma()
    
    def Kerma():
        return &quot;energy / mass&quot;


In C++, you can declare a function after the call once you place its header before it.

Am I missing something here?


Declare function at end of file in Python

    def play_game(word_list):
        hand = deal_hand(HAND_SIZE) # random init
        while True:
            cmd = raw_input(&#39;Enter n to deal a new hand, r to replay the last hand, or e to end game: &#39;)
            if cmd == &#39;n&#39;:
                hand = deal_hand(HAND_SIZE)
                play_hand(hand.copy(), word_list)
                print
            elif cmd == &#39;r&#39;:
                play_hand(hand.copy(), word_list)
                print
            elif cmd == &#39;e&#39;:
                break
            else:
                print &quot;Invalid command.&quot;

While WHAT is True?

I reckon saying &#39;while true&#39; is shorthand, but for what? While the variable &#39;hand&#39; is being assigned a value? And what if the variable &#39;hand&#39; is not being assigned a value?


What does &quot;while True&quot; mean in Python?

Is there a pythonic way to check if a list is already sorted in `ASC` or `DESC`

    listtimestamps = [1, 2, 3, 5, 6, 7]

something like `isttimestamps.isSorted()` that returns `True` or `False`.

I want to input a list of timestamps for some messages and check if the the transactions appeared in the correct order.

Pythonic way to check if a list is sorted or not

In Ruby you can read from a file using `s = File.read(filename)`. The shortest and clearest I know in Python is

    with open(filename) as f:
        s = f.read()

Is there any other way to do it that makes it even shorter (preferably one line) and more readable?

Note: initially I phrased the question as &quot;doing this in a single line of code&quot;. As pointed by S.Lott, shorter doesn&#39;t necessary mean more readable. So I rephrased my question just to make clear what I meant. I think the Ruby code is better and more readable not necessarily because it&#39;s one line versus two (though that matters as well), but also because it&#39;s a class method as opposed to an instance method, which poses no question about who closes the file, how to make sure it gets closed even if an exception is raised, etc. As pointed in the answers below, you can rely on the GC to close your file (thus making this a one-liner), but that makes the code worse even though it&#39;s shorter. Not only by being unportable, but by making it unclear.

Easiest way to read/write a file&#39;s content in Python

I had to split up a long css file. I put the smaller css files within a `styles` directory.

Now I have to update the the urls to go up one level with the `../` notation.

Is there anyway to specify the base URL from which to load assets like with the base tag in HTML, but with CSS?

Specifying base url for css

Is there anything built into `System.IO.Path` that gives me just the filepath?

For example, if I have a `string` 

&gt; @&quot;c:\webserver\public\myCompany\configs\promo.xml&quot;,

 

is there any BCL method that will give me 

&gt; &quot;c:\webserver\public\myCompany\configs\&quot;?

Get full path without filename from path that includes filename

Question: is there a simple sh/bash/zsh/fish/... command to print the absolute path of whichever file I feed it?

Usage case: I&#39;m in directory `/a/b` and I&#39;d like to print the full path to file `c` on the command-line so that I can easily paste it into another program: `/a/b/c`. Simple, yet a little program to do this could probably save me 5 or so seconds when it comes to handling long paths, which in the end adds up. So it surprises me that I can&#39;t find a standard utility to do this — is there really none?

Here&#39;s a sample implementation, abspath.py:

    #!/usr/bin/python
    # Author: Diggory Hardy &lt;diggory.hardy@gmail.com&gt;
    # Licence: public domain
    # Purpose: print the absolute path of all input paths

    import sys
    import os.path
    if len(sys.argv)&gt;1:
        for i in range(1,len(sys.argv)):
            print os.path.abspath( sys.argv[i] )
        sys.exit(0)
    else:
        print &gt;&gt; sys.stderr, &quot;Usage: &quot;,sys.argv[0],&quot; PATH.&quot;
        sys.exit(1)


How to obtain the absolute path of a file via Shell (BASH/ZSH/SH)?

In Python, suppose I have a path like this:

    /folderA/folderB/folderC/folderD/

How can I get just the `folderD` part?

How to get only the last part of a path in Python?

Say I have a program `X.EXE` installed in folder `c:\abcd\happy\` on the system. The folder is on the system path. Now suppose there is another program on the system that&#39;s also called X.EXE but is installed in folder `c:\windows\`.

Is it possible to quickly find out from the command line that if I type in `X.EXE` which of the two `X.EXE`&#39;s will get launched? (but without having to dir search or look at the process details in Task Manager).

Maybe some sort of in-built command, or some program out there that can do something like this? :

    detect_program_path X.EXE



Content Type	Original Author	Original Content on Stackoverflow
Question	Thorsley	View Question on Stackoverflow
Solution 1 - Python	kennytm	View Answer on Stackoverflow
Solution 2 - Python	nmichaels	View Answer on Stackoverflow
Solution 3 - Python	AlexandreS	View Answer on Stackoverflow

Create file path from variables

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

Solution 3 - Python

Why are .NET timers limited to 15 ms resolution?

Fill database tables with a large amount of test data

Attributions