PyQt5 crashing after interaction - python-3.x

Question

I've been programming an application with PyQt5, and when I try to open a new window after a button interaction, the program crashes, and spits out exit code -1073740791.
My code looks like this:
class Start(QWidget):
def __init__(self):
super().__init__()
self.run()
def switch1(self):
Initiative.initRoll.show()
def startScreen(self):
startButton = QPushButton('Start')
infoButton = QPushButton('How To Use')
creditButton = QPushButton('Credits')
settingButton = QPushButton('Settings')
grid = QGridLayout()
grid.addWidget(infoButton, 0, 0)
grid.addWidget(settingButton, 0, 1)
grid.addWidget(creditButton, 0, 2)
grid.addWidget(startButton, 1, 0, 1, 3)
self.setLayout(grid)
startButton.clicked.connect(self.switch1)
self.setWindowTitle('Battletech App')
def run(self):
Start.startScreen(self)
self.show()
class Initiative(QWidget):
def initRoll(self):
initButton = QPushButton('Roll for Initiative')
grid = QGridLayout()
grid.addWidget(initButton, 2, 0, 1, 3)
self.setLayout(grid)
self.setWindowTitle('Battletech App')
def main():
app = QApplication(sys.argv)
ex = Start()
sys.exit(app.exec_())
I've messed around with most of the code trying to fix it, but I'm not sure how to.

Answer 1

If you want to get a more descriptive error message then it is recommended that you run your code from the CMD or console. In your case it is:
Traceback (most recent call last):
File "/path/of/script.py", line 14, in switch1
Initiative.initRoll.show()
AttributeError: 'function' object has no attribute 'show'
Aborted (core dumped)
And the cause is clear, you are handling the creation of objects incorrectly. The logic is to use the class as an object provider, and use that object to call the functions (recommendation: Check your notes on OOP).
def switch1(self):
self.initiative = Initiative()
self.initiative.initRoll()
self.initiative.show()

Answer 2

tl;dr:
Your syntax to call instance methods is wrong, and you're trying to call functions that don't exist.
Change to:
def switch1(self):
self.initiative = Initiative()
self.initiative.initRoll()
self.initiative.show()
And also the following (while not technically wrong, your call is unorthodox):
def run(self):
self.startScreen()
self.show()
Explanation
The first problem is that you're trying to access an attribute (show) that doesn't exist. This is your command:
Initiative.initRoll.show()
The above roughly means: access the show attribute of initRoll, which is an attribute of Initiative.
The problem becomes clear if you run it from a terminal/prompt (something you should always do whenever you get an exception you cannot track in the IDE), as you can clearly see the following traceback:
Traceback (most recent call last):
File "file.py", line 11, in switch1
Initiative.initRoll.show()
AttributeError: 'function' object has no attribute 'show'
initRoll, your function, obviously doesn't have any show attribute. Initiative has, but trying to call Initiative.show() wouldn't work either, which leads us to another issue with your code.
The problem is the strange way you're trying to call instance methods.
You are doing that in two occasions.
In run() it works:
Start.startScreen(self)
That's because calling startScreen using self (which is the instance) as argument, can correctly execute it: the self argument exists, and it also matches the current instance.
While this approach works, is not the conventional way of calling instance methods, as long as they are method of the current instance.
This approach is normally found when subclassing, as it allows to call the base implementation on the class, and was much more common in Python 2. A typical case is the __init__:
class SomeClass(QWidget):
def __init__(self):
# direct call to the base implementation, using the reference to the
# current instance (self) as its argument
QWidget.__init__(self)
# using super(), as required by Python 2, which is almost the same as
# above: calls the base implementation by referring the *super* class
# for its instance
super(SomeClass, self).__init__()
# common Python 3 usage, which doesn't require the arguments
super().__init__()
In all the cases above, the (base) class __init__ is called with self as argument, which is exactly what you're doing with startScreen(self).
show() is an instance method, and as with all instance methods, the first argument refers to the instance and is mandatory.
If Qt was written in Python, the code for show would be the following:
def show(self):
# some code that actually tells the OS to map a region of the screen that
# will show some user interface
Being an instance method, it cannot be called just from a class using Initiative.show(). It has to be called from an instance:
# create the instance
initiative = Initiative()
# call the method
initiative.show()
In this case, show() will be called correctly (when functions are called from an instance, their self argument becomes implicitly the instance).
In the code given at the beginning I also made the initiative instance a member of the Start instance, using self.initiative = .... This is required, because failing to do so (using a local variable only: initiative = ...) will result in a garbage collection of that object as soon as the function returns, so the widget will be immediately closed (you might see it for a fraction of a second only, but that's not always the case).
Finally, two suggestions:
read more about classes and instances to better understand how they work and how they should be used, and do more studying on how object oriented programming works in general;
while "messing around" is sometimes fine, doing it completely randomly is never a good idea if you're planning on learning; in the long run, studying the documentation is always the right choice (even if it seems more boring than messing around), as it lets you better understand what you're doing, what happens and why, especially if the documentation is well written and/or there are multiple valid sources around (which is the case for both Python and Qt);