Get the best rational approximations for any real number in builtin Python
PEP-8 Guidelines

Follow the PEP-8 Style Guidelines, such as:


1 space around operators (1 / x instead of 1/x)
snake_case for identifiers &amp; functions (cont_frac instead of contFrac)


Import As

The preferred method of creating an alias for an import is:

from decimal import Decimal as D


Since you are only using the floor function from math, you could also:

from math import floor


Docstrings

"""Docstrings""" exist to help a user with the usage of a function.  There are usually in triple quotes, because they should be multi-line strings, with enough information to be useful to the caller, without needing the caller to read the source code.

def continue_fraction(x, k):
    """
    Construct a continued fraction from a real value

    Parameters:
        x (float): Real value to determine continued fraction of
        k (int): A loop limit representing accuracy somehow

    Returns:
        List[Int]: List of continued fraction values
    """


A """docstring""" is the first statement of a module, class, function or method, if it is a string.  In particular,

    """Best Rational Approx Init"""


is not a """docstring""", because it is not the first statement.  It should be a comment.

    # Best Rational Approx Init


Comments are used to document the source code, for someone reading the source code.  In contrast, """Docstrings""" are used to provide help to the user of the item, so they do not have to read the source code.  It is displayed using the help() command:

&gt;&gt;&gt; help(continue_fraction)


Don't use docstrings as comments, or vise-versa.

Superfluous Parenthesis

        ran = (hn0 + (i*hn1))
        rad = (kn0 + (i*kn1))


should be written as

        ran = hn0 + i * hn1
        rad = kn0 + i * kn1


Named Tuple

Consider using a named tuple, instead of using dictionaries for fixed content items.

from collections import namedtuple

fraction = namedtuple("fraction", "ratio, denom")

...

        ...
        ralist.append(fraction(f'{ran}/{rad}', rad))
        ...

    for x in sorted(conlist + ralist, key=lambda i: i.denom):
        finallist.append(x.ratio)


Collection

Why are you maintaining ralist separate from conlist, when you later add the two lists together and sort them??  Why not just maintain a single list?

List Comprehension

List appending is inefficient:

    finallist = []
    for x in sorted(conlist + ralist, key=lambda i: i.denom):
        finallist.append(x.ratio)


due to repeated reallocations of the list as the list size grows.  It is better to construct and initialize the list in one operation:

    finallist = [ x.ration for x in sorted(conlist + ralist, key=lambda i: i.denom) ]




Useless

This operation:

return list(dict.fromkeys(finallist))


takes a list, turns it into a dictionary with each list item as a key (all the dictionary values are None), and then constructs a list from just the dictionary's keys.  Uhm.   As long as the dictionary is kept in insertion order, which it is because you are using f'' strings so must be using Python 3.6 or later, this is indistinguishable from:

return finallist




Apparently the goal here was to remove duplicates.  A comment would have helped; it is not obvious.

Meaningful Function and Variable Names

What is contFrac and bestra?  It would be way clearer to use continued_fraction and best_rational_approximation, especially if you are writing this for "anyone exploring the logic of infinite continued fractions".

conlist, ralist, clist, app, ran and rad are equally obscure.