Get best of the week

Keterampilan Pemrogram Kunci Python

Dalam waktu kita yang dinamis, programmer perlu mengikuti dan terus belajar keterampilan baru agar tetap menjadi spesialis yang dicari.

Saya telah memprogram dalam Python selama sekitar dua tahun, dan sekarang saatnya untuk secara sadar mendekati pengembangan keterampilan baru. Untuk melakukan ini, saya memutuskan untuk menganalisis lowongan dan menyajikan keterampilan yang diperlukan dalam bentuk grafik. Saya berharap untuk melihat bahwa keterampilan akan membentuk kelompok yang sesuai dengan spesialisasi yang berbeda: pengembangan backend, ilmu data, dll. Tetapi bagaimana dengan kenyataan? Hal pertama yang pertama.

Pengumpulan data


Pertama, Anda harus memutuskan sumber data. Saya mempertimbangkan beberapa pilihan: Karir Habr , Pekerjaan Yandex , HeadHunter , dan lainnya. HeadHunter sepertinya yang paling nyaman, karena di sini di lowongan ada daftar keterampilan utama dan ada API terbuka yang nyaman .

Setelah mempelajari API HeadHunter, saya memutuskan untuk mengurai daftar id pekerjaan untuk kata kunci tertentu (dalam hal ini, "python"), dan kemudian mengurai daftar tag yang sesuai untuk setiap pekerjaan.

Saat mencari lowongan, lowongan dikembalikan halaman demi halaman, jumlah maksimum lowongan per halaman adalah 100. Awalnya saya menyimpan hasil lengkap dalam bentuk daftar jawaban halaman.

Untuk ini, modul permintaan digunakan. Di bidang "agen pengguna", sesuai dengan API, nama browser virtual dimasukkan sehingga HH mengerti bahwa skrip mengaksesnya. Dia membuat sedikit keterlambatan antara permintaan agar tidak membebani server.

ses = requests.Session()
ses.headers = {'HH-User-Agent': "Mozilla/5.0 (X11; Linux x86_64; rv:10.0) Gecko/20100101 Firefox/10.0"}

phrase_to_search = 'python'
url = f'https://api.hh.ru/vacancies?text={phrase_to_search}&per_page=100'
res = ses.get(url)

# getting a list of all pesponses
res_all = []
for p in range(res.json()['pages']):
    print(f'scraping page {p}')
    url_p = url + f'&page={p}'
    res = ses.get(url_p)
    res_all.append(res.json())
    time.sleep(0.2)

Akibatnya, saya mendapat daftar kamus jawaban, di mana setiap kamus berhubungan dengan satu halaman hasil pencarian.

Ternyata, API hh.ru membatasi jumlah lowongan maksimum menjadi dua ribu, yaitu, dengan 100 lowongan per halaman, jumlah halaman maksimum bisa 20. Untuk kata kunci Python, 20 halaman lowongan dikembalikan, yang berarti bahwa lowongan kerja Python nyata lebih mungkin terjadi. lebih-lebih.

Untuk mendapatkan daftar tag, saya melakukan hal berikut:
  • Iterasi pada setiap halaman hasil pencarian,
  • Iterasi setiap pekerjaan pada halaman dan mendapat id pekerjaan,
  • meminta rincian lowongan melalui API,
  • jika setidaknya satu tag ditentukan dalam kekosongan, maka daftar tag ditambahkan ke daftar.

# parcing vacancies ids, getting vacancy page and scraping tags from each vacancy
tags_list = []
for page_res_json in res_all:
    for item in page_res_json['items']:
        vac_id = item['id']
        vac_res = ses.get(f'https://api.hh.ru/vacancies/{vac_id}')
        if len(vac_res.json()["key_skills"]) > 0:  # at least one skill present
            print(vac_id)
            tags = [v for v_dict in vac_res.json()["key_skills"] for _, v in v_dict.items()]
            print(' '.join(tags))
            tags_list.append(tags)
            print()
        time.sleep(0.1)

Daftar tag disimpan sebagai kamus

res = {'phrase': phrase_to_search, 'items_number': len(tags_list), 'items': tags_list}
with open(f'./data/raw-tags_{phrase_to_search}.json', 'w') as fp:  # Serializing
    json.dump(res, fp)

Menariknya, dari 2.000 lowongan yang dilihat, hanya 1.579 lowongan memiliki tag.

Pemformatan data


Sekarang Anda perlu memproses tag dan menerjemahkannya ke dalam format yang nyaman untuk ditampilkan sebagai grafik, yaitu:
  • bawa semua tag ke satu register, jadi "pembelajaran mesin", "pembelajaran mesin" dan "Pembelajaran Mesin" memiliki arti yang sama
  • menghitung nilai node sebagai frekuensi kemunculan setiap tag,
  • hitung nilai koneksi sebagai frekuensi pertemuan tag bersama satu sama lain.

Mengurangi ke register tunggal, menghitung frekuensi kemunculan setiap tag, pemfilteran menurut ukuran node dilakukan sebagai berikut.

tags_list['items'] = [[i.lower() for i in line] for line in tags_list['items']]

# counting words occurrences
flattened_list = [i for line in tags_list for i in line]
nodes_dict_all = {i: flattened_list.count(i) for i in set(flattened_list)}
nodes_dict = {k:v for k, v in nodes_dict_all.items() if v > del_nodes_count}

Kejadian berpasangan dihitung sebagai berikut. Pertama-tama saya membuat kamus di mana kunci-kunci semuanya adalah semua pasangan tag yang mungkin dalam bentuk tuple, dan nilainya nol. Kemudian ia pergi melalui daftar tag dan meningkatkan penghitung untuk setiap pasangan yang ditemui. Kemudian saya menghapus semua elemen yang nilainya nol.

# tags connection dict initialization
formatted_tags = {(tag1, tag2): 0 for tag1, tag2 in itertools.permutations(set(nodes_dict.keys()), 2)}

# count tags connection
for line in tags_list:
    for tag1, tag2 in itertools.permutations(line, 2):
        if (tag1, tag2) in formatted_tags.keys():
            formatted_tags[(tag1, tag2)] += 1

# filtering pairs with zero count
for k, v in formatted_tags.copy().items():
    if v == 0:
        del formatted_tags[k]

Pada output, saya membentuk kamus

{
'phrase': phrase searched,
'items_number': number of vacancies parced, 
'items': {
 	"nodes": [
			{
			"id": tag name, 
		 	"group": group id, 
		 	"popularity": tag count
			},
		… 
		] 
	"links": [
			{
			"source": pair[0], 
			"target": pair[1], 
			"value": pair count
			},
		…
		]
	}
}

nodes = []
links = []
for pair, count in formatted_tags.items():
    links.append({"source": pair[0], "target": pair[1], "value": count})

max_count = max(list(nodes_dict.values()))
count_step = max_count // 7
for node, count in nodes_dict.items():
    nodes.append({"id": node, "group": count // count_step, "popularity": count})

data_to_dump = in_json.copy()
data_to_dump['items'] = {"nodes": nodes, "links": links}

Visualisasi python


Untuk memvisualisasikan grafik, saya menggunakan modul networkx. Inilah yang terjadi pertama kali tanpa menyaring node.



Visualisasi ini lebih seperti bola benang kusut daripada grafik keterampilan. Koneksi bingung dan menembus grafik sangat padat sehingga tidak mungkin untuk membuat node. Selain itu, ada terlalu banyak node pada grafik, beberapa sangat kecil sehingga tidak memiliki signifikansi statistik.

Karena itu, saya memfilter simpul terkecil dengan ukuran kurang dari 5, dan juga membuat tautan abu-abu. Dalam gambar ini, saya belum membawa kata-kata ke satu register, sementara saya mencoba untuk menghapus simpul Python terbesar untuk melepaskan koneksi.



Itu menjadi jauh lebih baik. Sekarang node dipisahkan, dan tautannya tidak menyumbat visualisasi. Menjadi mungkin untuk melihat keterampilan dasar, mereka berada di bola besar di tengah grafik, dan node kecil. Tetapi grafik ini masih memiliki banyak peningkatan.

Visualisasi JavaScript


Saya mungkin akan terus mengambil kode ini jika pada saat itu saya tidak memiliki bantuan dalam bentuk saudara. Dia aktif terlibat dalam pekerjaan dan membuat tampilan dinamis yang indah berdasarkan modul JavaScript D3 .

Ternyata begini.


Visualisasi dinamis tersedia di sini. Perhatikan bahwa node dapat ditarik.

Analisis Hasil


Seperti yang bisa kita lihat, grafik ternyata sangat terkait, dan kluster yang terdefinisi dengan jelas tidak dapat dideteksi sekilas. Anda dapat segera melihat beberapa node besar yang paling diminati: linux, sql, git, postgresql dan django. Ada juga keterampilan popularitas sedang dan keterampilan jarang ditemui.

Selain itu, Anda dapat memperhatikan fakta bahwa keterampilan masih membentuk kelompok berdasarkan profesi, yang terletak di sisi berlawanan dari pusat:

  • kiri bawah - analisis data,
  • di bagian bawah adalah database,
  • kanan bawah - pengembangan front-end,
  • di sebelah kanan sedang menguji,
  • kanan atas - pengembangan web,
  • pembelajaran mesin kiri atas.

Deskripsi cluster ini didasarkan pada pengetahuan saya dan mungkin mengandung kesalahan, tetapi ide itu sendiri, saya harap, jelas.

Berdasarkan hasil yang diperoleh, kesimpulan berikut dapat ditarik:
  • Anda perlu menguasai keterampilan yang sesuai dengan node besar, mereka akan selalu berguna,
  • Anda perlu menguasai keterampilan cluster yang sesuai dengan minat Anda.

Saya harap Anda menikmatinya dan analisis ini akan bermanfaat bagi Anda.

Anda dapat melihat kode atau berpartisipasi dalam pengembangannya menggunakan tautan: proyek GitHub , laptop yang dapat diamati dengan visualisasi,

Sukses dalam menguasai cakrawala baru!

More articles:


All Articles