diff --git a/src/shamira.py b/src/shamira.py
--- a/src/shamira.py
+++ b/src/shamira.py
@@ -15,41 +15,41 @@ class DecodingException(SException): pas
 class MalformedShare(SException): pass
 
 
-def _shareByte(secretB, k, n):
+def _share_byte(secret_b, k, n):
 	if not k<=n<255:
 		raise InvalidParams("Failed k<=n<255, k={0}, n={1}".format(k, n))
 	# we might be concerned with zero coefficients degenerating our polynomial, but there's no reason - we still need k shares to determine it is the case
-	coefs = [int(secretB)]+[int(b) for b in os.urandom(k-1)]
+	coefs = [int(secret_b)]+[int(b) for b in os.urandom(k-1)]
 	points = [gf256.evaluate(coefs, i) for i in range(1, n+1)]
 	return points
 
 
-def generateRaw(secret, k, n):
+def generate_raw(secret, k, n):
 	"""Splits secret into shares.
 
 	:param secret: (bytes)
 	:param k: number of shares necessary for secret recovery. 1 <= k <= n
 	:param n: (int) number of shares generated. 1 <= n < 255
 	:return: [(i, (bytes) share), ...]"""
-	shares = [_shareByte(b, k, n) for b in secret]
+	shares = [_share_byte(b, k, n) for b in secret]
 	return [(i+1, bytes([s[i] for s in shares])) for i in range(n)]
 
 
-def reconstructRaw(*shares):
+def reconstruct_raw(*shares):
 	"""Tries to recover the secret from its shares.
 
 	:param shares: ((i, (bytes) share), ...)
 	:return: (bytes) reconstructed secret. Too few shares returns garbage."""
-	secretLen = len(shares[0][1])
-	res = [None]*secretLen
-	for i in range(secretLen):
+	secret_len = len(shares[0][1])
+	res = [None]*secret_len
+	for i in range(secret_len):
 		points = [(x, s[i]) for (x, s) in shares]
-		res[i] = (gf256.getConstantCoef(*points))
+		res[i] = (gf256.get_constant_coef(*points))
 	return bytes(res)
 
 
 def generate(secret, k, n, encoding="b32"):
-	"""Wraps generateRaw().
+	"""Wraps generate_raw().
 
 	:param secret: (str or bytes)
 	:param k: number of shares necessary for secret recovery
@@ -58,21 +58,21 @@ def generate(secret, k, n, encoding="b32
 	:return: [(str) share, ...]"""
 	if isinstance(secret,str):
 		secret = secret.encode("utf-8")
-	shares = generateRaw(secret, k, n)
+	shares = generate_raw(secret, k, n)
 	return [encode(s, encoding) for s in shares]
 
 
 def reconstruct(*shares, encoding="", raw=False):
-	"""Wraps reconstructRaw.
+	"""Wraps reconstruct_raw.
 
 	:param shares: ((str) share, ...)
 	:param encoding: {hex, b32, b64, ""} encoding of share strings. If not provided or empty, the function tries to guess it.
 	:param raw: (bool) whether to return bytes (True) or str (False)
 	:return: (str or bytes) reconstructed secret. Too few shares returns garbage."""
 	if not encoding:
-		encoding = detectEncoding(shares)
+		encoding = detect_encoding(shares)
 
-	bs = reconstructRaw(*(decode(s, encoding) for s in shares))
+	bs = reconstruct_raw(*(decode(s, encoding) for s in shares))
 	try:
 		return bs if raw else bs.decode(encoding="utf-8")
 	except UnicodeDecodeError:
@@ -89,20 +89,20 @@ def encode(share, encoding="b32"):
 
 def decode(share, encoding="b32"):
 	try:
-		(i, _, shareStr) = share.partition(".")
+		(i, _, share_str) = share.partition(".")
 		i = int(i)
 		if not 1<=i<=255:
 			raise MalformedShare("Malformed share: Failed 1<=k<=255, k={0}".format(i))
 		if encoding=="hex": f = base64.b16decode
 		elif encoding=="b32": f = base64.b32decode
 		else: f = base64.b64decode
-		shareBytes = f(shareStr)
-		return (i, shareBytes)
+		share_bytes = f(share_str)
+		return (i, share_bytes)
 	except (ValueError, binascii.Error):
 		raise MalformedShare('Malformed share: share="{0}", encoding="{1}"'.format(share, encoding))
 
 
-def detectEncoding(shares):
+def detect_encoding(shares):
 	classes = [
 		(re.compile(r"\d+\.([0-9A-F]{2})+"), "hex"),
 		(re.compile(r"\d+\.([A-Z2-7]{8})*([A-Z2-7]{8}|[A-Z2-7]{2}={6}|[A-Z2-7]{4}={4}|[A-Z2-7]{5}={3}|[A-Z2-7]{7}={1})"), "b32"),