Funciones con y sin salida¶

¿Cuál es la diferencia entre las siguientes dos funciones?

In [1]:

mysin(x) = sin(x)
mysin2(x) = println(sin(x))

Out[1]:

mysin2 (generic function with 1 method)

In [2]:

mysin(3)

Out[2]:

0.1411200080598672

In [3]:

mysin2(3)

0.1411200080598672

In [4]:

x = mysin(3)
x

Out[4]:

0.1411200080598672

In [5]:

Out[5]:

0.1411200080598672

In [6]:

x = mysin2(3)
x

0.1411200080598672

In [7]:

La segunda versión no es útil, en el sentido que no regresa nada; el valor que se calculó se desapereció. Por lo tanto, casi siempre queremos que las funciones no impriman (excepto para depurar el código), sino que regresen valores.

Reutilizar código¶

¿Cómo podemos reutilizar código que ya hemos escrito?

No (es decir nunca) copiamos y pegamos.

Más bien, existe una manera fácil y ágil de "guardar" un pedazo de código para que lo podamos reutilizar después: ponerlo en una función. Las funciones existen para hacer disponible el trabajo que ya hemos hecho para que lo podamos reutilizar después.

Estabilidad de tipos¶

Haz

In [8]:

2^(-1)

DomainError
while loading In[8], in expression starting on line 1

 in power_by_squaring at intfuncs.jl:60
 in ^ at intfuncs.jl:84

¿Qué pasa? ¿Por qué?

En Julia, siempre debemos intentar que las funciones regresen siempre el mismo tipo de respuesta.

Evaluaciones de corto circuito¶

In [26]:

function imprime(x)
    println(string(x))
    x
end

Out[26]:

imprime (generic function with 1 method)

In [27]:

imprime(x==3)

true

Out[27]:

true

In [28]:

imprime(x==2)

false

Out[28]:

false

In [29]:

x = 3
y = 2

Out[29]:

In [30]:

imprime(x == 3) && imprime(y == 2)

true
true

Out[30]:

true

In [31]:

imprime(x == 3) && imprime(y == 1)

true
false

Out[31]:

false

In [32]:

imprime(x == 2) && imprime(y == 1)

false

Out[32]:

false

In [34]:

imprime(x == 3) || imprime(y == 1)

true

Out[34]:

true

¿Para qué sirve esto?

In [48]:

a = "1010110110001"
function pos_punto(a)
    for i=1:length(a)
#        if a[i] == '.'
#            println(i)
#        end
#         pos = i
        a[i] == '.' && return i
    end
    return 0
end

Out[48]:

pos_punto (generic function with 1 method)

In [49]:

pos_punto(a)

Out[49]:

In [39]:

search(a, '.' )

Out[39]:

In [50]:

search("hola" , '.')

Out[50]:

In [53]:

typeof("hola")

Out[53]:

ASCIIString (constructor with 2 methods)

In [52]:

'.'

Out[52]:

'.'

In [57]:

s = "1010" 

Out[57]:

"1010"

In [58]:

s[2]

Out[58]:

'0'

In [60]:

typeof(s[2])

Out[60]:

Char

In [59]:

int(ans)

Out[59]:

In [61]:

'hola'

syntax: invalid character literal
while loading In[61], in expression starting on line 1

In [62]:

'α'

Out[62]:

'α'

In [63]:

typeof(ans)

Out[63]:

Char

In [64]:

s =

syntax: incomplete: premature end of input
while loading In[64], in expression starting on line 1

In [71]:

s = "holαβ" 

Out[71]:

"holαβ"

In [66]:

typeof(s)

Out[66]:

UTF8String (constructor with 2 methods)

¿Cómo encontrar los caracteres en la cadena, de manera ingenua?

In [67]:

s[1]

Out[67]:

'h'

In [68]:

s[2]

Out[68]:

'o'

In [69]:

s[3]

Out[69]:

'l'

In [70]:

s[4]

Out[70]:

'α'

In [72]:

s[5]

invalid UTF-8 character index
while loading In[72], in expression starting on line 1

 in next at /usr/local/julia/julia-a05f87b79a/lib/julia/sys.dylib
 in getindex at string.jl:57

In [73]:

s[4]

Out[73]:

'α'

In [74]:

length(s)

Out[74]:

In [75]:

s[6]

Out[75]:

'β'

In [76]:

search(s, 'α')

Out[76]:

In [77]:

search(s, 'β')

Out[77]:

In [78]:

nextind(s, 4)

Out[78]:

In [79]:

@which search(s, 'β')

Out[79]:

search(s::String,c::Union(AbstractArray{Char,1},Set{Char},Char)) at string.jl:199

Completar nombres¶