>>> from scipy.optimize import minimize
>>> def f(x):
...     return (x[0] - 2) ** 2 + 10
... 
>>> res = minimize(f, [0.0], method='SLSQP')
>>> print res.x
[ 2.]

>>> res = minimize(f, [0.0], method='SLSQP', bounds=((-100.0,  1.0),))
>>> res
  status: 0
 success: True
    njev: 2
    nfev: 6
     fun: 10.999999999999996
       x: array([ 1.])
 message: 'Optimization terminated successfully.'
     jac: array([-1.99999988,  0.        ])
     nit: 2

>>> res = minimize(f, [0.0], method='SLSQP', bounds=((-100.0,  1.0),), constraints={'type': 'ineq', 'fun': lambda x: f(x) - 12})
>>> res
  status: 0
 success: True
    njev: 5
    nfev: 15
     fun: 12.000000000108864
       x: array([ 0.58578644])
 message: 'Optimization terminated successfully.'
     jac: array([-2.8284272,  0.       ])
     nit: 5

for el in l:
    addr[-1]+= 1
    print str(addr) + ':' + str(el)
    if (type(el) == list):  # sublist
        addr.append(0)
        f(el, addr)
    else:
        pass
return addr

import threading

def timed_func(timeout):
    job_is_done = False
    
    still_alive = threading.Event()
    still_alive.set()
    
    timer = threading.Timer(timeout, still_alive.clear)
    timer.start()
    
    while still_alive.is_set() and not job_is_done:
        # raise job_is_done flag then continue instead of just break!
        ...
        do some stuff..
        ...
    
    else:
        timer.join()  # wait for the timer to finish
    
    timer.cancel()

while True: timed_func(3)

def func():
  """ Return that""" 

def check_transtp(transtp):
if transtp == "tram" or transtp == "bus" or transtp == "trolleybus" or transtp == "night_bus":
return True
else:
return False

def check_transtp(transtp):
    return transtp in ["tram", "bus", "trolleybus", "night_bus"]

#!/usr/bin/env python3

from multiprocessing import Pool
from time import sleep

counter = 0
markers = range(20)

def runner(marker):
	print(marker)

def main():
	if counter == 10:
		raise SystemExit

	pool = Pool(2)
	pool.map(runner, markers)

while True:
	main()
	sleep(3)
	counter += 1

pool.terminate()
pool.join()

#!/usr/bin/env python3

class Hello:
	X = ['browser']
	def __init__(self, x):
		self.x = x

	def translate(self):
		Hello.X.extend(['-new-tab', self.x])

def main():
	hello1 = Hello(1)
	hello2 = Hello(2)
	hello1.translate()
	hello2.translate()

main()
print(Hello.X)

from multiprocessing import Pool

class Hello:
	X = ['browser']

	def __init__(self, x):
		self.x = x

	def translate(self):
		Hello.X.extend(['-new-tab', self.x])

def runner(marker):
	inst = Hello(marker)
	inst.translate()

def main():
	markers = range(2)
	pool = Pool(len(markers))
	pool.map(runner, markers)
	pool.terminate()

main()
print(Hello.X)

s.listen(backlog)
сonnection, address = s.accept()

data = сonnection.recv(1024)

for xx in range (21):
    if smap[yy][xx]=='#':
        map[yy][xx]=Tile(True)

for x in range(SCREEN_WIDTH):
    if smap[y][x] == '#':
        ....далее присваивание...

map = [[Tile(False)
                for y in range(MAP_HEIGHT) ]
                        for x in range(MAP_WIDTH) ]

map_ = [[Tile(cell == '#') for cell in row] for row in smap]

if block_sight == False

self.block_sight = block_sight or blocked

def __init__(self, blocked,color,block_sight = None):
    self.color=color 

for x in range(100):
    if maps[y][x]=='#':
        map[x][y]=wall_wood

return self.get_query_set().get(*args, **kwargs)

% self.model._meta.object_name)

False
>>> x(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'x' object is not callable
>>> Foo.__call__ = lambda s, y: y*y
>>> callable(x)
True
>>> x.__call__(4)
16
>>> x(4)    # краткая запись вызова __call__
16
>>> def foo(y): return y*y
>>> dir(foo)
['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', ..., '__str__', '__subclasshook__']
>>> isinstance(foo, object)
True
>>> foo.__call__(4)
16

tt0133093, The Matrix, Sci-Fi
tt0110912, Pulp Fiction, Crime

from collections import Counter

genres = Counter(l.split(',')[2].strip() for l in open('films.txt', 'r'))
unique_genres = list(genres.keys())
max_posters = max(genres.values())

from collections import namedtuple

_Movie = namedtuple('Movie', 'mdb_id, title, genre, poster')

def Movie(mdb_id, title, genre, poster=None):  # workaround for default "poster" argument
    return _Movie(mdb_id, title, genre, poster)

# read movies from file
movies = [Movie(*(i.strip() for i in line.split(',', 2)))
          for line in open('films.txt', 'r')]

genres = Counter(m.genre for m in movies)

for mov in movies:
    p_url = get_poster_url(mov.mdb_id)
    if p_url:
        mov.poster = urlopen(p_url).read()

movies.sort(key=lambda m: m.genre)

genre = mov.genre
try:
    x = 20+(WIDTH+20)*unique_genres.index(genre)
except ValueError: pass
else:
    y = 100 + y_counter[genre]
    ...

while not q1.empty():
    movie = q1.get()

try:
    while True:
        movie = q1.get(timeout=TIMEOUT)  # или .get_nowait()
        ...
except Empty: pass

from multiprocessing.pool import ThreadPool
downloader = ThreadPool(threads_num)
downloader.map(get_link_and_poster, movies)  # blocks until the result is ready.

for mov in downloader.imap_unordered(get_link_and_poster, movies):
    if mov.poster:
        ...

try:
    ...
    ...
except (AttributeError, ..., Whatever):  # looks like it wasn't wx.Window after all
    raise TypeError("Expected 'wx.Window' got '{0.__name__}'"
                    .format(type(window)))

if not hasattr(window, 'Show'):
    raise TypeError("Can't show this window!")

from abc import ABCMeta, abstractmethod
class A(metaclass=ABCMeta):  # for Python3
    # __metaclass__=ABCMeta  # for Python2
    @abstractmethod
    def foo(self): pass

class B(A):
    def foo(self): pass

class C(A): pass
>
>>> a=B()  # OK
>>> b=C()
TypeError: Can't instantiate abstract class C with abstract methods foo

for a in b:
    do_something(a)

c = iter(b)
a = next(c)

while True:
    try:
        do_something(a)
    except:
        pass
    else:
        try:
            a = next(c)
        except StopIteration:
            break

for a in b:
    try:
        do_something(a)
    except:
        pass

for a in b:
    try:
        do_something(a)
    except:
        прогнать_еще_раз_текущий_(а)

for a in b:
    f = True
    while f:
        try:
            do_something(a)
            f = False
        except Exception as e:
            pass

for a in b:
    while True:
        try:
            do_something(a)
        except Exception: pass
        else: break

time_alarm=time_alarm.split(':')
hours=time_alarm[0]
minutes=time_alarm[1]

hours, minutes = time_alarm.split(':')

for event in pygame.event.get():
            pygame.mouse.set_visible(0)

url = 'http://www.kinopoisk.ru'
page = opener.open(url)
html = str(page.read().decode(encoding='cp1251'))

                   'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.19 (KHTML, like Gecko) Version/3.1.2 Safari/525.21',
                   'Accept': r"text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1",
                   'Accept-Language': r"en-EN,ru;q=0.9,en;q=0.8",
                   #'Accept-Encoding': r"deflate, gzip, identity, *;q=0",
                   'Accept-Encoding': r"gzip;q=0,deflate;q=0, identity, *;q=0",
                   'Accept-Charset': r"Accept-Charset: iso-8859-1, utf-8, *;q=0.1",
                   'Keep-Alive': r"300",^M
                   'Connection': r"Keep-Alive",

                }

import datetime
print(datetime.datetime.fromtimestamp(int("1284101485")).strftime('%Y-%m-%d %H:%M:%S'))

class Dispatch:
    def foo1: pass
    def foo2: pass
    ...
    def foon: pass

while True:
    fun = input('blah.. blah..')
    if not fun: break
    foo = getattr(Dispatch, fun)  # или наоборот
    result = foo(*args, **kwargs)

import cmd

class Standart(cmd):
    def __init__(self, tasklist)
        self.tasklist = tasklist

    def do_Add(self):
        # addtask to self.tasklist
        pass

    # ...

    def do_Del(self):
        # deltask from self.tasklist
        pass

std = Standart(tasklist)
std.prompt = "Справка = help. Команда: " 
std.cmdloop()

if not os.path.abspath(path).startswith(abs_work_dir_path):
    raise Exception()

allowed_files = {'file1': 'httptest/files/1',
                 'file2': 'httptest/files/2',
                 ...
                 'test/file3': 'httptest/testfiles/3'}

try:
    file = open(allowed_files[path])
except KeyError:
    print('Access denied')

def fact(n)
  if n == 0 then return 1
  else return n * fact(n - 1) end
end

def test_fact
  assert(fact(0) == 1)
  assert(fact(1) == 1)
  assert(fact(3) == 6)
  assert(fact(5) == 120)
end

class AttributeDict(dict): 
    __getattr__ = dict.__getitem__
    __setattr__ = dict.__setitem__

urls = AttributeDict({})
urls.foo = bar

class Node:
    def __init__(self, val=None):
        self._val = val

    def __getattr__(self, name):
        d = self.__dict__
        attr = d.get(name)
        
        if not name.startswith('_') and attr is None:
            attr = Node()
            d[name] = attr

        return attr
    
    def __setattr__(self, name, val):
        d = self.__dict__
        
        if name.startswith('_'):
            d[name] = val
        
        else:
            self.__getattr__(name)._val = val