1
0
forked from tdwojak/Python2019

Add lab 03

This commit is contained in:
Tomasz Dwojak 2019-02-09 08:54:14 +01:00
parent c8a65f2b90
commit b51244f24e
5 changed files with 294 additions and 0 deletions

99
labs03/dane.txt Normal file
View File

@ -0,0 +1,99 @@
95
46
1
35
44
50
84
30
28
48
95
45
86
90
48
6
68
46
36
19
3
37
25
74
8
23
71
91
79
74
84
71
93
85
3
89
65
64
15
18
33
39
16
88
11
72
54
88
86
72
22
63
43
63
6
75
90
92
46
48
24
99
50
9
10
48
47
22
25
99
72
41
70
74
90
92
15
28
34
12
48
8
93
21
97
3
15
77
65
30
3
44
70
71
25
87
5
63
24

80
labs03/parse_results.py Executable file
View File

@ -0,0 +1,80 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Parse MTurk output file.
"""
import sys
import collections
import csv
import glob
import numpy as np
def map_formality(text: str):
values = {"Very Formal": 3,
"Formal": 2,
"Somewhat Formal": 1,
"Neutral": 0,
"Somewhat Informal": -1,
"Informal": -2,
"Very Informal": -3}
if text in values:
return values[text]
else:
return None
def mapping(text: str):
if text == 'Perfect':
return 5
elif text == 'Comprehensible':
return 4
elif text == 'Somewhat Comprehensible':
return 3
elif text == 'Incomprehensible':
return 2
elif text == 'Other':
return 1
def encode_quatation_marks(text):
return text.replace('\'', ''').replace('"', '"')
def read_files_from_dir(dir_name):
data = collections.defaultdict(list)
for fname in glob.glob(f"./{dir_name}/formality.test.*"):
with open(fname) as ff:
for line in ff:
line = line.strip()
data[fname].append(encode_quatation_marks(line))
return data
def main():
""" main """
result_file = sys.argv[1]
dir_name = sys.argv[2]
sent_scores = collections.defaultdict(list)
with open(result_file) as results:
mturk_data = csv.DictReader(results)
for row in mturk_data:
for i in range(1, 6):
# sent_scores[row[f'Input.sentence_{i}']].append(mapping(row[f'Answer.Q{i}Answer']))
sent_scores[row[f'Input.sentence_{i}']].append(map_formality(row[f'Answer.sentence_{i}_choice']))
for sent in sent_scores:
sent_scores[sent] = np.mean([i for i in sent_scores[sent] if i])
for filename, sents in read_files_from_dir(dir_name).items():
# print([sent_scores[sent] for sent in sents])
# print([sent_scores[sent] for sent in sents])
print(filename, np.nanmean([sent_scores[sent] for sent in sents]))
if __name__ == "__main__":
main()

33
labs03/tmp.py Normal file
View File

@ -0,0 +1,33 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
with open("./dane.txt") as ff:
x = [int(line.strip()) for line in ff]
print(np.mean(x))
print(np.var(x))
print(min(x))
print(max(x))
x_scaled = [(i - min(x)) / (max(x) - min(x)) for i in x]
print(min(x_scaled), max(x_scaled))
def normalize(data):
return [(i - np.mean(x)) / np.sqrt(np.var(x)) for i in data]
normalized = normalize(x)
print(np.mean(normalized), np.var(normalized))
x_binned = [i // 10 for i in x]
for begin in range(0, 1 + max(x_binned)):
if begin == 0:
print("[ ", 10 * begin, ", ", 10 * begin + 9, "]", "+" * x_binned.count(begin))
else:
print("[", 10 * begin, ",", 10 * begin + 9, "]", "+" * x_binned.count(begin))

26
labs03/zadania_05.md Normal file
View File

@ -0,0 +1,26 @@
*zad.1 *
- Stwórz nowy skrypt Pythona i nazwij go "histogram.py"
- Wczytaj plik "dane.txt", który jest plikiem tekstowym, w którym każdy wiersz zawiera jedną liczbę. Wynik zapisz do listy.
- Sprawdź czy masz zainstalowaną bibliotekę `numpy`. Jeżeli nie, to zainstaluj ją.
- Korzystając z funkcji numpy.mean i numpy.var, wyświetl na ekran średnią i wariancję z danych.
- Python posiada wbudowane funckje `min` i `max`, które zwracają najmniejszą i największą wartość.
- Przeskaluj dane do przedziału [0, 1] korzystając ze wzoru: x_scaled[i] = (x[i] - min(x)) / (max(x) - min(x))
- Napisz funckję, która znormalizuje dane do rozkładu N(0,1) korzystając ze wzoru: x_normed[i] = (x[i] - mean(x)) / sqrt(var(x))
- Upewnij się, że znormalizowane dane mają średnią równą 0, a wariancja jest równa 1.
- Zlicz ile jest elementów z każdym, z przedziałów: [0, 9], [10, 19], [20, 29],...
- Narysuj histogram ASCII, który dla każdego przedziału wyświetli liczbę elementów w następujący sposób:
```
[ 0 , 9 ] +++++++++++
[ 10 , 19 ] +++++++++
[ 20 , 29 ] +++++++++++
[ 30 , 39 ] ++++++++
[ 40 , 49 ] ++++++++++++++
[ 50 , 59 ] +++
[ 60 , 69 ] +++++++
[ 70 , 79 ] ++++++++++++++
[ 80 , 89 ] +++++++++
[ 90 , 99 ] +++++++++++++
```

56
labs03/zadania_06.py Normal file
View File

@ -0,0 +1,56 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
zad.1
Przepisz poniższy kod tak, aby korzystał z list składanych.
"""
elems = list(range(1024))
fives = []
for elem in elems:
if elem % 5 == 0:
fives.append(elem)
"""
zad. 2 - klasy
- Stwórz klasę Point2D, która będzie reprezentować punkt na płaszczyźnie.
- Napisz inicjalizator, który będzie przyjmować 2 parametry: x i y, a następnie
przypisze te wartości do pól: self.x i self.y
- Stwórz obiekt typu Point2D, przekazując dowolne wartości.
- Napisz metodę `dist(self, point)`, gdzie point to będzie obiekt tupy Point2D,
która obliczy odległość pomiędzy tymi punktami.
- Zaimplementuj metodę `__len__(self)`, która zwróci liczbę 2.
- Zaimplementuj metodę `__str__(self)`, który pozwoli na wyświetlenie w
czytelny sposób obiektu.
- Zaimplementuj metodę `__add__(self, point)`, gdzie point jest typu Point2D,
a która zwróci nowy punkt, powstanie z dodania współrzednych obu punktów.
- stwórz listę 4 punktów o współrzędnych: (0,0), (0, 5), (5,5), (5, 0)
- Oblicz sumę wszystkich odległości pomiędzy tymi punktami. Spróbuj wykorzystać
funkcje `sum` i `map`
"""
"""
zad. 3 Klasa wielokąt
- Zaimplementuj klasę wielokąt, która będzie reprezentować zbiór punktów na
płaszczyźnie.
- Napisz inicjalizator `__init__(self, points)`, który będzie przyjmować jako
argument listę punktów typy Point2D.
- napisz metodę, która zwróci punkt środkowy figury, tj. punkt o współrzednych
równych średnią z punktów wielokąta.
- Stwórz przykładowy wielokąt z punktów (0,0), (0, 5), (5,5), (5, 0) i
oblicz jego punkt środkowy.
- Korzystając funkcji min, napisz metodę która zwróci punkt najbardziej
wysunięty na lewo.
- Napisz metodę, która zwróci obwód figury: spróbuj wykorzystać funkcję sum.
"""
"""
zad. 4
- rozdziel kod w tym pliku, aby każda klasa znalazła się w osobnym pliku.
- Zaimportuj moduły z klasami tak, aby ten plik uruchamiał się normalnie.
- Przerób ten plik, aby wykorzystywał dyrektywe : if __name__ == '__main__'
"""