Use parentheses and [string literal concatenation](https://docs.python.org/3.6/reference/lexical_analysis.html#string-literal-concatenation):


    msg = (
             f&#39;Leave Request created successfully. &#39;
             f&#39;Approvers sent the request for approval: {leave_approver_list}&#39;
    )

Note, the first literal doesn&#39;t need an `f`, but I include it for consistency/readability.



You will need a line break unless you wrap your string within parentheses. In this case, `f` will need to be prepended to the second line:

    &#39;Leave Request created successfully.&#39;\
    f&#39;Approvers sent the request for approval: {leave_approver_list}&#39;

Here&#39;s a little demo:

    In [97]: a = 123

    In [98]: &#39;foo_&#39;\
        ...: f&#39;bar_{a}&#39;
    Out[98]: &#39;foo_bar_123&#39;

I recommend [juanpa&#39;s answer][1] since it is cleaner, but this is one way to do this.

  [1]: https://stackoverflow.com/questions/48881196/how-can-i-split-up-a-long-f-string-in-python/48881390#48881390




I can&#39;t figure out why this trivial code is not working:

**index.html:**



&lt;!-- language: lang-html --&gt;

    &lt;!doctype HTML&gt;
    &lt;html&gt;

    &lt;head&gt;
      &lt;script type=&quot;module&quot; src=&quot;/showImport.js&quot;&gt;&lt;/script&gt;
    &lt;/head&gt;

    &lt;body&gt;
      &lt;button onclick=&quot;showImportedMessage();&quot;&gt;Show Message&lt;/button&gt;
    &lt;/body&gt;

    &lt;/html&gt;


**showImport.js:**

    import showMessage from &#39;/show.js&#39;;
    
    function showImportedMessage() {
        showMessage();
    }

**show.js:**

    export default &quot;Why do I need this?&quot;;
    
    export function showMessage() {
        alert(&quot;Hello!&quot;);
    }

It is being served by NPM **http-server**. When I connect with Chrome (v65), I see the following error


    (index):8 Uncaught ReferenceError: showImportedMessage is not defined
        at HTMLButtonElement.onclick ((index):8)
    onclick @ (index):8

If I get rid of `type=module` (and import/export by putting the `showMessage` function right in `showImport.js`) everything works, but *the whole purpose of this was to use modules*.

Also I had to add that useless `export default` statement, without it Chrome would complain:

    Uncaught SyntaxError: The requested module &#39;/show.js&#39; does not provide an export named &#39;default&#39;

So what am I missing here?

How to use code from script with type=module


I tried to use break inside nested for each loop and it says **jump target cannot cross function boundary**. please let me know how can i break nested for each loop when certain condition is met in TypeScript.

   

    groups =[object-A,object-B,object-C]
        groups.forEach(function (group) {
        // names also an array
            group.names.forEach(function (name) {
        
            if (name == &#39;SAM&#39;){
             break; //can not use break here it says jump target cannot cross function boundary
          }
        
        }
        
        }



How to break/continue across nested for each loops in TypeScript

I am getting a *line too long* [PEP 8][1] *E501* issue.

    f&#39;Leave Request created successfully. Approvers sent the request for approval: {leave_approver_list}&#39;

I tried using a multi-line string, but that brings in a `\n`, which breaks my test:

    f&#39;&#39;&#39;Leave Request created successfully.
    Approvers sent the request for approval: {leave_approver_list}&#39;&#39;&#39;

How can I keep it single line and pass PEP&amp;nbsp;8 linting?

  [1]: https://pep8.org/




How can I split up a long f-string in Python?

I am getting a line too long <a href="https://pep8.org/" target="_blank" rel="noopener noreferrer">PEP 8</a> E501 issue.
<pre><code class="hljs language-vbnet">f'Leave Request created successfully. Approvers sent the request for approval: {leave_approver_list}'
</code></pre>
I tried using a multi-line string, but that brings in a <code>\n</code>, which breaks my test:
<pre><code class="hljs language-bash">f'''Leave Request created successfully.
Approvers sent the request for approval: {leave_approver_list}'''
</code></pre>
How can I keep it single line and pass PEP 8 linting?

I am moving my config from setup.py to setup.cfg and having issues setting up the `entry_points` parameter. At the moment I am using a hybrid approach which works, however, I would like to move the `entry_points` to setup.cfg.

From 

    def setup_package():
        setup(version=get_version(),
              entry_points={&#39;console_scripts&#39;:[&#39;app=my_package.app.run:cli&#39;],})

to

```cfg
[metadata]
name = my-package
description = my-package
license = unlicensed
long-description = README.md
platforms = any
classifiers =
  Programming Language :: Python

[options]
zip_safe = False
packages = my_package,  my_package.app
include_package_data = True
package_dir =
  = .
tests_require = pytest; pytest-cov

[entry_points]
console_scripts =
  my-package = my_package.app.run:cli
```

How to set up entry_points in setup.cfg

I was going through this example of a LSTM language model on github [(link)][1].
What it does in general is pretty clear to me. But I&#39;m still struggling to understand what calling `contiguous()` does, which occurs several times in the code.

For example in line 74/75 of the code input and target sequences of the LSTM are created.
Data (stored in `ids`) is 2-dimensional where first dimension is the batch size.

&lt;!-- language-all: lang-python --&gt;

    for i in range(0, ids.size(1) - seq_length, seq_length):
        # Get batch inputs and targets
        inputs = Variable(ids[:, i:i+seq_length])
        targets = Variable(ids[:, (i+1):(i+1)+seq_length].contiguous())

So as a simple example, when using batch size 1 and `seq_length` 10 `inputs` and `targets` looks like this:

    inputs Variable containing:
    0     1     2     3     4     5     6     7     8     9
    [torch.LongTensor of size 1x10]

    targets Variable containing:
    1     2     3     4     5     6     7     8     9    10
    [torch.LongTensor of size 1x10]

So in general my question is, what does `contiguous()` do and why do I need it?

Further I don&#39;t understand why the method is called for the target sequence and but not the input sequence as both variables are comprised of the same data.

How could `targets` be non-contiguous and `inputs` still be contiguous?

---

**EDIT:**

*I tried to leave out calling `contiguous()`, but this leads to an  error message when computing the loss.*

    RuntimeError: invalid argument 1: input is not contiguous at .../src/torch/lib/TH/generic/THTensor.c:231

*So obviously calling `contiguous()` in this example is necessary.* 

  [1]: https://github.com/yunjey/pytorch-tutorial/blob/master/tutorials/02-intermediate/language_model/main.py

PyTorch - What does contiguous() do?

I am trying to get the hard drive size and free space using Python (I am using Python 2.7 with macOS).

I am trying with `os.statvfs(&#39;/&#39;)`, especially with the following code.
Is it correct what I am doing? Which definition of the variable `giga` shall I use?

    import os
    
    def get_machine_storage():
    	result=os.statvfs(&#39;/&#39;)
    	block_size=result.f_frsize
    	total_blocks=result.f_blocks
    	free_blocks=result.f_bfree
    	# giga=1024*1024*1024
    	giga=1000*1000*1000
    	total_size=total_blocks*block_size/giga
    	free_size=free_blocks*block_size/giga
    	print(&#39;total_size = %s&#39; % total_size)
	    print(&#39;free_size = %s&#39; % free_size)
    
    get_machine_storage()

EDIT:
`statvfs` is deprecated in Python 3, do you know any alternative?

Get hard disk size in Python

The command `jupyter notebook` will open the Jupyter directory tree page where you can create a ipynb file. 

Is there a way to skip that page and create and open the ipynb file directly on the browser?

I was thinking something like jupyter notebook mynotebook.ipynb

How to create and open a jupyter notebook ipynb file directly from terminal

I&#39;m practicing the management of .txt files in python. I&#39;ve been reading about it and found that if I try to open a file that doesn&#39;t exists yet it will create it on the same directory from where the program is being executed. The problem comes that when I try to open it, I get this error:

&gt; IOError: [Errno 2] No such file or directory:
&gt; &#39;C:\\Users\\myusername\\PycharmProjects\\Tests\\copy.txt&#39;. 

I even tried specifying a path as you can see in the error.

    import os
    THIS_FOLDER = os.path.dirname(os.path.abspath(__file__))
    my_file = os.path.join(THIS_FOLDER, &#39;copy.txt&#39;)

How to create a new text file using Python

This question is motivated by my another question: https://stackoverflow.com/questions/48989065/how-to-await-in-cdef

There are tons of articles and blog posts on the web about `asyncio`, but they are all very superficial.  I couldn&#39;t find any information about how `asyncio` is actually implemented, and what makes I/O asynchronous.  I was trying to read the source code, but it&#39;s thousands of lines of not the highest grade C code, a lot of which deals with auxiliary objects, but most crucially, it is hard to connect between Python syntax and what C code it would translate into.

Asycnio&#39;s own documentation is even less helpful.  There&#39;s no information there about how it works, only some guidelines about how to use it, which are also sometimes misleading / very poorly written.

I&#39;m familiar with Go&#39;s implementation of coroutines, and was kind of hoping that Python did the same thing.  If that was the case, the code I came up in the post linked above would have worked.  Since it didn&#39;t, I&#39;m now trying to figure out why.  My best guess so far is as follows, please correct me where I&#39;m wrong:

1. Procedure definitions of the form `async def foo(): ...` are actually interpreted as methods of a class inheriting `coroutine`.
2. Perhaps, `async def` is actually split into multiple methods by `await` statements, where the object, on which these methods are called is able to keep track of the progress it made through the execution so far.
3. If the above is true, then, essentially, execution of a coroutine boils down to calling methods of coroutine object by some global manager (loop?).
4. The global manager is somehow (how?) aware of when I/O operations are performed by Python (only?) code and is able to choose one of the pending coroutine methods to execute after the current executing method relinquished control (hit on the `await` statement).

In other words, here&#39;s my attempt at &quot;desugaring&quot; of some `asyncio` syntax into something more understandable:


    async def coro(name):
        print(&#39;before&#39;, name)
        await asyncio.sleep()
        print(&#39;after&#39;, name)
    
    asyncio.gather(coro(&#39;first&#39;), coro(&#39;second&#39;))
    
    # translated from async def coro(name)
    class Coro(coroutine):
        def before(self, name):
            print(&#39;before&#39;, name)
        
        def after(self, name):
            print(&#39;after&#39;, name)
        
        def __init__(self, name):
            self.name = name
            self.parts = self.before, self.after
            self.pos = 0
        
        def __call__():
            self.parts[self.pos](self.name)
            self.pos += 1
        
        def done(self):
            return self.pos == len(self.parts)
    
    
    # translated from asyncio.gather()
    class AsyncIOManager:
    
        def gather(*coros):
            while not every(c.done() for c in coros):
                coro = random.choice(coros)
                coro()

Should my guess prove correct: then I have a problem.  How does I/O actually happen in this scenario? In a separate thread?  Is the whole interpreter suspended and I/O happens outside the interpreter?  What exactly is meant by I/O?  If my python procedure called C `open()` procedure, and it in turn sent interrupt to kernel, relinquishing control to it, how does Python interpreter know about this and is able to continue running some other code, while kernel code does the actual I/O and until it wakes up the Python procedure which sent the interrupt originally?  How can Python interpreter in principle, be aware of this happening?

How does asyncio actually work?

I have a project which I want to structure like this:

    myproject
    ├── api
    │   ├── __init__.py
    │   └── api.py
    ├── backend
    │   ├── __init__.py
    │   └── backend.py
    ├── models
    │   ├── __init__.py
    │   └── some_model.py
    └── __init__.py

Now, I want to import the module `some_model.py` in both `api.py` and `backend.py`. How do I properly do this?

I tried:

    from models import some_model

but that fails with `ModuleNotFoundError: No module named &#39;models&#39;`.

I also tried:

    from ..models import some_model

which gave me `ValueError: attempted relative import beyond top-level package`. 

What am I doing wrong here? How can I import a file from a different directory, which is not a subdirectory?

How to import a module from a different folder?

My question is related to [this][1]. I am using Python 3.6 in Jupyter Notebook. My project directory is `/user/project`. In this directory I&#39;m building a number of models and each has its own folder. However, there is a common `functions.py` file with functions that I want to use across all models. So I want to keep the `functions.py` file in `/user/project` but be able to call it from an `.ipynb` file in `/user/project/model1`, `/user/project/model2`, etc... How can I do this?


  [1]: https://stackoverflow.com/questions/4383571/importing-files-from-different-folder

Import py file in another directory in Jupyter notebook

Note: This question is for informational purposes only. I am interested to see how deep into Python&#39;s internals it is possible to go with this.

Not very long ago, a discussion began inside a certain [question](https://stackoverflow.com/q/49271187/4909087) regarding whether the strings passed to print statements could be modified after/during the call to `print` has been made. For example, consider the function:

    def print_something():
        print(&#39;This cat was scared.&#39;)

Now, when `print` is run, then the output to the terminal should display:

    This dog was scared.

Notice the word &quot;cat&quot; has been replaced by the word &quot;dog&quot;. Something somewhere somehow was able to modify those internal buffers to change what was printed. Assume this is done without the original code author&#39;s explicit permission (hence, hacking/hijacking).

This [comment](https://stackoverflow.com/questions/49271187/how-to-change-a-string-in-a-function-when-calling-a-function/49271219?noredirect=1#comment85545706_49271219) from the wise @abarnert, in particular, got me thinking:

&gt; There are a couple of ways to do that, but they&#39;re all very ugly, and
&gt; should never be done. The least ugly way is to probably replace the
&gt; `code` object inside the function with one with a different `co_consts`
&gt; list. Next is probably reaching into the C API to access the str&#39;s
&gt; internal buffer. [...]

So, it looks like this is actually possible.

Here&#39;s my naive way of approaching this problem:

    &gt;&gt;&gt; import inspect
    &gt;&gt;&gt; exec(inspect.getsource(print_something).replace(&#39;cat&#39;, &#39;dog&#39;))
    &gt;&gt;&gt; print_something()
    This dog was scared.

Of course, `exec` is bad, but that doesn&#39;t really answer the question, because it does not actually modify anything _during when/after_ `print` is called.

How would it be done as @abarnert has explained it?



Is it possible to &quot;hack&quot; Python&#39;s print function?

I have a bytes type object like this: 

    b&quot;{&#39;one&#39;: 1, &#39;two&#39;: 2}&quot;

I need to get the dictionary from that using python code. I am converting it into string and then converting into dictionary as follows.

    string = dictn.decode(&quot;utf-8&quot;)
    print(type(string))
    &gt;&gt; &lt;class &#39;str&#39;&gt;
    d = dict(toks.split(&quot;:&quot;) for toks in string.split(&quot;,&quot;) if toks)

But I am getting the below error:

    ------&gt; d = dict(toks.split(&quot;:&quot;) for toks in string.split(&quot;,&quot;) if toks)
    TypeError: &#39;bytes&#39; object is not callable


How to convert bytes type to dictionary?

I have some strings with all kinds of different emojis/images/signs in them.

Not all the strings are in English -- some of them are in other non-Latin languages, for example:

&lt;!-- language: lang-none --&gt;

    ▓ railway??
	→ Cats and dogs
	I&#39;m on &#128293;
	Apples ⚛ 
	✅ Vi sign
	♛ I&#39;m the king ♛ 
    Cor&#233;e ♦ du Nord ☁  (French)
     gj&#248;r at b&#229;de ◄╗ (Norwegian)
	Star me ★
	Star ⭐ once more
    早上好 ♛ (Chinese)
    Καλημέρα ✂ (Greek)
    another ✓ sign ✓
    добрай раніцы ✪ (Belarus)
    ◄ शुभ प्रभात ◄ (Hindi)
    ✪ ✰ ❈ ❧ Let&#39;s get together ★. We shall meet at 12/10/2018 10:00 AM at Tony&#39;s.❉

...and many more of these.

I would like to get rid of all these signs/images and to keep only the letters (and punctuation) in the different languages. 

I tried to clean the signs using the [EmojiParser library][1]:

    String withoutEmojis = EmojiParser.removeAllEmojis(input);

The problem is that EmojiParser is not able to remove the majority of the signs. The ♦ sign is the only one I found till now that it removed.
Other signs such as  ✪ ❉ ★ ✰ ❈ ❧ ✂ ❋ ⓡ ✿ ♛ &#128293; are not removed.

Is there a way to remove all these signs from the input strings and keeping only the letters and punctuation in the **different languages**?


  [1]: https://github.com/vdurmont/emoji-java

Remove ✅, &#128293;, ✈ , ♛ and other such emojis/images/signs from Java strings

How do I convert a *hexadecimal color string* like **`#b74093`** to a `Color` in Flutter?

I want to use a HEX color code in Dart.


How do I use hexadecimal color strings in Flutter?

My platform is a Mac. I&#39;m a C++ beginner and working on a personal project which processes Chinese and English. UTF-8 is the preferred encoding for this project.

I read some posts on Stack&amp;nbsp;Overflow, and many of them suggest using `std::string` when dealing with UTF-8 and avoid `wchar_t` as there&#39;s no `char8_t` right now for UTF-8.

However, none of them talk about how to properly deal with functions like `str[i]`, `std::string::size()`, `std::string::find_first_of()` or `std::regex` as these function usually returns unexpected results when facing UTF-8.

Should I go ahead with `std::string` or switch to `std::wstring`? If I should stay with `std::string`, what&#39;s the best practice for one to handle the above problems?



How do I properly use std::string on UTF-8 in C++?

This is a self-answered post. Below I outline a common problem in the NLP domain and propose a few performant methods to solve it.

Oftentimes the need arises to remove **punctuation** during text cleaning and pre-processing. Punctuation is defined as any character in `string.punctuation`:

    &gt;&gt;&gt; import string
    string.punctuation
    &#39;!&quot;#$%&amp;\&#39;()*+,-./:;&lt;=&gt;?@[\\]^_`{|}~&#39;

This is a common enough problem and has been asked before ad nauseam. The most idiomatic solution uses pandas `str.replace`. However, for situations which involve a _lot_ of text, a more performant solution may need to be considered. 

What are some good, performant alternatives to `str.replace` when dealing with hundreds of thousands of records?




Fast punctuation removal with pandas

How can I use f-string with logic to format an `int` as a `float`? I would like if `ppl` is `True` to format `num` to 2 decimal places, and if `ppl` is `False` to rformat it as whatever it is.

Something like `string = f&#39;i am {num:.2f if ppl else num}&#39;` but this does not work. The below code demonstrates the behaviour that I want to achieve with a simpler f-string if possible:

    ppl = True
    num = 3
    string = f&#39;I am {num:.2f}&#39; if ppl else f&#39;I am {num}&#39;
    print(string)
    #if ppl False
    #=&gt; i am 3
    #if ppl True
    #=&gt; i am 3.00

Using f-string with format depending on a condition

I want to use f-string with my string variable, not with string defined with a string literal, `&quot;...&quot;`.

Here is my code:

    name=[&quot;deep&quot;,&quot;mahesh&quot;,&quot;nirbhay&quot;]
    user_input = r&quot;certi_{element}&quot; # this string I ask from user  
    
    for element in name:
        print(f&quot;{user_input}&quot;)

This code gives output:

    certi_{element}
    certi_{element}
    certi_{element}

But I want:

    certi_{deep}
    certi_{mahesh}
    certi_{nirbhay}

How can I do this?

How can I use f-string with a variable, not with a string literal?

I&#39;m wondering how to use an f-string whilst using `r` to get a raw string literal. I currently have it as below but would like the option of allowing any name to replace `Alex` I was thinking adding an f-string and then replacing `Alex` with curly braces and putting username inside but this doesn&#39;t work with the `r`.

    username = input(&#39;Enter name&#39;)
    download_folder = r&#39;C:\Users\Alex\Downloads&#39;

Combine f-string and raw string literal

[f-Strings][1] are available from Python 3.6 and are very useful for formatting strings:

    &gt;&gt;&gt; n=&#39;you&#39;
    &gt;&gt;&gt; f&#39;hello {n}, how are you?&#39;
    &#39;hello you, how are you?&#39;

Reading more about them in [Python 3&#39;s f-Strings: An Improved String Formatting Syntax (Guide)][2]. I found an interesting pattern:

&gt; Note that using triple braces will result in there being only single braces in your string:

&gt;     &gt;&gt;&gt; f&quot;{{{74}}}&quot;
    &#39;{74}&#39;

&gt; However, you can get more braces to show if you use more than triple braces:

&gt;     &gt;&gt;&gt; f&quot;{{{{74}}}}&quot;
    &#39;{{74}}&#39;

And this is exactly the case:

    &gt;&gt;&gt; f&#39;{74}&#39;
    &#39;74&#39;

    &gt;&gt;&gt; f&#39;{{74}}&#39;
    &#39;{74}&#39;

Now if we pass from two `{` to three, the result is the same:

    &gt;&gt;&gt; f&#39;{{{74}}}&#39;
    &#39;{74}&#39;           # same as f&#39;{{74}}&#39; !

So we need up to 4! (`{{{{`) to get two braces as an output:

    &gt;&gt;&gt; f&#39;{{{{74}}}}&#39;
    &#39;{{74}}&#39;

Why is this? What happens with two braces to have Python require an extra one from that moment on?

  [1]: https://www.python.org/dev/peps/pep-0498/
  [2]: https://realpython.com/python-f-strings/





Content Type	Original Author	Original Content on Stackoverflow
Question	tread	View Question on Stackoverflow
Solution 1 - Python	juanpa.arrivillaga	View Answer on Stackoverflow
Solution 2 - Python	cs95	View Answer on Stackoverflow

How can I split up a long f-string in Python?

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

How to break/continue across nested for each loops in TypeScript

How to use code from script with type=module

Attributions