ਸਮੱਗਰੀ
ਸੰਦਰਭ ਸੂਚੀ ਦੇ ਅਨੁਸਾਰ ਟੈਕਸਟ ਨੂੰ ਫਾਰਮੂਲੇ ਨਾਲ ਤੇਜ਼ੀ ਨਾਲ ਅਤੇ ਥੋਕ ਵਿੱਚ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ - ਅਸੀਂ ਇਸਨੂੰ ਪਹਿਲਾਂ ਹੀ ਛਾਂਟ ਲਿਆ ਹੈ। ਆਉ ਹੁਣ ਇਸਨੂੰ ਪਾਵਰ ਕਿਊਰੀ ਵਿੱਚ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ।
ਜਿਵੇਂ ਅਕਸਰ ਹੁੰਦਾ ਹੈ ਪ੍ਰਦਰਸ਼ਨ ਕਰੋ ਇਹ ਕੰਮ ਸਮਝਾਉਣ ਨਾਲੋਂ ਬਹੁਤ ਸੌਖਾ ਹੈ ਇਸੇ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਆਓ ਦੋਵੇਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ 🙂
ਇਸ ਲਈ, ਸਾਡੇ ਕੋਲ ਦੋ "ਸਮਾਰਟ" ਡਾਇਨਾਮਿਕ ਟੇਬਲ ਹਨ ਜੋ ਇੱਕ ਕੀਬੋਰਡ ਸ਼ਾਰਟਕੱਟ ਨਾਲ ਆਮ ਰੇਂਜਾਂ ਤੋਂ ਬਣਾਈਆਂ ਗਈਆਂ ਹਨ Ctrl+T ਜਾਂ ਟੀਮ ਘਰ - ਇੱਕ ਸਾਰਣੀ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ ਕਰੋ (ਘਰ - ਸਾਰਣੀ ਦੇ ਰੂਪ ਵਿੱਚ ਫਾਰਮੈਟ):
ਮੈਂ ਪਹਿਲੇ ਟੇਬਲ ਨੂੰ ਬੁਲਾਇਆ ਡੇਟਾ, ਦੂਜੀ ਸਾਰਣੀ - ਡਾਇਰੈਕਟਰੀਫੀਲਡ ਦੀ ਵਰਤੋਂ ਸਾਰਣੀ ਦਾ ਨਾਮ (ਸਾਰਣੀ ਦਾ ਨਾਮ) ਟੈਬ ਕੰਸਟਰਕਟਰ (ਡਿਜ਼ਾਈਨ).
ਕਾਰਜ: ਸਾਰਣੀ ਵਿੱਚ ਪਤੇ ਬਦਲੋ ਡੇਟਾ ਇੱਕ ਕਾਲਮ ਤੋਂ ਸਾਰੀਆਂ ਘਟਨਾਵਾਂ ਲਭਣ ਲਈ ਕਿਤਾਬਚਾ ਕਾਲਮ ਤੋਂ ਉਹਨਾਂ ਦੇ ਅਨੁਸਾਰੀ ਸਹੀ ਹਮਰੁਤਬਾ ਨੂੰ ਬਦਲ. ਸੈੱਲਾਂ ਵਿੱਚ ਬਾਕੀ ਪਾਠ ਨੂੰ ਅਛੂਤ ਰਹਿਣਾ ਚਾਹੀਦਾ ਹੈ।
ਕਦਮ 1. ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਪਾਵਰ ਕਿਊਰੀ ਵਿੱਚ ਲੋਡ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਬਦਲੋ
ਸੰਦਰਭ ਸਾਰਣੀ ਵਿੱਚ ਕਿਸੇ ਵੀ ਥਾਂ 'ਤੇ ਕਿਰਿਆਸ਼ੀਲ ਸੈੱਲ ਨੂੰ ਸੈੱਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਟੈਬ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਡੇਟਾ (ਤਾਰੀਖ਼)ਜਾਂ ਟੈਬ 'ਤੇ ਬਿਜਲੀ ਪ੍ਰਸ਼ਨ (ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਐਕਸਲ ਦਾ ਪੁਰਾਣਾ ਸੰਸਕਰਣ ਹੈ ਅਤੇ ਤੁਸੀਂ ਪਾਵਰ ਕਿਊਰੀ ਨੂੰ ਇੱਕ ਵੱਖਰੀ ਟੈਬ 'ਤੇ ਐਡ-ਇਨ ਵਜੋਂ ਸਥਾਪਿਤ ਕੀਤਾ ਹੈ) ਬਟਨ 'ਤੇ ਸਾਰਣੀ/ਸੀਮਾ ਤੋਂ (ਸਾਰਣੀ/ਸੀਮਾ ਤੋਂ).
ਹਵਾਲਾ ਸਾਰਣੀ ਨੂੰ ਪਾਵਰ ਕਿਊਰੀ ਪੁੱਛਗਿੱਛ ਸੰਪਾਦਕ ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਜਾਵੇਗਾ:
ਦਖਲ ਨਾ ਦੇਣ ਲਈ, ਇੱਕ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਕਦਮ ਸੋਧਿਆ ਕਿਸਮ (ਬਦਲੀ ਗਈ ਕਿਸਮ) ਸੱਜੇ ਪੈਨਲ ਵਿੱਚ, ਲਾਗੂ ਕੀਤੇ ਕਦਮਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਮਿਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਸਿਰਫ਼ ਕਦਮ ਨੂੰ ਛੱਡ ਕੇ ਸਰੋਤ (ਸਰੋਤ):
ਹੁਣ, ਹੋਰ ਤਬਦੀਲੀਆਂ ਅਤੇ ਤਬਦੀਲੀਆਂ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇਸ ਸਾਰਣੀ ਨੂੰ ਇੱਕ ਸੂਚੀ (ਸੂਚੀ) ਵਿੱਚ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ।
ਲਿਰੀਕਲ ਡਿਗ੍ਰੇਸ਼ਨ
- ਸਾਰਣੀ ਇੱਕ ਦੋ-ਅਯਾਮੀ ਐਰੇ ਹੈ ਜਿਸ ਵਿੱਚ ਕਈ ਕਤਾਰਾਂ ਅਤੇ ਕਾਲਮ ਹਨ।
- ਰਿਕਾਰਡ (ਰਿਕਾਰਡ) - ਇੱਕ-ਅਯਾਮੀ ਐਰੇ-ਸਟ੍ਰਿੰਗ, ਜਿਸ ਵਿੱਚ ਨਾਮਾਂ ਦੇ ਨਾਲ ਕਈ ਖੇਤਰਾਂ-ਤੱਤ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ [ਨਾਮ = “ਮਾਸ਼ਾ”, ਲਿੰਗ = “f”, ਉਮਰ = 25]
- ਸੂਚੀ - ਇੱਕ ਇੱਕ-ਅਯਾਮੀ ਐਰੇ-ਕਾਲਮ, ਜਿਸ ਵਿੱਚ ਕਈ ਤੱਤ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ {1, 2, 3, 10, 42 or {"ਵਿਸ਼ਵਾਸ ਆਸ ਪਿਆਰ" }
ਸਾਡੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਅਸੀਂ ਮੁੱਖ ਤੌਰ 'ਤੇ ਕਿਸਮ ਵਿੱਚ ਦਿਲਚਸਪੀ ਲਵਾਂਗੇ ਸੂਚੀ.
ਇੱਥੇ ਚਾਲ ਇਹ ਹੈ ਕਿ ਪਾਵਰ ਕਿਊਰੀ ਵਿੱਚ ਸੂਚੀ ਆਈਟਮਾਂ ਨਾ ਸਿਰਫ਼ ਬੇਨਲ ਨੰਬਰ ਜਾਂ ਟੈਕਸਟ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਸਗੋਂ ਹੋਰ ਸੂਚੀਆਂ ਜਾਂ ਰਿਕਾਰਡ ਵੀ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਹ ਇੱਕ ਅਜਿਹੀ ਔਖੀ ਸੂਚੀ (ਸੂਚੀ) ਵਿੱਚ ਹੈ, ਜਿਸ ਵਿੱਚ ਰਿਕਾਰਡ (ਰਿਕਾਰਡ) ਸ਼ਾਮਲ ਹਨ, ਜੋ ਸਾਨੂੰ ਆਪਣੀ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ। ਪਾਵਰ ਕਿਊਰੀ ਸਿੰਟੈਕਟਿਕ ਨੋਟੇਸ਼ਨ ਵਿੱਚ (ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਐਂਟਰੀਆਂ, ਕਰਲੀ ਬਰੈਕਟਾਂ ਵਿੱਚ ਸੂਚੀਆਂ) ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:
{
[ ਲੱਭੋ = “ਸੈਂਟ. ਪੀਟਰਸਬਰਗ", ਬਦਲੋ = "ਸੈਂਟ. ਪੀਟਰਸਬਰਗ"] ,
[ ਲੱਭੋ = “ਸੈਂਟ. ਪੀਟਰਸਬਰਗ", ਬਦਲੋ = "ਸੈਂਟ. ਪੀਟਰਸਬਰਗ"] ,
[ ਲੱਭੋ = "ਪੀਟਰ", ਬਦਲੋ = "ਸੈਂਟ. ਪੀਟਰਸਬਰਗ"] ,
ਆਦਿ
}
ਪਾਵਰ ਕਿਊਰੀ ਵਿੱਚ ਬਣੀ ਐਮ ਭਾਸ਼ਾ ਦੇ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਜਿਹਾ ਪਰਿਵਰਤਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ - ਟੇਬਲ।ToRecords. ਇਸਨੂੰ ਫਾਰਮੂਲਾ ਬਾਰ ਵਿੱਚ ਸਿੱਧਾ ਲਾਗੂ ਕਰਨ ਲਈ, ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਉੱਥੇ ਸਟੈਪ ਕੋਡ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰੋ ਸਰੋਤ.
ਇਹ ਸੀ:
ਬਾਅਦ:
Table.ToRecords ਫੰਕਸ਼ਨ ਨੂੰ ਜੋੜਨ ਤੋਂ ਬਾਅਦ, ਸਾਡੀ ਸਾਰਣੀ ਦੀ ਦਿੱਖ ਬਦਲ ਜਾਵੇਗੀ - ਇਹ ਰਿਕਾਰਡਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਬਦਲ ਜਾਵੇਗੀ। ਵਿਅਕਤੀਗਤ ਰਿਕਾਰਡਾਂ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਕਿਸੇ ਵੀ ਸ਼ਬਦ ਦੇ ਅੱਗੇ ਸੈੱਲ ਬੈਕਗ੍ਰਾਊਂਡ ਵਿੱਚ ਕਲਿੱਕ ਕਰਕੇ ਵਿਊ ਪੈਨ ਦੇ ਹੇਠਾਂ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਭਰੋ (ਪਰ ਇੱਕ ਸ਼ਬਦ ਵਿੱਚ ਨਹੀਂ!)
ਉਪਰੋਕਤ ਤੋਂ ਇਲਾਵਾ, ਸਾਡੀ ਬਣਾਈ ਸੂਚੀ ਨੂੰ ਕੈਸ਼ (ਬਫਰ) ਕਰਨ ਲਈ - ਇੱਕ ਹੋਰ ਸਟ੍ਰੋਕ ਜੋੜਨਾ ਸਮਝਦਾਰ ਹੈ। ਇਹ ਪਾਵਰ ਕਿਊਰੀ ਨੂੰ ਸਾਡੀ ਲੁੱਕਅਪ ਸੂਚੀ ਨੂੰ ਇੱਕ ਵਾਰ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕਰਨ ਲਈ ਮਜ਼ਬੂਰ ਕਰੇਗਾ ਅਤੇ ਜਦੋਂ ਅਸੀਂ ਬਾਅਦ ਵਿੱਚ ਇਸਨੂੰ ਬਦਲਣ ਲਈ ਇਸਨੂੰ ਐਕਸੈਸ ਕਰਦੇ ਹਾਂ ਤਾਂ ਇਸਨੂੰ ਦੁਬਾਰਾ ਗਣਨਾ ਨਹੀਂ ਕਰਦੇ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਾਡੇ ਫਾਰਮੂਲੇ ਨੂੰ ਕਿਸੇ ਹੋਰ ਫੰਕਸ਼ਨ ਵਿੱਚ ਸਮੇਟਣਾ - ਸੂਚੀ.ਬਫਰ:
ਅਜਿਹੀ ਕੈਚਿੰਗ ਕਲੀਅਰ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਸ਼ੁਰੂਆਤੀ ਡੇਟਾ ਦੀ ਇੱਕ ਵੱਡੀ ਮਾਤਰਾ ਦੇ ਨਾਲ ਗਤੀ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਧਿਆਨ ਦੇਣ ਯੋਗ ਵਾਧਾ (ਕਈ ਗੁਣਾ!) ਦੇਵੇਗੀ।
ਇਸ ਨਾਲ ਹੈਂਡਬੁੱਕ ਦੀ ਤਿਆਰੀ ਪੂਰੀ ਹੋ ਜਾਂਦੀ ਹੈ।
ਇਸ 'ਤੇ ਕਲਿੱਕ ਕਰਨਾ ਬਾਕੀ ਹੈ ਘਰ - ਬੰਦ ਕਰੋ ਅਤੇ ਲੋਡ ਕਰੋ - ਬੰਦ ਕਰੋ ਅਤੇ ਲੋਡ ਕਰੋ… (ਘਰ - ਬੰਦ ਕਰੋ ਅਤੇ ਲੋਡ ਕਰੋ - ਬੰਦ ਕਰੋ ਅਤੇ ਲੋਡ ਕਰੋ..), ਇੱਕ ਵਿਕਲਪ ਚੁਣੋ ਬਸ ਇੱਕ ਕੁਨੈਕਸ਼ਨ ਬਣਾਓ (ਸਿਰਫ ਕਨੈਕਸ਼ਨ ਬਣਾਓ) ਅਤੇ ਐਕਸਲ 'ਤੇ ਵਾਪਸ ਜਾਓ।
ਕਦਮ 2. ਡਾਟਾ ਸਾਰਣੀ ਨੂੰ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
ਇੱਥੇ ਸਭ ਕੁਝ ਤਿੱਖਾ ਹੈ. ਜਿਵੇਂ ਕਿ ਹਵਾਲਾ ਪੁਸਤਕ ਦੇ ਨਾਲ ਪਹਿਲਾਂ, ਅਸੀਂ ਸਾਰਣੀ ਵਿੱਚ ਕਿਸੇ ਵੀ ਥਾਂ 'ਤੇ ਪਹੁੰਚਦੇ ਹਾਂ, ਟੈਬ 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਡੇਟਾ ਬਟਨ ਨੂੰ ਟੇਬਲ/ਰੇਂਜ ਤੋਂ ਅਤੇ ਸਾਡੀ ਮੇਜ਼ ਡੇਟਾ ਪਾਵਰ ਕਿਊਰੀ ਵਿੱਚ ਆਉਂਦਾ ਹੈ। ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਕਦਮ ਸੋਧਿਆ ਕਿਸਮ (ਬਦਲੀ ਗਈ ਕਿਸਮ) ਤੁਸੀਂ ਇਹ ਵੀ ਹਟਾ ਸਕਦੇ ਹੋ:
ਇਸਦੇ ਨਾਲ ਕੋਈ ਵਿਸ਼ੇਸ਼ ਤਿਆਰੀ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਅਤੇ ਅਸੀਂ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਣ ਚੀਜ਼ ਵੱਲ ਵਧਦੇ ਹਾਂ.
ਕਦਮ 3. List.Accumulate ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤਬਦੀਲੀਆਂ ਕਰੋ
ਆਉ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਡੇਟਾ ਟੇਬਲ ਵਿੱਚ ਇੱਕ ਗਣਿਤ ਕਾਲਮ ਜੋੜੀਏ ਇੱਕ ਕਾਲਮ ਜੋੜਨਾ - ਕਸਟਮ ਕਾਲਮ (ਕਾਲਮ ਸ਼ਾਮਲ ਕਰੋ — ਕਸਟਮ ਕਾਲਮ): ਅਤੇ ਖੁੱਲਣ ਵਾਲੀ ਵਿੰਡੋ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਕਾਲਮ ਦਾ ਨਾਮ ਦਰਜ ਕਰੋ (ਉਦਾਹਰਨ ਲਈ, ਠੀਕ ਕੀਤਾ ਪਤਾ) ਅਤੇ ਸਾਡਾ ਜਾਦੂ ਫੰਕਸ਼ਨ ਸੂਚੀ. ਇਕੱਤਰ ਕਰੋ:
ਇਸ 'ਤੇ ਕਲਿੱਕ ਕਰਨਾ ਬਾਕੀ ਹੈ OK - ਅਤੇ ਸਾਨੂੰ ਕੀਤੇ ਗਏ ਬਦਲਾਵਾਂ ਦੇ ਨਾਲ ਇੱਕ ਕਾਲਮ ਮਿਲਦਾ ਹੈ:
ਨੋਟ ਕਰੋ:
- ਕਿਉਂਕਿ ਪਾਵਰ ਕਿਊਰੀ ਕੇਸ-ਸੰਵੇਦਨਸ਼ੀਲ ਹੈ, ਇਸ ਲਈ ਅੰਤਮ ਲਾਈਨ ਵਿੱਚ ਕੋਈ ਤਬਦੀਲੀ ਨਹੀਂ ਕੀਤੀ ਗਈ, ਕਿਉਂਕਿ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸਾਡੇ ਕੋਲ "SPb" ਹੈ, "SPb" ਨਹੀਂ।
- ਜੇਕਰ ਸਰੋਤ ਡੇਟਾ ਵਿੱਚ ਇੱਕੋ ਵਾਰ ਬਦਲਣ ਲਈ ਕਈ ਸਬਸਟਰਿੰਗ ਹਨ (ਉਦਾਹਰਨ ਲਈ, 7ਵੀਂ ਲਾਈਨ ਵਿੱਚ ਤੁਹਾਨੂੰ "S-Pb" ਅਤੇ "ਪ੍ਰਾਸਪੈਕਟਸ" ਦੋਵਾਂ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ), ਤਾਂ ਇਹ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਪੈਦਾ ਕਰਦਾ ਹੈ (ਇਸ ਤੋਂ ਫਾਰਮੂਲੇ ਨਾਲ ਬਦਲਣ ਦੇ ਉਲਟ ਪਿਛਲੀ ਵਿਧੀ)।
- ਜੇਕਰ ਸਰੋਤ ਟੈਕਸਟ (9ਵੀਂ ਲਾਈਨ) ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੁਝ ਨਹੀਂ ਹੈ, ਤਾਂ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ (ਇਸ ਦੇ ਉਲਟ, ਦੁਬਾਰਾ, ਫਾਰਮੂਲੇ ਦੁਆਰਾ ਬਦਲਣ ਤੋਂ)।
ਅਜਿਹੀ ਬੇਨਤੀ ਦੀ ਗਤੀ ਬਹੁਤ, ਬਹੁਤ ਵਧੀਆ ਹੈ. ਉਦਾਹਰਨ ਲਈ, 5000 ਕਤਾਰਾਂ ਦੇ ਆਕਾਰ ਵਾਲੇ ਸ਼ੁਰੂਆਤੀ ਡੇਟਾ ਦੀ ਇੱਕ ਸਾਰਣੀ ਲਈ, ਇਹ ਪੁੱਛਗਿੱਛ ਇੱਕ ਸਕਿੰਟ ਤੋਂ ਵੀ ਘੱਟ ਸਮੇਂ ਵਿੱਚ ਅੱਪਡੇਟ ਕੀਤੀ ਗਈ ਸੀ (ਬਫ਼ਰਿੰਗ ਤੋਂ ਬਿਨਾਂ, ਲਗਭਗ 3 ਸਕਿੰਟ!)
List.Accumulate ਫੰਕਸ਼ਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ
ਸਿਧਾਂਤਕ ਤੌਰ 'ਤੇ, ਇਹ ਇਸ ਲੇਖ ਦਾ ਅੰਤ (ਮੇਰੇ ਲਈ ਲਿਖਣ ਲਈ, ਅਤੇ ਤੁਹਾਡੇ ਪੜ੍ਹਨ ਲਈ) ਹੋ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਨਾ ਸਿਰਫ਼ ਯੋਗ ਹੋਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਸਗੋਂ ਇਹ ਵੀ ਸਮਝਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇਹ "ਹੁੱਡ ਦੇ ਹੇਠਾਂ" ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਖਰਗੋਸ਼ ਦੇ ਮੋਰੀ ਵਿੱਚ ਥੋੜਾ ਡੂੰਘਾ ਡੁਬਕੀ ਕਰਨੀ ਪਵੇਗੀ ਅਤੇ ਸੂਚੀ ਨਾਲ ਨਜਿੱਠਣਾ ਪਵੇਗਾ। ਸਾਡੇ ਲਈ ਕੰਮ ਕਰੋ.
ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਸੰਟੈਕਸ ਹੈ:
=ਸੂਚੀ।ਸੂਚੀ ਵਿੱਚ, ਬੀਜ, ਸੰਚਾਲਕ)
ਜਿੱਥੇ ਕਿ
- ਸੂਚੀ ਵਿੱਚ ਉਹ ਸੂਚੀ ਹੈ ਜਿਸ ਦੇ ਤੱਤ ਅਸੀਂ ਦੁਹਰਾ ਰਹੇ ਹਾਂ।
- ਬੀਜ - ਸ਼ੁਰੂਆਤੀ ਸਥਿਤੀ
- ਸੰਚਾਲਕ - ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ ਸੂਚੀ ਦੇ ਅਗਲੇ ਤੱਤ 'ਤੇ ਕੁਝ ਕਾਰਵਾਈ (ਗਣਿਤ, ਟੈਕਸਟ, ਆਦਿ) ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਵੇਰੀਏਬਲ ਵਿੱਚ ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਨਤੀਜੇ ਨੂੰ ਇਕੱਠਾ ਕਰਦਾ ਹੈ।
ਆਮ ਤੌਰ 'ਤੇ, ਪਾਵਰ ਕਿਊਰੀ ਵਿੱਚ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਲਿਖਣ ਲਈ ਸੰਟੈਕਸ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:
(argument1, argument2, … argumentN) => ਆਰਗੂਮੈਂਟਾਂ ਵਾਲੀਆਂ ਕੁਝ ਕਾਰਵਾਈਆਂ
ਉਦਾਹਰਨ ਲਈ, ਸਮੇਸ਼ਨ ਫੰਕਸ਼ਨ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:
(a, b) => a + b
List.Accumulate ਲਈ, ਇਸ ਸੰਚਤ ਫੰਕਸ਼ਨ ਦੇ ਦੋ ਲੋੜੀਂਦੇ ਆਰਗੂਮੈਂਟ ਹਨ (ਉਹਨਾਂ ਨੂੰ ਕੁਝ ਵੀ ਨਾਮ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਆਮ ਨਾਮ ਹਨ ਰਾਜ и ਮੌਜੂਦਾ, ਜਿਵੇਂ ਕਿ ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਅਧਿਕਾਰਤ ਮਦਦ ਵਿੱਚ, ਜਿੱਥੇ:
- ਰਾਜ - ਇੱਕ ਵੇਰੀਏਬਲ ਜਿੱਥੇ ਨਤੀਜਾ ਇਕੱਠਾ ਹੁੰਦਾ ਹੈ (ਇਸਦਾ ਸ਼ੁਰੂਆਤੀ ਮੁੱਲ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ ਬੀਜ)
- ਮੌਜੂਦਾ - ਸੂਚੀ ਵਿੱਚੋਂ ਅਗਲਾ ਦੁਹਰਾਇਆ ਮੁੱਲ ਸੂਚੀ ਵਿੱਚ
ਉਦਾਹਰਨ ਲਈ, ਆਓ ਹੇਠਾਂ ਦਿੱਤੇ ਨਿਰਮਾਣ ਦੇ ਤਰਕ ਦੇ ਕਦਮਾਂ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ:
=ਸੂਚੀ।{3, 2, 5, 10, (ਸਟੇਟ, ਮੌਜੂਦਾ) => ਰਾਜ + ਮੌਜੂਦਾ)
- ਵੇਰੀਏਬਲ ਮੁੱਲ ਰਾਜ ਸ਼ੁਰੂਆਤੀ ਆਰਗੂਮੈਂਟ ਦੇ ਬਰਾਬਰ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ ਬੀਜIe ਰਾਜ = 10
- ਅਸੀਂ ਸੂਚੀ ਦਾ ਪਹਿਲਾ ਤੱਤ ਲੈਂਦੇ ਹਾਂ (ਮੌਜੂਦਾ = 3) ਅਤੇ ਇਸਨੂੰ ਵੇਰੀਏਬਲ ਵਿੱਚ ਜੋੜੋ ਰਾਜ (ਦਸ) ਸਾਨੂੰ ਪ੍ਰਾਪਤ ਰਾਜ = 13.
- ਅਸੀਂ ਸੂਚੀ ਦਾ ਦੂਜਾ ਤੱਤ ਲੈਂਦੇ ਹਾਂ (ਮੌਜੂਦਾ = 2) ਅਤੇ ਇਸ ਨੂੰ ਵੇਰੀਏਬਲ ਵਿੱਚ ਮੌਜੂਦਾ ਸੰਚਿਤ ਮੁੱਲ ਨਾਲ ਜੋੜੋ ਰਾਜ (ਦਸ) ਸਾਨੂੰ ਪ੍ਰਾਪਤ ਰਾਜ = 15.
- ਅਸੀਂ ਸੂਚੀ ਦਾ ਤੀਜਾ ਤੱਤ ਲੈਂਦੇ ਹਾਂ (ਮੌਜੂਦਾ = 5) ਅਤੇ ਇਸ ਨੂੰ ਵੇਰੀਏਬਲ ਵਿੱਚ ਮੌਜੂਦਾ ਸੰਚਿਤ ਮੁੱਲ ਨਾਲ ਜੋੜੋ ਰਾਜ (ਦਸ) ਸਾਨੂੰ ਪ੍ਰਾਪਤ ਰਾਜ = 20.
ਇਹ ਤਾਜ਼ਾ ਇਕੱਠਾ ਹੋਇਆ ਹੈ ਰਾਜ ਮੁੱਲ ਸਾਡੀ ਸੂਚੀ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ ਫੰਕਸ਼ਨ ਅਤੇ ਆਉਟਪੁੱਟ ਇਕੱਠੇ ਕਰੋ:
ਜੇਕਰ ਤੁਸੀਂ ਥੋੜਾ ਜਿਹਾ ਕਲਪਨਾ ਕਰਦੇ ਹੋ, ਤਾਂ List.Accumulate ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਸਿਮੂਲੇਟ ਕਰ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ, ਐਕਸਲ ਫੰਕਸ਼ਨ CONCATENATE (ਪਾਵਰ ਕਿਊਰੀ ਵਿੱਚ, ਇਸਦਾ ਐਨਾਲਾਗ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਟੈਕਸਟ।ਕੰਬਾਈਨ) ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ:
ਜਾਂ ਇੱਥੋਂ ਤੱਕ ਕਿ ਅਧਿਕਤਮ ਮੁੱਲ ਦੀ ਖੋਜ ਕਰੋ (ਐਕਸਲ ਦੇ MAX ਫੰਕਸ਼ਨ ਦੀ ਨਕਲ, ਜਿਸ ਨੂੰ ਪਾਵਰ ਕਿਊਰੀ ਵਿੱਚ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਸੂਚੀ। ਅਧਿਕਤਮ):
ਹਾਲਾਂਕਿ, List.Accumulate ਦੀ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾ ਆਰਗੂਮੈਂਟ ਦੇ ਤੌਰ 'ਤੇ ਨਾ ਸਿਰਫ਼ ਸਧਾਰਨ ਪਾਠ ਜਾਂ ਸੰਖਿਆਤਮਕ ਸੂਚੀਆਂ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਹੈ, ਸਗੋਂ ਹੋਰ ਗੁੰਝਲਦਾਰ ਵਸਤੂਆਂ - ਉਦਾਹਰਨ ਲਈ, ਸੂਚੀਆਂ-ਤੋਂ-ਸੂਚੀਆਂ ਜਾਂ ਸੂਚੀਆਂ-ਤੋਂ-ਰਿਕਾਰਡ (ਹੈਲੋ, ਡਾਇਰੈਕਟਰੀ!)
ਆਓ ਉਸ ਉਸਾਰੀ ਨੂੰ ਦੁਬਾਰਾ ਵੇਖੀਏ ਜਿਸ ਨੇ ਸਾਡੀ ਸਮੱਸਿਆ ਵਿੱਚ ਤਬਦੀਲੀ ਕੀਤੀ:
ਸੂਚੀ. ਇਕੱਤਰ ਕਰੋ(ਡਾਇਰੈਕਟਰੀ, [ਪਤਾ], (state,current) => Text.Replace(state, current[Find], current[ਬਦਲੋ]) )
ਇੱਥੇ ਅਸਲ ਵਿੱਚ ਕੀ ਹੋ ਰਿਹਾ ਹੈ?
- ਸ਼ੁਰੂਆਤੀ ਮੁੱਲ ਵਜੋਂ (ਬੀਜ) ਅਸੀਂ ਕਾਲਮ ਤੋਂ ਪਹਿਲਾ ਬੇਢੰਗੀ ਟੈਕਸਟ ਲੈਂਦੇ ਹਾਂ [ਪਤਾ] ਸਾਡੀ ਮੇਜ਼: 199034, ਸੇਂਟ ਪੀਟਰਸਬਰਗ, ਸਟਰ. ਬੇਰਿੰਗਾ, ਡੀ. 1
- ਫਿਰ ਸੂਚੀ. ਸੂਚੀ ਦੇ ਤੱਤਾਂ 'ਤੇ ਇਕ-ਇਕ ਕਰਕੇ ਦੁਹਰਾਓ ਇਕੱਠਾ ਕਰੋ - ਕਿਤਾਬਚਾ. ਇਸ ਸੂਚੀ ਦਾ ਹਰੇਕ ਤੱਤ ਇੱਕ ਰਿਕਾਰਡ ਹੈ ਜਿਸ ਵਿੱਚ ਖੇਤਰਾਂ ਦੀ ਇੱਕ ਜੋੜੀ ਹੁੰਦੀ ਹੈ "ਕੀ ਲੱਭਣਾ ਹੈ - ਕਿਸ ਨਾਲ ਬਦਲਣਾ ਹੈ" ਜਾਂ, ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਅਗਲੀ ਲਾਈਨ।
- ਇੱਕੂਮੂਲੇਟਰ ਫੰਕਸ਼ਨ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਰੱਖਦਾ ਹੈ ਰਾਜ ਸ਼ੁਰੂਆਤੀ ਮੁੱਲ (ਪਹਿਲਾ ਪਤਾ 199034, ਸੇਂਟ ਪੀਟਰਸਬਰਗ, ਸਟਰ. ਬੇਰਿੰਗਾ, ਡੀ. 1) ਅਤੇ ਇਸ 'ਤੇ ਇੱਕ ਐਕਯੂਮੂਲੇਟਰ ਫੰਕਸ਼ਨ ਕਰਦਾ ਹੈ - ਸਟੈਂਡਰਡ ਐਮ-ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਬਦਲਣ ਦੀ ਕਾਰਵਾਈ ਟੈਕਸਟ।ਬਦਲੋ (ਐਕਸਲ ਦੇ SUBSTITUTE ਫੰਕਸ਼ਨ ਦੇ ਸਮਾਨ)। ਇਸਦਾ ਸੰਟੈਕਸ ਹੈ:
Text.Replace (ਮੂਲ ਟੈਕਸਟ, ਜੋ ਅਸੀਂ ਲੱਭ ਰਹੇ ਹਾਂ, ਅਸੀਂ ਕਿਸ ਨਾਲ ਬਦਲ ਰਹੇ ਹਾਂ)
ਅਤੇ ਇੱਥੇ ਸਾਡੇ ਕੋਲ ਹੈ:
- ਰਾਜ ਸਾਡਾ ਗੰਦਾ ਪਤਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਪਿਆ ਹੈ ਰਾਜ (ਉਥੋਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਬੀਜ)
- ਮੌਜੂਦਾ[ਖੋਜ] - ਖੇਤਰ ਮੁੱਲ ਲਭਣ ਲਈ ਸੂਚੀ ਦੀ ਅਗਲੀ ਦੁਹਰਾਈ ਐਂਟਰੀ ਤੋਂ ਡਾਇਰੈਕਟਰੀ, ਜੋ ਵੇਰੀਏਬਲ ਵਿੱਚ ਹੈ ਮੌਜੂਦਾ
- ਮੌਜੂਦਾ[ਬਦਲੋ] - ਖੇਤਰ ਮੁੱਲ ਬਦਲ ਸੂਚੀ ਦੀ ਅਗਲੀ ਦੁਹਰਾਈ ਐਂਟਰੀ ਤੋਂ ਡਾਇਰੈਕਟਰੀਵਿੱਚ ਪਿਆ ਹੋਇਆ ਮੌਜੂਦਾ
ਇਸ ਤਰ੍ਹਾਂ, ਹਰੇਕ ਪਤੇ ਲਈ, ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸਾਰੀਆਂ ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਇੱਕ ਪੂਰਾ ਚੱਕਰ ਹਰ ਵਾਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, [ਲੱਭੋ] ਖੇਤਰ ਦੇ ਟੈਕਸਟ ਨੂੰ [ਬਦਲੋ] ਖੇਤਰ ਦੇ ਮੁੱਲ ਨਾਲ ਬਦਲਦੇ ਹੋਏ।
ਉਮੀਦ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਇਹ ਵਿਚਾਰ ਮਿਲ ਗਿਆ ਹੈ 🙂
- ਫਾਰਮੂਲੇ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਟੈਕਸਟ ਨੂੰ ਬਲਕ ਬਦਲੋ
- ਪਾਵਰ ਕਿਊਰੀ ਵਿੱਚ ਰੈਗੂਲਰ ਐਕਸਪ੍ਰੈਸ਼ਨ (RegExp)