uzverss

>>> table = {'a': [1, 2, 3],
             'b': ['spam', 'eggs'],
             'c': {'name':'bob'}}
>>>
>>> import pickle
>>> mydb = open('dbase', 'wb')
>>> pickle.dump(table, mydb)

C:\...\PP4E\Dbase> python
>>> import pickle
>>> mydb = open('dbase', 'rb')
>>> table = pickle.load(mydb)
>>> table
{'a': [1, 2, 3], 'c': {'name': 'bob'}, 'b': ['spam', 'eggs']}

Кодирование JSON
>>> import json
>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
'["foo", {"bar": ["baz", null, 1.0, 2]}]'

>>> import json
>>> json.dumps([1,2,3,{'4': 5, '6': 7}], separators=(',',':'))
'[1,2,3,{"4":5,"6":7}]'

Красивый вывод:
>>> import json
>>> print json.dumps({'4': 5, '6': 7}, sort_keys=True,
...                  indent=4, separators=(',', ': '))
{
    "4": 5,
    "6": 7
}

Декодироние JSON

>>> import json
>>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
[u'foo', {u'bar': [u'baz', None, 1.0, 2]}]

Использование json.tool из шелла для проверки и красивого вывода:
$ echo '{"json":"obj"}' | python -mjson.tool
{
    "json": "obj"
}

>>> import sqlite3
>>> conn = sqlite3.connect('dbase1') # при необходимости используйте полный путь к файлу
# мож­но пе­ре­дать спе­ци­аль­ную стро­ку «:memory:», что­бы соз­дать вре­мен­ную ба­зу дан­ных в па­мя­ти
>>> curs = conn.cursor()
>>> tblcmd = 'create table people (name char(30), job char(10), pay int(4))'
>>> curs.execute(tblcmd)
>>> curs.executemany('insert into people values (?, ?, ?)',
...          [ ('Sue', 'mus', '70000'),
...            ('Ann', 'mus', '60000')])
>>> rows = [['Tom', 'mgr', 100000],
...         ['Kim', 'adm', 30000],
...         ['pat', 'dev', 90000]]
>>> for row in rows:
...     curs.execute('insert into people values (? , ?, ?)', row)
...
>>> conn.commit() # сохранить изменения в базе
>>> curs.execute('select * from people') # выбрать записи
>>> curs.fetchall() # из­влечь записи
[('Bob', 'dev', 5000), ('Sue', 'mus', 70000), ('Ann', 'mus', 60000), ('Tom',
'mgr', 100000), ('Kim', 'adm', 30000), ('pat', 'dev', 90000)]

>>> for (name, job, pay) in curs.fetchall():
...     print(name, ':', pay)

>>> curs.execute('select * from people')
>>> colnames = [desc[0] for desc in curs.description]
>>> colnames
['name', 'job', 'pay']
>>> for row in curs.fetchall():
...     for name, value in zip(colnames, row):
...        print(name, '\t=>', value)
...    print()

>>> curs.execute('delete from people where name = ?', ['Bob'])
>>> curs.execute('delete from people where pay >= ?',(90000,))
>>> curs.execute('select * from people')
>>> curs.fetchall()
[('Sue', 'mus', 70000), ('Ann', 'mus', 65000), ('Kim', 'adm', 65000)]
>>> conn.commit()

>>> curs.execute('select * from people')
>>> colnames = [desc[0] for desc in curs.description]
>>> rowdicts = [dict(zip(colnames, row)) for row in curs.fetchall()]
>>> rowdicts[0]
{'pay': 70000, 'job': 'mus', 'name': 'Sue'}

>>> from sqlite3 import connect
>>> conn = connect('dbase1')
>>> curs = conn.cursor()
>>> curs.execute('delete from people')      # очистить таблицу
>>> curs.execute('select * from people')
>>> curs.fetchall()
[]
>>> file = open('data.txt')
>>> rows = [line.rstrip().split(',') for line in file]
>>> rows[0]
['bob', 'devel', '50000']

>>> curs.execute("select sum(pay), avg(pay) from people where job = 'devel'")
>>> curs.fetchall()
[(150000, 50000.0)]

>>> import records 
>>> db = records.Database('sqlite:///mydb.db') 
>>> 
>>> rows = db.query('SELECT * FROM cheese') 
>>> print(rows.dataset) 
name         |price 
-------------|----- 
red leicester|1.0 
wensleydale  |2.2 
>>> 
>>> print(rows.export('json')) 
[{"name": "red leicester", "price": 1.0}, {"name": "wensleydale", "price": 2.2}]

$ records 'SELECT * FROM cheese' yaml --url=sqlite:///mydb.db 
- {name: red leicester, price: 1.0} 
- {name: wensleydale, price: 2.2} 
$ records 'SELECT * FROM cheese' xlsx --url=sqlite:///mydb.db > cheeses.xlsx

>>> 'spam eggs ham'.split()
['spam', 'eggs', 'ham']
>>> tuple(['spam', 'eggs', 'ham'])
('spam', 'eggs', 'ham')
>>> list(('spam', 'eggs', 'ham'))
['spam', 'eggs', 'ham']
>>> list('spam eggs ham')
['s', 'p', 'a', 'm', ' ', 'e', 'g', 'g', 's', ' ', 'h', 'a', 'm']
>>> ''.join(['s', 'p', 'a', 'm', ' ', 'e', 'g', 'g', 's', ' ', 'h', 'a', 'm'])
'spam eggs ham'
>>> '*'.join('spam eggs ham')
's*p*a*m* *e*g*g*s* *h*a*m'
>>> 's*p*a*m* *e*g*g*s* *h*a*m'.split('*')
['s', 'p', 'a', 'm', ' ', 'e', 'g', 'g', 's', ' ', 'h', 'a', 'm']
>>> ''.join(['s', 'p', 'a', 'm', ' ', 'e', 'g', 'g', 's', ' ', 'h', 'a', 'm'])
'spam eggs ham'

вредный совет
выпрямить вложенные списки с помощью функции sum()
>>> l=[['a', 'b', 'c'], ['1', '2'], ['#']]
>>> sum(l, [])
['a', 'b', 'c', '1', '2', '#']

типа 
perl -pa0e'$_=join",",@F' 1.txt > 2.txt
sed ':a;N;$!ba;s/\n/ /g' my.txt > my1.txt

>>> s="""
... Keujiuz8 
... ze5iiFee 
... chuF7hae 
... Quah8equ 
... UZiloh9A 
... quiWin0d 
... Fael9uo8 
... pheeph7M
... """
>>> s
'\nKeujiuz8 \nze5iiFee \nchuF7hae \nQuah8equ \nUZiloh9A \nquiWin0d \nFael9uo8 \npheeph7M\n'
>>> ' '.join(s.split())
'Keujiuz8 ze5iiFee chuF7hae Quah8equ UZiloh9A quiWin0d Fael9uo8 pheeph7M'

>>> d=s.split()
>>> for i in range(len(d)): print(d[i])
... 
Keujiuz8
ze5iiFee
chuF7hae
Quah8equ
UZiloh9A
quiWin0d
Fael9uo8
pheeph7M

>>> a=['sjdej', 'jsjjjsj', 'jdeechfeo']
>>> for i in a: print(i)
... 
sjdej
jsjjjsj
jdeechfeo

>>> for i in range(1,4): print ("abc"*i)
... 
abc
abcabc
abcabcabc

>>> for i in range(2, 22, 3): print('Номер ('+ str(i)+')')
... 
Номер (2)
Номер (5)
Номер (8)
Номер (11)
Номер (14)
Номер (17)
Номер (20)

>>> supplers = ['pens', 'staplers', 'binders']
>>> for i in range(len(supplers)):
...     print('Index ' + str(i) + ' in supplers is: ' + supplers[i])
... 
Index 0 in supplers is: pens
Index 1 in supplers is: staplers
Index 2 in supplers is: binders

>>> str='blablabla'
>>> str=str.upper()
>>> str
'BLABLABLA'
>>> str=str.lower()
>>> str
'blablabla'
>>> str=str.capitalize()
>>> str
'Blablabla'
>>> str=str.swapcase()
>>> str
'bLABLABLA'
>>> str=str.title()
>>> str
'Blablabla'
>>> 'bLABLABLA'.casefold()
'blablabla'

>>> a=list('habrahabr')
>>> a.reverse()
>>> ''.join(a)
'rbaharbah'

>>> 'hanrahabr'[::-1]
'rbaharnah'

>>> import difflib 
>>> capitals = ('Montgomery', 'Juneau', 'Phoenix', 'Little Rock') 
>>> difflib.get_close_matches('Fenix', capitals) 
['Phoenix']

>>> 'spam eggs ham'[5:10]            # извлечение среза: подстрока
'eggs '
>>> 'spam ' + 'eggs ham'             # конкатенация (и *, len(), [ix])
'spam eggs ham'
>>> 'spam %s %s' % ('eggs', 'ham') # выражение форматирования: подстановка
'spam eggs ham'
>>> 'spam {} {}'.format('eggs', 'ham') # метод форматирования: альтернатива %
'spam eggs ham'
>>> 'spam = "%-5s", %+06d' % ('ham', 99) # более сложное форматирование
'spam = "ham ", +00099'
>>> 'spam = "{0:<5}", {1:+06}'.format('ham', 99)
'spam = "ham ", +00099'

>>> '-'.join([str(i) for i in range(10)])
'0-1-2-3-4-5-6-7-8-9'
>>> "bla {} blabl {} lala {}".format(1,2,3) 
'bla 1 blabl 2 lala 3'
>>> "bla {2} blabl {0:=10} lala {1}".format(1,2,3) 
'bla 3 blabl          1 lala 2'
>>> "bla   blabl  lala ".split()
['bla', 'blabl', 'lala']
>>> "blahblablhlala".split('h')
['bla', 'blabl', 'lala']
>>> "blahblablhlala".replace('a','z')
'blzhblzblhlzlz'
>>> '_'.join([str(i) for i in range(10)])
'0_1_2_3_4_5_6_7_8_9'

>>> y = {c.upper() * 4 for c in 'spamham'} # генератор множеств
>>> y
{'SSSS', 'AAAA', 'MMMM', 'HHHH', 'PPPP'}
>>>
>>> list(set([1, 2, 3, 1, 2]))             # удалит дубликаты из списка
[1, 2, 3]

>>> L = [{'n':3}, {'n':20}, {'n':0}, {'n':9}]
>>> L.sort(key=lambda x: x['n'])
>>> L
[{'n': 0}, {'n': 3}, {'n': 9}, {'n': 20}]

>>> L = [2, 4, 1, 3, 5]
>>> L.reverse()
>>> L
[5, 3, 1, 4, 2]
>>> L = [2, 4, 1, 3, 5]
>>> list(reversed(L))
[5, 3, 1, 4, 2]

>>> 'A B C D'.split()
['A', 'B', 'C', 'D']
>>> 'A+B+C+D'.split('+')
['A', 'B', 'C', 'D']
>>> '--'.join(['a', 'b', 'c'])
'a--b--c'

>>> 'aaa--bbb--ccc'.split('--')
['aaa', 'bbb', 'ccc']
>>> 'aaa--bbb--ccc'.replace('--', '...') 
'aaa...bbb...ccc' 

>>> x=[34,56]
>>> print((''.join(list(map(str,x)))),)
3456

удалить общие строки из двух списков

>>> a="abb bbb ccc eee".split()
>>> b="aab bbb ccd eee".split()
>>> aa=set(a)
>>> bb=set(b)
>>> c = bb.difference(aa)
>>> print(c)
{'aab', 'ccd'}

удаление повторяющихся в списке значений:

>>> nums = [1, 3, 2, 3, 1, 2, 3, 1, 2]
>>> unique_nums = list(set(nums))
>>> unique_nums
[1, 2, 3]

Замена в строке с помощью Python

аналог sed 's/Windows/Linux/g'
>>> s='Windows Windows Windows'
>>> s.replace('Windows', 'Linux')
'Linux Linux Linux'

аналог sed -i 's/Windows/Linux/g' text
>>> old="Windows"
>>> new="Linux"
>>> text="Windows Windows Windows"
>>> import re
>>> print(re.sub(r'\bWindows\b', 'Linux', line))


бы­ст­ро за­ме­нить в фай­ле ка­ж­дый сим­вол та­бу­ля­ции че­тырь­мя точ­ка­ми
from sys import *
stdout.write(('.' * 4).join(stdin.read().split('\t'))) 

[a-zA-Z0-9_]+ со­от­вет­ст­ву­ет са­мой длин­ной стро­ке из од­но­го или бо­лее сим­во­лов букв, цифр или под­чер­ки­ва­ний. 
\w Лю­бой ал­фа­вит­но-циф­ро­вой сим­вол ([a-zA-Z0-9_] для ASCII)
[\t ]* со­от­вет­ст­ву­ет ну­лю или бо­лее та­бу­ля­ций и про­бе­лов        

>>> table = "".maketrans('12', '34', 'cs')
>>> '1212cs 5612cs cscs'.translate(table)
'3434 5634 '

>>> intab = "aeiou"
>>> outtab = "12345"
>>> trantab = str.maketrans(intab, outtab)
>>> str = "this is string example....wow!!!"
>>> print (str.translate(trantab))
th3s 3s str3ng 2x1mpl2....w4w!!!

strip() удаляет начальные и конечные пробелы
replace() удаляет все пробелы из строки
translate() избавиться от всех пробелов, а также от символов новой строки
" ".join(s.split()) избавиться от всех повторяющихся пробелов и символов новой строки
'строка'[1:] удалить первый символ строки

добавить символы в начало и конец строки
yourstring = "L{0}LL".format(yourstring) 
yourstring = ''.join(('L','yourstring','LL'))
yourstring = "L%sLL" % yourstring
yourstring = "L" + yourstring + "LL"

yourstring = '"'{0}'"'.format(yourstring) добавить кавычки в начало и конец строки

user_input = "This\nstring has\tsome whitespaces...\r\n"

character_map = {
 ord('\n') : ' ',
 ord('\t') : ' ',
 ord('\r') : None
}
user_input.translate(character_map)  # This string has some whitespaces... "

аналог sed -i 's/Windows/Linux/g' text
>>> old="Windows"
>>> new="Linux"
>>> text="Windows Windows Windows"
>>> import re
>>> print(re.sub(r'\bWindows\b', 'Linux', line))

>>> import re
>>> re.split('--', 'aaa--bbb--ccc')
['aaa', 'bbb', 'ccc']
>>> re.sub('--', '...', 'aaa--bbb--ccc')    # случай с единственным разделителем
'aaa...bbb...ccc'
>>> re.split('--|==', 'aaa--bbb==ccc')      # разбить по -- или ==
['aaa', 'bbb', 'ccc']
>>> re.sub('--|==', '...', 'aaa--bbb==ccc') # заменить -- или ==
'aaa...bbb...ccc'
>>> re.split('[-=]', 'aaa-bbb=ccc')      # односимвольные альтернативы
['aaa', 'bbb', 'ccc']
>>> re.split('(--)|(==)', 'aaa--bbb==ccc')     # результат разбиения
['aaa', '--', None, 'bbb', None, '==', 'ccc'] # включает группы
>>> re.split('(?:--)|(?:==)', 'aaa--bbb==ccc') # часть выражения, не группы
['aaa', 'bbb', 'ccc']

>>> a='Это не будет развернуто: \nновая строка'
>>> print(a)
Это не будет развернуто: 
новая строка
>>> a='Это не будет развернуто: \tновая строка'
>>> print(a)
Это не будет развернуто: 	новая строка
>>> a='Это не будет развернуто: \vновая строка'
>>> print(a)
Это не будет развернуто: 
                         новая строка
>>> a='Это не будет развернуто: \fновая строка'
>>> print(a)
Это не будет развернуто: 
                         новая строка
>>> a='Однажды Арнольд сказал: "I\'ll be back"'
>>> print(a)
Однажды Арнольд сказал: "I'll be back"

https://shultais.education/blog/python-f-strings

>>> name = "User"
>>> age = 100
>>> print("Меня зовут " + name + ". Мне " + str(age) + " лет.")
>>> Меня зовут User. Мне 100 лет.

>>> name = "User"
>>> age = 100
>>> print("Меня зовут %s. Мне %d лет." % (name, age))
>>> Меня зовут User. Мне 100 лет.
>>> print("Меня зовут %(name)s. Мне %(age)d лет." % {"name": name, "age": age})
>>> Меня зовут User. Мне 100 лет.

>>> from string import Template
>>> name = "User"
>>> age = 100
>>> s = Template('Меня зовут $name. Мне $age лет.')
>>> print(s.substitute(name=name, age=age))
>>> Меня зовут User. Мне 100 лет.

>>> name = "User"
>>> age = 100
>>> print("Меня зовут {}. Мне {} лет.".format(name, age)
>>> Меня зовут User. Мне 100 лет.
>>> print("Меня зовут {name} Мне {age} лет.".format(age=age, name=name)
>>> Меня зовут User. Мне 100 лет.

# начиная с Python 3.6
>>> name = "User" 
>>> age = 100
>>> print(f"Меня зовут {name} Мне {age} лет.")
>>> Меня зовут User. Мне 100 лет.

>>> "обычная строка"
>>> f"f-строка"

f-строки также поддерживают расширенное форматирование чисел:
>>> from math import pi
>>> print(f"Значение числа pi: {pi:.2f}")
>>> Значение числа pi: 3.14

С помощью f-строк можно форматировать дату без вызова метода strftime():
>>> from datetime import datetime as dt
>>> now = dt.now()
>>> print(f"Текущее время {now:%d.%m.%Y %H:%M}")
>>> Текущее время 24.02.2017 15:51

Они поддерживают базовые арифметические операции. Да, прямо в строках:
>>> x = 10
>>> y = 5
>>> print(f"{x} x {y} / 2 = {x * y / 2}")
>>> 10 x 5 / 2 = 25.0

Позволяют обращаться к значениям списков по индексу:
>>> planets = ["Меркурий", "Венера", "Земля", "Марс"]
>>> print(f"Мы живим не планете {planets[2]}")
>>> Мы живим не планете Земля

А также к элементам словаря по ключу:
>>> planet = {"name": "Земля", "radius": 6378000}
>>> print(f"Планета {planet['name']}. Радиус {planet['radius']/1000} км.")
>>> Планета Земля. Радиус 6378.0 км. 

Причем вы можете использовать как строковые, так и числовые ключи. Точно также как в обычном Python коде:
>>> digits = {0: 'ноль', 'one': 'один'}
>>> print(f"0 - {digits[0]}, 1 - {digits['one']}")
>>> 0 - ноль, 1 - один

Вы можете вызывать в f-строках методы объектов:
>>> name = "User"
>>> print(f"Имя: {name.upper()}")
>>> Имя: User

А также вызывать функции:
>>> print(f"13 / 3 = {round(13/3)}")
>>> 13 / 3 = 4

>>> s = 'abc'
>>> t = (10, 20, 30)
>>> u = (-5, -10, -15)
>>> list(zip(s,t,u))
[('a', 10, -5), ('b', 20, -10), ('c', 30, -15)]
>>> [(s[i], t[i]) for i in range(len(s))] 
[('a', 10), ('b', 20), ('c', 30)]
>>> [(s[i], t[i]) for i in range(len(sorted((s,t), key=len)[0]))]
[('a', 10), ('b', 20), ('c', 30)]
>>> def shortest_sequence_range(*args):
...     return range(len(sorted(args, key=len)[0]))
... 
>>> [(s[i], t[i]) for i in shortest_sequence_range(s,t) ]
[('a', 10), ('b', 20), ('c', 30)]
>>> g = ((s[i], t[i]) for i in shortest_sequence_range(s,t) )
>>> for item in g: print(item)
... 
('a', 10)
('b', 20)
('c', 30)

>>> names = ['Tom', 'Dick', 'Harry']
>>> ages = [50, 35, 60]
>>> dict(zip(names, ages))
{'Harry': 60, 'Dick': 35, 'Tom': 50}

вместо
grep -F -f 2.txt 1.txt > 3.txt (все совпадающие)
grep -Fv -f 2.txt 1.txt > 3.txt (разница)
grep -i -Fv -f 2.txt 1.txt > 3.txt (разница без учёта регистра)
pcregrep -vFf 2.txt 1.txt

эти точнее
diff --old-line-format=$'%l\n' --new-line-format='' --unchanged-line-format='' <(sort -u 2.txt) <(sort -u 1.txt)
comm -23 1.txt 2.txt
comm -13 <(sort -u 1.txt) <(sort -u 2.txt)|cat > output
Compare-Object (gc 1.txt) (gc 2.txt)  -PassThru


$ cat 1.txt
one two three four
$ cat 2.txt
two three one

вначале привести к одинаковому регистру 
типа
$ tr '[:upper:]' '[:lower:]'  lower.txt

Все буквы будут большими:
$ sed -i 's/.*/\U&/' 1.txt

Все буквы будут маленькими:
$ sed -i 's/.*/\L&/' 1.txt

>>> with open('1.txt', 'r',  encoding='utf-8-sig') as fileinput: fileinput.read().lower();

>>> data = [set(open(i).read().split()) for i in ('1.txt', '2.txt')]
>>> print(data[0].difference(data[1]))