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 code(): print('Hello')
for x in range(10): code()

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

def square(x):
    return x*x

def square(x):
    return x**2

@dataclass
class Point:
    x: float
    y: float

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

point = {'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)

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

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)

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)

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

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]

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

from re import split
chunks = split(' +', s)

while True:
    pass

k in m

v in m.values()

y = ', '.join(x)

y = ', '.join(map(str, 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)

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)

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

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

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.remove(x)

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

b = s.isdigit()

file = tempfile.TemporaryFile()

td = tempfile.TemporaryDirectory()

m.pop(k, None)

for x in items1 + items2:
    print(x)

s = hex(x)

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

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

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)

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]

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)

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)

center = ((x1+x2)/2, (y1+y2)/2)

Point = namedtuple('Point', 'x y')
center = Point((x1+x2)/2, (y1+y2)/2)

x = os.listdir(d)

s = 's = %r\nprint(s%%s)'
print(s%s)

content_type = 'text/plain'
headers = {'Content-Type': content_type}
data = {}

r = requests.put(u, headers=headers, data=data)
status_code, content = r.status_code, r.content

t = str(date.today() + timedelta(days=1))

timer = threading.Timer(30.0, f, args=(42,) ) 
timer.start() 

sys.exit(0)

class UnionFind:
    def __init__(self, size):
        self.rank = [0] * size
        self.p = [i for i in range(size)]

    def find_set(self, i):
        if self.p[i] == i:
            return i
        else:
            self.p[i] = self.find_set(self.p[i])
            return self.p[i]

    def is_same_set(self, i, j):
        return self.find_set(i) == self.find_set(j)

    def union_set(self, i, j):
        if not self.is_same_set(i, j):
            x, y = self.find_set(i), self.find_set(j)
 

c = a @ b

c = np.matmul(a, b)

y = [T(e) for e in x if P(e)]

y = list(map(T, filter(P, x)))

a = (c_int * 10)(*range(10))
n = 10
libc = cdll.LoadLibrary('/path/to/c_library')
libc.foo(c_void_p(a), c_int(n))

if any(v > x for v in a):
    f()

a = decimal.Decimal('1234567890.123456789012345')

a = np.array([[1,2], [3,4], [5,6]])
b = a.T

a = [[1,2], [3,4], [5,6]]
b = list(map(list, zip(*a)))

b = np.roll(a, m, axis=1)

def foo(a):
    print(len(a))
    print(sum(
        x*(i+1) + y*(i+1)*2 for i, (x, y) in enumerate(a)
    ))

def foo(a: list[list[float]]):
    print(len(a))
    z = 0
    for i, x in enumerate(a):
        for j, y in enumerate(x):
            z = z + (y * (i + 1))
            z = z + (y * (j + 1))
    print(z)

def foo(data, r):
    for i in r: 
        data[i] = 42

foo(a, range(0, m+1, 2))

with open(path) as f:
    lines = f.readlines()

sys.exit(x)

F.truncate(F.tell())

h = math.hypot(x, y)

np.linalg.norm(adata2[:, 0:3] - adata1[ipc1, 0:3], axis=1)

n = np.linalg.norm(data)

s = sum(i**2 for i in data)

m = statistics.mean(data)
sd = statistics.stdev(data)

print(math.frexp(a))

try:
    foo = os.environ['FOO']
except KeyError:
    foo = "none"

foo = getenv('FOO', 'none')

foo = os.environ.get('FOO', 'none')

switch = {'foo': foo, 
	'bar': bar, 
	'baz': baz, 
	'barfl': barfl
	}

switch_funct = switch.get(string)
if switch_funct : switch_funct()

match str:
    case 'foo': foo()
    case 'bar': bar()
    case 'baz': baz()
    case 'barfl': barfl()

def func():
    a = [0] * n
    # local variable automatically deallocated at end of function
    return

for i in xrange(len(a)):
	a[i] = e*(a[i] + b[i] + c[i] + math.cos(a[i]))