from google.colab import drive
drive.mount('/content/drive')

# megjegyzés sor kettős kereszttel kezdődik és ezt a python értelmező kihagyja

A jol szerkesztett program jól olvasható, a programon belüli tagolások a space(betüköz behúzással) vagy TABULATOR nyomással lehetséges. 
Csak az egyiket alkalmazzuk és ne keverjük.

A véletlen szerú behúzásokat kerüljük. Ez általában hiba üzenetet is okoz.

##  Szám tipusú változók
i = 10      # egész szám (int) 
f = 3.14    # lebegőpontos szám (float) 
c = 2 - 5j  # komplex szám (complex) 

print(c)        # egy szerű nyomtatás

##  Szöveges állandók
s1 = 'alma'              # a határoló jel lehet ' 
s2 = "szilva"            # ...és " is 
s3 = '"alma" "szilva"'   # <= ilyenkor nem kell levédeni a sztringben a " karaktert!

# többsoros  szöveges állandók
s4 = """
 alma 
 szilva
 """ 

print(s4)  # egy szerű nyomtatás

## tömbszerű váltózók
t = (1, 2, 3)    # tuple !! utolag nem változtatható meg
l = [1, 2, 3]    # lista !! késöbb is bármely eleme módositható

## halmazszerű 
s = {1, 2, 3}                # halmaz 
d = {'x': 1, 'y': 2, 'z': 3} # szótár
d['x']                       # az 'x' kulcshoz rendelt érték lekérdezése 
d['x'] = 9                   # az 'x' kulcshoz érték módosítása
d['w'] = 0                   # új kulcs-érték pár hozzáadása
1 in s                       # eleme 1 az s halmaznak? 
'x' in d                     # van a d szótárban 'x' kulcs?



## tipus konverzió
int(2.3)         # float => int 
float('10')      # str => float 
str(20)          # int => str 
tuple([1, 2, 3]) # list => tuple 
list((4, 5, 6))  # tuple => list 
set((7, 8, 9))   # tuple => set

dict([('a', 1), ('b', 2)])     # pairs => dict 
list({'a': 1, 'b': 2}.items()) # dict => pairs


## Elágazások
if 2 * 2 == 4:     # Pythonban a elágazás feltétel megadása kettős ponttal zárulnak
     print('alma') # feltétel teljesülés belseje (végrehajtási kód) sorbehuzással különül el 
elif 2 * 2 == 5:   # a kód többi részétől. 
     print('szilva') 
else:              # Emiatt garantált, hogy a program 
     print('tök')  # megjelenése és logikai jelentése # összhangban van.


## Ciklusok

# végtelen ciklus megjegyzésként védve
#   while True: pass # Ha csak 1 végrehajtandó utasítás van, akkor írhatjuk a while-lal 1 sorba.

  
# a 0-tól 4-ig terjedő egész számok hetedik hatványának kiírása 
for i in range(4): 
   print(i**7)

# ciklusokből (azonnali) kilési parancsok : break, continue


## standard bemenet 

x = input('Kérek egy mondatot: ')          # programon belüli adatbekérő lehetőség
y = int(input('Kérek egy egész számot: ')) # tipus konverzióvál váltunk számjegy kérésre
  
  
## standard kimenet 
print('hello')          # kiírás soremeléssel 
print('hello', end='')  # kiírás soremelés nélkül



## feltétel nélküli 
a = [x**2 for x in range(10)] 
b = {x**2 for x in range(10)} 
c = {x: x**2 for x in range(10)} 

print (c)

## feltételes 
a = [x**2 for x in range(10) if x % 2 == 0] 
b = {x**2 for x in range(10) if x % 2 == 0} 
c = {x: x**2 for x in range(10) if x % 2 == 0}

print (c)


# lista rendezése helyben 
l = [2, 4, 1, 3] 
l.sort()


# kollekció rendezése listába 
l1 = sorted((2, 4, 1, 3)) 
l2 = sorted([2, 4, 1, 3]) 
l3 = sorted({2: 'b', 4: 'd', 1: 'a', 3: 'c'})

print(l3)


# párok listájának rendezése 
l1 = [('alma', 20), ('szilva', 30), ('barack', 10)] 
l2 = sorted(l1)                       # a kulcs a 0-ás elem 
l3 = sorted(l1, key=lambda x: x[1])   # a kulcs az 1-es elem

print(l3)


## fájl irás
f = open('pascal.txt', 'w')    ## elérési könyvtár megadása is szükséges lehet
f.write(' Első sor \n') 
f.write(' 2 sor \n') 
f.write(' 3 sor \n') 
f.close()


## fájl olvasás 1
content = open('pascal.txt').read()     # azonnali, direct beolvasás sztringbe (!! csinnyán bánjunk vele nagy fájlok esetén)
print(content)

## fájl olvasás 2
lines = open('pascal.txt').readlines()  # sorok beolvasása sztringlistába
print(lines)



# Pascal-háromszög kiszámítása és fájlba írása (komplex minta)
f = open('pascal.txt', 'w')    ## elérési könyvtár megadása is szükséges lehet
p = [1] 
for n in range(10): 
    f.write(str(p) + '\n') 
    q = [p[i] + p[i + 1] for i in range(len(p) - 1)] 
    p = [1] + q + [1] 
f.close()



## olvasás ciklusal
f = open('pascal.txt') 
f.readline() # 1. sor átugrása
for line in f: # további sorok tokenizálása 
   print(line.split(',')) 
f.close()



## általános eset: 
x, (y, z) = [10, (20, 30)] 

print(x)
print(y)
print(z)
print('-------1-----')
  
## többszörös értékadás: 
a, b = 30, 40 

print(a)
print(b)
print('-------2-----')

## csere (egylépésben): 
a, b = b, a

print(a)
print(b)
print('-------3-----')

a = ['spam', 'eggs', 1, 2]
print(a[:2], a[1: 3], a[:])   # => ['spam', 'eggs'] ['eggs', 1] ['spam', 'eggs', 1, 2]
print(a[-1], a[:-2])          # => 2 ['spam', 'eggs']
print(a[::-1], a[1::2])       # => [2, 1, 'eggs', 'spam'] ['eggs', 2]


a = ['A', 'B', 'C']

for i in range(len(a)):     # C nyelv szerü megadás mód 
  print(i, a[i])
  
print('-------1-----')

for i, ai in enumerate(a):  # Python nyelv szerü megadás mód 
  print(i, ai)


print('-------11-----')
  
  
a = ['A', 'B', 'C'] 
b = ['X', 'Y', 'Z']

for i in range(len(a)):       # C nyelv szerü megadás mód 
  print(a[i], b[i])
  
print('-------1-----')

for ai, bi in zip(a, b):      # Python nyelv szerü megadás mód 
  print(ai, bi)

## függvény létrehozása 1
def root(x, n=2): 
  '''  docstring rész
  függvény belső leirasa, hogy mit csinál
  n-th root of x.
  ''' 
  return x**(1.0 / n)

## függvény meghivása 1
print(root(2,2))

print('----------1--------------')

## függvény létrehozása 2
def fibon(F1=1, F2=1): 
  '''Return function that computes the 
  Fibonacci sequence with starting elements 
  F1 and F2.
  ''' 
  
  def g(n): 
     if n == 1:   return F1 
     elif n == 2: return F2 
     else:        return (g(n - 1) + g(n - 2)) 
  return g

## függvény meghivása 2
print(fibon(3))



# a random nevű standard modul importálása 
import random 
print(random.randint(1, 100))  # eredmény nyomtatása


# a random modulban található randint függvény importálása 
from random import randint 
print(randint(1, 100))        # eredmény nyomtatása


# modul teljes tartalmának importálása  (megjegyzés: általában kerülendő a névütközések miatt) 
from random import * 
print(randint(1, 100))


# függvény importálása almodulból 
from os.path import basename


# csomag importálása rövidített néven 
# (megjegyzés: a numpy egy külső csomag ezért előzetes installálása is szükséges lehet) 
import numpy as np


import re               ## könyvtár betöltés

# illeszkedésvizsgálat 
pattern = '^X+ .*' 
text = 'XXXX alma' 
if re.match(pattern, text): 
  print('a szöveg illeszkedik a mintára')
  
# ha többször használunk egy reguláris kifejezést, érdemes lefordítani 
p = re.compile('^X* .*')

# illeszkedésvizsgálat lefordított reguláris kifejezéssel 
print(p.match('alma'))        # => None # (if-ben hamisnak számít) 
print(p.match('XXXX alma'))   # => _sre.SRE_Match object # (if-ben igaznak számít)


import datetime           ## könyvtár betöltés
# mikroszekundum pontosságú időpont megadása 
print(datetime.datetime(2018, 2, 26, 9, 30, 30, 1000))  # (megjegyzés: időzóna információt is megadhatnánk)


# aritmetika nap pontosságú dátumokkal 
print(datetime.date(2018, 7, 31) + datetime.timedelta(1)) # => '2018-08-01'


# időzóna megadása a dátumhoz 
utc1 = datetime.timezone(datetime.timedelta(0, 3600)) 
print(utc1)                                                # => 'UTC+01:00' 


print(datetime.datetime(2018, 2, 26, 9, 30, 30))     # => '2018-02-26 09:30:30'


## Megjegyzés : nem szabványos csomagok időkezelésre: dateutil, pytz


import collections    ## könyvtár betöltés

# gyakoriságszámítást végző szótár 
print(collections.Counter([1, 1, 2]))       # => Counter({1: 2, 2: 1})


# alapértelmezett értéket feltételező szótár 
data = [(1, 'alma'), (2, 'körte'), (1, 'barack')] 
groups = collections.defaultdict(list) 
for x, y in data: 
  groups[x].append(y) 
print(groups)                # => defaultdict(<class 'list'>, 
                             # {1: ['alma', 'barack'], 2: ['körte']})
  
# garantáltan sorrendtartó szótár 
od = collections.OrderedDict() 
for i in 1, 2, 3: 
  od[i] = i**2 
print(od)                     # => OrderedDict([(1, 1), (2, 4), (3, 9)])
  
# olyan tuple, ahol névvel is lehet hivatkozni az elemekre 
Point = collections.namedtuple('Point', ('x', 'y')) 
p = Point(2, 3) 
print(p[0], p[1], p.x, p.y)   # => 2 3 2 3


import copy    ## könyvtár betöltés

# sekély másolat: csak legfelsőbb szintű elemek másolódnak 
a = [1, [2, 3]] 
b = copy.copy(a) 
b[1][0] = 20 
print(a)            # => [1, [20, 3]] 
print(b)            # => [1, [20, 3]] b változtatásától a is változott!

# mély másolat: az adatszerkezet összes eleméről másolat készül 
a = [1, [2, 3]] 
b = copy.deepcopy(a) 
b[1][0] = 20 
print(a)            # => [1, [2, 3]] 
print(b)            # => [1, [20, 3]] a nem változott, csak b


import math     ## könyvtár betöltés

# állandók 
print(math.e)     # => 2.718281828459045 
print(math.pi)    # => 3.141592653589793


# függvények 
print(math.sin(0))    # => 0.0 
print(math.cos(0))    # => 1.0 
print(math.asin(0.5)) # => 0.5235987755982989 
print(math.acos(0.5)) # => 1.047197551196597 
print(math.exp(1))    # => 2.718281828459045 
print(math.log(1))    # => 0.0


# radián-fok átalakítás 
print(math.degrees(math.pi)) # => 180.0 
print(math.radians(45))      # => 0.7853981633974483


# áttérés polárkoordinátákra 
x, y = 3, -4 
r = math.hypot(x, y) 
phi = math.atan2(y, x) 
print(r, phi)                # => 5.0 -0.9272952180016122


import random          ## könyvtár betöltés


# véletlenszám-generátor állapotának beállítása 
random.seed(42)


# float típusú érték generálása a [0, 1) intervallumból 
print(random.random())    # => 0.6394267984578837


# véletlenszám-generátor objektum létrehozása 
r = random.Random(42)


# float típusú érték generálása a [0, 1) intervallumból 
print(r.random())        # => 0.6394267984578837


# kockadobás szimulálása 
print(r.randint(1, 6))                    # => 2


# elem kisorsolása egy szekvenciából 
print(r.choice(['a', 'b', 'c', 'd']))     # => 'b'


# visszatevés nélküli mintavétel 
print(r.sample(['a', 'b', 'c', 'd'], 2))  # => ['a', 'c']



## lambda kifejezés: egysoros, névtelen függvény 
sqr = lambda x: x**2 
print(sqr(4))    # használata nyomtatásban


add = lambda x, y: x + y 
print(add(1, 2))  # használata nyomtatásban


## map: függvényt alkalmaz egy kollekció elemeire 
a = map(int, ['1', '2', '3']) 

b = map(lambda x: 2 * x, [1, 2, 3])



## ősosztály 
import math
class Shape: 
  def circularity(self): 
    a = self.area() 
    p = self.perimeter() 
    return 4 * math.pi * a / p**2 
  
  
## leszármazott osztály 1 
class Circle(Shape): 
  def __init__(self, r): self._r = r 
  def perimeter(self): return 2 * self._r * math.pi 
  def area(self): return self._r**2 * math.pi
  
  
## leszármazott osztály 2 
class Rectangle(Shape): 
  def __init__(self, a, b): self._a, self._b = a, b 
  def perimeter(self): return 2 * (self._a + self._b) 
  def area(self): return self._a * self._b



## tesztelés vektorokkal

class Vector(object):
    def __init__(self, sequence):
        self._internal_list = list(sequence)

my_vector = Vector([1, 2, 3])
print(my_vector)


v1 = Vector([1.0, 2.0, 3.0]) 
v2 = Vector([4.0, 5.0, 6.0]) 

print(len(v1), v1[0], v1[:2]) # => 3 1.0 [1.0, 2.0] 

print(v1 + v2)                # => Vector([5.0, 7.0, 9.0]) 

print(v1 * v2)                # => Vector([4.0, 10.0, 18.0])




##minta
x = int(input('Please enter an even number: ')) 
if x % 2 != 0: 
  raise ValueError('Odd number given!')
  
  
def divide(x, y): 
  try: 
    return x / y 
  except ZeroDivisionError: 
    print('Division by zero!') 
  finally: 
    print('Executing finally clause.')


## buggy.py file tartalma
def myavg(sequences): 
  joined = [] 
  for s in sequences: 
    joined.append(s) 
  return sum(joined) / len(joined)


sequences = [[1, 2, 3], [4, 5], [6, 7]] 
print(myavg(sequences)) 



## hibakeresés Jupyter Notebook környezetben: %run buggy.py %debug


## modul installálása colab Jupyter notebook alatt
!pip install -U -q PyDrive  
  
  

## minta modell

import tensorflow as tf
from tensorflow import keras
import datetime as dt
import os
import numpy as np
from google.colab import files
from google.colab import drive

# these are all the Google Drive and authentication libraries required
from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from google.colab import auth
from oauth2client.client import GoogleCredentials

# import the CIFAR-10 data then load into TensorFlow datasets
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()

# the training set with data augmentation
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(256).shuffle(10000)
train_dataset = train_dataset.map(lambda x, y: (tf.div(tf.cast(x, tf.float32), 255.0), tf.reshape(tf.one_hot(y, 10), (-1, 10))))
train_dataset = train_dataset.map(lambda x, y: (tf.image.central_crop(x, 0.75), y))
train_dataset = train_dataset.map(lambda x, y: (tf.image.random_flip_left_right(x), y))
train_dataset = train_dataset.repeat()

# the validation set
valid_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(5000).shuffle(10000)
valid_dataset = valid_dataset.map(lambda x, y: (tf.div(tf.cast(x, tf.float32),255.0), tf.reshape(tf.one_hot(y, 10), (-1, 10))))
valid_dataset = valid_dataset.map(lambda x, y: (tf.image.central_crop(x, 0.75), y))
valid_dataset = valid_dataset.repeat()

# now the model creation function
def create_model():
    model = keras.models.Sequential([
        keras.layers.Conv2D(96, 3, padding='same', activation=tf.nn.relu,
                            kernel_initializer=keras.initializers.VarianceScaling(distribution='truncated_normal'),
                            kernel_regularizer=keras.regularizers.l2(l=0.001),
                            input_shape=(24, 24, 3)),
        keras.layers.Conv2D(96, 3, 2, padding='same', activation=tf.nn.relu,
                            kernel_initializer=keras.initializers.VarianceScaling(distribution='truncated_normal'),
                            kernel_regularizer=keras.regularizers.l2(l=0.001)),
        keras.layers.Dropout(0.2),
        keras.layers.Conv2D(192, 3, padding='same', activation=tf.nn.relu,
                            kernel_initializer=keras.initializers.VarianceScaling(distribution='truncated_normal'),
                            kernel_regularizer=keras.regularizers.l2(l=0.001)),
        keras.layers.Conv2D(192, 3, 2, padding='same', activation=tf.nn.relu,
                            kernel_regularizer=keras.regularizers.l2(l=0.001)),
        keras.layers.BatchNormalization(),
        keras.layers.Dropout(0.5),
        keras.layers.Flatten(),
        keras.layers.Dense(256, activation=tf.nn.relu,
                           kernel_initializer=keras.initializers.VarianceScaling(),
                           kernel_regularizer=keras.regularizers.l2(l=0.001)),
        keras.layers.Dense(10),
        keras.layers.Softmax()
    ])

    model.compile(optimizer=tf.train.AdamOptimizer(),
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])
    return model
  
# finally create the model
model = create_model()

# LINUX parancsok közül jópár elérhető pl.: ls, mkdir, rmdir and curl.
# A fuller list of bash commands and functionality available on Google Colaboratory 
!cd ..
!ls  

## file feltöltés kiválasztással 1
from google.colab import files
uploaded = files.upload()


## file feltöltés kiválasztással 2
from google.colab import files
uploaded = files.upload()
for fn in uploaded.keys():
  print('User uploaded file "{name}" with length {length} bytes'.format(
      name=fn, length=len(uploaded[fn])))

##file feltöltés közvetlen file elériut meadással
files.download("downloaded_weights.12-1.05.hdf5")



## google drive elérés
from google.colab import drive
drive.mount('/content/drive')  ## a megjelenő ablakban azonosito megadása szükséges



with open('/content/drive/My Drive/foo.txt', 'w') as f:
  f.write('Hello Google Drive!')
!cat /content/drive/My\ Drive/foo.txt



## file letöltés
from google.colab import files

with open('example.txt', 'w') as f:
  f.write('some content')       ### minta file létrehozása

files.download('example.txt')   # létrehozott file letöltése