Bases de Python en más de 128 palabras[Partie 5]

Este artículo sigue las primeras cuatro partes que se pueden ver aquí:

Estoy discutiendo los conceptos básicos del lenguaje Python para aprenderlo rápidamente. En Francia, estas bases se imparten en la escuela secundaria en la segunda clase de SNT, primera y superior de la INE. También forman parte del programa de conocimientos de CAPES NSI.

Consolidación de funciones:

Un módulo es un archivo que contiene un conjunto de funciones que desea incluir en la aplicación.

monmodule.py de archivo de ejemplo:

saludos def (nombre):
  imprimir ("Hola" - nombre)

Uso del módulo en un programa Python:

importar mymodule

monmodule.salutations ("Sebastian")

Cambio de nombre del módulo:

importación monmodule como mod

mod.salutations ("Daniel")

La función dir es una función integrada para enumerar todos los nombres de función (o nombres de variables) en un módulo.

plataforma de importación

res - dir (plataforma)
Impresión 

Es posible importar solo partes de un módulo, utilizando la palabra clave desde.

de saludos de importación de mymodule

saludos ("John")

Paquetes:

Los paquetes permiten una estructuración jerárquica del espacio de nombres del módulo.

Los paquetes ayudan a evitar colisiones entre nombres de módulo.

Crear un paquete es bastante simple porque utiliza la estructura de directorios del sistema operativo.

Si consideramos un directorio llamado pkg que contiene dos módulos, module1.py y module2.py.

El contenido de los módulos es:

prueba de f():
    impresión ('módulo de prueba 1')

Clase Toto:
    Pasar
def test2():
    impresión («módulo de prueba 2»)

Clase Joe:
    Pasar

Con esta estructura, si el directorio pkg se encuentra en una ubicación donde se puede encontrar (es decir, uno de los directorios contenidos en sys.path).

Es posible hacer referencia a los dos módulos (pkg.module1, pkg.module2) e importarlos:

importar pkg.module1, pkg.module2

pkg.module1.test()
x - pkg.module2.Joe()

Valor aleatorio:

importación aleatoria

(random.random)) #Retourne un número decimal aleatoriamente entre 0 y 1
(random.randint(10,20)) #Retourne un todo en la brecha definida
miembro '["Seb","Jean","Louise"]
(random.choice) #Retourne un elemento de la lista al azar

Bases de Python en más de 128 palabras[Partie 4]

Este artículo sigue las tres primeras partes que se pueden ver aquí:

Estoy discutiendo los conceptos básicos del lenguaje Python para aprenderlo rápidamente. En Francia, estas bases se imparten en la escuela secundaria en la segunda clase de SNT, primera y superior de la INE. También forman parte del programa de conocimientos de CAPES NSI.

Excepciones:

Cuando se produce un error, (una excepción) se puede administrar mediante la instrucción try:

Tratar:
  impresión (r)
Excepto NameError:
  imprimir ("variable r indefinida")
Excepto:
  imprimir ("Otra excepción") 

Comentario:

#Ceci es un comentario
#sur
línea de #plusieurs
imprimir ("Hola Python")
"""
Este es un comentario
En
varias líneas
"""
imprimir ("Hola Python")

Clases:

Las clases son como un generador de objetos, ayuda a modelar conceptos reales.

Clase de persona:
  def __init__ (auto, nombre, edad):
    self.name
    self.age

  def ma_fonction (yo):
    impresión ("Nombre de la persona: " 'self.name)

p1 - Persona ("Sebastian", 36)
impresión (p1.name)
impresión (p1.edad) 
p1.ma_fonction()
p1.age - 40 #Modification de las propiedades del objeto
del p1.age #supprime propiedad del objeto
del p1 #supprime el objeto

self es una referencia a la instancia actual de la clase y se utiliza para tener acceso a las variables que pertenecen a la clase. Puede ser nombrado que no sea self, pero debe ser la primera configuración de cualquier función de clase.

Patrimonio:

La herencia define una clase que hereda todos los métodos y propiedades de otra clase.

Clase animal:
   def walk():
       impresión ('walk')

Perro clase (Animal)
    Pasar

c1 - Perro ()
c1.walk()

Fabricante:

La función __init () se llama automáticamente cada vez que se crea un nuevo objeto.

super () hará que la clase secundaria herede todos los métodos y propiedades de su elemento primario.

Clase de estudiante (Persona):
  def __init__ (auto, nombre, nombre):
    super().__init__ (nombre, nombre) 

Bases de Python en más de 128 palabras[Partie 3]

Este artículo sigue las dos primeras partes que se pueden ver aquí:

Estoy discutiendo los conceptos básicos del lenguaje Python para aprenderlo rápidamente. En Francia, estas bases se imparten en la escuela secundaria en la segunda clase de SNT, primera y superior de la INE. También forman parte del programa de conocimientos de CAPES NSI.

Tuplas:

Una tupla es una colección ordenada como listas e inmutable (que no cambia).

exampleTuple ("manzana", "pera", "fresa")
imprimir (exampleTuple)
imprimir (exampleTupl[1]e)
print (exampleTuple[-1]) #L significa de indexación negativa desde el final, -1 hace referencia al último elemento, -2 hace referencia al penúltimo elemento, etc.
#Vous de impresión ([1:2]ejemploTuple) puede especificar un intervalo de índices especificando dónde empezar y dónde finalizar el intervalo.
z - lista (exampleTuple) #conversion tupla en la lista
z[1] - "banana" 
x - tupla (z) #conversion lista de tuplas

para x en exampleTuple: #Boucle en una tupla
  impresión (x) 

si "pera" en exampleTuple: #test de la existencia en una tupla
  impresión ("Sí") 

Desembalaje:

coordenadas - (1.2,3)
x,y,z - coordenadas
impresión (x)

Diccionarios:

Un diccionario es una colección desordenada, editable e indizada.

Cliente
   "name": "Elodie"
   "edad": "45"
   "año": 1980
 }

impresión (client["age"]e)
clien["nouvelleCle"]te - "nuevo valor" #ajoute una nueva clave y valor
customer.get("solde") #renvoi 'None' porque la clave no existe

Funciones:

Las características permiten que el código se organice en piezas reutilizables. En Python, una función se define mediante la palabra clave def.

def exemple_fonction():
  imprimir ("TestFunction")

exemple_fonction()

Los datos se pueden cambiar a funciones como un ajuste. Puede agregar tantos ajustes como desee, simplemente sepárelos por una coma.

def exemple_fonction (nombre):
  imprimir ("Hola" - nombre)

exemple_fonction ("Juan")
exemple_fonction ("Pierre")

Bases de Python en más de 128 palabras[Partie 2]

Este artículo sigue la primera parte que se puede encontrar aquí: http://128mots.com/index.php/2019/12/04/python-les-bases-capes-nsi-snt-en-plus-de-128-mots/

Al igual que con el primer artículo, estoy hablando de los conceptos básicos del lenguaje Python para aprenderlo rápidamente. En Francia, estas bases se imparten en la escuela secundaria en la segunda clase de SNT, primera y superior de la INE. También forman parte del programa de conocimientos de CAPES NSI.

Prioridad de los operadores:

Resumo la prioridad de los operadores de Python, desde la prioridad más alta hasta la prioridad más baja

  • Paréntesis (): Agrupación de operaciones
  • Expositor: x 'y'
  • Multiplicación, multiplicación de matriz, división, división completa, módulo: ' , ', /, //, % %
  • Suma, resta:

Funciones matemáticas:

importar matemáticas
  • math.ceil (2.6) superior entero
  • math.floor(-5.3) parte entera, da aquí -8.0.
  • math.sqrt: raíz cuadrada.
  • math.pow (5, 5): 5 potencia 5.
  • math.exp(2): función exponencial.
  • math.log(2): función de logaritmo
  • math.log(3, 2): inicie sesión en la base 2.
  • math.factorial(4): factor
  • math.fsum(L): suma de los elementos de una lista
  • math.sin, math.cos, math.tan: funciones trigonométricas
  • math.pi: pi
  • math.degrees(y): convertir radianes a grados
  • math.radians(y): conversión de grados en radianes

Expresiones condicionales:

Python se basa en la sangría para definir el ámbito del código.

x - 100
Y - 23
si x y:
  imprimir ("x más grande que y")
elif a b:
  ("igualdad")
Otro:
  impresión ("y mayor que x")

Cuerdas F:

importar matemáticas
imprimir (f'El valor de pi es 'math.pi:.3f'.')

Listas bidimensionales (matrices):

matriz,[[1, 2, 3] [4,5, 6], [7, 8, 9]]
impresión (matri[0][1]z)

Métodos en las listas:

list.append ('n') #Ajoute un elemento al final de la lista
list.insert (0,'a') #Ajoute un elemento en la posición especificada
list.pop(1) #Enleve el elemento de la lista a la posición especificada

Bases de Python en más de 128 palabras[Partie 1]

Aquí están mis notas para aprender el lenguaje python muy rápidamente. En Francia, estas bases se imparten en la escuela secundaria en la segunda clase de SNT, primera y superior de la INE. También forman parte del programa de conocimientos de CAPES NSI.

Operadores lógicos:

  • y: returnS True si ambas declaraciones son verdaderas
  • gold: Returns True si una de las declaraciones es verdadera
  • No: Invierta el resultado, devuelva Sorset si el resultado es verdadero

Operadores de comparación:

  • Igualdad
  • No es igual
  • >< Supérieur / Inférieur supérieur=""></ Supérieur / Inférieur>
  • <=>Igual inferior / igual superior</=>
  • ¡diferente!

Pase de palabra clave:

Cuando se ejecuta la instrucción pass, no ocurre nada, pero evita un error cuando no se permite el código vacío.

x - 22
y - 150

si x y:
  Pasar

Entrada de usuario:

Uso de la instrucción input:

name - input ("Nombre de usuario:")
imprimir ("Nombre de usuario es: "

While Loop:

El bucle while ejecuta un conjunto de instrucciones siempre que una condición sea verdadera. La instrucción break permite detener el bucle incluso si la condición mientras es true.

x - 1
mientras que x< 11:></ 11:>
  si x 5:
    Romper
  x 1 

Para bucle:

Un bucle for realiza una iteración en una secuencia (una lista, una tupla, un diccionario, un conjunto o una cadena de caracteres).

Una lista:

para x en[1, 2, 3]:
  impresión (x)

Una cadena de caracteres:

para x en "hola":
  impresión (x)

Una tupla:

tuplaObjet ('Citroen', 2019, 'C4', 23000)
 
para los elementos de tupléObj:
    impresión (elementos)

Un diccionario:

dico - 'color': 'verde', 'animal': 'perro', 'legumbre': 'espinaca'
para cle in dico:
    Impresión

Función de rango:

Para completar un número específico de veces, utilice la función de rango ().

para x en rango(10):
  impresión (x)

Listas:

Una lista es una colección ordenada y editable y permite duplicados.

Lista["pomme", "banane", "poire"]
impresión (list[1]a)
imprimir #[-1]Affiche el último elemento de la lista
imprimir #[2:3]Lorsque especificar un rango, el valor devuelto será una nueva lista con los elementos especificados.
imprimir #Lorsque especificar un rango, el valor devuelto será una nueva lista con los elementos especificados.
#En omiti[:3]endo el valor inicial, el rango comenzará en el primer elemento:
imprimir #[1:]En omitiendo el valor final, el rango irá al final de la lista:
print #des [-2:-1]índices negativos para iniciar la búsqueda desde el final de la lista: este ejemplo devuelve los elementos del índice -2 (incluido) al índice -1 (excluido).

Trifusion e Implementación de Python en menos de 128 palabras

La fusión de tri sigue el paradigma de división para gobernar que consiste en dividir la tarea inicial en dos tareas más pequeñas similares.

El algoritmo es el siguiente:
Dividimos la lista para ser ordenada en dos mitades.
Ordenamos cada uno de ellos.
Las dos mitades obtenidas se combinan para reconstruir la lista ordenada.

Este algoritmo se aplica recursivamente, es decir, hasta que la lista que se va a ordenar se compone de un solo elemento.

Tri fusión (fuente: wikipedia)
#Tri función de fusión de la división de la tabla
def tri_fusion (tabla):
    si len (tabla)<= 1:></= 1:> 
        tabla de retorno
    pivote - len (tabla)//2
    Tabla1 - Tabla 1[:pivot]
    Tabla2 - Tabla2[pivot:]
    izquierda - tri_fusion (tabla1)
    derecha - tri_fusion (tabla2)
    fusión - fusión (izquierda, derecha)
    retorno fusión


#Tri función de fusión de 2 listas
def fusión (tabla1, tabla2):
    indice_tableau1 0
    indice_tableau2 0    
    taille_tableau1 - len (tabla1)
    taille_tableau2 - len (tabla2)
    tableau_fusionne[]
    mientras indice_tableau1<taille_tableau1 and=""></taille_tableau1><taille_tableau2:></taille_tableau2:>
        Si la tabla1< tab[indice_tableau1]leau2:></ tableau2[indice_tableau2]:>
            tableau_fusionne.append (tabla1[indice_tableau1])
            indice_tableau1 1
        Otro:
            tableau_fusionne.append (tabla2[indice_tableau2])
            indice_tableau2 1
    mientras indice_tableau1<taille_tableau1:></taille_tableau1:>
        tableau_fusionne.append (tabla1)
        indice_tableau1
    mientras indice_tableau2<taille_tableau2:></taille_tableau2:>
        tableau_fusionne.append (tabla2)
        indice_tableau2
    tableau_fusionne de regreso

Mesa[11, 222, 3, 899, 24, 5, 46, 67]
impresión (tabla)
tableau_trie - tri_fusion (tabla)
impresión (tableau_trie)

Viaje en profundidad a través de los gráficos y la implementación de Python en menos de 128 palabras

El viaje en profundidad de un gráfico es explorar el gráfico memorizando las cumbres visitadas y el camino para llegar allí.

El principio y explorar el gráfico de una cumbre dada y uno explora a todos sus vecinos yendo lo más profundo posible (es decir, repitiendo la operación de la cumbre visitada en la cumbre visitada hasta que uno está atascado, entonces uno regresa a través del camino llevado a la punto de partida).

La trayectoria profunda permite encontrar el árbol que cubre el gráfico que no es el mismo en general que el árbol de cobertura encontrado a través de la ruta en ancho del gráfico.

El algoritmo en resumen:

Fase de descenso:

Comience desde la cumbre elegida para comenzar y marcarla.

El mayor tiempo posible:

  • Ir a un vecino no visitado y marcarlo
  • Recuerda el tope o el arco por el que pasaste
  • Si todos los vecinos ya están visitados:
    • De vuelta a la parte superior por la que se descubrió (fase de retroceso: ascenso)

Si se visitan todas las tapas del gráfico (están en el árbol de cobertura), entonces el gráfico está relacionado de lo contrario el gráfico no está relacionado.

Ejemplo de Python con 3 gráficos:

Ejemplo de gráfico relacionado
Ejemplo de gráfico no relacionado
Ejemplo de gráfico relacionado

Módulo Python para la ruta en profundidad:

#Parcours en profundidad de un gráfico
Algoritmo recursivo: El principio es explorar el gráfico y volver a sus pasos cuando está atascado.
def parcours_en_profondeur (gráfico, sommet_en_cours:str, sommets_visites[]:):
	imprimir ('Tratar de explorar la cumbre:' ' str(sommet_en_cours))
	Si no sommet_en_cours en sommets_visites:
		sommets_visites.append(sommet_en_cours) #Ajoute la cumbre actual en el nodo visitado
		print ('Explorando la cumbre:' - str(sommet_en_cours))
	sommets_voisins_non_visites[]
	para sommet_voisin en gráfic[sommet_en_cours]o:
		Si no sommet_voisin en sommets_visites:
			sommets_voisins_non_visites.append (sommet_voisin) - Hace una lista de cumbres cercanas que aún no han sido visitadas

	para la cumbre en sommets_voisins_non_visites:
		#pour todos los picos cercanos no visitados se hacen una ruta profunda
		parcours_en_profondeur (gráfico, parte superior, sommets_visites)

#Fonction probar si el gráfico está relacionado después de un viaje en profundidad
def est_un_graphe_connexe (gráfico, sommets_visites):
	si len (sommets_visites)
		imprimir ("El gráfico está relacionado")
		impresión (20 - "-")
	Otro:
		imprimir ("El gráfico no está relacionado")
		impresión (20 - "-")


gráfico ajacence #Liste
Gráfico
	'A': ['B','C'],
	'B': ['A','C', 'D'],
	'C': ['D'],
	'D':['C','A']
}

sommets_visites[]
parcours_en_profondeur (gráfico, 'A',sommets_visites)
est_un_graphe_connexe (gráfico,sommets_visites)

Gráfico no relacionado #Exemple: La parte superior D no está conectada al gráfico
Gráfico
	'A': ['B','C'],
	'B': ['A','C'],
	'C': ['A'],
	'D':[]
}

sommets_visites
parcours_en_profondeur (gráfico, 'A',sommets_visites)
est_un_graphe_connexe (gráfico,sommets_visites)

#Autre ejemplo
Gráfico
	'A': ,
	'B': ,
	'C': ,
	'D':
}

sommets_visites
parcours_en_profondeur (gráfico, 'A',sommets_visites)
est_un_graphe_connexe (gráfico,sommets_visites)

#en final de la ruta si todos los picos están en las cumbres visitadas, entonces el gráfico está relacionado

#Note
#J se reúnen con la sangría errorError: unindent no coincide con ningún nivel de sangría externa
#Je simplemente lo resolvió reanudando toda la sangría al principio de la línea
#et sustituyéndola por tabulación en lugar de espacios