You can also take a look at llist python package, which provides some useful features that deque does not. There are not only doubly linked lists, but also single linked lists data structure in that package. IMHO, one of the biggest advantages of this package is the ability to store a reference to the llist elements.

For the most part it looks good, I haven't tested performance, but nothing stands out as bad. You should probably rewrite remove, so that it takes an index rather than a value. Imagine

list = LinkedList()
list.insert(2)
list.insert(2)
list.remove(2)

Your current code works great as long as there aren't duplicate values, but once there are everything gets kind of messed up.

With regards to pythonicness, the only comment I have is that if(x): is harder to type and harder to parse than if x:.

Summary

I won't dwell on what has already been cited by users toolic and J_H, so I just have a few comments:

Type Hinting

I would suggest that you include type hinting, especially if your functions do not contain docstrings that describe the type of arguments being passed to functions (J_H has suggested this, so pardon if this is too repetitive).

Be More Tolerant of Errors in User Input

If the user does not enter a valid integer in function run_and_add, you essentially quit. You should instead put out the prompt again and give the user as many chances needed to enter valid input. The user can always terminate by entering Ctrl-C if they get stuck.

Strive for Encapsulation and Reusability

I can't stress too strongly that your code is crying out for you to create a LinkedList abstract data type that abstracts the notion of a linked list while encapsulating the actual implementation. To that end, I would use attribute names that begin with '_' where appropriate to suggest that they are "private" and not to be either updated nor depended on existing in the future (such as the next instance attribute of the ListNode class.

The following classes are just one possibility. Note:

1. There is no print method implemented since printing the entire list is trivial given that the class implements the iterator protocol. Besides, what if you wanted to print to a file? Then a print method would require one or more additional arguments.
2. The client never explicitly creates ListNode instances.
3. The linked list keeps explicit track of the final (last) node in the list to provide efficient appending of a node or an entire linked list to the end.

I can envision your using this as a starting point and potentially adding other methods (for example, __eq__ methods to compare nodes and linked lists).

"""A module for creating and manipulating linked lists."""

from abc import ABC, abstractmethod
from typing import TypeVar, Any

LinkedListInstance = TypeVar('LinedListInstance', bound='LinkedList')

class NodeType(ABC):
    @property
    @abstractmethod
    def val(self):
        pass

    @val.setter
    @abstractmethod
    def val(self, val):
        pass

class LinkedList:

    class _ListNode(NodeType):
        """Initialize a new node with some value, val."""

        def __init__(self, val):
            self._val = val
            self._next = None

        @property
        def val(self):
            return self._val

        @val.setter
        def val(self, val):
            self._val = val

        def __repr__(self):
            return f'_ListNode({repr(self._val)})'

        def __str__(self):
            return str(self._val)

    def __init__(self):
        """Create a new, empty linked list."""

        self._head = None
        self._tail = None

    def append_node(self, val: Any) -> LinkedListInstance:
        """Append a new node to the list initialized with val."""

        new_node = LinkedList._ListNode(val)
        if self._head is None:
            self._head = new_node
        else:
            self._tail._next = new_node
        self._tail = new_node

        return self

    def insert_node(self, at_node: NodeType, val: Any) -> LinkedListInstance:
        """Create and insert a new node after the specified at_node node initialized
        with val."""

        if at_node is self._tail:  # special case
            return self.append_node(val)
        node_to_insert = LinkedList._ListNode(val)
        node_to_insert._next = at_node._next
        at_node._next = node_to_insert

        return self

    def append_list(self, linked_list: LinkedListInstance) -> LinkedListInstance:
        """Append a linked list to the current list."""

        if self._head is None:
            self._head = linked_list._head
        else:
            self._tail._next = self._head
        self._tail = linked_list._tail

        return self

    def __iter__(self) -> NodeType:
        """Iterate the list."""

        current = self._head
        while current is not None:
            yield current
            current = current._next

if __name__ == '__main__':
    def insert_node_at_position(linked_list: LinkedList, position: int) -> None:
        for counter, current_node in enumerate(linked_list, start=1):
            print(f"Node at position {counter}: {current_node}")
            if counter == position:
                while True:
                    try:
                        number = int(input("Please insert an Integer: "))
                    except ValueError:
                        print("Not an Integer")
                    else:
                        break
                linked_list.insert_node(current_node, number)
                print("Node added at position:", position)

        print("Updated linked list:")
        for node in linked_list:
            print(node)

    linked_list = LinkedList().append_node(1).append_node(2).append_node(3)
    insert_node_at_position(linked_list, 2)

For some needs, a deque may also be useful. You can add and remove items on both ends of a deque at O(1) cost.

from collections import deque
d = deque([1,2,3,4])

print d
for x in d:
    print x
print d.pop(), d