def func(foo, bar, *args, **kwargs):
    pass

    
mydict = dict()
mylist = list(mydict)

class c():
    attr = 5

another_comprehended_list = [item.attr for item in [c(), c(), c()]]
    
comprehended_list = [x for x in [1, 2, 3] if x in ('a')]
print x
    
def func(**kwargs):
    for item in kwargs.iterkeys():
        print item
    return kwargs

def yieldTest():
    yield "foo"
    
def my_func():
    my_var_04 = 5
    my_var_01 = 1
    my_var_07 = 12
    my_var_07 = 12
    my_var_07 = 12
    more_vars = 2
    my_var_02 = 2
    my_var_03 = 3

class cls():
    def myfunc(self):
        some_var = my_func
    
    def another(self):
        print self

new_threads = cls()

try:
    known_threads = {line.strip() for line  in ["foo"] if line.strip()}
except IOError:
    pass
    known_threads = set()

# Remove threads already in the cache so we can write the new ones only.
new_threads = new_threads - known_threads
        
import os

def ASDF(arg, arg2):
    arg = arg2
    print arg2
print ASDF()

a = a and a
a = a or b

class some_class(foo, bar):
    def __init__(self):
        pass
    
    attr1 = 3
    attr2 = 5
    attr3 = 'str'

argarg = 2

some_instance = some_class()
some_instance.attr1
some_instance.attr2
some_instance.some_method().foobar
some_instance.some_method(some_arg, some_arg2).second_attribute
some_instance \
		.   attr1 \
		.funcfunc(argarg, arg2arg) \
		.foo

#comment
"""
multiline comment
foo
bar
"""
 
import sys
import random

import PyQt4.QtCore

import bisect
bisect.bisect_right()

print sys

def returns_int(param):
    return 5

def returns_str(param):
    return 'str'

def returns_list(param): return [];

foo = returns_list()

bar = 'test'
foo = returns_int()
s = returns_str()
l = returns_list()

def simple_func(foo):
	""" usage comment, bla, param:foo"""
	pass

copied = simple_func
print copied

def function(foo):
	""" docstring
	more
	more more
	>>> test
	>>> test
	"""
	return foo

try:
    pass
except Exception as e:
    print e

def func(foo, bar, baz, bang, foobang, foobar, foobazbar, foobazbarbang):
    return foobang
    print foo
    print foobazbarbang
    
    import asynchat
    obj = asynchat.async_chat()
    obj.collect_incoming_data()
    import _winreg
    _winreg.CreateKey()
    import binhex
    binhex.hexbin()
    
    print foo, bar, baz, bang
    
    if foobazbar < 5:
        pass

func(sys)
simple_func()

def func_without_param():
    pass
    return [(lambda foo: foo) for fdlksh in [1, 2, 3]]

func_without_param()

def another_function(param):
    return [3 for x in param]

a = 5

bar = a == a
a != a
a < a
a <= a
a > a
a >= a
a is a
a is not a
a not in a
a in a

a = a + 1
a = a - 1
a = a * 1
a = a / 1
a = a % 1
a = a ^ 1
a = a & 1
a = a | 1
a = a ** 1
a = a >> 1
a = a << 1

a = not a
a = +a
a = -a
a = ~a

a = b[1:2:3][2]
extended = a[1:2, 2:3]

i += 3
i += j

print 3 if 5 < 7 else 4

from random import random

print random

random(foo=3)

a = lambda x: x**2

@staticmethod
@classmethod
def genfunc():
    yield foo

for target1, target2 in some_dict.iteritems():
    print target1, target2

pi = 3.1415

foo = 1, 2
bar = (1, 2)

with open('f') as foo:
    pass

global IMAGLOBALVARIABLE
IMAGLOBALVARIABLE = 0
try:
    a = 3 / 0
except ZeroDivisionError as err:
    raise ValueError
else:
    do_something()
finally:
    BAM

if 3 and 5:
    pass

for i in xrange(20):
    pass

while True:
    break
    continue

del foo

import random
random.random(3, 5)

somelist = [1, 2, 3, 4, 5]
somedict = { 'key1' : 'value1', key2: value2 }

print somelist[...]
print somelist[1:]
print somelist[:20]
print somelist[1:20]
print somelist[1:20:2]

class bar(parent):
    pass

if foo in bar and 3 < 5:
    pass

a = [x*2 for x in xrange(20)]

variable.variable2.variable3 = 15
def function(param1, param2, param3, *paramstar, **paramdstar):
    pass
    return param1 * param2

assert False
if not 3:
    pass

if 3 * 5 == 7:
    pass
