# 30 seconds of python

## Snippet List

Click on a snippetâ€™s name to view its code or a tag name to view all snippets in that category.

### List

#### all_equal

Check if all elements in a list are equal.

Use `[1:]`

and `[:-1]`

to compare all the values in the given list.

#### all_unique

Returns `True`

if all the values in a flat list are unique, `False`

otherwise.

Use `set()`

on the given list to remove duplicates, compare its length with the length of the list.

#### bifurcate

Splits values into two groups.
If an element in `filter`

is `True`

, the corresponding element in the collection belongs to the first group; otherwise, it belongs to the second group.

Use list comprehension and `enumerate()`

to add elements to groups, based on `filter`

.

#### bifurcate_by

Splits values into two groups according to a function, which specifies which group an element in the input list belongs to.
If the function returns `True`

, the element belongs to the first group; otherwise, it belongs to the second group.

Use list comprehension to add elements to groups, based on `fn`

.

#### chunk

Chunks a list into smaller lists of a specified size.

Use `list()`

and `range()`

to create a list of the desired `size`

.
Use `map()`

on the list and fill it with splices of the given list.
Finally, return use created list.

#### compact

Removes falsey values from a list.

Use `filter()`

to filter out falsey values (`False`

, `None`

, `0`

, and `""`

).

#### count_by

Groups the elements of a list based on the given function and returns the count of elements in each group.

Use `map()`

to map the values of the given list using the given function.
Iterate over the map and increase the element count each time it occurs.

#### count_occurences

Counts the occurrences of a value in a list.

Increment a counter for every item in the list that has the given value and is of the same type.

#### deep_flatten

Deep flattens a list.

Use recursion.
Define a function, `spread`

, that uses either `list.extend()`

or `list.append()`

on each element in a list to flatten it.
Use `list.extend()`

with an empty list and the `spread`

function to flatten a list.
Recursively flatten each element that is a list.

#### difference

Returns the difference between two iterables.

Create a `set`

from `b`

, then use list comprehension on `a`

to only keep values not contained in the previously created set, `_b`

.

#### difference_by

Returns the difference between two lists, after applying the provided function to each list element of both.

Create a `set`

by applying `fn`

to each element in `b`

, then use list comprehension in combination with `fn`

on `a`

to only keep values not contained in the previously created set, `_b`

.

#### every

Returns `True`

if the provided function returns `True`

for every element in the list, `False`

otherwise.

Use `all()`

in combination with `map`

and `fn`

to check if `fn`

returns `True`

for all elements in the list.

#### every_nth

Returns every nth element in a list.

Use `[nth-1::nth]`

to create a new list that contains every nth element of the given list.

#### filter_non_unique

Filters out the non-unique values in a list.

Use list comprehension and `list.count()`

to create a list containing only the unique values.

#### filter_unique

Filters out the unique values in a list.

Use list comprehension and `list.count()`

to create a list containing only the non-unique values.

#### flatten

Flattens a list of lists once.

Use nested list comprehension to extract each value from sub-lists in order.

#### group_by

Groups the elements of a list based on the given function.

Use `map()`

and `fn`

to map the values of the list to the keys of an object.
Use list comprehension to map each element to the appropriate `key`

.

#### has_duplicates

Returns `True`

if there are duplicate values in a flast list, `False`

otherwise.

Use `set()`

on the given list to remove duplicates, compare its length with the length of the list.

#### head

Returns the head of a list.

use `lst[0]`

to return the first element of the passed list.

#### initial

Returns all the elements of a list except the last one.

Use `lst[0:-1]`

to return all but the last element of the list.

#### initialize_2d_list

Initializes a 2D list of given width and height and value.

Use list comprehension and `range()`

to generate `h`

rows where each is a list with length `h`

, initialized with `val`

.
If `val`

is not provided, default to `None`

.

#### initialize_list_with_range

Initializes a list containing the numbers in the specified range where `start`

and `end`

are inclusive with their common difference `step`

.

Use `list`

and `range()`

to generate a list of the appropriate length, filled with the desired values in the given range.
Omit `start`

to use the default value of `0`

.
Omit `step`

to use the default value of `1`

.

#### initialize_list_with_values

Initializes and fills a list with the specified value.

Use list comprehension and `range()`

to generate a list of length equal to `n`

, filled with the desired values.
Omit `val`

to use the default value of `0`

.

#### intersection

Returns a list of elements that exist in both lists.

Create a `set`

from `a`

and `b`

, then use the built-in set operator `&`

to only keep values contained in both sets, then transform the `set`

back into a `list`

.

#### intersection_by

Returns a list of elements that exist in both lists, after applying the provided function to each list element of both.

Create a `set`

by applying `fn`

to each element in `b`

, then use list comprehension in combination with `fn`

on `a`

to only keep values contained in both lists.

#### last

Returns the last element in a list.

use `lst[-1]`

to return the last element of the passed list.

#### longest_item

Takes any number of iterable objects or objects with a length property and returns the longest one. If multiple objects have the same length, the first one will be returned.

Use `max()`

with `len`

as the `key`

to return the item with the greatest length.

#### max_element_index

Returns the pindex of the element with the maximum value in a list.

Use `max()`

and `list.index()`

to get the maximum value in the list and return its index.

#### max_n

Returns the `n`

maximum elements from the provided list.
If `n`

is greater than or equal to the provided list's length, then return the original list (sorted in descending order).

Use `sorted()`

to sort the list, `[:n]`

to get the specified number of elements.
Omit the second argument, `n`

, to get a one-element list.

#### min_n

Returns the `n`

minimum elements from the provided list.
If `n`

is greater than or equal to the provided list's length, then return the original list (sorted in ascending order).

Use `sorted() to sort the list,`

[:n]```
to get the specified number of elements.
Omit the second argument,
```

n`, to get a one-element list.

#### most_frequent

Returns the most frequent element in a list.

Use `set(list)`

to get the unique values in the `list`

combined with `max()`

to find the element that has the most appearances.

#### none

Returns `False`

if the provided function returns `True`

for at least one element in the list, `True`

otherwise.

Use `all()`

and `fn`

to check if `fn`

returns `False`

for all the elements in the list.

#### offset

Moves the specified amount of elements to the end of the list.

Use `lst[offset:]`

and `lst[:offset]`

to get the two slices of the list and combine them before returning.

#### sample

Returns a random element from an array.

Use `randint()`

to generate a random number that corresponds to an index in the list, return the element at that index.

#### shuffle

Randomizes the order of the values of an list, returning a new list.

Uses the Fisher-Yates algorithm to reorder the elements of the list.

#### similarity

Returns a list of elements that exist in both lists.

Use list comprehension on `a`

to only keep values contained in both lists.

#### some

Returns `True`

if the provided function returns `True`

for at least one element in the list, `False`

otherwise.

Use `any()`

in combination with `map()`

and `fn`

to check if `fn`

returns `True`

for any element in the list.

#### spread

Flattens a list, by spreading its elements into a new list.

Loop over elements, use `list.extend()`

if the element is a list, `list.append()`

otherwise.

#### symmetric_difference

Returns the symmetric difference between two iterables, without filtering out duplicate values.

Create a `set`

from each list, then use list comprehension on each one to only keep values not contained in the previously created set of the other.

#### symmetric_difference_by

Returns the symmetric difference between two lists, after applying the provided function to each list element of both.

Create a `set`

by applying `fn`

to each element in every list, then use list comprehension in combination with `fn`

on each one to only keep values not contained in the previously created set of the other.

#### tail

Returns all elements in a list except for the first one.

Return `lst[1:]`

if the list's length is more than `1`

, otherwise, return the whole list.

#### transpose

Returns the transpose of a two-dimensional list.

Use `*lst`

to get the passed list as tuples.
Use `zip()`

in combination with `list()`

to create the transpose of the given two-dimensional list.

#### union

Returns every element that exists in any of the two lists once.

Create a `set`

with all values of `a`

and `b`

and convert to a `list`

.

#### union_by

Returns every element that exists in any of the two lists once, after applying the provided function to each element of both.

Create a `set`

by applying `fn`

to each element in `a`

, then use list comprehension in combination with `fn`

on `b`

to only keep values not contained in the previously created set, `_a`

.
Finally, create a `set`

from the previous result and `a`

and transform it into a `list`

#### unique_elements

Returns the unique elements in a given list.

Create a `set`

from the list to discard duplicated values, then return a `list`

from it.

#### zip

Creates a list of elements, grouped based on the position in the original lists.

Use `max`

combined with `list comprehension`

to get the length of the longest list in the arguments.
Loop for `max_length`

times grouping elements.
If lengths of `lists`

vary, use `fill_value`

(defaults to `None`

).

### Math

#### average

Returns the average of two or more numbers.

Use `sum()`

to sum all of the `args`

provided, divide by `len(args)`

.

#### average_by

Returns the average of a list, after mapping each element to a value using the provided function.

Use `map()`

to map each element to the value returned by `fn`

.
Use `sum()`

to sum all of the mapped values, divide by `len(lst)`

.

#### clamp_number

Clamps `num`

within the inclusive range specified by the boundary values `a`

and `b`

.

If `num`

falls within the range, return `num`

.
Otherwise, return the nearest number in the range.

#### degrees_to_rads

Converts an angle from degrees to radians.

Use `math.pi`

and the degrees to radians formula to convert the angle from degrees to radians.

#### digitize

Converts a number to an array of digits.

Use `map()`

combined with `int`

on the string representation of `n`

and return a list from the result.

#### factorial

Calculates the factorial of a number.

Use recursion.
If `num`

is less than or equal to `1`

, return `1`

.
Otherwise, return the product of `num`

and the factorial of `num - 1`

.
Throws an exception if `num`

is a negative or a floating point number.

#### fibonacci

Generates an array, containing the Fibonacci sequence, up until the nth term.

Starting with `0`

and `1`

, use `list.append() to add the sum of the last two numbers of the list to the end of the list, until the length of the list reaches`

n```
.
If
```

n`is less or equal to`

0`, return a list containing`

0`.

#### gcd

Calculates the greatest common divisor of a list of numbers.

Use `reduce()`

and `math.gcd`

over the given list.

#### in_range

Checks if the given number falls within the given range.

Use arithmetic comparison to check if the given number is in the specified range.
If the second parameter, `end`

, is not specified, the range is considered to be from `0`

to `start`

.

#### is_divisible

Checks if the first numeric argument is divisible by the second one.

Use the modulo operator (`%`

) to check if the remainder is equal to `0`

.

#### is_even

Returns `True`

if the given number is even, `False`

otherwise.

Checks whether a number is odd or even using the modulo (`%`

) operator.
Returns `True`

if the number is even, `False`

if the number is odd.

#### is_odd

Returns `True`

if the given number is odd, `False`

otherwise.

Checks whether a number is even or odd using the modulo (`%`

) operator.
Returns `True`

if the number is odd, `False`

if the number is even.

#### lcm

Returns the least common multiple of two or more numbers.

Define a function, `spread`

, that uses either `list.extend()`

or `list.append()`

on each element in a list to flatten it.
Use `math.gcd()`

and `lcm(x,y) = x * y / gcd(x,y)`

to determine the least common multiple.

#### max_by

Returns the maximum value of a list, after mapping each element to a value using the provided function.

Use `map()`

with `fn`

to map each element to a value using the provided function, use `max()`

to return the maximum value.

#### median

Finds the median of a list of numbers.

Sort the numbers of the list using `list.sort()`

and find the median, which is either the middle element of the list if the list length is odd or the average of the two middle elements if the list length is even.

#### min_by

Returns the minimum value of a list, after mapping each element to a value using the provided function.

Use `map()`

with `fn`

to map each element to a value using the provided function, use `min()`

to return the minimum value.

#### rads_to_degrees

Converts an angle from radians to degrees.

Use `math.pi`

and the radian to degree formula to convert the angle from radians to degrees.

#### sum_by

Returns the sum of a list, after mapping each element to a value using the provided function.

Use `map()`

with `fn`

to map each element to a value using the provided function, use `sum()`

to return the sum of the values.

### String

#### byte_size

Returns the length of a string in bytes.

Use `s.encode('utf-8')`

to encode the given string and return its length.

#### camel

Converts a string to camelcase.

Use `re.sub()`

to replace any `-`

or `_`

with a space, using the regexp `r"(_|-)+"`

.
Use `title()`

to capitalize the first letter of each word convert the rest to lowercase.
Finally, use `replace()`

to remove spaces between words.

#### capitalize

Capitalizes the first letter of a string.

Capitalize the first letter of the string and then add it with rest of the string.
Omit the `lower_rest`

parameter to keep the rest of the string intact, or set it to `True`

to convert to lowercase.

#### capitalize_every_word

Capitalizes the first letter of every word in a string.

Use `s.title()`

to capitalize first letter of every word in the string.

#### decapitalize

Decapitalizes the first letter of a string.

Decapitalize the first letter of the string and then add it with rest of the string.
Omit the `upper_rest`

parameter to keep the rest of the string intact, or set it to `True`

to convert to uppercase.

#### is_anagram

Checks if a string is an anagram of another string (case-insensitive, ignores spaces, punctuation and special characters).

Use `s.replace()`

to remove spaces from both strings.
Compare the lengths of the two strings, return `False`

if they are not equal.
Use `sorted()`

on both strings and compare the results.

#### kebab

Converts a string to kebab case.

Break the string into words and combine them adding `-`

as a separator, using a regexp.

#### n_times_string

Prints out the same string a defined number of times.

Repeat the string `n`

times, using the `*`

operator.

#### palindrome

Returns `True`

if the given string is a palindrome, `False`

otherwise.

Use `s.lower()`

and `re.sub()`

to convert to lowercase and remove non-alphanumeric characters from the given string.
Then, compare the new string with its reverse.

#### reverse_string

Returns the reverse of a string.

Use string slicing to reverse the string.

#### snake

Converts a string to snake case.

Break the string into words and combine them adding `_`

as a separator, using a regexp.

#### split_lines

Splits a multiline string into a list of lines.

Use `s.split()`

and `'\n'`

to match line breaks and create a list.

### Utility

#### cast_list

Casts the provided value as an array if it's not one.

Use `isinstance()`

to check if the given value is enumerable and return it by using `list()`

or encapsulated in a list accordingly.

### Object

#### keys_only

Returns a flat list of all the keys in a flat dictionary.

Use `dict.keys()`

to return the keys in the given dictionary.
Return a `list()`

of the previous result.

#### map_values

Creates an object with the same keys as the provided object and values generated by running the provided function for each value.

Use `dict.keys()`

to iterate over the object's keys, assigning the values produced by `fn`

to each key of a new object.

#### values_only

Returns a flat list of all the values in a flat dictionary.

Use `dict.values()`

to return the values in the given dictionary.
Return a `list()`

of the previous result.

#### About

A few word about us, our goals and our projects.