Espero no estar en el lugar equivocado del foro...

Tengo un juego (Tierras del Sur, Argentum Online), el cual posee una interface gráfica que deseo editar. Al parecer (Muy obvio), está en un archivo (denominado interface.TDS). ¿Cómo empiezo a editarlo? Es decir, ¿cómo se que tipo de archivo es? Básicamente, quiero modificar el aspecto gráfico nada mas. ¿Alguna pista?

EDIT: Nada mas necesito una mínima orientación de como saber "qué es" ese archivo, no pido mas que eso Mientras sigo averiguando por otro laditos.

 Estoy relojeando MSDN,  y me propuse hacer un cambiador de íconos (Utilizo Python, pero no viene al caso).  Realmente no sé por dónde comenzar a buscar. Es decir, ¿Cómo se cambia el ícono de un archivo cualquiera? ¿Existe alguna API para eso? ¿En qué temas me tengo que informar? No vengo a pedir códigos ni nada (A menos que sea necesario), sólo un poco de orientación para poder ubicarme y comenzar a investigar.
(Estoy en Windows XP, por si interesa)

 Muchas gracias de antemano, y un cordial saludo.

 Buenas noches. Intenté hacer un pequeeño e inútil programa, el cuál se le da un numero, un rango, un valor de incremento y un valor de decremento, y el dá un resultado. Por ejemplo:

Numero: 10
Rango: 7
Valor decremento: 0.7
Valor incremento: 3

Es decir, mostrará 7 valores anteriores descontando de a 0.7 y 7 valores posteriores incrementando de a 3:

9.3 8.6 7.9 7.2 6.5 5.8 5.1 ... Y por otro lado mostrará 13 16 19 22 25 28 31

 El programa funciona, pero quisiera saber si cometí algún error, o algún detalles, alguna sugerencia o lo que fuere Muchas gracias de antemano!

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
using namespace std;
//Prototipos
int Menu_Principal();
//MAIN
int main() {
    Menu_Principal();
    getch();
return 0;
}
//Principal
int Menu_Principal() {
  double Numero, decVal, incVal;
  int Rango, Contador, Opcion;
  Contador = 1;
    cout << "Numero: "; cin >> Numero;
    cout << "Rango: "; cin >> Rango;
    cout << "Decrementar en: "; cin >> decVal;
    cout << "Incrementar en: "; cin >> incVal;
    cout << endl;
        //////////////////////////
        //Anteriores             /
        //////////////////////////
        cout << "ANTERIORES A " << Numero << endl;
        while (Contador <= Rango) {
            cout << Numero - (Contador * decVal) << " ";
            Contador += 1;
        }
        //////////////////////////
        //Posteriores            /
        //////////////////////////
        cout << endl << endl << "POSTERIORES A " << Numero << endl;
        Contador = 1;
        while (Contador <= Rango) {
            cout << Numero + (Contador * incVal) << " ";
            Contador += 1;
        }
    cout << endl << endl;
    cout << "1- Salir" << endl;
    cout << "2- Otro numero" << endl;
    cin >> Opcion;
    if (Opcion == 1) exit(0);
    else Menu_Principal();
return 0;
}
 

 Ya lo puse en el posteo del Videotutorial de C++, la cuestión es que a partir del enlace 12 inclusive no funcionan, acá encontré un link de 900mb aprox con todos los capítulos, pero como muchos no van a leer lo que comenté en el otro post, me gustaría pedir si algún mod o algo agregue este enlace o algo. Perdonen que arme un tema para esto, pasa que quizás otros necesitan el VT.

NO SUBÍ YO EL ENLACE, solo lo encontré y tiene todos los caps (Y funciona):

http://www.4shared.com/get/J0bkzFQM/videotutorial_de_c_por_shevche.html;jsessionid=D730E7069290D4E44251E217E65FBFD7.dc323

Mis disculpas de nuevo por la molestia n_n

 Es posible poder ejecutar diversas instrucciones "al mismo tiempo" en Python? Es decir, tengo programado un "intento de reloj" para consola, y ahora estoy entre 2 cosas:
-Que mientras el usuario vaya ingresando el número de opción,  el reloj siga corriendo a un costado.
 Creo que se llama ejecutar algo en background o tengo mal entendido las cosas. Es posible hacer esto?

 Tengo una enorme duda, yo tengo el siguiente código:

class Control:
       def __init__(self, *Extra):
[...]
 

¿Cómo se verifica si se le pasó parámetros extra? Yo lo que quiero hacer dentro es que, si se le pasaron parámetros, en base a esos parámetros se hagan algunas cosas, pero para eso necesito verificar si hay algo en la tupla "Extra". Cómo hago eso? u.u Es con "not"? No logro hacerlo :S

 Estoy intentando entender como diantres funciona un programa para cambiar los íconos de cualquier archivo jeje. Busqué un source para ver como funciona, y sólo encontré uno en VB (Lenguaje que no manejo), y no logro entender qué es lo que hace. Como que lee un ejecutable o algo así. Realmente no entiendo. ¿Qué debería leer para entenderlo? Porque no se qué "cosa" buscar para leer acerca de esto. O sea, ¿Cómo busco documentación en la que explique como funciona esto? u.u Porque quiero entender como funciona, así me hago mi cambiador de íconos en Python n.n (con las APIs obvio, que tampoco las encuentro xD)

 Gracias de antemano n.n

 [edit] ¿Cómo le pongo color al código?
 Bueno, edito el mismo post. Ya solucioné mis dudas, leí, entendí y estoy haciendo mi módulo (ya hace unos días) con varias funciones raras Pienso ponerle muchas cosas, hasta ahora tiene:
-Armado de menúes (Ahora estoy trabando en el armado de menúes con contexto)
-Armado de cajas de texto (con recuadros ASCII Extendidos)
-Marquesina de textos (Textos en movimiento, los cuáles voy a mejorar)
-Manejo de color en consola: Obtener atributs de texto, cambiarlos, etc.
-Obtención de valores: Se puede pasra una lista de cadenas, y devuelve la de menor y mayor longitud, o se puede pasar números y da el mayor y el menor, en una tupla.
-Tiene otros "dos print", ilprint para mostrar un mensaje con otro color, sin cambiar el color de la consola, es decir, cambia solopara mostrar el texto y vuelve a la normalidad y "olprint" que es lo mismo, solo que muestra el texto seguido (equivalente a sys.stdout.write)
-Invertir cadenas
-Muestra mensajes con beepeo
Y estoy trabajando en:
Barra de progreso
Inputboxes (Con recuadros ascii)
Animaciones ascii
Relojes (TAmbién en ASCII, toda la onda)
Y estoy modificando un programa mío para resolver cosas de matemática, y poderlo aplicar
Es una newbiada, y tiene cosas que están de mas, pero es porque forman parte de lo que estoy agregando
 tiene un par de variables definidas, como líneas, y cosas así Véanlo en el código, después voy a hacer un texto sobre como usarlo Es una newbiada total, y espero que algunos sabiondos puedan corregirme n.n Hay cosas que repito ESTÁN DE MAS pero porque van a formar parte de otra cosa que estoy armando
Y también puse de dónde aprendí eso

# -*- coding: cp1252 -*-
#--------------------------------------------
#Autor: GeSeM (S3KH)   Grisolía Emilio.
# Se permite la modificación, y edición de jazzer. Dejando a la moral de cada uno el hecho de mantener o no los créditos.
#Prohibido distribuirlo compilado SIN el fichero de texto, puesto que es código abierto.
#Programado en Python 2.7. 
#-- 
#Versión 2.0 
# Espero, pueda servirles un poco...!
#                                    Septiembre, 2011. Argentina.
#--------------------------------------------
 
print 'Cargando Jazzer...'
print 'Cargando datos... 100%'
ERROR01 = 'Error (Argumento invalido): '
ERROR02 = 'Error (Función inexistente): '
ERROR03 = 'Error (Dato/s invalido/s): '
VAR     = 'VAR'
n       = '-n'
endl    = 'endl'
 
 
 
print 'Cargando (modulos)... 100%'
 
 
#--- MÓDULOS IMPORTADOS ---#
 
import os, time, math, cmath, sys
print 'Cargando ctypes... 100%'
from ctypes import *
 
#-- El uso de ctypes brinda la posibilidad de poder usar las APIs de Windows, entre demás prestaciones de C
 
#------------CONSTANTES (WIN32API)------------------------#
 
print 'Cargando jazzer (GENERIC_READ)... 100%'
#GENERIC_READ
 
STD_INPUT_HANDLE     = -10
STD_OUTPUT_HANDLE    = -11
STD_ERROR_HANDLE     = -12
 
#-- Tipos de dato C
print 'Cargando datos C... 100%'
Short                = c_short
uShort               = c_ushort
Long                 = c_long
 
#-- HWND (GetStdHandle)
print 'Cargando HWND_STD(IO)... 100%'
HWND_StdOut          = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
HWND_StdIn           = windll.kernel32.GetStdHandle(STD_INPUT_HANDLE)
 
 
#------------CONSTANTES (COLORES)--------------------------#
# Dados en formato hexadecimal                             #
#----------------------------------------------------------#
print 'Cargando colores... 100%'
FOREGROUND_BLACK     = 0x0000
FOREGROUND_BLUE      = 0x0001
FOREGROUND_GREEN     = 0x0002
FOREGROUND_CYAN      = 0x0003
FOREGROUND_RED       = 0x0004
FOREGROUND_MAGENTA   = 0x0005
FOREGROUND_YELLOW    = 0x0006
FOREGROUND_GREY      = 0x0007
FOREGROUND_INTENSITY = 0x0008 # Color de texto intensificado
BACKGROUND_BLACK     = 0x0000
BACKGROUND_BLUE      = 0x0010
BACKGROUND_GREEN     = 0x0020
BACKGROUND_CYAN      = 0x0030
BACKGROUND_RED       = 0x0040
BACKGROUND_MAGENTA   = 0x0050
BACKGROUND_YELLOW    = 0x0060
BACKGROUND_GREY      = 0x0070
BACKGROUND_INTENSITY = 0x0080 # Fondo de texto intensificado
 
#-------------------------------------------------------------#
 
#-------- Carácter de emisión de sonido
beep                 = chr(7)
 
 
 
 
#----- CONSTANTES (Gráficas) ----------------------------------#
 
print 'Constantes graficas... 100%'
#----- LÍNEAS (ASCII EXTENDIDO) -----#
 
# Usadas para la construccion de menúes
 
# formato de constante:
# Las constantes de las líneas se componen de un prefijo "l", seguido de una S o una D
# para indicar si es simple(S) o doble(D). Finalmente, un juego de 3 letras indica cuál caracter es:
 
#-- ES(I/D) = Esquina Superior (Izquierda o Derecha)
#-- EI(I/D) = Esquina Inferior (Izquierda o Derecha)
#-- HOR     = HORizontal
#-- VER     = VERtical
#-- CRZ     = CRuZ
#-- T(DI/ID)= "T" (Derecha>Izquierda / Derecha<Izquierda) (Línea "T" que apunta hacia un lado)
#-- LT(B/A) = Línea T (Baja / Alta) (De abajo hacia arriba / De arriba hacia abajo)
 
#----------LÍNEAS DOBLES---------------------------#
lDESI    = chr(201) #-- Esquina superior izquierda
lDESD    = chr(187) #-- Esquina superior derecha
lDEID    = chr(188) #-- Esquina inferior derecha
lDEII    = chr(200) #-- Esquina inferior izquierda
 
lDVER    = chr(186) #-- Línea doble vertical
lDHOR    = chr(205) #-- Linea doble horizontal
 
lDLTA    = chr(203) #-- Línea "T" (Arriba)
lDLTB    = chr(202) #-- Línea "T" (Abajo)
lDTID    = chr(185) #-- Línea "T" (Izquierda>Derecha)
lDTDI    = chr(204) #-- Línea "T" (Derecha>Izquierda)
 
lDCRZ    = chr(206) #-- Linea doble "cruz"
 
#----------LÍNEAS SIMPLES---------------------------#
lSEII    = chr(192) #-- Esquina inferior izquierda
lSESI    = chr(218) #-- Esquina superior izquierda
lSESD    = chr(191) #-- Esquina superior derecha
lSEID    = chr(217) #-- Esquina inferior derecha
 
lSVER    = chr(179) #-- Línea vertical
lSHOR    = chr(196) #-- Línea horizontal
 
lSTID    = chr(195) #-- Línea "T" (Izquierda>Derecha)
lSLTB    = chr(193) #-- Línea "T" (abajo)
lSLTA    = chr(194) #-- Línea "T" (arriba)
lSTDI    = chr(180) #-- Linea "T" (Derecha>Izquierda)
 
lSCRZ    = chr(197) #-- Línea "cruz"
 
 
#----------------GRÁFICOS---------------------------#
# Carácteres que son usados para rellenar espacios
# o gráficos, animaciones, etc
#----------------------------------------------------#
 
fill_1           = chr(176) #-- Menos saturado
fill_2           = chr(177)
fill_3           = chr(178)
fill_4           = chr(219) #-- Mas saturado
#--
fill_5           = chr(220)
fill_6           = chr(221)
fill_7           = chr(222)
fill_8           = chr(223)
blank            = ' '
P                = '.'
D1, D2           = '<', '>'
line             = chr(10)
 
print 'Secuencias (animaciones)... 100%'
#---------SECUENCIAS--------------------------------#
# Las animaciones son secuencias de carácteres
# que mostrados (respetando dicha secuencia)
# generan "imágenes" en movimiento.
# Se almacenan en listas, para ser impresas
# siguiendo el orden en ellas.
#----------------------------------------------------#
 
ANIM01           = [P, P*2, P*3]                    #Secuencia de 3 puntos suspensivos
ANIM02           = [D1, D1*2, D1*3]                 #Secuencia con los direccionales (<)
ANIM03           = [D2, D2*2, D2*3]                 #Secuencia con los direccionales (>)
ANIM04           = [fill_1, fill_2, fill_3, fill_4] #Secuencia con carácteres de relleno
ANIM05           = ['\\', lSVER*2, '/', lSHOR*2]    #Secuencia de barra giratoria
ANIM06           = [blank, D1]                      #Prompt titilante
 
 
 
print 'Cargando controles... 100%'
#----------CONSTANTES DE CONTROLES------------------#
# Hay disponibles los siguientes "controles":
# Cajas de aviso
# Cajas de ingreso de datos
# Relojes (Numeración romana, occidenta (Analógica / Digital)
# Barras separadoras
#---------------------------------------------------#
# Próximamente (Barras de progreso, animaciones ASCII)
# Y mas...!
 
 
#--CAJAS DE TEXTO (Marco doble) (Argumentos)
 
DBox  = 'DBox'
DDBox = 'DDBox'
DIBox = 'DIBox'
D1Box = 'D1Box'
D2Box = 'D2Box'
 
 
#--CAJAS DE TEXTO (Marco simple) (Argumentos)
 
SBox  = 'SBox'
SDBox = 'SDBox'
SIBox = 'SIBox'
S1Box = 'S1Box'
S2Box = 'S2Box'
 
#Lista de cajas
 
Boxes = [DBox, DDBox, DIBox, D1Box, D2Box, SBox, SDBox, SIBox, S1Box, S2Box]
 
#------------- Relojes ----------------------#
CLOCK_OCC   = 'CLOCK_OCC'
CLOCK_ROM   = 'CLOCK_ROM'
 
DIGITAL   = 'DIGITAL'
ANALOGIC = 'ANALOGIC'
 
FORM12    = 'FORM12'    #Formato de 12horas
FORM24    = 'FORM24'    #Formato de 24horas
 
sContext = 'sRecuadro' #Sin recuadro
Context1 = 'Recuadro1' #Recuadro rectangular o cuadrado
Context2 = 'Recuadro2' #Recuadro circular o redondeado
 
NUM_OCC12 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
NUM_OCC24 = NUM_OCC12
iN = 13
while (iN <= 24):
    NUM_OCC24.append(iN)
    iN += 1
 
 
NUM_ROM  = {1:'I',
            2:'II',
            3:'III',
            4:'IV',
            5:'V',
            6:'VI',
            7:'VII',
            8:'VIII',
            9:'IX',
            10:'X',
            11:'XI',
            12:'XII'
            }
 
 
 
#---------------------------------------------#
 
 
 
 
 
 
print 'Cargando estructuras C... 100%'
#-------------------------------------------------------------------------------------#
 
#--ESTRUCTURAS C------------------------------#
# Las estructuras C son utilizadas
# junto con ctypes para poder invocar funciones
# del sistema operativo, que necesiten apuntar
# a estructuras de datos
#-----------------------------------
# Visitar MSDN y documentación de Python para mas información.
 
#----------------------Console (ScreenBufferInfo)
 
class COORD(Structure):           #-- Estructura para coordenadas.
        _fields_ =[
                ('X', Short),
                ('Y', Short)
                  ]
 
class SMALL_RECT(Structure):       #-- Estructura para posiciones.
        _fields_ =[
                ('Left', Short),
                ('Top', Short),
                ('Right', Short),
                ('Bottom',Short)
                  ]
 
class CONSOLE_SCREEN_BUFFER_INFO(Structure):
        _fields_ =[
                ('dwSize', COORD),
                ('dwCursorPosition', COORD),
                ('wAttributes', uShort),
                ('srWindow', SMALL_RECT),
                ('dwMaximumWindowSize', COORD)
                  ]
 
 
print 'Cargando funciones... (Misc)'
#--- Reversión de una cadena
#--- (Argumento = Cadena)
def strReverse(String):
        reversedString = ''
        reverseIndex  = -1
        abs_maxCount  = abs(len(String))
        while (abs(reverseIndex) <= abs_maxCount):
            reversedString = reversedString + String[reverseIndex]
            reverseIndex -= 1
        return reversedString
 
#--- Obtención de cadena de mayor y menor longitud, o número mas grande y mas chico
#--- Devuelve una tupla, siendo elemento 0 el mayor y 1 el menor.
#--- Los arugmentos son: 'str', 'num', para indicar si se trabaja con una cadena o números.
#--- Traspasar cualquier cantidad de cadenas/números
def GetValues(valueType, *Values):
        valTypes = ('str', 'num');
        if not (valueType in valTypes): return ERROR01+valueType;   
        if (valueType==valTypes[0]):
                maxStr, minStr = '', '';
                lenValues      = len(Values);
                Count          = 0;
                maxCount       = (lenValues - 1);
                while (Count < maxCount):
                        if (len(Values[Count]) > len(Values[Count+1])):
                                maxStr=Values[Count];
                                minStr=Values[Count+1];
                        elif (len(Values[Count]) < len(Values[Count+1])):
                                maxStr=Values[Count+1];
                                minStr=Values[Count];
                        Count += 1;
                return maxStr, minStr;
        elif (valueType==valTypes[1]):
                tmpMenor = 0
                tmpMayor = 0
                longitudValores    =len(Valores)
                Contador           = 0
                maxContador        = (longitudValores-1)
                while (Contador < maxContador):
                        if (Valores[Contador] >= Valores[Contador+1]):
                                tmpMayor = Valores[Contador]
                                tmpMenor = Valores[Contador+1]     
                        elif (Valores[Contador] <= Valores[Contador+1]):
                                tmpMayor = Valores[Contador+1]
                                tmpMenor = Valores[Contador]
                        Contador += 1
                return tmpMayor, tmpMenor
 
 
print 'Cargando funciones (WINAPI32)...100%'
#------------------------------FUNCIONES---------------------------------#
 
#--- Manejo de consola (Color e información)
#--- No necesita argumentos, devuelve el color de consola.
def GetConsoleColor():
        GConsoleScreenBufferInfo = CONSOLE_SCREEN_BUFFER_INFO()
        windll.kernel32.GetConsoleScreenBufferInfo(HWND_StdOut, byref(GConsoleScreenBufferInfo))
        return hex(GConsoleScreenBufferInfo.wAttributes)
#--- Argumento = Color
def SetConsoleColor(Color):
        bool = windll.kernel32.SetConsoleTextAttribute(HWND_StdOut, Color)
        return bool
 
 
 
 
 
 
#-------------------------------------------------------------------------#
 
 
print 'Cargando funciones de cálculo lineal... 100%'
class Lineal:
# Cálculo líneal
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
# Obtención de discriminante
    def Discriminante(self):
        Discriminante = self.b*self.b -4*self.a*self.c
        return Discriminante
# Obtención de raices (Soporte para raices en campo complejo)   
    def raices(self):
        Discriminante = self.b*self.b -4*self.a*self.c
        if (Discriminante < 0):
                real = -self.b/(2*self.a) 
                imag = math.sqrt (-Discriminante)/(2*self.a)
                return 'Im', 'X1', real, imag, 'X2', real, imag
        elif (Discriminante > 0):
                X1 = (-self.b + math.sqrt (Discriminante))/(2*self.a) 
                X2 = (-self.b - math.sqrt (Discriminante))/(2*self.a)
                return '2', X1, X2
        elif (Discriminante == 0):
                X = -self.b/(2*self.a)
                return '1', X
 
 
#-----------Draws--------------------------------------------------------#
def pchar(char): sys.stdout.write(char);
 
def iprint(Color, jline, *iText):
        def tpchar(Text):
            for item in Text: pchar(str(item));
        if (Color != n):
            prevColor = hex(GetConsoleColor());
            SetConsoleColor(Color);
        Count     = 0;
        fText     = [];
        for item in iText:fText.append(str(item));
        for item in fText:tpchar(str(item)); 
        if (Color != n):
            SetConsoleColor(prevColor);
        if (jline == endl):
            print line
 
class Draw:
        def __init__(self, *Args):
            self.Args = Args   #-- En construcción 
 
#----------CONTROLES------------------------------------------------------#
 
 
print 'Cargando controles... 100%'
 
 
 
 
class Control:
        def __init__(self, *Options):
                if not (Options):
                    pass;
 
                lnOptions = len(Options)
                #-- En construcción
 
 
 
 
 
        def Box(self, Color, Sound, Stop, Text, box):
                if not (box in Boxes):
                        x = Control()
                        Control.sbox(x, 0xC, 0, 1, 'Error <box inválido>', DBox)
                lenLDH  = lDHOR*len(Text)
                txtLn   = lDVER+Text+lDVER
                prevColor = GetColor()
                SetConsoleColor(Color)
                #-- Verificación argumento caja --#
                if (box == DBox):
                        print lDESI+lenLDH+lDESD+line+txtLn+line+lDEII+lenLDH+lDEID
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == DDBox):
                        print lDESI+lenLDH+lDLTA+line+txtLn+line+lDEII+lenLDH+lDLTB
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == DIBox):
                        print lDLTA+lenLDH+lDESD+line+txtLn+line+lDLTB+lenLDH+lDEID
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == D1Box):
                        print lDHOR+lenLDH+lDHOR+line+Texto+line+lDHOR+lenLDH+lDHOR
                        SetConsoleColor(prevColor)
                        if (Sound == 1): sys.stdout.write(chr(7))
                        if (Stop == 1): raw_input()
                elif (box == D2Box):
                        print lDVER+(blank*len(Texto))+lDVER+line+lDVER+Texto+lDVER+line+lDVER+(blank*len(Texto))+lDVER;
                        SetConsoleColor(prevColor);
                        if (Sound == 1): sys.stdout.write(chr(7));
                        if (Stop == 1): raw_input();
 

 Qué tal gente? Espero me puedan ayudar, lo agradecería de corazón.

 ¿Existe alguna función de Windows que me permita obtener los atributos de consola, como el color de texto y fondo? Se de "SetConsoleTextAttributes", y otras para obtener atributos de fuente, pero no da el color.
 
 Desde ya, agradecería mucho cualquiera ayuda

Un abrazo.

 Gente, programando en Python estoy usando las APIs para hacer un par de cosilias, y me veo con la necesidad de guardar los atributos del texto de la consola (Color y fondo). Usé SetConsoleTextAttribute para cambiar el color, pero yo desearía saber si hay alguna función que me devuelva esos atributos, para poder restaurarlos luego. La razón por la cuál no lo pongo en scripting es que esto es mas general, porque necesito saber una función que se ocupe de esto. Pensé que habría algo como GetConsoleTextAttribute, pero no No hay Si alguien me pudiera aunque sea decir el nombre, yo lo demás lo puedo buscar u.u Un abrazo gente, y gracias de antemano u.u

No es de Python la duda. Sólo busco la función (Lo cuál sería válido hasta para C, ASM etc)