Please enable JavaScript.

Coggle requires JavaScript to display documents.

Python - Coggle Diagram

- - - - print(*objects, sep=' ', end='\n', file=sys.stdout, flush = False)
        Prints the output.
        
        print(a,b)
        outputs two objects separated by a space by default.
  - - - Strings
        These store a bunch of symbols
        The symbols are treated as a list: they can be iterated through and can be accessed using slicing:
        if
        a = 'hello'
        then
        print(a[o])
        displays 'h'.
        
        Strings can be concatenated or joined together using the + sign; this does not put any spaces between them.
- - - - pd.DataFrame(your_data)
        This is used to make a data frame
      - Displaying stuff
        
        print(your_dataframe.head())
        or
        print(your_dataframe[:5])
        Prints the first five rows of the dataframe
        
        Displaying specific stuff
        
        print(your_dataframe['column'])
        Prints a specific column
        If several columns are needed, their names are to be passed via an array:
        print(your_dataframe[['specific', 'columns', 'here']])
        
        Sorting
        
        print(your_dataframe[your_dataframe['column_with_numbers' > x]])
        Prints only the rows where the number in the column is greater than x
        Accepts other conditions as well
        
        your_dataframe.sort_values(['name'],ascending=True)
        Sorts values in the specified column
        
        print(your_dataframe[your_dataframe['column'].isna()])
        Prints the rows that have a missing value
        Another method for this is isnull()
        
        print(your_dataframe.info())
        Prints a summary of the dataframe (index, columns, datatypes)
      - Manipulating data
        
        Adding rows
        
        new_row = pd.DataFrame(data_as_a_dict)
        new_df = pd.concat([original_df, new_row], ignore_index = True)
        Uses the concat() function to merge two dataframes
        
        your_dataframe.loc[len(your_dataframe)] = [data]
        Uses the loc[] method to add a row to the end of the list
        Can also be used to replace a row with another: just add the index of the row you want to replace
        
        Deleting rows or columns
        
        del your_dataframe['column']
        Deletes a specified column
        
        df.drop()
        Can delete rows or columns
        To specify if a row or a column is deleted, the axis parameter is used: axis=0 is the default option and it deletes rows, while axis=1 deletes columns
        Additionally, specific columns can be selected by passing columns=['column_name'] parameter, and for deleting rows we can use index=your_index
    - - your_dataframe['column'].mean()
        Calculates a mean of a column
- - - - Regular expressions
        These are used to find (and replace) patterns
        
        Tweaks
        
        Capturing groups
        (pattern)
        Parentheses are used to define groups within the regex to extract specific parts of a match
        
        Some useful methods
        
        match.group(index)
        returns a specific group (or the entire match if index = 0)
        
        match.groups()
        returns a tuple containing all the captured groups
        
        \1
        This is used to backreference capturing groups
        
        import re
        phone = '123-456-7890
        new_phone = re.sub(r'(\d{3})-(\d{}3)-(\d{4})', r'(\1)\2-\3', phone)
        
        (?:pattern)
        This is a non-capturing group: a group that will not be included in the match
        
        (?P<name>pattern)
        This can be used to name a capturing group, allowing access by a descriptive name
        
        Lookaheads and lookbehinds
        
        Lookaheads check if your pattern is (not) followed by another pattern without including it in the match
        Positive lookahead
        (your_pattern)(?=pattern_that_should_be_here)
        Negative lookahead
```(your_pattern)(?!pattern_that_should_not_be_here)

Lookbehinds check if your pattern is (not) preceeded by another pattern without including it in the match
Positive lookbehind
(?<=pattern_that_should_be_here)(your_pattern)
Negative lookbehind
(?<!pattern_that_should_not_be_here)(your_pattern)

A brief summary:
\ - escape character
^ - start of line
\A - start of string
$ - end of line
Z - end of string
\b - word boundary
\B - not word boundary
\< - start of word
> - end of word
\s - white space
\S - not white space
\d - digit
\D - not digit
\w - any alphanumeric character
\W - not alphanumeric character
* - 0 or more symbols to the left
+ - at least one symbol to the left
? - 0 or 1 symbol to the left
{3} - exactly 3 patterns
{3,} - at least 3 patterns
{3,5} - 3 to 5 patterns
\n - new line
\r - carriage return
\t - tab
. - any character except \n
(a|b) - a or b
[abc] - a or b or c
[^abc] - not a nor b nor c
[0-7] - 0 to 7
[a-q] - a to q
[A-Q] - A to Q (upper case)

Tips and tricks

A cool, robust way to find stuff between parentheses, brackets, etc.
\[([^\]])\]
This way we capture everything between the opening (\[) and the closing (\]) bracket that is not a closing bracket ([^\]])
Useful for catching things like tags