Python Regex Groups, Match and Search

Hey, Roberts Greibers here. I’ll give you a brief intro about my 7-year experience as a Python developer down the line – later in this post. 

But now I want you to scroll a bit more and dive right into Python regex groups and the Python regex example I’ve greatly detailed below. 

The following regex Python example is going to show you.. ⚠️

• What actually is import re in Python and how you can use it!
• How to THINK and come up with your own Python regex patterns
• A real-life Python regex example (sent in by a reader of this blog post)

If you’ve been Google searching for Python re examples, you’ve found the RIGHT place!

Most regular expression Python examples you’ll find online are very theoretical, showing you just the concept of a regex capturing group.. but they don’t tell you how to THINK in order to come up with your own solutions – your own regex patterns.

In this post, I’ll take a real Python regex situation and explain what fundamental steps I take to come up with a solution. 🚀

And if you really think about it…

It’s the ONLY way for you to truly understand regex Python examples and use them for your benefit. You have to understand the fundamental process behind solving a Python problem.

So, if getting deeper into a real regular expression Python example sounds interesting to you – keep on reading!

I’m explaining the whole story of how I came to the following situation in Python where regex capture group was part of the solution down below! 👇🏻

What Are Regular Expressions In Python?

Regular expressions in Python – That’s one of the most important tools you’ll have to learn as a Python developer if you’re dealing with log file parsing, text file parsing, or any other kind of text extraction from an existing string content. 

A situation where you want to extract only a certain part of a string (like a specific ID value, number, IBAN, etc.) will appear in a lot of different industries related to Python development. 

🚨 In most Python developer interviews you’ll be asked to at least explain the concept of using regex or even showcase a regular expression example in Python. 

So I’d really recommend you pay attention to the regex Python example I’m about share with you in this post. 

What Is import re In Python?

import re in Python SIMPLY means you’re importing the regular expressions library for the Python script you’re currently working on.

Once you’ve included the following line at the top of your Python script, the regular expression Python library will be available for you.

import re

Simple Python Regex Groups Situation

Assume a very simple situation, you’re working on a small Python project and you have a text with a couple of sub-parts you want to extract.

Let’s say you want to capture groups of subtexts within that one text.

How would you do that?

import re

text = 'User-Agent: Thunderbird 1.5.0.9 (X11/20061227)'

In some cases, you could hack it away with .replace() (Python built-in function), but very often you’ll find it won’t work for slightly advanced situations.

This is exactly where you could use Python regex to capture a group or groups of strings. 

Let’s look at how you could capture two groups of strings using regex in Python.

Assume, you want to capture strings Thunderbird 1.5.0.9 and X11/20061227

THE FIRST STEP: You have to come up with a Python regex grouping pattern and that’s what we’re going to look into right now. 👇🏻

Develop Python Regex Grouping Pattern 

Coming up with a regex pattern that matches Python strings is the most difficult part of the whole capturing group of strings situation. 

To make this process easier, I’d recommend you use visual tools like regex101.com to develop the exact pattern that works with Python re match (the library). 

Coming up with the above regex pattern took me less than 2 minutes. If you already know the basics of regular expressions in Python, this should be really easy for you too.

regex101.com tool makes regex pattern development process way easier as you’re able to see if the regex pattern matches or not right away without running any Python code.

On the right side of the regex101.com page you’ll also find an in-depth explanation of what’s actually happening with the regex pattern you’ve developed – why is it working or why is it not matching anything at all.

Here’s an explanation of the above regex pattern:

And this is just a simple Python regex example that matches two groups at the same time. You can expand this pattern and introduce more regex capturing groups but in most cases, that’s not even needed.

I personally prefer not to overuse regex groups, but rather develop more than just one regex pattern.

A regex pattern for each specific case..

I’ll explain the full details of my approach later in the post.. 💯

Regex Group, Compile, Search, Match (Code)

Alright, now that you’ve got the regex pattern ( User-Agent: (.+) ((.+)) ) that matches the exact subtext you want to capture, all you need is to figure out how you can use this regex pattern in Python.

In order to use regex in Python, you need to understand the following 3 functions:

• re.compile() – compile a regular expression pattern into an object
• re.search() – search where this regular expression produces a match
• match.group() – returns one or more subgroups of the match

import re

regex = 'User-Agent: (.+) \((.+)\)'

text = 'User-Agent: Thunderbird 1.5.0.9 (X11/20061227)'

rg = re.compile(regex)

match = rg.search(text)

group_1 = match.group(1)
group_2 = match.group(2)

print('group_1: ', group_1)
print('group_2: ', group_2)

Take the above example and extend it for your needs, this is all you need to get started with regular expressions in Python.

Output:

group_1:  Thunderbird 1.5.0.9
group_2:  X11/20061227

This is just a very simple example of capturing a string group in Python with regex.

In the following section of this blog post, I’ll share and explain a regex code example with you of a real Python project situation that was sent in by one of the blog readers.

🔥 If you’re serious about becoming a Python developer, see the end of the post for details on how I could help you become a Python developer in 6-12 months.

Also one more quick note – if you’re currently exploring Python regex..

..and learning about the real usage of regular expressions, I’d suggest you read other posts I’ve written on the “regex usage in Python” topics, you’ll find a bunch of real life Python regex examples in these posts:

• Extract XML Data Tag Value With Regex
• Extract XML Content Tag Value With Regex
• Extract Product Image URL With Regex
• Python Log File Parsing With Regex

Let’s get into the regular expression example of a real Python project that was sent in by one of the blog readers.

Real Regular Expression Situation In Python

How to come up with a real regex pattern in the shortest time possible?

To be honest, when you’re working on a Python project feature with a deadline..

In most cases…

You don’t have a lot of time to develop the best regular expression pattern.. 

You just need to get the JOB DONE as soon as possible! 💯

That’s exactly the situation Hernan was in..

Python Regex: Asterisk Log Parser System

Hernan was working on an Asterisk log parser system in Python and using my blog as a Python regex resource to learn from. 

Here are email messages Hernan sent to me after running into a multi-line (several lines of logs) problem.. 📧

(use arrows ⬅ ➡ to swipe screenshots)

And down below is a small part of the Asterisk log file Hernan sent in, just so you understand what we’re going to deal with.

As you can see, the problem here is that one entry (let’s call Event + LastData one entry) is separated into multiple file lines.

Event: Cdr Privilege: cdr,all AccountCode: Source:491454490 Destination:1545454572877 110 DestinationContext: testing CallerID: Channel: Console/dsp DestinationChannel: LastApplication: Hangup
LastData: StartTime: 2010-08-23 08:27:21 AnswerTime: 2010-08-23 08:27:21 EndTime: 2010-08-23 08:28:21 Duration: 60 BillableSeconds: 0 Disposition: ANSWERED AMAFlags: DOCUMENTATION UniqueID: 1282570041.3 UserField: Rate: 0.02 Carrier: BS&S

Event: Cdr Privilege: cdr,all AccountCode: Source: Destination: 110 DestinationContext: testing CallerID: Channel: Console/dsp DestinationChannel: LastApplication: Hangup
LastData: StartTime: 2010-08-23 08:27:21 AnswerTime: 2010-08-23 08:27:21 EndTime: 2010-08-23 08:27:21 Duration: 0 BillableSeconds: 0 Disposition: ANSWERED AMAFlags: DOCUMENTATION UniqueID: 1282570041.3 UserField: Rate: 0.02 Carrier: BS&S

Usually, you would extract all the necessary information from just one line as you would iterate through the file line by line with Python for loop.

BUT now you have to come up with a way to collect information for one entry from multiple lines.

And I can see how it could be challenging for someone just starting out with regex grouping in Python.

Actually, one of my Python Mentoring students had a very similar situation at her Data Analyst job, also related to log file parsing with Python… 👇🏻

Project Of A Mentoring Student (Python Regex)

🚨 A quick note before we get into the code – why you should look out for mentors who can show you the ways of thinking they use to solve Python problems..

Not that long ago one of my Python Mentoring students had to search for specific information through Anaplan log files manually.

I know from my QA experience – skimming through log files manually to find something can be time-consuming and really, really boring – especially if you have to do it every week.

In the above screenshot, you can see one of my students – Bashobi thanking me for providing instructions on how to build a Python log parser with regex groups. 

Back in the day, I used to work with Python module re (regular expressions library) and use any regex example Python documentation provided to build my own log file parsers in order to avoid any manual work I had to do. 

🚨 In Python Mentoring we tend to focus on real Python project situations and I’m willing to share a lot of tricks and tips I’ve learned through my 7+ years of experience as a Python developer.

If you’re interested in such an approach look out for my contact information somewhere below this post and contact me.

If You Struggle With Regex In Python

… it’s really NOT YOUR FAULT!

You’ve been struggling just because every other Python tutorial you’ve read already gives you the solution to your problems and solves them for you.

Think about it, how often do you Google search for Python answers, and how often do you come up with your own solutions?

The reason I’m BRINGING THIS UP now before we get to the Python regex groups is that THIS IS THE REAL REASON YOU’RE STUCK!

You’re not surrounded by experienced Python developers who could mentor you and guide you in the RIGHT direction!

You’ve got to STOP listening to people who are not where you want to be!

Or be honest with yourself and ask yourself:

Is the person I’m listening to really giving me the information that’s going to bring me to my GOAL of becoming a Python developer?

It doesn’t matter how many Python tutorials you go through..

.. and how many dumb Linkedin or Udemy courses do you do to get meaningless “certificates”

There’s only ONE QUESTION you have to know the answer to (or at least have a strategy to get to the answer)

What’s Your Solution Here?

Are you able to come up with your own Python solution for regex or any other related problem by yourself or NOT?

It doesn’t really matter if you can copy & paste Python code from a course or a blog online, everyone can do that..

Copy & pasting code IS NOT what professional Python developers do. 

❌ And it won’t get you hired as a Python developer either. ❌

What will get you hired: is a SKILL of analyzing problems and coming up with your own Python coding solutions – that’s what I’m also teaching to my Python Mentoring students.

The ONLY way you can learn the SKILL of analyzing problems and coming up with your own solutions is through HAVING MENTORS – more experienced developers teaching you.

And that’s what I’m about to SHARE WITH YOU with the NEXT STEPS in this post.  🔥

Capturing Group Regex: Python Example Steps

💡 If you THINK about the problem Hernan was having.. 

Parsing an Asterisk log file and using Python re groups to extract a specific part of the log file text..

There’s ONLY ONE point from where you should start…

The First Step To Solving A Python Regex Problem

You need to figure out how you can access the actual Asterisk log file from your Python script.

There are a couple of ways to open a file in Python …

… but the easiest and the simplest way to open a file for reading is to use with statement together with Python’s built-in open() function.

Change 'path/to/logfile.txt' part if you want to open your own file, the provided code below is just an example.

If you downloaded asterisk.txt from a download link provided earlier in the post, you want to change this path to 'path/to/asterisk.txt'

For reading a file, always use mode='r' which basically means you’re opening a file in reading mode.

with open('path/to/logfile.txt', 'r') as file:
    not_empty_lines = [
        line.replace('\n', '')
        for line in file.readlines()
        if line.replace('\n', '')
    ]

And as file: part defines the name of the variable that will contain a file object, in this case, I choose to use a variable name: file.

Why List Comprehension Before Python Regex Group?

The issue with Hernan’s Asterisk log file is that it includes empty file lines in between the actual logging entries. 

And before using the “regex capture groups” function, I would recommend removing them.

Depending on your log file size, you have to make a decision – either skip lines that include \n or remove \n from each line. 

I decided to remove \n from each line using list comprehension, see the code example:

not_empty_lines = [
    line.replace('\n', '')
    for line in file.readlines()
    if line.replace('\n', '')
]

It translates to a for loop with an if statement.

A slightly advanced list comprehension can also include an if statement:

not_empty_lines = []
for line in file.readlines():
    if solid_line := line.replace('\n', ''):
        not_empty_lines.append(solid_line)

file.readlines() is a way to get all file lines as strings in a List[str].

line.replace('\n', '') is used to replace all new line ( \n ) strings with an empty string, also will be considered to be equal to True for a text line – see the if statement part.

if solid_line := line.replace('\n', '') will provide only lines full of text – exactly what you need for Python regex capture group functions.

Why zip() Is Used Before Regex Grouping Python Code?

This is THE MOST IMPORTANT part of the whole blog post!

🚨 In certain situations, regex grouping patterns suggested by a typical Python tutorial WON’T WORK as expected!

You have to be aware of the incoming data format, for example, in Hernan’s case – one entry equals TWO LINES of the Asterisk log file. 

Event: Cdr Privilege: cdr,all AccountCode: Source:491454490 Destination:1545454572877 110 DestinationContext: testing CallerID: Channel: Console/dsp DestinationChannel: LastApplication: Hangup
LastData: StartTime: 2010-08-23 08:27:21 AnswerTime: 2010-08-23 08:27:21 EndTime: 2010-08-23 08:28:21 Duration: 60 BillableSeconds: 0 Disposition: ANSWERED AMAFlags: DOCUMENTATION UniqueID: 1282570041.3 UserField: Rate: 0.02 Carrier: BS&S

Event: Cdr Privilege: cdr,all AccountCode: Source: Destination: 110 DestinationContext: testing CallerID: Channel: Console/dsp DestinationChannel: LastApplication: Hangup
LastData: StartTime: 2010-08-23 08:27:21 AnswerTime: 2010-08-23 08:27:21 EndTime: 2010-08-23 08:27:21 Duration: 0 BillableSeconds: 0 Disposition: ANSWERED AMAFlags: DOCUMENTATION UniqueID: 1282570041.3 UserField: Rate: 0.02 Carrier: BS&S

In such cases, coming up with a regex groups Python pattern is going to be way harder if not even impossible!

You can easily end up wasting hours of your time tweaking regex patterns, never coming up with a working solution.

with open('path/to/logfile.txt', 'r') as file:
    not_empty_lines = [
        line.replace('\n', '')
        for line in file.readlines()
        if line.replace('\n', '')
    ]

for event, last_data in zip(not_empty_lines[::2], not_empty_lines[1::2]):
    print(f'event: {event}')
    print(f'last_data: {last_data}')

Here’s what I suggest you do in such situations.. 

You PRE-PROCESS the data, before trying to use any “capture group regex Python” patterns.

This way you don’t have to come up with a very complex string grouping regular expression, instead, you pre-process the data and use a SIMPLE capture group regex pattern. 

Let me explain how zip() and slice() helped in Hernan’s case.. 👇🏻

How To Pre-Process Text Before Applying Python Regex Groups

As I’ve mentioned above, in certain Python regex group situations it’s better to avoid coming up with complex regular expressions. 

Instead, THINK 💡 about the way you can pre-process your input data so that you don’t have to come up with a complex regex pattern.

Hernan was dealing with every two lines (equals one ENTRY) of the text file. 

Naturally, to make Python regex grouping easier he just had to come up with a way of accessing every two lines (equals one ENTRY) within one for loop cycle. 

Such a scenario can be achieved with the help of a built-in function called zip().

Okay, it’s clear you can use zip() function to iterate over two lists in PARALLEL. 

Preferably, we’re aiming to have all Event lines in one list and all LastData lines in another list. 

For that, you have to look into slice(), a very simple explanation of slicing lists in Python is the following:

# Slicing a List in Python (simple example)
my_list[start:stop:step] 

# Can be also written using slice() function (results in the same as above)
my_list[slice(start, stop, step)]

Assuming the above list slicing syntax in Python, you can do the following (read my code comments carefully, I’ll explain how slicing works in this case):

with open('./logs/asterisk.txt', 'r') as file:
    not_empty_lines = [
        line.replace('\n', '')
        for line in file.readlines()
        if line.replace('\n', '')
    ]

# First set of data we want to iterate over in parallel
# Should contain only "Event" lines.
# Here's how you can access EVERY SECOND line in a log file.
for line in not_empty_lines[::2]:
    print('[Event line]: ', line)

# Syntax explanation for not_empty_lines[::2]
# not_empty_lines[start:stop:step]
# ::2 == None:None:2
# Set start to None (start with a "Event" line)
# Set stop to None (run until the last line of the file)
# Use 2 steps to slice "not_empty_lines" list in a way only "Event" lines are selected

# Once you realize "not_empty_lines[::2]" is just a way of representing only event lines in a List,
# it would make more sense to create a new variable called "events"
# which would only hold event lines
events = not_empty_lines[::2]

# The same approach can be used for "LastData" lines
# It just needs a slight adjustment in slicing
for line in not_empty_lines[1::2]:
    print('[LastData line]: ', line)

# Syntax explanation for not_empty_lines[1::2]
# not_empty_lines[start:stop:step]
# 1::2 == 1:None:2
# Set start to 1 (start with a "LastData" line)
# Set stop to None (run until the last line of the file)
# Use 2 steps to slice "not_empty_lines" list in a way only "LastData" lines are selected

# Once you realize "not_empty_lines[::2]" is just a way of representing only "LastData" lines in a List,
# it would make more sense to create a new variable called "last_data"
# which would only hold event lines
last_data = not_empty_lines[1::2]

Output:

[Event line]:  Event: Cdr Privilege: cdr,all AccountCode: Source:491454490 Destination:1545454572877 110 DestinationContext: testing CallerID: Channel: Console/dsp DestinationChannel: LastApplication: Hangup
[Event line]:  Event: Cdr Privilege: cdr,all AccountCode: Source: Destination: 110 DestinationContext: testing CallerID: Channel: Console/dsp DestinationChannel: LastApplication: Hangup
[LastData line]:  LastData: StartTime: 2010-08-23 08:27:21 AnswerTime: 2010-08-23 08:27:21 EndTime: 2010-08-23 08:28:21 Duration: 60 BillableSeconds: 0 Disposition: ANSWERED AMAFlags: DOCUMENTATION UniqueID: 1282570041.3 UserField: Rate: 0.02 Carrier: BS&S
[LastData line]:  LastData: StartTime: 2010-08-23 08:27:21 AnswerTime: 2010-08-23 08:27:21 EndTime: 2010-08-23 08:27:21 Duration: 0 BillableSeconds: 0 Disposition: ANSWERED AMAFlags: DOCUMENTATION UniqueID: 1282570041.3 UserField: Rate: 0.02 Carrier: BS&S

And now going back to the zip() function, we can pass both – events and last_data lists to the zip() function to run them both in parallel and work with both lists within a single for loop cycle. 

Here’s how the data looks after passing events and last_data lists to zip() function.

import json

zipped = zip(events, last_data)
zipped_tuple = tuple(zipped)
zipped_pretty = json.dumps(zipped_tuple, indent=4)

print('zipped_pretty: ')
print(zipped_pretty)

Output:

zipped_pretty: 

[
    [
        "Event: Cdr Privilege: cdr,all AccountCode: Source:491454490 Destination:1545454572877 110 DestinationContext: testing CallerID: Channel: Console/dsp DestinationChannel: LastApplication: Hangup",
        "LastData: StartTime: 2010-08-23 08:27:21 AnswerTime: 2010-08-23 08:27:21 EndTime: 2010-08-23 08:28:21 Duration: 60 BillableSeconds: 0 Disposition: ANSWERED AMAFlags: DOCUMENTATION UniqueID: 1282570041.3 UserField: Rate: 0.02 Carrier: BS&S"
    ],
    [
        "Event: Cdr Privilege: cdr,all AccountCode: Source: Destination: 110 DestinationContext: testing CallerID: Channel: Console/dsp DestinationChannel: LastApplication: Hangup",
        "LastData: StartTime: 2010-08-23 08:27:21 AnswerTime: 2010-08-23 08:27:21 EndTime: 2010-08-23 08:27:21 Duration: 0 BillableSeconds: 0 Disposition: ANSWERED AMAFlags: DOCUMENTATION UniqueID: 1282570041.3 UserField: Rate: 0.02 Carrier: BS&S"
    ]
]

This is exactly what Hernan needed to be able to parse the whole Asterisk log file by groups of two.

• List #1 represents lines 1 and 2 of an asterisk.txt
• List #2 represents lines 3 and 4 of an asterisk.txt

Let’s look into how having events and last_data lines split into two lists can help achieve PARALLEL processing.

Regex Group Python Example (How To Easily Use A Regex Group)

Now you have to start to think..

How could you extract information from each set of event and _last_data lines that’s available for you in a single for loop cycle.

Source:491454490
Destination:1545454572877

StartTime: 2010-08-23 08:27:21
EndTime: 2010-08-23 08:28:21

If you just take a look at the content of asterisk.txt, it’s clear the most important values for each entry are:

• source
• destination
• start
• end

So let’s see how you could extract them using Python regex groups.

with open('./logs/asterisk.txt', 'r') as file:
    not_empty_lines = [
        line.replace('\n', '')
        for line in file.readlines()
        if line.replace('\n', '')
    ]

events = not_empty_lines[::2]
last_data = not_empty_lines[1::2]

for event, _last_data in zip(events, last_data):
    print(f'event: {event}')
    print(f'_last_data: {_last_data}')

    # How to extract a value from an "event" or "_last_data" line?

I’ve already explained the fundamental steps of coming up with a regex group Python pattern earlier in the post.

The process here is very similar.

STEP 1: Use regex101.com tool to come up with a valid regex pattern and check if it works right then and there.

For a regex group pattern use parentheses ( ) and the simplest regex group Python pattern is: (.+)

If you need to find another string, you only need to change the surrounding text of the pattern.

STEP 2: Use the pattern from STEP 1 in Python.

Here’s my Regex class template with a very simple xtract_with_regex method.

This is a regex template I’m using to start string extraction in Python.

The reason I’m using a template is just to save time and actually focus on solving the actual problem I’m trying to solve.

class Regex:

    _source = r'Source:(.+) Destination:'
    _destination = r'Destination:(.+) DestinationContext:'
    _start = r'LastData: StartTime:(.+) AnswerTime:'
    _end = r'EndTime:(.+) Duration:'

    def xtract_with_regex(self, line: str, regex: str):
        rg = re.compile(regex, re.IGNORECASE | re.DOTALL)
        match = rg.search(line)

        try:
            return match.group(1)
        except AttributeError or IndexError:
            return

Also, notice the try / except block part.

The reason I’m using try / except block in xtract_with_regex method is that I don’t really care if there was an exception.

I don’t want to raise any exceptions if something went wrong.

(depends on your situation, your project – here I don’t want to have any exceptions)

All I care about is if the string I was trying to extract was found or not found.

STEP 3: Putting everything together – Python regex groups code example.

Here’s the final solution, when you put all the steps I’ve explained above together this is the result you can come to.

import re
import json

with open('./logs/asterisk.txt', 'r') as file:
    not_empty_lines = [
        line.replace('\n', '')
        for line in file.readlines()
        if line.replace('\n', '')
    ]

events = not_empty_lines[::2]
last_data = not_empty_lines[1::2]

class Regex:

    _source = r'Source:(.+) Destination:'
    _destination = r'Destination:(.+) DestinationContext:'
    _start = r'LastData: StartTime:(.+) AnswerTime:'
    _end = r'EndTime:(.+) Duration:'

    def xtract_with_regex(self, line: str, regex: str):
        rg = re.compile(regex, re.IGNORECASE | re.DOTALL)
        match = rg.search(line)

        try:
            return match.group(1)
        except AttributeError or IndexError:
            return

regex = Regex()

entries = []

for event, _last_data in zip(events, last_data):
    source = regex.xtract_with_regex(
        line=event,
        regex=regex._source
    )
    destination = regex.xtract_with_regex(
        line=event,
        regex=regex._destination
    )
    start_time = regex.xtract_with_regex(
        line=_last_data,
        regex=regex._start
    )
    end_time = regex.xtract_with_regex(
        line=_last_data,
        regex=regex._end
    )
    entries.append({
        'source': source,
        'destination': destination,
        'start_time': start_time,
        'end_time': end_time,
    })

for entry in entries:
    print(' ')
    print('Entry:')
    print(' ')
    print(json.dumps(entry, indent=4))
    print(' ')

And in the end, you can use .append() to add a new entry to the entries List. Once everything is collected, simply print out the results:

Entry:
 
{
    "source": "491454490",
    "destination": "1545454572877 110",
    "start_time": " 2010-08-23 08:27:21",
    "end_time": " 2010-08-23 08:28:21"
}
 
 
Entry:
 
{
    "source": null,
    "destination": " 110",
    "start_time": " 2010-08-23 08:27:21",
    "end_time": " 2010-08-23 08:27:21"
}

How Regex Can Help Your Python Career

Python regex groups and learning to create regex patterns that matches certain substrings is one of those universal programming concepts.

You’ll have to learn and understand regex eventually as a Python developer.

Using Python Regex As A QA Engineer

I used to be in your situation – working as a QA engineer. (You can see more details on my Linkedin profile – click here)

And I used to STRUGGLE to figure out how to solve string capturing problems in Python… 😩

Luckily, my mentors back then introduced me to Python regex and gave me a couple of ideas to start out.

Now years later, I’ve gathered a bunch of secret tools and tactics used by Python developers and I’m here to share them with you.

Ever since then, Python regex grouping has been useful in my career, literally using regex all the time as a Python/Django developer. 

But obviously, this is just one of the many programming concepts I could share here in this short blog post.

The actual tools and concepts you need to know as a Python developer are HARD TO FIND! And not many developers are willing to SHARE THEM with you, they simply do not have the time..

Same with your company, they might not even want you to learn this, here’s why 👇🏻

Why Your Company Might Not Like That You Learn Python

Yeah, you heard that right, but hear me out before jumping to any conclusions.

Your company, your managers even your close friends and family – they don’t really care about what’s in YOUR BEST INTERESTS!

They care about themselves and their interests!

• The company you work for – just wants you to do the job and don’t ask for a raise.
• Your managers – pretty much the same idea, don’t complain and do your job. 
• Your friends or family – just want to spend time with you.

None of them wants you to learn Python 🐍, become a software developer, and invest all this time and energy into something that could potentially leave them without you.

They’re interested to KEEP you around!

If you want to grow in your career, you’ll have to say NO to a lot of things at first!

Later, of course, you can come back to your family and friends.. but if you become really good, you’ll probably leave your current company. 

And they don’t want you to LEAVE THEM!

So be careful!

Why I Might Stop Coaching Python 

Final words from me today..

You’re the ONLY person who can make the change in your life, don’t let it go to waste..

I’ve been in the industry for years already, I’ve learned all the tricks I wanted to learn, and I got the Python job I wanted to get!

Honestly, there’s no reason for me to spend my time teaching others, it’s actually diminishing returns at this point..

The ONLY REASON I’d be open to coaching someone is if they’re REALLY COMMITTED to their success 🚀

This is your chance to prove it to me!

If you can still find my contact details below, I’m open to hearing your story.

🚨 I’m only willing to work with serious people, If you don’t take your career seriously, please ignore this message.

Otherwise, send me details about your current situation, why would you want to learn Python and get a job as a Python developer.

I’ll see if there’s a chance we can have a call sometime soon. 

Talk soon!