ਪਾਈਥਨ 3 ਵਿੱਚ ਸਮਾਂ ਮੋਡੀਊਲ। ਮੁੱਖ ਢੰਗ, ਨਮੂਨੇ, ਉਦਾਹਰਨਾਂ

ਲਗਭਗ ਕੋਈ ਵੀ ਪ੍ਰੋਗਰਾਮ ਸਮੇਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ, ਇਸਦੇ ਲਈ ਇੱਕ ਵੱਖਰੀ ਲਾਇਬ੍ਰੇਰੀ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ - ਵਾਰਇਸ ਨਾਲ ਕਈ ਤਰ੍ਹਾਂ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸਨੂੰ ਕੰਮ ਕਰਨ ਲਈ, ਇਸਨੂੰ ਪਹਿਲਾਂ ਕੋਡ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਲਾਈਨ ਇਸ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ:

ਆਯਾਤ ਦਾ ਸਮਾਂ

ਆਉ ਇਸ ਮੋਡੀਊਲ ਨੂੰ ਅਭਿਆਸ ਵਿੱਚ ਸਹੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ ਇਸ ਬਾਰੇ ਵੱਖ-ਵੱਖ ਵਿਕਲਪਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰੀਏ। 

ਯੁਗ ਤੋਂ ਲੈ ਕੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਪਤਾ ਲਗਾਉਣਾ

ਇਸ ਕੰਮ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ, ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਵਾਰ() ਜੋ ਕੋਈ ਪੈਰਾਮੀਟਰ ਨਹੀਂ ਲੈਂਦਾ। ਇਸਦਾ ਵਾਪਸੀ ਮੁੱਲ ਇਹ ਹੈ ਕਿ 1 ਜਨਵਰੀ, 1970 ਤੋਂ ਕਿੰਨੇ ਸਕਿੰਟ ਲੰਘੇ ਹਨ। ਪਾਈਥਨ ਵਿੱਚ, ਇਸ ਸਮੇਂ ਨੂੰ ਇੱਕ ਯੁੱਗ ਦੀ ਸ਼ੁਰੂਆਤ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਘੱਟੋ-ਘੱਟ ਯੂਨਿਕਸ ਪਰਿਵਾਰ ਦੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਵਿੱਚ।

ਵਿੰਡੋਜ਼ ਲਈ, ਮਿਤੀ ਉਹੀ ਹੈ, ਪਰ ਨਕਾਰਾਤਮਕ ਮੁੱਲਾਂ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜੋ ਇਸ ਮਿਤੀ ਤੋਂ ਪਹਿਲਾਂ ਸਨ. 

ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਸਮਾਂ ਖੇਤਰ UTC ਹੈ।

ਆਯਾਤ ਦਾ ਸਮਾਂ

ਸਕਿੰਟ = time.time()

ਪ੍ਰਿੰਟ ("ਯੁਗ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟ =", ਸਕਿੰਟ)

ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਗੁੰਝਲਤਾ ਇਹ ਹੈ ਕਿ ਇਹ ਬਿਲਕੁਲ ਤਾਰੀਖ ਨਹੀਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਪਰ ਸਿਰਫ ਸਕਿੰਟਾਂ ਦੀ ਸੰਖਿਆ। ਹਰ ਕਿਸੇ ਲਈ ਜਾਣੂ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣ ਲਈ, ਤੁਹਾਨੂੰ ਸਹੀ ਜਾਣਕਾਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਸਦੇ ਲਈ, ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ time.ctime()।

ਆਮ ਫਾਰਮੈਟ ਵਿੱਚ ਮਿਤੀ, ਸਮਾਂ ਵਾਪਸ ਕਰਨਾ

ਆਮ ਫਾਰਮੈਟ ਵਿੱਚ ਵਾਰ ਵਾਪਸ ਕਰਨ ਲਈ, ਇੱਕ ਢੰਗ ਹੈ time.ctime()। ਬਰੈਕਟਸ ਇੱਕ ਵੇਰੀਏਬਲ ਜਾਂ ਸੰਖਿਆ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ ਜੋ ਯੁੱਗ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਬਾਅਦ ਬੀਤ ਚੁੱਕੇ ਸਕਿੰਟਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ। ਇਹ ਵਿਧੀ ਮਿਤੀ, ਸਾਲ, ਘੰਟਿਆਂ ਦੀ ਗਿਣਤੀ, ਮਿੰਟ, ਸਕਿੰਟ ਅਤੇ ਹਫ਼ਤੇ ਦੇ ਦਿਨ ਸਮੇਤ ਸਾਰੀਆਂ ਮਿਤੀਆਂ ਅਤੇ ਸਮੇਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਵਾਪਸ ਕਰਦੀ ਹੈ।

ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਆਰਗੂਮੈਂਟ ਤੋਂ ਬਿਨਾਂ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇਹ ਮੌਜੂਦਾ ਮਿਤੀ, ਸਮਾਂ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਹੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਇੱਥੇ ਇੱਕ ਕੋਡ ਸਨਿੱਪਟ ਹੈ ਜੋ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ।

ਆਯਾਤ ਦਾ ਸਮਾਂ

ਪ੍ਰਿੰਟ(time.ctime())

ਮੰਗਲਵਾਰ 23 ਅਕਤੂਬਰ 10:18:23 2018

ਆਖਰੀ ਲਾਈਨ ਉਹ ਹੈ ਜੋ ਕੰਸੋਲ ਤੇ ਛਾਪੀ ਜਾਂਦੀ ਹੈ ਜਿੱਥੇ ਪਾਈਥਨ ਇੰਟਰਪ੍ਰੇਟਰ ਚੱਲ ਰਿਹਾ ਹੈ। ਵਿਧੀ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਪ੍ਰਾਪਤ ਕੀਤੇ ਸਕਿੰਟਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਉਪਭੋਗਤਾ-ਜਾਣੂ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰਦੀ ਹੈ। ਇਹ ਸੱਚ ਹੈ ਕਿ ਉੱਪਰ ਦੱਸੇ ਗਏ ਸਾਰੇ ਤੱਤ ਘੱਟ ਹੀ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਇੱਕ ਨਿਯਮ ਦੇ ਤੌਰ 'ਤੇ, ਤੁਹਾਨੂੰ ਜਾਂ ਤਾਂ ਸਿਰਫ ਸਮਾਂ, ਜਾਂ ਸਿਰਫ ਅੱਜ ਦੀ ਮਿਤੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਇਸਦੇ ਲਈ, ਇੱਕ ਵੱਖਰਾ ਫੰਕਸ਼ਨ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ - strftime(). ਪਰ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਇਸ 'ਤੇ ਵਿਚਾਰ ਕਰੀਏ, ਸਾਨੂੰ ਕਲਾਸ ਨੂੰ ਪਾਰਸ ਕਰਨ ਦੀ ਲੋੜ ਹੈ time.struct_time।

class time.struct_time

ਇਹ ਦਲੀਲਾਂ ਦੀ ਇੱਕ ਸ਼੍ਰੇਣੀ ਹੈ ਜੋ ਕਈ ਤਰੀਕਿਆਂ ਦੁਆਰਾ ਸਵੀਕਾਰ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਇਸ ਕੋਲ ਕੋਈ ਵਿਕਲਪ ਨਹੀਂ ਹਨ। ਇਹ ਇੱਕ ਨਾਮਿਤ ਇੰਟਰਫੇਸ ਦੇ ਨਾਲ ਇੱਕ ਟੂਪਲ ਹੈ। ਸਾਦੇ ਸ਼ਬਦਾਂ ਵਿਚ, ਇਸ ਸ਼੍ਰੇਣੀ ਦੇ ਤੱਤਾਂ ਨੂੰ ਨਾਮ ਅਤੇ ਸੂਚਕਾਂਕ ਨੰਬਰ ਦੋਵਾਂ ਦੁਆਰਾ ਐਕਸੈਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਇਸ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਗੁਣ ਹੁੰਦੇ ਹਨ।

ਧਿਆਨ ਦਿਓ! ਕਈ ਹੋਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਦੇ ਉਲਟ, ਇੱਥੇ ਮਹੀਨਾ 1 ਤੋਂ 12 ਤੱਕ ਹੋ ਸਕਦਾ ਹੈ, ਨਾ ਕਿ ਜ਼ੀਰੋ ਤੋਂ 11 ਤੱਕ।

ਇੱਕ ਖਾਸ ਫਾਰਮੈਟ ਵਾਪਸ ਕਰਨਾ

ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ strftime() ਤੁਸੀਂ ਸਾਲ, ਮਹੀਨਾ, ਦਿਨ, ਘੰਟਾ, ਮਿੰਟ, ਸਕਿੰਟ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਟੈਕਸਟ ਸਤਰ ਵਿੱਚ ਵਾਪਸ ਕਰ ਸਕਦੇ ਹੋ। ਫਿਰ ਇਸਨੂੰ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਛਾਪੋ () ਜਾਂ ਹੋਰ ਕਾਰਵਾਈ ਕੀਤੀ.

ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ ਤੇ, ਇੱਕ ਫੰਕਸ਼ਨ ਕੋਈ ਵੀ ਵੇਰੀਏਬਲ ਲੈ ਸਕਦਾ ਹੈ ਜੋ ਇਸ ਮੋਡੀਊਲ ਦੇ ਹੋਰ ਫੰਕਸ਼ਨਾਂ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਮੁੱਲ ਨੂੰ ਲੈਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਸਥਾਨਕ ਸਮੇਂ ਨੂੰ ਇਸ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰ ਸਕਦੇ ਹੋ (ਇਸ ਬਾਰੇ ਬਾਅਦ ਵਿੱਚ ਚਰਚਾ ਕੀਤੀ ਜਾਵੇਗੀ), ਜਿਸ ਤੋਂ ਇਹ ਲੋੜੀਂਦੇ ਡੇਟਾ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ.

ਇੱਥੇ ਕੋਡ ਸਨਿੱਪਟ ਹੈ ਜਿੱਥੇ ਅਸੀਂ ਇਸਨੂੰ ਕਰਦੇ ਹਾਂ।

ਆਯਾਤ ਦਾ ਸਮਾਂ

name_tuple = time.localtime() # struct_time ਪ੍ਰਾਪਤ ਕਰੋ

time_string = time.strftime(«%m/%d/%Y, %H:%M:%S», name_tuple)

ਪ੍ਰਿੰਟ(ਟਾਈਮ_ਸਟ੍ਰਿੰਗ)

ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਮੌਜੂਦਾ ਮਿਤੀ ਅਤੇ ਸਮਾਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। ਤੱਤਾਂ ਦਾ ਫਾਰਮੈਟ ਅਤੇ ਕ੍ਰਮ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਉਹ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹਨ:

1. %Y ਸਾਲ ਹੈ।
2. %m ਮਹੀਨਾ ਹੈ।
3. %d – ਦਿਨ।
4. % H - ਸਮਾਂ।
5. %M – ਮਿੰਟ।
6. %S - ਸਕਿੰਟ।

ਇਸ ਅਨੁਸਾਰ, ਤੁਸੀਂ ਇਸਨੂੰ ਬਣਾ ਸਕਦੇ ਹੋ ਤਾਂ ਕਿ ਆਉਟਪੁੱਟ ਸਿਰਫ਼ ਮਹੀਨੇ ਅਤੇ ਦਿਨ ਦੀ ਹੋਵੇ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਸਾਲ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਸਿਰਫ਼ ਕਮਾਂਡ ਦੇਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਅਰਥਾਤ, ਉਪਰੋਕਤ ਫਾਰਮੂਲੇ ਵਿੱਚ ਇੱਕ ਆਰਗੂਮੈਂਟ %m/%d ਦੇ ਰੂਪ ਵਿੱਚ ਲਿਖੋ, ਅਤੇ ਬੱਸ ਹੋ ਗਿਆ। ਜਾਂ ਇਸਦੇ ਉਲਟ, %d/%m। 

ਵਾਸਤਵ ਵਿੱਚ, ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ ਦੀ ਗਿਣਤੀ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੈ। ਇੱਥੇ ਇੱਕ ਸਾਰਣੀ ਹੈ ਜਿੱਥੇ ਉਹਨਾਂ ਦਾ ਵਿਸਥਾਰ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ.

ਇੱਕ ਥਰਿੱਡ ਨੂੰ ਕੁਝ ਸਕਿੰਟਾਂ ਲਈ ਮੁਲਤਵੀ ਕਰੋ

ਇਸਦੇ ਲਈ, ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਨੀਂਦ (). ਪ੍ਰੋਗਰਾਮਿੰਗ ਕਾਰਜਾਂ ਦਾ ਇੱਕ ਕਾਫ਼ੀ ਵੱਡਾ ਬਲਾਕ ਸਮੇਂ ਦੇ ਬੀਤਣ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ਕਈ ਵਾਰ ਤੁਹਾਨੂੰ ਅਗਲੇ ਪੜਾਅ ਨੂੰ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮੇਂ ਲਈ ਮੁਲਤਵੀ ਕਰਨਾ ਪੈਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਹਾਨੂੰ ਕਿਸੇ ਅਜਿਹੇ ਡੇਟਾਬੇਸ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜਿਸਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਕੁਝ ਸਮਾਂ ਲੱਗਦਾ ਹੈ।

ਇੱਕ ਦਲੀਲ ਦੇ ਰੂਪ ਵਿੱਚ, ਵਿਧੀ ਇੱਕ ਮੁੱਲ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਜੋ ਐਲਗੋਰਿਦਮ ਤੋਂ ਅਗਲੇ ਪੜਾਅ ਵਿੱਚ ਦੇਰੀ ਕਰਨ ਲਈ ਸਕਿੰਟਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, ਇਸ ਸਨਿੱਪਟ ਵਿੱਚ, ਦੇਰੀ 10 ਸਕਿੰਟ ਹੈ।

ਆਯਾਤ ਦਾ ਸਮਾਂ

ਵਿਰਾਮ = 10

ਪ੍ਰਿੰਟ ("ਪ੍ਰੋਗਰਾਮ ਸ਼ੁਰੂ ਹੋਇਆ...")

time.sleep (ਵਿਰਾਮ)

ਪ੍ਰਿੰਟ(str(ਰੋਕ) + »ਸਕਿੰਟ ਲੰਘ ਗਏ।»)

ਨਤੀਜੇ ਵਜੋਂ, ਅਸੀਂ ਇਹ ਪ੍ਰਾਪਤ ਕਰਾਂਗੇ:

ਪ੍ਰੋਗਰਾਮ ਸ਼ੁਰੂ…

10 ਸਕਿੰਟ ਬੀਤ ਗਏ।

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਆਉਟਪੁੱਟ ਤੋਂ ਦੇਖ ਸਕਦੇ ਹਾਂ, ਪ੍ਰੋਗਰਾਮ ਪਹਿਲਾਂ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ ਕਿ ਇਹ ਸ਼ੁਰੂ ਹੋ ਗਿਆ ਹੈ। ਅਤੇ ਦਸ ਸਕਿੰਟਾਂ ਬਾਅਦ, ਉਸਨੇ ਲਿਖਿਆ ਕਿ ਇਹ ਸਮਾਂ ਲੰਘ ਗਿਆ ਸੀ.

ਫੰਕਸ਼ਨ ਤੁਹਾਨੂੰ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਵਿਰਾਮ ਦੀ ਮਿਆਦ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਫੰਕਸ਼ਨ ਆਰਗੂਮੈਂਟ ਦੇ ਫਰੈਕਸ਼ਨਲ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਨੀਂਦ ਉਦਾਹਰਨ ਲਈ, 0,1. ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਦੇਰੀ 100 ਮਿਲੀਸਕਿੰਟ ਹੋਵੇਗੀ।

ਸਥਾਨਕ ਸਮਾਂ ਪ੍ਰਾਪਤ ਕਰੋ

ਲੋਕਲਟਾਈਮ() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇੱਕ ਖਾਸ ਟਾਈਮ ਜ਼ੋਨ ਵਿੱਚ ਯੁੱਗ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਲੈ ਕੇ ਸਕਿੰਟਾਂ ਦੀ ਗਿਣਤੀ ਮਿਲਦੀ ਹੈ। 

ਆਉ ਸਪਸ਼ਟਤਾ ਲਈ ਇੱਕ ਉਦਾਹਰਨ ਕੋਡ ਦਿੰਦੇ ਹਾਂ।

ਆਯਾਤ ਦਾ ਸਮਾਂ

ਨਤੀਜਾ = time.localtime(1575721830)

ਪ੍ਰਿੰਟ ("ਨਤੀਜਾ:", ਨਤੀਜਾ)

ਪ੍ਰਿੰਟ(«nгод:», result.tm_year)

ਪ੍ਰਿੰਟ(«tm_hour:», result.tm_hour)

ਯੁਗ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਸੰਖਿਆ ਦੇ ਆਧਾਰ 'ਤੇ UTC ਵਿੱਚ struct_time ਵਾਪਸ ਕਰੋ

ਇਹ ਕੰਮ time.gmtime() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਢੰਗ. ਜੇ ਅਸੀਂ ਇੱਕ ਉਦਾਹਰਣ ਦੇ ਦੇਈਏ ਤਾਂ ਇਹ ਸਪੱਸ਼ਟ ਹੋ ਜਾਵੇਗਾ।

ਆਯਾਤ ਦਾ ਸਮਾਂ

ਨਤੀਜਾ = time.gmtime(1575721830)

ਪ੍ਰਿੰਟ ("ਨਤੀਜਾ:", ਨਤੀਜਾ)

ਪ੍ਰਿੰਟ(«nгод:», result.tm_year)

ਪ੍ਰਿੰਟ(«tm_hour:», result.tm_hour)

ਜੇਕਰ ਤੁਸੀਂ ਕਿਰਿਆਵਾਂ ਦੇ ਇਸ ਕ੍ਰਮ ਨੂੰ ਚਾਲੂ ਕਰਦੇ ਹੋ, ਤਾਂ ਸਮਾਂ, ਸਾਲ ਅਤੇ ਸਮਾਂ ਖੇਤਰ ਨਾਲ ਸੰਬੰਧਿਤ ਤੱਤਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਪ੍ਰਦਰਸ਼ਿਤ ਹੋਵੇਗਾ।

ਸਥਾਨਕ ਸਮੇਂ ਵਿੱਚ ਸਵੈਚਲਿਤ ਰੂਪਾਂਤਰਨ ਦੇ ਨਾਲ ਯੁੱਗ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਟਾਂ ਦੀ ਸੰਖਿਆ ਵਾਪਸ ਕਰੋ

ਜੇ ਤੁਹਾਨੂੰ ਅਜਿਹੇ ਕੰਮ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ mktime(), ਜੋ ਲੈਂਦਾ ਹੈ struct_time. ਉਸ ਤੋਂ ਬਾਅਦ, ਇਹ ਫੰਕਸ਼ਨ ਦੀ ਉਲਟ ਕਾਰਵਾਈ ਕਰਦਾ ਹੈ ਸਥਾਨਕ ਸਮਾਂ()। ਯਾਨੀ, ਇਹ ਸਥਾਨਕ ਟਾਈਮ ਜ਼ੋਨ ਦੇ ਅਨੁਸਾਰ ਸਮੇਂ ਨੂੰ ਸਮਾਂ ਜ਼ੋਨ ਲਈ ਐਡਜਸਟ ਕੀਤੇ ਗਏ, ਯੁੱਗ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਬਾਅਦ ਬੀਤ ਚੁੱਕੇ ਸਕਿੰਟਾਂ ਦੀ ਸੰਖਿਆ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।

mktime() ਅਤੇ localtime() ਫੰਕਸ਼ਨ ਆਪਸ ਵਿੱਚ ਨੇੜਿਓਂ ਜੁੜੇ ਹੋਏ ਹਨ। ਇਹ ਕੋਡ ਸਨਿੱਪਟ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਇਸ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਆਉ ਇਸ ਨੂੰ ਹੋਰ ਡੂੰਘਾਈ ਨਾਲ ਸਮਝਣ ਲਈ ਇਸ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ। 

ਆਯਾਤ ਦਾ ਸਮਾਂ

ਸਕਿੰਟ = 1575721830

# struct_time ਵਾਪਸ ਕਰਦਾ ਹੈ

t = time.localtime(ਸੈਕਿੰਡ)

ਪ੍ਰਿੰਟ(«t1: «, t)

# struct_time ਤੋਂ ਸਕਿੰਟ ਵਾਪਸ ਕਰਦਾ ਹੈ

s = time.mktime(t)

ਪ੍ਰਿੰਟ («ns:», ਸਕਿੰਟ)

ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਵੇਰੀਏਬਲ ਸਕਿੰਟ ਯੁੱਗ ਤੋਂ 1575721830 ਸਕਿੰਟ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਪਹਿਲਾਂ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਸਹੀ ਮਿਤੀ, ਸਮਾਂ ਅਤੇ ਹੋਰ ਮਾਪਦੰਡ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹਨ, ਇਸ ਮੁੱਲ ਦੇ ਅਧਾਰ ਤੇ, ਇਸਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਰੱਖੋ t, ਅਤੇ ਫਿਰ ਇਸਦੀ ਸਮੱਗਰੀ ਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਬਦਲਦਾ ਹੈ s.

ਉਸ ਤੋਂ ਬਾਅਦ ਇੱਕ ਨਵੀਂ ਲਾਈਨ ਨੂੰ ਹਰਾਉਂਦਾ ਹੈ ਅਤੇ ਕੰਸੋਲ ਵਿੱਚ ਸਕਿੰਟਾਂ ਦੀ ਸੰਖਿਆ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ. ਤੁਸੀਂ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਉਹੀ ਨੰਬਰ ਹੋਵੇਗਾ ਜੋ ਸਕਿੰਟ ਵੇਰੀਏਬਲ ਨੂੰ ਦਿੱਤਾ ਗਿਆ ਸੀ।

9 ਨੰਬਰਾਂ ਤੋਂ ਆਉਟਪੁੱਟ ਮਿਤੀ ਜੋ struct_time ਦਾ ਹਵਾਲਾ ਦਿੰਦੀ ਹੈ

ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਕੋਲ ਸਾਲ, ਮਹੀਨਾ, ਮਿਤੀ, ਹਫ਼ਤੇ ਦੇ ਦਿਨ ਅਤੇ ਹੋਰ ਕਈ ਮੁੱਲਾਂ ਨੂੰ ਦਰਸਾਉਣ ਵਾਲੇ 9 ਨੰਬਰ ਹਨ, ਅਤੇ ਸਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਸਤਰ ਵਿੱਚ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ। ਇਸਦੇ ਲਈ, ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ asctime(). ਉਹ ਸਵੀਕਾਰ ਜਾਂ ਤਿਆਰ ਹੈ struct_time, ਜਾਂ 9 ਮੁੱਲਾਂ ਦਾ ਕੋਈ ਹੋਰ ਟੁਪਲ ਜੋ ਸਮਾਨ ਲਈ ਖੜ੍ਹਾ ਹੈ। ਉਸ ਤੋਂ ਬਾਅਦ, ਇੱਕ ਸਤਰ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਮਿਤੀ, ਸਮਾਂ ਅਤੇ ਕਈ ਹੋਰ ਮਾਪਦੰਡ ਹਨ। 

ਇੱਕ ਸਿੰਗਲ ਵੇਰੀਏਬਲ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਡੇਟਾ ਲਿਆਉਣ ਲਈ ਇਸ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਹੈ।.

ਉਦਾਹਰਨ ਲਈ, ਇਹ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਹੋ ਸਕਦਾ ਹੈ ਜਿੱਥੇ ਉਪਭੋਗਤਾ ਦਿਨ, ਮਹੀਨਾ, ਸਾਲ, ਹਫ਼ਤੇ ਦਾ ਦਿਨ, ਅਤੇ ਇੱਕ ਇਵੈਂਟ ਲਈ ਰਜਿਸਟ੍ਰੇਸ਼ਨ ਸੰਬੰਧੀ ਹੋਰ ਡੇਟਾ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਉਸ ਤੋਂ ਬਾਅਦ, ਪ੍ਰਾਪਤ ਜਾਣਕਾਰੀ ਨੂੰ ਡੇਟਾਬੇਸ ਵਿੱਚ ਦਾਖਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਕਿਸੇ ਹੋਰ ਵਿਅਕਤੀ ਨੂੰ ਜਾਰੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜੋ ਇਸਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ।

ਪਾਈਥਨ ਸਤਰ ਦੇ ਅਧਾਰ ਤੇ ਸਮਾਂ ਅਤੇ ਮਿਤੀ ਪ੍ਰਾਪਤ ਕਰਨਾ

ਮੰਨ ਲਓ ਕਿ ਉਪਭੋਗਤਾ ਨੇ ਵੱਖਰਾ ਡੇਟਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਹੈ, ਅਤੇ ਸਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਉਸ ਫਾਰਮੈਟ ਵਿੱਚ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਜੋੜਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਵਿਅਕਤੀ ਦੁਆਰਾ ਦਾਖਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਫਿਰ ਕਿਸੇ ਹੋਰ ਵੇਰੀਏਬਲ ਦੀ ਇੱਕ ਕਾਪੀ ਬਣਾਉ, ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਮਿਆਰੀ ਫਾਰਮੈਟ ਵਿੱਚ ਦੁਬਾਰਾ ਬਣਾਓ। ਇਸਦੇ ਲਈ, ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ time.strptime()।

ਇਹ ਇੱਕ ਵੇਰੀਏਬਲ ਲੈਂਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇਹ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਸਾਡੇ ਲਈ ਪਹਿਲਾਂ ਤੋਂ ਜਾਣੂ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ struct_time.

ਸਪਸ਼ਟਤਾ ਲਈ, ਅਸੀਂ ਅਜਿਹਾ ਪ੍ਰੋਗਰਾਮ ਲਿਖਾਂਗੇ।

ਆਯਾਤ ਦਾ ਸਮਾਂ

time_string = «15 ਜੂਨ, 2019»

ਨਤੀਜਾ = time.strptime(time_string, «%d %B, %Y»)

ਪ੍ਰਿੰਟ (ਨਤੀਜਾ)

ਅੰਦਾਜ਼ਾ ਲਗਾਓ ਕਿ ਆਉਟਪੁੱਟ ਕੀ ਹੋਵੇਗੀ? ਹੇਠਲੀ ਲਾਈਨ 'ਤੇ ਦੇਖੇ ਬਿਨਾਂ ਅਨੁਮਾਨ ਲਗਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। ਅਤੇ ਫਿਰ ਜਵਾਬ ਦੀ ਜਾਂਚ ਕਰੋ।

time.struct_time(tm_year=2019, tm_mon=6, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=166, tm_isdst=-1)

ਇੱਕ ਸ਼ਬਦ ਵਿੱਚ, ਪਾਈਥਨ ਵਿੱਚ ਤਾਰੀਖਾਂ ਅਤੇ ਸਮੇਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨਾ ਔਖਾ ਨਹੀਂ ਹੈ. ਇਹਨਾਂ ਹਦਾਇਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਲਈ ਇਹ ਕਾਫ਼ੀ ਹੈ, ਅਤੇ ਸਭ ਕੁਝ ਕੰਮ ਕਰੇਗਾ. ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਵਾਰ ਉਪਭੋਗਤਾ ਨੂੰ ਸਮੇਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਬਹੁਤ ਸਾਰੇ ਮੌਕੇ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ:

1. ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮੇਂ ਲਈ ਪ੍ਰੋਗਰਾਮ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਮੁਅੱਤਲ ਕਰੋ।
2. ਯੁੱਗ ਤੋਂ ਬਾਅਦ ਲੰਘਿਆ ਸਮਾਂ, ਸਕਿੰਟਾਂ ਵਿੱਚ ਦਿਖਾਓ। ਇਸ ਜਾਣਕਾਰੀ ਦੀ ਵਰਤੋਂ ਸਮੇਂ ਨੂੰ ਜੋੜਨ ਜਾਂ ਇਸ 'ਤੇ ਹੋਰ ਗਣਿਤਿਕ ਕਾਰਵਾਈਆਂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।
3. ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲੋ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਪ੍ਰੋਗਰਾਮਰ ਖੁਦ ਸੈੱਟ ਕਰ ਸਕਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਤੱਤ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣਗੇ ਅਤੇ ਕਿਸ ਕ੍ਰਮ ਵਿੱਚ. 

ਇਸ ਦੀਆਂ ਕਈ ਹੋਰ ਸੰਭਾਵਨਾਵਾਂ ਵੀ ਹਨ, ਪਰ ਅੱਜ ਅਸੀਂ ਸਭ ਤੋਂ ਬੁਨਿਆਦੀ ਸੰਭਾਵਨਾਵਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕੀਤਾ ਹੈ। ਉਹ ਲਗਭਗ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਕੰਮ ਆਉਣਗੇ ਜੋ ਸਮੇਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ. ਖੁਸ਼ਕਿਸਮਤੀ.