As [PEP 8 states][1]:

&gt; The preferred way of wrapping long lines is by using Python&#39;s implied line continuation inside parentheses, brackets and braces. Long lines can be broken over multiple lines by wrapping expressions in parentheses. These should be used in preference to using a backslash for line continuation.


  [1]: https://www.python.org/dev/peps/pep-0008/#maximum-line-length

I&#39;m using Rails, Puma, Capistrano3. I have installed the gem `capistrano3-puma` as well. I started Puma with Puma Jungle [https://github.com/puma/puma/tree/master/tools/jungle/upstart][1]

How do I restart Puma during deployment?

  [1]: https://github.com/puma/puma/tree/master/tools/jungle/upstart

How to restart puma after deploy?

I am trying to load the rJava using the command:  

     library(rJava)

But I get the following error:

     Error : .onLoad failed in loadNamespace() for &#39;rJava&#39;, details:
       call: fun(libname, pkgname)
       error: JAVA_HOME cannot be determined from the Registry
     Error: package or namespace load failed for ‘rJava’

I tried reinstalling both the Java and the R program with the latest versions
but still get these errors..
May I know how I can resolve this? Thank you very much!


rJava install error &quot;JAVA_HOME cannot be determined from the Registry&quot;

Lately have seen imports like this

    from module import (function, another_function, 
                        another_function)

Seemingly this has been done to be able to stretch the `import` statement over more than one line. In cases like this I usually just import like so

    from module import function, another_function, \
                another_function

What exactly are the parentheses doing in this case and are they considered to be bad practice? 


Why import statements with parentheses?

Lately have seen imports like this
<pre><code class="hljs language-javascript">from module import (function, another_function, 
 another_function)
</code></pre>
Seemingly this has been done to be able to stretch the <code>import</code> statement over more than one line. In cases like this I usually just import like so
<pre><code class="hljs language-javascript">from module import function, another_function, \
 another_function
</code></pre>
What exactly are the parentheses doing in this case and are they considered to be bad practice?

I have a Pandas dataframe (this is only a little piece)

    &gt;&gt;&gt; d1
       y norm test  y norm train  len(y_train)  len(y_test)  \
    0    64.904368    116.151232          1645          549
    1    70.852681    112.639876          1645          549

                                        SVR RBF  \
    0   (35.652207342877873, 22.95533537448393)
    1  (39.563683797747622, 27.382483096332511)

                                            LCV  \
    0  (19.365430594452338, 13.880062435173587)
    1  (19.099614489458364, 14.018867136617146)

                                       RIDGE CV  \
    0  (4.2907610988480362, 12.416745648065584)
    1    (4.18864306788194, 12.980833914392477)

                                             RF  \
    0   (9.9484841581029428, 16.46902345373697)
    1  (10.139848213735391, 16.282141345406522)

                                               GB  \
    0  (0.012816232716538605, 15.950164822266007)
    1  (0.012814519804493328, 15.305745202851712)

                                                 ET DATA
    0  (0.00034337162272515505, 16.284800366214057)  j2m
    1  (0.00024811554516431878, 15.556506191784194)  j2m
    &gt;&gt;&gt;

I want to split all the columns that contain tuples. For example, I want to replace the column `LCV` with the columns `LCV-a` and `LCV-b`.

How can I do that?





How can I split a column of tuples in a Pandas dataframe?

Say if you had a number input `8` in python and you wanted to generate a list of consecutive numbers up to `8` like

    [0, 1, 2, 3, 4, 5, 6, 7, 8]

How could you do this?

How can I generate a list of consecutive numbers?

I just wrote some testing python code into `test.py`, and I&#39;m launching it as follows:

    perl test.py

After a while I realized my mistake. I say &quot;after a while&quot;, because the
Python code gets actually correctly executed, as if in Python interpreter!

Why is my Perl interpreting my Python? `test.py` looks like this:

    #!/usr/bin/python

    ...Python code here...

Interestingly, if I do the opposite (i.e. call `python something.pl`) I get a good deal of syntax errors.

Why don&#39;t I get any syntax errors when I execute my Python script with Perl?

I have the following DataFrame:

        Col1  Col2  Col3  Type
    0      1     2     3     1
    1      4     5     6     1
    ...
    20     7     8     9     2
    21    10    11    12     2
    ...
    45    13    14    15     3
    46    16    17    18     3
    ...

The DataFrame is read from a CSV file. All rows which have `Type` 1 are on top, followed by the rows with `Type` 2, followed by the rows with `Type` 3, etc.

I would like to shuffle the order of the DataFrame&#39;s rows so that all `Type`&#39;s are mixed. A possible result could be:

        Col1  Col2  Col3  Type
    0      7     8     9     2
    1     13    14    15     3
    ...
    20     1     2     3     1
    21    10    11    12     2
    ...
    45     4     5     6     1
    46    16    17    18     3
    ...

How can I achieve this?

Shuffle DataFrame rows

I have a pandas data frame which has some rows and columns. Each column has a header. Now as long as I keep doing data manipulation operations in pandas, my variable headers are retained. But if I try some data pre-processing feature of Sci-kit-learn lib, I end up losing all my headers and the frame gets converted to just a matrix of numbers. 

I understand why it happens because scikit-learn gives a numpy ndarray as output. And numpy ndarray being just matrix would not have column names. 

But here is the thing. If I am building some model on my dataset, even after initial data pre-processing and trying some model, I might have to do some more data manipulation tasks to run some other model for better fit. Without being able to access column header makes it difficult to do data manipulation as I might not know what is the index of a particular variable, but it&#39;s easier to remember variable name or even look up by doing df.columns. 

How to overcome that? 

EDIT1: Editing with sample data snapshot. 

    	Pclass	Sex	Age	SibSp	Parch	Fare	Embarked
    0	3	0	22	1	0	7.2500	1
    1	1	1	38	1	0	71.2833	2
    2	3	1	26	0	0	7.9250	1
    3	1	1	35	1	0	53.1000	1
    4	3	0	35	0	0	8.0500	1
    5	3	0	NaN	0	0	8.4583	3
    6	1	0	54	0	0	51.8625	1
    7	3	0	2	3	1	21.0750	1
    8	3	1	27	0	2	11.1333	1
    9	2	1	14	1	0	30.0708	2
    10	3	1	4	1	1	16.7000	1
    11	1	1	58	0	0	26.5500	1
    12	3	0	20	0	0	8.0500	1
    13	3	0	39	1	5	31.2750	1
    14	3	1	14	0	0	7.8542	1
    15	2	1	55	0	0	16.0000	1

The above is basically the pandas data frame. Now when I do this on this data frame it will strip the column headers. 

    from sklearn import preprocessing 
    X_imputed=preprocessing.Imputer().fit_transform(X_train) 
    X_imputed

New data is of numpy array and hence the column names are stripped. 

    array([[  3.        ,   0.        ,  22.        , ...,   0.        ,
              7.25      ,   1.        ],
           [  1.        ,   1.        ,  38.        , ...,   0.        ,
             71.2833    ,   2.        ],
           [  3.        ,   1.        ,  26.        , ...,   0.        ,
              7.925     ,   1.        ],
           ..., 
           [  3.        ,   1.        ,  29.69911765, ...,   2.        ,
             23.45      ,   1.        ],
           [  1.        ,   0.        ,  26.        , ...,   0.        ,
             30.        ,   2.        ],
           [  3.        ,   0.        ,  32.        , ...,   0.        ,
              7.75      ,   3.        ]])

So I want to retain the column names when I do some data manipulation on my pandas data frame. 
 

How to retain column headers of data frame after Pre-processing in scikit-learn

I have a problem

    @import Foundation;

and I see:  
https://stackoverflow.com/questions/18947516/import-vs-import-ios-7

and I set &quot;Enable Modules&quot; to &quot;YES&quot; 

and my problem is not solved

use of @import when modules are disabled

I&#39;m currently playing around with React Native. I&#39;m trying to structure my app, however it&#39;s starting to get messy with imports.

    --app/
        -- /components
            -- Loading.js
        -- index.ios.js

Now, within my `index.ios.js` i&#39;m able to simply do:

`import Loading from &#39;./components/Loading&#39;;`

However, when I start to create more components, with a deeper directory struture, it starts to get messy:

`import Loading from &#39;.../../../../components/Loading&#39;;`

I understand the preferred solution would be to make private npm modules for things, but that&#39;s overkill for a small project.

You could do a `global.requireRoot` type solution on the browser, but how do I implement this with import?

ES6 import from root

It seems there are already quite some questions here about relative import in python 3, but after going through many of them I still didn&#39;t find the answer for my issue. 
so here is the question. 

I have a package shown below

    package/
       __init__.py
       A/
          __init__.py
          foo.py
       test_A/
          __init__.py
          test.py

and I have a single line in test.py:

    from ..A import foo

now, I am in the folder of `package`, and I run 

    python -m test_A.test

I got message

    &quot;ValueError: attempted relative import beyond top-level package&quot;

but if I am in the parent folder of `package`, e.g., I run:

    cd ..
    python -m package.test_A.test

everything is fine. 

**Now my question is:** 
when I am in the folder of `package`, and I run the module inside the test_A sub-package as `test_A.test`, based on my understanding, `..A` goes up only one level, which is still within the `package` folder, why it gives message saying `beyond top-level package`. What is exactly the reason that causes this error message?





beyond top level package error in relative import

In `src/lib.rs` I have the following

    extern crate opal_core;

    mod functions;
    mod context;
    mod shader;

Then in `src/context.rs` I have something like this, which tries to import symbols from `src/shader.rs`:

    use opal_core::shader::Stage;
    use opal_core::shader::Shader as ShaderTrait;
    use opal_core::GraphicsContext as GraphicsContextTrait;

    use functions::*; // this import works fine
    use shader::*; // this one doesn&#39;t

    pub struct GraphicsContext {
        functions: Gl
    }

    fn shader_stage_to_int(stage: &amp;Stage) -&gt; u32 {
        match stage {
            &amp;Stage::Vertex =&gt; VERTEX_SHADER,
            &amp;Stage::Geometry =&gt; GEOMETRY_SHADER,
            &amp;Stage::Fragment =&gt; FRAGMENT_SHADER,
        }
    }

    impl GraphicsContextTrait for GraphicsContext {

        /// Creates a shader object
        fn create_shader(&amp;self, stage: Stage, source: &amp;str) -&gt; Box&lt;ShaderTrait&gt; {
            let id;
    
            unsafe {
                id = self.functions.CreateShader(shader_stage_to_int(&amp;stage));
            }

            let shader = Shader {
                id: id,
                stage: stage,
                context: self
            };
    
            Box::new(shader)
        }
    }

The problem is that the statement `use shader::*;` gives the error *unresolved import*.

I was reading the docs and they said that `use` statements always go from the root of the current crate (`opal_driver_gl`) so I thought `shader::*` should be importing `opal_driver_gl::shader::*` but it doesn&#39;t appear to do so. Do I need to use the `self` or `super` keywords here?

Thanks if you can help. 

How do I import from a sibling module?

I want to test a few functions that are included in my main package, but my tests don&#39;t appear to be able to access those functions.

My sample main.go file looks like:

    package main
    
    import (
    	&quot;log&quot;
    )
    
    func main() {
    	log.Printf(foo())
    }
    
    func foo() string {
    	return &quot;Foo&quot;
    }

and my main_test.go file looks like:

    package main
    
    import (
    	&quot;testing&quot;
    )
    
    func Foo(t testing.T) {
    	t.Error(foo())
    }

when I run `go test main_test.go` I get

    # command-line-arguments
    .\main_test.go:8: undefined: foo
    FAIL    command-line-arguments [build failed]

As I understand, even if I moved the test file elsewhere and tried importing from the main.go file, I couldn&#39;t import it, since it&#39;s `package main`.

What is the correct way of structuring such tests? Should I just remove everything from the `main` package asides a simple main function to run everything and then test the functions in their own package, or is there a way for me to call those functions from the main file during testing?

How to test the main package functions in golang?

I was trying to create a branch from `master` with the following command,

    git branch SSLOC-201_Implement___str__()_of_ProductSearchQuery

when Git suddenly stopped responding. I suspect the unescaped `()` are to blame, somehow. Now, whenever I try to run any Git command, I get the same error:

    git:176: command not found: _of_ProductSearchQuery

with the number after `git` increasing every time I type a command.

Can anyone explain what happened? And how do I get back to normal? I&#39;d like to delete that branch, but how can I do that?

Complex Git branch name broke all Git commands

The following code is wrong (see it [on ideone](http://ideone.com/vSoRsM)):

    public class Test
    {
    	public static void Main()
    	{
    	    int j = 5;
    	    (j++);      // if we remove the &quot;(&quot; and &quot;)&quot; then this compiles fine.
    	}
    }

&gt; error CS0201: Only assignment, call, increment, decrement, await, and
&gt; new object expressions can be used as a statement

1. Why does the code compile when we remove the parentheses?
2. Why does it not compile with the parentheses?
3. Why was C# designed that way?

Why was the statement (j++); forbidden?

As per as my knowledge we use `try catch` as follows:

    try {
       //Some code that may generate exception
    }
    catch(Exception ex) {
    }
       //handle exception
    finally {
       //close any open resources etc.
    }

But in a code I found following

    try(
        ByteArrayOutputStream byteArrayStreamResponse  = new ByteArrayOutputStream();					
    	HSLFSlideShow	pptSlideShow = new HSLFSlideShow(
                                          new HSLFSlideShowImpl(
     Thread.currentThread().getContextClassLoader()
           .getResourceAsStream(Constants.PPT_TEMPLATE_FILE_NAME)
                                         ));
     ){
    }
    catch (Exception ex) {
           //handel exception
    }
    finally {
          //close any open resource
    }

I am not able to understand why this parentheses `()` just after try. 

What is the usage of it? Is it new in Java 1.7? What kind of syntax I can write there?

Please also refer me some API documents.

Content Type	Original Author	Original Content on Stackoverflow
Question	LarsVegas	View Question on Stackoverflow
Solution 1 - Python	deceze	View Answer on Stackoverflow

Why import statements with parentheses?

Python Problem Overview

Python Solutions

Solution 1 - Python

rJava install error "JAVA_HOME cannot be determined from the Registry"

How to restart puma after deploy?

Attributions