Thanks to @ErykSun the solution:

Python code

string1 = "my string 1"
string2 = "my string 2"

# create byte objects from the strings
b_string1 = string1.encode('utf-8')
b_string2 = string2.encode('utf-8')

# send strings to c function
my_c_function.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
my_c_function(b_string1, b_string2)

ctypes.cast() is used to convert one ctype instance to another ctype datatype. You don't need it To convert it to python string. Just use ".value" to get it in python string.

>>> s = "Hello, World"
>>> c_s = c_char_p(s)
>>> print c_s
c_char_p('Hello, World')
>>> print c_s.value
Hello, World

More info here

To answer the question without reading too much else into it I would

Copychar str[2] = "\0"; /* gives {\0, \0} */
str[0] = fgetc(fp);

You could use the second line in a loop with whatever other string operations you want to keep using chars as strings.

No. Use a dictionary.

>>> names = {'p1': 100, 'p2': 200}
>>> t = names['p1']
>>> t
100

This will throw a KeyError if the name does not exist:

>>> t = names['p3']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'p3'

... but you can use dict.get and provide a default value:

>>> t = names.get('p3', 'default')
>>> t
'default'

where the default-default-value is None.

(By the way, this has nothing to do with converting strings to a char(acter?), your terminology is quite confusing.)

You can use PyUnicode_AsEncodedString, which

Encode a Unicode object and return the result as Python bytes object. encoding and errors have the same meaning as the parameters of the same name in the Unicode encode() method. The codec to be used is looked up using the Python codec registry. Return NULL if an exception was raised by the codec.

see https://docs.python.org/3/c-api/unicode.html#c.PyUnicode_AsEncodedString

Then with PyBytes_AsString you get a pointer to internal buffer with a terminating NUL byte. This buffer must neither be deallocated nor modified. If you need a copy you could use e.g. strdup.

see https://docs.python.org/3/c-api/bytes.html#c.PyBytes_AsString

Slightly modifying your code it could look like this:

PyObject *encodedString = PyUnicode_AsEncodedString(commandString, "UTF-8", "strict");
if (encodedString) { //returns NULL if an exception was raised
    char *commandChars = PyBytes_AsString(encodedString); //pointer refers to the internal buffer of encodedString
    if(commandChars) {
        printf("the string '%s' consists of the following chars:\n", commandChars);
        for (int i = 0; commandChars[i] != '\0'; i++) {
            printf("%c ", commandChars[i]);
        }
        printf("\n");
    }
    Py_DECREF(encodedString);
}

If one would test with:

import cExt

fruits = ["apple", "pears", "cherry", "pear", "blueberry", "strawberry"]         
res = cExt.listCheck(fruits)
print(res)

The output would be:

the string 'apple' consists of the following chars:
a p p l e 
the string 'pears' consists of the following chars:
p e a r s 
the string 'cherry' consists of the following chars:
c h e r r y 
the string 'pear' consists of the following chars:
p e a r 
the string 'blueberry' consists of the following chars:
b l u e b e r r y 
the string 'strawberry' consists of the following chars:
s t r a w b e r r y 
[1, 1, 1, 1, 1, 1]

Side note not directly related to the question: Your CitemCheck function returns a pointer to int, but if looking at how it is called, it seems that you want to return an int value. The function signature should look more like this:

static int CitemCheck(PyObject *commandString, int commandStringLength)

(note the removed * after int).

I've found the solution

name = bytes(self.name.get().encode('utf-8'))
cmd.name = name