Create and Pass data to Template in CakePHP 4

Template in the CakePHP 4 is a .php file where define the HTML layout of the page. Template files automatically get loaded on the page. For this need to create files in a specific pattern.

From Controller, you can pass data to the template file.

In this tutorial, I show how you can create template files and pass values from the controller to the template in CakePHP 4 project.

1. Create Controller

Create a HomeController.php file in src/Controller/ folder.

Create HomeController Class that extends AppController.

In the class create 2 methods –

• index() – Assign a string value to $page and $content variables. To pass this value to the template use $this->set(). It takes an Array value. compact() function converts passed variable names to an Array in which the key is same as the variable name.
• aboutus() – Assign a string value to $page variable. Initialize $data['page'] with $page. Pass $data to $this->set(). In the template file reading the value is the same as the above-specified way.

CakePHP automatically converts the method names as a request parameter.

This will create the following requests –

• index – http://localhost:8765/home or http://localhost:8765/home/index
• aboutus – http://localhost:8765/home/aboutus

Completed Code

<?php
declare(strict_types=1);

namespace App\Controller;

class HomeController extends AppController
{

     public function index(){
          $page = "Homepage";
          $content = "Welcome to Makitweb";

          // Pass value to template
          $this->set(compact('page','content'));
     }

     public function aboutus(){
          $page = "About US";

          // Pass value to template
          $data['page'] = $page;
          $this->set($data);
     }

}

2. Create Template

Create a new Home folder in templates/ folder. Now in the Home folder create index.php and aboutus.php file.

Here, make sure the folder name is the same as the controller name – Home and the file name is the same as the method names created in the controller – index(), and aboutus().

templates/Home/index.php

In the page just create a <h1 > and <p > tag. You can either read the values passed from the controller using <?php echo $page ?> or <?= $page ?>.

Completed Code

<h1><?= $page ?></h1>
<p><?= $content ?></p>

templates/Home/aboutus.php

In this file also create <h1> and <p> tags. I displayed static value in the <p > tag and display passed value in <h1 > tag – <?= $page ?>.

Completed Code

<h1><?= $page ?></h1>
<p>About us page content</p>

4. Output

Home page (http://localhost:8765/home/index)

About us page (http://localhost:8765/home/aboutus)

5. Conclusion

You don’t need to call template files explicitly from the controller. So the naming of the files and folder is important while creating a template.

If you found this tutorial helpful then don't forget to share.

Original article source at: https://makitweb.com/

#cakephp #php #pass 

Create and Pass Data to Template in CakePHP 4

Template in the CakePHP 4 is a .php file where define the HTML layout of the page. Template files automatically get loaded on the page. For this need to create files in a specific pattern.

From Controller, you can pass data to the template file.

In this tutorial, I show how you can create template files and pass values from the controller to the template in CakePHP 4 project.

1. Create Controller

Create a HomeController.php file in src/Controller/ folder.

Create HomeController Class that extends AppController.

In the class create 2 methods –

• index() – Assign a string value to $page and $content variables. To pass this value to the template use $this->set(). It takes an Array value. compact() function converts passed variable names to an Array in which the key is same as the variable name.
• aboutus() – Assign a string value to $page variable. Initialize $data['page'] with $page. Pass $data to $this->set(). In the template file reading the value is the same as the above-specified way.

CakePHP automatically converts the method names as a request parameter.

This will create the following requests –

• index – http://localhost:8765/home or http://localhost:8765/home/index
• aboutus – http://localhost:8765/home/aboutus

Completed Code

<?php
declare(strict_types=1);

namespace App\Controller;

class HomeController extends AppController
{

     public function index(){
          $page = "Homepage";
          $content = "Welcome to Makitweb";

          // Pass value to template
          $this->set(compact('page','content'));
     }

     public function aboutus(){
          $page = "About US";

          // Pass value to template
          $data['page'] = $page;
          $this->set($data);
     }

}

2. Create Template

Create a new Home folder in templates/ folder. Now in the Home folder create index.php and aboutus.php file.

Here, make sure the folder name is the same as the controller name – Home and the file name is the same as the method names created in the controller – index(), and aboutus().

templates/Home/index.php

In the page just create a <h1 > and <p > tag. You can either read the values passed from the controller using <?php echo $page ?> or <?= $page ?>.

Completed Code

<h1><?= $page ?></h1>
<p><?= $content ?></p>

templates/Home/aboutus.php

In this file also create <h1> and <p> tags. I displayed static value in the <p > tag and display passed value in <h1 > tag – <?= $page ?>.

Completed Code

<h1><?= $page ?></h1>
<p>About us page content</p>

4. Output

Home page (http://localhost:8765/home/index)

About us page (http://localhost:8765/home/aboutus)

5. Conclusion

You don’t need to call template files explicitly from the controller. So the naming of the files and folder is important while creating a template.

If you found this tutorial helpful then don't forget to share.

Original article source at: https://makitweb.com/

#cakephp #pass #data #php 

A Light Package for Generating & Comparing Password Hashing in Go

argon2-hashing   

argon2-hashing provides a light wrapper around Go's argon2 package. Argon2 was the winner of the Password Hashing Competition that makes it easier to securely derive strong keys from weak inputs (i.e. user passwords).

With this library you can:

• Generate a argon2 derived key with a crytographically secure salt and default parameters.
• Tune argon2 with you own parameters based of you hardware configuration.
• Compare a derived key with the possible cleartext equivalent (user password).

Currently supported only Argon2id function.

The API closely mirrors with Go's Bcrypt library and Alex Edwards simple-scrypt package.

Installation

With a Go modules:

go get -u github.com/andskur/argon2-hashing

Example

argon2-hashing doesn't try to re-invent the wheel or do anything "special". It wraps the argon2.IDKey function as thinly as possible, generates a crytographically secure salt for you using Go's crypto/rand package, and returns the derived key with the parameters prepended:

package main

import(
    "fmt"
    "log"

    "github.com/andskur/argon2-hashing"
)

func main() {
    // e.g. r.PostFormValue("password")
    passwordFromForm := "qwerty123"

    // Generates a derived key with default params
    hash, err := argon2.GenerateFromPassword([]byte(passwordFromForm), argon2.DefaultParams)
    if err != nil {
        log.Fatal(err)
    }

    // Print the derived key.
    fmt.Printf("%s\n", hash)

    // Uses the parameters from the existing derived key. Return an error if they don't match.
    err = argon2.CompareHashAndPassword(hash, []byte(passwordFromForm))
    if err != nil {
        log.Fatal(err)
    }
}

Argon2 introduction

The Argon2 algorithm accepts a number of configurable parameters:

• Memory — The amount of memory used by the algorithm (in kibibytes).
• Iterations — The number of iterations (or passes) over the memory.
• Parallelism — The number of threads (or lanes) used by the algorithm.
• Salt length — Length of the random salt. 16 bytes is recommended for password hashing.
• Key length — Length of the generated key (or password hash). 16 bytes or more is recommended.
• The memory and iterations parameters control the computational cost of hashing the password. The higher these figures are, the greater the cost of generating the hash. It also follows that the greater the cost will be for any attacker trying to guess the password.

But there's a balance that you need to strike. As you increase the cost, the time taken to generate the hash also increases. If you're generating the hash in response to a user action (like signing up or logging in to a website) then you probably want to keep the runtime to less than 500ms to avoid a negative user experience.

If the Argon2 algorithm is running on a machine with multiple cores, then one way to decrease the runtime without reducing the cost is to increase the parallelism parameter. This controls the number of threads that the work is spread across. There's an important thing to note here though: changing the value of the parallelism parameter changes the output of the algorithm. So — for example — running Argon2 with a parallelism parameter of 2 will result in a different password hash to running it with a parallelism parameter of 4.

Choosing Parameters

Picking the right parameters for Argon2 depends heavily on the machine that the algorithm is running on, and you'll probably need to do some experimentation in order to set them appropriately.

The recommended process for choosing the parameters can be paraphrased as follows:

1. Set the parallelism and memory parameters to the largest amount you are willing to afford, bearing in mind that you probably don't want to max these out completely unless your machine is dedicated to password hashing.
2. Increase the number of iterations until you reach your maximum runtime limit (for example, 500ms).
3. If you're already exceeding the your maximum runtime limit with the number of iterations = 1, then you should reduce the memory parameter.

Thanks to

• Alex Edwards - For an excellent article, after which I was inspired to develop this package.
• Matt Silverlock - For an great and well documented simple-scrypt package which I took for the structural basis.

Author: Andskur
Source Code: https://github.com/andskur/argon2-hashing 
License: MIT License

#go #golang #cryptography #pass 

Como anexar A Uma Lista Ou Matriz Em Python Como Um Profissional

Neste artigo, você aprenderá sobre o .append()método em Python. Você também verá como .append()difere de outros métodos usados ​​para adicionar elementos a listas.

Vamos começar!

O que são listas em Python? Uma definição para iniciantes

Uma matriz na programação é uma coleção ordenada de itens e todos os itens precisam ser do mesmo tipo de dados.

No entanto, ao contrário de outras linguagens de programação, os arrays não são uma estrutura de dados embutida no Python. Em vez de arrays tradicionais, o Python usa listas.

Listas são essencialmente arrays dinâmicos e são uma das estruturas de dados mais comuns e poderosas em Python.

Você pode pensar neles como contêineres ordenados. Eles armazenam e organizam tipos semelhantes de dados relacionados juntos.

Os elementos armazenados em uma lista podem ser de qualquer tipo de dados.

Pode haver listas de inteiros (números inteiros), listas de floats (números de ponto flutuante), listas de strings (texto) e listas de qualquer outro tipo de dados interno do Python.

Embora seja possível que as listas contenham apenas itens do mesmo tipo de dados, elas são mais flexíveis do que as matrizes tradicionais. Isso significa que pode haver uma variedade de tipos de dados diferentes dentro da mesma lista.

As listas têm 0 ou mais itens, o que significa que também pode haver listas vazias. Dentro de uma lista também pode haver valores duplicados.

Os valores são separados por uma vírgula e colocados entre colchetes, [].

Como criar listas em Python

Para criar uma nova lista, primeiro dê um nome à lista. Em seguida, adicione o operador de atribuição ( =) e um par de colchetes de abertura e fechamento. Dentro dos colchetes, adicione os valores que você deseja que a lista contenha.

#create a new list of names
names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#print the list to the console
print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny']

Como as listas são indexadas em Python

As listas mantêm uma ordem para cada item.

Cada item na coleção tem seu próprio número de índice, que você pode usar para acessar o próprio item.

Índices em Python (e em qualquer outra linguagem de programação moderna) começam em 0 e aumentam para cada item da lista.

Por exemplo, a lista criada anteriormente tinha 4 valores:

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

O primeiro valor na lista, "Jimmy", tem um índice de 0.

O segundo valor na lista, "Timmy", tem um índice de 1.

O terceiro valor na lista, "Kenny", tem um índice de 2.

O quarto valor na lista, "Lenny", tem um índice de 3.

Para acessar um elemento na lista por seu número de índice, primeiro escreva o nome da lista, depois entre colchetes escreva o inteiro do índice do elemento.

Por exemplo, se você quisesse acessar o elemento que tem um índice de 2, você faria:

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

print(names[2])

#output
#Kenny

Listas em Python são mutáveis

Em Python, quando os objetos são mutáveis , significa que seus valores podem ser alterados depois de criados.

As listas são objetos mutáveis, portanto, você pode atualizá-las e alterá-las depois de criadas.

As listas também são dinâmicas, o que significa que podem crescer e diminuir ao longo da vida de um programa.

Os itens podem ser removidos de uma lista existente e novos itens podem ser adicionados a uma lista existente.

Existem métodos internos para adicionar e remover itens de listas.

Por exemplo, para add itens, há as .append(), .insert()e .extend()métodos.

Para remove itens, há as .remove(), .pop()e .pop(index)métodos.

O que o .append()método faz?

O .append()método adiciona um elemento adicional ao final de uma lista já existente.

A sintaxe geral se parece com isso:

list_name.append(item)

Vamos decompô-lo:

• list_name é o nome que você deu à lista.
• .append()é o método de lista para adicionar um item ao final de list_name.
• item é o item individual especificado que você deseja adicionar.

Ao usar .append(), a lista original é modificada. Nenhuma nova lista é criada.

Se você quiser adicionar um nome extra à lista criada anteriormente, faça o seguinte:

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#add the name Dylan to the end of the list
names.append("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']

Qual é a diferença entre os métodos .append()e .insert()?

A diferença entre os dois métodos é que .append()adiciona um item ao final de uma lista, enquanto .insert()insere um item em uma posição especificada na lista.

Como você viu na seção anterior, .append()irá adicionar o item que você passar como argumento para a função sempre no final da lista.

Se você não quiser apenas adicionar itens ao final de uma lista, poderá especificar a posição com a qual deseja adicioná-los .insert().

A sintaxe geral fica assim:

list_name.insert(position,item)

Vamos decompô-lo:

• list_name é o nome da lista.
• .insert() é o método de lista para inserir um item em uma lista.
• positioné o primeiro argumento para o método. É sempre um número inteiro - especificamente é o número de índice da posição onde você deseja que o novo item seja colocado.
• itemé o segundo argumento para o método. Aqui você especifica o novo item que deseja adicionar à lista.

Por exemplo, digamos que você tenha a seguinte lista de linguagens de programação:

programming_languages = ["JavaScript", "Java", "C++"]

print(programming_languages)

#output
#['JavaScript', 'Java', 'C++']

Se você quisesse inserir "Python" no início da lista, como um novo item da lista, você usaria o .insert()método e especificaria a posição como 0. (Lembre-se de que o primeiro valor em uma lista sempre tem um índice de 0.)

programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(0, "Python")

print(programming_languages)

#output
#['Python', 'JavaScript', 'Java', 'C++']

Se, em vez disso, você quisesse que "JavaScript" fosse o primeiro item da lista e, em seguida, adicionasse "Python" como o novo item, você especificaria a posição como 1:

programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(1,"Python")

print(programming_languages)

#output
#['JavaScript', 'Python', 'Java', 'C++']

O .insert()método oferece um pouco mais de flexibilidade em comparação com o .append()método que apenas adiciona um novo item ao final da lista.

Qual é a diferença entre os métodos .append()e .extend()?

E se você quiser adicionar mais de um item a uma lista de uma só vez, em vez de adicioná-los um de cada vez?

Você pode usar o .append()método para adicionar mais de um item ao final de uma lista.

Digamos que você tenha uma lista que contém apenas duas linguagens de programação:

programming_languages = ["JavaScript", "Java"]

print(programming_languages)

#output
#['JavaScript', 'Java']

Você então deseja adicionar mais dois idiomas, no final dele.

Nesse caso, você passa uma lista contendo os dois novos valores que deseja adicionar, como argumento para .append():

programming_languages = ["JavaScript", "Java"]

#add two new items to the end of the list
programming_languages.append(["Python","C++"])

print(programming_languages)

#output
#['JavaScript', 'Java', ['Python', 'C++']]

Se você observar mais de perto a saída acima, ['JavaScript', 'Java', ['Python', 'C++']], verá que uma nova lista foi adicionada ao final da lista já existente.

Então, .append() adiciona uma lista dentro de uma lista .

Listas são objetos, e quando você usa .append()para adicionar outra lista em uma lista, os novos itens serão adicionados como um único objeto (item).

Digamos que você já tenha duas listas, assim:

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

E se você quiser combinar o conteúdo de ambas as listas em uma, adicionando o conteúdo de more_namesa names?

Quando o .append()método é usado para essa finalidade, outra lista é criada dentro de names:

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

#add contents of more_names to names
names.append(more_names)

print(names)

#output
#['Jimmy', 'Timmy', ['Kenny', 'Lenny']]

Então, .append()adiciona os novos elementos como outra lista, anexando o objeto ao final.

Para realmente concatenar (adicionar) listas e combinar todos os itens de uma lista para outra , você precisa usar o .extend()método.

A sintaxe geral fica assim:

list_name.extend(iterable/other_list_name)

Vamos decompô-lo:

• list_name é o nome de uma das listas.
• .extend() é o método para adicionar todo o conteúdo de uma lista a outra.
• iterablepode ser qualquer iterável, como outra lista, por exemplo, another_list_name. Nesse caso, another_list_nameé uma lista que será concatenada com list_name, e seu conteúdo será adicionado um a um ao final de list_name, como itens separados.

Então, tomando o exemplo anterior, quando .append()for substituído por .extend(), a saída ficará assim:

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

names.extend(more_names)

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny']

Quando usamos .extend(), a nameslista foi estendida e seu comprimento aumentado em 2.

A maneira como .extend()funciona é que ele pega uma lista (ou outro iterável) como argumento, itera sobre cada elemento e, em seguida, cada elemento no iterável é adicionado à lista.

Há outra diferença entre .append()e .extend().

Quando você deseja adicionar uma string, como visto anteriormente, .append()adiciona o item inteiro e único ao final da lista:

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#add the name Dylan to the end of the list
names.append("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']

Se, em .extend()vez disso, você adicionasse uma string ao final de uma lista, cada caractere na string seria adicionado como um item individual à lista.

Isso ocorre porque as strings são iteráveis ​​e .extend()iteram sobre o argumento iterável passado para ela.

Então, o exemplo acima ficaria assim:

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#pass a string(iterable) to .extend()
names.extend("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'D', 'y', 'l', 'a', 'n']

Conclusão

Resumindo, o .append()método é usado para adicionar um item ao final de uma lista existente, sem criar uma nova lista.

Quando é usado para adicionar uma lista a outra lista, cria uma lista dentro de uma lista.

Se você quiser saber mais sobre Python, confira a Certificação Python do freeCodeCamp . Você começará a aprender de maneira interativa e amigável para iniciantes. Você também construirá cinco projetos no final para colocar em prática o que aprendeu.

fonte: https://www.freecodecamp.org

#python 

Ajouter En Python - Comment Ajouter à Une Liste Ou à Un Tableau

Dans cet article, vous découvrirez la .append()méthode en Python. Vous verrez également en quoi .append()diffère des autres méthodes utilisées pour ajouter des éléments aux listes.

Commençons!

Que sont les listes en Python ? Une définition pour les débutants

Un tableau en programmation est une collection ordonnée d'éléments, et tous les éléments doivent être du même type de données.

Cependant, contrairement à d'autres langages de programmation, les tableaux ne sont pas une structure de données intégrée à Python. Au lieu des tableaux traditionnels, Python utilise des listes.

Les listes sont essentiellement des tableaux dynamiques et sont l'une des structures de données les plus courantes et les plus puissantes de Python.

Vous pouvez les considérer comme des conteneurs commandés. Ils stockent et organisent ensemble des données similaires.

Les éléments stockés dans une liste peuvent être de n'importe quel type de données.

Il peut y avoir des listes d'entiers (nombres entiers), des listes de flottants (nombres à virgule flottante), des listes de chaînes (texte) et des listes de tout autre type de données Python intégré.

Bien qu'il soit possible pour les listes de ne contenir que des éléments du même type de données, elles sont plus flexibles que les tableaux traditionnels. Cela signifie qu'il peut y avoir une variété de types de données différents dans la même liste.

Les listes ont 0 ou plusieurs éléments, ce qui signifie qu'il peut également y avoir des listes vides. À l'intérieur d'une liste, il peut également y avoir des valeurs en double.

Les valeurs sont séparées par une virgule et placées entre crochets, [].

Comment créer des listes en Python

Pour créer une nouvelle liste, donnez d'abord un nom à la liste. Ajoutez ensuite l'opérateur d'affectation ( =) et une paire de crochets ouvrants et fermants. A l'intérieur des parenthèses, ajoutez les valeurs que la liste doit contenir.

#create a new list of names
names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#print the list to the console
print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny']

Comment les listes sont indexées en Python

Les listes maintiennent un ordre pour chaque article.

Chaque élément de la collection a son propre numéro d'index, que vous pouvez utiliser pour accéder à l'élément lui-même.

Les index en Python (et tout autre langage de programmation moderne) commencent à 0 et augmentent pour chaque élément de la liste.

Par exemple, la liste créée précédemment avait 4 valeurs :

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

La première valeur de la liste, "Jimmy", a un indice de 0.

La deuxième valeur de la liste, "Timmy", a un indice de 1.

La troisième valeur de la liste, "Kenny", a un indice de 2.

La quatrième valeur de la liste, "Lenny", a un indice de 3.

Pour accéder à un élément de la liste par son numéro d'index, écrivez d'abord le nom de la liste, puis entre crochets écrivez l'entier de l'index de l'élément.

Par exemple, si vous vouliez accéder à l'élément qui a un index de 2, vous feriez :

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

print(names[2])

#output
#Kenny

Les listes en Python sont modifiables

En Python, lorsque les objets sont mutables , cela signifie que leurs valeurs peuvent être modifiées une fois qu'ils ont été créés.

Les listes sont des objets modifiables, vous pouvez donc les mettre à jour et les modifier après leur création.

Les listes sont également dynamiques, ce qui signifie qu'elles peuvent augmenter et diminuer tout au long de la vie d'un programme.

Des éléments peuvent être supprimés d'une liste existante et de nouveaux éléments peuvent être ajoutés à une liste existante.

Il existe des méthodes intégrées pour ajouter et supprimer des éléments des listes.

Par exemple, pour add articles, il y a les .append(), .insert()et les .extend()méthodes.

Pour supprimer des éléments, il existe les méthodes .remove(), .pop()et .pop(index).

A quoi sert la .append()méthode ?

La .append()méthode ajoute un élément supplémentaire à la fin d'une liste déjà existante.

La syntaxe générale ressemble à ceci :

list_name.append(item)

Décomposons-le :

• list_name est le nom que vous avez donné à la liste.
• .append()est la méthode de liste pour ajouter un élément à la fin de list_name.
• item est l'élément individuel spécifié que vous souhaitez ajouter.

Lors de l'utilisation de .append(), la liste d'origine est modifiée. Aucune nouvelle liste n'est créée.

Si vous souhaitez ajouter un nom supplémentaire à la liste créée précédemment, procédez comme suit :

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#add the name Dylan to the end of the list
names.append("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']

Quelle est la différence entre les méthodes .append()et .insert()?

La différence entre les deux méthodes est qu'elle .append()ajoute un élément à la fin d'une liste, alors qu'elle .insert()insère et élément à une position spécifiée dans la liste.

Comme vous l'avez vu dans la section précédente, .append()ajoutera l'élément que vous passez comme argument à la fonction toujours à la fin de la liste.

Si vous ne souhaitez pas simplement ajouter des éléments à la fin d'une liste, vous pouvez spécifier la position à laquelle vous souhaitez les ajouter avec .insert().

La syntaxe générale ressemble à ceci :

list_name.insert(position,item)

Décomposons-le :

• list_name est le nom de la liste.
• .insert() est la méthode de liste pour insérer un élément dans une liste.
• positionest le premier argument de la méthode. C'est toujours un entier - en particulier c'est le numéro d'index de la position où vous voulez que le nouvel élément soit placé.
• itemest le deuxième argument de la méthode. Ici, vous spécifiez le nouvel élément que vous souhaitez ajouter à la liste.

Par exemple, supposons que vous disposiez de la liste suivante de langages de programmation :

programming_languages = ["JavaScript", "Java", "C++"]

print(programming_languages)

#output
#['JavaScript', 'Java', 'C++']

Si vous vouliez insérer "Python" au début de la liste, en tant que nouvel élément de la liste, vous utiliseriez la .insert()méthode et spécifieriez la position comme 0. (Rappelez-vous que la première valeur d'une liste a toujours un indice de 0.)

programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(0, "Python")

print(programming_languages)

#output
#['Python', 'JavaScript', 'Java', 'C++']

Si vous aviez plutôt voulu que "JavaScript" soit le premier élément de la liste, puis ajoutez "Python" comme nouvel élément, vous spécifieriez la position comme suit1 :

programming_languages = ["JavaScript", "Java", "C++"]

programming_languages.insert(1,"Python")

print(programming_languages)

#output
#['JavaScript', 'Python', 'Java', 'C++']

La .insert()méthode vous donne un peu plus de flexibilité par rapport à la .append()méthode qui ajoute uniquement un nouvel élément à la fin de la liste.

Quelle est la différence entre les méthodes .append()et .extend()?

Que faire si vous souhaitez ajouter plusieurs éléments à une liste à la fois, au lieu de les ajouter un à la fois ?

Vous pouvez utiliser la .append()méthode pour ajouter plusieurs éléments à la fin d'une liste.

Supposons que vous ayez une liste qui ne contient que deux langages de programmation :

programming_languages = ["JavaScript", "Java"]

print(programming_languages)

#output
#['JavaScript', 'Java']

Vous souhaitez ensuite ajouter deux autres langues, à la fin.

Dans ce cas, vous passez une liste contenant les deux nouvelles valeurs que vous souhaitez ajouter, en argument à .append():

programming_languages = ["JavaScript", "Java"]

#add two new items to the end of the list
programming_languages.append(["Python","C++"])

print(programming_languages)

#output
#['JavaScript', 'Java', ['Python', 'C++']]

Si vous regardez de plus près la sortie ci-dessus, ['JavaScript', 'Java', ['Python', 'C++']]vous verrez qu'une nouvelle liste a été ajoutée à la fin de la liste déjà existante.

Donc, .append() ajoute une liste à l'intérieur d'une liste .

Les listes sont des objets, et lorsque vous utilisez .append()pour ajouter une autre liste dans une liste, les nouveaux éléments seront ajoutés en tant qu'objet unique (élément).

Supposons que vous ayez déjà deux listes, comme ceci :

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

Et si vous vouliez combiner le contenu des deux listes en une seule, en ajoutant le contenu de more_namesto names?

Lorsque la .append()méthode est utilisée à cette fin, une autre liste est créée à l'intérieur de names:

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

#add contents of more_names to names
names.append(more_names)

print(names)

#output
#['Jimmy', 'Timmy', ['Kenny', 'Lenny']]

Donc, .append()ajoute les nouveaux éléments comme une autre liste, en ajoutant l'objet à la fin.

Pour réellement concaténer (ajouter) des listes et combiner tous les éléments d'une liste à une autre , vous devez utiliser la .extend()méthode.

La syntaxe générale ressemble à ceci :

list_name.extend(iterable/other_list_name)

Décomposons-le :

• list_name est le nom de l'une des listes.
• .extend() est la méthode pour ajouter tout le contenu d'une liste à une autre.
• iterablepeut être n'importe quel itérable tel qu'une autre liste, par exemple, another_list_name. Dans ce cas, another_list_nameest une liste qui sera concaténée avec list_name, et son contenu sera ajouté un par un à la fin de list_name, en tant qu'éléments séparés.

Ainsi, en reprenant l'exemple précédent, lorsque .append()est remplacé par .extend(), la sortie ressemblera à ceci :

names = ["Jimmy", "Timmy"]
more_names = ["Kenny", "Lenny"]

names.extend(more_names)

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny']

Lorsque nous avons utilisé .extend(), la namesliste s'est allongée et sa longueur a été augmentée de 2.

La façon dont cela .extend()fonctionne est qu'il prend une liste (ou un autre itérable) comme argument, itère sur chaque élément, puis chaque élément de l'itérable est ajouté à la liste.

Il existe une autre différence entre .append()et .extend().

Lorsque vous souhaitez ajouter une chaîne, comme vu précédemment, .append()ajoutez l'élément entier et unique à la fin de la liste :

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#add the name Dylan to the end of the list
names.append("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'Dylan']

Si vous aviez .extend()plutôt l' habitude d'ajouter une chaîne à la fin d'une liste, chaque caractère de la chaîne serait ajouté en tant qu'élément individuel à la liste.

C'est parce que les chaînes sont un itérable et .extend()qu'elles itèrent sur l'argument itérable qui lui est transmis.

Ainsi, l'exemple ci-dessus ressemblerait à ceci :

names = ["Jimmy", "Timmy", "Kenny", "Lenny"]

#pass a string(iterable) to .extend()
names.extend("Dylan")

print(names)

#output
#['Jimmy', 'Timmy', 'Kenny', 'Lenny', 'D', 'y', 'l', 'a', 'n']

Conclusion

En résumé, la .append()méthode est utilisée pour ajouter un élément à la fin d'une liste existante, sans créer de nouvelle liste.

Lorsqu'il est utilisé pour ajouter une liste à une autre liste, il crée une liste dans une liste.

Si vous souhaitez en savoir plus sur Python, consultez la certification Python de freeCodeCamp . Vous commencerez à apprendre de manière interactive et conviviale pour les débutants. Vous construirez également cinq projets à la fin pour mettre en pratique ce que vous avez appris.

Merci d'avoir lu et bon codage!

Link: https://www.freecodecamp.org/news/append-in-python-how-to-append-to-a-list-or-an-array/

#python 

A Python Binding to The Tokenizer Ucto

Ucto for Python

This is a Python binding to the tokeniser Ucto. Tokenisation is one of the first step in almost any Natural Language Processing task, yet it is not always as trivial a task as it appears to be. This binding makes the power of the ucto tokeniser available to Python. Ucto itself is a regular-expression based, extensible, and advanced tokeniser written in C++ (https://languagemachines.github.io/ucto).

Installation

Easy

• On Arch Linux, use the python-ucto-git <https://aur.archlinux.org/packages/python-ucto-git/>_ package from the Arch User Repository (AUR).
• In all other cases, for easy installation of both python-ucto as well as ucto itself, please use our LaMachine distribution (https://proycon.github.io/LaMachine)

Manual (Advanced)

• Make sure to first install ucto itself (https://languagemachines.github.io/ucto) and all its dependencies.
• Install Cython if not yet available on your system: $ sudo apt-get cython cython3 (Debian/Ubuntu, may differ for others)
• Clone this repository and run: $ sudo python setup.py install (Make sure to use the desired version of python)

Advanced note: If the ucto libraries and includes are installed in a non-standard location, you can set environment variables INCLUDE_DIRS and LIBRARY_DIRS to point to them prior to invocation of setup.py install.

Usage

Import and instantiate the Tokenizer class with a configuration file.

import ucto
configurationfile = "tokconfig-eng"
tokenizer = ucto.Tokenizer(configurationfile)

The configuration files supplied with ucto are named tokconfig-xxx where xxx corresponds to a three letter iso-639-3 language code. There is also a tokconfig-generic one that has no language-specific rules. Alternatively, you can make and supply your own configuration file. Note that for older versions of ucto you may need to provide the absolute path, but the latest versions will find the configurations supplied with ucto automatically. See here for a list of available configuration in the latest version.

The constructor for the Tokenizer class takes the following keyword arguments:

• lowercase (defaults to False) -- Lowercase all text
• uppercase (defaults to False) -- Uppercase all text
• sentenceperlineinput (defaults to False) -- Set this to True if each sentence in your input is on one line already and you do not require further sentence boundary detection from ucto.
• sentenceperlineoutput (defaults to False) -- Set this if you want each sentence to be outputted on one line. Has not much effect within the context of Python.
• paragraphdetection (defaults to True) -- Do paragraph detection. Paragraphs are simply delimited by an empty line.
• quotedetection (defaults to False) -- Set this if you want to enable the experimental quote detection, to detect quoted text (enclosed within some sort of single/double quote)
• debug (defaults to False) -- Enable verbose debug output

Text is passed to the tokeniser using the process() method, this method returns the number of tokens rather than the tokens itself. It may be called multiple times in sequence. The tokens themselves will be buffered in the Tokenizer instance and can be obtained by iterating over it, after which the buffer will be cleared:

#pass the text (a str) (may be called multiple times),
tokenizer.process(text)

#read the tokenised data
for token in tokenizer:
    #token is an instance of ucto.Token, serialise to string using str()
    print(str(token))

    #tokens remember whether they are followed by a space
    if token.isendofsentence():
        print()
    elif not token.nospace():
        print(" ",end="")

The process() method takes a single string (str), as parameter. The string may contain newlines, and newlines are not necessary sentence bounds unless you instantiated the tokenizer with sentenceperlineinput=True.

Each token is an instance of ucto.Token. It can be serialised to string using str() as shown in the example above.

The following methods are available on ucto.Token instances: * isendofsentence() -- Returns a boolean indicating whether this is the last token of a sentence. * nospace() -- Returns a boolean, if True there is no space following this token in the original input text. * isnewparagraph() -- Returns True if this token is the start of a new paragraph. * isbeginofquote() * isendofquote() * tokentype -- This is an attribute, not a method. It contains the type or class of the token (e.g. a string like WORD, ABBREVIATION, PUNCTUATION, URL, EMAIL, SMILEY, etc..)

In addition to the low-level process() method, the tokenizer can also read an input file and produce an output file, in the same fashion as ucto itself does when invoked from the command line. This is achieved using the tokenize(inputfilename, outputfilename) method:

tokenizer.tokenize("input.txt","output.txt")

Input and output files may be either plain text, or in the FoLiA XML format. Upon instantiation of the Tokenizer class, there are two keyword arguments to indicate this:

• xmlinput or foliainput -- A boolean that indicates whether the input is FoLiA XML (True) or plain text (False). Defaults to False.
• xmloutput or foliaoutput -- A boolean that indicates whether the input is FoLiA XML (True) or plain text (False). Defaults to False. If this option is enabled, you can set an additional keyword parameter docid (string) to set the document ID.

An example for plain text input and FoLiA output:

tokenizer = ucto.Tokenizer(configurationfile, foliaoutput=True)
tokenizer.tokenize("input.txt", "ucto_output.folia.xml")

FoLiA documents retain all the information ucto can output, unlike the plain text representation. These documents can be read and manipulated from Python using the FoLiaPy library. FoLiA is especially recommended if you intend to further enrich the document with linguistic annotation. A small example of reading ucto's FoLiA output using this library follows, but consult the documentation for more:

import folia.main as folia
doc = folia.Document(file="ucto_output.folia.xml")
for paragraph in doc.paragraphs():
    for sentence in paragraph.sentence():
        for word in sentence.words()
            print(word.text(), end="")
            if word.space:
                print(" ", end="")
        print()
    print()

Test and Example

Run and inspect example.py

Download Details:
Author: proycon
Source Code: https://github.com/proycon/python-ucto
License: 

#python 

What is PaaS? Platform as a Service Definition

PaaS Service Delivery Model | Types of PaaS | Platform as a Service

Cloud computing is a domain that is being integrated with every other domain in the world of IT. Individuals to multinational corporations worths trillions of dollars are looking towards using a lot of cloud computing going forward. Now, this is only possible because of the various service models that are available. Like IaaS, PaaS and SaaS. This gives the developers unparalleled customization options to build and deploy applications faster and better. Keeping this in mind, we have come up with this video where we will take a look at PaaS in depth.

• 00:00:00 Introduction 
• 00:02:00 Agenda
• 00:04:00 What is Cloud Computing
• 00:10:36 How does it work: Cloud Computing
• 00:17:08 Types of Cloud Deployment
• 00:33:15 Cloud Computing Services
• 00:49:15 Deep Dive into PaaS
• 00:56:02 Advantages
• 00:57:49 Disadvantages
• 01:00:52 Types of PaaS
• 01:08:12 Top providers of PaaS
• 01:16:18 Summary

#cloud #cloudcomputing #pass