Me aburria he hice este pequeño code para detectar ciertos tipos de unidades y listarlas:
#############################################
# Author: k0ws #
# Usage: cUnidades() #
# Webs: Indetectables ~ UdTools ~ Underc0de #
#############################################
import win32file as file
import win32api as api
def cUnidades():
listdrives = api.GetLogicalDriveStrings().split("\x00")
i = 0
print "Lista de FlashDrives o HDD: "
for drive in listdrives:
if len(listdrives) == (i + 1):
break
if (file.GetDriveType(listdrives[i])) == 2:
try:
api.GetDiskFreeSpace(listdrives[i].replace('\\',''))
print listdrives[i] + " - Conectado"
except:
print listdrives[i] + " - Desconectado"
if (file.GetDriveType(listdrives[i])) == 3:
try:
api.GetDiskFreeSpace(listdrives[i].replace('\\',''))
print listdrives[i] + " - Conectado"
except:
print listdrives[i] + " - Desconectado"
i = i + 1
cUnidades()
Info sobre los tipos de unidades: http://msdn.microsoft.com/en-us/library/windows/desktop/aa364939(v=vs.85).aspx (http://msdn.microsoft.com/en-us/library/windows/desktop/aa364939(v=vs.85).aspx)
Se que se puede optimizar, pero paso ::)
-Saludos-
Muy buen codigo bro!
Muy bueno verte por los lados de python!
Muy bueno verte por python bro.
Para la próxima deberias contemplar usar librerias ntativas antes de hacer uso de las externas, habrá menos problemas con las dependencias y se reducirá el peso de la aplicación.
Ctypes es una buena solución, puedes importar las DLL's de windows y usar sus funciones, en este caso, GetLogicalDrives es de kernel32 y puedes usarla con ctypes:
"ctypes.windll.kernel32.GetLogicalDrives" -> http://www.nullege.com/codes/search/ctypes.windll.kernel32.GetLogicalDrives (http://www.nullege.com/codes/search/ctypes.windll.kernel32.GetLogicalDrives)
Saludos bro
Muchas gracias Sanko, lo hare para la proxima ;)
interesante! hace poco estaba pensando en como detectar cuando se conecta un pendrive....
HOLA!!!
No imports = Better Code
GRACIAS POR LEER!!!
Muy bueno el código brothe, aparte de lo que te acaba de decir Sanko, te hago una observación más.
Cuando usas el for, no tienes que usar un contador entero (como sí se hace en los while) porque el for ya lleva la cuenta. Y si lo que haces es recorrer una lista como en tu caso, no es necesario que hagas esto: listdrives ya que la variable drive que definiste para el for tiene esa misma información; por lo que puedes cambiar el listdrives por drive
en lugar de:
if (file.GetDriveType(listdrives[i])) == 2:
puedes poner:
if (file.GetDriveType(drive)) == 2:
Y te evitas el contador.
Saludos!
Basandome en tu code y en lo comentado por Sanko se me ocurre algo asi para detectar cuando algn conecta un pendrive
import ctypes
import time
print "is running.."
while(1):
drive_bitmask = ctypes.windll.kernel32.GetLogicalDrives()
for letter in range(65,91):
if drive_bitmask & 1:
unidad = chr(letter)+ u":\\"
if (ctypes.windll.kernel32.GetDriveTypeW(unidad)==2) :
print "se ha insertado",unidad
#hace algo
time.sleep(3600) #duerme un ratito
drive_bitmask >>= 1
Gracias 11Sep, eso del contador me ha pasado por que antes programa java y lo usaba mucho jajaja, ni me fije. Thx Bro.
@deni_celine: He mirado tu code por encima y no entiendo esta parte:
if drive_bitmask & 1:
-Saludos-
No tienes permitido ver los links.
Registrarse o Entrar a mi cuenta
Gracias 11Sep, eso del contador me ha pasado por que antes programa java y lo usaba mucho jajaja, ni me fije. Thx Bro.
@deni_celine: He mirado tu code por encima y no entiendo esta parte:
if drive_bitmask & 1:
-Saludos-
Tomatelo como
if drive_bitmask == 1: o lo que vendría siendo lo mismo que
if drive_bitmask:#True a nivel de bits es lo mismo, pero mejor validado. Tal vez este metiendo la pata vaya, que nos explique el sino
& es un AND a nivel de bits y va preguntando bit by bit si es verdadero , la siguiente instrucción es para moverse al siguiente bit
drive_bitmask >>= 1
y Si como dice Sanko se obtendría el mismo resultado con
if drive_bitmask:#True
pero mejor validado xd
Y se hace esto debido a que en el resultado de la función GetLogicalDrives el primer bit corresponde a la unidad A, el siguiente B, el tercero a C y asi sucesivamente.
http://msdn.microsoft.com/en-us/library/windows/desktop/aa364972%28v=vs.85%29.aspx
Bueno eso es lo que entendí yo .... que solo estoy aprendiendo xd
No tienes permitido ver los links.
Registrarse o Entrar a mi cuenta
& es un AND a nivel de bits y va preguntando bit by bit si es verdadero , la siguiente instrucción es para moverse al siguiente bit
drive_bitmask >>= 1
y Si como dice Sanko se obtendría el mismo resultado con
if drive_bitmask:#True
pero mejor validado xd
Y se hace esto debido a que en el resultado de la función GetLogicalDrives el primer bit corresponde a la unidad A, el siguiente B, el tercero a C y asi sucesivamente.
http://msdn.microsoft.com/en-us/library/windows/desktop/aa364972%28v=vs.85%29.aspx
Bueno eso es lo que entendí yo .... que solo estoy aprendiendo xd
si eso decia la doc que retornaba, me habian dejado con la duda ya xd
No tienes permitido ver los links.
Registrarse o Entrar a mi cuenta
& es un AND a nivel de bits y va preguntando bit by bit si es verdadero , la siguiente instrucción es para moverse al siguiente bit
drive_bitmask >>= 1
¿Moverse al siguiente bit? rara explicación para la operación de desplazamiento.
Lo que conseguimos con ese operador es desplazar los bits de la variable a izquierdas o a derechas dependiendo del sentido indicado. Python ya distingue si tiene que realizar desplazamiento lógico o aritmético distinguiendo si el valor es con signo o sin signo.
Para lo que se suelen utilizar es para realizar multiplicaciones eficientes a nivel del procesador ya que es menos costoso realizar un par de sumas y desplazamientos con un CSA y un Barrel shifter por ejemplo con coste log(n) + C que calcular una multiplicación usando el algoritmo de recodificación por parejas que suele dar buenos resultados con un coste de n/2.
Si te fijas al desplazar n veces un bit a izquierdas estamos multiplicando por 2^n mientras que al desplazar n bits a derechas dividimos por 2^n, esto lo aplican los compiladores en los casos en los que sea más eficiente separar una multiplicación de esta forma que utilizar el operador de multiplicación de la ALU.
Ej: 3 * 36 ( operamos con 7 bits ) -> 36 = 2^5 + 2^2 -> 3*36 = 3*2^5 + 3*2^2
0000011 * 0100100
Desplazamos los bits del 3 5 veces a izquierdas -> 1100000
Desplazamos los bits del 3 2 veces a izquierdas -> 0001100
Sumamos los resultados -> 1101100 = 108 = 3*36
Con pocos bits como este caso la ganancia es mínima, la multiplicación serían (con el algoritmo de recodificación por parejas, si no, serían 8 ciclos) 4 ciclos (3.5 redondeado al alza) + 1 de inicialización, en total 5 ciclos mientras que con el otro método hemos sacado el resultado con 3 ciclos.
Creo que me he ido del tema pero necesitaba explicarlo xD.
No tienes permitido ver los links.
Registrarse o Entrar a mi cuenta
Gracias 11Sep, eso del contador me ha pasado por que antes programa java y lo usaba mucho jajaja, ni me fije. Thx Bro.
@deni_celine: He mirado tu code por encima y no entiendo esta parte:
if drive_bitmask & 1:
-Saludos-
En java también existe esa forma de iterar:
public static <E> void testit(E[] vec){
for(E i : vec){
System.out.println(i.toString());
}
}
public static void main(String args[])
{
Integer nVect[] = new Integer[5];
for(int i=0;i<5;i++) nVect[i] = new Integer(i);
testit(nVect);
}
Un saludo :D
los resultados que obtiene la función son, en mi caso...
59322604 = 11100010010011000011101100
29661302 = 1110001001001100001110110
14830651 = 111000100100110000111011
7415325 = 1110001001001100001110
por eso digo que se va moviendo un bit, a la izquierda .... es una explicación un tanto rara, pero con el ejemplo se entiende.... como dije estoy aprendiendo y aún entiendo menos de la mitad de lo que dijiste xd , de todas formas es interesante
Todo correcto ;D