As other said, it resolves to the current path and therefore exists, but here's why,

pathlib.Path is acutally a subclass of pathlib.PurePath which assumes the current directory when the pathsegments (argument) is empty (equivalent to '').

You can prove that empirically like this,

from pathlib import PurePath
print(PurePath())
>>>> .

I assume there is an advantage gained by defining the Path('') to be the same as Path('.').

Correct. Even though I'm not the creator of that lib, I assume this is for syntax and logical reasons. Indeed, people often want to refer to the current directory to compute something dynamically. Therefore, for the same reason . points to the current directory, the lib creator probably wanted to let you write something like this,

>>>> p = Path() # or possibly Path('.')
>>> [x for x in p.iterdir() if x.is_dir()]

that would list sub directories.

Basically, see this as a default. It was logic that the default path returned by Path() was the current directory. Thus, logically, an empty string value should have the same behavior.

You need to patch the class, not the instance. It is enough to patch the method on the Path class, as it defines the exists method for the whole of the pathlib library (PosixPath, WindowsPath, PurePosixPath and PureWindowsPath all inherit the implementation):

>>> from unittest.mock import patch
>>> from pathlib import Path
>>> p = Path('~/test.py')
>>> with patch.object(Path, 'exists') as mock_exists:
...     mock_exists.return_value = True
...     p.exists()
...
True
>>> with patch.object(Path, 'exists') as mock_exists:
...     mock_exists.return_value = False
...     p.exists()
...
False
>>> with patch.object(Path, 'exists') as mock_exists:
...     mock_exists.return_value = 'Anything you like, actually'
...     p.exists()
...
'Anything you like, actually'

The pathlib classes use __slots__ to keep their memory footprint low, which has the side-effect of their instances not supporting arbitrary attribute assignment.

Use os.path.isdir for directories only:

>>> import os
>>> os.path.isdir('new_folder')
True

Use os.path.exists for both files and directories:

>>> import os
>>> os.path.exists(os.path.join(os.getcwd(), 'new_folder', 'file.txt'))
False

Alternatively, you can use pathlib:

 >>> from pathlib import Path
 >>> Path('new_folder').is_dir()
 True
 >>> (Path.cwd() / 'new_folder' / 'file.txt').exists()
 False

Your example works as expected, because pathlib.Path.exists doesn't take any arguments. The path you are interested in is saved in the Path object.

import pathlib
from unittest import TestCase
from unittest.mock import patch

def my_exists(self):
    # self is the Path instance, str(Path) returns the path string
    return str(self) == "a"

class MyTest(TestCase):
    def test_exists(self):
        with patch.object(pathlib.Path, 'exists', my_exists):
            self.assertTrue(pathlib.Path("a").exists())
            self.assertFalse(pathlib.Path("b").exists())

Yes, that is Path.mkdir:

pathlib.Path('/tmp/sub1/sub2').mkdir(parents=True, exist_ok=True)

From the docs:

If parents is true, any missing parents of this path are created as needed; they are created with the default permissions without taking mode into account (mimicking the POSIX mkdir -p command).

If parents is false (the default), a missing parent raises FileNotFoundError.

If exist_ok is false (the default), FileExistsError is raised if the target directory already exists.

If exist_ok is true, FileExistsError exceptions will be ignored (same behavior as the POSIX mkdir -p command), but only if the last path component is not an existing non-directory file.

If you pass in an argument with spaces in it, you need to surround it with quotation marks ("), so it knows that you're not passing in multiple arguments. Also, as a general rule of thumb, don't include spaces in filenames.