Hello World - 默认分类
type: channel
link: https://www.ronie.ren/index.php/category/default/
description: 只是一个默认分类
items: redis 限流
items: Nginx 配置文件注释
items: docker compose kafka
items: docker-compose-redis
items: LeetCode（2023-10-30）
items: LeetCode（2023-09-21）
items: VHD
items: 64-ia-32-architectures-software-developer-vol-1-manual.pdf
items: 家庭
items: Python

redis 限流
type: item
date: 2025-12-31T09:34:21+00:00
description: redis 限流redis 令牌桶限流@dataclass(frozen=True) class RateLimitResult: allowed: bool remaining_tokens: float retry_after_seconds: float now_ms: int class RedisTokenBucketRateLimiter: _TOKEN_BUCKET_LUA = r""" local key = KEYS[1] -- 令牌桶状态存储的 Redis Key（Hash） local capacity = tonumber(ARGV[1]) -- 桶容量：最多可累积的令牌数 local rate = tonumber(ARGV[2]) -- 补充速率：每秒补充多少令牌（tokens/s） local requested = tonumber(ARGV[3]) -- 本次请求要消耗的令牌数 local ttl_ms = tonumber(ARGV[4]) -- 令牌桶 Key 的过期时间（毫秒），用于回收冷 Key local t = redis.call('TIME') -- 读取 Redis 服务器时间：{秒, 微秒} local now = tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000) -- 服务器时间换算为毫秒时间戳 local data = redis.call('HMGET', key, 'tokens', 'ts') -- 读取当前令牌数(tokens)与上次更新时间(ts) local tokens = tonumber(data[1]) -- 当前令牌数（可能为 nil） local ts = tonumber(data[2]) -- 上次更新时间戳（毫秒，可能为 nil） if tokens == nil then tokens = capacity end -- 初始化：若不存在，则认为桶是满的 if ts == nil then ts = now end -- 初始化：若不存在，则将上次更新时间设为当前 if now < ts then ts = now end -- 防御：若时钟回拨导致 now < ts，则强制对齐 local delta_ms = now - ts -- 距离上次更新过去了多少毫秒 local refill = (delta_ms / 1000.0) * rate -- 这段时间应补充的令牌数量（可为小数） tokens = math.min(capacity, tokens + refill) -- 将令牌补充后并截断到容量上限 local allowed = 0 -- 是否允许：0/1（Lua 没有布尔返回给 Python 的统一类型） local retry_after_ms = 0 -- 如果不允许，建议等待多少毫秒再试 if tokens >= requested then -- 若令牌充足 allowed = 1 -- 标记允许 tokens = tokens - requested -- 扣除本次消耗 else -- 否则令牌不足 allowed = 0 -- 标记拒绝 if rate > 0 then -- 若补充速率 > 0，可计算需要等待的时间 local missing = requested - tokens -- 还差多少令牌 retry_after_ms = math.ceil((missing / rate) * 1000) -- 差额按速率换算为等待毫秒数（向上取整） else -- 若 rate=0，则永远补不回令牌 retry_after_ms = -1 -- 用 -1 表示无法通过等待获得令牌 end -- 结束 rate>0 分支 end -- 结束 tokens>=requested 分支 redis.call('HMSET', key, 'tokens', tokens, 'ts', now) -- 写回最新 tokens 与 ts（原子更新） if ttl_ms ~= nil and ttl_ms > 0 then -- 若配置了过期时间且 >0 redis.call('PEXPIRE', key, ttl_ms) -- 给令牌桶 Key 设置过期（毫秒） end -- 结束 ttl 分支 return {allowed, tokens, retry_after_ms, now} -- 返回：是否允许、剩余令牌、建议等待(ms)、当前时间(ms) """ def __init__( self, redis: Optional[AsyncRedis…

Nginx 配置文件注释
type: item
date: 2025-03-27T07:00:49+00:00
description: user nobody; # Nginx worker进程运行的用户及用户组 worker_processes 4; # 在master/worker运行方式下，定义worker进程的个数; 可以为auto worker_rlimit_nofile 65535; # 设置 Nginx worker 进程可以打开的最大文件描述符数量。这个指令通常用于确保 Nginx 能够处理大量并发连接，因为每个连接通常会占用一个文件描述符。 worker_rlimit_core 1m; # 通过worker_rlimit_core配置可以限制core文件的大小 working_directory /usr/local/lighthouse/softwares/nginx/coredump; # 设置coredump文件所放置的目录 daemon on; # 是否以守护进程方式运行Nginx master_process on; # 是否以 master/worker 方式工作 worker_cpu_affinity 1000 0100 0010 0001; # 绑定worker进程到指定的CPU内核 error_log logs/error.log notice; # error_log/path/file level; timer_resolution 100ms; # 每次内核的事件调用（如epoll、select、poll、kqueue等）返回时，都会执行一次gettimeofday，实现用内核的时钟来更新Nginx中的缓存时钟。 events { # 处理网络连接设置的核心部分 debug_connection 10.224.66.14; # 仅仅来自以上IP地址的请求才会输出debug级别的日志 debug_connection 10.224.57.0/24; # 其他请求仍然沿用error_log中配置的日志级别 accept_mutex on; # 负载均衡锁 accept锁默认是打开的，如果关闭它，那么建立TCP连接的耗时会更短，但worker进程之间的负载会非常不均衡 accept_mutex_delay 500ms; # 使用accept锁后，同一时间只有一个worker进程能够取到accept锁。这个accept锁不是阻塞锁，如果取不到会立刻返回。 如果有一个worker进程试图取accept锁而没有取到，它至少要等accept_mutex_delay定义的时间间隔后才能再次试图取锁。 multi_accept off; # 当事件模型通知有新连接时，尽可能地对本次调度中客户端发起的所有TCP请求都建立连接。 use epoll; # 事件驱动模型 worker_connections 8192; # 每个worker进程可以同时处理的最大连接数。 } http { include mime.types; default_type application/octet-stream; log_format combinedio '$remote_addr - $remote_user [$time_local] ' '"$request" $status $body_bytes_sent ' '"$http_referer" "$http_user_agent" $request_length $request_time $upstream_response_time'; access_log logs/access.log combinedio; sendfile on; # 硬盘 >> kernel buffer >> user buffer>> kernel socket buffer >>协议栈 | 硬盘 >> kernel buffer (快速拷贝到kernelsocket buffer) >>协议栈 gzip on; # 压缩响应内容 tcp_nopush on; # 数据量达到一定值后发送 tcp_nodelay on; # 对keepalive连接是否使用TCP_NODELAY选项。# 应用程序每产生一次操作就会发送一个包, delay 会等待数据，因此操作后它不会发送一个数据包，而是将这段时间内的数据打成一个大的包 keepalive_timeout 0; # 一个keepalive连接在闲置超过一定时间后,服务器关闭这个连接。 client_body_timeout 10; # second HTTP包体 client_header_timeout 10; # second 客户端与服务器建立连接后将开始接收HTTP头部，在这个过程中，如果在一个时间间隔（超时时间）内没有读取到客户端发来的字节，则认为超…

docker compose kafka
type: item
date: 2025-02-24T08:59:00+00:00
description: docker kafka 配置文件version: '3.8' name: "kafka-service" # https://docs.docker.com/compose/how-tos/project-name/ services: kafka-server0: image: bitnami/kafka:latest hostname: kafka0 container_name: kafka0 ports: - "9092:9094" environment: KAFKA_CFG_NODE_ID: 0 KAFKA_CFG_BROKER_ID: 0 KAFKA_CFG_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093,EXTERNAL://0.0.0.0:9094 KAFKA_CFG_ADVERTISED_LISTENERS: PLAINTEXT://kafka0:9092,EXTERNAL://192.168.60.134:9092 KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,EXTERNAL:PLAINTEXT,PLAINTEXT:PLAINTEXT KAFKA_CFG_CONTROLLER_QUORUM_VOTERS: 1@kafka1:9093,2@kafka2:9093,0@kafka0:9093 KAFKA_CFG_PROCESS_ROLES: broker,controller # KAFKA_CFG_LOG_DIRS: /var/lib/kafka/data KAFKA_CFG_OFFSETS_TOPIC_REPLICATION_FACTOR: 3 KAFKA_CFG_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 3 KAFKA_CFG_TRANSACTION_STATE_LOG_MIN_ISR: 2 KAFKA_CFG_MIN_INSYNC_REPLICAS: 1 KAFKA_CFG_AUTO_CREATE_TOPICS_ENABLE: true KAFKA_CFG_CONTROLLER_LISTENER_NAMES: CONTROLLER KAFKA_KRAFT_CLUSTER_ID: d6c6ea9d1bfe423ebdc74579b10c61f0 networks: kafka: ipv4_address: 172.16.0.2 volumes: - ~/kafka-data/0:/bitnami/kafka kafka-server1: image: bitnami/kafka:latest hostname: kafka1 container_name: kafka1 ports: - "9094:9094" environment: KAFKA_CFG_NODE_ID: 1 KAFKA_CFG_BROKER_ID: 1 KAFKA_CFG_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093,EXTERNAL://0.0.0.0:9094 KAFKA_CFG_ADVERTISED_LISTENERS: PLAINTEXT://kafka1:9092,EXTERNAL://192.168.60.134:9094 KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,EXTERNAL:PLAINTEXT,PLAINTEXT:PLAINTEXT KAFKA_CFG_CONTROLLER_QUORUM_VOTERS: 1@kafka1:9093,2@kafka2:9093,0@kafka0:9093 KAFKA_CFG_PROCESS_ROLES: broker,controller # KAFKA_CFG_LOG_DIRS: /var/lib/kafka/data KAFKA_CFG_OFFSETS_TOPIC_REPLICATION_FACTOR: 3 KAFKA_CFG_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 3 KAFKA_CFG_TRANSACTION_STATE_LOG_MIN_ISR: 2 KAFKA_CFG_MIN_INSYNC_REPLICAS: 1 KAFKA_CFG_AUTO_CREATE_TOPICS_ENABLE: true KAFKA_CFG_CONTROLLER_LISTENER_NAMES: CONTROLLER KAFKA_KRAFT_CLUSTE…

docker-compose-redis
type: item
date: 2025-02-24T08:57:56+00:00
description: RedisRedis-Server通过bitnami/redis:7.4.1实现 redis 主从集群version: '3.8' name: 'redis-service' services: redis-master: image: 'bitnami/redis:7.4.1' container_name: redis-master hostname: redis-master expose: - '6379' environment: - REDIS_REPLICATION_MODE=master - REDIS_PASSWORD=OeLFo2b3GVXKj0Ren1Dh - REDIS_MASTER_PORT_NUMBER=6379 networks: redis: ipv4_address: 192.168.0.2 redis-replica: image: 'bitnami/redis:7.4.1' deploy: replicas: 2 depends_on: - redis-master environment: - REDIS_REPLICATION_MODE=slave - REDIS_MASTER_HOST=192.168.0.2 - REDIS_MASTER_PORT_NUMBER=6379 - REDIS_MASTER_PASSWORD=OeLFo2b3GVXKj0Ren1Dh - REDIS_PASSWORD=OeLFo2b3GVXKj0Ren1Dh networks: redis: networks: redis: driver: bridge name: redis-net ipam: config: - subnet: 192.168.0.0/24 gateway: 192.168.0.1 Redis-Sentinel为保证redis集群高可用，添加redis sentinel监控master节点。version: '3.8' name: 'redis-sentinel-cluster' services: redis-sentinel: image: 'bitnami/redis-sentinel:6.2.16' deploy: replicas: 3 environment: REDIS_SENTINEL_PORT_NUMBER: '26379' REDIS_MASTER_HOST: '192.168.0.2' REDIS_MASTER_PORT_NUMBER: '6379' REDIS_SENTINEL_QUORUM: '2' # 在进行故障转移之前，必须同意主节点失效的 Sentinel 实例的最小数量。 REDIS_MASTER_PASSWORD: 'OeLFo2b3GVXKj0Ren1Dh' REDIS_SENTINEL_DOWN_AFTER_MILLISECONDS: '5000' REDIS_SENTINEL_FAILOVER_TIMEOUT: '5000' REDIS_MASTER_SET: 'mymaster' networks: - redis networks: redis: name: 'redis-net' external: true测试后发现，redis sentinel 能在master节点失效后选举新master节点，但是在docker-compose中只暴露了master节点的6379端口。于是在redis-net网络中添加nginx反代。nginx反代（不可用）nginx-reverse-proxy: image: 'bitnami/nginx:1.27' volumes: - ./nginx.conf:/opt/bitnami/nginx/conf/stream_server_blocks/my_server_block.conf environment: NGINX_ENABLE_STREAM: yes ports: - '6379:6379' networks: redis: depends_on: - redis-replica添加反代后，发现slave节点不能向master节点转发命令（记错了，这个是redis分片集群的功能，分片节点计算键的插槽，该插槽不归该节点管就转发给该管这个插槽的节点）。放弃反代，直接将测试代码接入redis-net网络。问题发现容器内无法访问外部网络(.venv) ronie@ronie:~/PycharmProjects/evilbox$ docker attach 81 / # ping www.baidu.com PING www.baidu.com (180.101.50.188): 56 data bytes…

LeetCode（2023-10-30）
type: item
date: 2023-10-30T09:52:07+00:00
description: 1711. 大餐计数1711. 大餐计数from typing import List from collections import Counter import math class Solution: def countPairs(self, deliciousness: List[int]) -> int: min_deliciousness = min(deliciousness) if min_deliciousness <= 0: min_deliciousness = 0.5 max_deliciousness = max(deliciousness) count = Counter(deliciousness) ans = 0 wait_list = [2 ** i for i in range(int(math.log(min_deliciousness * 2, 2)), int(math.log(max_deliciousness * 2, 2)) + 1)] used = set() for k, v in count.items(): for i in range(len(wait_list)): if wait_list[i] - k in count: if wait_list[i] - k == k and v > 1: ans += (1 + v - 1) * (v - 1) // 2 ans = ans % (10 ** 9 + 7) elif wait_list[i] - k == k: pass else: if wait_list[i] - k not in used: ans += v * count[wait_list[i] - k] ans = ans % (10 ** 9 + 7) used.add(k) return ans % (10 ** 9 + 7)1702. 修改后的最大二进制字符串1702. 修改后的最大二进制字符串class Solution: def maximumBinaryString(self, binary: str) -> str: left = 0 binary = list(binary) while left < len(binary) and binary[left] == '1': left += 1 right = left + 1 while right < len(binary): if binary[right] == '1': right += 1 continue if right - left == 1: binary[left] = '1' else: binary[left] = '1' binary[right] = '1' binary[left + 1] = '0' left += 1 right += 1 return ''.join(binary)133. 克隆图133. 克隆图class Node: def __init__(self, val=0, neighbors=None): self.val = val self.neighbors = neighbors if neighbors is not None else [] from typing import Optional class Solution: def __init__(self): self.created = {} self.used = set() def cloneGraph(self, node: Optional['Node']) -> Optional['Node']: if node is None: return None val = node.val self.dfs(node) return self.created[val] def dfs(self, node: Optional['Node']): if node.val in self.used: return if node.val not in self.created: new_node = Node(node.val) self.created[node.val] = new_node else: new_node = self.created[node.val] self.used.add(node.val) for i in range(len(node.neighbors)): if node.neighbors[i].val in self.created: new_node.neighbors.append(self.created[node…

LeetCode（2023-09-21）
type: item
date: 2023-09-21T08:33:00+00:00
description: 2260. 必须拿起的最小连续卡牌数2260. 必须拿起的最小连续卡牌数class Solution: def minimumCardPickup(self, cards: List[int]) -> int: res = {} mark = {cards[k]: False for k in range(len(cards))} for i in range(len(cards)): if cards[i] in res: if res[cards[i]][1] - res[cards[i]][0] > i - res[cards[i]][2] or res[cards[i]][1] == res[cards[i]][0]: res[cards[i]] = [res[cards[i]][2], i, i] mark[cards[i]] = True res[cards[i]][2] = i else: res[cards[i]] = [i, i, i] ans = float('inf') for k, v in res.items(): if v[0] == v[1]: continue if mark[k] and ans > v[1] - v[0] + 1: ans = v[1] - v[0] + 1 return ans if ans != float('inf') else -11893. 检查是否区域内所有整数都被覆盖1893. 检查是否区域内所有整数都被覆盖class Solution: def isCovered(self, ranges: List[List[int]], left: int, right: int) -> bool: ranges.sort(key=lambda x: x[0]) father = [ranges[i][0] for i in range(len(ranges))] for i in range(1, len(ranges)): if ranges[i][0] < ranges[i - 1][1] and ranges[i][1] < ranges[i - 1][1]: ranges[i][1] = ranges[i - 1][1] for i in range(1, len(ranges)): if ranges[i][0] - ranges[i - 1][1] <= 1: father[i] = father[i - 1] left_father = None right_father = None for i in range(len(ranges)): if ranges[i][0] <= left <= ranges[i][1] and not left_father: left_father = father[i] if ranges[i][0] <= right <= ranges[i][1] and not right_father: right_father = father[i] if left_father and right_father: break if left_father is None and right_father is None: return False else: return left_father == right_father2269. 找到一个数字的 K 美丽值2269. 找到一个数字的 K 美丽值class Solution: def divisorSubstrings(self, num: int, k: int) -> int: num = str(num) ans = 0 for i in range(len(num) - k + 1): sub_num = int(num[i:i+k]) if sub_num == 0: continue if int(num) % sub_num == 0: ans += 1 return ans1779. 找到最近的有相同 X 或 Y 坐标的点1779. 找到最近的有相同 X 或 Y 坐标的点class Solution: def nearestValidPoint(self, x: int, y: int, points: List[List[int]]) -> int: ans = 0 distance = float('inf') for i in range(len(points)): if points[i][0] == x or points[i][1] == y: dis = abs(points[i][0] - x) + abs(points[i][1] -…

VHD
type: item
date: 2023-09-16T09:09:00+00:00
description: VHDVHD 结构是一种虚拟磁盘的实现方式，即通过文件来模拟物理磁盘的方式来存储数据。VHD结构有2种实现方式：固定方式和动态方式。本文只讨论固定方式。固定方式就是用真实大小的文件模拟同样大小的一个虚拟磁盘。VHD 头部VHD和其他文件不同，VHD其信息放在尾部，也就是最后一个扇区中。我们应当首先读取最后一个扇区的内容。字段字节数说明cookie8标识，应为conectix，用于判断VHD是否有效features40： HD_NO_FEATURES1： HD_TEMPORARY2： HD_RESERVEDff_version4VHD版本data_offset8固定磁盘，总是0xFFFFFFFF。timestamp4VHD的创建时间，指2000年1月1日00:00:00至今的秒数crtr_app4创建者crtr_ver4创建版本crtr_os4创建者系统orig_size8创建的虚拟磁盘大小，这个大小指虚拟出来的磁盘的可用寻址空间。curr_size8用于vhd在线扩容后的最后大小表述，如果没有扩容，和orig_size相同。geometry4VHD的C/H/S结构参数柱面数2字节，磁头数1字节，扇区数1字节type40： HD_TYPE_NONE 2： HD_TYPE_FIXED 固定磁盘3： HD_TYPE_DYNAMIC 动态磁盘4： HD_TYPE_DIFF 差异磁盘checksum4本扇区的校验和uuid16磁盘标识，在差异磁盘中，决定了VHD间的主从关系。saved1是否在保存状态hidden1VDI是否隐藏VHD 写入VHD文件规定读写需要针对磁道，读写必须要在某个磁道的开头处，然后读取n个磁道（n*512字节）。如果你的数据不够512的倍数，那么写入的时候需要将数据凑到512字节的倍数，不够的部分补0。import datetime import logging class Vhd: def __init__(self, file_name): self.head = {} self.file_name = file_name self.f = open(self.file_name, 'rb+') self.head_info() def head_info(self): self.f.seek(-512, 2) self.head["cookie"] = self.f.read(8).decode() self.head["features"] = self.f.read(4) self.head["ff_version"] = self.f.read(4) self.head["data_offset"] = self.f.read(8) t = int.from_bytes(self.f.read(4)) t = datetime.datetime(2000, 1, 1, 8) + datetime.timedelta(seconds=t) self.head["timestamp"] = t.strftime("%Y-%m-%d %H:%M:%S") self.head["crtr_app"] = self.f.read(4).decode() self.head["crtr_ver"] = self.f.read(4) self.head["crtr_os"] = self.f.read(4) self.head["orig_size"] = int.from_bytes(self.f.read(8)) self.head["curr_size"] = int.from_bytes(self.f.read(8)) cylinder = int.from_bytes(self.f.read(2)) head = int.from_bytes(self.f.read(1)) sector = int.from_bytes(self.f.read(1)) self.head["geometry"] = (cylinder, head, sector) type_ = int.from_bytes(self.f.read(4)) if type_ == 0: type_ = "HD_TYPE_NONE" elif type_ == 2: type_ = "HD_TYPE_FIXED" elif type_ == 3: type_ = "HD_TYPE_DYNAMIC" elif type_ == 4: type_ = "HD_TYPE_DIFF" self.head["type"] = type_ self.head["checksum"] = self.f.read(4) self.head["uuid"]…

64-ia-32-architectures-software-developer-vol-1-manual.pdf
type: item
date: 2023-09-15T09:17:00+00:00
description: 该翻译，计划.2023-12-01开始

家庭
type: item
date: 2023-09-03T04:37:17+00:00
description: 家庭1. 研究家庭的主要方法恩格斯在开篇提到摩尔根的发现：在易洛魁人中间盛行的，是一种双方可以轻易解除的个体婚姻，摩尔根称之为“对偶制家庭”。这种家庭形式中，父母、子女、兄弟、姐妹之间的关系非常明确，但是，这些称呼的实际使用，却与此矛盾。易洛魁人的男子，不仅把自己亲生的子女称为自己的儿子和女儿，而且把他兄弟的子女也称为自己的儿子和女儿，而他们都称他为父亲，他把自己姊妹的子女则称为自己的外甥和外甥女，他们称他为舅父。同样，易洛魁人的女子，把自己姊妹的子女和她自己亲生的子女一概都称为自己的儿子和女儿，而他们都称她为母亲，她把自己兄弟的子女称为自己的内侄和内侄女，她自己被称为他们的姑母。这样的亲属关系同亲属制度矛盾，是怎样产生的呢？摩尔根在《古代社会》中说：“家庭是一个能动的要素；它从来不是静止不动的，而是随着社会从较低阶段向较高阶段的发展，从低级的形式如进到较高的形式。反之，亲属制度却是被动的；它只是把家庭经过一个长久时期所发生的进步记录下来，并且只是在家庭已经根本变化了的时候，它才发生根本的变化。”这句话也就是说：亲属制度是对亲属关系的反映。当一种家庭形式确立起来，相应的亲属制度也随之确立，但是在家庭形式变动过程中，亲属制度可能还没那么迅速地随之发生变化，还以习惯的方式继续存在着。但是有一点是明确的，没有一定的家庭形式也就不可能形成与之相应的亲属制度，反之，由亲属制度追根溯源必然能在现实的历史发展过程找寻到与之相应的家庭关系。于是，我们可以得出这样一个结论：如果现行家庭形式中产生的亲属关系，是同亲属制度相矛盾的，那么在这之前必然存在一种家庭形式，其产生的亲属关系是与现行的亲属制度相适应的，由现行的亲属制度追根溯源必然能在现实的历史发展过程中找寻到与之相应的家庭关系。2.原始的家庭形式​恩格斯认为原始的家庭形式就是“群婚”，即“整群的男子与整群的女子互为所有”。产生群婚这种家庭形式存在两个前提：一是以群的联合力量和集体行动来弥补个体自卫能力的不足。二是成年雄者的相互宽容，没有忌妒。​关于第二点，我们不得不提到高等动物中群和家庭的关系。恩格斯认为，较高等级的脊椎动物与人类在家庭和群的关系有重要的差别：​较高等级的脊椎动物由于雄性存在本能性的嫉妒，使其联结又限制着动物家庭的发展，又同样使其的家庭跟群对立起来，在家庭紧密结合的地方，群只是一种稀有的例外。反之，在自由的性关系或多偶制盛行的地方，群差不多是自动地形成的……为了使群能够组成，家庭的纽结必然要放松，个体必然要重新自由。因此我们可以得从这样一个结论：高等动物的群和家庭并不是互相补充，而是互相对立的。雄者的嫉妒使高等动物的群基本不可能产生。"而成年雄者的相互宽容，没有忌妒，则是形成较大的持久的集团的首要条件。"也就是说，原始状态下的人类在家庭和群之间的选择是明确的，为了要在凶险的自然界中维持生存，就必须要选择后者，不能因为个体的家庭而抛弃共居生活的群。​在此基础上，群婚便自然而然的产生出来了。与这个阶段相适应的性关系被恩格斯称之为杂乱的性关系，即不排除兄弟姐妹之间，父母与子女之间的性关系。人类之后的家庭形式，便在此基础上发展起来。3.几种家庭形式血缘家庭婚姻集团按辈分划分，即在家庭范围内，一群直系或旁系的兄弟姊妹互相通婚，但婚姻关系基本上排除祖辈与孙辈、父母辈与子女辈的婚配。这种家庭的典型形式是一对配偶的子孙中，每一代都互为兄弟姊妹，也互为夫妻。在亲属称谓上无父系和母系的区别，祖父与外祖父、伯叔父与舅父、姑母与姨母、舅母与母亲等都使用相同称呼。即一对配偶的子孙中每一代都互为兄弟姊妹，也互为夫妻。目前血缘家庭已经绝迹，但在夏威夷的亲属制度揭示了它的存在。普那路亚家庭血缘家庭排除了父母与子女之间的性关系，而普那路亚家庭更进一步，排除了兄弟姊妹之间的性关系。按照夏威夷的习俗，若干数目的姊妹——同胞的或血统较远的即从（表）姊妹，再从（表）姊妹或更远一些的姊妹——是她们共同丈夫们的共同的妻子，但是在这些共同丈夫之中，排除了她们的兄弟；这些丈夫彼此已不再互称兄弟，他们也不再必须是兄弟了，而是互称普那路亚，即亲密的同伴，即所谓Associé。同样，一列兄弟——同胞的或血统较远的——则跟若干数目的女子（只要不是自己的姊妹）共同结婚，这些女子也互称普那路亚。普那路亚家庭是群婚的最高发展阶段，普那路亚家庭的出现对人类历史的发展造成了巨大的影响，氏族就是在普那路亚家庭的基础上直接发展而来的。氏族就是由这一进步直接引起的，而且远远超过了最初的目的，它构成地球上即使不是所有的也是大多数野蛮民族的社会制度的基础。所有的群婚家庭中，只有孩子的母亲是能够被确定的，孩子的父亲是不确定的。母亲能够把自己亲生的子女同其他一切并非自己亲生的子女区别开来，即使母亲也称共同家庭中的其他孩子为自己的子女。也就是说，只要存在着群…

Python
type: item
date: 2023-03-31T08:27:00+00:00
description: Python 对象基础Python 整数对象Python 字符串对象Python 列表对象Python 字典对象Python 字节码对象Python 栈帧对象Python 简单表达式Python 复杂表达式Python 控制流程