Your task is simply to count the total number of lowercase letters in a string.

## Examples

Difficulty: EASY
Starter code: def lowercase_count(strng):
	

Solutions:
def lowercase_count(strng):
	return sum((a.islower() for a in strng))


import re

def lowercase_count(string):
	return len(re.findall('[a-z]', string))


def lowercase_count(str):
	return sum((1 for c in str if c.islower()))


def lowercase_count(strng):
	return len([ch for ch in strng if ch.islower()])


def lowercase_count(s):
	return sum((c.islower() for c in s))


lowercase_count = lambda s: sum((e.islower() for e in s))


def lowercase_count(s):
	return sum((1 for c in s if c.islower()))


def lowercase_count(strng):
	return sum((1 for i in strng if i.islower()))


import re

def lowercase_count(st):
	return len(re.sub('[^a-z]*', '', st))


import re

def lowercase_count(text):
	return len(re.findall('[a-z]', text))


import re

def lowercase_count(str):
	return len(re.findall('[a-z]', str))


import re
lowercase_count = lambda s: len(re.findall('[a-z]', s))


import re

def lowercase_count(str):
	return len(re.sub('[^a-z]', '', str))


def lowercase_count(s):
	return len(list(filter(lambda x: x in map(chr, range(97, 123)), s)))


import re

def lowercase_count(strng):
	regex = re.compile('[a-z]')
	match = regex.findall(strng)
	if match:
		return len(match)
	return 0


def lowercase_count(strg):
	c = 0
	case = 'abcdefghijklmnopqrstuvwxyz'
	for x in strg:
		if x in case:
			c = c + 1
	return c


def lowercase_count(strng):
	lowers = 'abcdefghijklmnopqrstuvwxyz'
	count = 0
	for c in strng:
		if c in lowers:
			count += 1
	return count


def lowercase_count(string):
	return sum(map(str.islower, string))


variable = 'abc'

def lowercase_count(strng):
	array = []
	for x in strng:
		index = ord(x[0])
		if 97 <= index <= 122 and index > 91:
			variableForArray = chr(index)
			array.append(variableForArray)
		else:
			continue
	return len(array)


def lowercase_count(strng):
	return len([i for i in strng if i.islower()])


def lowercase_count(strng):
	lowerCastCount = 0
	for i in strng:
		if i.isdigit():
			None
		elif i.islower():
			lowerCastCount += 1
	return lowerCastCount


from re import findall

def lowercase_count(string: str) -> int:
	return len(findall('[a-z]', string))


def lowercase_count(strng):
	import re
	return len(re.findall('[a-z]', strng))


def lowercase_count(strng):
	return sum(map(str.islower, strng))


lowercase_count = lambda s: len([x for x in s if x in 'abcdefghijklmnopqrstuvwxyz'])


def lowercase_count(strng):
	import string
	return len(''.join([i for i in strng if i in string.ascii_lowercase]))


def lowercase_count(string):
	c = 0
	for i in string:
		if i.islower() == True:
			c += 1
	return c


def lowercase_count(strng):
	l_1 = list(strng)
	l_2 = list('qwertyuiopasdfghjklzxcvbnm')
	l_3 = []
	for elem in l_1:
		if elem in l_2:
			l_3.append(elem)
	return len(l_3)


def lowercase_count(s):
	return sum((1 for i in s if 'a' <= i <= 'z'))


def lowercase_count(s):
	ALPHABET = 'abcdefghijklmnopqrstuvwxyz'
	return sum((x in ALPHABET for x in s))


def lowercase_count(lst):
	n = 0
	for s in lst:
		if s >= 'a' and s <= 'z':
			n = n + 1
	return n


def lowercase_count(strng):
	total = 0
	for i in list(strng):
		if i in list('qwertyuiopasdfghjklzxcvbnm'):
			total = total + 1
	return total


def lowercase_count(strng):
	lc = 0
	for letter in strng:
		if 'z' >= letter >= 'a':
			lc += 1
	return lc


def lowercase_count(strng):
	li = list(strng)
	counter = 0
	for c in range(len(li)):
		if 96 < ord(li[c]) < 123:
			counter += 1
	return counter


def lowercase_count(strng):
	ans = 0
	for x in strng:
		if x.islower() == True:
			ans += 1
	return ans


def lowercase_count(strng):
	i = 0
	for x in strng:
		if 'a' <= x <= 'z':
			i += 1
	return i


def lowercase_count(strng):
	count = 0
	for chr in strng:
		if chr != chr.upper():
			count += 1
	return count


def lowercase_count(strng):
	somme = 0
	for minuscule in strng:
		if minuscule.islower():
			somme += 1
	return somme


def lowercase_count(string):
	lower_cases = 'abcdefghijklmnopqrstuvwxyz'
	lower_case_counter = 0
	index = 0
	while index < len(string):
		if string[index] in lower_cases:
			lower_case_counter += 1
		index += 1
	return lower_case_counter


def lowercase_count(str):
	count = 0
	alpha = 'a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z'
	trex = alpha.split(',')
	for x in str:
		if x in trex:
			count += 1
	return count


def lowercase_count(strng):
	return sum((True for i in strng if i.islower()))


def lowercase_count(strng):
	import re
	from re import finditer
	pattern = '[a-z]'
	count = 0
	for it in finditer(pattern, strng):
		count += 1
	return count


def lowercase_count(strng: str) -> int:
	return sum((c.islower() for c in strng))


def lowercase_count(strng):
	lst = list(strng)
	count = 0
	for letter in lst:
		if letter.islower():
			count += 1
	return count


import re

def lowercase_count(strng):
	pattern = re.compile('[a-z]{1}')
	matches = pattern.findall(strng)
	return len(matches)


def lowercase_count(strng):
	count = 0
	for letter in strng:
		if letter.isalpha():
			if ord(letter) <= ord('z') and ord(letter) >= ord('a'):
				count += 1
	return count


def lowercase_count(string):
	string = str(string)
	a = 0
	for i in string:
		if i.islower():
			a += 1
	return a


def lowercase_count(string):
	res = 0
	for i in string:
		if ord(i) > 96 and ord(i) < 123:
			res += 1
	return res


import re

def lowercase_count(strng):
	return len(''.join(re.findall('([a-z]+)', strng))) if re.search('([a-z]+)', strng) else 0


def lowercase_count(strng):
	return sum((1 for n in strng if n.islower()))


def lowercase_count(strng):
	return sum([int(x.islower()) for x in strng])


import string

def lowercase_count(strng):
	return sum([x in string.ascii_lowercase for x in strng])


def lowercase_count(strng):
	num = 0
	for chr in strng:
		if chr.islower() == True:
			num += 1
	return num


def lowercase_count(strng):
	letters = str(strng)
	lowercase = 0
	for i in letters:
		if i.islower():
			lowercase += 1
	return lowercase


def lowercase_count(strng):
	nb = 0
	for ch in strng:
		if ch.islower():
			nb += 1
	return nb


def lowercase_count(strng):
	letters = 'abcdefghijklmnopqrstuvwxyz'
	return len([i for i in strng if i in letters])


def lowercase_count(strng):
	lower = 0
	for letter in strng:
		if letter >= 'a' and letter <= 'z':
			lower += 1
	return lower


def lowercase_count(strng):
	return sum([1 if c.islower() else 0 for c in strng])


def lowercase_count(s):
	num = 0
	for i in s:
		if i.islower():
			num += 1
	return num


def lowercase_count(strng):
	return sum((1 for string in strng if string in 'abcdefghijklmnopqrstuvwxyz'))


import string

def lowercase_count(string):
	return len([x for x in string if x in 'abcdefghijklmnopqrstuvwxyz'])


def lowercase_count(strng):
	count = 0
	for let in strng:
		if let.isalpha() and let == let.lower():
			count += 1
	return count


def lowercase_count(strng):
	count = 0
	s = [i for i in strng]
	for x in s:
		if x.islower() == True:
			count += 1
		else:
			pass
	return count


from re import sub

def lowercase_count(strng):
	return len(sub('[^a-z]', '', strng))


from regex import sub

def lowercase_count(strng):
	return len(sub('[^a-z]', '', strng))


def lowercase_count(string):
	lowercase = [c for c in string if c.islower()]
	return len(lowercase)


import string

def lowercase_count(s):
	return sum([1 for i in s if i in string.ascii_lowercase])


def lowercase_count(strng):
	sum = 0
	for i in range(len(strng)):
		if strng[i].islower() == True:
			sum += 1
	return sum


def lowercase_count(strng):
	import re
	result = ''
	match = re.findall('[a-z]', strng)
	result = ''.join(match)
	return len(result)


import re

def lowercase_count(strng):
	match = re.findall('[a-z]', strng)
	count = 0
	for i in match:
		count += 1
	return count


def lowercase_count(strng):
	dgu = []
	rwp = []
	pwr = list(str(strng))
	pwr.sort()
	for lower in pwr:
		if lower.islower():
			rwp.append(lower)
	dgu = len(rwp)
	return dgu


lowercase_count = lambda s: len(list(filter(str.islower, s)))


def lowercase_count(s):
	return len([x for x in s if x in 'abcdefghijklmnopqrstuvwxyz'])


def lowercase_count(strng):
	count = 0
	for i in strng:
		if i.islower():
			count += 1
	return count
lowercase_count('cdfABH')


import re

def lowercase_count(strng):
	ct = 0
	for i in range(len(strng)):
		if re.search('[a-z]', strng[i]) != None:
			ct += 1
	return ct


def lowercase_count(strng):
	results = 0
	for letter in strng:
		if letter.islower():
			results = results + 1
	return results


def lowercase_count(strng):
	counter = 0
	for el in strng:
		if el in 'qwertyuiopasdfghjklzxcvbnm':
			counter += 1
	return counter


import re

def lowercase_count(strng):
	lower = [c for c in strng if re.search('[a-z]', c)]
	return len(lower)


import string

def lowercase_count(strng):
	count = 0
	for str in strng:
		if str in string.ascii_lowercase:
			count += 1
	return count


def lowercase_count(strng):
	lowercase = ''.join((c for c in strng if c.islower()))
	return len(lowercase)


def lowercase_count(strng):
	c = 0
	for i in range(len(strng)):
		if strng[i] in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']:
			c = c + 1
	return c


def lowercase_count(string):
	accum = 0
	abc = list('qwertyuioplkjhgfdsazxcvbnm')
	for i in string:
		if i in abc:
			accum += 1
	return accum


def lowercase_count(strng):
	letters = list(strng)
	count = 0
	for i in letters:
		if ord(i) > 96 and ord(i) < 123:
			count += 1
	return count


def lowercase_count(strng):
	count = 0
	for x in strng:
		if x.islower():
			count += 1
	else:
		return count


def lowercase_count(string):
	sum = 0
	for i in string:
		if i.islower():
			sum += 1
	return sum


def lowercase_count(strng):
	count = 0
	for char in strng:
		if char.islower() is True:
			count = count + 1
		else:
			continue
	return count


import re

def lowercase_count(strng):
	r = re.compile('[a-z]')
	return len(r.findall(strng))


def lowercase_count(strng):
	ctr = 0
	for i in strng:
		if i.islower():
			ctr += 1
	return ctr


def lowercase_count(strng):
	n = 0
	for k in strng:
		if k.islower():
			n += 1
	return n


def lowercase_count(strng):
	count = 0
	for el in strng:
		count = count + (1 if el != el.upper() else 0)
	return count


def lowercase_count(strng):
	return len([i for i in strng if i.lower() == i and i.isalpha()])