how to find the owner of a file or directory in python

You want to use os.stat():

os.stat(path)
 Perform the equivalent of a stat() system call on the given path. 
 (This function follows symlinks; to stat a symlink use lstat().)

The return value is an object whose attributes correspond to the 
members of the stat structure, namely:

- st_mode - protection bits,
- st_ino - inode number,
- st_dev - device,
- st_nlink - number of hard links,
- st_uid - user id of owner,
- st_gid - group id of owner,
- st_size - size of file, in bytes,
- st_atime - time of most recent access,
- st_mtime - time of most recent content modification,
- st_ctime - platform dependent; time of most recent metadata 
             change on Unix, or the time of creation on Windows)

Example of usage to get owner UID:

from os import stat
stat(my_filename).st_uid

Note, however, that stat returns user id number (for example, 0 for root), not actual user name.

See os.stat. It gives you st_uid which is the user ID of the owner. Then you have to convert it to the name. To do that, use pwd.getpwuid.

Here is some example code, showing how you can find the owner of file:

#!/usr/bin/env python
import os
import pwd
filename = '/etc/passwd'
st = os.stat(filename)
uid = st.st_uid
print(uid)
# output: 0
userinfo = pwd.getpwuid(st.st_uid)
print(userinfo)
# output: pwd.struct_passwd(pw_name='root', pw_passwd='x', pw_uid=0, 
#          pw_gid=0, pw_gecos='root', pw_dir='/root', pw_shell='/bin/bash')
ownername = pwd.getpwuid(st.st_uid).pw_name
print(ownername)
# output: root

I stumbled across this recently, looking to get owner user and group information, so I thought I’d share what I came up with:

import os
from pwd import getpwuid
from grp import getgrgid

def get_file_ownership(filename):
    return (
        getpwuid(os.stat(filename).st_uid).pw_name,
        getgrgid(os.stat(filename).st_gid).gr_name
    )

On Windows this Works but uses the cli

import os
from subprocess import Popen, PIPE
from collections import namedtuple


def sliceit(iterable, tup):
    return iterable[tup[0]:tup[1]].strip()

def convert_cat(line):
    # Column Align Text indicies from cmd
    # Date time dir filesize owner filename
    Stat = namedtuple('Stat', 'date time directory size owner filename')
    stat_index = Stat(date=(0, 11), 
                      time=(11, 18), 
                      directory=(18, 27), 
                      size=(27, 35), 
                      owner=(35, 59), 
                      filename=(59, -1))

    stat = Stat(date=sliceit(line, stat_index.date),
                      time=sliceit(line, stat_index.time),
                      directory=sliceit(line, stat_index.directory),
                      size=sliceit(line, stat_index.size),
                      owner=sliceit(line, stat_index.owner),
                      filename=sliceit(line, stat_index.filename))
    return stat

def stat(path):
    if not os.path.isdir(path):
        dirname, filename = os.path.split(path)
    else:
        dirname = path
    cmd = ["cmd", "/c", "dir", dirname, "/q"]
    session = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
    # cp1252 is common on my Norwegian Computer,
    # check encoding from your windows system
    result = session.communicate()[0].decode('cp1252')

    if os.path.isdir(path):
        line = result.splitlines()[5]
        return convert_cat(line)
    else:
        for line in result.splitlines()[5:]:
            if filename in line:
                return convert_cat(line)
        else:
            raise Exception('Could not locate file')

if __name__ == '__main__':
    print(stat('C:\temp').owner)
    print(stat('C:\temp\diff.py'))

It’s an old question, but for those who are looking for a simpler solution with Python 3.

You can also use Path from pathlib to solve this problem, by calling the Path‘s owner and group method like this:

from pathlib import Path

path = Path("/path/to/your/file")
owner = path.owner()
group = path.group()
print(f"{path.name} is owned by {owner}:{group}")

So in this case, the method could be the following:

from typing import Union
from pathlib import Path

def find_owner(path: Union[str, Path]) -> str:
    path = Path(path)
    return f"{path.owner()}:{path.group()}"