{"id":28741,"date":"2021-01-26T13:55:23","date_gmt":"2021-01-26T21:55:23","guid":{"rendered":"https:\/\/careerkarma.com\/blog\/?p=28741"},"modified":"2022-07-20T08:35:05","modified_gmt":"2022-07-20T15:35:05","slug":"python-regex","status":"publish","type":"post","link":"https:\/\/careerkarma.com\/blog\/python-regex\/","title":{"rendered":"Python Regex: An Introduction to Using Regular Expressions"},"content":{"rendered":"\n

As a new developer, regular expressions (or regex as it\u2019s commonly known), can be daunting because of the strange, unfamiliar syntax:     <\/p>\n\n\n\n

 ^[<\/strong>A-Za-z0-9._%+-]<\/strong>+@[<\/strong>A-Za-z0-9.-]<\/strong>+\\.[<\/strong>A-Za-z]<\/strong>{2,}$ <\/pre>\n\n\n\n
<\/p>\n\n\n\n
When I was a new developer and saw the expression above for the first time, I remember my first thought was \u201csay what? I\u2019m never going to be able to learn that gobbledygook. That\u2019s too much for me. I can\u2019t do it.<\/em>\u201d
<\/p>\n\n\n\n
But you can! It\u2019s just a matter of getting over that initial overwhelming feeling that regular expressions are too foreign. Just like learning or speaking a foreign language \u2014 once you get the hang of it, it will come pretty naturally. I promise!
<\/p>\n\n\n\n
In this article, we take a look at what regular expressions are, why they are used, and how to use them in Python. By the time you finish this article, you\u2019ll have a solid understanding of regular expressions so you can interpret what the expression above means!<\/p>\n\n\n\n
What are Regular Expressions? <\/h2>\n\n\n\n
When we take a look at what a regular expression is, we need to remind ourselves of what a string is. Remember that a string is just a collection of characters that are strung together<\/em> and bounded by a set of quotation marks:
<\/p>\n\n\n\n
 \u201cHello World\u201d\n\n\u201c555-555-5555\u201d\n\n   \u201cJohn Doe\n123 Main St.\nAnywhere, USA 99999-9999\u201d\n\n  \u201cemail@email.io\u201d<\/pre>\n\n\n\n
<\/p>\n\n\n\n
These are all examples of strings. They can be of any length, or no length at all. Regular Expressions, or more commonly shortened to regex<\/em>, is an expression whose components match patterns up with strings to find out some sort of information.
<\/p>\n\n\n\n
What\u2019s great about regex is that it doesn\u2019t necessarily care about the language you are coding in \u2014 it\u2019s fairly language agnostic. The difference comes in the language\u2019s methods and how to perform actions using those expressions. <\/p>\n\n\n\n
What are Regular Expressions Used For?<\/h3>\n\n\n\n
Regex is a pattern that we would want to specifically look for in a string. We can use regex to search for a particular phrase or pattern to replace it with something else, or we can validate forms to be certain a user is entering information in a certain format so that it is consistent across all users.<\/p>\n\n\n\n
Search and Replace<\/h4>\n\n\n\n
Say for instance we have a phone number presented in this format:
<\/p>\n\n\n\n
 555 555 5555 <\/pre>\n\n\n\n
<\/p>\n\n\n\n
This is a valid format for a phone number in the United States. But what if we wanted to replace the spaces with dashes? Or add parentheses around the area code and a dash to make it more readable?<\/p>\n\n\n\n
We can use regular expressions for that! We\u2019ll go over in the next section how to do that with Python \u2014 for now I want you to get the general feel for what you can do with regular expressions and how they can be useful.
<\/p>\n\n\n\n
The result we would see after a search and replace on a phone number in Python for the format we would like to use would be:
<\/p>\n\n\n\n
555-555-5555\n     or\n(555)555-5555<\/pre>\n\n\n\n
<\/p>\n\n\n\n
There is no need to hardcode or look for a specific value or index of the string in regular expressions because we can just look for the patterns in the strings and manipulate all of the records we have to match.<\/p>\n\n\n\n
Validate<\/h4>\n\n\n\n
Have you ever filled something in on a site only for it to display an error message because of a missed symbol or a pattern you didn\u2019t follow? More than likely regular expressions were used to make sure your input matched what their database is looking for.
<\/p>\n\n\n\n
This is called validation and is super useful when building forms to be certain that a phone number follows the format you\u2019d like for it to be in or that an email address is a properly formatted email address, or a password matches the parameters you have set for it to be a valid password (length, special characters, digits, upper or small case, etc). 
<\/p>\n\n\n\n
This helps prevent errors in your database by alerting the user to typos or mismatched patterns. 
<\/p>\n\n\n\n
In the next section, we will take a look at the components or pattern matchers<\/em> that build regular expressions.<\/p>\n\n\n\n
Types of Regex Pattern Matchers<\/h2>\n\n\n\n
Literal characters, metacharacters, and quantifiers make up the types of pattern matchers we see in regex. A pattern matcher is a character that is used to help find a pattern in a string. It is the primary building block of a regular expression.<\/p>\n\n\n\n
Literal Characters<\/h3>\n\n\n\n
The most basic example of a pattern matcher in regex is a literal character. It matches a hard coded character or string.
<\/p>\n\n\n\n
Examples: <\/p>\n\n\n\n
hello<\/code> \u21d2 collection of five distinct characters.<\/p>\n\n\n\n
When a regex pattern is applied here, it looks for each of these characters in succession. \u201chello\u201d, \u201chelloing\u201d, or \u201chelloed\u201d would pass a pattern check, but \u201cHello\u201d, \u201chelo\u201d, or \u201cHeLlo\u201d would not.
<\/p>\n\n\n\n
A<\/code> \u21d2 collection of one distinct character.<\/p>\n\n\n\n
Because regex looks for distinct characters, it is case sensitive too. So \u201cA\u201d would pass, but \u201ca\u201d would not. We\u2019ll get into this more in a little bit. 
<\/p>\n\n\n\n
A simple sentence\\<\/code>. \u21d2 collection of several distinct characters.
<\/p>\n\n\n\n
Regex looks for every character in the expression in succession when it looks at a string. If \u201cA simple sentence\u201d is not in the searched string exactly as it is written in the regex, it would not pass.<\/p>\n\n\n\n
Escape Characters<\/h4>\n\n\n\n
Take a look at the last example. Notice that there is a \\ in front of the period. A dot in regular expression syntax is synonymous with keywords in languages like JavaScript or Python.
<\/p>\n\n\n\n
You can’t use a period\/dot on its own if you want it to be part of a pattern in regular expressions. You have to escape the character in order for the regular expression engine to interpret that as a literal representation of a period instead of the regex meaning. 
<\/p>\n\n\n\n
Here are some other special sequences of characters that need to be escaped if you want the literal character instead of the translated meaning that the regex engine compiles it to.<\/p>\n\n\n\n
  • Asterisk *<\/li>
  • Backslash \/<\/li>
  • Plus +<\/li>
  • Caret ^<\/li>
  • Dollar Sign $<\/li>
  • Dot\/Period .<\/li>
  • Pipe |<\/li>
  • Question Mark ?<\/li>
  • Parentheses \u2013 both types ()<\/li>
  • Curly Braces \u2013 both types {}<\/li><\/ul>\n\n\n\n
    Literal characters in regex match exactly with the character you include as part of the pattern. If you want to include a character that\u2019s listed above, be sure to escape it so that it can also be a part of your regex.<\/p>\n\n\n\n
    Common Matchers<\/h3>\n\n\n\n
    The purpose of a matcher is to match multiple letters in a pattern. This collection of pattern matching symbols is fairly consistent among the programming languages that use regex.
    <\/p>\n\n\n\n
    Matcher<\/td>Description<\/td>Example<\/td><\/tr>
    .<\/td>Matches any character<\/td>n.w would match now, naw, or new<\/em>, etc. Any character passes the test<\/td><\/tr>
    ^regex<\/td>Looks for pattern at beginning of the line<\/td>^hello would match hello in a line that started with that pattern<\/td><\/tr>
    regex$<\/td>Looks for pattern at end of the line<\/td>world$ would match world in a line that ended with that pattern<\/td><\/tr>
    [abc]<\/td>Matches a, b, or c <\/td>[misp]is considered a set<\/em> and would match any string that has any of those characters in it. 
    For example, it could match all the individual letters in mississippi, and miss, but only some of the letters in marsh, and missouri<\/td><\/tr>
    [abc][xyz]<\/td>Matches a, b, or c followed by x, y, or z<\/td>\/[Mm][sip]\/ would match any string that starts with M or m, followed by a set that has any of the characters in [sip]<\/td><\/tr>
    [^abc]<\/td>Not a, b, or c<\/td>[^rstlne] would match any character that is not r, s, t, l, n, or e<\/td><\/tr>
    [a-zA-Z0-9]<\/td>Matches any character within the range<\/td>[a-n] would match any character between a and n. and, end, blind, can<\/em>, all have characters that entirely match here<\/td><\/tr>
    A|B<\/td>A or B<\/td>M|m. would match any word or phrase at least two characters in length that matches either an M or an m plus at least one or more other characters.<\/td><\/tr>
    CAT<\/td>Matches C, followed by A, followed by T<\/td>hello world would match hello world<\/em> exactly
    <\/td><\/tr><\/tbody><\/table>\n\n\n\n
    <\/h3>\n\n\n\n
    Metacharacters<\/h3>\n\n\n\n
    Regular expressions also use metacharacters to describe a pattern. Metacharacters have some sort of meaning behind them and will describe the shape of the pattern.
    <\/p>\n\n\n\n
    Metacharacter<\/td>Description<\/td>Example<\/td><\/tr>
    \\d<\/td>Matches any digit<\/td>\\d would match 1, 2, or 3, etc. Shorthand for [0-9]<\/td><\/tr>
    \\D<\/td>Matches any non-digit character<\/td>\\D would match A, B, g, etc.. Shorthand for [^0-9] <\/td><\/tr>
    \\s<\/td>Matches any whitespace character<\/td>\\s would match new lines, tabs, spaces, etc. 
    <\/td><\/tr>
    \\S<\/td>Matches any non-whitespace character <\/td>\\S would match any character except a whitespace character. <\/td><\/tr>
    \\w<\/td>Matches any word character<\/td>A word character, short for [a-zA-Z_0-9]<\/td><\/tr>
    \\W<\/td>Matches any non-word character<\/td>[\\W] would match any special characters. Shorthand for [^\\w]<\/td><\/tr><\/tbody><\/table>\n\n\n\n
    Note<\/strong>: Capital letter metacharacters (\\W, \\D, etc) usually correspond to the opposite of what the lowercase letter metacharacters do (\\w, \\d, etc). <\/p>\n\n\n\n
    Quantifiers<\/h3>\n\n\n\n
    Quantifier<\/td>Description<\/td>Example<\/td><\/tr>
    +<\/td>One of more of preceding character<\/td>\\d+ would match two or more digits<\/td><\/tr>
    *<\/td>Zero or more of preceding character<\/td>.* would match any character 0 or more times 
    Note: Technically an empty string would fulfill this regex!<\/td><\/tr>
    ?<\/td>Zero or one of the preceding character<\/td>a?.* would match a, any, hello, world <\/em><\/td><\/tr>
    {number}<\/td>Matches preceding character exactly number<\/em> of times <\/td>\\d{3} matches exactly three digits [0-9]<\/td><\/tr>
    {num1,num2}<\/td>Matches preceding character in a range of nums<\/td>\\d{3,5} matches 3 to 5 digits that are [0-9]<\/td><\/tr><\/tbody><\/table>\n\n\n\n
    Use the quantifiers, metacharacters, and other matchers as the building blocks for your regular expressions. The syntax mentioned here is similar across multiple languages that use regular expressions.
    <\/p>\n\n\n\n
    However, there are some things that are used in Ruby or JavaScript, for instance, that would not be transferable to Python.
    <\/p>\n\n\n\n
    Let\u2019s learn a little more about how regular expressions work in Python in the next section.<\/p>\n\n\n\n
    How Do Regular Expressions Work in Python?<\/h2>\n\n\n\n
    To use regular expressions in Python import the re<\/code> module into the top of your file. <\/p>\n\n\n\n
    import re \nstring = "The quick brown fox jumped over the lazy dog"\n \n \nresult = re.search("q.+k\\s", string) # this is the match object if it returns a positive result. It will return a NoneType object otherwise\nprint(result.span(), "<== This is the tuple containing the span of indexes the result is in")\nprint(result.string, "<== This is the original string ")\nprint(result.group(), "<== This is the group of characters that match our regex pattern")\n\n===================================================================\n\nimport re \nstring = """The \nquick brown \nfox jumped over the lazy dog\n"""\n\nresult = re.search("""\n\t\t\t\t\t^ # beginning of line\n                    Q # literal character 'Q'\n                    . # dot ==> any character\n                    + # quantifier == more than 1\n                    k # literal character 'k'\n                    \\s # special character '\\s'\n                    """, string, flags=re.IGNORECASE | re.M | re.VERBOSE)\n\nif result:                                 \n  print(result.span(), "<== This is the tuple containing the span of indexes the result is in")\n  print(result.string, "<== This is the original string ")\n  print(result.group(), "<== This is the group of characters that match our regex pattern")\nelse:\n\tprint(result)\n\n\n===================================================================\n\nimport re \nprint(re.match("quick", str, flags=re.IGNORECASE))\nprint(re.search("quick", str, flags=re.IGNORECASE | re.MULTILINE))\n\n===================================================================\n\nimport re \nphone = "555 555 5555"\ncorrectFormat = re.sub("\\s", "-", phone)\nprint(correctFormat)\n\n===================================================================\n\nimport re \n\nleft_parens = re.sub("^", "(", phone) \nright_parens = re.sub("\\s", ")", left_parens, 1)\nsecondCorrectFormat = re.sub("\\s", "-", right_parens)\nprint(secondCorrectFormat)<\/pre><\/div>\n\n\n\n
    It\u2019s that simple! There is nothing special you have to add or packages you need to download. It\u2019s already built-in as long as you import it. 
    <\/p>\n\n\n\n
    The fun comes from how to use the different methods that are available to us in the re module.<\/p>\n\n\n\n
    re.search(regex, str, flags=0)<\/strong><\/h3>\n\n\n\n
    Use the search function when you want to apply a regex pattern to a string to see if the pattern is contained in the string. This method will take a regular expression pattern and match it anywhere in the string.
    <\/p>\n\n\n\n
    If the regex pattern is NOT contained in the string, the interpreter will return None<\/code>. If there is a match, a Match<\/code> object will be returned that will contain some information about it. <\/p>\n\n\n\n
    The Match<\/code> object has a property and two methods that can be used to retrieve information about the match:<\/p>\n\n\n\n
    match_obj.span()<\/code> a method that returns a tuple containing the start and end positions of the match (the end position is inclusive).<\/p>\n\n\n\n
    match_obj.string<\/code> a property that returns the string passed into the function.<\/p>\n\n\n\n
    match_obj.group()<\/code> a method that returns the part of the string where there was a match.<\/p>\n\n\n\n
    match_obj<\/code> here will be replaced with the variable you assign to the result of your re.search()<\/code> method. Here is an example using each method and property: 
    <\/p>\n\n\n\n
    import re\n \nstring = "The quick brown fox jumped over the lazy dog"\n \nresult = re.search("q.+k\\s", string) # this is the match object if it returns a positive result. It will return a NoneType object otherwise\nprint(result.span(), "<== This is the tuple containing the span of indexes the result is in")\nprint(result.string, "<== This is the original string ")\nprint(result.group(), "<== This is the group of characters that match our regex pattern")<\/pre><\/div>\n\n\n\n
    The main thing to remember here is that the Match<\/code> object in Python has methods and  properties.
    <\/p>\n\n\n\n
    We use the property string to access the original string we tested the regex against, the span method to access the indexes, and the group method to get the actual matched result. 
    <\/p>\n\n\n\n
    There are other methods and properties that can be referenced in the Python docs, but these are good to get you started. <\/p>\n\n\n\n
    Optional arguments:  flags<\/h4>\n\n\n\n
    There is an optional argument you can use with the re<\/code> module\u2019s search method as well. To use it assign the flags<\/code> parameter to a list of the flags you would like to use. The default is set to 0. Some of the more popular options include: 
    <\/p>\n\n\n\n
    • re.DEBUG<\/li><\/ul>\n\n\n\n
      This flag will display debug information about the compiled regex if needed. <\/p>\n\n\n\n
      <\/p>\n\n\n\n
      • re.I
        re.IGNORECASE<\/li><\/ul>\n\n\n\n
        Case insensitive matching. This will ignore the case of the characters passed into sets or literal characters so that both capital- and lower- case letters will match.
        <\/p>\n\n\n\n
        • re.M
          re.MULTILINE<\/li><\/ul>\n\n\n\n
          Multiline mode. Allows beginning of line and end of line regex metacharacters to be used in multiline strings. Otherwise it would just look at the beginning and the end of the string. Without the multiline flag, the regex engine considers the string one line.
          <\/p>\n\n\n\n
          • re.S
            re.DOTALL<\/li><\/ul>\n\n\n\n
            This flag tells the regex engine that the dot character will match any character. The default behavior is for the dot character to match every character except a newline character. 
            <\/p>\n\n\n\n
            • re.X
              re.VERBOSE<\/li><\/ul>\n\n\n\n
              The verbose flag allows you to add comments to your regular expression to break down your expression and comment on its purpose. This may help immensely as you are learning regex in Python. 
              <\/p>\n\n\n\n
              This code snippet takes the example from above and incorporates some of the flags listed above. When using more than one flag, use the bitwise | operator in between each as a separator.
              <\/p>\n\n\n\n
              import re\n \nstring = """The\nquick brown\nfox jumped over the lazy dog\n"""\n \nresult = re.search("""\n          \t\t  ^ # beginning of line\n                   Q # literal character 'Q'\n                   . # dot ==> any character\n                   + # quantifier == more than 1\n                   k # literal character 'k'\n                   \\s # special character '\\s'\n                   """, string, flags=re.IGNORECASE | re.M | re.VERBOSE)\n                  \n                  \n                  \n                  \nif result:                                \nprint(result.span(), "<== This is the tuple containing the span of indexes the result is in")\nprint(result.string, "<== This is the original string ")\nprint(result.group(), "<== This is the group of characters that match our regex pattern")\nelse:\n  \tprint(result)<\/pre><\/div>\n\n\n\n
              Take the time to notice how the flags help us in testing our string. Try taking the flags parameter out. Does the string return a result? If not, what does it return as a result? 
              <\/p>\n\n\n\n
              Remember that the search method on the re module takes in the regex, the string to be searched, and an optional flags parameter. A truthy value will return a Match Object that has properties and methods associated with it. A falsy value returns a NoneType object. <\/p>\n\n\n\n
              re.match(regex, str, flags=0)<\/strong><\/h3>\n\n\n\n
              Use the  match method when you are looking to match a regex pattern to the beginning of the string. If you want to match the regex pattern anywhere in the string, use the search method above instead. 
              <\/p>\n\n\n\n
              import re\n \nstring = """The\nquick brown\nfox jumped over the lazy dog\n"""\n \nprint(re.match("quick", string, flags=re.IGNORECASE | re.MULTILINE))\nprint(re.search("quick", string, flags=re.IGNORECASE | re.MULTILINE))<\/pre><\/div>\n\n\n\n
              When looking at this code in a Python interpreter, you will see that the first method, match()<\/code>, will not return a Match<\/code> object, but instead None<\/code>. The second allows for looking inside the string and will return a Match<\/code> object. This is because the match()<\/code> method only looks at the beginning of a string, even if the re.MULTILINE<\/code> flag is raised. <\/p>\n\n\n\n
              re.sub(findRegex, replaceWith, str, count=0, flags=0)<\/strong><\/h3>\n\n\n\n
              The sub()<\/code> method in the re module takes a regex, finds the leftmost match in a string, and replaces it with something else. It repeats the same operation for the number of times indicated in the count parameter. If there is no count parameter or it is set to zero, all occurrences will be replaced. 
              <\/p>\n\n\n\n
              At the beginning of this article we talked about reformatting a phone number. Let\u2019s take a look at how to do that here: 
              <\/p>\n\n\n\n
              import re\n \nphone = "555 555 5555"\ncorrectFormat = re.sub("\\s", "-", phone)\nprint(correctFormat) # 555-555-5555<\/pre><\/div>\n\n\n\n
              This takes our phone string, finds all occurrences of whitespace, and replaces it with a dash. In this case, we end up with 555-555-5555<\/code>.<\/p>\n\n\n\n
              Let\u2019s try a more difficult reformat:
              <\/p>\n\n\n\n
              import re\n \nphone = "555 555 5555"\n \nleft_parens = re.sub("^", "(", phone)\nright_parens = re.sub("\\s", ")", left_parens, 1)\nsecondCorrectFormat = re.sub("\\s", "-", right_parens)\nprint(secondCorrectFormat) # (555)555-5555<\/pre><\/div>\n\n\n\n
              In this example, we go to the beginning of the line to add an open parentheses and assign that new string to a variable. <\/p>\n\n\n\n
              We then take that newly assigned variable (left_parens<\/code>) and use it to perform the same operation on finding the next available whitespace character to replace it with a close parentheses. This is assigned to right_parens<\/code>. <\/p>\n\n\n\n
              Finally, we take the right_parens<\/code> variable and use it to perform the same operation on the final whitespace character to replace it with a dash. <\/p>\n\n\n\n
              This will give us (555)555-5555<\/code>. <\/p>\n\n\n\n
              To recap, the sub()<\/code> method takes in a regex pattern, a replacement string or function, the actual string we want to perform the sub()<\/code> on, and a count. If we don\u2019t provide a count, it will perform the replacements on all occurrences. It returns the new string with the substitutions performed. <\/p>\n\n\n\n
              Conclusion<\/h2>\n\n\n\n
              Regular Expressions are a way to validate data or to search and replace characters in our strings. Regex consists of metacharacters, quantifiers, and literal characters that can be used to test our strings to see if it passes a validation test or to search and replace Matches. 
              <\/p>\n\n\n\n
              Regex can be a little overwhelming at first, but once you get it, it\u2019s a little bit like riding a bike.  It\u2019ll be in the back of your memory and super easy to pick up again.
              <\/p>\n\n\n\n
              When you feel you have a handle on what comes up in this article, take a look at the Python docs to see what else can be done with regular expressions. Definitely take a look at the compile and split methods. 
              <\/p>\n\n\n\n
              Happy regexing!<\/p>\n","protected":false},"excerpt":{"rendered":"As a new developer, regular expressions (or regex as it\u2019s commonly known), can be daunting because of the strange, unfamiliar syntax:     ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$ When I was a new developer and saw the expression above for the first time, I remember my first thought was \u201csay what? I\u2019m never going to be able to learn that…","protected":false},"author":77,"featured_media":28742,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[16578],"tags":[],"class_list":{"0":"post-28741","1":"post","2":"type-post","3":"status-publish","4":"format-standard","5":"has-post-thumbnail","7":"category-python"},"acf":{"post_sub_title":"","sprint_id":"","query_class":"Python","school_sft":"","parent_sft":"","school_privacy_policy":"","has_review":null,"is_sponser_post":"","is_guest_post":""},"yoast_head":"\nPython Regex: A Complete Guide<\/title>\n<meta name=\"description\" content=\"In this article about Python-flavored regex on Career Karma, learn about the components that make up a regular expression, as well as methods and properties to use when testing strings with regex patterns!\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/careerkarma.com\/blog\/python-regex\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Python Regex: An Introduction to Using Regular Expressions\" \/>\n<meta property=\"og:description\" content=\"In this article about Python-flavored regex on Career Karma, learn about the components that make up a regular expression, as well as methods and properties to use when testing strings with regex patterns!\" \/>\n<meta property=\"og:url\" content=\"https:\/\/careerkarma.com\/blog\/python-regex\/\" \/>\n<meta property=\"og:site_name\" content=\"Career Karma\" \/>\n<meta property=\"article:publisher\" content=\"http:\/\/facebook.com\/careerkarmaapp\" \/>\n<meta property=\"article:published_time\" content=\"2021-01-26T21:55:23+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2022-07-20T15:35:05+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2021\/01\/photo-1511619726879-d4974d118c05.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1020\" \/>\n\t<meta property=\"og:image:height\" content=\"765\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Christina Kopecky\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@career_karma\" \/>\n<meta name=\"twitter:site\" content=\"@career_karma\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Christina Kopecky\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"17 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/careerkarma.com\/blog\/python-regex\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/careerkarma.com\/blog\/python-regex\/\"},\"author\":{\"name\":\"Christina Kopecky\",\"@id\":\"https:\/\/careerkarma.com\/blog\/#\/schema\/person\/ae0cdc4a5d198690d78482646894074e\"},\"headline\":\"Python Regex: An Introduction to Using Regular Expressions\",\"datePublished\":\"2021-01-26T21:55:23+00:00\",\"dateModified\":\"2022-07-20T15:35:05+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/careerkarma.com\/blog\/python-regex\/\"},\"wordCount\":2742,\"commentCount\":0,\"image\":{\"@id\":\"https:\/\/careerkarma.com\/blog\/python-regex\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2021\/01\/photo-1511619726879-d4974d118c05.jpg\",\"articleSection\":[\"Python\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/careerkarma.com\/blog\/python-regex\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/careerkarma.com\/blog\/python-regex\/\",\"url\":\"https:\/\/careerkarma.com\/blog\/python-regex\/\",\"name\":\"Python Regex: A Complete Guide\",\"isPartOf\":{\"@id\":\"https:\/\/careerkarma.com\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/careerkarma.com\/blog\/python-regex\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/careerkarma.com\/blog\/python-regex\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2021\/01\/photo-1511619726879-d4974d118c05.jpg\",\"datePublished\":\"2021-01-26T21:55:23+00:00\",\"dateModified\":\"2022-07-20T15:35:05+00:00\",\"author\":{\"@id\":\"https:\/\/careerkarma.com\/blog\/#\/schema\/person\/ae0cdc4a5d198690d78482646894074e\"},\"description\":\"In this article about Python-flavored regex on Career Karma, learn about the components that make up a regular expression, as well as methods and properties to use when testing strings with regex patterns!\",\"breadcrumb\":{\"@id\":\"https:\/\/careerkarma.com\/blog\/python-regex\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/careerkarma.com\/blog\/python-regex\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/careerkarma.com\/blog\/python-regex\/#primaryimage\",\"url\":\"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2021\/01\/photo-1511619726879-d4974d118c05.jpg\",\"contentUrl\":\"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2021\/01\/photo-1511619726879-d4974d118c05.jpg\",\"width\":1020,\"height\":765,\"caption\":\"close up photo of R and E, painted red, but with paint peeling off.\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/careerkarma.com\/blog\/python-regex\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Blog\",\"item\":\"https:\/\/careerkarma.com\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Python\",\"item\":\"https:\/\/careerkarma.com\/blog\/python\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Python Regex: An Introduction to Using Regular Expressions\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/careerkarma.com\/blog\/#website\",\"url\":\"https:\/\/careerkarma.com\/blog\/\",\"name\":\"Career Karma\",\"description\":\"Latest Coding Bootcamp News & Career Hacks from Industry Insiders\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/careerkarma.com\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/careerkarma.com\/blog\/#\/schema\/person\/ae0cdc4a5d198690d78482646894074e\",\"name\":\"Christina Kopecky\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/careerkarma.com\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2020\/06\/image-3-150x150.jpg\",\"contentUrl\":\"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2020\/06\/image-3-150x150.jpg\",\"caption\":\"Christina Kopecky\"},\"description\":\"Christina is an experienced technical writer, covering topics as diverse as Java, SQL, Python, and web development. She earned her Master of Music in flute performance from the University of Kansas and a bachelor's degree in music with minors in French and mass communication from Southeast Missouri State. Prior to joining the Career Karma team in June 2020, Christina was a teaching assistant, team lead, and section lead at Lambda School, where she led student groups, performed code and project reviews, and debugged problems for students. Christina's technical content is featured frequently in publications like Codecademy, Repl.it, and Educative.\",\"sameAs\":[\"http:\/\/www.linkedin.com\/in\/cmvnk\"],\"url\":\"https:\/\/careerkarma.com\/blog\/author\/christina-kopecky\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Python Regex: A Complete Guide","description":"In this article about Python-flavored regex on Career Karma, learn about the components that make up a regular expression, as well as methods and properties to use when testing strings with regex patterns!","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/careerkarma.com\/blog\/python-regex\/","og_locale":"en_US","og_type":"article","og_title":"Python Regex: An Introduction to Using Regular Expressions","og_description":"In this article about Python-flavored regex on Career Karma, learn about the components that make up a regular expression, as well as methods and properties to use when testing strings with regex patterns!","og_url":"https:\/\/careerkarma.com\/blog\/python-regex\/","og_site_name":"Career Karma","article_publisher":"http:\/\/facebook.com\/careerkarmaapp","article_published_time":"2021-01-26T21:55:23+00:00","article_modified_time":"2022-07-20T15:35:05+00:00","og_image":[{"width":1020,"height":765,"url":"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2021\/01\/photo-1511619726879-d4974d118c05.jpg","type":"image\/jpeg"}],"author":"Christina Kopecky","twitter_card":"summary_large_image","twitter_creator":"@career_karma","twitter_site":"@career_karma","twitter_misc":{"Written by":"Christina Kopecky","Est. reading time":"17 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/careerkarma.com\/blog\/python-regex\/#article","isPartOf":{"@id":"https:\/\/careerkarma.com\/blog\/python-regex\/"},"author":{"name":"Christina Kopecky","@id":"https:\/\/careerkarma.com\/blog\/#\/schema\/person\/ae0cdc4a5d198690d78482646894074e"},"headline":"Python Regex: An Introduction to Using Regular Expressions","datePublished":"2021-01-26T21:55:23+00:00","dateModified":"2022-07-20T15:35:05+00:00","mainEntityOfPage":{"@id":"https:\/\/careerkarma.com\/blog\/python-regex\/"},"wordCount":2742,"commentCount":0,"image":{"@id":"https:\/\/careerkarma.com\/blog\/python-regex\/#primaryimage"},"thumbnailUrl":"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2021\/01\/photo-1511619726879-d4974d118c05.jpg","articleSection":["Python"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/careerkarma.com\/blog\/python-regex\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/careerkarma.com\/blog\/python-regex\/","url":"https:\/\/careerkarma.com\/blog\/python-regex\/","name":"Python Regex: A Complete Guide","isPartOf":{"@id":"https:\/\/careerkarma.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/careerkarma.com\/blog\/python-regex\/#primaryimage"},"image":{"@id":"https:\/\/careerkarma.com\/blog\/python-regex\/#primaryimage"},"thumbnailUrl":"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2021\/01\/photo-1511619726879-d4974d118c05.jpg","datePublished":"2021-01-26T21:55:23+00:00","dateModified":"2022-07-20T15:35:05+00:00","author":{"@id":"https:\/\/careerkarma.com\/blog\/#\/schema\/person\/ae0cdc4a5d198690d78482646894074e"},"description":"In this article about Python-flavored regex on Career Karma, learn about the components that make up a regular expression, as well as methods and properties to use when testing strings with regex patterns!","breadcrumb":{"@id":"https:\/\/careerkarma.com\/blog\/python-regex\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/careerkarma.com\/blog\/python-regex\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/careerkarma.com\/blog\/python-regex\/#primaryimage","url":"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2021\/01\/photo-1511619726879-d4974d118c05.jpg","contentUrl":"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2021\/01\/photo-1511619726879-d4974d118c05.jpg","width":1020,"height":765,"caption":"close up photo of R and E, painted red, but with paint peeling off."},{"@type":"BreadcrumbList","@id":"https:\/\/careerkarma.com\/blog\/python-regex\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog","item":"https:\/\/careerkarma.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Python","item":"https:\/\/careerkarma.com\/blog\/python\/"},{"@type":"ListItem","position":3,"name":"Python Regex: An Introduction to Using Regular Expressions"}]},{"@type":"WebSite","@id":"https:\/\/careerkarma.com\/blog\/#website","url":"https:\/\/careerkarma.com\/blog\/","name":"Career Karma","description":"Latest Coding Bootcamp News & Career Hacks from Industry Insiders","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/careerkarma.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/careerkarma.com\/blog\/#\/schema\/person\/ae0cdc4a5d198690d78482646894074e","name":"Christina Kopecky","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/careerkarma.com\/blog\/#\/schema\/person\/image\/","url":"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2020\/06\/image-3-150x150.jpg","contentUrl":"https:\/\/careerkarma.com\/blog\/wp-content\/uploads\/2020\/06\/image-3-150x150.jpg","caption":"Christina Kopecky"},"description":"Christina is an experienced technical writer, covering topics as diverse as Java, SQL, Python, and web development. She earned her Master of Music in flute performance from the University of Kansas and a bachelor's degree in music with minors in French and mass communication from Southeast Missouri State. Prior to joining the Career Karma team in June 2020, Christina was a teaching assistant, team lead, and section lead at Lambda School, where she led student groups, performed code and project reviews, and debugged problems for students. Christina's technical content is featured frequently in publications like Codecademy, Repl.it, and Educative.","sameAs":["http:\/\/www.linkedin.com\/in\/cmvnk"],"url":"https:\/\/careerkarma.com\/blog\/author\/christina-kopecky\/"}]}},"_links":{"self":[{"href":"https:\/\/careerkarma.com\/blog\/wp-json\/wp\/v2\/posts\/28741","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/careerkarma.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/careerkarma.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/careerkarma.com\/blog\/wp-json\/wp\/v2\/users\/77"}],"replies":[{"embeddable":true,"href":"https:\/\/careerkarma.com\/blog\/wp-json\/wp\/v2\/comments?post=28741"}],"version-history":[{"count":0,"href":"https:\/\/careerkarma.com\/blog\/wp-json\/wp\/v2\/posts\/28741\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/careerkarma.com\/blog\/wp-json\/wp\/v2\/media\/28742"}],"wp:attachment":[{"href":"https:\/\/careerkarma.com\/blog\/wp-json\/wp\/v2\/media?parent=28741"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/careerkarma.com\/blog\/wp-json\/wp\/v2\/categories?post=28741"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/careerkarma.com\/blog\/wp-json\/wp\/v2\/tags?post=28741"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}