contenido
antecedentes
Durante mucho tiempo, la adivinación china se basa en la implementación manual de los adivinos, y los procedimientos son engorrosos (a menudo es necesario bañarse, calcular el clima, meditar, etc.). El trabajo de preparación es complicado (generalmente requiere monedas de cobre y otros accesorios), y el método de cálculo es complicado. Necesita calcular manualmente el binario y convertirlo en el hexagrama final. Para resolver este problema, el autor ha implementado un conjunto de herramientas científicas de adivinación basadas en python para la adivinación rápida
. El método de adivinación es implementado por gossip + Zhouyi + Plum Blossom Yishu, y el script se desarrolla en base a python3.9.0. Mi investigación sobre los Cinco Elementos de Zhouyi es relativamente superficial, discúlpeme si hay alguna omisión. El
efecto final es como se muestra en la figura. Después de ejecutar el programa, obtendrá automáticamente los hexagramas de lo que está pensando de acuerdo con la fortuna actual (este hexagrama, hexagrama mutuo y hexagrama de cambio).
conocimiento previo
Fundamentos
En primer lugar, necesitamos comprender algunos conocimientos básicos de adivinación. En la actualidad, varios métodos de adivinación convencionales en mi país se basan básicamente en una fácil evolución. En general, se obtienen diferentes hexagramas de acuerdo con ciertos fenómenos, y los diferentes hexagramas eventualmente representarán el comienzo, desarrollo y resultado de la adivinación.
Tai Chi da a luz dos instrumentos, dos instrumentos dan a luz cuatro imágenes y cuatro imágenes dan a luz chismes
Creo que todo el mundo ha oído hablar de esta frase en muchos trabajos de cine y televisión, pero pocas personas conocen su verdadero significado.Esta frase en realidad resume el proceso de generación de hexagramas.
-
Tai Chi: Representa un estado de caos absoluto. Es un concepto filosófico. Debe ser aplicado a nuestro mundo objetivo. Puede entenderse como el estado del universo antes del big bang. Todas las leyes físicas no tienen efecto. Este estado.
-
Liangyi: También es un concepto filosófico que representa los dos estados opuestos de una cosa. Cuando se aplica al mundo objetivo, puede ser "vida-muerte", "negro-blanco", "claro-turbio". En el proceso de adivinación, por lo general Habrá dos estados de "yin y yang". Para la conveniencia de la grabación, los antiguos inventaron dos símbolos para representar estos dos estados. Cuando la adivinación, llamamos a uno de esos estados yao (yao).
-
Cuatro imágenes: cuando combinamos yin y yang en pares, podemos obtener cuatro combinaciones diferentes. Los antiguos las llamaban cuatro imágenes. Tenga en cuenta que las cuatro imágenes aquí también son filosóficas. También pueden ser las cuatro direcciones de este, oeste, noroeste. Cuando la adivinación, generalmente usamos "Taiyin", "Shaoyin", "Sol" y "Shaoyang" para llamar a estos cuatro signos.
-
Ocho trigramas: cuando agregamos una línea a las cuatro imágenes, es decir, cuando se combinan tres yin y yang, podemos obtener ocho combinaciones. Los antiguos creían que estas ocho combinaciones pueden representar ocho tipos de cosas en la naturaleza (los ocho estados) , es decir, para el chisme
. Por supuesto, los ocho estados no son suficientes para representar la dirección de desarrollo de las cosas, por lo que los antiguos combinaron el chisme (chisme individual llamado Jinggua) en pares, dando como resultado otros 64 trigramas diferentes. Así es como los sesenta -cuatro hexagramas en el Libro de los Cambios surgieron
En la actualidad, la adivinación dominante en China básicamente obtiene diferentes hexagramas a través de diferentes números, y finalmente juzga la dirección de las cosas. De hecho, para los programadores, dos metros pueden considerarse como un número binario de un dígito, con dos estados de 0 y 1. Sixiang es un número binario de dos dígitos con cuatro estados de 00, 01, 10 y 11. El chisme es un número binario de tres dígitos con cuatro estados: 000, 001, 010, 011, 100, 101, 110 y 111
Cómo generar hexagramas
Ahora sabemos cómo evolucionan los hexagramas, pero no hemos podido entender el camino de los hexagramas. De hecho, en el proceso de adivinación, la mayor diferencia entre los diferentes métodos de adivinación son las diferentes formas de comenzar los hexagramas. Camino de los hexagramas
El método Gua de conteo fácil de Plum Blossom (aquí solo se interceptan dos tipos de métodos Gua)
1. Año, mes y fecha:
divida la suma del año, mes y día del calendario lunar entre ocho y use el resto como el número de hexagramas para encontrar el hexagrama superior; divida la suma del tiempo entre ocho, use el resto como el número de hexagramas para encontrar el siguiente hexagrama, luego divida la suma del año, mes, día y hora entre seis, y usa el resto como línea móvil.
Ejemplo: El hexagrama comienza el día 11 del cuarto mes del año Renshen en el calendario lunar: 9 cuentas en el año Shen y 6 cuentas en la hora si.
El hexagrama anterior es: (año + mes + día) ÷ 8, toma el resto. Es decir: (9+4+11)÷8, aquí no queda resto.
El siguiente hexagrama es: (año + mes + día + hora) ÷ 8, tome el resto. Es decir: (9+4+11+6) ÷ 8, el resto es 6, que es Kan Gua.
El número de líneas móviles es: (año + mes + día + hora) ÷ 6, tome el resto. Es decir: (9+4+11+6) dividido por 6, aquí no queda resto.
Este hexagrama es: el hexagrama superior es Kun, el hexagrama inferior es Kan y la línea móvil es la línea superior.
2. Contar los hexagramas directamente
Este es un método simple y muy preciso para comenzar los hexagramas. Cuando alguien pide medir algo, puede pedirle a la persona que diga dos números a voluntad, el primer número se toma como el hexagrama superior, el segundo número se toma como el hexagrama inferior, la suma de los dos números se divide por 6, y el resto es la línea en movimiento. O puede usar otros métodos que pueden obtener dos números para comenzar hexagramas, como voltear libros, calendarios, etc.
desarrollar
Resumamos el proceso de Plum Blossom Yishu en palabras de los programadores. El proceso es el siguiente
- Obtenga un número aleatorio (usamos la marca de tiempo actual aquí) módulo 8 y utilícelo como un bloqueo (un número binario de tres dígitos)
- Obtenga otro número aleatorio, tome el módulo de ocho y utilícelo como un cuelgue (un número binario de tres dígitos)
- Combine los dos números aleatorios anteriores para obtener un número binario de seis dígitos
- Convierta el número binario de seis dígitos en un número decimal y busque en la tabla para obtener este hexagrama
- Tome un número aleatorio, tome el módulo 6, cambie el 0 de los dígitos correspondientes del número binario de seis dígitos anterior a 1 y 1 a 0, luego conviértalo en un número decimal y busque en la tabla para obtener el cambio.
- Verifique la tabla de acuerdo con el hexagrama original y el hexagrama modificado para obtener el resultado de la adivinación
import json
import random
import time
#别挂配置数据
gua_data_path = "data.json"
#别卦数据
gua_data_map = {
}
fake_delay = 10
#读取别卦数据
def init_gua_data(json_path):
with open(gua_data_path,'r',encoding='utf8')as fp:
global gua_data_map
gua_data_map = json.load(fp)
#爻图标映射
yao_icon_map = {
0:"- -",
1:"---"
}
#经卦名
base_gua_name_map = {
0:"坤",1:"震",2:"坎",3:"兑",4:"艮",5:"离",6:"巽",7:"乾"
}
#数字转化为二进制数组
def base_gua_to_yao(gua, yao_length=3):
result = []
while gua >= 1:
level = 0 if gua % 2 == 0 else 1
gua //= 2
result.append(level)
while len(result) < yao_length:
result.append(0)
return result
#二进制数组转化为数字
def base_yao_to_gua(array):
array = array[:]
while len(array) > 0 and array[-1] == 0:
array.pop()
result = 0
for i in range(len(array)):
if array[i] == 0:
continue
result += pow(2, i)
return result
#打印一个挂
def print_gua(gua):
yao_list = base_gua_to_yao(gua, 6)
up_yao_list = yao_list[0:3]
up = base_yao_to_gua(up_yao_list)
print(yao_icon_map[up_yao_list[2]])
print(yao_icon_map[up_yao_list[1]] + " " + base_gua_name_map[up])
print(yao_icon_map[up_yao_list[0]])
print("")
down_yao_list = yao_list[3:6]
down = base_yao_to_gua(down_yao_list)
print(yao_icon_map[down_yao_list[2]])
print(yao_icon_map[down_yao_list[1]] + " " + base_gua_name_map[down])
print(yao_icon_map[down_yao_list[0]])
#使用梅花易数
def calculate_with_plum_flower():
#起上卦
print("使用梅花易数♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️♣️")
print_a_wait_animation("卜上卦：", fake_delay)
up_base_gua = int(round(time.time() * 1000)) % 8
up_yao_array = base_gua_to_yao(up_base_gua)
print("上卦获取成功,上卦为:", base_gua_name_map[up_base_gua])
#起下卦
print_a_wait_animation("正在获取下卦：", fake_delay)
down_base_gua = random.randint(0, 999999999999) % 8
down_yao_array = base_gua_to_yao(down_base_gua)
print("上卦获取成功,下卦为:", base_gua_name_map[down_base_gua])
#组成卦象
print_a_wait_animation("正在组成本卦：", fake_delay)
print("------------------------------------------------本卦------------------------------------------------")
yao_list = up_yao_array + down_yao_array
gua = base_yao_to_gua(yao_list)
print_gua(gua)
#读取本卦象信息
gua_code = str(base_gua_name_map[up_base_gua]) + str(base_gua_name_map[down_base_gua])
gua_data = gua_data_map[gua_code]
print("本卦为:", gua_data['name'])
print("辞:", gua_data['words'],"译:",gua_data['white_words'])
print("象:", gua_data['picture'],"译:",gua_data['white_picture'])
print_a_wait_animation("正在组成互卦：", fake_delay)
print("------------------------------------------------互卦------------------------------------------------")
#读取互卦象信息
up_hu_yao_list = [yao_list[4],yao_list[5],yao_list[0]]
up_hu_gua = base_yao_to_gua(up_hu_yao_list)
down_hu_yao_list =[yao_list[5],yao_list[0],yao_list[1]]
down_hu_gua = base_yao_to_gua(down_hu_yao_list)
hu_yao_list = up_hu_yao_list + down_hu_yao_list
hu_gua = base_yao_to_gua(hu_yao_list)
hu_gua_code = str(base_gua_name_map[up_hu_gua]) + str(base_gua_name_map[down_hu_gua])
hu_gua_data = gua_data_map[hu_gua_code]
print_gua(hu_gua)
print("互卦为:", hu_gua_data['name'])
print("辞:", hu_gua_data['words'],"译:",hu_gua_data['white_words'])
print("象:", hu_gua_data['picture'],"译:",hu_gua_data['white_picture'])
print_a_wait_animation("正在组成变卦：", fake_delay)
print("------------------------------------------------变卦------------------------------------------------")
change_index = int(round(time.time() * 1000)) % 6
change_yao_list = yao_list[:]
change_yao_list[change_index] = 0 if change_yao_list[change_index] == 1 else 1
up_change_yao_list = change_yao_list[0:3]
up_change_gua = base_yao_to_gua(up_change_yao_list)
down_change_yao_list =change_yao_list[3:5]
down_change_gua = base_yao_to_gua(down_change_yao_list)
change_gua = base_yao_to_gua(change_yao_list)
print_gua(change_gua)
change_gua_code = str(base_gua_name_map[up_change_gua]) + str(base_gua_name_map[down_change_gua])
change_gua_data = gua_data_map[change_gua_code]
print("变卦为:", change_gua_data['name'])
print("辞:", change_gua_data['words'],"译:",change_gua_data['white_words'])
print("象:", change_gua_data['picture'],"译:",change_gua_data['white_picture'])
def print_a_wait_animation(tips,times):
animation = "|/-\\"
idx = 0
for i in range(times):
print(tips + animation[idx % len(animation)],animation[idx % len(animation)],animation[idx % len(animation)],animation[idx % len(animation)],animation[idx % len(animation)], end="\r"),
idx += 1
time.sleep(0.1)
init_gua_data(gua_data_path)
calculate_with_plum_flower()
código fuente
https://github.com/MrFengGG/ToChange/tree/master