Programming-Idioms.org

print("Hello World")

print('Hello World')

for _ in range(10):
    print("Hello")

print("Hello\n"*10)

i = 0
while i < 10:
    print('Hello')
    i += 1

def f(): print('Hello')
for x in range(10): f()

f = lambda: print('Hello')
for x in range(10): f()

for x in repeat('Hello', 10): print(x)

def finish(name):
    print(f'My job here is done. Goodbye {name}')

f = lambda: print('abc')
f()

def square(x):
    return x*x

def square(x):
    return x**2

square = lambda x: x * x

@dataclass
class Point:
    x: float
    y: float

Point = namedtuple("Point", "x y")

point = {'x': 1.2, 'y': 3.4}

class P:
    def __init__(self, x: float, y: float):
        self.x, self.y = x, y

point = dict(x=1.2, y=3.4)

for x in items:
        doSomething( x )

[do_something(x) for x in items]

for i, x in enumerate(items):
    print(i, x)

for x in enumerate(items): print(x)

x = {"one" : 1, "two" : 2}

x = dict(a=1, b=2, c=3)

class Node:
	def __init__(self, data):
		self.data = data
		self.left = None
		self.right = None

class Node:
  def __init__(self, data, left_child, right_child):
    self.data = data
    self._left_child = left_child
    self._right_child = right_child

shuffle(x)

random.shuffle(x)

random.choice(x)

x in list

for k, v in mymap.items():
    print(k, v)

for x in mymap.items(): print(x)

random.uniform(a,b)

random.randint(a,b)

def dfs(bt):
	if bt is None:
		return
	dfs(bt.left)
	f(bt)
	dfs(bt.right)

class Node:
    def __init__(self, value, *children):
        self.value = value
        self.children = list(children)

def DFS(f, root):
	f(root)
	for child in root:
		DFS(f, child)

x = reversed(x)

y = x[::-1]

x.reverse()

def search(m, x):
    for idx, item in enumerate(m):
        if x in item:
            return idx, item.index(x)

def search(x, m):
    for i, M in enumerate(m):
        for j, N in enumerate(M):
            if N == x: return (i, j)

a, b = b, a

a =int(input("enter a number"))
b =int(input("enter b number")) 
a, b = b, a
 
print("Value of a:", a)
print("Value of a", b)

i = int(s)

s =  '{:.2f}'.format(x)

s = f'{x:.2f}'

s = "ネコ"

q = Queue()

def worker():
    while True:
        print(f"Hello, {q.get()}")
        q.task_done()

Thread(target=worker, daemon=True).start()

q.put("Alan")
q.join()

x = [[0] * n for _ in range(m)]

x = [[[0 for k in range(p)] for j in range(n)] for i in range(m)]

x = numpy.zeros((m,n,p))

items = sorted(items, key=lambda x: x.p)

items = sorted(items, key=attrgetter('p'))

del items[i]

items.pop(i)

pool = Pool()
for i in range(1, 1001):
	pool.apply_async(f, [i])

def f(i):
   if i == 0:
       return 1
   else:
       return i * f(i-1)

def exp(x, n):
        return x**n

lock = threading.Lock()

lock.acquire()
try:
	x = f(x)
finally:
	lock.release()

with threading.Lock():
    x = f(x)

class T(object):
    pass

x = set(T())

class T:
   ...

s = set(T() for _ in range(x))

def compose(f, g):
    return lambda a: g(f(a))

def compose(f, g):
	return lambda x: g(f(x))

compose = lambda f, g, x: g(f(x))

def add(a, b):
	return a+b

add_to_two = partial(add, 2)

t = s[i:j]

t = s[slice(i, j)]

ok = word in s

class Vertex(set): pass
class Graph(defaultdict):
  def __init__(self, *paths):
    self.default_factory = Vertex
    for path in paths:
      self.make_path(path)

  def make_path(self, labels):
    for l1, l2 in zip(labels, labels[1:]):
      self[l1].add(l2)
      self[l2].add(l1)

G = Graph((0, 1, 2, 3), (1, 4, 2))

t = s[::-1]

t = ''.join(reversed(s))

for v in a:
    try:
        for u in b:
            if v == u:
                raise Exception()
        print(v)
    except Exception:
        continue

for v in a:
  keep = True
  for w in b:
    if w == v:
      keep = False
      break
  if keep:
    print(v)

class BreakOuterLoop (Exception): pass

try:
    position = None
    for row in m:
        for column in m[row]:
            if m[row][column] == v:
                position = (row, column)
                raise BreakOuterLoop
except BreakOuterLoop:
    pass

def loop_breaking(m, v): 
    for i, row in enumerate(m): 
        for j, value in enumerate(row): 
            if value == v: 
                return (i, j)
    return None

print(loop_breaking(([1,2,3],[4,5,6],[7,8,9]), 6))

matrix = [[1,2,3],[4,-5,6],[7,8,9]]
try:
    print(next(i for i in chain.from_iterable(matrix) if i < 0))
except StopIteration:
    pass

b = False
for r in m:
    for i in r:
        if i < 0:
            print(i)
            b = True
    if b: break

b = False
for r in m:
    for i in r:
        if i < 0:
            print(i)
            b = True
    if b: break

s.insert(i, x)

time.sleep(5)

t = s[:5]

t = s[-5:]

s = """Huey
Dewey
Louie"""

chunks = s.split()

chunks = split(' +', s)

while True:
    pass

while 1: ...

k in m

m.get(k)

v in m.values()

y = ', '.join(x)

y = ', '.join(map(str, x))

f = lambda a, b: f'{a}, {b}'
y = reduce(f, x)

s = sum(x)

s = str(i)

def f(i):
	i * i

with Pool(1000) as p:
	p.map(func=f, iterable=range(1, 1001))

print('Finished')

y = list(filter(p, x))

y = [element for element in x if p(element)]

lines = open(f).read()

with open(f) as fo:
    lines = fo.read()

print(x, "is negative", file=sys.stderr)

x = sys.argv[1]

d = datetime.datetime.now()

i = x.find(y)

x2 = x.replace(y, z)

x = 3 ** 247

s = '{:.1%}'.format(x)

s = f"{x:.01%}"

z = x**n

def binom(n, k):
    return math.factorial(n) // math.factorial(k) // math.factorial(n - k)

def binom(n, k):
    return math.comb(n, k)

x = bytearray(int(math.ceil(n / 8.0)))

rand = random.Random(s)

rand = random.Random()

print(' '.join(sys.argv[1:]))

def fact(a_class, str_):
    if issubclass(a_class, Parent):
        return a_class(str_)

x = gcd(a, b)

x = math.gcd(a, b)

x = (a*b)//gcd(a, b)

x = math.lcm(a, b)

s = '{:b}'.format(x)

s = format(x, 'b')

x = 3j-2
y = x * 1j

while True:
    do_something()
    if not c:
        break

y = float(x)

y = int(x)

y = int(x + 0.5)

c = Context(rounding=ROUND_HALF_UP)
y = round(Decimal(x, c))

count = s.count(t)

r = re.compile(r"htt+p")

c = bin(i).count("1")

c = i.bit_count()

def adding_will_overflow(x,y):
    return False

def multiplyWillOverflow(x,y):
	return False

sys.exit(1)

buf = bytearray(1000000)

raise ValueError("x is invalid")

class Foo(object):
    def __init__(self):
        self._x = 0

    @property
    def x(self):
        """
        Doc for x
        """
        return self._x

with open("data.json", "r") as input:
    x = json.load(input)

with open("data.json", "w") as output:
    json.dump(x, output)

def control(f):
    f()

def control(f: Callable): f()

print(type(x))

print(x.__class__)

x = os.path.getsize(path)

b = s.startswith(prefix)

b = s.endswith(suffix)

d = datetime.date.fromtimestamp(ts)

d = date(2016, 9, 28)
x = d.strftime('%Y-%m-%d')

d = date.today()
x = d.isoformat()

items.sort(key=c)

items.sort(key=functools.cmp_to_key(c))

with urllib.request.urlopen(u) as f:
    s = f.read()

s = requests.get(u).content.decode()

filename, headers = urllib.request.urlretrieve(u, 'result.txt')

with open("results.txt", "wb") as fh:
	fh.write(requests.get(u).content)

x = lxml.etree.parse('data.xml')

s = sys.argv[0]

dir = os.getcwd()

dir = os.path.dirname(os.path.abspath(__file__))

dir = str(Path(__file__).parent)

if 'x' in locals():
	print(x)

try:
    x
except NameError:
    print("does not exist")

n = pympler.asizeof.asizeof(t)

blank = not s or s.isspace()

subprocess.call(['x', 'a', 'b'])

for k in sorted(mymap):
    print(mymap[k])

for e in sorted(m.items()):
    print(e)

for x, k in sorted((x, k) for k,x in mymap.items()):
    print(k, x)

for key, value in sorted(d.items(), key=operator.itemgetter(1)):
    print(key, value)

b = x == y

b = d1 < d2

s2 = s1.replace(w, '')

n = len(x)

y = set(x)

x = list(set(x))

x = list(OrderedDict(zip(x, x)))

def dedup(x):
  y = []
  for i in x:
    if not i in y:
      y.append(i)
  return y

n = int(input("Input Prompting String: "))

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((UDP_IP, p))
while True:
    data, addr = sock.recvfrom(1024)
    print("received message:", data)

class Suit:
	SPADES, HEARTS, DIAMONDS, CLUBS = range(4)

class Suit(Enum):
	SPADES = 1
	HEARTS = 2
	DIAMONDS = 3
	CLUBS = 4

assert isConsistent

def binarySearch(a, x):
    i = bisect.bisect_left(a, x)
    return i if i != len(a) and a[i] == x else -1

t1 = time.perf_counter_ns()
foo()
t2 = time.perf_counter_ns()
print('Nanoseconds:', t2 - t1)

def foo():
    return 'string', True

foo = lambda: ('abc', True)

foo = imp.load_module('foobody', 'foobody.txt').foo

def BFS(f, root):
	Q = [root]
	while Q:
		n = Q.pop(0)
		f(n)
		for child in n:
			if not n.discovered:
				n.discovered = True
				Q.append(n)

def breadth_first(start, f):
  seen = set()
  q = deque([start])
  while q:
    vertex = q.popleft()
    f(vertex)
    seen.add(vertex)
    q.extend(v for v in vertex.adjacent if v not in seen)

def depth_first(start, f):
  seen = set()
  stack = [start]
  while stack:
    vertex = stack.pop()
    f(vertex)
    seen.add(vertex)
    stack.extend(
      v for v in vertex.adjacent if v not in seen
    )

f1() if c1 else f2() if c2 else f3() if c3 else None

if c1:
    f1()
elif c2:
    f2()
elif c3:
    f3()

if c1: f1()
elif c2: f2()
elif c3: f3()

duration = timeit.timeit("f()", setup="from __main__ import f")

start = time.time()
f()
end = time.time()
return end - start

ok = word.lower() in s.lower()

items = [a, b, c]

items = list((a, b, c))

items.remove(x)

newlist = [item for item in items if item != x]

b = s.isdigit()

f = lambda x: x in digits
b = all(f(x) for x in s)
b = b and bool(len(s))

file = tempfile.TemporaryFile()

td = tempfile.TemporaryDirectory()

m.pop(k, None)

for x in items1 + items2:
    print(x)

for x in chain(items1, items2): print(x)

s = hex(x)

s = format(x, 'x')

for pair in zip(item1, item2): print(pair)

for x in z(items1, items2): print(x)

b = os.path.exists(fp)

b = Path(fp).exists()

logging.basicConfig(stream=sys.stdout, level=logging.DEBUG, format="%(asctime)-15s %(message)s")
logger = logging.getLogger('NAME OF LOGGER')

logger.info(msg)

s = u'545,2222'
locale.setlocale(locale.LC_ALL, 'de')
f = locale.atof(s)

f = float(s)

f = float(s)

t = re.sub('[^\u0000-\u007f]', '',  s)

t = s.encode("ascii", "ignore").decode()

f = lambda x: ord(x) < 0x80
t = ''.join(filter(f, list(s)))

list(map(int, input().split()))

numbers = [int(x) for x in input().split()]

p = p.rstrip("/")

if p.endswith(os.sep):
    p = p[:-1]

s = c

t = f"{s}{i}"

r1, g1, b1 = [int(c1[p:p+2], 16) for p in range(1,6,2)]
r2, g2, b2 = [int(c2[p:p+2], 16) for p in range(1,6,2)]
c = '#{:02x}{:02x}{:02x}'.format((r1+r2) // 2, (g1+g2) //2, (b1+b2)// 2)

class RGB(numpy.ndarray):
  @classmethod
  def from_str(cls, rgbstr):
    return numpy.array([
      int(rgbstr[i:i+2], 16)
      for i in range(1, len(rgbstr), 2)
    ]).view(cls)
 
  def __str__(self):
    self = self.astype(numpy.uint8)
    return '#' + ''.join(format(n, 'x') for n in self)
 
c1 = RGB.from_str('#a1b1c1')
print(c1)
c2 = RGB.from_str('#1A1B1C')
print(c2)

print((c1 + c2) / 2)

s = slice(1, 7)
x = bytes.fromhex(c1[s])
y = bytes.fromhex(c2[s])
f = lambda x: sum(x) // 2
r, g, b = map(f, zip(x, y))
c = (r << 16) + (g << 8) + b
c = f'#{c:06x}'

path = pathlib.Path(_filepath)
path.unlink()

os.remove(filepath)

s = format(i, '03d')

PLANET = 'Earth'

y = random.sample(x, k)

class Trie:
   def __init__(self, prefix, value=None):
       self.prefix = prefix
       self.children = []
       self.value = value

if sys.maxsize > 2**32:
    f64()
else:
    f32()

elements = [c * x for x in elements]

f = lambda x: x * c
elements = list(map(f, elements))

if 'b' in sys.argv[1:]: bat()
if 'f' in sys.argv[1:]: fox()

options = {
	'b': bat
	'f': fox
}

for option, function in options:
	if option in sys.argv[1:]:
		function()

for x in zip(list[::2], list[1::2]):
    print(x)

def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = tee(iterable)
    next(b, None)
    return zip(a, b)

for a, b in pairwise(list):
    print(a, b)

for x in batched(a, 2): print(x)

i = iter(a)
for x in zip_longest(i, i):
    print(x)

webbrowser.open(s)

x = items[-1]

ab = a + b

t = s[s.startswith(p) and len(p):]

t = s.removeprefix(p)

t = s.removesuffix(w)

n = len(s)

n = len(mymap)

s.append(x)

m[k] = v

f'{1000:,}'

format(1000, ',')

'{:,}'.format(1000)

data = parse.urlencode(<your data dict>).encode()
req =  request.Request(u, data=data, method="POST")
resp = request.urlopen(req)

s = a.hex()

a = bytearray.fromhex(s)

extensions = [".jpg", ".jpeg", ".png"]
L = [f for f in os.listdir(D) if os.path.splitext(f)[1] in extensions]

filtered_files = ["{}/{}".format(dirpath, filename) for dirpath, _, filenames in os.walk(D) for filename in filenames if re.match(r'^.*\.(?:jpg|jpeg|png)$', filename)]

list(itertools.chain(*(glob.glob("*/**.%s" % ext) for ext in ["jpg", "jpeg", "png"])))

extensions = [".jpg", ".jpeg", ".png"]
L = [f for f in glob.glob(os.path.join(D, "**/*"), recursive=True) if os.path.splitext(f)[1] in extensions]

b = (x1 < x < x2) and (y1 < y < y2)