```if:python
Create a function `args_count`, that returns the count of passed arguments
```
```if:kotlin
Create a function `argsCount`, that returns the count of passed arguments
```
```if:ruby
Create a method `args_count`, that returns the count of passed arguments
```
```if:julia
Create a method `argscount`, that returns the count of passed arguments
```
```python
args_count(1, 2, 3) -> 3
args_count(1, 2, 3, 10) -> 4
```

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Starter code: def args_count(*args, **kwargs):
	

Solutions:
def args_count(*args, **kwargs):
	return len(args) + len(kwargs)


args_count = lambda *a, **b: len(a) + len(b)


def args_count(*arg, **kwarg):
	return len(arg) + len(kwarg)


def args_count(*args, **kwargs):
	args_counter = 0
	for _ in args:
		args_counter += 1
	for _ in kwargs:
		args_counter += 1
	return args_counter


def args_count(*unnamed, **named):
	return len(unnamed) + len(named)


def args_count(*a, **b):
	return len(a) + len(b)


def args_count(*args, **kargs):
	return len(args) + len(kargs)


args_count = lambda *Q, **S: len(Q) + len(S)


args_count = lambda *a, **k: len(a) + len(k)


def args_count(*args, **kwargs):
	result = 0
	result = result + len(args) + len(kwargs)
	return result


def args_count(*arg, **kwargs):
	print(arg, kwargs)
	return len(arg) + len(kwargs)


def args_count(*args, **kwargs):
	return len(args) if not kwargs else len(args) + len(kwargs)


def args_count(*argv, **kwargs):
	return len(argv) + len(list(kwargs.items()))


def args_count(*n, **x):
	return len(n) + len(x.keys())


def args_count(*args, **kwargs):
	counter = 0
	for arg in args:
		counter += 1
	if kwargs:
		for kwarg in kwargs:
			counter += 1
	return counter


args_count = lambda *r, **kw: len(r) + len(kw)


def args_count(*args, **kwargs):
	return sum([1 for i in args]) + sum([1 for i in kwargs])


def args_count(*args, **kwargs):
	ctr = 0
	for x in args:
		ctr += 1
	for y in kwargs:
		ctr += 1
	return ctr


def args_count(*x, **k):
	return len(x) + len(k)


def args_count(*args, **kwargs):
	args_lst = [arg for arg in args]
	kwargs_lst = [kwarg for kwarg in kwargs]
	return len(args_lst) + len(kwargs_lst)


def args_count(*args, **kwargs):
	return len([x for x in args]) + len([x for x in kwargs])


def args_count(*args, **kwargs):
	e = 0
	for i in args:
		e += 1
	for i in kwargs:
		e += 1
	return e


def args_count(*i, **a):
	return len(i) + len(a)


def args_count(*args, **qwargs):
	return len(args) + len(qwargs)


def args_count(*n, **n2):
	my_result = 0
	for i in n:
		my_result += 1
	for i in n2:
		my_result += 1
	return my_result


def args_count(*args, **kwargs):
	s = 0
	for a in args:
		s += 1
	for (key, value) in list(kwargs.items()):
		s += 1
	return s


def args_count(*args, **kwargs):
	a = [arg for arg in args]
	k = [arg for arg in kwargs]
	return len(a + k)


def args_count(*args, **kwargs):
	try:
		return len(args) + len(kwargs)
	except TypeError:
		return 0


def args_count(*a, **q):
	return len(a) + len(q)


def args_count(*args, **kwargs):
	return len([x for x in args]) + len([y for y in kwargs.values()])


def args_count(*args, **kwrags):
	return len(args) + len(kwrags)


def args_count(*a, **k):
	return (len(a) if a else 0) + (len(k) if k else 0)


def args_count(*args, **k):
	return len(args) + len(k.keys())


def args_count(*arg, **karg):
	args = []
	for (k, v) in karg.items():
		args.append(v)
	for a in arg:
		args.append(a)
	return len(args)


def args_count(*arg, **argu):
	return len(arg) + len(argu)


def args_count(*args, **kwargs):
	number_a = len([a for a in args])
	number_w = len([w for w in kwargs])
	return number_a + number_w


def args_count(*args, **kwargs):
	number_a = [a for a in args]
	number_k = [k for k in kwargs]
	return len(number_a) + len(number_k)


def args_count(*args, **kwargs):
	count = 0
	for item in args:
		count += 1
	for item in kwargs:
		count += 1
	return count


def args_count(*n, **m):
	return len(n) + len(m)


def args_count(*pos_args, **named_args):
	return len(pos_args) + len(named_args)


def args_count(*a1, **keyword):
	return len(a1) + len(keyword)


from inspect import signature

def args_count(*args, **kwargs):
	sum = 0
	for i in args:
		sum += 1
	for i in kwargs:
		sum += 1
	return sum


import sys

def args_count(*argv, **kwargs):
	count = 0
	for i in argv:
		count += 1
	for i in kwargs:
		count += 1
	return count


def args_count(*n, **s):
	return len(n) + len(s)


def args_count(*arg, **kwargs):
	return len(list(arg) + list(kwargs))


def args_count(*args, **kwargs):
	print(locals())
	my_params = locals()
	return len(my_params['kwargs']) + len(my_params['args'])


def args_count(*args, **kwargs):
	return len(args) + len(kwargs)
args_count(100, 'tot', 3.5, 3, 2, 4, 2)


def args_count(*args, **also):
	return len(args) + len(also)


def args_count(*therest, **alsorest):
	count = 0
	for n in therest:
		count += 1
	for m in alsorest:
		count += 1
	return count


def args_count(*args, **qargs):
	count = 0
	for i in args:
		count += 1
	for i in qargs:
		count += 1
	return count


def args_count(*args, **kwargs):
	counter = 0
	for item in args:
		counter += 1
	for (key, value) in list(kwargs.items()):
		counter += 1
	return counter


def args_count(*args, **options):
	return len(args) + len(options)


def args_count(*args, **kwargs):
	index = 0
	for x in args:
		index = index + 1
	for x in kwargs:
		index = index + 1
	return index


def args_count(*args, **kwargs):
	if len(kwargs.keys()) > 0:
		return len(args) + len(kwargs.keys())
	else:
		return len(args)


def args_count(*args, **kwargs):
	print(*args)
	if len(kwargs.keys()) > 0:
		return len(args) + len(kwargs.keys())
	return len(args)


def args_count(*args, **kwards):
	return len(args) + len(kwards)


def args_count(*p, **n):
	counter = 0
	for i in p:
		counter += 1
	for z in n:
		counter += 1
	return counter


def args_count(*args, **kwargs):
	a = 0
	for i in args:
		a += 1
	for i in kwargs:
		a += 1
	return a


def args_count(*n, **n2):
	return len(n) + len(n2)


def args_count(*test, **kwtest):
	z = []
	count = 0
	for x in test:
		count += 1
	for x in kwtest:
		count += 1
	return count


def args_count(*args, **kwargs):
	x = 0
	y = []
	for w in args:
		x += 1
	for t in kwargs:
		x += 1
	return x


def args_count(*aa, **kwargs):
	return len(kwargs) + len(aa)


def args_count(*args, **kwargs):
	total = [sum([+1 for arg in args]) + len(kwargs.keys()) if kwargs is not None else None]
	return total[0]


def args_count(*a1, **a2):
	total = sum((1 for i in a1))
	total += sum((1 for i in a2))
	return total


args_count = lambda *args_list, **args_dict: len(args_list) + len(args_dict)


def args_count(*args, **kwargs):
	num = 0
	num2 = 0
	for i in args:
		num = num + 1
	for i in kwargs:
		num2 = num2 + 1
	return num + num2


def args_count(*args, **number):
	c = 0
	for i in args:
		c += 1
	for i in number:
		c += 1
	return c


def args_count(*arbitrarios, **arbitrariosCla):
	return len(arbitrarios) + len(arbitrariosCla)


def args_count(*a, **s):
	return a.__len__() + s.__len__()


def args_count(*args, **kvalues):
	s = len(args) + len(kvalues)
	return s


def args_count(*arg1, **args):
	return len(arg1) + len(args)


def args_count(*args, **kwargs):
	return len(args) + len(list(kwargs.keys()))


def args_count(*x, **y):
	return len(x) + len(y)


def args_count(*argsv, **kwargs):
	return len(argsv) + len(kwargs)


import sys

def args_count(*args, **kwargs):
	i = 0
	for num in args:
		i += 1
	for key in kwargs.items():
		i += 1
	return i


def args_count(*args, **kwargs):
	count = 0
	for arg in args:
		count += 1
	for (name, value) in list(kwargs.items()):
		count += 1
	return count


def args_count(*args, **kwargs):
	counter = 0
	for key in args:
		counter += 1
	for key in kwargs:
		counter += 1
	return counter


def args_count(*args, **kwargs):
	return len(args) + len(kwargs)
args_count(1, a=12)


def args_count(*args, **kwargs):
	arcount = 0
	for ar in args:
		arcount = 1 + arcount
	return arcount + len(kwargs)


def args_count(*args, **kwargs):
	if kwargs is not None:
		return len(args) + len(kwargs)
	return len(args)


def args_count(*arg, **keyarg):
	return len(arg) + len(keyarg)


def args_count(*args, **kwargs):
	lista = []
	for i in args:
		lista.append(str(i))
	for j in kwargs:
		lista.append(j)
	return len(lista)


def args_count(*arg, **kwargs):
	count = 0
	for a in arg:
		count += 1
	return count + len(kwargs.items())


def args_count(*li, **li2):
	return len(li) + len(li2)


def args_count(*arg, **kwarg):
	count = 0
	for i in kwarg:
		count += 1
	for j in arg:
		count += 1
	return count


def args_count(*args, **kwargs):
	count = 0
	for arg in args:
		count += 1
	for kwarg in kwargs:
		count += 1
	return count


def args_count(*args, **wargs):
	return len(args) + len(wargs)


def args_count(*args, **kwargs):
	total = 0
	args = list(args) + list(kwargs)
	for i in args:
		total += 1
	return total


def args_count(*args, **kwargs):
	new_list = []
	new_list.extend(tuple((*args,))) if args else None
	new_list.extend(tuple((*kwargs,))) if kwargs else None
	return len(new_list)


def args_count(*arg, **dict):
	return len(arg) + len(dict)


def args_count(*t, **a1):
	print(t)
	print(a1)
	if a1:
		return len(t) + len(a1)
	else:
		return len(t)


def args_count(*params, **params2):
	result = 0
	for i in params:
		result += 1
	for i in params2:
		result += 1
	return result


def args_count(*a, **b):
	count = len(a)
	count2 = len(b)
	count3 = count + count2
	return count3


def args_count(*num, **data):
	count = 0
	for i in num:
		count += 1
	for i in data:
		count += 1
	return count


def args_count(*args, **kwargs):
	list1 = []
	list2 = []
	for arg in args:
		arg = str(arg)
		list1.append(arg)
	for kwarg in kwargs:
		list2.append(kwarg)
	count = len(list1) + len(list2)
	return count