如何写权限分配简易脚本

本文目录导读：

1. 基于位运算的权限系统（最简洁）
2. JSON配置式权限分配
3. 数据库式权限管理
4. 命令行工具版
5. 使用建议

我来帮你写一个简易的权限分配脚本,包含几种常见实现方式：

基于位运算的权限系统（最简洁）

# 定义权限常量
READ = 1      # 0001
WRITE = 2     # 0010
EXECUTE = 4   # 0100
DELETE = 8    # 1000
class PermissionManager:
    def __init__(self):
        self.permissions = 0
    def add_permission(self, perm):
        """添加权限"""
        self.permissions |= perm
    def remove_permission(self, perm):
        """移除权限"""
        self.permissions &= ~perm
    def has_permission(self, perm):
        """检查是否有某个权限"""
        return (self.permissions & perm) == perm
    def get_permissions(self):
        """获取所有权限"""
        perms = []
        if self.has_permission(READ):
            perms.append("READ")
        if self.has_permission(WRITE):
            perms.append("WRITE")
        if self.has_permission(EXECUTE):
            perms.append("EXECUTE")
        if self.has_permission(DELETE):
            perms.append("DELETE")
        return perms
# 使用示例
pm = PermissionManager()
pm.add_permission(READ | WRITE)  # 添加读和写权限
print(pm.has_permission(READ))   # True
print(pm.get_permissions())      # ['READ', 'WRITE']

JSON配置式权限分配

import json
class SimplePermissionSystem:
    def __init__(self, config_file=None):
        self.users = {}
        self.roles = {
            "admin": ["read", "write", "delete", "execute"],
            "editor": ["read", "write"],
            "viewer": ["read"]
        }
        if config_file:
            self.load_config(config_file)
    def assign_role(self, username, role):
        """为用户分配角色"""
        if role not in self.roles:
            return False
        if username not in self.users:
            self.users[username] = {}
        self.users[username]["role"] = role
        self.users[username]["permissions"] = self.roles[role]
        return True
    def check_permission(self, username, permission):
        """检查用户是否有某个权限"""
        user = self.users.get(username)
        if not user:
            return False
        return permission in user["permissions"]
    def save_config(self, filename):
        """保存配置"""
        config = {
            "users": self.users,
            "roles": self.roles
        }
        with open(filename, 'w') as f:
            json.dump(config, f, indent=2)
    def load_config(self, filename):
        """加载配置"""
        with open(filename, 'r') as f:
            config = json.load(f)
            self.users = config["users"]
            self.roles = config["roles"]
# 使用示例
ps = SimplePermissionSystem()
ps.assign_role("张三", "editor")
print(ps.check_permission("张三", "write"))  # True
print(ps.check_permission("张三", "delete")) # False

数据库式权限管理

from dataclasses import dataclass
from typing import Dict, List, Set
@dataclass
class User:
    name: str
    role: str
@dataclass
class Resource:
    name: str
    owner: str
class ACLPermissionSystem:
    def __init__(self):
        self.users: Dict[str, User] = {}
        self.resources: Dict[str, Resource] = {}
        self.acl: Dict[str, Dict[str, Set[str]]] = {}
        # acl[resource_name][username] = {"read", "write", ...}
        # 默认角色权限
        self.role_permissions = {
            "admin": {"read", "write", "delete", "manage"},
            "user": {"read", "write"},
            "guest": {"read"}
        }
    def add_user(self, name: str, role: str = "user"):
        """添加用户"""
        self.users[name] = User(name=name, role=role)
    def add_resource(self, name: str, owner: str):
        """添加资源"""
        self.resources[name] = Resource(name=name, owner=owner)
        # 资源拥有者获得所有权限
        self.assign_permission(name, owner, {"read", "write", "delete"})
    def assign_permission(self, resource: str, user: str, permissions: Set[str]):
        """为用户分配资源权限"""
        if resource not in self.acl:
            self.acl[resource] = {}
        if user not in self.acl[resource]:
            self.acl[resource][user] = set()
        self.acl[resource][user].update(permissions)
    def check_access(self, user: str, resource: str, permission: str) -> bool:
        """检查用户是否有某个资源的权限"""
        # 检查用户是否存在
        if user not in self.users:
            return False
        # 管理员拥有所有权限
        if self.users[user].role == "admin":
            return True
        # 检查ACL
        if resource in self.acl and user in self.acl[resource]:
            if permission in self.acl[resource][user]:
                return True
        return False
    def batch_assign(self, resource: str, users: List[str], permissions: Set[str]):
        """批量分配权限"""
        for user in users:
            if user in self.users:
                self.assign_permission(resource, user, permissions)
# 使用示例
acl_system = ACLPermissionSystem()
acl_system.add_user("Alice", "admin")
acl_system.add_user("Bob", "user")
acl_system.add_resource("file1.txt", "Bob")
print(acl_system.check_access("Alice", "file1.txt", "read"))   # True (admin)
print(acl_system.check_access("Bob", "file1.txt", "write"))    # True (owner)

命令行工具版

import argparse
import json
class CmdPermissionTool:
    def __init__(self):
        self.data = {"users": {}, "roles": {}}
    def add_role(self, name, permissions):
        self.data["roles"][name] = permissions
    def add_user(self, name, role):
        if role in self.data["roles"]:
            self.data["users"][name] = {
                "role": role,
                "permissions": self.data["roles"][role]
            }
            return True
        return False
    def check(self, user, permission):
        if user in self.data["users"]:
            return permission in self.data["users"][user]["permissions"]
        return False
    def run_cli(self):
        """命令行交互"""
        parser = argparse.ArgumentParser(description='简易权限管理系统')
        parser.add_argument('action', choices=['add_user', 'add_role', 'check', 'list'])
        parser.add_argument('--user', help='用户名')
        parser.add_argument('--role', help='角色')
        parser.add_argument('--perm', help='权限')
        parser.add_argument('--perms', nargs='+', help='权限列表')
        args = parser.parse_args()
        if args.action == 'add_role':
            if args.role and args.perms:
                self.add_role(args.role, args.perms)
                print(f"角色 {args.role} 创建成功，权限: {args.perms}")
        elif args.action == 'add_user':
            if args.user and args.role:
                if self.add_user(args.user, args.role):
                    print(f"用户 {args.user} 分配角色 {args.role} 成功")
                else:
                    print("角色不存在")
        elif args.action == 'check':
            if args.user and args.perm:
                result = self.check(args.user, args.perm)
                print(f"用户 {args.user} {'有' if result else '没有'} {args.perm} 权限")
        elif args.action == 'list':
            print(json.dumps(self.data, indent=2))
# 使用示例
if __name__ == "__main__":
    tool = CmdPermissionTool()
    # 命令行调用：python script.py add_role --role admin --perms read write delete
    tool.run_cli()

使用建议

1. 选择合适的方案：

   • 简单应用：用位运算方案
   • 配置文件管理：用JSON方案
   • 复杂系统：用数据库方案
   • 命令行工具：用argparse方案

2. 扩展建议：

   • 添加数据库持久化
   • 增加权限组继承
   • 实现权限审计日志
   • 添加树形资源权限

根据你的具体需求选择最合适的方案,需要更多功能或改进可以告诉我！