පයිතන් හි ගොනු සෑදීම සහ වෙනස් කිරීමේ දිනය / වේලාවන් ලබා ගන්නේ කෙසේද?

මා සතුව ස්ක්‍රිප්ට් එකක් ඇත, එය ගොනු සෑදීම සහ වෙනස් කිරීමේ දිනයන් මත පදනම්ව යම් යම් දේ කිරීමට අවශ්‍ය නමුත් ලිනක්ස් සහ වින්ඩෝස් මත ධාවනය කළ යුතුය.

පයිතන් හි ගොනු සෑදීම සහ වෙනස් කිරීම ලබා ගැනීමට ඇති හොඳම හරස් වේදිකා ක්‍රමය කුමක්ද?date/times

හරස් වේදිකා ආකාරයෙන් යම් ආකාරයක වෙනස් කිරීමේ දිනයක් ලබා ගැනීම පහසුය - අමතන්න , එවිට ගොනුව අවසන් වරට වෙනස් කළ විට ඔබට යුනික්ස් කාලරාමුව ලැබෙනු ඇත .os.path.getmtime(path)path

අනෙක් අතට, ගොනු නිර්මාණය කිරීමේ දිනයන් ලබා ගැනීම විචක්ෂණශීලී හා වේදිකාව මත රඳා පවතින අතර විශාල මෙහෙයුම් පද්ධති තුන අතර පවා වෙනස් වේ:

• මත වින්ඩෝස් , ගොනු ගේ ctime(දී ලේඛනගත https://msdn.microsoft.com/en-us/library/14h5k7ff.aspx ) එහි නිර්මාණය දිනය ගබඩා. ඔබ තුළින් Python මෙම ප්රවේශ විය හැකි os.path.getctime()හෝ .st_ctimeඇමතුමක් ප්රතිඵලයක් වන විශේෂණය os.stat(). මෙය යුනික්ස් හි ක්‍රියා නොකරනු ඇත, එහිදී ctime ගොනුවේ ගුණාංග හෝ අන්තර්ගතය වෙනස් කළ අවසන් අවස්ථාව මෙයයි .
• මත මැක් , හොඳින් වෙනත් යුනික්ස් මත පදනම් වූ OSes ලෙස, ඔබ භාවිතා කළ හැකිය .st_birthtimeවෙත දුරකථන ඇමතුමක් ප්රතිඵලයක් වන විශේෂණය os.stat().

• මත ලිනක්ස් , මේ වන විට කිසි විටෙකත් විය නොහැකි, අවම වශයෙන් Python සඳහා සී දීර්ඝ ලියන තොරව ය. ලිනක්ස් සමඟ බහුලව භාවිතා වන සමහර ගොනු පද්ධති ගබඩා කිරීමේ දිනයන් ගබඩා කරයි (නිදසුනක් ලෙස, ext4ඒවා ගබඩා කරයි st_crtime), ලිනක්ස් කර්නලය ඒවාට ප්‍රවේශ වීමට ක්‍රමයක් ඉදිරිපත් නොකරයි ; විශේෂයෙන්, stat()C හි ඇමතුම් වලින් ලැබෙන ව්‍යුහයන් , නවතම කර්නල් අනුවාදයට අනුව, කිසිදු නිර්මාණ දින ක්ෂේත්‍රයක් අඩංගු නොවේ . හඳුනාගැනීමේ st_crtimeයන්ත්‍රය දැනට පයිතන් ප්‍රභවයේ කොතැනකවත් නොපෙන්වන බව ඔබට දැක ගත හැකිය . අවම වශයෙන් ඔබ මත ඉන්නේ නම් ext4, දත්ත ඇත ගොනු පද්ධතිය තුළ inodes අනුයුක්ත, නමුත් එය ප්රවේශ කිසිදු පහසු විදිහක් නැහැ.

  ලිනක්ස් මත ඉදිරි-හොඳම දේ මගින් ගොනුවේ ප්රවේශ වේ mtimeතුලින්, os.path.getmtime()එම හෝ .st_mtimeආයතනයකට විශේෂණය os.stat()ප්රතිඵලයක්. ගොනුවේ අන්තර්ගතය වෙනස් කරන ලද අවසාන අවස්ථාව මෙය ඔබට ලබා දෙනු ඇත, සමහර භාවිත අවස්ථා සඳහා එය ප්‍රමාණවත් විය හැකිය.

මේ සියල්ල එකට ගත් විට, හරස් වේදිකා කේතය මේ වගේ දෙයක් විය යුතුයි ...

import os
import platform

def creation_date(path_to_file):
    """
    Try to get the date that a file was created, falling back to when it was
    last modified if that isn't possible.
    See http://stackoverflow.com/a/39501288/1709587 for explanation.
    """
    if platform.system() == 'Windows':
        return os.path.getctime(path_to_file)
    else:
        stat = os.stat(path_to_file)
        try:
            return stat.st_birthtime
        except AttributeError:
            # We're probably on Linux. No easy way to get creation dates here,
            # so we'll settle for when its content was last modified.
            return stat.st_mtime

ඔබට තේරීම් කිහිපයක් තිබේ. එකක් සඳහා, ඔබට os.path.getmtimeසහ os.path.getctimeකාර්යයන් භාවිතා කළ හැකිය :

import os.path, time
print("last modified: %s" % time.ctime(os.path.getmtime(file)))
print("created: %s" % time.ctime(os.path.getctime(file)))

ඔබේ අනෙක් විකල්පය භාවිතා කිරීම os.stat:

import os, time
(mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(file)
print("last modified: %s" % time.ctime(mtime))

සටහන : ctime()නැත නැත * nix පද්ධති මත නිර්මාණය කාලය යොමු, ඒ වෙනුවට, පසුගිය කාලය inode දත්ත වෙනස් විය. (සිත්ගන්නාසුලු බ්ලොග් සටහනකට සබැඳියක් ලබා දීමෙන් කොජිරෝට එම කරුණ වඩාත් පැහැදිලිව දැක්වීම ගැන ස්තූතියි)

මේ සඳහා භාවිතා කළ හැකි හොඳම කාර්යය වන්නේ os.path.getmtime () ය . අභ්‍යන්තරව, මෙය භාවිතා කරයි os.stat(filename).st_mtime.

දිවා කාල මොඩියුලය හොඳම හැසිරවීමේ කාලරාමු වේ, එබැවින් ඔබට වෙනස් කිරීමේ දිනය datetimeමෙවැනි වස්තුවක් ලෙස ලබා ගත හැකිය :

import os
import datetime
def modification_date(filename):
    t = os.path.getmtime(filename)
    return datetime.datetime.fromtimestamp(t)

භාවිත උදාහරණය:

>>> d = modification_date('/var/log/syslog')
>>> print d
2009-10-06 10:50:01
>>> print repr(d)
datetime.datetime(2009, 10, 6, 10, 50, 1)

os.stat https://docs.python.org/2/library/stat.html#module-stat

සංස්කරණය කරන්න: නව කේතයෙන් ඔබ බොහෝ විට භාවිතා කළ යුත්තේ os.path.getmtime () (ස්තූතියි ක්‍රිස්ටියන් ඕඩාර්ඩ්)
නමුත් එය තත්පර තත්පරයකින් time_t හි පාවෙන ලක්ෂ්‍ය අගයක් ලබා දෙන බව සලකන්න (ඔබේ මෙහෙයුම් පද්ධතිය එයට සහය දක්වන්නේ නම්)

මෝඩ් වේලාව ලබා ගැනීමට ක්‍රම දෙකක් තිබේ, os.path.getmtime () හෝ os.stat (), නමුත් ctime විශ්වාසදායක හරස් වේදිකාවක් නොවේ (පහත බලන්න).

os.path.getmtime ()

getmtime ( path ) මාර්ගය
අවසන් වරට වෙනස් කළ කාලය නැවත ලබා දෙන්න. ප්‍රතිලාභ අගය යනු යුගයේ සිට තත්පර ගණනක් ලබා දෙන අංකයකි (කාල මොඩියුලය බලන්න). ගොනුව නොපවතී නම් හෝ ප්‍රවේශ විය නොහැකි නම් os.error මතු කරන්න. 1.5.2 අනුවාදයේ නව. 2.3 අනුවාදයේ වෙනස් කර ඇත: os.stat_float_times () සත්‍ය නම්, ප්‍රති result ලය පාවෙන ලක්ෂ්‍ය අංකයකි.

os.stat ()

stat ( path ) දී ඇති මාර්ගයේ
stat () පද්ධති ඇමතුමක් සිදු කරන්න. ප්‍රතිලාභ අගය යනු සංඛ්‍යා ව්‍යුහයේ සාමාජිකයන්ට අනුරූප වන වස්තුවකි, එනම්: st_mode (ආරක්ෂණ බිටු), st_ino (ඉනෝඩ් අංකය), st_dev (උපාංගය), st_nlink (දෘ link සබැඳි ගණන), st_uid (හිමිකරුගේ පරිශීලක හැඳුනුම්පත) ), st_gid (අයිතිකරුගේ කණ්ඩායම් හැඳුනුම්පත), st_size (ගොනුවේ ප්‍රමාණය, බයිට් වලින්), st_atime (නවතම ප්‍රවේශයේ වේලාව ), st_mtime (නවතම අන්තර්ගත වෙනස් කිරීමේ කාලය), st_ctime (වේදිකාව මත රඳා පවතී; නවතම පාර-දත්ත වෙනස් වීමේ කාලය) යුනික්ස් මත හෝ වින්ඩෝස් හි නිර්මාණය කරන වේලාව) :

>>> import os
>>> statinfo = os.stat('somefile.txt')
>>> statinfo
(33188, 422511L, 769L, 1, 1032, 100, 926L, 1105022698,1105022732, 1105022732)
>>> statinfo.st_size
926L
>>> 

ඉහත උදාහරණයේ දී ඔබ පිළිවෙලින් mtime සහ ctime ලබා ගැනීම සඳහා statinfo.st_mtime හෝ statinfo.st_ctime භාවිතා කරනු ඇත.

පයිතන් 3.4 සහ ඊට ඉහළින්, ඔබට බොහෝ මොඩියුලය සඳහා ආවරණ ඇතුළත් වස්තු දිශානත පාත්ලිබ් මොඩියුල අතුරුමුහුණත භාවිතා කළ හැකිය . ගොනු සංඛ්‍යාලේඛන ලබා ගැනීම සඳහා උදාහරණයක් මෙන්න.

>>> import pathlib
>>> fname = pathlib.Path('test.py')
>>> assert fname.exists(), f'No such file: {fname}'  # check that the file exists
>>> print(fname.stat())
os.stat_result(st_mode=33206, st_ino=5066549581564298, st_dev=573948050, st_nlink=1, st_uid=0, st_gid=0, st_size=413, st_atime=1523480272, st_mtime=1539787740, st_ctime=1523480272)

os.stat_resultඅඩංගු දේ පිළිබඳ වැඩි විස්තර සඳහා , ප්‍රලේඛනය වෙත යොමු වන්න . ඔබට අවශ්‍ය වෙනස් කිරීමේ කාලය සඳහා fname.stat().st_mtime:

>>> import datetime
>>> mtime = datetime.datetime.fromtimestamp(fname.stat().st_mtime)
>>> print(mtime)
datetime.datetime(2018, 10, 17, 10, 49, 0, 249980)

ඔබට වින්ඩෝස් හි නිර්මාණ කාලය හෝ යුනික්ස් හි නවතම පාර-දත්ත වෙනස් කිරීම අවශ්‍ය නම්, ඔබ භාවිතා කරන්නේ fname.stat().st_ctime:

>>> ctime = datetime.datetime.fromtimestamp(fname.stat().st_ctime)
>>> print(ctime)
datetime.datetime(2018, 4, 11, 16, 57, 52, 151953)

මෙම ලිපියේ වඩාත් ප්‍රයෝජනවත් තොරතුරු සහ පාත්ලිබ් මොඩියුලය සඳහා උදාහරණ ඇත.

import os, time, datetime

file = "somefile.txt"
print(file)

print("Modified")
print(os.stat(file)[-2])
print(os.stat(file).st_mtime)
print(os.path.getmtime(file))

print()

print("Created")
print(os.stat(file)[-1])
print(os.stat(file).st_ctime)
print(os.path.getctime(file))

print()

modified = os.path.getmtime(file)
print("Date modified: "+time.ctime(modified))
print("Date modified:",datetime.datetime.fromtimestamp(modified))
year,month,day,hour,minute,second=time.localtime(modified)[:-3]
print("Date modified: %02d/%02d/%d %02d:%02d:%02d"%(day,month,year,hour,minute,second))

print()

created = os.path.getctime(file)
print("Date created: "+time.ctime(created))
print("Date created:",datetime.datetime.fromtimestamp(created))
year,month,day,hour,minute,second=time.localtime(created)[:-3]
print("Date created: %02d/%02d/%d %02d:%02d:%02d"%(day,month,year,hour,minute,second))

මුද්රණ

somefile.txt
Modified
1429613446
1429613446.0
1429613446.0

Created
1517491049
1517491049.28306
1517491049.28306

Date modified: Tue Apr 21 11:50:46 2015
Date modified: 2015-04-21 11:50:46
Date modified: 21/04/2015 11:50:46

Date created: Thu Feb  1 13:17:29 2018
Date created: 2018-02-01 13:17:29.283060
Date created: 01/02/2018 13:17:29

os.statනම් කර ඇති ටුපල් එකක් st_mtimeසහ st_ctimeගුණාංග සමඟ ආපසු එයි . වෙනස් කිරීමේ කාලය st_mtimeවේදිකා දෙකෙහිම ඇත; අවාසනාවකට මෙන්, වින්ඩෝස් හි ctime"නිර්මාණ කාලය" යන්නෙන් අදහස් වන අතර පොසික්ස් හි එහි තේරුම "කාලය වෙනස් කිරීම" යන්නයි. POSIX වේදිකාවල නිර්මාණ කාලය ලබා ගත හැකි ක්‍රමයක් ගැන මම නොදනිමි.

>>> import os
>>> os.stat('feedparser.py').st_mtime
1136961142.0
>>> os.stat('feedparser.py').st_ctime
1222664012.233
>>> 

සංකේතාත්මක සබැඳි අනුගමනය කිරීම වැදගත් නොවේ නම්, ඔබට os.lstatබිල්ඩින් ද භාවිතා කළ හැකිය .

>>> os.lstat("2048.py")
posix.stat_result(st_mode=33188, st_ino=4172202, st_dev=16777218L, st_nlink=1, st_uid=501, st_gid=20, st_size=2078, st_atime=1423378041, st_mtime=1423377552, st_ctime=1423377553)
>>> os.lstat("2048.py").st_atime
1423378041.0

crtimeගොනු නිර්මාණය කිරීමේ වේලාවට හරස් වේදිකා ප්‍රවේශය ක්‍රියාත්මක කරන පුස්තකාලය දෙස බැලීම වටී .

from crtime import get_crtimes_in_dir

for fname, date in get_crtimes_in_dir(".", raise_on_error=True, as_epoch=False):
    print(fname, date)
    # file_a.py Mon Mar 18 20:51:18 CET 2019

os.statනිර්මාණ කාලය ඇතුළත් වේ. එහි මූලද්‍රව්‍යය සඳහා st_anything පිළිබඳ අර්ථ දැක්වීමක් නොමැත os.stat().

එබැවින් මෙය උත්සාහ කරන්න:

os.stat('feedparser.py')[8]

Ls -lah හි ඇති ගොනුවේ ඔබ නිර්මාණය කළ දිනය සමඟ සසඳන්න

ඒවා සමාන විය යුතුය.

පද්ධතියේ stat විධානය ක්‍රියාත්මක කිරීමෙන් සහ ප්‍රතිදානය විග්‍රහ කිරීමෙන් මට පොසික්ස් මත නිර්මාණ කාලය ලබා ගැනීමට හැකි විය.

commands.getoutput('stat FILENAME').split('\"')[7]

ටර්මිනල් (ඕඑස් එක්ස්) වෙතින් පයිතන්ට පිටතින් ධාවනය වන සංඛ්‍යාව ආපසු:

805306374 3382786932 -rwx------ 1 km staff 0 1098083 "Aug 29 12:02:05 2013" "Aug 29 12:02:05 2013" "Aug 29 12:02:20 2013" "Aug 27 12:35:28 2013" 61440 2150 0 testfile.txt

... මෙහි සිව්වන දිවා කාලය ගොනු නිර්මාණය වේ (වෙනත් අදහස් සටහන් කර ඇති පරිදි වේලාව වෙනස් කිරීමට වඩා).