If a function just calls another function, delete one of them. You don't need both main() and testing(), since the former does nothing other than call the latter.

Global variables are almost never needed. Don't organize programs around the need to modify global variables. Instead, organize your programs around functions that rely only on their local variables (or methods the follow similar principles). If some functions need access to the same information, pass that data back and forth using function arguments and return values.

Don't put logic in top-level code. At the top level of a program, you can perform imports or define constants, functions, or classes. Put all other code inside of functions or methods. If we apply all of the preceding ideas to your current code, we end up with the following structure:

def main():
    lives = 6
    chosen_word = random.choice(WORD_LIST)
    ...
    while lives > 0:
        guess = ask_input()
        blanks, lives = replace_blank(guess, chosen_word, blanks, lives)
        ...

def ask_input():
    ...

def replace_blank(guess, chosen_word, blanks, lives):
    ...
    return (blanks, lives)

Try to design functions so that they perform a single task. This reorganization of the code highlights some awkwardness in the implementation. The main() function initializes lives and blanks but then delegates responsibility for updating them to the replace_blank() function. Meanwhile, that function has various other responsibilities, like printing messages to the user and clearing the terminal.

Missing features. Many hangman games tell the user what letters have already been guessed and I've never seen one that penalizes a player for guessing an already-guessed letter. I mention this missing behavior because it points the way toward a less awkward code design. The first step is to select a data structure to hold prior guesses. A set is a natural fit. In fact, if we know the initial number of lives, the secret word, and the prior guesses, all other information about game state can be derived (remaining lives, whether the game is finished, how the secret word should be displayed, etc).

Try to separate logic/algorithm from interactivity and printing. Code that interacts with users is a hassle to test and debug. Ideally, you want most of your program to operate purely in the data realm: for functions that means receiving data and returning data; for methods it might mean receiving data and then returning data or modifying internal data. However, many programs require interactivity and related printing. Programs like this are often good fits for a design that used a main function to handle interactions and an immutable object that knows hold to hold the current state and then how to compute the next state. Let's start with a sketch of the interactive layer. This is where we perform all printing and collecting of user input.

import random
import os

WORD_LIST = [...]

HANGMANPICS = [...]

def main():
    # Setup.
    gs = GameState(random.choice(WORD_LIST))

    # Play until done.
    while not gs.is_finished:
        # Printing.
        os.system('clear')
        print(gs.graphic)
        print('Secret word:', gs.display_word)
        print('Prior guesses:', gs.display_guesses)
        if gs.message:
            print(gs.message)
        # Derive the next state based on user input.
        gs = gs.next_state(ask_input())

    # Wrap up.
    print(gs.outcome)

def ask_input():
    while True:
        guess = input("Guess a letter?  ").lower()
        if guess.isalpha() and len(guess) == 1:
            return guess

if __name__ == '__main__':
    main()

The rest of the code just requires implementing the needed data-retrieval behaviors in GameState. As noted, the initial state will hold an empty set for prior guesses. A message attribute will be used to store information needed by our interactive layer when printing game status.

from dataclasses import dataclass, field

@dataclass(frozen = True)
class GameState:
    word : str
    prior_guesses : set = field(default_factory = set)
    message : str = ''

    INITIAL_LIVES = len(HANGMANPICS) - 1
    BLANK = '_'

Inside the GameState class, we need to implement various properties to get information derived from our core pieces of data (the word and the prior guesses):

class GameState:

    @property
    def lives(self):
        return self.INITIAL_LIVES - sum(
            char not in self.word
            for char in self.prior_guesses
        )

    @property
    def display_word(self):
        return ''.join(
            char if char in self.prior_guesses else self.BLANK
            for char in self.word
        )

    @property
    def display_guesses(self):
        return ' '.join(sorted(self.prior_guesses))

    @property
    def is_finished(self):
        return self.lives <= 0 or self.word == self.display_word

    @property
    def graphic(self):
        return HANGMANPICS[self.INITIAL_LIVES - self.lives]

    @property
    def outcome(self):
        return (
            None if not self.is_finished else
            'You won' if self.display_word == self.word else
            'You lost'
        )

Finally, the class needs a method to generate a new GameState instance based on the current state and the user's guess:

class GameState:

    def next_state(self, guess):
        w = self.word
        pg = self.prior_guesses
        message = (
            f'Already guessed: {guess}' if guess in pg else
            f'Correct: {guess}' if guess in w else
            f'Not in word: {guess}. You lose a life'
        )
        return GameState(w, pg | {guess}, message)