728 x 90

, i

Julia – silna konkurencja języków takich jak Matlab, R czy Python cz. 3

Julia – silna konkurencja języków takich jak Matlab, R czy Python cz. 3

W poprzednim artykule poznaliśmy niezbędne do dalszej pracy polecenia oraz struktury wykorzystywane w Julii.  Zachęcamy do przeanalizowania podanych przez nas przykładów oraz sprawdzenia ich działania linijka po linijce a także dalszej nauki z naszym tutorialem.

Wstęp

W tej publikacji zapoznamy się z ważnymi pętlami, typami własnymi oraz metodami tworzenia wykresów. Przekonamy się także, że możemy utrwalać wyniki działania programów za pomocą operacji na plikach oraz DateFrames.

Pętle

Pętle są elementem każdego języka programowania. Są proste do zrozumienia, a ich właściwa implementacja sprawia, że nasze programy stają się krótsze i bardziej przejrzyste. Jeśli chcielibyśmy wypisać na ekran 100 liczb, moglibyśmy napisać 100 osobnych linijek:

Println(„1”)

Println(„2”)

Println(„100”)

Zatem do dzieła! 😀

Drugim sposobem jest użycie struktury zwanej pętlą, która powoduje, że dany fragment kodu wykonuje się wielokrotnie. Spójrzmy zatem na poniższy kod.

 

for i in 1:100
    print(i,", ")
end

Łatwiej? Mam nadzieję, że przekonaliśmy już was do stosowania pętli. Zobaczmy różne warianty tej struktury:

for i in 1:10
     print(i, ", ")
end

println()
for i = 1:10
     print(i, ", ")
end
println()

# deklarujemy teraz listę i wybiszemy tylko elementy zawierające parzyste numery
a2 = collect(1:20)

for i in a2
     if i % 2 == 0
         print(i, ", ")
     end
end
println()

#Teraz zmodyfikujemy listę za pomocą pętli - usuniemy wszystkie elementy
# po jednym w kazdej iteracji, az lista bedzie pusta

while !isempty(a2)
    print(pop!(a2), ", ")
end
println()

Wynik działania programu:

Przydatna jest również funkcja enumerate, która daje możliwość indeksowania wartości z listy. Przykład poniżej:

 

a3= ["jeden","dwa","trzy"]
for(i,v) in enumerate(a3)
    print(i,": ",v,", ")
end

#coś o połączeniu tablicy asocjacyjnej z pętlami poniżej

 d1 = Dict(1=>"jeden", 2=>"dwa", 3=>"trzy")
# słowniki mogą być również używane w pętlach:
 for k in sort(collect(keys(d1)))
     print(k, ": ", d1[k], ", ")
 end
println()

Typy własne

Teraz przejdziemy do trochę trudniejszego tematu, szczególnie dla osób początkujących. W języku Juli występują struktury danych, spotykane także w innych językach tj. C, C++, PL/SQL.

W jednej strukturze możemy przetrzymywać wiele danych różnego typu. Koncepcja ta przypomina trochę ideę baz danych.  Spójrzmy na przykład deklaracji oraz kilku podstawowych operacji.

type Student
   imie::AbstractString
   plec::Bool
   wiek::Int16
   numer_indeksu::Int
   srednia::Float32
end

# Załozmy ze mamy 5 studentow w szkole
# aby wszystkich odnotować musimy storzyć tablicę
# zawierającą 5 pol

 studenci = Student[]
  push!(studenci, Student("Jan", true, 21, 1, 2.0))
  push!(studenci, Student("Adam", true, 22, 2, 3.20))
  push!(studenci, Student("Pawel", true, 20, 3, 4.73))
  push!(studenci, Student("Mikolaj", true, 21, 4, 3.1))
  push!(studenci, Student("Zbigniew", true, 23, 5, 4.0))

for a in studenci
     println("Imie: $(a.imie) Srednia: $(a.srednia) ")
end

Wejście / Wyjście

Nasze programy mogą już wykonywać złożone obliczenia, korzystając z różnych struktur języka Juli. Jeśli chcemy, by te dane nie były ulotne, tzn. abyśmy nie utracili ich po wyłączeniu programu, musimy zapisać je do pliku. Jednocześnie rozwiązanie to pozwala na wprowadzanie wielu danych za pomocą minimalnej ilości kodu. Obsługa plików jest podobna do konwencji języka Python. Poniżej przedstawiono kilka metod otwierania plików.

# Otwieramy plik baza.dat i odczytujemy. Warto pamiętać że wykorzystując polecenie do zamykamy plik po zakończeniu operacji
fname="baza.dat"
open(fname,"r") do f
    for line in eachline(f)
        print(line)
    end
end

#Teraz otwieramy plik do odczyty i go wyświetlamy, następnie zamykamy go
  f=open(fname,"r")
  showall(readlines(f))
  close(f)

  f=open(fname,"r")
  fstring=readall(f)
  close(f)

#Wyswietlenie danych o pliku a następnie zawartości
  println(summary(fstring))
  print(fstring)

  • Po użyciu „do” do otworzenia baza.dat, plik jest automatycznie zamykany
  • Następnie za pomocą pętli for, pobieramy kolejne linijki, używając klauzuli eachline dochodzimy do końca pliku
  • Open (zmienna, opcja otwarcia) otwiera plik, a Close(zmienna) zamyka plik
plik="wyjście.dat"
 f=open(plik,"w")
  println(f,"Zawartosc")
  println(f,"jeszcze wiecej")
  println(f,"ostatnia linijka")
 close(f)

Zapis do pliku jest bardzo prosty – wystarczy otworzyć plik w trybie pisania „w”, a następnie zapisać do pliku, przez przekierowanie bufora z konsoli do pliku.

Wykresy

Potrzebujesz wykresu nie ma sprawy. Juli też da radę. Musimy dodać pakiet Winston za pomocą polecenia pkg.add(). Następnie określamy rozmiar, wyświetlamy i zapisujemy wykres.

 

Pkg.add("Winston")
using Winston

 figure(width=600, height=400)
 p1=plot(cumsum(rand(500) .-0.5),"r",cumsum(rand(500).-0.5),"b")
  display(p1)
  savefig("p1.svg")

 

Pkg.add("Winston")
using Winston
using Calculus

 figure(width=600, height=400)
 x=0:0.1:10
 y=sin(x)
 y2=sin(2sin(2sin(x)))

  display(plot(x,y,"g^",x,y2,"b-o"))

using Winston
using Calculus

 figure(width=600, height=400)
 x=0:0.1:10
 y=sin(x)
 y2=abs(x)

 display(plot(x,y,"g^",x,y2,"b-o"))

using Winston
using Calculus

figure(width=600, height=400)
x=0:0.1:10
y=zeta(x)

display(plot(x,y,”g”)

DataFrames

Omawiając struktury stworzyliśmy małą pięciopozycyjną ulotną bazę danych, następnie nauczyliśmy się używać plików Teraz pójdziemy o krok dalej. Zastosujemy ramki danych do przechowywania informacji.  W poniższym kodzie możemy znaleźć wiele przydatnych poleceń, które zostały opatrzone niezbędnymi komentarzami, więc poznanie DataFrames nie sprawi nikomu trudności.

using DataFrames
 showln(x) = (show(x); println())

# Deklaracja ramki danych i uzupełnienie jej danymi
  df = DataFrame(A = [1, 2], B = [e, pi], C = ["xx", "xy"])
#Wyswietlenie ramki
  showln(df)

#Wyswietlanie odpowiednich kolumn
  showln(df[1]) # Wyswietlenie pierwszej kolumny
  showln(df[:A]) # Wyswietlenie kolumny o nazwie A showln(df[2]) # Wyswietlenie drugiej kolumny
  showln(df[:B]) # Wyswietlenie kolumny o nazwie B

#Wyswietlanie wierszy
  showln(df[1, :])
  showln(df[1:2, :])

#Import pliku .csv
 iris = readtable("iris.csv")

using RDatasets
 iris = dataset("datasets","iris")

# Wyswietla nazwy kolumn
  showln(names(iris))
# Wyświetla typy kolumn
  showln(eltypes(iris))

#Wyswietlenie tabeli w z danymi o pewnej wlasnosci
  showln(iris[iris[:Species] .== "setosa", :])


# Zliczanie ilości wystąpień wg. danego atrybutu
  showln(by(iris, :Species, df -> size(df, 1)))

# Discretize entire columns at a time
  iris[:SepalLength] = round(Integer, iris[:SepalLength])
  iris[:SepalWidth] = round(Integer, iris[:SepalWidth])


# Dodawanie usuwanie kolumn
# Dodajemy kolumnę o losowych wartościach

# insert!(df::DataFrame,index::Int64,item::AbstractArray{T,1},name::Symbol)
# insert random numbers at col 5:
 insert!(iris, 5, rand(nrow(iris)), :randCol)

# Usuwamy
 delete!(iris, :randCol)

 

 

To już koniec serii poświęconej temu językowi programowania. Mamy nadzieję, że zachęciliśmy was do dalszego korzystania z tej jakże ciekawej techniki. Staraliśmy się przybliżyć wam podstawy tak abyście na tych fundamentach mogli dalej rozwijać potencjał jaki leży w Juli. Spróbujcie wykorzystać go na studiach, w pracy czy hobbistycznych projektach – na pewno się nie zawiedziecie 😉

Życzymy powodzenia!

Żródła obrazów: freeimages.com 

Implementacje zostały opracowane we własnym zakresie, a wartość merytoryczna została zaczerpnięta ze strony: https://learnxinyminutes.com/docs/julia/

Leave a Comment

Your email address will not be published. Required fields are marked with *

Cancel reply

Inne artykuły