“Group by” ı bash'tan simüle etmenin en iyi yolu?

Her satırda bir adres olan IP adresleri içeren bir dosyanız olduğunu varsayalım:

10.0.10.1
10.0.10.1
10.0.10.3
10.0.10.2
10.0.10.1

Her IP adresi için dosyada kaç kez göründüğünü sayan bir kabuk betiğine ihtiyacınız vardır. Önceki giriş için aşağıdaki çıkışa ihtiyacınız vardır:

10.0.10.1 3
10.0.10.2 1
10.0.10.3 1

Bunu yapmanın bir yolu:

cat ip_addresses |uniq |while read ip
do
    echo -n $ip" "
    grep -c $ip ip_addresses
done

Ancak gerçekten verimli olmaktan çok uzak.

Bu sorunu bash kullanarak nasıl daha verimli çözersiniz?

(Eklenecek bir şey var: Perl veya awk'den çözülebileceğini biliyorum, bash'da daha iyi bir çözümle ilgileniyorum, bu dillerde değil.)

İLAVE BİLGİ:

Kaynak dosyanın 5 GB ve algoritmayı çalıştıran makinede 4 GB olduğunu varsayalım. Yani sıralama etkili bir çözüm değildir, dosyayı bir kereden fazla okumaz.

Hashhtable benzeri çözümü beğendim - herkes bu çözümde iyileştirmeler yapabilir mi?

EK BİLGİ # 2:

Bazı insanlar, örneğin perl'de çok daha kolay olduğunda neden bash yaparken rahatsız edeyim diye sordu. Nedeni makinede bu perl benim için mevcut değildi yapmak zorundaydı. Alıştığım aletlerin çoğu olmadan özel olarak yapılmış bir linux makinesiydi. Ve bence bu ilginç bir problemdi.

Bu yüzden lütfen soruyu suçlamayın, hoşunuza gitmiyorsa görmezden gelin. :-)

sort ip_addresses | uniq -c

Bu, önce sayıyı yazdırır, ancak bunun dışında tam olarak istediğiniz şey olmalıdır.

Hızlı ve kirli yöntem aşağıdaki gibidir:

cat ip_addresses | sort -n | uniq -c

Bash içindeki değerleri kullanmanız gerekiyorsa, tüm komutu bir bash değişkenine atayabilir ve sonra sonuçlar arasında geçiş yapabilirsiniz.

PS

Sort komutu atlanırsa, uniq yalnızca birbirini izleyen özdeş satırlara baktığından doğru sonuçları elde edemezsiniz.

bir grup mevcut alanı temel alarak birden çok alanı toplamak için aşağıdaki örneği kullanın: (gereksinimlerinize göre 1 $, 2 $, 3 $, 4 $ tutarını değiştirin)

cat file

US|A|1000|2000
US|B|1000|2000
US|C|1000|2000
UK|1|1000|2000
UK|1|1000|2000
UK|1|1000|2000

awk 'BEGIN { FS=OFS=SUBSEP="|"}{arr[$1,$2]+=$3+$4 }END {for (i in arr) print i,arr[i]}' file

US|A|3000
US|B|3000
US|C|3000
UK|1|9000

Kanonik çözüm, başka bir katılımcı tarafından belirtilen çözümdür:

sort | uniq -c

Perl veya awk ile yazılabileceklerden daha kısa ve özlüdür.

Sıralamayı kullanmak istemediğinizi yazarsınız, çünkü verilerin boyutu makinenin ana bellek boyutundan daha büyüktür. Unix sıralama komutunun uygulama kalitesini hafife almayın. Sort, 128k (131.072 bayt) belleğe (PDP-11) sahip makinelerde çok büyük miktarda veriyi (orijinal AT&T faturalandırma verilerini düşünün) işlemek için kullanıldı. Sıralama, önceden ayarlanmış bir sınırdan (genellikle makinenin ana belleğinin boyutuna yakın olarak ayarlanır) daha fazla veriyle karşılaştığında, ana bellekte okuduğu verileri sıralar ve geçici bir dosyaya yazar. Daha sonra eylemi bir sonraki veri parçalarıyla tekrarlar. Son olarak, bu ara dosyalar üzerinde bir birleştirme sıralaması gerçekleştirir. Bu, sıralamanın makinenin ana belleğinden çok daha büyük veriler üzerinde çalışmasına izin verir.

cat ip_addresses | sort | uniq -c | sort -nr | awk '{print $2 " " $1}'

bu komut size istenen çıktıyı verir

Görünüşe göre ya lineer davranış elde etmek için bash'ta karmaları simüle etmek için büyük miktarda kod kullanmanız ya da ikinci dereceden süper lineer versiyonlara bağlı kalmanız gerekiyor.

Bu sürümler arasında saua'nın çözümü en iyisidir (ve en basitidir):

sort -n ip_addresses.txt | uniq -c

Http://unix.derkeiler.com/Newsgroups/comp.unix.shell/2005-11/0118.html buldum . Ama cehennem kadar çirkin ...

Çözüm (mysql gibi gruplandır)

grep -ioh "facebook\|xing\|linkedin\|googleplus" access-log.txt | sort | uniq -c | sort -n

Sonuç

3249  googleplus
4211 linkedin
5212 xing
7928 facebook

Muhtemelen bir karma tablo olarak dosya sisteminin kendisini kullanabilirsiniz. Sahte kod aşağıdaki gibi:

for every entry in the ip address file; do
  let addr denote the ip address;

  if file "addr" does not exist; then
    create file "addr";
    write a number "0" in the file;
  else 
    read the number from "addr";
    increase the number by 1 and write it back;
  fi
done

Sonunda, tek yapmanız gereken tüm dosyaları taramak ve içindeki dosya adlarını ve numaralarını yazdırmak. Alternatif olarak, bir sayı tutmak yerine, dosyaya her seferinde boşluk veya yeni satır ekleyebilirsiniz ve sonunda dosya boyutuna bayt cinsinden bakabilirsiniz.

Ben awk ilişkisel dizi de bu durumda kullanışlı hissediyorum

$ awk '{count[$1]++}END{for(j in count) print j,count[j]}' ips.txt

Buraya posta yoluyla bir grup

Diğer çözümlerin çoğu kopyaları sayar. Anahtar / değer çiftlerini gerçekten gruplamanız gerekiyorsa şunu deneyin:

İşte benim örnek veriler:

find . | xargs md5sum
fe4ab8e15432161f452e345ff30c68b0 a.txt
30c68b02161e15435ff52e34f4fe4ab8 b.txt
30c68b02161e15435ff52e34f4fe4ab8 c.txt
fe4ab8e15432161f452e345ff30c68b0 d.txt
fe4ab8e15432161f452e345ff30c68b0 e.txt

Bu, md5 sağlama toplamına göre gruplandırılmış anahtar / değer çiftlerini yazdırır.

cat table.txt | awk '{print $1}' | sort | uniq  | xargs -i grep {} table.txt
30c68b02161e15435ff52e34f4fe4ab8 b.txt
30c68b02161e15435ff52e34f4fe4ab8 c.txt
fe4ab8e15432161f452e345ff30c68b0 a.txt
fe4ab8e15432161f452e345ff30c68b0 d.txt
fe4ab8e15432161f452e345ff30c68b0 e.txt

Saf darbe (çatal yok!)

Bir yol var, bir darbeişlev . Çatal olmadığı için bu yol çok hızlı! ...

... demet iken ip adresleri kalmak küçük !

countIp () { 
    local -a _ips=(); local _a
    while IFS=. read -a _a ;do
        ((_ips[_a<<24|${_a[1]}<<16|${_a[2]}<<8|${_a[3]}]++))
    done
    for _a in ${!_ips[@]} ;do
        printf "%.16s %4d\n" \
          $(($_a>>24)).$(($_a>>16&255)).$(($_a>>8&255)).$(($_a&255)) ${_ips[_a]}
    done
}

Not: IP adresleri, dizi için dizin olarak kullanılan 32 bit işaretsiz tam sayı değerine dönüştürülür . Bu kullanımı basit bash dizileri , ilişkisel dizi (hangi daha pahalı)!

time countIp < ip_addresses 
10.0.10.1    3
10.0.10.2    1
10.0.10.3    1
real    0m0.001s
user    0m0.004s
sys     0m0.000s

time sort ip_addresses | uniq -c
      3 10.0.10.1
      1 10.0.10.2
      1 10.0.10.3
real    0m0.010s
user    0m0.000s
sys     0m0.000s

Ev sahibimde , bunu yapmak yaklaşık 1.000 adrese kadar çatal kullanmaktan çok daha hızlıdır, ancak 10.000 adresi sıralamaya çalıştığımda yaklaşık 1 saniye sürüyor .

Ben böyle yapardım:

perl -e 'while (<>) {chop; $h{$_}++;} for $k (keys %h) {print "$k $h{$k}\n";}' ip_addresses

ama uniq sizin için işe yarayabilir.

Bash'de bir şey aradığınızı anlıyorum, ancak başka birinin Python'da bir şey araması durumunda, bunu düşünmek isteyebilirsiniz:

mySet = set()
for line in open("ip_address_file.txt"):
     line = line.rstrip()
     mySet.add(line)

Setteki değerler varsayılan olarak benzersiz olduğundan ve Python bu konuda oldukça iyi olduğundan, burada bir şeyler kazanabilirsiniz. Kodu test etmedim, bu yüzden hata olabilir, ama bu sizi oraya götürebilir. Ve olayları saymak istiyorsanız, bir küme yerine bir diktenin kullanılması kolaydır.

Edit: Ben berbat bir okuyucum, bu yüzden yanlış cevap verdim. Burada, olayları sayacak bir dikteye sahip bir pasaj.

mydict = {}
for line in open("ip_address_file.txt"):
    line = line.rstrip()
    if line in mydict:
        mydict[line] += 1
    else:
        mydict[line] = 1

Dictionary mydict artık anahtar olarak benzersiz IP'lerin bir listesini ve değerleri olarak gerçekleşme sayısını tutar.

Sipariş önemli değilse sıralama atlanabilir

uniq -c <source_file>

veya

echo "$list" | uniq -c

kaynak listesi değişkense