Hands On Programming With R Write Your Own Function ES

Clases
prácticas
Programació
n
Con R
Escribir sus propias funciones y simulaciones
Garrett Grolemund
Prólogo por Hadley Wickham
WWW .IT-EBOOKS.INFO
Prácticas de Programación con R
Aprender a programar por bucear en el lenguaje R, y luego utilizar sus
nuevas habilidades para resolver problemas de ciencia de datos prácticos.
Con este libro, usted aprenderá cómo cargar datos, armar y desarmar los
"Prácticas de
objetos de datos, navegar R entorno sistema, escribir sus propias funciones, Programación con R es
y hacer uso de todas las herramientas de programación de r. amigable,
conversacional y activo.
RStudio Instructor Maestro Garrett Grolemund no sólo le enseña a Es la siguiente mejor
programar, pero también le muestra cómo obtener más de R que acaba de
cosa a aprender R
visualización y modelado de datos. Conseguirá valiosos conocimientos de
programación y apoyo su trabajo como científico de datos al mismo tiempo.
programación de mí o de
Garrett en persona.
Espero que disfruten de su
■ Trabajar con las manos con tres proyectos de
análisis de datos prácticos basados en juegos de
casino
lectura tanto como yo. "
-Hadley Wickham
■ Almacenar, recuperar y cambiar los valores de los El Científico Jefe de
RStudio
datos en la memoria del equipo.
■ Escribir programas y simulaciones que superan aquellos
escritos por los típicos R usuarios
■ Utilizar herramientas de programación R como si
ELSE , bucles For, y S3 clases
■ Aprenda a escribir rapidísimo vectorizadas código R

■ Tome ventaja de R del sistema de paquetes y herramientas de
depuración
■ Practicar y aplicar conceptos de programación R como usted
aprender ellos
Garrett Grolemund es un estadístico, profesor, y R el desarrollador que trabaja

como un dato científico y Maestro Instructor en RStudio. Garrett recibió su
doctorado en la Universidad de Rice, donde su investigación los orígenes del
análisis de datos como un proceso cognitivo e identificados como preocupaciones
epistemológicas y atencionales guía cada análisis de datos.
Los programas de estadística y análisis de datos

Twitter: @oreillymedia
facebook.com/oreilly
US $39.99 $41.99
ISBN: 978-1-449-35901-0
WWW .IT-EBOOKS.INFO
Prácticas de Programación con
R
G GROLEMUND ARRETT
WWW .IT-EBOOKS.INFO
Prácticas de Programación con R
Por Garrett Grolemund
Copyright © 2014 Grolemund Garrett. Todos los derechos reservados.
Impreso en los Estados Unidos de América.
Publicado por O'Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
O'Reilly libros pueden adquirirse para fines educativos, comerciales, de ventas o uso promocional.
Ediciones Online también están disponibles para la mayoría de títulos
(http://my.safaribooksonline.com). Para obtener más información, póngase en contacto con nuestro
departamento de ventas institucionales/corporativos: 800-998-9938 o corporate@oreilly.com.
Indizador: Judith
Editores: Julie Steele y Courtney Nash McConville
Editor de Producción: Matthew
Hacker Cover Designer: Randy Comer
Diseñador de
Copyeditor: Eliahu Sussman interiores: David Futato
Corrector: Amanda Kersey Illustrator: Rebecca Demarest
Julio de 2014: Primera edición
Historial de revisión de la Primera edición:

2014-07-08: Primera versión
Consulte http://oreilly.com/catalog/errata.csp?isbn=9781449359010 para ver detalles de

versión.
Resumen manual, la palabra Manual logo, O'Reilly y el logotipo son marcas comerciales
registradas de O'Reilly Media, Inc. aprendizajes prácticos con R, la imagen de una naranja-
winged loros Amazona, y trade dress relacionados son marcas comerciales de O'Reilly Media,
Inc.
Muchas de las denominaciones usadas por los fabricantes y vendedores para distinguir sus
productos son considerados como marcas comerciales. Cuando tales denominaciones aparecen
en este libro, y O'Reilly Media, Inc. fue consciente de una reclamación de la marca, las
designaciones se han impreso en las tapas o las mayúsculas iniciales.
Si bien se han tomado todas las precauciones posibles en la preparación de este libro, la editorial
y los autores no asumen ninguna responsabilidad por errores u omisiones, o por los daños
resultantes del uso de la información aquí contenida.
ISBN: 978-1-449-35901-0
[LSI]
WWW .IT-EBOOKS.INFO
Tabla de
contenido
Foreword. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
vii Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ix
Parte I. Project 1: Weighted Dice
1. The Very Basics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

The R User Interface 3
Objects 7
Functions 12
Sample with Replacement 14
Writing Your Own Functions 16
The Function Constructor 17
Arguments 18
Scripts 20
Summary 22
2. Packages and Help Pages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Packages 23
install.packages 24
library 24
Getting Help with Help Pages 29
Parts of a Help Page 30
Getting More Help 33
Summary 33
Project 1 Wrap-up 34
Iii
WWW .IT-EBOOKS.INFO
La parte II. Project 2: Playing Cards
3. R Objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Atomic Vectors 38
Dobles 39
Enteros 40
Caracteres 41
Logicals 42
Complex and Raw 42
Atributos 43
Nombres 44
Dim 45
Matrices 46
Las matrices 46
La clase 47
Dates and Times 48
Factores 49
La coacción 51
Listas 53
Data Frames 55
Loading Data 57
Saving Data 61
Resumen 61
4. R Notation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65
Selecting Values 65
Positive Integers 66
Negative Integers 68
Cero 69
Blank Spaces 69
Logical Values 69
Nombres 70
Deal a Card 70
Shuffle the Deck 71
Dollar Signs and Double Brackets 73
Resumen 76
5. Modifying Values. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Changing Values in Place 77
Logical Subsetting 80
Logical Tests 80
Boolean Operators 85
Iv | Tabla de contenido
WWW .IT-EBOOKS.INFO
Missing Information 89
na.rm 90
is.na 90
Summary 91
6. Environments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Entornos 93
Working with Environments 95
The Active Environment 97
Scoping Rules 98
Asignación 99
Evaluación 99
Cierres 107
Resumen 112
Parte III. Project 3: Slot Machine
7. Programs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Estrategia 118
Sequential Steps 118
Parallel Cases 119
if Statements 120
else Statements 123
Lookup Tables 130
Code Comments 136
Resumen 137
8. S3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
The S3 System 139
Attributes 140
Generic Functions 145
Methods 146
Method Dispatch 148
Classes 151
S3 and Debugging 152
S4 and R5 152
Summary 152
9. Loops. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
Expected Values 155
Tabla de
contenido |v
WWW .IT-EBOOKS.INFO
Ampliar.grid 157
for Loops 163
while Loops 168
repeat Loops 169
Resumen 169
10. Speed. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

Vectorized Code 171
How to Write Vectorized Code 173
How to Write Fast for Loops in R 178
Vectorized Code in Practice 179
Loops Versus Vectorized Code 183
Resumen 183
A. Installing R and RStudio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
B. R Packages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
C. Updating R and Its Packages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
D. Loading and Saving Data in R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
E. Debugging R Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Vi | Tabla de contenido
WWW .IT-EBOOKS.INFO
Prólogo
Aprender a programar es importante si usted es serio acerca de la comprensión de los

datos. No hay argumento que los datos que la ciencia debe realizarse en un ordenador,
pero usted tiene una opción entre el aprendizaje de una interfaz gráfica de usuario
(GUI) o un lenguaje de programación. Ambos Garrett y creo firmemente que el
aprendizaje es una capacidad vital para todos los que trabajan intensamente con los
datos. Aunque práctico, una interfaz gráfica de usuario (GUI) es, en última instancia,
limitar, porque obstaculiza tres propiedades esenciales para un buen análisis de datos:
Reproducibilidad
La habilidad de re-crear un último análisis, que es crucial para la buena
ciencia.
Automatización
La capacidad de volver a crear rápidamente un análisis cuando cambian los datos
(como siempre).
Comunicación
El código es sólo texto, por lo que es fácil comunicarse. Cuando el aprendizaje,
esto hace que sea fácil obtener ayuda, ya sea con el correo electrónico, Google,
desbordamiento de la pila, o en otros lugares.
No tenga miedo de la programación! Cualquiera puede aprender a programar con

el derecho motiva- ción, y este libro está organizado para mantenerse motivado.
Este no es un libro de referencia; en cambio, se estructuró en torno a tres manos
sobre los desafíos. Dominar estos desafíos te llevará a través de los conceptos
básicos de programación r e, incluso, en algunos temas intermedios, tales como
código vectorizadas, alcance, métodos y S3. Desafíos reales son una gran
manera de aprender, porque no eres memorizar funciones void de contexto; en su
lugar, estás aprendiendo funciones como necesite para resolver un problema real.
Aprenderá haciendo, no por la lectura.
Como usted aprender a programar, usted va a sentirse frustrado. Usted está aprendiendo
una nueva lan- Meden, y tomará tiempo para dominar. Pero la frustración no es sólo natural,
es realmente un signo positivo que usted debe ver. La frustración es tu cerebro del camino
de la pereza; está intentando conseguir que usted salga y vaya hacer algo fácil o divertido.
Si desea llegar físicamente montador, necesitas llevar tu cuerpo a pesar de que se queja.
Si desea obtener mejores en programación, tendrás que empujar a su cerebro. Reconocer
cuando usted consigue
Vi
i
WWW .IT-EBOOKS.INFO
Frustrado y lo ven como una cosa buena: estás ahora mismo estiramiento.
Esfuérzate un poco más cada día, y pronto será un programador de confianza.
Prácticas de Programación con R es amigable, conversacional y activo. Es la
siguiente mejor cosa a aprender R programación de mí o de Garrett en
persona. Espero que disfruten de su lectura tanto como yo.
-Hadley Wickham
Chief Scientist, RStudio
P.d. Garrett es demasiado modesta para mencionarlo, pero su paquete
lubridate hace que trabajar con fechas y horas en R mucho menos dolorosa.
Compruébalo por ti mismo.
Viii | Prólogo
WWW .IT-EBOOKS.INFO
Prefaci
o
Este libro le enseñará cómo programar en R. te vaya desde la carga de datos

para escribir sus propias funciones (que superan las funciones de otros R
usuarios). Pero esta no es una típica introducción a R. quiero ayudarle a
convertirse en un dato científico, así como de un equipo científico, así que este
libro se centrará en las habilidades de programación que están más
relacionadas con los datos científicos.
Los capítulos del libro están organizados según tres proyectos prácticos-dado que son
bastante considerable de proyectos, que abarcan varios capítulos. Elegí estos
proyectos por dos razones. En primer lugar, cubren la amplitud del lenguaje R.
Aprenderá cómo cargar datos, armar y desarmar los objetos de datos, navegar R
entorno sistema, escribir sus propias funciones, y utilizar todas las herramientas de
programación de R's, como si else , bucles for, clases de S3, R y R Sistema de
paquete de herramientas de depuración. Los proyectos también le enseñarán cómo
escribir código R vectorizadas, un estilo de rapidísimas código que toma ad- Mirador
de todas las cosas R hace mejor.
Pero lo más importante de los proyectos te enseñará cómo resolver los problemas
logísticos de datos de ciencia y hay muchos problemas logísticos. Cuando se trabaja con
datos que necesitará para almacenar, recuperar y manipular grandes conjuntos de valores
sin introducir errores. A medida que trabaja a través de todo el libro, te enseñaré no sólo
cómo programar con R, pero cómo usar las habilidades de programación para apoyar su
trabajo como un dato científico.
Cada programador no necesita ser un científico de datos, por lo que no todos

los programadores encontrarán este libro útil. Encontrará este libro útil si estás
en una de las categorías siguientes:
1. Usted ya usa R como una herramienta estadística, pero le gustaría

aprender cómo escribir sus propias funciones y simulaciones con R.
2. Le gustaría enseñar a usted cómo programar, y puedes ver el sentido de
aprender un idioma en relación a los datos de la ciencia.
Ix
WWW .IT-EBOOKS.INFO
Una de las mayores sorpresas en este libro es que yo no cubren las aplicaciones
tradicionales de R, como modelos y gráficos; en su lugar, puedo tratar R meramente
como un lenguaje de programación. ¿Por qué este foco estrecho? R está diseñado
para ser una herramienta que ayuda a los científicos a analizar los datos. Tiene
muchas funciones que hacen que Excelentes parcelas y ajustar modelos a datos.
Como resultado, muchos estadísticos aprenda a utilizar R como si se tratara de una
pieza de software-aprenden las funciones que hacen lo que quieren, y omitir el resto.
Este es un método de aprendizaje comprensible R. Visualización y modelización

de los datos son complicadas las habilidades que requieren toda la atención de
un científico. Tiene experiencia, juicio y centrarse para extraer confiables de un
conjunto de datos. No recomendaría que cualquier científico datos distraer a sí
misma con la programación de computadoras hasta que siente comodidad- capaz
con la teoría y la práctica básicas de su arte. Si le gustaría aprender el arte de la
ciencia de datos, recomiendo el libro La Ciencia de datos con R, mi compañero
de volumen para este libro.
Sin embargo, aprender a programar debe ser sobre todo datos científico en la lista
de tareas. Saber programar te hará un analista más flexible y aumentar los datos
de su dominio de la ciencia en todos los sentidos. Mi metáfora preferida para
describir este fue presentado por Greg nieve sobre la R ayuda lista en mayo de
2006. Utilizando las funciones de r es como montar un autobús. Escribir
programas en R es igual que conducir un coche.
Los buses son muy fáciles de usar, basta con saber qué autobús para llegar, donde
conseguir y donde bajarse (y usted necesita para pagar el billete). Los coches, por
otro lado, requieren mucho trabajo: necesitas tener algún tipo de mapa o direcciones
(incluso si el mapa está en su cabeza), necesitas poner gas en cada ahora y
entonces, usted necesita saber las reglas de la carretera (tienen algún tipo de licencia
de conductor). La gran ventaja del coche es que puede tomar un montón de lugares
que el bus no va y es más rápido para algunos viajes que requeriría la transferencia
entre buses.
Utilizando esta analogía, programas como SPSS son buses, fácil de usar para las cosas
estándar, pero muy frustrante si usted quiere hacer algo que no esté ya preprogramadas.
R es un SUV con tracción a las 4 ruedas (aunque respetuoso con el medio
ambiente) con una bicicleta en la parte posterior, una en la parte superior
de kayak, senderismo y zapatillas en el asiento del acompañante, y el
montañismo y espeleología en la marcha atrás.
R te puede llevar donde usted quiera ir si se toma el tiempo para aprender a usar el
equipo, pero que va a tardar más de aprendizaje donde las paradas de autobús están en
SPSS.
- Greg Snow
Greg compara R A SPSS, pero él asume que usted utilice los plenos poderes de R; en
otras palabras, que usted aprenda a programar en R. Si sólo utiliza funciones que preexist
en R, estás utilizando R como SPSS: es un bus que sólo puede llevarle a determinados
lugares.
Esta flexibilidad asuntos a los datos científicos. Los detalles exactos de un

método de simulación o cambiará de problema en problema. Si no se puede
construir un método adaptado a su situación, puede sentirse tentado a hacer
suposiciones irreales, así que se puede utilizar un mal método que ya existe.
X | Prefacio
WWW .IT-EBOOKS.INFO
Este libro le ayudará a dar el salto desde el bus al coche. He escrito para programadores.
No puedo hablar de la teoría de la ciencia de la computación-no hay dis- cussions de
big O() y poco o() en estas páginas. Tampoco puedo entrar en detalles avanzados tales
como el funcionamiento de la evaluación diferida. Estas cosas son interesantes si usted
piensa de la ciencia de la computación en el plano teórico, pero son una distracción cuando
usted primero aprender a programar.
En cambio, yo le enseñe cómo programar en R con tres ejemplos concretos. Estos

ejemplos son cortos, fáciles de entender, y cubren todo lo que necesita saber.
Me han enseñado este material muchas veces en mi trabajo como maestro Instructor en
RStudio. Como profesor, he encontrado que los estudiantes aprenden conceptos
abstractos mucho más rápido cuando están ilustrados con ejemplos concretos. Los
ejemplos tienen un segundo de ventaja, así como: proporcionan la práctica inmediata.
Aprender a programar es como aprender a hablar otra LAN- indicador de progreso más
rápido cuando la práctica. En realidad, aprender a programar es aprender a hablar otro
idioma. Obtendrá los mejores resultados si seguir junto con los ejemplos del libro y
experimentar siempre que una idea te sorprende.
El libro es un complemento a los datos de la ciencia con la R. En este libro, que

me explique cómo utilizar R para hacer parcelas, modelo de datos y escribir
informes. Ese libro enseña estas tareas como datos conocimientos científicos, que
requieren juicio y experiencia no como ejercicios de programación, que son
también. Este libro le enseñará cómo programar en R. no asume que usted ha
dominado la ciencia de datos técnicas enseñadas en el volumen 1 (ni que usted
intentó jamás). Sin embargo, este conjunto de habilidades que amplifica. Y si te
amo tanto, usted será un poderoso, del equipo científico de datos aumentada,
colocar el mando un sueldo elevado e influir en el diálogo científico.
Convenciones usadas en este libro

Se utilizan las siguientes convenciones tipográficas en este libro:
Cursiva
Indica los términos nuevos, direcciones URL, direcciones de correo
electrónico, nombres de archivo y extensiones de archivo.
Anchura constante
Utilizado para la programación, así como dentro de los párrafos que se
refieren a los elementos de programa como variables o nombres de
función, bases de datos, tipos de datos, variables de entorno,
declaraciones y palabras clave.
Anchura constante bold
Muestra los comandos u otro texto que se debería escribir literalmente
por el usuario.
Anchura constante italic
Muestra el texto que debería ser reemplazado con valores proporcionados
por el usuario o por valores disuadir- minado por el contexto.
Prefacio |
Xi
WWW .IT-EBOOKS.INFO
Este elemento representa un consejo o sugerencia.
Este elemento indica una nota general.
Este elemento indica una advertencia o precaución.
Safari® Libros Online

Safari Books Online Es una biblioteca digital on-demand
que ofrece experto content en ambos libros y vídeos de los
autores más importantes del mundo en tecnología y
negocios.
Los profesionales de tecnología, desarrolladores de software, diseñadores web y

negocios y crea- tiva profesionales utilizan Safari Books Online como su principal
recurso para la investigación, prob lem - resolver, el aprendizaje y la formación
para obtener la certificación.
Safari Books Online ofrece una amplia gama de product mixes precios y programas
de organi‐ zations, government agencies, y individuals. Los suscriptores tienen
acceso a miles de libros, videos de capacitación, y prepublicación manuscritos en una
base de datos plenamente de editoriales como O'Reilly Media, Prentice Hall, Addison-
Wesley Professional Pro- fessional, Microsoft Press, Sams, que, Peachpit Press,
coordinador de Prensa, Cisco Press, John Wiley & Sons, Syngress, Morgan
Kaufmann, IBM Redbooks, Packt, Adobe Press, FT Press, Apress, Manning, New
Riders, McGraw-Hill, Jones & Bartlett, curso Technol- gía y docenas more. Para
obtener más información acerca de Safari Books Online, visite nosotros online.
Cómo ponerse en contacto con

nosotros
Por favor dirija sus comentarios y preguntas acerca de este libro a la editorial:
O'Reilly Media, Inc.

1005 Gravenstein Highway North
Xii | Prefacio
WWW .IT-EBOOKS.INFO
Sebastopol, CA 95472
800-998-9938 (en los Estados Unidos o Canadá)
707-829-0515 (internacional o local)
707-829-0104 (fax)
Tenemos una página web para este libro, donde tenemos una lista de erratas,
ejemplos, y cualquier información adicional. Puede acceder a esta
página http://bit.ly/HandsOnR
Para comentar o hacer preguntas técnicas sobre este libro, enviar un correo
electrónico a bookques tions@oreilly.com.
Para obtener más información acerca de nuestros libros, cursos, conferencias
y noticias, visite nuestro sitio web en http://www.oreilly.com.
Encuéntranos en Facebook: http://facebook.com/oreilly
Síganos en Twitter: http://twitter.com/oreillymedia
Nos mire en YouTube: http://www.youtube.com/oreillymedia
Agradecimientos
Muchas excelentes personas me han ayudado a escribir este libro, de mis dos
editores, Courtney Nash y Julie Steele, al resto del equipo de O'Reilly, quien
diseñó, corregido, indexados y el libro. Además, Greg Snow generosamente
Permitidme citarlo en este prefacio. Les doy a todos mi más sincero
agradecimiento.
También me gustaría agradecer a Hadley Wickham, que ha moldeado la forma en
que pienso sobre y enseñar R. Muchas de las ideas contenidas en este libro
proviene de las Estadísticas 405, un curso que me ayudó Hadley enseñar cuando
yo era un estudiante de doctorado en la Universidad de Rice.
Nuevas ideas surgieron de los alumnos y profesores de Introducción a la

ciencia con R, un taller que enseño en nombre de RStudio. Gracias a todos
vosotros. Me gustaría dar las gracias especialmente a mis ayudantes de
enseñanza Josh Paulson, Winston Chang, Jaime Ramos, Jay Emerson, y
Vivian Zhang.
Gracias también a JJ Allaire y el resto de mis colegas a quienes proporcionan el
RStudio RStudio IDE, una herramienta que hace que sea mucho más fácil de usar,
enseñar y escribir sobre R.
Por último, me gustaría agradecer a mi esposa, Kristin, por su apoyo y

comprensión mientras escribía este libro.
Prefacio |
Xiii
WWW .IT-EBOOKS.INFO
WWW .IT-EBOOKS.INFO
Parte I
Proyecto 1: ponderación
de los dados
Los ordenadores nos permiten ensamblar, manipular y visualizar conjuntos de datos, todo
ello a velocidades que habría deleitado ayer científicos. En resumen, los equipos le dan
superpoderes científico! Pero tendrás que recoger algunos conocimientos de programación
si desea utilizar plenamente de ellos.
Como un dato científico que sabe cómo programar, usted mejorará su capacidad
para:
• Memorizar (store) conjuntos completos de datos

• Recuperar los valores de los datos sobre demanda
• Realizar cálculos complejos con grandes cantidades de datos
• Realizar tareas repetitivas sin ser descuidado o aburrido
Los equipos pueden hacer todas estas cosas de forma rápida y libre de
errores, que permite que tu mente hacer las cosas que sobresale en: toma de
decisiones y la asignación de significado.
Emocionante sonido? ¡Genial! Empecemos.
Cuando yo era un estudiante de la universidad, a veces me daydreamed de ir a Las
Vegas. Pensé que conocer estadísticas podría ayudarme a ganar en grande. Si eso
es lo que le ha llevado a la ciencia de los datos, es mejor sentarse; Tengo algunas
malas noticias. Incluso un estadístico perderá dinero en un casino en el largo plazo.
Esto es debido a que las probabilidades para cada juego siempre están apilados en
favor del casino. Sin embargo, existe una laguna a esta regla. Usted puede hacer
dinero y muy fiable. Todo lo que tienes que hacer es ser el casino.
Lo creas o no, R puede ayudarle a hacerlo. En el transcurso del libro, podrá utilizar r para
construir tres objetos virtuales: un par de dados que puede girar para generar números
aleatorios, una baraja de cartas que se pueden mezclar y tratar de, y una máquina de
ranura modelada en la vida real algunos terminales de video lotería. Después de eso, sólo
tendrá que añadir algunos vídeos
WWW .IT-EBOOKS.INFO
Gráficos y una cuenta bancaria (y tal vez obtener algunas licencias
gubernamentales), y va a estar en el negocio. Dejaré los detalles para usted.
Estos proyectos se alegre, pero también son profundos. Cuando se
completen, se convertirá en un experto en las habilidades que necesita para
trabajar con los datos como un dato científico. Aprenderá a almacenar datos
en la memoria del ordenador, cómo acceder a los datos que ya está ahí, y
cómo transformar los valores de los datos en la memoria cuando sea
necesario. También aprenderá cómo escribir sus propios programas en R que
puede utilizar para analizar los datos y ejecutar simulaciones.
Si simulando un slot machine (o a los dados, o tarjetas) parece frivilous, pensar de
esta manera: jugando a una máquina tragaperras es un proceso. Una vez que usted
puede simular, serás capaz de simular otros procesos, tales como el muestreo
bootstrap, cadena de Markov Monte Carlo, y otros procedimientos de análisis de datos.
Además, estos proyectos proporcionan ejemplos concretos para el aprendizaje de
todos los componentes de R Programación: objetos, tipos de datos, clases, notación,
funciones, environments, si los árboles, loops, y vectorización. Este primer proyecto
facilitará a estudiar estas cosas por enseñar los principios básicos del INST.
Su primera misión es simple: montar R código evolutivo que simulará un par

de dados, como en la mesa de Craps. Una vez que haya hecho esto, veremos
los dados un poco de peso a su favor, sólo para mantener las cosas
interesantes.
En este proyecto, usted aprenderá a:
• Utilice el R e interfaces RStudio

• Ejecute los comandos R
• Crear objetos R
• Escribir sus propios scripts y funciones de R
• Cargar y usar paquetes de R
• Generar muestras aleatorias
• Crear parcelas rápido
• Obtenga ayuda cuando la necesite
No se preocupe si parece que vamos a cubrir mucho terreno rápidamente. Este proyecto
está diseñado para proporcionarle una descripción sucinta de la R el lenguaje. Regresará
a muchos de los conceptos que nos reunamos aquí en los proyectos 2 y 3, donde se
examinarán los conceptos en profundidad.
Usted necesitará tener R y RStudio instalados en su equipo antes de poder utilizarlos.

Ambos son gratis y fácil de descargar. Consulte Appendix A para obtener
instrucciones completas. Si usted está listo para comenzar, abra RStudio sobre su
ordenador y leer.
WWW .IT-EBOOKS.INFO
Capítulo 1
Los Conceptos Básicos
Este capítulo proporciona un panorama amplio de la R el lenguaje de

programación que te enseguida. En ella, puedes construir un par de dados
virtual que puede utilizar para generar números aleatorios. No se preocupe si
nunca has programado antes; el capítulo le enseñará todo lo que necesita
saber.
Para simular un par de dados, usted tendrá que destilan cada mueren en sus
características esenciales. No se puede colocar un objeto físico, como un
morir, en un ordenador (bueno, no sin aflojando unos tornillos), pero puede
guardar información sobre el objeto en la memoria del ordenador.
Qué información debe usted ahorrar? En general, un morir tiene seis piezas importantes
de en- Formación: cuando tira un dado, sólo puede resultar en uno de los seis números: 1,
2, 3, 4, 5 y
6. Puede capturar las características esenciales de un chip guardando los
números 1, 2, 3, 4, 5 y 6 como un grupo de valores en la memoria del
ordenador.
Trabajemos para guardar estos números primero y luego considerar un
método para "rolling" nuestro morir.
La interfaz de usuario de R
Antes de que usted puede pedir a su equipo para guardar algunos números, necesitará
saber cómo hablar con él. Ahí es donde R y RStudio. RStudio le da una forma de
comunicarse con su equipo. R le da un lenguaje para hablar. Para comenzar, abra
RStudio como lo haría con cualquier otra aplicación abierta en el ordenador. Al hacerlo,
debería aparecer una ventana en su pantalla como la que se muestra en la Figure 1-
1.
3
WWW .IT-EBOOKS.INFO
Figura 1-1. El equipo hace su antojo cuando escriba R comandos en el prompt
en la línea inferior del panel de consola. No olvide presionar la tecla Intro.
Cuando abra por primera vez RStudio, la consola aparecerá en el panel de la
izquierda, pero puede cambiar esto con Archivo > Preferencias en la barra de
menú.
Si todavía no tienes R y RStudio intalled en su equipo- o no

saben de qué estoy hablando-visita Appendix A. El apéndice le
dará una visión general de las dos herramientas libres y decirle
cómo descargar.
La interfaz RStudio es simple. Escribe el código R en la línea inferior de la

consola RStudio panel y, a continuación, haga clic en Entrar para ejecutarlo.
El código que escriba se denomina comando, porque estará al mando de su
equipo para hacer algo para usted. La línea se escribe en la línea de
comandos se llama.
Cuando se escribe un comando en el símbolo del sistema y presione la tecla Intro, el
equipo ejecuta el comando y muestra los resultados. A continuación, se muestra un
indicador RStudio fresco para el siguiente comando. Por ejemplo, si escribe 1 + 1 y
pulsa enter, RStudio mostrará:
> 1 + 1
[1] 2
>
Usted notará que un [1] aparece junto a su resultado. R es sólo para hacerle saber
que esta línea comienza con el primer valor en el resultado. Algunos comandos
devuelven más de uno
4 | Capítulo 1: Conceptos básicos
WWW .IT-EBOOKS.INFO
Valor, y sus resultados se pueden llenar varias líneas. Por ejemplo, el
comando 100:130 devuelve 31 valores; crea una secuencia de enteros de
100 a 130. Observe que los nuevos números aparecen entre corchetes al
inicio de la segunda y tercera líneas de salida. Estos números sólo significa
que la segunda línea comienza con el valor 14 en el resultado, y la tercera
línea comienza con el valor 25. Puede ignorar la mayoría de los números que
aparecen entre paréntesis:
> 100:130
[1] 100 101 102 103 104 105 106 107 108 109 110 111 112
[14] 113 114 115 116 117 118 119 120 121 122 123 124 125
[25] 126 127 128 129 130
El operador dos puntos (+) devuelve cada entero entre dos números
enteros. Es una manera fácil de crear una secuencia de números.
R No es un idioma?
Puede oírme hablar de R en tercera persona. Por ejemplo, yo
podría decir, "Dígale a r a hacer esto" o "Dígale a r a hacer eso",
pero por supuesto R no puede hacer nada; es sólo un idioma. Esta
forma de hablar es la abreviatura para decir, "Dígale a su equipo
para hacerlo escribiendo un comando en el lenguaje R en la línea
de comandos de la consola RStudio." El equipo, y no R, hace el
trabajo real.
Este abreviación es confuso y algo perezoso para utilizar? Sí. Hacer un
montón de gente lo usa? Todos los que conozco, tal vez porque es tan
cómodo.
¿Cuándo nos compilar?

En algunos lenguajes, como C, Java, FORTRAN, tienes que
com- montón tu código legible en código legible por máquina (a
menudo 1s y 0s) antes de ejecutarlo. Si has programado en esa
lan- meden antes, usted puede preguntarse si usted tiene que
compilar el código R antes de poder usarlo. La respuesta es no. R
es un lenguaje dinámico de pro- gramación, lo que significa R
interpreta automáticamente el código que se ejecute.
Si escribe un comando incompleto R y presione Enter, aparecerá un símbolo

+, lo que significa que está esperando a que escriba el resto de su mandato.
Finalice el comando o presione Esc para empezar:
> 5 -
+
+ 1 [
1] 4
Si escribe un comando que no reconoce, R R devolverá un mensaje de error. Si alguna

vez ver un mensaje de error, no se preocupe. R es simplemente diciendo que su equipo
no pudo
La interfaz de usuario de R | 5
WWW .IT-EBOOKS.INFO
Entender o hacer lo que le pidió que hiciera. A continuación, puede probar
un comando diferente en la siguiente línea de comandos:
> 3 % 5
Error: la entrada inesperada en "3 % 5"
>
Una vez que usted obtenga el cuelga de la línea de comandos, usted puede
fácilmente hacer nada en R que lo haría con una calculadora. Por ejemplo, usted
podría hacer algunas nociones básicas de aritmética:
2 * 3
## 6
4 - 1
## 3
6 / (4 - 1)
## 2
¿Ha notado usted algo diferente acerca de este código? He dejado el >'s y [1]. Esto hará
que el código sea más fácil de copiar y pegar si quieres ponerlo en tu propia consola.
R trata el hashtag #, personaje, de una manera especial; R no se ejecutará cualquier

cosa que siga un hashtag en una línea. Esto hace hashtags muy útil para añadir
comentarios y anno- tations a su código. Los seres humanos serán capaces de leer
los comentarios, pero el equipo se pase sobre ellos. El hashtag es conocido como
el símbolo de comentario en R.
Para el resto del libro, voy a utilizar hashtags para mostrar la salida de R código. Usaré
un solo hashtag añadir mis propias observaciones y un doble hashtag ##, para mostrar
los resultados del código. Voy a evitar mostrar >s y s [1] a menos que yo quiero que
usted mire.
Cancelación de órdenes
R Algunos comandos pueden tardar mucho tiempo en ejecutarse.
Puede cancelar un comando una vez iniciado tecleando Ctrl +
C. Tenga en cuenta que también puede tomar R mucho tiempo
para cancelar el comando.
Ejercicio
Esa es la interfaz básica para ejecutar código en R RStudio. Creo que usted
tiene? Si es así, trate de hacer estas tareas simples. Si ejecuta todo
correctamente, debe acabar con el mismo número que comenzó con:
1. Elija cualquier número y añadir 2.

2. Multiplique el resultado por 3.
3. Restar 6 de la respuesta.
WWW .IT-EBOOKS.INFO
4. Dividir lo que obtienes por 3.
A lo largo de todo el libro, voy a poner los ejercicios en cajas, como la que se
acaba de mencionar. Voy a seguir cada ejercicio con un modelo de respuesta,
como la que sigue.
Usted puede comenzar con el número 10 y, a continuación, siga los pasos
anteriores:
10 + 2
## 12
12 * 3
## 36
36 - 6
## 30
30 / 3
## 10
Ahora que ya sabe cómo utilizar R, vamos a usarla para hacer un virtual mueren.
El operador : desde hace un par de páginas te da una buena manera de crear un grupo de
números de uno a seis. El operador : devuelve los resultados como
un vectorunidimensional , un conjunto de números:
1:6
## 1 2 3 4 5 6
Eso es todo lo que hay de cómo mueren virtual ve! Pero usted no está hecho
todavía. Ejecutando 1:6 genera un vector de números para que usted pueda ver,
pero no se guarde ese vector en cualquier parte de la memoria del ordenador. Lo
que usted está viendo es básicamente las huellas de seis números que existió
brevemente y luego se funde en la RAM del equipo. Si desea utilizar esos
números, usted tendrá que preguntar a su equipo para guardar algunos- donde.
Puede hacerlo mediante la creación de un objeto R.
Objetos
R permite guardar datos almacenándolo en un R objeto. ¿Qué es un objeto?
Sólo un nombre que puede utilizar para acceder a los datos almacenados. Por
ejemplo, puede guardar los datos en un objeto como A o B. Donde R se
encuentra en el objeto, se reemplazará con los datos guardados en el interior,
de la siguiente manera:
<- 1
a
## 1
a + 2
## 3
Objetos |
7
WWW .IT-EBOOKS.INFO
Para crear un objeto R, elija un nombre y, a continuación, utilice el
símbolo menor que <, seguido de un signo menos, -, para guardar
datos en ella. Esta combinación se asemeja a una flecha, <-. R hará un
objeto, dar su nombre, y almacenar en ella lo sigue la flecha.
Cuando le pida a R ¿En qué consiste el , le informa en la siguiente
línea.
Puede utilizar el objeto de nuevos comandos R, demasiado.
Desde un previamente almacenado el valor de 1, ahora estás
añadiendo de 1 a 2.
Así, por ejemplo, el código siguiente crea un objeto denominado morir que
contiene los números del uno al seis. Para ver qué es lo que se almacena en
un objeto, simplemente escriba el nombre del objeto por sí mismo:
Die <- 1:6
Die
## 1 2 3 4 5 6
Cuando se crea un objeto, el objeto aparecerá en el panel entorno de RStudio,

tal como se muestra en la Figure 1-2. Este panel le mostrará todos los objetos
que hayas creado desde su apertura RStudio.
Figura 1-2. El panel entorno RStudio rastrea los R objetos que cree.
Puede asignar un nombre a un objeto en R casi cualquier cosa que quieras,

pero hay algunas reglas. Primero, un nombre no puede empezar con un
número. Segundo, un nombre no puede utilizar algunos símbolos especiales,
como ^, !, $, @, +, -, /o *:

WWW .IT-EBOOKS.INFO
Buenos
nombres Nombres que causan errores
Un 1trial
B $
FOO ^significa
Mi_var 2º
.Día !Mal
R también entiende la capitalización (o es sensible a las mayúsculas

y minúsculas), por lo tanto, el nombre y
Nombre se refieren a objetos diferentes:
Nombre <- 1
Nombre <- 0
Nombre + 1
## 2
Por último, R anterior sobrescribirá cualquier información almacenada en un objeto sin

pedirle permiso. Por lo tanto, es una buena idea no utilizar nombres que ya están
tomadas:
Mi_number <- 1
Mi_number
## 1
Mi_number <- 999

Mi_number
## 999
Usted puede ver el objeto que los nombres que se han utilizado ya con la
función ls:
Ls()
## "A" "Morir" "Mi_number" "nombre" "Nombre"
También puede ver que los nombres que se han usado por el examen del entorno
RStudio panel.
Ahora tiene un virtual dado que se almacena en la memoria del ordenador. Puede
acceder a él siempre que quieras escribiendo la palabra morir. Entonces, ¿qué
se puede hacer con este morir? Bastante. R Reemplazar un objeto con su
contenido, siempre que el nombre del objeto aparece en un comando. Así, por
ejemplo, se pueden realizar todo tipo de operaciones matemáticas con el morir.
La matemática no es tan útil para tirar los dados, pero la manipulación de
conjuntos de números será su stock y el comercio como un dato científico.
Veamos cómo hacerlo:
Morir - 1
## 0 1 2 3 4 5
Morir / 2
## 0.5 1.0 1.5 2.0 2.5 3.0
Morir * die
## 1 4 9 16 25 36
Objetos |
9
WWW .IT-EBOOKS.INFO
Si usted es un gran fan de álgebra lineal (y quién no lo es?), puede que
observe que R no siempre sigue las reglas de multiplicación de matrices. En
su lugar, utiliza el elemento R-wise ejecu- ción. Al manipular un conjunto de
números, R se aplica la misma operación para cada elemento en el conjunto.
Así, por ejemplo, cuando ejecuta morir - 1, R resta uno de cada elemento
de la matriz.
Cuando se utilizan dos o más vectores en una operación, R se alinean los vectores y
realizar una secuencia de operaciones individuales. Por ejemplo, cuando
ejecuta morir * morir, las líneas R hasta morir los dos vectores y, a
continuación, multiplica el primer elemento del vector 1 por el primer elemento del
vector 2. A continuación, multiplica el segundo elemento del vector 1 por el segundo
elemento del vector 2, y así sucesivamente, hasta que cada elemento se ha
multiplicado. El resultado será un nuevo vector de la misma longitud que los dos
primeros, como se muestra en la Figure 1-3.
Figura 1-3. Cuando R realiza element-sabio, coincide con la ejecución de

vectores y luego manipula cada par de elementos de forma independiente.
Si usted da r dos vectores de longitudes desiguales, R se repita el vector más

cortos hasta que es tan larga como el vector más largo y, a continuación, realice
los cálculos matemáticos, como se muestra en la Figure 1-4. Esto no es un cambio
permanente el vector más corto será su tamaño original después de R hace los
cálculos. Si la longitud del vector corto no dividir uniformemente en la longitud del
vector de largo, R devolverá un mensaje de advertencia. Este comportamiento se
conoce como vector de reciclaje, y ayuda R elemento do-wise operaciones:
1:2
## 1 2
1:4
## 1 2 3 4
WWW .IT-EBOOKS.INFO
Die
## 1 2 3 4 5 6
Die + 1:2
## 2 4 4 6 6 8
Die + 1:4
## 2 4 6 8 6
8 mensaje de
advertencia: En
die + 1:4 :
Longitud del objeto ya no es un múltiplo de la longitud del
objeto más corto
Figura 1-4. R se repita un vector a corto elemento do-wise operaciones con

dos vectores de longitudes desiguales.
Element-wise operaciones son una característica muy útil en R porque manipular

grupos de valores en una manera ordenada. Cuando comience a trabajar con
conjuntos de datos, elemento-wise op- deliberaciones garantizará que los valores
de una observación, o caso sólo son emparejados con los valores de la misma
observación o caso. Element-wise operaciones también hacen más fácil escribir
tus propios programas y funciones en R.
Pero no creo que R ha dado sobre la multiplicación de matriz tradicional. Sólo

tienes que preguntar cuando lo desee. Puede hacerlo con la multiplicación
interior * %% y operador de multiplicación exterior con el %s% operador:
Die * %% muere
## 91
Die %s% muere

## [,1] [,2] [,3] [,4] [,5] [,6].
## [1] 1 2 3 4 5 6
Objetos| 11
WWW .IT-EBOOKS.INFO
## [2] 2 4 6 8 10 12
## [3] 3 6 9 12 15 18
## [4] 4 8 12 16 20 24
## [5] 5 10 15 20 25 30
## [6] 6 12 18 24 30 36
También puede hacer cosas como la transposición de una matriz con t y tomar su
determinante con det.
No se preocupe si no está familiarizado con estas operaciones. Son fáciles de

buscar, y no es necesario para este libro.
Ahora que puede hacer operaciones matemáticas con el objeto de morir, veamos
cómo puede "rollo". Enrollar su die requerirá algo más sofisticado que la aritmética
básica; necesitará seleccionar aleatoriamente uno de los valores del morir. Y para ello,
necesitará una función.
Funciones
R viene con muchas funciones que se pueden utilizar para realizar tareas
sofisticadas como muestreo aleatorio. Por ejemplo, puede redondear un
número con la función round, o calcular su factorial con la función factorial.
Utilizando una función es bastante simple. Sólo tiene que escribir el nombre
de la función y, a continuación, los datos que desea que la función para operar
en paréntesis:
Round(3,1415)
## 3
El factorial(3).
## 6
Los datos que se pasan a la función se llama la función del argumento. El argumento puede
ser un R raw data, objeto, o incluso los resultados de otra función de r. En este último caso,
R funcionará desde la recóndita función para las regiones ultraperiféricas, como en Figure
1-5:
Significa(1:6)
## 3.5
Significa(die)
## 3.5
Round(significa(die)
## 4
Por suerte para nosotros, hay una función de R que puede ayudar a "rollo" el morir.
Puede simular un rollo del troquel con R la función de
ejemplo. Muestra toma dos argumentos: un vector denominado x y un número
denominado tamaño. Devolverá el tamaño de muestra los elementos del vector:
Muestra(x = 1:4, Tamaño = 2).
## 3 2
WWW .IT-EBOOKS.INFO
Figura 1-5. Cuando link funciona en conjunto, R resolverá el problema de la
recóndita operación para las regiones ultraperiféricas. Aquí R primero busca
morir y, a continuación, calcula la media de uno a seis rondas de la media.
Para rodar su morir y obtener un número posterior, configurar x para morir y

muestra un elemento de ella.
Obtendrá una nueva (quizás) número distinto cada vez que rollo:
Muestra(x = morir, tamaño = 1)
## 2

## 1

## 6
Muchos R funciones toman varios argumentos que les ayuden a hacer su

trabajo. Puede dar una función tantos argumentos como te gusta mientras
cada argumento se separan con una coma.
Usted puede haber notado que me muera y 1 iguales a los nombres de los argumentos en
la muestra, X y tamaño. Cada argumento en cada R función tiene un nombre. Puede
especificar qué datos deben ser asignados a qué argumento estableciendo un nombre igual
a los datos, como en la pre- cede el código. Esto cobra importancia a medida que usted
comience a pasar múltiples argumentos para la misma función; nombres le ayudan a evitar
la transmisión de los datos erróneos al argumento incorrecto. Sin embargo, el uso de
nombres es opcional. Usted notará que R usuarios no utilizan a menudo el nombre del
primer argumento de una función. Así que usted puede ver el código anterior escrito como:
Muestra(die, tamaño = 1)
## 2
A menudo, el nombre del primer argumento no es muy descriptivo, y

generalmente es evidente cuál es el primer dato se refiere a de todos
modos.
Pero, ¿cómo saber qué nombres de argumento a utilizar? Si intenta utilizar
un nombre que una función no puede esperar, es probable que obtenga un
mensaje de error:
Round(3,1415, esquinas = 2)
## Error en round(3,1415, esquinas = 2) : argumento(s) no utilizados
(esquinas = 2).
Funciones |
13
WWW .IT-EBOOKS.INFO
Si no estás seguro de qué nombres para su uso con una función, puede buscar
los argumentos de función con args. Para ello, coloque el nombre de la
función en el paréntesis detrás de args. Por ejemplo, puede ver que
la función round toma dos argumentos, uno llamado x y uno
denominado digits:
Args(ronda)
## Función (x = 0), dígitos
## NULL
¿Ha notado usted que args muestra que los dígitos argumento de ronda ya está
establecido a 0? Con frecuencia, una función R tendrá argumentos opcionales
como dígitos. Estos argumentos se consideran opcionales porque vienen con un
valor predeterminado. Puede pasar de un nuevo valor a un argumento opcional, si lo
desea, y R utilizará el valor por defecto si no lo hacen. Por ejemplo, mesas redondas
será su número a 0 dígito después de la coma decimal por defecto. Para ignorar el
valor predeterminado, suministrar su propio valor para dígitos:
Round(3,1415, dígitos = 2)
## 3.14
Usted debe escribir los nombres de cada argumento después de los primeros uno
o dos cuando llame a una función con varios argumentos. ¿Por qué? En primer
lugar, esto le ayudará a usted y a otros ONU- entiendo tu código. Es evidente que
el argumento generalmente su primera entrada se refiere a (y a veces la segunda
entrada). Sin embargo, necesitas una gran capacidad de memoria para recordar
el tercer y cuarto argumento de cada función de r. Segundo, y más importante,
escribiendo los nombres de argumento evita errores.
Si no se escriben los nombres de sus argumentos, R coincidirán con los valores

de los argumentos en su función por orden. Por ejemplo, en el código siguiente,
el primer valor, die, coincidirá con el primer argumento de la muestra, que se
denomina x. El valor siguiente, 1, será igualado con el siguiente
argumento, tamaño:
Muestra(die, 1)
## 2
Como usted proporcionar más argumentos, es más probable que su orden y

R del orden no podrá alinear. Como resultado, los valores pueden pasar al
argumento incorrecto. Los nombres de argumento prevenir esto. R siempre
coincidirá con un valor de nombre de argumento, no importa donde aparece
en el orden de los argumentos:
Muestra(size = 1, x = die)
## 2
Con sustitución de muestra

Si establece el tamaño = 2, casi se puede simular un par de dados. Antes de
ejecutar este código, piense por un momento por qué ese podría ser el
caso. Ejemplo devolverá dos números, uno para cada troquel:
WWW .IT-EBOOKS.INFO
Muestra(die, tamaño = 2).
## 3 4
He dicho "casi" funciona porque este método hace algo gracioso. Si utiliza muchas veces,
te darás cuenta de que la segunda morir nunca tiene el mismo valor que los primeros en
morir, lo que significa que jamás podrás rodar algo como una pareja de treses o Snake
Eyes. ¿Qué está sucediendo?
De forma predeterminada, el ejemplo genera una muestra sin reemplazo. Para ver lo que esto
significa, imagine que muestra los lugares de todos los valores de morir en una jarra o URN.
A continuación, imagine que alcanza la muestra en el frasco y saca valores uno por uno para
construir su muestra. Una vez que un valor ha sido elaborada a partir de la jarra, conjuntos de
ejemplos de lado. El valor no retroceder en el jar, por lo que no puede ser dibujado de nuevo.
Por lo tanto, si selecciona una muestra seis en su primer sorteo, no será capaz de seleccionar
seis en el segundo sorteo; seis ya no está en la jarra para ser seleccionado. Aunque
el ejemplo crea su muestra electrónicamente, aparentemente sigue este comportamiento
físico.
Un efecto secundario de este comportamiento es que cada sorteo depende de los sorteos
que se presentan ante ella. En el mundo real, sin embargo, al rodar un par de dados, cada
dado es independiente de los demás. Si el primer die llega hasta seis, no impide la segunda
venida mueren de seis. De hecho, no influyen en la segunda morir de alguna manera.
Puede recrear este comportamiento en la muestra añadiendo el argumento sustituir =
TRUE:
Muestra(die, tamaño = 2, sustituir = TRUE).
## 5 5
El argumento sustituir = true hace que muestra a otra con sustitución.

Nuestro ejemplo jar proporciona una buena manera de comprender la diferencia
entre el muestreo con re- Colocación y sin. Cuando la muestra se utiliza la
sustitución, dibuja un valor de la jarra y registra el valor. A continuación, pone el
valor en la jarra. En otras palabras, ejemplo reemplaza cada valor después de
cada sorteo. Como resultado, la muestra puede seleccionar el mismo valor en el
segundo sorteo. Cada valor tiene una probabilidad de ser seleccionado cada vez.
Es como si cada sorteo fueron el primer sorteo.
Muestreo con reemplazo es una forma sencilla de crear muestras aleatorias

independientes. Cada valor de la muestra será una muestra de un tamaño que es
independiente de los otros valores. Este es el camino correcto para simular un par
de dados:
Muestra(die, tamaño = 2, sustituir = TRUE).
## 2 4
Felicito a usted; usted acaba de realizar su primera simulación en R! Ahora

tiene un método para simular el resultado de tirar un par de dados. Si desea
sumar los dados, usted puede alimentar su resultado directamente en
la función suma:
<- dados muestra(die, tamaño = 2, sustituir = TRUE).
Dados
## 2 4
Sum(dados)
## 6
Con sustitución de muestra |

15
WWW .IT-EBOOKS.INFO
¿Qué pasaría si usted llama dados varias veces? R podría generar un nuevo
par de valores dados cada vez? Vamos a probarlo:
Dados
## 2 4
Dados
## 2 4
Dados
## 2 4
Nope. Cada vez que usted llame dados, R le mostrará el resultado de que una vez
que se denomina muestra y guarda la salida a dados. R no se vuelva a
ejecutar muestra(die, 2, sustituir = TRUE) para crear una nueva tirada de
los dados. Esto es un alivio, en cierto modo. Una vez que guarde un conjunto de
resultados a un r objeto, esos resultados no cambian. La programación sería muy difícil
si los valores de los objetos cambia cada vez que lo llamó.
Sin embargo, sería conveniente disponer de un objeto que puede volver a tirar los
dados cada vez que usted llame. Usted puede hacer que dicho objeto escribiendo su
propia función de r.
Escribir sus propias funciones

Para recapitular, ya tienes trabaja r código que simula tirar un par de dados:
Die <- 1:6
Sum(dados)
Puede escribir este código en la consola en cualquier momento desea volver a

rodar los dados. Sin embargo, esta es una forma extraña de trabajar con el código.
Sería más fácil para usar su código si lo envolvió en su propia función, que es
exactamente lo que vamos a hacer ahora. Vamos a escribir una función
denominada rollo que puede utilizar para rodar su virtual dados. Cuando haya
terminado, la función funcionará como esto: cada vez que usted llame roll(), R
devolverá la suma de los dos dados de laminación:
Roll()
## 8
Roll()
## 3
Roll()
## 7
Las funciones pueden parecer misterioso o de fantasía, pero son simplemente

otro tipo de R objeto. En lugar de contener datos, contienen código. Este
código se almacena en un formato especial que facilita la reutilización del
código en situaciones nuevas. Puede escribir sus propias funciones por
recrear este formato.
WWW .IT-EBOOKS.INFO
La función constructor
Cada función en R tiene tres partes básicas: un nombre, un cuerpo de código
y un conjunto de argumentos. Para hacer su propia función, necesita replicar
estas piezas y almacenarlos en un objeto R, que se puede hacer con
la función . Para ello, llame function() y seguir con un par de llaves {}:
Mi_FUNCTION <- función() {}
La función para crear una función de cualquier código R se coloca entre las llaves.
Por ejemplo, puedes convertir tu código de dados en una función, llamando
al:
Roll <- función() {
Die <- 1:6
Sum(dados)
}
Observe que he sangrado cada línea de código entre las llaves. Esto hace que el
código sea más fácil para usted y para mí leer pero no tiene ningún impacto sobre
cómo se ejecuta el código. R ignora los espacios y saltos de línea y se ejecuta una
expresión completa a la vez.
Sólo tienes que pulsar la tecla intro entre cada línea después de la primera
llave, {. R esperará para escribir la última llave, }, antes de que responda.
No olvide guardar la salida de la función de un objeto R. Este objeto se
convertirá en su nueva función. Para utilizarlo, escriba el nombre del objeto
seguido de un paréntesis abierto y cerrado:
Roll()
## 9
Puede pensar en los paréntesis como el "gatillo" que causa R para ejecutar la
función. Si escribe el nombre de una función sin paréntesis, r le mostrará el
código que se almacena dentro de la función. Si escribe el nombre con el
paréntesis, R se ejecuta ese código:
Rollo
## Function() {
## Die <- 1:6
## <- dados muestra(die, tamaño = 2, sustituir = TRUE)
## Sum(dados)
## }
Roll()
## 6
El código que se coloca dentro de su función es conocido como el cuerpo de la función.

Cuando se ejecuta una función en R, R ejecutará todo el código en el cuerpo y, a
continuación, devolver el resultado de la última línea de código. Si la última línea de código
no devuelve un valor, tampoco
Escribir sus propias funciones | 17

WWW .IT-EBOOKS.INFO
Su función, por lo que quiere asegurarse de que su última línea de código que devuelve un
valor. Una manera de verificar esto es a pensar qué pasaría si ejecutó el cuerpo de código
línea por línea en la línea de comandos. R sería mostrar un resultado después de la última
línea, o ¿no?
Aquí tiene algún código que muestre un resultado:

Dados
1 + 1
Sqrt(2).
Y aquí tiene algún código que no:

Dos <- 1 + 1
A <- sqrt(2).
¿Se observa el patrón? Estas líneas de código no devolver un valor a la

línea de comandos; ellos guardar un valor en un objeto.
Argumentos
¿Qué ocurre si eliminamos una línea de código de nuestra función y cambió
el nombre mueren a los huesos, como este?
Rollo2 <- función() {
<- dados muestra(huesos, tamaño = 2, sustituir = TRUE).
Sum(dados)
}
Ahora voy a obtener un error al ejecutar la función. La función necesita el

objeto huesos para hacer su trabajo, pero no hay ningún objeto
denominado los huesos se encuentran:
Rollo2()
## Error en la muestra(huesos, tamaño = 2, sustituir = TRUE) :
## Objeto 'huesos' no encontrado
Puede suministrar los huesos cuando usted llame rollo2 si hacen que los
huesos de un argumento de la función. Para ello, poner el nombre de los
huesos en los paréntesis que siguen a la hora de definir la función rollo2:
Rollo2 <- función(huesos) {
Sum(dados)
}
Ahora rollo2 funcionará mientras que suministre los huesos cuando se

llama a la función. Usted puede tomar ventaja de esto para diferentes tipos de
rodillo de dados cada vez que usted llame rollo2. Calabozos y Dragones,
aquí vamos!
Recuerde, estamos rodando pares de dados:

WWW .IT-EBOOKS.INFO
Rollo2(huesos = 1:4)
## 3
Rollo2(huesos = 1:6)
## 10
Rollo2(1:20).
## 31
Observe que rollo2 todavía dar un error si no proporciona un valor para

el argumento de huesos cuando llame rollo2:
Rollo2()
## Error en la muestra(huesos, tamaño = 2, sustituir = TRUE) :
## Argumento "huesos" está ausente, no tiene ningún valor
predeterminado
Este error se puede evitar dando los huesos argumento un valor

predeterminado. Para ello, establezca los huesos igual a un valor cuando
defina rollo2:
Rollo2 <- función(huesos = 1:6) {
Sum(dados)
}
Ahora usted puede suministrar un nuevo valor para los huesos si te gusta,
y roll2 utilizará por defecto si no:
Rollo2()
## 9
Puede dar a sus funciones como muchos argumentos como desee. Sólo la lista de sus
nombres, sep- arated por comas, en los paréntesis que siguen a la función. Cuando
se ejecuta la función, R reemplazar cada nombre de argumento en el cuerpo de la
función con el valor que el usuario proporciona para el argumento. Si el usuario no
suministra un valor R se sustituya el nombre del argumento con el valor
predeterminado del argumento (si se ha definido uno).
Para resumir, la función le ayuda a construir su propio R funciones. Se crea un

cuerpo de código de la función para ejecutar escribiendo el código entre las llaves
que siguen func tion. Crear argumentos para la función usar suministrando sus
nombres en los paréntesis que siguen a la función. Por último, le dará a su
función un nombre por guardar su salida a un r objeto, como se muestra en
la Figure 1-6.
Una vez que hayas creado tu función, R tratarla como cualquier otra función
en R. Piense cómo esto es útil. ¿Alguna vez has intentado crear una nueva
opción de Excel y agregarlo a la barra de menú de Microsoft? O una nueva
animación de diapositivas y añadirlo a las opciones de Powerpoint? Cuando
se trabaja con un lenguaje de programación, puede hacer este tipo de cosas.
A medida que aprenda a programar en R, usted será capaz de crear nuevas
herramientas personalizadas y reproducible para usted cuando usted
quiera. Part III Te enseñará mucho más sobre cómo escribir func- ciones en
R.
Argumentos |
19
WWW .IT-EBOOKS.INFO
Figura 1-6. Cada función en R tiene las mismas piezas, y puede utilizar la
función para crear estas piezas.
Scripts
¿Qué pasa si desea editar rollo2 otra vez? Usted puede retroceder y volver a escribir
cada línea de código en Rollo2, pero sería mucho más fácil si usted tenía un proyecto de
código para empezar. Puede crear un borrador de tu código a medida que se vaya
utilizando un r script. Una R script es un archivo de texto sin formato que guarda r código.
Puede abrir una r script en RStudio yendo a Archivo
> Nuevo Archivo > R script en la barra de menú. RStudio abrirá
entonces un nuevo script encima de su panel de consola, como se muestra
en la Figure 1-7.
Os animo vivamente a escribir y editar todos sus r código en un script antes de
ejecutarlo en la consola. ¿Por qué? Este hábito crea un registro reproducible de tu
trabajo. Cuando haya terminado el día, usted puede guardar la secuencia de
comandos y, a continuación, utilizarlo para ejecutar la totalidad del análisis al día
siguiente. Los scripts son también muy útiles para la edición y corrección de pruebas
de su código, y hacen una buena copia de su trabajo para compartir con los demás.
Para guardar un script, haga clic en el panel de scripts, y luego ir a Archivo >
Guardar como en la barra de menú.
RStudio viene con muchas características integradas que facilitan el trabajo

con secuencias de comandos. En primer lugar, puede ejecutar
automáticamente una línea de código en un archivo de secuencia de
comandos haciendo clic en el botón Ejecutar, como se muestra en la Figure
1-8.
R podrán ejecutar cualquier línea de código esté situado el cursor. Si usted tiene una
sección entera alto- Iluminado, R se ejecutará el código resaltado. Alternativamente,
puede ejecutar el script completo haciendo clic en el botón Source. No me gusta hacer
clic en los botones? Puede utilizar Control + Retorno como un método abreviado para
el botón Ejecutar. En Macs, que sería Comando + Retorno.
WWW .IT-EBOOKS.INFO
Figura 1-7. Cuando abra una R Script (Archivo > Nuevo > R Archivo de
secuencia de comandos en la barra de menús), RStudio crea un cuarto panel
encima de la consola donde se puede escribir y editar el código.
Figura 1-8. Puede ejecutar una parte de código resaltado en su secuencia de

comandos si hace clic en el botón Ejecutar en la parte superior del panel de
scripts. Puede ejecutar la secuencia de comandos completa haciendo clic en
el botón Source.
Si no estás convencido acerca de scripts, pronto lo será. Se convierte en un dolor

de cabeza para escribir varias líneas de código en la consola de línea de
comandos de una sola línea. Vamos a evitar que el dolor de cabeza y abrir tu
primer script ahora antes de pasar al siguiente capítulo.
Scripts |
21
WWW .IT-EBOOKS.INFO
Función de extracción
RStudio viene con una herramienta que puede ayudarle a crear
funciones. Para usarlo, resalte las líneas de código en su r script
que desea convertir en una función. A continuación, haga clic en >
Extraer el Código de función en la barra de menú. RStudio
le preguntará por un nombre de función a utilizar y, a continuación,
ajuste el código en una llamada a una función. Se escaneará el
código de undefined variables y utilizarlas como argumentos.
Es posible que desee comprobar RStudio. Se supone que el
código es correcto, por lo que si se hace algo sorprendente,
usted puede tener un problema en el código.
Resumen
Usted ha cubierto mucho terreno ya. Ahora tiene un virtual die almacenados
en la memoria del ordenador com -, así como su propia función R que saca
un par de dados. Usted también ha comenzado hablando el lenguaje R.
Como has visto, R es un lenguaje que se puede utilizar para comunicarse con el
ordenador. Escribir comandos en R y ejecutarlas en la línea de comandos para
que el equipo lea. El equipo se hablan a veces back-por ejemplo, cuando se
comete un error, pero normalmente sólo hace lo que usted le pide y, a
continuación, se muestra el resultado.
Los dos componentes más importantes de la lengua R son objetos, que almacenan datos
y funciones que manipulan los datos. R también utiliza una gran cantidad de operadores
como +, -, *, /y <-- para realizar tareas básicas. Como un dato científico, se utilizará R
objetos para almacenar datos en la memoria de su computadora, y usted podrá utilizar
funciones para automatizar tareas y hacer cálculos complicados. Vamos a examinar
objetos con mayor profundidad más adelante en Part II y profundizar en las funciones
de Part III. El vocabulario que han desarrollado aquí hará que cada uno de los proyectos
más fáciles de entender. Sin embargo, no hemos terminado con los dados todavía.
En Chapter 2, podrá ejecutar algunas simulaciones sobre los dados y construir su

primera gráficos en R. Verá también dos de los componentes más útiles de la R
idioma: R pack- Edades, que son colecciones de funciones writted por R del
talentoso comunidad de desarrolladores, y R la documentación, que es una
colección de páginas de ayuda incorporada en R que explica cada función y el
conjunto de datos en el lenguaje.
WWW .IT-EBOOKS.INFO
Capítulo 2
Paquetes y páginas de
ayuda.
Ahora tiene una función que simula tirar un par de dados. Vamos a hacer las cosas un
poco más interesante, ponderando los dados a su favor. La casa siempre gana,
¿verdad? Hagamos de la tirada de dados de alta números ligeramente más a menudo
que pasa bajo los números.
Antes de que el peso de los dados, debemos asegurarnos de que sean justas
para empezar. Dos herramientas le ayudarán a ello: la repetición y visualización.
Por coincidencia, estas herramientas también son dos de los superpoderes más
útiles en el mundo de los datos científicos.
Vamos a repetir nuestras tiradas de dados con una función

denominada replicar, y vamos a visualizar nuestros rollos con una función
denominada qplot. Qplot no viene con R cuando lo
descargue; qplot viene en un paquete de R independiente. Muchas de las
herramientas más útiles de R R vienen en paquetes, así que tomemos un
momento para mirar lo que hay paquetes de R y de cómo puede utilizarlos.
Paquetes
No eres la única persona escribir sus propias funciones con R. muchos profesores,
pro- grammers y estadísticos, utilizar R para diseñar herramientas que pueden ayudar
a la gente a analizar los datos. Ellos entonces que estas herramientas de uso gratuito
para todo el mundo. Para utilizar estas herramientas, sólo tienes que bajar- carga de
ellos. Vienen premontados como colecciones de funciones y objetos llamados
pack- edades. Appendix B Contiene instrucciones detalladas para descargar y
actualizar R pack- Edades, pero veremos los fundamentos aquí.
Vamos a usar la función qplot para hacer rápidamente algunas parcelas. Qplot viene
en el paquete ggplot2, un popular paquete para hacer gráficos. Antes de poder
utilizar qplot, o cualquier otra cosa en el paquete ggplot2, necesitará descargar e
instalarlo.
23
WWW .IT-EBOOKS.INFO
Instalar los paquetes.
Cada paquete de R http://cran.r-project.org, que está alojado en el mismo sitio
web que aloja R. Sin embargo, usted no necesita visitar el sitio web para descargar
un paquete de R; puede abajo- paquetes de carga R directamente desde la línea
de comandos. He aquí cómo:
1. Abra RStudio.
2. Asegúrese de que está conectado a Internet.
3. Ejecute install.packages("ggplot2") en la línea de comandos.
Eso es todo. R tendrá su equipo visite el sitio web, descargue ggplot2, e

instalar el paquete en el disco duro donde R quiere encontrarlo. Ahora tienes
el paquete ggplot2. Si desea instalar otro paquete, sustituir ggplot2 con el
nombre de paquete en el código.
Biblioteca
La instalación de un paquete no coloque sus funciones al alcance de su mano
todavía: simplemente se coloca en su disco duro. Para usar un paquete de R,
después tiene que cargar en tu r la sesión con el
comando library("ggplot2"). Si desea cargar un paquete diferente, sustituir
ggplot2 con el nombre de paquete en el código.
Para ver lo que esto hace, intentar un experimento. En primer lugar, pedir R
para mostrar que la función qplot. R no podrán encontrar qplot qplot
porque vive en el paquete ggplot2, que no se han cargado:
Qplot
## Error: objeto 'qplot' no encontrado
Ahora cargar el paquete ggplot2:

Biblioteca("ggplot2")
Si instaló el paquete con install.packages como instruido, todo debería ir bien.

No se preocupe si no ve ningún resultado o mensajes. Ninguna noticia es buena
noticia cuando se carga un paquete. No se preocupe si no ve un mensaje
cualquiera; ggplot2, algunas veces dis- juega útiles mensajes de arranque.
Mientras usted no ve nada que dice "Error", lo estás haciendo muy bien.
Ahora si pido ver qplot, R le mostrará un poco de código (qplot es una larga función):
Qplot
## (Un poco de código)
Appendix B Contiene muchos más detalles acerca de la adquisición y uso de paquetes. Mi

recomendación- mend que leerlo si no está familiarizado con R Sistema de paquetes. Lo
principal a recordar es que sólo es necesario instalar un paquete una vez, pero tendrá que
cargar con
24 | Capítulo 2: Paquetes y páginas de ayuda.

WWW .IT-EBOOKS.INFO
Biblioteca cada vez que desee utilizar en una nueva sesión de r. R
descargará todos sus paquetes cada vez que cierre RStudio.
Ahora que has cargado qplot, hagamos un trompo. Hace qplot "quick parcelas." Si usted
da qplot dos vectores de la misma longitud, qplot dibujará un Scatter plot para
usted. Qplot usará el primer vector como un conjunto de valores de x y el segundo vector
como un conjunto de valores de y. Busque la trama que aparece en la ficha de parcelas en
el panel inferior derecho de su ventana RStudio.
El siguiente código hará que la trama que aparece en la Figure 2-1. Hasta
ahora, hemos estado creando secuencias de números con el operador :; pero
también puede crear vectores de números con la función c. Dar c todos los
números que desee que aparezca en el vector, separados por una
coma. C significa para concatenar, pero se puede considerar como "recoger"
o "combinar":
X <- c(-1, -0,8, -0,6, -0,4, -0,2, 0, 0.2, 0.4, 0.6, 0.8, 1)
X
## -1,0 -0,8 -0,6 -0,4 -0,2 0.0 0.2 0.4 0.6 0.8 1.0
Y <- x^3
Y
## -1.000 -0.512 -0.216 -0.064 -0.008 0.000 0.008
## 0,064 0,216 0,512 1,000
Qplot(x, y)
Figura 2-1. qplot hace un Scatter plot cuando le dan dos vectores.
No necesita nombrar tus vectores x e y. Yo simplemente no tenía que hacer el ejemplo

claro. Como se puede ver en la Figure 2-1, un Scatter plot es un conjunto de puntos, cada
traza de acuerdo con sus valores de x e y. Juntos, los vectores x e y describir un conjunto
de 10 puntos. ¿Cómo R
Paquetes | 25
WWW .IT-EBOOKS.INFO
Haga coincidir los valores de x e y para hacer de estos puntos? Con el
elemento-wise la ejecución, como vimos en la Figure 1-3.
Scatterplots son útiles para visualizar la relación entre dos variables. Sin
embargo, vamos a utilizar un tipo diferente de gráfico, un histograma. Un
histograma que visualiza la distribución de una sola variable; muestra cuántos
puntos de datos aparecen en cada valor de x.
Echemos un vistazo a un histograma para ver si esto tiene sentido. Qplot hará un
histograma cuando dan sólo un vector de parcela. El siguiente código hace que la
parcela en izquierdo Figure 2-2 (nos preocuparemos sobre la parcela derecha sólo en
segundo). Para asegurarnos de que nuestros gráficos tienen el mismo aspecto, utilice
el argumento extra binwidth = 1:
X <- c(1, 2, 2, 2, 3, 3)
Binwidth qplot(x = 1).
Figura 2-2. qplot hace un histograma cuando se le asigna un único vector.
Esta gráfica muestra que nuestro vector contiene un valor en el intervalo [1, 2) colocando
una barra de altura 1 por encima de ese intervalo. Asimismo, el gráfico muestra que el
vector contiene tres valores en el intervalo [2, 3) colocando una barra de altura 3 en ese
intervalo. Muestra que el vector contiene dos valores en el intervalo [3, 4) colocando una
barra de altura 2 en ese intervalo. En estos intervalos, el disco soporte, [, significa que el
primer número está incluido en el intervalo. Los paréntesis, ), significa que el último
número no está incluido.
Vamos a probar otro histograma. Este código hace que la parcela derecha
en Figure 2-2. Observe que existen cinco puntos con un valor de 1 en x2. El
histograma muestra esta trazando una barra de altura de 5 por encima del
intervalo x2 = [1, 2):

WWW .IT-EBOOKS.INFO
X2 <- c(1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4).
Qplot(x2, binwidth = 1).
Ejercicio
Llamaremos x3 sea el vector siguiente:
X3 <- c(0, 1, 1, 2, 2, 2, 3, 3, 4).
Imagine lo que un histograma de x3 sería similar. Asumir que el histograma

tiene un ancho de 1 bandejas. ¿Cuántas barras será el histograma? Dónde
van a aparecer? Cómo serán de alta?
Cuando haya terminado, trazar un histograma de x3 con binwidth = 1, y ver si está a la
derecha.
Usted puede hacer un histograma de x3 con qplot(x3, binwidth = 1). El

histograma se verá como una pirámide simétrica. La barra central tendrá una
altura de 3 y aparecerá encima [2, 3), pero asegúrese de probarlo y ver por ti
mismo.
Puede utilizar un histograma para mostrar visualmente cómo común los

valores de x son diferentes. Números cubiertos por una barra de altura no son
más comunes que los números cubiertos por una barra corta.
¿Cómo se puede utilizar un histograma para comprobar la exactitud de los
dados?
Bien, si tira los dados muchas veces y realizar un seguimiento de los
resultados, es de esperar algunos números de ocurrir más que otros. Esto es
porque hay más formas de obtener algunos números mediante la adición de
los dos dados juntos que para obtener otros números, como se muestra en
la Figure 2-3.
Si tira los dados muchas veces y trazar los resultados con qplot, el
histograma le mostrará cómo a menudo cada suma apareció. Las sumas que
se produjeron la mayoría de las veces tendrá la máxima bares. El histograma
debe parecerse a la trama en Figure 2-3 si los dados son bastante ponderado.
Aquí es donde entra en replicar. Replicar proporciona una manera fácil de repetir
un comando R muchas veces. Para usarlo, primero dar duplicar el número de veces
que desea repetir un comando r y, a continuación, darle el comando que desea
repetir. Replicar ejecutará el comando varias veces y guardar los resultados como
un vector:
Replicar(3, 1 + 1)
## 2 2 2
Replicar(10, roll())
## 3 7 5 3 6 2 3 8 11 7
Paquetes | 27
WWW .IT-EBOOKS.INFO
En la figura 2-3. Cada combinación de dados debe producirse con la misma
frecuencia. Como resultado, algunas sumas ocurrirá con más frecuencia que otros.
Con justa dados, cada suma debería aparecer en proporción a la cantidad de
combinaciones que lo hacen.
Un histograma de tu primer 10 rollos probablemente no lucen como el patrón

que se muestra en la Figure 2-3. ¿Por qué no? Hay demasiada aleatoriedad
involucrados. Recuerde que usamos dados en la vida real, porque son
eficaces generadores de números aleatorios. Patrones de frecuencias de
largo plazo sólo aparecerán en el largo plazo. Así que vamos a simular 10.000
tiradas de dados y trazar los resultados. No se
preocupe; qplot y replicar puede encargarse de ello. Los resultados
aparecen en Figure 2-4:
Rollos <- replicar(10000, roll())
Qplot(rollos, binwidth = 1).
Los resultados sugieren que los dados son justas. A largo plazo, cada número
se produce en proporción a la cantidad de combinaciones que lo generan.
Ahora, ¿cómo puede el sesgo estos resultados? El patrón anterior se produce porque cada
bajo- mentir combinación de dados (por ejemplo, (3,4) se produce con la misma frecuencia.
Si pudiera aumentar la probabilidad de que un 6 se enrolla en morir, entonces cualquier
combinación con un seis en ocurrirá más a menudo que cualquier combinación sin un seis
en ella. La combinación (6, 6) se producirían más de todos. Esto no hará que los dados
añadir hasta 12 más a menudo de lo que añadir hasta siete, pero sesgará los resultados
hacia los números más altos.
WWW .IT-EBOOKS.INFO
Figura 2-4. El comportamiento de nuestros dados sugiere que son justas.
Siete ocurre con más frecuencia que cualquier otro número y frecuencias
disminuye en proporción al número de die combinaciones que crear cada
número.
Para decirlo de otra manera, la probabilidad de cualquier número individual de

laminación en una feria morir es de 1/6. Me gustaría que usted cambie la
probabilidad de 1/8 para cada uno de los siguientes números 6 y, a
continuación, aumentar la probabilidad de sacar un seis a 3/8:
Probabilidad Probabilidad
Número justo ponderada
1 1/6 1/8
2 1/6 1/8
3 1/6 1/8
4 1/6 1/8
5 1/6 1/8
6 1/6 3/8
Puede cambiar las probabilidades, añadiendo un nuevo argumento a

la función de ejemplo. No voy a decirte lo que el argumento es; en lugar de
eso voy a la página de ayuda para la función de ejemplo. ¿Qué es eso? R
funciones vienen con páginas de ayuda? Sí lo hacen, así que vamos a
aprender a leer.
Obtener ayuda con páginas de ayuda.

Hay más de 1.000 funciones en el núcleo de R y R se crean nuevas funciones todo el
tiempo. Esto puede ser un montón de material para memorizar y aprender!
Afortunadamente, cada función R viene con su propia página de ayuda, al que se puede
acceder escribiendo el nombre de la función después de
Obtener ayuda con páginas de ayuda. | 29
WWW .IT-EBOOKS.INFO
Un signo de interrogación. Por ejemplo, cada uno de estos comandos se abrirá
una página de ayuda. Buscar las páginas que aparecen en la ficha Ayuda de
RStudio del panel inferior derecha:
Sqrt ?
Log10 ?
Muestra ?
Páginas de ayuda contienen información útil acerca de lo que hace cada función. Estas
páginas de ayuda también sirven como documentación de código, por lo que su lectura
puede ser agridulce. A menudo parecen ser escritos por personas que ya conoce la función
y no necesitan ayuda.
No deje que esto le molesta, puede ganar un montón de una página de ayuda
mediante el escaneo de infor- mación que tiene sentido y disimular el resto.
Esta técnica inevitablemente traerá a la parte más útil de cada página de
ayuda: la parte inferior. Aquí, casi cada página de ayuda incluye código de
ejemplo que pone en acción la función. Ejecutar este código es una gran
manera de aprender con el ejemplo.
Si una función viene en un paquete de R, R no podrán

encontrar su página ayuda a menos que el paquete está
cargado.
Partes de una página de Ayuda

Cada página de ayuda está dividido en secciones. Las secciones que aparecen
pueden variar desde la página de ayuda en la página de ayuda, pero en general,
usted puede esperar encontrar estos temas útiles:
Descripción
Un breve resumen de lo que hace la función.
Uso
Un ejemplo de cómo se escribe la función. Cada argumento de la función aparecerá
en la orden r espera que proporcione (si no se utilizan los nombres de argumento).
Argumentos
Una lista de cada uno de los argumentos de la función toma, qué tipo de
información R espera que proporcione para el argumento de la función, y lo hará
con la información.
Detalles
Una descripción más detallada de la función y la forma en que funciona.
La sección Detalles también ofrece la función autor una oportunidad para
alertar al usuario de cualquier cosa que usted desee saber cuando se
utiliza la función.
Valor
Una descripción de lo que devuelve la función cuando se ejecute.
WWW .IT-EBOOKS.INFO
Véase también
Una breve lista de funciones relacionados con r.
Ejemplos
Código de ejemplo que usa la función y está garantizado para trabajar. Ejemplos
de la sec- ción de una página de ayuda normalmente muestra un par de maneras
diferentes de usar una función. Esto ayuda a dar una idea de lo que es capaz de
la función.
Si quieres mirar la página de ayuda para una función, pero ha olvidado el nombre de
la función, puede realizar búsquedas por palabra clave. Para ello, escriba dos signos
de interrogación seguido de una palabra clave en la línea de comando del R. R
desplegará una lista de enlaces a páginas de ayuda relacionados con la palabra clave.
Puede pensar en esto como la página de ayuda de la página de ayuda:
Registro ??
Echemos un paseo por ejemplo's página de ayuda. Recuerde: estamos

buscando algo que podría ayudarle a cambiar las probabilidades implicadas
en el proceso de muestreo. No voy a reproducir toda la página de ayuda aquí
(sólo las piezas más suculentas), por lo que deberá seguir en su equipo.
En primer lugar, abra la página de ayuda. Aparecerá en el mismo panel de
RStudio como sus parcelas (pero no en la ficha Ayuda, no las parcelas tab):
Muestra ?
¿Qué ve usted? Comenzando desde la

parte superior:
Muestras Aleatorias y permutaciones
Descripción
La muestra se toma una muestra del tamaño especificado a
partir de los elementos de x usando ya sea con o sin
sustitución.
Hasta ahora, todo bien. Usted sabía todo eso. La siguiente sección, uso
tiene una posible pista. Se menciona un argumento denominado prob:
Uso
Muestra(x, tamaño, sustituir = FALSO, prob = NULL)
Si se desplaza hacia abajo, a los argumentos, la sección de descripción

de prob suena muy prometedor:
Un vector de probabilidad pesas para obtener los elementos del
vector que está siendo muestreado.
La sección Detalles confirma nuestras sospechas. En este caso, también le indica cómo
proceder:
El prob Argumento opcional puede ser usado para dar un vector de
coeficientes de ponderación para la obtención de los elementos del
vector que está siendo muestreado. No necesitan suma a uno, pero
deben tener un valor negativo y no todos cero.
Aunque la página de ayuda no decirlo aquí, estos pesos se corresponde a los elementos
que se muestra en el elemento-sabios de la moda. El primer peso describirá el primer
Obtener ayuda con páginas de
ayuda. | 31
WWW .IT-EBOOKS.INFO
Segundo elemento, el peso, el segundo elemento, y así sucesivamente. Esta
es una práctica común en R.
Lectura:
Si Replace es True, Walker de alias del método (Ripley, 1987) se
utiliza...
Bueno, parece que el tiempo para iniciar rozando. Debemos tener suficiente
información ahora para averiguar cómo el peso de nuestros dados.
Ejercicio
Reescribir la función de rollo a rollo un par de dados: ponderado
Die <- 1:6
Sum(dados)
}
Usted necesitará agregar un prob argumento a la función dentro del rollo

de muestra. Este ar- gument debería decirle a una muestra a los números
del uno al cinco con probabilidad de 1/8), y el número 6 con una probabilidad
de 3/8.
Cuando haya terminado, podrá leer acerca de un modelo de respuesta.
El peso de los dados, usted necesita agregar un argumento prob con un

vector de pesos a sample, como esta:
Die <- 1:6
<- dados muestra(die, tamaño = 2,
sustituir = TRUE, prob = c(1/ 1/ 8 ,8, 1, 1
/ 8/ 1/ 8 ,8, 3/8)).
Sum(dados)
}
Esto hará que el rodillo para elegir 1 a 5 con una probabilidad de 1/8 y 6 con una
probabilidad de 3/8.
Sobrescribir la versión anterior de rodar con la nueva función (ejecutando el

fragmento de código anterior en la línea de comandos). A continuación, visualice
el nuevo comportamiento a largo plazo de los dados. He puesto los
resultados Figure 2-5 junto a nuestros resultados originales:
Rollos <- replicar(10000, roll())
Qplot(rollos, binwidth = 1).
Esto confirma que hemos ponderado efectivamente los dados. Números altos ocurren
mucho más a menudo que los números bajos. Lo curioso es que este comportamiento sólo
se apreciará cuando examine las frecuencias de largo plazo. En un solo rollo, dados se
parecen comportarse de forma aleatoria. Esta es una gran noticia si juegas a los Colonos
de Catan (sólo dile a tus amigos
WWW .IT-EBOOKS.INFO
Has perdido los dados), pero debería ser preocupante si se analizan datos,
porque significa que el sesgo puede ocurrir fácilmente sin que nadie se
percate de ello en el corto plazo.
Figura 2-5. Los dados están ahora claramente sesgada hacia números altos,
desde altas sumas oc- cur con mucha más frecuencia que baja las sumas.
Obtención de ayuda adicional

R también viene con un súper activa comunidad de usuarios a los que puede acudir para
obtener help on the R-help mailing list. Usted puede enviar un correo a la lista de preguntas,
pero hay una gran posibilidad de que su pregunta ya ha sido contestada. Averiguar
buscando en el archives.
Incluso mejor que el r-help lista Stack Overflow, es un sitio web que permite a los
programadores a contestar preguntas y usuarios para clasificar las respuestas
basadas en la amabilidad. Personalmente, me parece que el formato de
desbordamiento de la pila para que sea más fácil de utilizar que el r-help lista de
correo (y los encuestados para ser más favorable al ser humano). Puedes enviar
tus propias preguntas o buscar a través de un desbordamiento de pila previamente
respondió a preguntas relacionadas con R. Hay más de 30.000.
Por tanto el R lista de ayuda y el desbordamiento de la pila, es más probable que obtenga
una respuesta útil si proporcionan un ejemplo reproducible con tu pregunta. Esto significa
pegar en un breve fragmento de código que los usuarios pueden ejecutar para llegar al
error o pregunta que tenga en mente.
Resumen
R paquetes y páginas de ayuda puede hacer que un programador más productivo. Usted
vio en Chapter 1 que R le da la potencia para escribir sus propias funciones que hacen
cosas específicas, pero a menudo la función que desea escribir ya existirá en un paquete
de r. Profesores, programadores y científicos han desarrollado más de 5.000 paquetes para
usted
Resumen | 33
WWW .IT-EBOOKS.INFO
El uso, lo que permite ahorrar un valioso tiempo de programación. Para utilizar
un paquete que necesita instalar en su ordenador una vez
con install.packages, y, a continuación, cargarlos en cada nueva sesión
con R biblioteca.
R las páginas de ayuda le ayudarán a dominar las funciones que aparecen en
R y sus paquetes. Cada función y el conjunto de datos en R tiene su propia
página de ayuda. Aunque las páginas de ayuda a menudo contienen
contenido avanzado, también contienen valiosas ideas y ejemplos que le
pueden ayudar a aprender cómo utilizar una función.
Ya has visto lo suficiente de R para "aprender haciendo", que es el mejor camino
para aprender R. Puedes hacer tus propios comandos R, ejecutarlas y obtenga
ayuda cuando la necesite para entender algo que no he explicado. Os animo a
experimentar con sus propias ideas en R a medida que lea los dos próximos
proyectos.
Proyecto 1 Wrap-up
Has hecho más en este proyecto que permiten el fraude y juego; también ha
aprendido a hablar con su equipo en la lengua de R. R es un idioma como el
Inglés, Español o Alemán, excepto R le ayuda hablar con ordenadores, no los
seres humanos.
Te has encontrado los substantivos del lenguaje R, Objetos. Y esperemos que haya
adivinado que func- nes son los verbos (supongo que los argumentos de la función
serían los adverbios). Cuando se combinan las funciones y los objetos, puede
expresar un pensamiento completo. Por encadenar pensamientos juntos en una
secuencia lógica, usted puede construir elocuente, incluso las manifestaciones
artísticas. En este sentido, R no es diferente de cualquier otro idioma.
R comparte otra característica de los idiomas humanos: no se sentirá muy cómodo

hablando R hasta que construir un vocabulario de R comandos a utilizar. Afortunadamente,
usted no tiene que ser reservado. Su equipo será el único "oír" usted habla R. tu ordenador
no es muy indulgente, pero tampoco es el juez. No es necesario preocuparse; podrás
ampliar tu vocabulario R tremendamente entre aquí y el final del libro.
Ahora que puede utilizar R, es el momento de convertirse en un experto en el uso de R

para hacer ciencia de datos. Las bases de datos que la ciencia es la capacidad para
almacenar grandes cantidades de datos y recuperar los valores de demanda. A partir de
esto, todo lo demás sigue la manipulación de datos, visualización de datos, el modelado de
datos y mucho más. Sin embargo, no puede guardar fácilmente un conjunto de datos en tu
mente memorizando. Ni se puede almacenar fácilmente un conjunto de datos en papel por
escrito abajo. La única manera eficaz de almacenar grandes cantidades de datos con un
ordenador. De hecho, los equipos son tan eficientes que su desarrollo durante las últimas
tres décadas ha cambiado completamente el tipo de datos que se pueden acumular y los
métodos que podemos utilizar para analizar. En resumen, el almacenamiento de datos
informáticos ha impulsado la revolución en la ciencia que llamamos Ciencia de datos.
Part II Le harán parte de esta revolución por enseñar cómo utilizar R para almacenar
conjuntos de datos en la memoria del ordenador y cómo recuperar y manipular los datos
una vez allí.
WWW .IT-EBOOKS.INFO
Parte II
Proyecto 2: Juegos de
Cartas
Este proyecto, que abarca los próximos cuatro capítulos, le enseñará a almacenar,
recuperar y cambiar los valores de los datos en la memoria del ordenador. Estas
habilidades le permitirán guardar y administrar datos sin acumular errores. En el
proyecto, deberá diseñar una baraja de cartas que se pueden mezclar y tratar de.
Lo mejor de todo, la plataforma hará recordar qué cartas han sido repartidas, al
igual que una baraja real. Puede utilizar la plataforma para jugar juegos de cartas,
decir la fortuna, y probar estrategias de contar las tarjetas.
A lo largo del camino, usted aprenderá a:
• Guardar los nuevos tipos de datos, como cadenas de caracteres y

valores lógicos
• Guardar un conjunto de datos como un vector, matriz, lista, matriz o
trama de datos
• Cargar y guardar sus propios conjuntos de datos con R
• Extraer los valores individuales de un conjunto de datos
• Cambiar valores individuales dentro de un conjunto de datos
• Escribir pruebas lógicas
• Utilice R falta-símbolo de valor, NA
Para mantener el proyecto simple, he dividido en cuatro tareas. Cada tarea

te enseñará nuevas habilidades para la gestión de datos con R:
Tarea 1: construir la plataforma
En Chapter 3, tendrás que diseñar y construir una baraja de cartas virtuales. Este
será un conjunto completo de datos, como los que va a utilizar como un dato
científico. Necesitará saber cómo utilizar R de los tipos de datos y estructuras de
datos para realizar este trabajo.
WWW .IT-EBOOKS.INFO
Tarea 2: escribir funciones que ocupan y shuffle
Siguiente, en la Chapter 4que escribirá dos funciones para su uso con la
plataforma. Una función tratará las cartas de la baraja, y el otro va a reorganizar
la baraja. Para escribir estas funciones, usted necesitará saber cómo extraer los
valores de un conjunto de datos con R.
Tarea 3: cambiar el sistema de puntos para adaptarse a tu juego

En Chapter 5, se utilizará el sistema de notación R para cambiar los valores
del punto de tus cartas para coincidir con los juegos de cartas que quieran
desempeñar, como la guerra, corazones, o Blackjack. Esto le ayudará a
cambiar valores en lugar de los conjuntos de datos existentes.
Tarea 4: administrar el estado de la cubierta
Por último, en Chapter 6, asegúrese de que la cubierta recuerda que las tarjetas
se ha ocupado. Esta es una tarea avanzada, y se introducirá el entorno R sistema
y reglas de ámbito. Para hacerlo correctamente, usted tendrá que aprender los
detalles de cómo R busca y utiliza los datos que ha almacenado en su equipo.
WWW .IT-EBOOKS.INFO
Capítulo 3
R objetos
En este capítulo, podrá utilizar r para montar una baraja de 52 cartas.

Empezarás por la construcción simple R objetos que representan los naipes y
después trabajar su manera hasta una completa tabla de datos. En breve,
podrá construir el equivalente de una hoja de cálculo de Excel desde cero.
Cuando haya terminado, la baraja de cartas se verá algo como esto:
Cara Valor palo
Rey de picas 13
Reina picas 12
Jack picas 11
Diez picas 10
Nueve picas 9
8 picas 8
...
¿Necesita crear un conjunto de datos desde cero para usarlo en el r? No, en absoluto.
Puede cargar la mayoría de conjuntos de datos en R con un único y sencillo paso,
consulte “Loading Data” on page 57. Pero este ejercicio te enseñará cómo R almacena
los datos y cómo se puede armar o desarmar a sus propios conjuntos de datos.
También conocerá los distintos tipos de objetos disponibles para su uso en R R (no
todos los objetos son los mismos!). Consideramos que este ejercicio un rito de pasaje;
al hacerlo, se convertirá en un experto en almacenamiento de datos en R.
Vamos a empezar con lo básico. El tipo más simple de objeto en R es

un atómico vector. Los vectores no se nuclear atómica Powered, pero son
muy sencillos y no aparecen por todas partes. Si se mira con suficiente
atención, verá que la mayoría de las estructuras R se construyen a partir de
vectores atómica.
37
WWW .IT-EBOOKS.INFO
Vectores atómica
Un vector atómico es simplemente un vector de datos. De hecho, ya has hecho
un vector atómico, su objeto de morir Part I. Usted puede hacer un vector
atómica mediante la agrupación de algunos valores de datos junto con c:
Die <- c(1, 2, 3, 4, 5, 6)
Die
## 1 2 3 4 5 6
Es.vector(die)
## TRUE
Es.vector comprueba si un objeto es un vector atómico.

Devuelve TRUE si el objeto es un vector atómico y FALSE en caso
contrario.
Usted también puede hacer un vector atómico con un solo valor. R guarda
valores individuales como un vector de longitud atómica 1:
Cinco <- 5
Cinco
## 5
Es.vector(5)
## TRUE
Longitud(5)
## 1
Longitud(die)
## 6
Longitud
Length devuelve la longitud de un vector atómico.
Cada vector atómico almacena sus valores como un vector unidimensional, y cada
vector atómico sólo puede almacenar un tipo de datos. Se pueden guardar distintos
tipos de datos en R utilizando diferentes tipos de vectores atómica. En total, R
reconoce seis tipos básicos de vectores
atómica: dobles, enteros, personajes, logicals, compleja, y materias.
Para crear tu baraja de cartas, tendrá que utilizar diferentes tipos de vectores
atómica para guardar distintos tipos de información (texto y números). Puede
hacerlo mediante unas sencillas convenciones cuando introduzcas tus datos. Por
ejemplo, puede crear un vector por entero incluyendo un capital L con su entrada.
Puede crear un vector de caracteres por surround- ing su entrada en comillas:
38 | Capítulo 3: Objetos R
WWW .IT-EBOOKS.INFO
Int <- 1L
Texto <- "ACE"
Cada tipo de vector atómica tiene su propio convenio (descrito a continuación).

R reconocerá la convención y utilizarlo para crear un vector atómico del tipo
apropiado. Si a usted le gustaría hacer atómica vectores que tiene más de un
elemento en ellos, puede combinar un elemento con la función c de Chapter
2. Utilizar el mismo convenio con cada elemento:
Int <- c(1L, 5L).
Texto <- c("Ace", "corazones").
Puede que te preguntes por qué R utiliza varios tipos de vectores. Tipos de
vectores ayuda R se comportan como se espera que lo haga. Por ejemplo, R
podrán hacer operaciones matemáticas con atomic Vectores que contienen
num- bers, pero no con atomic Vectores que contienen cadenas de caracteres:
Sum(num)
## 6
Sum(texto)
## Error en suma(texto) : 'tipo' no válida (carácter) del argumento
Pero estamos consiguiendo delante de nosotros! Prepárese para decir hola a

los seis tipos de vectores atómica en R.
Dobles
Un doble vector almacena números regulares. Los números pueden ser
positivos o negativos, grandes o pequeñas, y tienen dígitos a la derecha del
decimal o no. En general, R guardará cualquier número que escriba R como
una doble. Así, por ejemplo, la matriz se hizo en Part I fue un doble objeto:
Die <- c(1, 2, 3, 4, 5, 6)
Die
## 1 2 3 4 5 6
Lo más probable es saber qué tipo de objeto con el que está trabajando en R (es
obvio), pero también puede pedirle a R qué tipo de objeto es un objeto con typeof.
Por ejemplo:
Typeof(die)
## "Double"
Algunos R las funciones se refieren a valores numéricos, como "dobles" y voy

a menudo a hacer lo mismo. Doble es un término de informática. Se refiere a
la cantidad de bytes que usa su ordenador para almacenar un número, pero
me parece "Numérico" para ser mucho más intuitiva de datos al hacer ciencia.
Vectores atómica |
39
WWW .IT-EBOOKS.INFO
Enteros
Vectores enteros almacenar números enteros, números que pueden
escribirse sin decimales componente. Como un dato científico, no podrá
utilizar el tipo integer muy a menudo porque puede guardar números enteros
como un doble objeto.
Puede crear específicamente un entero en R escribiendo un número seguido de una letra
mayúscula
L. Por ejemplo:
Int <- c(-1L, 2L, 4L).
Int
## -1 2 4
Typeof(int).
## "Integer"
Tenga en cuenta que R no guarda un número como un número entero, a menos que se
incluya la L. Números enteros sin la L se guardará como dobles. La única diferencia
entre 4 y 4L es cómo R guarda el número en la memoria del ordenador. Los números
enteros se definen con más precisión en la memoria del ordenador que se duplica (a menos
que el entero es muy grande o pequeña).
¿Por qué habría de guardar los datos como un entero en lugar de una doble? A veces una
diferencia de precisión puede tener efectos sorprendentes. El ordenador asigna 64 bits de
memoria para almacenar cada doble R en un programa. Esto permite mucha precisión,
pero algunos números no se pueden expresar exactamente en 64 bits, el equivalente de
una secuencia de 64 unos y ceros. Por ejemplo, el número π contiene una infinidad de
secuencias de dígitos a la derecha del decimal. Su equipo debe ronda π a algo parecido,
pero no exactamente igual a π π para almacenar en su memoria. Muchos números
decimales comparten un destino similar.
Como resultado, cada doble tiene una precisión de aproximadamente 16 dígitos

significativos. Esto introduce un poco de error. En la mayoría de los casos, este
error de redondeo pasará inadvertido. Sin embargo, en algunas situaciones, el
error de redondeo puede causar resultados sorprendentes. Por ejemplo, usted
puede esperar el resultado de la expresión inferior a cero, pero no lo es:
Sqrt(2)^2 - 2
## 4.440892E-16
La raíz cuadrada de dos no se puede expresar exactamente en 16 dígitos

significativos. Como resultado, R tiene para redondear la cantidad, y la
expresión se resuelve a algo muy parecido, pero no exactamente igual a cero.
Estos errores se conocen como errores de coma flotante, y hacer
operaciones aritméticas en estas condiciones se conoce como aritmética de
punto flotante. Aritmética de punto flotante no es una característica de R; es
una característica de la programación de computadoras. Normalmente los
errores de coma flotante no será lo suficiente como para arruinar tu día.
Simplemente tenga en cuenta que pueden ser la causa de resultados
sorprendentes.
Puede evitar errores de punto flotante evitando los decimales y usando sólo números
enteros. Cómo- nunca, esta no es una opción en la mayoría de los datos de la ciencia de
las situaciones. No se puede hacer mucho con las matemáticas
WWW .IT-EBOOKS.INFO
Con enteros antes de que usted necesita un valor que no sea entero para
expresar el resultado. Afortunadamente, los errores provocados por la
aritmética de punto flotante son generalmente insignificantes (y cuando no lo
son, son fáciles de detectar). Como resultado, normalmente usará en dobles
en lugar de números enteros como un dato científico.
Caracteres
Un vector de caracteres almacena pequeños fragmentos de texto. Puede crear un
vector de caracteres en R escribiendo un carácter o cadena de caracteres entre
comillas:
Texto <- c("Hola", "Mundo").
Texto
## "Hola" "Mundo"
Typeof(texto)
## "Character"
Typeof("Hola")
## "Character"
Los elementos individuales de un vector de caracteres son conocidos

como cadenas. Tenga en cuenta que una cadena puede contener algo más
que letras. Puede montar una cadena de caracteres de números o símbolos.
Ejercicio
Puede detectar la diferencia entre una cadena de caracteres y un número? Aquí hay
una prueba:
Cuáles de estas son cadenas de caracteres y cuales son los
números? 1, "1", "uno".
"1" y "1" son cadenas de caracteres. Cadenas de caracteres puede contener

varios acters char -, pero que no los valores numéricos. Son simplemente cadenas
que tienen números en ellos. Usted puede decirle a cadenas de números reales,
porque las cadenas vienen sur- rodeado por comillas. De hecho, todo rodeado por
comillas en R será tratada como una cadena de caracteres, sin importar lo que aparece
entre comillas.
Es fácil confundir R objetos con cadenas de caracteres. ¿Por qué? Porque

ambos aparecen como fragmentos de texto en código R. Por ejemplo, x es el
nombre de una R objeto denominado "x", "x" es una cadena de caracteres
que contiene el carácter "x". Uno es un objeto que contiene los datos brutos,
el otro es un pedazo de datos raw.
Esperar un error siempre se olvida de su comillas; R comenzará buscando un
objeto que probablemente no existe.
Vectores atómica |
41
WWW .IT-EBOOKS.INFO
Logicals
Almacenar vectores lógicos TRUEy FALSES, R la forma de datos booleanos.
Logicals son muy útiles para hacer las cosas como las comparaciones:
3 > 4
## FALSE
Cada vez que escriba TRUE o FALSE en letras mayúsculas (sin las comillas), R tratará su
entrada como lógica de datos. R también asume que T y F son un atajo
para verdadero y
Falso:
Logic <- c(True, False True)
Logic
## Verdadero FALSO VERDADERO
Typeof(Logic)
## "Lógica"
Typeof(F)
## "Lógica"
Complejo y materias
Se duplica, enteros, caracteres y logicals son los tipos más comunes de atomic vectores
en R, pero R también reconoce dos tipos más: compleja y cruda. Es dudoso que usted
nunca podrá utilizar estos datos para analizar, pero aquí están en aras de la exhaustividad.
Vectores complejos almacenar números complejos. Para crear un vector

complejo, agregar un término imaginario a un número con i:
Comp <- c(1 + 1i, 1 + 2i, 1 + 3i)
Comp
## 1+1i 1+2i 1+3i
Typeof(comp.)
## "Complejo".
Almacén de materias materias vectores de bytes de datos. Hacer materias

vectores se complica, pero usted puede hacer un vacío materias vector de
longitud n con raw(n). Consulte la página de ayuda de materias para más
opciones a la hora de trabajar con este tipo de datos:
Raw(3).
## 00 00 00
Typeof(raw(3)).
## "Raw"
WWW .IT-EBOOKS.INFO
Ejercicio
Crear un vector atómico que almacena sólo la cara nombres de las tarjetas en una escalera
real, por ejemplo, el As de espadas, Rey de picas, la reina de picas, jota de picas, y diez de
picas. La cara nombre del as de picas sería "Ace" y "picas" es el traje.
Qué tipo de vector se puede utilizar para guardar los nombres?
Un vector de caracteres es el tipo más apropiado de vector atómico en la que

guardar los nombres en las tarjetas. Puede crear uno con la función c si rodea
cada nombre con comillas:
<- mano c("Ace", "el rey", la "reina", "jack", "diez").
Mano
## "Ace" "El rey" "Reina" "jack" "Diez"
Typeof(mano)
## "Character"
Esto crea un grupo unidimensional de los nombres en las tarjetas-gran trabajo!

Ahora vamos a hacer una estructura de datos más sofisticados, una tabla de
dos dimensiones de los nombres en las tarjetas y trajes. Puede crear un objeto
más sofisticado de un vector atómico dando algunos atributos y asignarle una
clase.
Atributos
Un atributo es un fragmento de información que puede adjuntar a un vector atómico (o
cualquier objeto R). El atributo no afectará ninguno de los valores en el objeto, y no
aparecerá cuando se muestra el objeto. Se puede pensar en un atributo como
"metadatos"; simplemente es un lugar adecuado para colocar la información asociada
con un objeto. R Se suele omitir estos metadatos, pero algunas funciones R verificará
para atributos específicos. Estas funciones pueden utilizar los atributos para hacer
cosas especiales con los datos.
Puede ver los atributos que tiene un objeto

con atributos. Atributos devolverá NULL si un objeto no tiene atributos.
Un vector atómico, como die, no tiene atributos a menos que le dé algunos:
Atributos(die)
## NULL
NULL
R Utiliza null para representar el conjunto nulo, un objeto
vacío. NULL es a menudo devueltos por funciones cuyos valores
son indefinidos. Puede crear un objeto NULL NULL
escribiendo en mayúsculas.
Atributos | 43
WWW .IT-EBOOKS.INFO
Nombres
La mayoría de los atributos comunes para dar un vector atómico son nombres,
dimensiones (DIM), y clases. Cada uno de estos atributos tiene su propia función
auxiliar que puede utilizar para dar atributos a un objeto. También puede utilizar
las funciones auxiliares para buscar el valor de estos atributos para objetos que
ya cuentan con ellos. Por ejemplo, puede buscar el valor del atributo nombres
de morir con nombres:
Nombres(die)
## NULL
NULL significa que morir no tienen un atributo de nombres. Puede dar uno
a morir por como- firma un vector de caracteres para la salida de nombres.
El vector debe incluir un nombre para cada elemento de morir:
Nombres(die) <- c("uno", "dos", "tres", "cuatro", "cinco", "seis").
Mueren ahora tiene un atributo nombres:

Nombres(die)
## "Uno"."Dos" "Tres", "cuatro" "Cinco" "Seis"
Atributos(die)
## $names
## [1] "uno", "dos", "tres", "cuatro", "cinco", "seis"
R mostrará los nombres por encima de los elementos de la matriz cuando se mira
el vector:
Die
## Uno Dos tres Cuatro Cinco Seis
## 1 2 3 4 5 6
Sin embargo, los nombres no afectan a los valores reales del vector, ni los
nombres se ven afectados cuando se manipulan los valores del vector:
Die + 1
Cuatr Sei
## Uno Dos Tres o Cinco s
## 2 3 4 5 6 7
También puede utilizar nombres para cambiar los nombres de atributo o

Quitar todo junto. Para cambiar los nombres, asigne un nuevo conjunto de
etiquetas de nombres:
Nombres(die) <- c("uno", "dos", "tres", "Quatro", "El
Abuelo", "seis")
Die
## La onu Dos Tres quatro Cinco Seis
## 1 2 3 4 5 6
Para quitar los nombres de atributo establecido en Nulo:

Nombres(die) <- NULL
Die
## 1 2 3 4 5 6
WWW .IT-EBOOKS.INFO
Dim
Puede transformar un vector atómico en una matriz de n dimensiones dándole una
dimensiones atributo con dim. Para ello, establezca el atributo numérico dim a un vector
de longitud n. R podrán reorganizar los elementos del vector en n dimensiones. Cada
dimensión tendrá tantas filas o columnas, etc.) como el valor de la enésima dim vector.
Por ejemplo, puede reorganizar mueren en una matriz de 2 × 3 (que tiene 2 filas y 3
columnas):
Dim(die) <- c (2, 3).
Die
## [,1] [,2] [,3].
## [1] 1 3 5
## [2] 2 4 6
O una matriz de 3 × 2 (que tiene 3 filas y 2 columnas):

Dim(die) <- c (3, 2).
Die
## [,1] [,2]
## [1] 1 4
## [2] 2 5
## [3] 3 6
O un 1 × 2 × 3 hypercube (que tiene 1 filas, 2 columnas y 3 "rebanadas"). Esta

es una estructura tridimensional, pero R tendrá que demostrar que corte a
corte a corte en su pantalla de ordenador de dos dimensiones:
Dim(die) <- c(1, 2, 3).
Die
## , 1
##
## [,1] [,2]
## [1] 1 2
##
## , 2
##
## [,1] [,2]
## [1] 3 4
##
## , 3
##
## [,1] [,2]
## [1] 5 6
R siempre usará el primer valor de dim para el número de filas y el segundo

valor para el número de columnas. En general, las filas siempre vienen
primero en R las operaciones que tratan con filas y columnas.
Usted puede notar que no tiene mucho control sobre cómo R reorganiza los valores en filas
y columnas. Por ejemplo, R siempre se llena cada matriz por columnas en lugar de filas. Si
desea más control sobre este proceso, puede utilizar uno de los R's helper
Atributos | 45
WWW .IT-EBOOKS.INFO
Funciones, matriz o array. Ellos hacen la misma cosa como cambiar
el atributo de dim, pero proporcionan argumentos adicionales para
personalizar el proceso.
Matrices
Matrices de almacenar valores en una matriz bidimensional, como una matriz
de lineal alge- bra. Para crear una matriz, primero debe indicar un
vector atómico para reorganizar en una matriz. A continuación, defina cuántas
filas deben estar en la matriz nrow estableciendo el argumento en un
número. Matrix organizará su vector de valores en una matriz con el número
especificado de filas. Alternativamente, puede establecer el argumento ncol
R, que indica el número de columnas que desea incluir en la matriz:
M <- matrix(die, nrow = 2).
M
## [,1] [,2] [,3].
## [1] 1 3 5
## [2] 2 4 6
Matrix permitirá llenar la matriz columna por columna por defecto, pero
puede rellenar la matriz fila por fila si se incluye el argumento byrow=TRUE:
M <- matrix(die, nrow = 2, byrow = TRUE)
M
## [,1] [,2] [,3].
## [1] 1 2 3
## [2] 4 5 6
Matrix también tiene otros argumentos predeterminados que se pueden utilizar para
personalizar su matriz. Usted puede leer acerca de ellos en la matriz's página de
ayuda (accesible por ?Matrix).
Las matrices
La función array crea una matriz n-dimensional. Por ejemplo, usted podría usar ar
ray para ordenar los valores en un cubo de tres dimensiones o un hypercube en 4, 5
o n dimensiones. array no es como puede adaptar como matrix y básicamente hace
lo mismo que estableciendo el atributo dim. Para utilizar array, proporcionan un vector
atómico como el primer argumento, y un vector de dimensiones como el segundo
argumento, ahora llamado dim:
Ar <- array(c(11: 21: 14 ,24, 31:34), dim = c(2, 2, 3)).
Ar
## , 1
##
## [,1] [,2]
## [1] 11 13
## [2] 12 14
##
## , 2
##
WWW .IT-EBOOKS.INFO
## [,1] [,2]
## [1] 21 23
## [2] 22 24
##
## , 3
##
## [,1] [,2]
## [1] 31 33
## [2] 32 34
Ejercicio
Cree la siguiente matriz, en la que almacena el nombre y el traje de cada
tarjeta en un royal flush.
## [,1]. [,2]
## [1] "Ace" "picas"
## [2] "rey" "picas"
## [3], "reina" "picas"
## [4], "jack" "picas"
## [5] "diez" "picas"
Hay más de una manera de construir esta matriz, pero, en todo caso, necesitará comenzar
haciendo un vector de caracteres con 10 valores. Si comienza con el siguiente carácter
vectorial, puede convertirlo en una matriz con cualquiera de los siguientes tres comandos:
Parte c1 <-("Ace", "el rey",
la "reina", "jack", "diez", "picas", "picas", "picas",
"picas", "picas")
Matrix(parte1, nrow = 5).

Matrix(parte1, Ncol = 2).
Dim(parte1) <- c (5, 2)
También puede iniciar con un vector de caracteres que enumera las tarjetas
en un orden ligeramente diferente. En este caso, necesitará pedir R para
rellenar la matriz fila por fila en lugar de la columna por columna:
Parte c2 <-
("Ace", "picas", "rey", "picas", "reina", "picas", "jack",
"picas", "diez", "picas")
Matrix(parte2, nrow = 5, byrow = TRUE)

Matrix(parte2, Ncol = 2, byrow = TRUE)
La clase
Observe que al cambiar las dimensiones del objeto no cambiará el tipo de
objeto, pero va a cambiar el atributo de clase del objeto:
La clase |
47
WWW .IT-EBOOKS.INFO
Dim(die) <- c (2, 3).
Typeof(die)
## "Double"
Clase(die)
## "Matrix"
Una clase es un caso especial de vector atómico. Por ejemplo, el chip matrix es
un caso especial de un doble vector. Cada elemento de la matriz es todavía una
doble, pero los elementos han sido ordenados en una nueva estructura. R añade
un atributo class a morir cuando cambió sus dimensiones. Esta clase
describe morirde nuevo formato. Muchas funciones de r buscar específicamente
un atributo de clase del objeto y, a continuación, manipular el objeto en un modo
predeterminado basado en el atributo.
Tenga en cuenta que un atributo de clase del objeto no siempre aparece

cuando ejecute atributos; puede que necesite buscar específicamente con
la clase:
Atributos(die)
## $dim
## [1] 2 3
Puede aplicar la clase de objetos que no tienen un atributo de clase. Clase devolverá un
valor basado en el objeto de tipo atómico. Observe que la "clase" de un doble es "numérico",
una extraña desviación, pero estoy agradecido. Creo que la propiedad más importante de
un doble vector es que contiene números, una propiedad que "Numérico" hace evidente:
Clase("Hola").
## "Carácter"
Clase(5).
## "Numérico"
También puede utilizar la clase para definir un atributo de clase del objeto, pero esto
generalmente es una mala idea. R esperan que los objetos de una clase comparten ciertas
características comunes, tales como los atributos que el objeto puede no poseer.
Aprenderá cómo crear y utilizar sus propias clases en Part III.
Fechas y horas
El atributo system permite R representan más tipos de datos que se duplica, enteros, caracteres
logicals, complejos y raws. Por ejemplo, R utiliza una clase especial para representar fechas y
horas. Para ver esto, ejecute Sys.time(). Sys.time devuelve la hora actual en el equipo. El
tiempo parece como una cadena de caracteres cuando se muestran, pero su tipo de datos es
en realidad "doble", y su clase es "POSIXct" "POSIXt" (que tiene dos clases):
Ahora <- Sys.time()
Ahora
## "2014-03-17 12:00:00 UTC"
Typeof(ahora)
## "Double"
WWW .IT-EBOOKS.INFO
Clase(ahora)
## "POSIXct" "POSIXt"
POSIXct se utiliza ampliamente como un marco para la representación de fechas y tiempos.

En el marco POSIXct, cada vez está representado por el número de segundos que han
pasado entre la hora y las 12:00 AM el 1 de enero de 1970 (en el Tiempo Universal
Coordinado (UTC) zona). Por ejemplo, la vez anterior se produce 1,395,057,600 segundos
después. Así, en el sistema POSIXct, el tiempo se guardarán como 1395057600.
R crea el objeto de tiempo mediante la creación de un doble vector con un

elemento, 1395057600. Usted puede ver este vector quitando el atributo
class de ahora, o utilizando la función de la clase de la ONU, que hace la
misma cosa:
Unclass(ahora)
## 1395057600
R entonces da el doble vector un atributo de clase que contiene dos

clases, "POSIXct" y "POSIXt". Este atributo alertas R funciones que están tratando con
un tiempo POSIXct, a fin de que puedan tratar de manera especial. Por ejemplo, R
funciones utilizará el estándar POSIXct para convertir el tiempo en una cadena de
caracteres descriptivos antes de mostrarla.
Usted puede tomar ventaja de este sistema dando la clase POSIXct al azar
R objetos. Por ejemplo, ¿se ha preguntado alguna vez qué día era de un millón
de segundos después de las 12:00 a.m. del 1 de enero de 1970?
Mil <- 1000000
Mil
## 1e+06
Clase(mil) <- c("POSIXct", "POSIXt")

Mil
## "1970-01-12 13:46:40 UTC"
Ene. 12, 1970. Yikes. Un millón de segundos pasa más rápido de lo que usted
podría pensar. Este timo- versión funcionaba bien porque la clase POSIXct no
depende de los atributos adicionales, pero en general, obligando a la clase de un
objeto es una mala idea.
Hay muchas diferentes clases de datos en R y sus paquetes, y se inventan nuevas

clases cada día. Sería difícil aprender acerca de cada clase, pero no es necesario.
La mayoría de las clases son útiles sólo en situaciones específicas. Dado que
cada clase cuenta con su propia página de ayuda, usted puede esperar para
aprender acerca de una clase hasta que encuentres. Sin embargo, hay una clase
de datos que es tan omnipresente en R que usted debe aprender sobre él junto
con los tipos de datos atómicos. Factores de esa clase es.
Factores
Los factores son R la forma de almacenar información categórico, como el origen étnico o
el color de los ojos. Pensar en un factor como algo parecido a un género; sólo puede tener
ciertos valores (masculinos o femeninos),
La clase |
49
WWW .IT-EBOOKS.INFO
Y estos valores puede tener su propio orden idiosincrásicas (las damas
primero). Este arreglo hace factores muy útiles para el tratamiento de los
niveles de grabación de un estudio y otras cate- gorical variables.
Hacer un factor, pasar un vector atómico en el factor función. R se recodifica los
datos en el vector como enteros y almacenar los resultados en un vector de enteros.
R también añadir un atributo a los niveles enteros, la cual contiene un conjunto de
etiquetas para mostrar los valores del factor, y un atributo de clase, que contiene
el factor de clase:
<- factor de
género(c("masculinas"o "femeninas", "femenino", "macho")).
Typeof(sexo)
## "Integer"
Atributos(sexo)
## Los niveles de dólares
## [1] "femenino" o "masculino"
##
## $class
## [1] "factor"
Usted puede ver exactamente cómo R está almacenando su factor

con unclass:
Unclass(sexo)
## [1] 2 1 1 2
## Attr("niveles")
## [1] "femenino" o "masculino"
R utiliza el atributo niveles cuando se muestra el factor, como verás. R mostrará

cada 1 como hembra, la primera etiqueta en los niveles de vectores, y
cada 2 como macho, la segunda etiqueta. Si el factor incluido 3s, se mostrarían como la
tercera etiqueta, y así sucesivamente:
Género
## Macho Hembra hembra macho
## Niveles: femenino masculino
Factores que hacen que sea fácil de poner las variables categóricas en un
modelo estadístico porque las variables ya están codificadas como números.
Sin embargo, factores puede ser confuso ya que lucen como cadenas de
caracteres, pero se comportan como números enteros.
R tratan frecuentemente para convertir cadenas de caracteres a factores cuando carga
y crear datos. En general, usted tendrá una experiencia más suave si no deja R
factores hacen hasta que pregunte por ellos. Te mostraré cómo hacer esto cuando
comenzamos la lectura de datos.
Puede convertir un factor a una cadena de caracteres con

el como.carácter función. R conservará la versión de visualización del factor, no
los enteros almacenados en la memoria:
As.character(sexo)
## "Machos" "Hembra" "femenino" o "masculino"
WWW .IT-EBOOKS.INFO
Ahora que conoce las posibilidades previstas por R vectores atómicos,
hagamos un tipo más complicadas del juego de cartas.
Ejercicio
Muchos juegos de cartas asignar un valor numérico a cada tarjeta. Por ejemplo, en el
blackjack, cada cara de la tarjeta vale 10 puntos, cada número tarjeta valga entre 2 y
10 puntos, y cada as vale 1 o 11 puntos, dependiendo de la puntuación final.
Hacer un juego de cartas virtuales combinando "Ace", el "corazón", y 1 en un

vector. ¿Qué tipo de vector atómico tendrá como resultado? Compruebe si es
correcto.
Puede haber adivinado que este ejercicio no iría bien. Cada vector atómico sólo puede
almacenar un tipo de datos. Como resultado, R convierte todos sus valores para las
cadenas de caracteres:
Card <- c("Ace", "corazones", 1)
Card
## "Ace" "Corazones" "1"
Esto puede causar problemas si desea realizar operaciones matemáticas con

ese punto de valor, por ejemplo, para ver quién ganó el juego de blackjack.
Los tipos de datos de vectores

Si intenta poner varios tipos de datos en un vector, R
convertir los elementos a un solo tipo de datos.
Desde matrices y matrices son casos especiales de vectores atómico, sufren

el mismo comportamiento. Cada uno sólo puede almacenar un tipo de datos.
Esto crea un par de problemas. Primero, muchos conjuntos de datos contienen
varios tipos de datos. Los programas simples como Excel y números puede
guardar varios tipos de datos en el mismo conjunto de datos, y usted debe esperar
que r puede también. No se preocupe, puede hacerlo.
Segundo, la coacción es un comportamiento común en R, por lo que deseará saber
cómo funciona.
La coacción
R coerción comportamiento puede parecer un inconveniente, pero no es arbitraria.
R siempre sigue las mismas reglas cuando convierte los tipos de datos. Una vez
que se haya familiarizado con estas reglas, puede utilizar R coerción
comportamiento sorprendentemente a hacer cosas útiles.
Entonces, ¿cómo R coaccionar a tipos de datos? Si una cadena de caracteres está
presente en un vector atómico, R convertir todo lo demás en el vector de cadenas de
caracteres. Si un vector sólo contiene
La coacción
| 51
WWW .IT-EBOOKS.INFO
Logicals y números, R convertirá el logicals a números; cada verdadero se
convierte en un 1, y toda falsa se convierte en un 0, como se muestra en
la Figure 3-1.
Figura 3-1. R siempre utiliza las mismas reglas para obligar a un solo tipo de
datos. Si las cadenas de caracteres están presentes, todo va a ser forzado a
una cadena de caracteres. De lo contrario, logicals son obligados a valores
numéricos.
Este acuerdo conserva la información. Es fácil mirar a una cadena de

caracteres y decirle qué información se utiliza para contener. Por ejemplo,
puede ver fácilmente el origen de la "verdadera" y "5". También puede
hacer copias de seguridad de un vector de transformación de 1s y 0s
en TRUEy FALSE.
R utiliza las mismas reglas de coerción cuando intenta realizar operaciones
matemáticas con los valores lógicos. Por lo que el siguiente código:
Sum(c(True True, False False)).
Será:
Sum(c(1, 1, 0, 0)).
## 2
Esto significa que la suma contará el número de verdadeross en un vector

(lógica y calcular la proporción media de ciertos). Aseado, ¿eh?
Usted puede preguntar expresamente a R para convertir datos de un tipo a otro con
el como funciones.
R convertirá los datos cuando hay una forma razonable de hacerlo:
WWW .IT-EBOOKS.INFO
As.character(1).
## "1"
As.lógico(1).
## TRUE
As.numeric(FALSE)
## 0
Ahora ya sabe cómo R convierte los tipos de datos, pero esto no le ayudará a
ahorrar un naipe. Para ello, será necesario evitar la coacción por completo.
Usted puede hacer esto mediante el uso de un nuevo tipo de objeto, una lista.
Antes de mirar las listas, vamos a abordar una cuestión que pueda estar en
tu mente.
Muchos de los conjuntos de datos contienen varios tipos de información. La
incapacidad de los vectores, matrices y matrices para almacenar varios tipos
de datos parece una limitación importante. Entonces, ¿por qué molestarse con
ellos?
En algunos casos, el uso de un único tipo de datos es una enorme ventaja. Vectores,
matrices y matrices hacen que sea muy fácil de hacer matemáticas en grandes conjuntos
de números porque R sabe que puede manipular cada valor de la misma manera.
Operaciones con vectores, matrices y matrices también tienden a ser rápida porque los
objetos son tan simples para almacenar en la memoria.
En otros casos, permitiendo que un único tipo de datos no es una desventaja. Los vectores
son los más comunes en la estructura de datos R porque almacenar variables muy bien.
Cada valor en una variable que mide la misma propiedad, por lo que no hay necesidad de
usar diferentes tipos de datos.
Listas
Las listas son como vectores atómica porque agrupar los datos en un conjunto
unidimensional. Cómo- nunca, listas no agrupar los valores individuales; las listas agrupar
R objetos como vectores atómica y otras listas. Por ejemplo, puede hacer una lista que
contenga un numeric vector de longitud 31 en su primer elemento, un vector de caracteres
de longitud 1 en su segundo elemento, y una nueva lista de longitud 2 en su tercer
elemento. Para ello, utilice la función de lista.
Lista crea una lista, de la misma manera c crea un vector. Separar cada
elemento de la lista con una coma:
Lista1 <- list(100:130, "R", list(True, False)).
Lista1
## [[1]]
## [1] 100 101 102 103 104 105 106 107 108 109 110 111 112
## [14] 113 114 115 116 117 118 119 120 121 122 123 124 125
## [27] 126 127 128 129 130
##
## [[2]]
## [1] "R"
##
Listas |
53
WWW .IT-EBOOKS.INFO
## [[3]]
## [[3]][[1]]
## [1] TRUE
##
## [[3]][[2]]
## [1] falsa
Salí de la notación [1] en la salida para que pueda ver cómo cambia para las listas. El
doble de los índices entre corchetes decirle qué elemento de la lista que se visualiza. El
único soporte de índices decirles que el subelemento de un elemento se está mostrando.
Por ejemplo, 100 es el primer subelemento del primer elemento de la lista. "R" es el
primer elemento secundario del segundo elemento. Este sistema de notación dos surge
porque cada elemento de una lista puede ser cualquier objeto R, incluyendo un nuevo
vector (o lista) con sus propios índices.
Las listas son un tipo de objeto en R, a la par con atomic vectores. Como vectores atómico,
son utilizados como bloques de construcción para crear muchos más tipos de objetos
spohisticated R.
Como puede imaginar, la estructura de las listas puede ser bastante

complicado, pero este flex- ibility listas hace una útil herramienta de
almacenamiento multiuso en R: Puede agrupar cualquier cosa con una lista.
Sin embargo, no toda lista debe ser complicado. Puede guardar un juego de
cartas en una simple lista.
Ejercicio
Utilice una lista para almacenar un solo juego de cartas, como el as de
corazones, que tiene un valor del punto de uno. La lista debe salvar la cara de
la tarjeta, el traje, y el valor del punto en elementos separados.
Usted puede crear su tarjeta como esta. En el ejemplo siguiente, el primer

elemento de la lista es un vector de caracteres de longitud (1). El segundo
elemento es también un vector de caracteres, y el tercer elemento es un vector
numérica:
Card <- list("Ace", "corazones", 1)
Card
## [[1]]
## [1] "ACE"
##
## [[2]]
## [1] "corazones"
##
## [[3]]
## [1] 1
También puede utilizar una lista para almacenar toda una baraja de cartas. Ya puede
guardar un único juego de cartas como una lista, puede guardar una baraja de cartas
como una lista de 52 sublistas (uno para
WWW .IT-EBOOKS.INFO
Cada tarjeta). Pero no vayamos a molestar, hay una forma mucho más clara
para hacer la misma cosa. Puede utilizar una clase especial de lista, conocida
como una trama de datos.
Las tramas de datos

Las tramas de datos son la versión bidimensional de una lista. Ellos son, de lejos,
la estructura de almacenamiento de los más útiles para el análisis de datos, y
proporcionan una manera ideal para almacenar toda una baraja de cartas. Se
puede pensar en una trama de datos como R es equivalente a la hoja de cálculo
de Excel porque almacena los datos en un formato similar.
Las tramas de datos de vectores de grupo juntos en una tabla de dos

dimensiones. Cada vector se convierte en una columna en la tabla. Como
resultado, cada columna de una trama de datos puede contener un tipo
diferente de datos; pero dentro de una columna, cada celda debe ser del
mismo tipo de datos, como en la Figure 3-2.
Figura 3-2. Las tramas de datos almacenar datos como una secuencia de
columnas. Cada columna puede ser un tipo de datos distinto. Cada columna de
una trama de datos deben tener la misma longitud.
La creación de una trama de datos a mano tiene mucho de escribir, pero se puede
hacer (si te gusta) con los datos. Función de marco. Dar data.frame cualquier
número de vectores, cada uno separado por una coma. Cada vector debe ser igual a
un nombre que describa el vector. Da ta.frame girará cada vector en una columna
de la nueva trama de datos:
Df <- data.frame(face = c("Ace", "dos", "seis").
Palo = c("clubs", "clubs", "clubs"), valor = c(1, 2, 3)).
Df
## Cara Valor palo
Clubes de
## ace 1
Dos
## clubes 2
Sei
## s Clubes 3
Las tramas de datos | 55
WWW .IT-EBOOKS.INFO
Tendrá que asegurarse de que cada vector es la misma longitud (o puede
hacerse así con R las normas de reciclaje; consulte Figure 1-4), como tramas
de datos puede combinar columnas de longitudes diferentes.
En el código anterior, he nombrado los argumentos en data.frame, cara
de paloy valor, pero usted puede nombrar los argumentos que
quieras. Data.frame utilizará sus nombres de argumentos para etiquetar las
columnas de la trama de datos.
Nombres
También puede dar nombres a una lista o vector al crear uno de
estos objetos. Utilice la misma sintaxis que con data.frame:
Lista(face = "Ace", palo = "corazones", valor = 1).
C(face = "Ace", palo = "corazones", valor = "uno").
Los nombres serán almacenados en el atributo nombres del objeto.
Si nos fijamos en el tipo de una trama de datos, verá que es una lista. De
hecho, cada trama de datos es una lista con los datos de la
clase.Frame. Puede ver qué tipos de objetos se agrupan por una lista (o
marco de datos) con la función str:
Typeof(df)
## "List".
Clase(df)
## "Data.frame"
Str(df)
## 'Data.frame': 3 obs. 3 variables:
## $ cara : Factor w/ 3 niveles "Ace","6","2": 1 3 2
## $ palo : Factor w/ 1 nivel "clubes": 1 1 1
## $ valor: num 1 2 3
Observe que R guardó sus cadenas de caracteres como factores. Le dije que
factores R le gusta! No es algo muy importante aquí, pero usted puede evitar
este comportamiento añadiendo el argumento stringsAsFactors =
False a data.frame:
Df <- data.frame(face = c("Ace", "dos", "seis").
Palo = c("clubs", "clubs", "clubs"),
valor = c(1, 2, 3), stringsAsFactors = FALSE)
Una trama de datos es una gran manera de construir toda una baraja de cartas. Puede
hacer que cada fila en el marco de datos un juego de cartas, y cada columna de un
tipo de valor, cada uno con su propio tipo de datos apropiado. La trama de datos sería
algo como esto:
## Cara Valor palo
El
## rey Picas 13
## Reina Picas 12
## Jack Picas 11
## 10 Picas 10
WWW .IT-EBOOKS.INFO
## Nueve Picas 9
## Ocho Picas 8
## Siete Picas 7
## Seis Picas 6
## Cinco Picas 5
Cuatr
## o Picas 4
## Tres Picas 3
## Dos Picas 2
## Ace Picas 1
El
## rey Clubes 13
## Reina Clubes 12
## Jack Clubes 11
## 10 Clubes 10
## ... Y así sucesivamente.
Puede crear esta trama de datos con data.frame, pero mire el escribir
juego! Necesita escribir tres vectores, cada uno con 52 elementos:
Deck <- data.frame(
Face = c("rey",
la "reina", "jack", "diez", "9", "8", "7", "6", "5", "4", "tres", "dos",
"Ace", "el rey",
"Ace", "el rey",
"Ace", "el rey",
"Ace").
Palo = c("picas", "picas", "picas", "picas", "picas", "picas", "picas", "
picas", "picas", "picas", "picas", "picas", "picas", "clubs", "clubs",
"clubs", "clubs", "clubs", "clubs", "clubs", "clubs", "clubs", "clubs",
"clubs", "clubs", "clubs", "diamantes", "diamantes", "diamantes", "dia
mantes", "diamantes", "diamantes", "diamantes", "diamantes", "diamantes
", "diamantes", "diamantes", "diamantes", "Diamonds", "corazones", "cor
azones", "corazones", "corazones", "corazones", "corazones", "corazones
", "corazones", "corazones", "corazones", "corazones", "corazones", "co
razones").
Valor = C(13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 13, 12, 11, 10, 9, 8,
7, 6, 5, 4, 3, 2, 1, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 13, 12, 11,
10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
)
Usted debe evitar escribir grandes conjuntos de datos a mano siempre que sea posible.
Escribir invita a errores tipográficos y los errores, para no mencionar el RSI. Siempre es
mejor adquirir grandes conjuntos de datos como un archivo de computadora. Luego puedes
preguntarle R para leer el archivo y guardar el contenido como un objeto.
He creado un archivo para cargar que contiene una trama de datos de

información de la tarjeta de juego, así que no se preocupe acerca de la
escritura en el código. En su lugar, dirija su atención hacia la carga de datos
en R.
Carga de datos
Puede cargar la baraja la trama de datos desde el archivo deck.csv. Por favor,
tómese un momento para abajo- carga el archivo antes de la lectura. Visite el sitio
web, haga clic en "Descargar Gist," y a continuación, abra la carpeta que tu navegador
web descargas. Cubierta.csv estará dentro.
Carga de datos |
57
WWW .IT-EBOOKS.INFO
Cubierta.csv es un archivo de valores separados por comas, o CSV para corto. CSVs son
archivos de texto sin formato, lo que significa que se pueden abrir en un editor de texto (así
como muchos otros programas). Si abre desk.csv, verá que contiene una tabla de datos
que se asemeja a la siguiente tabla. Cada fila de la tabla se guarda en su propia línea y se
utiliza una coma para separar las células dentro de cada fila. Cada archivo CSV comparte
este formato básico:
"Face","traje,"valor".
"Rey","picas",13
"Reina","picas,12
"Jack","picas,11
"Diez","picas,10
"Nueve","picas,9
... Y así sucesivamente.
La mayoría de los datos de las aplicaciones de la ciencia puede abrir archivos de

texto sin formato y exportar datos como archivos de texto sin formato. Esto
convierte archivos de texto sin formato, una especie de lingua franca para datos
científicos.
Para cargar un archivo de texto sin formato en R, haga clic en el icono de
RStudio dataset de importación, que se muestra en la Figure 3-3. A
continuación, seleccione "Archivo de texto".
Figura 3-3. Puede importar datos desde archivos de texto sin formato con RStudio la
importación de los datos.
RStudio le pedirá que seleccione el archivo que desea importar y, a continuación, se abrirá
un asistente para ayudarle a importar los datos, tal como se muestra en la Figure 3-4. Utilice
el asistente para decirle qué RStudio nombre para el conjunto de datos. También puede
utilizar el asistente para decirle qué personaje RStudio el conjunto de datos se utiliza como
separador, el carácter que se utiliza para representar los decimales (generalmente un
período en los Estados Unidos y una coma en Europa), ni si el conjunto de datos viene con
una fila de nombres de columna (conocido como un encabezado). Para ayudarle, el
asistente muestra
WWW .IT-EBOOKS.INFO
¿Qué te parece el archivo RAW, así como lo que su carga será el aspecto de
los datos basados en los valores de entrada.
También puedes desmarcar la casilla "Cadenas como factores" en el
asistente. Recomiendo hacer esto. Si no, R cargará todas sus cadenas de
caracteres como cadenas de caracteres. Si no, R convertirlos en factores.
Figura 3-4. El asistente de importación de RStudio.
Una vez que todo parece correcto, haga clic en Importar. RStudio leerá los datos y
guardarlo en una trama de datos. RStudio abrirá también un visor de datos, para que
pueda ver los nuevos datos en un formato de hoja de cálculo. Esta es una buena
manera de asegurarse de que todo vino a través de como expected. Si todo funcionó
bien, el archivo debe aparecer en la ficha Vista de RStudio, como en Figure 3-5. Puede
examinar el marco de datos en la consola con cabeza(cubierta).
Datos en línea
Puede cargar un archivo de texto directamente desde Internet
haciendo clic en el botón "Desde URL Web…" opción en dataset
de importación. El archivo tendrá que tener su propia URL, y tendrá
que estar conectado.
Carga de datos | 59
WWW .IT-EBOOKS.INFO
Figura 3-5. Cuando se importa un conjunto de datos, RStudio va a guardar los
datos en una trama de datos y luego mostrar la trama de datos en una ficha
de Vista. Puede abrir cualquier trama de datos en una ficha de vista en
cualquier momento con la función Ver.
Ahora es tu turno. Descargar deck.csv e importarlo en RStudio. Asegúrese de guardar

la salida en un objeto denominado R cubierta: lo utilizará en los próximos capítulos.
Si todo va bien, las primeras líneas de la trama de datos debería tener este aspecto:
Cabeza(cubierta)
## Valor traje cara
## Rey de picas 13
## Reina picas 12
## Jack picas 11
## Diez picas 10
## Nueve picas 9
## 8 picas 8
Cabeza y cola son dos funciones que proporcionan una manera fácil
de peek en grandes conjuntos de datos. Jefe devolverá sólo los
primeros seis filas del conjunto de datos, y la cola devolverá sólo los
últimos seis filas. Para ver un número diferente de filas o colas de
cabeza, dar un segundo argumento, el número de filas que desea ver,
por ejemplo, la cabeza cubierta,(10).
R puede abrir muchos tipos de archivos no solo de CSVs. Visita Appendix

D a aprender a abrir otros tipos de archivos comunes en R.
WWW .IT-EBOOKS.INFO
Guardar datos
Antes de seguir, vamos a guardar una copia de la plataforma como un
nuevo archivo .csv. De esa manera usted puede enviarla por correo
electrónico a un colega, almacenarlo en una unidad USB, o bien abrirlo en un
programa diferente. Puede guardar cualquier trama de datos en R a
un archivo .csv con el comando write.csv. Para guardar la cubierta,
ejecutar:
Escriba.csv(cubierta, archivo = "tarjetas.csv", row.names = FALSE)
R convertirá su trama de datos en un archivo de texto con el formato de valores

separados por comas) y guarde el archivo en su directorio de trabajo. Para ver
donde su directorio de trabajo, ejecute getwd(). Para cambiar la ubicación de su
directorio de trabajo, visite sesión > Configurar directorio de trabajo > Elija un
directorio en la barra de menú RStudio.
Puede personalizar el proceso de guardar con write.csv's gran conjunto de

argumentos opcionales (consulte "write.csv para más detalles). Sin
embargo, hay tres argumentos que debe utilizar cada vez que
ejecute write.csv.
Primero, usted debe dar escribir.csv el nombre de la trama de datos que

desea guardar. A continuación, debe proporcionar un nombre de archivo para
darle a su archivo. R tendrá este nombre literalmente, así que asegúrese de
proporcionar una extensión.
Finalmente, se debe añadir el argumento row.names = FALSE. Esto evitará que R a partir
de la adición de una columna de números en el inicio de la trama de datos. Estos números
se identifique sus filas de 1 a 52, pero es poco probable que cualquier programa que
abra cards.csv en comprender el sistema de nombre de fila. Lo más probable es que el
programa asumirá que la fila son los nombres de la primera columna de datos de la trama
de datos. De hecho, esto es exactamente lo que R asumirá si reabrir cards.csv. Si guarda
y cartas abiertas.csv varias veces en R, te darás cuenta de que duplicar las columnas de
números de fila formando en el inicio de la trama de datos. No puedo explicar por qué R
hace esto, pero no puedo explicar cómo evitarlo: utilice row.names
= Falso siempre que guarde datos con write.csv.
Para obtener más información sobre cómo guardar archivos, incluyendo cómo
comprimir archivos guardados y cómo guardar archivos en otros formatos,
consulte Appendix D.
Buen trabajo. Ahora tienes una baraja de cartas virtuales para trabajar con.
Tómese un respiro, y cuando venga, vamos a empezar a escribir algunas
funciones para usar en su cubierta.
Resumen
Puede guardar los datos de R con cinco objetos diferentes, que le permiten
almacenar diferentes tipos de valores de diferentes tipos de relaciones, como en
la Figure 3-6. De estos objetos, las tramas de datos son, con mucho, la más útil
para datos científicos. Las tramas de datos se almacena una de las formas más
comunes de los datos utilizados en la ciencia de datos, datos tabulares.
Guardar datos|
61
WWW .IT-EBOOKS.INFO
Figura 3-6. R las estructuras de datos más comunes son matrices, vectores,
matrices, listas y data marcos.
Puede cargar datos tabulares en una trama de datos con el botón RStudio dataset de
importación, siempre que los datos se guardan como un archivo de texto. Este
requisito no es como la limitación como suena. La mayoría de los programas de
software pueden exportar datos como un archivo de texto. Por lo tanto, si usted tiene
un archivo de Excel (por ejemplo), puede abrir el archivo en Excel y exportar los datos
en formato CSV para su uso con R. De hecho, abrir un archivo en su programa original
es buena práctica. Utilizar los metadatos de archivos de Excel, como hojas y fórmulas,
que ayudan a trabajar con el archivo de Excel. R puede intentar extraer datos raw
desde el archivo, pero no será tan bueno en ello como Microsoft Excel. Ningún
programa es mejor a la hora de convertir archivos de Excel a Excel. Del mismo modo,
ningún programa es mejor en la conversión de archivos Xport SAS SAS, y así
sucesivamente.
Sin embargo, puede que te encuentres con un archivo específico de programa, pero no el
programa que lo creó. Usted no querrá comprar un multi-mil dólares licencia SAS SAS sólo
para abrir un archivo. Afortunadamente R puede abrir muchos tipos de archivos, incluidos
archivos de otros pro- gramos y bases de datos. R incluso tiene su propio programa de
formatos específicos que pueden ayudarle a ahorrar tiempo y memoria si usted sabe que
usted estará trabajando completamente en R. Si desea conocer más acerca de todas sus
opciones para cargar y guardar datos en R, consulte Appendix D.
WWW .IT-EBOOKS.INFO
Chapter 4 Se basará en los conocimientos aprendidos en este capítulo. Aquí,
usted ha aprendido cómo almacenar datos en R. En Chapter 4, aprenderá a
valores de acceso una vez que han sido almacenados. También podrás
escribir dos funciones que le permiten empezar a usar tu baraja, función
aleatoria y función de un proyecto.
Resumen | 63
WWW .IT-EBOOKS.INFO
WWW .IT-EBOOKS.INFO
Capítulo 4
Notación R
Ahora que usted tiene una baraja de cartas, necesita una manera de hacer cosas como la
tarjeta con él. Primero, usted querrá para reordenar la baraja de vez en cuando. Y a
continuación, usted querrá tratar las cartas de la baraja (una tarjeta a la vez,
independientemente de la tarjeta está en la parte superior-no somos los tramposos).
Para hacer estas cosas, usted tendrá que trabajar con los valores individuales
dentro de la trama de datos, una tarea esencial para datos científicos. Por
ejemplo, para tratar una tarjeta de la parte superior de la cubierta, necesitará
escribir una función que selecciona la primera fila de valores en su trama de
datos, como esta:
Tratar(cubierta)
## Valor traje cara
## Rey picas 13
Puede seleccionar valores dentro de un objeto de R con R el sistema de

notación.
La selección de valores
R tiene un sistema de notación que permite extraer valores de R objetos. Para
extraer un valor o conjunto de valores de una trama de datos, escriba el
nombre del marco de datos seguido por un par de soportes de disco:
Cubierta[ , ]
Entre paréntesis se destinarán dos índices separados por una coma. Los
índices Díselo a r los valores que van a regresar. R utilizará el primer índice
para el subconjunto de filas de la trama de datos y el segundo índice al
subconjunto de las columnas.
Usted tiene una opción cuando viene a la escritura de los índices. Hay seis diferentes
maneras de escribir un índice para R, y cada uno hace algo ligeramente diferente. Todos
ellos son muy simples y bastante práctico, por lo que echemos un vistazo a cada uno de
ellos. Puede crear índices con:
65
WWW .IT-EBOOKS.INFO
• Enteros positivos
• Los enteros negativos
• Cero
• Espacios en blanco
• Los valores lógicos
• Nombres
La más sencilla es usar números enteros positivos.
Enteros positivos
R trata enteros positivos como ij notación en álgebra
lineal: plataforma[i,j] devolverá el valor de la plataforma que se
encuentra en la i-ésima fila y la columna de JTH, Figure 4-1. Observe
que i y j sólo necesitan ser enteros en el sentido matemático. Pueden
guardarse como valores numéricos en R:
Cabeza(cubierta)
## Valor traje cara
## Rey de picas 13
## Reina picas 12
## Jack picas 11
## Diez picas 10
## Nueve picas 9
## 8 picas 8
Cubierta[1, 1]
## "Rey"
Para extraer más de un valor, use un vector de enteros positivos. Por ejemplo, puede
volver a la primera fila de la plataforma con deck[1, c(1, 2, 3)] o deck[1,
1:3]:
Cubiertac([ 1 ,1, 2, 3)]
## Cara Valor palo
## Rey picas 13
R devolverá los valores de cubierta que son tanto en la primera fila y la primera,
segunda y tercera columnas. Tenga en cuenta que R no va a quitar estos valores
de la plataforma. R le dará un nuevo conjunto de valores que son copias de los
valores originales. A continuación, puede guardar este nuevo conjunto para un
objeto de R con R del operador de asignación:
<-
nueva cubierta
[1, C(1, 2, 3)]
Nuevo
## Cara Palo Valor
Rey de
## picas 13
66 | Capítulo 4: notación R
WWW .IT-EBOOKS.INFO
Repetición
Si se repite un número en su índice, R volverá el
corresponden- ing value(s) más de una vez en tu
"subconjunto". Este código devolverá la primera fila de
la plataforma dos veces:
Deck[c (1, 1), c(1, 2, 3)]
## Cara Valor palo
Rey de
## picas 13
El
## rey Picas 13
Figura 4-1. Utiliza la notación R ij sistema de álgebra lineal. Los comandos de

esta figura devolverá los valores sombreados.
R El sistema de notación no se limita a las tramas de datos. Puede usar la misma sintaxis
para seleccionar los valores de cualquier objeto R, mientras que el suministro de un índice
para cada una de las dimensiones del objeto. Así, por ejemplo, puede subconjunto un
vector (que tiene una dimensión) con un solo índice:
Vec <- c(6, 1, 3, 6, 10, 5).
Vec[1:3]
## 6 1 3
La selección de
valores | 67
WWW .IT-EBOOKS.INFO
La indexación empieza en 1
En algunos lenguajes de programación, indexación comienza
con 0. Esto significa que 0 devuelve el primer elemento de un
vector, 1 devuelve el segundo elemento, y así sucesivamente.
Este no es el caso de R. indexación en R se comporta como la
indexación en álgebra lineal. El primer elemento es siempre
indexadas por 1. R ¿Por qué es diferente? Quizás porque fue
escrito para matemáticos. Aquellos de nosotros que aprendieron la
indización de un curso de álgebra lineal se preguntan por qué los
equipos los programadores comienzan con 0.
Drop = FALSE
Si selecciona dos o más columnas de una trama de datos, R
volverá una nueva trama de datos:
Cubierta[1:2, 1:2]
## Cara Palo
## Rey de picas
## Reina picas
Sin embargo, si se selecciona una única columna, R devolverá un vector:

Cubierta[1:2, 1]
## "El Rey" "reina"
Si prefiere una trama de datos en su lugar, puede agregar el

argumento opcional drop = FALSE entre paréntesis:
Cubierta[1:2, 1, drop = FALSE]
## Cara
## El rey
## Reina
Este método también funciona para la selección de una sola

columna de una matriz o una matriz.
Los enteros negativos

Los enteros negativos hacer exactamente lo contrario de enteros positivos
cuando la indexación. R devolverá todos los elementos excepto los elementos
en un índice negativo. Por ejemplo, cubierta[-1, 1:3] devolverá
todo pero la primera fila de la plataforma. Cubierta[-(2:52),
1:3] devolverá la primera fila (y excluir a todo lo demás):
Cubierta[-(2:52), 1:3]
## Cara Valor palo
## Rey picas 13
Los enteros negativos son una forma más eficiente al subconjunto de los
enteros positivos si desea incluir la mayor parte de una trama de datos de filas
o columnas.
R devolverá un error si intenta emparejar un entero negativo con un entero
positivo en el mismo índice:
WWW .IT-EBOOKS.INFO
Deck[c(-1, 1), 1]
## Error en xj[i] : sólo 0's puede ser mezclado con subíndices
negativos
Sin embargo, usted puede utilizar ambos números enteros positivos y

negativos al subconjunto de un objeto si se utilizan en diferentes índices (por
ejemplo, en el caso de que se utilice en el índice de filas y columnas en el
índice, como deck[-1, 1]).
Cero
¿Qué sucedería si se usa como un índice cero? Cero no es un número entero positivo ni
un número entero negativo, pero R se siguen utilizando para hacer un tipo de subconjunto.
R volverá nada desde una dimensión cuando se utiliza cero como un índice. Esto crea un
objeto vacío:
Cubierta[0, 0]
## La trama de datos con 0 columnas y 0 filas
Para ser honesto, la indexación con cero no es muy útil.
Espacios en blanco
Puede utilizar un espacio en blanco para decirle a R para extraer cada valor
en una dimensión. Esto permite subconjunto un objeto en una dimensión, pero
no a los demás, lo cual es útil para extraer todas las filas o columnas de una
trama de datos:
Cubierta[1]
## Cara Valor palo
El
## rey Picas 13
Los valores lógicos

Si usted proporciona un vector de TRUEy FALSEs como su índice, R igualará
cada verdadero y falso a una fila en el marco de datos (o una columna en función
de dónde se sitúe el índice). R volverá entonces cada fila corresponde a
un verdadero, Figure 4-2.
Puede ayudar a imaginar R la lectura a través de la trama de datos y

preguntando, "¿Debo devolver la iª fila de la estructura de datos?" y, a
continuación, consulta el ith valor del índice para su respuesta. Para que este
sistema funcione, el vector debe ser tan largo como la dimensión que están
tratando de subconjunto:
Cubiert
a[1, C(TRUE, TRUE FALSE)]
## Cara Palo
## El
rey Picas
Filas <
- C(TRUE, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F
F, F F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F
F, F F, F, F, F, F, F, F, F, F, F, F, F).
Deck[filas ]
## Cara Valor palo
## El
rey Picas 13
La selección de
valores | 69
WWW .IT-EBOOKS.INFO
Figura 4-2. Puede utilizar vectores de FALSEs TRUEs y decirle a R
exactamente qué valores desea extraer y que usted no lo hace. El comando
devolverá sólo el num- bers 1, 6 y 5.
Este sistema puede parecer extraño que quiere escribir

tantas TRUEy FALSEs?-pero será muy poderosa en la Chapter 5.
Nombres
Por último, usted puede pedir los elementos que desea por su nombre (si el
objeto tiene nombres (véase “Names” on page 44). Esta es una manera
común para extraer las columnas de una trama de datos, desde columnas casi
siempre tienen nombres:
Cubierta[1, c("cara", "palo", "valor")]
## Cara Valor palo
## Rey picas 13
# El valor total
de cubierta de la
columna "Valor"[ ,]
## 13 12 11 10 9 8 7 6 5 4 3 2 1 13 12 11 10 9 8
## 7 6 5 4 3 2 1 13 12 11 10 9 8 7 6 5 4 3 2
## 1 13 12 11 10 9 8 7 6 5 4 3 2 1
Tratar una tarjeta

Ahora que conoce los fundamentos del sistema de notación R, pongamos a
usarlo.
Ejercicio
Complete el siguiente código para realizar una función que devuelva la
primera fila de una trama de datos:
WWW .IT-EBOOKS.INFO
Tratar <- función(tarjetas) {
# ?
}
Puede utilizar cualquiera de los sistemas para escribir un acuerdo función

que devuelve la primera fila de la trama de datos. Voy a usar números enteros
positivos y espacios en blanco porque creo que son fáciles de Bajo- soporte:
Tratar <- función(tarjetas) {
Tarjetas[1] .
}
La función hace exactamente lo que quiere: se trata de la tarjeta superior de tu

conjunto de datos.
Sin embargo, la función se vuelve menos impresionante si ejecuta tratar una y otra
vez:
Tratar(cub
ierta)
## Cara Valor palo
## Rey picas 13
Tratar(cub
ierta)
## Cara Valor palo
## Rey picas 13
Tratar(cub
ierta)
## Cara Valor palo
## Rey picas 13
Tratar siempre devuelve el Rey de picas porque baraja no sabe que hemos
tratado la tarjeta de distancia. Así, el Rey de picas permanece donde está, en la
parte superior de la cubierta, listo para ser ocupado de nuevo. Este es un problema
difícil de resolver, y tenemos que lidiar con él en Chapter 6. En el ínterin, puede
solucionar el problema de barajar tu mazo después de cada proyecto. A
continuación, una nueva tarjeta será siempre en la parte superior.
Barajar es un compromiso temporal: las probabilidades en juego en tu baraja no
coincidirán con las probabilidades que se producen cuando se juega con una sola
baraja de cartas. Por ejemplo, seguirá existiendo la probabilidad de que el Rey de
picas aparece dos veces en una fila. Sin embargo, las cosas no son tan malas como
pueden parecer. La mayoría de los casinos utilizar cinco o seis cubiertas en un tiempo
en juegos de cartas para evitar que la cuenta de la tarjeta. Las probabilidades de que
usted encontraría en esas situaciones son muy semejantes a las que vamos a crear
aquí.
Mezclar la baraja
Cuando se aplica el orden aleatorio de una baraja de cartas real, puede
reorganizar aleatoriamente el orden de las cartas. En su baraja virtual, cada
tarjeta es una fila de una trama de datos. Para mezclar la cubierta, usted
necesita para reordenar las filas aleatoriamente en la trama de datos. Puede
hacerse esto? Usted apuesta! Y ya sabes todo lo que necesitas para hacerlo.
Esto puede parecer una tontería, pero comenzar extrayendo cada fila en la
trama de datos:
Mezclar la baraja |
71
WWW .IT-EBOOKS.INFO
Cubierta deck2 <-[1:52, ]
Cabeza(deck2)
## Valor traje cara
## Rey de picas 13
## Reina picas 12
## Jack picas 11
## Diez picas 10
## Nueve picas 9
## 8 picas 8
¿Qué se obtiene? Un nuevo marco de datos cuyo orden no ha cambiado en

absoluto. ¿Qué pasa si usted pide R para extraer las filas en un orden distinto?
Por ejemplo, usted podría preguntar a la fila 2, fila 1, y luego el resto de las
tarjetas:
Cubierta deck3 <-[c(2, 1, 3:52), ]
Cabeza(deck3)
## Valor traje cara
## Reina picas 12
## Rey de picas 13
## Jack picas 11
## Diez picas 10
## Nueve picas 9
## 8 picas 8
R cumple. Obtendrá todas las filas, y van a venir en el orden que le pregunte por ellos. Si
desea que las filas para entrar en un orden aleatorio, entonces usted necesita para ordenar
los números enteros de 1 a 52 en un orden aleatorio y utilizar los resultados como un índice
de fila. ¿Cómo podría generar una combinación aleatoria de números enteros? Con nuestro
vecindario amigable muestra función:
<- muestra aleatoria(1:52, Tamaño = 52)
Random
## 35 28 39 9 18 29 26 45 47 48 23 22 21 16 32 38 1 15 20
## 11 2 4 14 49 34 25 8 6 10 41 46 17 33 5
7 44 3 27
## 50 12 51 40 52 24 19 13 42 37 43 36 31 30
Cubierta deck4 <-[random, ]

Cabeza(deck
4)
## Cara Valor palo
Cinco
## Diamantes 5
Reina de
## diamantes 12
El as de
## diamantes 1
## Cinco Picas 5
## Nueve Clubes 9
Jota de
## diamantes 11
Ahora el nuevo conjunto es verdaderamente barajan. Usted estará terminado

una vez que ajusta estos pasos en una función.
WWW .IT-EBOOKS.INFO
Ejercicio
Uso de los anteriores ideas para escribir una función
aleatoria. Shuffle debería tener una trama de datos y devolver un barajan
copia de la trama de datos.
Su función shuffle tendrá una apariencia similar a la que sigue:

<- la función SHUFFLE(tarjetas) {
Tarjetas[random, ]
}
Nice work! Ahora usted puede mezclar las cartas entre cada proyecto:
Tratar(cubier
ta)
## Cara Valor palo
El
## rey Picas 13
Deck2 <- shuffle(cubierta)
Tratar(deck2
)
## Cara Valor palo
Clube
## Jack s 11
Signos de dólar y corchetes dobles

Dos tipos de objetos en R obedecer un opcional segundo sistema de notación. Puede
extraer los valores de las tramas de datos y listas con la sintaxis $. Conocerás
la sintaxis $ una y otra vez como una R programador, así que veamos cómo funciona.
Para seleccionar una columna de una trama de datos, escriba el nombre del marco de
datos y el nombre de la columna separados por un $. Observe que no debe ir entre
comillas alrededor del nombre de la columna:
Deckvalor
$
## 13 12 11 10 9 8 7 6 5 4 3 2 1 13 12 11 10 9 8 7
## 6 5 4 3 2 1 13 12 11 10 9 8 7 6 5 4 3 2 1 13
## 12 11 10 9 8 7 6 5 4 3 2 1
R devolverá todos los valores de la columna como un vector. Esta notación $ es

increíblemente útil porque se suelen almacenar las variables de los conjuntos de
datos como columnas en una trama de datos. A partir de tiempo al tiempo, deseará
ejecutar una función como la media o la mediana de los valores de una variable.
En R, estas funciones esperan un vector de valores como entrada
y cubierta$valor ofrece sus datos en el siguiente formato:
Significa(deck$valor)
## 7
Mediana(deck$valor)
## 7
Signos de dólar y corchetes dobles |

73
WWW .IT-EBOOKS.INFO
Puede usar la misma notación $ con los elementos de una lista, si tienen
nombres. Esta notación tiene una ventaja con las listas, demasiado. Si una
lista Subconjunto de la manera habitual, R devolverá una lista nueva que
tiene los elementos solicitados. Esto es cierto incluso si sólo se puede solicitar
un único elemento.
Para ver esto, haga una lista:
Lst <- list(números = c (1, 2), lógico = TRUE,
cadenas = c("a", "b", "c")) lst
## Los números de dólares
## [1] 1 2
## $lógico
## [1] TRUE
## Cadenas de dólares
## [1] "a", "b", "c"
Y luego subconjunto:
Lst[1]
## [1] 1 2
El resultado es un menor con un elemento de la lista. Ese elemento es el

vector c(1, 2). Esto puede ser molesto porque muchas R funciones no
funcionan con listas. Por ejemplo, SUMA(lst ([1]) , se devolverá un error.
Sería horrible si una vez que se almacena un vector en una lista, sólo se podía
nunca recuperarlo en una lista:
Sum(lst[1])
## Error en suma(lst ([1]) : 'tipo' no válida (lista) del argumento
Cuando se utiliza la notación $, R devolverá los valores seleccionados como

son, sin la estructura de la lista que les rodea:
Los números $ lst
## 1 2
Inmediatamente después, puede enviar los resultados a una función:

Sum(lst$números)
## 3
Si los elementos de la lista no tienen nombres (o no desea utilizar los

nombres), se pueden utilizar dos escuadras, en lugar de uno, a subconjuntos
de la lista. Esta notación se hacen la misma cosa como la notación $:
Lst[[1]]
## 1 2
En otras palabras, si un subconjunto de la lista con un solo soporte, notación R

devolverá una lista más pequeña. Si subconjunto una lista con doble soporte,
notación R devolverá sólo los valores que
WWW .IT-EBOOKS.INFO
Estábamos dentro de un elemento de la lista. Puede combinar esta función
con cualquier de los métodos de indexación del R:
Lst["números"]
## [1] 1 2
Lst"números"[[]]
## 1 2
Esta diferencia es sutil pero importante. En la comunidad de R, hay un popular, y

servicial, forma de pensar, Figure 4-3. Imagine que cada lista es un tren y cada
elemento es un vagón de tren. Cuando utilice corchetes únicos, R selecciona
individuo los vagones de tren y los devuelve como un nuevo tren. Cada vehículo
conserva su contenido, pero esos contenidos están aún dentro de un vagón de
tren (es decir, una lista). Cuando utilice corchetes dobles, R realmente descarga
el coche y le devuelve el contenido.
Figura 4-3. Puede resultar útil pensar en la lista como un tren. Utilice corchetes
únicos para seleccionar los vagones de tren, corchetes dobles para
seleccionar el contenido dentro de un coche.
Signos de dólar y corchetes dobles | 75

WWW .IT-EBOOKS.INFO
Nunca conecte
En los primeros días del R, se hizo popular para
utilizar attach() sobre un conjunto de datos una vez que se ha
cargado. No hagas eso! Fije recrea un entorno informático- ambiente
similares a los utilizados en otras aplicaciones de estadística como
Stata y SPSS, que usuarios de traspaso deseado. Sin embargo, R no
es SPSS o Stata. R está optimizado para utilizar la R entorno
informático, y ejecutar- ning attach() puede causar confusión con
algunas funciones de r.
Attach() ¿Qué hacer? En la superficie, fije le ahorra escribir. Si

conecta el conjunto de datos de la plataforma, puede hacer referencia
a cada una de sus variables por su nombre; en lugar de
escribir cubierta$cara, puede escribir simplemente cara. Pero
typ- ing no es malo. Te da la oportunidad de ser explícito, y en la
programación de computadoras, explícito es buena. Conectar un
conjunto de datos crea la pos- bilidad que R se confunden dos
nombres de variables. Si esto ocurre dentro de una función, es muy
probable que usted pueda obtener resultados inútiles y un mensaje de
error inútil para explicar lo sucedido.
Ahora que usted es un experto en recuperación de valores almacenados en

R, Resumamos lo que ha conseguido.
Resumen
Usted ha aprendido cómo tener acceso a los valores que se han almacenado en R. Puede
recuperar una copia de valores que viven dentro de una trama de datos y utilice las copias
para los nuevos cálculos.
De hecho, puede usar la notación R del sistema para acceder a los valores de
cualquier objeto R. Para utilizarlo, escriba el nombre de un objeto, seguido por las
escuadras y los índices. Si su objeto es unidimensional, como un vector, sólo tendrá
que proporcionar un índice. Si es bidimensional, como una trama de datos, necesita
suministrar dos índices separados por una coma. Y, si se trata de n-dimensional,
necesita alimentación n índices, separados por una coma.
En Chapter 5, este sistema va un paso más allá y aprender a cambiar los

valores reales que se almacenan dentro de la trama de datos. Todo esto es
añadir algo especial: el control completo de sus datos. Ahora puede almacenar
sus datos en tu ordenador, recuperar los valores individuales a voluntad, y
usar el ordenador para realizar cálculos con los valores correctos.
Esto puede sonar básico? Puede ser, pero que también es muy potente y eficiente
de los datos esenciales para la ciencia. Ya no es necesario memorizar todo en su
cabeza, ni preocuparse por hacer cálculos mentales equivocados. Este bajo nivel
de control sobre sus datos es también un prereq- uisite para hacer más eficiente
la r programas, el tema de la Part III.
WWW .IT-EBOOKS.INFO
Capítulo 5
Modificación de valores
¿Estás listo para jugar algunos juegos con tu baraja virtual? ¡No tan rápido! El sistema de
puntos en tu baraja de cartas no alinear bien con muchos juegos de cartas. Por ejemplo,
en la guerra y Poker de Ases, suelen estar puntuadas superiores a los reyes. Tendrían un
valor de 14 puntos, no 1.
En esta tarea, va a cambiar el sistema de puntos de tu baraja tres veces para que
coincida con tres juegos diferentes: guerra, corazones y blackjack. Cada uno de
estos juegos le enseñará algunos- algo diferente acerca de la modificación de los
valores dentro de un conjunto de datos. Empiece por hacer una copia de
la plataforma que se puede manipular. Esto asegurará que usted siempre
tendrá una copia prístina de baraja para caer sobre (si las cosas van mal):
Cubierta deck2 <-
Cambiando los valores en su lugar

Puede utilizar R sistema de notación para modificar valores dentro de un
objeto de r. En primer lugar, describir el valor (o valores) que desea modificar.
A continuación, utilice el operador de asignación <-- para sobrescribir los
valores. R actualizará los valores seleccionados en el objeto original. Vamos
a poner esto en acción con un ejemplo real:
Vec <- c(0, 0, 0, 0, 0, 0)
Vec
## 0 0 0 0 0 0
He aquí cómo usted puede seleccionar el primer valor de vec:

Vec[1]
## 0
Y aquí está cómo usted puede modificarla:

Vec[1] <- 1000
Vec
## 1000 0 0 0 0 0
77
WWW .IT-EBOOKS.INFO
Puede reemplazar varios valores a la vez mientras el número de nuevos
valores es igual al número de valores seleccionados:
Vec[c(1, 3, 5)] <- c(1, 1, 1).
Vec
## 1 0 1 0 1 0
Vec[4] : 6 <- vec[4] : 6 + 1

Vec
## 1 0 1 1 2 1
También puede crear valores que no existe aún en el objeto. R ampliará el

objeto para dar cabida a los nuevos valores:
Vec[7] <- 0
Vec
## 1 0 1 1 2 1 0
Esto proporciona una gran manera de agregar nuevas variables para el

conjunto de datos:
Deck2$nueva <- 1:52
Cabeza(deck
2)
Traje nuevo
## Cara valor
## Rey de picas 13 1
## Reina picas 12 2
## Jack picas 11 3
## Diez picas 10 4
## Nueve picas 9 5
## 8 picas 8 6
También puede quitar columnas de una trama de datos (y los elementos de

una lista) asignándoles el símbolo NULL:
Deck2$nuevos <- NULL
Cabeza(deck2)
## Valor traje cara
## Rey de picas 13
## Reina picas 12
## Jack picas 11
## Diez picas 10
## Nueve picas 9
## 8 picas 8
En el juego de la guerra, los ases son king (metafóricamente hablando).

Reciben el mayor valor de todas las tarjetas, que sería algo así como 14. Cada
otra tarjeta obtiene el valor que ya tiene en la cubierta. Para jugar a la
guerra, sólo tienes que cambiar los valores de sus ases del 1 al 14.
Mientras que no barajan su cubierta, saber exactamente dónde están los ases.
Aparecen cada 13 tarjetas. Por lo tanto, puedes describir con r sistema de notación:
78 | Capítulo 5: la modificación de valores

WWW .IT-EBOOKS.INFO
Deck2[c(13, 26, 39, 52), ]
## Cara Valor palo
## Ace Picas 1
## Ace Clubes 1
El as de
## diamantes 1
Corazon
## Ace es 1
Usted puede sólo los valores de los ases por subconjuntos de las columnas Dimensión
de deck2. O, mejor aún, puede subconjunto del vector columna deck2$valor:
Deck2[c(13, 26, 39, 52), 3]
## 1 1 1 1
Deck2Valor $[c(13, 26, 39, 52)]

## 1 1 1 1
Ahora todo lo que tienes que hacer es asignar un nuevo conjunto de valores a estos
antiguos valores. El conjunto de nuevos valores tendrán que ser del mismo tamaño
que el conjunto de valores que se van a sustituir. Así que usted podría guardar c(14,
14, 14, 14) en los valores de ace, o usted puede guardar 14 y confiar en R las
normas de reciclaje para ampliar de 14 a c(14, 14, 14, 14):
Deck2Valor $[c(13, 26, 39, 52)] <- C(14, 14, 14, 14).
# O
Deck2Valor $[c(13, 26, 39, 52)] <- 14
Observe que los valores cambian en su lugar. No acabará con una copia
modificada de la plataforma2; los nuevos valores aparecerán dentro
de deck2:
Cabeza(deck2, 13).
## Valor traje cara
## Rey de picas 13
## Reina picas 12
## Jack picas 11
## Diez picas 10
## Nueve picas 9
## 8 picas 8
## Siete Palas 7
## Seis picas 6
## Cinco picas 5
## Cuatro picas 4
## Tres picas 3
## Dos picas 2
## As picas 14
La misma técnica funcionará si los datos se almacenan en un vector, matriz, lista,

matriz o trama de datos. Sólo describir los valores que desea cambiar con
notación R del sistema y, a continuación, asignar más de esos valores con R del
operador de asignación.
Las cosas estaban muy fácilmente en este ejemplo porque usted sabía exactamente dónde
estaba cada ACE. Las tarjetas fueron ordenados en forma ordenada y un as apareció cada
13 filas.
Cambiando los valores en su lugar | 79
WWW .IT-EBOOKS.INFO
Pero ¿qué pasa si la cubierta se había sido mezcladas? Usted puede mirar a
través de todas las tarjetas y tomar nota de las ubicaciones de los ases, pero
que sería tedioso. Si la trama de datos eran más grandes, podría ser
imposible:
Deck3 <- shuffle(cubierta)
¿Dónde están los ases ahora?

Cabeza(deck
3)
## Cara Valor palo
## Reina Clubes 12
El
## rey Clubes 13
## Ace Picas 1 # Un as
## Nueve Clubes 9
## 7 Picas 7
## Reina de
diamantes 12
¿Por qué no pedir R para encontrar las ACE para usted? Usted puede hacer esto
con la lógica de subconjuntos. Subconjuntos lógicos proporciona una forma de
llevar a cabo la extracción selectiva y modificación con R objetos, una especie de
buscar y destruir su propia misión en el interior de conjuntos de datos.
Subconjuntos lógicos
¿Te acuerdas de R índice lógico del sistema, “Logical Values” on page 69?
Para recapitular, puede seleccionar valores con un vector de TRUEy FALSE. El
vector debe ser de la misma longitud que la dimensión que desea subconjunto.
R volverá cada elemento que coincida con una verdadera:
Vec
## 1 0 1 1 2 1 0
Vec[c(FALSE, FALSE FALSE, FALSE True, False F

alse)] ## 2
A primera vista, este sistema puede parecer poco práctico. ¿Quién quiere
escribir largos vectores de TRUEs y FALSEs? Nadie. Pero no tienes que
hacerlo. Puedes dejar una prueba lógica crear un vector de FALSEs TRUEs y
para usted.
Pruebas lógicas
Una prueba lógica es una comparación como "es uno menos que dos?", 1 <
2, o "tres es mayor que cuatro?", 3 > 4. R proporciona siete operadores
lógicos que puede utilizar para hacer comparaciones, se muestra en la Table
5-1.
WWW .IT-EBOOKS.INFO
En la tabla 5-1. R operadores
lógicos.
Pruebas
Operador Sintaxis Es mayor que b?
> A > B
Es mayor que o igual a b?
>= A >= b
Es inferior a b?
< A < b
Es un menor o igual a b?
<= Un <= b
Es un igual a b?
== A == b
No es igual a b?
!= Un != b
Es en el grupo c(a, b, c)?
%En % Un %en % c(a, b, c)
Cada operador devuelve un valor TRUE o FALSE. Si utiliza un operador para comparar
vectores, R-elemento hará comparaciones sabia exactamente como lo hace con los
operadores aritméticos:
1 > 2
## FALSE
1 > c(0, 1, 2).

## TRUE FALSE FALSE
C(1, 2, 3) == c(3, 2, 1)
## FALSE Verdadero Falso
%En % es el único operador que no es elemento normal-wise

ejecución. %en% comprueba si el valor(s) en el lado izquierdo están en el vector en el
lado derecho. Si usted proporciona un vector en el lado izquierdo, %en% no va
a emparejar los valores de la izquierda con los valores de la derecha y, a continuación,
elemento do-wise pruebas. En su lugar, %en % se prueba de forma independiente si
cada valor a la izquierda se encuentra en el vector de la derecha:
%1% en c(3, 4, 5).
## FALSE
C (1, 2) % %en c(3, 4, 5).

## Falso falso
C(1, 2, 3) % %en c(3, 4, 5).

## Falso falso TRUE
C(1, 2, 3, 4) % %en c(3, 4, 5).

## Falso falso TRUE TRUE
Observe que usted prueba para la igualdad con un doble signo igual ==, y ni
un solo signo igual =, que es otra forma de escribir <-. Es fácil olvidar y
utilizar a = b para comprobar si a es igual a b. Lamentablemente, estarás en
una desagradable sorpresa. R no devuelven TRUE o FALSE, porque no
tienen una voluntad igual a: b, porque acabas de correr el equivalente
de un <- b.
Subconjuntos lógicos | 81
WWW .IT-EBOOKS.INFO
= Es un operador de asignación
Tenga cuidado de no confundir = con ==. = hace la misma
cosa como <-: se asigna un valor a un objeto.
Puede comparar dos objetos R con un operador lógico; sin embargo, los
operadores lógicos tienen más sentido si se comparan dos objetos del mismo
tipo de datos. Si se comparan objetos de distintos tipos de datos, R utilizará
sus normas de coacción para obligar a los objetos del mismo tipo antes de
que se realiza la comparación.
Ejercicio
Extraer la cara cubierta de Columna2 y comprobar si cada valor es igual
a as. Como un desafío, utilizar R rápidamente a contar cuántas cartas son
iguales a as.
Puede extraer el rostro columna con R $ notación:

Deck2$cara
## "El Rey" "reina" "jack" "diez" "nueve".
## "8", "7", "6", "5", "4"
## "Tres", "dos", "as" de "rey" "reina"
## "Jack" "diez" "9" "8" "7"
## "6", "5", "4", "tres", "dos"
## "Ace" "rey", "reina" "jack" "diez"
## "9", "8", "7", "6", "5"
## "Cuatro", "tres", "dos", "as" de "rey"
## "Reina" "jack" "diez" "9" "8"
## "7", "6", "5", "4", "3"
## "Dos" "ACE"
A continuación, puede utilizar el operador == para comprobar si cada valor es igual

a as. En el código siguiente, R utilizará sus normas de reciclaje para indivuidually
comparar cada valor de deck2$cara a "Ace". Observe que las comillas son
importantes. Si los dejas fuera, R intentará encontrar un objeto denominado ace para
comparar contra el deck2$cara:
Deck2cara $ == "ACE"
## Falso FALSO FALSO FALSO FALSO FALSO FALSO
## Falso FALSO FALSO FALSO FALSO VERDADERO FALSO
## Falso FALSO FALSO FALSO VERDADERO FALSO FALSO
## Falso FALSO FALSO VERDADERO FALSO FALSO FALSO
## Falso FALSO VERDADERO

WWW .IT-EBOOKS.INFO
Puede utilizar suma a contar rápidamente el número de verdadeross en el vector anterior.
Recuerde que R se coaccionará logicals a valores numéricos cuando realizar operaciones
matemáticas con ellos. R se convertirá en verdadero y falsoen ceros. Como resultado,
suma contará el número de verdadeross:
Sum(deck2cara $ == "Ace").
## 4
Puede utilizar este método para detectar y, a continuación, cambiar los ases
en tu mazo, incluso si has barajan sus cartas. En primer lugar, construir una
prueba lógica que identifica los ases en la baraja barajada:
Deck3cara $ == "ACE"
A continuación, utilice la prueba para destacar los valores de punto de ACE.

Desde la prueba devuelve un vector de lógica, se puede usar como un índice:
Deck3Valor $[deck3cara $ == "Ace"]
## 1 1 1 1
Por último, el uso de la asignación para cambiar los valores de ace en

el deck3:
Deck3Valor $[deck3cara $ == "Ace"] <- 14
Cabeza(deck
3)
## Cara Valor palo
## Reina Clubes 12
El
## rey Clubes 13
## Ace Picas 14 # Un as
## Nueve Clubes 9
## 7 Picas 7
## Reina de
diamantes 12
Para resumir, puede utilizar una prueba lógica para seleccionar valores
dentro de un objeto.
Subconjuntos lógicos es una técnica poderosa porque le permite identificar
rápidamente, extraer y modificar los valores individuales en el conjunto de
datos. Cuando se trabaja con lógica de subconjuntos, usted no necesita
saber dónde en el conjunto de datos existe un valor. Usted sólo necesita saber
cómo describir el valor con una prueba lógica.
Subconjuntos lógicos es una de las cosas R hace mejor. De hecho,
subconjuntos lógicos es un componente clave de programación vectorizadas,
un estilo de codificación que permite escribir rápida y eficiente R código, que
vamos a estudiar en Chapter 10.
Pongamos los subconjuntos lógicos para su uso con un nuevo juego: los
corazones. En corazones, cada tarjeta tiene un valor de cero:
Cubierta deck4 <-
Deck4$valor <- 0
Cabeza(deck4, 13).
## Valor traje cara
El
## rey Picas 0
## Reina Picas 0
WWW .IT-EBOOKS.INFO
## Jack picas 0
## Diez picas 0
## Nueve picas 0
## 8 picas 0
## Siete Palas 0
## Seis picas 0
## Cinco picas 0
## Cuatro picas 0
## Tres picas 0
## Dos picas 0
## As picas 0
Excepto las tarjetas en el palo de corazones y la reina de picas. Cada tarjeta en el palo de
corazones tiene un valor de 1. Puede encontrar estas tarjetas y sustituir sus valores?
Pruébalo.
Ejercicio
Asigne un valor de 1 para cada tarjeta en la cubierta4 que tiene un palo de
corazones.
Para ello, en primer lugar, escribir un test que identifica las tarjetas en
el palo Corazones:
Deck4$palo == "corazones"
## Falso FALSO FALSO FALSO VERDADERO VERDADERO VERDADERO
## TRUE TRUE TRUE TRUE TRUE TRUE TRUE
## Verdadero VERDADERO VERDADERO
A continuación, utilice su prueba para seleccionar los valores de estas

tarjetas:
Deck4Valor $[deck4$palo == "corazones"]
## 0 0 0 0 0 0 0 0 0 0 0 0 0
Por último, asigne un número nuevo en estos valores:

Deck4Valor
$[deck4$palo == "corazones"] <- 1
Ahora todos vuestros corazones cartas han sido actualizadas:

Deck4Valor $[deck4$palo == "corazones"]
## 1 1 1 1 1 1 1 1 1 1 1 1 1
En los corazones y la reina de picas tiene el valor más inusual de todos: ella
valen 13 puntos. Debe ser simple para cambiar su valor, pero ella es
sorprendentemente difícil de encontrar. Usted puede encontrar todas
las reinas:
Cubierta deck4[4cara $ == "reina", ]
## Cara Palo Valor
## Reina Picas 0
Capítulo 5: la modificación de
84 | valores
WWW .IT-EBOOKS.INFO
## Reina Clubes 0
Reina de
## diamantes 0
Corazon
## Reina es 1
Pero eso tres cartas demasiados. Por otro lado, usted podría encontrar todas
las tarjetas en picas:
Cubierta deck4[4$palo == "picas", ]
## Valor traje cara
## Rey de picas 0
## Reina picas 0
## Jack picas 0
## Diez picas 0
## Nueve picas 0
## 8 picas 0
## Siete Palas 0
## Seis picas 0
## Cinco picas 0
## Cuatro picas 0
## Tres picas 0
## Dos picas 0
## As picas 0
Pero eso 12 cartas demasiados. Lo que realmente quiere encontrar todas las
cartas que tienen un valor nominal igual a la reina y un traje de valor igual a
raudales. Puede hacerlo con un operador booleano. Operadores booleanos
para combinar múltiples pruebas lógicas juntos en una sola prueba.
Operadores booleanos
Son cosas como los operadores booleanos and (&) o (|). Se colapsan los resultados de
varias pruebas lógicas en un único verdadero o falso. R tiene seis operadores
booleanos, se muestra en la Table 5-2.
Tabla 5-2. R operadores booleanos

Operado
r Sintaxis Pruebas
& Cond1 & Cond2 Son ambos cond1 y cond2 verdad?
| Cond1 tubo2 cond. Es uno o más de cond1 y cond2 verdad?
Es exactamente uno
Xor Xor(cond1, cond2) de cond1 y cond2 verdad?
Es cond1 falso? (Por ejemplo, ! voltea la resultados de
! !Cond1 una prueba lógica)
Cualq Cualquier(cond1, cond2,
uier cond3, …) Ninguna de las condiciones son verdaderas?
Todos(cond1, cond2, cond3,
Todos …) Todas las condiciones son verdaderas?
Para usar un operador booleano, colóquelo entre dos completas pruebas

lógicas. R ejecutará cada prueba lógica y, a continuación, utilice el operador
booleano para combinar los resultados en un
único verdadero o falso, Figure 5-1.
Subconjuntos lógicos |
85
WWW .IT-EBOOKS.INFO
El error más común con los operadores booleanos
Es fácil olvidarse de poner una prueba completa en cualquiera de los lados
de un operador booleano. En inglés, es eficaz para decir " x es mayor que
2 y menor que 9?" Pero en R, necesita escribir el equivalente de " x
es mayor que 2 y es x menos de nueve?" como se muestra en la Figure
5-1.
Figura 5-1. R evaluará las expresiones en cada lado de un operador booleano

separadas- ly y, a continuación, combinar los resultados en un único verdadero o
falso. Si no proporciona una prueba completa a cada lado del operador, R
devolverá un error.
Cuando se utiliza con vectores, operadores booleanos seguirá el mismo

elemento-sabio de ejecución como la aritmética y operadores lógicos:
<- c(1, 2, 3).
B <- c(1, 2, 3).
C <- c(1, 2, 4)
A == b
## Verdadero VERDADERO VERDADERO
B == c
## TRUE TRUE FALSE
A == b & b == c
## TRUE TRUE FALSE
Se puede utilizar un operador booleano para localizar la reina de picas en su

plataforma? Por supuesto que puede. Desea probar cada tarjeta para ver si
es tanto una reina y una pala. Puede escribir esta prueba en R con:
Deck4cara $ == "reina" & deck4$palo == "picas"
## Verdadero FALSO FALSO FALSO FALSO FALSO FALSO

WWW .IT-EBOOKS.INFO
## Falso FALSO FALSO
Voy a guardar los resultados de esta prueba para su propio objeto. Que hará
que los resultados sean más fáciles de trabajar con:
<- queenOfSpades deck4cara $ == "reina" & deck4$palo == "picas"
A continuación, puede utilizar la prueba como un índice para seleccionar el

valor de la reina de picas. Asegúrese de que la prueba realmente selecciona
el valor correcto:
Deck4[queenOfSpades, ]
## Valor traje cara
## Reina picas 0
Deck4Valor $[queenOfSpades]
## 0
Ahora que ya ha encontrado la reina de picas, usted puede actualizar su

valor:
Deck4Valor $[queenOfSpades] <- 13
Deck4[queenOfSpades, ]
## Valor traje cara
## Reina picas 13
Tu baraja está ahora listo para jugar a corazones.
Ejercicio
Si usted piensa que el cuelgue de pruebas lógicas, intente convertir estas
frases en pruebas escritas con código R. Para ayudarte, he definido algunos
R objetos después de las oraciones que se pueden utilizar para probar sus
respuestas:
• W es positivo?
• X es mayor que 10 y menor que 20?
• Es objeto y la palabra febrero?
• Cada valor de z un día de la semana?
W <- c(-1, 0, 1)
X <- c(5, 15).
Y <- "febrero"
Z <- c("Lunes", "Martes", "Viernes").
Aquí están algunas respuestas. Si usted quedó atrapado, asegúrese de

volver a leer cómo R evalúa pruebas lógicas que utilizan valores booleanos:
WWW .IT-EBOOKS.INFO
W > 0.
10 < X Y X < 20
Y == "febrero"
Todos(z %
%en c("Lunes", "Martes", "Miércoles", "Jueves", "Viern
es", "Sábado", "domingo")).
Veamos un último juego, blackjack. En el blackjack, cada número de tarjeta tiene un

valor igual a su valor nominal. Cada cara de la tarjeta (rey, reina o jota) tiene un valor
de 10. Por último, cada as tiene un valor de 11 o 1, dependiendo del resultado final del
juego.
Comencemos con una copia nueva de la plataforma-de manera que el

número de cartas (2 a 10) comenzará con el valor correcto:
Cubierta deck5
<-
Cabeza(deck5, 1
3).
## Rey de picas 13
## Reina picas 12
## Jack picas 11
## Diez picas 10
## Nueve picas 9
## 8 picas 8
## Siete Palas 7
## Seis picas 6
## Cinco picas 5
## Cuatro picas 4
## Tres picas 3
## Dos picas 2
## As picas 1
Puede cambiar el valor de la cartas de cara de un plumazo con %en %:

<- facecard deck5$cara %en % c("rey", la "reina", "jack").
Deck5[facecard, ]
## Cara Valor palo
El
## rey Picas 13
## Reina Picas 12
## Jack Picas 11
El
## rey Clubes 13
## Reina Clubes 12
## Jack Clubes 11
Rey de
## diamantes 13
Reina de
## diamantes 12
Jota de
## diamantes 11
El Corazon
## rey es 13
Corazon
## Reina es 12
Corazon
## Jack es 11
Deck5Valor $[facecard] <- 10

Cabeza(deck5, 13).
## Valor traje cara
WWW .IT-EBOOKS.INFO
## Rey de picas 10
## Reina picas 10
## Jack picas 10
## Diez picas 10
## Nueve picas 9
## 8 picas 8
## Siete Palas 7
## Seis picas 6
## Cinco picas 5
## Cuatro picas 4
## Tres picas 3
## Dos picas 2
## As picas 1
Ahora sólo hay que fijar los valores de ace-o no? Es difícil decidir qué valor dar a los
ases porque su valor exacto cambiará de mano a mano. Al final de cada mano, un ace
será igual a 11 si la suma de las cartas del jugador no exceda 21. De lo contrario, el
Ace será igual a 1. El valor real de la ace dependerá de las otras cartas en la mano
del jugador. Este es un caso de falta de información. Por el momento, no tiene
suficiente información para asignar un valor al punto correcto as tarjetas.
Falta información
Información faltante problemas ocurren frecuentemente en los datos científicos. Por lo
general, son la más clara: usted no conoce un valor debido a que la medición se ha perdido,
dañado, o nunca tomadas para comenzar con. R tiene una manera de ayudarle a gestionar
estos valores faltantes.
El carácter na es un símbolo especial en R. es la sigla de "no disponible" y

puede ser utilizado como un marcador de posición para la información que
falta. R tratará NA exactamente como usted quisiera tratar la información
faltante. Por ejemplo, ¿qué resultado se puede esperar si agrega 1 a un
pedazo de información que falta?
1 + NA
## NA
R volverá una segunda pieza de información faltante. No sería correcto decir que
1 + NA = 1 porque hay una buena probabilidad de que la cantidad que
falta no es cero. Usted no tiene suficiente información para determinar el
resultado.
¿Y si prueba si un trozo de información faltante es igual a 1?
NA == 1
## NA
Nuevamente, su respuesta sería algo así como "no sé si esto es igual a uno", es
decir, NA. Generalmente, NAs se propaga cuando se utiliza en una operación de R o
func- ción. Esto puede evitarle errores basados en los datos que faltan.
Falta información | 89
WWW .IT-EBOOKS.INFO
Na.rm
Los valores que faltan pueden ayudarle a trabajar alrededor de los agujeros
en los conjuntos de datos, sino que también puede crear algunos problemas
frustrante. Supongamos, por ejemplo, que usted ha recopilado 1.000
observaciones y desee llevar a su promedio con R media de la función.
Incluso si uno de los valores es NA, el resultado será NA:
C(NA, 1:50)
## NA 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
## 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
## 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
Significa(c(NA, 1:50)).
## NA
Comprensiblemente, usted puede preferir un comportamiento diferente. La

mayoría de funciones de r vienen con el argumento opcional, na.rm, que
significa quitar NA. R ignorará NAs cuando se eval- uates una función si
desea añadir el argumento na.rm = TRUE:
Significa(c(NA, 1:50), na.rm = TRUE).
## 25.5
Es.na
En ocasiones, es posible que desee identificar la NAs en el conjunto de datos con una
prueba lógica, sino que también crea un problema. ¿Cómo procedería? Si algo es un
valor que falta, cualquier prueba que utiliza lógica devolverá un valor ausente, incluso
esta prueba:
NA == NA
## NA
Lo que significa que este tipo de pruebas no te ayudará a encontrar los

valores que faltan:
C(1, 2, 3, NA) == NA
## NA NA NA NA
Pero no se preocupe demasiado duro; R proporciona una función especial que

puede comprobar si un valor es un NA. La función nombrada es
sensiblemente.na:
Es.NA NA()
## TRUE
Vec <- c(1, 2, 3 NA)

Es.na(vec)
## Falso FALSO FALSO TRUE
Vamos a establecer todos los valores a ACE NA. Esto se logran dos cosas. En primer lugar,
recordarle que usted no conoce el valor final de cada ACE. Segundo, se le impedirá la
puntuación accidentalmente una mano que tiene un as antes de determinar el valor final
del ACE.
Puede configurar su as valores para NA en la misma forma que establezca un número:

WWW .IT-EBOOKS.INFO
Deck5Valor $[deck5cara $ == "Ace"] <- NA
Cabeza(deck5, 13).
## Valor traje cara
## Rey de picas 10
## Reina picas 10
## Jack picas 10
## Diez picas 10
## Nueve picas 9
## 8 picas 8
## Siete Palas 7
## Seis picas 6
## Cinco picas 5
## Cuatro picas 4
## Tres picas 3
## Dos picas 2
## As picas NA
Felicitaciones. Tu baraja está ahora listo para un juego de blackjack.
Resumen
Los valores se pueden modificar en el lugar dentro de un objeto de R cuando
se combinan notación R la sintaxis con el operador de asignación, <-. Esto le
permite actualizar sus datos y limpie los conjuntos de datos.
Cuando se trabaja con grandes conjuntos de datos, modificar y recuperar valores
crea un problema logístico de su propio. ¿Cómo se puede buscar a través de los
datos para encontrar los valores que desea modificar o recuperar? Como un
usuario de R, puede hacerlo con la lógica de subconjuntos. Crear una prueba
lógica con la lógica y los operadores booleanos y, a continuación, utilice la prueba
como un índice en la notación R soporte. R devolverá los valores que usted está
buscando, incluso si usted no sabe dónde están.
Recuperar los valores individuales no serán su única preocupación como una

R programador. También necesitará recuperar conjuntos completos de datos;
por ejemplo, puede llamar a uno en una función. Chapter 6 Le enseñará cómo
R busca y guarda los datos conjuntos y otros R objetos en su entorno. Podrá
utilizar este conocimiento para solucionar el trato y funciones de
reproducción aleatoria.
Resumen | 91
WWW .IT-EBOOKS.INFO
WWW .IT-EBOOKS.INFO
Capítulo 6
Entornos
Tu baraja está ahora listo para un juego de blackjack (o corazones o la guerra),

pero son sus funciones shuf fle y tratar hasta el tabaco? No definitivamente.
Por ejemplo, tratar trata la misma tarjeta una y otra vez:
Tratar(cub
ierta)
## Cara Valor palo
## Rey picas 13
Tratar(cub
ierta)
## Cara Valor palo
## Rey picas 13
Tratar(cub
ierta)
## Cara Valor palo
## Rey picas 13
La función de reproducción aleatoria y no aleatoria de la baraja (devuelve

una copia de la cubierta que ha sido mezcladas). En resumen, estas dos
funciones usan la plataforma, pero ni manipula cubierta-y nos gustaría
que ellos.
Para corregir estas funciones, usted necesitará aprender cómo R almacena, analiza,
y manipula objetos como cubierta. R hace todas estas cosas con la ayuda de un
entorno de sistema.
Entornos
Pensemos por un momento cómo el ordenador almacena los archivos. Cada archivo
se guarda en una carpeta, y cada carpeta se guarda en otra carpeta, que forma un
sistema de archivos jerárquico. Si su equipo quiere abrir un archivo, primero debe
buscar el archivo en este sistema de archivos.
Usted puede ver su sistema de archivos mediante la apertura de una ventana del finder.
Por ejemplo, Figure 6-1 muestra una parte del sistema de archivos en mi ordenador. Tengo
toneladas de carpetas. Dentro de uno de ellos hay una subcarpeta
denominada Documentos, dentro de esa subcarpeta es un sub-subcarpeta denominada
93
WWW .IT-EBOOKS.INFO
Ggsubplot, dentro de esa carpeta es una carpeta denominada inst, dentro de
que es una carpeta denominada doc, y dentro de que es un archivo
denominado manual.pdf.
Figura 6-1. El equipo organiza los archivos en una jerarquía de carpetas y

subcarpetas. Para buscar un archivo, necesita encontrar dónde se guardará en el
sistema de archivos.
R utiliza un sistema similar para guardar objetos R. Cada objeto se guardan

dentro de un entorno, una lista-como objeto que se asemeja a una carpeta de
su ordenador. Cada entorno está acondicionado- conecta a un entorno
primario, un entorno de nivel superior, lo que crea una jerarquía de entornos.
Puede ver R del sistema con el entorno parenvs función en el paquete
devtools. Parenvs(todos = TRUE) devolverá una lista de los entornos que su r
sesión está utilizando. El rendimiento real variará de una sesión a otra dependiendo
de los paquetes que se han cargado. Aquí está el resultado de mi sesión actual:
Biblioteca(devtools)
Parenvs(todos = TRUE).
## Etiqueta Nombre
## 1 <entorno: R_GlobalEnv> ""
## 2 <entorno: paquete:devtools> "Paquete:devtools"
"Herramientas:r
## 3 <entorno: 0x7fff3321c388> studio"
## 4 <entorno: paquete:stats> "Paquete:Stats"
## 5 <entorno: paquete:Gráficos> "paquete:gráficos"
## 6 <entorno: paquete:grDevices> "paquete:grDevices"
## 7 <entorno: paquete:Utils> "Paquete:Utils"
## 8 <entorno: paquete:datasets> "paquete:datasets"
## 9 <entorno: paquete:métodos> "paquete:métodos"
"Se carga
automáticam
## 10 <entorno: 0x7fff3193Dab0> ente"
## 11 <Medio ambiente: base> ""
## 12 <entorno: R_EmptyEnv> ""
94 | Capítulo 6: Entornos
WWW .IT-EBOOKS.INFO
Se tarda algo de imaginación para interpretar este resultado, así que vamos a visualizar los
entornos como un sistema de carpetas, Figure 6-2. Se puede considerar el medio ambiente
como este árbol. El ambiente de menor nivel se llama R_GlobalEnv y se guardan dentro
de un entorno denominado paquete:devtools, que se guardan dentro del entorno
denominado 0x7fff3321c388, y así sucesivamente, hasta llegar a la final, de más alto
nivel de medio ambiente, R_emp _EmptyEnv tyEnv . R R es el único medio que no
tiene un entorno primario.
Figura 6-2. R R almacena objetos en un entorno que se asemeja al árbol de

carpetas del ordenador.
Recuerde que este ejemplo es sólo una metáfora. R de ambientes existentes en

la memoria RAM, y no en el sistema de archivos. Además, R en entornos que no
son técnicamente se guardan dentro de uno al otro. Cada entorno está conectado
a un entorno primario, lo cual facilita la búsqueda del entorno R árbol. Pero esta
conexión es unidireccional: no hay manera de echar un vistazo al ambiente y
decirle cuáles son sus "hijos". Así que usted puede buscar abajo del entorno R
árbol. En otros aspectos, sin embargo, funciona el sistema del medio ambiente R-
sim ilar a un sistema de archivos.
Trabajar con entornos.

R viene con algunas funciones auxiliares que puede utilizar para explorar su entorno de
árbol. En primer lugar, puede referirse a cualquiera de los entornos de su árbol con as.El
medio ambiente.
Trabajar con entornos. | 95

WWW .IT-EBOOKS.INFO
As.ambiente tiene un entorno de nombre (como una cadena de
caracteres) y devuelve el entorno correspondiente:
As.medio ambiente("paquete:Stats")
## <entorno: paquete:stats>
## Attr("nombre").
## [1] "paquete:Stats"
## Attr("ruta")
## [1] "/Library/Frameworks/R.marco/VERSIONES/3.0/resources/library/stats"
Tres ambientes en su árbol también cuentan con sus propias funciones de

descriptor de acceso. Estos son el medio ambiente mundial ( R_GlobalEnv), el
entorno basebase (), y el entorno vacío (R_EmptyEnv). Puede hacer referencia
a ellos con:
Globalenv()
## <entorno: R_GlobalEnv>
Baseenv()
## <Medio ambiente: base>
Emptyenv()
##<entorno: R_EmptyEnv>
A continuación, puede buscar un entorno principal con sus padres.env:

Parent.env(globalenv())
## <entorno: paquete:devtools>
## Attr("nombre").
## [1] "paquete:devtools"
## Attr("ruta")
## [1] "/Library/Frameworks/R.marco/VERSIONES/3.0/resources/library/devtools"
Observe que el entorno vacío es el único entorno R sin un padre:

Parent.env(emptyenv())
## Error en parent.env(emptyenv()) : el entorno vacío no tiene principal
Puede ver los objetos guardados en un entorno con ls o ls.str. Ls devolverá sólo
los nombres de los objetos, pero ls.str mostrará un poco acerca de la estructura de
cada objeto:
Ls(emptyenv())
El carácter ##(0)
Ls(globalenv())
## "Deal" "Deck" "Deck2" "Deck3" "Deck4" "Deck5"
"Morir
## " "Género" "Mano" "Lst" "Mat" "Mil"
"Nuevo
## " "Ahora" "Shuffle" "Vec"
El entorno está vacía, no sorprendentemente vacía; el entorno base tiene

demasiados objetos para enumerar aquí; y el medio ambiente mundial tiene
algunas caras conocidas. Es donde R ha guardado todos los objetos que has
creado hasta ahora.
WWW .IT-EBOOKS.INFO
RStudio entorno del panel muestra todos los objetos en su
entorno global.
Puede utilizar la sintaxis de R $ para acceder a un objeto en un entorno

específico. Por ejemplo, puede acceder a la plataforma de medio ambiente
global:
Cabeza(globalenv()$cubierta, 3)
## Valor traje cara
## Rey de picas 13
## Reina Picas 12
## Jack Picas 11
Y puede utilizar la función assign para guardar un objeto en un medio determinado.

En primer lugar dar asignar el nombre del nuevo objeto (como una cadena de
caracteres). A continuación, asigne el valor de dar el nuevo objeto, y finalmente el
entorno para guardar el objeto en:
Assign("nuevo", "Hola" Global, globalenv envir =())
Globalenv()$nuevo
## "Hola" global
Observe que asigne funciona de forma similar a <-. Si ya existe un objeto con el nombre
dado en el ambiente determinado, asigne se sobrescribirá sin pedir permiso. Esto
permite asignar útiles para actualizar los objetos pero crea el potencial para el desamor.
Ahora que usted puede explorar el entorno R árbol, examinemos cómo R lo utiliza. R
trabaja estrechamente con el medio ambiente árbol para buscar objetos, almacenar
objetos y evaluar func- ciones. Cómo R ¿cada una de estas tareas dependerá del
entorno activo actual.
El entorno activo
En cualquier momento del tiempo, R está trabajando estrechamente con un único
entorno. R almacenará los nuevos objetos en este entorno (si se crea alguna) y R
se utilizan este medio como un punto de partida para buscar objetos existentes (si
llama a cualquiera). Llamaré a este entorno especial el entorno activo. El entorno
activo es generalmente el global environment, pero esto puede cambiar cuando
se ejecuta una función.
Puede utilizar el medio ambiente para ver el actual entorno activo:
Medio ambiente()
<Medio ambiente: R_GlobalEnv>
El medio ambiente mundial desempeña un papel especial en la R. es el

entorno activo para cada comando que se ejecuta en la línea de comandos.
Como resultado, cualquier objeto que cree en la línea de comandos se
guardarán en el entorno mundial. Se puede pensar en el medio ambiente
mundial en el área de trabajo del usuario.
Trabajar con entornos. | 97
WWW .IT-EBOOKS.INFO
Cuando usted llama a un objeto en la línea de comandos, R buscará primero
en el entorno global- ambiente. Pero, ¿y si el objeto no está allí? En ese caso,
R va a seguir una serie de reglas para buscar el objeto.
Reglas de alcance
R sigue un conjunto de normas especiales para buscar objetos. Estas reglas
son conocidos como R las reglas de alcance, y ya ha reunido un par de ellas:
1. R busca objetos en el actual entorno activo.

2. Cuando trabaje en la línea de comandos, el entorno activo es el mundial
envi- ambiente. Por lo tanto, R busca objetos que usted llame a la línea de
comandos en el entorno mundial.
Aquí hay una tercera regla que explica cómo R busca objetos que no están
en el entorno activo:
3. Cuando R no encuentra un objeto en un entorno R busca en el entorno

principal del entorno, entonces el padre de los padres, y así
sucesivamente, hasta que R busca el objeto o alcance el entorno vacío.
Por lo tanto, si usted llama a un objeto en la línea de comandos, R la buscará en

el entorno mundial. Si R no se encuentra allí, R buscará en el padre del medio
ambiente global y, a continuación, el padre del padre, y así sucesivamente,
trabajando su camino hasta el medio ambiente árbol hasta que encuentre el
objeto, tal como se muestra en la Figure 6-3. Si R no puede encontrar el objeto en
cualquier entorno, devolverá un mensaje de error que dice que no se encontró el
objeto.
Figura 6-3. R va a buscar un objeto por su nombre en el entorno activo, aquí el global
medio ambiente. Si R no encuentra el objeto, se buscará en la activa
WWW .IT-EBOOKS.INFO
Medio ambiente principal y, a continuación, el padre del padre, y así
sucesivamente hasta que R busca el objeto o se ejecuta fuera de entornos.
Recuerde que las funciones son un tipo de objeto en R. R podrán

almacenar y buscar las funciones de la misma manera que se
almacena y busca otros objetos, buscando por su nombre en el
árbol de entorno.
Asignación
Cuando se asigna un valor a un objeto, R guarda el valor en el entorno activo
bajo el nombre del objeto. Si ya existe un objeto con el mismo nombre en el
activo- Environ ment, R se sobrescribirá.
Por ejemplo, existe un objeto llamado nuevo en el entorno global:
Nuevo
## "Hola" global
Puede guardar un nuevo objeto denominado nueva para el medio ambiente

mundial con este comando. R sobrescribirá el objeto antiguo como resultado:
Nueva <- "Hola" activo
Nuevo
## "Hola" activo
Este acuerdo crea un quandry para R R cuando se ejecuta una función. Muchas
funciones guardar objetos temporales que les ayuden a realizar su trabajo. Por
ejemplo, la función de rollo de Part I guarda un objeto denominado morir y un objeto
llamado dados:
Die <- 1:6
Sum(dados)
}
R debe guardar estos objetos temporales en el entorno activo; pero si R hace que, se puede
sobrescribir los objetos existentes. Autores de función no puede adivinar de antemano qué
nombres puede existir ya en su entorno activo. R ¿cómo evitar este riesgo? Cada vez R
ejecuta una función, se crea un nuevo entorno activo para evaluar la función.
Evaluación
R crea un entorno nuevo cada vez que se evalúa como una función. R utilizará el nuevo
environment como el entorno activo mientras se ejecuta la función y, a continuación, R
volverá al entorno que se llama la función de llevar el resultado de la función con
Asignación | 99
WWW .IT-EBOOKS.INFO
Él. Vamos a llamar a estos nuevos entornos entornos de tiempo de
ejecución porque R se crea en tiempo de ejecución para evaluar funciones.
Utilizaremos la siguiente función para explorar los entornos de ejecución R's.
Queremos saber cuáles son los entornos aspecto: ¿Cuáles son los entornos de
sus padres, y ¿qué objetos que contienen? Show_env es diseñado para decirnos:
Show_env <- function(){
Lista(ran.En entorno =()
Parent = parent.env (medio ambiente())
Objetos = ls.str(medio ambiente()))
}
Show_env es en sí misma una función, de modo que cuando

pedimos show_env(), R creará un runtime environment para evaluar la
función. Los resultados de show_env nos dirá el nombre del entorno en
tiempo de ejecución, su padre, y los objetos que el runtime environment
contiene:
Show_env()
## $ran.de
## <entorno: 0x7FF711d12e28>
##
## $parent
##
## $objetos
Los resultados revelan que R creó un nuevo entorno

llamado 0x7FF711d12e28 para ejecutar show_env() . El medio ambiente
no tenía objetos en él, y su padre era el medio ambiente mundial. Para
propósitos de ejecutar show_env, R del medio ambiente parecía árbol Figure
6-4.
Vamos a ejecutar show_env de nuevo:
Show_env()
## $ran.de
## <entorno: 0x7FF715f49808>
##
## $parent
##
## $objetos
Esta vez show_env corrió en un nuevo entorno, 0x7FF715f49808. R crea un

nuevo medio ambiente - cada vez que se ejecute una función.
El 0x7FF715f49808 medio ambiente tiene exactamente el mismo aspecto
que 0x7FF711d12e28. Es vacío y tiene el mismo ambiente global como su
padre.
WWW .IT-EBOOKS.INFO
Figura 6-4. R crea un nuevo entorno para ejecutar show_env en. El medio
ambiente es un hijo del medio ambiente mundial.
Ahora vamos a considerar que el medio ambiente R utilizará como el padre

del entorno en tiempo de ejecución.
R conectará una función del entorno de tiempo de ejecución para el medio
ambiente que la función se creó por primera vez en. Este ambiente juega un
papel importante en la vida de la función- porque todos los entornos de tiempo
de ejecución de la función se utiliza como un padre. Vamos a llamar a este
entorno, el entorno de origen. Puede buscar una función de origen del
medio ambiente mediante la ejecución de la función:
Medio ambiente(show_env)
El entorno de origen del show_env es el medio ambiente mundial, porque hemos

creado show_env en la línea de comandos, pero el entorno de origen no necesita ser el
entorno global. Por ejemplo, el entorno de parenvs es el paquete devtools:
Medio ambiente(parenvs)
## <entorno::namespace devtools>
En otras palabras, el padre de un entorno de tiempo de ejecución no siempre será

el global environment; será cualquier ambiente la función fue creada en.
Por último, veamos los objetos contenidos en un entorno de tiempo de ejecución. Por
el momento, show_env's runtime environments no contienen objetos, pero eso es fácil
de solucionar. Sólo tiene show_env crear algunos objetos en su cuerpo de código. R
podrán almacenar cualquier objeto creado por show_env en su entorno de ejecución.
¿Por qué? Porque el entorno de tiempo de ejecución será el entorno activo cuando los
objetos se crean:
Evaluación |
101
WWW .IT-EBOOKS.INFO
Show_env <- function(){
<- 1
B <- 2
C <- 3
}
Esta vez cuando ejecutamos show_env, R almacena a, b, c y en el entorno en

tiempo de ejecución:
Show_env()
## $ran.de
## <entorno: 0x7ff712312CD0>
##
## $parent
##
## $objetos
## A : num 1
## B : num 2
## C : num 3
Esta es la forma R asegura que una función no sobrescribe cualquier cosa

que no deberían. Los objetos creados por la función se almacenan en un lugar
seguro, fuera del camino runtime environment.
R también pondrá un segundo tipo de objeto en un entorno de tiempo de
ejecución. Si una función tiene argumentos, R se copia sobre cada argumento
para el entorno de tiempo de ejecución. El argumento aparecerá como un
objeto que tiene el nombre del argumento, pero el valor de cualquier entrada
del usuario proporcionada para el argumento. Esto garantiza que una función
será capaz de encontrar y utilizar cada uno de sus argumentos:
Foo <- "lléveme a su runtime"
Show_env <- función(x = foo){

}
Show_env()
## $ran.de
## <entorno: 0x7ff>712398958
##
## $parent
##
## $objetos
## X : CDH "lléveme a su runtime"

WWW .IT-EBOOKS.INFO
Pongamos esto todos juntos para ver cómo se evalúa una función R. Antes
de llamar a una función, R está trabajando en un entorno activo; vamos a
llamar a esto el entorno de la llamada. Es el entorno R llama a la función.
A continuación, se llama a la función. R responde por medio de la creación de un
nuevo entorno de tiempo de ejecución. Este medio será un niño de origen la
función el entorno. R se copia cada uno de los argumentos de la función en el
entorno de tiempo de ejecución y, a continuación, hacer el entorno en tiempo de
ejecución el nuevo entorno activo.
A continuación, r ejecuta el código en el cuerpo de la función. Si el código que
crea los objetos, r los almacena en el activo, es decir, el entorno de ejecución. Si
el código llama a cualquier objeto, R utiliza sus reglas de alcance para verlos. R
buscará el entorno de tiempo de ejecución, entonces el padre de runtime
environment (que será el entorno de origen), entonces el padre del origen del
medio ambiente y así sucesivamente. Observe que el entorno de la llamada podría
no estar en la ruta de búsqueda. Normalmente, una función sólo llamará R sus
argumentos, que puede encontrar en el entorno de ejecución activa.
Por último, R finaliza la ejecución de la función. Cambia el entorno activo de

vuelta al llamar a medio ambiente. Ahora R ejecuta cualquier otros comandos
en la línea de código que llama a la función. Por lo tanto, si se guarda el
resultado de la función a un objeto con <-, el nuevo objeto se almacena en el
entorno de la llamada.
Para recapitular, R almacena sus objetos en un entorno de sistema. En cualquier
momento del tiempo, R está trabajando estrechamente con un único entorno activo.
Almacena los objetos nuevos de este environment, y utiliza el medio ambiente como
un punto de partida cuando busca los objetos existentes. R es un entorno activo es
generalmente el medio ambiente mundial, pero R se ajustará el entorno activo para
hacer cosas como ejecutar funciones de una manera segura.
¿Cómo puede usar este conocimiento para solucionar el trato y funciones

de reproducción aleatoria?
En primer lugar, comencemos con una pregunta de calentamiento.
Supongamos que redefinir la frente en la línea de comandos como este:
Tratar <- función() {
Cubierta[1]
}
Observe que ocupan ya no toma un argumento, y se llama al objeto de

cubierta, que vive en el medio ambiente mundial.
Ejercicio
R va a ser capaz de encontrar deck y devolver una respuesta cuando llamo
a la nueva versión de tratar, como proyecto()?
Evaluación |
103
WWW .IT-EBOOKS.INFO
Sí. Tratar todavía funcionará igual que antes. R funcionará tratar en un
entorno en tiempo de ejecución que es hijo del medio ambiente mundial. ¿Por
qué ser un niño del medio ambiente mundial? Porque el medio ambiente
global es el entorno de origen del acuerdo (que hemos definido se ocupan en
el medio ambiente mundial):
Medio ambiente(deal)
Al tratar las llamadas cubierta, R tendrá que buscar el objeto de cubierta.

R las reglas de alcance que conducirá a la versión de la plataforma en el
entorno mundial, tal como se muestra en la Figure 6-5. Tratar funciona como
se espera como resultado:
Proyecto()
## Valor traje cara
## Rey picas 13
Figura 6-5. R considera cubierta mirando en la matriz de tratar el runtime

environment. La principal es el medio ambiente mundial, tratar el origen del
medio ambiente. Aquí, R busca la copia de la cubierta.
Ahora vamos a arreglar el acuerdo función para quitar las tarjetas se ha

ocupado de la plataforma. Recordar que tratar devuelve la tarjeta
superior de la cubierta , pero no quita las cartas de la baraja. Como
resultado, tratar siempre devuelve la misma tarjeta:
Proyecto()
## Valor traje cara
## Rey picas 13
Proyecto()
## Valor traje cara
## Rey picas 13

WWW .IT-EBOOKS.INFO
Usted sabe bastante R sintaxis para eliminar la tarjeta superior de
la cubierta. En el código siguiente se guardará una copia de
prisitine deck y luego retire la tarjeta superior:
Cubierta deck <-
Cubierta deck <-[-1, ]
Cabeza(cubierta, 3)
## Valor traje cara
## Reina picas 12
## Jack Picas 11
## 10 Picas 10
Ahora vamos a agregar el código para tratar. Aquí se tratan salva (y

devuelve) la Carta de la parte superior de la cubierta. Entre ellos, se retira
la tarjeta de la plataforma…o no?
Card <- cubierta[1] .
Cubierta deck <-[-1, ]
Card
}
Este código no funcionará, porque R estará en un entorno de tiempo de ejecución cuando se

ejecuta la Cubierta deck <-[-1]. En lugar de sobrescribir la copia global
de cubierta con deck[-1], tratar crearán una copia ligeramente modificada de
la plataforma en su entorno de ejecución, como en la Figure 6-6.
Figura 6-6. El proyecto busca la función de cubierta en el entorno mundial,

pero ahorra deck[-1] en el entorno de ejecución como un nuevo objeto
denominado cubierta.
Evaluación |
105
WWW .IT-EBOOKS.INFO
Ejercicio
Reescribir la Cubierta deck <-[-1] línea de tratar de asignar deck[-1] a un
objeto denominado cubierta en el entorno mundial. Sugerencia: considere
la función assign.
Puede asignar un objeto a un entorno específico con la función assign:

Assign("deck", cubierta[-1, ], globalenv envir =())
Card
}
Ahora ocuparse finalmente limpiar la copia global de la plataforma, y

podemos repartir cartas tal como lo haría en la vida real:
Proyecto()
## Valor traje cara
## Reina picas 12
Proyect
o()
## Cara Valor palo
## Jack picas 11
Proyect
o()
## Cara Valor palo
## Diez picas 10
Volvamos nuestra atención a la función Shuffle:

<- la función SHUFFLE(tarjetas) {
Tarjetas[random, ]
}
Shuffle(cubierta) no mezclar la baraja objeto; no devuelve una copia

de la baraja barajada objeto:
Cabeza(cubierta, 3)
## Valor traje cara
## Nueve picas 9
## 8 Picas 8
## Siete Picas 7
A <- shuffle(cubierta)
Cabeza(cubierta, 3)
## Valor traje cara
## Nueve picas 9
## 8 Picas 8
## 7 Picas 7

WWW .IT-EBOOKS.INFO
Jefe(a, 3)
## Cara Valor palo
El as de
## diamantes 1
## 7 Clubes 7
## Dos Clubes 2
Este comportamiento es ahora indeseable de dos maneras. En primer lugar, shuffle no

shuffle cubierta. Sec- ond, shuffle devuelve una copia de la plataforma, que pueden
estar ausentes las tarjetas que han sido tratados de distancia. Sería mejor
si shuffle devolvió el reparto de cartas de la baraja y luego mezcladas. Esto es lo que
sucede cuando se aplica el orden aleatorio de una baraja de cartas en la vida real.
Ejercicio
Reescribir shuffle para que reemplaza la copia de cubierta que vive en el
medio ambiente global, con una baraja en la versión de plataforma, intacto
copia de cubierta que también vive en el medio ambiente mundial. La nueva
versión del shuffle no debe tener argumentos y no devuelva ningún
resultado.
Puede actualizar el ipod en la misma forma en que se actualiza la cubierta.

La siguiente versión va a hacer el trabajo:
Shuffle <- function(){
Assign("deck", DECK[random, ] envir = globalenv())
}
Desde cubierta vive en el medio ambiente mundial, shuffle's ambiente de

origen, shuffle será capaz de encontrar la plataforma en tiempo de
ejecución. R buscará primero en la plataforma shuffle's runtime
environment y, a continuación, en origen de entorno shuffle 's el medio
ambiente mundial- que es donde se almacena la cubierta.
La segunda línea de reordenar shuffle creará una copia de la baraja y guárdelo
como cubierta en el entorno mundial. Esto sobrescribirá la anterior, nonshuffled versión
de plataforma.
Cierres
Finalmente nuestro sistema funciona. Por ejemplo, puede barajar las cartas y
luego repartir una mano de blackjack:
Shuffle()
Proyecto()
## Valor traje cara
## Reina
corazones 12
Proyecto()
Cierres | 107
WWW .IT-EBOOKS.INFO
## Valor traje cara
## Ocho
corazones 8
Pero el sistema requiere la cubierta y la cubierta que existe en el entorno

mundial. Un montón de cosas en este entorno, y es posible que
la plataforma puede obtener modificados o borrados por accidente.
Sería mejor si pudiéramos almacenar la cubierta en un lugar seguro, lugar fuera

del camino, como uno de los seguros, de modo que crea entornos R para ejecutar
funciones en. De hecho, almacenar en la cubierta de un entorno de tiempo de
ejecución no es tan mala idea.
Puede crear una función que toma como argumento de cubierta y guarda una copia de
la plataforma como
Cubierta. La función también puede guardar sus propias copias
del proyecto y aleatorio:
Configuración <- función(cubierta) {
Cubierta deck <-

Card
}
SHUFFLE <- function(){

}
}
Cuando se ejecuta el programa de instalación, R creará un entorno de

tiempo de ejecución para almacenar estos objetos. El medio ambiente será
similar a la de Figure 6-7.
Ahora bien, todas estas cosas están a salvo fuera de la forma en que un niño del medio
ambiente mundial. Pero seguro que hace que sean difíciles de usar. Vamos a
pedirle setup para volver tratar y mezclar de manera que podamos utilizarlos. La
mejor manera de hacerlo es devolver las funciones como una lista:
Cubierta deck <-

Card
}

}
Lista(tratar = tratar, shuffle = Shuffle)

}
WWW .IT-EBOOKS.INFO
Tarjetas <- setup(cubierta)
Figura 6-7. Ejecutar el programa de instalación guardará la cubierta y la

cubierta en un lugar fuera del camino, y crear un proyecto y función aleatoria.
Cada uno de estos objetos se almacenan en un entorno- ambiente cuyo padre
sea el medio ambiente mundial.
A continuación, puede guardar cada uno de los elementos de la lista a un

objeto dedicado en el entorno global:
Tratar <- tarjetasdeal $
Shuffle <- tarjetas$shuffle
Ahora puede ejecutar el proyecto y shuffle como antes. Cada objeto

contiene el mismo código que el reparto original y aleatorio:
Tratar
## Function() {
## Card <- Baraja[1 ].
## Assign("deck, deck[-1, ] envir = globalenv())
## Card
## }
## <entorno: 0x7ff7169c3390>
Shuffle
## Function(){
## <- muestra aleatoria(1:52, tamaño = 52)
## Assign("deck, DECK[random, ] envir = globalenv())
## }
## <entorno: 0x7ff7169c3390>
Sin embargo, las funciones tienen ahora una diferencia importante. Su origen medio
ambiente ya no es el medio ambiente mundial (aunque mucho y shuffle se
encuentran actualmente guardados
Cierres | 109
WWW .IT-EBOOKS.INFO
Allí). Su origen es el entorno runtime environment que R cuando se ejecutó
el programa de instalación. Ahí es donde R creado DEAL y SHUFFLE, las
funciones copiadas en el new deal y shuffle, como se muestra en:
Medio ambiente(deal)
## <entorno: 0x7ff7169c3390>
Medio ambiente (shuffle)

## <entorno: 0x7ff7169c3390>
¿Por qué es esto importante? Porque ahora, cuando ejecute deal o shuffle, R
evaluará las funciones en un entorno de tiempo de ejecución que
utiliza 0x7ff7169c3390 como su padre. Cubierta deck y estará en este entorno
primario, lo que significa que ocupan y shuffle podrá encontrarlos en tiempo de
ejecución. Cubierta deck y estará en la ruta de búsqueda de funciones' pero todavía
fuera de la manera en todo lo demás, como se muestra en la Figure 6-8.
Figura 6-8. Ahora tratar de reproducción aleatoria y se ejecutará en un entorno

que ha protegido la cubierta y cubierta en su ruta de búsqueda.
Este arreglo se llama un cierre. Setup's runtime environment "encierra"

el acuerdo y funciones de reproducción aleatoria. Ambas tratan y shuffle puede
trabajar estrechamente con los objetos contenidos en el entorno envolvente, pero casi nada
más. El entorno envolvente no está en la ruta de búsqueda de cualquier otra función de R
o el medio ambiente.
Usted puede haber notado que tratan y shuffle actualizar el objeto de

cubierta en el entorno mundial. No te preocupes, vamos a cambiar eso.
Queremos tratar y shuffle para trabajar exclusivamente con los objetos en los
padres (encerrar) el entorno de sus entornos de tiempo de ejecución. En lugar de
tener cada función del medio ambiente mundial de referencia para actualizar
la plataforma, puede tener ellos hacen referencia a su entorno primario en
tiempo de ejecución, como se muestra en la Figure 6-9:
Cubierta deck <-

WWW .IT-EBOOKS.INFO
Assign("deck", cubierta[-1, ], envir = parent.env (medio
ambiente()))
Card
}

Assign("deck", DECK[random, ] envir = parent.env (medio
ambiente()))
}
Lista(tratar = tratar, shuffle = Shuffle)

}
Tarjetas <- setup(cubierta)

Tratar <- tarjetasdeal $
Shuffle <- tarjetas$shuffle
Figura 6-9. Cuando usted cambia su código, tratar y shuffle irá desde la
actualización del entorno mundial (izquierda) para actualizar su entorno primario
(a la derecha).
Finalmente tenemos un auto-contenida la tarjeta de juego. Puede eliminar (o

modificar) la copia global de la plataforma tanto como quiera y aún jugar a
las cartas. Tratar y shuffle utilizará las prístinas, protegido copia
de cubierta:
Rm(cubierta)
Shuffle()
Proyecto()
## Cara Valor palo
## Ace Hearts 1
Cierres | 111
WWW .IT-EBOOKS.INFO
Proyecto()
## Cara Valor palo
## Jack clubes 11
Blackjack!
Resumen
R guarda sus objetos en un entorno de sistema que se asemeja al sistema de
archivos de su equipo. Si usted entiende este sistema, puede predecir cómo
R buscará objetos. Si llama a un objeto en la línea de comandos, R busca el
objeto en el entorno mundial y luego los padres del entorno mundial,
trabajando su camino hasta el árbol de entorno un entorno a la vez.
R se utiliza una ruta de búsqueda ligeramente diferente cuando se llama a un
objeto desde el interior de una func- ción. Cuando se ejecuta una función, R
crea un nuevo entorno para ejecutar comandos. Este medio será un niño del
ambiente donde la función fue definido originalmente. Este puede ser el medio
ambiente global, pero también puede no serlo. Este comportamiento se puede
usar para crear los cierres, que son funciones vinculadas a objetos en
entornos protegidos.
A medida que se familiarice con el medio ambiente R system, puede utilizarlo para producir
resultados elegante, como hemos hecho aquí. Sin embargo, el valor real de la comprensión
del entorno sistema viene de saber cómo R funciones hagan su trabajo. Puede utilizar este
conocimiento para averiguar lo que está mal cuando una función no funciona como se
esperaba.
Proyecto 2 Wrap-up
Ahora tendrá el control completo sobre los conjuntos de datos y los valores que usted carga
en R. Puede almacenar datos como objetos R, puede recuperar y manipular valores de
datos a voluntad, e incluso puede predecir cómo R almacenará y buscar objetos en la
memoria del ordenador.
Puede que no lo sepa, pero su experiencia le hace un potente ordenador

aumentados de datos del usuario. Puede utilizar R para almacenar y trabajar
con grandes conjuntos de datos de los que podría manejar. Hasta ahora sólo
hemos trabajado con deck, un pequeño conjunto de datos; pero puede utilizar
las mismas técnicas para trabajar con cualquier conjunto de datos que caben
en la memoria del ordenador.
Sin embargo, el almacenamiento de datos no es la única tarea logística que tendrá
que afrontar como un dato científico. A menudo deseará realizar tareas con sus
datos que son tan complejas o repetitivas que son difíciles de hacer, sin necesidad
de un ordenador. Algunas de las cosas que se pueden hacer con las funciones
que ya existen en R y sus paquetes, pero otras no pueden. Usted será el más
versátil como un dato científico si usted puede escribir sus propios programas de
computadoras para seguir. R puede ayudarle a hacerlo. Cuando esté listo, Part
III le enseñará los conocimientos más útiles para escribir programas en R.
WWW .IT-EBOOKS.INFO
Parte III
Proyecto 3: máquina
de ranura
Las máquinas tragamonedas son el juego más popular en los casinos más modernos. Si
nunca has visto uno, una máquina de ranura se asemeja a un juego de arcade que tiene
una palanca en su lado. Por una pequeña cuota puede tirar de la palanca, y la máquina
generará una combinación aleatoria de tres symbols. Si la combinación correcta aparece,
puede ganar un premio, quizás incluso el bote.
Máquinas de ranura hacer fantásticas ganancias para los casinos porque ofrecen una muy
baja tasa de pagos. En muchos juegos, como el blackjack y la ruleta, las probabilidades
son sólo ligeramente apilados en favor del casino. A la larga, el casino paga atrás de 97 a
98 centavos de cada dólar de los premios que un jugador pasa en estos juegos. Con
máquinas tragaperras, es típico de un casino a pagar sólo 90 a 95 centavos y el casino
mantiene el resto. Si esto parece disimulada, tenga en cuenta que las máquinas
tragamonedas son uno de los más populares juegos en un casino; pocas personas parecen
pensar. Y si consideran que las loterías del estado tienen porcentajes de pago que están
mucho más cerca de 50 centavos de dólar, máquinas de ranura no se ven tan mal.
En este proyecto, se construirá una máquina tragaperras real, Trabajo modelada en

algunos terminales de vídeo lotería de la vida real de Manitoba, Canadá. Los
terminales fueron una fuente de scan- dal en la década de los noventa. Podrá llegar al
fondo de este escándalo escribiendo un programa que recrea las máquinas
tragaperras. Usted entonces hacer algunos cálculos y ejecutar algunas simulaciones
que revelan la verdadera tasa de pagos de las máquinas.
WWW .IT-EBOOKS.INFO
Este proyecto le enseñará cómo escribir programas y ejecutar simulaciones
en R. también aprenderá a:
• Utilizar una estrategia práctica para el diseño de programas

• Utilice instrucciones if y else para decirle qué hacer cuando R
• Crear tablas de búsqueda para buscar los valores
• Utilice para, mientras, y repita los bucles para automatizar
operaciones repetitivas
• Utilizar métodos de S3, R la versión de programación OO
• Medir la velocidad de código R
• Escribir código rápido, vectorizar R
WWW .IT-EBOOKS.INFO
Capítulo 7
Programas
En este capítulo, usted podrá construir una máquina tragaperras real, trabajo que
puede reproducir mediante la ejecución de una función de r. Cuando haya
terminado, usted será capaz de jugar como esta:
Play()
## 0 0 DD
## $0
Play()
## 7 7 7
## $80
La función de reproducción tendrá que hacer dos cosas. En primer lugar, necesitará
generar aleatoriamente tres símbolos; y, en segundo lugar, se tendrá que calcular un
premio sobre la base de esos símbolos.
El primer paso es fácil simular. Puede generar aleatoriamente tres símbolos

con la función sample-al igual que "aleatoriamente" laminados en dos
dados Part I. La siguiente función genera tres símbolos de un grupo de
símbolos de la máquina de ranura común: diamonds (DD), sietes (7), triples
barras (BBB), barras dobles (BB), solo barras (B), cerezas (C), y ceros (0). Los
símbolos son seleccionados aleatoriamente, y cada símbolo aparece con una
probabilidad diferente:
Get_símbolos <- función() {
<- rueda c("DD", "7", "BBB", "BB", "B", "C", "0").
Muestra(rueda, tamaño = 3, sustituir = TRUE,
Prob = c(0,03, 0,03, 0,06, 0,1, 0,25, 0,01, 0,52)).
}
Puede usar get_símbolos para generar los símbolos utilizados en la máquina

de ranura:
Símbolos_get()
## "BBB" "0" "C"
Símbolos_get()
## "0", "0", "0"
115
WWW .IT-EBOOKS.INFO
Símbolos_get()
## "7" "0" "B"
Get_símbolos utiliza las probabilidades observadas en un grupo de terminales de video

lotería de Manitoba, Canadá. Estas máquinas tragamonedas se convirtió en polémica
brevemente en la década de 1990, cuando un periodista decidió poner a prueba su tasa de
pagos. Las máquinas parecían pagan sólo 40 centavos de dólar, aunque el fabricante alegó
que pagan 92 centavos de dólar. Los datos originales recogidos en las máquinas y una
descripción de la controversia está disponible en línea en a journal article by W. John Braun.
La polémica amainó cuando las pruebas adicionales demostraron que el fabricante era
correcta.
Las máquinas de ranura de Manitoba utilice el complicado régimen de pagos

se muestra en la Table 7-1. Un jugador ganará un premio si él obtiene:
1. Tres del mismo tipo de símbolo (a excepción de tres ceros)

2. Tres bares (mezcla de variedades)
3. Uno o más cerezas
De lo contrario, el jugador no recibe ningún premio.

El valor monetario del premio es determinado por la combinación exacta de símbolos
y se ve modificada por la presencia de diamantes. Los diamantes son tratados como
"wild cards", lo que significa que puede ser considerado como cualquier otro símbolo
si aumentara un jugador del premio. Por ejemplo, un jugador que saca 7 DD podría
ganar un premio para conseguir tres sietes. Hay una excepción a esta regla, sin
embargo: un diamante no puede ser considerado como una cereza, a menos que el
jugador también obtiene una verdadera cereza. Esto evita un fiasco similar, Rollo 0 DD
0 De ser calificado como 0 C 0.
Los diamantes son también especiales en otra forma. Cada diamante que aparece en
una combinación duplica la cantidad del premio final. Hasta 7 DD sería realmente
anotó superiores a 7 7 7. Tres sietes ganaría $80, pero dos sietes y un diamante
podría ganar $160. Uno de siete y dos diamantes sería aún mejor, resultando en un
premio que se ha duplicado dos veces, o $320. Jackpot se produce cuando un jugador
saca un DD DD DD. A continuación, un jugador gana 100 dólares duplicó tres veces,
que es $800.
En la tabla 7-1. Cada juego de la máquina de ranura cuesta $1. Símbolos del
Jugador determinar cuánto ganan. Diamantes (DD) son salvajes y cada
diamante dobla el premio final. * = cualquier símbolo.
Combinación Premio($)
DD DD DD 100
7 7 7 80
BBB BBB BBB 40
BB BB BB 25
116 | Capítulo 7: Programas

WWW .IT-EBOOKS.INFO
Combinación Premio($)
B B B 10
C C C 10
Cualquier combinación de
barras 5
C C * 5
C * C 5
* C C 5
C * * 2
* C * 2
* * C 2
Para crear la función de reproducción, tendrá que escribir un programa que puede
tomar la salida de get_símbolos y calcular el premio correcto basado en Table
7-1.
En R, los programas se guardan como R scripts o funciones. Guardaremos su
programa como una función denominada puntuación. Cuando haya
terminado, usted será capaz de usar puntuación para calcular un premio
como este:
Calificación(c("DD", "DD", "DD")).
## 800
Después de que será fácil crear toda la máquina de ranura, como este:
Play <- función() {
Símbolos <- get_símbolos()
Print(símbolos)
Puntuación (símbolos)
}
El comando Imprimir imprime la salida a la ventana de consola, lo que

permite imprimir una forma útil para mostrar mensajes desde dentro del
cuerpo de una función.
Usted puede notar que desempeñar una nueva función, llamadas imprimir.
Esto ayudará a jugar mostrar los tres símbolos de la máquina de ranura, ya
que no se devuelve la última línea de la función. El comando Imprimir imprime
la salida a la ventana de la consola, incluso si R llamadas desde dentro de
una función.
En Part I, yo le animó a escribir todo el código R R en un script, un archivo de
texto donde se puede redactar y guardar el código. Dicho asesoramiento será muy
importante a medida que avanza en este capítulo. Recuerde que usted puede abrir
una secuencia de comandos en R RStudio yendo a la barra de menú y haciendo
clic en Archivo > Nuevo > Archivo R Script.
Programas |
117
WWW .IT-EBOOKS.INFO
Estrategia
Los resultados de la máquina de ranura de puntuación es una tarea compleja que
requiere un algoritmo complejo.
Usted puede hacer esto, y otras tareas de codificación, más fácil usando una
estrategia simple:
1. Divida las tareas complejas en subtareas simples.

2. Utilice ejemplos concretos.
3. Describir sus soluciones en inglés y, a continuación, convertirlos a R.
Empecemos por ver cómo puede dividir un programa en subtareas que son
fáciles de trabajar con.
Un programa es un conjunto de instrucciones paso a paso para que su equipo
siga. Tomadas en conjunto, estas instrucciones pueden lograr algo muy
sofisticado. Tomado aparte, cada paso individual probablemente será fácil y
sencillo.
Puede hacer que la codificación sea más sencilla, identificando los pasos
individuales o subtareas dentro de su programa. A continuación, puede
trabajar en cada subtarea por separado. Si una subtarea parece complicado
intentar dividir de nuevo incluso en subtareas que son incluso más sencillo. A
menudo puede reducir un programa en R substasks tan simple que cada uno
puede realizarse con una función preexistente.
R programas contienen dos tipos de subtareas: pasos secuenciales y asuntos
paralelos.
Pasos secuenciales
Una forma de subdividir un programa consiste en una serie de pasos secuenciales.
La función de reproducción tiene el enfoque, se muestra en la Figure 7-1. En primer lugar,
se genera tres símbolos (paso 1) y, a continuación, se muestra en la ventana de consola
(paso 2) y, a continuación, decenas de ellos (paso 3):
# Paso 1: Generar símbolos

los símbolos <- get_símbol
os()
# Paso 2: mostrar los

símbolos print(símbolos)
# Paso 3: los símbolos

de
puntuación puntuación
(símbolos)
}
Tener R ejecutar pasos en secuencia, coloque los pasos uno tras otro en
una secuencia de comandos R o cuerpo de la función.
WWW .IT-EBOOKS.INFO
Figura 7-1. La función de reproducción utiliza una serie de pasos.
Asuntos paralelos
Otra manera de dividir una tarea es detectar grupos de casos similares dentro
de la tarea. Algunas tareas requieren diferentes algoritmos para diferentes
grupos de entrada. Si puede identificar a los grupos, puede trabajar con sus
algoritmos de uno a la vez.
Por ejemplo, la puntuación será necesario calcular el premio de una manera si
los símbolos contiene tres de una clase (en este caso, la puntuación será
necesario que coincida con el símbolo común para un
premio). Puntuación tendrá que calcular el premio una segunda forma si los
símbolos son todos los bares (en ese caso, la puntuación puede simplemente
asignar un premio de $5). Y, por último, la puntuación será necesario calcular
el premio de un tercer camino, si los símbolos no contienen tres de una clase o
todas las barras (en ese caso, la puntuación debe contar el número de cerezas
presente). calificación nunca utilizará todos los tres de estos algoritmos de
una vez; no siempre va a elegir sólo uno para ejecutar el algoritmo basado en el
com- bination de símbolos.
Los diamantes complicar todo esto porque los diamantes pueden ser tratados
como comodines. Pasemos por alto que por ahora y centrarse en el caso más
simple donde el premio doble diamantes pero no son
comodines. Puntuación puede duplicar el premio según sea necesario después
de que ejecuta uno de los siguientes algoritmos, como se muestra en la Figure 7-
2.
La adición de la puntuación de los casos al reproducir pasos revela una

estrategia para completar el programa de la máquina de ranura, como se
muestra en la Figure 7-3.
Hemos solucionado ya los primeros pasos en esta estrategia. Nuestro
programa puede obtener tres símbolos de la máquina de ranura con
la función get_símbolos. A continuación, puede mostrar los símbolos con
la función de impresión. Veamos ahora cómo el programa puede manejar los
casos de puntuación en paralelo.
Estrategia |
119
WWW .IT-EBOOKS.INFO
Figura 7-2. La función de puntuación debe distinguir entre casos paralelos.
Figura 7-3. La simulación de la máquina de ranura completa incluirá las

subtareas que son ar- variaban tanto en serie y en paralelo.
Si las declaraciones
Los casos de vinculación en paralelo, se requiere un poco de estructura; su
programa se enfrenta a una bifurcación en la carretera cada vez que debe
elegir entre los casos. Usted puede ayudar al programa a navegar esta
horquilla con una instrucción if.
Si una instrucción indica R para realizar una determinada tarea para un
determinado caso. En inglés se diría algo así como: "Si esto es verdad, ¿eso."
En R, le diría:
Si (este) {
Que
}

WWW .IT-EBOOKS.INFO
Este objeto debe ser una prueba lógica o una R expresión que evalúa a un
solo VERDADERO o FALSO. Si se evalúa como TRUE, R funcionará todo el código que
aparece entre las llaves que siguen a la instrucción if (es decir, entre los símbolos { y }).
Si se evalúa como FALSE, R omitirá el código entre las llaves sin ejecutarlo.
Por ejemplo, podría escribir una instrucción if que garantiza algunos objetos, num, es
positivo:
Si (num < 0) {
Num <- num * -1
}
Si num < 0 es VERDADERO, R multiplicará num por uno negativo, que

harán num positiva:
Num <- -2
Si (num < 0) {
Num <- num * -1
}
Núm.
## 2
Si num < 0 es false, R no hará nada y num permanecerá como es positivo (o cero):
Num <- 4
Si (num < 0) {
Num <- num * -1
}
Núm.
## 4
La condición de una instrucción if debe evaluar a un único verdadero o falso.

Si el estado crea un vector de TRUEy FALSEs (que es más fácil hacer que usted
puede pensar), la instrucción if se imprimirá un mensaje de advertencia y usar
sólo el primer elemento del vector. Recuerde que puede condensar los vectores
de valores lógicos para un único verdadero o falso con todas y cada una de
las funciones.
Usted no tiene que limitar sus sentencias if en una sola línea de código; puede incluir
tantas líneas como desee entre las llaves. Por ejemplo, el código siguiente utiliza
muchas líneas para asegurarse de que num es positivo. Las líneas adicionales imprimir
algún estado informativo- declaraciones si num comienza como un número negativo.
R omitirá el bloque de código completo-imprimir declaraciones y todo
si num comienza como un número positivo:
Num <- -1
Si (num < 0) {
Print("num es negativo.").
Print("No te preocupes, voy a arreglarlo.").
Num <- num * -1
Si las
declaraciones |
121
WWW .IT-EBOOKS.INFO
Print("Ahora num es positivo.").
}
## "Num es negativa".
## "No se preocupe, voy a arreglarlo".
## "Ahora num es positiva".
Núm.
## 1
Pruebe los siguientes cuestionarios para desarrollar su comprensión de las

sentencias if.
Un quiz
Lo que esta devolución?
X <- 1
Si (3 == 3) {
X <- 2
}
X
Respuesta: El código devolverá el número 2. X comienza en 1 y, a

continuación, R se encuentra la instrucción if. Dado que la condición se
evalúa como TRUE, R ejecutará x <- 2, cambiando el valor de x.
Quiz B
X <- 1
Si (TRUE) {
X <- 2
}
X
Respuesta: este código también devolverá el número 2. Funciona de la misma manera que
el código en un quiz, excepto la condición en esta declaración ya es True. R no necesita
evaluar. Como resultado, el código dentro de la instrucción if se ejecutará, y x se establece
en 2.
Quiz C
X <- 1
Si (x == 1) {
X <- 2
Si (x == 1) {

WWW .IT-EBOOKS.INFO
X <- 3
}
}
X
Respuesta: una vez más, el código de retorno será el número 2. X comienza como 1, y la
condición de la primera instrucción if se evalúa a verdadero, el cual causa R para ejecutar
el código en el cuerpo de la instrucción if. En primer lugar, R establece x igual a 2, entonces
R se evalúa la segunda instrucción if, que se encuentra en el cuerpo de la primera. Esta
vez x == 1 se evaluará como false porque x ahora es igual a 2. Como resultado, R
ignora x <- 3 y sale tanto si las declaraciones.
Else
Si declaraciones R dicen qué hacer cuando su condición es true, pero
también puede decirle a R qué hacer cuando la condición es false. Otra
cosa es una contrapartida a si que extiende una sentencia if para incluir un
segundo caso. En inglés, le dice, "Si esto es cierto, ¿un plan; else do plan B."
En R, le diría:
Si (este) {
Un plan
} Else {
Plan B
}
Cuando esta se evalúa a verdadero, R ejecutará el código en el primer

conjunto de llaves, pero no el código en la segunda. Cuando esta se evalúa
como FALSE, R ejecutará el código en el segundo juego de llaves, pero no el
primero. Puede utilizar este acuerdo para cubrir todos los casos posibles. Por
ejemplo, podría escribir algún código decimal que se redondea al entero más
cercano.
Comience con un decimal:
A <- 3.14
Aísle el componente decimal con trunc:

Dec <- - TRUNC(a)
Dec
## 0.14
Trunc toma un número y devuelve sólo la parte del número que aparece a la
izquierda de la coma decimal (es decir, la parte entera del número).
A - TRUNC(a) es una manera conveniente para devolver la parte
decimal de un.
A continuación, utilice un si otro árbol para redondear el número (hacia

arriba o hacia abajo):
Si (dec >= 0.5) {
A <- TRUNC(a) + 1
Else | 123
WWW .IT-EBOOKS.INFO
} Else {
A <- TRUNC(a)
}
Un
## 3
Si su situación tiene más de dos casos mutuamente exclusivos, puede

encadenar varias instrucciones if y else juntos añadiendo una
nueva instrucción if inmediatamente después de else. Por ejemplo:
<- 1
B <- 1
Si (a > b) {
Print("gana!").
} Else If (a < b) {
print("B gana!").
} Else {
Print("empate").
}
## "Empate".
R funcionará a través de la si las condiciones hasta que uno se evalúa

como TRUE, R ignorará las restantes cláusulas if y else en el árbol. Si no hay
condiciones se evalúan como TRUE, R se ejecutará la última instrucción else.
Si dos si afirmaciones describen eventos mutuamente excluyentes, es mejor

unirse a la si el estado- acuerdos con una persona, si se limita a
enumerarlas por separado. Esto permite R ignorar la segunda instrucción if
siempre que la primera devuelve un valor TRUE, que ahorra trabajo.
Puede utilizar if y else para vincular las subtareas en la función de la máquina

de ranura. Abra un nuevo r script y copie este código en ella. El código será el
esqueleto de nuestra función de puntuación final. Compárelo con el diagrama de
flujo para la puntuación en Figure 7-2:
Si ( # Caso 1: todos los mismo )
{
Premio <- # Buscar el premio
} Else if ( Caso # 2: todas las
barras ) { premio <- #
asignar $5
} Else {
# Contar las cerezas
Premio <- # calcular un premio
}
# Contar diamantes
# El premio doble si es necesario
Nuestro esqueleto es bastante incompleta; hay muchas secciones que son sólo los
comentarios de código en lugar de código real. Sin embargo, hemos reducido el
programa a ocho sencillos subtareas:
Probar si los símbolos son tres de una especie.

WWW .IT-EBOOKS.INFO
Probar si los símbolos son todas las barras.
Buscar el premio para tres de una clase basada en el símbolo común.
Asignar un premio de $5.
Contar el número de cerezas.
Contar el número de diamantes.
Calcular un premio sobre la base del número de cerezas.
Ajustar el premio para los diamantes.
Si lo desea, puede reorganizar su organigrama en estas tareas, tal como se

muestra en la Figure 7-4. El gráfico se describen la misma estrategia, pero de
una forma más precisa. Voy a usar una forma de rombo para simbolizar un if
else decisión.
Figura 7-4. puntuación puede navegar tres casos con dos si bien las
decisiones. También podemos romper algunas de nuestras tareas en dos
pasos.
Ahora podemos trabajar a través de las subtareas de a uno por vez, añadiendo R
código al árbol como si vamos. Cada subtarea será fácil de resolver si configura
un ejemplo concreto a trabajar y tratar de describir una solución en inglés antes
de la codificación en R.
La primera subtarea le pide para probar si los símbolos son tres de una
especie. ¿Cómo debería comenzar a escribir el código de esta subtarea?
Usted sabe que la función de puntuación final será algo parecido a esto:
Score <- función(símbolos) {
# Calcular un premio
Premio
}
Else | 125
WWW .IT-EBOOKS.INFO
Su argumento, símbolos, será la salida de get_symbols, un vector que contiene
tres cadenas de caracteres. Puede empezar a escribir el score como he escrito,
mediante la definición de un objeto denominado puntuación y luego, lentamente,
llenando el cuerpo de la función. Sin embargo, esto sería una mala idea. La
eventual función tendrá ocho piezas separadas y no funcionará correctamente
hasta que todas las piezas están escritos (y sí funciona correctamente). Esto
significa que usted tendría que escribir toda la función de puntuación antes de
que usted podría probar cualquiera de las subtareas. Si la puntuación no
funciona, lo cual es muy probable que no sepa qué necesidades subtarea fijo.
Usted puede ahorrar tiempo y dolores de cabeza si se centran en una subtarea
en un momento. Para cada subtarea, crear un ejemplo concreto que puede probar
su código. Por ejemplo, se sabe que la puntuación se necesita trabajar en un
vector denominado símbolos que contiene tres cadenas de caracteres. Si haces
un vector real denominada symbols, puede ejecutar el código para muchos de
sus subtareas en el vector como vaya:
Símbolos <- c("7", "7", "7").
Si un trozo de código no funciona en los símbolos, usted sabrá que usted

necesita para arreglarlo antes de avanzar. Puede cambiar el valor de
los símbolos de la subtarea a la subtarea para asegurar que el código
funciona en cada situación:
Símbolos <- c("B", "BB", "BBB").
Símbolos <- c("C", "DD", "0").
Combine únicamente las subtareas en una función de puntuación una vez

cada subtarea trabaja sobre un con- creta ejemplo. Si usted sigue este plan,
pasará más tiempo utilizando sus funciones y menos tiempo tratando de
averiguar por qué no funcionan.
Después de configurar un ejemplo concreto, intenta describir cómo se
realizará la subtarea en inglés. Más precisamente puede describir su solución,
más fácil será escribir su código R.
Nuestra primera subtarea nos invita a "probar si los símbolos son tres de una especie."
Esta frase no sugieren ningún código R útil para mí. Sin embargo, yo podría describir una
prueba más precisa de un trío: tres símbolos será el mismo si el primer símbolo es igual
que el segundo y el segundo símbolo es igual a la tercera. O, más precisamente:
Un vector llamado contendrá tres símbolos del mismo símbolo si el primer

elemento de símbolos es igual que el segundo elemento de símbolos y el
segundo elemento de símbolos es igual al tercer elemento de símbolos.
Ejercicio
Gire la instrucción anterior en una prueba lógica escrita en R. Utilice sus
conocimientos de pruebas lógicas, operadores booleanos, y de subconjuntos
de Chapter 4. La prueba debe funcionar
WWW .IT-EBOOKS.INFO
Con los símbolos de vector y devuelven true si y sólo si cada elemento
de símbolos es el mismo. Asegúrese de probar su código de símbolos.
Aquí hay un par de maneras de probar que contiene tres símbolos del mismo símbolo.
El primer método es paralela a la sugerencia anterior en Inglés, pero hay otras
maneras de hacer la misma prueba. No hay una respuesta correcta o incorrecta, tan
largo como su solución funciona, que es fácil de comprobar porque has creado un
vector denominado símbolos:
Los símbolos
## "7", "7", "7"
Símbolos[1] símbolos ==[2] [2] &

símbolos símbolos ==[3] ## TRUE
Símbolos[1] símbolos ==[2] [1] &

símbolos símbolos ==[3] ## TRUE
Todos(símbolos símbolos ==[1])

## TRUE
Como tu vocabulario amplía las funciones de R, usted pensará de más maneras de

realizar tareas básicas.
Un método que me gusta para controlar tres de una especie es:
Longitud(único(símbolos) == 1)
La exclusiva función devuelve cada término único que aparece en un vector. Si

el MJS bols vector contiene tres de una clase (es decir, un término único que
aparece tres veces), entonces (símbolos únicos) devolverá un vector de
longitud 1.
Ahora que usted tiene un test de funcionamiento, puede añadirlo a la
secuencia de comandos de la máquina de ranura:
<- [1] símbolos símbolos ==[2] && [2] símbolos símbolos ==[3]
Si la (misma) {
} Else if ( Caso # 2: todas las
barras ) { premio <- # asignar
$5
} Else {
}
# Contar diamantes
Else | 127
WWW .IT-EBOOKS.INFO
&& Y || se comportan como & y | , pero en ocasiones puede ser más eficiente.
Los operadores de dobles no se evaluará la segunda prueba en un par de pruebas
si la primera prueba da el resultado claro. Por ejemplo, si los símbolos[1] no es
igual a los símbolos[2] en la siguiente expresión, && no evaluarán símbolos[2]
== símbolos[3]; se puede volver inmediatamente una falsa para toda la
expresión (porque FALSE & TRUE y FALSE FALSE y ambos se evalúan
como FALSE). Esta eficiencia puede acelerar sus programas; sin embargo, el doble
de los operadores no son apropiadas en todas partes. && Y
|| No vectorizada, lo que significa que sólo puede manejar una sola
prueba lógica en cada lado del operador.
El segundo premio caso ocurre cuando todos los símbolos son un tipo de barra, por
ejemplo, B, BB, y BBB. Empecemos creando un ejemplo concreto para trabajar con:
Símbolos <- c("B", "BBB", "BB")
Ejercicio
Utilice R es lógico y los operadores booleanos para escribir una prueba que
determinará si un vector denominado símbolos sólo contiene símbolos que son
un tipo de barra. Compruebe si la prueba funciona con nuestro
ejemplo símbolos vectoriales. Recuerde describir cómo la prueba debería
trabajar en inglés y, a continuación, convertir la solución a R.
Como con muchas otras cosas en la R, hay varias maneras de probar si

los símbolos contiene todas las barras. Por ejemplo, podría escribir un
ensayo muy largo que utiliza múltiples operadores Booleanos, como este:
Símbolos[1] == "B" | símbolos[1] == "BB" | símbolos[1] == "BBB"
& símbolos[2] == "B" | símbolos[2] == "BB" | símbolos[2] == "B
BB" & símbolos[3] == "B" | símbolos[3] == "BB" | símbolos[3] =
= "BBB"
## TRUE
Sin embargo, esta no es una solución muy eficaz, porque R tiene para ejecutar
nueve pruebas lógicas (y tienes que escribirlas). A menudo puede sustituir
varios | operadores con una sola %en %. También, usted puede verificar que la
prueba es verdadera para cada elemento de un vector con todos. Estos dos
cambios acortar el código anterior:
Todos(símbolos %en % c("B", "BB", "BBB")).
## TRUE
Vamos a agregar este código a nuestro script:

<- [1] símbolos símbolos ==[2] && [2]
símbolos símbolos ==[3] bares <- símbolos %en
% c("B", "BB", "BBB").
Si la (misma) {
WWW .IT-EBOOKS.INFO
} Else
If (todos(barras)) {
premio <- # asignar
$5
} Else {
}
# Contar diamantes
Usted puede haber notado que puedo dividir este ensayo en dos pasos, bares y todo
(bares). Eso es sólo una cuestión de preferencia personal. Siempre que sea posible,
me gusta escribir mi código para que pueda ser leída con la función y los nombres de
objeto de transmitir lo que hacen.
Usted también puede haber notado que nuestra prueba de caso 2 capturará
algunos símbolos que debe ser en el caso 1, porque contienen tres de una
clase:
Símbolos <- c("B", "B", "B").
Todos(símbolos %en % c("B", "BB", "BBB")).
## TRUE
Eso no es un problema, sin embargo, porque hemos conectado nuestros

casos con else si en el caso de árbol. Tan pronto como R llega a un caso
que se evalúa como TRUE, se omitirá el resto del árbol. Piénsalo de esta
manera: cada persona indica R sólo ejecute el código que le sigue si ninguna
de las condiciones anteriores han sido cumplidos. Así que cuando tenemos
tres del mismo tipo de barra, R evaluará el código para el Caso 1 y, a
continuación, omita el código para el caso 2 (caso 3).
Nuestro siguiente subtarea es asignar un premio para los símbolos. Cuando
el vector de símbolos contiene tres símbolos iguales, el premio dependerá de
qué símbolo son tres. Si hay tres DDs, el premio será de $100; si hay tres 7s,
el premio será de $80; y así sucesivamente.
Esto sugiere otro si el árbol. Puede asignar un premio con un código como
este:
Si la (misma) {
Símbolo Símbolos <-[1].
Si el símbolo == "DD") {
Premio <- 800
} Else
If (símbolo == "7")
{ premio <- 80
} Else
If (símbolo == "BBB")
{ premio <- 40
} Else
If (símbolo == "BB")
{ premio <- 5
} Else
If (símbolo == "B")
{ premio <- 10
} Else
If (símbolo == "C")
{ premio <- 10
} Else
If (símbolo == "0")
{ premio <- 0
Else | 129
WWW .IT-EBOOKS.INFO
}
}
Aunque este código funcionará, es un poco de tiempo para escribir y leer, y

pueden requerir R para realizar varias pruebas lógicas correctas antes de la
entrega del premio. Podemos hacerlo mejor con un método diferente.
Tablas de búsqueda
Muy a menudo en R, la forma más sencilla de hacer algo implicará el subconjunto.
¿Cómo podrías usar subconjuntos de aquí? Desde que se conoce la relación exacta
entre los símbolos y sus premios, usted puede crear un vector que recoge esta
información. Este vector puede almacenar símbolos como los nombres y los valores
como elementos del premio:
Los
pagos <- c("DD" = 100, "7" = 80, "BBB" = 40,
"BB" = 25, "B" = 10, "C" = 10, "0" = 0).
Pagos
## DD 7 BBB BB B C 0
## 100 80 40 25 10 10 0
Ahora puede extraer el premio correcto a cualquier símbolo por subconjuntos

del vector con el nombre del símbolo:
Los pagos"DD"[]
## DD
## 100
Los pagos[] "B"

## B
## 10
Si desea dejar atrás el nombre del símbolo cuando el subconjunto, puede

ejecutar la función de nombre de la ONU en la salida:
Unname(desembolsos[] "DD")
## 100
Unname devuelve una copia del objeto con el atributo nombres

extraídos.
Desembolsos es un tipo de tabla de consultaR , un objeto que puede utilizar

para buscar valores. Sub- ajuste de pagos proporciona una manera sencilla
de encontrar el premio de un símbolo. No tome muchas líneas de código, y lo
hace de la misma cantidad de trabajo si su símbolo es DD o 0. Puede crear
tablas de búsqueda en R creando objetos con nombre que puede ser
subconjunto en formas inteligentes.
Lamentablemente, nuestro método no es automático; necesitamos decir R
cuyo símbolo para buscar en los pagos. O ¿estamos? ¿Qué pasaría si
subconjunto de pagos por símbolos[1]? Pruébalo:
WWW .IT-EBOOKS.INFO
Símbolos <- c("7", "7", "7").
Los símbolos [1].
## "7"
Los pagos[símbolos[1]]
## 7
## 80
Símbolos <- c("C", "C", "C").

Los pagos[símbolos[1]]
## C
## 10
Usted no necesita saber exactamente el símbolo para mirar hacia arriba, porque usted
puede decir R para buscar cualquier símbolo pasa a ser en símbolos. Puede
encontrar este símbolo con sym bols símbolos[1] ,[2], o símbolos[3], porque
cada uno de ellos contiene el mismo símbolo, en este caso. Ahora tienes un simple
método automatizado para calcular el premio cuando símbolos contiene tres de una
especie. Agreguemos a nuestro código y, a continuación, busque en el Caso 2:
% c("B", "BB", "BBB").
Si la (misma) {
Los
pagos <- c("DD" = 100, "7" = 80, "BBB" = 40,
"BB" = 25, "B" = 10, "C" = 10, "0" = 0).
Premio <- unname(desembolsos[símbolos[1]])
} Else
If (todos(barras)) {
premio <- # asignar
$5
} Else {
}
# Contar diamantes
Caso 2 ocurre cuando los símbolos son todas las barras. En ese caso, el
premio será de $5, lo cual es fácil asignar:
% c("B", "BB", "BBB").
Si la (misma) {
Los
pagos <- c("DD" = 100, "7" = 80, "BBB" = 40,
"BB" = 25, "B" = 10, "C" = 10, "0" = 0).
} Else
If (todos(barras))
{ premio <- 5
} Else {
}
Tablas de búsqueda | 131
WWW .IT-EBOOKS.INFO
# Contar diamantes
Ahora podemos trabajar en el último caso. Aquí, usted necesitará saber cómo
muchas de las cerezas son en símbolos antes de poder calcular un premio.
Ejercicio
¿Cómo puede saber cuáles son los elementos de un vector
denominado símbolos son una C? Diseñar una prueba y probarlo.
Desafío
Cómo se puede contar el número de cs en un vector
denominado símbolos? Recuerde R o reglas de coerción.
Como siempre, vamos a trabajar con un ejemplo real:

Símbolos <- c("C", "DD", "C").
Una manera de probar para las cerezas sería para verificar, en su caso, de los
símbolos son un C:
Símbolos == "C"
## Verdadero Falso TRUE
Sería aún más útil para contar cuántos de los símbolos son cerezas. Usted puede
hacer esto con suma, que espera entrada numérica, no lógicas. Sabiendo esto, R
restringen el verdaderoy falsos a 1s y 0s antes de proceder a la suma. Como
resultado, suma devolverá el número de verdad, que es también el número de
cerezas:
Sum(símbolos == "C").
## 2
Puede utilizar el mismo método para contar el número de diamantes

en símbolos:
Sum(símbolos == "DD")
## 1
Vamos a agregar estas dos subtareas para el esqueleto del programa:

% c("B", "BB", "BBB").
Si la (misma) {
Los
pagos <- c("DD" = 100, "7" = 80, "BBB" = 40,
"BB" = 25, "B" = 10, "C" = 10, "0" = 0).
WWW .IT-EBOOKS.INFO
} Else
If (todos(barras))
{ premio <- 5
} Else {
Las
cerezas <- suma(símbolos == "C"
) premio <- # calcular un
premio
}
Los diamantes <- suma(símbolos == "DD")

Desde el Caso 3 aparece más abajo en el árbol si que los Casos 1 y 2, el código en el
caso 3 se aplicará únicamente a los jugadores que no disponen de tres de una especie o
todas las barras. Según el plan de pago de la máquina de ranura, estos jugadores ganarán
$5 si tienen dos cerezas y $2 si tienen una cereza. Si el jugador no tiene las cerezas, ella
obtiene un premio de $0. No es necesario preocuparse de tres cerezas porque ese
resultado ya está cubierto en el caso 1.
Como en el caso 1, podría escribir un árbol si que maneja cada combinación

de cerezas, pero al igual que en el caso 1, esta sería una solución ineficaz:
Si (cerezas == 2) {
Premio <- 5
} Else
If (cerezas == 1) {
premio <- 2
} Else {}
premio <-
0
}
De nuevo, creo que la mejor solución supondrá el subconjunto. Si usted se

siente ambicioso, puede intentar trabajar esta solución en su propio, pero
usted aprenderá rápidamente así como por el trabajo mental a través de las
siguientes propuestas de solución.
Sabemos que nuestro premio debería ser de $0 si no tenemos las cerezas, $2
si tenemos una cereza, y $5 si tenemos dos cerezas. Puede crear un vector
que contiene esta información. Esta será una simple tabla de búsqueda:
C(0, 2, 5).
Ahora, como en el caso 1, puede subconjunto del vector para recuperar el

premio correcto. En este caso, el premio no se identifican por un nombre de
símbolo, sino por el número de cerezas. ¿Tenemos esa información? Sí, es
almacenado en las cerezas. Podemos usar subconjuntos de números
enteros básicas para obtener el premio correcto de la tabla de consulta previa,
por ejemplo, c(0, 2, 5)[1].
Las cerezas no es exactamente adecuado para subconjunto entero porque
podría contener un cero, pero eso es fácil de solucionar. Podemos
subconjunto con cerezas + 1. Ahora, cuando las cerezas son iguales a
cero, tenemos:
Las cerezas + 1
## 1
Tablas de búsqueda
| 133
WWW .IT-EBOOKS.INFO
C(0, 2, 5)[cerezas + 1]
## 0
Cuando las cerezas es igual a uno, tenemos:

Las cerezas + 1
## 2
C(0, 2, 5)[cerezas + 1]
## 2
Y cuando las cerezas equivale a tres, tenemos:

Las cerezas + 1
## 3
C(0, 2, 5)[cerezas + 1]
## 5
Examine estas soluciones hasta que esté satisfecho de que devolver el premio
correcto para cada número de cerezas. A continuación, añadir el código a su
script, tal y como sigue:
% c("B", "BB", "BBB").
Si la (misma) {
Los
pagos <- c("DD" = 100, "7" = 80, "BBB" = 40,
"BB" = 25, "B" = 10, "C" = 10, "0" = 0).
} Else
If (todos(barras))
{ premio <- 5
} Else {
Las
cerezas <- suma(símbolos == "C")
premio <- c(0, 2, 5)[cerezas + 1]
}

Tablas de búsqueda versus si los árboles

Esta es la segunda vez que hemos creado una tabla de búsqueda para evitar
escribir un caso de árbol. ¿Por qué es esta técnica útil y por qué siguen
apareciendo? Si muchos árboles en R son esenciales. Proporcionan una manera
útil decirle a R para utilizar diferentes algoritmos en diferentes casos. Sin
embargo, si los árboles no son apropiadas en todas partes.
Si los árboles tienen un par de inconvenientes. Primero, ellos requieren R para

ejecutar múltiples pruebas como funciona su manera abajo si el árbol, que pueden
crear un trabajo innecesario. Segundo, como verá Chapter 10, puede ser difícil de
usar si los árboles de código vectorizadas, un estilo de código que aprovecha las
fortalezas de R de programación para crear programas rápidamente. Tablas de
búsqueda no sufren cualquiera de estos inconvenientes.
WWW .IT-EBOOKS.INFO
Usted no será capaz de reemplazar cada árbol si con una tabla de búsqueda, ni
debe. Sin embargo, normalmente puede utilizar las tablas de búsqueda para evitar
asignar variables con si los árboles. Como regla general, use un árbol si si cada
rama del árbol se ejecuta código diferente. Use una tabla de búsqueda si cada
rama del árbol sólo asigna un valor diferente.
Para convertir un árbol si a una tabla de consulta, identificar los valores que se asignan
y almacenarlos en un vector. A continuación, identifique los criterios de selección
utilizados en las condiciones del árbol. Si las condiciones utilizar cadenas de
caracteres, dar el vector de su nombres y usar nombres basados en
sub- Configuración. Si las condiciones usar números enteros, utilizar subconjunto
basado en enteros.
La subtarea final es duplicar el premio una vez para cada diamante presente.
Esto significa que el premio final será algún múltiplo del premio actual. Por
ejemplo, si ningún diamonds están presentes, el premio será:
* 1
premio # 1 = 2 ^ 0
Si un diamante se presente, será:

* 2
premio # 2 = 2 ^ 1
Si están presentes dos diamantes, será:

* 4
premio # 4 = 2 ^ 2
Y si tres diamantes están presentes, será:

* 8
premio # 8 = 2 ^ 3
Puede pensar de una manera fácil de manejar esto? ¿Cómo de algo similar
a estos ejemplos?
Ejercicio
Escribir un método para ajustar premio basado en diamantes. Describir una
solución en inglés primero y, a continuación, escribir el código.
Aquí está un breve solución inspirada en el modelo anterior. El premio ajustado será igual
a:
* 2 premio ^ diamantes
Que nos da nuestra puntuación final del script:

% c("B", "BB", "BBB").
Si la (misma) {
Los
pagos <- c("DD" = 100, "7" = 80, "BBB" = 40,
"BB" = 25, "B" = 10, "C" = 10, "0" = 0).
Tablas de búsqueda | 135
WWW .IT-EBOOKS.INFO
} Else
If (todos(barras))
{ premio <- 5
} Else {
Las
}

Los comentarios de código

Ahora tienes una puntuación de trabajo script que puede guardar a una función. Antes
de guardar el script, sin embargo, considere la posibilidad de agregar comentarios a
su código con un #. Los comentarios pueden hacer que el código sea más fácil de
entender, explicando por qué el código hace lo que hace. También puede utilizar los
comentarios para romper programas de larga duración en fragmentos analizables. Por
ejemplo, yo incluiría tres comentarios en el código de puntuación:
# Identificar caso
% c("B", "BB", "BBB").
# Obtener
premio si (
misma) {
Los
pagos <- c("DD" = 100, "7" = 80, "BBB" = 40,
"BB" = 25, "B" = 10, "C" = 10, "0" = 0).
Premio <- unname(desembolsos[símbolo
s[1]]) } else if (todos(barras)) {
Premio <
- 5 } else
{
Las
}
# Ajuste de diamantes
Ahora que cada parte de tu código funciona, se puede envolver en una función con los
métodos que aprendió en “Writing Your Own Functions” on page 16. Utilice RStudio
Extracto de opción de función en la barra de menú bajo el código, o utilice la función .
Asegúrese de que la última línea de la función devuelve un resultado (no), e identificar
los argumentos utilizados por la función. A menudo los ejemplos concretos que ha
usado para probar el código, al igual que los símbolos, serán los argumentos de la
función. Ejecute el código siguiente para empezar a utilizar la función de puntuación:
Score <- función (símbolos) {
# Identificar caso
% c("B", "BB", "BBB").
WWW .IT-EBOOKS.INFO
# Obtener
premio si (
misma) {
Los
pagos <- c("DD" = 100, "7" = 80, "BBB" = 40,
"BB" = 25, "B" = 10, "C" = 10, "0" = 0).
Premio <
- 5 } else
{
Las
}
# Ajuste de diamantes
}
Una vez definida la función de puntuación, el juego funciona tan bien:

Print(símbolos)
}
Ahora es fácil jugar la máquina de ranura:

Play()
## "0" "BB" "B"
## 0
Play()
## "DD" "0" "B"
## 0
Play()
## "BB" "BB" "B"
## 25
Resumen
R Un programa es un conjunto de instrucciones para que su equipo siga que
se ha organizado en una secuencia de pasos y casos. Esto puede hacer que
los programas parecen sencillas, pero no se engañe: usted puede crear
resultados complicados con la combinación correcta de medidas sencillas (y
casos).
Como programador, tiene más probabilidades de ser engañados en el sentido opuesto. Un
programa puede parecer imposible escribir cuando usted sabe que debe hacer algo
impresionante. Que no cunda el pánico en estas situaciones. Antes de dividir el trabajo en
tareas simples y, a continuación, dividir las tareas de nuevo. Se puede visualizar la relación
entre las tareas con un diagrama de flujo si
Resumen |
137
WWW .IT-EBOOKS.INFO
Ayuda. A continuación, trabaje en las subtareas de a uno por vez. Describir
las soluciones en inglés y, a continuación, convertirlos a R código. Pruebe
cada solución contra ejemplos concretos como usted vaya. Una vez que cada
una de las subtareas obras, combinar el código en una función que puede
compartir y reutilizar.
R proporciona herramientas que pueden ayudarle a hacerlo. Puede gestionar los casos
con if y else . Puede crear una tabla de búsqueda con objetos y de subconjuntos. Puede
agregar comentarios en el código con #. Y usted puede guardar sus programas como una
función con la función.
Muchas veces las cosas van mal cuando la gente escribir programas.
Corresponderá a usted para averiguar el origen de los errores que se produzcan
y a solucionarlos. Debería ser fácil encontrar el origen de tus errores si utiliza un
enfoque gradual para escribir funciones, escribir y luego prueba un bit a la vez.
Sin embargo, si la fuente de un error elude a usted, o usted se encuentra
trabajando con grandes trozos de código no probados, considere el uso de R
construido en depuración- ging herramientas, descrito en Appendix E.
Los dos capítulos siguientes le enseñará más herramientas que puede utilizar en sus
programas. Como usted dominar estas herramientas, le resultará más fácil escribir R
programas que te permiten hacer lo que quieran a sus datos. En Chapter 8, aprenderá a
utilizar R del sistema S3, una mano invisible que formas muchas partes de R. que utilizará
el sistema para crear una clase personalizada para su salida de la máquina de ranura, y
usted dirá R cómo mostrar los objetos que tienen su clase.
WWW .IT-EBOOKS.INFO
Capítulo 8
S3
Usted puede haber notado que su máquina de ranura resultados no mirar el camino
me prometió que lo haría. He sugerido que la máquina de ranura podría mostrar sus
resultados como este:
Play()
## 0 0 DD
## $0
Pero la máquina actual muestra los resultados en un formato menos bonito:

Play()
## "0" "0" "DD"
## 0
Además, la máquina de ranura utiliza un hack para mostrar símbolos (que

llamamos imprimir desde play). Como resultado, los símbolos no siga su premio si
guarda la salida:
Uno_play <- play()
## "B" "0" "B"
Uno_play
## 0
Puede solucionar ambos problemas con R S3 del sistema.
El sistema S3
S3 se refiere a un sistema integrado en la clase R. El sistema regula cómo R
maneja objetos de diferentes clases. Ciertas funciones R buscará un objeto
de la clase S3 y, a continuación, se comportan de manera diferente en
respuesta.
La función de impresión es como esta. Cuando imprima un vector
numérico, impresión mostrará un número:
139
WWW .IT-EBOOKS.INFO
Num <- 1000000000
Print(num)
## 1000000000
Pero si se dan ese número S3 clase POSIXct seguida

por POSIXt, imprimir mostrará una vez:
Clase(num) <- c("POSIXct", "POSIXt")
Print(num)
## "2001-09-08 19:46:40 CST"
Si se utilizan objetos con clases y hacer que se ejecute en R S3 del sistema. S3

comportamiento puede parecer extraño al principio, pero es fácil predecir una vez
que se familiarice con él.
R S3 sistema se articula en torno a tres componentes: atributos

(especialmente la clase a- homenaje), funciones genéricas y métodos.
Atributos
En “Attributes” on page 43, ha aprendido que muchos objetos R vienen con atributos,
pedazos de información adicional que se les da un nombre y se anexa al objeto. Atributos
no afecta a los valores del objeto, pero atenerse al objeto como un tipo de metadatos que
r puede utilizar para manipular el objeto. Por ejemplo, una trama de datos almacena los
nombres de fila y columna como atributos. Las tramas de datos también almacenar su
clase, "data.frame", como un atributo.
Puede ver los atributos del objeto con el atributo. Si ejecuta el atributo de
la baraja la trama de datos que ha creado en Part II, podrá ver:
Atributos(cubierta)
## $names
## [1] "cara", "palo" "valor".
##
## $class
## [1] "data.frame"
##
## $row.names
## [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
## [20] 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
## [37] 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
R viene con muchas funciones de ayuda que le permiten configurar y tener

acceso a los atributos más comunes utilizados en R. ya has reunido
los nombres, dim, y funciones de clase, que cada obra con un atributo
denominado eponymously. Sin embargo, R también ha row.names, Niveles,
y muchas otras funciones auxiliares basados en atributos. Puede utilizar
cualquiera de estas funciones para recuperar un valor del atributo:
Row.names(DECK)
## [1] "1", "2", "3", "4", "5", "6", "7", "8", "9" o "10", "11", "12", "13"
## [14] "14" a "15", "16", "17", "18", "19", "20", "21", "22", "23", "24",
"25", "26"
140 | Capítulo 8: S3
WWW .IT-EBOOKS.INFO
## [27] "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37",
"38", "39"
## [40] "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50",
"51", "52"
O para cambiar el valor del atributo:

Row.names(DECK) <- 101:152
O para dar al objeto un nuevo atributo en total:

Los niveles(cubierta) <- c("nivel 1", "nivel 2", "nivel 3").
Atributos(cubierta)
## $names
## [1] "cara", "palo" "valor".
##
## $class
## [1] "data.frame"
##
## $row.names
## [1] 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
## [18] 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
## [35] 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
## [52] 152
##
## Los niveles de dólares
## [1] "nivel 1" de "nivel 2", "nivel 3"
R es muy "laissez faire" cuando se trata de atributos. Le permitirá agregar los

atributos que desea un objeto (y entonces se suele hacer caso omiso de ellos). La
única vez que r se queja es cuando una función necesita encontrar un atributo y
no está allí.
Puede agregar cualquier general a un objeto con atributos attr; también

puede usar attr para buscar el valor de cualquier atributo de un objeto.
Veamos cómo funciona esto con uno_play, el resultado de jugar nuestra
máquina de ranura una vez:
Uno_play <- play()
Uno_play
## 0
Atributos(uno_play)
## NULL
Attr toma dos argumentos: una r objeto y el nombre de un atributo (como

una cadena de caracteres). Para dar el objeto R un atributo con el nombre
especificado, guardar un valor en la salida de attr. Vamos a dar un_play un
atributo denominado símbolos que contiene un vector de character
cadenas:
Attr(1_play, "símbolos") <- c("B", "0", "B").
Atributos(uno_play)
## Símbolos de dólares
## [1] "B" "0" "B"
Atributos | 141
WWW .IT-EBOOKS.INFO
Para buscar el valor de cualquier atributo, dar attr una r objeto y el nombre
del atributo que desea buscar:
Attr(1_play, "símbolos").
## "B" "0" "B"
Si usted da un atributo a un vector atómico, como uno_play, R suele mostrar

el atributo por debajo de los valores del vector. Sin embargo, si cambia el
atributo de la clase vector, R puede mostrar toda la información en el vector
en una nueva forma (como vimos con POS IXct objetos):
Uno_play
## [1] 0
## Attr("Símbolos")
## [1] "B" "0" "B"
R generalmente ignoran los atributos del objeto a menos que les dé un nombre
que un R función busca, como nombres o clase. Por ejemplo, R ignorará
el atributo de símbolos uno_Play cuando se manipulan uno_play:
Uno_play + 1
## 1
## "B" "0" "B"
Ejercicio
Modificar la reproducción para volver un premio que contiene los símbolos
asociados a ella como un atributo denominado símbolos. Quitar la llamada
redundante para imprimir (símbolos):
Print(símbolos)
}
Puede crear una nueva versión de jugar por capturar la salida de puntuación
(símbolos) y asignar un atributo. Jugar puede volver la versión mejorada de la salida:
Premio <- (símbolos de puntuación)
Attr(premio, "símbolos") <- símbolos
Premio
}
Jugar ahora devuelve tanto el premio y los símbolos asociados con el

premio. Los resultados no parecen bastante, pero los símbolos stick con el
premio cuando nos copiarlo a un nuevo objeto. Podemos trabajar en la
limpieza de la pantalla en un minuto:
WWW .IT-EBOOKS.INFO
Play()
## [1] 0
## [1] "B" "BB" "0"
Dos_play <- play()
Dos_play
## [1] 0
## [1] "0" "B" "0"
También puede generar un premio y establecer sus atributos en un solo paso con
la estructura función. Estructura crea un objeto con un conjunto de atributos. El
primer argumento de la estructura debe ser una r objeto o conjunto de valores, y
los argumentos restantes deben ser nombrados los atributos de la estructura para
agregar al objeto. Puede otorgar estos argumentos nombres de argumento alguno que
te guste. Estructura de agregar los atributos al objeto bajo los nombres que usted
proporcione los nombres de argumento:
Estructura(puntuación (símbolos), símbolos símbolos =)
}
Tres_play <- play()

Tres_play
## 0
## "0" "BB" "B"
Ahora que tu juego salida contiene un atributo de símbolos, ¿qué puedes hacer
con él? Puede escribir sus propias funciones que buscar y utilizar el atributo. Por
ejemplo, la FOL- bajando la función Buscar uno_play's símbolos atributo y
utilizarla para mostrar uno_play en una bonita forma. Vamos a utilizar esta
función para mostrar nuestros resultados de ranura, así que tomemos un
momento para estudiar lo que hace:
Slot_display <- función(premio){
# Extraer símbolos
Símbolos <- attr(premio, "símbolos")
# Colapso símbolos en una sola

cadena símbolos <- pegar(símbolos,
colapso = " ")
# Símbolo de cosechadora con premios como una expresión regular

# \N es expresión regular para la nueva línea (es
decir, el Retorno o Intro) cadena <- pegar(símbolos,
premio, sep = "\n$")
# Mostrar expresión regular en la consola sin

comillas cat(string)
}
Atributos | 143
WWW .IT-EBOOKS.INFO
Slot_display_play(uno)
## B 0 B
## $0
La función espera un objeto como uno_play que tiene tanto un valor numérico y
un atributo de símbolos. La primera línea de la función buscará el valor del atributo
símbolos y guardarla como un objeto denominado símbolos. Hagamos un
ejemplo símbolos objeto lo podemos ver lo que el resto de la función. Podemos
utilizar un atributo_play 's símbolos para hacer el trabajo. Símbolos será un vector de
tres cadenas de caracteres:
Símbolos <- attr(1_play, "símbolos").
Los símbolos
## "B" "0" "B"
Siguiente, slot_display utiliza pegar para contraer las tres cadenas

de símbolos en una cadena de un solo carácter. Pegar contrae un vector de
cadenas de caracteres en una cadena única cuando se dé
el colapso argumento. Pegar usará el valor del colapso para separar las
cadenas anteriormente distintas. Por lo tanto, los símbolos se convierte en B
0 B las tres cadenas separadas por un espacio:
Símbolos <- pegar(símbolos, colapso = " ")
Los símbolos
## "B 0 B"
Nuestra función utiliza, a continuación, pegar en una nueva forma de

combinar símbolos con el valor del premio. Pegar combina objetos independientes en
una cadena de caracteres cuando se da un argumento de sep. Aquí, por
ejemplo, pega combinará la cadena de símbolos, B 0 B, con el número de premio,
0. Pegar usará el valor del argumento de sep para separar las entradas de la nueva
cadena. Aquí, ese valor es \n$, así que nuestro resultado se asemeja "B 0 B\n$0":
Premio <- uno_play
Cadena <- pegar(símbolos, premio, sep = "\n$")
Cadena
## "B 0 B\n$0"
La última línea de la ranura_display llama cat en la nueva cadena. Cat es

como imprimir; muestra su entrada en la línea de comandos. Sin embargo,
el gato no rodean su salida con comillas. Cat también reemplaza
cada \n con una nueva línea o un salto de línea. El resultado es lo que vemos.
Observe que se ve justo cómo me sugirió que nuestro juego de salida debe
buscar en Chapter 7:
Cat(string)
## B 0 B
## $0
Puede usar la ranura_display para limpiar manualmente la salida

de jugar:
WWW .IT-EBOOKS.INFO
Slot_display(play())
## C B 0
## $2
Slot_display(play())
## 7 0 BB
## $0
Este método de limpieza la salida le requiere a usted que intervenir

manualmente en su r la sesión (para llamar slot_display). Hay una función
que puede utilizar para limpiar automáticamente la salida de jugar cada vez
que se muestra. Esta función es imprimir, y es una función genérica.
Las funciones genéricas

R utiliza la impresión más a menudo de lo que puede pensar; R llama imprimir cada
vez que se muestra un resultado en la ventana de consola. Esta llamada se realiza en
segundo plano, de modo que no lo notan; pero la llamada explica cómo hace de salida en
la ventana de la consola (recordemos que imprimen siempre imprime su argumento en la
ventana de la consola). Esta impresión llamada también explica por qué la salida
de print siempre coincide con lo que verá al mostrar un objeto en la línea de comandos:
Print(pi).
## 3.141593
Pi
## 3.141593
Print(cabeza(cubierta))
## Valor traje cara
## Rey de picas 13
## Reina picas 12
## Jack picas 11
## Diez picas 10
## Nueve picas 9
## 8 picas 8
Cabeza(cubierta)
## Valor traje cara
## Rey de picas 13
## Reina picas 12
## Jack picas 11
## Diez picas 10
## Nueve picas 9
## 8 picas 8
Print(play())
## 5
Las funciones genéricas | 145

WWW .IT-EBOOKS.INFO
## "B" "BB" "B"
Play()
## 5
## "B" "BB" "B"
Puede cambiar cómo R muestra su salida slot reescribiendo imprimir para parecerse
a la ranura_display. A continuación, R se imprime la salida en nuestro formato
ordenado. Sin embargo, este método tendría efectos colaterales negativos. No desea
llamar a la ranura R_display cuando imprime una trama de datos numéricos, un
vector, o cualquier otro objeto.
Afortunadamente, la impresión no es una función normal; es una función

genérica. Esto significa que la impresión está escrito en una manera que le
permite hacer cosas distintas en diferentes casos. Ya has visto este
comportamiento en acción (aunque puede no haberse dado
cuenta). Imprimir hizo una cosa cuando nos fijamos en la versión de
unclassed num:
Num <- 1000000000
Print(num)
## 1000000000
Y una cosa diferente cuando nos dieron una clase: Núm.

Clase(num) <- c("POSIXct", "POSIXt")
Print(num)
## "2001-09-08 19:46:40 CST"
Echemos un vistazo al código dentro de impresión para ver cómo se hace

esto. Usted puede imaginar que la impresión es el atributo class de su entrada
y, a continuación, utiliza un árbol si elige una salida para mostrar. Si esto
ocurriera, gran trabajo! Imprimir hace algo muy similar, pero mucho más
simple.
Métodos
Cuando llame a imprimir, imprimir llama a una función
especial, UseMethod:
Imprimir
## Función (x, ...).
## UseMethod("print").
## <bytecode: 0x7ffee4c62f80>
## <entorno: namespace:base>
UseMethod examina la clase de entrada que usted proporcione para el primer

argumento de la impresión, y luego pasa todos sus argumentos para una
nueva función diseñada para manejar esa clase de entrada. Por ejemplo,
cuando se da la impresión de un objeto, UseMethod POSIXct pasará
todos imprimir's argumentos para imprimir.POSIXct. R ejecutará
entonces imprimir.POSIXct y devolver los resultados:
Print.POSIXct
## La función (x, ...).
WWW .IT-EBOOKS.INFO
## {
## Max.imprimir <-("getOption max.imprimir", 9999L)
## Si (max.imprimir < longitud(x)) {
## Print(format(x[seq_LEN(max.imprimir)], usetz = TRUE),
...).
## Cat(" [ alcanzado getOption(\"max.imprimir\") -- se
omite",
## Longitud(x) - max.impresión, "entradas ]\n").
## }
## Otra alternativa es imprimir(format(x, usetz = TRUE), ...).
## Invisible(x)
## }
## <bytecode: 0x7FA948f3d008>
Si usted da la impresión de un objeto, factor UseMethod pasará

todos imprimir's argumentos para imprimir.factor. R ejecutará
entonces imprimir.factor y devolver los resultados:
Print.factor
## Función (x, quote = FALSE max.niveles = NULL, ancho = getOption("width"),
## ...)
## {
## <- ord.es ordenado(x)
## Si (longitud(x) == 0L)
## Cat(si (ORD)
## "Ordenó"
## ...
## Drop <- n > maxl
## Cat(si (caída)
## Pegar(format(n), ""), T0, pegar(si (caída)
## C(lev[1L:max(1, maxl - 1)], "...", si (maxl > 1) lev[n])
## Otro colapso colsep lev, =), "\n", sep = "").
## }
## Invisible(x)
## }
## <bytecode: 0x7FA94a64d470>
Print.POSIXct y print.factor son llamados métodos de impresión. Por sí

mismos, print.POSIXct e imprimir. trabajo como factor R regular funciones. Sin
embargo, cada uno fue escrito específicamente para UseMethod podría llamar para
manejar una clase específica de entrada de impresión.
Observe que print. print.factor POSIXct y hacer dos cosas diferentes

(Observe también que he abreviado el medio de impresión.factor-es una larga
función). Esto es cómo imprimir consigue hacer cosas distintas en diferentes
casos. Imprimir llamadas UseMethod, que llama a un método especializado basado
en la clase de imprimir's primer argumento.
Usted puede ver qué métodos existen para una función genérica llamando
a los métodos de la func- ción. Por ejemplo, imprima tiene casi 200
métodos (lo cual nos da una idea de cuántas clases existen en R):
Métodos(print)
## [1] print.acf*
Métodos |
147
WWW .IT-EBOOKS.INFO
## [2] print.anova
## [3] print.aov*
## ...
## [176] print.xgettext*
## [177] print.xngettext*
## [178] print.xtabs*
##
## Invisible funciones están marcadas
Este sistema de funciones genéricas, métodos y envío basados en clases es

conocido como S3, ya que se originó en la tercera versión de S, el lenguaje de
programación que se prolongaría en S-PLUS y R. Muchas funciones comunes de
R S3 son genéricos que funcionan con un conjunto de métodos de clase. Por
ejemplo, el resumen y la cabeza también llamada UseMethod. Más funciones
básicas, como c, +, -, < y otros también se comportan como funciones genéricas,
aunque se llame .primitivo en lugar de UseMethod.
El sistema S3 permite R funciones a comportarse de manera diferente para las

distintas clases. S3 se puede utilizar para dar formato a la salida de la ranura. En
primer lugar, tome la salida de su propia clase. A continuación, escribir un método
de impresión para esa clase. Para hacer esto eficazmente, usted necesitará saber
un poco acerca de cómo UseMethod selecciona un método para utilizar la función.
La distribución del método

UseMethod utiliza un sistema muy simple para coincidir con los métodos a
las funciones.
S3 Cada método tiene un nombre con dos partes. La primera parte del nombre se
refieren a la función que el método funciona. La segunda parte se referirá a la
clase. Estas dos piezas estarán separados por un punto. Así, por ejemplo, el
método de impresión que funciona con funciones se llama imprimir.función.
El método de resumen que trabaja con matrices será
denominado resumen.matrix. Y así sucesivamente.
Cuando UseMethod debe llamar a un método, se busca una función con el

R3-S correcto nombre de estilo. La función no tiene que ser de alguna manera
especial; sólo tiene que tener el nombre correcto.
Usted puede participar en este sistema escribiendo su propia función y dándole un
válido S3-nombre de estilo. Por ejemplo, vamos a dar uno_play una clase propia. No
importa lo que usted llama la clase; R almacenará cualquier cadena de caracteres en
el atributo class:
Clase(uno_play) <- "ranuras"
Ahora vamos a escribir un S3, el método de impresión por las ranuras de

la clase. El método no necesita hacer nada especial, incluso no necesita
imprimir una_play. Pero no necesitan ser
denominado print.ranuras UseMethod ; de lo contrario no la
encontrará. El método también debería tener los mismos argumentos
que imprimirR ; de lo contrario, dará un error cuando intenta pasar el
arguments imprimir.ranuras:
WWW .IT-EBOOKS.INFO
Args(print)
## Función (x, ...).
## NULL
Print.ranuras <- función(x, ) { ...

Cat("estoy utilizando el método print.ranuras")
}
Nuestro método no funciona? Sí, y no sólo eso; R utiliza el método Print para
mostrar el contenido de un_play. Este método no es muy útil, así que me voy
a quitar. Usted tendrá la oportunidad de escribir uno mejor en un minuto:
Print(uno_play)
## Estoy utilizando el método print.ranuras
Uno_play
## Estoy utilizando el método print.ranuras
Rm(print.ranuras).
Algunos R objetos tienen múltiples clases. Por ejemplo, la salida de Sys. tiene
dos clases de tiempo. Que clase UseMethod usar para encontrar un método
de impresión?
Ahora <- Sys.time()
Atributos(ahora)
## $class
## [1] "POSIXct" "POSIXt"
UseMethod buscará primero un método que coincida con la primera clase enumeradas en
la clase del objeto vector. Si no puede encontrar uno UseMethod, buscará entonces el
método que coincide con la segunda clase (y así sucesivamente si hay más clases en un
objeto de la clase vector).
Si usted da impresión de un objeto cuya clase o clases no tienen un método de

impresión, UseMe dto llamará print.default, un método especial escrito para manejar
casos generales.
Vamos a utilizar este sistema para escribir un mejor método de impresión de la

máquina de ranura de salida.
Ejercicio
Escribir un nuevo método de impresión de las ranuras de la clase. El método
debe llamar slot_display para devolver bien el formato de salida de la
máquina de ranura.
¿Qué nombre debe utilizar para este método?
Es sorprendentemente fácil de escribir una buena impresión.slots método porque ya

hemos hecho todo el trabajo duro cuando escribimos slot_display. Por ejemplo, el
siguiente método funcionará. Sólo asegúrese de que el método se
denomina impresión.franjas UseMethod puedes encontrarlo,
Métodos |
149
WWW .IT-EBOOKS.INFO
Y asegúrese de que toma los mismos argumentos que se imprimen
de manera UseMethod puede pasar esos argumentos
para imprimir.ranuras sin ningún problema:
Print.ranuras <- función(x, ) { ...
Slot_display(x)
}
Ahora R utilizará automáticamente la ranura_display para mostrar los

objetos de la clase ranuras (y sólo los objetos de la clase "ranuras"):
Uno_play
## B 0 B
## $0
Vamos a asegurar que cada pieza de la máquina de ranura ranuras de

salida tiene la clase.
Ejercicio
Modificar la función de reproducción de manera que asigna las ranuras para
el atributo class de su salida:
Estructura(puntuación (símbolos), símbolos símbolos =)
}
Puede establecer el atributo class de la salida al mismo tiempo que establezca

el atributo negrita sym. Simplemente añada class = "ranuras" a
la estructura llamada:
Estructura(puntuación (símbolos), los símbolos , los símbolos =
clase = "ranuras").
}
Ahora cada una de nuestras máquinas tragamonedas juega tendrá la

clase slots:
Clase(play())
## "Ranuras"
Como resultado, R las mostrará en el formato correcto de la máquina de

ranura:
Play()
## BB BB BBB
## $5
Play()
## BB 0 0
## $0
WWW .IT-EBOOKS.INFO
Clases
Puede utilizar el sistema S3 para hacer una nueva clase de objetos sólidos en R.
luego R tratará los objetos de una clase de una manera coherente, de manera
sensata. Para hacer que una clase:
1. Elija un nombre para su clase.

2. Asignar a cada instancia de la clase un atributo de clase.
3. Los métodos de la clase de escritura para cualquier función genérica
probabilidades de usar los objetos de una clase.
Muchos R paquetes están basados en clases que se han construido en una

manera similar. Aunque este trabajo es simple, puede que no sea fácil. Por
ejemplo, considere cómo muchos métodos que existen para las clases
predefinidas.
Usted puede llamar a métodos de una clase con el argumento class, que toma una
cadena de caracteres. Métodos devolverán cada método escrito para la clase.
Observe que los métodos no va a ser capaz de mostrar los métodos que vienen en
un paquete de R descarga:
Métodos(class = "factor")
.
## [1] [.Factor [[.Factor
## [3] [[<-.factor [<-.factor
[5] Todos.La
## . igualdad.factor As.personaje.factor
## [7] como.data.frame.factor.Date.factor
Como
## [9]. factor.list. As..factor lógico
##
[11]. As.POSIXlt.factor As.vector.factor
## [13] Factor de
. Droplevels.factor formato.
##
[15]. Es.na<-.factor Length<-.factor
## Los niveles<-
[17]. .factor Math.factor
## Parcela.factor
[19]. Ops.factor *
## Vuelva a
[21]. Print.factor nivelar.factor*
Volver a poner
## en
[23]. venta.factor* Rep.factor
## [25] Resumen.factor Resumen.factor
## [27].factor xtfrm
##
## Invisible funciones están marcadas
Esta salida indica cuánto trabajo es necesario para crear un sistema robusto, well-
behaved clase.
Generalmente, necesitará escribir un método de clase para cada operación
básica de r.
Considere dos retos que tendrá que afrontar de inmediato. En primer lugar,
R cae atributos (como clase) cuando se combina objetos en un vector:
Play1 <- play()
Play1
## B BBB BBB
## $5
Play2 <- play()

Play2
## 0 B 0
Clases | 151
WWW .IT-EBOOKS.INFO
## $0
C(play1, play2)
## [1] 5 0
Aquí, R deja de utilizar print.ranuras para visualizar el vector porque el

vector c(play1, play2) ya no tiene un atributo de clase "ranuras".
A continuación, R bajará los atributos de un objeto (como clase) al subconjunto del
objeto:
Play1[1]
## [1] 5
Puede evitar este comportamiento por escrito un c.ranuras [.método y

un método de ranuras, pero entonces las dificultades se acumulan
rápidamente. ¿Cómo combinar los símbolos atributos de varias obras en un
vector de símbolos atributos? ¿Cómo cambiaría print.ranuras para
manejar vectores de salidas? Estos desafíos están abiertos para explorar. Sin
embargo, usualmente usted no deberá intentar este tipo de programación a
gran escala como un dato científico.
En nuestro caso, es muy práctico para dejar objetos ranuras volver al único
premio valores cuando se combinan grupos de ellos juntos en un vector.
S3 y depuración
S3 puede ser molesto si estás tratando de entender R funciones. Es difícil decir qué
hace una función si su cuerpo de código contiene una llamada a UseMethod. Ahora
que sabes que UseMethod llama a un método específico de clase, puede buscar y
examinar el método directamente. Será una función cuyo nombre sigue
el <función.class> sintaxis, o posiblemente <función.default>. También puede
utilizar los métodos para ver qué función meth- SAO están asociados con una función
o una clase.
S4 y R5
R también contiene otros dos sistemas que crear la clase de comportamiento
específico. Estos son conocidos como S4 y R5 (o clases de referencia). Cada uno de
estos sistemas es mucho más difícil de usar que el S3, y quizá como consecuencia,
más raras. Sin embargo, ofrecen garantías que S3 no lo hace. Si desea obtener más
información acerca de estos sistemas, incluyendo cómo escribir y usar sus propias
funciones genéricas, recomiendo el libro de próxima publicación Advanced R
Pro- gramación por Hadley Wickham.
Resumen
Los valores no son el único lugar para almacenar información en R, y las funciones no son
la única forma de crear un comportamiento único. También puede hacer ambas cosas con
R S3 del sistema.
WWW .IT-EBOOKS.INFO
El sistema S3 proporciona una manera sencilla de crear un objeto en un
comportamiento específico de R. En otras palabras, es la versión R de la
programación orientada a objetos (OOP). El sistema se apli- carse por
funciones genéricas. Estas funciones examinar el atributo class de su entrada
y llamar a un método específico de clase para generar la salida. Muchos
métodos de S3 buscará y utilizará la información adicional que se almacena
en los atributos del objeto. Muchas de las funciones de R S3 son genéricos.
R S3 el sistema es más útil para las tareas de la informática a las tareas de
los datos de la ciencia, sino la comprensión S3 puede ayudarle a solucionar
los problemas de su trabajo en I como un dato científico.
Ahora ya sabes un poco acerca de cómo escribir código R que realiza tareas
personalizadas, pero ¿cómo podría repetir estas tareas? Como un dato científico, se
suele repetir tareas, algunas veces - miles o incluso millones de veces. ¿Por qué?
Porque la repetición permite simular resultados y estimar las probabilidades. Chapter
9 Le mostrará cómo automatizar una repetición con R's y mientras funciona. Podrá
utilizar para simular distintos slot machine juega y para calcular la tasa de pagos de
la máquina tragaperras.
Resumen |
153
WWW .IT-EBOOKS.INFO
WWW .IT-EBOOKS.INFO
Capítulo 9
Los bucles
Los bucles son R método para repetir una tarea, lo que las convierte en una
herramienta útil para pro- gramación simulaciones. Este capítulo le enseñará a
utilizar las herramientas de lazo de r.
Vamos a usar la función de puntuación para resolver un problema del
mundo real.
Su máquina de ranura está modelada en verdaderas máquinas que fueron
acusados de fraude. La ma- chines parecían pagan 40 centavos de dólar, pero
el fabricante alegaron que se les paga 92 centavos de dólar. Puede calcular
exactamente la tasa de pagos de su máquina con el programa score. La tasa
de pagos será el valor esperado de la máquina de ranura del premio.
Valores esperados
El valor esperado de un evento aleatorio es un tipo de promedio ponderado; es la suma de
los posibles resultados del evento, ponderados por la probabilidad de que ocurra cada
resultado:
N
E (x) = ∑ (xi · P(xi )
I=1
Se puede pensar en el valor esperado como promedio del premio que usted podría
observar si usted juega la máquina de ranura un número infinito de veces. Vamos a utilizar
la fórmula para calcular algunos simples valores esperados. A continuación, vamos a
aplicar la fórmula para su máquina de ranura.
¿Te acuerdas de la matriz creada en Part I?

Die <- c(1, 2, 3, 4, 5, 6)
Cada vez que tira los dados, devuelve un valor seleccionado al azar (de uno
a seis). Usted puede encontrar el valor esperado de la rodadura morir con la
fórmula:
155
WWW .IT-EBOOKS.INFO
N
E (die) = ∑ (diei · P(diei )
I=1
La diei s son los posibles resultados de tirar el morir: 1, 2, 3, 4, 5 y 6; y los P(diei )'s
son las probabilidades asociadas con cada uno de los resultados. Si el morir es justo,
cada resultado se producirá con la misma probabilidad: 1/6. Así nuestra ecuación se
reduce a:
N
E (die) = ∑ (diei · P(diei )
I=1
1 1 1 1 1 1
=1· 6 +2·6 +3· 6 +4·6 +5·6 +6·6
= 3,5
Por lo tanto, el valor esperado de una feria rodante morir es de 3,5. Usted
puede notar que este también es el valor promedio de la DIE. El valor
esperado será igual a la media si cada resultado tiene la misma probabilidad
de ocurrencia.
Pero lo que si cada resultado tiene una probabilidad de ocurrencia de
diferentes? Por ejemplo, hemos dado nuestra ponderada Chapter 2 para que
cada die rodó 1, 2, 3, 4 y 5 con una probabilidad de 1/8 y 6 con una
probabilidad de 3/8. Puede utilizar la misma fórmula para calcular el valor
esperado en estas condiciones:
1 1 1 1 1 3
E (die)
=1·8 +2·8·3+8+8+4·5· 6·8+8
= 4,125
Por lo tanto, el valor esperado de un morir cargado no es igual al valor medio de

sus- viene. Si rodar una carga muere un número infinito de veces, el resultado sería el
promedio de 4,125, que es superior a lo que cabría esperar de un buen morir.
Observe que hicimos las mismas tres cosas para calcular estos dos valores
esperados. Tenemos:
1. Una lista con todos los posibles resultados

2. Determina el valor de cada resultado (aquí sólo el valor de la matriz)
3. Calcula la probabilidad de que cada resultado producido
El valor esperado fue entonces la suma de los valores en el paso 2,

multiplicado por las probabilidades en el paso 3.
Puede utilizar estos pasos para calcular los valores esperados más
sofisticados. Por ejemplo, puede calcular el valor esperado de tirar un par de
dados ponderada. Vamos a hacerlo paso a paso.
156 | Capítulo 9: Los bucles

WWW .IT-EBOOKS.INFO
En primer lugar, hacer una lista de todos los posibles resultados. Un total de
36 resultados diferentes pueden aparecer cuando tira dos dados. Por ejemplo,
es posible que el rodillo (1, 1), que notates uno en la primera mueren y uno en
el segundo dado. O bien, puede que el rodillo (1, 2), uno de los primeros en
morir y dos en el segundo. Y así sucesivamente. Listado de estas
combinaciones puede ser tedioso, pero R tiene una función que puede ayudar.
Ampliar.grid
La función expand.grid en R proporciona una forma rápida de escribir cada
combinación de elementos en n vectores. Por ejemplo, puede mostrar una
lista de todas las combinaciones de los dos dados. Para hacerlo,
ejecute expand.Parrilla en dos copias de morir:
Rollos <- expand.grid(die, die)
Ampliar.grid devolverá una trama de datos que contiene cada forma de

emparejar un elemento del primer vector mueren con un elemento del
segundo vector mueren. Este capturará todos los 36 posibles combinaciones
de valores:
Rollos
## Var1 var2
## 1 1 1
## 2 2 1
## 3 3 1
## ...
## 34 4 6
## 35 5 6
## 36 6 6
Puede utilizar Expand.grid con más de dos vectores si te gusta. Por ejemplo,
podría enumerar todas las combinaciones de los tres dados de laminación
con expand.grid(die, die, die) y cada combinación de rolling cuatro dados
con expand.grid(morir, morir, morir, morir), y así
sucesivamente. Ampliar.grid siempre devolverá una trama de datos que
contiene cada posible combi- nación de n elementos a partir de los n vectores.
Cada combinación contendrá exactamente un elemento de cada vector.
Puede determinar el valor de cada tirada una vez que haya hecho su lista de resultados, .
Esta será la suma de los dos dados, que se puede calcular utilizando R-sabio del elemento
de ejecución:
Rollos$valor <- rollos$Var1 + rollos$Var2
Cabeza(rollos, 3)
## Var1 var2 Valor
## 1 1 2
## 2 1 3
## 3 1 4
R coincidirán los elementos en cada vector antes de agregarlos juntos. Como

resultado, cada elemento de valor se refieren a los elementos
de var1 y var2 que aparecen en la misma fila.
Ampliar.grid |
157
WWW .IT-EBOOKS.INFO
A continuación, debe determinar la probabilidad de que cada combinación
aparece. Puede cal- culate esto con una regla básica de probabilidad:
La probabilidad de que n independiente, todas ocurren los eventos aleatorios
es igual al producto de las probabilidades de que cada evento aleatorio ocurre.
O más sucintamente:
P(A & B & C & ...) = P(A) · P(B) · P(C) · ...
Por consiguiente, la probabilidad de que tenemos un rollo (1, 1) será igual a la

probabilidad de que nos saca un uno en la primera mueren, 1/8 veces la probabilidad
de que nos saca un uno en la segunda morir, 1/8:
P(1 y 1) = P(1) · P(1)

1 1
=8·8
1
=
64
Y la probabilidad de que un rodillo (1, 2) será:
P(1 y 2) = P(1) · P(2)

1 1
=8·8
1
=
64
Y así sucesivamente.
Permítanme sugerir un proceso de tres pasos para el cálculo de estas
probabilidades en R. En primer lugar, podemos buscar las probabilidades de
los valores de laminación en var1. Haremos esto con la tabla que aparece a
continuación:
Prob <- c("1" = 1/8, "2" = 1/8, "3" = 1/8, "4" = 1/8, "5" = 1/8, "6" = 3/8)
Prob
## 1 2 3 4 5 6
## 0,125 0,125 0,125 0,125 0,125 0,375
Si subconjunto esta tabla por rolls$var1, obtendrá un vector de

probabilidades perfectamente encajadas en los valores de var1:
Rollos$Var1
## 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6
Prob[rollos$Var1]

WWW .IT-EBOOKS.INFO
## 1 2 3 4 5 6 1 2 3 4 5 6
## 0.125 0.125 0.125 0.125 0.125 0.375 0.125 0.125 0.125 0.125 0.125 0.375
## 1 2 3 4 5 6 1 2 3 4 5 6
## 0.125 0.125 0.125 0.125 0.125 0.375 0.125 0.125 0.125 0.125 0.125 0.375
## 1 2 3 4 5 6 1 2 3 4 5 6
## 0.125 0.125 0.125 0.125 0.125 0.375 0.125 0.125 0.125 0.125 0.125 0.375
Rollos$prob1 <
- Prob[rollos$Var1]
Cabeza(rollos,
3)
## Var1 var2 Valor Prob1
## 1 1 2 0.125
## 2 1 3 0.125
## 3 1 4 0.125
En segundo lugar, podemos buscar las probabilidades de los valores de

laminación en var2:
Rollos$prob2 <- prob[rollos$Var2]
Cabeza(rollos, 3)
## Var1 var2 valor prob1 prob2
## 1 1 2 0.125 0.125
## 2 1 3 0.125 0.125
## 3 1 4 0.125 0.125
En tercer lugar, podemos calcular la probabilidad de cada combinación de

laminación multiplicando prob1 por prob2:
Rollos$prob <- rollos$prob1 * rollos$prob2
Cabeza(rollos,
3)
## Var1 var2 valor prob1 prob2 Prob
## 1 1 2 0.125 0.125 0.015625
## 2 1 3 0.125 0.125 0.015625
## 3 1 4 0.125 0.125 0.015625
Es fácil calcular el valor esperado ahora que tenemos cada resultado, el valor de
cada resultado, y la probabilidad de cada resultado. El valor esperado será la
suma de los valores de los dados multiplicado por las probabilidades de los dados:
Sum(Rollos rollos * valor $$prob)
## 8.25
Por lo que el valor esperado de rolling dos dados cargados es 8,25. Si rodó
un par de dados cargados un número infinito de veces, la suma promedio sería
de 8,25. (Si eres curioso, el valor esperado de rodadura justo un par de dados
es 7, lo que explica por qué el 7 desempeña un gran papel en juegos de dados
como Craps).
Ahora que se ha calentado, vamos a utilizar nuestro método para calcular el
valor esperado de la máquina de ranura premio. Vamos a seguir los mismos
pasos que acabamos tomó:
1. Vamos a hacer una lista de cada posible resultado de jugar la máquina.

Esta será una lista de cada combinación de tres símbolos de ranura.
Ampliar.grid |
159
WWW .IT-EBOOKS.INFO
2. Vamos a calcular la probabilidad de obtener cada combinación cuando
usted juega la máquina.
3. Determinaremos el premio que se ganan con cada combinación.
Cuando hayamos terminado, tendremos un conjunto de datos que tiene este

aspecto:
## Var1 var2 var3 prob1 prob2 prob3 Premio prob
## DD DD DD 0.03 0.03 0.03 0.000027 800
## 7 DD DD 0.03 0.03 0.03 0.000027 0
## BBB DD DD 0.06 0.03 0.03 0.000054 0
## ... Y así sucesivamente.
El valor esperado será entonces la suma de los premios multiplicado por su

probabilidad de occuring:
N
E (premio) = ∑ (Premio premio i · P (i )
I=1
¿Listo para empezar?
Ejercicio
Utilizar expand.grid para hacer una trama de datos que contiene cada
posible combinación de tres símbolos de vector de la rueda:
Asegúrese de añadir el argumento stringsAsFactors =

False para expandir su llamada.grid; de lo
contrario, expanda.grid guardará las combinaciones como factores, una
desafortunada elección que va a trastornar la función de puntuación.
Para crear una trama de datos de cada combinación de tres símbolos, necesitará
ejecutar ex.grid pand y darle tres copias de rueda. El resultado será una
trama de datos con 343 filas, una para cada combinación única de tres símbolos
de ranura:
Combos <- expand.grid(rueda, rueda, rueda, stringsAsFactors = FALSE)
Combos
## Var1 var2 var3
## 1 DD DD DD
## 2 7 DD DD
## 3 BBB DD DD
## 4 BB DD DD
## 5 B DD DD
## 6 C DD DD
## ...
## 341B00

WWW .IT-EBOOKS.INFO
## 342 C 0 0
## 343 0 0 0
Ahora, vamos a calcular la probabilidad de obtener cada combinación. Puede

utilizar el prob- habilidades contenidas en el prob argumento
de get_símbolos para hacer esto. Esas probabilidades de determinar la
frecuencia de cada símbolo se elige cuando su máquina de ranura genera
símbolos. Se calcularon tras observar 345 obras de las terminales de vídeo
lotería de Manitoba. Los ceros tienen la mayor probabilidad de ser
seleccionadas (0,52) y las cerezas al menos (0,01):
Prob = c(0,03, 0,03, 0,06, 0,1, 0,25, 0,01, 0,52).
}
Ejercicio
Aislar el anterior las probabilidades en una tabla de búsqueda. ¿Qué
nombres se utiliza en su tabla?
Sus nombres deben coincidir con la entrada en la que desea buscar. En este
caso, la entrada será las cadenas de caracteres que aparecen
en var1, var2 var3 , y. De modo que su tabla de búsqueda debe tener este
aspecto:
Prob <- c("DD" = 0,03, "7" = 0,03, "BBB" = 0,06,
"BB" = 0,1, "B" = 0,25, "C" = 0,01, "0" = 0,52)
.
Ahora miremos nuestras probabilidades.
Ejercicio
Busque las probabilidades de obtener los valores de var1. Después agregarlas
a combos como una columna denominada prob1. Haga lo mismo para var2 (prob2)
y var3 (prob3).
Recuerde que debe utilizar la notación de selección r para buscar valores en

una tabla de búsqueda. Los valores que el resultado será clave para el
índice que se utilice:
Combos$prob1 <- prob[combos$Var1]
Cabeza(combos, 3)
## Var1 var2 var3 prob1 prob2 prob3
## DD DD DD 0,03 0,03 0,03
Ampliar.grid |
161
WWW .IT-EBOOKS.INFO
## 7 DD DD 0.03 0.03 0.03
## BBB DD DD 0,06 0,03 0,03
Ahora, ¿cómo debemos calcular el total de probabilidad de cada

combinación? Nuestros tres símbolos de ranura son elegidas de manera
independiente, lo que significa que la misma norma que rige nuestras
probabilidades de dados rige nuestro símbolo probabilidades:
P(A & B & C & ...) = P(A) · P(B) · P(C) · ...
Ejercicio
Calcular el total de las probabilidades para cada combinación. Guardarlos
como una columna denominada prob en combosy, a continuación, revisar su
trabajo.
Puede comprobar que la matemática ha trabajado sumando las probabilidades. Las
probabilidades debería sumar uno, porque una de las combinaciones debe aparecer
cuando usted juega la máquina tragaperras. En otras palabras, una combinación
aparecerá, con una probabilidad de uno.
Puede calcular las probabilidades de cada combinación posible de un

plumazo con algún elemento-wise ejecución:
Combos$prob <- combos$prob1 * combos$prob2 * combos$prob3
Cabeza(combo
s, 3)
## Var1 var2 Var3 prob1 prob2 prob3 Prob
## DD DD DD 0.03 0.03 0.03 0.000027
## 7 DD DD 0.03 0.03 0.03 0.000027
## BBB DD DD 0,06 0,03 0,03 0.000054
La suma de las Probabilidades es uno, lo que sugiere que nuestra

matemática es correcta:
Sum(combos$prob)
## 1
Usted sólo necesita hacer una cosa más antes de poder calcular el valor esperado: debe
determinar el premio para cada combinación de combos. Puede calcular el premio
con puntuación. Por ejemplo, podemos calcular el premio para la primera fila
de combos como este:
Símbolos <- c(combos[1, 1], combos[1, 2], combos[1, 3])
## "DD" "DD" "DD"
## 800
Sin embargo, hay 343 filas, lo que hace que el trabajo tedioso si va a calcular
las puntuaciones manualmente. Será más rápido para automatizar esta tarea
y tienen R lo haga por usted, que usted puede hacer con un bucle for.
WWW .IT-EBOOKS.INFO
Bucles for.
Un bucle for un trozo de código se repite muchas veces, una vez para cada
elemento de un conjunto de datos de entrada. Los bucles for proporcionan
una manera de decirle a R, "Hacer esto para cada valor de eso." En R sintaxis,
esto tiene el siguiente aspecto:
(Valor ) {
Este
}
El objeto debe ser un conjunto de objetos (a menudo un vector de números o

cadenas de caracteres). El bucle for se ejecutará el código que aparece entre
las llaves una vez para cada miembro de esa. Por ejemplo, el bucle for a
continuación va print("RUN") una vez para cada elemento de un vector de
cadenas de caracteres:
(Valor en c("mi", "primero", "para", "
loop")) { print("ejecutar").
}
## "Ejecutar"
## "Ejecutar"
## "Ejecutar"
## "Ejecutar"
El valor de los símbolos de un bucle for actúa como argumento de una función.
El bucle for creará un objeto denominado valor y asignar un nuevo valor en cada
ejecución del bucle. El código del bucle puede obtener acceso a este valor
llamando al objeto de valor.
¿Qué valores del bucle para asignar al valor? Se utilizarán los elementos en el conjunto
en el que se ejecuta el bucle. Para comienza con el primer elemento y, a continuación,
asigna un valor al elemento diferente en cada ejecución del bucle for, hasta que
todos los elementos se han asignado al valor. Por ejemplo, el bucle for se ejecutará a
continuación imprimir(valor) cuatro veces y se imprimirá un elemento de c ("Mi",
"segundo", "para", "loop") cada vez:
(Valor en c("mi", "segundo", "para", "l

oop")) { print(valor)
}
## "Mi"
## El "segundo"
## "For".
## "Bucle"
En la primera tanda, el bucle for sustituye "mi" para el valor en

el print(valor). En la segunda tanda que sustituía el "segundo", y así
sucesivamente hasta que se ejecute print(valor) una vez con cada
elemento del conjunto:
Si nos fijamos en valor después del bucle se ejecute, verá que aún contiene
el valor del último elemento en el juego:
Valor
## "Loop"
Bucles for. |
163
WWW .IT-EBOOKS.INFO
He estado usando el valor del símbolo en mi bucles for, pero no hay nada
especial acerca de él. Puede utilizar cualquier símbolo que te gusta en el bucle
para hacer la misma cosa mientras el símbolo aparece antes en los paréntesis
que siguen para. Por ejemplo, se puede reescribir el bucle anterior con alguno
de los siguientes:
(Palabra en c("mi", "segundo", "para",
"loop")) { print(word)
}
(Cadena en c("mi", "segundo", "para", "l
oop")) { print(string)
}
Para i en c("mi", "segundo", "para",
"loop")) { print(i)
}
Elegir cuidadosamente sus símbolos

R ejecutará el bucle en cualquier ambiente desde el cual lo ejecute.
Esta es una mala noticia si el bucle utiliza nombres de objeto que ya
existen en el medio ambiente. El bucle sobrescribirá los objetos
existentes con los objetos que crea. Esto se aplica al símbolo de valor.
Para ejecutar bucles en conjuntos

En muchos lenguajes de programación, para bucles están diseñados para
trabajar con números enteros, no establece. Te dará el bucle de un valor
inicial y un valor final, así como un incremento en el valor por anticipado
entre los bucles. A continuación, se ejecuta el bucle for el bucle hasta que
el valor supere el valor final.
Puede recrear este efecto en R por tener un bucle para ejecutar

un conjunto de enteros, pero no perder de vista el hecho de que
R para ejecutar bucles en los miembros de un conjunto, no
secuencias de números enteros.
Los bucles for son muy útiles en la programación porque le ayudan a conectar un
trozo de código con cada elemento de un conjunto. Por ejemplo, podríamos utilizar
un bucle for para ejecutar una puntuación para cada fila de combos. Sin embargo,
R para bucles tienen una deficiencia que querrá conocer antes de empezar a
utilizarlos: para bucles no salida de retorno.
Los bucles for son como Las Vegas: lo que ocurre en un bucle for
permanece en un bucle for. Si desea utilizar los productos de un bucle for,
debe escribir el bucle for para que guarde su propia producción como va.
Nuestros ejemplos anteriores parecía salida de retorno, pero esto es engañoso.
El examen- ples funcionó porque nos llama imprimir, que siempre imprime sus
argumentos en la consola (incluso si se llama desde una función, un bucle for, o
cualquier otra cosa). Nuestros bucles no devolverá nada si quita
la impresión llamada:
WWW .IT-EBOOKS.INFO
(Valor en c("mi", "terceros", "para",
"loop")) { valor
}
##
Para guardar la salida de un bucle for, debe escribir el bucle de modo que guarda su propia
producción a medida que se ejecuta. Usted puede hacer esto mediante la creación de un
vector o lista vacía antes de ejecutar el bucle for. A continuación, utilizar el bucle for para
llenar el vector o lista. Cuando el bucle for es terminado, podrás acceder a la lista o vector,
que ahora tendrá todos sus resultados.
Veamos esto en acción. El siguiente código crea un vector vacío de longitud 4:

Chars <- vector (longitud = 4).
El siguiente bucle la rellenará con cadenas:

Palabras <- c("mi", "cuarto", "para", "loop")
Para i en 1:4) {
Chars[i] <- palabras[i]
}
Chars
## "Mi" "Cuarto" "for". "Bucle"
Este enfoque suele exigir que cambie los conjuntos que se ejecute el bucle for.
En lugar de ejecutarse en un conjunto de objetos, ejecutar en un conjunto de
enteros que puede utilizar para indexar tanto su objeto y su vector de
almacenamiento. Este enfoque es muy común en R. encontrará en la práctica que
el uso de bucles, no tanto para ejecutar código, pero llenar de vectores y las listas
con los resultados de código.
Vamos a utilizar un bucle for para calcular el premio por cada fila de combos.
Para empezar, cree una nueva columna en combos para almacenar los
resultados del bucle for:
Combos$premio <- NA
Cabeza(combos,
3)
## Var1 var2 var3 prob1 prob2 prob3 Premio prob
## DD DD DD 0.03 0.03 0.03 0.000027 NA
## 7 DD DD 0.03 0.03 0.03 0.000027 NA
## BBB DD DD 0.06 0.03 0.03 0.000054 NA
El código crea una nueva columna denominada premio y lo llena con NAs. R
utiliza sus normas de reciclaje para rellenar cada valor de la columna con NA.
Bucles for. | 165
WWW .IT-EBOOKS.INFO
Ejercicio
Crear un bucle para que se ejecute la puntuación en todos los 343 filas
de combos. El bucle debe ejecutar puntuación en las tres primeras entradas
de la Iª fila de combos y debe almacenar los resultados en la iésimaentrada
de combos$premio.
Usted puede marcar las filas de combos con:

Para i en 1:nrow(combos) {
Símbolos <- c(combos[i, 1], combos[i, 2], combos[1, 3])
Combospremio $[i] <- (símbolos de puntuación)
}
Después de ejecutar el bucle for, combos$premio contendrá el premio

correcto para cada fila. Este ejercicio también prueba la función de
puntuación; score parece que funciona correctamente para cada posible
combinación de ranura:
Cabeza(combo
s, 3)
## Var1 var2 Var3 prob1 prob2 prob3 Premio prob
## DD DD DD 0.03 0.03 0.03 0.000027 800
## 7 DD DD 0.03 0.03 0.03 0.000027 0
## BBB DD DD 0.06 0.03 0.03 0.000054 0
Ahora estamos listos para calcular el valor esperado del premio. El valor
esperado es la suma de combos$premio ponderado por combos$prob. Esta
es también la tasa de pagos de la máquina de ranura:
Sum(combos combos * Premio $$prob)
## 0.538014
Uh oh. El premio esperado es de alrededor de 0,54, lo que significa que

nuestra máquina de ranura sólo paga 54 centavos de dólar en el largo plazo.
¿Esto significa que el fabricante de las máquinas de ranura de
Manitoba estaba mintiendo?
No, porque hemos ignorado una importante característica de la máquina de ranura
cuando escribimos puntuación: Un diamante es un comodín. Se puede tratar de
una DD como cualquier otro símbolo si aumenta su premio, con excepción de uno de
ellos. No puede hacer un DD C a menos que ya tenga otra C en sus símbolos (sería
demasiado fácil si cada DD automáticamente ganado $2).
La mejor cosa sobre DDs es que sus efectos son acumulativos. Por ejemplo,
considerar la combinación B, DD B. No solamente el DD cuentan como un B,
que podría ganar un premio de $10; el DD también se dobla el premio a $20.
La adición de este comportamiento para nuestro código es un poco más difícil que lo que
hemos hecho hasta ahora, sino que implica a todos los mismos principios. Usted puede
decidir que su máquina de ranura no utilice comodines y mantener el código que tenemos.
En ese caso, su máquina de ranura tendrá una tasa de pagos de alrededor del 54 por
ciento. O bien, se puede reescribir el código para utilizar comodines. Si usted lo hace, usted
WWW .IT-EBOOKS.INFO
Encontrará que su máquina de ranura tiene un porcentaje de pagos del 93 por
ciento, un uno por ciento más que la reclamación del fabricante. Se puede
calcular este índice con el mismo método que hemos utilizado en esta sección.
Desafío
Hay muchas maneras de modificar la puntuación que contaría DDs como
silvestres. Si quieres poner a prueba tus habilidades como programador de
una R, intentar escribir su propia versión de puntuación que controla
correctamente los diamantes.
Si quieres un desafío más modestos, estudiar el siguiente código de
puntuación. Representa wild diamantes en una manera que puedo encontrar
elegantes y concisos. A ver si puedes entender cada paso en el código y cómo
logra su resultado.
Aquí está una versión de puntuación que maneja wild diamantes:

Score <- función(símbolos) {

Las cerezas <- suma(símbolos == "C").
# Identificar caso
# Puesto que los diamantes son salvajes, sólo nondiamonds
# Asunto de tres de una clase y
todas las ranuras de las barras
de símbolos <-[símbolos != "DD"]
Mismo <- longitud(único(slots)) == 1 b
ares <- ranuras %en
% c("B", "BB", "BBB").
# Asignar premio
Si (diamantes == 3) {
Premio <- 100
} Else If (misma) {
Los
pagos <- c("7" = 80, "BBB" = 40, "BB"
= 25, "B" = 10, "C" = 10, "0" = 0).
Premio <- unname(desembolsos[ranur
as[1]]) } else if (todos(barras)) {
Premio <- 5
} Else If (cerezas > 0) {
# Los diamantes cuentan como cerezas
# Siempre que hay una verdadera cherry
Premio <- c(0, 2, 5)[cerezas + diamantes + 1]
} Else {
premio <-
0
}
# Doble para cada premio

diamante * 2^diamantes
}
Bucles for. | 167
WWW .IT-EBOOKS.INFO
Ejercicio
Calcular el valor esperado de la máquina de ranura cuando se utiliza la
nueva función de puntuación. Puede utilizar el marco de datos combos
existentes, pero necesitará crear un bucle for para recalcular
los combos$premio.
Para actualizar el valor esperado, sólo actualizar combos$premio:

Para i en 1:nrow(combos) {
Símbolos <- c(combos[i, 1], combos[i, 2], combos[1, 3])
Combospremio $[i] <- (símbolos de puntuación)
}
A continuación, se vuelve a calcular el valor esperado:

Sum(combos combos * Premio $$prob)
## 0.934356
Este resultado confirma la reclamación del fabricante. En todo caso, las

máquinas de ranura parecen más generoso que el fabricante afirma.
Los bucles while

R tiene dos compañeras al bucle for: el bucle while y el bucle repeat. Un bucle
while ejecuta de nuevo un fragmento mientras una determinada condición sigue
siendo True. Para crear un bucle while, siga mientras por un Estado y un trozo
de código como este:
Mientras (condición) {
Código
}
Mientras se volverán a ejecutar condición, que debe ser una prueba lógica,
al inicio de cada ciclo. Si la condición se evalúa como TRUE, mientras se
ejecuta el código entre sus llaves. Si la condición se evalúa
como FALSE, mientras se termina el bucle.
¿Por qué podría el estado cambia de True a False? Presumiblemente porque el

código dentro de su bucle ha cambiado aún si la condición es TRUE. Si el código no
tiene ninguna relación con el estado, un bucle while se ejecuta hasta que la detenga.
Así que ten cuidado. Puede detener un bucle while golpeando escapar o haciendo
clic en el icono de señal de stop en la parte superior del panel de consola RStudio. El
icono aparecerá una vez que el bucle comienza a funcionar.
Como los bucles for, que los bucles while no devuelve un resultado, por lo
que debe pensar lo que quiera del bucle de retorno y guárdelo en un objeto
durante el bucle.
Puede utilizar los bucles while para hacer cosas que tengan un número variable
de iteraciones, como calcular cuánto tiempo se tarda en ir a la quiebra las ranuras
de juego (como sigue). Sin embargo, en la práctica, mientras que los bucles
son mucho menos comunes que los bucles for en R:
WWW .IT-EBOOKS.INFO
Juega_hasta_rompió <- función(start_con) {
Cash <- start_con
N <- 0
Mientras (cash > 0) {
<- efectivo efectivo - 1 + play()
N <- n + 1
}
N
}
Juega_hasta_rompió(100)
## 260
Repita los bucles

Repita los bucles son incluso más básicas de bucles while. Que se vuelva
a repetir un trozo de código hasta que les dices a tope (golpeando escapar) o
hasta que encuentre el comando break, que detendrá el bucle.
Puede utilizar un bucle de repetición para recrear juega_hasta_rompió, mi
función que simula cuánto se tarda en perder dinero mientras juegas ranuras:
Juega_hasta_rompió <- función(start_con) {
Cash <- start_con
N <- 0
Repita {
<- efectivo efectivo - 1 + play()
N <- n + 1
Si (cash <= 0) {
Romper
}
}
N
}
Juega_hasta_rompió(100)
## 237
Resumen
Puede repetir tareas en R con para, mientras, y repita los bucles. Para
utilizar , para darle un trozo de código para ejecutar y un conjunto de objetos
para recorrer. Para el fragmento de código se ejecutará una vez para cada
objeto. Si desea guardar la salida del bucle, puede asignar a un objeto que
existe fuera del bucle.
La repetición juega un papel importante en los datos científicos. Es la base para la
simulación, así como de estimaciones de la varianza y la probabilidad. Los bucles no son
la única forma de crear repe- tition en R (considere la posibilidad de replicar, por
ejemplo), pero son una de las maneras más populares.
Repita los bucles

| 169
WWW .IT-EBOOKS.INFO
Lamentablemente, los bucles en R A veces puede ser más lento que los bucles en
otros idiomas. Como resultado, los bucles de R de un mal rap. Esta reputación no es
completamente merecida, pero no alto- la luz una cuestión importante. La velocidad
es esencial para el análisis de datos. Cuando se ejecuta el código rápido, usted puede
trabajar con más datos y hacer más antes de que se agote el tiempo o com- putational
potencia. Chapter 10 Le enseñará cómo escribir rápido para bucles y código rápido
en general con R. allí, aprenderás a escribir código vectorizadas, un estilo de
rapidísimas código que aprovecha todas las ventajas de r.

WWW .IT-EBOOKS.INFO
Capítulo 10
Velocidad
Como un dato científico, necesitas velocidad. Puede trabajar con datos más
grande y hacer más ambi- te infeccioso tareas cuando se ejecuta el código
rápido. Este capítulo le mostrará un modo específico de escribir código rápido
en R. A continuación utilizará el método para simular 10 millones de juegos de
la máquina tragaperras.
Código vectorizadas
Puede escribir un trozo de código en muchas formas diferentes, pero el más
rápido R código se suele tomar ventaja de tres cosas: pruebas lógicas,
subconjuntos, y element-wise la ejecución. Estas son las cosas que R hace mejor.
Código que utiliza estas cosas generalmente tiene una cierta calidad:
es vectorizar; el código puede tomar un vector de valores como entrada y
manipular cada valor en el vector al mismo tiempo.
Para ver qué aspecto tiene el código vectorizadas comparar estos dos ejemplos de la
función de valor absoluto. Cada uno toma un vector de números y la transforma en un
vector de valores absolutos (por ejemplo, números positivos). El primer ejemplo no es
vectorizado; abs_loop utiliza un bucle for para manipular cada elemento del vector
de uno en uno:
Abs_loop <- función(VEC){
Para i en 1:longitud(vec)) {
Si (vec[i] < 0) {
Vec[i] <--vec[i]
}
}
Vec
}
En el segundo ejemplo, abs_set, es una versión vectorizada de abs_loop. Utiliza

sub- Configuración lógica para manipular cada número negativo en el vector al
mismo tiempo:
Abs_establece <- función(VEC){
<- negs vec < 0
171
WWW .IT-EBOOKS.INFO
Vec[negs] <- negs vec[ -1] *
Vec
}
Abs_set es mucho más rápido que el abs_loop porque se basa en las operaciones que R
hace rápidamente:
Pruebas lógicas, subconjuntos, y element-wise la ejecución.
Puede usar la función system.time para ver cuan
rápido abs_set . System.time toma una expresión R, ejecuta y, a
continuación, muestra cuánto tiempo transcurrido mientras la expresión corrió.
Comparar abs_loop y abs_set, en primer lugar hacer un largo vector de
números positivos y negativos. Siempre contendrá 10 millones de valores:
Long <- rep(c(-1, 1), 5000000)
Rep repite un valor, o un vector de valores, muchas veces. Utilizar rep,

asígnele un vector de valores y, a continuación, el número de veces que
se repite el vector. R devolverá los resultados en una nueva, más vector.
A continuación, puede usar System.tiempo para medir cuánto tiempo tarda

cada función evaluar a largo:
System.time(abs_loop(long)
## Transcurrido el sistema de usuario
## 15.982 0.032 16.018
System.time(abs_establece(long)
## 0.529 0.063 0.592
No confunda system.time con Sys.time, que devuelve la hora actual.
Las dos primeras columnas de la salida del sistema. Informe de tiempo

cuántos segundos el equipo dedicado a ejecutar la llamada por parte del
usuario y el sistema de partes de su proceso, una dicotomía que variarán
desde OS A OS.
La última columna muestra el número de segundos transcurridos mientras R
corrió la expresión. Los resultados muestran que la abs_set calcula el valor
absoluto 30 veces más rápido que el abs_loop cuando se aplica a un vector
de 10 millones de números. Usted puede esperar una velocidad similar-ups
siempre que escribir código vectorizadas.
Ejercicio
Muchas funciones ya están R preexistentes vectorizar y han sido optimizados para
per- formulario rápidamente. Se puede hacer el código más rápido apoyándose en
estas funciones siempre que sea posible. Por ejemplo, R incorpora una función de valor
absoluto, ABS.
172 | Capítulo 10: Velocidad
WWW .IT-EBOOKS.INFO
Compruebe para ver cuánto más rápido abs calcula el valor absoluto de largo de abs_loop
Y abs_set .
Usted puede medir la velocidad de ABS con System.time. Abs tarda una vertiginosa
velocidad de 0,05 segundos para calcular el valor absoluto de 10 millones de números.
Esto es 0.592 / 0.054 =
10.96 veces más rápido que el abs_set y casi 300 veces más rápido que
el abs_loop:
System.time(abs(long)
## 0.037 0.018 0.054
Cómo escribir código vectorizadas

Vectorizar es fácil escribir código en R R porque la mayoría de las funciones
ya están vectorizado. Código basado en estas funciones puede hacerse
fácilmente vectorizar y por lo tanto rápido. Para crear código vectorizadas:
1. Utilizar funciones vectorizadas para completar los pasos secuenciales en su

programa.
2. Utilizar subconjuntos lógicos para manejar asuntos paralelos. Intentar
manipular cada elemento en un caso a la vez.
Abs y abs_loop_set ilustran estas reglas. Las funciones tanto manejar dos casos
y realizar un paso secuencial, Figure 10-1. Si el número es positivo, las funciones
dejarlo solo. Si el número es negativo, las funciones se multiplica por uno negativo.
Figura 10-1. abs_loop utiliza un bucle for para tamizar los datos en uno de los
dos casos: negativo num- bers y números no negativos.
Puede identificar todos los elementos de un vector que caen en una caja con una prueba
lógica. R ejecutará la prueba en el elemento-wise moda y devolver un valor
verdadero para cada elemento que
Cómo escribir código vectorizadas
| 173
WWW .IT-EBOOKS.INFO
Pertenece en el caso. Por ejemplo, vec < 0 identifica cada valor de vec que
pertenece al caso negativo. Puede usar la misma prueba lógica para extraer
el conjunto de valores negativos con subconjuntos lógicos:
Vec <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).
Vec < 0
## Falso VERDADERO VERDADERO FALSO FALSO FALSO VERDADERO FALSO
VERDADERO VERDADERO
Vec[vec < 0]
## -2 -4 -6 -8 -10
El plan Figure 10-1 exige ahora un paso secuencial: debe multiplicar cada uno de
los valores negativos por uno negativo. Todos R operadores aritméticos son
vectorizadas, así que usted puede usar * para completar este paso de moda
vectorizadas. * Se multiplica cada número en el VEC[vec < 0] por uno negativo
al mismo tiempo:
Vec[vec < 0] * -1
## 2 4 6 8 10
Por último, puede utilizar R del operador de asignación, que es también

vectorizado, para guardar el nuevo conjunto en el juego antiguo en el vec
original objeto. Desde <- es vectorizado, los elementos de la nueva serie se
emparejan con los elementos del juego antiguo, en orden y, a continuación,
element-sabio se producirá de asignación. Como resultado, cada valor negativo
será sustituido por su compañero, como positivo en Figure 10-2.
Figura 10-2. Utilizar subconjuntos lógicos para modificar grupos de valores en

su lugar. R aritmética y operadores de asignación son vectorizadas, que le
permite manipular y actualizar- ple varios valores a la vez.

WWW .IT-EBOOKS.INFO
Ejercicio
La siguiente función se convierte en un vector de símbolos de ranura a un vector de
nuevos símbolos de ranura. Puede vectorización? ¿Cuánto más rápido la versión
vectorizadas trabajo?
Change_símbolos <- función(VEC){
Para i en 1:longitud(vec)){
Si (vec[i] == "DD") {
Vec[i] <- "Joker"
} Else
If (vec[i] == "C") {
vec[i] <- "ACE"
} Else If (vec[i] == "7")
{ vec[i] <- "king"
}Else If (vec[i] == "B") {
Vec[i] <- "reina"
} Else If (vec[i] == "BB")
{ vec[i] <- "jack"
} Else If (vec[i] == "BBB")
{ vec[i] <- "diez"
} Else {
Vec[i] <- "nueve".
}
}
Vec
}
Vec <- c("DD", "C", "7", "B", "BB", "BBB", "0").
Cambiar_symbols(vec)
## "Joker" "Ace" "rey", "reina" "jack" "diez" "nueve".
Muchos <- rep(vec, 1000000)
System.time(change_símbolos(muchos)
## 30.057 0.031 30.079
Cambiar_symbols usa un bucle for para ordenar valores en siete casos

diferentes, como demonio- strated en Figure 10-3.
Para vectorización change_símbolos, crear una prueba lógica que puede
identificar cada caso:
Vec[vec == "DD"]
## "DD"
Vec[vec == "C"]
## "C"
Vec[vec == "7"]
## "7"
Cómo escribir código vectorizadas | 175

WWW .IT-EBOOKS.INFO
Vec[vec == "B"]
## "B"
Vec[vec == "BB"]
## "BB"
Vec[vec == "BBB"]
## "BBB"
Vec[vec == "0"]
## "0"
Figura 10-3. Change_muchos hace algo diferente para cada uno de los siete
casos.
A continuación, escribir código que puede cambiar los símbolos para cada
caso:
Vec[vec == "DD"] <- "Joker"
Vec[vec == "C"] <- "ACE"
Vec[vec == "7"] <- "king"
Vec[vec == "B"] <- "reina"
Vec[vec == "BB"] <- "jack"
Vec[vec == "BBB"] <- "diez"
Vec[vec == "0"] <- "nueve".
Cuando se combinan en una función, tiene una versión vectorizada

de change_sym bols que corre alrededor de 14 veces más rápido:
Change_vec <- función (VEC) {
Vec[vec == "DD"] <- "Joker"
Vec[vec == "C"] <- "ACE"
Vec[vec == "7"] <- "king"
Vec[vec == "B"] <- "reina"
Vec[vec == "BB"] <- "jack"

WWW .IT-EBOOKS.INFO
Vec[vec == "BBB"] <- "diez"
Vec[vec == "0"] <- "nueve".
Vec
}
System.time(change_vec(muchos)
## 1.994 0.059 2.051
O, mejor aún, use una tabla de búsqueda. Tablas de búsqueda son un

método vectorizadas porque dependen de R vectorizar las operaciones de
selección:
Change_vec2 <- función(VEC){
Tb <- c("DD" = "Joker", "C" = "Ace", "7" = "rey", "B" = "
reina", "BB" = "jack", "BBB" = "10", "0" = "9").
Unname(tb[vec])
}
System.time(change_vec(muchos)
## 0.687 0,059 0,746
Aquí, una tabla de búsqueda es 40 veces más rápido que la función original.
Abs_ change_loop y muchos ilustran una característica de vectorizar código:
programadores suelen escribir código nonvectorized más lento, apoyándose en los bucles
for innecesarias, como el de change_muchos. Yo creo que este es el resultado de un
malentendido general sobre R. para bucles no se comportan de la misma manera en R
como lo hacen en otros idiomas, lo que significa que debe escribir código en r de manera
diferente que la que tendría en otros idiomas.
Cuando usted escribe en lenguajes como C y Fortran, debe compilar el código antes
de su equipo puede ejecutar. Esta compilación paso cómo optimiza los bucles en el
código utiliza la memoria de su equipo, lo que hace que los bucles muy rápido. Como
resultado, muchos programadores usan para bucles con frecuencia cuando se
escriben en C y Fortran.
Cuando usted escribe en R, sin embargo, no compilar el código. Puede omitir este paso, lo
que hace que la programación en R una experiencia más amigable. Lamentablemente, esto
también significa que no dan sus bucles el acelerón que recibirían en C o Fortran. Como
resultado, sus bucles se ejecutan más lentamente que las otras operaciones que hemos
estudiado: pruebas lógicas, subconjuntos, y element-wise la ejecución. Si usted puede
escribir el código con las rápidas operaciones, en lugar de un bucle for, debería hacerlo.
No importa el idioma en el que desea escribir, debe tratar de usar las características del
lenguaje que se ejecuten más rápido.
Cómo escribir código vectorizadas | 177
WWW .IT-EBOOKS.INFO
Si y para
Un buen método para detectar bucles que podrían vectorizar es
buscar combinaciones de si y para. Si sólo se puede aplicar a un
valor a la vez, lo que significa que se utiliza a menudo en
conjunción con un bucle for. El bucle for permite aplicar si a todo
un vector de valores. Esta com- bination generalmente puede ser
reemplazado con subconjuntos lógicos, que va a hacer la misma
cosa pero se ejecuten mucho más rápido.
Esto no significa que usted nunca debería usar los bucles for en R. todavía hay
muchos lugares en donde R para bucles de sentido. Los bucles for realizar una
tarea básica que no siempre se puede recrear con código vectorizadas. Los
bucles for son fáciles de entender y ejecutar razonablemente rápido en R, tan
largo como usted tome algunas precauciones.
Cómo escribir rápido para bucles en R

Puede aumentar drásticamente la velocidad de tus bucles for haciendo dos cosas
para op- timize cada bucle. En primer lugar, hacer tanto como usted puede fuera
del bucle for. Cada línea de código que se coloca dentro del bucle for se ejecutará
muchas, muchas veces. Si una línea de código sólo debe ejecutarse una vez,
colóquelo fuera del bucle para evitar repeticiones.
Segundo, asegúrese de que todos los objetos de almacenamiento que utilice

con el bucle son lo suficientemente grande para contener todos los resultados
del bucle. Por ejemplo, ambos bucles a continuación necesitará para
almacenar un millón de valores. El primer bucle almacena sus valores en un
objeto llamado output que comienza con una longitud de un millón de:
System.time(
Salida <- rep(NA, 1000000)
Para i en 1:1000000) {
Output[i] <- i + 1
}
)
## 1.709 0.015 1.724
El segundo bucle almacena sus valores en un objeto llamado output que

comienza con una longitud de uno. R ampliará el objeto a una longitud de un
millón a medida que se ejecuta el bucle. El código en este bucle es muy similar
al código en el primer bucle, aunque el bucle tarda 37 minutos más tiempo en
ejecutarse que el primer bucle:
System.time(
Salida <- NA
Para i en 1:1000000) {
Output[i] <- i + 1
}
)
WWW .IT-EBOOKS.INFO
## 560.951 2249.927 1689.537
Los dos bucles hacen la misma cosa, entonces, ¿qué representa la diferencia?
En el segundo bucle, R tiene que aumentar la longitud de la salida por uno de
cada ejecución del bucle. Para ello, R necesita encontrar un nuevo lugar en la
memoria del ordenador que puede contener el objeto más grande. R A
continuación debe copiar el vector de salida más y borrar la versión antigua
de salida antes de pasar a la próxima ejecución del bucle. Al final del bucle, R
ha reescrito la salida en la memoria del ordenador de un millón de veces.
En el primer caso, el tamaño de salida no cambia nunca; R puede definir

un objeto de salida en la memoria y lo utilizan para cada ejecución del bucle
for.
Los autores de R usar lenguajes de bajo nivel como C y Fortran

para escribir R funciones básicas, muchas de las cuales
utilizan bucles for. Estas funciones son compilados y
optimizados antes de que se conviertan en una parte de R, lo
que los hace muy rápido.
Siempre que usted vea .primitivas, .interno,
o .llamada escrito en la definición de una función, puede estar
seguro de que la función se llama código de otro idioma.
Obtendrá todas las ventajas de velocidad que idioma utilizando
la función.
Vectorizar código en la práctica

Para ver cómo puede ayudarle código vectorizadas como un dato científico,
considerar nuestra máquina de ranura proyecto. En Chapter 9, se calcula la
tasa de pagos exactos para su máquina de ranura, pero podría haber calcula
esta tasa de pagos con una simulación. Si usted juega la máquina de ranura,
muchas veces, el premio promedio por encima de todos los juegos sería una
buena estimación de la verdadera tasa de pagos.
Este método de estimación se basa en la ley de los grandes números y es similar
a muchas simulaciones de estadística. Para ejecutar la simulación, usted podría
utilizar un bucle for:
Las ganancias <- vector(longitud = 1000000)
Para i en 1:1000000) {
Las ganancias[i] <- play()
}
Significa(ganancias)
## 0.9366984
La estimación de la tasa de pagos después de 10 millones de líneas es 0,937,

que está muy cerca de la verdadera tasa de pagos de 0.934. Observe que
estoy usando la función de puntuación modificada que trata diamonds como
comodines.
Vectorizar código en la práctica | 179
WWW .IT-EBOOKS.INFO
Si ejecuta esta simulación, observará que se toma un tiempo para ejecutarse. De
hecho, la sim- 342,308 ulation tarda unos segundos en ejecutarse, que es de unos
5,7 minutos. Esto no es particularmente impresionante, y usted puede hacer mejor
usando vectorizar código:
System.time(para (i en 1:1000000) {
Las ganancias[i] <- play()
})
## 0.355 342.308 342.041
La puntuación actual función no es vectorizado. Tiene una combinación de una

sola ranura y si utiliza un árbol para asignar un premio. Esta combinación de
una si el árbol con un bucle for sugiere que podría escribir un trozo de código
vectorizadas que toma muchas combinaciones de ranuras y luego utiliza subconjuntos
lógicos para operar en todas a la vez.
Por ejemplo, se puede reescribir get_símbolos para generar ranura n

combinaciones y devolverlos como una matriz n × 3, como la que sigue. Cada
fila de la matriz contendrá una ranura combinada para ser puntuada:
Get_many_símbolos <- función(n) {
<- rueda c("DD", "7", "BBB", "BB", "B", "C", "0")
vec <- muestra(rueda, tamaño = 3 * n,
sustituir = TRUE,
Prob = c(0,03, 0,03, 0,06, 0,1, 0,25, 0,01, 0,52)).
Matrix(vec, Ncol = 3).
}
Get_many_symbols(5).
## [,1] [,2] [,3].
## [1] "B" "0" "B"
## [2], "0", "BB" "7"
## [3] "0" "0" "BBB"
## [4] "0" "0" "B"
## [5] "BBB" "0" "0"
Usted también podría reescribir jugar para tener un parámetro n, y volver n premios, en
una trama de datos:
Play_muchos <- función(n) {
Symb_mat <- get_many_symbols(n = n)
Data.frame(w1 = symb_mat[1], W2 = symb_mat[2]
W3 = symb_mat[3], premio = score_muchos(symb_mat)
}
Esta nueva función hará fácil simular un millón, o incluso 10 millones de juegos
de la máquina de ranura, que será nuestro objetivo. Cuando hayamos
terminado, usted será capaz de estimar la tasa de pagos con:
# Juega <- play_muchos(10000000))
# Significa(juega$premio)
Ahora sólo necesita escribir score_muchos, un vectorizado (matix-izado?) versión

de puntuación que toma una matriz n × 3 y devuelve n premios. Será difícil escribir
esta función porque la puntuación es bastante complicada. No me esperaba que
usted se sienta seguro
WWW .IT-EBOOKS.INFO
Haciendo esto en su propia hasta que haya más práctica y experiencia que
hemos sido capaces de desarrollar aquí.
Te gustaría poner a prueba tus habilidades y escribir una versión
de score_muchos, le recomiendo que use la función rowSums dentro de su
código. Calcula la suma de cada fila de números (o logicals) en una matriz.
Si quisiera probar usted mismo en una forma más modesta, recomiendo que
usted estudie el siguiente modelo score_muchas funcionan hasta que usted
comprenda cómo funciona cada parte y cómo los componentes trabajan juntos
para crear una función vectorizadas. Para ello, será útil para crear un ejemplo
concreto, como esta:
Símbolos <- matrix(
C("DD", "DD", "DD",
"C", "DD", "0",
"B", "B", "B",
"B", "BB", "BBB",
"C", "C", "0",
"7", "DD", "DD"), nrow = 6, byrow = TRUE)
Los símbolos
## [,1] [,2] [,3].
## [1], "DD" "DD" "DD"
## [2] "C" "DD" "0"
## [3] "B" "B" "B"
## [4], "B", "BB" "BBB"
## [5], "C", "C" "0"
## [6] "7" "DD" "DD"
A continuación, se puede ejecutar cada línea de score_muchos contra el

ejemplo y examinar los resultados a medida que se avanza.
Ejercicio
Estudiar el modelo SCORE_muchas funcionan hasta que usted esté satisfecho
de que usted comprenda cómo funciona y podría escribir una función similar a
sí mismo.
Reto avanzada
En lugar de examinar la respuesta modelo, escribir su propia versión
vectorizada de puntuación. Se supone que los datos se almacenan en
una matriz n × 3 donde cada fila de la matriz contiene una combinación de
ranuras para ser puntuada.
Puede utilizar la versión de puntuación que trata de diamantes como salvajes o la versión
de puntuación que no lo hace. Sin embargo, la respuesta modelo usará la versión
tratamiento de diamantes como salvajes.
Vectorizar código en la práctica | 181
WWW .IT-EBOOKS.INFO
Score_muchos es una versión vectorizada de puntuación. Puede usarlo
para ejecutar la simulación al inicio de esta sección en poco más de 20
segundos. Esto es 17 veces más rápido que utilizar un bucle for:
# Los símbolos deben ser una matriz con una columna para
cada ventana de la máquina de
ranura score_muchos <- función(símbolos) {
# Paso 1: asignar el premio base basada en las cerezas y diamantes --

-------
## Contar el número de cerezas y diamantes en cada
combinación de cerezas <- rowSums(símbolos == "C").
Los diamantes <- rowSums(símbolos == "DD")
## Diamantes cuentan como cerezas silvestres

Premio <- c(0, 2, 5)[cerezas + diamantes + 1]
## ...Pero no si hay cerezas real cero

### (Cerezas es coaccionado a falso cuando
las cerezas == 0) premio[!cerezas] <- 0
# Paso 2: Cambiar el premio para las combinaciones que

contienen tres de una
especie misma <- símbolos[ 1] símbolos ==[ 2] &
Símbolos[ 2] símbolos ==[ 3]
Beneficios <- c("DD" = 100, "7" = 80, "BBB" =
40, "BB" = 25, "B" = 10, "C" = 10, "0" = 0).
Premio[mismo] <- beneficios[símbolos[mismo, 1]]
# Paso 3: Cambie el premio para las combinaciones que contienen todas

las barras ------
Bares <- símbolos == "B" | símbolos == "BB" | sím
bolos == "BBB" all_bares <- bares,[ 1] y bares,[
2] y bares,[ 3] & !mismo premio[all_bars] <- 5
# Paso 4: Controlar comodines ---------------------------------------

------
## Combos con dos

diamantes dos_salvaje <- di
amantes == 2
### Identificar el símbolo nonwild

Uno <- dos_comodines y símbolos,[ 1] símbolos
!=[ 2] & símbolos[ 2] símbolos ==[ 3]
Dos <- dos_comodines y símbolos,[ 1] símbolos
!=[ 2] & símbolos[ 1] símbolos ==[ 3]
Tres <- dos_comodines y símbolos,[ 1] símbol
os ==[ 2] & símbolos[ 2] símbolos !=[ 3]
### Tratar como un trío

de premio[un] <- beneficios[símbolos[1, 1]
]
premio[dos] <- beneficios[símbolos[2, 2]]
premio[tres] <- beneficios[símbolos[3, 3]]
## Combos con uno

salvaje _wild <- diamante
s == 1
WWW .IT-EBOOKS.INFO
### Tratar como todas las barras (si procede).
Wild_bares <- uno_wild & (rowSums(bar) == 2)
Premio[silvestre_bars] <- 5
### Tratar como tres de una clase (si

procede) uno <- uno_wild & símbolos[ 1] símbolo
s ==[ 2]
Dos <- uno_wild & símbolos[ 2] símbolos ==[ 3]
tres <- uno_wild & símbolos[ 3] símbolos ==[ 1]
premio[un] <- beneficios[símbolos[1, 1]]
premio[dos] <- beneficios[símbolos[2, 2]]
premio[tres] <- beneficios[símbolos[3, 3]]
# Paso 5: doble premio para cada diamante en combo ------------------

*(Premio unname 2^diamantes).
System.time(play_many(10000000)).
## 22.367 20.942: 1433
Bucles frente a código vectorizadas

En muchos idiomas, bucles for correr muy rápido. Como resultado, los
programadores aprende a utilizar los bucles for, siempre que sea posible al
código. A menudo estos programadores siguen confiando en los bucles for
cuando comienzan a programa en R, generalmente sin tomar los pasos
necesarios para optimizar la R de bucles. Estos programadores pueden volverse
desilusionados con R cuando su código no funciona tan rápido como les gustaría.
Si usted piensa que esto puede estar ocurriendo a usted, examinar la frecuencia
con la que se están utilizando para bucles y lo que usted está utilizando. Si usted
se encuentra el uso de bucles para cada tarea, hay una buena probabilidad de
que usted está "Hablando con un acento R C." La Curación es aprender a escribir
y usar código vectorizadas.
Esto no significa que los bucles for no tienen lugar en R. los bucles for son una
característica muy útil; se pueden hacer muchas cosas que no puede hacer el código
vectorizadas. Tampoco debe convertirse en un esclavo para vectorizar con el código.
A veces se toman más tiempo para volver a escribir código en el VEC- torized formato
que permiten ejecutar un bucle for. Por ejemplo, ¿sería más rápido para permitir que
el proceso de simulación de ranura de 5,7 minutos o reescribir la partitura?
Resumen
Código rápido es un componente importante de datos ciencia porque usted puede
hacer más con un código rápido de lo que usted puede hacer con un código lento.
Puede trabajar con grandes conjuntos de datos antes de restricciones
computacionales intervenir, y usted puede hacer cálculos más limitaciones de tiempo
antes de intervenir. El código más rápido en R dependerá de las cosas que mejor hace
R: pruebas lógicas, subconjuntos, y element-wise la ejecución. He llamado a este tipo
de código
Resumen |
183
WWW .IT-EBOOKS.INFO
Vectorizar código porque el código escrito con estas operaciones tendrá un
vector de valores como entrada y operar sobre cada elemento del vector al
mismo tiempo. La mayoría del código escrito en R ya está vectorizado.
Si utiliza estas operaciones, pero el código no aparece vectorizada, analizar la
sequential pasos y asuntos paralelos en su programa. Asegúrese de que usted
haya usado vectorizar funciones para manejar los pasos y subconjuntos lógicos
para manejar los casos. Ser consciente, cómo nunca, que algunas tareas no se
pueden vectorizar.
Proyecto 3 Wrap-up
Ahora ha escrito su primer programa en R, y es un programa que debe estar
orgullosa. El juego no es un simple ejercicio de hola mundo, pero un
verdadero programa que realiza una tarea real en una forma complicada.
Escribir nuevos programas en R siempre será difícil porque la programación depende tanto
de su propia creatividad, capacidad de resolver problemas, y la experiencia en la escritura
de tipos similares de programas. No obstante, puede utilizar las sugerencias en este
capítulo para hacer incluso el más complicado programa manejable: dividir las tareas en
pasos sencillos y casos, trabajar con ejemplos concretos, y describir las posibles soluciones
en inglés.
Este proyecto completa la educación se inició en Chapter 1. Ahora puede utilizar

r para manejar los datos, lo que ha aumentado su capacidad para analizar los
datos. Usted puede:
• Cargar y almacenar datos en su ordenador y no en papel o en tu mente.

• Recordar con precisión y cambiar valores individuales sin depender de la
memoria
• Instruir a su equipo para hacer tediosa, o complejas, tareas en su
nombre
Estas habilidades a resolver un importante problema logístico que enfrentan todos

los datos científicos: ¿Cómo se puede almacenar y manipular datos sin cometer
errores? Sin embargo, este no es el único problema que tendrá que afrontar como
un dato científico. El siguiente problema aparece cuando se intenta comprender
la información contenida en los datos. Es casi imposible detectar ideas o para
descubrir patrones en los datos raw. Un tercer problema aparece cuando se
intenta utilizar el conjunto de datos de razonar acerca de la realidad, que incluye
cosas que no figuran en el conjunto de datos. ¿Qué es exactamente lo que
implican sus datos acerca de cosas fuera del conjunto de datos? Cómo
determinados puede ser?
Me refiero a estos problemas como la logística, táctica y los problemas estratégicos de
ciencia de datos, como se muestra en la Figure 10-4. También te encontrarás cara a cara
con ellos siempre que intenta aprender de datos:
Un problema logístico
¿Cómo se puede almacenar y manipular datos sin cometer errores?
Un problema táctico
¿Cómo puede descubrir la información contenida en los datos?
WWW .IT-EBOOKS.INFO
Un problema estratégico
¿Cómo puede utilizar los datos para sacar conclusiones sobre el mundo
en general?
Figura 10-4. Los tres conjuntos de datos de habilidades básicas de la ciencia:

la programación informática, datos com- prehension y razonamiento científico.
A well-rounded científico de datos tendrá que ser capaz de resolver cada uno de estos
problemas en muchas situaciones diferentes. Por aprender a programar en R, que domine
el problema logístico, que es un requisito previo para la solución de los problemas tácticos
y estratégicos.
Si te gustaría aprender a razonar con datos, o cómo transformar, visualizar y

explorar los conjuntos de datos con R herramientas, recomiendo el libro
La Ciencia de datos con R, el volumen complementario de este libro. Datos
R enseña la ciencia con un flujo de trabajo sencillo para transformar, visualizar y
modelado de datos en R, así como la manera de comunicar los resultados con el
R Markdown y brillante y paquetes. Más importante aún, la Ciencia de datos con
R le enseñará a utilizar los datos para sacar conclusiones sobre el mundo en
general, que es la verdadera ciencia de datos científicos.
Proyecto 3 Wrap-up | 185

WWW .IT-EBOOKS.INFO
WWW .IT-EBOOKS.INFO
Apéndice A
Instalar R y RStudio
Para empezar a trabajar con R, deberá adquirir su propia copia. Este apéndice le
mostrará cómo descargar R así como RStudio, una aplicación de software que hace
R más fáciles de usar. Usted irá de descarga R R para abrir su primer período de
sesiones.
Tanto R y RStudio son gratis y fácil de descargar.
Cómo descargar e instalar R

R es mantenido por un equipo internacional de desarrolladores que hacen el
idioma disponible a través de la página web de The Comprehensive R Archive
Network. La parte superior de la página web proporciona tres enlaces para
descargar R. siga el vínculo que describe su oper- ellos sistema: Windows, Mac o
Linux.
Windows
Para instalar R en Windows, haga clic en el botón "Descargar enlace R para Windows".
A continuación, haga clic en el enlace "base". A continuación, haga clic en el primer
vínculo en la parte superior de la página nueva. Este vínculo debe decir algo así como
"Descargar R 3.0.3 para Windows", excepto la 3.0.3 será reemplazada por la versión
más actual de R. el enlace descargas un programa instalador que instala la versión
más actualizada de R para Windows. Ejecutar este programa y paso a través del
asistente de instalación que aparecerá. El asistente instalará R en sus carpetas de
archivos de programa y colocar un acceso directo en el menú Inicio. Tenga en cuenta
que tendrá que tener todas las apropiadas privilegios de administración para instalar
nuevo software en su máquina.
Mac
Para instalar R en un Mac, haga clic en el botón "Descargar R para Mac". A continuación,
haga clic en el enlace paquete R-3.0.3 (o el enlace del paquete de la versión más
actualizada de R). Un instalador descargará para guiarle a través del proceso de
instalación, lo cual es muy fácil. El instalador
187
WWW .IT-EBOOKS.INFO
Le permite personalizar su instalación, pero los valores por defecto será
adecuado para la mayoría de usuarios. Nunca he encontrado un motivo para
cambiarlos. Si su equipo requiere una contraseña antes de instalar nuevos
programas, tendrás aquí.
Fuente Versus binarios

R puede instalarse a partir de binarios precompilados o construido desde el código
fuente en cualquier sistema operativo. Para Windows y Mac máquinas, instalar R a
partir de binarios es extremadamente fácil. El binario viene precargado en su propio
instalador. Aunque usted puede construir R desde el código fuente en estas
plataformas, el proceso es mucho más complicado y no puede proporcionar muchos
beneficios para la mayoría de los usuarios. Para sistemas Linux, la verdad es todo lo
contrario. Binarios precompilados puede ser encontrada en algunos sistemas, pero es
mucho más común para construir R desde los archivos fuente al instalar en Linux. Las
páginas de descarga de CRAN’s website proporcionar información acerca de la
construcción de R a partir del código fuente para Windows, Mac y Linux.
Linux
R viene preinstalado en muchos sistemas Linux, pero querrá la última versión de R si
el suyo está fuera de fecha. The CRAN website Proporciona archivos para construir R
desde el código fuente en Debian, REDHAT, SUSE, Ubuntu y sistemas bajo el enlace
"Descargar R para Linux." Haga clic en el vínculo y, a continuación, seguir el rastro de
directorio para la versión de Linux que desea instalar. El procedimiento de instalación
exacta variará dependiendo del sistema Linux que utilice. Guías CRAN el proceso
mediante la agrupación de cada conjunto de archivos de código fuente con la
documen- tación o archivos README que explica cómo instalar en su sistema.
32 bits frente a 64 bits

R viene tanto en versiones de 32 bits y de 64 bits. Que se debe utilizar? En la mayoría de
los casos, no importa. Ambas versiones utilizan números enteros de 32 bits, lo que significa
que calcular números a la misma precisión numérica. La diferencia se produce en la forma
en que cada versión administra la memoria. 64-bit R utiliza punteros de memoria de 64 bits
y 32 bits R utiliza la memoria de 32 bits de punto- ers. Esto significa 64-bit R tiene un mayor
espacio de memoria a utilizar (y a través de la búsqueda).
Como una regla empírica, compilaciones de 32 bits R son más rápidas que las
compilaciones de 64 bits, aunque no siempre. Por otro lado, compilaciones de 64 bits
puede manejar archivos más grandes y juegos de datos con menos problemas de
gestión de memoria. En la versión, el tamaño máximo permitido de vector tops en
alrededor de 2 millones de elementos. Si su sistema operativo no es compatible con
programas de 64 bits, o la RAM es menor de 4 GB, 32-bit R es para usted. Los
instaladores de Mac y Windows instalará automáticamente ambas versiones si su
sistema es compatible con 64 bits de R.
188 | Apéndice A: Instalación de R y RStudio
WWW .IT-EBOOKS.INFO
Utilizando R
R No es un programa que puede abrir y empezar a utilizar, como Microsoft Word
o Internet Explorer. En su lugar, R es un lenguaje de programación, como C, C++,
o UNIX. Puede utilizar R escribiendo comandos en el lenguaje R y pidiendo su
ordenador para interpretarlos. En los viejos tiempos, la gente corrió R código en
una ventana de terminal UNIX-como si fueran los hackers en una película de los
años ochenta. Ahora casi todo el mundo utiliza r con una aplicación llamada
RStudio, y te recomiendo que hagas, demasiado.
R y UNIX
Aún puede ejecutar R en un sistema UNIX o bash ventana
escribiendo el comando:
R
Que abre un R intérprete. A continuación, puede hacer su

trabajo y cerrar el intérprete ejecutando q() cuando haya
terminado.
RStudio
RStudio es una aplicación como Microsoft Word, excepto que en lugar de ayudar a escribir
en inglés, RStudio ayuda a escribir en R. Yo uso RStudio a lo largo de todo el libro, porque
facilita el uso de la R sea mucho más fácil. Además, el interfaz RStudio parece el mismo
para Windows, Mac OS y Linux. Que me ayudarán a coincidir con el libro a su experiencia
personal.
Usted puede download RStudio de forma gratuita. Simplemente haga clic en

el botón "Descargar RStudio" y siga las sencillas instrucciones que seguir. Una
vez que hayas instalado RStudio, puede abrirlo como cualquier otro programa
en su equipo, generalmente haciendo clic en un icono en su escritorio.
La GUI de R
Usuarios de Windows y Mac no suelen programa desde una
ventana de terminal, por lo que las descargas para Windows y Mac
R vienen con un sencillo programa que abre una ventana de
terminal como para ejecutar código en R. Esto es lo que se abre al
hacer clic en el icono R en su Win- dows o equipo Mac. Estos
programas hacen un poco más que la ventana básica de terminal,
pero no mucho. Usted puede oír a gente referirse a ellos como el
Windows o Mac R GUI.
Cuando abra RStudio, aparece una ventana con tres paneles en ella, como en Figure A-1.
El panel más grande es una ventana de consola. Ahí es donde va a ejecutar su código R y
ver los resultados. La ventana de la consola es exactamente lo que te gustaría ver si ejecuta
R en una consola de UNIX o el GUI de Windows o Mac. Todo lo que ves es exclusivo de
RStudio. En otros paneles ocultos son un editor de texto, una ventana gráfica, un
depurador, un administrador de archivos, y mucho
Utilizando R | 189
WWW .IT-EBOOKS.INFO
Más. Usted aprenderá acerca de estos paneles, como se tornan útiles
durante el curso de este libro.
Figura A-1. El RStudio IDE para inst.
Todavía necesito para descargar R?

Incluso si usted utiliza RStudio, aún necesitará descargar com- R a
su ordenador. RStudio ayuda a utilizar la versión de R que vive en su
com- ordenador, pero no vienen con una versión de R por su propia
cuenta.
Apertura R
Ahora que usted tiene tanto R y RStudio en su ordenador, usted puede comenzar
a utilizar R abriendo el programa RStudio. Abra RStudio como lo harías con
cualquier programa, haciendo clic en su icono o escribiendo "RStudio" en el
prompt Ejecutar de Windows.
190 | Apéndice A: Instalación de R y RStudio

WWW .IT-EBOOKS.INFO
Apéndice B
R paquetes
Muchas de las funciones más útiles de R no vienen precargados cuando arranque R, pero
residen en paquetes que pueden ser instalados en la parte superior de R. R paquetes son
similares a las bibliotecas de C, C++ y Javascript, los paquetes de Python, y gemas en
Ruby. Un paquete de R paquetes- gether funciones útiles, archivos de ayuda y los
conjuntos de datos. Puede utilizar estas funciones dentro de su propio código R una vez
que cargue el paquete en que viven. Generalmente el contenido de un paquete de R están
todos relacionados con un único tipo de tarea, que el paquete de ayuda a resolver. R
paquetes le permitirán tomar ventaja de las características más útiles de R: su gran
comunidad de escritores de paquetes (muchos de los cuales están activos los datos
científicos) y sus rutinas escritas previamente para el manejo de muchos comunes (y
exóticas) de datos tareas de ciencias.
R Base
Usted puede escuchar R usuarios (o me) se refieren a la "base R."
¿Qué es la base R? Es simplemente la colección de funciones de
r que se carga cada vez que usted inicie R. Estas funciones
proporcionan los elementos básicos de la lengua, y no tienes que
cargar un paquete antes de poder utilizarlos.
Instalación de paquetes
Para usar un paquete de R, primero debe instalar en su ordenador y, a continuación,
cargarlos en su sesión actual de R. La forma más sencilla de instalar un paquete de R es
con el install.pack edades R FUNCIÓN. Abrir R y escriba lo siguiente en la línea de
comandos:
Install.packages("") Nombre del paquete
Esto buscará el paquete especificado en la recogida de los paquetes alojados en el sitio

CRAN. Cuando R encuentra el paquete, lo descargará en una carpeta Bibliotecas en su
equipo. R puede acceder al paquete aquí en futuras sesiones de R sin reinstalar.
Cualquiera puede escribir un paquete de R y difundirlo como les gusta; sin embargo, casi
todos los R paquetes son publicados a través del sitio web de Cran. CRAN comprueba
cada paquete antes de R
191
WWW .IT-EBOOKS.INFO
Publicarlo. Esto no elimina todos los errores dentro de un paquete, pero significa que
usted puede confiar en un paquete en CRAN para ejecutarse en la versión actual de
R en su sistema operativo.
Puede instalar varios paquetes a la vez vinculando sus nombres con R la función
CONCATENAR, c. Por ejemplo, para instalar el ggplot2, remodelar2 y dplyr paquetes,
ejecute:
Install.packages("ggplot(C2", "reformar2", "dplyr")
Si esta es la primera vez que instala un paquete, R le pedirá que elija una línea de espejo
de instalación. Los espejos son clasificados por ubicación. Tus descargas debe ser más
rápida si selecciona un espejo que está cerca de usted. Si desea descargar un paquete
nuevo, pruebe el primer espejo de Austria. Este es el principal repositorio CRAN, y que
nuevos paquetes a veces puede tardar un par de días para hacerla en torno al resto de los
espejos.
Los paquetes de carga

La instalación de un paquete no coloque inmediatamente sus funciones al
alcance de su mano. Simplemente coloca en su ordenador. Para usar un
paquete de R, después tiene que cargar en tu r la sesión con el comando:
Biblioteca(nombre de paquete)
Observe que las comillas han desaparecido. Puede utilizarlos si te gusta, pero
las comillas son opcionales para el comando de la biblioteca. (Esto no se
aplica para el comando.paquetes stall).
Biblioteca hará que todas las funciones del paquete, conjuntos de datos y archivos de
ayuda disponibles a usted hasta que usted cierra su sesión actual de R. La próxima vez
que inicie una sesión de R, tendrás que recargar el paquete con la biblioteca si desea
utilizarlo, pero no tendrás que volver a instalarlo. Sólo tiene que instalar cada paquete una
vez. Después de eso, una copia del paquete vivirá en su biblioteca. Para ver los paquetes
que tienes actualmente en tu biblioteca R, ejecute:
Biblioteca()
Biblioteca() también muestra la ruta de acceso a la Real Biblioteca R, que

es la carpeta que contiene los paquetes de r. Usted puede notar muchos
paquetes que no recuerde la instalación. Esto es porque R descarga
automáticamente un conjunto de paquetes útiles cuando instale por primera
vez R.
192 | Apéndice B: Paquetes de R
WWW .IT-EBOOKS.INFO
Instalar paquetes desde (casi) cualquier lugar
El paquete de R devtools facilita la instalación de paquetes desde
loca- ciones distinto del sitio CRAN. devtools proporciona funciones
como install_github, instalar,
gitorious_ install_bitbucket, y en cala_url. Estos trabajos
similares a install.packages, pero buscan nuevos
emplazamientos para R paquetes. Install_github es
especialmente útil porque muchos R los desarrolladores proporcionan
versiones de desarrollo de sus paquetes en GitHub. La versión de
desarrollo de un paquete conservar una Sneak Peek de nuevas
funciones y parches pero puede no ser tan estable y tan libre de bugs
como el CRAN versión.
¿Por qué R te hacen molestarse en instalar y cargar los paquetes? Usted puede imaginar
una R donde cada paquete venía precargado, pero esto sería un programa muy grande y
lento. A partir del 6 de mayo de 2014, el sitio CRAN aloja 5.511 paquetes. Es más sencillo
instalar y cargar los paquetes que desee utilizar cuando desee utilizarlas. Esto mantiene su
copia de R rápido porque tiene menos funciones y páginas de ayuda a través de la
búsqueda en cualquier momento. El acuerdo tiene además otras ventajas. Por ejemplo, es
posible actualizar la copia de un paquete de R sin actualizar toda tu copia de R.
¿Cuál es la mejor manera de aprender acerca de R

paquetes?
Es difícil utilizar un paquete de R si no sabe que existe. Usted podría
ir a la CRAN Paquetes sitio web y haga clic en el enlace para ver una
lista de los paquetes disponibles, pero tendrás que recorrer miles de
ellos. Además, muchos paquetes R hacer las mismas cosas.
¿Cómo puede saber qué paquete les hace mejor? El R-
paquetes mailing list es un lugar para comenzar. Envía anuncios de
nuevos paquetes y mantiene un archivo de viejos anuncios. Blogs que
el total de puestos aproximadamente R también puede proporcionar
valiosas pistas. Mi recomendación- mend www.r-bloggers.com[R-
bloggers]. RStudio mantiene una lista de algunos de los más útiles R
paquetes en la sección de introducción de Http://support.rstudio.com.
Por último, CRAN agrupa algunos de los más útiles y más respetado
de paquetes subject area. Este es un excelente lugar para aprender
acerca de los paquetes diseñados para su área de trabajo.
Los paquetes de carga | 193

WWW .IT-EBOOKS.INFO
WWW .IT-EBOOKS.INFO
Apéndice C
R y sus paquetes de
actualización
El equipo de desarrollo del núcleo R continuamente ataca el lenguaje R con la captura

de bugs, mejorando el rendimiento y la actualización R para trabajar con las nuevas
tecnologías. Como resultado, las nuevas versiones de R se liberan varias veces al
año. La forma más fácil de mantenerse al día con R es verificar periódicamente the
CRAN website. El sitio web se actualiza con cada nueva versión y convierte la versión
disponible para su descarga. Tendrá que instalar la nueva versión. El proceso es el
mismo que cuando se instala por primera vez R.
No se preocupe si usted no está interesado en mantenerse actualizado sobre

R del núcleo fechorías. R cambia sólo ligeramente entre versiones, y no es
probable que note la diferencia. Sin embargo, la actualización a la versión
actual de R es un buen lugar para empezar si alguna vez encuentra un error
que no se puede explicar.
RStudio constantemente también mejora su producto. Puede adquirir las
actualizaciones más recientes simplemente descargándolos desde RStudio.
R paquetes
Paquete autores ocasionalmente nuevas versiones de sus paquetes para agregar
funciones, corregir errores o mejorar el rendimiento. El comando
update.packages comprueba si tiene la versión más actual del paquete e instala
la versión más actual si no lo hacen. La sintaxis para update.packages sigue la
de install.packages. Si ya tienes ggplot2, remodelar2 y dplyr en su equipo,
que sería una buena idea buscar actualizaciones antes de usarlos:
Update.packages("ggplot(C2", "reformar2", "dplyr")
Usted debe comenzar un nuevo r la sesión después de actualizar los

paquetes. Si usted tiene un paquete cargado cuando lo actualice, tendrás que
cerrar tu r la sesión y abrir uno nuevo para comenzar a utilizar la versión
actualizada del paquete.
195
WWW .IT-EBOOKS.INFO
WWW .IT-EBOOKS.INFO
Apéndice D
Cargar y guardar datos en R
Este apéndice le mostrará cómo cargar y guardar datos en R a partir de archivos de

texto sin formato, R archivos y hojas de cálculo de Excel. También le mostrará los
paquetes de R que puede utilizar para cargar datos desde bases de datos y otros
programas comunes, como SAS y MATLAB.
Los conjuntos de datos en la base de R

R viene con muchos conjuntos de datos precargados en el paquete de datasets, que
viene con la base R. Estos conjuntos de datos no son muy interesantes, pero te dan
una oportunidad para probar el código o hacer un punto sin tener que cargar un
conjunto de datos desde fuera de R. Usted puede ver una lista de los conjuntos de
datos de R, así como una breve descripción de cada uno de ellos ejecutando:
Ayuda(package = "datasets")
Para utilizar un conjunto de datos, simplemente escriba su nombre. Cada

conjunto de datos está ya guardadas previamente como un objeto R. Por
ejemplo:
Iris
## Sépalo.Length sépalo.Width pétalo.Length pétalo.Width especie
## 1 5.1. 3.5 1.4 0.2 Setosa
## 2 4.9 3.0 1.4 0.2 Setosa
## 3 4.7 3.2 1.3 0.2 Setosa
## 4 4.6 3.1. 1.5 0.2 Setosa
## 5 5.0 3.6 1.4 0.2 Setosa
## 6 5.4 3.9 1.7 0.4 Setosa
Sin embargo, los conjuntos de datos de R no son ningún sustituto para sus
propios datos, lo que puede cargar en R desde una amplia variedad de
formatos de archivo. Pero antes de cargar los archivos de datos en R,
necesitará determinar donde su directorio de trabajo .
197
WWW .IT-EBOOKS.INFO
Directorio de trabajo
Cada vez que abra R, que se vincula a un directorio de su ordenador, los
cuales R llama al directorio de trabajo. Esto es donde R buscará archivos
cuando intento cargar ellos, y es donde R guarda los archivos al guardarlos.
La ubicación de su directorio de trabajo variará en diferentes equipos. Para
determinar qué directorio R está utilizando como su directorio de trabajo,
ejecute:
Getwd()
## "/Users/garrettgrolemund"
Los archivos de datos se pueden colocar directamente en la carpeta en la que está el

directorio de trabajo, o puede mover el directorio de trabajo al directorio donde están
los archivos de datos. Puede mover el directorio de trabajo a cualquier carpeta en su
ordenador con la función setwd. Simplemente dar setwd la ruta de archivo para el
nuevo directorio de trabajo. Yo prefiero definir mi directorio de trabajo a una carpeta
dedicada a cualquier proyecto que estoy trabajando actualmente. De esa manera
puedo mantener todos mis datos, scripts, gráficos e informes en el mismo lugar. Por
ejemplo:
Setwd("~/Users/garrettgrolemund/Documents/Book_Project").
Si la ruta de acceso del archivo no empieza con el directorio raíz, R supondrá

que comienza en el directorio de trabajo actual.
También puede cambiar su directorio de trabajo haciendo clic en sesión > Set Working
Di- rectoría > Elija un directorio en la barra de menú RStudio. La GUI de Windows y Mac
tienen opciones similares. Si usted comienza a R desde una línea de comandos UNIX
(como Linux), el directorio de trabajo será independientemente del directorio en el que
estaba cuando se denomina R.
Usted puede ver qué archivos están en su directorio de trabajo con

la lista.Los archivos(). Si ve el archivo que desea abrir en su directorio
de trabajo, entonces usted está listo para continuar. Cómo abrir los archivos
en su directorio de trabajo dependerá del tipo de archivo que desea abrir.
Archivos de texto sin formato

Archivos de texto sin formato son una de las maneras más comunes para guardar
datos. Son muy sencillos y puede ser leído por muchas diferentes programas
informáticos, incluso el más básico de los editores de texto. Por esta razón, los
datos públicos a menudo se presenta como archivos de texto sin formato. Por
ejemplo, la Oficina del Censo, la Administración de Seguridad Social, y de la
Oficina de Estadísticas Laborales hacen sus datos disponibles como archivos de
texto sin formato.
He aquí cómo el royal flush conjunto de datos Chapter 3 aparecería como un
archivo de texto sin formato (He añadido una columna de valor):
"Tarjeta", "palo", "valor".
"As", "picas", 14
"El Rey", "picas", 13
"Reina", "picas", 12
198 | Apéndice D: Cargar y guardar datos en R
WWW .IT-EBOOKS.INFO
"Jack", "picas", 11
"Diez", "picas", 10
Un archivo de texto sin formato almacena una tabla de datos en un documento de

texto. Cada fila de la tabla se guarda en su propia línea y una simple convención
se utiliza para separar las células dentro de una fila. A menudo, las celdas están
separadas por una coma, pero también pueden estar separados por un
delimitador de tabulación, un tubo (es decir, | ), o de cualquier otro carácter. Cada
archivo sólo utiliza un método de separación de células, lo cual minimiza la
confusión. Dentro de cada celda, los datos aparecen como usted esperaría ver,
como palabras y números.
Todos los archivos de texto se pueden guardar con la extensión .txt (texto), pero a veces
un archivo recibirán una extensión especial que anuncia la forma en que separa las
entradas de celda de datos. Ya que las entradas en la base de datos mencionada
anteriormente se separan con una coma, este archivo será un archivo de valores
separados por comas de archivo y generalmente será guardado con la extensión .csv.
Leer.tabla
Para cargar un archivo de texto, utilice Read.table. El primer argumento
de read.table debe ser el nombre del archivo (si se encuentra en su
directorio de trabajo), o la ruta de archivo para el archivo (si no está en su
directorio de trabajo). Si la ruta de acceso del archivo no empieza con el
directorio raíz, R se anexa al final de la ruta que conduce a su directorio de
trabajo- tory.puede dar lectura.tabla otros argumentos. Los dos aspectos
más importantes son la SEP y el cabezal.
Si el conjunto de datos de escalera real se guarda como un archivo
denominado poker.csv en el directorio de trabajo, puede cargarlo con:
Poker <- read.table("poker.csv", sep = "", encabezado = TRUE).
Sep
Utilice sep decirle a leer.tabla de caracteres que utiliza el archivo para
separar las entradas de datos. Para averiguarlo, puede que tenga que abrir el
archivo en un editor de texto y mirar. Si no se especifica un argumento
sep, lea.tabla intentará separar celdas cuando se trata de un espacio en
blanco, como una tabulación o espacio. R no será capaz de decirle
si leer.mesa no esta correctamente o no, por lo que confían en él a su propio
riesgo.
Cabezal
Utilice el cabezal para decirle a leer.tabla si la primera línea del archivo
contiene nombres de variable en lugar de valores. Si la primera línea del
archivo es un conjunto de nombres de variable, debe definir el encabezado =
TRUE.
Na.strings
Los conjuntos de datos a menudo se usan símbolos especiales para representar la
información faltante. Si usted sabe que sus datos utiliza un determinado símbolo para
representar la falta de entradas, puedes decirle
Archivos de texto sin formato | 199
WWW .IT-EBOOKS.INFO
Leer.tabla (y las funciones anteriores) ¿Qué es el símbolo con
el na.strings argumento. Leer.tabla convertirá todas las instancias del símbolo
de la información faltante para NA, que es R falta el símbolo de información
(véase “Missing Information” on page 89).
Por ejemplo, el conjunto de datos de poker figuran la falta de valores almacenados
como una ,como esta:
## "Tarjeta", "palo","valor".
## "Ace"", picas"", 14"
## "El Rey", "picas"", 13"
## "Reina","","".
## "Jack","","".
## "Diez","","".
Usted puede leer el conjunto de datos en R y convertir los valores faltantes

en NAs como vas con el comando:
Poker <- read.table("poker.csv", sep = "", encabezado = TRUE,
na.string = "").
R ahorraría una versión de poker que tiene este aspecto:

## Card Valor palo
## As picas14
## Rey de picas13
## Reina <na> NA
## Jack <na> NA
## 10 <na> NA
Skip y nrow
A veces, un archivo de texto sin formato vendrá con un texto introductorio que no forma
parte del conjunto de datos. O, usted puede decidir que usted sólo desea leer en parte
de un conjunto de datos. Usted puede hacer todas estas cosas con
el skip y nrow argumentos. Utilice omitir decirle a R para saltar un número
específico de líneas antes de que se inicie la lectura de los valores del archivo.
Utilice nrow decirle a R para detener la lectura de valores después de que haya leído
en un cierto número de líneas.
Por ejemplo, imagine que el royal flush completo archivo tiene este aspecto:
Estos datos fueron recopilados por el Instituto Nacional de Poker.
Nosotros accidentalmente se repite la última fila de datos.
"Tarjeta", "palo", "valor".

"Ace", "picas", 14
"Rey", "picas", 13
"Reina", "picas", 12
"Jack", "picas", 11
"Diez", "picas", 10
"Diez", "picas", 10
Usted puede leer las seis líneas (cinco filas más un encabezado) que desee
con:
Read.table("poker.csv", sep = "", encabezado = TRUE, salte = 3,
nrow = 5).
## Card Palo Valor
## 1 Ace Picas 14
WWW .IT-EBOOKS.INFO
El
## 2 rey Picas 13
## 3 Reina Picas 12
## 4 Jack Picas 11
## 5 10 Picas 10
Observe que la fila de encabezado no cuentan hacia el total de filas permitidas

por nrow.
StringsAsFactors
R lee en números tal y como se espera, pero cuando R viene a través de cadenas de
caracteres (por ejemplo, letras y palabras) comienza a comportarse de forma extraña.
R quiere convertir cada cadena de caracteres en un factor. Este es el comportamiento
predeterminado de R, pero creo que es un error. A veces factores son útiles. En otras
ocasiones, son claramente el tipo de datos incorrecto para el trabajo. También factores
provocan comportamientos extraños, especialmente cuando se desea mostrar datos.
Este comportamiento puede ser sorprendente si no se da cuenta que R al convertir los
datos de factores. En general, tendrás una experiencia fluida R si no dejes que R hace
que los factores hasta que pregunte por ellos. Afortunadamente, es fácil hacerlo.
Establecer el argumento falso stringsAsFactors garantizará que R

guarda las cadenas de caracteres en su conjunto de datos como cadenas de
caracteres, no de factores. Utilizar stringsAsFactors, usted escribiría:
Read.table("poker.csv", sep = "", encabezado = TRUE,
stringsAsFactors = FALSE)
Si se carga más de un archivo de datos, puede cambiar el comportamiento

predeterminado de factoring a nivel mundial con:
Opciones(stringsAsFactors = FALSE)
Esto garantizará que todas las cadenas se leerá como cadenas, no como factores, hasta
que termine su
R La sesión, o cambie el valor predeterminado global ejecutando:
Opciones(stringsAsFactors = TRUE).
La familia de lectura
R también viene con algunos atajos de teclado predefinidos para leer.tabla, se
muestra en la Table D-1.
Tabla D-1. R las funciones de lectura. Puede sobrescribir cualquiera de los

argumentos predeterminados según sea necesario.
Read.csv sep2 = ";", cabezal = TRUE, dec =
Función Valores
"", lea.delim2 sep = "\t", cabezal = TRUE, dec = ""
predeterminados
Leer.tabla Sep = " ", cabezal =
FALSE
Leer.csv sep = "", cabezal =
TRUE leer.delim sep = "\t", cabezal
= TRUE
Utilice Los archivos CSV con el formato decimal
Función de lectura de propósito general Europeo archivos delimitados por tabuladores
Variable separados por comas (CSV) con formato decimal europeo
Archivos delimitados por tabuladores
Archivos de texto
sin formato | 201
WWW .IT-EBOOKS.INFO
El primer acceso directo, read.csv, se comporta como leer.tabla pero
establece automáticamente sep = "" y cabezal = TRUE, que puede ahorrarle
algunos escribiendo:
Poker <- leer.csv("poker.csv").
Leer.delim establece automáticamente a la Sep el carácter de tabulación,

que es muy útil para leer archivos delimitados por tabulaciones. Estos son los
archivos donde cada celda separados por una
tabulación. Leer.delim también establece cabezal = True de forma
predeterminada.
Leer.delim2 y leer.csv2 existen para R usuarios europeos. Estas
funciones decirle a R que los datos utiliza una coma en lugar de un período
para indicar decimales. (Si te estás preguntando cómo esto funciona con
archivos CSV, archivos CSV2 células generalmente se separan con un punto
y coma, no una coma).
Importación de los datos

También puede cargar archivos de texto simple con RStudio
Import del botón, tal y como se describe en “Loading Data” on
page 57. Importación de los datos proporciona una versión GUI
de read.table.
Leer.fwf
Un tipo de archivo de texto desafía el patrón mediante su diseño para separar
celdas de datos. Cada fila se coloca en su propia línea (como con otros archivos
de texto sin formato) y, a continuación, cada columna comienza en un número
específico de caracteres de la parte izquierda del documento. Para lograr esto, un
número arbitrario de espacios de carácter se añade al final de cada entrada para
colocar correctamente la siguiente entrada. Estos documentos son conocidos
como archivos de ancho fijo y suelen acabar con la extensión .fwf.
He aquí una manera royal flush el conjunto de datos podría lucir como un archivo
de ancho fijo. En cada fila, el traje entrada comienza exactamente 10 caracteres
desde el inicio de la línea. No importa cuántos caracteres apareció en la primera
celda de cada fila:
Card Palo Valor
Ace Picas 14
El rey Picas 13
Reina Picas 12
Jack Picas 11
10 Picas 10
Archivos de ancho fijo son agradables para los ojos humanos (pero nada
mejor que un archivo delimitado por tabulaciones); sin embargo, pueden ser
difíciles de trabajar. Quizás debido a esto, R viene con una función para leer
archivos de ancho fijo, pero ninguna función para guardarlos.
Lamentablemente, varias agencias del gobierno de los Estados Unidos
parecen como archivos de ancho fijo, y que es probable que encuentre uno o
más durante su carrera.
WWW .IT-EBOOKS.INFO
Puede leer archivos de ancho fijo en R con la función read.fwf. La función toma
los mismos argumentos que leer.tabla pero requiere un argumento
adicional, anchos, que debe ser un vector de números. Cada iª entrada de
los anchos vector deberá indicar el ancho (en caracteres) de la Iª columna del
conjunto de datos.
Si la mencionada escalera real de ancho fijo datos se guardan
como poker.fwf en su trabajo- Directorio de ING, puede leerlo con:
Poker <- leer.fwf("poker.fwf", anchos = C(10, 7, 6),
cabezal = TRUE).
Enlaces HTML
Muchos archivos de datos están disponibles en el Internet en su propia
dirección web. Si estás conectado a Internet, puede abrir estos archivos
directamente en R con read.table, read.csv, etc. puede pasar una
dirección web en el nombre de archivo como argumento para cualquiera de
R-funciones de lectura de datos. Como resultado, se podía leer en el conjunto
de datos de poker desde una dirección web como Http://…/poker.csv con:
Poker <- leer.csv("Http://.../poker.csv")
Sólo asegúrese de que la dirección web enlaces directamente al archivo y no a

una página web que se vincula al archivo. Normalmente, cuando usted visita una
dirección web del archivo de datos, el archivo comenzará a descargar o los datos
raw aparecerá en la ventana del navegador.
Tenga en cuenta que los sitios web que empiezan con https:// son sitios
seguros, lo que significa que R no podrán tener acceso a los datos
proporcionados a través de estos enlaces.
Guardar archivos Plain-Text

Una vez que los datos están en R, puede guardarlo en cualquier formato de
archivo que admite R. Si desea guardarlo como un archivo de texto sin formato,
puede utilizar la familia de funciones de escritura. Las tres funciones básicas de
escritura aparecen en Table D-2. Utilice write.csv para guardar los datos como
un archivo .csv y escribir.tabla para guardar los datos como un documento
delimitado por tabuladores o un documento con separadores más exóticos.
Tabla D-2. R guarda conjuntos de datos a archivos de texto sin formato con la
familia de funciones de escritura
Formato de archivo Y la sintaxis de la función
Escriba.csv(r_object, archivo = filepath, row.names =
CSV . FALSE)
Escriba.csv2(r_object, archivo = filepath, row.names =
.CSV (con decimales europeas FALSE)
Notación)
Delimitado por Write.table(r_object, archivo = filepath, sep =
tabulaciones "\t",
Row.names=FALSE)
El primer argumento de cada función es el R objeto que contiene el conjunto de datos.
El argumento de archivo es el nombre del archivo (incluida la extensión) que desee dar a
los datos guardados. Por defecto, cada función para guardar tus datos en su directorio de
trabajo. Sin embargo, usted
Archivos de texto
sin formato | 203
WWW .IT-EBOOKS.INFO
Puede proporcionar una ruta de archivo para el archivo de argumento. R
obligará a guardar el archivo al final de la ruta de acceso del archivo. Si la ruta
de acceso del archivo no empieza con el directorio raíz, R se anexa al final de
la ruta que conduce a su directorio de trabajo.
Por ejemplo, puede guardar los datos de poker (hipotético) marco a un
subdirectorio denominado datos dentro de su directorio de trabajo con el
comando:
Escriba.csv(poker, "Datos/poker.csv", row.names = FALSE)
Tenga en cuenta que escribir.csv y write.table no puede crear nuevos directorios

en el equipo. Cada carpeta en la ruta del archivo debe existir antes de intentar guardar un
archivo con ella.
El argumento row.names evita R desde el almacenamiento de los datos de

fila del bastidor de nombres como una col- umn en el archivo de texto. Habrás
notado que R nombres automáticamente cada fila en una trama de datos con
un número. Por ejemplo, cada fila en nuestro Póker trama de datos aparece
con un número a su lado:
Poker
## Valor palo
## 1 As picas 14
## 2 Rey de picas 13
## 3 reina picas 12
## 4 Jack Picas 11
## 5 10 Picas 10
Estos números de fila son útiles, pero pueden acumularse rápidamente si comienza a
guardar. R agregará un nuevo conjunto de números por defecto cada vez que lea el archivo
de nuevo. Evitar esto siempre row.names = FALSE cuando se utiliza una función en
la familia de escritura.
Comprimir archivos
Para comprimir un archivo de texto sin formato, rodean el nombre de archivo
o ruta de archivo con la función bzfile gzfile xzfile , , o. Por ejemplo:
Escriba.csv(poker, archivo = bzfile("datos/poker.csv.bz2"),
row.names = FALSE)
Cada una de estas funciones se comprima la salida con un tipo de compresión

diferente formato, se muestra en la Table D-3.
Tabla D-3. R viene con tres funciones auxiliares para comprimir archivos
Función Tipo de compresión
Bzfile Bzip2
Gzfile Gzip (GNU zip)
Xzfile Compresión xz
Es una buena idea para ajustar la extensión del archivo para reflejar la
compresión. R las funciones de lectura abrirá archivos de texto sin formato
comprimido en cualquiera de estos formatos. Por ejemplo, puede leer un
archivo comprimido denominado poker.csv.bz2 con:
WWW .IT-EBOOKS.INFO
Leer.csv("poker.csv.bz2")
O:
Leer.csv("datos/poker.csv.bz2")
Dependiendo de dónde se guarda el archivo.
RArchivos
R Ofrece dos formatos de archivo de su propia para almacenar datos, .RDS y .RData. Los
archivos pueden RDS
Almacenar una sola R objeto y RData puede almacenar archivos de
múltiples objetos R.
Puede abrir un archivo con readRDS RDS. Por ejemplo, si la escalera real los
datos se guardan como poker.RDS, puede abrir con:
<- readRDS Pokerpoker.( "RDS").
Apertura RData archivos es aún más fácil. Simplemente ejecute la

función carga con el archivo:
Load("archivo.RData").
No hay necesidad de asignar el resultado a un objeto. El R objetos en su RData

archivo será cargado en tu r la sesión con sus nombres originales. RData archivos
puede contener varios objetos R, por lo que la carga se puede leer en varios
objetos. Cargar no decirle cuántos objetos se está leyendo, ni cuáles son sus
nombres, de modo que vale la pena conocer un poco sobre el RData archivo antes
de cargarlo.
Si peor viene a peor, puede mantener un ojo en el panel entorno en RStudio

como se carga un archivo RData. Muestra todos los objetos que hayas creado
o cargado durante su r la sesión. Otro truco útil es poner los paréntesis
alrededor de su carga, así como de comando (load("poker.RData"). Esto
causa R para imprimir los nombres de cada objeto se carga desde el archivo.
Ambos readRDS carga y tomar una ruta de archivo como primer argumento,
al igual que R otras funciones de lectura y escritura. Si el archivo está en el
directorio de trabajo, la ruta de acceso del archivo será el nombre del archivo.
Guardar archivos de R
Puede guardar un objeto R como una trama de datos como un archivo RData
o un archivo de RDS. RData puede almacenar archivos R múltiples objetos a
la vez, pero los archivos de RDS son la mejor opción porque foster
reproducibles código.
Para guardar los datos como un RData objeto, utilice la función Guardar. Para
guardar los datos como un objeto RDS, utilice la función saveRDS. En cada caso,
el primer argumento debe ser el nombre del R objeto que desee guardar. Luego
debe incluir un argumento de archivo que tiene el nombre de archivo o la ruta de
acceso del archivo que desea guardar el conjunto de datos.
R archivos
| 205
WWW .IT-EBOOKS.INFO
Por ejemplo, si tiene tres objetos, R a, b, c, puede guardar todos ellos en la misma
RData archivo y, a continuación, cargarlos en otro r la sesión:
<- 1
B <- 2
C <- 3
Guardar(a, b, c, File = "stuff.RData").
Load("stuff.RData").
Sin embargo, si olvida los nombres de los objetos o dar tu archivo a alguien utilizar,
será difícil determinar qué es lo que está en el archivo, incluso después de que
usted (o no) la carga. La interfaz de usuario para los archivos de RDS es mucho
más claro. Sólo puede guardar un objeto por archivo, y quien carga puede decidir
lo que desean llamar a sus nuevos datos. Como un bono, usted no tendrá que
preocuparse por sobrescribir cualquier carga R objetos que pasó a tener el mismo
nombre que los objetos que están cargando:
SaveRDS(a, File = "stuff.RDS").
A <- readRDS("stuff.RDS").
Guardar los datos como un archivo R ofrece algunas ventajas sobre guardar los datos
como un archivo de texto. R comprime automáticamente el archivo y guardar los
metadatos relacionados R asociado con el objeto. Esto puede ser útil si los datos
contienen factores, fechas y horas, o atributos de clase. No tienes que esta
información de reanálisis a r la forma en que lo haría si se convierte todo en un archivo
de texto.
Por otro lado, R no se pueden leer los archivos por muchos otros programas, que
les hace ineficiente para compartir. También pueden crear un problema para el
almacenamiento a largo plazo si usted no piensa que usted tendrá una copia de
R cuando se vuelve a abrir los archivos.
Hojas de cálculo de Excel.

Microsoft Excel es un popular programa de hoja de cálculo que casi se ha convertido
en estándar en el mundo de los negocios. Hay una buena probabilidad de que usted
tendrá que trabajar con una hoja de cálculo de Excel en R por lo menos una vez en su
carrera. Usted puede leer las hojas de cálculo en R y R también guardar datos en una
hoja de cálculo en una variedad de maneras.
Exportación desde Excel

El mejor método para mover datos de Excel a R es exportar la hoja de cálculo de
Excel como un archivo .csv o .txt . R no sólo ser capaz de leer el archivo de texto,
de modo que cualquier otro software de análisis de datos. Los archivos de texto
son la lingua franca de almacenamiento de datos.
Exportar los datos resuelve otra dificultad. Excel utiliza los formatos propietarios y los
metadatos que no se transfiera fácilmente en inst. Por ejemplo, un solo archivo de Excel
puede incluir varias hojas de cálculo, cada uno con sus propias columnas y macros. Cuando
se exporta el archivo de Excel como un archivo .csv o .txt, se asegura de que este formato
es transferida a un archivo de texto sin formato en la manera más apropiada. R no puede
ser capaz de administrar la conversión de manera eficiente.
WWW .IT-EBOOKS.INFO
Exportar datos desde Excel, abrir la hoja de cálculo de Excel y, a continuación, vaya a
"Guardar como" en el menú botón de Microsoft Office. A continuación, seleccione CSV en
el cuadro Guardar como tipo que aparece y guardar los archivos. A continuación, puede
leer el archivo en R con la función read.csv.
Copiar y pegar
También puede copiar partes de una hoja de cálculo de Excel y pegarlos en R. Para ello,
abra la hoja de cálculo, seleccione las celdas que desea leer en R., a continuación,
seleccione Editar > Copiar en la barra de menú, o bien usar un atajo de teclado para copiar
las celdas en el portapapeles.
En la mayoría de los sistemas operativos, puede leer los datos almacenados en el

portapapeles en R con:
Read.table("portapapeles").
En Macs necesitará usar:

Read.table(pipe("pbpaste")).
Si las celdas contienen valores con espacios en ellos, esto

interrumpiría read.table. Usted puede intentar otra función de lectura (o
simplemente exportar formalmente los datos desde Excel) antes de leerla en
R.
XLConnect
Muchos paquetes han sido escritas para ayudarle a leer archivos de Excel
directamente en R. Unfortu- nately, muchos de estos paquetes no funcionan
en todos los sistemas operativos. Otros han sido realizados fuera de fecha por
el formato de archivo .xlsx. Un paquete que funciona en todos los sistemas
de archivos (y obtiene buenas críticas) es el paquete XLConnect. Para
utilizarlo, necesitará instalar y cargar el paquete:
Install.packages("XLConnect")
Biblioteca(XLConnect)
XLConnect se basa en Java para ser independiente de la plataforma. Así,

cuando abra por primera vez XLCon- ecte, RStudio puede pedir para
descargar Java Runtime Environment si usted no tiene ya uno.
La lectura de las hojas de cálculo

Puede utilizar XLConnect para leer en una hoja de cálculo de Excel con una
o un proceso de dos pasos. Voy a comenzar con el proceso de dos pasos. En
primer lugar, cargar un libro de Excel con carga
Libro. loadWorkbook puede cargar los archivos .xls y .xlsx archivos. Toma
un argumento: la ruta de acceso del archivo a su libro de Excel (este será el
nombre del libro si se guardan en el directorio de trabajo):
Wb <- loadWorkbook("archivo.xlsx")
A continuación, leer una hoja de cálculo del libro con readWorksheet, que toma varios
argumentos. El primer argumento debe ser objeto de un libro creado con loadWork
Hojas de cálculo de
Excel. | 207
WWW .IT-EBOOKS.INFO
Libro. El siguiente argumento, hoja, debe ser el nombre de la hoja de cálculo en el libro
que te gustaría leer en R. Este será el nombre que aparece en la pestaña en la parte inferior
de la hoja de cálculo. También puede dar un número de hoja, que especifica la hoja que
desee leer en (uno para la primera hoja, dos para la segunda, y así sucesivamente).
Luego readWorksheet toma cuatro argumentos que especifican un cuadro

delimitador de celdas para leer en: startRow, startCol endRow endCol , , y.
Utilice startRow y startCol para describir la celda en la esquina superior izquierda
del rectángulo de selección de celdas que desea leer. Utilice endRow y endCol para
especificar la celda en la esquina inferior derecha del cuadro delimitador. Cada uno de
estos argumentos tiene un número. Si no se suministran argumentos,
delimitador readWorksheet leerá en la región rectangular de celdas en la hoja de
cálculo que contiene datos. ReadWorksheet asumirá que esta región contiene una fila
de encabezado, pero puedes decir lo contrario con cabezal = FALSE.
Para leer en la primera hoja del BM, puede usar:
Hoja1 <- readWorksheet(BM, hoja = 1, startRow = 0, 0,
endRow startCol = = 100, endCol = 3).
R se guarde el resultado como una trama de datos. Todos los argumentos

en readWorkbook excepto la primera están vectorizadas, así que usted puede
utilizar para leer en varias hojas del mismo libro a la vez (o en varias regiones de
celda de una sola hoja). En este caso, la hoja readWork devolverá una lista de
tramas de datos.
Puede combinar estos dos pasos con readWorksheetFromFile. Toma el archivo

argumento de loadWorkbook y lo combina con los argumentos de readWorksheet.
Puede usarlo para leer uno o más hojas directamente desde un archivo de Excel:
Hoja1 <- readWorksheetFromFile("archivo.xlsx", hoja = 1,
startRow = 0, 0, endRow startCol = = 100, endCol = 3).
Escribir hojas de cálculo

Al escribir en una hoja de cálculo de Excel es un proceso de cuatro pasos.
Primero, necesitará configurar una obra- libro objeto con loadWorkbook. Esto
funciona igual que antes, excepto si no está utilizando un archivo de Excel
existente, debe añadir el argumento create = TRUE. XLConnect creará un libro
en blanco. Al guardarlo, XLConnect escribirá a la ubicación del archivo que ha
especificado aquí con loadWorkbook:
Wb <- loadWorkbook("archivo.xlsx", crear = TRUE).
A continuación, necesita crear una hoja de cálculo dentro de un libro objeto

con createSheet.
Dígale que createSheet libro para colocar la hoja en la que uso para la hoja.
CreateSheet(wb, "Hoja 1").
A continuación, puede guardar la trama de datos o matriz para la hoja

con writeWorksheet. El primer argumento de writeWorksheet, Objeto, es el libro para
escribir los datos. El
WWW .IT-EBOOKS.INFO
Segundo argumento, data, es para escribir los datos. El tercer
argumento, hoja, es el nombre de la hoja para escribir. Los siguientes dos
argumentos, y startCol startRow, decirle a r donde en la hoja de cálculo
para colocar la celda superior izquierda de los nuevos datos. Estos
argumentos cada uno de forma predeterminada el valor 1. Por último, puede
utilizar el cabezal para decirle a R si sus nombres de columna debe ser
escrito con los datos:
WriteWorksheet(BM, data = poker, hoja = "Hoja 1").
Una vez que haya terminado de agregar hojas y datos para su libro, puede
guardarlo ejecutando saveWorkbook sobre el objeto Workbook. R podrán
guardar el libro en el nombre de archivo o ruta que proporcionó en loadWorkbook.
Si esto lleva a un archivo de Excel existente, R se sobrescribirá. Si conduce a un
archivo nuevo, R lo creará.
También puede contraer estos pasos en una sola llamada con writeWorksheetToFile, como
esta:
WriteWorksheetToFile("archivo.xlsx", datos = poker,

hoja = "Hoja 1", startRow = 1, startCol = 1).
El paquete XLConnect también te permite hacer cosas más avanzadas con hojas de
cálculo de Excel, como la escritura en una región denominada en una hoja de cálculo,
Trabajando con fórmulas, y como- Firma de estilos a las celdas. Usted puede leer
acerca de estas funciones en la XLConnect vignette, que es accesible mediante la
carga XLConnect y luego ejecutando:
Vignette("XLConnect")
Carga de archivos desde otros

programas
Usted debe seguir los mismos consejos que dí para archivos de Excel siempre
que desee trabajar con formatos de archivo nativos de otros programas: abra
el archivo en el programa original y exportar los datos como un archivo de
texto, normalmente un archivo CSV. Esto asegurará el más fiel transcripción
de los datos en el archivo, y generalmente le ofrecen más opciones para
personalizar el modo en que los datos se transcribieron.
A veces, sin embargo, usted puede adquirir un archivo pero no el programa del
que proviene. Como resultado, usted no será capaz de abrir el archivo en su
programa nativo y exportarla como un archivo de texto. En este caso, puede
utilizar una de las funciones Table D-4 para abrir el archivo. Estos func- ciones
principalmente en R extranjeros del paquete. Cada uno intenta leer en un
formato de archivo diferente con tan pocos hipo como sea posible.
Tabla D-4. Una serie de funciones intentará leer los tipos de archivos de otros
programas de análisis de datos
Formato de archivo Función Biblioteca
Leer.shapefile
Escuela ERSI es un ArcGIS . Formatos de archivo
Matlab ReadMat R.MATLAB
Minitab Leer.MTP Relaciones
Conjunto de datos SAS
(permanente) Leer.SSD Relaciones
Carga de archivos desde otros programas

| 209
WWW .IT-EBOOKS.INFO
Formato de archivo Función Biblioteca
SAS (XPORT formato) Leer.xport Relaciones
Sps. Read.spss Relaciones
Stata Leer.dta Relaciones
Systat Leer systat. Relaciones
La conexión a las bases de datos

También puede utilizar r para conectarse a una base de datos y leer datos. La
forma de hacerlo dependerá del sistema de gestión de bases de datos que se
utilice. Trabajar con una base de datos requerirá experiencia que va más allá
de las habilidades de un típico R usuario. Sin embargo, si usted está
interesado en hacer esto, el mejor lugar para comenzar es mediante la
descarga de estos paquetes R y leer la documentación.
Utilice el paquete RODBC para conectarse a las bases de datos a través de una
conexión ODBC.
Utilice el paquete DBI para conectarse a bases de datos a través de conductores

individuales. El DBI pack- edad proporciona una sintaxis común para trabajar con bases de
datos diferentes. Usted tendrá que descargar un paquete específico de base de datos para
utilizar en conjunción con DBI. Estos paquetes proporcionan la API para los controladores
nativos de diferentes programas de base de datos. Para usar MySQL RMySQL, para uso
de SQLite RSQLite, para uso con Oracle, para utilizar PostgreSQL ROracle RPost- greSQL
y para las bases de datos que utilizan los controladores basados en Java Database
Connectivity (JDBC) utilizar API RJDBC. Una vez que haya cargado el controlador
apropiado paquete, puede usar los comandos proporcionados por DBI para acceder a su
base de datos.
WWW .IT-EBOOKS.INFO
Apéndice E
Depurar código R
Este apéndice se refiere a entornos, el tema Chapter 6, y utiliza

ejemplos de Chapter 7 y Chapter 8. Usted debe leer estos
capítulos primero a sacar el máximo partido de este apéndice.
R viene con un simple conjunto de herramientas de depuración que amplifica

RStudio. Puede utilizar estas herramientas para comprender mejor el código
que produce un mensaje de error o devuelve un resultado inesperado.
Generalmente, éste será su propio código, pero también puede examinar las
funciones en R o uno de sus paquetes.
Depuración de código puede tener como mucho la creatividad y la perspicacia
como escribir código. No hay ninguna garantía de que usted encontrará un bug o
ser capaz de arreglarlo cuando usted lo hace. Sin embargo, tú te puedes ayudar
mediante R las herramientas de depuración. Estos incluyen
el rastreo, navegador, depurar debugonce, TRACE,
y recuperar funciones.
El uso de estas herramientas es normalmente un proceso de dos pasos. En

primer lugar, localizar el lugar donde se ha producido un error. A continuación,
intenta determinar por qué se produjo. Usted puede hacer el primer paso con
R la función de rastreo.
Rastreo.
El rastreo herramienta identifica la ubicación de un error. Muchas funciones
de R R llamar a otras funciones que llaman a otras funciones, y así
sucesivamente. Cuando se produce un error, puede que no sea claro cuál de
estas funciones ha ido mal. Veamos un ejemplo. Las siguientes funciones
llamar uno al otro, y la última función crea un error (usted verá porqué en un
segundo):
Primero <- función() segunda()
Segundo <- función() Tercer()
211
WWW .IT-EBOOKS.INFO
Tercer <- función() cuarto()
Cuarto <- función() quinto()
Quinta <- función() bug()
Cuando se ejecuta la primera, segunda llamada, que llamará a terceros,

que llamará cuarto, que llamará quinto, que llamará bug, una función que
no existe. Aquí está lo que parecerá en la línea de comandos:
First()
## Error en el quinto() : no pudo encontrar la función "bug"
El informe de error nos indica que el error se produjo cuando R intentó

ejecutar quinta. También nos indica la naturaleza del error (no hay una
función llamada bug). Aquí, es obvio por qué R llama quinto, pero puede no
ser tan obvio por qué R llama a una función cuando se produce un error en el
medio silvestre.
Puede ver la ruta de funciones que R llama antes de golpear un error
escribiendo trace back() en la línea de comandos. Rastreo devolverá
una pila de llamadas, una lista de las funciones que R se llaman en el orden
que les había llamado. La función inferior será el comando que se ha
introducido en la línea de comandos. La primera función será la función que
ha causado el error:
Rastreo()
## 5: Quinto() en #1
## 4: cuarto() en #1
## 3: Tercer() en #1
## 2: Segundo() en #1
## 1: first()
Rastreo siempre hará referencia al último error que se ha producido. Si quieres echar
un vistazo a un menor error reciente, tendrá que volver a crearlo antes de ejecutar
el rastreo.
¿Cómo puede ayudarle? En primer lugar, rastreo devuelve una lista de

sospechosos. Una de estas funciones ha causado el error, y cada función es más
sospechosas que los que están debajo de él. Lo más probable es que nuestro bug
vinieron de quinta (lo hizo), pero también es posible que una función anterior hizo
algo extraño como quinta llamada cuando no debería tener.
Segundo, rastreo puede mostrar si R bajamos el camino que usted esperaba.

Si esto ocurriera, mire la última función antes de que las cosas salieron mal.
Tercero, el rastreo puede revelar el grado alarmante de recursión infinita de
errores. Para el ex- amplio, si cambia la quinta para que llame a segunda,
las funciones hará un bucle: segundo llamará a terceros, que
llamará cuarto, que llamará quinto, que va a llamar la segunda e iniciar el
ciclo de nuevo. Es más fácil hacer este tipo de cosas en la práctica de lo que
usted podría pensar:
Quinta <- función() segunda()
212 | Apéndice E: Depuración de código R
WWW .IT-EBOOKS.INFO
Cuando usted llame primero(), R comenzará a ejecutar las funciones. Después de un
rato, se notará que se repite y devolverá un error. Rastreo mostrará exactamente lo que
estaba haciendo R:
First()
## Error: evaluación demasiado profundamente anidados: recursión
infinita/opciones(expresiones=)?
Rastreo()
## 5000: Cuarta() en #1
## 4999: Tercera() en #1
## 4998: segunda() en #1
## 4997: QUINTO() en #1
## 4996: Cuarta() en #1
## 4995: Tercera() en #1
## 4994: segunda() en #1
## 4993: QUINTO() en #1
## ...
Observe que hay 5.000 líneas de salida en este rastreo. Si usted está usando
RStudio, usted no podrá ver el rastreo de una recursión infinita error (he utilizado el
GUI de Mac para obtener esta salida). RStudio reprime el rastreo de errores de
recursión infinita para pre- La ventilación grandes pilas de llamada desde su consola
empujando la historia de R del búfer de memoria. Con RStudio, tendrá que reconocer
el error de recursividad infinita por su mensaje de error. Sin embargo, aún se puede
ver el imponente rastreo ejecutando cosas en un shell de UNIX o el GUI de Windows
o Mac.
RStudio hace que sea muy fácil de usar rastreo. No necesita escribir el
nombre de la función. Cuando se produce un error, RStudio lo mostrará en un
cuadro gris con dos opciones. La primera es mostrar rastreo, se muestra en
la Figure E-1.
Figura E-1. RStudio del show rastreo opción.
Si hace clic en Mostrar Rastreo, RStudio ampliará el cuadro gris y mostrar la pila de
llamadas de rastreo, como en Figure E-2. La opción Mostrar trazas persistirá junto a un
mensaje de error en su consola, incluso al escribir comandos nuevos. Esto significa que
puede ir hacia atrás y mirar las pilas de llamadas para todos los errores, no sólo el error
más reciente.
Imagina que has usado rastreo para localizar una función que usted piensa
que podría causar un error. Ahora, ¿qué debe hacer? Usted debe tratar de
averiguar qué hizo la función a causa de un error mientras se ejecutó (si lo
hiciera nada). Puede examinar la forma en que la función se ejecuta con
el explorador.
Rastreo. | 213
WWW .IT-EBOOKS.INFO
Figura E-2. RStudio Rastreo del display.
Navegador
Usted puede pedir R para hacer una pausa en el medio de la ejecución de una función
de control y dar vuelta con el explorador. Esto le permitirá introducir nuevas en la
línea de comandos. El entorno activo de estos comandos no será el medio ambiente
mundial (como de costumbre); será el entorno de tiempo de ejecución de la función
que se ha pausado. Como resultado, usted puede mirar los objetos que está utilizando
la función, buscar sus valores con las mismas reglas de ámbito que la función podría
utilizar y ejecutar código bajo las mismas condiciones que la función se ejecute en él.
Esta disposición ofrece la mejor oportunidad para observar el origen de errores en una
función.
Para utilizar el navegador, añadir la llamada browser() en el cuerpo de una

función y, a continuación, vuelva a guardar la función. Por ejemplo, si quería
una pausa en medio de la puntuación en función del Chapter 7, yo podría
añadir browser() al cuerpo de puntuación y, a continuación, vuelva a
ejecutar el siguiente código, que define el resultado:
Score <- función (símbolos) {
# Identificar caso
% c("B", "BB", "BBB").
# Obtener
premio si (
misma) {
Los
pagos <- c("DD" = 100, "7" = 80, "BBB" = 40,
"BB" = 25, "B" = 10, "C" = 10, "0" = 0).
Premio <
- 5 } else
{
Las
WWW .IT-EBOOKS.INFO
}
Browser()
# Ajustar de diamantes
}
Ahora cada vez que se ejecuta R puntuación, vendrá a la

llamada browser(). Usted puede ver esto con la función de reproducción
de Chapter 7. Si no tienes a mano play, puedes acceder a él mediante la
ejecución de este código:
Prob = c(0,03, 0,03, 0,06, 0,1, 0,25, 0,01, 0,52)).
}

Estructura(puntuación (símbolos), los símbolos , los símbolos =
clase = "ranuras").
}
Cuando se ejecuta el juego, el juego se llamar a get_símbolos y luego puntuación.

Como R funciona a través de puntuación, que vendrá a través de la llamada
al navegador y ejecutarlo. R Cuando se ejecuta esta llamada, varias cosas van a ocurrir,
como en la Figure E-3. En primer lugar, R se detenga la ejecución de puntuación.
Segundo, la com- My pronto cambiará al navegador[1]> y R me dará de nuevo el control;
ahora puedo escribir comandos nuevos en la nueva línea de comandos. Tercero, tres
botones aparecerán en el panel de la consola: Siguiente, Continuar, y se detiene. Cuarto,
RStudio mostrará el código fuente de la puntuación en el panel de scripts, y se resalta la
línea que contiene el navegador(). Quinto, los entornos ficha cambiará. En lugar de
revelar los objetos que se guardan en el entorno mundial, dará a conocer los objetos que
se guardan en el entorno de tiempo de ejecución de la puntuación (consulte Chapter
6 para obtener una explicación del entorno del R system). Sexto, RStudio abrirá un nuevo
panel de trazas, que muestra la pila de llamadas RStudio tomó llegar a Explorador. La
más reciente, la función de puntuación, quedará resaltada.
Ahora estoy en un nuevo modo de R, llamado modo navegador. Modo navegador está
diseñado para ayudarle a descubrir errores y la pantalla nueva RStudio está diseñado para
ayudarle a navegar a través de este modo.
Cualquier comando que se ejecute en modo explorador será evaluado en el

contexto del entorno de tiempo de ejecución de la función que llamó
el explorador. Esta será la función que está resaltada en el nuevo panel de
trazas. Aquí, esa función es puntuación. Así que mientras estamos en el
modo Explorador, el entorno activo será puntuación's runtime environment.
Esto le permite hacer dos cosas.
Navegador |
215
WWW .IT-EBOOKS.INFO
Figura E-3. RStudio actualiza su pantalla cada vez que se entra en el modo
de explorador para ayudarle a navegar en el modo.
En primer lugar, usted puede inspeccionar los objetos que utiliza la puntuación.
Los entornos actualizado panel muestra qué objetos puntuación ha guardado en
su entorno local. Usted puede inspeccionar cualquier de ellos escribiendo su
nombre en el listado de comandos. Esto le da una forma de ver los valores de las
variables en tiempo de ejecución que normalmente no podría acceder. Si un valor
se ve claramente equivocada, puede estar cerca de encontrar un bug:
Busque[1]> Símbolos
## [1] "B" "B" "0"
Busque[1]> mismo
## [1] FALSE
En segundo lugar, se puede ejecutar el código y ver los mismos resultados

que vería la puntuación. Por ejemplo, puede ejecutar las líneas restantes de
la partitura de la función y ver si hacen algo inusual. Puede ejecutar estas
líneas escribiendo en la línea de comandos, o puede utilizar los tres botones
de navegación que aparecen ahora por encima del símbolo, tal como se
muestra en la Figure E-4.
El primer botón, a continuación, ejecutará la siguiente línea de código en
la puntuación. La línea resaltada en el panel scripts avanzará por una línea para
indicar la nueva ubicación en función de la puntuación. Si la siguiente línea comienza
un fragmento de código, como un bucle o un árbol, si R se ejecutará todo el segmento
y pondrá de relieve todo el fragmento en la ventana Script.
El segundo botón, Continuar, ejecutará todas las líneas restantes de

la puntuación y, a continuación, salir del modo explorador.
El tercer botón, parada, saldrá de modo navegador sin correr más líneas de puntuación.

WWW .IT-EBOOKS.INFO
Figura E-4. Usted puede navegar el modo explorador con los tres botones en
la parte superior del panel de consola.
Usted puede hacer lo mismo escribiendo los comandos n, cy Q en el navegador rápido.

Esto crea una molestia: ¿Qué pasa si usted desea buscar un objeto denominado n, co q?
Escribir el nombre del objeto no funcionará, R o avanzar, continuar o salir del modo
explorador. En su lugar, usted tendrá que mirar estos objetos con los
comandos get("n"), get("C"), y get("P"). cont es sinónimo de c en el modo
explorador y dónde se imprime la pila de llamadas, de modo que tendrá que buscar estos
objetos con get .
Modo navegador puede ayudar a ver las cosas desde la perspectiva de sus funciones,
pero no pueden mostrar dónde radica el error. Sin embargo, el modo explorador le
puede ayudar a probar hy- potheses e investigar el comportamiento de la función.
Generalmente, eso es todo lo que necesitan para detectar y corregir un error. El
navegador es la herramienta de depuración básica de R. Cada una de las siguientes
funciones sólo proporciona una forma alternativa para entrar en el modo explorador.
Una vez que se corrija el error, debe volver a guardar su función una tercera
vez, esta vez sin el navegador() realiza la llamada. Mientras el explorador
llamada está allí, R hará una pausa cada vez que usted, u otra función,
llamadas puntuación.
Puntos de ruptura
Puntos de ruptura del RStudio proporcionan una forma gráfica para añadir
un navegador declaración a func- ción. Para utilizarlos, abrir el script donde se
ha definido una función. A continuación, haga clic a la izquierda del número de
línea de la línea de código en el cuerpo de la función a la que te gustaría añadir el
navegador declaración. Un punto rojo aparecerá hueco para mostrar dónde se
producirá el punto de ruptura. A continuación, ejecute el script haciendo clic en el
botón Source en la parte superior del panel de scripts. El punto hueco se convertirá
en un sólido punto rojo para mostrar que la función tiene un punto de ruptura
(véase Figure E-5).
Puntos de ruptura
| 217
WWW .IT-EBOOKS.INFO
R tratará el punto de ruptura como un navegador, declaración, entrar en el
modo explorador cuando la encuentre. Puede quitar un punto de interrupción
haciendo clic en el punto rojo. El punto desaparecerá y el punto de ruptura
será eliminado.
Figura E-5. Puntos de ruptura proporcionan el equivalente gráfico de un

navegador declaración.
Puntos de ruptura y el navegador proporciona una gran manera de depurar

funciones que usted ha definido. Pero lo que si desea depurar una función que
ya existe en el r? Puede hacerlo con la función de depuración.
Debug
Usted puede "agregar" un navegador llamada al comienzo de una función preexistente
con debug. Para ello, ejecute debug en la función. Por ejemplo, puede
ejecutar debug muestra con:
Debug(ejemplo)
Posteriormente, R actuará como si hay un explorador() una declaración en la

primera línea de la función. R Cada vez que se ejecuta la función, entrará
inmediatamente en modo de explorador, lo que le permite avanzar a través de la
función de línea en línea. R seguirá comportándose de esta manera hasta que
"quitar" el navegador declaración con undebug:
Undebug(ejemplo)
Puede comprobar si una función está en "modo de depuración" con isdebugged.

Esto devolverá TRUE si se ha ejecutado la función de depuración pero que
todavía tienen que ejecutar undebug:
Isdebugged(ejemplo)
## FALSE
Si todo esto es demasiado de una molestia, puede hacer lo que hago y

uso debugonce en vez de debug. R entrará en modo navegador la próxima vez que
se ejecuta la función pero auto-
WWW .IT-EBOOKS.INFO
Undebug matically la función después. Si usted necesita para navegar a través
de la función de nuevo, puede simplemente ejecutar debugonce sobre ella
una segunda vez.
Usted puede recrear en RStudio debugonce siempre que se produzca un error.
"Volver a ejecutar con debug" aparecerá en el cuadro de error gris debajo
muestran Rastreo (Figure E-1). Si hace clic en esta opción, RStudio volverán a
ejecutar el comando como si tuvieras la primera ejecución debugonce sobre ella.
R podrán ir inmediatamente a modo de explorador, lo que le permite ejecutar el
código paso a paso. El comportamiento del navegador sólo se producirá en esta
ejecución del código. Usted no tiene que preocuparse de llamar undebug cuando
haya terminado.
Trace
Puede agregar el explorador declaración aún más en la función, y no al comienzo,
con traza. Trace toma el nombre de una función como una cadena de
caracteres y luego un R la expresión que se va a insertar en la función. También
puede proporcionar un argumento que le indica en qué línea de traza de la
función para colocar la expresión. Así, para insertar un explorador llamada en la
cuarta línea de la muestra, se puede ejecutar:
Trace("sample", navegador, a = 4).
Puede utilizar la traza a insertar otros R (no sólo las funciones de navegador) en una
función, pero puede que necesite pensar de una astuta razón para hacerlo. También puede
ejecutar la traza en una función sin insertar ningún código nuevo. R se
imprime traza:<la función> en la línea de comandos cada vez que se ejecuta la función
R. Esta es una gran manera de probar un reclamo que hice en Chapter 8, que R
llama imprimir cada vez que aparece algo en la línea de comandos:
Trace(print)
Primera
## Trace: print(function () segunda())
## Function() Segundo()
Cabeza(cubierta)
## Trace: imprimir
## Valor traje cara
## 1 Rey de picas 13
## 2 queen picas 12
## 3 Jack picas 11
## 4 Diez picas 10
## 5 Nueve picas 9
## 6 8 picas 8
Una función puede volver a la normalidad después de llamar rastro

con untrace:
Untrace(ejemplo)
Untrace(print)
Trace |
219
WWW .IT-EBOOKS.INFO
Recuperar
La recuperación de la función proporciona una opción final para la
depuración. Combina la pila de llamadas de rastreo con el navegador en
modo de explorador. Puede utilizar recuperar sólo como explorador,
insertándolo directamente en una función del cuerpo.
Demostremos recuperar con la quinta función:
Quinta <- función() recuperar()
Cuando se ejecuta R recuperar, hará una pausa y mostrar la pila de

llamadas, pero eso no es todo. R le da la opción de abrir un navegador en
modo en cualquiera de las funciones que aparecen en la pila de llamadas.
Irritantemente, la pila de llamadas se mostrarán boca abajo frente
a rastrear. La función más reciente estará en la parte inferior, y la función
original quedará en la parte superior:
First()
##
## Introduzca un número de fotograma, o 0 para salir
##
## 1: first()
## 2: #1: Segundo()
## 3: #1: tercera()
## 4: #1: cuarto()
## 5: #1: quinta()
Para entrar en un modo de explorador, escriba el número junto a la función,

en cuyo entorno de tiempo de ejecución que desea examinar. Si no desea
examinar cualquiera de las funciones, tipo 0:
3
## Selección: 3
## Llama desde: cuarto()
## Busque[1]>
A continuación, puede proceder como normal. Recuperar le da la

oportunidad de inspeccionar las variables arriba y abajo en la pila de llamadas
y es una potente herramienta para destapar errores. Sin embargo, la adición
de recuperar el cuerpo de una función de R puede ser engorroso. La
mayoría R usuarios lo utilizan como una opción global para el manejo de
errores.
Si se ejecuta el siguiente código, R llamará
automáticamente recuperar() cuando se produce un error:
Opciones(error = recuperar)
Este comportamiento durará hasta que usted cierra su sesión, o R el comportamiento

inverso, llamando al:
Opciones(error = NULL)
WWW .IT-EBOOKS.INFO
Índic
e
[1]. 6
Los símbolos [[ (Disco doble), soportes, 73
Operador !=, 81
{} (Llaves), 17
" (Comillas), 41
| Operador, 85 128
# (Hashtag carácter), 6, 136
operador ||, 128
## (Doble hashtag
carácter), 6 $ (signo de
dólar), 73, 97 Un
%*% Funciones de descriptor de acceso, 96
Operador, 11 %en Entornos activos, 97, 99
% El álgebra, 66
operador, 81 %s% Todas las funciones, 85, 121
operador, 11 opera Cualquier función, 85, 121
dor & 85, 128 && Args () 14
operador 128 ) Argumentos
(paréntesis), Aplicar múltiples, 13
el 26 operador Valores predeterminados para, 19
+, 148 Definición de, 12
+ indicador, 5 Mirando hacia arriba, 14
- El operador, 148 Naming, 13, 18
.Llamada, 179 La aritmética básica, 6
.Interno 179 Función array, 46
.Primitivo, 179 As.funciones de carácter, 50
: (Dos puntos), el Como función.entorno 95
operador 5, 7 operad Función asignar 97
or <, 81, 148 Asignación, 99
<- el operador de Operador de asignación (<-
asignación, 77, 81, 97, 174 <= ), 77, 81, 97, 174 vectores atómica
operador, 81 Caracteres, 41
= (signo igual), Clase, 47
el 81 operador
==, 81 >,
operador 81
> prompt, 6 >=,
operador 81
? (Signo de interrogación), 29
[ (Soporte duro, único), 26, 65, 74
Nos gustaría escuchar sus sugerencias para mejorar nuestros índices. Enviar correo
electrónico a Index@oreilly.com.
221
WWW .IT-EBOOKS.INFO
La coacción en, 51 Prevención de factoring, 201
Complejo, 42 Factores vs. 50
Crear con c, 38 Vs. R objetos, 41
Descubrir el tipo de, 39 Atributo de clase 47
Se duplica, 39, 48 Clases, crear nuevo, 151
Enteros, 40 (Véase también sistema de clase S3)
Logicals, 42 Los cierres, 107
Raw, 42 Código
Probando, 38 Los comentarios de código, 136
Tipos de, 38 Compilación de, 5, 177
Attach() 76 Creación de borradores con
Función attr, 141 R, 20 creando scripts en
Atributos velocidad (véase código
Agregar, 141 vectorizadas) de legibilidad, 17
Como metadatos, 43, 140 Estrategia para la codificación, 118, 138
Clase, 47 La coerción, 51
Dim, 45 Operador dos puntos (:), 5, 7
Mostrar, 43, 140 Columnas, eliminar de las tramas de
Mirando hacia arriba, 141 datos, 78 archivo de valores separados
Nombres, 44 por comas (.csv file), 58, la 199 207 línea
Valor promedio, 156 de comandos
Definición de, 4
Los paquetes de descarga
B R, 24 mensajes de error, 6
R base, 191, 197 Página de ayuda de
Binarios, instalar palabras clave, 31 los
R, 188 binwidth comandos de búsqueda
argumento, 26 espacio en Cancelación 6
blanco la Definición de, 4
indexación, 69 booleano, 4 Repitiendo con replicar, 27
2 operadores Comentando el símbolo, 6
booleanos, 85 Las comparaciones, 42, 82
Argumentos, delimitador 208 Vectores atómicas complejas, 38, 42
Las llaves ({}), 17 (C) la función CONCATENAR, 25, 38, 148
Puntos de ruptura, 217 Copiar/pegar, desde hojas de cálculo de
Navegador (herramienta Excel 207
de depuración), 214 Modo Página de CRAN, 24, 187, 192
de CreateSheet, 208
explorador, 215 bytes 42 Ctrl + C, 6
Función bzfile 204
Compresión bzip2, 204
D
Datos
C Boolean, 42
(C) la función La coerción de tipos de datos, 51
CONCATENAR, 25, 38 148 calc Examinar importadas, 59
uladora, 6 Importar desde internet 59
Llamar a medio ambiente, 103 Cargar/guardar
La capitalización, 9 Los conjuntos de datos en la base
La distinción entre mayúsculas y R, 197
minúsculas, 9 Hojas de cálculo de Excel 206.209
Información categórica, 50 En las bases de datos 210
Carácter vectores atómico, 38, 41 En R objetos, 57, 61
Cadenas de caracteres
Cargando archivos de otros
Montaje, 41 programas, 209 archivos de
texto, 198-205
222 | Índice
WWW .IT-EBOOKS.INFO
R archivos, 205 Dimensiones (DIM), 45 envío,
Directorio de trabajo 198 atributo de los métodos,
el 148 signo del dólar
Varios tipos de objetos, se almacena
($), 73, 97
en R 51
Los tipos de objetos disponibles 61
Almacenar como vectores,
lógico 42
Almacenar como unidimensional,
conjuntos 53
Almacenar como listas
bidimensional, 55
Bytes de almacenamiento, 42
Almacenar información
categórica, 50 almacenar
varios tipos de 53 tipos de
objetos, se almacena en R 38
Las tramas de datos
Atributos y, 140
Beneficios 55
Examinando los datos
importados, 59 eliminar
columnas, 78 seleccionar
columnas de, 68, 73
La ciencia de datos
Ventajas de las habilidades de
programación, 1 conjuntos de
habilidades básicas necesarias
para, 185 fundación de, 34
Problema tipos
enfrentan, 184 los
conjuntos de datos
Acople, 76
Examinar, 60
En base R, 197
Cargando con el asistente de
importación, RStudio 58
Entrada manual de, 57
Varios tipos de datos, 51
Utilizando, 197
Las bases de datos,
conexión, 210 fechas/hor
as, 48 DBI paquete, 210
La función de depuración 218
Herramientas de depuración
Puntos de ruptura, 217
Explorador, 214
Depurar, 218
S3 sistema de clase, 152
Recuperar, 220
Trace, 219
Rastreo, 211
Debugonce, 219
Paquete de R devtools
Instalación de R de fuentes
alternas, 193 función parenvs 94
Los entornos de
Vectores, atómica
ejecución, 100 guardar
doble 38, 39 48 doble signo
objetos en
de igualdad (==), 81 doble
particular, 97 reglas de
carácter hashtag (##), 6 gota
alcance, 98
= falso
Visualización de objetos guardados
argumento, 68 lenguajes de
en, 96
programación dinámicos, 5
Visualizar la estructura 95
Operador de igualdad (==) 81
E El signo igual (=) 81
Elemento de ejecución- Los errores y mensajes de error
sabio, 10, 81, 86, 171 else, 12 Los valores de los argumentos, 19
3-130 endCol argumento, 208 Interfaz de línea de
EndRow argumento, 208 comandos at, 6 errores de
Medio ambiente, función 97 punto flotante, 40 en
Panel entorno, 8, 9 objeto de llamadas, 98
Entornos Indización entero
Acceso a objetos específicos, 97 positivo/negativo, 68 estrategia
Activo, 97, 99 para abordar, 138 cuando la
Asignación y 99 creación de cadenas de
Llamar a medio ambiente, 103 caracteres, 41 cuando se nombre a
Los cierres, 107 argumentos, 13 con sentencias
Mostrar con función parenvs 94 if, 121
Vacía, 96 Escuela ERSI es un formato de
La evaluación, 100-107 ArcGIS, 209
Global, 96 La evaluación, 100-107
Hojas de cálculo de Excel.
Funciones auxiliares
para, 95 organización Copiar/pegar datos
jerárquica de, 93 mirando de 207 tramas de datos 55
hacia arriba, el 96 origen,
el entorno primario 101
Índice |
223
WWW .IT-EBOOKS.INFO
Exportación de datos 206 Como verbos, 34
Lectura, 207 Como personaje. 50
Escribiendo, 208
Paquete XLConnect, 207, 209
Ampliar.grid y, 157- función162
Los valores esperados, 155
Expresiones, 121
Función de extracción, 22, 136
F
F (falso), 42, 69, 80, 121
Función factorial, 12
El factoring, prevenir, 56, 59, 201
Factores, 50
Falso (F), 42, 69, 80, 121
Archivos
Archivos de ancho fijo
(.fwf), 202 vínculos
HTML en, 203
Listado en el directorio de
trabajo, 198 cargar/guardar desde
otros programas, la 209 falta de
información, 199 archivos de
texto, 198
(Véase también archivos de texto
sin formato)
R archivos
Abrir/Guardar, 205
Frente a archivos de texto
plano, 206
RData archivos
Apertura, 205
Ahorro, 205
Vs. Archivos RDS, 205
Archivos RDS
Apertura, 205
Ahorro, 205
Vs. RData
archivos, 205 RStudio,
asistente de importación de
archivos 58
Archivos de ancho fijo
(.fwf), 202 aritmética de
punto flotante, 40 errores
de punto
flotante, 40 bucles
for, 163-
168, 178 paquete
exterior, 209 constructor
Function, 17 funciones
Funciones de descriptor de
acceso, 96
Todos, 85, 121
Cualquier, 85, 121
Argumentos, 12
Matriz, 46
As.entorno, 95 Replicar, 27
Asignar, 97 Redondo, 12
Attr, 141 Row.names, 140
Base de la colección de, R 191 R_EmptyEnv, 96
Fundamentos de, 16 R_GlobalEnv, 96
Cuerpo de, 18 La función de ejemplo, 12, 29
Medio ambiente, 97 Muestra con sustitución, 14
Ampliar.grid 157- función162 Show_env, 100
Función de extracción, 22, 136 De almacenamiento, 99
Factorial, 12 Función Suma 15
Genérico, 145 Sys.tiempo, 172
Cabeza, 60 System.time, 172
Páginas de ayuda para, 29 Cola, 60
Funciones auxiliares, 44, 95, 140 Almacenamiento temporal de, 99
Install.packages, 191 Única, 127
Es.na, 90 UseMethod, 146, 148
Los niveles, 140 Utilizando, 12
Ls, 9, 96 Escribir su propio, 17
Ls.str, 96
Función de matriz, 46 G
Media, 90 Las funciones genéricas, 145
Varios argumentos, 13, 19 Getwd() 61. 198
Orden de ejecución 12 Paquete ggplot2, 23
Parenvs, 94
Partes de, 17
Imprimir, 117, 139, 145
224 | Índice
WWW .IT-EBOOKS.INFO
Entorno global 96 Enteros
Gnu zip (compresión Negativo, 68
gzip), 204 gráficos Positivo, 66
Histogramas, 26 Es.na función, 90
Función qplot, 23 Es.vector() 38
Scatterplots, 25
Gzfile función, 204
K
Keywords, 31
H
Soporte duro, sola
([), 26, 65 74 soportes de
L
disco, doble ([[), 73 carácter L, 40
hashtag (#), 6 función de Función de niveles, 140
cabeza, 60 Biblioteca(), comando, 24, 192
Cabeza(deck) 59 Álgebra lineal, 66
Argumento encabezado, 199 List.files() 198
Encabezados, 58 Listas, 53, 73
Ayuda Función de carga, 205
Páginas de ayuda 29 LoadWorkbook, 207
Las comunidades de usuarios, 33 Vectores, atómica lógico 38, 42
Funciones auxiliares Operadores lógicos, 81
Matriz, 46 Subconjuntos lógicos, 80
As.entorno, 95 Pruebas lógicas, 80, 121, 171
Para entornos, 95 Valor lógico indización, 69
Los niveles, 140 Tablas de consulta 130:135
Matrix, 46 Los bucles
Finalidad 44 Ventajas e inconvenientes de
Row.names, 140 la 169 función expand.grid
Histogramas, 26 y, 157-162 los valores
Vínculos HTML, en ficheros de esperados y, 155 bucles
texto, 203 código legible, 5 for, 163-168
Repita, 169
Ahorro de salida, 169
Yo Vs. código vectorizadas, 183
Yo, 42 Los bucles while, 168
Si las declaraciones, 120 Función ls, 9, 96
Ij notación, 66 Ls.función str, 96
Muestras aleatorias
independientes, 15 índices
0 vs. 1 como punto de
M
partida, 68 espacios en Mac R GUI, 189
blanco, 69 los valores Código legible por máquina, 5
lógicos 69 Formato de Matlab, 209
Nombre, 70 Función de matriz, 46
Los enteros negativos, 68 Multiplicación de matrices, 10
Números enteros positivos, 66 Función media, 90
Escrito 65 Mensajes, mostrar, 117, 145
Cero, 69 (Véase también los errores y mensajes de
Errores de recursión
error)
infinita, 213 install.packages
Los metadatos, 43
función, 24 191 vectores,
Métodos 146:150
atómica , Entero 38, 40
Índice |
225
WWW .IT-EBOOKS.INFO
Formato de Minitab, 210
Falta información
P
Paquetes, 191
En ficheros de texto, 199
(Véase también paquetes R)
Gestión, 89
DBI, 210
Varios tipos de datos,
Exterior, 209
almacenar, 53 multiplicació
n Ggplot2, 23
Operadores para RODBC, 210
interior/exterior, 11 XLConnect, 207, 209
Elemento vs. matrix-sabio, Asuntos paralelos subtarea, 119
ejecución 10 Paréntesis.env, 96
Entorno principal, 94
Paréntesis ), 26
N Función parenvs 94
NA, caracteres 89 Los archivos de texto sin formato
Na.rm argumento, 90 Beneficios de, 198, 206
Na.strings argumento, 199 Comprimir, 204
Nombres/denominación Argumento encabezado, 199
Atributos, 142 Enlaces en HTML, 203
Tramas de datos, 56 La carga, 58, 199, 201
Mostrar usados anteriormente, 9 Na.strings argumento, 199
Nombre indización, 70 Argumento nrow, 200
Nombres de atributo 44 Leer.fwf, 202
De los argumentos, 13 Ahorro, 203
Métodos, 148 Argumento sep, 199 vaya
Reglas de R objetos, 8 argumento, 200 stringAsFa
Argumento nrow, 200 ctors argumento, 201 la
NULL 43, 78 estructura de la
Números tabla, 199 vs. R
Crear una secuencia de archivos, 206
, 5 7 manipular conjuntos Naipes proyecto construcción
de, 9 un vector cubierta
de 7 vectores, regresando completa, 56 cambiando los
con c, el 25 ahorro como valores de punto de
R, 7 almacenar objetos tarjeta, 77 creando una copia
como vectores de del mismo, la 77 creación de
doble, 39 almacenar como cartas de la
vectores de baraja, 38 repartir las
enteros, 40 almacenamiento cartas, 70, 104 Descarga de
complejo 42 trama de datos, la
Almacenar en n-dimensional, plataforma 57 cubierta
arrays de 46 almacenamiento en acabada
matrices bidimensionales, 46 vs. apariencia, 37 localizando
cadenas, 41 tarjetas
Valores numéricos (ver doble atomic individuales, 86 descripción
vectores) de 35
Tarjeta de ahorro nombres, 43
Oh Guardar datos, 61
Barajar cartas, 71, 107
Programación orientada a objetos
Almacenamiento de tarjetas en
(OOP), 153 objetos
runtime environment, 108 almacenar
Definición de, 7
tarjetas con listas, 54
(Véase también objetos R) Números enteros positivos, 66
Funciones como, 99 Clase POSIXct 48
Temporal, 99 Clase POSIXt 48
Los datos en línea, 59
Entorno de origen, 101
La función de factor, 147 print.POSIXct
impresión, 117, 139 14 método, 147
5 imprimir.método
226 | Índice
WWW .IT-EBOOKS.INFO
Probabilidad, 158 Sistema de notación R
Programas Espacio en blanco la
Los comentarios de código, 136 indexación, 69 cambiando
Mostrar mensajes en los valores en su lugar,
, 117 145 else, 123-130 si el 77 signo del dólar
las declaraciones, 120 ($), 73, 97
Mejora el rendimiento de (véase Extracción de valores de R
código vectorizadas) objetos 65 duros, los corchetes
Tablas de ([]), 73
búsqueda, 130- Soportes de disco, doble
135 asuntos paralelos ([[]]), 73 valores
subtarea, 119 guardar 1 lógicos, 69 nombre de
17 indización indización, 70
Pasos secuenciales Entero negativo la
subtarea, 118 estrategia de indexación, 68 número
codificación, 118, 126, 138 envol entero positivo de
ver en funciones, 136 indexación, 66 indexación,
cero 69
R Acceso a
Q objetos, 9
Función qplot Acceso en entornos
Descargar/Instalar, 23 específicos, 97 matrices 46
Creación de histograma, 26 Como
Scatter Plot creación con, 25 nombres, 34 v
El signo de interrogación (?) 29 ectores
Las parcelas, rápido 25 atómica
Comilla ("), 41 Personajes 41 com
plejos, 42 crear con
R c, 38 tipo de
R descubrimiento, 39
32- frente a las versiones de 64 duplica, 39 enteros
bits, 188 40 logicals, 42
Base R, 191 Raw, 42 prob
Modo de explorador, 215 ando, 38 tipo
s de, 38
Edificio en declaraciones
elocuentes, 34 construyendo Atributos
desde los archivos Como
fuente, 188 descarga/instalación, metadatos, 43 dim
187 programación dinámica , 45 mostrar 43, 1
capacidades, 5 páginas de 40 nombres, 44, 1
ayuda, 29 42
Instalando a partir de binarios, 188 Clase, la 47 coerción,
Apertura, 190 la 51 creación, la 8 creación de
Actualización, 195 vacío, 69 creando objetos
Las comunidades de usuarios, 33 nulos, 43 tramas de
Interfaz de usuario (véase datos, 55, 59, 68, 73 fechas/horas,
RStudio) con 48 elemento-wise en
RStudio, 189 utilizando con ejecución, 10 extracción de
Unix 189 vs. R idioma, 5 valores (consulte notación R)
R Expresiones, 121 factores, 50
R archivos
Abrir/Guardar, 205
Frente a archivos de texto plano, 206
R biblioteca, mostrar los paquetes Listas, 53,
actuales, 192 la 73 carga de
datos, 57
(Véase la manipulación de Modificar valores en el
matrices, los entornos). 46 lugar, 77 nombres 8
Índice |
227
WWW .IT-EBOOKS.INFO
Guardar en particular Recursividad errores, 213
entorno, 97 reglas de alcance Repita los bucles, 169
y 98 tipos disponibles, 61 Replicar la función, 27
Actualización, 97 Paquete RODBC, 210
Reciclaje en vectores, 10 Función Round, 12
Ver guardados en Row.names = FALSE 61
entornos, 96 frente a cadenas Función row.names 140
de caracteres, 41 RStudio
R paquetes Cambiar directorio de
Beneficios de, 191, 193 trabajo, 198 interfaz de línea de
Mostrar actualmente comandos, el 4 visor de
instalado, 192 instalar 191 datos, 59
Instalación de fuentes Descargar 189
alternativas, la 193 instalación Panel entorno, 8, 9, 96
desde la línea de comandos, Función de extracción, opción 136
la 24 instalación de Asistente de importación de archivos 58
espejos, 192 instalar Gui para Windows y Mac, 189
varios, 192 lista de Ficha Ayuda, 29
disponibles, 193 IDE para R, 190
Carga, 192 Apertura R scripts en, 117
Seleccionar, 193 Reconociendo errores recursión infinita, 213
Actualización, 195 Mostrar la opción de rastreo. 213
Utilizando, 24 Panel de rastreo. 215
R scripts, 20, 117 Actualización, 195
R.biblioteca de MATLAB, 209 Regla de probabilidad, 158
Muestras Aleatorias, 15 Los entornos de ejecución, 100
Raw vectores atómico, 38, 42 R_EmptyEnv, 96
RData archivos R_GlobalEnv, 96
Apertura, 205
Ahorro, 205
Vs. Archivos RDS, 205 S
Archivos RDS Sistema de clase S3
Apertura, 205 Alternativas 152
Ahorro, 205 Atributos 140-145
Vs. RData archivos, 205 Clases, 151
Read.csv, 201 La depuración, 152
Leer.csv2, 201 Ejemplo de, 139
Leer.delim, 201 Las funciones genéricas, 145
Leer.delim2, 201 Métodos 146:150
Leer.dta, función 210 Orígenes del, 148
Leer.fwf, 202 Descripción de, 153
Leer.MTP, función 210 La función de ejemplo, 12, 14, 29, 115
Leer.shapefile, función 209 SAS (permanente), formato de
Read.SPSS, función 210 conjunto de datos 210 SAS
Leer.ssd, función 210 (XPORT format), 210 función de
Leer.systat, función 210 guardar, 205
Read.table, 199, 201, 207 Función saveRDS 205
Leer.xport, función 210 SaveWorkbook, 209
Función readMat 209 Scatterplots, 25
Función readRDS 205 Reglas de alcance, 98
ReadWorksheet, 207 Scripts, 20, 117
La recuperación de la función, 220 Sep argumento, 199
228 | Índice
WWW .IT-EBOOKS.INFO
Pasos secuenciales subtarea, 118 T (TRUE), 42, 69, 80, 121
Setwd() 198 Función de cola 60
Formatos de archivo de biblioteca, 209 Las tareas de repetición (véase bucles)
Argumento sheet, 207 Texto, guardar como vectores de
Show_env, función 100 caracteres, 41
Vaya argumento, 200
Slot machine project
Cálculo de la tasa de pagos, 155
Calcular el valor del premio, 159
Calculando premios, 117, 119
La creación de la función de
reproducción, 117, 118
Mostrar premios, 139
Generar/selección de símbolos, 115
Manitoba Video Lotería, plan de pagos 116
Guardar el programa, 117
La subtarea esqueleto, 124
Prueba de símbolo
subtarea, 125 archivos de código
fuente del edificio
R, 188 caracteres especiales en
los nombres, la 8 velocidad
(véase código vectorizadas)
hojas de cálculo (ver hojas de
cálculo de Excel), formato
SPSS 210
Sitio web de
desbordamiento de
pila, 33 startCol
argumento 208 StartRo
w
argumento, 208 Stata,
el formato,
la 210 función str, 56
Argumento
stringAsFactors 56, 201 caden
as
Montaje, 41
Vs. números, 41
Vs. R objetos, 41
(Véase también cadenas de
caracteres)
Subtareas
Asuntos paralelos, 119
Pasos secuenciales, 118
Representación de esqueleto, 124
Estrategia para la
codificación, 126, 138
Función Suma,
los 15 símbolos, los
nombres, 8 sys.time() 48,
172 Formato de
Systat, 210 system.Funci
ón de hora, 172
T
Función de seguimiento 219 Operadores booleanos para
subconjuntos, 85
Herramienta de rastreo. 211
Capturar todas las combinaciones posibles
Los árboles
de, 157
Conversión de tablas de Cambiando de lugar, 77
búsqueda, 135 else Creación de nuevas 78
if, 129 else, árboles 123
Los valores esperados, 155
Ineficiencia de, 133
Pruebas lógicas para el subconjunto, 80
Frente a tablas de búsqueda, 134
Gestionar faltantes, 89
TRUE (T), 42, 69, 80, 121
Sustitución, 78
Typeof(), 39
Selección de tramas de
datos/listas, 73 selección de R
U objetos, 65 seleccionar varios 66
Unclass, 50 Código vectorizadas
Función única 127 Beneficios 184
Huso horario universal coordinado Ejemplo de, 171
(UTC), 49 Unix Los bucles for y, 178
Utilizando R, 189 Utilizando, 179
Directorio de Vs. bucles, 183
trabajo, 198 update.packages Escrito 173-178
comando, 195 función Vectores
UseMethod, 146, 148 Los operadores booleanos y, 86
La coacción en, 51
Element-sabio, y ejecución 10
V En los histogramas, 26
Valores En Scatter plot creación, 25
Valor promedio, 156
Índice |
229
WWW .IT-EBOOKS.INFO
Varios tipos de Listado de los archivos del
datos, 51 volviendo con directorio de
el operador :, 7 vector de trabajo, 198 buscar/ca
reciclaje, 10 mbiar, 61 198 mover, 1
98
Escriba.csv, 61, 203
W Escriba.csv2, 203
Proyecto dados ponderada Write.table, 203
dados virtual de WriteWorksheet, 208
acceso, 9 añadiendo los WriteWorksheetToFile, 209
dados, la 15 polarización
de los
rollos, 28 comprobación X
de la precisión de los Paquete XLConnect 207,
dados, 27 creando el 209 operador Xor, 85
R, 8 creando objetos Compresión xz 204
dados, virtual 7 Función xzfile 204
Frecuencia de feria combinaciones
de dados, 27 volver a tirar los
dados, 16
Z
Tirar los Indización, cero 69
dados, 12 simulando los
pares de
dados, 14 simulando
reiterados rollos, 28
Los bucles while, 168
Windows R GUI, 189
230 | Índice
WWW .IT-EBOOKS.INFO
Acerca del Autor
Garrett Grolemund es un estadístico, profesor, y R el desarrollador que trabaja para
RStudio. Él ve los datos como una ciencia en gran medida sin explotar la fuente de
valor tanto para la industria y aca- demia. Garrett recibió su doctorado en la
Universidad de Rice en Hadley Wickham's Lab, donde su investigación los orígenes
de datos de la ciencia como un proceso cognitivo e identificados como preocupaciones
epistemológicas y atencionales guía cada análisis de datos.
Garrett es un apasionado de ayudar a la gente a evitar la frustración e innecesario aprender- ing

atravesó mientras la ciencia datos de mastering. Incluso antes de que él terminó su disser- tation,
comenzó los entrenamientos de empresas líderes en investigación y análisis de datos para la
revolución- alytics. Ha enseñado en Google, eBay, Roche, y muchas otras compañías, y está
desarrollando un programa de capacitación para que hará RStudio know-how útil aún más
accesible.
Fuera de la enseñanza, Garrett dedica tiempo a hacer ensayos clínicos, la

investigación jurídica, la investigación y el análisis financiero. También desarrolla
software R, es coautor de la lubridate paquete R-que proporciona métodos para
analizar, manipular y hacer operaciones aritméticas con fecha-veces-y escribió el
paquete ggsubplot, que extiende el paquete ggplot2.
Colofón
El animal en la portada de prácticas de programación con R es un color naranja-Am
alado- azón loroAmazona amazonica (). Loros guaros, como las aves son conocidas
localmente, residen a lo largo de todo el año en los trópicos húmedos en la Cordillera
Oriental de los Andes en América del Sur, desde Colombia y Venezuela en el norte
hasta el centro de Brasil en el sur.
Naranja-winged Amazonas son tanto voluble y sociables. Sólo tranquila cuando se

alimentan, estas aves roost comunalmente en árboles con tantos como un millar de
contrapartes. Los machos de las especies, que regurgitar comida para una pareja
femenina mientras ella incuba los huevos y regurgita comida en turno para alimentar
a las crías, mantener barrios cerca del nido durante el día, pero volver a la manada en
la noche. A menudo son vistos en vuelos de mañana y tarde desde el árbol-top perchas
para sitios de alimentación o nidos en cavidades de árboles.
Las alas naranja variedad muestra el plumaje verde generalmente típica de otros
Am- azón loros, desde los cuales se distingue por su color naranja plumas espéculo.
El fore: jefe de la naranja-winged Amazonas es, al igual que la de la Amazonia de
fachada azul, cubierto de plumas azules que dan forma a amarillo en la corona y
mejillas. El color de la bocina en la base de la naranja-winged Amazon's beak se
convierte en un gris oscuro en la punta. Machos y hembras presentan diferencias en
la apariencia no estable.
Muchos de los animales en O'Reilly cubiertas están en peligro de extinción; todos

ellos son importantes para el mundo. Para aprender más sobre cómo puede
ayudar, vaya a animals.oreilly.com.
La imagen de cubierta es de Meyers Kleines Léxico. La tapa fuentes son URW
Typewriter y Guardian Sans. La fuente del texto es Adobe Minion Pro; la fuente de
encabezado es Adobe Myriad condensada; y el código fuente es Dalton Maag's
Ubuntu Mono.
WWW .IT-EBOOKS.INFO

Hands On Programming With R Write Your Own Function ES

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Hands On Programming With R Write Your Own Function ES

Încărcat de

Drepturi de autor:

Formate disponibile

Clases

■ Aprenda a escribir rapidísimo vectorizadas código R

Garrett Grolemund es un estadístico, profesor, y R el desarrollador que trabaja

Los programas de estadística y análisis de datos

Julio de 2014: Primera edición

Historial de revisión de la Primera edición:

Consulte http://oreilly.com/catalog/errata.csp?isbn=9781449359010 para ver detalles de

Parte I. Project 1: Weighted Dice

1. The Very Basics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2. Packages and Help Pages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Parte III. Project 3: Slot Machine

10. Speed. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

A. Installing R and RStudio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

C. Updating R and Its Packages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195

D. Loading and Saving Data in R. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

E. Debugging R Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

Aprender a programar es importante si usted es serio acerca de la comprensión de los

No tenga miedo de la programación! Cualquiera puede aprender a programar con

Este libro le enseñará cómo programar en R. te vaya desde la carga de datos

Cada programador no necesita ser un científico de datos, por lo que no todos

1. Usted ya usa R como una herramienta estadística, pero le gustaría

Este es un método de aprendizaje comprensible R. Visualización y modelización

Esta flexibilidad asuntos a los datos científicos. Los detalles exactos de un

En cambio, yo le enseñe cómo programar en R con tres ejemplos concretos. Estos

El libro es un complemento a los datos de la ciencia con la R. En este libro, que

Convenciones usadas en este libro

Este elemento indica una nota general.

Este elemento indica una advertencia o precaución.

Safari® Libros Online

Los profesionales de tecnología, desarrolladores de software, diseñadores web y

Cómo ponerse en contacto con

O'Reilly Media, Inc.

Nuevas ideas surgieron de los alumnos y profesores de Introducción a la

Por último, me gustaría agradecer a mi esposa, Kristin, por su apoyo y

• Memorizar (store) conjuntos completos de datos

Su primera misión es simple: montar R código evolutivo que simulará un par

• Utilice el R e interfaces RStudio

Usted necesitará tener R y RStudio instalados en su equipo antes de poder utilizarlos.

Este capítulo proporciona un panorama amplio de la R el lenguaje de

Si todavía no tienes R y RStudio intalled en su equipo- o no

La interfaz RStudio es simple. Escribe el código R en la línea inferior de la

¿Cuándo nos compilar?

Si escribe un comando incompleto R y presione Enter, aparecerá un símbolo

Si escribe un comando que no reconoce, R R devolverá un mensaje de error. Si alguna

R trata el hashtag #, personaje, de una manera especial; R no se ejecutará cualquier

1. Elija cualquier número y añadir 2.

Cuando se crea un objeto, el objeto aparecerá en el panel entorno de RStudio,

Puede asignar un nombre a un objeto en R casi cualquier cosa que quieras,

8 | Capítulo 1: Conceptos básicos

R también entiende la capitalización (o es sensible a las mayúsculas

Por último, R anterior sobrescribirá cualquier información almacenada en un objeto sin

Mi_number <- 999

Figura 1-3. Cuando R realiza element-sabio, coincide con la ejecución de

Si usted da r dos vectores de longitudes desiguales, R se repita el vector más

Figura 1-4. R se repita un vector a corto elemento do-wise operaciones con

Element-wise operaciones son una característica muy útil en R porque manipular

Pero no creo que R ha dado sobre la multiplicación de matriz tradicional. Sólo

Die %s% muere

No se preocupe si no está familiarizado con estas operaciones. Son fáciles de

Para rodar su morir y obtener un número posterior, configurar x para morir y

Muestra(x = morir, tamaño = 1)

Muestra(x = morir, tamaño = 1)

Muchos R funciones toman varios argumentos que les ayuden a hacer su