Преобразование значений столбцов в строки в Pandas

В этой статье вы узнаете, как преобразовать значения столбцов в строки в Pandas.

Pandas DataFrame — это не что иное, как двумерная структура данных или двумерный массив, который представляет данные в строках и столбцах. Другими словами, его сравнивают с прямоугольными сетками, используемыми для хранения данных. Он с открытым исходным кодом, мощный, быстрый и простой в использовании. По сути, при работе с большими данными нам нужно их анализировать, манипулировать и обновлять, и библиотека панд играет в этом ведущую роль. Мы можем проверить тип столбца Pandas с помощью df.dtypes. По сути, значения столбца состоят из объекта, целого числа и т. д. Но мы можем преобразовать их в строки. Существует несколько способов выполнения этого действия. Такие как- df.astype(),castingи т. д. В этой статье мы рассмотрим их и посмотрим, как мы можем преобразовать значения столбцов в строки в Pandas. Давайте создадим простой Pandas DataFrame и сначала проверим его тип в следующем разделе:

import pandas as pd

student_df = pd.DataFrame({'Name' : ['Alex', 'Rohit', 'Cole', 'Deven', 'John'],
                           'Marks' : [72, 83, 68, 90, 88]
                          })

print(student_df)
print(student_df.dtypes)

# Output:
#     Name  Marks
# 0   Alex     72
# 1  Rohit     83
# 2   Cole     68
# 3  Deven     90
# 4   John     88

# Name     object
# Marks     int64
# dtype: object

Здесь вы можете видеть, что мы создали простой Pandas DataFrame, который представляет имя и оценки учащегося. Тип этого столбца DataFrame — objectи int64. Мы преобразуем их в строки.

Пример первый: преобразовать значения столбца в строки, используяastype

import pandas as pd

student_df = pd.DataFrame({'Name' : ['Alex', 'Rohit', 'Cole', 'Deven', 'John'],
                           'Marks' : [72, 83, 68, 90, 88]
                          })

student_df['Name'] = student_df['Name'].astype('string')
student_df['Marks'] = student_df['Marks'].astype('string')
print(student_df.dtypes)

# Output:
# Name     string
# Marks    string
# dtype: object

Тип данных значений столбца был изменен на stringиз objectи из int64-за использования этого метода.

Пример второй: преобразовать значения столбцов в строки с помощьюcasting

import pandas as pd

student_df = pd.DataFrame({'Name' : ['Alex', 'Rohit', 'Cole', 'Deven', 'John'],
                           'Marks' : [72, 83, 68, 90, 88]
                          })

casted_df = student_df.astype({'Name':'string', 'Marks':'int32'})
print(casted_df.dtypes)
# Output:
# Name     string
# Marks     int32
# dtype: object

Тип столбцов был objectи in64. Мы используем приведение, чтобы изменить его типы, и в выводе вы можете увидеть, что тип данных stringи int32сейчас. Это подходы, которые вы можете использовать для преобразования значений столбцов в строки в Pandas.

Оригинальный источник статьи по адресу: https://codesource.io/

#python #pandas #strings #values 

将列值转换为 Pandas 中的字符串

在本文中，您将学习如何在 Pandas 中将列值转换为字符串。

Pandas DataFrame 只是一个二维数据结构或二维数组，以行和列的形式表示数据。换句话说，它与用于存储数据的矩形网格相比。它是开源的，功能强大，快速且易于使用。基本上，在处理大数据时，我们需要分析、操作和更新它们，而 pandas 的图书馆在这方面起着主导作用。我们可以在 的帮助下检查 Pandas 列的类型df.dtypes。基本上，列值由对象、整数等组成。但我们可以将它们转换为字符串。有几种方法可以执行此操作。比如df.astype()- ,casting等。在本文中，我们将探索它们并了解如何在 Pandas 中将列值转换为字符串。让我们创建一个简单的 Pandas DataFrame 并在下面的部分首先检查它的类型：

import pandas as pd

student_df = pd.DataFrame({'Name' : ['Alex', 'Rohit', 'Cole', 'Deven', 'John'],
                           'Marks' : [72, 83, 68, 90, 88]
                          })

print(student_df)
print(student_df.dtypes)

# Output:
#     Name  Marks
# 0   Alex     72
# 1  Rohit     83
# 2   Cole     68
# 3  Deven     90
# 4   John     88

# Name     object
# Marks     int64
# dtype: object

在这里，您可以看到我们创建了一个简单的 Pandas DataFrame 来表示学生的姓名和分数。这个 DataFrame 列的类型是objectand int64。我们将把它们转换成字符串。

示例一：使用将列值转换为字符串astype

import pandas as pd

student_df = pd.DataFrame({'Name' : ['Alex', 'Rohit', 'Cole', 'Deven', 'John'],
                           'Marks' : [72, 83, 68, 90, 88]
                          })

student_df['Name'] = student_df['Name'].astype('string')
student_df['Marks'] = student_df['Marks'].astype('string')
print(student_df.dtypes)

# Output:
# Name     string
# Marks    string
# dtype: object

由于使用此方法，列值的数据类型已从和更改string为。objectint64

示例二：使用将列值转换为字符串casting

import pandas as pd

student_df = pd.DataFrame({'Name' : ['Alex', 'Rohit', 'Cole', 'Deven', 'John'],
                           'Marks' : [72, 83, 68, 90, 88]
                          })

casted_df = student_df.astype({'Name':'string', 'Marks':'int32'})
print(casted_df.dtypes)
# Output:
# Name     string
# Marks     int32
# dtype: object

列的类型是object和in64。我们使用转换来更改其类型，在输出中，您可以看到数据类型是string现在int32。这些是您可以遵循的将列值转换为 Pandas 中的字符串的方法。

文章原文出处：https: //codesource.io/

#python #pandas #strings #values 

Convert Column Values to Strings in Pandas

In this article, you will learn how to convert column values to strings in Pandas.

A Pandas DataFrame is nothing but a two-dimensional data structure or two-dimensional array that represents the data in rows and columns. In other words, it is compared to rectangular grids used to store data. It is open-source and potent, fast, and easy to use. Basically, while working with big data we need to analyze, manipulate and update them and the pandas’ library plays a lead role there. We can check the type of Pandas column with the help of df.dtypes. Basically, the column values are consists of Object, Integer, etc. But we can convert them to strings. There are several ways of performing this action. Such as- df.astype(), casting, etc. In this article, we will explore them and see how we can convert column values to strings in Pandas. Let’s create a simple Pandas DataFrame and check its type first in the below section:

import pandas as pd

student_df = pd.DataFrame({'Name' : ['Alex', 'Rohit', 'Cole', 'Deven', 'John'],
                           'Marks' : [72, 83, 68, 90, 88]
                          })

print(student_df)
print(student_df.dtypes)

# Output:
#     Name  Marks
# 0   Alex     72
# 1  Rohit     83
# 2   Cole     68
# 3  Deven     90
# 4   John     88

# Name     object
# Marks     int64
# dtype: object

Here, you can see that we have created a simple Pandas DataFrame that represents the student’s name and marks. The type of this DataFrame column is object and int64. We will convert them into strings.

Example One: convert column values to strings using astype

import pandas as pd

student_df = pd.DataFrame({'Name' : ['Alex', 'Rohit', 'Cole', 'Deven', 'John'],
                           'Marks' : [72, 83, 68, 90, 88]
                          })

student_df['Name'] = student_df['Name'].astype('string')
student_df['Marks'] = student_df['Marks'].astype('string')
print(student_df.dtypes)

# Output:
# Name     string
# Marks    string
# dtype: object

The data type of the column values has been changed to string from the object and int64 because of using this method.

Example Two: convert column values to strings using casting

import pandas as pd

student_df = pd.DataFrame({'Name' : ['Alex', 'Rohit', 'Cole', 'Deven', 'John'],
                           'Marks' : [72, 83, 68, 90, 88]
                          })

casted_df = student_df.astype({'Name':'string', 'Marks':'int32'})
print(casted_df.dtypes)
# Output:
# Name     string
# Marks     int32
# dtype: object

The type of the columns was object and in64. We use casting to change its types and in the output, you can see that the data type is string and int32 now. These are the approaches that you may follow to convert column values to strings in Pandas.

Original article source at: https://codesource.io/

#python #pandas #strings #values 

Mustard: A Swift Library for tokenizing Strings When Splitting

Mustard 🌭

Mustard is a Swift library for tokenizing strings when splitting by whitespace doesn't cut it.

Quick start using character sets

Foundation includes the String method components(separatedBy:) that allows us to get substrings divided up by certain characters:

let sentence = "hello 2017 year"
let words = sentence.components(separatedBy: .whitespaces)
// words.count -> 3
// words = ["hello", "2017", "year"]

Mustard provides a similar feature, but with the opposite approach, where instead of matching by separators you can match by one or more character sets, which is useful if separators simply don't exist:

import Mustard

let sentence = "hello2017year"
let words = sentence.components(matchedWith: .letters, .decimalDigits)
// words.count -> 3
// words = ["hello", "2017", "year"]

If you want more than just the substrings, you can use the tokens(matchedWith: CharacterSet...) method which will return an array of TokenType.

As a minimum, TokenType requires properties for text (the substring matched), and range (the range of the substring in the original string). When using CharacterSets as a tokenizer, the more specific type CharacterSetToken is returned, which includes the property set which contains the instance of CharacterSet that was used to create the match.

import Mustard

let tokens = "123Hello world&^45.67".tokens(matchedWith: .decimalDigits, .letters)
// tokens: [CharacterSet.Token]
// tokens.count -> 5 (characters '&', '^', and '.' are ignored)
//
// second token..
// token[1].text -> "Hello"
// token[1].range -> Range<String.Index>(3..<8)
// token[1].set -> CharacterSet.letters
//
// last token..
// tokens[4].text -> "67"
// tokens[4].range -> Range<String.Index>(19..<21)
// tokens[4].set -> CharacterSet.decimalDigits

Advanced matching with custom tokenizers

Mustard can do more than match from character sets. You can create your own tokenizers with more sophisticated matching behavior by implementing the TokenizerType and TokenType protocols.

Here's an example of using DateTokenizer (see example for implementation) that finds substrings that match a MM/dd/yy format.

DateTokenizer returns tokens with the type DateToken. Along with the substring text and range, DateToken includes a Date object corresponding to the date in the substring:

import Mustard

let text = "Serial: #YF 1942-b 12/01/17 (Scanned) 12/03/17 (Arrived) ref: 99/99/99"

let tokens = text.tokens(matchedWith: DateTokenizer())
// tokens: [DateTokenizer.Token]
// tokens.count -> 2
// ('99/99/99' is *not* matched by `DateTokenizer` because it's not a valid date)
//
// first date
// tokens[0].text -> "12/01/17"
// tokens[0].date -> Date(2017-12-01 05:00:00 +0000)
//
// last date
// tokens[1].text -> "12/03/17"
// tokens[1].date -> Date(2017-12-03 05:00:00 +0000)

Documentation & Examples

• Greedy tokens and tokenizer order
• Token types and AnyToken
• TokenizerType: implementing your own tokenizer
• EmojiTokenizer: matching emoji substrings
• LiteralTokenizer: matching specific substrings
• DateTokenizer: tokenizer based on template match
• Alternatives to using Mustard
• Performance comparisons

Roadmap

•  Include detailed examples and documentation
•  Ability to skip/ignore characters within match
•  Include more advanced pattern matching for matching tokens
•  Make project logo 🌭
•  Performance testing / benchmarking against Scanner
•  Include interface for working with Character tokenizers

Requirements

• Swift 4.1

Contributing

Feedback, or contributions for bug fixing or improvements are welcome. Feel free to submit a pull request or open an issue.

Download Details:

Author: Mathewsanders
Source Code: https://github.com/mathewsanders/Mustard 
License: MIT license

#swift #tokenize #sub #strings 

How to Use Grep for Multiple Patterns Or Strings

The users of the Linux operating system can use grep to investigate the various patterns or strings in a file. The grep method of multiple strings or patterns can be used if the operating system contains files with multiple strings and the user wants to target or reach the specified two or more strings from the file. The strings and real path of the relevant file are typically included in the grep command. The pipe symbol can be used to divide them. Before the pipe “|”, we can add a backslash to create the regular expressions. To ignore the cases while doing search operations, the users can use the “-i” option when launching the grep program.

Utilization of “Grep” in Multiple Strings and Patterns

To utilize this method in the Linux operating system, we create a text file first on the desktop with the “file.txt” name and then save the statement data in the file to search the string in it. We store the data in this text file on the desktop as provided in the following:

After the creation and addition of data in the file, we move into the terminal of the Linux. Then, we add the command of granting access to the desktop since the “file.txt” directory is a desktop. So, we add the “cd Desktop/” command and the command that we assign to it for the grep of searching out our two strings of “bat” and “ball” which are present in the data of our file. We utilize the following provided command:

Linux@linux:~/Desktop$ grep ‘bat\|ball’ file.txt

After adding up the command of grep for multiple strings, we press enter. It displays the string of “bat” and “ball” which are present in the data string with the bold red colored letter as we can see in the following output:

Linux@linux:~$ There are many games but the most loving game in England is played by bat and ball known as cricket.

 Here, we search for two strings. Now, we see the searching of three strings in the “file.txt” data and search for the “hockey”, “world”, and “badminton” strings in the file. We add up the following command into the terminal:

Linux@linux:~/Desktop$ grep ‘hockey\|world\|badminton’ file.txt

 Adding up this command in the terminal and pressing enter display the output with the strings with the red colored font on screen by searching these strings in the data which are present in our granted data of “file.txt”. As we can see in the attached textual output, there are three pattern string lines of data. Only three strings get the red colored as we assigned in the command. It majorly targets that for search but goes through reading all the strings which are present in the file.

Linux@linux:~$ People play hockey also and watch it with keen interest.
The Fifa world cup of 2022 is won by Argentina.
I love to play badminton.

 Now, to have more concepts related to the pattern of strings, we create a new text file of “linux.txt” where we store some statement lines data and utilize the simple “grep –I”. We search the “Linux” and “multiple” string in the file that could perform without any case sensitivity. It might not have any impact on the upper or lower case letter of the string. The command that we implement in the terminal for this string is provided in the following for the “linux.txt” file:

Linux@linux:~/Desktop$ grep –I ‘linux\|multiple’ linux.txt

 When we add this command to a string and run it, it reads the two particular strings from our file which are present in the string and highlight them with red color, showing that it finds those strings from the pattern. The rest of the unwanted strings are displayed just in a simple manner.

Linux@linux:~$ this is a professional blog related to the linux operating system for the topic under discussion of grep for multiple strings.

 To have some concepts related to the patterns in grep with searching of strings, we utilize a few more grep commands. We create another new file with the name “name.txt” as a text file and grant it with some names as a string. The command that we utilize only targets the particularly called strings and ignore the rest of the string even if it does not display it on the output screen. The strings that are shown in the output have a sequential arrangement as they were already present in the text file. As we want to get the “Smith” and “Alex” strings, we write them with the “grep –iw” command. The whole command is provided in the following:

Linux@linux:~/Desktop$ grep –iw  ‘Alex\|Smith’ name.txt

 When we go through the working of this directory, we see that it displays two strings, “Smith” and “Alex”, on the screen.

Linux@linux:~$ Smith
Alex

 Now, we discuss some concepts of the pattern of some strings. If we want to show a half pattern rather than showing the whole string, we utilize the required string pattern only except for using the full string name. Now, we want to read the “Alex” string in full but we want some pattern of the “Smith” string. We utilize its “Smi” rather than the full string name. For this purpose, we  assign the following command in the Linux terminal:

Linux@linux:~/Desktop$ grep ‘Smi\|Alex’ name.txt

 After pressing the enter button, it displays the two string names, “Smith” and “Alex”, on the screen. But the “Smith” string shows a half pattern of “Smi” as the red highlighted color. And “th” is not read to be highlighted as it was not granted in the command, so it makes the pattern of a string.

Linux@linux:~$ Smith
Alex

 To have some relation of pattern along with the error or detection in the string or finding out whether the string or pattern is present in the directory or not, we utilize the grep along with the “-c”. Then, we assign the “Linux” and “abc” with the pattern path as “/home/linux” as our operating system user path location and “*.txt” for the detection of the text file.

Linux@linux:~/Desktop$ grep –c ‘linux\|abc’ /home/Linux/*.txt

 After running the command, it displays the path with “0” in our Linux files. With the text extension, we simply utilize the specific terms. Arithmetic is used to indicate all content. Zero (0) represents no matching data.

/home/Linux/data.txt: 0
/home/Linux/mh.txt: 0

Conclusion

The Linux grep command for multiple patterns or strings is covered in this article. First, we created three files with the names “file.txt”, “linux.txt”, and “name.txt” on our operating system, each of which contains various strings or patterns. Before using the third command on “linux.txt”, the first two commands are used in “the file.txt”. To deal with the numerous strings or patterns included in the “name.txt” file, the fourth and fifth commands are applied.

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

#linux #strings #multiple #pattern 

Guide to Strings in MySQL

Learn how MySQL stores and displays your string variables so that you can have better control over your data.

Strings are one of the most common data types you will use in MySQL. Many users insert and read strings in their databases without thinking too much about them. This article aims to give you a bit of a deep dive into how MySQL stores and displays your string variables so that you can have better control over your data.

You can break strings into two categories: binary and nonbinary. You probably think about nonbinary strings most of the time. Nonbinary strings have character sets and collations. Binary strings, on the other hand, store things such as MP3 files or images. Even if you store a word in a binary string, such as song, it is not stored in the same way as in a nonbinary string.

I will focus on nonbinary strings. All nonbinary strings in MySQL are associated with a character set and a collation. A string's character set controls what characters can be stored in the string, and its collation controls how the strings are ordered when you display them.

Character sets

To view the character sets on your system, run the following command:

SHOW CHARACTER SET;

This command will output four columns of data, including the character set:

• Name
• Brief description
• Default collation
• Maximum size of each character in the character set

MySQL used to default to the latin1 character set, but since version 8.0, the default has been utf8mb4. The default collation is now utf8mb4_0900_ai_ci. The ai indicates that this collation is accent insensitive (á = a), and the ci specifies that it is case insensitive (a = A).

Different character sets store their characters in various-sized chunks of memory. For example, as you can see from the above command, characters stored in utf8mb4 are stored in memory from one to four bytes in size. If you want to see if a string has multibyte characters, you can use the CHAR_LENGTH() and LENGTH() functions. CHAR_LENGTH() displays how many characters a string contains, whereas LENGTH() shows how many bytes a string has, which may or may not be the same as a string's length in characters, depending on the character set. Here is an example:

SET @a = CONVERT('data' USING latin1);

SELECT LENGTH(@a), CHAR_LENGTH(@a);

+------------+-----------------+
| LENGTH(@a) | CHAR_LENGTH(@a) |
+------------+-----------------+
|     4      |       4         |
+------------+-----------------+

This example shows that the latin1 character set stores characters in single-byte units. Other character sets, such as utf16, allow multibyte characters:

SET @b = CONVERT('data' USING utf16);

SELECT LENGTH(@b), CHAR_LENGTH(@b);

+------------+------------------+
| LENGTH(@b) | CHAR_LENGTH(@b)  |
+------------+------------------+
|       8    |        4         |
+------------+------------------+

Collation

A string's collation will determine how the values are displayed when you run a SQL statement with an ORDER BY clause. Your choice of collations is determined by what character set you select. When you ran the command SHOW CHARACTER SET above, you saw the default collations for each character set. You can easily see all the collations available for a particular character set. For example, if you want to see which collations are allowed by the utf8mb4 character set, run:

SHOW COLLATION LIKE 'utf8mb4%';

A collation can be case-insensitive, case-sensitive, or binary. Let's build a simple table, insert a few values into it, and then view the data using different collations to see how the output differs:

CREATE TABLE sample (s CHAR(5));

INSERT INTO sample (s) VALUES
 ('AAAAA'), ('ccccc'),  ('bbbbb'), ('BBBBB'), ('aaaaa'), ('CCCCC');

SELECT * FROM sample;

+-----------+
| s         |
+-----------+
| AAAAA     |
| ccccc     |
| bbbbb     |
| BBBBB     |
| aaaaa     |
| CCCCC     |
+-----------+

With case-insensitive collations, your data is returned in alphabetical order, but there is no guarantee that capitalized words will come before lowercase words, as seen below:

SELECT * FROM sample ORDER BY s COLLATE utf8mb4_turkish_ci;

+-----------+
| s         |
+-----------+
| AAAAA     |
| aaaaa     |
| bbbbb     |
| BBBBB     |
| ccccc     |
| CCCCC     |
+-----------+

On the other hand, when MySQL runs a case-sensitive search, lowercase will come before uppercase for each letter:

SELECT * FROM sample ORDER BY s COLLATE utf8mb4_0900_as_cs;

+-----------+
| s         |
+-----------+
| aaaaa     |
| AAAAA     |
| bbbbb     |
| BBBBB     |
| ccccc     |
| CCCCC     |
+-----------+

And binary collations will return all capitalized words before lowercase words:

SELECT * FROM sample ORDER BY s COLLATE utf8mb4_0900_bin;

+-----------+
| s         |
+-----------+
| AAAAA     |
| BBBBB     |
| CCCCC     |
| aaaaa     |
| bbbbb     |
| ccccc     |
+-----------+

If you want to know which character set and collation a string uses, you can use the aptly named charset and collation functions. A server running MySQL version 8.0 or higher will default to using the utf8mb4 character set and utf8mb4_0900_ai-ci collation:

SELECT charset('data');

+-------------------+
| charset('data')   |
+-------------------+
| utf8mb4           |
+-------------------+

 SELECT collation('data');

+--------------------+
| collation('data')  |
+--------------------+
| utf8mb4_0900_ai_ci |
+--------------------+

You can use the SET NAMES command to change the character set or collation used.

To change from the utf8mb4 character set to utf16, run this command:

SET NAMES 'utf16';

If you would also like to choose a collation other than the default, you can add a COLLATE clause to the SET NAMES command.

For example, say your database stores words in the Spanish language. The default collation for MySQL (utf8mb4_0900_ai_ci) sees ch and ll as two different characters and will sort them as such. But in Spanish, ch and ll are individual letters, so if you want them sorted in the proper order (following c and l, respectively), you need to use a different collation. One option is to use the utf8mb4_spanish2_ci collation.

SET NAMES 'utf8mb4' COLLATE 'utf8mb4_spanish2-ci';

Storing strings

MySQL allows you to choose between several data types for your string values. (Even more so than other popular databases such as PostgreSQL and MongoDB.)

Here is a list of MySQL's binary string data types, their nonbinary equivalents, and their maximum length:

• binary: char (255)
• varbinary: varchar (65,535)
• tinyblob: tinytext (255)
• blob: text (65,535)
• mediumblob: mediumtext (16,777,215)
• longblob: longtext (4,294,967,295)

One important thing to remember is that unlike the varbinary, varchar, text, and blob types, which are stored in variable length fields (that is, using only as much space as needed), MySQL stores binary and char types in fixed length fields. So a value such as char(20) or binary(20) will always take up 20 bytes, even if you store less than 20 characters in them. MySQL pads the values with the ASCII NUL value (0x00) for binary types and spaces for char types.

Another thing to consider when choosing data types is whether you want spaces after the string to be preserved or stripped. When displaying data, MySQL strips whitespace from data stored with the char data type, but not varchar.

CREATE TABLE sample2 (s1 CHAR(10), s2 VARCHAR(10));

INSERT INTO sample2 (s1, s2) VALUES ('cat       ', 'cat       ');

SELECT s1, s2, CHAR_LENGTH(s1), CHAR_LENGTH(s2) FROM sample2;

+---------+---------+-----------------------------------+
| s1      | s2      | CHAR_LENGTH(s1) | CHAR_LENGTH(s2) |
+---------+---------+-----------------------------------+
| cat     | cat     |        3        |       10        |
+---------+---------+-----------------------------------+

Wrap up

Strings are one of the most common data types used in databases, and MySQL remains one of the most popular database systems in use today. I hope that you have learned something new from this article and will be able to use your new knowledge to improve your database skills.

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

#mysql #strings 

How to Use The LastindexOf() Method for Strings & Arrays In JavaScript

JavaScript lastIndexOf() method explained with examples

The JavaScript lastIndexOf() method is a method of JavaScript String and Array prototype objects.

The function is used to return the index (position) of the last occurrence of the given argument.

The index of both JavaScript strings and arrays start from 0, and here are some examples of using the lastIndexOf() method:

// A string
let aString = "Good morning! It's a great morning to learn programming.";
let index = aString.lastIndexOf("morning");

console.log(index); // 27

// An array
let anArray = ["day", "night", "dawn", "day"];
let valueIndex = anArray.lastIndexOf("day");

console.log(valueIndex); // 3

As you can see from the examples above, the lastIndexOf() method is available for string and array type values in JavaScript.

When the value you search for is not found in the string or array, the method will return -1:

let aString = "Nathan Sebhastian";
let index = aString.lastIndexOf("morning");

console.log(index); // -1

let anArray = ["day", "night", "dawn", "day"];
let valueIndex = anArray.lastIndexOf("dusk");

console.log(valueIndex); // -1

The lastIndexOf() method is also case sensitive, so you need to have the letter case in the argument match the actual string.

The above example returns -1 because Nathan is different from nathan:

let aString = "Nathan Sebhastian";
let index = aString.lastIndexOf("nathan");

console.log(index); // -1

The lastIndexOf() method will search your string or array backward.

This means the method will look for matching values from the last element and ends with the first element.

Finally, the method also accepts a second parameter to define the start position of the search.

The following example shows how to start the lastIndexOf() search at index 4:

let aString = "Hello World!";
let index = aString.lastIndexOf("World", 4);

console.log(index); // -1

Because a second argument 4 is passed to the lastIndexOf() method, JavaScript will search the value from index 4 to index 0 only.

While the World string is available inside the aString variable, the index starts at 6. Since it’s outside the search range of the lastIndexOf() method, the value is not found and -1 is returned.

The same rule applies when you search for a value in an array:

let anArray = [8, 3, 4, 8, 2];
let index = anArray.lastIndexOf(8, 2);

console.log(index); // 0

In the abov example, the lastIndexOf() method returns 0 for the index of the value 8.

This is because the second argument 2 makes the method search from index 2 only. Since the last index of the value(8) is 3, it stays outside of the method search range.

And that’s how the lastIndexOf() method works in JavaScript. 😉

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

#javascript #method #strings 

String Handling in Python

In this tutorial, you'll learn about string handling in Python: String manipulation, built-in methods and functions and formatting to generate useful information and to display. 

Strings play a very important role in storing a variety of data such as email ids, website names, PAN card number, ID card number, license number, passport number etc. Using string built-in methods and functions we can process this data as per our need by writing Python programs. Strings can be sliced to generate different sub strings of the given string using string slicing. Also, multiple strings from a list can be combined together to form a single string. Strings can split to form multiple sub strings based on the character of separation between words of the given string. Using string formatting, data can be displayed as per the need. This course discusses a variety of ways to format string literals. f-string is the easiest way to format the string data. Using function, ASCII value of a character can be obtained and a character for ASCII value can be obtained. Calculating the number of words and number of characters is possible by writing small Python programs. Data stored in different types of files can be accessed and stored in string literals in Python programs and these string literals can be operated to retrieve useful information. Many domains in software development like Artificial Intelligence, Data Analytics, Data Mining, Machine Learning, Cloud Computing etc. are dealing with strings data type and this course will help you to know basic and important concepts of strings in Python.

What you’ll learn:

•        Strings declaration
•        Accepting and displaying string
•        Built-in methods of strings
•        Built-in functions of strings
•        String slicing
•        String Concatenation and string multiplication
•        String formatting

Are there any course requirements or prerequisites?

•        Basics of Computer programming

Who this course is for:

•        Begginers in Python programming

#python #strings 

Glue: Glue Strings to Data in R

glue 

Overview

Glue offers interpreted string literals that are small, fast, and dependency-free. Glue does this by embedding R expressions in curly braces which are then evaluated and inserted into the argument string.

Installation

# Install released version from CRAN
install.packages("glue")

# Install development version from GitHub
devtools::install_github("tidyverse/glue")

Usage

Variables can be passed directly into strings.

library(glue)
name <- "Fred"
glue('My name is {name}.')
#> My name is Fred.

Note that glue::glue() is also made available via stringr::str_glue(). So if you’ve already attached stringr (or perhaps the whole tidyverse), you can access glue() like so:

library(stringr) # or library(tidyverse)

stringr_fcn <- "`stringr::str_glue()`"
glue_fcn    <- "`glue::glue()`"

str_glue('{stringr_fcn} is essentially an alias for {glue_fcn}.')
#> `stringr::str_glue()` is essentially an alias for `glue::glue()`.

Long strings are broken by line and concatenated together.

library(glue)

name <- "Fred"
age <- 50
anniversary <- as.Date("1991-10-12")
glue('My name is {name},',
  ' my age next year is {age + 1},',
  ' my anniversary is {format(anniversary, "%A, %B %d, %Y")}.')
#> My name is Fred, my age next year is 51, my anniversary is Saturday, October 12, 1991.

Named arguments are used to assign temporary variables.

glue('My name is {name},',
  ' my age next year is {age + 1},',
  ' my anniversary is {format(anniversary, "%A, %B %d, %Y")}.',
  name = "Joe",
  age = 40,
  anniversary = as.Date("2001-10-12"))
#> My name is Joe, my age next year is 41, my anniversary is Friday, October 12, 2001.

glue_data() is useful with magrittr pipes.

`%>%` <- magrittr::`%>%`
head(mtcars) %>% glue_data("{rownames(.)} has {hp} hp")
#> Mazda RX4 has 110 hp
#> Mazda RX4 Wag has 110 hp
#> Datsun 710 has 93 hp
#> Hornet 4 Drive has 110 hp
#> Hornet Sportabout has 175 hp
#> Valiant has 105 hp

Or within dplyr pipelines

library(dplyr)
head(iris) %>%
  mutate(description = glue("This {Species} has a petal length of {Petal.Length}"))
#>   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
#> 1          5.1         3.5          1.4         0.2  setosa
#> 2          4.9         3.0          1.4         0.2  setosa
#> 3          4.7         3.2          1.3         0.2  setosa
#> 4          4.6         3.1          1.5         0.2  setosa
#> 5          5.0         3.6          1.4         0.2  setosa
#> 6          5.4         3.9          1.7         0.4  setosa
#>                             description
#> 1 This setosa has a petal length of 1.4
#> 2 This setosa has a petal length of 1.4
#> 3 This setosa has a petal length of 1.3
#> 4 This setosa has a petal length of 1.5
#> 5 This setosa has a petal length of 1.4
#> 6 This setosa has a petal length of 1.7

Leading whitespace and blank lines from the first and last lines are automatically trimmed.

This lets you indent the strings naturally in code.

glue("
    A formatted string
    Can have multiple lines
      with additional indention preserved
    ")
#> A formatted string
#> Can have multiple lines
#>   with additional indention preserved

An additional newline can be used if you want a leading or trailing newline.

glue("

  leading or trailing newlines can be added explicitly

  ")
#> 
#> leading or trailing newlines can be added explicitly

\\ at the end of a line continues it without a new line.

glue("
    A formatted string \\
    can also be on a \\
    single line
    ")
#> A formatted string can also be on a single line

A literal brace is inserted by using doubled braces.

name <- "Fred"
glue("My name is {name}, not {{name}}.")
#> My name is Fred, not {name}.

Alternative delimiters can be specified with .open and .close.

one <- "1"
glue("The value of $e^{2\\pi i}$ is $<<one>>$.", .open = "<<", .close = ">>")
#> The value of $e^{2\pi i}$ is $1$.

All valid R code works in expressions, including braces and escaping.

Backslashes do need to be doubled just like in all R strings.

  `foo}\`` <- "foo"
glue("{
      {
        '}\\'' # { and } in comments, single quotes
        \"}\\\"\" # or double quotes are ignored
        `foo}\\`` # as are { in backticks
      }
  }")
#> foo

glue_sql() makes constructing SQL statements safe and easy

Use backticks to quote identifiers, normal strings and numbers are quoted appropriately for your backend.

library(glue)

con <- DBI::dbConnect(RSQLite::SQLite(), ":memory:")
colnames(iris) <- gsub("[.]", "_", tolower(colnames(iris)))
DBI::dbWriteTable(con, "iris", iris)
var <- "sepal_width"
tbl <- "iris"
num <- 2
val <- "setosa"
glue_sql("
  SELECT {`var`}
  FROM {`tbl`}
  WHERE {`tbl`}.sepal_length > {num}
    AND {`tbl`}.species = {val}
  ", .con = con)
#> <SQL> SELECT `sepal_width`
#> FROM `iris`
#> WHERE `iris`.sepal_length > 2
#>   AND `iris`.species = 'setosa'

# `glue_sql()` can be used in conjunction with parameterized queries using
# `DBI::dbBind()` to provide protection for SQL Injection attacks
 sql <- glue_sql("
    SELECT {`var`}
    FROM {`tbl`}
    WHERE {`tbl`}.sepal_length > ?
  ", .con = con)
query <- DBI::dbSendQuery(con, sql)
DBI::dbBind(query, list(num))
DBI::dbFetch(query, n = 4)
#>   sepal_width
#> 1         3.5
#> 2         3.0
#> 3         3.2
#> 4         3.1
DBI::dbClearResult(query)

# `glue_sql()` can be used to build up more complex queries with
# interchangeable sub queries. It returns `DBI::SQL()` objects which are
# properly protected from quoting.
sub_query <- glue_sql("
  SELECT *
  FROM {`tbl`}
  ", .con = con)

glue_sql("
  SELECT s.{`var`}
  FROM ({sub_query}) AS s
  ", .con = con)
#> <SQL> SELECT s.`sepal_width`
#> FROM (SELECT *
#> FROM `iris`) AS s

# If you want to input multiple values for use in SQL IN statements put `*`
# at the end of the value and the values will be collapsed and quoted appropriately.
glue_sql("SELECT * FROM {`tbl`} WHERE sepal_length IN ({vals*})",
  vals = 1, .con = con)
#> <SQL> SELECT * FROM `iris` WHERE sepal_length IN (1)

glue_sql("SELECT * FROM {`tbl`} WHERE sepal_length IN ({vals*})",
  vals = 1:5, .con = con)
#> <SQL> SELECT * FROM `iris` WHERE sepal_length IN (1, 2, 3, 4, 5)

glue_sql("SELECT * FROM {`tbl`} WHERE species IN ({vals*})",
  vals = "setosa", .con = con)
#> <SQL> SELECT * FROM `iris` WHERE species IN ('setosa')

glue_sql("SELECT * FROM {`tbl`} WHERE species IN ({vals*})",
  vals = c("setosa", "versicolor"), .con = con)
#> <SQL> SELECT * FROM `iris` WHERE species IN ('setosa', 'versicolor')

Optionally combine strings with +

x <- 1
y <- 3
glue("x + y") + " = {x + y}"
#> x + y = 4

Other implementations

Some other implementations of string interpolation in R (although not using identical syntax).

• stringr::str_interp
• R.utils::gstring
• rprintf

String templating is closely related to string interpolation, although not exactly the same concept. Some packages implementing string templating in R include.

• whisker
• brew

Code of Conduct

Please note that the glue project is released with a Contributor Code of Conduct. By contributing to this project, you agree to abide by its terms.

Download Details:

Author: tidyverse
Source Code: https://github.com/tidyverse/glue 
License: Unknown, MIT licenses found

#r #strings 

Bracer: Brace Expansions in R

bracer

bracer provides support for performing brace expansions on strings in R.

Examples

library("bracer")
options(bracer.engine = "r")
expand_braces("Foo{A..F}")

## [1] "FooA" "FooB" "FooC" "FooD" "FooE" "FooF"

expand_braces("Foo{01..10}")

##  [1] "Foo01" "Foo02" "Foo03" "Foo04" "Foo05" "Foo06" "Foo07" "Foo08" "Foo09"
## [10] "Foo10"

expand_braces("Foo{A..E..2}{1..5..2}")

## [1] "FooA1" "FooA3" "FooA5" "FooC1" "FooC3" "FooC5" "FooE1" "FooE3" "FooE5"

expand_braces("Foo{-01..1}")

## [1] "Foo-01" "Foo000" "Foo001"

expand_braces("Foo{{d..d},{bar,biz}}.{py,bash}")

## [1] "Food.py"     "Food.bash"   "Foobar.py"   "Foobar.bash" "Foobiz.py"  
## [6] "Foobiz.bash"

expand_braces is vectorized and returns one big character vector of all the brace expansions. str_expand_braces is an alternative that returns a list of character vectors.

expand_braces(c("Foo{A..F}", "Bar.{py,bash}", "{{Biz}}"))

## [1] "FooA"     "FooB"     "FooC"     "FooD"     "FooE"     "FooF"     "Bar.py"  
## [8] "Bar.bash" "{{Biz}}"

str_expand_braces(c("Foo{A..F}", "Bar.{py,bash}", "{{Biz}}"))

## [[1]]
## [1] "FooA" "FooB" "FooC" "FooD" "FooE" "FooF"
## 
## [[2]]
## [1] "Bar.py"   "Bar.bash"
## 
## [[3]]
## [1] "{{Biz}}"

glob is a wrapper around Sys.glob that uses expand_braces to support both brace and wildcard expansion on file paths.

glob("R/*.{R,r,S,s}")

## [1] "R/engine-r.R"      "R/engine-v8.R"     "R/expand_braces.R"
## [4] "R/glob.R"

Installation

To install the release version on CRAN use the following command in R:

install.packages("bracer")

To install the developmental version use the following command in R:

remotes::install_github("trevorld/bracer")

Installing the suggested V8 package will enable use of the javascript alternative parser:

install.packages("V8")

Limitations of pure R parser and alternative javascript parser

The bracer pure R parser currently does not properly support the "correct" (Bash-style) brace expansion under several edge conditions such as:

1. Unbalanced braces e.g. {{a,d} (but you could use an escaped brace instead \\{{a,d})
2. Using surrounding quotes to escape terms e.g. {'a,b','c'} (but you could use an escaped comma instead {a\\,b,c})
3. Escaped braces within comma-separated lists e.g. {a,b\\}c,d}
4. (Non-escaping) backslashes before braces e.g. {a,\\\\{a,b}c}
5. Sequences from letters to non-letter ASCII characters e.g. X{a..#}X

options(bracer.engine = "r")
expand_braces("{{a,d}")

## [1] "{{a,d}"

expand_braces("{'a,b','c'}")

## [1] "'a"  "b'"  "'c'"

expand_braces("{a,b\\}c,d}")

## [1] "a,b}c" "d"

expand_braces("{a,\\\\{a,b}c}")

## [1] "ac}"  "{ac}" "bc}"

expand_braces("X{a..#}X")

## [1] "X{a..#}X"

However if the 'V8' suggested R package is installed we can instead use an embedded version of the braces Javascript library which can correctly handle these edge cases. To do so we need to set the bracer "engine" to "v8".

options(bracer.engine = "v8")
expand_braces("{{a,d}")

## [1] "{a" "{d"

expand_braces("{'a,b','c'}")

## [1] "a,b" "c"

expand_braces("{a,b\\}c,d}")

## [1] "a"   "b}c" "d"

expand_braces("{a,\\\\{a,b}c}")

## [1] "a"    "\\ac" "\\bc"

expand_braces("X{a..#}X")

##  [1] "XaX"  "X`X"  "X_X"  "X^X"  "X]X"  "X\\X" "X[X"  "XZX"  "XYX"  "XXX" 
## [11] "XWX"  "XVX"  "XUX"  "XTX"  "XSX"  "XRX"  "XQX"  "XPX"  "XOX"  "XNX" 
## [21] "XMX"  "XLX"  "XKX"  "XJX"  "XIX"  "XHX"  "XGX"  "XFX"  "XEX"  "XDX" 
## [31] "XCX"  "XBX"  "XAX"  "X@X"  "X?X"  "X>X"  "X=X"  "X<X"  "X;X"  "X:X" 
## [41] "X9X"  "X8X"  "X7X"  "X6X"  "X5X"  "X4X"  "X3X"  "X2X"  "X1X"  "X0X" 
## [51] "X/X"  "X.X"  "X-X"  "X,X"  "X+X"  "X*X"  "X)X"  "X(X"  "X'X"  "X&X" 
## [61] "X%X"  "X$X"  "X#X"

Download Details:

Author: Trevorld
Source Code: https://github.com/trevorld/bracer 
License: Unknown, MIT licenses found

#r #strings 

WeakRefStrings.jl: A Minimal String Type for Julia

WeakRefStrings  

A string type for minimizing data-transfer costs in Julia

Installation

The package is registered in the General registry and so can be installed with Pkg.add.

julia> using Pkg; Pkg.add("WeakRefStrings")

Project Status

The package is tested against Julia 1.6 and nightly on Linux, OS X, and Windows.

Contributing and Questions

Contributions are very welcome, as are feature requests and suggestions. Please open an issue if you encounter any problems or would just like to ask a question.

Usage

InlineString

A set of custom string types of various fixed sizes. Each inline string is a custom primitive type and can benefit from being stack friendly by avoiding allocations/heap tracking in the GC. When used in an array, the elements are able to be stored inline since each one has a fixed size. Currently support inline strings from 1 byte up to 255 bytes.

The following types are supported: String1, String3, String7, String15, String31, String63, String127, String255.

PosLenString

A custom string representation that takes a byte buffer (buf), poslen, and e escape character, and lazily allows treating a region of the buf as a string. Can be used most efficiently as part of a PosLenStringVector which only stores an array of PosLen (inline) along with a single buf and e and returns PosLenString when indexing individual elements.

WeakRefString

Usage of WeakRefStrings is discouraged for general users. Currently, a WeakRefString purposely does not implement many Base Julia String interface methods due to many recent changes to Julia's builtin String interface, as well as the complexity to do so correctly. As such, WeakRefStrings are used primarily in the data ecosystem as an IO optimization and nothing more. Upon indexing a WeakRefStringArray, a proper Julia String type is materialized for safe, correct string processing. In the future, it may be possible to implement safe operations on WeakRefString itself, but for now, they must be converted to a String for any real work.

Additional documentation is available at the REPL for ?WeakRefStringArray and ?WeakRefString.

Download Details:

Author: JuliaData
Source Code: https://github.com/JuliaData/WeakRefStrings.jl 
License: View license

#julia #data #strings 

ShortStrings.jl: A Fast Implementation Of Short Strings Of Fixed Size

ShortStrings

This is an efficient string format for storing strings using integer types. For example, UInt32 can hold 3 bytes of string with 1 byte to record the size of the string and a UInt128 can hold a 15-byte string with 1 byte to record the size of the string.

Using BitIntegers.jl, integer of larger size than UInt128 can be defined. This package supports string with up to 255 bytes in size.

Quick Start

using ShortStrings

using SortingAlgorithms
using Random: randstring

N = Int(1e6)
svec = [randstring(rand(1:15)) for i=1:N]
# convert to ShortString
ssvec = ShortString15.(svec)

# sort short vectors
@time sort(svec);
@time sort(ssvec, by = x->x.size_content, alg=RadixSort);

# conversion to shorter strings is also possible with
ShortString7(randstring(7))
ShortString3(randstring(3))

# convenience macros are provided for writing actual strings (e.g., for comparison)
s15 = ss15"A short string"  # ShortString15 === ShortString{Int128}
s7 = ss7"shorter"           # ShortString7 === ShortString{Int64}
s3 = ss3"srt"               # ShortString3 === ShortString{Int32}

# The ShortString constructor can automatically select the shortest size that a string will fit in
ShortString("This is a long string")

# The maximum length can also be added:
ShortString("Foo", 15)

# The `ss` macro will also select the shortest size that will fit
s31 = ss"This also is a long string"

0.386383 seconds (126 allocations: 11.450 MiB, 18.62% gc time, 0.59% comp
ilation time)
  0.279547 seconds (742.26 k allocations: 74.320 MiB, 70.85% compilation ti
me)
"This also is a long string"

Benchmarks

using SortingLab, ShortStrings, SortingAlgorithms, BenchmarkTools;
N = Int(1e6);
svec = [randstring(rand(1:15)) for i=1:N];
# convert to ShortString
ssvec = ShortString15.(svec);
basesort = @benchmark sort($svec)
radixsort_timings = @benchmark SortingLab.radixsort($svec)
short_radixsort = @benchmark ShortStrings.fsort($ssvec)
# another way to do sorting
sort(ssvec, by = x->x.size_content, alg=RadixSort)

using RCall
@rput svec;
r_timings = R"""
replicate($(length(short_radixsort.times)), system.time(sort(svec, method="radix"))[3])
""";

using Plots
bar(["Base.sort","SortingLab.radixsort","ShortStrings radix sort", "R radix sort"],
    mean.([basesort.times./1e9, radixsort_timings.times./1e9, short_radixsort.times./1e9, r_timings]),
    title="String sort performance - len: 1m, variable size 15",
    label = "seconds")

using SortingLab, ShortStrings, SortingAlgorithms, BenchmarkTools;
N = Int(1e6);
svec = rand([randstring(rand(1:15)) for i=1:N÷100],N)
# convert to ShortString
ssvec = ShortString15.(svec);
basesort = @benchmark sort($svec) samples = 5 seconds = 120
radixsort_timings = @benchmark SortingLab.radixsort($svec) samples = 5 seconds = 120
short_radixsort = @benchmark ShortStrings.fsort($ssvec) samples = 5 seconds = 120

using RCall

@rput svec;
r_timings = R"""
replicate(max(5, $(length(short_radixsort.times))), system.time(sort(svec, method="radix"))[3])
""";

using Plots
bar(["Base.sort","SortingLab.radixsort","ShortStrings radix sort", "R radix sort"],
    mean.([basesort.times./1e9, radixsort_timings.times./1e9, short_radixsort.times./1e9, r_timings]),
    title="String sort performance - len: $(N÷1_000_000)m, fixed size: 15",
    label = "seconds")

Notes

This is based on the discussion here. If Julia.Base adopts the hybrid representation of strings then it makes this package redundant.

Build Status

Download Details:

Author: JuliaString
Source Code: https://github.com/JuliaString/ShortStrings.jl 
License: View license

#julia #strings 

MutableStrings.jl: Mutable String Types for Julia

Mutable Strings

Large scale text processing often requires several changes to be made on large string objects. Using immutable strings can result in significant inefficiencies in such cases. Using byte arrays directly prevents us from using the convenient string methods. This package provides Mutable ASCII and UTF8 string types that allow mutating the string data through the familiar string methods.

Types

• MutableASCIIString: immutable MutableASCIIString <: DirectIndexString
• MutableUTF8String: immutable MutableUTF8String <: String
• MutableString: typealias MutableString Union(MutableASCIIString, MutableUTF8String)

Methods

All methods on immutable strings can also be applied to a MutableString. Additionally the below methods allow modifications on MutableString objects:

Case Conversion

• uppercase!(s::MutableString) : In-place uppercase conversion
• lowercase!(s::MutableString) : In-place lowercase conversion
• ucfirst!(s::MutableString) : Convert the first letter to uppercase in-place
• lcfirst!(s::MutableString) : Convert the first letter to lowercase in-place

Search/Replace

The usual search methods on String type also applies to MutableStrings.

replace!(s::MutableString, pattern, repl::Union(ByteString,Char,Function), limit::Integer=0)

The above method allows in-place replacement of patterns matching pattern with repl upto limit occurrences. If limit is zero, all occurrences are replaced.

As with search, the pattern argument may be a single character, a vector or a set of characters, a string, or a regular expression.

If repl is a ByteString, it replaces the matching region. If it is a Char, it replaces each character of the matching region. If repl is a function, it must accept a SubString representing the matching region and return either a Char or a ByteString to be used as the replacement.

Others

• setindex!(s::MutableString, x, i0::Real)
• setindex!(s::MutableString, r::ByteString,I::Range1{T<:Real})
• setindex!(s::MutableString, c::Char, I::Range1{T<:Real})
• reverse!(s::MutableString)
• map!(f, s::MutableString)

Parts of a mutable string can be modified as:

   s[10] = 'A'
   s[12:14] = "ABC"

Performance

• Most operations on a MutableString are faster than those on an immutable String.
• Replacing segments of mutable strings with different length replacements is slower than recreating the entire string.
• MutableStrings are always more memory efficient than immutable Strings.

Notes

• Significant code has been duplicated from Julia base to specialize the MutableString methods. A proper type-reorganization would eliminate this.
• The hash method on MutableString behaves similar to that on String. This can result in surprises when it is used as a key in collections.
• Since UTF8 has variable character byte lengths, MutableUTF8String also allows replacing segments of the string with arbitrary length replacements, e.g: s[10] = "ABC". This is inconsistent with behavior of MutableASCIIString, and remains to be debated.

Note: This package is now deprecated in favor of https://github.com/quinnj/Strings.jl (see https://github.com/tanmaykm/MutableStrings.jl/issues/3)

Download Details:

Author: Tanmaykm
Source Code: https://github.com/tanmaykm/MutableStrings.jl 
License: View license

#julia #strings #types 

Convenient input, display of LaTeX equation strings for Julia language

LaTeXStrings

This is a small package to make it easier to type LaTeX equations in string literals in the Julia language, written by Steven G. Johnson.

With ordinary strings in Julia, to enter a string literal with embedded LaTeX equations you need to manually escape all backslashes and dollar signs: for example, $\alpha^2$ is written \$\\alpha^2\$. Also, even though IJulia is capable of displaying formatted LaTeX equations (via MathJax), an ordinary string will not exploit this. Therefore, the LaTeXStrings package defines:

A LaTeXString class (a subtype of String), which works like a string (for indexing, conversion, etcetera), but automatically displays as text/latex in IJulia.

L"..." and L"""...""" string macros which allow you to enter LaTeX equations without escaping backslashes and dollar signs (and which add the dollar signs for you if you omit them).

FAQ: Not a LaTeX renderer

LaTeXStrings does not do any rendering — its sole purpose is to make it easier to enter LaTeX-rendered strings without typing a lot of backslash escapes, as well as providing a type to tell display backends to use LaTeX rendering if possible.

Other packages like plotting software, Jupyter notebooks, Pluto, etcetera, are responsible for the LaTeX rendering (if any). For example, they might use MathJax, MathTeXEngine.jl, or other renderers. LaTeXStrings only provides the LaTeX text to these backend, and has no influence on what LaTeX features (if any) are supported.

Usage

After installing LaTeXStrings with Pkg.add("LaTeXStrings") in Julia, run

using LaTeXStrings

to load the package. At this point, you can construct LaTeXString literals with the constructor L"..." (and L"""...""" for multi-line strings); for example L"1 + \alpha^2" or L"an equation: $1 + \alpha^2$". (Note that $ is added automatically around your string, i.e. the string is interpreted as an equation, if you do not include $ yourself.)

If you want to perform string interpolation (inserting the values of other variables into your string), use %$ instead of the plain $ that you would use for interpolation in ordinary Julia strings. For example, if x=3 is a Julia variable, then L"y = %$x" will produce L"y = 3".

You can also use the lower-level constructor latexstring(args...), which works much like string(args...) except that it produces a LaTeXString result and automatically puts $ at the beginning and end of the string if an unescaped $ is not already present. Note that with latexstring(...) you do have to escape $ and \: for example, latexstring("an equation: \$1 + \\alpha^2\$"). Note that you can supply multiple arguments (of any types) to latexstring, which are converted to strings and concatenated as in the string(...) function.

Finally, you can use the lowest-level constructor LaTeXString(s). The only advantage of this is that it does not automatically put $ at the beginning and end of the string. So, if for some reason you want to use text/latex display of ordinary text (with no equations or formatting), you can use this constructor. (Note that IJulia only formats LaTeX equations; other LaTeX text-formatting commands like \emph are ignored.)

Download Details:

Author: Stevengj
Source Code: https://github.com/stevengj/LaTeXStrings.jl 
License: MIT license

#julia #strings #math 

A Type for Efficiently Storing Short Strings Of Known Size

FixedSizeStrings.jl

This is a string type for compactly storing short strings of statically-known size. Each character is stored in one byte, so currently only the Latin-1 subset of Unicode is supported.

To use, call FixedSizeString{n}(itr), where n is the length and itr is an iterable of characters. Alternatively, other string types can be converted to FixedSizeString{n}.

FixedSizeStrings works well in the following cases:

• Very short strings, e.g. <= 8 characters
• Storing many strings of the same length, when the number of unique strings is large

If you have a large array with a relatively small number of unique strings, it is probably better to use PooledArrays with whatever string type is convenient.

TODO and open questions:

• Support more characters by adding a parameter for the representation (UInt16, UInt32)
• Does it make sense to support UTF-8?
• Possibly add MaxLengthString, which is the same except can be padded with 0 bytes to represent fewer than the maximum possible number of characters.

Download Details:

Author: JuliaComputing
Source Code: https://github.com/JuliaComputing/FixedSizeStrings.jl 
License: MIT license

#julia #strings