• WORD
  • FORMATO AUTOMATICO Y ESTILOS
  • INSERTAR CUADRO DE TEXTO Y ECUACION
  • REFERENCIASTABLA DE CONTENIDO Y BIBLIOGRAFIA
  • Ir a Prácticas
  • EXCEL
  • FORMULAS I y II
  • TABLAS Y GRAFICOS DINAMICOS
  • SUBTOTALES Y BASE DE DATOS
  • MACROS
  • Ir a Prácticas
  • AUTOCAD
  • 2D:DIBUJO Y ACOTAR
  • INSERTAR BLOQUES Y PLOT
  • 3D: MODELADO Y EDICION DE SOLIDOS
  • RENDER Y ANIMACIONES
  • Ir a Prácticas

viernes, 3 de octubre de 2025

MATCH, TUPLAS Y DICCIONARIOS

 MATCH, DICCIONARIOS, TUPLAS Y CONJUNTOS

MATCH: En Python, "match" se refiere principalmente a la sentencia match-case, introducida en Python 3.10, que funciona como una alternativa al condicional if/elif/else o al switch de otros lenguajes, permitiendo la coincidencia de patrones con un valor y ejecutando el código correspondiente al primer patrón que coincida. También puede referirse a la función re.match(), que busca una coincidencia solo al principio de una cadena usando expresiones regulares.

CODIGO:

##############################################################

    match color:

        case "rojo":

            print("El color es rojo.")

        case "verde":

            print("El color es verde.")

        case "azul":

            print("El color es azul.")

        case _: # Comodín para cualquier otro color

            print("No es un color primario.")

##############################################################

 

FECHAS:

CODIGO:

##############################################################

import datetime

tiempo=datetime.datetime.now()

print(tiempo)

print(tiempo.year)

print(tiempo.month)

print(tiempo.day)

print(tiempo.minute)

print(tiempo.hour)

print("{}:{}:{}".format(tiempo.day,tiempo.month,tiempo.year))

if tiempo.hour>=18:

    print("buenas noches")

elif tiempo.hour>=12:

    print("buenas tardesS")

else:

    print("buenos dias")

 

 

##############################################################

 

TUPLAS:

CODIGO:

##############################################################

import math

print(dir(math))

t=5

print(type(t))

#tuplas

 

t = 12345, 54321, 'hello!'

print(t[0])

print(t)

u = t, (1, 2, 3, 4, 5)

print(u)

v = ([1, 2, 3], [3, 2, 1])

print(v)

t=()

print(t)

t=3,

print(t)

t = (3,"Hi",9)

print(t)

x,y,z=t

print(x,y,z)

tup=(1,"hola",7.43,[3,1,5],3,'x',7)

print(tup)

print(tup[0])

print(tup[-2])

print(tup[2:])

print(3 in tup)

print(tup.index("hola"))

print(tup.count(3))

print(len(tup))

lista=list(tup)

print(lista)

##############################################################

 

DICCIONARIO:

CODIGO:

##############################################################

#diccionarios

x={'a':1,'b':2,'c':3}

#llaves

print(x.keys())

#valores

print(x.values())

#items

print(x.items())

#valor buscado

print(x.get('a'))

#agregar valores

x.update({'c':7,'e':9})

print(x)

#borrar

x.pop('b')

print(x)

#borrar borrar ultimo elemento

x.popitem()

print(x)

#setdefault, busca un valor en un diccionario y si no nos da un valor por defecto

x.setdefault('f',4)

print(x)

#borrar todo el diccionario

x.clear()

print(x)

#itear con una lista

y=dict.fromkeys(['w','e','t','i',],7)

print(y)

#copiar

z=y.copy()

print(z)

 

 

#agregar dos diccionarios

i={'a':4,'b':7}

j={'c':1,'e':5}

i.update(j)

print(i)

 

 

#zip: sirve para combinar varios objetos iterables

nombres = ["Ana", "Carlos", "María"]

puntuaciones = [95, 88, 76]

 

# Usar zip() para combinar las listas

puntuaciones_por_nombre = zip(nombres, puntuaciones)

 

# Convertir el objeto zip a una lista para ver el resultado

lista_final = list(puntuaciones_por_nombre)

 

print(lista_final)

##############################################################

 

CONJUNTOS:

CODIGO:

##############################################################

a={"z",8,"9",(10,20,30),8,9,8}

b={7,8,9}

z=len(a)

print(z)

lista=[1,2,3]

a.update(lista)

b.update([1,2,3])

print(b)

print(a)

print(a<b)

print(b<a)

A=set()

print(type(A))

A={1,2,3}

B={1,2,3,2,1,2,1}

print(A==B)

num=[1,2,3,3,2,1,2,1]

C=set(num)

print(num)

print(C)

for n in A:

    print(n)

print(len(A))

print(3 in A)

print(7 not in A)

A.remove(1)

print(A)

A.discard(7)

print(A)

B.clear()

print(B)

B.add(8)

B.add(9)

print(B)

 

x=set()

x.add(7)

x={5,2,3,7,8}

y={7,3,5,14,1}

print(hash(5))

#union

z=x|y

print(z)

#interseccion

w=x&y

print(w)

#diferencia

t=y-x

print(t)

#diferencia simetrica

u=x^y

print(u)

a=frozenset({1,2,3})

#convertir a conjuntir inmutables

b={3,4,7}

c={1,2,3,4,7,8}

#es subconjunto de

print(a.issubset(c))

print(c.issuperset(b))

print(a.isdisjoint(b))

nimales = {'perro', 'vaca', 'raton', 'conejo', 'aguila', 'vaca', 'conejo'}

animales2 = {'conejo', 'burro', 'ballena', 'gato', 'perico', 'perro', 'gato', 'ballena'}

animales3 = {'perro','conejo','aguila'}

print(animales) #Se eliminan los elementos repetidos

#Operaciones entre conjuntos

print("cardinalidad en animales: ",len(animales)) #cardinalidad

print('cocodrilo' in animales2) #Comprobando pertenencia

print(animales == animales2) #Igualdad entre conjuntos, el orden no importa

print(animales3.issubset(animales)) #Subconjunto, animales3 subconjunto de animales?

print(animales3.issubset(animales) and animales3!=animales) #Subconjunto propio

print(animales.union(animales2)) #Union ->  animales | animales2

print(animales.intersection(animales2)) #Intesección -> animales & animales2

print(animales - animales2) #Diferencia

print(animales ^ animales2) #Diferenci

 

##############################################################

 

 

FUNCIONES:

Las funciones en Python son bloques de código que agrupan instrucciones para realizar una tarea específica y se pueden reutilizar. Se definen usando la palabra clave def y se llaman escribiendo su nombre seguido de paréntesis. Permiten organizar el código, hacerlo más modular y evitar la repetición de instrucciones.

CODIGO:

####################################################################

def imprimir_saludo():

    print("buenos dias")

imprimir_saludo()

def resta(a,b):

    resultado=a-b

    print(resultado)

resta(7,4)

def saludo(nombre="encontrado"):

    print("hola",nombre)

saludo()

 

 

def suma(a,b):

    resultado=a+b

    return resultado

print(suma(5,9))

 

 

def numeros(x,y):

    for j in range(x,y):

        print(j)

print(numeros(7,25))

#ingresar listas

 

def HallaMaxMin(listas):

    return (max(listas), min(listas))

maximo, minimo =HallaMaxMin([7,3,9,1,2,4,5,9,11])

print("el mayor valor es ",maximo)

print("el menor valor es ",minimo)

 

#funciones con listas

 

def serie(x,y):

    lista=[]

    for i in range(x,y+1):

        item=2*i+1

        lista.append(item)

    return lista

x=5

y=25

calculo=serie(x,y)

print(calculo)

#########################################################################


viernes, 19 de septiembre de 2025

SENTENCIAS DE CONTROL EN PYTHON

CADENAS

En Python, una cadena (o "string") es una secuencia inmutable de caracteres que se delimita con comillas simples ('...') o dobles ("..."). Puedes crear cadenas de una sola línea, o usar comillas triples ('''...''' o """...""") para cadenas que abarcan varias líneas. Son uno de los tipos de datos más utilizados, sirviendo para almacenar texto y realizar operaciones con él, como concatenación, búsqueda, reemplazo, y formato mediante métodos integrados y f-string

1. Declaracion de cadenas

Comillas simples o dobles: La forma más común es encerrar el texto entre 'Hola' o "Python".

Cadenas multilínea: Para textos que ocupan varias líneas, se usan comillas triples: '''Línea 1\nLínea 2''' o """Línea 1\nLínea 2""".

F-strings: Son una forma moderna y legible de formatear cadenas, anteponiendo la letra f a las comillas, lo que permite incorporar variables y expresiones dentro de la cadena, como f"Hola, {nombre}"

CODIGO

===================================================================

pa='''hola\n saludos \n excelente'''

print(pa)

num=0

for i in range(1,8):

    num+=1

print(f"el numero es {num}" )

=======================================================================

2. METODOS EN PYTHON

Python es un lenguaje multiparadigma, que soporta programación orientada a objetos (POO), siendo las clases y los objetos sus principales bloques de desarrollo. Las clases son los modelos sobre los cuáles se construirán nuestros objetos, mientras que los objetos son instancias de esa clase

Los métodos son acciones o funciones que puede realizar un objeto. Al igual que Python ofrece una serie de funciones "built-in", también pone a nuestra disposición un conjunto de métodos ya creados. Estos métodos dependen del tipo de objeto con el que estemos trabajando.

2.1.METODOS DE CADENAS

CODIGO

======================================================================

cadena1="Python clase"’

cadena2="buenos dias"

cadena3=","

mayusc=cadena1.upper()

minuscula=cadena1.lower()

primera_letra=cadena1.capitalize()

buscar_cadena=cadena1.find("v")

buscar_Cadena2=cadena1.index("v")

contar=cadena1.count("i")

contar2=cadena1.count("i",7,14)

reemplazar=cadena1.replace('o','x',1)

cortar=cadena1.split("v")

concatenar1=cadena3.join(cadena1)

print(concatenar1)

=======================================================================

2.2.METODOS DE LISTA

Los métodos de lista en Python permiten manipular colecciones de datos de manera eficiente

 

CODIGO

==========================================================================

lista=[4,5,2,3,"python"]

buscar=5

print(buscar in lista) 

print(lista.index(buscar))

if buscar in lista:

    print(lista.index(buscar))

else:

    print("no esta en la lista")

lista.append("HOLA")

print(lista)

print(lista.count(2))

lista.insert(2,"fe")

print(lista)

iterable="cadena"

lista.extend(iterable)

adicional=[3,5,2,9]

lista.extend(adicional)

print(lista)

print(lista.pop())

print(lista)

lista.remove(5)

print(lista)

#operadores en strings

x="hola"

y=" amigos"

print(x+y)

print("bueno dias "+x+y)

print(x*3+y)

========================================================================

SENTENCIAS FOR

colores=["azul","morado","rojo","azul","verde"]

for color in colores:

    print(color)

 

cadena="python"

for caracter in cadena:

    print(caracter)

 

utiles=["lapiz","cuaderno","libro","lapicero","color"]

for indicador,art in enumerate(utiles):

    print(f"el indice es {indicador} y el articulo es {art}")

#bucles anidados

codigos=["x","y","z","w"]

nume=[5,7,1,7]

 

for cod in codigos:

    for num in nume:

        print(f"{cod}{num}")

 

zonas=["este","oeste","sur","norte"]

for ind, zona in enumerate(zonas):

    print(zona)

    if zona=="sur":

        print(f"sur esta en la  posicion {ind}")

        break

 

print("continue")

zonas=["este","oeste","sur","norte"]

for ind, zona in enumerate(zonas):

    if zona=="sur":

        continue

    print(zona)

 

colores=["AZUL","ROJO","MORADO","VERDE","CELESTE"]

minus=[m.lower() for m in colores]

print(minus)

 

SENTENCIA WHILE

 

print("while")

cont=0

while cont<11:

    print(cont)

    cont+=1

 

cont=0

while True:

    print(cont)

    cont+=1

    if cont==11:

        break

 

cont=0

while cont<10:

    cont+=1

    if cont%3==0:

        continue

    print(cont)

cont=0

while cont<11:

    print(cont)

    cont+=1

else:

    print("bucle terminado")

 

num=4

while num<5:

    try:

        num=int(input("escribe un numero mayor que 5:"))

        if num<5:

            print("ingresa un numero correcto")

    except:

        print("ingresa un numero")

print("el numero introducido es ", num)

 

       

 

while True:

    respuesta=input("quieres salir del bucle:")

    if respuesta.lower()=="s":

        break

MATCH:

 

operator = input("Enter an operator (+, -, *, /): ")

x = 10

y = 5

 

match operator:

    case '+':

        result = x + y

    case '-':

        result = x - y

    case '*':

        result = x * y

    case '/':

        result = x / y

    case _:  # Default case if no other pattern matches

        result = "Invalid operator"

 

print(f"Result: {result}")

DICCIONARIOS

 

diccionario={1:"carlos",2:"renato",4:"maria",7:"jose"}

print(diccionario)

diccionario[2]="abraham"

del diccionario[1]

diccionario[9]="matias"

print(diccionario)

for i,j in diccionario.items():

    print(i,j)

  

viernes, 12 de septiembre de 2025

LISTAS Y ESTRUCTURAS DE CONTROL: PYTHON

 

5. LISTAS:

Las listas en Python son colecciones mutables y ordenadas de elementos, escritos entre corchetes [] y separados por comas. Permiten almacenar diversos tipos de datos en un solo lugar, son indexables a partir del 0, y ofrecen métodos como append() para añadir elementos, remove() para eliminarlos, y insert() para insertarlos en una posición específica.

 

SINTAXIS [::-1]

iterable[inicio:fin:paso]

que permite extraer una serie de elementos del iterable, comenzando por el numerado como inicio y terminando por el numerado como fin-1, aumentando de paso en paso.

 

Si omites inicio se empezará en el primer elemento del iterable, si omites fin se terminará en el último elemento del iterable.

 

Si el paso es negativo, el iterable se recorre "hacia atrás", y en ese caso los valores por defecto cuando se omite inicio y fin se invierten.

 

Así pues iterable[::-1] devuelve los elementos del iterable, comenzando por el último y terminando por el primero, en orden inverso a como estaban

También podemos poner la  función sorted para ordenar  y la función set para quitar duplicados

CODIGO

=========================================================================

my_list = [1, 2, 3, 4, 5]

reversed_list = my_list[::-1]  # Output: [5, 4, 3, 2, 1]

print("lista al reves: ",reversed_list)

my_string = "abcdefgh"

every_other_char = my_string[::2]  # Output: "aceg"

print(every_other_char)

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

subset = numbers[1:8:2]  # Output: [1, 3, 5, 7]

print(subset)

colores=["azul","rojo","verde","morado","amarillo","celeste","blanco"]

print(colores)

#modificar

colores[1]="anaranjado"

print(colores)

#agregar un item

colores.append("marron")

#agregar mas de un item

colores.extend(["rosado","pastel"])

print(colores)

print(len(colores))

 

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

sorted_numbers = sorted(numbers)

print(sorted_numbers)  # Output: [1, 1, 2, 3, 4, 5, 6, 9]

print(numbers)         # Output: [3, 1, 4, 1, 5, 9, 2, 6] (original list unchanged)

numbers2 = [3, 1, 4, 1, 5, 9, 2, 6]

sorted_desc = sorted(numbers2, reverse=True)

print(sorted_desc)     # Output: [9, 6, 5, 4, 3, 2, 1, 1]

words = ["apple", "banana", "kiwi", "grape"]

sorted_by_length = sorted(words, key=len)

print(sorted_by_length)  # Output: ['kiwi', 'grape', 'apple', 'banana']

 

people = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]

sorted_by_age = sorted(people, key=lambda person: person["age"])

print(sorted_by_age)     # Output: [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}]

 

nums=[1,2,2,3,1,4,5]

print(list(set(nums)))

==============================================================

6.  FORMATOS DE CONTROL:

1. Estructuras de Control Condicionales (Decisión)

Se usan para ejecutar código solo si se cumplen ciertas condiciones.

if: Ejecuta un bloque de código si la condición es verdadera.

elif: Permite evaluar una segunda condición si la primera condición if fue falsa.

else: Ejecuta un bloque de código si ninguna de las condiciones if o elif anteriores es verdadera.

CODIGO

=======================================================================

 

nota=float(input("ingrese la, nota final del estudio:"))

if nota>=18:

    print("excelente")

elif nota>=11 and nota<18:

    print("aprobado")

else:

    print("desaprobado")

lista=range(1,11)

for x  in lista:

    if x==9:

        break

    if x==5:

        continue

    print("numero:",x)

 ===============================================================

2. Estructuras de Control de Bucles (Repetición)

Se utilizan para repetir un bloque de código varias veces.

for: Itera sobre una secuencia (como una lista, tupla o cadena) y ejecuta un bloque de código para cada elemento.

while: Repite un bloque de código mientras una condición sea verdadera.

 CODIGO

==============================================================

for x in range(10):

    print("iteraccion: ",x)

y=0

while(y!=10):

    print("iteracion:",y)

    y=y+1

 

import time

test=["v","l"]

for i in range(3):

    print(test[i%2]*3)

    time.sleep(0.3)

=================================================================

7. FUNCIONES:

En Python, una función es un bloque de código reutilizable que realiza una tarea específica y puede ser llamado desde otras partes del programa. Se definen con la palabra clave def, seguidas del nombre de la función y paréntesis que pueden contener parámetros. Las funciones pueden recibir datos de entrada (argumentos), procesarlos y devolver un resultado.

Por ejemplo en este caso el marcador de posición único {} se utiliza cuando solo es necesario insertar un valor en la cadena. El método format() reemplaza el marcador de posición con el valor especificado.

CODIGO

====================================================================

def tabla5():

    for i in range(11):

        print("5x{}={}".format(i,i*5))

tabla5()

    ===================================================================

8. TUPLAS:

En Python, una tupla es una colección ordenada e inmutable (no modificable) de elementos, que pueden ser del mismo o de diferentes tipos de datos. Se definen usando paréntesis () y elementos separados por comas, o incluso sin paréntesis si no hay ambigüedad. Son útiles para almacenar datos que no deben cambiar, como coordenadas o para devolver múltiples valores de una función.

CODIGO

==========================================================================

tupla_frutas=("platano","mandarina","arandano")

print(tupla_frutas[0])

print(tupla_frutas[-2])

======================================================================

9. DICCIONARIOS:

Un diccionario en Python es una estructura de datos que almacena elementos como pares clave-valor. Cada clave es única y sirve para identificar y acceder a su valor asociado, que puede ser de cualquier tipo de dato, como cadenas, números o listas. Los diccionarios se definen utilizando llaves {} y se usan comúnmente en ciencia de datos para organizar y recuperar información de manera eficiente.

CODIGO

====================================================================

midiccionario={"carlos":"ingenieria","maria":"zootecnia","marcos":"medicina"}

print(midiccionario["carlos"])

midiccionario["jose"]="contador"

print(midiccionario)

midiccionario["marcos"]="administrador"

print(midiccionario)

del midiccionario["carlos"]

print(midiccionario)

misdatos={"area":"produccion","tienda":{"norte","sur","este","oeste"}}

print(misdatos["tienda"])

print(misdatos)

 

==================================================================

EJERCICIO:

HACER EL METODO DE BURBUJA PARA ORDENAR ELEMENTOS NUMERICOS:

CODIGO:

=========================================================================

def burbuja(lista):

    n=len(lista)

    recorridos=0

    cambios=0

    for i in range(1,n):

        recorridos+=1

        for j in range(0,n-1):

            if lista[j]>lista[j+1]:

                cambios+=1

                temp=lista[j]

                lista[j]=lista[j+1]

                lista[j+1]=temp

    print("numero de cambios",cambios)

    print("numero de recorridos",recorridos)

    return lista

 

#ingreso de elementos

lista=[5,4,3,2]

print(lista)

 

#ordenar lista

lista_ordenada=burbuja(lista)

print(lista_ordenada)

=====================================================================

INTRODUCCION: PYTHON

 

Python

1.CONCEPTO:

Es un lenguaje de programación de alto nivel, interpretado y de código abierto, reconocido por su sintaxis clara y legible, su versatilidad y su facilidad de uso para principiantes. Diseñado por Guido van Rossum, se utiliza ampliamente en desarrollo web, ciencia de datos, inteligencia artificial y automatización, gracias a su amplio ecosistema de bibliotecas y su gran comunidad de desarrolladores.

 

COMENTARIOS:

Para colocar comentarios en Python podemos hacerlo con:

CODIGO

=====================================================================

#

“”” texto “””

 ====================================================================

2) CONSTANTES Y OPERACIONES

Las operaciones básicas con Python se realizan usando operadores aritméticos para realizar cálculos con números. Los operadores más comunes son la suma +, la resta -, la multiplicación *, la división /, el módulo % (residuo de una división), y el operador de potencia **.

Operadores Aritméticos Básicos

Suma (+): Suma dos números. Ejemplo: 5 + 3 da 8.

Resta (-): Resta un número de otro. Ejemplo: 10 - 4 da 6.

Multiplicación (*): Multiplica dos números. Ejemplo: 6 * 2 da 12.

División (/): Divide el primer número por el segundo. El resultado siempre es un número decimal (float).

Ejemplo: 10 / 2 da 5.0.

División entera (//): Divide y redondea el resultado hacia abajo, obteniendo un número entero.

Ejemplo: 10 // 3 da 3.

Módulo (%): Calcula el residuo de una división.

Ejemplo: 10 % 3 da 1 (ya que 10 dividido por 3 es 3 con un residuo de 1).

Potencia (`: `)**: Eleva el primer número a la potencia del segundo.

Ejemplo: 2 ** 3 (2 al cubo) da 8.

 

CODIGO

======================================================================

num1=5

num2=7

print(num1+num2)

print(num1-num2)

print(num1*num2)

print(num1/num2)

print(num1//num2)

print(num1**num2)

print(num1%num2)

if num1%2==0:

    print("es par")

else:

    print("impar")

======================================================================

3. VARIABLES:

En Python, una variable es un nombre simbólico que actúa como un contenedor o un alias para almacenar datos en la memoria del ordenador. Se crean directamente al asignárseles un valor, no requieren una declaración previa como en otros lenguajes, y pueden contener diferentes tipos de datos, como números o texto. Python es de tipado dinámico, lo que significa que el tipo de dato de una variable se determina automáticamente en el momento de la asignación.

CODIGO

====================================================================

variable=input("ingrese la variable: ")

#print("el valor que ingresaste es :",variable)

 

variable=float(variable)

print("el resultado es: ",variable*variable)

 

import math as m

variable=0

variable=bool(variable)

print(variable)

x=m.sqrt(4)

print(x)

 

edad=input("cual es tu edad?")

edad_numero=int(edad)

edad_mas_cinco=edad_numero+5

print("dentro de 5 años tendras:",edad_mas_cinco)

===================================================================

4.ALEATORIOS:

En Python, la aleatoriedad se logra principalmente usando el módulo random, que ofrece funciones para generar números pseudoaleatorios, elegir elementos al azar de una secuencia y realizar otras operaciones de aleatorización. Para usarlo, primero debes importarlo con import random

CODIGO

=================================================================

 

import random

random_cara_Cruz=random.randint(0,1)

if random_cara_Cruz==0:

    print("cara")

else:

    print("cruz")

random_float=random.uniform(0,10)

print(random_float)

 

random_de0_a1=random.random()

print(random_de0_a1)

 

amigos=["gabriel","miguel","rafael"]

import random

print(random.choice(amigos))

random_index=random.randint(0,2)

print(amigos[random_index])

random_index2=random.randint(0,len(amigos)-1)

print(amigos[random_index2])

jueves, 28 de agosto de 2025

PROGRAMACION DEL BOTON SPIN(BOTON DE NUMERO)

Objeto Range:

Representa una celda, una fila, una columna, una selección de celdas que contienen uno o más bloques de celdas contiguos o un rango 3D.

Es decir nos representa una celda, ejemplo: Range(“A1”).

 

Propiedad Offset:

Devuelve un objeto Range que representa un rango desplazado del rango especificado.

expresion.Offset (filas a moverse, columnas a moverse)

 

Ejemplo:

Sub ejemplo()

Worksheets("hoja1").Activate

ActiveCell.Offset(rowOffset:=3, columnOffset:=3).Activate

End Sub

 ejercicio

domingo, 3 de agosto de 2025

SELECTED VALUE Y EL USO DE BOTONES

SELECTED VALUE

Devuelve el valor cuando el contexto de columnName 

se ha filtrado solo a un valor distinto.

 De lo contrario, devuelve alternateResult.

SELECTEDVALUE(<columnName>[, <alternateResult>])

ISFILTERED

Devuelve TRUE cuando se filtra directamente la tabla o columna especificadas.

ISFILTERED(<TableNameOrColumnName>)


PODEMOS USARLO COMO TITULO DINAMICO EN MATRICES:

TITULO DINAMICO = IF(ISFILTERED(ZONA[ZONA])," LAS VENTAS DE LA CIUDAD " & 

SELECTEDVALUE(ZONA[ZONA]) & " TOTALIZAN " &[TOTALES])


TAMBIEN PODEMOS USARLO COMO COLOR DINAMICO EN UN GRAFICO:

COLOR DINAMICO = IF(SELECTEDVALUE(TRABAJADORES[AREA])="PRODUCCION","#e0ad4d","#242424")


MEASURE

Presenta una definición de medida en una instrucción DEFINE de una consulta DAX.

[DEFINE 

    (

      MEASURE <table name>[<measure name>] = <scalar expression>

    ) + 

]


(EVALUATE <table expression>) 


USO DE LA VISTA DE TMDL :

DESPUES DE LA ARRASTRAR LA TABLA PODEMOS COLOCAR EL CODIGO PARA HACER

MEDIDAS MULTIPLES

measure 'suma1' =sum(TRABAJADORES[SUELDO])

measure 'suma2' =sum(TRABAJADORES[EXTRA])

measure 'suma3' =sum(TRABAJADORES[BONO])



MAPA ARGIS

EN EL OBJETO VISUAL ARGIS, PODEMOS HACER UNA SELECCION,

Y PONER EL TAMAÑO DE LA INFORMACION, Y 

CAMBIAR EL MAPA BASE



PARA HACER UN BOTON  EN POWER BI:

1) PRIMERO HACEMOS MARCADORES EN LA PAGINA A VINCULAR.

2) LUEGO INSERTAMOS EL BOTON, 

3) HABILITAR ACCION Y PONERLE TIPO MARCADOR  Y EL NOMBRE DADO DEL MARCADOR





PARA USAR LOS SCRIPTS DE PYTHON

1) PRIMERO INSTALAR PYTHON

2) INSTALAR LIBRERIAS EN DOS

3) INSTALAR PANDAS Y MATPLOTLIB

PANDAS:

py -m pip install pandas


MATPLOTLIB:

python -m pip install -U pip

python -m pip install -U matplotlib


4)HABILITAR PYTHON EN OPCIONES DE POWER BI

EJEMPLO DE SCRIPT EN POWER QUERY:

  

import pandas as pd

dataset["primeraletra"] = dataset["ZONA"].str.slice(stop=1)

dataset=dataset.head(5) 

sábado, 19 de julio de 2025

SCRATCH: CREACION DE JUEGOS

JUEGO PONG

PRIMERO TENEMOS QUE CREAR PERSONAJES: 

PADDLE

BALL

LINE



TAMBIEN HAY QUE CREAR LA VARIABLE PUNTOS, PARA PUNTUAR Y ASI USAR EN EL CODIGO SUS BLOQUES.

LUEGO DE PONER LOS PERSONAJES, HAY QUE CREAR UN PALABRA QUE DIGA "GAME OVER", PODEMOS HACERLO EN EL BOTON DE PINTAR QUE ESTA EN EL MENU DE PERSONAJES, Y COLOCAR LA PROGRAMACION PARA QUE SE MUESTRE CUANDO RECIBA LA VARIABLE MENSAJE.

TAMBIEN DEBEMOS ELEGIR VARIOS FONDOS PARA QUE ASI SE CAMBIE SEGUN EL CODIGO CADA 10 PUNTOS



domingo, 6 de julio de 2025

SCRATCH

Scratch es un motor de videojuegos desarrollado por MIT Media Lab. Su principal característica consiste en que permite el desarrollo de habilidades mentales mediante el aprendizaje de la programación, esta programación se hace mediante un eventos y bucles, se ejecuta mediante comandos en bloques. Sus características se basan en la logica computacional, por lo cual es muy difundido en la educación de niños, adolescentes y adultos.
JUEGO DE CANASTA