1643710104
¿Qué es un ITIN y qué puedo hacer con él?
Si no naciste en los Estados Unidos y actualmente vives ahí, te pedirán un Número de Seguridad Social para poder aplicar para la mayoría de los productos financieros. ¿Qué pasa si no tienes Número de Seguridad Social? Bueno, puedes obtener un ITIN (Número de Identificación Personal del Contribuyente) y aplicar para diferentes productos financieros usando este número. Lea más en: https://crediverso.com/es/que-es-un-itin-y-que-puedo-hacer-con-el/
What is GEEK
Buddha Community
1643710104
¿Qué es un ITIN y qué puedo hacer con él?
Si no naciste en los Estados Unidos y actualmente vives ahí, te pedirán un Número de Seguridad Social para poder aplicar para la mayoría de los productos financieros. ¿Qué pasa si no tienes Número de Seguridad Social? Bueno, puedes obtener un ITIN (Número de Identificación Personal del Contribuyente) y aplicar para diferentes productos financieros usando este número. Lea más en: https://crediverso.com/es/que-es-un-itin-y-que-puedo-hacer-con-el/
1652926080
Cómo Construir Un Analizador En Rust Por Diversión Y Ganancias
Un viernes por la mañana, holgazaneando, estás pensando en los nuevos programas de Netflix para ver. Su jefe viene y le pide que escriba un analizador para un archivo de unidad de Systemd .
Lo necesita para el lunes.
Estás nervioso.
La última vez que se le pidió que escribiera un analizador, se metió en la madriguera del conejo de la web, copiando y pegando fórmulas Regex hasta que funcionó™.
Tomas un sorbo de tu té de boba para calmarte. Buscas Systemd en Google y te gusta... no, no es tan simple como pensabas.
Tu buen truco de copiar y pegar expresiones regulares sale volando por la ventana. Las posibilidades de pasar un fin de semana sin interrupciones para atracones de programas se acercan rápidamente null.
#PEG al rescate
No pierdas la esperanza todavía. Permítame presentarle Parse Expression Grammer (PEG) , una manera fácil de familiarizarse con los analizadores y ahorrar su valioso fin de semana.
PEG es una forma legible de escribir reglas de sintaxis y es bastante similar a las expresiones regulares, que es diferente de una contraparte de gramática libre de contexto como Backus-Naur Form (BNF) en la que las expresiones deben reducirse a símbolos más pequeños. Lo siento, Noam Chomsky , quizás otros días de trabajo.
Usaré una biblioteca de análisis de Rust PEG llamada Pest , que es bastante impresionante. Si aún no lo has hecho, esperaré mientras instalas Rust .
#Empezando
Comencemos con una gramática simple para analizar una declaración de declaración de variable similar a JavaScript. Comenzaremos pensando en un conjunto de reglas para entradas válidas.
#Una declaración de declaración:
- comienza con una palabra clave
var, seguida de uno o más identificadores. - es insensible al espacio en blanco
- termina con un punto y coma (
;)
#Un grupo de identificadores:
- está precedido por una
varpalabra clave - está delimitado por comas
- es insensible al espacio en blanco
#Un identificador:
- puede contener cualquier número de dígitos, caracteres y guiones bajos en mayúsculas y minúsculas
- no puede comenzar con un dígito
- no puede contener ningún espacio
Un identificador es un término , lo que significa que es una pieza irrompible del token. También lo son las varpalabras clave y los puntos y comas.
Regresa un poco al lado BNF, usando Extended Backus-Naur Grammar (EBNF) , podrías definir formalmente la gramática anterior de esta manera:
<alpha> := 'a' | 'b' | 'c' | 'd' | 'e' | /* ... */ 'z'
| 'A' | 'B' | 'C' | 'D' | 'E' | /* ... */ 'Z'
<digit> := 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<Decl> := 'var' <Idents> '\n'? ';'
<Idents> := <Ident> ('\n'? ',' <Ident>)*
<Ident> := <alpha>+ (<alpha> | <digit> | '_')*El nombre de la regla en mayúsculas representa un símbolo que no termina (es decir, se puede dividir en términos más pequeños). El nombre en minúscula representa un término.
En aras de la brevedad, omitimos los espacios en blanco implícitos de las reglas. Básicamente, pueden existir uno o más espacios en blanco entre cada símbolo que ve.
¡Vamos a profundizar en ello! Las reglas <alpha>y <digit>se explican por sí mismas, por lo que dejaremos que lo adivines.
<Decl>es la regla más compleja para una instrucción de declaración, que presenta una varpalabra clave, un <Idents>símbolo, una nueva línea opcional y termina con un punto y coma. Básicamente, esta regla dice: "Cualquier entrada de cadena que comience con var, seguida de uno o más espacios, luego una subregla <Idents>, seguida de uno o más espacios y finalmente termine con un solo punto y coma es válida y felizmente la masticaré. "
<Idents>puede ser un solo <Ident>símbolo, seguido de cero o más pares de comas y <Ident>.
Finalmente, un <Ident>debe comenzar con uno o más caracteres, seguido de cero o más caracteres, dígitos o guiones bajos.
#Ok, código por favor
¡Espera, joven Anakin! Cabeza caliente, eres. He aquí que, con la gramática definida, podremos analizar estas declaraciones:
var foo, bar, baz;
var foo_1, baRamYu,baz99;
var foo_x
, baroo
, bazoo
;No, no me olvidé de formatear mi código. ¡Es JS válido, y también es para nuestro analizador! Aquí hay algo que nuestras reglas no soportarán:
var 99Problems¿Alguien quiere adivinar qué está mal aquí? ✋ Deja tu respuesta en el comentario. (psss, si tu respuesta es correcta, te sigo + 3 me gusta en tu publicación 👍)
#Entra el óxido y las plagas
Ok, espero que ya tengas Rust instalado (En tu terminal, intenta escribir which cargoy ver si aparece). Comience creando un nuevo proyecto binario de Rust con
$ cargo new --bin maybe-js; cd maybe-jsDentro de la carpeta del proyecto, abra el Cargo.tomlarchivo y agregue lo siguiente en dependencies, y ejecútelo cargo updatepara instalarlo.
[dependencies]
pest = "2.0"
pest_derive = "2.0"Una vez hecho esto, cdingrese srcy cree un archivo llamado grammar.pesty pegue lo siguiente en él:
alpha = { 'a'..'z' | 'A'..'Z' }
digit = { '0'..'9' }
underscore = { "_" }
newline = _{ "\n" | "\r" }
WHITESPACE = _{ " " }
declaration = { "var" ~ !newline ~ idents ~ newline? ~ ";" }
idents = { ident ~ (newline? ~ "," ~ ident)* }
ident = @{ !digit ~ (alpha | digit | underscore)+ }Ahora bien, si he tenido su atención durante los últimos minutos, no debería ser difícil adivinar lo que está sucediendo aquí. (Oh, ¿no lo he hecho? De todos modos... aquí vamos)
Los cinco primeros son todos términos. Son conjuntos de valores válidos. el | se llama Choice Operator , que es como "o-si no".
first | or_elseAl hacer coincidir una expresión de elección, firstse intenta. Si first coincide con éxito, la expresión completa se realiza correctamente de inmediato. Sin embargo, si firstfalla, or_elsese intenta a continuación.
La newlineregla tiene un peculiar _antes del corchete, que en Pest habla significa "silencioso": simplemente no lo queremos como parte de nuestros tokens analizados, pero de todos modos es parte de una sintaxis válida.
La WHITESPACEregla tiene un lugar especial en Pest. Si lo definió, Pest insertará automáticamente espacios en blanco opcionales implícitos (de acuerdo con la WHITESPACEregla que defina) entre cada símbolo. Nuevamente, _dice que queremos silenciarlo, ya que no queremos toneladas de espacios en blanco como parte de nuestro árbol de sintaxis.
La declarationregla es muy similar a la contraparte de EBNF que aprendimos antes. Las tildes ("~") simplemente significan "y luego". La regla comienza con una palabra clave "var", seguida de cualquier cosa que no sea un salto de línea (el "!" hace lo que hubiera adivinado intuitivamente: negar una regla), seguida de una subregla idents, un salto de línea opcional y finaliza con un punto y coma.
La identsregla es nuevamente similar al ejemplo EBNF. Es un solo ident, seguido de cero o más idents separados por comas.
La identregla es un poco especial. La "@", conocida como Atomic , delante del corchete está ahí para decir: "No quiero que se apliquen espacios en blanco implícitos a esta regla". Seguro que no queremos incluir ningún espacio en nuestro nombre de variable. Además, marcar una regla como atómica de esta manera trata la regla como un término, silenciando las reglas internas de coincidencia. Cualquier regla interna se descarta.
string_lit = { "\"" ~ inner ~ "\"" }
inner = { ASCII_ALPHANUMERIC* }Tenga en cuenta que ASCII_ALPHANUMERICes una regla incorporada conveniente en Pest para cualquier carácter y dígito ASCII.
Si analizamos una cadena "hola" con esta regla, esto generará primero un string_litnodo, que a su vez tiene un innernodo que contiene la cadena "hola", sin comillas.
Agregar un sigilo "@" delante del string_litcorchete:
string_lit = @{ "\"" ~ inner ~ "\"" }
inner = { ASCII_ALPHANUMERIC* }string_litTerminaremos con un nodo plano que contiene ""hola"".
Un sigilo similar "$" conocido como Compound Atomic , protege los espacios en blanco implícitos dentro de la regla. La diferencia es que permite que las reglas de coincidencia internas se analicen normalmente.
La !digitparte evita que la regla avance si comienza con un número. Si no es así, una o más combinaciones de caracteres, números y guiones bajos están bien.
#Pero espera, ¿dónde está el código?
¡Dang, mi inteligente explorador! Pareces arrinconarme en cada movimiento. Sí, eso no era código en absoluto, sino una definición de gramática de Pest. Ahora tenemos que escribir un código de Rust para analizar un texto. Inicie src/main.rsy agregue lo siguiente:
/// You need to do this to use macro
extern crate pest;
#[macro_use]
extern crate pest_derive;
/// 1. Import modules
use std::fs;
use pest::Parser;
use pest::iterators::Pair;
/// 2. Define a "marker" struct and add a path to our grammar file.
#[derive(Parser)]
#[grammar = "grammar.pest"]
struct IdentParser;
/// 3. Print the detail of a current Pair and optional divider
fn print_pair(pair: &Pair<Rule>, hard_divider: bool) {
println!("Rule: {:?}", pair.as_rule());
println!("Span: {:?}", pair.as_span());
println!("Text: {:?}", pair.as_str());
if hard_divider {
println!("{:=>60}", "");
} else {
println!("{:->60}", "");
}
}
fn main() {
/// 4. Parse a sample string input
let pair = IdentParser::parse(Rule::declaration, "var foo1, bar_99, fooBar;")
.expect("unsuccessful parse")
.next().unwrap();
print_pair(&pair, true);
/// 5. Iterate over the "inner" Pairs
for inner_pair in pair.into_inner() {
print_pair(&inner_pair, true);
match inner_pair.as_rule() {
/// 6. If we match an idents rule...
Rule::idents => {
/// 7. Iterate over another inner Pairs
for inner_inner_pair in inner_pair.into_inner() {
match inner_inner_pair.as_rule() {
/// 8. The term ident is the last level
Rule::ident => {
print_pair(&inner_inner_pair, false);
}
_ => unreachable!(),
}
}
}
_ => unreachable!(),
}
}
}Está bien si no entiendes la mayoría de las cosas aquí. Ejecutémoslo cargo runen el directorio de su proyecto y miremos la salida impresa.
Rule: declaration
Span: Span { str: "var foo1, bar_99, fooBar;", start: 0, end: 28 }
Text: "var foo1, bar_99, fooBarBaz;"
============================================================
Rule: idents
Span: Span { str: "foo1, bar_99, fooBar", start: 4, end: 27 }
Text: "foo1, bar_99, fooBarBaz"
============================================================
Rule: ident
Span: Span { str: "foo1", start: 4, end: 8 }
Text: "foo1"
------------------------------------------------------------
Rule: ident
Span: Span { str: "bar_99", start: 10, end: 16 }
Text: "bar_99"
------------------------------------------------------------
Rule: ident
Span: Span { str: "fooBar", start: 18, end: 27 }
Text: "fooBarBaz"
------------------------------------------------------------El concepto más importante aquí es un Pair. Representa un par de tokens coincidentes o, de manera equivalente, el texto distribuido que una regla con nombre coincidió correctamente.
A menudo usamos Pairs para:
Determinar qué regla produjo elPair
Usar el Paircomo materia prima&str
Inspeccionar las sub-reglas internas nombradas que produjeron elPair
let pair = Parser::parse(Rule::enclosed, "(..6472..) and more text")
.unwrap().next().unwrap();
assert_eq!(pair.as_rule(), Rule::enclosed);
assert_eq!(pair.as_str(), "(..6472..)");
let inner_rules = pair.into_inner();
println!("{}", inner_rules); // --> [number(3, 7)]A Pairpuede tener cero, una o más reglas internas. Para máxima flexibilidad, Pair::into_inner()devuelve Pairs, que es un tipo de iterador sobre cada par.
💡
Pair::into_inner()es un idioma muy común cuando se trabaja con Pest. Asegúrate de entender quéPaires a.
#Vamos a analizar Systemd
Ahora es el momento de poner el trabajo. Aquí hay un ejemplo de un archivo de unidad Systemd:
[Unit]
Description=Nginx
After=network-online.target
Wants=network-online.target
[Service]
Type=simple
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/home/ec2-user/.local/bin
Environment=LD_LIBRARY_PATH=/usr/local/lib
Environment=PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
ExecStart=/usr/local/sbin/nginx-runner.sh
Restart=on-failure
RestartSec=0
KillMode=process
[Install]
WantedBy=multi-user.targetEl archivo está agrupado en secciones, cada una con un nombre entre corchetes. Cada sección contiene cero o más pares de nombre y valor de propiedad, separados por un signo igual "=".
Tratemos de desarrollar un conjunto de reglas. Cree un nuevo proyecto de óxido con cargo new --bin systemd-parser, luego cree un archivo con el nombre src/grammar.pestcon las siguientes reglas:
/// Implicit white spaces are ok.
WHITESPACE = _{ " " }
/// Set of characters permited
char = { ASCII_ALPHANUMERIC | "." | "_" | "/" | "-" }
/// name is one or more chars. Note that white spaces are allowed.
name = { char+ }
// value can be zero or more char, plus = and : for path variables.
value = { (char | "=" | ":" )* }
/// section is a name, enclosed by square brackets.
section = { "[" ~ name ~ "]" }
/// property pair is a name and value, separated by an equal sign.
property = { name ~ "=" ~ value }
/// A Systemd unit file structure
file = {
SOI ~
((section | property)? ~ NEWLINE)* ~
EOI
}En el main.rsarchivo, comience con lo siguiente
extern crate pest;
#[macro_use]
extern crate pest_derive;
use std::fs;
use std::env::current_dir;
use std::collections::HashMap;
use pest::Parser;
#[derive(Parser)]
#[grammar = "grammar.pest"]
struct SystemdParser;
/// Implement a simple AST representation
#[derive(Debug, Clone)]
pub enum SystemdValue {
List(Vec<String>),
Str(String),
}
// ...Como primer paso, después de las importaciones y la configuración iniciales, definimos una SystemdValueenumeración como una representación simple del tipo de datos en un archivo Systemd. SystemdValue::Str(String)capturará un solo valor de propiedad y SystemdValue::List(Vec<String>)capturará varios valores de propiedad con un nombre de clave de propiedad duplicado. Por ejemplo, en el nginx.servicearchivo anterior hay varias Environmentpropiedades.
Aquí está la mainfunción:
fn main() {
// Read and parse the unit file.
let unparsed_file = fs::read_to_string("nginx.service")
.expect("cannot read file");
let file = SystemdParser::parse(Rule::file, &unparsed_file).expect("fail to parse")
.next()
.unwrap();
// Create a fresh HashMap to store the data.
let mut properties: HashMap<String, HashMap<String, SystemdValue>> = HashMap::new();
// These two mutable variables will be used to store
// section name and property key name.
let mut current_section_name = String::new();
let mut current_key_name = String::new();
// Iterate over the file line-by-line.
for line in file.into_inner() {
match line.as_rule() {
Rule::section => {
// Update the current_section_name
let mut inner_rules = line.into_inner();
current_section_name = inner_rules.next().unwrap().as_str().to_string();
}
Rule::property => {
let mut inner_rules = line.into_inner();
// Get a sub map of properties with the current_section_name key, or create new.
let section = properties.entry(current_section_name.clone()).or_default();
// Get the current property name and value.
let name = inner_rules.next().unwrap().as_str().to_string();
let value = inner_rules.next().unwrap().as_str().to_string();
// If the property name already exists...
if name == current_key_name {
// Get the section of the map with the key name, or insert a new SytemdValue::List.
let entry = section.entry(current_key_name.clone()).or_insert(SystemdValue::List(vec![]));
// Push the value onto the inner vector of SystemdValue::List.
if let SystemdValue::List(ent) = entry {
ent.push(value);
}
} else {
// Create a new SystemdValue::List and save it under name key.
let entry = section.entry(name.clone()).or_insert(SystemdValue::List(vec![]));
// Push the current value onto the vector, then set the
// current_key_name to the current name.
if let SystemdValue::List(ent) = entry {
ent.push(value);
}
current_key_name = name;
}
}
Rule::EOI => (),
_ => unreachable!(),
}
}
}Todo esto está bien, pero no usamos SystemdValue::Strninguna parte del código. Para mantener limpio el código, decidimos tratar cada propiedad como HashMap<String, SystemdValue::List(Vec<String>), donde la clave del mapa es la clave de propiedad y el vector String almacena la lista de valores de propiedad. Si no hay valor, el vector está vacío. Si hay un valor, este vector contiene ese único valor, y así sucesivamente.
Para que la API sea un poco más fácil de usar, escribiremos una pequeña función auxiliar para procesar todos los correos electrónicos de un solo valor Systemd::List(Vec<String>)y convertirlos en archivos Systemd::Str(String).
// Iterate over the nested maps, and convert empty and
// single-element `SystemdValue::List<Vec<String>>` to
// `SystemdValue::Str(String)`.
fn pre_process_map(map: &mut HashMap<String, HashMap<String, SystemdValue>>) {
for (_, value) in map.into_iter() {
for (_, v) in value.into_iter() {
if let SystemdValue::List(vs) = v {
if vs.len() == 0 {
let v_ = SystemdValue::Str(String::new());
*v = v_.clone();
} else if vs.len() == 1 {
let v_ = SystemdValue::Str((vs[0]).clone());
*v = v_.clone();
}
}
}
}
}¡Ahora estamos listos para imprimirlo para que el mundo lo vea!
fn main() {
// Our main code
pre_process_map(properties);
println!("{:#?}", properties);
}¡Auge! ¡Felicidades! Acaba de escribir un analizador de archivos Systemd, además de uno mini JS. 🤯 Ahora tendrás algo de tiempo libre para divertirte el viernes por la noche. Con otra tarde, es posible que incluso descubras cómo serializar el archivo de tu unidad Systemd en JSON para impresionar a tu jefe el lunes.
Puede consultar el código del analizador implementado como biblioteca en [este repositorio] (https://github.com/jochasinga/systemd-parser)
Fuente: https://hackernoon.com/how-to-build-a-parser-in-rust-for-fun-and-profit
1643094772
¿Qué es un analista de datos y por qué usar Python para el análisis de datos?
Aprenda qué es un analista de datos y qué debe saber al usar el lenguaje de programación Python para el análisis de datos.
La programación se está convirtiendo en una habilidad vital utilizada por varios profesionales en diferentes industrias en el entorno digital actual. Python es uno de los lenguajes que ha tenido una adopción generalizada a lo largo de los años. Se estima que la cantidad de desarrolladores de Python alcanzó un máximo de 8,2 millones en 2020 y sigue aumentando.
Hay muchas razones por las que varias personas recurren a Python. Una posible explicación es que el lenguaje tiene una curva de aprendizaje relativamente baja, lo que permite a los programadores usar menos líneas de código para completar las tareas.
Los analistas de datos se encuentran entre los muchos profesionales que usan Python en sus operaciones diarias. Antes de ver por qué Python es popular entre los analistas de datos, comprendamos primero quién es un analista de datos.
¿Quién es un analista de datos?
Un analista de datos interpreta los conjuntos de datos actuales utilizando técnicas estadísticas avanzadas para producir información e informes significativos. El campo de la ciencia de datos se basa mucho en datos del mundo real y análisis computacional para concluir.
Otras profesiones en el campo incluyen científicos de datos e ingenieros de datos. La principal diferencia entre un científico de datos y un analista de datos es que este último utiliza los datos disponibles para responder cualquier pregunta o problema que se le presente. Por el contrario, un científico de datos utiliza los conocimientos obtenidos para hacer predicciones basadas en datos.
Por otro lado, los ingenieros de datos crean arquitectura e infraestructura para la generación de datos y es más probable que estén bien versados en ingeniería y desarrollo de software que en análisis de datos.
¿Por qué los analistas de datos prefieren Python a otros lenguajes?
A lo largo de los años, Python ha tenido una adopción más amplia, gracias a varios factores que hacen que el lenguaje sea favorable para los desarrolladores novatos y veteranos. Desde su lanzamiento en 1991, Python ha experimentado mejoras significativas para convertirlo en el lenguaje de programación fácil de usar y de alto rendimiento de hoy. Estos son los motivos por los que Python es popular entre los analistas de datos y los científicos de datos.
1. Python es flexible y fácil de aprender
Python es un lenguaje de programación fácil de usar para principiantes que le permite crear secuencias de comandos de sitios web y aplicaciones personalizados y más fáciles de usar. Esta función de flexibilidad también es necesaria cuando se trabaja con conjuntos de datos grandes y complejos. Los analistas de datos pueden usar Python para crear, editar y personalizar modelos de datos con la ayuda de algoritmos basados en ML. Del mismo modo, es posible sistematizar conjuntos de datos y utilizar la minería de datos para completar varias tareas en una escala de tiempo breve.
2. Python es de código abierto y bien soportado
Python es de código abierto, de uso gratuito y cuenta con una comunidad sólida y activa de desarrolladores. Python se ejecuta en entornos Linux y Windows y puede moverse rápidamente a múltiples plataformas. Varias bibliotecas Python de código abierto están disponibles para su uso, como matplotlib, seaborn y plotly para visualización de datos, NumPy, pandas, sklearn, PyTorch y TensorFlow para ingeniería de datos, ciencia de datos y aprendizaje automático .
La comunidad activa de desarrolladores significa que estas bibliotecas están en constante desarrollo y mejora. Esto puede ser útil para los analistas de datos nuevos y expertos que desean desarrollar sus habilidades analíticas.
3. Python admite gráficos y visualización
Python admite elementos visuales como tablas y gráficos, lo que permite a los analistas de datos trabajar con una amplia variedad de datos. Las técnicas de representación de datos visuales son fáciles de entender y recordar, lo que las convierte en una opción ideal para los profesionales que manejan una gran cantidad de datos.
Uso de Python para el análisis de datos: lo que debe saber
Como se indicó anteriormente, Python es un lenguaje de programación de código abierto, lo que significa que todos los recursos están disponibles de forma gratuita para cualquier persona. Esto es bueno y malo. Es bueno porque reduce los gastos y acelera el ciclo de desarrollo de aplicaciones. Sin embargo, esto también es malo, ya que el software de código abierto puede presentar dos tipos de riesgos. Uno es el riesgo de propiedad intelectual de las licencias recíprocas y restrictivas, y el otro son los riesgos de seguridad a través de códigos maliciosos.
El riesgo de seguridad es un problema importante para muchos desarrolladores y empresas, especialmente aquellos que desconocen las vulnerabilidades de código abierto. Según una investigación reciente, Python clasificó cinco de los lenguajes de programación menos seguros con un 5% de vulnerabilidades. C se consideró el menos seguro con un 47 % de vulnerabilidades, seguido de PHP (17 %) y Java (10 %). A partir de esta investigación, es seguro asumir que Python es más seguro que los otros lenguajes de la lista, pero aun así vale la pena tomar precauciones.
Conclusión
Python es sin duda uno de los mejores lenguajes de programación que encuentran casos de uso en diferentes industrias y entornos de trabajo. Como analista de datos que usa Python para interpretar datos, debe prestar atención al riesgo de IP y las vulnerabilidades de ciberseguridad.
Una regla general es adoptar metodologías sólidas de evaluación de riesgos que integren todas sus estrategias de gestión de riesgos. Sería útil si también considerara una solución de administración de riesgos automatizada que le permita administrar todos los riesgos en su organización, de manera rápida y conveniente.
Feliz aprendizaje ♥
Enlace: https://www.thepythoncode.com
#python
1678338209
¿Por qué es necesario el cumplimiento corporativo y qué es?
Independientemente de su industria, el cumplimiento corporativo debe ser un factor importante de sus operaciones diarias. ¿Cómo maneja su empresa el cumplimiento y la reducción de riesgos? Tomar precauciones preventivas puede parecer una carga al principio, pero podría ahorrarle a su negocio innumerables dólares a largo plazo. Las violaciones del cumplimiento corporativo pueden dar lugar a multas, sanciones, juicios, daños a la reputación y más. Evite que su empresa tenga que aprender este conocimiento de la manera más difícil. Cree un programa de cumplimiento de inmediato poniéndose en contacto con la empresa de cumplimiento corporativo.
¿Qué implica el cumplimiento empresarial?
"La práctica de obedecer una directiva" o "el estado de satisfacer normas o estándares" son las definiciones de cumplimiento. Se define como el procedimiento para garantizar que su empresa y su personal se adhieran a todas las normas, reglamentaciones, reglamentos y prácticas éticas que son relevantes para su organización e industria en el sector empresarial.
El cumplimiento empresarial incluye el cumplimiento de las normas federales y estatales, así como de las políticas y los procesos internos. Al ayudar a identificar y detener las infracciones de las normas, hacer cumplir las normas ayuda a su empresa a evitar multas y acciones legales. Estos son los ejemplos de cumplimiento corporativo:
¿Qué pretende lograr un programa de cumplimiento empresarial?
El objetivo es salvaguardar su empresa. Eso es todo al respecto. Sin embargo, la inversión podría dar buenos resultados al ayudar a evitar el desperdicio, el fraude, el uso indebido, la intolerancia y otros comportamientos que ponen en peligro las operaciones y su negocio.
Su programa de cumplimiento comercial debe estar vinculado con todas las iniciativas de cumplimiento de toda la empresa, desde la administración de políticas internas y externas hasta la capacitación exhaustiva de los empleados. Puede reducir la probabilidad de errores e infracciones significativos asegurándose de que todos los miembros del personal y los departamentos colaboran para mantener los estándares. Si tiene alguna duda, póngase en contacto con el mejor marco de cumplimiento corporativo ahora mismo.
1677665590
Qué es Flutter y cómo trabajar con él
En este tutorial, veamos qué es Flutter y cómo trabajar con él. Aprende a crear aplicaciones móviles con Flutter. Flutter es un marco de desarrollo de aplicaciones móviles de Google que le permite crear aplicaciones iOS y Android atractivas y de alto rendimiento.
En este artículo, veamos qué es Flutter y cómo trabajar con él.
¿Qué es Flutter?
Flutter es un marco de desarrollo de aplicaciones móviles de código abierto creado por Google. Le ayuda a crear aplicaciones hermosas, rápidas y de alta calidad para iOS, Android y la web, todo desde una única base de código.
Flutter se ha convertido rápidamente en una opción popular entre los desarrolladores. Gracias a su facilidad de uso y rendimiento, puede crear hermosas aplicaciones móviles con Flutter.
Beneficios de Flutter
Flutter utiliza el lenguaje de programación Dart de Google . Dart es similar a JavaScript o TypeScript y ofrece un modelo de programación reactivo para crear interfaces de usuario.
Esto significa que en lugar de tener que actualizar la interfaz de usuario cuando cambia su código, el marco lo hará por usted. Esto hace que sea más fácil y eficiente crear interfaces de usuario dinámicas y receptivas.
Flutter recarga en caliente. Imagen del autor.
Flutter también tiene un ciclo de desarrollo rápido. Flutter tiene una función de recarga en caliente que lo ayuda a ver los cambios que realiza en el código de inmediato. Con Flutter, no tienes que esperar a que el código se compile cada vez que cambias una parte del código.
La fuerza principal de Flutter son los widgets.
Widgets de aleteo
While building an app, you usually have to write functionality from scratch. For example, if you want to embed a Google map within your code, you have to write the code to import Google Maps into your app.
But Flutter provides ready-made widgets for almost all common app functions. Think of it like working with a lego set. Flutter provides a rich set of pre-designed widgets that you can customize to create beautiful interfaces.
These widgets are not simple UI elements like buttons and text boxes. They include complex widgets like scrolling lists, navigations, sliders, and many others. These widgets help save you time and let you focus on the business logic of your application.
Here is a full list of in-built Flutter widgets that you can peruse.
Another advantage of Flutter is its performance.
El motor gráfico de Flutter, Skia, dibuja cada píxel en la pantalla. Esto hace posible lograr animaciones fluidas de 60 cuadros por segundo, incluso en dispositivos de gama baja.
Flutter también tiene una comunidad grande y creciente de desarrolladores que contribuyen al marco. También viene con documentación detallada y una amplia biblioteca de paquetes y complementos. Puede integrar fácilmente esos complementos en su aplicación para agregar funciones como mapas, comunicación de red y almacenamiento local.
Ahora que sabe qué es Flutter y por qué es útil, veamos cómo se compara con otra biblioteca popular, React-Native.
Reaccionar nativo frente a Flutter
Flutter vs reaccionar nativo
React Native y Flutter son dos de los marcos de desarrollo de aplicaciones móviles multiplataforma más populares disponibles en la actualidad. Ambos ofrecen la capacidad de crear aplicaciones móviles visualmente atractivas y de alto rendimiento para múltiples plataformas.
Pero hay algunas diferencias clave entre los dos marcos que debe tener en cuenta al elegir el adecuado para su proyecto.
React Native está basado en JavaScript y es una extensión de la biblioteca React . React-native usa componentes nativos para construir la interfaz de usuario, lo que proporciona una apariencia nativa para la aplicación.
React Native tiene una comunidad grande y establecida en comparación con Flutter y es una excelente opción si sus productos existentes usan JavaScript o React.
Flutter ofrece un enfoque único para crear interfaces de usuario mediante el uso de su propio conjunto de widgets personalizables. Este enfoque le da a Flutter una apariencia única en comparación con otros marcos de desarrollo móvil.
El ciclo de desarrollo rápido de Flutter y la función de recarga en caliente permiten a los desarrolladores crear aplicaciones más rápido que otras alternativas.
React Native tiene una curva de aprendizaje más fácil en comparación con Flutter. Dado que la mayoría de los desarrolladores conocen JavaScript, no tienen que aprender un nuevo lenguaje como Dart para crear aplicaciones con Flutter.
Pero la dependencia de React Native en componentes nativos dificulta lograr un rendimiento constante en múltiples plataformas. También puede generar inconsistencias en la interfaz de usuario entre iOS y Android.
Flutter ofrece un mejor rendimiento, con su motor gráfico dibujando cada píxel en la pantalla. Con Flutter, puede obtener animaciones suaves y fluidas incluso en hardware de gama baja. Flutter también ofrece una apariencia unificada y consistente para la aplicación en todas las plataformas, ya que los desarrolladores usan el mismo conjunto de widgets para crear la interfaz de usuario.
Entonces, React Native y Flutter tienen sus propias fortalezas y debilidades, y la elección correcta depende de sus necesidades y requisitos específicos.
React Native es una buena opción para empresas con inversiones existentes en JavaScript y React. Flutter es una mejor opción para proyectos que necesitan interfaces de usuario receptivas, únicas y de alto rendimiento junto con un ciclo de desarrollo rápido.
Cómo instalar Flutter
The best way to install Flutter is to follow the official installation page. You can choose your operating system and follow the instructions.
Once you have installed Flutter, you can use its inbuilt tool called Flutter doctor to check the components. For example, on Mac, you should see a similar response on running flutter doctor .
Flutter doctor
Hello World in Flutter
Let’s create a simple hello world app using Flutter.
We can use the flutter create <app name> to create a new app.
Flutter create
Now we can cd into the directory and change the main file. It will be located under <app_name>/lib/main.dart. Replace the code in the main.dart file with the following code.import 'package:flutter/material.dart':
import 'package:flutter/material.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Hello, World!',
home: Scaffold(
appBar: AppBar(
title: const Text('Hello, World!'),
),
body: const Center(
child: Text('Hello, World!'),
),
),
);
}
}Este código define una aplicación de Flutter que mostrará "¡Hola, mundo!" en el centro de la pantalla. La función main() llamará a la función runApp() con una instancia de la clase MyApp.
En el método build() de MyApp, un widget de MaterialApp con el título "¡Hola, mundo!" es creado. El widget Scaffold contiene una barra de aplicaciones con el título "¡Hola, mundo!" y el widget Center colocará el texto en el centro de la pantalla.
Así es como se verá la salida después de ejecutar el flutter runcomando.
Flutter hola mundo
¿Qué es Flutterflow?
flutterflow. Créditos: Flutterflow.io
Antes de terminar, quiero compartir una herramienta que ha mejorado enormemente mi productividad al crear aplicaciones con Flutter. Esto no es un respaldo, simplemente me gusta mucho la herramienta y quiero que usted también sepa sobre ella.
Flutter Flow es una herramienta de diseño visual que te permite crear aplicaciones de Flutter mediante una interfaz de arrastrar y soltar. Puede crear interfaces de usuario complejas e interactivas para sus aplicaciones Flutter sin escribir ningún código.
Flutterflow funciona proporcionando una interfaz visual para diseñar la interfaz de usuario de su aplicación, que luego se traduce al código de Flutter. Facilita la creación y la iteración del diseño de su aplicación, ya que puede ver los cambios que realiza en tiempo real.
Flutterflow también ofrece desarrollo colaborativo, por lo que puede crear sus aplicaciones junto con un equipo. Flutterflow viene con muchas integraciones como Firebase, Stripe e incluso la API de OpenAI.
Una vez que haya creado su aplicación, puede publicarla en la tienda de aplicaciones o en la tienda de juegos utilizando la integración integrada de Codemagic.
Conclusión
Flutter es un marco increíble para crear aplicaciones móviles. Ofrece tiempos de desarrollo rápidos, diseños hermosos y receptivos, y una base de código única para iOS y Android. Su función de recarga en caliente permite a los desarrolladores ver los cambios en tiempo real, lo que reduce el tiempo total de desarrollo.
Además, la biblioteca de widgets de Flutter permite la creación de diseños personalizados y complejos con facilidad. En términos de rendimiento, Flutters va muy por delante de alternativas como React-Native.
Fuente: https://www.freecodecamp.org
#flutter