diff --git a/notes-other/pythonetc/getitem.md b/notes-other/pythonetc/getitem.md
new file mode 100644
index 0000000..4ebe4dd
--- /dev/null
+++ b/notes-other/pythonetc/getitem.md
@@ -0,0 +1,11 @@
+When you have a dict with a deep inheritance (like a configuration file) and path in it specified as a string, there is a fun and short way how to get a value from the dict by the given path:
+
+```python
+from functools import reduce
+from operator import getitem
+
+d = {'a': {'b': {'c': 13}}}
+path = 'a.b.c'
+reduce(getitem, path.split('.'), d)
+# 13
+```
diff --git a/notes-other/pythonetc/simplenamespace.md b/notes-other/pythonetc/simplenamespace.md
new file mode 100644
index 0000000..5fab84f
--- /dev/null
+++ b/notes-other/pythonetc/simplenamespace.md
@@ -0,0 +1,18 @@
+[types.SimpleNamespace](https://docs.python.org/3/library/types.html#types.SimpleNamespace) is a way to make a `dict` with access by attributes:
+
+```python
+from types import SimpleNamespace
+sn = SimpleNamespace(a=1, b=2)
+sn.a
+# 1
+
+sn.c
+# AttributeError: ...
+```
+
+However, values from SimpleNamespace can't be accessed by getitem anymore because "There should be one obvious way to do it":
+
+```python
+sn['a']
+# TypeError: 'types.SimpleNamespace' object is not subscriptable
+```
diff --git a/notes-other/pythonetc/zen.md b/notes-other/pythonetc/zen.md
new file mode 100644
index 0000000..fb6d9a1
--- /dev/null
+++ b/notes-other/pythonetc/zen.md
@@ -0,0 +1,44 @@
+The famous "Zen of Python" was introduced in [PEP-20](https://www.python.org/dev/peps/pep-0020/). This is 19 Guido van Rossum's aphorisms collected by Tim Peters. Do `import this` in the Python interpreter to see them:
+
+```python
+>>> import this
+The Zen of Python, by Tim Peters
+
+Beautiful is better than ugly.
+Explicit is better than implicit.
+Simple is better than complex.
+Complex is better than complicated.
+Flat is better than nested.
+Sparse is better than dense.
+Readability counts.
+Special cases aren't special enough to break the rules.
+Although practicality beats purity.
+Errors should never pass silently.
+Unless explicitly silenced.
+In the face of ambiguity, refuse the temptation to guess.
+There should be one-- and preferably only one --obvious way to do it.
+Although that way may not be obvious at first unless you're Dutch.
+Now is better than never.
+Although never is often better than *right* now.
+If the implementation is hard to explain, it's a bad idea.
+If the implementation is easy to explain, it may be a good idea.
+Namespaces are one honking great idea -- let's do more of those!
+```
+
+The fun thing is how this module looks like. The original text is encoded by [ROT13](https://en.wikipedia.org/wiki/ROT13) algorithm and is decoded on the fly:
+
+
+```python
+s = """Gur Mra bs Clguba, ol Gvz Crgref
+...
+"""
+
+d = {}
+for c in (65, 97):
+ for i in range(26):
+ d[chr(i+c)] = chr((i+13) % 26 + c)
+
+print("".join([d.get(c, c) for c in s]))
+```
+
+Some say it violates almost all the principles that it contains.