Program to check if in line are doubled words
Here are some suggestions:

Keep file handlers in one function.

First off, the get_text_file() and lines_list() methods:


def get_text_file(self):
    file = open('C:/Users/PC/Documents/skychallenge_skyphrase_input.txt', 'r')
    return file

def lines_list(self):
    text = self.get_text_file()
    line_list = text.readlines()
    return [line.split() for line in line_list]




It's generally a bad idea to pass files outside of a function... it poses some questions: Who will close the file? When? And how? Instead, open and close it in the same function so that the file can be contained.
Since the lines_list() method is only reading text off from get_text_file() (and nothing else), it may be better to simply write one function which reads handles and reads lines off the file. (The splitting of lines, line.split(), can be done in phrases_validation().)


With these points in mind, we could define get_text_lines() as:

def get_text_lines(self):
    with open('C:/Users/PC/Documents/skychallenge_skyphrase_input.txt', 'r') as file:
        line_list = file.readlines()

    return line_list


Notice that the use of the with statement. This automatically closes the file when the block-scope is exited.

Using the above function implies modifying phrases_validation():

def phrases_validation(self):
    # ...
    for line in get_text_lines():   # call function here
        # ...
        words = line.split()        # split lines here
        for word in words:          # iterate through split line here
            # ...


The Validation Algorithm

I've tried annotating the meat of your phrases_validation:


# iterate through lines...
for line in get_text_lines():

    new_line = []  # container to store 1s and 0s

    # iterate through words...
    words = line.split()
    for word in words:

        exam = line.count(word)

        # append 0 if word is duplicated
        if exam &gt; 1:
            new_line.append(0)

        # append 1 if word is not duplicated
        else:
            new_line.append(1)

    # increment validated_phrases if no duplicates
    if 0 in new_line:
        validated_phrases += 0
    else:
        validated_phrases += 1



Some general suggestions:


Opt for readability. Since only 0 and 1 are being used, this implies a binary domain, and thus can be substituted with False and True respectively.
validated_phrases += 0 This can be removed since nothing is added. Simply do

if 0 not in new_line:
    validated_phrases += 1



Some possible improvements to the algorithm:

Using the any built-in function.

The any built-in function takes a list and tests for truth. If any of the elements are Truthy, any returns True, else False. Your inner loop can make use of the any function:

for line in get_text_lines():
    words = line.split()

    has_duplicates = any(words.count(word) &gt; 1 for word in words)
    if not has_duplicates:
        validated_phrases += 1


Here, a comprehension was used: words.count(word) &gt; 1 for word in words.

This generates an iterable of True/False values: True if words.count(word) &gt; 1 and False otherwise. We then check whether there are any duplicates and if not, increment validated_phrases.

(To keep track of the number of duplicates, you can use the sum function instead. This will add the True values, counting the number of duplicates.)

Using the set class.

Indeed, there are a couple more ways to check for duplicates. list.count has a time-complexity with an upper-bound of \$O(n)\$ (with \$n\$ being the length of the list), i.e. it searches the entire list, which may be slow when the list grows to sizes of thousands or millions.

One other way to check for duplicates would be to obtain a container of unique words, and check whether it has the same length as the list of words in the line. We can use set to obtain the unique words.

for line in get_text_lines():
    words = line.split()

    unique_words = set(words)
    has_duplicates = len(unique_words) != len(words)
    if not has_duplicates:
        validated_phrases += 1,


I'm not entirely sure about the complexity of set(words) but the len function has a time complexity of \$O(1)\$ which can be really fast in the long run.

Using the collections.Counter class.

Another way that might be of interest would be to use Counter from the collections module.

for line in get_text_lines():
    words = line.split()

    counter = Counter(words)
    has_duplicates = any(counter[word] != 1 for word in counter)
    if not has_duplicates:
        validated_phrases += 1


(For this, remember to add from collections import Counter at the top of your script.)

Try not to rely on __str__.

In your code, the main algorithm, phrases_validation(), is only called when str(text) or text__str__() is called (this is implicitly called by print(text)).

It's creative... but prefer to directly call phrases_validation():

validator = SkyphrasesValidation()
print(validator.phrases_validation())


(And call str() on it if needed.) This is more explicit to readers that you're calling the phrases_validation() method.

Generally, the __str__ magic method should be overloaded when you're trying to display a class' members contents. Unfortunately, SkyphrasesValidation doesn't have any members.

The variable name text can be interpreted in several ways. Is it a text file? A string?  Consider a more descriptive name instead. (validator was used in the example above.)

Class?

The class could have been substituted with one/two functions. But sticking with a class... since the self argument is rarely used, consider making the methods static or instead, place get_text_lines() outside of the class and pass the lines of text to phrases_validation() as an argument.

Hope this helps!