Your attachment has this code. See added comments. 

class Road(type):
  pass

class X():
  pass

# This calls the function that creates a class named 'Hello'.
print(type('Hello', (), {})) # => <class '__main__.Hello'>

# The following line is equivalent to the preceding line because Road
# is a subclass of (the class) type. So, since Road is not defined as a function 
# the superclass function (type) is called. (At least I believe that's what's happening.)
print(Road('Hello', (), {})) # Equivalent to type('Hello', (), {})

# The following calls the function that asks for the type of X. It
# doesn't really call type as a class.
print(type(X))
# The preceding is as if we had a function
def type(x): 
   return x.__class__
# and we are calling that function. We are simply asking to look up the
# __class__ attribute of x.

# The following line asks to create an instance of Road. But since Road is
# itself a type, it is asking for an instance of type. To create an instance
# of type requires the function type(_, _, _), which calls type.__new__, which
# takes three arguments.
print(Road(X)) # => TypeError: type.__new__() takes exactly 3 arguments (1 given)

Another bit of information.

>>> help(type)
Help on class type in module builtins:
class type(object)
 |  type(object_or_name, bases, dict)
 |  type(object) -> the object's type         (a)
 |  type(name, bases, dict) -> a new type     (b)
 |  ...

My guess is that this means that type can be called in two ways,
(a) either with one argument (an object), in which case it returns the type of its argument,
(b) or with three arguments (a name, a tuple of bases, and a dictionary), in which case it creates a new type, i.e., a new Class. 

In other words, depending on how type( ... ) is called, two completely different functions are executed.

As Abel pointed out, this is not consistent with standard Python syntax. Normally one can't use the same name for two functions, even if the two functions have different signatures.

It's been a while since I used Java, but if I'm remembering correctly, one can use the same name for different functions in Java. How about C/C++ ? Since Python is implemented in C++ (or is it straight C?) can use use the same name for multiple functions in C?

This is getting a bit involved (and probably less and less interesting), but here are a few more examples.

class Road(type):
  pass

class X:
  pass

class W:
  pass

x_object = X()
y = x_object.__new__(W)
print(type(y))                            # => <class '__main__.W'>

z = 1.0.__new__(float, 42)
print(z, type(z))                         # => 42.0 <class 'float'>

print(type.__new__ is Road.__new__)       # => True
print(type.__new__ is W.__new__)          # => False
print(x_object.__new__ is W.__new__)      # => True
print(bool.__new__ is W.__new__)          # => False
print(object.__new__ is x_object.__new__) # => True