Whether you want to store text, manipulate it, or accept keyboard inputs and outputs, understanding what strings are and how to effectively use them is extremely important.

This article will teach everything you need to know about handling and working with strings in C++.

What is a String?

Strings, at their core, are essentially collections of characters. Some examples include "Hello World", "My name is Bob", and so on. They're enclosed in double quotes ".

In C++, we have two types of strings:

1. C-style strings

2. std::strings (from the C++ Standard string class)

You can very easily create your own string class with their own little functions, but it's not something we're going to get into in this article.

C-style Strings

These are strings derived from the C programming language and they continue to be supported in C++. These "collections of characters" are stored in the form of arrays of type char that are null-terminated (the \0 null character).

How to define a C-style string:

char str[] = "c string";

Here, str is a char array of length 9 (the extra character comes from the \0 null character that's added by the compiler).

Here are some other ways of defining C-style strings in C++:

char str[9] = "c string";
char str[] = {'c', ' ', 's', 't', 'r', 'i', 'n', 'g', '\0'};
char str[9] = {'c', ' ', 's', 't', 'r', 'i', 'n', 'g', '\0'};

How to pass C-style strings to a function

#include <iostream>

int main() {
    char str[] = "This is a C-style string";
    display(str);
}

// C-style strings can be passed to functions as follows:
void display(char str[]) {
    std::cout << str << "\n";
}

How to use C-style string functions in C++

The C Standard Library came with a couple of handy functions that you can use to manipulate strings. While they're not widely recommended to use (see below), you can still use them in C++ code by including the <cstring> header:

#include <cstring> // required


1. strcpy(s1,s2) --> Copies string s2 into string s1.                 
2. strcat(s1,s2) --> Concatenates string s2 onto the end of string s1
3. strlen(s1)    --> Returns the length of string s1         
4. strcmp(s1,s2) --> Returns 0 if s1==s2; less than 0 if s1<s2; greater than 0 if s1>s2
5. strchr(s1,ch) --> Returns a pointer to the first occurrence of character ch in string s1
6. strstr(s1,s2) --> Returns a pointer to the first string s2 in string s1

std::string

C-style strings are relatively unsafe – if the string/char array is not null-terminated, it can lead to a whole host of potential bugs.

For example, buffer overflows among a whole host of other drawbacks are some reasons why the use of C-style strings are not recommended in the C++ developer community.

The std::string class that's provided by the C++ Standard Library is a much safer alternative. Here's how you use it:

How to define a std::string

#include <iostream> 
#include <string> // the C++ Standard String Class

int main() {
    std::string str = "C++ String";
    std::cout << str << "\n"; // prints `C++ String`"
}

The most obvious difference to note between C-style strings and std::strings is the length of the string. If you ever need the length of a C-style string, you'll need to compute it each time using the strlen() function like so:

#include <iostream>
#include <cstring> // required to use `strlen`

int main() {
    char str[] = "hello world";
    std::cout << strlen(str) << "\n";
}

If you don't store this in a variable and require it in multiple parts of your program, you can quickly observe how expensive this option is.

On the other hand, a std::string string already has an in-built length property. To access it, you use the .length() property as follows:

#include <iostream>
#include <string> // required to use `std::string`

int main() {
    std::string str = "freeCodeCamp";
    std::cout << str.length() << "\n";
}

Simple, neat, concise, but an important computational reduction.

But accessing the length property isn't the only benefit to using std::strings. Here are a few more examples:

#include <iostream>
#include <string>

int main() {
   std::string str = "freeCodeCamp";

   // Inserting a single character into `str`
   str.push_back('s');
   std::cout << str << "\n"; // `str` is now `freeCodeCamps`

   // Deleting the last character from `str`
   str.pop_back();
   std::cout << str << "\n"; // `str` is now `freeCodeCamp`

   // Resizing a string
   str.resize(13);
   std::cout << str << "\n"; 

   // Decreasing excess capacity of the string
   str.shrink_to_fit()
   std::cout << str << "\n";
}

How to pass an std::string to a function

#include <iostream>

int main() {
    std::string str = "This is a C-style string";
    display(str);
}

// Passing `std::string`s are as you would normally pass a regular object
void display(std::string str) {
    std::cout << str << "\n";
}

When would you use a C-style string over std::string?

By now, you should be convinced of the numerous advantages that std::strings have over C-style strings (most notably automatic memory management). But there are times when you'd want to use C-style strings instead:

1. If you're from a C background, you might be comfortable working with C-style strings.

2. A std::string, despite its benefits, is enormously complex. Like the rest of the language, if you don't know what you're doing, it can get real complicated very quickly. Plus, it uses a ton of memory that may not be ideal for the purposes of your programs.

3. If you're careful to manage your program's memory during runtime (by freeing an object's memory when you're done using it), there is a performance benefit to using C-style strings considering how small and lightweight they are.

Wrapping Up

I hope this article served as an introduction to strings in C++. There's so much more to learn about this wonderful abstraction, and I hope to write more articles delving into the more advanced concepts of strings and C++.

Happy learning!

So, you have gathered a dataset, built a neural network, and trained your model.

But despite the hours (and sometimes days) of work you've invested to create the model, it spits out predictions with an accuracy of 50–70%. Chances are, this is not what you expected.

Here are a few strategies, or hacks, to boost your model’s performance metrics.

1. Get More Data

Deep learning models are only as powerful as the data you bring in. One of the easiest ways to increase validation accuracy is to add more data. This is especially useful if you don’t have many training instances.

If you’re working on image recognition models, you may consider increasing the diversity of your available dataset by employing data augmentation. These techniques include anything from flipping an image over an axis and adding noise to zooming in on the image. If you are a strong machine learning engineer, you could also try data augmentation with GANs.

Read more about data augmentation here.

Keras has an amazing image preprocessing class to perform data augmentation: ImageDataGenerator.

Be careful that the augmentation technique you use changes the entire class of an image. For example, the image of a 3 flipped over the y-axis doesn’t make sense! [Source](https://bair.berkeley.edu/blog/2019/06/07/data_aug/" rel="noopener)

2. Add More Layers

Adding more layers to your model increases its ability to learn your dataset’s features more deeply. This means that it will be able to recognize subtle differences that you, as a human, might not have picked up on.

This hack entirely relies on the nature of the task you are trying to solve.

For complex tasks, such as differentiating between the breeds of cats and dogs, adding more layers makes sense because your model will be able to learn the subtle features that differentiate a poodle from a Shih Tzu.

For simple tasks, such as classifying cats and dogs, a simple model with few layers will do.

More layers -> More nuanced model.

Photo by [Unsplash](https://unsplash.com/@alvannee?utm_source=medium&utm_medium=referral" rel="photo-creator noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener">Alvan Nee on <a href="https://unsplash.com?utm_source=medium&utm_medium=referral" rel="photo-source noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener noopener)

3. Change Your Image Size

When you preprocess your images for training and evaluation, there is a lot of experimentation you can do with regards to the image size.

If you choose an image size that is too small, your model will not be able to pick up on the distinctive features that help with image recognition.

Conversely, if your images are too big, it increases the computational resources required by your computer and/or your model might not be sophisticated enough to process them.

Common image sizes include 64x64, 128x128, 28x28 (MNIST), and 224x224 (VGG-16).

Keep in mind that most preprocessing algorithms do not consider the aspect ratio of the image, so smaller-sized images might appear to have shrunk over a certain axis.

Converting an image from a large resolution to a small size, like 28x28, usually ends up with a lot of pixelation that tends to have negative effects on your model’s performance. [Source](https://dribbble.com/shots/4829233-Pixelated-Mona-Lisa" rel="noopener)

4. Increase Epochs

Epochs are basically how many times you pass the entire dataset through the neural network. Incrementally train your model with more epochs with intervals of +25, +100, and so on.

Increasing epochs makes sense only if you have a lot of data in your dataset. However, your model will eventually reach a point where increasing epochs will not improve accuracy.

At this point, you should consider playing around with your model’s learning rate. This little hyperparameter dictates whether your model reaches its global minimum (the ultimate goal for neural nets) or gets stuck in a local minimum.

Global Minimum is the ultimate goal for neural networks. [Source](https://www.dna-ghost.com/single-post/2018/03/13/Neural-network-Escaping-from-variety-of-non-global-minimum-traps" rel="noopener)

5. Decrease Colour Channels

Colour channels reflect the dimensionality of your image arrays. Most colour (RGB) images are composed of three colour channels, while grayscale images have just one channel.

The more complex the colour channels are, the more complex the dataset is and the longer it will take to train the model.

If colour is not such a significant factor in your model, you can go ahead and convert your colour images to grayscale.

You can even consider other colour spaces, like HSV and Lab.

RGB images are composed of three colour channels: red, green, and blue. [Source](https://www.youtube.com/watch?v=ZqUotba3V5Y" rel="noopener)

6. Transfer Learning

Transfer learning involves the use of a pre-trained model, such as YOLO and ResNet, as a starting point for most computer vision and natural language processing tasks.

Pre-trained models are state-of-the-art deep learning models that were trained on millions and millions of samples, and often for months. These models have an astonishingly huge capability of detecting nuances in different images.

These models can be used as a base for your model. Most models are so good that you won’t need to add convolutional and pooling Layers.

Read more about using transfer learning.

Transfer learning can greatly improve your model’s accuracy from ~50% to 90%! Source: [Nvidia blog](https://www.nvidia.com/content/dam/en-zz/en_sg/ai-innovation-day-2019/assets/pdf/9_NVIDIA-Transfer-Learning-Toolkit-for-Intelligent-Video-Analytics.pdf" rel="noopener)

Final Thoughts

The hacks above offer a base for you to optimize a model. To really fine tune a model, you’ll need to consider tuning the various hyperparameters and functions involved in your model, such as the learning rate (as discussed above), activation functions, loss functions, and so on.

This hack comes as an “I hope you know what you’re doing” warning because there is a wider scope to mess up your model.

Always Save Your Models

Always save your model every time you make a change to your deep learning model. This will help you reuse a previous configuration of the model if it provides greater accuracy.

Most deep learning frameworks like Tensorflow and Pytorch have a “save model” method.

# In Tensorflow
model.save('model.h5') # Saves the entire model to a single artifact

# In Pytorch
torch.save(model, PATH)

There are countless other ways to further optimize your deep learning, but the hacks described above serve as a base in the optimization part of deep learning.

Tweet at me letting me know what your favourite hack is!

I won’t lie: it’s a lot of math.

And this is one of the reasons AI puts off many beginners. After much research and talks with several veterans in the field, I’ve compiled this no-nonsense guide that covers all of the fundamentals of the math you’ll need to know.

The concepts mentioned below are usually covered over several semesters in college, but I’ve boiled them down to the core principles that you can focus on.

This guide is an absolute life-saver for beginners, so you can study the topics that matter most. But it's an even better resource for practitioners, such as myself, who require a quick breeze-through on these concepts.

Note: You don’t need to know all of the concepts (below) in order to get your first job in AI. All you need is a firm grasp of the fundamentals. Focus on those and consolidate them.

1. Algebra You Need to Know for AI

Knowledge of algebra is perhaps fundamental to math in general. Besides mathematical operations like addition, subtraction, multiplication and division, you’ll need to know the following:

• Exponents

• Radicals

• Factorials

• Summations

• Scientific Notations

2. Linear Algebra You Need to Know for AI

Linear Algebra is the primary mathematical computation tool in Artificial Intelligence and in many other areas of Science and Engineering. With this field, you need to understand 4 primary mathematical objects and their properties:

• Scalars **** — a single number (can be real or natural).

• Vectors — a list of numbers, arranged in order. Consider them as points in space with each element representing the coordinate along an axis.

• Matrices — a 2-D array of numbers where each number is identified by 2 indices.

• Tensors **** — an N-D array (N>2) of numbers, arranged on a regular grid with N-axes. Important in Machine Learning, Deep Learning and Computer Vision.

• Eigenvectors & Eigenvalues — special vectors and their corresponding scalar quantity. Understand the significance and how to find them.

• Singular Value Decomposition **** — factorization of a matrix into 3 matrices. Understand the properties and applications.

• Principal Component Analysis (PCA) — understand the significance, properties, and applications.

Properties such as the Dot product, Vector product and the Hadamard product are useful to know as well.

3. Calculus You Need to Know for AI

Calculus deals with changes in parameters, functions, errors and approximations. Working knowledge of multi-dimensional calculus is imperative in Artificial Intelligence.

The following are the most important concepts (albeit non-exhaustive) in Calculus:

• Derivatives — rules (addition, product, chain rule, and so on), hyperbolic derivatives (tanh, cosh, and so on) and partial derivatives.

• Vector/Matrix Calculus — different derivative operators (Gradient, Jacobian, Hessian and Laplacian)

• Gradient Algorithms **** — local/global maxima and minima, saddle points, convex functions, batches and mini-batches, stochastic gradient descent, and performance comparison.

4. Statistics & Probability Concepts You Need to Know for AI

This topic will probably take up a significant chunk of your time. Good news: these concepts aren’t difficult, so there’s no reason why you shouldn’t master them.

• Basic Statistics — Mean, median, mode, variance, covariance, and so on.

• Basic rules in probability **** — events (dependent and independent), sample spaces, conditional probability.

• Random variables **** — continuous and discrete, expectation, variance, distributions (joint and conditional).

• Bayes’ Theorem — calculates validity of beliefs. Bayesian software helps machines recognize patterns and make decisions.

• Maximum Likelihood Estimation (MLE) **** — parameter estimation. Requires knowledge of fundamental probability concepts (joint probability and independence of events).

• Common Distributions — binomial, poisson, bernoulli, gaussian, exponential.

5. Information Theory Concepts You Need to Know for AI

This is an important field that has made significant contributions to AI and Deep Learning, and is yet unknown to many. Think of it as an amalgamation of calculus, statistics, and probability.

• Entropy **** — also called Shannon Entropy. Used to measure the uncertainty in an experiment.

• Cross-Entropy **** — compares two probability distributions and tells us how similar they are.

• Kullback Leibler Divergence **** — another measure of how similar two probability distributions are.

• Viterbi Algorithm **** — widely used in Natural Language Processing (NLP) and Speech.

• Encoder-Decoder — used in Machine Translation RNNs and other models.

Math is Fun!

If you are terrified at the mere mention of “math”, you’re probably not going to have much fun in Artificial Intelligence.

But if you’re willing to invest time to improve your familiarity with the principles underlying calculus, linear algebra, stats, and probability, nothing — not even math — should get in the way of you getting into AI.

PS: Math really is fun. As you go deeper into math, be sure to understand the beauty of a certain math concept and how it affects something. You’ll soon share the unbridled passion that many mathematicians and AI Scientists have!

A tip: Treat mathematical concepts as a pay-as-you-go: whenever a foreign concept pops up, grab it and devour it! The guide above presents a minimal, yet comprehensive, resource to understand any kind of topic or concept in AI.

Happy learning!

With more than 2.5 exabytes of data generated every day, it comes as no surprise that this data needs to be stored somewhere where we can access it when we need it.

This article will walk you through a hackable cheatsheet to get you up and running with SQL quickly.

What is SQL?

SQL stands for Structured Query Language. It is a language for relational database management systems. SQL is used today to store, retrieve, and manipulate data within relational databases.

Here’s what a basic relational database looks like:

Using SQL, we can interact with the database by writing queries.

Here’s what an example query looks like:

SELECT * FROM customers;

Using this SELECT statement, the query selects all the data from all the columns in the customer’s table and returns data like so:

Source: Database Guide

The asterisk wildcard character (*) refers to “all” and selects all the rows and columns. We can replace it with specific column names instead — here only those columns will be returned by the query

SELECT FirstName, LastName FROM customers;

Adding a WHERE clause allows you to filter what gets returned:

SELECT * FROM customers WHERE age >= 30 ORDER BY age ASC;

This query returns all data from the products table with an age value of greater than 30.

The use of ORDER BY keyword just means the results will be ordered using the age column from the lowest value to the highest

Using the INSERT INTO statement, we can add new data to a table. Here’s a basic example adding a new user to the customers table:

INSERT INTO customers(FirstName, LastName, address, email)
VALUES ('Alice', 'Bob', 'McLaren Vale, South Australia', 'test@fakeGmail.com');

Of course, these examples demonstrate only a very small selection of what the SQL language can do. We'll learn more about it in this guide.

Why Learn SQL?

We live in the age of Big Data, where data is used extensively to find insights and inform strategy, marketing, advertising and a plethora of other operations.

Big businesses like Google, Amazon, AirBnb utilize large, relational databases as a basis of improving customer experience. Understanding SQL is a great skill to have not only for data scientists and analysts but for everyone.

How do you think that you suddenly got a Youtube ad on shoes when just a few minutes ago, you were Googling your favourite shoes? That’s SQL (or a form of SQL) at work!

SQL vs MySQL

Before we move on, I just want to clarify an often-confused topic — the difference between SQL and MySQL. As it turns out, they aren’t the same thing!

SQL is a language, while MySQL is a system to implement SQL.

SQL outlines syntax that allows you to write queries that manage relational databases.

MySQL is a database system that runs on a server. It allows you to write queries using SQL syntax to manage MySQL databases.

In addition to MySQL, there are other systems that implement SQL. Some of the more popular ones include:

• SQLite

• Oracle Database

• PostgreSQL

• Microsoft SQL Server

How to Install MySQL

For most cases, MySQL is the preferred choice for a database management system. Many popular Content Management Systems (like Wordpress) use MySQL by default, so using MySQL to manage those applications can be a good idea.

In order to use MySQL, you’ll need to install it on your system:

Install MySQL on Windows

The recommended way to install MySQL on Windows is by using the MSI installer from the MySQL website.

This resource will guide you with the installation process.

Install MySQL on macOS

On macOS, installing MySQL also involves downloading an installer.

This resource will guide you through the installation process.

How to Use MySQL

With MySQL now installed on your system, I recommend that you use some sort of SQL management application to make managing your databases a much easier process.

There are lots of apps to choose from which largely do the same job, so it’s down to your own personal preference on which one to use:

• MySQL Workbench developed by Oracle

• phpMyAdmin (operates in the web browser)

• HeidiSQL (Recommended for Windows)

• Sequel Pro (Recommended for macOS)

When you’re ready to start writing your own SQL queries, consider importing dummy data rather than creating your own database.

Here are some dummy databases that are available for download free of charge.

SQL Cheatsheet – The Icing on the Cake

SQL Keywords

Here you can find a collection of keywords used in SQL statements, a description, and where appropriate an example. Some of the more advanced keywords have their own dedicated section.

Where MySQL is mentioned next to an example, this means this example is only applicable to MySQL databases (as opposed to any other database system).

ADD -- Adds a new column to an existing table

ADD CONSTRAINT -- Creates a new constraint on an existing table, which is used to specify rules for any data in the table.

ALTER TABLE -- Adds, deletes or edits columns in a table. It can also be used to add and delete constraints in a table, as per the above.

ALTER COLUMN -- Changes the data type of a table’s column.

ALL -- Returns true if all of the subquery values meet the passed condition.

AND -- Used to join separate conditions within a WHERE clause.

ANY -- Returns true if any of the subquery values meet the given condition.

AS -- Renames a table or column with an alias value which only exists for the duration of the query.

ASC -- Used with ORDER BY to return the data in ascending order.

BETWEEN -- Selects values within the given range.

CASE -- Changes query output depending on conditions.

CHECK -- Adds a constraint that limits the value which can be added to a column.

CREATE DATABASE -- Creates a new database.

CREATE TABLE -- Creates a new table. 

DEFAULT -- Sets a default value for a column

DELETE -- Delete data from a table.

DESC -- Used with ORDER BY to return the data in descending order.

DROP COLUMN -- Deletes a column from a table.

DROP DATABASE -- Deletes the entire database.

DROP DEAFULT -- Removes a default value for a column.

DROP TABLE -- Deletes a table from a database.

EXISTS -- Checks for the existence of any record within the subquery, returning true if one or more records are returned.

FROM -- Specifies which table to select or delete data from.

IN --  Used alongside a WHERE clause as a shorthand for multiple OR conditions.

INSERT INTO -- Adds new rows to a table.

IS NULL -- Tests for empty (NULL) values.

IS NOT NULL -- The reverse of NULL. Tests for values that aren’t empty / NULL.

LIKE -- Returns true if the operand value matches a pattern.

NOT -- Returns true if a record DOESN’T meet the condition.

OR -- Used alongside WHERE to include data when either condition is true.

ORDER BY -- Used to sort the result data in ascending (default) or descending order through the use of ASC or DESC keywords.

ROWNUM -- Returns results where the row number meets the passed condition.

SELECT -- Used to select data from a database, which is then returned in a results set.

SELECT DISTINCT -- Sames as SELECT, except duplicate values are excluded.

SELECT INTO -- Copies data from one table and inserts it into another.

SELECT TOP -- Allows you to return a set number of records to return from a table.

SET -- Used alongside UPDATE to update existing data in a table.

SOME -- Identical to ANY.

TOP -- Used alongside SELECT to return a set number of records from a table.

TRUNCATE TABLE -- Similar to DROP, but instead of deleting the table and its data, this deletes only the data.

UNION -- Combines the results from 2 or more SELECT statements and returns only distinct values.

UNION ALL -- The same as UNION, but includes duplicate values.

UNIQUE -- This constraint ensures all values in a column are unique.

UPDATE -- Updates existing data in a table.

VALUES -- Used alongside the INSERT INTO keyword to add new values to a table.

WHERE -- Filters results to only include data which meets the given condition.

Comments in SQL

Comments allow you to explain sections of your SQL statements, without being executed directly.

In SQL, there are 2 types of comments, single line and multiline.

Single Line Comments in SQL

Single line comments start with ‘- -’. Any text after these 2 characters to the end of the line will be ignored.

-- This part is ignored

SELECT * FROM customers;

Multiline Comments in SQL

Multiline comments start with /* and end with */. They stretch across multiple lines until the closing characters have been found.

/*

This is a multiline comment.
It can span across multiple lines.

*/

SELECT * FROM customers;

/*

This is another comment. 
You can even put code within a comment to prevent its execution

SELECT * FROM icecreams;

*/

Data Types in MySQL

When creating a new table or editing an existing one, you must specify the type of data that each column accepts.

In this example, data passed to the id column must be an int (integer), while the FirstName column has a VARCHAR data type with a maximum of 255 characters.

CREATE TABLE customers(
id int,
FirstName varchar(255)
);

1. String Data Types

CHAR(size) -- Fixed length string which can contain letters, numbers and special characters. The size parameter sets the maximum string length, from 0 – 255 with a default of 1.

VARCHAR(size) -- Variable length string similar to CHAR(), but with a maximum string length range from 0 to 65535.

BINARY(size) -- Similar to CHAR() but stores binary byte strings.

VARBINARY(size) -- Similar to VARCHAR() but for binary byte strings.

TINYBLOB -- Holds Binary Large Objects (BLOBs) with a max length of 255 bytes.

TINYTEXT -- Holds a string with a maximum length of 255 characters. Use VARCHAR() instead, as it’s fetched much faster.

TEXT(size) -- Holds a string with a maximum length of 65535 bytes. Again, better to use VARCHAR().

BLOB(size) -- Holds Binary Large Objects (BLOBs) with a max length of 65535 bytes.

MEDIUMTEXT -- Holds a string with a maximum length of 16,777,215 characters.

MEDIUMBLOB -- Holds Binary Large Objects (BLOBs) with a max length of 16,777,215 bytes.

LONGTEXT -- Holds a string with a maximum length of 4,294,967,295 characters.

LONGBLOB -- Holds Binary Large Objects (BLOBs) with a max length of 4,294,967,295 bytes.

ENUM(a, b, c, etc…) -- A string object that only has one value, which is chosen from a list of values which you define, up to a maximum of 65535 values. If a value is added which isn’t on this list, it’s replaced with a blank value instead.

SET(a, b, c, etc…) -- A string object that can have 0 or more values, which is chosen from a list of values which you define, up to a maximum of 64 values.

2. Numeric Data Types

BIT(size) -- A bit-value type with a default of 1. The allowed number of bits in a value is set via the size parameter, which can hold values from 1 to 64.

TINYINT(size) -- A very small integer with a signed range of -128 to 127, and an unsigned range of 0 to 255. Here, the size parameter specifies the maximum allowed display width, which is 255.

BOOL -- Essentially a quick way of setting the column to TINYINT with a size of 1. 0 is considered false, whilst 1 is considered true.

BOOLEAN    -- Same as BOOL.

SMALLINT(size) -- A small integer with a signed range of -32768 to 32767, and an unsigned range from 0 to 65535. Here, the size parameter specifies the maximum allowed display width, which is 255.

MEDIUMINT(size) -- A medium integer with a signed range of -8388608 to 8388607, and an unsigned range from 0 to 16777215. Here, the size parameter specifies the maximum allowed display width, which is 255.

INT(size) -- A medium integer with a signed range of -2147483648 to 2147483647, and an unsigned range from 0 to 4294967295. Here, the size parameter specifies the maximum allowed display width, which is 255.

INTEGER(size) -- Same as INT.

BIGINT(size) -- A medium integer with a signed range of -9223372036854775808 to 9223372036854775807, and an unsigned range from 0 to 18446744073709551615. Here, the size parameter specifies the maximum allowed display width, which is 255.

FLOAT(p) -- A floating point number value. If the precision (p) parameter is between 0 to 24, then the data type is set to FLOAT(), whilst if it's from 25 to 53, the data type is set to DOUBLE(). This behaviour is to make the storage of values more efficient.

DOUBLE(size, d) -- A floating point number value where the total digits are set by the size parameter, and the number of digits after the decimal point is set by the d parameter.

DECIMAL(size, d) -- An exact fixed point number where the total number of digits is set by the size parameters, and the total number of digits after the decimal point is set by the d parameter.

DEC(size, d) -- Same as DECIMAL.

3. Date/Time Data Types

DATE -- A simple date in YYYY-MM–DD format, with a supported range from ‘1000-01-01’ to ‘9999-12-31’.

DATETIME(fsp) -- A date time in YYYY-MM-DD hh:mm:ss format, with a supported range from ‘1000-01-01 00:00:00’ to ‘9999-12-31 23:59:59’. By adding DEFAULT and ON UPDATE to the column definition, it automatically sets to the current date/time.

TIMESTAMP(fsp) -- A Unix Timestamp, which is a value relative to the number of seconds since the Unix epoch (‘1970-01-01 00:00:00’ UTC). This has a supported range from ‘1970-01-01 00:00:01’ UTC to ‘2038-01-09 03:14:07’ UTC.
By adding DEFAULT CURRENT_TIMESTAMP and ON UPDATE CURRENT TIMESTAMP to the column definition, it automatically sets to current date/time.

TIME(fsp) -- A time in hh:mm:ss format, with a supported range from ‘-838:59:59’ to ‘838:59:59’.

YEAR -- A year, with a supported range of ‘1901’ to ‘2155’.

SQL Operators

1. Arithmetic Operators in SQL

+ -- Add
– -- Subtract
* -- Multiply
/ -- Divide
% -- Modulus

2. Bitwise Operators in SQL

& -- Bitwise AND
| -- Bitwise OR
^-- Bitwise XOR

3. Comparison Operators in SQL

= -- Equal to
> -- Greater than
< -- Less than
>= -- Greater than or equal to
<= -- Less than or equal to
<> -- Not equal to

4. Compound Operators in SQL

+= -- Add equals
-= -- Subtract equals
*= -- Multiply equals
/= -- Divide equals
%= -- Modulo equals
&= -- Bitwise AND equals
^-= -- Bitwise exclusive equals
|*= -- Bitwise OR equals

SQL Functions

1. String Functions in SQL

ASCII -- Returns the equivalent ASCII value for a specific character.

CHAR_LENGTH -- Returns the character length of a string.

CHARACTER_LENGTH -- Same as CHAR_LENGTH.

CONCAT -- Adds expressions together, with a minimum of 2.

CONCAT_WS -- Adds expressions together, but with a separator between each value.

FIELD -- Returns an index value relative to the position of a value within a list of values.

FIND IN SET -- Returns the position of a string in a list of strings.

FORMAT -- When passed a number, returns that number formatted to include commas (eg 3,400,000).

INSERT -- Allows you to insert one string into another at a certain point, for a certain number of characters.

INSTR -- Returns the position of the first time one string appears within another.

LCASE -- Converts a string to lowercase.

LEFT -- Starting from the left, extracts the given number of characters from a string and returns them as another.

LENGTH -- Returns the length of a string, but in bytes.

LOCATE -- Returns the first occurrence of one string within another,

LOWER -- Same as LCASE.

LPAD -- Left pads one string with another, to a specific length.

LTRIM -- Removes any leading spaces from the given string.

MID -- Extracts one string from another, starting from any position.

POSITION -- Returns the position of the first time one substring appears within another.

REPEAT -- Allows you to repeat a string

REPLACE -- Allows you to replace any instances of a substring within a string, with a new substring.

REVERSE    -- Reverses the string.

RIGHT -- Starting from the right, extracts the given number of characters from a string and returns them as another.

RPAD -- Right pads one string with another, to a specific length.

RTRIM -- Removes any trailing spaces from the given string.

SPACE -- Returns a string full of spaces equal to the amount you pass it.

STRCMP -- Compares 2 strings for differences

SUBSTR -- Extracts one substring from another, starting from any position.

SUBSTRING -- Same as SUBSTR

SUBSTRING_INDEX    -- Returns a substring from a string before the passed substring is found the number of times equals to the passed number.

TRIM --    Removes trailing and leading spaces from the given string. Same as if you were to run LTRIM and RTRIM together.

UCASE -- Converts a string to uppercase.

UPPER -- Same as UCASE.

2. Numeric Functions in SQL

ABS -- Returns the absolute value of the given number.

ACOS -- Returns the arc cosine of the given number.

ASIN -- Returns the arc sine of the given number.

ATAN -- Returns the arc tangent of one or 2 given numbers.

ATAN2 -- Returns the arc tangent of 2 given numbers.

AVG -- Returns the average value of the given expression.

CEIL -- Returns the closest whole number (integer) upwards from a given decimal point number.

CEILING -- Same as CEIL.

COS -- Returns the cosine of a given number.

COT -- Returns the cotangent of a given number.

COUNT -- Returns the amount of records that are returned by a SELECT query.

DEGREES -- Converts a radians value to degrees.

DIV -- Allows you to divide integers.

EXP -- Returns e to the power of the given number.

FLOOR -- Returns the closest whole number (integer) downwards from a given decimal point number.

GREATEST -- Returns the highest value in a list of arguments.

LEAST -- Returns the smallest value in a list of arguments.

LN -- Returns the natural logarithm of the given number.

LOG -- Returns the natural logarithm of the given number, or the logarithm of the given number to the given base.

LOG10 -- Does the same as LOG, but to base 10.

LOG2 -- Does the same as LOG, but to base 2.

MAX -- Returns the highest value from a set of values.

MIN -- Returns the lowest value from a set of values.

MOD -- Returns the remainder of the given number divided by the other given number.

PI -- Returns PI.

POW -- Returns the value of the given number raised to the power of the other given number.

POWER -- Same as POW.

RADIANS -- Converts a degrees value to radians.

RAND -- Returns a random number.

ROUND -- Rounds the given number to the given amount of decimal places.

SIGN -- Returns the sign of the given number.

SIN -- Returns the sine of the given number.

SQRT -- Returns the square root of the given number.

SUM -- Returns the value of the given set of values combined.

TAN -- Returns the tangent of the given number.

TRUNCATE -- Returns a number truncated to the given number of decimal places.

3. Date Functions in SQL

ADDDATE -- Adds a date interval (eg: 10 DAY) to a date (eg: 20/01/20) and returns the result (eg: 20/01/30).

ADDTIME -- Adds a time interval (eg: 02:00) to a time or datetime (05:00) and returns the result (07:00).

CURDATE -- Gets the current date.

CURRENT_DATE -- Same as CURDATE.

CURRENT_TIME -- Gest the current time.

CURRENT_TIMESTAMP -- Gets the current date and time.

CURTIME -- Same as CURRENT_TIME.

DATE -- Extracts the date from a datetime expression.

DATEDIFF -- Returns the number of days between the 2 given dates.

DATE_ADD -- Same as ADDDATE.

DATE_FORMAT -- Formats the date to the given pattern.

DATE_SUB -- Subtracts a date interval (eg: 10 DAY) to a date (eg: 20/01/20) and returns the result (eg: 20/01/10).

DAY -- Returns the day for the given date.

DAYNAME -- Returns the weekday name for the given date.

DAYOFWEEK -- Returns the index for the weekday for the given date.

DAYOFYEAR -- Returns the day of the year for the given date.

EXTRACT -- Extracts from the date the given part (eg MONTH for 20/01/20 = 01).

FROM DAYS -- Returns the date from the given numeric date value.

HOUR -- Returns the hour from the given date.

LAST DAY -- Gets the last day of the month for the given date.

LOCALTIME -- Gets the current local date and time.

LOCALTIMESTAMP -- Same as LOCALTIME.

MAKEDATE -- Creates a date and returns it, based on the given year and number of days values.

MAKETIME -- Creates a time and returns it, based on the given hour, minute and second values.

MICROSECOND -- Returns the microsecond of a given time or datetime.

MINUTE -- Returns the minute of the given time or datetime.

MONTH -- Returns the month of the given date.

MONTHNAME -- Returns the name of the month of the given date.

NOW -- Same as LOCALTIME.

PERIOD_ADD -- Adds the given number of months to the given period.

PERIOD_DIFF -- Returns the difference between 2 given periods.

QUARTER -- Returns the year quarter for the given date.

SECOND -- Returns the second of a given time or datetime.

SEC_TO_TIME -- Returns a time based on the given seconds.

STR_TO_DATE -- Creates a date and returns it based on the given string and format.

SUBDATE -- Same as DATE_SUB.

SUBTIME -- Subtracts a time interval (eg: 02:00) to a time or datetime (05:00) and returns the result (03:00).

SYSDATE -- Same as LOCALTIME.

TIME -- Returns the time from a given time or datetime.

TIME_FORMAT -- Returns the given time in the given format.

TIME_TO_SEC -- Converts and returns a time into seconds.

TIMEDIFF -- Returns the difference between 2 given time/datetime expressions.

TIMESTAMP -- Returns the datetime value of the given date or datetime.

TO_DAYS -- Returns the total number of days that have passed from ‘00-00-0000’ to the given date.

WEEK -- Returns the week number for the given date.

WEEKDAY -- Returns the weekday number for the given date.

WEEKOFYEAR -- Returns the week number for the given date.

YEAR -- Returns the year from the given date.

YEARWEEK -- Returns the year and week number for the given date.

4. Miscellaneous Functions in SQL

BIN -- Returns the given number in binary.

BINARY -- Returns the given value as a binary string.

CAST -- Converst one type into another.

COALESCE -- From a list of values, returns the first non-null value.

CONNECTION_ID -- For the current connection, returns the unique connection ID.

CONV -- Converts the given number from one numeric base system into another.

CONVERT -- Converts the given value into the given datatype or character set.

CURRENT_USER -- Returns the user and hostname which was used to authenticate with the server.

DATABASE -- Gets the name of the current database.

GROUP BY -- Used alongside aggregate functions (COUNT, MAX, MIN, SUM, AVG) to group the results.

HAVING -- Used in the place of WHERE with aggregate functions.

IF -- If the condition is true it returns a value, otherwise it returns another value.

IFNULL -- If the given expression equates to null, it returns the given value.

ISNULL -- If the expression is null, it returns 1, otherwise returns 0.

LAST_INSERT_ID -- For the last row which was added or updated in a table, returns the auto increment ID.

NULLIF -- Compares the 2 given expressions. If they are equal, NULL is returned, otherwise the first expression is returned.

SESSION_USER -- Returns the current user and hostnames.

SYSTEM_USER -- Same as SESSION_USER.

USER -- Same as SESSION_USER.

VERSION -- Returns the current version of the MySQL powering the database.

Wildcard Characters in SQL

In SQL, Wildcards are special characters used with the LIKE and NOT LIKE keywords. This allows us to search for data with sophisticated patterns rather efficiently.

% -- Equates to zero or more characters.
-- Example: Find all customers with surnames ending in ‘ory’.
SELECT * FROM customers
WHERE surname LIKE '%ory';

_ -- Equates to any single character.
-- Example: Find all customers living in cities beginning with any 3 characters, followed by ‘vale’.
SELECT * FROM customers
WHERE city LIKE '_ _ _vale';

[charlist] -- Equates to any single character in the list.
-- Example: Find all customers with first names beginning with J, K or T.
SELECT * FROM customers
WHERE first_name LIKE '[jkt]%';

SQL Keys

In relational databases, there is a concept of primary and foreign keys. In SQL tables, these are included as constraints, where a table can have a primary key, a foreign key, or both.

1. Primary Keys in SQL

A primary lets each record in a table be uniquely identified. You can only have one primary key per table, and you can assign this constraint to any single or combination of columns. However, this means each value within this column(s) needs to be unique.

Typically in a table, the ID column is a primary key, and is usually paired with the AUTO_INCREMENT keyword. This means the value increases automatically as and when new records are created.

Example (MySQL)

Create a new table and set the primary key to the ID column.

CREATE TABLE customers (
id int NOT NULL AUTO_INCREMENT,
FirstName varchar(255),
Last Name varchar(255) NOT NULL,
address varchar(255),
email varchar(255),
PRIMARY KEY (id)
);

2. Foreign Keys in SQL

You can apply a foreign key to one column or many. You use it to link 2 tables together in a relational database.

The table containing the foreign key is called the child key,

The table containing the referenced (or candidate) key is called the parent table.

This essentially means that the column data is shared between 2 tables, because a foreign key also prevents invalid data from being inserted which isn’t also present in the parent table.

Example (MySQL)

Create a new table and turn any column that references IDs in other tables into foreign keys.

CREATE TABLE orders (
id int NOT NULL,
user_id int,
product_id int,
PRIMARY KEY (id),
FOREIGN KEY (user_id) REFERENCES users(id),
FOREIGN KEY (product_id) REFERENCES products(id)
);

Indexes in SQL

Indexes are attributes that can be assigned to columns that are frequently searched against to make data retrieval a quicker and more efficient process.

CREATE INDEX -- Creates an index named ‘idx_test’ on the first_name and surname columns of the users table. In this instance, duplicate values are allowed.
CREATE INDEX idx_test
ON users (first_name, surname);
CREATE UNIQUE INDEX -- The same as the above, but no duplicate values.
CREATE UNIQUE INDEX idx_test
ON users (first_name, surname);
DROP INDEX -- Removes an index.
ALTER TABLE users
DROP INDEX idx_test;

SQL Joins

In SQL, a JOIN clause is used to return a result which combines data from multiple tables, based on a common column which is featured in both of them.

There are a number of different joins available for you to use:

• Inner Join (Default): Returns any records which have matching values in both tables.

• Left Join: Returns all of the records from the first table, along with any matching records from the second table.

• Right Join: Returns all of the records from the second table, along with any matching records from the first.

• Full Join: Returns all records from both tables when there is a match.

A common way of visualising how joins work is like this:

Source: Website Setup

SELECT orders.id, users.FirstName, users.Surname, products.name as ‘product name’
FROM orders
INNER JOIN users on orders.user_id = users.id
INNER JOIN products on orders.product_id = products.id;

Views in SQL

A view is essentially an SQL results set that gets stored in the database under a label, so you can return to it later without having to rerun the query.

These are especially useful when you have a costly SQL query which you might need a number of times. So instead of running it over and over to generate the same results set, you can just do it once and save it as a view.

How to Create Views in SQL

To create a view, you can do so like this:

CREATE VIEW priority_users AS
SELECT * FROM users
WHERE country = ‘United Kingdom’;

Then in future, if you need to access the stored result set, you can do so like this:

SELECT * FROM [priority_users];

How to Replace Views in SQL

With the CREATE OR REPLACE command, you can update a view like this:

CREATE OR REPLACE VIEW [priority_users] AS
SELECT * FROM users
WHERE country = ‘United Kingdom’ OR country=’USA’;

How to Delete Views in SQL

To delete a view, simply use the DROP VIEW command.

DROP VIEW priority_users;

Conclusion

The majority of websites and applications use relational databases in some way or the other. This makes SQL extremely valuable to know as it allows you to create more complex, functional systems.

Happy learning!

A few days later, I found that he was still trying to figure out how to get it to work on his machine.

After dozens of hours, I finally found out why — Caer implemented code from the previous versions of other Python packages that simply wasn't available in their newer releases.

And so despite having those packages installed, my friend wasn’t able to run Caer.

Issues like this aren’t specific to Python packages. You might face something similar when moving locally-built code into production and not have it work because of different operating systems.

But what if there was a way to mitigate this issue of portability?

Well, there is – Docker!

Before we talk about Docker, you need to understand the intuition behind a container.

What is a Container?

A container is an entire runtime environment: an application with all its dependencies, libraries, binaries, and configuration files needed to run it, bundled up into one package.

Photo by [Unsplash](https://unsplash.com/@victoire_jonch?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">Victoire Joncheray / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit)

Containerization abstracts away differences in OS distributions, application dependencies, and underlying infrastructure.

Containers are like VMs, but way smaller

With virtualization, these containers are called Virtual Machines. These include the operating system in addition to the application. A server running three virtual machines may have three different operating systems running on top of it.

Imagine how bulky this can get.

In contrast, you can have the same server run 3 containerized applications with Docker that all run the same operating system. The parts of the operating system that are shared are read-only, while a container has a mount (a way to access the container) for writing.

While VMs may be several gigabytes in size, a container may be just a few megabytes in size.

The magic of containers

When applications are containerized, only the operating system is virtualized, as opposed to hardware (as is the case with VMs). Instead of provisioning hardware, a virtual OS is provisioned to the application, enabling you to run multiple applications and set resource-limitations as you please.

Source: Container Journal

How to Use Docker

Docker is a containerization tool used that developers use to spin up isolated, reproducible environments for their applications.

It has a fast development process, it is easy to use, it works the same on local machines, dev, staging, and production servers, and it is extremely scalable.

Docker, in fact, drove the shift to the containerization of applications, and is, to no one's surprise, the most powerful player in the market today.

How to install Docker

• Windows or MacOS: Install Docker Desktop

• Linux: Install Docker and Docker Compose

If you are on Linux, you’ll need to run your commands as root or add the user to the Docker group:

sudo usermod -aG docker $(thatsme)

How to Create a Dockerfile

In Python, to containerize an application, you will need to pack it as a Docker Image. To generate one, you need to define a Dockerfile. This name of the file is simply DOCKERFILE (no extension).

# Defining a base image (Python 3 in our case)
FROM python:3# Adding a Python script to be run

ADD hello_world_script.py /

# If our script uses the Caer package, we'll have to pip install it:RUN pip install caer

# To execute the Python script:
CMD [ "python", "./hello_world_script.py" ]

• FROM instructs Docker what image the application is based on (a mouthful, I know)

• RUN executes any additional commands (such as a pip install)

• CMD executes the commands when the image is loaded

For this demonstration, I have used the caer package that you can install with a simple pip install caer .

Suppose, our hello_world_script.py script looks like this:

import caer

print(caer.__version__)

img = caer.imread('./img1.png')

print(img.shape) # image shape
print(img) # image tensor

To build the image from the Dockerfile, go ahead and run the following:

docker build -t caer-readimg .

Once the image has been built, you’ll be able to run it as a container.

You’ll also notice a ‘caer-readimg’ image (you can view all your Docker image by running the docker images command).

To run this image,

docker run caer-readimg

How to delete a Docker Image

# The image_id can be found when you run `docker images`

docker rmi <image_id>

How to delete a Docker Container

# Retrieve the container ID:
docker ps -a 

# Deleting the container
docker rm <container_id>

Wrapping Up

That’s how easy it is to get started with Docker. Of course, you probably don't need to build a Docker image if your application is as simple as the code discussed above – but it makes sense especially if you’re working on the same project with multiple people.

Be sure to follow me on Twitter for updates on future articles. Happy learning!

In this article, we'll explore what the map() function is and how to use it in your code.

The map() function in Python

The map() function (which is a built-in function in Python) is used to apply a function to each item in an iterable (like a Python list or dictionary). It returns a new iterable (a map object) that you can use in other parts of your code.

The general syntax for this is:

map(function, iterable, [iterable1, iterable2, ...])

Let's see an example: imagine you have a list of numbers, and you want to create a new list with the cubes of the numbers in the first list. A traditional approach would involve using the for loop:

org_list = [1, 2, 3, 4, 5]
fin_list = []

for num in org_list:
    fin_list.append(num**3)

print(fin_list) # [1, 8, 27, 64, 125]

which is perfectly valid, but let's see how using the map() function simplifies your code:

org_list = [1, 2, 3, 4, 5]

# define a function that returns the cube of `num`
def cube(num):
    return num**3

fin_list = list(map(cube, org_list))
print(fin_list) # [1, 8, 27, 64, 125]

Don't know about you, but I find this to be much cleaner logic.

In case you're wondering what went on behind the scenes, the map() function essentially iterated through each element of the iterable (in our case, org_list) and applied the cube function on it. It finally returned a new iterable (fin_list ) with the result.

How to Use Lambda Expressions in Python

Instead of writing a separate function to calculate the cube of a number, we can use a lambda expression in its place. Here's how you'd do that:

fin_list = list(map(lambda x:x**3, org_list))
print(fin_list) # [1, 8, 27, 64, 125]

Much cleaner, wouldn't you agree?

How to Use Built-in Functions in Python

You can also pass in built-in Python functions. For example if you had a list of strings, you can easily create a new list with the length of each string in the list.

org_list = ["Hello", "world", "freecodecamp"]
fin_list = list(map(len, org_list))
print(fin_list) # [5, 5, 12]

How to Use Functions with Multiple Iterables in Python

So far we've passed into map() functions that take only one argument (recall the cube(num)). But what if your function takes in multiple arguments? An example of this would be the pow(x, y) function that takes in 2 arguments (it returns the result of x^y).

To apply a function with multiple arguments, simply pass in another iterable name following the first one.

base = [1, 2, 3, 4]
power = [1, 2, 3, 4]

result = list(map(pow, base, power))
print(result) # [1, 4, 27, 256]

Wrapping Up

In this article, you've learned how to work with the map() function in Python. You also saw how it can dramatically reduce the size of your code, making it more readable and bug-free.

You should now be comfortable working with map() using built-in functions, lambda expressions, and even your own custom function!

Be sure to follow me on Twitter for updates on future articles. Have a nice one!

In this tutorial, we'll explore what sets are, how to create them, and the different operations you can use on them.

What are sets in Python?

In Python, sets are exactly like lists except for the fact that their elements are immutable (that means you cannot change/mutate an element of a set once declared). However, you can add/remove elements from the set.

If that was confusing, let me try and summarize:

A set is a mutable, unordered group of elements, where the elements themselves are immutable.

Another characteristic of a set is that it may include elements of different types. This means you can have a group of numbers, strings, and even tuples, all in the same set!

How to Create a Set

The most common way of creating a set in Python is by using the built-in set() function.

>>> first_set = set(("Connor", 32, (1, 2, 3)))
>>> first_set
{32, 'Connor', (1, 2, 3)}
>>> 
>>> second_set = set("Connor")
>>> second_set
{'n', 'C', 'r', 'o'}

You can also create sets using the curly brace {} syntax:

>>> third_set = {"Apples", ("Bananas", "Oranges")}
>>> type(third_set)
<class 'set'>

The set() function takes in an iterable and yields a list of objects which will be inserted into the set. The {} syntax places the objects themselves into the set.

As you've probably realized, whether you use the set() function or the {} to create a set, each element needs to be an immutable object. So if you add a list (which is a mutable object) to a set, you'll run into an error:

>>> incorrect_set = {"Apples", ["Bananas", "Oranges"]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

How to Add or Remove Elements in a Set

We already know that sets are mutable. This means you can add/remove elements in a set.

Here's an example of adding elements to a set using the update() function.

>>> add_set = set((1, 2, 3, 4))
>>> add_set
{1, 2, 3, 4}
>>>
>>> add_set.update((1,))
>>> add_set
{1, 2, 3, 4}
>>> add_set.update(("cello", "violin"))
>>> add_set
{1, 2, 3, 4, 'violin', 'cello'}

But notice how nothing changes when we try to add "cello" to the set again:

>>> add_set.update(("cello",))
>>> add_Set
{1, 2, 3, 4, 'violin', 'cello'}

This is because sets in Python cannot contain duplicates. So, when we tried to add "cello" again to the set, Python recognized we were trying to add a duplicate element and didn't update the set. This is one caveat that differentiates sets from lists.

Here's how you would remove elements from a set:

>>> sub_set = add_set
>>> sub_set.remove("violin")
>>> sub_set
{1, 2, 3, 4, 'cello'}

The remove(x) function removes the element x from a set. It returns a KeyError if x is not part of the set:

>>> sub_set.remove("guitar")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'guitar'

There are a couple of other ways to remove an element(s) from a set:

• the discard(x) method removes x from the set, but doesn't raise any error if x is not present in the set.

• the pop() method removes and returns a random element from the set.

• the clear() method removes all elements from a set

Here are some examples to illustrate:

>>> m_set = set((1, 2, 3, 4))
>>> 
>>> m_set.discard(5) # no error raised even though '5' is not present in the set
>>>
>>> m_set.pop()
4
>>> m_set
{1, 2, 3}
>>>
>>> m_set.clear()
>>> m_set
set()

Python set() Operations

If you remember your basic high school math, you'll probably recall mathematical set operations like union, intersection, difference and symmetric difference. Well, you can achieve the same thing with Python sets.

1. Set Union

The union of two sets is the set of all the elements of both the sets without duplicates. You can use the union() method or the | syntax to find the union of a Python set.

>>> first_set = {1, 2, 3}
>>> second_set = {3, 4, 5}
>>> first_set.union(second_set)
{1, 2, 3, 4, 5}
>>>
>>> first_set | second_set     # using the `|` operator
{1, 2, 3, 4, 5}

2. Set Intersection

The intersection of two sets is the set of all the common elements of both the sets. You can use the intersection() method of the & operator to find the intersection of a Python set.

>>> first_set = {1, 2, 3, 4, 5, 6}
>>> second_set = {4, 5, 6, 7, 8, 9}
>>> first_set.intersection(second_set)
{4, 5, 6}
>>>
>>> first_set & second_set     # using the `&` operator
{4, 5, 6}

3. Set Difference

The difference between two sets is the set of all the elements in first set that are not present in the second set. You would use the difference() method or the - operator to achieve this in Python.

>>> first_set = {1, 2, 3, 4, 5, 6}
>>> second_set = {4, 5, 6, 7, 8, 9}
>>> first_set.difference(second_set)
{1, 2, 3}
>>>
>>> first_set - second_set     # using the `-` operator
{1, 2, 3}
>>>
>>> second_set - first_set
{8, 9, 7}

4. Set Symmetric Difference

The symmetric difference between two sets is the set of all the elements that are either in the first set or the second set but not in both.

You have the choice of using either the symmetric_difference() method or the ^ operator to do this in Python.

>>> first_set = {1, 2, 3, 4, 5, 6}
>>> second_set = {4, 5, 6, 7, 8, 9}
>>> first_set.symmetric_difference(second_set)
{1, 2, 3, 7, 8, 9}
>>>
>>> first_set ^ second_set     # using the `^` operator
{1, 2, 3, 7, 8, 9}

How to Modify a Set by Operations

Each of the set() operations that we discussed above can be used to modify an existing Python set. Similar to how you would use an augmented assignment syntax such as += or *= to update a variable, you can do the same for sets:

>>> a = {1, 2, 3, 4, 5, 6}
>>> b = {4, 5, 6, 7, 8, 9}
>>>
>>> a.update(b)          # a "union" operation
>>> a
{1, 2, 3, 4, 5, 6, 7, 8, 9}
>>>
>>> a &= b               # the "intersection" operation
>>> a
{4, 5, 6, 7, 8, 9}
>>>
>>> a -= set((7, 8, 9))  # the "difference" operation
>>> a
{4, 5, 6}
>>>
>>> a ^= b               # the "symmetric difference" operation
>>> a
{7, 8, 9}

Other Set Operations in Python

These are not so common, but they're useful in seeing how sets relate to others.

• the a.issubset(b) method or <= operator returns true if the a is a subset of b

• the a.issuperset(b) method or >= operator returns true if the a is a superset of b

• the a.isdisjoint(b) method return true if there are no common elements between sets a and b

Frozen Sets in Python

Because sets are mutable, they are unhashable – which means you cannot use them as dictionary keys.

Python allows you to work around this by using a frozenset instead. This has all the properties of a set, except that it is immutable (this means that you cannot add/remove elements from the frozenset). It is also hashable, so it can be used as keys to a dictionary.

The frozenset datatype has all the methods of a set (such as difference(), symmetric_difference, and union) but because it is immutable, it doesn't have methods to add/remove elements.

>>> a = frozenset((1, 2, 3, 4))
>>> b = frozenset((3, 4, 5, 6))
>>>
>>> a.issubset(b)
False
>>> a.update(b)    # raises an error
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'update'

And using frozensets as dictionary keys is as simple as 1, 2, 3:

>>> a = frozenset((1, 2, 3, 4))
>>> b = frozenset(("w", "x", "y", "z"))
>>>
>>> d = {a: "hello", b: "world"}
>>> d
{frozenset({1, 2, 3, 4}): 'hello', frozenset({'w', 'x', 'y', 'z'}): 'world'}

Wrapping Up

That's it! You've learned about what sets are, how to create and work with them, and different operations you can use on them.

With sets done, you should now be comfortable with most of Python built-in functions. All you need to do now is practice. Good luck!

Be sure to follow me on Twitter for more updates. Have a nice one!