iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 01:31:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove non-breaking spaces

Browse Source
This commit is contained in:
Boris Verkhovskiy 2024-12-18 17:58:08 -07:00
parent f888151153
commit 3ecbf961d3
32 changed files with 530 additions and 530 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ansible.md
View File

@ -352,7 +352,7 @@ Get familiar with how you can use roles in the simple_apache_role example
```
playbooks/roles/simple_apache_role/
├── tasks
│   └── main.yml
│ └── main.yml
└── templates
└── main.yml
```

8
bash.md
View File

@ -343,7 +343,7 @@ echo "#helloworld" | tee output.out >/dev/null
rm -v output.out error.err output-and-error.log
rm -r tempDir/ # recursively delete
# You can install the `trash-cli` Python package to have `trash`
# which puts files in the system trash and doesn't delete them directly
# which puts files in the system trash and doesn't delete them directly
# see https://pypi.org/project/trash-cli/ if you want to be careful
# Commands can be substituted within other commands using $( ):
@ -360,7 +360,7 @@ case "$Variable" in
# List patterns for the conditions you want to meet
0) echo "There is a zero.";;
1) echo "There is a one.";;
*) echo "It is not null.";; # match everything
*) echo "It is not null.";; # match everything
esac
# `for` loops iterate for as many arguments given:
@ -462,8 +462,8 @@ cut -d ',' -f 1 file.txt
# replaces every occurrence of 'okay' with 'great' in file.txt
# (regex compatible)
sed -i 's/okay/great/g' file.txt
# be aware that this -i flag means that file.txt will be changed
# -i or --in-place erase the input file (use --in-place=.backup to keep a back-up)
# be aware that this -i flag means that file.txt will be changed
# -i or --in-place erase the input file (use --in-place=.backup to keep a back-up)
# print to stdout all lines of file.txt which match some regex
# The example prints lines which begin with "foo" and end in "bar"

2
cs/python.md
View File

@ -610,7 +610,7 @@ for nasobek in nasobicka_2([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]):
break
# Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo
# hodně času i paměti, proto se místo toho čísla generují postupně.
# hodně času i paměti, proto se místo toho čísla generují postupně.
for nasobek in nasobicka_2(range(900000000)):
# Vypíše postupně: "Zpracovávám číslo 1", ..., "Zpracovávám číslo 5"
if nasobek >= 10:

4
css.md
View File

@ -224,13 +224,13 @@ body {
/* Nest style rule inside another (CSS 3) */
.main {
.bgred { /* same as: .main .bgred { } */
.bgred { /* same as: .main .bgred { } */
background: red;
}
& .bggreen { /* same as: .main .bggreen { } */
background: green;
}
&.bgblue { /* (without space) same as: .main.bgblue { } */
&.bgblue { /* (without space) same as: .main.bgblue { } */
background: blue;
}
}

10
cue.md
View File

@ -488,12 +488,12 @@ To make it concrete, consider the following:
```
mymodule
├── config
│   ├── a.cue
│   └── b.cue
│ ├── a.cue
│ └── b.cue
├── cue.mod
│   ├── module.cue
│   ├── pkg
│   └── usr
│ ├── module.cue
│ ├── pkg
│ └── usr
└── main.cue
```

12
de/pythonlegacy.md
View File

@ -461,18 +461,18 @@ class Human(object):
return "*grunt*"
# Eine Eigenschaft (Property) ist wie ein Getter.
    # Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen.
    # Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben.
# Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen.
# Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben.
@property
def age(self):
return self._age
    # Damit kann die Eigenschaft festgelegt werden
# Damit kann die Eigenschaft festgelegt werden
@age.setter
def age(self, age):
self._age = age
    # Damit kann die Eigenschaft gelöscht werden
# Damit kann die Eigenschaft gelöscht werden
@age.deleter
def age(self):
del self._age
@ -561,7 +561,7 @@ class Superhero(Human):
# Mit der Funktion "super" können Sie auf die Methoden der übergeordneten Klasse
# zugreifen, die vom untergeordneten Objekt überschrieben werden,
# in diesem Fall die Methode __init__.
        # Dies ruft den Konstruktor der übergeordneten Klasse auf:
# Dies ruft den Konstruktor der übergeordneten Klasse auf:
super().__init__(name)
# überschreiben der "sing" Methode
@ -583,7 +583,7 @@ if __name__ == '__main__':
print('I am a superhero')
# Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, die sowohl von getattr() als auch von super() verwendet wird.
    # Dieses Attribut ist dynamisch und kann aktualisiert werden.
# Dieses Attribut ist dynamisch und kann aktualisiert werden.
print(Superhero.__mro__) # => (<class '__main__.Superhero'>,
# => <class 'human.Human'>, <class 'object'>)

2
el/python.md
View File

@ -523,7 +523,7 @@ next(our_iterator) # => "one"
next(our_iterator) # => "two"
next(our_iterator) # => "three"
# Όταν ο iterator έχει επιστρέψει όλα τα δεδομένα του, προκαλεί ένα μια εξαίρεση StopIteration.
# Όταν ο iterator έχει επιστρέψει όλα τα δεδομένα του, προκαλεί ένα μια εξαίρεση StopIteration.
next(our_iterator) # προκαλεί StopIteration
# Μπορείς να πάρεις όλα τα αντικείμενα ενός iteratior καλώντας list() πάνω του.

12
es/c++.md
View File

@ -280,7 +280,7 @@ foo(bar(tempObjectFun()))
void constReferenceTempObjectFun() {
// ConstRef obtiene el objeto temporal, y es válido hasta el final de esta
  // función.
// función.
const string& constRef = tempObjectFun();
...
}
@ -328,10 +328,10 @@ public:
Dog();
// Declaraciones de funciones de la clase (implementaciones a seguir)
    // Nota que usamos std::string aquí en lugar de colocar
    // using namespace std;
    // arriba.
    // Nunca ponga una declaración "using namespace" en un encabezado.
// Nota que usamos std::string aquí en lugar de colocar
// using namespace std;
// arriba.
// Nunca ponga una declaración "using namespace" en un encabezado.
void setName(const std::string& dogsName);
void setWeight(int dogsWeight);
@ -471,7 +471,7 @@ public:
Point& operator+=(const Point& rhs);
// También tendría sentido añadir los operadores - y -=,
    // pero vamos a omitirlos por razones de brevedad.
// pero vamos a omitirlos por razones de brevedad.
};
Point Point::operator+(const Point& rhs) const

54
es/fsharp.md
View File

@ -248,7 +248,7 @@ module EjemploDeSecuencia =
let secuencia1 = seq { yield "a"; yield "b" }
// Las secuencias pueden usar yield y
    // puede contener subsecuencias
// puede contener subsecuencias
let extranio = seq {
// "yield" agrega un elemento
yield 1; yield 2;
@ -262,7 +262,7 @@ module EjemploDeSecuencia =
extranio |> Seq.toList
// Las secuencias se pueden crear usando "unfold"
    // Esta es la secuencia de fibonacci
// Esta es la secuencia de fibonacci
let fib = Seq.unfold (fun (fst,snd) ->
Some(fst + snd, (snd, fst + snd))) (0,1)
@ -278,8 +278,8 @@ module EejemploDeTipoDeDatos =
// Todos los datos son inmutables por defecto
     // las tuplas son tipos anónimos simples y rápidos
     // - Usamos una coma para crear una tupla
// las tuplas son tipos anónimos simples y rápidos
// - Usamos una coma para crear una tupla
let dosTuplas = 1,2
let tresTuplas = "a",2,true
@ -301,7 +301,7 @@ module EejemploDeTipoDeDatos =
// ------------------------------------
// Los tipos de unión (o variantes) tienen un conjunto de elección
     // Solo un caso puede ser válido a la vez.
// Solo un caso puede ser válido a la vez.
// ------------------------------------
// Usamos "type" con barra/pipe para definir una unión estándar
@ -326,7 +326,7 @@ module EejemploDeTipoDeDatos =
// ------------------------------------
// Los tipos se pueden combinar recursivamente de formas complejas
    // sin tener que crear subclases
// sin tener que crear subclases
type Empleado =
| Trabajador of Persona
| Gerente of Empleado lista
@ -349,9 +349,9 @@ module EejemploDeTipoDeDatos =
| DireccionDeCorreoInvalido direccion -> () // no enviar
// Combinar juntos, los tipos de unión y tipos de registro
     // ofrece una base excelente para el diseño impulsado por el dominio.
     // Puedes crear cientos de pequeños tipos que reflejarán fielmente
     // el dominio.
// ofrece una base excelente para el diseño impulsado por el dominio.
// Puedes crear cientos de pequeños tipos que reflejarán fielmente
// el dominio.
type ArticuloDelCarrito = { CodigoDelProducto: string; Cantidad: int }
type Pago = Pago of float
@ -368,17 +368,17 @@ module EejemploDeTipoDeDatos =
// ------------------------------------
// Los tipos nativos tienen el comportamiento más útil "listo para usar", sin ningún código para agregar.
     // * Inmutabilidad
     // * Bonita depuración de impresión
     // * Igualdad y comparación
     // * Serialización
// * Inmutabilidad
// * Bonita depuración de impresión
// * Igualdad y comparación
// * Serialización
     // La impresión bonita se usa con %A
// La impresión bonita se usa con %A
printfn "dosTuplas=%A,\nPersona=%A,\nTemp=%A,\nEmpleado=%A"
dosTuplas persona1 temp1 trabajador
// La igualdad y la comparación son innatas
     // Aquí hay un ejemplo con tarjetas.
// Aquí hay un ejemplo con tarjetas.
type JuegoDeCartas = Trebol | Diamante | Espada | Corazon
type Rango = Dos | Tres | Cuatro | Cinco | Seis | Siete | Ocho
| Nueve | Diez | Jack | Reina | Rey | As
@ -398,11 +398,11 @@ module EejemploDeTipoDeDatos =
module EjemplosDePatronesActivos =
// F# tiene un tipo particular de coincidencia de patrón llamado "patrones activos"
    // donde el patrón puede ser analizado o detectado dinámicamente.
// donde el patrón puede ser analizado o detectado dinámicamente.
    // "clips de banana" es la sintaxis de los patrones activos
// "clips de banana" es la sintaxis de los patrones activos
    // por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ...
// por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ...
let (|Digito|Latra|EspacioEnBlanco|Otros|) ch =
if System.Char.IsDigit(ch) then Digito
else if System.Char.IsLetter(ch) then Letra
@ -425,7 +425,7 @@ module EjemplosDePatronesActivos =
// -----------------------------------------
// Puede crear un patrón de coincidencia parcial también
    // Solo usamos un guión bajo en la definición y devolvemos Some si coincide.
// Solo usamos un guión bajo en la definición y devolvemos Some si coincide.
let (|MultDe3|_|) i = if i % 3 = 0 then Some MultDe3 else None
let (|MultDe5|_|) i = if i % 5 = 0 then Some MultDe5 else None
@ -447,7 +447,7 @@ module EjemplosDePatronesActivos =
module EjemploDeAlgoritmo =
// F# tiene una alta relación señal / ruido, lo que permite leer el código
    // casi como un algoritmo real
// casi como un algoritmo real
// ------ Ejemplo: definir una función sumaDeCuadrados ------
let sumaDeCuadrados n =
@ -464,7 +464,7 @@ module EjemploDeAlgoritmo =
// Si la lista está vacía
| [] ->
[] // devolvemos una lista vacía
       // si la lista no está vacía
// si la lista no está vacía
| primerElemento::otrosElementos -> // tomamos el primer elemento
let elementosMasPequenios = // extraemos los elementos más pequeños
otrosElementos // tomamos el resto
@ -487,9 +487,9 @@ module EjemploDeAlgoritmo =
module AsyncExample =
// F# incluye características para ayudar con el código asíncrono
    // sin conocer la "pirámide del destino"
    //
    // El siguiente ejemplo descarga una secuencia de página web en paralelo.
// sin conocer la "pirámide del destino"
//
// El siguiente ejemplo descarga una secuencia de página web en paralelo.
open System.Net
open System
@ -531,9 +531,9 @@ module AsyncExample =
module EjemploCompatibilidadNet =
// F# puede hacer casi cualquier cosa que C# pueda hacer, y se ajusta
    // perfectamente con bibliotecas .NET o Mono.
// perfectamente con bibliotecas .NET o Mono.
  // ------- Trabaja con las funciones de las bibliotecas existentes -------
// ------- Trabaja con las funciones de las bibliotecas existentes -------
let (i1success,i1) = System.Int32.TryParse("123");
if i1success then printfn "convertido como %i" i1 else printfn "conversion fallida"
@ -559,7 +559,7 @@ module EjemploCompatibilidadNet =
// ------- Código orientado a objetos -------
// F# es también un verdadero lenguaje OO.
    // Admite clases, herencia, métodos virtuales, etc.
// Admite clases, herencia, métodos virtuales, etc.
// interfaz de tipo genérico
type IEnumerator<'a> =

256
es/hy.md
View File

@ -6,162 +6,162 @@ translators:
- ["Roberto R", "https://github.com/rrodriguze"]
---
Hy es un lenguaje de Lisp escrito sobre Python. Esto es posible convirtiendo
código Hy en un árbol abstracto de Python (ast). Por lo que, esto permite a
Hy llamar a código Python nativo y viceversa.
Hy es un lenguaje de Lisp escrito sobre Python. Esto es posible convirtiendo
código Hy en un árbol abstracto de Python (ast). Por lo que, esto permite a
Hy llamar a código Python nativo y viceversa.
```hylang
;; Esto es una intrucción muy básica a Hy, como la del siguiente enlace
;; https://hylang.org/try-hy
;; Esto es una intrucción muy básica a Hy, como la del siguiente enlace
;; https://hylang.org/try-hy
;;
; Comentarios usando punto y coma, como en otros Lisps
; Comentarios usando punto y coma, como en otros Lisps
;; Nociones básicas de expresiones
; Los programas List están hechos de expresiones simbólicas como la siguiente
(some-function args)
; ahora el esencial "Hola Mundo"
(print "hello world")
;; Nociones básicas de expresiones
; Los programas List están hechos de expresiones simbólicas como la siguiente
(some-function args)
; ahora el esencial "Hola Mundo"
(print "hello world")
;; Tipos de datos simples
; Todos los tipos de datos simples son exactamente semejantes a sus homólogos
; en Python
42 ; => 42
3.14 ; => 3.14
True ; => True
4+10j ; => (4+10j) un número complejo
;; Tipos de datos simples
; Todos los tipos de datos simples son exactamente semejantes a sus homólogos
; en Python
42 ; => 42
3.14 ; => 3.14
True ; => True
4+10j ; => (4+10j) un número complejo
; Vamos a comenzar con un poco de arimética simple
(+ 4 1) ;=> 5
; el operador es aplicado a todos los argumentos, como en otros Lisps
(+ 4 1 2 3) ;=> 10
(- 2 1) ;=> 1
(* 4 2) ;=> 8
(/ 4 1) ;=> 4
(% 4 2) ;=> 0 o operador módulo
; la exponenciación es representada por el operador ** como Python
(** 3 2) ;=> 9
; las funciones anidadas funcionan como lo esperado
(+ 2 (* 4 2)) ;=> 10
; también los operadores lógicos igual o no igual se comportan como se espera
(= 5 4) ;=> False
(not (= 5 4)) ;=> True
; Vamos a comenzar con un poco de arimética simple
(+ 4 1) ;=> 5
; el operador es aplicado a todos los argumentos, como en otros Lisps
(+ 4 1 2 3) ;=> 10
(- 2 1) ;=> 1
(* 4 2) ;=> 8
(/ 4 1) ;=> 4
(% 4 2) ;=> 0 o operador módulo
; la exponenciación es representada por el operador ** como Python
(** 3 2) ;=> 9
; las funciones anidadas funcionan como lo esperado
(+ 2 (* 4 2)) ;=> 10
; también los operadores lógicos igual o no igual se comportan como se espera
(= 5 4) ;=> False
(not (= 5 4)) ;=> True
;; variables
; las variables se configuran usando SETV, los nombres de las variables pueden
; usar utf-8, excepto for ()[]{}",'`;#|
(setv a 42)
(setv π 3.14159)
(def *foo* 42)
;; otros tipos de datos de almacenamiento
; strings, lists, tuples & dicts
; estos son exactamente los mismos tipos de almacenamiento en Python
"hello world" ;=> "hello world"
; las operaciones de cadena funcionan de manera similar en Python
(+ "hello " "world") ;=> "hello world"
; Las listas se crean usando [], la indexación comienza en 0
(setv mylist [1 2 3 4])
; las tuplas son estructuras de datos inmutables
(setv mytuple (, 1 2))
; los diccionarios son pares de valor-clave
(setv dict1 {"key1" 42 "key2" 21})
; :nombre se puede usar para definir palabras clave en Hy que se pueden usar para claves
(setv dict2 {:key1 41 :key2 20})
; usar 'get' para obtener un elemento en un índice/key
(get mylist 1) ;=> 2
(get dict1 "key1") ;=> 42
; Alternativamente, si se usan palabras clave que podrían llamarse directamente
(:key1 dict2) ;=> 41
;; variables
; las variables se configuran usando SETV, los nombres de las variables pueden
; usar utf-8, excepto for ()[]{}",'`;#|
(setv a 42)
(setv π 3.14159)
(def *foo* 42)
;; otros tipos de datos de almacenamiento
; strings, lists, tuples & dicts
; estos son exactamente los mismos tipos de almacenamiento en Python
"hello world" ;=> "hello world"
; las operaciones de cadena funcionan de manera similar en Python
(+ "hello " "world") ;=> "hello world"
; Las listas se crean usando [], la indexación comienza en 0
(setv mylist [1 2 3 4])
; las tuplas son estructuras de datos inmutables
(setv mytuple (, 1 2))
; los diccionarios son pares de valor-clave
(setv dict1 {"key1" 42 "key2" 21})
; :nombre se puede usar para definir palabras clave en Hy que se pueden usar para claves
(setv dict2 {:key1 41 :key2 20})
; usar 'get' para obtener un elemento en un índice/key
(get mylist 1) ;=> 2
(get dict1 "key1") ;=> 42
; Alternativamente, si se usan palabras clave que podrían llamarse directamente
(:key1 dict2) ;=> 41
;; funciones y otras estructuras de programa
; las funciones son definidas usando defn, o el último sexp se devuelve por defecto
(defn greet [name]
  "A simple greeting" ; un docstring opcional
  (print "hello " name))
;; funciones y otras estructuras de programa
; las funciones son definidas usando defn, o el último sexp se devuelve por defecto
(defn greet [name]
"A simple greeting" ; un docstring opcional
(print "hello " name))
(greet "bilbo") ;=> "hello bilbo"
(greet "bilbo") ;=> "hello bilbo"
; las funciones pueden tener argumentos opcionales, así como argumentos-clave
(defn foolists [arg1 &optional [arg2 2]]
  [arg1 arg2])
; las funciones pueden tener argumentos opcionales, así como argumentos-clave
(defn foolists [arg1 &optional [arg2 2]]
[arg1 arg2])
(foolists 3) ;=> [3 2]
(foolists 10 3) ;=> [10 3]
(foolists 3) ;=> [3 2]
(foolists 10 3) ;=> [10 3]
; las funciones anonimas son creadas usando constructores 'fn' y 'lambda'
; que son similares a 'defn'
(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
; las funciones anonimas son creadas usando constructores 'fn' y 'lambda'
; que son similares a 'defn'
(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
;; operaciones de secuencia
; Hy tiene algunas utilidades incluidas para operaciones de secuencia, etc.
; recuperar el primer elemento usando 'first' o 'car'
(setv mylist [1 2 3 4])
(setv mydict {"a" 1 "b" 2})
(first mylist) ;=> 1
;; operaciones de secuencia
; Hy tiene algunas utilidades incluidas para operaciones de secuencia, etc.
; recuperar el primer elemento usando 'first' o 'car'
(setv mylist [1 2 3 4])
(setv mydict {"a" 1 "b" 2})
(first mylist) ;=> 1
; corte listas usando 'cut'
(cut mylist 1 3) ;=> [2 3]
; corte listas usando 'cut'
(cut mylist 1 3) ;=> [2 3]
; obtener elementos de una lista o dict usando 'get'
(get mylist 1) ;=> 2
(get mydict "b") ;=> 2
; la lista de indexación comienza a partir de 0, igual que en Python
; assoc puede definir elementos clave/índice
(assoc mylist 2 10) ; crear mylist [1 2 10 4]
(assoc mydict "c" 3) ; crear mydict {"a" 1 "b" 2 "c" 3}
; hay muchas otras funciones que hacen que trabajar con secuencias sea
; entretenido
; obtener elementos de una lista o dict usando 'get'
(get mylist 1) ;=> 2
(get mydict "b") ;=> 2
; la lista de indexación comienza a partir de 0, igual que en Python
; assoc puede definir elementos clave/índice
(assoc mylist 2 10) ; crear mylist [1 2 10 4]
(assoc mydict "c" 3) ; crear mydict {"a" 1 "b" 2 "c" 3}
; hay muchas otras funciones que hacen que trabajar con secuencias sea
; entretenido
;; Python interop
;; los import funcionan exactamente como en Python
(import datetime)
(import functools [partial reduce]) ; importa fun1 e fun2 del module1
(import matplotlib.pyplot :as plt) ; haciendo una importación en foo como en bar
; todos los métodos de Python incluídos etc. son accesibles desde Hy
; a.foo(arg) is called as (.foo a arg)
(.split (.strip "hello world  ")) ;=> ["hello" "world"]
;; Python interop
;; los import funcionan exactamente como en Python
(import datetime)
(import functools [partial reduce]) ; importa fun1 e fun2 del module1
(import matplotlib.pyplot :as plt) ; haciendo una importación en foo como en bar
; todos los métodos de Python incluídos etc. son accesibles desde Hy
; a.foo(arg) is called as (.foo a arg)
(.split (.strip "hello world ")) ;=> ["hello" "world"]
;; Condicionales
; (if condition (body-if-true) (body-if-false)
(if (= passcode "moria")
  (print "welcome")
  (print "Speak friend, and Enter!"))
;; Condicionales
; (if condition (body-if-true) (body-if-false)
(if (= passcode "moria")
(print "welcome")
(print "Speak friend, and Enter!"))
; anidar múltiples cláusulas 'if else if' con condiciones
; anidar múltiples cláusulas 'if else if' con condiciones
(cond
 (= someval 42) (print "Life, universe and everything else!")
 (> someval 42) (print "val too large")
 (< someval 42) (print "val too small"))
(= someval 42) (print "Life, universe and everything else!")
(> someval 42) (print "val too large")
(< someval 42) (print "val too small"))
; declaraciones de grupo con 'do', son ejecutadas secuencialmente
; formas como defn tienen un 'do' implícito
; declaraciones de grupo con 'do', son ejecutadas secuencialmente
; formas como defn tienen un 'do' implícito
(do
 (setv someval 10)
 (print "someval is set to " someval)) ;=> 10
(setv someval 10)
(print "someval is set to " someval)) ;=> 10
; crear enlaces léxicos con 'let', todas las variables definidas de esta manera
; tienen alcance local
(let [[nemesis {"superman" "lex luther"
                "sherlock" "moriarty"
                "seinfeld" "newman"}]]
  (for [(, h v) (.items nemesis)]
    (print (.format "{0}'s nemesis was {1}" h v))))
; crear enlaces léxicos con 'let', todas las variables definidas de esta manera
; tienen alcance local
(let [[nemesis {"superman" "lex luther"
"sherlock" "moriarty"
"seinfeld" "newman"}]]
(for [(, h v) (.items nemesis)]
(print (.format "{0}'s nemesis was {1}" h v))))
;; clases
; las clases son definidas de la siguiente manera
;; clases
; las clases son definidas de la siguiente manera
(defclass Wizard [object]
  (defn __init__ [self spell]
    (setv self.spell spell))
(defn __init__ [self spell]
(setv self.spell spell))
  (defn get-spell [self]
    self.spell))
(defn get-spell [self]
self.spell))
```
### Otras lecturas
### Otras lecturas
Este tutorial apenas es una introducción básica para Hy/Lisp/Python.
Este tutorial apenas es una introducción básica para Hy/Lisp/Python.
Docs Hy: [https://hylang.org/hy/doc](https://hylang.org/hy/doc)
Docs Hy: [https://hylang.org/hy/doc](https://hylang.org/hy/doc)
Repo Hy en GitHub: [https://github.com/hylang/hy](https://github.com/hylang/hy)
Repo Hy en GitHub: [https://github.com/hylang/hy](https://github.com/hylang/hy)
Acceso a freenode irc con #hy, hashtag en twitter: #hylang
Acceso a freenode irc con #hy, hashtag en twitter: #hylang

10
es/kotlin.md
View File

@ -36,7 +36,7 @@ fun main(args: Array<String>) {
/*
En la mayoría de los casos, Kotlin puede determinar cuál es el tipo de una variable,
de tal manera que no tenemos que especificarlo explícitamente cada vez.
    Podemos declarar explícitamente el tipo de una variable así:
Podemos declarar explícitamente el tipo de una variable así:
*/
val foo: Int = 7
@ -59,7 +59,7 @@ fun main(args: Array<String>) {
/*
Una cadena está delimitada por comillas triple (""").
    Estas cadenas pueden contener saltos de línea y otros caracteres.
Estas cadenas pueden contener saltos de línea y otros caracteres.
*/
val fooRawString = """
fun helloWorld(val name : String) {
@ -70,7 +70,7 @@ fun main(args: Array<String>) {
/*
Las cadenas pueden contener interpolación de cadenas.
    La interpolación de cadenas comienza con un signo de dólar ($).
La interpolación de cadenas comienza con un signo de dólar ($).
*/
val fooTemplateString = "$fooString tiene ${fooString.length} caracteres"
println(fooTemplateString)
@ -78,8 +78,8 @@ fun main(args: Array<String>) {
/*
Para que una variable pueda aceptar valor nulo se debe especificar
explícitamente como anulable añadiendole ? a su tipo.
    Podemos acceder a una variable anulable mediante el uso del operador ?.
    Podemos utilizar el operador ?: para especificar un valor alternativo
Podemos acceder a una variable anulable mediante el uso del operador ?.
Podemos utilizar el operador ?: para especificar un valor alternativo
a usar si una variable es nula.
*/
var fooNullable: String? = "abc"

4
fr/c++.md
View File

@ -746,8 +746,8 @@ bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
// Suppose que chaque fonction retourne faux si elle échoue
if (!faireQuelqueChoseAvecLeFichier(fh)) {
       fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites
       return false; // Propage l'erreur
fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites
return false; // Propage l'erreur
}
if (!faireAutreChoseAvec(fh)) {
fclose(fh);

50
fr/livescript.md
View File

@ -93,7 +93,7 @@ fruits = <[ apple orange pear ]>
fruits[0] # => "apple"
# Les objets sont une collection non ordonnées de paires clé/valeur, et
# d'autres choses (que nous verrons plus tard).
# d'autres choses (que nous verrons plus tard).
person =
name: "Christina"
likes:
@ -101,7 +101,7 @@ person =
* "and other cute stuff"
# A nouveau, vous pouvez utiliser une expression plus consise à l'aide des
# accolades:
# accolades:
person = {name: "Christina", likes: ["kittens", "and other cute stuff"]}
# Vous pouvez récupérer une entrée via sa clé:
@ -113,7 +113,7 @@ person["name"] # => "Christina"
trailing-space = /\s$/ # les mots-composés deviennent motscomposés
# A l'exception que vous pouvez pouvez utiliser des expressions sur plusieurs
# lignes!
# lignes!
# (les commentaires et les espaces seront ignorés)
funRE = //
function\s+(.+) # nom
@ -135,9 +135,9 @@ funRE = //
# Les comparaisons sont presque identiques, à l'exception que `==` équivaut au
# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la
# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes
# (sans conversion de type)
# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la
# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes
# (sans conversion de type)
2 == 2 # => true
2 == "2" # => false
2 ~= "2" # => true
@ -169,8 +169,8 @@ not false # => true
########################################################################
# Puisque LiveScript est fonctionnel, vous vous attendez à une bonne prise en
# charge des fonctions. En LiveScript, il est encore plus évident que les
# fonctions sont de premier ordre:
# charge des fonctions. En LiveScript, il est encore plus évident que les
# fonctions sont de premier ordre:
add = (left, right) -> left + right
add 1, 2 # => 3
@ -181,7 +181,7 @@ two!
# LiveScript utilise l'environnement de la fonction, comme JavaScript.
# A l'inverse de JavaScript, le `=` fonctionne comme un opérateur de
# déclaration, et il déclarera toujours la variable située à gauche (sauf si
# déclaration, et il déclarera toujours la variable située à gauche (sauf si
# la variable a été déclarée dans l'environnement parent).
# L'opérateur `:=` est disponible pour réutiliser un nom provenant de
@ -189,18 +189,18 @@ two!
# Vous pouvez extraire les arguments d'une fonction pour récupérer
# rapidement les valeurs qui vous intéressent dans une structure de données
# rapidement les valeurs qui vous intéressent dans une structure de données
# complexe:
tail = ([head, ...rest]) -> rest
tail [1, 2, 3] # => [2, 3]
# Vous pouvez également transformer les arguments en utilisant les opérateurs
# binaires et unaires. Définir des arguments par défaut est aussi possible.
# binaires et unaires. Définir des arguments par défaut est aussi possible.
foo = (a = 1, b = 2) -> a + b
foo! # => 3
# You pouvez utiliser cela pour cloner un argument en particulier pour éviter
# les effets secondaires. Par exemple:
# les effets secondaires. Par exemple:
copy = (^^target, source) ->
for k,v of source => target[k] = v
target
@ -220,12 +220,12 @@ identity = -> it
identity 1 # => 1
# Les opérateurs ne sont pas des fonctions en LiveScript, mais vous pouvez
# facilement les transformer en fonction:
# facilement les transformer en fonction:
divide-by-two = (/ 2)
[2, 4, 8, 16].map(divide-by-two).reduce (+)
# Comme dans tout bon langage fonctionnel, vous pouvez créer des fonctions
# composées d'autres fonctions:
# composées d'autres fonctions:
double-minus-one = (- 1) . (* 2)
# En plus de la formule mathématique `f . g`, vous avez les opérateurs `>>`
@ -235,7 +235,7 @@ double-minus-one = (- 1) << (* 2)
# Pour appliquer une valeur à une fonction, vous pouvez utiliser les opérateurs
# `|>` et `<|`:
# `|>` et `<|`:
map = (f, xs) --> xs.map f
[1 2 3] |> map (* 2) # => [2 4 6]
@ -248,15 +248,15 @@ reduce = (f, xs, initial) --> xs.reduce f, initial
[1 2 3] |> reduce (+), _, 0 # => 6
# Le tiret bas est également utilisé pour l'application partielle,
# que vous pouvez utiliser pour toute fonction:
# Le tiret bas est également utilisé pour l'application partielle,
# que vous pouvez utiliser pour toute fonction:
div = (left, right) -> left / right
div-by-two = div _, 2
div-by-two 4 # => 2
# Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel.
# (mais vous devriez essayer des approches plus fonctionnelles, comme
# (mais vous devriez essayer des approches plus fonctionnelles, comme
# Promises).
# Un fonction de rappel est une fonction qui est passée en argument à une autre
# fonction:
@ -289,7 +289,7 @@ x = switch
| otherwise => \object # `otherwise` et `_` correspondent.
# Le corps des fonctions, les déclarations et les assignements disposent d'un
# `switch` implicite, donc vous n'avez pas besoin de le réécrire:
# `switch` implicite, donc vous n'avez pas besoin de le réécrire:
take = (n, [x, ...xs]) -->
| n == 0 => []
| _ => [x] ++ take (n - 1), xs
@ -300,14 +300,14 @@ take = (n, [x, ...xs]) -->
########################################################################
# Comme en python, vous allez pouvoir utiliser les listes en compréhension,
# ce qui permet de générer rapidement et de manière élégante une liste de
# valeurs:
# ce qui permet de générer rapidement et de manière élégante une liste de
# valeurs:
oneToTwenty = [1 to 20]
evens = [x for x in oneToTwenty when x % 2 == 0]
# `when` et `unless` peuvent être utilisés comme des filtres.
# Cette technique fonctionne sur les objets de la même manière. Vous allez
# Cette technique fonctionne sur les objets de la même manière. Vous allez
# pouvoir générer l'ensemble de paires clé/valeur via la syntaxe suivante:
copy = { [k, v] for k, v of source }
@ -317,8 +317,8 @@ copy = { [k, v] for k, v of source }
########################################################################
# Bien que LiveScript soit un langage fonctionnel, il dispose d'intéressants
# outils pour la programmation objet. La syntaxe de déclaration d'une classe
# est héritée de CoffeeScript:
# outils pour la programmation objet. La syntaxe de déclaration d'une classe
# est héritée de CoffeeScript:
class Animal
(@name, kind) ->
@kind = kind
@ -332,7 +332,7 @@ kitten = new Cat 'Mei'
kitten.purr! # => "*Mei (a cat) purrs*"
# En plus de l'héritage classique, vous pouvez utiliser autant de mixins
# que vous voulez pour votre classe. Les mixins sont juste des objets:
# que vous voulez pour votre classe. Les mixins sont juste des objets:
Huggable =
hug: -> @action 'is hugged'

2
fr/racket.md
View File

@ -416,7 +416,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no `d'
(values i (number->string i)))
; => '#hash((1 . "1") (2 . "2") (3 . "3"))
;; Il y a plein d'autres fonctions natives pour collecter des données à
;; Il y a plein d'autres fonctions natives pour collecter des données à
;; l'aide de boucles
(for/sum ([i 10]) (* i i)) ; => 285
(for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000

376
fr/rust.md
View File

@ -35,271 +35,271 @@ Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts
// Les fonctions
// `I32` est le type 32 bits entiers signés
fn add2(x: i32, y: i32) -> i32 {
    // Retour implicite (pas de point virgule)
    x + y
// Retour implicite (pas de point virgule)
x + y
}
// Fonction principale
fn main() {
    // Nombres //
// Nombres //
    // Liaison immutable
    let x: i32 = 1;
// Liaison immutable
let x: i32 = 1;
    // Suffixes entiers et flottants
    let y: I32 = 13i32;
    let f: f64 = 1.3f64;
// Suffixes entiers et flottants
let y: I32 = 13i32;
let f: f64 = 1.3f64;
    // Inférence de type
    // La plupart du temps, le compilateur Rust peut déduire quel est le type
// Inférence de type
// La plupart du temps, le compilateur Rust peut déduire quel est le type
// de variable, donc vous n'avez pas à écrire une annotation de type explicite.
    // Tout au long de ce tutoriel, les types sont explicitement annotées dans
// Tout au long de ce tutoriel, les types sont explicitement annotées dans
// de nombreux endroits, mais seulement à des fins de démonstration.
// L'inférence de type peut les générer pour vous la plupart du temps.
    let implicit_x = 1;
    let implicit_f = 1,3;
let implicit_x = 1;
let implicit_f = 1,3;
    // Arithmétique
    let somme = x + y + 13;
// Arithmétique
let somme = x + y + 13;
    // Variable Mutable
    let mut mutable = 1;
    let mutable = 4;
    let mutable += 2;
// Variable Mutable
let mut mutable = 1;
let mutable = 4;
let mutable += 2;
    // Chaînes //
// Chaînes //
    // Chaîne littérales
    let x: &str = "Bonjour tout le monde !";
// Chaîne littérales
let x: &str = "Bonjour tout le monde !";
    // Affichage
    println!("{} {}", f, x); // 1.3 Bonjour tout le monde
// Affichage
println!("{} {}", f, x); // 1.3 Bonjour tout le monde
    // Une `Chaîne` - une chaîne de tas alloué
    let s: String = "Bonjour tout le monde".to_string();
// Une `Chaîne` - une chaîne de tas alloué
let s: String = "Bonjour tout le monde".to_string();
    // Un morceau de chaîne - une vue immutable sur une autre chaîne.
    // C'est essentiellement un pointeur immutable sur une chaîne - ça ne
    // contient effectivement pas le contenu d'une chaîne, juste un pointeur vers
    // le début et la fin de la chaîne.
    let s_slice: &str = &s;
// Un morceau de chaîne - une vue immutable sur une autre chaîne.
// C'est essentiellement un pointeur immutable sur une chaîne - ça ne
// contient effectivement pas le contenu d'une chaîne, juste un pointeur vers
// le début et la fin de la chaîne.
let s_slice: &str = &s;
    println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde
println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde
    // Vecteurs/tableau //
// Vecteurs/tableau //
    // Un tableau de taille fixe
    let four_ints: [i32; 4] = [1, 2, 3, 4];
// Un tableau de taille fixe
let four_ints: [i32; 4] = [1, 2, 3, 4];
    // Un tableau dynamique(vecteur)
    let mut vecteur: Vec<i32> = vec![1, 2, 3, 4];
    vecteur.push(5);
// Un tableau dynamique(vecteur)
let mut vecteur: Vec<i32> = vec![1, 2, 3, 4];
vecteur.push(5);
    // Une tranche - une vue immutable sur un vecteur ou un tableau.
    // Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs.
    let tranche: &[i32] = &vecteur;
// Une tranche - une vue immutable sur un vecteur ou un tableau.
// Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs.
let tranche: &[i32] = &vecteur;
    // Utiliser `{:?}` pour afficher quelque chose en mode debug
    println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
// Utiliser `{:?}` pour afficher quelque chose en mode debug
println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
    // Tuples //
// Tuples //
    // Un tuple est un ensemble de valeurs qui peuvent être de différents types.
    let x:(i32, &str, f64) = (1, "bonjour", 3.4);
// Un tuple est un ensemble de valeurs qui peuvent être de différents types.
let x:(i32, &str, f64) = (1, "bonjour", 3.4);
    // Déstructurer `let`
    let (a, b, c) = x;
    println!("{} {} {}", a, b, c); // 1 bonjour 3.4
// Déstructurer `let`
let (a, b, c) = x;
println!("{} {} {}", a, b, c); // 1 bonjour 3.4
    // indexation
    println!("{}", x.1); // Bonjour
// indexation
println!("{}", x.1); // Bonjour
    //////////////
    // 2. Types //
    //////////////
//////////////
// 2. Types //
//////////////
    // Struct
    struct Point {
        x: i32,
        y: i32,
    }
// Struct
struct Point {
x: i32,
y: i32,
}
    let origine: Point = Point { x: 0, y: 0 };
let origine: Point = Point { x: 0, y: 0 };
    // Un struct avec des champs sans nom, appelé 'tuple struct'.
    struct Point2(i32, i32);
// Un struct avec des champs sans nom, appelé 'tuple struct'.
struct Point2(i32, i32);
    let origine2 = Point2(0, 0);
let origine2 = Point2(0, 0);
    // Basic C-like enum
    enum Direction {
        Àgauche,
        Droite,
        En_Haut,
        Vers_Le_Bas,
    }
// Basic C-like enum
enum Direction {
Àgauche,
Droite,
En_Haut,
Vers_Le_Bas,
}
    let en_haut = Direction::En_Haut;
let en_haut = Direction::En_Haut;
    // Enum avec des champs
    enum OptionnelI32 {
        AnI32(I32),
        Rien,
    }
// Enum avec des champs
enum OptionnelI32 {
AnI32(I32),
Rien,
}
    let deux: OptionnelI32 = OptionnelI32::AnI32(2);
    let rien = OptionnelI32::Rien;
let deux: OptionnelI32 = OptionnelI32::AnI32(2);
let rien = OptionnelI32::Rien;
    // Generics //
// Generics //
    struct Foo<T> { bar: T }
struct Foo<T> { bar: T }
    // Ceci est défini dans la bibliothèque standard comme `Option`.
    enum Optionnel<T> {
        SomeVal(T),
        NoVal,
    }
// Ceci est défini dans la bibliothèque standard comme `Option`.
enum Optionnel<T> {
SomeVal(T),
NoVal,
}
    // Méthodes //
// Méthodes //
    impl<T> Foo<T> {
        // Méthodes prennent un paramètre explicite `de self`.
        fn get_bar(self) -> T {
            self.bar
        }
    }
impl<T> Foo<T> {
// Méthodes prennent un paramètre explicite `de self`.
fn get_bar(self) -> T {
self.bar
}
}
    let a_foo = Foo { bar: 1 };
    println!("{}", a_foo.get_bar()); // 1
let a_foo = Foo { bar: 1 };
println!("{}", a_foo.get_bar()); // 1
    // Traits (connu sous le nom des interfaces ou des classes de types dans
// Traits (connu sous le nom des interfaces ou des classes de types dans
// d'autres langues).
    trait Frobnicate<T> {
        fn frobnicate(self) -> Option<T>;
    }
trait Frobnicate<T> {
fn frobnicate(self) -> Option<T>;
}
    impl<T> Frobnicate<T> for Foo<T> {
        fn frobnicate(self) -> Option<T> {
            Some(self.bar)
        }
    }
impl<T> Frobnicate<T> for Foo<T> {
fn frobnicate(self) -> Option<T> {
Some(self.bar)
}
}
    let another_foo = Foo { bar: 1 };
    println!("{:?}", another_foo.frobnicate()); // Some(1)
let another_foo = Foo { bar: 1 };
println!("{:?}", another_foo.frobnicate()); // Some(1)
    /////////////////////////
    // 3. Motif correspondant //
    /////////////////////////
/////////////////////////
// 3. Motif correspondant //
/////////////////////////
    let foo = OptionnelI32::AnI32(1);
    match foo {
        OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n),
        OptionnelI32::Rien => println!("Il n'y a rien!"),
    }
let foo = OptionnelI32::AnI32(1);
match foo {
OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n),
OptionnelI32::Rien => println!("Il n'y a rien!"),
}
    // Motif avancé correspondant
    struct FooBar { x: i32, y: OptionnelI32 }
    let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) };
// Motif avancé correspondant
struct FooBar { x: i32, y: OptionnelI32 }
let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) };
    match bar {
        FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} =>
            println!("Les chiffres sont nuls!"),
        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m =>
            println!("Les chiffres sont les mêmes"),
        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} =>
            println!("Différents numéros: {} {}", n, m)!,
        FooBar { x: _, y: OptionnelI32 :: Rien} =>
            println!("Le deuxième numéro est rien!"),
    }
match bar {
FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} =>
println!("Les chiffres sont nuls!"),
FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m =>
println!("Les chiffres sont les mêmes"),
FooBar { x: n, y: OptionnelI32 :: AnI32(m)} =>
println!("Différents numéros: {} {}", n, m)!,
FooBar { x: _, y: OptionnelI32 :: Rien} =>
println!("Le deuxième numéro est rien!"),
}
    /////////////////////
    // 4. Flux de contrôle //
    /////////////////////
/////////////////////
// 4. Flux de contrôle //
/////////////////////
    // `for` boucles / itération
    let array = [1, 2, 3];
    for i in array {
        println!("{}", i);
    }
// `for` boucles / itération
let array = [1, 2, 3];
for i in array {
println!("{}", i);
}
    // Ranges
    for i in 0u32..10 {
        print!("{}", i);
    }
    println!("");
    // imprime `0 1 2 3 4 5 6 7 8 9`
// Ranges
for i in 0u32..10 {
print!("{}", i);
}
println!("");
// imprime `0 1 2 3 4 5 6 7 8 9`
    // `if`
    if 1 == 1 {
        println!("Maths est travaille!");
    } else {
        println!("Oh non ...!");
    }
// `if`
if 1 == 1 {
println!("Maths est travaille!");
} else {
println!("Oh non ...!");
}
    // `if` comme expression
    let valeur = if true {
        "bien"
    } else {
        "mal"
    };
// `if` comme expression
let valeur = if true {
"bien"
} else {
"mal"
};
    // `while` boucle
    while 1 == 1 {
        println!("L'univers fonctionne normalement.");
    }
// `while` boucle
while 1 == 1 {
println!("L'univers fonctionne normalement.");
}
    // Boucle infinie
    loop {
        println!("Bonjour!");
    }
// Boucle infinie
loop {
println!("Bonjour!");
}
    /////////////////////////////////
    // 5. Sécurité & pointeurs mémoire //
    /////////////////////////////////
/////////////////////////////////
// 5. Sécurité & pointeurs mémoire //
/////////////////////////////////
// Pointeur occasion - une seule chose peut "posséder" pointeur à un moment.
    // Cela signifie que lorsque le `Box` laisse son champ d'application, il
// Cela signifie que lorsque le `Box` laisse son champ d'application, il
// peut être automatiquement libérée en toute sécurité.
    let mut mine: Box<i32> = Box::new(3);
    *mine = 5; // déréférencer
    // Ici, `now_its_mine` prend possession de `mine`. En d'autres termes,
let mut mine: Box<i32> = Box::new(3);
*mine = 5; // déréférencer
// Ici, `now_its_mine` prend possession de `mine`. En d'autres termes,
// `mine` est déplacé.
    let mut now_its_mine = mine;
    *now_its_mine += 2;
let mut now_its_mine = mine;
*now_its_mine += 2;
    println!("{}", now_its_mine); // 7
    // println!("{}", now_its_mine); // Cela ne compile pas parce
println!("{}", now_its_mine); // 7
// println!("{}", now_its_mine); // Cela ne compile pas parce
// que `now_its_mine` possède maintenant le pointeur
    // Référence - un pointeur immutable qui fait référence à d'autres données.
    // Quand une référence est prise à une valeur, nous disons que la valeur
// Référence - un pointeur immutable qui fait référence à d'autres données.
// Quand une référence est prise à une valeur, nous disons que la valeur
// a été "emprunté".
    // Même si une valeur est emprunté immutablement, il ne peut pas être
// Même si une valeur est emprunté immutablement, il ne peut pas être
// muté ou déplacé.
    // Un emprunt dure jusqu'à la fin de la portée, il a été créé.
    let mut var = 4;
    var = 3;
    let ref_var: &i32 = &var;
// Un emprunt dure jusqu'à la fin de la portée, il a été créé.
let mut var = 4;
var = 3;
let ref_var: &i32 = &var;
    println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé
    println!("{}", *ref_var);
    // Var = 5; // Cela ne compile pas parce que `var` est emprunté.
    // *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une
println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé
println!("{}", *ref_var);
// Var = 5; // Cela ne compile pas parce que `var` est emprunté.
// *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une
// référence immutable.
    // Référence Mutable
    // Même si une valeur est empruntée de façon mutable, elle ne peut pas être
// Référence Mutable
// Même si une valeur est empruntée de façon mutable, elle ne peut pas être
// accessible à tous.
    let mut var2 = 4;
    let ref_var2: &mut i32 = &mut var2;
let mut var2 = 4;
let ref_var2: &mut i32 = &mut var2;
// '*' est utilisé pour pointer vers le var2 mutably emprunté.
*ref_var2 += 2;
println!("{}", * ref_var2); // 6, // var2 ne compilerait pas.
    // ref_var2 est de type &mut i32 donc stocke la référence à i32,
// ref_var2 est de type &mut i32 donc stocke la référence à i32,
// pas la valeur.
    // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté.
// var2 = 2; // Cela ne compile pas parce que `var2` est emprunté.
}
```

14
fr/xml.md
View File

@ -41,10 +41,10 @@ Contrairement à HTML, XML ne spécifie pas comment afficher ou formater les inf
Il commence par une déclaration, qui informe certaines métadonnées (en option).
XML utilise une structure arborescente. Ci-dessus, le nœud racine est «librairie», qui a
   trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ...
trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ...
On crée les nœuds avec des balises d'ouverture / fermeture, et les enfants sont les nœuds juste entre
   les balises d'ouverture et de fermeture. -->
les balises d'ouverture et de fermeture. -->
<!-- XML porte deux types d'informations:
@ -72,7 +72,7 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d
```xml
<!-- Ci-dessous, vous pouvez voir une version simplifiée du document de librairie,
   avec l'addition de définition DTD. -->
avec l'addition de définition DTD. -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE note SYSTEM "Librairie.dtd">
@ -95,10 +95,10 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d
]>
<!-- La DTD commence par une déclaration.
   Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants.
   Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut
   appelé «catégorie», avec «littérature» comme valeur par défaut.
   Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés
Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants.
Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut
appelé «catégorie», avec «littérature» comme valeur par défaut.
Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés
(Anglais: «parsed character data») -->
<!-- La DTD pourrait être déclarée dans le fichier XML lui-même -->

10
id/smallbasic.md
View File

@ -28,7 +28,7 @@ print "halo"
REM Struktur kontrol
FOR index = 0 TO 10 STEP 2
  ? "Ini adalah nomor baris"; indeks
? "Ini adalah nomor baris"; indeks
NEXT
J=0
REPEAT
@ -57,10 +57,10 @@ End Try
REM Fungsi dan subrutin buatan pengguna
func add2(x, y)
  'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC
  local k
  k = "k akan lenyap ketika FUNC ini mengembalikan nilai"
  add2 = x + y
'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC
local k
k = "k akan lenyap ketika FUNC ini mengembalikan nilai"
add2 = x + y
akhir
Print add2(5,5)
sub cetak_ini(ini)

30
id/xml.md
View File

@ -95,23 +95,23 @@ Pengurai XML dirancang menjadi sangat ketat, dan akan berhenti melakukan pengura
</tokobuku>
<!-- Di atas adalah contoh file XML biasa.
   Dimulai dengan deklarasi, menginformasikan beberapa metadata (opsional).
  
   XML menggunakan struktur pohon. Di atas, simpul akar adalah 'tokobuku',
Dimulai dengan deklarasi, menginformasikan beberapa metadata (opsional).
XML menggunakan struktur pohon. Di atas, simpul akar adalah 'tokobuku',
yang memiliki tiga node anak, para 'buku'. Node-node tersebut dapat memiliki
node-node anak, dan seterusnya ...
  
   Node dibuat menggunakan tag buka/tutup, dan node-node anak hanya
Node dibuat menggunakan tag buka/tutup, dan node-node anak hanya
berada di antara tag buka dan tutup .-->
<!-- XML membawa dua jenis data:
   1 - Atribut -> Itu metadata tentang sebuah node.
       Biasanya, parser XML menggunakan informasi ini untuk menyimpan data dengan
1 - Atribut -> Itu metadata tentang sebuah node.
Biasanya, parser XML menggunakan informasi ini untuk menyimpan data dengan
benar. Hal ini ditandai dengan muncul dengan format nama = "nilai" dalam pembukaan tag.
   2 - Elemen -> Itu data yang murni.
       Itulah yang parser akan mengambil dari file XML.
       Elemen muncul antara tag membuka dan menutup.-->
2 - Elemen -> Itu data yang murni.
Itulah yang parser akan mengambil dari file XML.
Elemen muncul antara tag membuka dan menutup.-->
<!-- Di bawah ini, unsur dengan dua atribut-->
@ -131,7 +131,7 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi.
```xml
<!-- Di bawah, Anda dapat melihat versi sederhana dari dokumen tokobuku,
  dengan penambahan definisi DTD .-->
dengan penambahan definisi DTD .-->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE catatan SYSTEM "tokobuku.dtd">
@ -155,10 +155,10 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi.
<!-- DTD dimulai dengan deklarasi.
  Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'.
  Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut
  disebut 'kategori', dengan "Sastra" sebagai nilai default.
  Node yang 'judul' dan 'harga' mengandung karakter data diurai .-->
Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'.
Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut
disebut 'kategori', dengan "Sastra" sebagai nilai default.
Node yang 'judul' dan 'harga' mengandung karakter data diurai .-->
<!-- DTD dapat dideklarasikan di dalam file XML itu sendiri .-->

4
it/rst.md
View File

@ -57,13 +57,13 @@ Le liste sono semplici come in Markdown:
- primo articolo
- Secondo elemento
     - Sottoelemento
- Sottoelemento
oppure
* Primo elemento
* Secondo elemento
     * Sottoelemento
* Sottoelemento
Le tabelle sono molto semplici da inserire:

8
julia.md
View File

@ -94,8 +94,8 @@ false
'a'
# Strings are UTF8 encoded, so strings like "π" or "☃" are not directly equivalent
# to an array of single characters.
# Only if they contain only ASCII characters can they be safely indexed.
# to an array of single characters.
# Only if they contain only ASCII characters can they be safely indexed.
ascii("This is a string")[1] # => 'T'
# => 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
# Beware, Julia indexes everything from 1 (like MATLAB), not 0 (like most languages).
@ -114,7 +114,7 @@ ascii("This is a string")[1] # => 'T'
println("I'm Julia. Nice to meet you!") # => I'm Julia. Nice to meet you!
# Another way to format strings is the printf macro from the stdlib Printf.
using Printf # this is how you load (or import) a module
using Printf # this is how you load (or import) a module
@printf "%d is less than %f\n" 4.5 5.3 # => 5 is less than 5.300000
@ -392,7 +392,7 @@ end
for animal = ["dog", "cat", "mouse"]
println("$animal is a mammal")
# You can use $ to interpolate variables or expression into strings.
# In this special case, no need for parenthesis: $animal and $(animal) give the same
# In this special case, no need for parenthesis: $animal and $(animal) give the same
end
# => dog is a mammal
# => cat is a mammal

2
latex.md
View File

@ -202,7 +202,7 @@ We can also insert Tables in the same way as figures.
% the {} arguments below describe how each row of the table is drawn.
% The basics are simple: one letter for each column, to control alignment:
% basic options are: c, l, r and p for centered, left, right and paragraph
% optionally, you can add a | for a vertical line
% optionally, you can add a | for a vertical line
% See https://en.wikibooks.org/wiki/LaTeX/Tables for more details
\begin{tabular}{c|cc} % here it means "centered | vertical line, centered centered"
Number & First Name & Last Name \\ % Column rows are separated by &

2
mips.md
View File

@ -244,7 +244,7 @@ gateways and routers.
## FUNCTIONS ##
_functions:
# Functions are callable procedures that can accept arguments and return
# values all denoted with labels, like above
# values all denoted with labels, like above
main: # Programs begin with main func
jal return_1 # jal will store the current PC in $ra

2
pl/java.md
View File

@ -119,7 +119,7 @@ public class LearnJava {
// Zmienną inicjalizuje się poprzez <rodzaj> <nazwa> = <wartość>
int barInt = 1;
// Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością
// Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością
// rodzaj <nazwa1>, <nazwa2>, <nazwa3>
// <nazwa1> = <nazwa2> = <nazwa3> = <wartość>
int barInt1, barInt2, barInt3;

10
pt-br/csharp.md
View File

@ -106,7 +106,7 @@ namespace Learning.CSharp
char fooChar = 'A';
// Strings - ao contrário dos anteriores tipos base, que são todos os tipos de valor,
            // Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
// Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
Console.WriteLine(fooString);
@ -732,9 +732,9 @@ on a new line! ""Wow!"", the masses cried";
}
// Você também pode definir uma propriedade automática em uma linha
        // Esta sintaxe criará um campo de apoio automaticamente.
        // Você pode definir um modificador de acesso no getter ou no setter (ou ambos)
        // para restringir seu acesso:
// Esta sintaxe criará um campo de apoio automaticamente.
// Você pode definir um modificador de acesso no getter ou no setter (ou ambos)
// para restringir seu acesso:
public bool IsBroken { get; private set; }
// Properties can be auto-implemented
@ -856,7 +856,7 @@ on a new line! ""Wow!"", the masses cried";
/// <summary>
/// Exemplo de como conectar-se ao DB via LinqToSql.
    /// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional)
/// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional)
/// http://msdn.microsoft.com/en-us/data/jj193542.aspx
/// </summary>
public class BikeRepository : DbContext

20
pt-br/java.md
View File

@ -413,7 +413,7 @@ class Velocipede extends Bicicleta {
// Exemplo - Comida:
public interface Comestivel {
public void comer(); // Qualquer classe que implementa essa interface, deve
                        // implementar este método.
// implementar este método.
}
public interface Digestivel {
@ -483,8 +483,8 @@ public abstract class Animal
}
// Não há necessidade de inicializar, no entanto, em uma interface
    // a variável é implicitamente final e, portanto, tem
    // de ser inicializada.
// a variável é implicitamente final e, portanto, tem
// de ser inicializada.
protected int idade;
public void mostrarIdade()
@ -503,7 +503,7 @@ class Cachorro extends Animal
{
// Nota: ainda precisamos substituir os métodos abstratos na
    // classe abstrata.
// classe abstrata.
@Override
public void fazerSom()
{
@ -512,10 +512,10 @@ class Cachorro extends Animal
}
// NOTA: Você receberá um erro se usou a
    // anotação Override aqui, uma vez que java não permite
    // sobrescrita de métodos estáticos.
    // O que está acontecendo aqui é chamado de "esconder o método".
    // Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/
// anotação Override aqui, uma vez que java não permite
// sobrescrita de métodos estáticos.
// O que está acontecendo aqui é chamado de "esconder o método".
// Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/
public static void main(String[] args)
{
Cachorro pluto = new Cachorro();
@ -540,7 +540,7 @@ class Cachorro extends Animal
public final class TigreDenteDeSabre extends Animal
{
// Nota: Ainda precisamos substituir os métodos abstratos na
    // classe abstrata.
// classe abstrata.
@Override
public void fazerSom();
{
@ -555,7 +555,7 @@ public abstract class Mamifero()
// <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>)
// Métodos finais, como classes finais, não podem ser substituídos por uma classe filha,
    // e são, portanto, a implementação final do método.
// e são, portanto, a implementação final do método.
public final boolean EImpulsivo()
{
return true;

34
pt-br/sass.md
View File

@ -131,10 +131,10 @@ div {
/* Sass fornece funções que podem ser utilizados para realizar uma variedade de
    tarefas. Considere o seguinte */
tarefas. Considere o seguinte */
/* Funções pode ser chamado usando seu nome e passando o
    argumentos necessários */
argumentos necessários */
body {
width: round(10.25px);
@ -162,7 +162,7 @@ body {
reutilizável. */
/* Esta função terá um tamanho de destino e o tamanho do pai (parent), calcular
   e voltar a percentagem */
e voltar a percentagem */
@function calculate-percentage($target-size, $parent-size) {
@return $target-size / $parent-size * 100%;
@ -219,11 +219,11 @@ $main-content: calculate-percentage(600px, 960px);
}
/* Ao ampliar uma declaração CSS é preferível a criação de um mixin,
   por causa da maneira em que agrupa as classes com todos que compartilham
   o mesmo estilo base. Se isso for feito com um mixin, a largura,
   altura, e a borda seria duplicado para cada instrução que
   o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
   adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */
por causa da maneira em que agrupa as classes com todos que compartilham
o mesmo estilo base. Se isso for feito com um mixin, a largura,
altura, e a borda seria duplicado para cada instrução que
o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */
@ -293,8 +293,8 @@ ul li a {
/* Sass permite criar arquivos parciais. Isso pode ajudar a manter seu Sass
   código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css.
   Parciais não são geradas em CSS. */
código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css.
Parciais não são geradas em CSS. */
@ -309,9 +309,9 @@ ol {
}
/* Sass oferece @import que pode ser usado para importar parciais em um arquivo.
   Isso difere da declaração CSS @import tradicional, que faz
   outra solicitação HTTP para buscar o arquivo importado. Sass converte os
   arquivo importados e combina com o código compilado. */
Isso difere da declaração CSS @import tradicional, que faz
outra solicitação HTTP para buscar o arquivo importado. Sass converte os
arquivo importados e combina com o código compilado. */
@import 'reset';
@ -339,9 +339,9 @@ body {
/* Os Placeholders são úteis na criação de uma declaração CSS para ampliar. Se você
   deseja criar uma instrução CSS que foi usado exclusivamente com @extend,
   você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez
   de '.' ou '#'. Placeholder não aparece no CSS compilado. */
deseja criar uma instrução CSS que foi usado exclusivamente com @extend,
você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez
de '.' ou '#'. Placeholder não aparece no CSS compilado. */
%content-window {
font-size: 14px;
@ -375,7 +375,7 @@ body {
/* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
   ser úteis para calcular os valores diretamente no seu arquivos Sass em vez
ser úteis para calcular os valores diretamente no seu arquivos Sass em vez
de usar valores que você já calcula manualmente. O exemplo abaixo é
de um projeto simples de duas colunas. */

2
raku.md
View File

@ -6,7 +6,7 @@ contributors:
- ["Samantha McVey", "https://cry.nu"]
---
Raku (formerly Perl 6) is a highly capable, feature-rich programming language
Raku (formerly Perl 6) is a highly capable, feature-rich programming language
made for at least the next hundred years.
The primary Raku compiler is called [Rakudo](http://rakudo.org), which runs on

6
ru/c.md
View File

@ -33,7 +33,7 @@ translators:
void function_1();
void function_2();
// Точка входа в программу – это функция main.
// Точка входа в программу – это функция main.
int main() {
// для форматированного вывода в консоль используется printf
// %d – означает, что будем выводить целое число, \n переводит указатель вывода
@ -120,7 +120,7 @@ int main() {
printf("%d\n", a_string[16]); // => 0
// байт #17 тоже равен 0 (а также 18, 19, и 20)
// Если между одинарными кавычками есть символ – это символьный литерал,
// Если между одинарными кавычками есть символ – это символьный литерал,
// но это тип int, а не char (по историческим причинам).
int cha = 'a'; // хорошо
@ -325,7 +325,7 @@ int main() {
// Вы также можете динамически выделять несколько блоков памяти с помощью
// функции malloc из стандартной библиотеки, которая принимает один
// аргумент типа size_t – количество байт необходимых для выделения.
// аргумент типа size_t – количество байт необходимых для выделения.
int *my_ptr = malloc(sizeof(*my_ptr) * 20);
for (xx = 0; xx < 20; xx++) {
*(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx

4
stylus.md
View File

@ -81,8 +81,8 @@ a {
/*
You can store a CSS value (such as the color) of a variable.
  Although it is optional, it is recommended to add $ before a variable name
  so you can distinguish a variable from another CSS value.
Although it is optional, it is recommended to add $ before a variable name
so you can distinguish a variable from another CSS value.
*/
$primary-color = #A3A4FF

4
tr/php.md
View File

@ -17,7 +17,7 @@ PHP 5+ versiyonu için geçerlidir.
// // işareti ile tek satırlık yorum satırı başlar.
# # işareti de aynı görevi görür ancak // daha genel kullanımdadır.
# # işareti de aynı görevi görür ancak // daha genel kullanımdadır.
@ -45,7 +45,7 @@ Hello World Again!
* Tipler ve Değişkenler
*************************************/
// Değişkenler $ sembolü ile başlar.
// Değişkenler $ sembolü ile başlar.
// Geçerli bir değişken bir harf veya alt çizgi ile başlar,
// devamında da bir sayı, harf veya alt çizgi ile devam eder.

96
tr/pythonlegacy.md
View File

@ -35,8 +35,8 @@ uygulanabilir. Python 3 için başka bir zaman tekrar bakınız.
10 * 2 #=> 20
35 / 5 #=> 7
# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız
# sonuç otomatik olarak kırpılır.
# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız
# sonuç otomatik olarak kırpılır.
5 / 2 #=> 2
# Bölünme işlemini düzenlemek için kayan noktalı sayıları bilmeniz gerekir.
@ -80,30 +80,30 @@ not False #=> True
"Hello " + "world!" #=> "Hello world!"
# A string can be treated like a list of characters
# Bir string'e karakter listesi gibi davranabilirsiniz.
# Bir string'e karakter listesi gibi davranabilirsiniz.
"This is a string"[0] #=> 'T'
# % karakter dizisini(string) formatlamak için kullanılır, bunun gibi:
"%s can be %s" % ("strings", "interpolated")
# String'leri formatlamanın yeni bir yöntem ise format metodudur.
# Bu metod tercih edilen yöntemdir.
# Bu metod tercih edilen yöntemdir.
"{0} can be {1}".format("strings", "formatted")
# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz.
# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz.
"{name} wants to eat {food}".format(name="Bob", food="lasagna")
# None bir objedir
None #=> None
# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın.
# Onun yerine "is" kullanın.
# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın.
# Onun yerine "is" kullanın.
"etc" is None #=> False
None is None #=> True
# 'is' operatörü obje kimliği için test etmektedir. Bu ilkel değerler
# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır.
# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır.
# None, 0 ve boş string/list'ler False olarak değerlendirilir.
# None, 0 ve boş string/list'ler False olarak değerlendirilir.
# Tüm eşitlikler True döner
0 == False #=> True
"" == False #=> True
@ -122,12 +122,12 @@ some_var = 5 # Değişken isimlerinde gelenek küçük karakter ve alt çizgi
# kullanmaktır.
some_var #=> 5
# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye
# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla
# bilgi için kontrol akışı kısmına göz atınız.
# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye
# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla
# bilgi için kontrol akışı kısmına göz atınız.
some_other_var # isim hatası fırlatılır
# isterseniz "if"i bir ifade gibi kullanabilirsiniz.
# isterseniz "if"i bir ifade gibi kullanabilirsiniz.
"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
# Listeler
@ -151,7 +151,7 @@ li[0] #=> 1
li[-1] #=> 3
# Listede bulunmayan bir index'teki elemana erişirken "IndexError" hatası
# fırlatılır
# fırlatılır
li[4] # IndexError fırlatılır
# slice syntax'ı ile belli aralıktakı değerlere bakabilirsiniz.
@ -177,7 +177,7 @@ li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
# "len" ile listenin uzunluğunu bulmak
len(li) #=> 6
# Tüpler listeler gibidir sadece değişmezler(immutable)
# Tüpler listeler gibidir sadece değişmezler(immutable)
tup = (1, 2, 3)
tup[0] #=> 1
tup[0] = 3 # TypeError fırlatılır.
@ -188,12 +188,12 @@ tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
tup[:2] #=> (1, 2)
2 in tup #=> True
# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere
# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere
# atanabilir
a, b, c = (1, 2, 3) # a şu anda 1, b şu anda 2 ve c şu anda 3
# Eğer parantez kullanmaz iseniz tüpler varsayılan olarak oluşturulur
d, e, f = 4, 5, 6
# şimdi iki değeri değiş tokuş etmek çok kolaydır.
# şimdi iki değeri değiş tokuş etmek çok kolaydır.
e, d = d, e # d şimdi 5 ve e şimdi 4
@ -207,24 +207,24 @@ filled_dict["one"] #=> 1
# Tüm anahtarlara(key) "keys()" metodu ile ulaşılır
filled_dict.keys() #=> ["three", "two", "one"]
# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir
# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir
# Tüm değerleri almak için "values()" kullanabilirsiniz.
filled_dict.values() #=> [3, 2, 1]
# Not - Sıralama ile ilgili anahtarlar ile aynı durum geçerlidir.
# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir
# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir
"one" in filled_dict #=> True
1 in filled_dict #=> False
# Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
# Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
filled_dict["four"] # KeyError
# "get()" metodu KeyError fırlatılmasını önler
# "get()" metodu KeyError fırlatılmasını önler
filled_dict.get("one") #=> 1
filled_dict.get("four") #=> None
# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
# imknaı sağlar.
filled_dict.get("one", 4) #=> 1
filled_dict.get("four", 4) #=> 4
@ -237,10 +237,10 @@ filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5
# Sets store ... well sets
empty_set = set()
# Bir demek değer ile bir "set" oluşturmak
# Bir demek değer ile bir "set" oluşturmak
some_set = set([1,2,2,3,4]) # some_set is now set([1, 2, 3, 4])
# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir
# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir
filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
# Bir set'e daha fazla eleman eklemek
@ -253,10 +253,10 @@ filled_set & other_set #=> {3, 4, 5}
# | işareti ile
filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
# "-" işareti ile iki set'in farkları alınabilir
# "-" işareti ile iki set'in farkları alınabilir
{1,2,3,4} - {2,3,5} #=> {1, 4}
# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz
# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz
2 in filled_set #=> True
10 in filled_set #=> False
@ -268,7 +268,7 @@ filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
# Bir değişken oluşturmak
some_var = 5
# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir!
# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir!
# "some_var is smaller than 10" yazdırılır.
if some_var > 10:
print "some_var is totally bigger than 10."
@ -286,7 +286,7 @@ Ekrana yazdırılan:
mouse is a mammal
"""
for animal in ["dog", "cat", "mouse"]:
# Biçimlendirmeleri string'e katmak için % kullanabilirsiniz
# Biçimlendirmeleri string'e katmak için % kullanabilirsiniz
print "%s is a mammal" % animal
"""
@ -315,7 +315,7 @@ while x < 4:
# try/except bloğu ile hatalar ayıklanabilir
# Python 2.6 ve üstü için çalışacaktır:
# Python 2.6 ve üstü için çalışacaktır:
try:
# "raise" bir hata fırlatmak için kullanılabilir
raise IndexError("This is an index error")
@ -339,18 +339,18 @@ add(5, 6) #=> prints out "x is 5 and y is 6" and returns 11
# Diğer bir yol fonksiyonları anahtar argümanları ile çağırmak
add(y=6, x=5) # Anahtar argümanlarının sırası farklı da olabilir
# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz
# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz
def varargs(*args):
return args
varargs(1, 2, 3) #=> (1,2,3)
# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da
# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da
# tanımlayabilirsiniz.
def keyword_args(**kwargs):
return kwargs
# Şu şekilde kullanılacaktır
# Şu şekilde kullanılacaktır
keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
# Eğer isterseniz ikisini aynı anda da yapabilirsiniz
@ -363,15 +363,15 @@ all_the_args(1, 2, a=3, b=4) prints:
{"a": 3, "b": 4}
"""
# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz!
# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın.
# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz!
# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın.
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args) # foo(1, 2, 3, 4) ile eşit
all_the_args(**kwargs) # foo(a=3, b=4) ile eşit
all_the_args(*args, **kwargs) # foo(1, 2, 3, 4, a=3, b=4) ile eşit
# Python first-class fonksiyonlara sahiptir
# Python first-class fonksiyonlara sahiptir
def create_adder(x):
def adder(y):
return x + y
@ -387,7 +387,7 @@ add_10(3) #=> 13
map(add_10, [1,2,3]) #=> [11, 12, 13]
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz.
# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz.
[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
@ -399,7 +399,7 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
# We subclass from object to get a class.
class Human(object):
# Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır.
# Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır.
species = "H. sapiens"
# Basic initializer
@ -408,18 +408,18 @@ class Human(object):
# değişkenine atama
self.name = name
# Bir instance metodu. Tüm metodlar ilk argüman olarak "self"
# Bir instance metodu. Tüm metodlar ilk argüman olarak "self"
# parametresini alır
def say(self, msg):
return "%s: %s" % (self.name, msg)
# Bir sınıf metodu tüm "instance"lar arasında paylaşılır
# İlk argüman olarak sınıfı çağırarak çağrılırlar
# İlk argüman olarak sınıfı çağırarak çağrılırlar
@classmethod
def get_species(cls):
return cls.species
# Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır
# Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır
@staticmethod
def grunt():
return "*grunt*"
@ -452,24 +452,24 @@ Human.grunt() #=> "*grunt*"
import math
print math.sqrt(16) #=> 4.0
# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
from math import ceil, floor
print ceil(3.7) #=> 4.0
print floor(3.7) #=> 3.0
# Modüldeki tüm fonksiyonları dahil edebilirsiniz
# Uyarı: bu önerilmez
# Uyarı: bu önerilmez
from math import *
# Modülün adını kısaltabilirsiniz
# Modülün adını kısaltabilirsiniz
import math as m
math.sqrt(16) == m.sqrt(16) #=> True
# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül
# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı
# aynı olmalıdır.
# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül
# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı
# aynı olmalıdır.
# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz.
# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz.
import math
dir(math)
```

8
zh-cn/vim.md
View File

@ -53,15 +53,15 @@ translators:
t<字符> # 向前跳移到 <字符> 的左侧
# 例如，
   f<               # 向前跳移到 < 上
f< # 向前跳移到 < 上
t< # 向前跳移到 < 的左侧
# 按词移动
# 默认一个单词由字母，数字和下划线组成
   w               # 移动到下一个词首
   b               # 移动到前一个词首
   e               # 移动到下一个词尾
w # 移动到下一个词首
b # 移动到前一个词首
e # 移动到下一个词尾
# 移动的其它命令