Indentation

Please fix your code indentation, as it is now it's painful to figure out what's supposed to be happening. The comments provide the corect suggestions to make it easy for you as well.

CONSTANTS

The characters for living and dead cells should be module-level constants. Makes them easily changeable and the code more readable:

LIVING_CELL = '#'
DEAD_CELL = ' '
CELLS = (LIVING_CELL, DEAD_CELL)

variable_names

PEP8 states that variable and function names should follow snake_case.

nextCells -> next_cells

List creation

List comprehensions are generally preferrable to manual list comprehensions. Consider this improved creation of next_cells:

import random

next_cells = []

for _ in range(WIDTH):
    column = [random.choice(CELLS) for _ in range(HEIGHT)]
    next_cells.append(column)

You might even go a step further and go for a nested comprehension:

next_cells = [[random.choice(CELLS) for _ in range(HEIGHT)] for _ in range(WIDTH)]

I'd say this one-liner is still pretty readable, probably even more so than the first suggestion, therefore I recommend it.

Naming iteration variables _ is a convention to signal that the variable value is never actually used.

Main logic

You're doing way too much manual checking when counting the neighbors. You should not manually construct all possible combinations of coordinates. Instead, think about the underlying logic and how to translate that into more concise code. I'm sure there are also many resources available (probably on this site alone) for proper checking / counting neighbors for a given coordinate.

Please also note that the original game rules are designed for a board of infinite size, as far as I know there are no "official" rules for boards of limited sizes.

print('\n\n\n\n\n') is better expressed as print('\n' * 5).

Indentation

Please fix your code indentation, as it is now it's painful to figure out what's supposed to be happening. The comments provide the corect suggestions to make it easy for you as well.

CONSTANTS

The characters for living and dead cells should be module-level constants. Makes them easily changeable and the code more readable:

LIVING_CELL = '#'
DEAD_CELL = ' '
CELLS = (LIVING_CELL, DEAD_CELL)

variable_names

PEP8 states that variable and function names should follow snake_case.

nextCells -> next_cells

List creation

List comprehensions are often times preferrable to manual list comprehensions. Consider this improved creation of next_cells:

import random

next_cells = []

for _ in range(WIDTH):
    column = [random.choice(CELLS) for _ in range(HEIGHT)]
    next_cells.append(column)

You might even go a step further and go for a nested comprehension:

next_cells = [[random.choice(CELLS) for _ in range(HEIGHT)] for _ in range(WIDTH)]

I'd say this one-liner is still pretty readable, probably even more so than the first suggestion, therefore I recommend it.

random.choice is a better choice for expressing your intention in this snippet.

Naming iteration variables _ is a convention to signal that the variable value is never actually used.

Main logic

You're doing way too much manual checking when counting the neighbors. You should not manually construct all possible combinations of coordinates. Instead, think about the underlying logic and how to translate that into more concise code. I'm sure there are also many resources available (probably on this site alone) for proper checking / counting neighbors for a given coordinate.

Please also note that the original game rules are designed for a board of infinite size, as far as I know there are no "official" rules for boards of limited sizes.

print('\n\n\n\n\n') is better expressed as print('\n' * 5).

Indentation

Please fix your code indentation, as it is now it's painful to figure out what's supposed to be happening. The comments provide the corect suggestions to make it easy for you as well.

CONSTANTS

The characters for living and dead cells should be module-level constants. Makes them easily changeable and the code more readable:

LIVING_CELL = '#'
DEAD_CELL = ' '

variable_names

PEP8 states that variable and function names should follow snake_case.

nextCells -> next_cells

List creation

List comprehensions are generally preferrable to manual list comprehensions. Consider this improved creation of next_cells:

next_cells = []

for _ in range(WIDTH):
    column = [random.choice(CELLS) for _ in range(HEIGHT)]
    next_cells.append(column)

You might even go a step further and go for a nested comprehension:

next_cells = [[random.choice(CELLS) for _ in range(HEIGHT)] for _ in range(WIDTH)]

I'd say this one-liner is still pretty readable, probably even more so than the first suggestion, therefore I recommend it.

Naming iteration variables _ is a convention to signal that the variable value is never actually used.

Main logic

You're doing way too much manual checking when counting the neighbors. You should not manually construct all possible combinations of coordinates. Instead, think about the underlying logic and how to translate that into more concise code. I'm sure there are also many resources available (probably on this site alone) for proper checking / counting neighbors for a given coordinate.

Please also note that the original game rules are designed for a board of infinite size, as far as I know there are no "official" rules for boards of limited sizes.

print('\n\n\n\n\n') is better expressed as print('\n' * 5).

Indentation

Please fix your code indentation, as it is now it's painful to figure out what's supposed to be happening. The comments provide the corect suggestions to make it easy for you as well.

CONSTANTS

The characters for living and dead cells should be module-level constants. Makes them easily changeable and the code more readable:

LIVING_CELL = '#'
DEAD_CELL = ' '
CELLS = (LIVING_CELL, DEAD_CELL)

variable_names

PEP8 states that variable and function names should follow snake_case.

nextCells -> next_cells

List creation

List comprehensions are generally preferrable to manual list comprehensions. Consider this improved creation of next_cells:

import random

next_cells = []

for _ in range(WIDTH):
    column = [random.choice(CELLS) for _ in range(HEIGHT)]
    next_cells.append(column)

You might even go a step further and go for a nested comprehension:

next_cells = [[random.choice(CELLS) for _ in range(HEIGHT)] for _ in range(WIDTH)]

I'd say this one-liner is still pretty readable, probably even more so than the first suggestion, therefore I recommend it.

Naming iteration variables _ is a convention to signal that the variable value is never actually used.

Main logic

You're doing way too much manual checking when counting the neighbors. You should not manually construct all possible combinations of coordinates. Instead, think about the underlying logic and how to translate that into more concise code. I'm sure there are also many resources available (probably on this site alone) for proper checking / counting neighbors for a given coordinate.

Please also note that the original game rules are designed for a board of infinite size, as far as I know there are no "official" rules for boards of limited sizes.

print('\n\n\n\n\n') is better expressed as print('\n' * 5).