how is every object related to pyObject when c does not have Inheritance

Your assertion that C has no concept of object-oriented programming is wrong. C doesn't explicitly have OOP, and it wasn't built with it in mind, but you can certainly do OOP things with C without too much effort. This comes from leveraging the fact that C doesn't actually really care what a struct's internal memory layout looks like. If you have two structs:

struct A {
    int field1;
    int field2;
    double field3;
};

struct B {
    A fieldA
    int field4;
    float field5;
};

then that essentially lets B behave as a subclass of A. After all, the first part of B's memory layout is exactly the same as A's memory layout. If you pass it around as a void pointer, then you can typecast away and C doesn't really care:

void doSomething(void *obj) {
    int field2value = ((A*) obj).field2;
    float field5value = ((B*) obj).field5;
    printf("field2: %d\nfield5: %f", field2value, field5value);
}

You tell C what type you think the void pointer is supposed to be, and it makes that happen. And you get unexpected behavior if you guess wrong, or you get a segfault if the type you think it's supposed to be is larger than the type it actually is. You can use this to clumsily implement inheritance:

void constructA(void* obj) {
    a = (A*) obj
    a.field1 = 4;
    a.field2 = 2;
    a.field3 = 3.14;
}

void constructB(void *obj) {
    constructA(obj);
    b = (B*) obj;
    b.field4 = 7;
    b.field5 = 6.28;
}

int main() {
    B *myObj = malloc(sizeof(B));
    constructB(myObj);
    free(myObj);
}   

If one of A's variables is a function pointer, then that's fine. That function pointer gets passed down alongside the rest. You can call it from anywhere, after all. You can supplant its functionality in a "subclass", and then still call the original version later on, if you don't actually override its spot in memory - or if you do, you could have your replacement manually call the function it was pointing to.

A lot of advanced C code uses a similar pattern for replicating the idea of inheritance (or, alternatively, just uses C++, which optimizes this whole arrangement and abstracts it away so that programmers can work with a more intuitive syntax).

But even then, that's missing the point. One of my favorite things about python is, at the deepest level, its consistency - everything is an object, and all objects are basically hashmaps with names pointing to a references. Python's idea of duck typing works not because the underlying C code has any idea of inheritance, but because the code just looks for an attribute with the right name, and if it finds one, it uses it.

Subclasses in python, then, are the same as above - a new python object that initializes itself from the top down, adding more and more fields to the hashmap as it gets closer to the bottom.