Me pareció la forma mas enredada posible de explicar las tuplas.
El diccionario seen_letters[letter] lo usamos para encontrar usando la letra como llave a la tupla (indice, cantidad) donde colocaremos la cantidad de veces que esta repetido la letra, a medida que se va ejecutando el for voy actualizando cantidad de repeticiones y agregando nuevas letras.
P.D: tuve que ver el video 3 veces jeje, pero ya le cogi el tiro
La verdad si, concuerdo con que es un enredo tenaz y además todas las variables declaradas en ingles me parece algo sumamente fastidioso. :/
A medida que se le van agregando keys al diccionario (nos movemos cada vez más a la derecha de la palabra dada) este se llena con la cantidad de veces que se repite dicha letra.
Por ese motivo se puede entender que el diccionario esta estructurado de tal forma que la primera key del mismo corresponde a la primer letra de la palabra. Por eso no entiendo porque hace falta crear una lista (final_letters) y luego ordenarla. Creo que la mejor solucion sería esta:
(
en else:seen_letters[letter]=(seen_letters[letter][0], seen_letters[letter][1]+1)```
¿Eso es un diccionario que es igual a una tupla que contiene el indice del diccionario y la cantidad de veces que se repite ese diccionario?, osea un diccionario dentro de una tupla?
En el apartado del else lo que se hace es igualar el value de la key “letter” en el diccionario. EL value de dicha key es una tupla de size 2. En 0 guarda la el indice de la letra si anteriormente ya estaba en seen_letters y en el 1 va sumando la cantidad de veces que se repite dicha letra.
Yo lo resolví sin tuplas de la siguiente forma:
# -*- coding: utf-8-*-def first_not_repeating_char(char_sequence): status_chars ={}for letter inchar_sequence:if status_chars.get(letter)==None: status_chars[letter]=0 status_chars[letter]+=1for i,value inenumerate(char_sequence):if status_chars[value]==1:return value
return"_"if __name__ =="__main__": char_sequence =raw_input('Ingresa una secuencia de caracteres:') result =first_not_repeating_char(char_sequence)if result =="_": print "Todos los caracteres se repiten"else: print "El primer caracter no repetido es: {}".format(result)
De igual manera no usé tuplas pero me agrado mas tu solución. Dejo mi ejemplo:
Aquí hay una solución basada en la respuesta de mariovasqueza pero simplificando la función. Cuando en la iteración se encuentra el primer caracter que no se repite, la función retorna ese caracter y finaliza sin seguir iterando. Si no encuentra ninguno, simplemente retorna '_'.
Hay un proverbio chino que dice:
"Si el alumno no supera al maestro,
ni es bueno el alumno,
ni es bueno el maestro."
Gracias, una solución muy simple y clara.
Veo la clase y tiene sentido lo que hace el profesor, pero al mismo tiempo pienso que ni por casualidad se me hubiese ocurrido hacer algo asi ni podria haber llegado a ese resultado o a los que postean los estudiantes en esta seccion. Es mas, empece a ir para atras en las clases para ver si me habia perdido algunos capitulos o me habia equivocado de curso. Sera que comence hace muy poco a estudiar programacion? Estare viejo? Me da curiosidad saber si las personas que postean distintas soluciones ya estan trabajando en programacion o hace mucho que estudian.....bueno.....perdon que no tiene que ver con la clase, pero tenia la necesidad de compartirlo. Un saludo a todos!!
Me pasa lo mismo, es cuestion de tiempo...
De todas formas paciencia, estamos igual :)
o quizá, no te estas retando a dar soluciones antes de verlas.
no es tan bueno abusar de esta manera de pensar, a veces primero necesitamos las herramientas y después la creatividad fluye mejor.
otras veces se requiere que enfrentemos el reto para ir creando la identidad de programador, o la satisfacción de lograr pequeñas cosas.
De esta clase me quedo con que hay que ser muy resistente a la frustración
En casi todos los ejercicios pienso que esto no es lo mío pero espero que con el tiempo y la práctica ser capaz de sacar la lógica por mi mismo.
Para todos aquellos que quieran ver como su codigo funciona paso a paso sin necesidad de usar demasiados print statements les recomiendo usar visual studio code la herramienta debugging que ayuda muchísimo
hola yo utilizo el visual studio code para arduino pero que necesitaria para usarla con python como tu dices gracias (Y)
me enrrede mucho con ese enumerate(), asi que aca les dejo la documentacion que me soluciono la vida
Fue dificil entender, pero ayuda mucho imprimir los valores que se van obteniendo , para ver que se hace en cada proceso si a simple vista no se logra entender, aqui les dejo mi código con algunos comentarios en cada linea y algunos prints también, sé que en pantalla no se logra ver muy bien... pero pueden copiar y pegar el código en un editor para verlo mejor y entenderlo.
"""
"abacabad" c
"abacabaabacaba" _
"abcdefghijklmnopqrstuvwxyziflskecznslkjfabe" d
"bcccccccccccccyb" y
"""
def first_not_repeating_char(char_sequence): seen_letters ={} #crea un diccionario, para posteriormente guardar letras que son "vistas o repetidas"for idx, letter inenumerate(char_sequence): #crea una especie de "conteo" en idx respecto a cada letra(letter) dentro de char_sequence
if letter not inseen_letters: #verifica que el valor para cada letra en la secuencia inicial NO este en seen_letters(letras repetidas) seen_letters[letter]=(idx,1) #si es la primera vez que encuentra la letra, crea una tupla con valores de indice de la letra y cantidad de veces vista dentro del diccionario con key de la letra,ej:'a':(0,2)print("solo te vi una vez")print(seen_letters)else: seen_letters[letter]=(seen_letters[letter][0], seen_letters[letter][1]+1) #si no es la primera vez que la ve, entonces crea otra tupla donde agrega el valor del indice en el primer lugar y el valor de veces vista en la posicion 2, este valor va aumentando cada vez que ve una palabra repetida
final_letters =[] #esta es la lista donde se guardaran las letras que se repiten una sola vez
for key, value in seen_letters.iteritems(): #obtiene los valores de key y value dentro del diccionario para verificar el dato de numero de repeciones, este corresponde al value[1]if value[1]==1: #si solo se repite la letra una vez
final_letters.append((key, value[0])) #entonces lo agrega a la lista de final_letters
print("final_letters")print(final_letters) not_repeated_letters =sorted(final_letters, key=lambda value: value[1]) #este se usa para ordenar la lista de final_letters de manera ordenada, ya los datos vienen desordenados desde seen_letters
print("not_repeated_letters")print(not_repeated_letters)ifnot_repeated_letters: #si la lista de not_repeated_letters no esta vacia
print(not_repeated_letters[0])return not_repeated_letters[0][0] #entonces retorna la posicion 0 dentro de la lista , y la posicion 0 dentro de esa tupla ,ej:{('a',4),('b',6)}, en ese caso retorna a
else:return'_' #si la lista de not_repeated_letters esta vacia , es decir no hay caracteres repetidos, retorna '_'if __name__ =='__main__': #programa que retorna caracteres no repetidos, si se repiten arroja el mensaje de todos los caracteres se repiten
char_sequence =str(raw_input('Escribe una secuencia de caracteres: ')) #caracteres de entrada
result =first_not_repeating_char(char_sequence)if result =='_':print('Todos los caracteres se repiten.')else:print('El primer caracter no repetido es: {}'.format(result))```
Gracias, me ayudó bastante.
Excelente. Se agradece este tipo de comentarios. Ayudo a no quedarse perdido en esta clase.
Hay un error en el vídeo y es cuando habla sobre almacenar las letras que solo se vieron una vez, y es que cuando lo explica gráficamente no debe guardar la tupla ( 'a', 0) ya que cuando se acaba el ciclo las únicas tuplas que tienen valor de 1 son las de c y d, a propósito, cuando hace el primer ciclo también esta aplicando el método iteritems sino que el método enumerate ya genera una serie de tuplas donde el primer valor es el indice y el segundo es el valor que es en este caso la misma letra.
si alguien también es nuevo como yo, me parece útil decir que cuando se habla de método, se refiere al hecho de usar una función, solo que esa función no la escribe sino que ya esta ''escrita'' dentro del mismo lenguaje y se puede usar, como ejemplos se tienen los métodos (funciones) enumerate(),sorted(),iter.items()
Considero bueno el hecho que desde el curso se quiera dejar una formación avanzada por decirlo de alguna manera, pero deben tener en cuenta que muchas personas llegan sin saber nada de programación y posiblemente este sea su primer contacto con la programación, y ya se que existen otros cursos dentro de la misma plataforma, puede que personas solo hayan pagado un curso en especifico o vengan con convenios como el del MinTic y posiblemente la ruta que seleccionaron para estos terminen frustrando a la persona por ser un primer acercamiento no apropiado, y también se que mucho depende de la tolerancia a la frustración y dedicación pero de igual manera se están poniendo barreras cuando se puede iniciar desde un acercamiento mas simple porque la plataforma cuenta con el material, lo dejo como recomendación
Una de las cosas que procuro hacer durante el proceso de las clases es ver los comentarios que realizan algunas personas; comentarios como este nos brindan a aquellos que apenas nos empezamos a sumergir en este mundo a aclarar muchas dudas o ver otros caminos. Muchas gracias por tu aporte!
Excelente aporte.
Mi solucion antes de ver el video:
Jugué un poco con las tuplas y encontré que podia crear una tupla con una cadena de texto.
Luego encontré que podia utilizar la funcion tuple.count(x) que cuenta cuantas occurrencias hay de x en la tupla.
Data Structures python 3
def first_not_repeating_char(char_sequence): mi_tupla =tuple(char_sequence) first_char ='_'for char inmi_tupla:if mi_tupla.count(char)==1: first_char = char
return first_char
if __name__ =='__main__': char_sequence =str(input('Escribe una secuencia de caracteres: ')) result =first_not_repeating_char(char_sequence)if result =='_':print('Todos los caracteres se repiten.')else:print('El primer caracter que no se repite es: {}'.format(result))
Tu solución está WOW, aunque tiene una falla lógca, la detecté al probar la cadena “abcdefghijklmnopqrstuvwxyziflskecznslkjfabe”, me regresa ‘y’ y no ‘d’.
Es porque sigues evaluando dentro del for en vez de salir de él.
Me podrian explicar por que ? , no entiendo muy bien la razon
Para quienes les causó un poco de duda sobre cómo se usó el método sorted, intentaré aclarar un par de conceptos.
El primero es que nosotros al método sorted le podemos ingresar una lista desordenada sin ningún otro parámetro y el método la ordena. Ejm
sorted([4,6,7,1,2,9])>>[1,2,4,6,7,9]
En el caso de este vídeo, al método sorted le estamos enviando adicional otro parámetro porque la lista que estamos iterando tiene dos valores en cada índice (idx 0 = la llave del dict, idx 1 = el índice dónde encontramos la letra) es por esto que debemos especificarle al método sorted por cuál valor queremos que nos organice los elementos de la lista. Si usamos la posición 0, como son letras las ordena de forma decreciente de la a la z, pero como necesitamos es que lo ordene por índice, y así determinar cual de las letras que solo están una vez en la palabra encontramos primero debemos especificar ese parámetro (key=lambda value: value[1]) y así poder ordenar la lista por el índice.
Esta enredador este tema, creo tengo que ir mas con la teoría para entender este ejemplo.
Buenas tardes, a continuacion adjunto mi seccion de codigo, para los que no sepan del metodo count() (como yo hasta esta clase) les doy el siguiente link para que le den una ojeada, saludos!
Link:
def first_not_repeating_char(char_sequence):for letra inchar_sequence:if char_sequence.count(letra)==1:return letra
return"_"
Minuto 9:25 alguien me confirma por favor, si hay algún error al expresarse el tutor D. Aroesti, que la verdad esta clase esta maluca, segundo dia completo viendo esto y aun no lo comprendo muy bien.
Efectivamente Carlos!
Debería ser [('c',3),('d',7)]
Saludos!
hice esto antes de la explicación
cadenas =["aasdgbsdrwfcASaabd","pastafrola","12355534535268","224455"]def primerCaracterNoRepetido(cadena): cadena =str(cadena) caracteresExistentes ={}for i incadena:if i not in caracteresExistentes.keys(): caracteresExistentes[i]=1else: caracteresExistentes[i]+=1for i in caracteresExistentes.keys():if caracteresExistentes[i]==1:return i
return"_"if __name__ =="__main__":print(primerCaracterNoRepetido(cadenas[1]))
Mi ejemplo no es utilizando tuplas, pero es bastante corto y al parecer funciona :):
Buenas noches! No me quedO muy claro esta lInea de cOdigo:
Recuerda que en el diccionario, por clave (que es la letra), se está guardando una tupla que contiene el índice de la letra y el número de veces que se ha encontrado en la secuencia.
Por ejemplo, supongamos que así está nuestro diccionario:
seen_letters ={'a':(2,1)}
Donde estamos diciendo que la letra 'a' se encontró por primera vez en la posición 2 y que se "ha visto" 1 vez.
Cuando se encuentra una letra que ya está en el diccionario de "letras vistas", entonces al diccionario en esa letra (por así decirlo), se le asigna una nueva tupla que debe contener el índice donde se vio esa letra por primera vez, este índice se obtiene así:
seen_letters[letter][0]
Volviendo a nuestro diccionario si decimos:
seen_letters['a'][0]
Eso sería igual a 2
Además, se debe sumar el número de veces que se ha encontrado la letra, que es lo que se hace aquí:
seen_letters[letter][1]+1
Ahí sacamos el número de veces que ya llevábamos y le sumamos 1. En nuestro ejemplo el resultado de esto sería 2, ya que teníamos 1 en la posición 1 de la tupla.
En este caso, lo único que estaría cambiando es el el número de veces que se ha visto la letra pero como las tuplas son inmutables, se debe crear una nueva con esta información para que reemplace a la que ya existía.
Al hacer estos cambios, nuestro diccionario de ejemplo, ahora quedaría así:
seen_letters ={'a':(2,2)}
Muchas gracias, Fer, yo tenía exactamente la misma duda.
lambda parametros: resultado
es equivalente a
def nombre(parametros):
return resultado
