ಪೂರ್ವೇತಿಹಾಸದ
ransomware ವೈರಸ್‌ನಿಂದ ಸರ್ವರ್ ಆಕ್ರಮಣಕ್ಕೆ ಒಳಗಾಯಿತು, ಅದು "ಅದೃಷ್ಟದ ಅಪಘಾತದಿಂದ" ಭಾಗಶಃ .ibd ಫೈಲ್ಗಳನ್ನು (innodb ಕೋಷ್ಟಕಗಳ ಕಚ್ಚಾ ಡೇಟಾ ಫೈಲ್‌ಗಳು) ಸ್ಪರ್ಶಿಸದೆ ಬಿಟ್ಟಿತು, ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ .fpm ಫೈಲ್ಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿದೆ ( ರಚನೆ ಕಡತಗಳು). ಈ ಸಂದರ್ಭದಲ್ಲಿ, .idb ಅನ್ನು ಹೀಗೆ ವಿಂಗಡಿಸಬಹುದು:
- ಪ್ರಮಾಣಿತ ಪರಿಕರಗಳು ಮತ್ತು ಮಾರ್ಗದರ್ಶಿಗಳ ಮೂಲಕ ಮರುಸ್ಥಾಪನೆಗೆ ಒಳಪಟ್ಟಿರುತ್ತದೆ. ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಅತ್ಯುತ್ತಮವಾದದ್ದು ಇದೆ ;
- ಭಾಗಶಃ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಕೋಷ್ಟಕಗಳು. ಹೆಚ್ಚಾಗಿ ಇವುಗಳು ದೊಡ್ಡ ಕೋಷ್ಟಕಗಳಾಗಿವೆ, ಇದಕ್ಕಾಗಿ (ನಾನು ಅರ್ಥಮಾಡಿಕೊಂಡಂತೆ) ದಾಳಿಕೋರರು ಪೂರ್ಣ ಗೂಢಲಿಪೀಕರಣಕ್ಕಾಗಿ ಸಾಕಷ್ಟು RAM ಅನ್ನು ಹೊಂದಿರಲಿಲ್ಲ;
- ಸರಿ, ಸಂಪೂರ್ಣವಾಗಿ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಲಾದ ಟೇಬಲ್‌ಗಳನ್ನು ಪುನಃಸ್ಥಾಪಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಅಪೇಕ್ಷಿತ ಎನ್ಕೋಡಿಂಗ್ ಅಡಿಯಲ್ಲಿ ಯಾವುದೇ ಪಠ್ಯ ಸಂಪಾದಕದಲ್ಲಿ ಅದನ್ನು ತೆರೆಯುವ ಮೂಲಕ (ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ ಇದು UTF8) ಮತ್ತು ಪಠ್ಯ ಕ್ಷೇತ್ರಗಳ ಉಪಸ್ಥಿತಿಗಾಗಿ ಫೈಲ್ ಅನ್ನು ಸರಳವಾಗಿ ವೀಕ್ಷಿಸುವ ಮೂಲಕ ಕೋಷ್ಟಕಗಳು ಯಾವ ಆಯ್ಕೆಗೆ ಸೇರಿವೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಾಯಿತು, ಉದಾಹರಣೆಗೆ:
ಅಲ್ಲದೆ, ಫೈಲ್‌ನ ಆರಂಭದಲ್ಲಿ ನೀವು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ 0 ಬೈಟ್‌ಗಳನ್ನು ವೀಕ್ಷಿಸಬಹುದು ಮತ್ತು ಬ್ಲಾಕ್ ಎನ್‌ಕ್ರಿಪ್ಶನ್ ಅಲ್ಗಾರಿದಮ್ (ಅತ್ಯಂತ ಸಾಮಾನ್ಯ) ಬಳಸುವ ವೈರಸ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಅವುಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತವೆ.
ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ, ಆಕ್ರಮಣಕಾರರು ಪ್ರತಿ ಎನ್‌ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಫೈಲ್‌ನ ಕೊನೆಯಲ್ಲಿ 4-ಬೈಟ್ ಸ್ಟ್ರಿಂಗ್ (1, 0, 0, 0) ಅನ್ನು ಬಿಟ್ಟಿದ್ದಾರೆ, ಇದು ಕಾರ್ಯವನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ. ಸೋಂಕಿತವಲ್ಲದ ಫೈಲ್ಗಳನ್ನು ಹುಡುಕಲು, ಸ್ಕ್ರಿಪ್ಟ್ ಸಾಕು:
def opened(path):
files = os.listdir(path)
for f in files:
if os.path.isfile(path + f):
yield path + f
for full_path in opened("C:somepath"):
file = open(full_path, "rb")
last_string = ""
for line in file:
last_string = line
file.close()
if (last_string[len(last_string) -4:len(last_string)]) != (1, 0, 0, 0):
print(full_path)ಹೀಗಾಗಿ, ಇದು ಮೊದಲ ಪ್ರಕಾರಕ್ಕೆ ಸೇರಿದ ಫೈಲ್ಗಳನ್ನು ಹುಡುಕಲು ಹೊರಹೊಮ್ಮಿತು. ಎರಡನೆಯದು ಬಹಳಷ್ಟು ಹಸ್ತಚಾಲಿತ ಕೆಲಸವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಆದರೆ ಕಂಡುಬಂದದ್ದು ಈಗಾಗಲೇ ಸಾಕಷ್ಟು ಆಗಿತ್ತು. ಎಲ್ಲವೂ ಚೆನ್ನಾಗಿರುತ್ತದೆ, ಆದರೆ ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕು ಸಂಪೂರ್ಣವಾಗಿ ನಿಖರವಾದ ರಚನೆ ಮತ್ತು (ಸಹಜವಾಗಿ) ನಾನು ಆಗಾಗ್ಗೆ ಬದಲಾಗುತ್ತಿರುವ ಟೇಬಲ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬೇಕಾದ ಪ್ರಕರಣವು ಹುಟ್ಟಿಕೊಂಡಿತು. ಕ್ಷೇತ್ರದ ಪ್ರಕಾರವನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆಯೇ ಅಥವಾ ಹೊಸ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಲಾಗಿದೆಯೇ ಎಂಬುದು ಯಾರಿಗೂ ನೆನಪಿಲ್ಲ.
ವೈಲ್ಡ್ಸ್ ಸಿಟಿ, ದುರದೃಷ್ಟವಶಾತ್, ಅಂತಹ ಸಂದರ್ಭದಲ್ಲಿ ಸಹಾಯ ಮಾಡಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ, ಅದಕ್ಕಾಗಿಯೇ ಈ ಲೇಖನವನ್ನು ಬರೆಯಲಾಗುತ್ತಿದೆ.
ವಿಷಯಕ್ಕೆ ಬನ್ನಿ
3 ತಿಂಗಳ ಹಿಂದಿನ ಟೇಬಲ್‌ನ ರಚನೆಯು ಪ್ರಸ್ತುತ ಒಂದಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ (ಬಹುಶಃ ಒಂದು ಕ್ಷೇತ್ರ, ಮತ್ತು ಬಹುಶಃ ಹೆಚ್ಚು). ಟೇಬಲ್ ರಚನೆ:
CREATE TABLE `table_1` (
`id` INT (11),
`date` DATETIME ,
`description` TEXT ,
`id_point` INT (11),
`id_user` INT (11),
`date_start` DATETIME ,
`date_finish` DATETIME ,
`photo` INT (1),
`id_client` INT (11),
`status` INT (1),
`lead__time` TIME ,
`sendstatus` TINYINT (4)
); ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಹೊರತೆಗೆಯಬೇಕು:
id_pointಇಂಟ್ (11);id_userಇಂಟ್ (11);date_startದಿನಾಂಕ ಸಮಯ;date_finishದಿನಾಂಕ ಸಮಯ.
ಚೇತರಿಕೆಗಾಗಿ, .ibd ಫೈಲ್‌ನ ಬೈಟ್-ಬೈ-ಬೈಟ್ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ನಂತರ ಅವುಗಳನ್ನು ಹೆಚ್ಚು ಓದಬಹುದಾದ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ನಮಗೆ ಬೇಕಾದುದನ್ನು ಕಂಡುಹಿಡಿಯಲು, ನಾವು ಇಂಟ್ ಮತ್ತು ಡೇಟಾಟೈಮ್‌ನಂತಹ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಮಾತ್ರ ವಿಶ್ಲೇಷಿಸಬೇಕಾಗಿದೆ, ಲೇಖನವು ಅವುಗಳನ್ನು ಮಾತ್ರ ವಿವರಿಸುತ್ತದೆ, ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನಾವು ಇತರ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಸಹ ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ, ಅದು ಇತರ ರೀತಿಯ ಘಟನೆಗಳಿಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಸಂಚಿಕೆ 1: DATETIME ಮತ್ತು TEXT ಪ್ರಕಾರಗಳನ್ನು ಹೊಂದಿರುವ ಕ್ಷೇತ್ರಗಳು ಶೂನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿವೆ, ಮತ್ತು ಅವುಗಳನ್ನು ಫೈಲ್‌ನಲ್ಲಿ ಸರಳವಾಗಿ ಬಿಟ್ಟುಬಿಡಲಾಗಿದೆ, ಈ ಕಾರಣದಿಂದಾಗಿ, ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ ಪುನಃಸ್ಥಾಪಿಸಲು ರಚನೆಯನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. ಹೊಸ ಕಾಲಮ್‌ಗಳಲ್ಲಿ, ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವು ಶೂನ್ಯವಾಗಿದೆ ಮತ್ತು innodb_flush_log_at_trx_commit = 0 ಸೆಟ್ಟಿಂಗ್‌ನಿಂದ ವಹಿವಾಟಿನ ಭಾಗವು ಕಳೆದುಹೋಗಬಹುದು, ಆದ್ದರಿಂದ ರಚನೆಯನ್ನು ನಿರ್ಧರಿಸಲು ಹೆಚ್ಚುವರಿ ಸಮಯವನ್ನು ವ್ಯಯಿಸಬೇಕಾಗುತ್ತದೆ.
ಸಂಚಿಕೆ 2: DELETE ಮೂಲಕ ಅಳಿಸಲಾದ ಸಾಲುಗಳು ಎಲ್ಲಾ ibd ಫೈಲ್‌ನಲ್ಲಿರುತ್ತವೆ, ಆದರೆ ALTER TABLE ನೊಂದಿಗೆ ಅವುಗಳ ರಚನೆಯನ್ನು ನವೀಕರಿಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕು. ಪರಿಣಾಮವಾಗಿ, ಡೇಟಾ ರಚನೆಯು ಫೈಲ್‌ನ ಪ್ರಾರಂಭದಿಂದ ಅದರ ಅಂತ್ಯದವರೆಗೆ ಬದಲಾಗಬಹುದು. ನೀವು ಆಗಾಗ್ಗೆ ಆಪ್ಟಿಮೈಜ್ ಟೇಬಲ್ ಅನ್ನು ಬಳಸಿದರೆ, ನೀವು ಅಂತಹ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸುವ ಸಾಧ್ಯತೆಯಿಲ್ಲ.
ಗಮನ ಕೊಡಿ, DBMS ಆವೃತ್ತಿಯು ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ವಿಧಾನದ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ ಮತ್ತು ಈ ಉದಾಹರಣೆಯು ಇತರ ಪ್ರಮುಖ ಆವೃತ್ತಿಗಳಿಗೆ ಕೆಲಸ ಮಾಡದಿರಬಹುದು. ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ, mariadb 10.1.24 ನ ವಿಂಡೋಸ್ ಆವೃತ್ತಿಯನ್ನು ಬಳಸಲಾಗಿದೆ. ಅಲ್ಲದೆ, mariadb ನಲ್ಲಿ ನೀವು InnoDB ಕೋಷ್ಟಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೂ, ವಾಸ್ತವವಾಗಿ ಅವುಗಳು , ಇದು InnoDB mysql ನೊಂದಿಗೆ ವಿಧಾನದ ಅನ್ವಯಿಸುವಿಕೆಯನ್ನು ಹೊರತುಪಡಿಸುತ್ತದೆ.
ಫೈಲ್ ವಿಶ್ಲೇಷಣೆ
ಪೈಥಾನ್‌ನಲ್ಲಿ, ಡೇಟಾ ಪ್ರಕಾರ ನಿಯಮಿತ ಸಂಖ್ಯೆಯ ಸಂಖ್ಯೆಗಳ ಸ್ಥಳದಲ್ಲಿ ಯುನಿಕೋಡ್ ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ನೀವು ಈ ಫಾರ್ಮ್‌ನಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ವೀಕ್ಷಿಸಬಹುದಾದರೂ, ಅನುಕೂಲಕ್ಕಾಗಿ ನೀವು ಬೈಟ್ ಅರೇ ಅನ್ನು ನಿಯಮಿತ ಅರೇ ಆಗಿ ಪರಿವರ್ತಿಸುವ ಮೂಲಕ ಬೈಟ್‌ಗಳನ್ನು ಸಂಖ್ಯಾ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಬಹುದು (ಪಟ್ಟಿ(ಉದಾಹರಣೆ_ಬೈಟ್_ಅರೇ)). ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ಎರಡೂ ವಿಧಾನಗಳು ವಿಶ್ಲೇಷಣೆಗೆ ಸೂಕ್ತವಾಗಿವೆ.
ಹಲವಾರು ibd ಫೈಲ್ಗಳನ್ನು ನೋಡಿದ ನಂತರ, ನೀವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಕಾಣಬಹುದು:
ಇದಲ್ಲದೆ, ನೀವು ಈ ಕೀವರ್ಡ್‌ಗಳಿಂದ ಫೈಲ್ ಅನ್ನು ಭಾಗಿಸಿದರೆ, ನೀವು ಹೆಚ್ಚಾಗಿ ಡೇಟಾ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಸಹ ಪಡೆಯುತ್ತೀರಿ. ನಾವು ಇನ್ಫಿಮಮ್ ಅನ್ನು ವಿಭಾಜಕವಾಗಿ ಬಳಸುತ್ತೇವೆ.
table = table.split("infimum".encode())ಒಂದು ಕುತೂಹಲಕಾರಿ ಅವಲೋಕನ: ಸಣ್ಣ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ಹೊಂದಿರುವ ಕೋಷ್ಟಕಗಳಿಗೆ, ಇನ್ಫಿಮಮ್ ಮತ್ತು ಸುಪ್ರೀಮಮ್ ನಡುವೆ ಬ್ಲಾಕ್ನಲ್ಲಿನ ಸಾಲುಗಳ ಸಂಖ್ಯೆಗೆ ಪಾಯಿಂಟರ್ ಇರುತ್ತದೆ.
- 1 ನೇ ಸಾಲನ್ನು ಹೊಂದಿರುವ ಪರೀಕ್ಷಾ ಕೋಷ್ಟಕ
- 2 ಸಾಲುಗಳೊಂದಿಗೆ ಪರೀಕ್ಷಾ ಕೋಷ್ಟಕ
ಸಾಲು ಅರೇ ಟೇಬಲ್[0] ಅನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು. ಅದರ ಮೂಲಕ ನೋಡಿದ ನಂತರ, ಕಚ್ಚಾ ಟೇಬಲ್ ಡೇಟಾವನ್ನು ಕಂಡುಹಿಡಿಯಲು ನನಗೆ ಇನ್ನೂ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. ಹೆಚ್ಚಾಗಿ, ಈ ಬ್ಲಾಕ್ ಅನ್ನು ಸೂಚ್ಯಂಕಗಳು ಮತ್ತು ಕೀಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
ಕೋಷ್ಟಕ[1] ದಿಂದ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಅದನ್ನು ಸಂಖ್ಯಾ ಸರಣಿಗೆ ಭಾಷಾಂತರಿಸಿದರೆ, ನೀವು ಈಗಾಗಲೇ ಕೆಲವು ಮಾದರಿಗಳನ್ನು ಗಮನಿಸಬಹುದು, ಅವುಗಳೆಂದರೆ:
ಇವು ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಇಂಟ್ ಮೌಲ್ಯಗಳಾಗಿವೆ. ಮೊದಲ ಬೈಟ್ ಸಂಖ್ಯೆ ಧನಾತ್ಮಕ ಅಥವಾ ಋಣಾತ್ಮಕ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ. ನನ್ನ ವಿಷಯದಲ್ಲಿ, ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳು ಸಕಾರಾತ್ಮಕವಾಗಿವೆ. ಉಳಿದ 3 ಬೈಟ್‌ಗಳಿಂದ, ಈ ಕೆಳಗಿನ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ಧರಿಸಬಹುದು. ಸ್ಕ್ರಿಪ್ಟ್:
def find_int(val: str): # example '128, 1, 2, 3'
val = [int(v) for v in val.split(", ")]
result_int = val[1]*256**2 + val[2]*256*1 + val[3]
return result_intಉದಾಹರಣೆಗೆ, 128, 0, 0, 1 = 1ಅಥವಾ 128, 0, 75, 108 = 19308.
ಟೇಬಲ್ ಸ್ವಯಂ ಹೆಚ್ಚಳದೊಂದಿಗೆ ಪ್ರಾಥಮಿಕ ಕೀಲಿಯನ್ನು ಹೊಂದಿತ್ತು ಮತ್ತು ಅದನ್ನು ಇಲ್ಲಿಯೂ ಕಾಣಬಹುದು
ಪರೀಕ್ಷಾ ಕೋಷ್ಟಕಗಳಿಂದ ಡೇಟಾವನ್ನು ಹೋಲಿಸಿದ ನಂತರ, DATETIME ಆಬ್ಜೆಕ್ಟ್ 5 ಬೈಟ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಮತ್ತು 153 ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಯಿತು (ಹೆಚ್ಚಾಗಿ ವಾರ್ಷಿಕ ಮಧ್ಯಂತರಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ). DATTIME ಶ್ರೇಣಿಯು '1000-01-01' ರಿಂದ '9999-12-31' ಆಗಿರುವುದರಿಂದ, ಬೈಟ್‌ಗಳ ಸಂಖ್ಯೆಯು ಬದಲಾಗಬಹುದು ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಆದರೆ ನನ್ನ ವಿಷಯದಲ್ಲಿ, ಡೇಟಾವು 2016 ರಿಂದ 2019 ರ ಅವಧಿಯಲ್ಲಿ ಬರುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ಊಹಿಸುತ್ತೇವೆ 5 ಬೈಟ್‌ಗಳು ಸಾಕು.
ಸೆಕೆಂಡುಗಳಿಲ್ಲದೆ ಸಮಯವನ್ನು ನಿರ್ಧರಿಸಲು, ಕೆಳಗಿನ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಲಾಗಿದೆ. ಸ್ಕ್ರಿಪ್ಟ್:
day_ = lambda x: x % 64 // 2 # {x,x,X,x,x }
def hour_(x1, x2): # {x,x,X1,X2,x}
if x1 % 2 == 0:
return x2 // 16
elif x1 % 2 == 1:
return x2 // 16 + 16
else:
raise ValueError
min_ = lambda x1, x2: (x1 % 16) * 4 + (x2 // 64) # {x,x,x,X1,X2}ವರ್ಷ ಮತ್ತು ತಿಂಗಳಿಗೆ ಕ್ರಿಯಾತ್ಮಕ ಕಾರ್ಯವನ್ನು ಬರೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ಅದನ್ನು ಹ್ಯಾಕ್ ಮಾಡಬೇಕಾಗಿತ್ತು. ಸ್ಕ್ರಿಪ್ಟ್:
ym_list = {'2016, 1': '153, 152, 64', '2016, 2': '153, 152, 128',
'2016, 3': '153, 152, 192', '2016, 4': '153, 153, 0',
'2016, 5': '153, 153, 64', '2016, 6': '153, 153, 128',
'2016, 7': '153, 153, 192', '2016, 8': '153, 154, 0',
'2016, 9': '153, 154, 64', '2016, 10': '153, 154, 128',
'2016, 11': '153, 154, 192', '2016, 12': '153, 155, 0',
'2017, 1': '153, 155, 128', '2017, 2': '153, 155, 192',
'2017, 3': '153, 156, 0', '2017, 4': '153, 156, 64',
'2017, 5': '153, 156, 128', '2017, 6': '153, 156, 192',
'2017, 7': '153, 157, 0', '2017, 8': '153, 157, 64',
'2017, 9': '153, 157, 128', '2017, 10': '153, 157, 192',
'2017, 11': '153, 158, 0', '2017, 12': '153, 158, 64',
'2018, 1': '153, 158, 192', '2018, 2': '153, 159, 0',
'2018, 3': '153, 159, 64', '2018, 4': '153, 159, 128',
'2018, 5': '153, 159, 192', '2018, 6': '153, 160, 0',
'2018, 7': '153, 160, 64', '2018, 8': '153, 160, 128',
'2018, 9': '153, 160, 192', '2018, 10': '153, 161, 0',
'2018, 11': '153, 161, 64', '2018, 12': '153, 161, 128',
'2019, 1': '153, 162, 0', '2019, 2': '153, 162, 64',
'2019, 3': '153, 162, 128', '2019, 4': '153, 162, 192',
'2019, 5': '153, 163, 0', '2019, 6': '153, 163, 64',
'2019, 7': '153, 163, 128', '2019, 8': '153, 163, 192',
'2019, 9': '153, 164, 0', '2019, 10': '153, 164, 64',
'2019, 11': '153, 164, 128', '2019, 12': '153, 164, 192',
'2020, 1': '153, 165, 64', '2020, 2': '153, 165, 128',
'2020, 3': '153, 165, 192','2020, 4': '153, 166, 0',
'2020, 5': '153, 166, 64', '2020, 6': '153, 1, 128',
'2020, 7': '153, 166, 192', '2020, 8': '153, 167, 0',
'2020, 9': '153, 167, 64','2020, 10': '153, 167, 128',
'2020, 11': '153, 167, 192', '2020, 12': '153, 168, 0'}
def year_month(x1, x2): # {x,X,X,x,x }
for key, value in ym_list.items():
key = [int(k) for k in key.replace("'", "").split(", ")]
value = [int(v) for v in value.split(", ")]
if x1 == value[1] and x2 // 64 == value[2] // 64:
return key
return 0, 0ನೀವು ಸಾಕಷ್ಟು ಸಮಯವನ್ನು ಕಳೆದರೆ, ಈ ತಪ್ಪು ತಿಳುವಳಿಕೆಯನ್ನು ಸರಿಪಡಿಸಬಹುದು ಎಂದು ನನಗೆ ಖಾತ್ರಿಯಿದೆ.
ಮುಂದೆ, ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ದಿನಾಂಕದ ಸಮಯದ ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುವ ಕಾರ್ಯ. ಸ್ಕ್ರಿಪ್ಟ್:
def find_data_time(val:str):
val = [int(v) for v in val.split(", ")]
day = day_(val[2])
hour = hour_(val[2], val[3])
minutes = min_(val[3], val[4])
year, month = year_month(val[1], val[2])
return datetime(year, month, day, hour, minutes)ಇಂಟ್, ಇಂಟ್, ಡೇಟ್‌ಟೈಮ್, ಡೇಟ್‌ಟೈಮ್‌ನಿಂದ ಆಗಾಗ್ಗೆ ಪುನರಾವರ್ತಿತ ಮೌಲ್ಯಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ನಿರ್ವಹಿಸಲಾಗಿದೆ , ಇದು ನಿಮಗೆ ಬೇಕಾಗಿರುವುದು ತೋರುತ್ತಿದೆ. ಇದಲ್ಲದೆ, ಅಂತಹ ಅನುಕ್ರಮವು ಪ್ರತಿ ಸಾಲಿಗೆ ಎರಡು ಬಾರಿ ಪುನರಾವರ್ತನೆಯಾಗುವುದಿಲ್ಲ.
ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿ ಬಳಸಿ, ನಾವು ಅಗತ್ಯ ಡೇಟಾವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ:
fined = re.findall(r'128, d*, d*, d*, 128, d*, d*, d*, 153, 1[6,5,4,3]d, d*, d*, d*, 153, 1[6,5,4,3]d, d*, d*, d*', int_array)ಈ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಹುಡುಕುವಾಗ, ಅಗತ್ಯವಿರುವ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ NULL ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಆದರೆ ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ ಇದು ನಿರ್ಣಾಯಕವಲ್ಲ. ನಂತರ ನಾವು ಲೂಪ್ನಲ್ಲಿ ಕಂಡುಕೊಂಡದ್ದನ್ನು ನಾವು ಹಾದು ಹೋಗುತ್ತೇವೆ. ಸ್ಕ್ರಿಪ್ಟ್:
result = []
for val in fined:
pre_result = []
bd_int = re.findall(r"128, d*, d*, d*", val)
bd_date= re.findall(r"(153, 1[6,5,4,3]d, d*, d*, d*)", val)
for it in bd_int:
pre_result.append(find_int(bd_int[it]))
for bd in bd_date:
pre_result.append(find_data_time(bd))
result.append(pre_result)ವಾಸ್ತವವಾಗಿ, ಅಷ್ಟೆ, ಫಲಿತಾಂಶದ ರಚನೆಯಿಂದ ಡೇಟಾ ನಮಗೆ ಅಗತ್ಯವಿರುವ ಡೇಟಾ. ###PS.###
ಈ ವಿಧಾನವು ಎಲ್ಲರಿಗೂ ಸೂಕ್ತವಲ್ಲ ಎಂದು ನಾನು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೇನೆ, ಆದರೆ ಲೇಖನದ ಮುಖ್ಯ ಗುರಿ ನಿಮ್ಮ ಎಲ್ಲಾ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವ ಬದಲು ತ್ವರಿತ ಕ್ರಮವಾಗಿದೆ. ಮೂಲ ಕೋಡ್ ಅನ್ನು ನೀವೇ ಅಧ್ಯಯನ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುವುದು ಅತ್ಯಂತ ಸರಿಯಾದ ಪರಿಹಾರವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ , ಆದರೆ ಸೀಮಿತ ಸಮಯದ ಕಾರಣ, ಪ್ರಸ್ತುತ ವಿಧಾನವು ವೇಗವಾಗಿದೆ ಎಂದು ತೋರುತ್ತಿದೆ.
ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಫೈಲ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸಿದ ನಂತರ, ನೀವು ಅಂದಾಜು ರಚನೆಯನ್ನು ನಿರ್ಧರಿಸಲು ಮತ್ತು ಮೇಲಿನ ಲಿಂಕ್‌ಗಳಿಂದ ಪ್ರಮಾಣಿತ ವಿಧಾನಗಳಲ್ಲಿ ಒಂದನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಮರುಸ್ಥಾಪಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಇದು ಹೆಚ್ಚು ಸರಿಯಾಗಿರುತ್ತದೆ ಮತ್ತು ಕಡಿಮೆ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.
ಮೂಲ: www.habr.com