Python is fun. For pyglet, you need to install avbin and package it somehow. I believe frastlin was messing with packaging the dll, so if he would post here that'd be great.
Pyglet basically works like this. You have your loop, that runs the game for you. Bgt gives you things like this.
When you press enter, wait 5 seconds then open the game.
Pyglet is like this.
On every repeating of the loop (which you set as 1 second a loop), make a variable that is added to by 1 till it is 5. As you know the loop is 1 ittiration (repeat) one second, and you add 1 to the variable in every ittiration, logically when the counter (variable) is 5, the loop has executed 5 times. So. Check every loop ittiration if the counter is 5, if not, counter+=1. When the counter is 5 (5 seconds have passed), execute the code.
This could be slitely complicated than bgt, but it gives you a lot of flexibility later on.
If you need any more help, just post in here-me, and other python users will be happy to help.

Just chimed in to clerrify that you dn't need the ; at the end of python lines.

At Dhruv: ah, oops. I copy-edited the code and must have forgotten to remove them. Fixing now.

Personally, I'd go with Python. As Python is used for, like, literally, everything. I'd probably go with it because I enjoy it and love its syntax. It's just like writing an article or book, accept your writing the book and having a program (Python) - the editor - check it over for errors and tell you what you need to correct. The classes are books, volumes, etc., and the defined functions are chapters. Inside the chapters, the variables, statements, etc. are text that the editor reads when it looks at your book - or books. That's kind of how I analyze a Python program.

@severestormsteve1, yes, PureBASIC is good for games. But its not good for general programming, in my opinion. It has quite the good graphics and sound libs, but Python doesn't have any braces either. A simple GUI hello world in Python is as follows (note that tkinter needs some major accessibility improvements, but otherwise its nice):

import tkinter
from tkinter import ttk

class Application:
    def __init__(self, root):
        self.root = root
        self.root.title('Hello World')
        ttk.Frame(self.root, width=200, height=100).pack()
        ttk.Label(self.root, text='Hello World').place(x=10, y=10)

if __name__ == '__main__':
    root = tkinter.Tk()
    Application(root)
    root.mainloop()

This example shows usage of the Frame and Label widgets, and some basic layout management using pack() and place(). Of course, this is not accessible, as I just found out. Other GUI libraries must be used, but all the same Python would be a better choice as it contains many more features related to its purpose, and many more purposes, with hundreds, if not thousands of libraries downloadable on pypi.org.
We could argue this back and fourth, but I won't. My top recommendation, though, is Python.

Hi,
I don't want to argue in this python/purebasic debate, but I just want to clerrify some points.
the thing that you're doing with print is a commandline interface. I can just do that with
print "hello world!"
As for an accessible gui solution, wx widgets are pretty accessible, and a hello world appplication in wx goes like this (copyed from docs)
import wx

app = wx.App(False)  # Create a new app, don't redirect stdout/stderr to a window.
frame = wx.Frame(None, wx.ID_ANY, "Hello World") # A Frame is a top-level window.
frame.Show(True)     # Show the frame.
app.MainLoop()
That's all there is to it!
Also, you don't need _ in python; it's just a useful sign to separate function names, like my_function_name.

Yeah. One point also is no one has actually created any kind of good audiogame in python yet. I will be trying to do that, to show it can be definitely done .

I would like to point out that SoundRTS was written in Python, so post 14's statement is not true.
I even have proof:

# from soundrts/SoundRTS/clientmain.py:
from lib import log
from version import VERSION_FOR_BUG_REPORTS
from paths import CLIENT_LOG_PATH
log.set_version(VERSION_FOR_BUG_REPORTS)
log.add_secure_file_handler(CLIENT_LOG_PATH, "w")
log.add_http_handler("http://jlpo.free.fr/soundrts/metaserver")
log.add_console_handler()

import locale
try:
    locale.setlocale(locale.LC_ALL, '')
except:
    from lib.log import warning
    warning("couldn't set locale")

import os
import pickle
import sys
import time
import urllib

from clientmedia import voice, init_media, close_media
from clientmenu import Menu, input_string, END_LOOP
from clientserver import connect_and_play, start_server_and_connect
from clientversion import revision_checker
import config
from constants import MAIN_METASERVER_URL
from definitions import style
from game import TrainingGame, ReplayGame, reload_all
from lib.log import exception
from multimaps import worlds_multi
from msgs import nb2msg
from package import get_packages, get_all_packages_paths
from paths import REPLAYS_PATH, SAVE_PATH
import res
from singlemaps import campaigns
import stats
from version import compatibility_version


_ds = open("cfg/default_servers.txt").readlines()
_ds = [_x.split() for _x in _ds]
DEFAULT_SERVERS = [" ".join(["0"] + _x[:1] + [compatibility_version()] + _x[1:]) for _x in _ds]
SERVERS_LIST_HEADER = "SERVERS_LIST"
SERVERS_LIST_URL = MAIN_METASERVER_URL + "servers.php?header=%s&include_ports=1" % SERVERS_LIST_HEADER


class Application(object):

    def choose_server_ip_in_a_list(self):
        servers_list = None
        try:
            f = urllib.urlopen(SERVERS_LIST_URL)
            if f.read(len(SERVERS_LIST_HEADER)) == SERVERS_LIST_HEADER:
                servers_list = f.readlines()
        except:
            pass
        if servers_list is None:
            voice.alert([1029]) # hostile sound
            warning("couldn't get the servers list from the metaserver"
                    " => using the default servers list")
            servers_list = DEFAULT_SERVERS
        nb = 0
        menu = Menu()
        for s in servers_list:
            try:
                ip, version, login, port = s.split()[1:]
                # ignore the first parameter (time)
            except:
                warning("line not recognized from the metaserver: %s", s)
                continue
            nb += 1
            if version == compatibility_version():
                menu.append([login, 4073, login], (connect_and_play, ip, port))
        menu.title = nb2msg(len(menu.choices)) + [4078] + nb2msg(nb) + [4079]
        menu.append([4075, 4076], None)
        menu.run()

#...

So there you go. A game written in Python.
@Genroa, the only reason Python is slow is because the people who write the programs that you use don't know how to optimize their code. If they called the right module, and compiled their script into a .pyo file, the interpreter would be much faster. Alternatively, they could use cx_freeze, written in Python, to compile it to a win32 .EXE executable which would make it even faster.

@dhruv, yes, I agree with you on that point. However, while Python doesn't have that many games written in it, it's got its own set of modules that make it a perfect programming language for both game programming and general programming: pathlib --- Object-oriented filesystem paths, os.path --- Common pathname manipulations, csv --- CSV File Reading and Writing,   hashlib --- Secure hashes and message digests, hmac --- Keyed-Hashing for Message Authentication,   os --- Miscellaneous operating system interfaces,   email --- An email and MIME handling package, etc. PB could have all of this, but it would require a lot of C/C++/ASM programming to accomplish.

As genroa said, use the language you're familiar with; ignore the rest of my post if you don't want highly opinionated things
Python does have a broad feature set. If you don't believe me, go look at the packages in the python cheese shop, which has more than like 50k packages to do diferent things with.
And for game development, pygame, pyglet, etc. Embedding matters for scripting purposes, for example advanced mods and the like, see the entombed2 topic for an explonation of this topic.
So, As I said, use whatever you like. Steve uses purebasic so he's defending purebasic; I use python so i'm defending python. Don't mind me. I get defensive
Edit: @genroa, look up evennia. I don't think it faces difficulties like that

I am too. While I might gotten a little agressive, I was pointing out the perks and faults of it too. I do enjoy other languages like Java/C/C++/C#, however Java really is not a programming language where graphics are concerned, since while it has a lot of libraries, its GUI is not accessible without third-party tools. C/C++ has hundreds of tousands of libraries available, which is more than all three languages we've discussed here - Python, Lua, and PB - so that's probably why its most widely used. C# is .NET CCPPJAVA (C C++ Java), in other words. C# is just a sort of hybrid language between all three. F#, though, is a sort of Java remix, and that's why I don't use it.