mount -o loop,offset=307200 imagen.nrg /punto/de/montaje
sudo mkdir /mnt/raiz sudo mount /dev/sda4oloquesea /mnt/raiz sudo chroot /mnt/raiz sudo grub-install /dev/sda4
sudo grub-install /dev/sda4
"si var no es None y no es el valor por defecto para este tipo de variable".Por tanto estas cosas son True:
lista2 = copy.deepcopy(lista1)En los casos en que nos hay colecciones anidadas, puede bastar una copia superficial (shallow), que puede hacer de estas formas con los diccionarios:
dicc2 = dict(dicc1) dicc2 = dicc1.copy() dicc2 = copy.copy(dicc1)y de estas formas con las listas:
lista2 = list(lista1) lista2 = copy.copy(lista1)
dicc = {} # ésta no borra el diccionario "original"
dicc.clear() # ésta sí
En cuanto a las variables globales, se puede acceder directamente
a ellas, para lectura, desde dentro de una función, siempre que no
exista una variable local con su mismo nombre. Pero si intentamos
modificar su valor, en realidad creará al vuelo una variable local
con su mismo nombre. Para poder modificar una variable global debemos
declarla así, dentro de la función:Nota: si la variable global es mutable (p.e. un diccionario) y no la declaramos con 'global' dentro de una función, no podremos hacer que apunte a otro objeto, pero sí podremos alteraTruer su contenido. Por tanto, nuevamente, dicc={} no borraría el diccionario original, pero dicc.clear(), sí, y dicc['campo1']=3 alteraría el contenido de la variable global.global mi_variable_global
l = []Para vaciar una existente no existe un método como el 'clear' de los diccionarios, sino que hay que hacer:
l[:] = [] # equivalente: del l[:]No es muy fácil de recordar, pero como se intuye, mediante slicing podemos vaciar solo una parte de la lista:
l[2:3] = [] # equivalente: del l[2:3]
for k in sorted(d):
print d[k]
#!/usr/bin/env python # coding: utf-8 mi_variable = "Hola mundo" print type(mi_variable)
a = b = 2 print a print b print a == b
'una' "dos" 'tres\ncuatro' # Cadenas de texto u'eñe' # Unicode r'\n' # Raw (no se hace sustitución de caracteres) '''Primera Segunda''' # Cadena en varias líneas
'.'*10 # Repetición de cadenas c = 'hola mundo' c[0] # h c[-2] # d c[5:7] # mu c[2::3] # lmd c[:3] # 3 primeros caracteres c[-3:] # 3 últimos caracteres
True, False, and, or, not, ==, !=, <, >, <=, >=.
l = [22, True, 'hola', [11, 33]] l[3][0] # 11 len(l) # 4 l[-1] = 'adiós' # sustituye [11, 33] por 'adiós' l[0:2] = ['Uno por dos'] # l vale ['Uno por dos', 'hola', 'adiós'] l = [] # lista vacía
l = (1,) # la coma final diferencia la tupla de un entero entre paréntesis type(l) #l = (1) # no es una tupla type(l) # l = () # tupla vacía
>>> canasta = ['manzana', 'naranja', 'manzana', 'pera', 'naranja', 'banana']
>>> fruta = set(canasta) # crea un conjunto sin repetidos
>>> fruta
set(['pera', 'manzana', 'banana', 'naranja'])
>>> 'naranja' in fruta # verificación de pertenencia rápida
True
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # letras únicas en a
set(['a', 'r', 'b', 'c', 'd'])
>>> a – b # letras en a pero no en b
set(['r', 'b', 'd'])
>>> a | b # letras en a o en b
set(['a', 'c', 'b', 'd', 'm', 'l', 'r', 'z'])
>>> a & b # letras en a y en b
set(['a', 'c'])
>>> a ^ b # letras en a o b pero no en ambos
set(['b', 'd', 'm', 'l', 'r', 'z'])
d = {'Clave 1': 'Valor 1',
'Clave 2': 'Valor 2',
'Clave 3': 'Valor 3'}
d['Clave 2'] = 'Nuevo Valor 2'
d['Clave 4'] = 'Valor de la nueva clave'
'Clave 3' in d # True
len(d) # 3
if numero < 0: print “Negativo” elif numero > 0: print “Positivo” print '...aunque si numero es una cadena también entra aquí...' else: print “Cero”
var = “par” if (num % 2 == 0) else “impar” # A if C else B
if numero < 0: print “Negativo” else: print “Positivo o Cero”
i = 0
while i < 5:
entrada = raw_input("> ")
if entrada == "fin":
break # sale del bucle 'while' o 'for' más interior
elif entrada == "paso":
continue # fuerza la siguiente iteración sin esperar a que finalice ésta
else:
print entrada
i += 1
else:
print 'salimos del bucle porque van 5 entradas; si saliésemos con "break" no se ejecutaría esto'
lista = ['uno', 'dos', 'tres'] for elemento in lista: print elemento
for i in range(0, 5, 2): print i # 0 2 4 if (i % 2) > 0: break # acabamos en cuanto encontremos el primer impar else: print 'todos los números eran pares'
def mi_funcion2(param1, param2 = 'por defecto', *otros): print param1 print param2 for val in otros: print val def mi_funcion3(): pass # definimos la función vacía (p.e. Para rellenarla más tarde) mi_funcion2(1) mi_funcion2(1, 2, 3, 'cuatro', 5)
def varios(param1, param2, **otros): for i in otros.items(): print i varios(1, 2, tercero = 3, cuarto = 'cuatro')
def f(x, y): return x * 2, y * 2 a, b = f(2, 3)
class Coche: “””Abstraccion de los objetos coche.””” def __init__(self, gasolina): self.gasolina = gasolina print “Tenemos”, self.gasolina, “litros” def conducir(self): if self.gasolina > 0: self.gasolina -= 1 print “Quedan”, self.gasolina, “litros” else: print “No se mueve”
mi_coche = Coche(3) mi_coche.conducir()
class Estructura: pass # la definimos vacía mio = Estructura() mio.atributo1 = 'S.O. GNU' mio.atributo2 = 'FLOSS'
class Terrestre: def desplazar(self): print 'El animal anda' def respirar(self): print 'Respira fuera del agua' class Acuatico: def desplazar(self): print 'El animal nada' def respirar(self): print 'Respira bajo el agua' class Cocodrilo(Terrestre, Acuatico): #heredamos de ambas pero prevalece 'Terrestre' def desplazar(self): #sobreescrimos los métodos heredados print "Repta" c = Cocodrilo() c.desplazar() Acuatico.desplazar(c) #usamos el método de una de la superclases de las que hereda c.respirar()
class Ejemplo: def publico(self): print 'Publico' def __privado(self): print 'Privado' ej = Ejemplo() ej.publico() ej.__privado() # da error ej._Ejemplo__privado() # truco para acceder al método "oculto"
class Fecha(): def __init__(self): self.__dia = 1 def getDia(self): return self.__dia def setDia(self, dia): if dia >= 1 and dia <= 31: self.__dia = dia else: print 'No es un día' mi_fecha = Fecha() print mi_fecha.getDia() mi_fecha.setDia(3) mi_fecha.setDia(33) print mi_fecha.getDia()
class Fecha2(object): # object es un objeto vacío de nuevo-estilo necesario para 'property' def __init__(self): self.__dia = 1 def getDia(self): return self.__dia def setDia(self, dia): if dia >= 1 and dia <= 31: self.__dia = dia else: print 'No es un día' dia = property(getDia, setDia) mi_fecha2 = Fecha2() print mi_fecha2.dia mi_fecha2.dia = 3 mi_fecha2.dia = 33 print mi_fecha2.dia
__init__(self, args) __new__(cls, args) __del__(self) __str__(self) __cmp__(self, otro) __len__(self)
Diccionario.get(k[, d]) Diccionario.has_key(k) Diccionario.items() Diccionario.keys() Diccionario.pop(k[, d]) Diccionario.values() Cadena.count(sub[, start[, end]]) Cadena.find(sub[, start[, end]]) Cadena.join(sequence) Cadena.partition(sep) Cadena.replace(old, new[, count]) Cadena.split([sep [,maxsplit]]) Cadena.lower() Cadena.upper() Cadena.swapcase() Cadena.title() Cadena.strip() Lista.append(object) Lista.count(value) Lista.extend(iterable) Lista.index(value[, start[, stop]]) Lista.insert(index, object) Lista.pop([index]) Lista.remove(value) Lista.reverse() Lista.sort(cmp=None, key=None, reverse=False)
def funcion(): print 'Hola' f = funcion f()
def cuadrado(n): return n ** 2 l = [1, 2, 3] print map(cuadrado, l)
def es_par(n): return (n % 2.0 == 0) l = [1, 2, 3] print filter(es_par, l)
l = [1, 2, 3] print filter(lambda n: n % 2.0 == 0, l)
def sumar(x, y): return x + y l = [1, 2, 3] print reduce(sumar, l)
l = [0, 1, 2, 3] l2 = [n ** 2 for n in l] l2 = [n for n in l if n % 2.0 == 0] m = ['a', 'b'] n = [s * v for s in m for v in l if v > 0]
def mi_decorador(funcion): def nueva(*args): print 'Llamada a la funcion', funcion.__name__ retorno = funcion(*args) return retorno return nueva
@mi_decorador
def imprime(texto):
print texto
imprime('Hola')
def imprime(texto):
print texto
mi_decorador(imprime)('Hola')
a = 1 b = 0 try: r = a / b except (NameError, ValueError): print 'La variable no existe o el valor no es un número' except: print 'otro tipo de error' else: print 'sin errores' finally: print 'Se ejecuta siempre al final de todo'
class MiError(Exception): def __init__(self, valor): self.valor = valor def __str__(self): return 'Error ' + str(self.valor) resultado = 22 try: if resultado > 20: raise MiError(33) except MiError, e: print e
BaseException, Exception, GeneratorExit, StandardError, ArithmeticError, FloatingPointError, OverflowError, ZeroDivisionError, AssertionError, AttributeError, EOFError, EnvironmentError, IOError, OSError, WindowsError, ImportError, LookupError, IndexError, KeyError, MemoryError, NameError, UnboundLocalError, ReferenceError, RuntimeError, NotImplementedError, SyntaxError, IndentationError, TabError, SystemError, TypeError, ValueError, UnicodeError, UnicodeDecodeError, UnicodeEncodeError, UnicodeTranslateError, StopIteration, Warning, DeprecationWarning, FutureWarning, ImportWarning, PendingDeprecationWarning, RuntimeWarning, SyntaxWarning, UnicodeWarning, UserWarning, KeyboardInterrupt, SystemExit.
import time print time.asctime()
from time import asctime print asctime()
if __name__ == “__main__”: print “Se muestra si no es importacion sino que lo ejecutamos directamente”
import paq.subpaq.modulo paq.subpaq.modulo.func()
try: edad = raw_input(“Cuantos anyos tienes? “) dias = int(edad) * 365 #print 'Has vivido ' + dias + ' dias' # incorrecto print 'Has vivido ' + str(dias) + ' dias' # correcto print 'Has vivido', dias, 'dias' # correcto print 'Línea 1.', print 'Sigo en la línea 1.\tTabulado.' except ValueError: print “Eso no es un numero” print 'adecuado para humanos:', str(0.1), ' ,, para intérprete:', repr(0.1)
import sys for i in range(0, len(sys.argv)): print sys.argv[i],
from math import pi
# vieja manera
print '%8s %-18.16s %x %.4f' % ('Hola', 'Hexadecimal y Piiiii', 255, pi)
# nuevas maneras
print '{0} {1:18.16s} {2:x} {3:.4f}'.format('Hola'.rjust(8), 'Hexadecimal y Piiiii', 255, pi)
print '{0} {1:18.16s} {3:x} {2:.4f}'.format('Hola'.rjust(8), 'Hexadecimal y Piiiii', pi, 255)
print '{0} {1:18.16s} {hexa:x} {2:.4f}'.format('Hola'.rjust(8), 'Hexadecimal y Piiiii', pi, hexa=255)
f = open('archivo.txt', 'w')
f.writelines('línea 1\n')
f.close()
f = open('archivo.txt', 'a')
f.write('lín')
f.writelines('ea 2\n')
f.close()
f = open('archivo.txt', 'r')
print f.read(5) # bytes (no caracteres)
print f.tell()
f.seek(-1, 2) # desde el final
print f.tell()
f.seek(4, 0) # desde el principio (por defecto)
print f.tell()
f.seek(-1, 1) # desde la posición actual
print f.tell()
l = f.readlines()
for e in l: print e,
f.close()
tempfile.TemporaryFile()
import re
if re.match('(c|p|j)yth..', 'python'): print 'coincide'
if re.match('\.config', '.config'): print 'coincide'
if re.match('\.config|\.setup', '.config'): print 'coincide'
if re.match('[pjc]yt[a-zA-Z]on[^a-zA-Z][.,]', 'python2.'): print 'coincide'
if re.match('^http', 'http://mundogeek.net'): print 'coincide'
'\d': Equivale a [0-9] '\D': Equivale a [^0-9] '\w': Equivale a [a-zA-Z0-9_] '\W': Equivale a [^a-zA-Z0-9_] '\s': Equivale a [ \t\n\r\f\v] '\S': Equivale a [^ \t\n\r\f\v]
Lo que tenemos a la izquierda...
'+': puede aparecer una o mas veces.
'*': puede aparecer cero o mas veces.
'?': puede aparecer cero o una vez.
'{3,8}': tiene que aparecer de 3 a 8 veces.
import socket socket_s = socket.socket() socket_s.bind((“localhost”, 9999)) socket_s.listen(10) # máximo 10 conexiones socket_c, (host_c, puerto_c) = socket_s.accept() recibido = socket_c.recv(1024) # recogemos 1024 bytes como máximo print “Recibido: “, recibido socket_c.send(recibido) socket_c.close() socket_s.close()
import socket s = socket.socket() s.connect((“localhost”, 9999)) s.send(mensaje) s.close()
import urllib, urllib2
try:
f = urllib2.urlopen('http://www.python.org')
#Modificamos UserAgent
o_request = urllib2.Request('http://www.python.org', headers={'User-Agent': 'Cliente Http Python'})
f = urllib2.urlopen(o_request)
params = urllib.urlencode({'usuario': 'manuel', 'password': 'contraseña'})
#Parámetros por POST
f = urllib2.urlopen('http://ejemplo.com/login', params)
#Parámetros por GET
f = urllib2.urlopen('http://ejemplo.com/login' + '?' + params)
print f.read()
f.close()
except:
print 'Ocurrió un error' # si no queremos hacer nada pondríamos 'pass'
import threading, time, random class MiThread(threading.Thread): def __init__(self, num, nombre): threading.Thread.__init__(self) self.num = num # atributo creado por nosotros self.name = nombre # atributo existente en la clase (por defecto 'Thread-1'...) def run(self): print 'Soy el hilo nº', self.num, self.name time.sleep(random.random() * 0.3) # esperamos entre >= 0 y < 0.3 print 'Soy el hilo principal' for i in range(0, 10): t = MiThread(i, 'mi_hilo' + str(i)) t.start() t.join() # espera x seg. a que finalice la ejecución del hilo
lista = [] lock = threading.Lock() def anhadir(obj): lock.acquire() # se queda bloqueado aquí hasta que el candado esté libre lista.append(obj) lock.release() def obtener(): # indicamos con False que no queremos esperar # si devuelve True es que nos lo han dado (estaba libre) if lock.acquire(False) == True: obj = lista.pop() lock.release() return obj
q = Queue.Queue() class MiThread(threading.Thread): def __init__(self, q): self.q = q threading.Thread.__init__(self)
def run(self):
while True:
try:
obj = q.get(False)
except Queue.Empty:
print “Fin”
break
print obj
for i in range(10):
q.put(i)
t = MiThread(q)
t.start()
t.join()
try:
import cPickle as pickle
except ImportError:
import pickle
fichero = file('datos.dat', 'w')
animales = ['pitón', 'mono', 'camello']
pickle.dump(animales, fichero, 1) # 0=texto (por defecto) ,, 1=binario
fichero.close()
fichero = file('datos.dat')
animales2 = pickle.load(fichero)
print animales2
fichero.close()
sql = “select all from t where valor=?”
import sqlite3 as dbapi
conn = dbapi.connect("bbdd.dat") # opcional :memory:
cursor = conn.cursor()
cursor.execute("drop table empleados")
cursor.execute("""create table empleados (dni text, nombre text, departamento text)""")
cursor.execute("""insert into empleados
values ('12345678-A', 'Manuel Gil', 'Contabilidad')""")
conn.commit() #no es necesario si tenemos autocommit pero no está de más para dejar el código preparado para otro caso/BDD
cursor.execute("""select * from empleados where departamento='Contabilidad'""")
for tupla in cursor: # tb. cursor.fetchone(), cursor.fetchmany(n) o cursor.fetchall() ; (si no se indica n, se toma cursor.arraysize que vale 1 por defecto)
print tupla
for t in [('87654321-Z', 'Pepe Mel', 'Informatica'),
('dni2', 'Yo', 'sistemas')]:
cursor.execute('insert into empleados values (?,?,?)', t)
# ¿esto es equivalente?
c.executemany('insert into empleados values (?,?,?)',
[
('87654321-Z', 'Pepe Mel', 'Informatica'),
('dni2', 'Yo', 'sistemas')
] )
conn.rollback()
t = ('Informatica',)
cursor.execute("""select * from empleados
where departamento=?""", t) # evitamos inyección de código
print cursor.fetchone() # Dará None por el rollback
cursor.close()
conn.close()
def haz_algo(arg): '''Esta función es para...''' print arg # por poner algo print haz_algo.__doc__ help(haz_algo)
def cuadrados(lista): '''Calcula el cuadrado de los numeros de una lista >>> l = [3, 2, 1, 0] >>> cuadrados(l) [9, 4, 1, 0] >>> tirar = l.pop(3) # tenemos que asignar el valor a algo para que la prueba no finalice aquí >>> l.append(4) >>> cuadrados(l) == [9, 4, 1, 16] True ''' return [n ** 2 for n in lista] if __name__ == '__main__': import doctest doctest.testmod() # se le puede indicar el módulo a evaluar (por defecto, el actual)
def cuadrado(num): '''Calcula el cuadrado de un numero. >>> l = [0, 1, 2, 3] >>> for n in l: ... cuadrado(n) 0 1 4 9 ''' return num ** 2
import doctest, modulo1, modulo2 doctest.testmod(modulo1) doctest.testmod(modulo2)
import unittest def cuadrado(num): '''Calcula el cuadrado de un numero.''' return num ** 2 class EjemploPruebas(unittest.TestCase): def test(self): l = [0, 1, 2, 3] r = [cuadrado(n) for n in l] self.assertEqual(r, [0, 1, 4, 9]) if __name__ == '__main__': unittest.main()
import module module.name1...
# ugh! return dir+"/"+file # better return os.path.join(dir, file)More useful functions in os.path: basename(), dirname() and splitext().
value = foo.bar()[’first’][0]*baz.quux(1, 2)[5:9] \ + calculate_number(10, 20)*forbulate(500, 360) bien: value = (foo.bar()[’first’][0]*baz.quux(1, 2)[5:9] + calculate_number(10, 20)*forbulate(500, 360))
from lxml import etreeConstruyendo un XML:
raiz = etree.Element("root")
print raiz.tag # etiqueta XML
raiz.append(etree.Element("child1"))
hijo2 = etree.SubElement(raiz, "child2") # más eficiente que lo anterior
hijo2.set("id", "002")
print hijo2.get("id")
etree.SubElement(raiz, "child3", id="003", tipo="hijo") # podemos ignorar el valor devuelto e indicar atributos
print(etree.tostring(raiz, pretty_print=True)) # serializamos el XML
atributos = raiz[1].attrib # diccionario con los atributos
print atributos
Los elementos funcionan casi como listas Python:print len(raiz) # nº de nodos hijos
raiz.append(etree.Element("child3")) # añade un nodo al final (aunque es más eficiente 'etree.SubElement()')
raiz.insert(0, etree.Element("child0")) # creamos un nuevo nodo en la primera posición
# los nodos no se pueden copiar, solo mover (a no ser que utilicemos deepcopy: from copy import deepcopy)
raiz.insert(1, raiz[2]) # esto mueve 'child2' antes que 'child1'
raiz[0] = raiz[-1] # esto mueve 'child3' a la primera posición "sobresscribendo" 'child0'
print [etree.tostring(n) for n in raiz]
Moverse por el árbol:raiz[0].getparent() # raiz raiz[1].getprevious() # raiz[0] raiz[0].getnext() # raiz[1]Texto en nodos:
nieto1 = etree.SubElement(hijo1, "grandchild") # ahora agregamos un nodo después del texto nieto1.text = "texto" nieto1.tail = "nieto de hijo1" # añade el texto después del nodo (no dentro) hijo2 = raiz[1] nieto2 = etree.SubElement(hijo2, "grandchild", descripcion="hijo de hijo2") # ahora agregamos un nodo después del texto print etree.tostring(hijo1) print hijo1.text # solo entrega el texto hasta que aparezca otra etiqueta print etree.tostring(hijo1, method="text") # nos saltamos las etiquetasTree iteration:
print [nodo.tag for nodo in raiz.iter()] # todo el árbol
print [etree.tostring(nodo) for nodo in raiz[2].iter()] # solo la rama del tercer nodo
print [etree.tostring(nodo) for nodo in raiz.iter('grandchild')] # solo los nodos con esa etiqueta
Nodos especiales:raiz.append(etree.Entity("#234"))
raiz.append(etree.Comment("comentario"))
print [nodo.text for nodo in raiz.iter(tag=etree.Entity)]
print [nodo.text for nodo in raiz.iter(tag=etree.Comment)]
ElementPath (en algunos sentidos hace lo mismo que iterar filtrando
por tag):raiz.find('grandchild') # primer hijo directo con ese tag
raiz.find('.//grandchild') # primer descendiente con ese tag
raiz.find('grandchild[@descripcion]') # primer hijo directo con ese tag
raiz.findall('.//grandchild') # lista con todos los descendientes con ese tag
raiz.iterfind('.//grandchild') # iterador de todos los descendientes con ese tag
raiz.findtext('grandchild') # .text del primer hijo directo con ese tag
import StringIO s = ' ]>&tasty; ' arbol = etree.parse(StringIO.StringIO(s)) print 'arbol:\n' + etree.tostring(arbol, pretty_print=True) rama = etree.XML(s) print 'rama:\n' + etree.tostring(rama, pretty_print=True)
parser = etree.XMLParser(remove_blank_text=True) # this creates a parser that removes empty text between tags
root = etree.XML(" ", parser)
some_file_like = StringIO.StringIO("data1data2data3 ")
for event, element in etree.iterparse(some_file_like):
print("%5s, %4s, %s" % (event, element.tag, element.text))
some_file_like = StringIO.StringIO("data1data2data3 ")
for event, element in etree.iterparse(some_file_like, events=("start", "end")):
print("%5s, %4s, %s" % (event, element.tag, element.text))
# para parsear un XML grande tipo DUMP
some_file_like = StringIO.StringIO("data1data2data3 ")
for _, element in etree.iterparse(some_file_like, tag="a"):
print("%4s, %s" % (element.tag, element.text))
element.clear()
# código que muestra como se lee y escribe un ODS llamado 'ejemplo.ods'
import ooolib
libro = ooolib.Calc()
libro.load('ejemplo.ods')
# recorremos todas las hojas
for i in range(0, libro.get_sheet_count()):
libro.set_sheet_index(i) # nos situamos en la hoja
print libro.get_sheet_name()
# obtenemos la esquina inferior derecha del rectángulo que contiene a los datos
(num_cols, num_filas) = libro.get_sheet_dimensions()
# escribimos un decimal en la primera columna justo debajo de la última fila
libro.set_cell_value(1, num_filas + 1, 'float', 3.14159)
num_filas += 1 # actualizamos el nº de filas
libro.save('ejemplo.ods') # grabamos a disco los cambios
for y in range(1, num_filas + 1):
for x in range(1, num_cols + 1):
# tupla con el tipo de dato (string, float...) y su valor
dato = libro.get_cell_value(x, y)
if dato == None:
print '\tNone' # no hay nada en la celda
else:
print '\ttipo:', dato[0], ',,', 'valor:', dato[1]
Set)
lleno o vacío (len()=0 o not, pero no
None). Si cogemos uno solo de ellos
mediante un iterador (o añadiendo .first()
a select()) obtenemos un objeto Row
o None.rows.as_list() # list of dictionariesrows[0].as_dict() # row.as_dict()rows3 = rows1 & rows2 # unionrows3 = rows1 | rows2 # union removing
duplicatesfor row in rows.sort(lambda row:
row.name):El sábado 24 asistí a una conferencia de empresas de Software Libre. Tres empresas españolas explicaron cómo hacen dinero desarrollando software libre.
Todas ellas coincidieron en que la mayoría de sus proyectos tienen una parte de software privativo, bien por conveniencia a la hora de ciertas negociaciones, bien por facilitar convencer a los directivos o bien porque en ese momento es la pieza clave que les hace ser competitivos (en ese caso suele liberarse el código más adelante).
Los tres coincidieron en resaltar que lo importante es el modelo de negocio, entender quién eres como empresa y no el software libre en sí, que lo veían más como una herramienta útil, que como un modelo ético.
pcsc_scan' para verificar o funcionamento do lector)pcsc_scan':