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 Point:
    def __init__(self, x, y):
        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]

f = lambda x: ...
for x in items: f(x)

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

print(*enumerate(items))

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)

if x: z = 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 = '%.2f' % x

s = format(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 = []
for i in range(m):
    x.append([.0] * n)

x = [*repeat([.0] * n, m)]

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

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

x = []
for a in range(m):
    t = []
    for b in range(n):
        t.append([.0] * p)
    x.append(t)

f = lambda: [*repeat([.0] * p, m)]
x = [*repeat(f(), n)]

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))

class T:
    def __init__(self, x):
        self.x = x
    def __hash__(self):
        return hash(self.x)
    def __eq__(self, t):
        return self.x == t.x
x = {T('abc'), T(123), T(lambda: ...)}

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: \
    lambda 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)

z = False
for x in a:
    for y in b:
        if y == x:
            z = True
            break
    if not z: print(x)
    z = False

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

z = False
for a in m:
    for b in a:
        if z := b < 0:
            print(b)
            break
    if z: break

s.insert(i, x)

time.sleep(5)

t = s[:5]

t = s[-5:]

s = """Huey
Dewey
Louie"""

s = ('line 1\n'
     'line 2\n'
     'line 3\n'
     'line 4')

chunks = s.split()

chunks = split(' +', s)

while True:
    pass

while 1: ...

k in m

m.get(k)

v in m.values()

def k(x, m):
    for k, v in m.items():
        if v == x: return k
k = k(v, m) or False

x = False
for y in m.items():
    if y[1] == v:
        x = y[0]
        break

y = ', '.join(x)

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

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

s = sum(x)

s = reduce(add, 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)]

y = [*filter(p, x)]

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%}"

s = '%.1f%%' % (x * 100)

s = format(x, '.1%')

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)))

class BitSet:
    def __init__(self, n):
        self.a = [False] * n
    def __getitem__(self, i):
        return self.a[i]
    def __setitem__(self, k, v):
        self.a[k] = v
    def __str__(self):
        s = ('01'[x] for x in self.a)
        return ''.join(s)
x = BitSet(n)

rand = random.Random(s)

rand = random.Random()

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

print(*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

x = True
while x:
    x = c

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")

r = compile('ht{2,}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)

n = getsizeof(t)

blank = not s or s.isspace()

blank = not s or \
        not sub(r'\s+', '', s)

blank = not s or \
        not any(x not in ws for x in s)

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

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

print(*sorted(mymap.items()))

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

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)

for x in sorted(mymap.items(), key=itemgetter(1)):
    print(x)

for x in sorted(mymap, key=mymap.get):
    print(x, mymap[x])

b = x == y

b = d1 < d2

s2 = s1.replace(w, '')

n = len(x)

y = set(x)

y = {*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

a, b, n = 0, 0, len(x)
t = None
while a != n:
    t, b = x[a], a + 1
    while b != n:
        if x[b] == t:
            del x[b]
            n = n - 1
        else: b = b + 1
    a = a + 1

x = list({*x})

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

n = int(input())

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()

p = '(?i)' + escape(word)
ok = not not search(p, s)

items = [a, b, c]

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

items.remove(x)

for i in range(len(items)):
    if items[i] == x:
        del items[i]
        break

del items[items.index(x)]

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

items = [a for a in items if a != x]

items = list(a for a in items if a != x)

while items.count(x):
    items.remove(x)

f = lambda a: a != x
items = list(filter(f, items))

i, n = 0, len(items)
while i != n:
    if items[i] == x:
        del items[i]
        n = n - 1
    else:
        i = i + 1

b = s.isdigit()

b = all(x in digits for x in 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')

s = '%x' % x

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

print(*zip_longest(items1, items2))

a, b = iter(items1), iter(items2)
print(*zip_longest(a, b))

a, b = len(items1), len(items2)
for i in range(max(a, b)):
    if i < a: print(items1[i])
    if i < b: print(items2[i])

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, s))

t = sub(r'[^\x00-\x7f]', '', s)

t = sub(r'[^\0-\176]', '', s)

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

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

a = (x.split() for x in [*stdin])
a = map(int, chain(*a))

p = p.rstrip("/")

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

s = c

t = f"{s}{i}"

t = s + str(i)

t = '%s%s' % (s, i)

t = '{}{}'.format(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)

a = bytes.fromhex(c1[1:])
b = bytes.fromhex(c2[1:])
r, g, b = (sum(x) // 2 for x in zip(a, b))
c = (r << 16) + (g << 8) + b
c = f'{c:06x}'

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

os.remove(filepath)

s = format(i, '03d')

s = '%03d' % i

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 = [*map(f, elements)]

for i, x in enumerate(elements):
    elements[i] = x * c

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()

a = dict.fromkeys(argv[1:])
for x in a.keys():
    match x:
        case 'b': bat()
        case 'f': fox()

s = argv[1:]
for x, f in (('b', bat), ('f', fox)):
    if x in s: f()

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)

x = iter(list)
print(*zip_longest(x, x))

for x in range(0, len(list), 2):
    print(list[x], list[x + 1])

webbrowser.open(s)

x = items[-1]

ab = a + b

ab = list(chain(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

m.update({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)