>>> L1 = [2,3,4]
>>> L2 = [1,2]
>>> [i for i in L1 if i in L2]
[2]


>>> S1 = set(L1)
>>> S2 = set(L2)
>>> S1.intersection(S2)
set([2])

Both empty lists and empty sets are False, so you can use the value directly as a truth value.

Operators like <= in Python are generally not overriden to mean something significantly different than "less than or equal to". It's unusual for the standard library does this--it smells like legacy API to me.

Use the equivalent and more clearly-named method, set.issubset. Note that you don't need to convert the argument to a set; it'll do that for you if needed.

set(['a', 'b']).issubset(['a', 'b', 'c'])

When number of occurrences doesn't matter, you can still use the subset functionality, by creating a set on the fly:

>>> list1 = ['a', 'c', 'c']
>>> list2 = ['x', 'b', 'a', 'x', 'c', 'y', 'c']
>>> set(list1).issubset(list2)
True

If you need to check if each element shows up at least as many times in the second list as in the first list, you can make use of the Counter type and define your own subset relation:

>>> from collections import Counter
>>> def counterSubset(list1, list2):
        c1, c2 = Counter(list1), Counter(list2)
        for k, n in c1.items():
            if n > c2[k]:
                return False
        return True
   
>>> counterSubset(list1, list2)
True
>>> counterSubset(list1 + ['a'], list2)
False
>>> counterSubset(list1 + ['z'], list2)
False

If you already have counters (which might be a useful alternative to store your data anyway), you can also just write this as a single line:

>>> all(n <= c2[k] for k, n in c1.items())
True

In C, there are two text related data types: char and strings. A string is a pointer to an array of chars, that by convention is terminated with a NUL character ('\0'). A char is a single byte representing an ASCII character.

You create a string literal by compiling a series of characters contained between opening and closing double quotes: "this is a string literal"

On the other hand, you create a char literal by compiling a single character expression - possibly with a backslash escape - between a pair of single quotes: 't', 'h', 'e', 's', 'e', ' ', 'a', 'r', 'e', ' ', 'c', 'h', 'a', 'r', ' ', 'l', 'i', 't', 'e', 'r', 'a', 'l', 's', '\n'

After the advent of code pages and multi-byte character encodings, C added (grudging) support for "wide chars" (that is, more than 8 bits used to store a single element) and for "multi-byte chars" (that is, character encodings that used 8-bit values, but required more than one to encode a single glyph).

The compiler is seeing your line initializing the array:

char a[]={'a','5ab','na','8s'};

And is assuming that '5ab' and 'na' and '8s' are an attempt, by you, to specify a wide or multi-byte character literal. It knows that characters (not strings) are enclosed in single quotes. It knows that you're using type char. So these can't be strings. But they aren't multi-byte characters, either.

In reality, I think you meant for them to be strings. You're probably coming from python, or bash, or perl or some other language where single quotes can delimit strings. But that's not C.

To create a list of strings, you need to know that strings are of type char * (or const char *). You then want to create an array of them - that's your list:

const char *list_of_str[] = {
    "hello",
    "my name",
    "is George"
};

You'll notice that argv is a list of strings. ;-)