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

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

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

ਅਸੀਂ ਪਾਇਥਨ ਅਤੇ ਆਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵਿਸ਼ਲੇਸ਼ਣਾਤਮਕ ਵਿੰਡੋ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਲੋਡ ਕਰਨ ਤੋਂ ਲੈ ਕੇ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਪੂਰੇ ਮਾਰਗ ਦੁਆਰਾ ਕਦਮ-ਦਰ-ਕਦਮ ਅੱਗੇ ਵਧਾਂਗੇ।

ਸਮੱਗਰੀ

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

1. R ਅਤੇ Python ਵਿਚਕਾਰ ਮੁੱਖ ਸੰਟੈਕਸ ਅੰਤਰ
   1.1. ਪੈਕੇਜ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਐਕਸੈਸ ਕਰਨਾ
   1.2. ਅਸਾਈਨਮੈਂਟ
   1.3. ਇੰਡੈਕਸਿੰਗ
   1.4. ਢੰਗ ਅਤੇ ਓ.ਓ.ਪੀ
   1.5. ਪਾਈਪਲਾਈਨਾਂ
   1.6. ਡਾਟਾ ਬਣਤਰ
2. ਪੈਕੇਜਾਂ ਬਾਰੇ ਕੁਝ ਸ਼ਬਦ ਜੋ ਅਸੀਂ ਵਰਤਾਂਗੇ
   2.1. ਸੁਥਰਾ
   2.2. ਡੇਟਾ.ਟੈਬਲ
   2.3. ਪੰਡਾਸ
3. ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰ ਰਿਹਾ ਹੈ
4. ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
5. ਡਾਟਾਫ੍ਰੇਮ ਬਣਾਉਣਾ
6. ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੇ ਕਾਲਮਾਂ ਦੀ ਚੋਣ ਕਰਨਾ
7. ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ
8. ਗਰੁੱਪਿੰਗ ਅਤੇ ਏਗਰੀਗੇਸ਼ਨ
9. ਟੇਬਲਾਂ ਦਾ ਲੰਬਕਾਰੀ ਸੰਘ (UNION)
10. ਟੇਬਲਾਂ ਦਾ ਹਰੀਜੱਟਲ ਜੋੜ (ਸ਼ਾਮਲ)
11. ਮੂਲ ਵਿੰਡੋ ਫੰਕਸ਼ਨ ਅਤੇ ਗਣਨਾ ਕੀਤੇ ਕਾਲਮ
12. R ਅਤੇ Python ਵਿੱਚ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਵਿਧੀਆਂ ਵਿਚਕਾਰ ਪੱਤਰ ਵਿਹਾਰ ਸਾਰਣੀ
13. ਸਿੱਟਾ
14. ਤੁਸੀਂ ਕਿਸ ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ ਇਸ ਬਾਰੇ ਇੱਕ ਛੋਟਾ ਸਰਵੇਖਣ

ਜੇ ਤੁਸੀਂ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਮੇਰਾ ਲੱਭ ਸਕਦੇ ਹੋ ਤਾਰ и YouTube ਚੈਨਲ। ਜ਼ਿਆਦਾਤਰ ਸਮੱਗਰੀ ਆਰ ਭਾਸ਼ਾ ਨੂੰ ਸਮਰਪਿਤ ਹੈ।

R ਅਤੇ Python ਵਿਚਕਾਰ ਮੁੱਖ ਸੰਟੈਕਸ ਅੰਤਰ

ਤੁਹਾਡੇ ਲਈ Python ਤੋਂ R ਵਿੱਚ ਸਵਿਚ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਣ ਲਈ, ਜਾਂ ਇਸਦੇ ਉਲਟ, ਮੈਂ ਕੁਝ ਮੁੱਖ ਨੁਕਤੇ ਦੇਵਾਂਗਾ ਜਿਨ੍ਹਾਂ ਵੱਲ ਤੁਹਾਨੂੰ ਧਿਆਨ ਦੇਣ ਦੀ ਲੋੜ ਹੈ।

ਪੈਕੇਜ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਐਕਸੈਸ ਕਰਨਾ

ਇੱਕ ਵਾਰ ਇੱਕ ਪੈਕੇਜ ਨੂੰ R ਵਿੱਚ ਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਇਸਦੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਲਈ ਪੈਕੇਜ ਦਾ ਨਾਮ ਦੇਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ ਇਹ ਆਰ ਵਿੱਚ ਆਮ ਨਹੀਂ ਹੈ, ਪਰ ਇਹ ਸਵੀਕਾਰਯੋਗ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਇਸਦੇ ਕਿਸੇ ਇੱਕ ਫੰਕਸ਼ਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਪੈਕੇਜ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ, ਪਰ ਪੈਕੇਜ ਦਾ ਨਾਮ ਅਤੇ ਫੰਕਸ਼ਨ ਦਾ ਨਾਮ ਨਿਰਧਾਰਤ ਕਰਕੇ ਇਸਨੂੰ ਕਾਲ ਕਰੋ। R ਵਿੱਚ ਪੈਕੇਜ ਅਤੇ ਫੰਕਸ਼ਨ ਨਾਮਾਂ ਵਿਚਕਾਰ ਵਿਭਾਜਕ ਇੱਕ ਡਬਲ ਕੋਲੋਨ ਹੈ। package_name::function_name().

ਪਾਈਥਨ ਵਿੱਚ, ਇਸਦੇ ਉਲਟ, ਇੱਕ ਪੈਕੇਜ ਦੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ ਤੇ ਇਸਦਾ ਨਾਮ ਦੱਸ ਕੇ ਕਾਲ ਕਰਨਾ ਕਲਾਸਿਕ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਇੱਕ ਪੈਕੇਜ ਡਾਊਨਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਛੋਟਾ ਨਾਮ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ. pandas ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਉਪਨਾਮ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ pd. ਇੱਕ ਪੈਕੇਜ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਬਿੰਦੀ ਦੁਆਰਾ ਐਕਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ package_name.function_name().

ਅਸਾਈਨਮੈਂਟ

R ਵਿੱਚ, ਕਿਸੇ ਵਸਤੂ ਨੂੰ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਇੱਕ ਤੀਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਆਮ ਗੱਲ ਹੈ। obj_name <- value, ਹਾਲਾਂਕਿ ਇੱਕ ਸਿੰਗਲ ਬਰਾਬਰ ਚਿੰਨ੍ਹ ਦੀ ਇਜਾਜ਼ਤ ਹੈ, R ਵਿੱਚ ਸਿੰਗਲ ਬਰਾਬਰ ਚਿੰਨ੍ਹ ਮੁੱਖ ਤੌਰ 'ਤੇ ਫੰਕਸ਼ਨ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਮੁੱਲ ਪਾਸ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਪਾਈਥਨ ਵਿੱਚ, ਅਸਾਈਨਮੈਂਟ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਸਿੰਗਲ ਬਰਾਬਰ ਚਿੰਨ੍ਹ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ obj_name = value.

ਇੰਡੈਕਸਿੰਗ

ਇੱਥੇ ਵੀ ਕਾਫ਼ੀ ਮਹੱਤਵਪੂਰਨ ਅੰਤਰ ਹਨ. R ਵਿੱਚ, ਇੰਡੈਕਸਿੰਗ ਇੱਕ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਨਤੀਜੇ ਵਾਲੀ ਰੇਂਜ ਵਿੱਚ ਸਾਰੇ ਨਿਰਧਾਰਤ ਤੱਤ ਸ਼ਾਮਲ ਕਰਦੀ ਹੈ,

ਪਾਈਥਨ ਵਿੱਚ, ਇੰਡੈਕਸਿੰਗ ਜ਼ੀਰੋ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਚੁਣੀ ਗਈ ਰੇਂਜ ਵਿੱਚ ਸੂਚਕਾਂਕ ਵਿੱਚ ਨਿਰਧਾਰਤ ਆਖਰੀ ਤੱਤ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦਾ ਹੈ। ਇਸ ਲਈ ਡਿਜ਼ਾਈਨ x[i:j] ਪਾਈਥਨ ਵਿੱਚ ਜੇ ਐਲੀਮੈਂਟ ਸ਼ਾਮਲ ਨਹੀਂ ਹੋਵੇਗਾ।

ਆਰ ਨੋਟੇਸ਼ਨ ਵਿੱਚ, ਨਕਾਰਾਤਮਕ ਸੂਚਕਾਂਕ ਵਿੱਚ ਵੀ ਅੰਤਰ ਹਨ x[-1] ਆਖਰੀ ਨੂੰ ਛੱਡ ਕੇ ਵੈਕਟਰ ਦੇ ਸਾਰੇ ਤੱਤ ਵਾਪਸ ਕਰ ਦੇਵੇਗਾ। ਪਾਈਥਨ ਵਿੱਚ, ਇੱਕ ਸਮਾਨ ਸੰਕੇਤ ਕੇਵਲ ਆਖਰੀ ਤੱਤ ਵਾਪਸ ਕਰੇਗਾ।

ਢੰਗ ਅਤੇ ਓ.ਓ.ਪੀ

ਆਰ ਓਓਪੀ ਨੂੰ ਆਪਣੇ ਤਰੀਕੇ ਨਾਲ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਮੈਂ ਇਸ ਬਾਰੇ ਲੇਖ ਵਿੱਚ ਲਿਖਿਆ ਸੀ "ਆਰ ਭਾਸ਼ਾ ਵਿੱਚ OOP (ਭਾਗ 1): S3 ਕਲਾਸਾਂ". ਆਮ ਤੌਰ 'ਤੇ, R ਇੱਕ ਕਾਰਜਸ਼ੀਲ ਭਾਸ਼ਾ ਹੈ, ਅਤੇ ਇਸ ਵਿੱਚ ਹਰ ਚੀਜ਼ ਫੰਕਸ਼ਨਾਂ 'ਤੇ ਬਣੀ ਹੋਈ ਹੈ। ਇਸ ਲਈ, ਉਦਾਹਰਨ ਲਈ, ਐਕਸਲ ਉਪਭੋਗਤਾਵਾਂ ਲਈ, 'ਤੇ ਜਾਓ tydiverse ਇਸ ਨੂੰ ਵੱਧ ਆਸਾਨ ਹੋ ਜਾਵੇਗਾ pandas. ਹਾਲਾਂਕਿ ਇਹ ਮੇਰੀ ਵਿਅਕਤੀਗਤ ਰਾਏ ਹੋ ਸਕਦੀ ਹੈ।

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

ਪਾਈਪਲਾਈਨਾਂ

ਸ਼ਾਇਦ ਇਹ ਇਸ ਲਈ ਨਾਮ ਹੈ pandas ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਹੀ ਨਹੀਂ ਹੋਵੇਗਾ, ਪਰ ਮੈਂ ਇਸਦਾ ਮਤਲਬ ਸਮਝਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗਾ।

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

ਆਉ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਦੀ ਉਦਾਹਰਨ ਲਈਏ, ਜਿੱਥੇ ਅਸੀਂ ਵੱਖਰੇ ਆਬਜੈਕਟ ਵਿੱਚ ਵਿਚਕਾਰਲੇ ਗਣਨਾਵਾਂ ਨੂੰ ਸਟੋਰ ਕਰਦੇ ਹਾਂ:

temp_object <- func1()
temp_object2 <- func2(temp_object )
obj <- func3(temp_object2 )

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

ਜਾਂ ਇਸ ਤੋਂ ਵੀ ਮਾੜਾ, ਪਰ ਐਕਸਲ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਵਧੇਰੇ ਜਾਣੂ।

obj  <- func3(func2(func1()))

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

ਅਸੀਂ R ਵਿੱਚ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ ਕਈ ਪਹੁੰਚਾਂ ਨੂੰ ਦੇਖਾਂਗੇ, ਅਤੇ ਉਹ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਸਮਾਨ ਕਾਰਵਾਈਆਂ ਕਰਦੇ ਹਨ।

ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਪਾਈਪਲਾਈਨਾਂ tidyverse ਆਪਰੇਟਰ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ %>%.

obj <- func1() %>% 
            func2() %>%
            func3()

ਇਸ ਤਰ੍ਹਾਂ ਅਸੀਂ ਕੰਮ ਦਾ ਨਤੀਜਾ ਲੈਂਦੇ ਹਾਂ func1() ਅਤੇ ਇਸਨੂੰ ਪਹਿਲੀ ਦਲੀਲ ਵਜੋਂ ਪਾਸ ਕਰੋ func2(), ਫਿਰ ਅਸੀਂ ਇਸ ਗਣਨਾ ਦੇ ਨਤੀਜੇ ਨੂੰ ਪਹਿਲੀ ਦਲੀਲ ਵਜੋਂ ਪਾਸ ਕਰਦੇ ਹਾਂ func3(). ਅਤੇ ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਵਸਤੂ ਵਿੱਚ ਕੀਤੀਆਂ ਗਈਆਂ ਸਾਰੀਆਂ ਗਣਨਾਵਾਂ ਲਿਖਦੇ ਹਾਂ obj <-.

ਉਪਰੋਕਤ ਸਾਰੇ ਨੂੰ ਇਸ ਮੀਮ ਦੁਆਰਾ ਸ਼ਬਦਾਂ ਨਾਲੋਂ ਬਿਹਤਰ ਦਰਸਾਇਆ ਗਿਆ ਹੈ:

В data.table ਚੇਨਾਂ ਦੀ ਵਰਤੋਂ ਇਸੇ ਤਰ੍ਹਾਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

newDT <- DT[where, select|update|do, by][where, select|update|do, by][where, select|update|do, by]

ਹਰੇਕ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਤੁਸੀਂ ਪਿਛਲੀ ਕਾਰਵਾਈ ਦੇ ਨਤੀਜੇ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

В pandas ਅਜਿਹੇ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਇੱਕ ਬਿੰਦੀ ਦੁਆਰਾ ਵੱਖ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

obj = df.fun1().fun2().fun3()

ਉਹ. ਅਸੀਂ ਆਪਣਾ ਮੇਜ਼ ਲੈਂਦੇ ਹਾਂ df ਅਤੇ ਉਸਦੀ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ fun1(), ਫਿਰ ਅਸੀਂ ਪ੍ਰਾਪਤ ਨਤੀਜੇ 'ਤੇ ਵਿਧੀ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਾਂ fun2(), ਦੇ ਬਾਅਦ fun3(). ਨਤੀਜਾ ਨਤੀਜਾ ਇੱਕ ਵਸਤੂ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ obj .

ਡਾਟਾ ਬਣਤਰ

R ਅਤੇ Python ਵਿੱਚ ਡਾਟਾ ਬਣਤਰ ਸਮਾਨ ਹਨ, ਪਰ ਵੱਖ-ਵੱਖ ਨਾਮ ਹਨ।

ਵੇਰਵਾ
ਵਿੱਚ ਨਾਮ ਆਰ
Python/pandas ਵਿੱਚ ਨਾਮ

ਟੇਬਲ ਬਣਤਰ
data.frame, data.table, tibble
ਡਾਟਾਫ੍ਰੇਮ

ਮੁੱਲਾਂ ਦੀ ਇੱਕ-ਅਯਾਮੀ ਸੂਚੀ
ਵੈਕਟਰ
ਪਾਂਡਾ ਵਿੱਚ ਲੜੀ ਜਾਂ ਸ਼ੁੱਧ ਪਾਈਥਨ ਵਿੱਚ ਸੂਚੀ

ਬਹੁ-ਪੱਧਰੀ ਗੈਰ-ਸਾਰਣੀ ਬਣਤਰ
ਸੂਚੀ
ਸ਼ਬਦਕੋਸ਼ (ਡਿਕਟ)

ਅਸੀਂ ਹੇਠਾਂ ਕੁਝ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਸੰਟੈਕਸ ਵਿੱਚ ਅੰਤਰ ਦੇਖਾਂਗੇ।

ਪੈਕੇਜਾਂ ਬਾਰੇ ਕੁਝ ਸ਼ਬਦ ਜੋ ਅਸੀਂ ਵਰਤਾਂਗੇ

ਪਹਿਲਾਂ, ਮੈਂ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਪੈਕੇਜਾਂ ਬਾਰੇ ਥੋੜਾ ਜਿਹਾ ਦੱਸਾਂਗਾ ਜਿਨ੍ਹਾਂ ਤੋਂ ਤੁਸੀਂ ਇਸ ਲੇਖ ਦੇ ਦੌਰਾਨ ਜਾਣੂ ਹੋਵੋਗੇ.

ਸੁਥਰਾ

ਸਰਕਾਰੀ ਵੈਬਸਾਈਟ: tidyverse.org

ਲਾਇਬਰੇਰੀ ਨੂੰ tidyverse RStudio ਦੇ ਸੀਨੀਅਰ ਰਿਸਰਚ ਸਾਇੰਟਿਸਟ ਹੇਡਲੀ ਵਿੱਕਮ ਦੁਆਰਾ ਲਿਖਿਆ ਗਿਆ। tidyverse ਪੈਕੇਜਾਂ ਦਾ ਇੱਕ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਸਮੂਹ ਹੈ ਜੋ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ 5 CRAN ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ ਚੋਟੀ ਦੇ 10 ਡਾਊਨਲੋਡਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ।

ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਕੋਰ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਪੈਕੇਜ ਹੁੰਦੇ ਹਨ: ggplot2, dplyr, tidyr, readr, purrr, tibble, stringr, forcats. ਇਹਨਾਂ ਪੈਕੇਜਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਦਾ ਉਦੇਸ਼ ਇੱਕ ਖਾਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨਾ ਹੈ। ਉਦਾਹਰਣ ਲਈ dplyr ਡਾਟਾ ਹੇਰਾਫੇਰੀ ਲਈ ਬਣਾਇਆ ਗਿਆ, tidyr ਡੇਟਾ ਨੂੰ ਇੱਕ ਸੁਚੱਜੇ ਰੂਪ ਵਿੱਚ ਲਿਆਉਣ ਲਈ, stringr ਸਤਰ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨਾ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ggplot2 ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਡੇਟਾ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਟੂਲਸ ਵਿੱਚੋਂ ਇੱਕ ਹੈ।

ਫਾਇਦਾ tidyverse ਸਾਦਗੀ ਅਤੇ ਸੰਟੈਕਸ ਨੂੰ ਪੜ੍ਹਨ ਵਿੱਚ ਆਸਾਨ ਹੈ, ਜੋ ਕਿ ਬਹੁਤ ਸਾਰੇ ਤਰੀਕਿਆਂ ਨਾਲ SQL ਪੁੱਛਗਿੱਛ ਭਾਸ਼ਾ ਦੇ ਸਮਾਨ ਹੈ।

ਡੇਟਾ.ਟੈਬਲ

ਸਰਕਾਰੀ ਵੈਬਸਾਈਟ: r-datatable.com

ਲੇਖਕ data.table H2O.ai ਦਾ ਮੈਟ ਡੋਲ ਹੈ।

ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਪਹਿਲੀ ਰਿਲੀਜ਼ 2006 ਵਿੱਚ ਹੋਈ ਸੀ।

ਪੈਕੇਜ ਸੰਟੈਕਸ ਇੰਨਾ ਸੁਵਿਧਾਜਨਕ ਨਹੀਂ ਹੈ ਜਿੰਨਾ ਵਿੱਚ tidyverse ਅਤੇ R ਵਿੱਚ ਕਲਾਸਿਕ ਡੇਟਾਫ੍ਰੇਮਾਂ ਦੀ ਵਧੇਰੇ ਯਾਦ ਦਿਵਾਉਂਦਾ ਹੈ, ਪਰ ਉਸੇ ਸਮੇਂ ਕਾਰਜਸ਼ੀਲਤਾ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਵਿਸਤਾਰ ਕੀਤਾ ਗਿਆ ਹੈ।

ਇਸ ਪੈਕੇਜ ਵਿੱਚ ਸਾਰਣੀ ਦੇ ਨਾਲ ਸਾਰੀਆਂ ਹੇਰਾਫੇਰੀਆਂ ਦਾ ਵਰਣਨ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਜੇਕਰ ਤੁਸੀਂ ਸੰਟੈਕਸ ਦਾ ਅਨੁਵਾਦ ਕਰਦੇ ਹੋ data.table SQL ਵਿੱਚ, ਤੁਹਾਨੂੰ ਕੁਝ ਅਜਿਹਾ ਮਿਲਦਾ ਹੈ: data.table[ WHERE, SELECT, GROUP BY ]

ਇਸ ਪੈਕੇਜ ਦੀ ਤਾਕਤ ਵੱਡੀ ਮਾਤਰਾ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਦੀ ਗਤੀ ਹੈ।

ਪੰਡਾਸ

ਸਰਕਾਰੀ ਵੈਬਸਾਈਟ: pandas.pydata.org

ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਨਾਮ ਅਰਥ ਗਣਿਤ ਸ਼ਬਦ "ਪੈਨਲ ਡੇਟਾ" ਤੋਂ ਆਇਆ ਹੈ, ਜੋ ਜਾਣਕਾਰੀ ਦੇ ਬਹੁ-ਆਯਾਮੀ ਢਾਂਚੇ ਵਾਲੇ ਸੈੱਟਾਂ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਲੇਖਕ pandas ਅਮਰੀਕੀ ਵੇਸ ਮੈਕਕਿਨੀ ਹੈ।

ਜਦੋਂ ਪਾਈਥਨ ਵਿੱਚ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਗੱਲ ਆਉਂਦੀ ਹੈ, ਬਰਾਬਰ pandas ਨੰ. ਇੱਕ ਬਹੁਤ ਹੀ ਮਲਟੀਫੰਕਸ਼ਨਲ, ਉੱਚ-ਪੱਧਰੀ ਪੈਕੇਜ ਜੋ ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੀ ਸਰੋਤ ਤੋਂ ਡੇਟਾ ਲੋਡ ਕਰਨ ਤੋਂ ਲੈ ਕੇ ਇਸਦੀ ਕਲਪਨਾ ਕਰਨ ਤੱਕ, ਡੇਟਾ ਨਾਲ ਕੋਈ ਹੇਰਾਫੇਰੀ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਵਾਧੂ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰ ਰਿਹਾ ਹੈ

ਇਸ ਲੇਖ ਵਿੱਚ ਵਿਚਾਰੇ ਗਏ ਪੈਕੇਜ ਬੁਨਿਆਦੀ R ਅਤੇ Python ਡਿਸਟਰੀਬਿਊਸ਼ਨ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹਨ। ਹਾਲਾਂਕਿ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਚੇਤਾਵਨੀ ਹੈ, ਜੇਕਰ ਤੁਸੀਂ ਐਨਾਕਾਂਡਾ ਡਿਸਟਰੀਬਿਊਸ਼ਨ ਨੂੰ ਇੰਸਟਾਲ ਕੀਤਾ ਹੈ, ਤਾਂ ਇਸ ਤੋਂ ਇਲਾਵਾ ਵੀ ਇੰਸਟਾਲ ਕਰੋ pandas ਦੀ ਲੋੜ ਨਹੀ ਹੈ.

ਆਰ ਵਿੱਚ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨਾ

ਜੇਕਰ ਤੁਸੀਂ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਵਾਰ RStudio ਵਿਕਾਸ ਵਾਤਾਵਰਣ ਨੂੰ ਖੋਲ੍ਹਿਆ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਸ਼ਾਇਦ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹੋਵੋਗੇ ਕਿ R ਵਿੱਚ ਲੋੜੀਂਦੇ ਪੈਕੇਜ ਨੂੰ ਕਿਵੇਂ ਇੰਸਟਾਲ ਕਰਨਾ ਹੈ। ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨ ਲਈ, ਸਟੈਂਡਰਡ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰੋ। install.packages() ਇਸਨੂੰ ਸਿੱਧੇ ਆਰ ਵਿੱਚ ਚਲਾ ਕੇ।

# установка пакетов
install.packages("vroom")
install.packages("readr")
install.packages("dplyr")
install.packages("data.table")

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

# подключение или импорт пакетов в рабочее окружение
library(vroom)
library(readr)
library(dplyr)
library(data.table)

ਪਾਈਥਨ ਵਿੱਚ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨਾ

ਇਸ ਲਈ, ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਸ਼ੁੱਧ ਪਾਈਥਨ ਸਥਾਪਿਤ ਹੈ, ਤਾਂ pandas ਤੁਹਾਨੂੰ ਇਸ ਨੂੰ ਦਸਤੀ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ. ਤੁਹਾਡੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਆਧਾਰ 'ਤੇ ਕਮਾਂਡ ਲਾਈਨ, ਜਾਂ ਟਰਮੀਨਲ ਖੋਲ੍ਹੋ ਅਤੇ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਦਿਓ।

pip install pandas

ਫਿਰ ਅਸੀਂ ਪਾਈਥਨ ਤੇ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ ਅਤੇ ਕਮਾਂਡ ਨਾਲ ਇੰਸਟਾਲ ਕੀਤੇ ਪੈਕੇਜ ਨੂੰ ਆਯਾਤ ਕਰਦੇ ਹਾਂ import.

import pandas as pd

ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਡੇਟਾ ਮਾਈਨਿੰਗ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਕਦਮਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। Python ਅਤੇ R ਦੋਵੇਂ, ਜੇਕਰ ਲੋੜ ਹੋਵੇ, ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੀ ਸਰੋਤ ਤੋਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਵਿਆਪਕ ਮੌਕੇ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ: ਸਥਾਨਕ ਫਾਈਲਾਂ, ਇੰਟਰਨੈਟ ਤੋਂ ਫਾਈਲਾਂ, ਵੈਬਸਾਈਟਾਂ, ਹਰ ਕਿਸਮ ਦੇ ਡੇਟਾਬੇਸ।

ਲੇਖ ਦੇ ਦੌਰਾਨ ਅਸੀਂ ਕਈ ਡੇਟਾਸੈਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ:

1. ਗੂਗਲ ਵਿਸ਼ਲੇਸ਼ਣ ਤੋਂ ਦੋ ਡਾਊਨਲੋਡ।
2. ਟਾਇਟੈਨਿਕ ਯਾਤਰੀ ਡੇਟਾਸੈਟ

ਸਾਰਾ ਡਾਟਾ ਮੇਰੇ 'ਤੇ ਹੈ GitHub csv ਅਤੇ tsv ਫਾਈਲਾਂ ਦੇ ਰੂਪ ਵਿੱਚ. ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਕਿੱਥੋਂ ਮੰਗਾਂਗੇ?

R ਵਿੱਚ ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ: tidyverse, vroom, readr

ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਡਾਟਾ ਲੋਡ ਕਰਨ ਲਈ tidyverse ਇੱਥੇ ਦੋ ਪੈਕੇਜ ਹਨ: vroom, readr. vroom ਵਧੇਰੇ ਆਧੁਨਿਕ, ਪਰ ਭਵਿੱਖ ਵਿੱਚ ਪੈਕੇਜਾਂ ਨੂੰ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਤੋਂ ਹਵਾਲਾ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ vroom.

ਵਰੂਮ ਬਨਾਮ ਰੀਡਰ
ਦੀ ਰਿਹਾਈ ਕੀ ਕਰਦੀ ਹੈ vroom ਲਈ ਮਤਲਬ readr? ਫਿਲਹਾਲ ਅਸੀਂ ਦੋ ਪੈਕੇਜਾਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਵਿਕਸਤ ਕਰਨ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਹੇ ਹਾਂ, ਪਰ ਸੰਭਾਵਨਾ ਹੈ ਕਿ ਅਸੀਂ ਭਵਿੱਖ ਵਿੱਚ ਪੈਕੇਜਾਂ ਨੂੰ ਇਕਜੁੱਟ ਕਰਾਂਗੇ। ਵਰੂਮ ਦੀ ਆਲਸੀ ਰੀਡਿੰਗ ਦਾ ਇੱਕ ਨੁਕਸਾਨ ਇਹ ਹੈ ਕਿ ਕੁਝ ਡਾਟਾ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਸਾਹਮਣੇ ਨਹੀਂ ਲਿਆਂਦਾ ਜਾ ਸਕਦਾ, ਇਸ ਲਈ ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਇਕਮੁੱਠ ਕਰਨਾ ਹੈ ਇਸ ਬਾਰੇ ਕੁਝ ਸੋਚਣ ਦੀ ਲੋੜ ਹੈ।

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

ਇਸ ਲੇਖ ਵਿੱਚ ਅਸੀਂ ਦੋਵੇਂ ਡਾਟਾ ਲੋਡਿੰਗ ਪੈਕੇਜਾਂ ਨੂੰ ਦੇਖਾਂਗੇ:

R: vroom ਪੈਕੇਜ ਵਿੱਚ ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

# install.packages("vroom")
library(vroom)

# Чтение данных
## vroom
ga_nov  <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- vroom("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

R: ਰੀਡਰ ਵਿੱਚ ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

# install.packages("readr")
library(readr)

# Чтение данных
## readr
ga_nov  <- read_tsv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- read_tsv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

ਪੈਕੇਜ ਵਿੱਚ vroom, csv/tsv ਡੇਟਾ ਫਾਰਮੈਟ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ, ਲੋਡਿੰਗ ਉਸੇ ਨਾਮ ਦੇ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ vroom(), ਪੈਕੇਜ ਵਿੱਚ readr ਅਸੀਂ ਹਰੇਕ ਫਾਰਮੈਟ ਲਈ ਇੱਕ ਵੱਖਰਾ ਫੰਕਸ਼ਨ ਵਰਤਦੇ ਹਾਂ read_tsv() и read_csv().

R: data.table ਵਿੱਚ ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

В data.table ਡਾਟਾ ਲੋਡ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ fread().

R: data.table ਪੈਕੇਜ ਵਿੱਚ ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

# install.packages("data.table")
library(data.table)

## data.table
ga_nov  <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_nowember.csv")
ga_dec  <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/ga_december.csv")
titanic <- fread("https://raw.githubusercontent.com/selesnow/publications/master/data_example/r_python_data/titanic.csv")

Python ਵਿੱਚ ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ: pandas

ਜੇਕਰ ਅਸੀਂ R ਪੈਕੇਜਾਂ ਨਾਲ ਤੁਲਨਾ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਇਸ ਕੇਸ ਵਿੱਚ ਸੰਟੈਕਸ ਸਭ ਤੋਂ ਨੇੜੇ ਹੈ pandas ਹੋ ਜਾਵੇਗਾ readr, ਕਿਉਂਕਿ pandas ਕਿਤੇ ਵੀ ਡੇਟਾ ਦੀ ਬੇਨਤੀ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਇਸ ਪੈਕੇਜ ਵਿੱਚ ਫੰਕਸ਼ਨਾਂ ਦਾ ਪੂਰਾ ਪਰਿਵਾਰ ਹੈ read_*().

• read_csv()
• read_excel()
• read_sql()
• read_json()
• read_html()

ਅਤੇ ਕਈ ਹੋਰ ਫੰਕਸ਼ਨ ਵੱਖ-ਵੱਖ ਫਾਰਮੈਟਾਂ ਤੋਂ ਡਾਟਾ ਪੜ੍ਹਨ ਲਈ ਤਿਆਰ ਕੀਤੇ ਗਏ ਹਨ। ਪਰ ਸਾਡੇ ਉਦੇਸ਼ਾਂ ਲਈ ਇਹ ਕਾਫ਼ੀ ਹੈ read_table() ਜ read_csv() ਦਲੀਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਤੰਬਰ ਨੂੰ ਕਾਲਮ ਵਿਭਾਜਕ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ।

Python ਵਿੱਚ ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ: pandas

import pandas as pd

ga_nov  = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/ga_nowember.csv", sep = "t")
ga_dec  = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/ga_december.csv", sep = "t")
titanic = pd.read_csv("https://raw.githubusercontent.com/selesnow/publications/master/data_example/russian_text_in_r/titanic.csv")

ਡਾਟਾਫ੍ਰੇਮ ਬਣਾਉਣਾ

ਟੇਬਲ ਮਸ਼ਹੂਰ, ਜਿਸਨੂੰ ਅਸੀਂ ਲੋਡ ਕੀਤਾ ਹੈ, ਉੱਥੇ ਇੱਕ ਖੇਤਰ ਹੈ ਲਿੰਗ, ਜੋ ਯਾਤਰੀ ਦੇ ਲਿੰਗ ਪਛਾਣਕਰਤਾ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ।

ਪਰ ਯਾਤਰੀ ਲਿੰਗ ਦੇ ਰੂਪ ਵਿੱਚ ਡੇਟਾ ਦੀ ਵਧੇਰੇ ਸੁਵਿਧਾਜਨਕ ਪੇਸ਼ਕਾਰੀ ਲਈ, ਤੁਹਾਨੂੰ ਲਿੰਗ ਕੋਡ ਦੀ ਬਜਾਏ ਨਾਮ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਛੋਟੀ ਡਾਇਰੈਕਟਰੀ ਬਣਾਵਾਂਗੇ, ਇੱਕ ਸਾਰਣੀ ਜਿਸ ਵਿੱਚ ਕ੍ਰਮਵਾਰ ਕੇਵਲ 2 ਕਾਲਮ (ਕੋਡ ਅਤੇ ਲਿੰਗ ਨਾਮ) ਅਤੇ 2 ਕਤਾਰਾਂ ਹੋਣਗੀਆਂ।

R ਵਿੱਚ ਇੱਕ ਡੇਟਾਫ੍ਰੇਮ ਬਣਾਉਣਾ: tidyverse, dplyr

ਹੇਠਾਂ ਦਿੱਤੀ ਕੋਡ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲੋੜੀਂਦਾ ਡੇਟਾਫ੍ਰੇਮ ਬਣਾਉਂਦੇ ਹਾਂ tibble() .

R: dplyr ਵਿੱਚ ਇੱਕ ਡੇਟਾਫ੍ਰੇਮ ਬਣਾਉਣਾ

## dplyr
### создаём справочник
gender <- tibble(id = c(1, 2),
                 gender = c("female", "male"))

R: data.table ਵਿੱਚ ਇੱਕ ਡੇਟਾਫ੍ਰੇਮ ਬਣਾਉਣਾ

R: data.table ਵਿੱਚ ਇੱਕ ਡੇਟਾਫ੍ਰੇਮ ਬਣਾਉਣਾ

## data.table
### создаём справочник
gender <- data.table(id = c(1, 2),
                    gender = c("female", "male"))

ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਡੇਟਾਫ੍ਰੇਮ ਬਣਾਉਣਾ: ਪਾਂਡਾ

В pandas ਫਰੇਮਾਂ ਦੀ ਸਿਰਜਣਾ ਕਈ ਪੜਾਵਾਂ ਵਿੱਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਹਿਲਾਂ ਅਸੀਂ ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਬਣਾਉਂਦੇ ਹਾਂ, ਅਤੇ ਫਿਰ ਅਸੀਂ ਡਿਕਸ਼ਨਰੀ ਨੂੰ ਡੇਟਾਫ੍ਰੇਮ ਵਿੱਚ ਬਦਲਦੇ ਹਾਂ।

ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਡੇਟਾਫ੍ਰੇਮ ਬਣਾਉਣਾ: ਪਾਂਡਾ

# создаём дата фрейм
gender_dict = {'id': [1, 2],
               'gender': ["female", "male"]}
# преобразуем словарь в датафрейм
gender = pd.DataFrame.from_dict(gender_dict)

ਕਾਲਮ ਚੁਣਨਾ

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

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

R ਵਿੱਚ ਕਾਲਮ ਚੁਣਨਾ: tidyverse, dplyr

ਸੰਟੈਕਸ dplyr SQL ਕਿਊਰੀ ਭਾਸ਼ਾ ਦੇ ਸਮਾਨ ਹੈ, ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਤੋਂ ਜਾਣੂ ਹੋ ਤਾਂ ਤੁਸੀਂ ਜਲਦੀ ਹੀ ਇਸ ਪੈਕੇਜ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰ ਲਵੋਗੇ।

ਕਾਲਮ ਚੁਣਨ ਲਈ, ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ select().

ਹੇਠਾਂ ਕੋਡ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨਾਲ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਤਰੀਕਿਆਂ ਨਾਲ ਕਾਲਮ ਚੁਣ ਸਕਦੇ ਹੋ:

• ਲੋੜੀਂਦੇ ਕਾਲਮਾਂ ਦੇ ਨਾਮਾਂ ਦੀ ਸੂਚੀ ਬਣਾਉਣਾ
• ਰੈਗੂਲਰ ਸਮੀਕਰਨ ਵਰਤਦੇ ਹੋਏ ਕਾਲਮ ਦੇ ਨਾਮ ਵੇਖੋ
• ਕਾਲਮ ਵਿੱਚ ਮੌਜੂਦ ਡੇਟਾ ਦੀ ਕਿਸਮ ਜਾਂ ਕਿਸੇ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾ ਦੁਆਰਾ

R ਵਿੱਚ ਕਾਲਮ ਚੁਣਨਾ: dplyr

# Выбор нужных столбцов
## dplyr
### выбрать по названию столбцов
select(ga_nov, date, source, sessions)
### исключь по названию столбцов
select(ga_nov, -medium, -bounces)
### выбрать по регулярному выражению, стобцы имена которых заканчиваются на s
select(ga_nov, matches("s$"))
### выбрать по условию, выбираем только целочисленные столбцы
select_if(ga_nov, is.integer)

R: data.table ਵਿੱਚ ਕਾਲਮ ਚੁਣਨਾ

ਵਿਚ ਉਹੀ ਓਪਰੇਸ਼ਨ data.table ਥੋੜੇ ਵੱਖਰੇ ਤਰੀਕੇ ਨਾਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਲੇਖ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਮੈਂ ਇੱਕ ਵਰਣਨ ਪ੍ਰਦਾਨ ਕੀਤਾ ਸੀ ਕਿ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਕਿਹੜੀਆਂ ਆਰਗੂਮੈਂਟਾਂ ਹਨ data.table.

DT[i,j,by]

ਕਿੱਥੇ:
i - ਕਿੱਥੇ, i.e. ਕਤਾਰਾਂ ਦੁਆਰਾ ਫਿਲਟਰ ਕਰਨਾ
j - ਚੁਣੋ | ਅੱਪਡੇਟ | ਕਰੋ , i.e. ਕਾਲਮ ਚੁਣਨਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਦਲਣਾ
ਦੁਆਰਾ - ਡਾਟਾ ਗਰੁੱਪਿੰਗ

R: data.table ਵਿੱਚ ਕਾਲਮ ਚੁਣਨਾ

## data.table
### выбрать по названию столбцов
ga_nov[ , .(date, source, sessions) ]
### исключь по названию столбцов
ga_nov[ , .SD, .SDcols = ! names(ga_nov) %like% "medium|bounces" ]
### выбрать по регулярному выражению
ga_nov[, .SD, .SDcols = patterns("s$")]

ਪਰਿਵਰਤਨਸ਼ੀਲ .SD ਤੁਹਾਨੂੰ ਸਾਰੇ ਕਾਲਮਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਅਤੇ .SDcols ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੇ ਕਾਲਮਾਂ ਦੇ ਨਾਮ ਫਿਲਟਰ ਕਰਨ ਲਈ ਨਿਯਮਤ ਸਮੀਕਰਨ, ਜਾਂ ਹੋਰ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲੋੜੀਂਦੇ ਕਾਲਮਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੋ।

ਪਾਈਥਨ, ਪਾਂਡਾ ਵਿੱਚ ਕਾਲਮ ਚੁਣਨਾ

ਵਿੱਚ ਨਾਮ ਦੁਆਰਾ ਕਾਲਮ ਚੁਣਨ ਲਈ pandas ਇਹ ਉਹਨਾਂ ਦੇ ਨਾਵਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਕਾਫੀ ਹੈ। ਅਤੇ ਰੈਗੂਲਰ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਾਮ ਦੁਆਰਾ ਕਾਲਮਾਂ ਨੂੰ ਚੁਣਨ ਜਾਂ ਬਾਹਰ ਕੱਢਣ ਲਈ, ਤੁਹਾਨੂੰ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ drop() и filter(), ਅਤੇ ਦਲੀਲ ਧੁਰਾ = 1, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਦਰਸਾਉਂਦੇ ਹੋ ਕਿ ਕਤਾਰਾਂ ਦੀ ਬਜਾਏ ਕਾਲਮਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ।

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

ਪਾਈਥਨ ਵਿੱਚ ਕਾਲਮ ਚੁਣਨਾ: ਪਾਂਡਾ

# Выбор полей по названию
ga_nov[['date', 'source', 'sessions']]
# Исключить по названию
ga_nov.drop(['medium', 'bounces'], axis=1)
# Выбрать по регулярному выражению
ga_nov.filter(regex="s$", axis=1)
# Выбрать числовые поля
ga_nov.select_dtypes(include=['number'])
# Выбрать текстовые поля
ga_nov.select_dtypes(include=['object'])

ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ

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

R ਵਿੱਚ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ: tydyverse, dplyr

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

ਇੱਕ ਸਾਰਣੀ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਲਾਜ਼ੀਕਲ ਸਮੀਕਰਨ ਲਿਖਣ ਵੇਲੇ, ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਬਿਨਾਂ ਹਵਾਲੇ ਦੇ ਅਤੇ ਸਾਰਣੀ ਦੇ ਨਾਮ ਦੀ ਘੋਸ਼ਣਾ ਕੀਤੇ ਬਿਨਾਂ ਕਾਲਮ ਦੇ ਨਾਮ ਦਿਓ।

ਫਿਲਟਰ ਕਰਨ ਲਈ ਮਲਟੀਪਲ ਲਾਜ਼ੀਕਲ ਸਮੀਕਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਹੇਠਾਂ ਦਿੱਤੇ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ:

• & ਜਾਂ ਕੌਮਾ - ਲਾਜ਼ੀਕਲ AND
• | - ਲਾਜ਼ੀਕਲ OR

R: dplyr ਵਿੱਚ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ

# фильтрация строк
## dplyr
### фильтрация строк по одному условию
filter(ga_nov, source == "google")
### фильтр по двум условиям соединённым логическим и
filter(ga_nov, source == "google" & sessions >= 10)
### фильтр по двум условиям соединённым логическим или
filter(ga_nov, source == "google" | sessions >= 10)

R: data.table ਵਿੱਚ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ

ਜਿਵੇਂ ਕਿ ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਉੱਪਰ ਲਿਖਿਆ ਹੈ, ਵਿੱਚ data.table ਡੇਟਾ ਪਰਿਵਰਤਨ ਸੰਟੈਕਸ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਬੰਦ ਹੈ।

DT[i,j,by]

ਕਿੱਥੇ:
i - ਕਿੱਥੇ, i.e. ਕਤਾਰਾਂ ਦੁਆਰਾ ਫਿਲਟਰ ਕਰਨਾ
j - ਚੁਣੋ | ਅੱਪਡੇਟ | ਕਰੋ , i.e. ਕਾਲਮ ਚੁਣਨਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਦਲਣਾ
ਦੁਆਰਾ - ਡਾਟਾ ਗਰੁੱਪਿੰਗ

ਆਰਗੂਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ i, ਜਿਸਦਾ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਪਹਿਲਾ ਸਥਾਨ ਹੈ।

ਕਾਲਮਾਂ ਨੂੰ ਬਿਨਾਂ ਹਵਾਲਾ ਚਿੰਨ੍ਹ ਅਤੇ ਸਾਰਣੀ ਦਾ ਨਾਮ ਦੱਸੇ ਬਿਨਾਂ ਲਾਜ਼ੀਕਲ ਸਮੀਕਰਨਾਂ ਵਿੱਚ ਐਕਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਲਾਜ਼ੀਕਲ ਸਮੀਕਰਨ ਇੱਕ ਦੂਜੇ ਨਾਲ ਉਸੇ ਤਰ੍ਹਾਂ ਸੰਬੰਧਿਤ ਹਨ ਜਿਵੇਂ ਕਿ ਵਿੱਚ dplyr & ਅਤੇ | ਆਪਰੇਟਰਾਂ ਰਾਹੀਂ।

R: data.table ਵਿੱਚ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ

## data.table
### фильтрация строк по одному условию
ga_nov[source == "google"]
### фильтр по двум условиям соединённым логическим и
ga_nov[source == "google" & sessions >= 10]
### фильтр по двум условиям соединённым логическим или
ga_nov[source == "google" | sessions >= 10]

ਪਾਈਥਨ ਵਿੱਚ ਫਿਲਟਰਿੰਗ ਸਤਰ: ਪਾਂਡਾ

ਵਿੱਚ ਕਤਾਰਾਂ ਦੁਆਰਾ ਫਿਲਟਰ ਕਰੋ pandas ਵਿੱਚ ਫਿਲਟਰ ਕਰਨ ਦੇ ਸਮਾਨ data.table, ਅਤੇ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਕਾਲਮਾਂ ਤੱਕ ਪਹੁੰਚ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਡੇਟਾਫ੍ਰੇਮ ਦੇ ਨਾਮ ਨੂੰ ਦਰਸਾ ਕੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਫਿਰ ਕਾਲਮ ਦਾ ਨਾਮ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਹਵਾਲਾ ਚਿੰਨ੍ਹ ਵਿੱਚ ਵੀ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ (ਉਦਾਹਰਨ df['col_name']), ਜਾਂ ਮਿਆਦ ਦੇ ਬਾਅਦ ਹਵਾਲੇ ਤੋਂ ਬਿਨਾਂ (ਉਦਾਹਰਨ df.col_name).

ਜੇਕਰ ਤੁਹਾਨੂੰ ਕਈ ਸ਼ਰਤਾਂ ਦੁਆਰਾ ਇੱਕ ਡੇਟਾਫ੍ਰੇਮ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਹਰੇਕ ਸ਼ਰਤ ਨੂੰ ਬਰੈਕਟਾਂ ਵਿੱਚ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਲਾਜ਼ੀਕਲ ਸਥਿਤੀਆਂ ਆਪਰੇਟਰਾਂ ਦੁਆਰਾ ਇੱਕ ਦੂਜੇ ਨਾਲ ਜੁੜੀਆਂ ਹੁੰਦੀਆਂ ਹਨ & и |.

ਪਾਈਥਨ ਵਿੱਚ ਫਿਲਟਰਿੰਗ ਸਤਰ: ਪਾਂਡਾ

# Фильтрация строк таблицы
### фильтрация строк по одному условию
ga_nov[ ga_nov['source'] == "google" ]
### фильтр по двум условиям соединённым логическим и
ga_nov[(ga_nov['source'] == "google") & (ga_nov['sessions'] >= 10)]
### фильтр по двум условиям соединённым логическим или
ga_nov[(ga_nov['source'] == "google") | (ga_nov['sessions'] >= 10)]

ਡੇਟਾ ਦਾ ਸਮੂਹੀਕਰਨ ਅਤੇ ਇਕੱਤਰੀਕਰਨ

ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਕਾਰਜਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਗਰੁੱਪਿੰਗ ਅਤੇ ਏਗਰੀਗੇਸ਼ਨ।

ਇਹਨਾਂ ਕਾਰਵਾਈਆਂ ਨੂੰ ਕਰਨ ਲਈ ਸੰਟੈਕਸ ਉਹਨਾਂ ਸਾਰੇ ਪੈਕੇਜਾਂ ਵਿੱਚ ਫੈਲਿਆ ਹੋਇਆ ਹੈ ਜਿਹਨਾਂ ਦੀ ਅਸੀਂ ਸਮੀਖਿਆ ਕਰਦੇ ਹਾਂ।

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

R ਵਿੱਚ ਡੇਟਾ ਦਾ ਸਮੂਹੀਕਰਨ ਅਤੇ ਇਕੱਤਰੀਕਰਨ: tidyverse, dplyr

В dplyr ਫੰਕਸ਼ਨ ਗਰੁੱਪਿੰਗ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ group_by(), ਅਤੇ ਏਕੀਕਰਣ ਲਈ summarise(). ਵਾਸਤਵ ਵਿੱਚ, dplyr ਫੰਕਸ਼ਨ ਦਾ ਇੱਕ ਪੂਰਾ ਪਰਿਵਾਰ ਹੈ summarise_*(), ਪਰ ਇਸ ਲੇਖ ਦਾ ਉਦੇਸ਼ ਮੂਲ ਸੰਟੈਕਸ ਦੀ ਤੁਲਨਾ ਕਰਨਾ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਅਜਿਹੇ ਜੰਗਲ ਵਿੱਚ ਨਹੀਂ ਜਾਵਾਂਗੇ।

ਮੂਲ ਏਕੀਕਰਣ ਫੰਕਸ਼ਨ:

• sum() - ਸਾਰ
• min() / max() - ਨਿਊਨਤਮ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ
• mean() - ਔਸਤ
• median() - ਮੱਧ
• length() - ਮਾਤਰਾ

R: dplyr ਵਿੱਚ ਗਰੁੱਪਿੰਗ ਅਤੇ ਏਗਰੀਗੇਸ਼ਨ

## dplyr
### группировка и агрегация строк
group_by(titanic, Pclass) %>%
  summarise(passangers = length(PassengerId),
            avg_price  = mean(Fare))

ਕੰਮ ਕਰਨ ਲਈ group_by() ਅਸੀਂ ਪਹਿਲੀ ਦਲੀਲ ਵਜੋਂ ਸਾਰਣੀ ਨੂੰ ਪਾਸ ਕੀਤਾ ਮਸ਼ਹੂਰ, ਅਤੇ ਫਿਰ ਖੇਤਰ ਨੂੰ ਸੰਕੇਤ ਕੀਤਾ Pclass, ਜਿਸ ਦੁਆਰਾ ਅਸੀਂ ਆਪਣੇ ਟੇਬਲ ਨੂੰ ਸਮੂਹ ਕਰਾਂਗੇ। ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇਸ ਕਾਰਵਾਈ ਦਾ ਨਤੀਜਾ %>% ਫੰਕਸ਼ਨ ਲਈ ਪਹਿਲੀ ਦਲੀਲ ਵਜੋਂ ਪਾਸ ਕੀਤਾ ਗਿਆ summarise(), ਅਤੇ 2 ਹੋਰ ਖੇਤਰ ਸ਼ਾਮਲ ਕੀਤੇ: ਯਾਤਰੀ и ਔਸਤ_ਕੀਮਤ. ਪਹਿਲਾਂ, ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ length() ਟਿਕਟਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਗਣਨਾ ਕੀਤੀ, ਅਤੇ ਦੂਜੇ ਵਿੱਚ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ mean() ਔਸਤ ਟਿਕਟ ਦੀ ਕੀਮਤ ਪ੍ਰਾਪਤ ਕੀਤੀ.

R: data.table ਵਿੱਚ ਡੇਟਾ ਦਾ ਸਮੂਹੀਕਰਨ ਅਤੇ ਇਕੱਤਰੀਕਰਨ

В data.table ਆਰਗੂਮੈਂਟ ਨੂੰ ਏਕੀਕਰਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ j ਜਿਸਦਾ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਦੂਜਾ ਸਥਾਨ ਹੈ, ਅਤੇ ਗਰੁੱਪਿੰਗ ਲਈ by ਜ keyby, ਜਿਨ੍ਹਾਂ ਦਾ ਤੀਜਾ ਸਥਾਨ ਹੈ।

ਇਸ ਕੇਸ ਵਿੱਚ ਏਕੀਕਰਣ ਫੰਕਸ਼ਨਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਵਰਣਨ ਕੀਤੇ ਸਮਾਨ ਹੈ dplyr, ਕਿਉਂਕਿ ਇਹ ਮੂਲ R ਸੰਟੈਕਸ ਤੋਂ ਫੰਕਸ਼ਨ ਹਨ।

R: data.table ਵਿੱਚ ਸਮੂਹੀਕਰਨ ਅਤੇ ਇਕੱਤਰੀਕਰਨ

## data.table
### фильтрация строк по одному условию
titanic[, .(passangers = length(PassengerId),
            avg_price  = mean(Fare)),
        by = Pclass]

ਪਾਈਥਨ ਵਿੱਚ ਡੇਟਾ ਦਾ ਸਮੂਹੀਕਰਨ ਅਤੇ ਇਕੱਤਰੀਕਰਨ: ਪਾਂਡਾ

ਵਿੱਚ ਗਰੁੱਪਿੰਗ pandas ਦੇ ਵਰਗਾ dplyr, ਪਰ ਏਕੀਕਰਨ ਸਮਾਨ ਨਹੀਂ ਹੈ dplyr ਚਾਲੂ ਨਹੀਂ data.table.

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

ਏਕੀਕਰਣ ਲਈ ਤੁਸੀਂ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ agg()ਜੋ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ। ਡਿਕਸ਼ਨਰੀ ਕੁੰਜੀਆਂ ਉਹ ਕਾਲਮ ਹਨ ਜਿਨ੍ਹਾਂ 'ਤੇ ਤੁਸੀਂ ਐਗਰੀਗੇਸ਼ਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋਗੇ, ਅਤੇ ਮੁੱਲ ਐਗਰੀਗੇਸ਼ਨ ਫੰਕਸ਼ਨਾਂ ਦੇ ਨਾਮ ਹਨ।

ਏਗਰੀਗੇਸ਼ਨ ਫੰਕਸ਼ਨ:

• sum() - ਸਾਰ
• min() / max() - ਨਿਊਨਤਮ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ
• mean() - ਔਸਤ
• median() - ਮੱਧ
• count() - ਮਾਤਰਾ

ਫੰਕਸ਼ਨ reset_index() ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਨ ਵਿੱਚ ਇਸਨੂੰ ਨੇਸਟਡ ਇੰਡੈਕਸ ਨੂੰ ਰੀਸੈਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ pandas ਡਾਟਾ ਏਗਰੀਗੇਸ਼ਨ ਤੋਂ ਬਾਅਦ ਡਿਫਾਲਟ।

ਨਿਸ਼ਾਨ ਤੁਹਾਨੂੰ ਅਗਲੀ ਲਾਈਨ 'ਤੇ ਜਾਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਪਾਈਥਨ ਵਿੱਚ ਸਮੂਹੀਕਰਨ ਅਤੇ ਇਕੱਤਰੀਕਰਨ: ਪਾਂਡਾ

# группировка и агрегация данных
titanic.groupby(["Pclass"]).
    agg({'PassengerId': 'count', 'Fare': 'mean'}).
        reset_index()

ਟੇਬਲਾਂ ਦਾ ਲੰਬਕਾਰੀ ਜੋੜ

ਇੱਕ ਓਪਰੇਸ਼ਨ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਇੱਕੋ ਢਾਂਚੇ ਦੀਆਂ ਦੋ ਜਾਂ ਵੱਧ ਟੇਬਲਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹੋ। ਸਾਡੇ ਦੁਆਰਾ ਲੋਡ ਕੀਤੇ ਗਏ ਡੇਟਾ ਵਿੱਚ ਟੇਬਲ ਸ਼ਾਮਲ ਹਨ ga_nov и ga_dec. ਇਹ ਟੇਬਲ ਬਣਤਰ ਵਿੱਚ ਇੱਕੋ ਜਿਹੇ ਹਨ, ਯਾਨੀ. ਇਹਨਾਂ ਕਾਲਮਾਂ ਵਿੱਚ ਇੱਕੋ ਜਿਹੇ ਕਾਲਮ, ਅਤੇ ਡਾਟਾ ਕਿਸਮਾਂ ਹਨ।

ਇਹ ਨਵੰਬਰ ਅਤੇ ਦਸੰਬਰ ਦੇ ਮਹੀਨੇ ਲਈ ਗੂਗਲ ਵਿਸ਼ਲੇਸ਼ਣ ਤੋਂ ਇੱਕ ਅਪਲੋਡ ਹੈ, ਇਸ ਭਾਗ ਵਿੱਚ ਅਸੀਂ ਇਸ ਡੇਟਾ ਨੂੰ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਜੋੜਾਂਗੇ।

ਲੰਬਕਾਰੀ ਰੂਪ ਵਿੱਚ R ਵਿੱਚ ਸਾਰਣੀਆਂ ਨੂੰ ਜੋੜਨਾ: tidyverse, dplyr

В dplyr ਤੁਸੀਂ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 2 ਟੇਬਲਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਜੋੜ ਸਕਦੇ ਹੋ bind_rows(), ਇਸਦੇ ਆਰਗੂਮੈਂਟਾਂ ਵਜੋਂ ਟੇਬਲ ਪਾਸ ਕਰਨਾ।

R: dplyr ਵਿੱਚ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ

# Вертикальное объединение таблиц
## dplyr
bind_rows(ga_nov, ga_dec)

R: data.table ਵਿੱਚ ਲੰਬਕਾਰੀ ਤੌਰ 'ਤੇ ਸਾਰਣੀਆਂ ਨੂੰ ਜੋੜਨਾ

ਇਹ ਕੁਝ ਵੀ ਗੁੰਝਲਦਾਰ ਨਹੀਂ ਹੈ, ਆਓ ਵਰਤੋਂ ਕਰੀਏ rbind().

R: data.table ਵਿੱਚ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ

## data.table
rbind(ga_nov, ga_dec)

ਪਾਈਥਨ ਵਿੱਚ ਲੰਬਕਾਰੀ ਤੌਰ 'ਤੇ ਟੇਬਲਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣਾ: ਪਾਂਡਾ

В pandas ਫੰਕਸ਼ਨ ਟੇਬਲ ਨੂੰ ਜੋੜਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ concat(), ਜਿਸ ਵਿੱਚ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਜੋੜਨ ਲਈ ਫਰੇਮਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਪਾਸ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਪਾਈਥਨ ਵਿੱਚ ਫਿਲਟਰਿੰਗ ਸਤਰ: ਪਾਂਡਾ

# вертикальное объединение таблиц
pd.concat([ga_nov, ga_dec])

ਟੇਬਲਾਂ ਦਾ ਹਰੀਜੱਟਲ ਜੋੜ

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

ਜੋੜਾਂ ਦੀਆਂ ਕਈ ਕਿਸਮਾਂ ਹਨ:

ਪਹਿਲਾਂ ਲੋਡ ਕੀਤੀ ਸਾਰਣੀ ਵਿੱਚ ਮਸ਼ਹੂਰ ਸਾਡੇ ਕੋਲ ਇੱਕ ਕਾਲਮ ਹੈ ਲਿੰਗ, ਜੋ ਯਾਤਰੀ ਦੇ ਲਿੰਗ ਕੋਡ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ:

1 - ਔਰਤ
2 - ਪੁਰਸ਼

ਨਾਲ ਹੀ, ਅਸੀਂ ਇੱਕ ਸਾਰਣੀ ਬਣਾਈ ਹੈ - ਇੱਕ ਹਵਾਲਾ ਕਿਤਾਬ ਲਿੰਗ. ਯਾਤਰੀਆਂ ਦੇ ਲਿੰਗ 'ਤੇ ਡੇਟਾ ਦੀ ਵਧੇਰੇ ਸੁਵਿਧਾਜਨਕ ਪੇਸ਼ਕਾਰੀ ਲਈ, ਸਾਨੂੰ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਲਿੰਗ ਦਾ ਨਾਮ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ ਲਿੰਗ ਮੇਜ਼ ਨੂੰ ਮਸ਼ਹੂਰ.

ਹਰੀਜ਼ੱਟਲ ਟੇਬਲ ਨੂੰ R ਵਿੱਚ ਜੋੜੋ: tidyverse, dplyr

В dplyr ਹਰੀਜੱਟਲ ਜੋੜਨ ਲਈ ਫੰਕਸ਼ਨਾਂ ਦਾ ਇੱਕ ਪੂਰਾ ਪਰਿਵਾਰ ਹੈ:

• inner_join()
• left_join()
• right_join()
• full_join()
• semi_join()
• nest_join()
• anti_join()

ਮੇਰੇ ਅਭਿਆਸ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ left_join().

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

ਹਰੀਜੱਟਲ ਟੇਬਲ ਨੂੰ R: dplyr ਵਿੱਚ ਜੋੜੋ

# объединяем таблицы
left_join(titanic, gender,
          by = c("Sex" = "id"))

R: data.table ਵਿੱਚ ਟੇਬਲਾਂ ਦਾ ਹਰੀਜੱਟਲ ਜੋੜਨਾ

В data.table ਤੁਹਾਨੂੰ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੁੰਜੀ ਦੁਆਰਾ ਟੇਬਲਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣ ਦੀ ਲੋੜ ਹੈ merge().

data.table ਵਿੱਚ ਮਰਜ() ਫੰਕਸ਼ਨ ਲਈ ਆਰਗੂਮੈਂਟਸ

• x, y — ਜੁੜਨ ਲਈ ਟੇਬਲ
• ਦੁਆਰਾ — ਕਾਲਮ ਜੋ ਕਿ ਜੁੜਨ ਦੀ ਕੁੰਜੀ ਹੈ ਜੇਕਰ ਇਸਦਾ ਦੋਨਾਂ ਟੇਬਲਾਂ ਵਿੱਚ ਇੱਕੋ ਨਾਮ ਹੈ
• by.x, by.y — ਅਭੇਦ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਕਾਲਮ ਨਾਮ, ਜੇਕਰ ਉਹਨਾਂ ਦੇ ਟੇਬਲ ਵਿੱਚ ਵੱਖਰੇ ਨਾਮ ਹਨ
• all, all.x, all.y — ਜੋੜਨ ਦੀ ਕਿਸਮ, ਸਾਰੇ ਦੋਵਾਂ ਟੇਬਲਾਂ ਤੋਂ ਸਾਰੀਆਂ ਕਤਾਰਾਂ ਵਾਪਸ ਕਰ ਦੇਵੇਗਾ, all.x ਖੱਬੇ ਜੋੜਨ ਦੀ ਕਾਰਵਾਈ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ (ਪਹਿਲੀ ਸਾਰਣੀ ਦੀਆਂ ਸਾਰੀਆਂ ਕਤਾਰਾਂ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ), all.y — ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ ਰਾਈਟ ਜੁਆਇਨ ਓਪਰੇਸ਼ਨ (ਦੂਜੀ ਸਾਰਣੀ ਦੀਆਂ ਸਾਰੀਆਂ ਕਤਾਰਾਂ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ)।

R: data.table ਵਿੱਚ ਟੇਬਲਾਂ ਦਾ ਹਰੀਜੱਟਲ ਜੋੜਨਾ

# объединяем таблицы
merge(titanic, gender, by.x = "Sex", by.y = "id", all.x = T)

ਲੇਟਵੀਂ ਸਾਰਣੀ ਪਾਈਥਨ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ: ਪਾਂਡਾ

ਦੇ ਨਾਲ ਨਾਲ ਵਿੱਚ data.table, ਵਿਚ pandas ਫੰਕਸ਼ਨ ਟੇਬਲ ਨੂੰ ਜੋੜਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ merge().

ਪਾਂਡਿਆਂ ਵਿੱਚ ਮਰਜ() ਫੰਕਸ਼ਨ ਦੀਆਂ ਆਰਗੂਮੈਂਟਸ

• ਕਿਵੇਂ - ਕਨੈਕਸ਼ਨ ਦੀ ਕਿਸਮ: ਖੱਬੇ, ਸੱਜੇ, ਬਾਹਰੀ, ਅੰਦਰੂਨੀ
• on — ਕਾਲਮ ਜੋ ਕਿ ਇੱਕ ਕੁੰਜੀ ਹੈ ਜੇਕਰ ਇਸਦਾ ਦੋਨਾਂ ਟੇਬਲਾਂ ਵਿੱਚ ਇੱਕੋ ਨਾਮ ਹੈ
• left_on, right_on — ਕੁੰਜੀ ਕਾਲਮਾਂ ਦੇ ਨਾਮ, ਜੇਕਰ ਉਹਨਾਂ ਦੇ ਟੇਬਲ ਵਿੱਚ ਵੱਖਰੇ ਨਾਮ ਹਨ

ਲੇਟਵੀਂ ਸਾਰਣੀ ਪਾਈਥਨ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ: ਪਾਂਡਾ

# объединяем по ключу
titanic.merge(gender, how = "left", left_on = "Sex", right_on = "id")

ਮੂਲ ਵਿੰਡੋ ਫੰਕਸ਼ਨ ਅਤੇ ਗਣਨਾ ਕੀਤੇ ਕਾਲਮ

ਵਿੰਡੋ ਫੰਕਸ਼ਨ ਐਗਰੀਗੇਸ਼ਨ ਫੰਕਸ਼ਨਾਂ ਦੇ ਅਰਥਾਂ ਵਿੱਚ ਸਮਾਨ ਹਨ, ਅਤੇ ਅਕਸਰ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਵੀ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਪਰ ਏਗਰੀਗੇਸ਼ਨ ਫੰਕਸ਼ਨਾਂ ਦੇ ਉਲਟ, ਵਿੰਡੋ ਫੰਕਸ਼ਨ ਆਊਟਗੋਇੰਗ ਡੇਟਾਫ੍ਰੇਮ ਦੀਆਂ ਕਤਾਰਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਨਹੀਂ ਬਦਲਦੇ ਹਨ।

ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ, ਵਿੰਡੋ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ ਆਉਣ ਵਾਲੇ ਡੇਟਾਫ੍ਰੇਮ ਨੂੰ ਕੁਝ ਮਾਪਦੰਡਾਂ ਦੇ ਅਨੁਸਾਰ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਦੇ ਹਾਂ, ਜਿਵੇਂ ਕਿ. ਇੱਕ ਖੇਤਰ, ਜਾਂ ਕਈ ਖੇਤਰਾਂ ਦੇ ਮੁੱਲ ਦੁਆਰਾ। ਅਤੇ ਅਸੀਂ ਹਰੇਕ ਵਿੰਡੋ 'ਤੇ ਅੰਕਗਣਿਤ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਕਰਦੇ ਹਾਂ। ਇਹਨਾਂ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਨਤੀਜਾ ਹਰੇਕ ਲਾਈਨ ਵਿੱਚ ਵਾਪਸ ਕੀਤਾ ਜਾਵੇਗਾ, i.e. ਸਾਰਣੀ ਵਿੱਚ ਕਤਾਰਾਂ ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਨੂੰ ਬਦਲੇ ਬਿਨਾਂ।

ਉਦਾਹਰਨ ਲਈ, ਆਉ ਸਾਰਣੀ ਨੂੰ ਲੈਂਦੇ ਹਾਂ ਮਸ਼ਹੂਰ. ਅਸੀਂ ਇਸਦੀ ਕੈਬਿਨ ਕਲਾਸ ਦੇ ਅੰਦਰ ਹਰੇਕ ਟਿਕਟ ਦੀ ਕੀਮਤ ਕਿੰਨੀ ਪ੍ਰਤੀਸ਼ਤ ਦੀ ਗਣਨਾ ਕਰ ਸਕਦੇ ਹਾਂ।

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

R ਵਿੱਚ ਵਿੰਡੋ ਫੰਕਸ਼ਨ: tidyverse, dplyr

ਕਤਾਰ ਗਰੁੱਪਿੰਗ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ, ਨਵੇਂ ਕਾਲਮ ਜੋੜਨ ਲਈ, ਵਿੱਚ dplyr ਫੰਕਸ਼ਨ ਦੀ ਸੇਵਾ ਕਰਦਾ ਹੈ mutate().

ਤੁਸੀਂ ਫੀਲਡ ਦੁਆਰਾ ਡੇਟਾ ਦਾ ਸਮੂਹ ਕਰਕੇ ਉੱਪਰ ਦੱਸੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰ ਸਕਦੇ ਹੋ Pclass ਅਤੇ ਇੱਕ ਨਵੇਂ ਕਾਲਮ ਵਿੱਚ ਫੀਲਡ ਦਾ ਸਾਰ ਕਰਨਾ ਕਿਰਾਇਆ. ਅੱਗੇ, ਸਾਰਣੀ ਨੂੰ ਅਨਗਰੁੱਪ ਕਰੋ ਅਤੇ ਖੇਤਰ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਵੰਡੋ ਕਿਰਾਇਆ ਪਿਛਲੇ ਪੜਾਅ ਵਿੱਚ ਕੀ ਹੋਇਆ ਸੀ।

R: dplyr ਵਿੱਚ ਵਿੰਡੋ ਫੰਕਸ਼ਨ

group_by(titanic, Pclass) %>%
  mutate(Pclass_cost = sum(Fare)) %>%
  ungroup() %>%
  mutate(ticket_fare_rate = Fare / Pclass_cost)

R: data.table ਵਿੱਚ ਵਿੰਡੋ ਫੰਕਸ਼ਨ

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

ਵਿੱਚ ਨਵੇਂ ਕਾਲਮ ਜੋੜਨ ਲਈ data.table ਆਪਰੇਟਰ ਮੌਜੂਦ :=. ਹੇਠਾਂ ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ data.table

R: data.table ਵਿੱਚ ਵਿੰਡੋ ਫੰਕਸ਼ਨ

titanic[,c("Pclass_cost","ticket_fare_rate") := .(sum(Fare), Fare / Pclass_cost), 
        by = Pclass]

ਪਾਈਥਨ ਵਿੱਚ ਵਿੰਡੋ ਫੰਕਸ਼ਨ: ਪਾਂਡਾ

ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਕਾਲਮ ਜੋੜਨ ਦਾ ਇੱਕ ਤਰੀਕਾ pandas - ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ assign(). ਕੈਬਿਨ ਕਲਾਸ ਦੁਆਰਾ ਟਿਕਟਾਂ ਦੀ ਕੀਮਤ ਦਾ ਸਾਰ ਦੇਣ ਲਈ, ਕਤਾਰਾਂ ਨੂੰ ਸਮੂਹ ਕੀਤੇ ਬਿਨਾਂ, ਅਸੀਂ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ transform().

ਹੇਠਾਂ ਇੱਕ ਹੱਲ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਸਾਰਣੀ ਵਿੱਚ ਜੋੜਦੇ ਹਾਂ ਮਸ਼ਹੂਰ ਉਹੀ 2 ਕਾਲਮ।

ਪਾਈਥਨ ਵਿੱਚ ਵਿੰਡੋ ਫੰਕਸ਼ਨ: ਪਾਂਡਾ

titanic.assign(Pclass_cost      =  titanic.groupby('Pclass').Fare.transform(sum),
               ticket_fare_rate = lambda x: x['Fare'] / x['Pclass_cost'])

ਫੰਕਸ਼ਨ ਅਤੇ ਢੰਗ ਪੱਤਰ ਵਿਹਾਰ ਸਾਰਣੀ

ਹੇਠਾਂ ਸਾਡੇ ਦੁਆਰਾ ਵਿਚਾਰੇ ਗਏ ਪੈਕੇਜਾਂ ਵਿੱਚ ਡੇਟਾ ਦੇ ਨਾਲ ਵੱਖ-ਵੱਖ ਕਾਰਵਾਈਆਂ ਕਰਨ ਦੇ ਤਰੀਕਿਆਂ ਵਿਚਕਾਰ ਪੱਤਰ ਵਿਹਾਰ ਦੀ ਇੱਕ ਸਾਰਣੀ ਹੈ।

ਵੇਰਵਾ
ਸੁਥਰਾ
ਡੇਟਾ.ਟੈਬਲ
ਪੰਡਾਸ

ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
vroom()/ readr::read_csv() / readr::read_tsv()
fread()
read_csv()

ਡਾਟਾਫ੍ਰੇਮ ਬਣਾਉਣਾ
tibble()
data.table()
dict() + from_dict()

ਕਾਲਮ ਚੁਣਨਾ
select()
ਇੱਕ ਦਲੀਲ j, ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਦੂਜਾ ਸਥਾਨ
ਅਸੀਂ ਲੋੜੀਂਦੇ ਕਾਲਮਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਪਾਸ ਕਰਦੇ ਹਾਂ / drop() / filter() / select_dtypes()

ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ
filter()
ਇੱਕ ਦਲੀਲ i, ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਪਹਿਲੀ ਸਥਿਤੀ
ਅਸੀਂ ਫਿਲਟਰਿੰਗ ਹਾਲਤਾਂ ਨੂੰ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਸੂਚੀਬੱਧ ਕਰਦੇ ਹਾਂ / filter()

ਗਰੁੱਪਿੰਗ ਅਤੇ ਏਗਰੀਗੇਸ਼ਨ
group_by() + summarise()
ਬਹਿਸ j + by
groupby() + agg()

ਟੇਬਲਾਂ ਦਾ ਲੰਬਕਾਰੀ ਸੰਘ (UNION)
bind_rows()
rbind()
concat()

ਟੇਬਲਾਂ ਦਾ ਹਰੀਜੱਟਲ ਜੋੜ (ਸ਼ਾਮਲ)
left_join() / *_join()
merge()
merge()

ਮੂਲ ਵਿੰਡੋ ਫੰਕਸ਼ਨ ਅਤੇ ਗਣਨਾ ਕੀਤੇ ਕਾਲਮਾਂ ਨੂੰ ਜੋੜਨਾ
group_by() + mutate()
ਇੱਕ ਦਲੀਲ j ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ := + ਦਲੀਲ by
transform() + assign()

ਸਿੱਟਾ

ਸ਼ਾਇਦ ਲੇਖ ਵਿੱਚ ਮੈਂ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਸਭ ਤੋਂ ਅਨੁਕੂਲ ਅਮਲਾਂ ਦਾ ਵਰਣਨ ਨਹੀਂ ਕੀਤਾ ਹੈ, ਇਸ ਲਈ ਮੈਨੂੰ ਖੁਸ਼ੀ ਹੋਵੇਗੀ ਜੇਕਰ ਤੁਸੀਂ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਮੇਰੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਠੀਕ ਕਰਦੇ ਹੋ, ਜਾਂ ਆਰ / ਪਾਈਥਨ ਵਿੱਚ ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਹੋਰ ਤਕਨੀਕਾਂ ਦੇ ਨਾਲ ਲੇਖ ਵਿੱਚ ਦਿੱਤੀ ਗਈ ਜਾਣਕਾਰੀ ਨੂੰ ਸਿਰਫ਼ ਪੂਰਕ ਕਰਦੇ ਹੋ.

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

ਜੇ ਤੁਸੀਂ ਲੇਖ ਨੂੰ ਪਸੰਦ ਕੀਤਾ ਹੈ, ਤਾਂ ਮੈਂ ਆਪਣੇ ਨਵੇਂ ਗਾਹਕਾਂ ਨੂੰ ਲੈ ਕੇ ਖੁਸ਼ ਹੋਵਾਂਗਾ YouTube и ਤਾਰ ਚੈਨਲ।

ਪੋਲ

ਤੁਸੀਂ ਆਪਣੇ ਕੰਮ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਪੈਕੇਜਾਂ ਵਿੱਚੋਂ ਕਿਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ?

ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਤੁਸੀਂ ਆਪਣੀ ਪਸੰਦ ਦਾ ਕਾਰਨ ਲਿਖ ਸਕਦੇ ਹੋ।

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

ਤੁਸੀਂ ਕਿਹੜਾ ਡਾਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਪੈਕੇਜ ਵਰਤਦੇ ਹੋ (ਤੁਸੀਂ ਕਈ ਵਿਕਲਪ ਚੁਣ ਸਕਦੇ ਹੋ)

• 45,2%tidyverse19

• 33,3%data.table14

• 54,8%pandas23

42 ਉਪਭੋਗਤਾਵਾਂ ਨੇ ਵੋਟ ਕੀਤਾ। 9 ਉਪਭੋਗਤਾ ਬਚੇ ਰਹੇ।

ਸਰੋਤ: www.habr.com