Sequências F#
Neste artigo, examinaremos mais de perto as sequências do F# e como elas podem ser usadas com exemplos.
F# Sequences é uma abstração de dados sobre uma coleção e permite avaliação e composição de dados eficientes e preguiçosas, permitindo fornecer acesso rápido e eficiente aos dados.
Índice-
Criando Sequências F#
Essa sintaxe é usada para definir sequências da seguinte maneira:
seq { expr }
For example,
let seq1 = seq { 1 .. 8 }
As sequências também podem ser criadas usando intervalos e compreensões, semelhantes às listas.
Uma expressão de sequência é uma expressão que você pode usar para criar sequências a partir dos dados de entrada.
Você pode fazer estas coisas:
- Isso pode ser feito especificando um intervalo de valores.
- Isso pode ser feito especificando um intervalo junto com incrementos ou decrementos.
- Isso é feito usando uma palavra-chave chamada yield para produzir valores que farão parte de uma sequência após serem executados.
- Você pode fazer isso usando o operador ' → '.
Exemplo Básico de Sequências F#
Aqui está o exemplo simples para entender o conceito de sequência:
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//Sequences
let seq1 = seq { 1 .. 8 }
//ascending order and increment
printfn "The Sequence: %A" seq1
let seq2 = seq { 1 .. 2 .. 20 }
//descending order and decrement
printfn "The Sequence: %A" seq2
let seq3 = seq {20 .. -2 .. 0}
printfn "The Sequence: %A" seq3
//using yield
let seq4 = seq { for a in 1 .. 8 do yield a, a*a, a*a*a }
printfn "The Sequence: %A" seq4
E a saída será:
The Sequence: seq [1; 2; 3; 4; ...] The Sequence: seq [1; 3; 5; 7; ...] The Sequence: seq [20; 18; 16; 14; ...] The Sequence: seq [(1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64); ...]
Verificador de números primos
Para verificar se os números são primos ou não na sequência:
Example:
1
O programa acima resulta da seguinte forma:
1 2 3 5 7 11 13 17 19
Operações de Sequência F#
Aqui está uma tabela mostrando as operações básicas que podem ser executadas em um tipo de dados de sequência:
| Valor | Visão geral |
| anexar: seq<'T> → seq<'T> → seq<'T> | A função retorna uma nova sequência contendo os elementos da primeira sequência seguidos pelos elementos da segunda sequência no final. |
| média: seq<^T> → ^T | O elemento médio na sequência de elementos é retornado como resultado dessa função. |
| mediaBy : ('T → ^U) → seq<'T> → ^U | Aplicando a função a cada elemento da sequência e tirando a média de ambos os elementos, retornará a média dos elementos gerados. |
| cache: seq<'T> → seq<'T> | Este método retorna uma sequência de sequências que correspondem a uma versão em cache da sequência de entrada que foi inserida. |
| cast: IEnumerable → seq<'T> | Fornece uma maneira de encapsular sistemas de tipo flexível. A sequência de coleções é digitada como uma sequência de coleções. |
| escolha: (opção 'T → 'U) → seq<'T> → seq<'U> | A função fornecida será aplicada a todos os elementos da sequência, um por um. Esta função retornará uma sequência do resultado de cada elemento para cada elemento onde a função retorna Some como resultado. |
| coletar : ('T → 'Coleção) → seq<'T> → seq<'U> | Esta função será aplicada a cada elemento da sequência, um de cada vez. Retorna a sequência combinada de todos os resultados após concatenar todos eles. |
| compareWith : ('T → 'T → int) → seq<'T> → seq<'T> → int | A função compara duas sequências, elemento por elemento, usando a função de comparação fornecida. |
| concat : seq<'Coleção> → seq<'T> | Uma nova sequência será retornada que conterá os elementos de todas as sequências, ordenadas alfabeticamente. |
| countBy : ('T → 'Chave) → seq<'T> → seq<'Chave * int> | Essa função gera chaves exclusivas para cada elemento de uma sequência e retorna o número de instâncias dessas chaves na sequência original. |
| atraso : (unidade → seq<'T>) → seq<'T> | Retorna uma sequência que é criada a partir de uma especificação de sequência que foi atrasada e a configuração que foi dada. |
| distinto : seq<'T> → seq<'T> | Nesse método, as entradas são hash e a igualdade das entradas é comparada para determinar se são duplicatas. As últimas ocorrências de um elemento são descartadas se o elemento ocorrer mais de uma vez na sequência. |
| distintaBy : ('T → 'Chave) → seq<'T> → seq<'T> | Com base na comparação geral de hashing e igualdade das chaves retornadas pela função de geração de chaves, essa função retorna uma sequência de entradas que não contém nenhuma entrada duplicada. Quando o mesmo elemento ocorre em uma sequência várias vezes, a ocorrência posterior do elemento é descartada. |
| vazio: seq<'T> | A função retorna uma sequência vazia com o tipo fornecido como seu valor. |
| exactamenteUm : seq<'T> → 'T | A sequência vazia é criada como resultado desta função. |
| existe : ('T → bool) → seq<'T> → bool | A função verifica se algum elemento da sequência atende ao predicado fornecido, verificando se ele está presente. |
| existe2 : ('T1 → 'T2 → bool) → seq<'T1> → seq<'T2> → bool | Nesta função, é testado para ver se um par de elementos correspondentes nas sequências é satisfeito pelo predicado dado. |
| filtro: ('T → bool) → seq<'T> → seq<'T> | Nesta função, é retornada uma nova coleção que contém apenas os elementos da coleção original para os quais o predicado fornecido corresponde a true. |
| find : ('T → bool) → seq<'T> → 'T | Ele retorna o elemento que é o primeiro elemento a retornar verdadeiro quando a função fornecida é usada. |
| findIndex : ('T → bool) → seq<'T> → int | Um predicado que é satisfeito pelo primeiro elemento na sequência é retornado. |
| fold : ('Estado → 'T → 'Estado) → 'Estado → seq<'T> → 'Estado | Essa função encadeia um argumento de acumulador por meio de cada elemento da coleção. Aplica a função ao segundo argumento e ao primeiro elemento da sequência. Este resultado será então passado pelo programa junto com o segundo elemento, e o processo continuará desta forma. Em seguida, retorna o resultado final. Uma função f é dada, e os elementos são i0…iN, então esta função calcula f (… (fs i0) i1 …) iN. |
| forall : ('T → bool) → seq<'T> → bool | Esta função é usada para determinar se todos os elementos da sequência atendem ou não ao predicado fornecido. |
| forall2 : ('T1 → 'T2 → bool) → seq<'T1> → seq<'T2> → bool | O objetivo do teste é verificar se todos os pares de elementos extraídos de qualquer uma das sequências satisfazem o predicado fornecido. Os elementos restantes da sequência serão ignorados se um dos comprimentos da sequência for menor que o outro. |
| groupBy : ('T → 'Key) → seq<'T> → seq<'Key * seq<'T>> | Cada elemento de uma sequência é aplicado a uma função de geração de chaves, que produz uma sequência de chaves exclusivas com base nos elementos dessa sequência. Além de uma chave única, existe também uma sequência contendo todos os elementos que correspondem à chave única para torná-la única. |
| cabeça: seq<'T> → 'T | É usado para retornar o primeiro elemento de uma sequência. |
| init : int → (int → 'T) → seq<'T> | A função cria uma sequência usando o gerador fornecido como um índice em cada item da sequência. |
| initInfinite : (int → 'T) → seq<'T> | A função retorna elementos sucessivos quando iterados, com base na sequência recém-criada. Uma chamada para a função não salva seus resultados, o que significa que a função terá que ser aplicada novamente para regenerar os elementos no futuro. Usando o índice, a função pode gerar um item. |
| isEmpty : seq<'T> → bool | Este método retorna true se a sequência não contiver nenhum elemento e false se contiver. |
| iter : ('T → unidade) → seq<'T> → unidade | Cada elemento na sequência será aplicado com a função fornecida. |
| iter2 : ('T1 → 'T2 → unidade) → seq<'T1> → seq<'T2> → unidade | A função dada é aplicada simultaneamente a duas sequências. Deve haver um tamanho idêntico entre as duas sequências. |
| iteri : (int → 'T → unidade) → seq<'T> → unidade | Cada elemento na sequência é aplicado à função dada. Inteiros passados para a função indicam índices de elementos. |
| último : seq<'T> → 'T | O último elemento da sequência é retornado quando esta função é chamada. |
| comprimento: seq<'T> → int | O comprimento da sequência é retornado por esta função. |
| mapa: ('T → 'U) → seq<'T> → seq<'U> | Nesse método, os elementos de uma coleção são os resultados da aplicação de uma determinada função a cada elemento de uma coleção e o resultado é retornado como os elementos de uma nova coleção. |
| map2 : ('T1 → 'T2 → 'U) → seq<'T1> → seq<'T2> → seq<'U> | Nesse método, uma nova coleção é criada cujos elementos correspondem aos respectivos elementos dos dois conjuntos de coleções se a função fornecida for aplicada aos pares aos elementos correspondentes dos dois conjuntos. |
| mapi : (int → 'T → 'U) → seq<'T> → seq<'U> | Aplicar uma determinada função a cada elemento da coleção cria uma nova coleção cujos elementos são os resultados do aplicativo. Este índice inteiro representa o índice do elemento (de 0) quando passado para a função. |
| max : seq<'T> → 'T | Ao usar Operators.max, essa função retorna o maior valor entre todos os elementos da sequência. |
| maxBy : ('T → 'U) → seq<'T> → 'T | A função retorna o maior elemento da sequência entre todos os elementos da sequência, comparando o resultado da função com seu método Operators.max. |
| min: seq<'T> → 'T | Essa função retorna o elemento mais baixo em uma sequência, comparado usando Operators.min como método de comparação. |
| minBy : ('T → 'U) → seq<'T> → 'T | Usando Operators.min no resultado da função, esta função retorna o menor elemento dentro de todos os elementos da sequência. |
| nth : int → seq<'T> → 'T | O índice de cada item na sequência. 0 é o índice do primeiro elemento na sequência. |
| ofArray : 'T array → seq<'T> | Fornece uma exibição de sequência da matriz fornecida. |
| ofList : 'Lista T → seq<'T> | Fornece uma exibição de sequência da lista fornecida. |
| pairwise : seq<'T> → seq<'T * 'T> | Essa função retorna uma sequência que contém o número de elementos na sequência de entrada junto com o número dos predecessores dos elementos, exceto que o primeiro elemento é retornado apenas como o predecessor do segundo elemento na sequência. |
| pick : (opção 'T → 'U) → seq<'T> → 'U | Esta função é aplicada a elementos sucessivos, retornando o primeiro valor retornado pela função onde um valor de Some é retornado pela função. |
| somente leitura : seq<'T> → seq<'T> | Nesse método, o objeto de sequência é criado a partir do objeto de sequência fornecido e delegado a ele. O objetivo do typecasting é evitar que a sequência original seja descoberta e mutada novamente por um typecast. Por exemplo, se você receber uma matriz de elementos para produzir uma sequência, receberá os elementos da matriz, mas não poderá converter o objeto de sequência de volta em uma matriz de elementos. |
| reduzir : ('T → 'T → 'T) → seq<'T> → 'T | Cada elemento da sequência é aplicado com uma função e um argumento acumulador é inserido no cálculo para gerar a saída. Os dois primeiros elementos devem ser aplicados com a função no início. Você então precisa alimentar este resultado junto com o terceiro elemento na função e assim por diante. O resultado final deve ser devolvido. |
| scan : ('Estado → 'T → 'Estado) → 'Estado → seq<'T> → seq<'Estado> | Este método é semelhante ao Seq.fold, porém calcula sob demanda e retorna a sequência de resultados intermediários e finais como resultado. |
| singleton : 'T → seq<'T> | Este método retorna uma sequência com apenas um item nela. |
| skip : int → seq<'T> → seq<'T> | Durante a geração da sequência retornada, o usuário pode especificar o número de elementos que devem ser ignorados da sequência subjacente, seguido por um rendimento dos elementos restantes da sequência. |
| skipWhile : ('T → bool) → seq<'T> → seq<'T> | Se o predicado fornecido retornar true, será retornada uma sequência que pula os elementos da sequência subjacente para produzir os elementos restantes enquanto o predicado fornecido retorna true. |
| sort : seq<'T> → seq<'T> | Ao usar Operators.compare, essa função classifica a sequência fornecida a ela. |
| sortBy : ('T → 'Chave) → seq<'T> → seq<'T> | A sequência fornecida é classificada usando as chaves fornecidas pela projeção fornecida na entrada. Usando o método Operators.compare, as chaves são comparadas entre si. |
| soma: seq<^T> → ^T | Esta função soma todos os elementos e retorna um número inteiro. |
| somaPor | A função retorna uma soma dos resultados gerados aplicando a função a cada elemento de uma sequência para gerar os resultados. |
| pegue: int → seq<'T> → seq<'T> | A função retorna o primeiro elemento em uma sequência até que uma certa contagem tenha sido especificada. |
| takeWhile : ('T → bool) → seq<'T> → seq<'T> | Uma sequência nesta função retorna elementos da sequência subjacente quando iterada um certo número de vezes enquanto retorna verdadeiro se o predicado fornecido for verdadeiro e nenhum outro elemento quando o predicado fornecido for falso. |
| toArray : seq<'T> → 'T[] | A partir de uma coleção de itens, esta função cria um array. |
| toList : seq<'T> → 'Lista T | A partir de uma determinada coleção, esta função criará uma lista. |
| truncate : int → seq<'T> → seq<'T> | Quando enumerada, esta função fornece uma sequência com um número máximo de elementos para retornar quando for enumerada. |
| tryFind : ('T → bool) → seq<'T> → 'T opção | Esta função retorna o primeiro elemento, ou None se tal elemento não existir, que é retornado pela função dada. |
| tryFindIndex : ('T → bool) → seq<'T> → opção int | O índice é retornado se o predicado fornecido for satisfeito no início da sequência, caso contrário, se o predicado não for satisfeito no início da sequência, None será retornado. |
| tryPick : ('T → 'U opção) → seq<'T> → 'U opção | Esta função é aplicada a elementos sucessivos, retornando o primeiro valor retornado pela função onde um valor de some é retornado pela função. |
| desdobrar : ('Estado → 'T * 'Opção de estado) → 'Estado → seq<'T> | Este método retorna uma sequência contendo os elementos que seriam gerados pela computação fornecida , se for fornecida. |
| onde : ('T → bool) → seq<'T> → seq<'T> | Para retornar uma nova coleção, você deve especificar um predicado que retorne true para todos os elementos encontrados na coleção anterior. Seq.filter é um sinônimo. |
| janelado: int → seq<'T> → seq<'T []> | A função retorna uma sequência que produz janelas deslizantes de elementos que contêm elementos extraídos da entrada da sequência. Há uma nova matriz retornada para cada janela. |
| zip : seq<'T1> → seq<'T2> → seq<'T1 * 'T2> | Uma lista de pares é formada pela combinação de duas sequências. Se uma sequência esgotou todos os elementos, a outra sequência é ignorada e nenhum outro elemento é adicionado à outra sequência. Isso ocorre apesar das duas sequências não terem comprimentos iguais. |
| zip3 : seq<'T1> → seq<'T2> → seq<'T3> → seq<'T1 * 'T2 * 'T3> | Uma lista de triplos é formada pela combinação de três sequências. Se uma sequência esgotou todos os elementos, a outra sequência é ignorada e nenhum outro elemento é adicionado à outra sequência. Isso ocorre apesar das três sequências não terem comprimentos iguais. |
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//Creating sequences
let emptySeq = Seq.empty
let seq1 = Seq.singleton 12
printfn"The singleton sequence:"
printfn "%A " seq1
printfn"The init sequence:"
let seq2 = Seq.init 8 (fun n -> n * 2)
Seq.iter (fun i -> printf "%d " i) seq2
printfn""
//converting an array to sequence by using cast
printfn"The array sequence 1:"
let seq3 = [| 1 .. 8 |] :> seq<int>
Seq.iter (fun i -> printf "%d " i) seq3
printfn""
//converting an array to sequence by using Seq.ofArray
printfn"The array sequence 2:"
let seq4 = [| 1..2.. 20 |] |> Seq.ofArray
Seq.iter (fun i -> printf "%d " i) seq4
printfn""
A saída do exemplo acima é a seguinte:
The singleton sequence:seq [12] The init sequence: 0 2 4 6 8 10 12 14 The array sequence 1: 1 2 3 4 5 6 7 8 The array sequence 2: 1 3 5 7 9 11 13 15 17 19
Os seguintes pontos precisam ser observados:
- O método Seq.empty cria uma sequência vazia quando é chamado.
- No método Seq.singleton , apenas um elemento de uma sequência é criado especificando seu nome.
- O método Seq.init cria uma sequência de elementos dentro da qual uma função é passada para criar os elementos.
- Os métodos Seq.ofArray e Seq.ofList<'T> são usados para criar sequências a partir de arrays e listas de elementos.
- No método Seq.iter , você pode iterar por meio de uma sequência iterando por meio dela.
Cálculo de Soma e Média
Calculando a soma e a média de todos os elementos em sequência:
Example:
1
2
3
4
5
6
7
8
9
10
11
let num1 = seq { 2.0..2.0..20.0}
let num2 = seq { 2..2.. 20}
let sum = Seq.sum num2
let avg = Seq.average num1
printfn "Sum: %d" sum
printfn "Average: %f" avg
F# Sequence Seq.unfold
Usando o método Seq.unfold , você pode criar uma sequência a partir de um estado transformável para que cada elemento na sequência possa ser criado usando esse estado.
Isso é feito transformando o estado antes de prosseguir com a computação.
Aqui estão os primeiros 30 números naturais produzidos pelo método Seq.unfold:
Example:
1
2
3
4
5
6
7
let seq1 = Seq.unfold (fun state -> if (state > 30) then None else Some(state, state + 1)) 0
printfn "The sequence of natural numbers from 0 to 30. \n"
for x in seq1 do printf "%d, " x
printfn" "
E o resultado do exemplo acima é:
The sequence seq1 contains numbers from 0 to 30. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
Conversão de matriz para sequência e classificação
Abaixo está um exemplo de criação de uma matriz e, em seguida, convertendo-a em uma sequência, bem como classificando a sequência.
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
let numbers = [| 5; 1; 4; 2; 3 |]
let sequence = Seq.ofArray numbers
let sortedNumbers = Seq.sort sequence
printfn "Original sequence: %A" numbers
printfn "Sorted sequence: %A" sortedNumbers
The output of the above example is as follows:
Original sequence: [|5; 1; 4; 2; 3|]
Sorted sequence: seq [1; 2; 3; 4; …]
Seq.truncate & Seq.take
Esse método, Seq.truncate , cria uma nova sequência a partir de outra sequência, mas restringe o próximo elemento na nova sequência a um número especificado.
Com o método Seq.take , é criada uma nova sequência que começa precisamente com um número especificado de elementos e os contém a partir do início da sequência.
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
let sequence = seq { for i in 1 .. 10 -> 2*i }
let truncate = Seq.truncate 5 sequence
let take = Seq.take 4 sequence
printfn"The original: "
Seq.iter (fun i -> printf "%d " i) sequence
printfn""
printfn"The truncated: "
Seq.iter (fun i -> printf "%d " i) truncate
printfn""
printfn"The take: "
Seq.iter (fun i -> printf "%d " i) take
printfn""
A saída será:
The original: 2 4 6 8 10 12 14 16 18 20 The truncated: 2 4 6 8 10 The take: 2 4 6 8
Exemplo de Explicação
O exemplo acima demonstra o uso das funções Seq.truncate e Seq.take em F# para obter subsequências de uma sequência.
Primeiro, definimos uma sequência usando uma expressão de sequência que gera os valores 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 .
Em seguida, usamos Seq.truncate para truncar a sequência para os 5 primeiros elementos e armazenar o resultado em truncate. Também usamos Seq.take para pegar os 4 primeiros elementos da sequência e armazenar o resultado.
Finalmente, usamos Seq.iter para imprimir a sequência original e as duas subsequências. A função Seq.iter aplica uma função a cada elemento de uma sequência e, neste caso, a usamos para imprimir os elementos da sequência.
Observe que Seq.truncate retorna uma nova sequência com o número especificado de elementos desde o início da sequência original. Se a sequência original tiver menos elementos do que o número especificado, a sequência inteira será retornada.
Da mesma forma, Seq.take retorna uma nova sequência com o número especificado de elementos desde o início da sequência original. Se a sequência original tiver menos elementos do que o número especificado, apenas os elementos disponíveis serão retornados.
Nós valorizamos o seu feedback.
+1
+1
+1
+1
+1
+1
+1
