import re
raw_data = "John Doe"
results = lambda: re.search("^[A-Z][a-z]+ [A-Z][a-z]+$", raw_data)
invalid = [None]
name = (results() or invalid)[0]
print(name)
Ye or nay?
#🔒 Using logic to replace value
silver forge
honest pumiceBOT
```py
import re
raw_data = "John Doe"
results = lambda: re.search("^[A-Z][a-z]...
@silver forge
Python help channel opened
twin laurel
!e
Depends on what you mean by ye and nay
import re
raw_data = "John Doe"
results = lambda: re.search("^[A-Z][a-z]+$", raw_data)
invalid = [None]
name = (results or invalid)[0]
:x: Your 3.12 eval job has completed with return code 1.
001 | Traceback (most recent call last):
002 | File "/home/main.py", line 8, in <module>
003 | name = (results or invalid)[0]
004 | ~~~~~~~~~~~~~~~~~~~~^^^
005 | TypeError: 'function' object is not subscriptable
what do you want to do?
edgy jay
!e
import re
raw_data = "John Doe"
results = lambda: re.search("^[A-Z][a-z]+$", raw_data)
invalid = [None]
name = (results() or invalid)[0]
print(name)
:white_check_mark: Your 3.12 eval job has completed with return code 0.
None
That actually sounds reasonable
though if you have more than 1 group (or named groups), it's going to be a pain
twin laurel
I kinda wish re returned this kind of object instead of None ```py
class NullMatch:
def getitem(self, idx):
return None
def groupdict(self):
return {}
...
def __bool__(self):
return False
@wraith skiff you win this time
(he likes null objects, but I haven't found them useful before, probably)
silver forge
So overall, readable?
twin laurel
Yeah I would say it's good
silver forge
I would use it in a function but whatever.
twin laurel
if you had more than 1 group or had named groups, maybe a simple None check would be better (or a custom object like the above if you have this pattern appear a lot)
actually, in that case defaultdict(lambda: None) could work
silver forge
"" or None
None and ""
Also is doing stuff like this strange?
silver forge
Because never seen anyone use it but me.
When I was in college my professor ignored it and I never got to ask, so I kept using it.
edgy jay
(None and "") == ""
silver forge
I can't remember some of the other weird habits I had, but it's probably specific to C++.
I had some strange ones, but no one every said anything. -shrug-
twin laurel
```py
"" or None
```
```py
None and ""
```
Also is doing stuff like this strange...
It's commonly used when you want to replace None with a different kind of default
https://github.com/aio-libs/aiohttp/blob/98eec45100822cc1092b7ea1fc9f734912cd2c82/aiohttp/multipart.py#L137
honest pumiceBOT
aiohttp/multipart.py line 137
encoding = encoding or "utf-8"```I've never seen it done before outside my work. XD
twin laurel
Since you seem to like regexes, maybe check out https://grep.app/ 🙂
You can make a query like https://grep.app/search?q= or &case=true&filter[lang][0]=Python and see how something is used in popular projects
twin laurel
For example, you can skip all matches for "express or implied" and "or agreed to in writing" with a pattern like or ([^ia]|i[^m][^p]|a[^g][^r])
the website is using a pretty restrictive regex flavour (for speed), but in Python flavour you'd do [ ]or[ ](?!implied)(?!agreed to)
silver forge
Reading regex makes me want to break things.
Keeps things short, but it's annoying to read.
I use it and think, "okay it's done, let's forget about it".
It is what it is and I get to be lazy, kinda.
twin laurel
I think it's good if you don't overuse the more advanced parts, and recognize some similarities (like how (?!), (?<), (?!<), (?P<foo>) all share the (?...) shape)
Also you can make them verbose
!e
import re
pat = re.compile(r"""
\sor\s
(?!implied) # skip MIT License
(?!agreed to) # skip Apache 2.0 License
""", re.VERBOSE)
print(pat)
:white_check_mark: Your 3.12 eval job has completed with return code 0.
re.compile('\n\\sor\\s\n(?!implied) # skip MIT License\n(?!agreed to) # skip Apache 2.0 License\n', re.VERBOSE)
Another shortcut I didn't know python had: :=.
Python seems to have ^ but not xor.
Unless it has another word for it.
twin laurel
well, a xor b is just bool(a) != bool(b)
or and and are useful because they're lazy, but xor can't be made lazy
silver forge
`or` and `and` are useful because they're lazy, but `xor` can't be made lazy
What do you mean it can't be made easy? They have ^, but not in the form of xor.
twin laurel
What do you mean it can't be made easy? They have `^`, but not in the form of `x...
or and and short-circuit if the result is already known
!e
def foo():
print("foo")
return 5
def bar():
print("bar")
return 6
x = foo() or bar()
print(x)
:white_check_mark: Your 3.12 eval job has completed with return code 0.
001 | foo
002 | 5
Python help channel closed