Python数据可视化入门指南

4星 · 超过85%的资源需积分: 10 103 浏览量更新于2024-07-22 1 收藏 6.8MB PDF 举报

"beginning python visualization" 本书《beginning python visualization》是一本专为Python初学者设计的数据可视化指南，采用英文撰写，旨在提升读者在数据可视化领域的技能和理解。书中涵盖了从基础到进阶的各种主题，适合希望提升Python编程能力并应用在数据可视化领域的读者。作者在序言中分享了他对数学和计算机的热爱，以及如何在大学时期对数值分析产生兴趣，数值分析是将数学与计算机完美结合的领域。他还提到了MATLAB，这是一个广泛用于数字信号处理和数值分析的工具，但在本书中，他选择了Python作为数据可视化的平台，因为Python具有强大的库和社区支持，使其成为数据科学和可视化领域的新宠。书中内容结构清晰，包括： 1. 第1章：导航数据可视化世界，引导读者了解数据可视化的基础概念和重要性。 2. 第2章：环境设置，介绍如何配置Python环境，包括安装必要的数据可视化库，如matplotlib和seaborn。 3. 第3章：Python程序员入门，教授Python编程基础，以适应后续的可视化任务。 4. 第4章：数据组织，讨论如何有效地管理和结构化数据，以便进行可视化处理。 5. 第5章：处理文本文件，讲解读取、解析和操作文本数据的方法。 6. 第6章：图形和图表，深入学习如何创建各种类型的图表，如折线图、散点图、直方图等。 7. 第7章：数学游戏，通过有趣的例子来应用数学原理进行可视化，增强学习趣味性。 8. 第8章：科学与可视化，探讨在科学应用中的数据可视化，如物理、生物、地理等领域的案例。 9. 第9章：图像处理，介绍如何处理和分析图像，如像素操作、滤波器等。 10. 第10章：高级文件处理，涉及更复杂的数据输入/输出技巧，如CSV和JSON文件的处理。 11. 附录：额外源代码列表，提供书中示例代码的详细清单，方便读者实践。此外，书后还附有索引，便于查找特定主题。通过阅读此书，读者可以逐步掌握Python编程和数据可视化的核心技术，从而能够创建出专业且有洞察力的数据可视化作品。

CHAPTER 1 ■ NAVIGATING THE WORLD OF DATA VISUALIZATION

len(x) tells us the size of the array of lists. It’s also a crude way for us to ensure that data was actually read into

the array.

The second line in the function is called a docstring, and it is characterized by three quotes (""") surrounding the

text in the following manner: """dosctring""". In this case, a docstring is used to document the function; that is, it

enables us to explain what it does. Issuing the command help(funcname) yields its docstring:

>>> help(read_csv_file)

Help on function read_csv_file in module __main__:

read_csv_file(filename)

Reads a CSV file and return it as a list of rows.

You should use help() whenever you need a reminder of what a function does. help() can be invoked with

functions as well as modules. For example, the following invokes help on module csv:

>>> help(csv)

Help on module csv:

NAME

csv - CSV parsing and writing.

DESCRIPTION

This module provides classes that assist in the reading and writing

of Comma Separated Value (CSV) files, and implements the interface

described by PEP 305. Although many CSV files are simple to parse,

the format is not formally defined by a stable specification and

is subtle enough that parsing lines of a CSV file with something

like line.split(",") is bound to fail. The module supports three

basic APIs: reading, writing, and registration of dialects.

The line data = [] declares a variable named data and initializes it as an empty list. We will use data to store the

values from the CSV file.

The csv module helps us read CSV files by automating a lot of the tasks associated with reading them. I will

discuss CSV files and the csv module in more detail in Chapters 4 and 5; this chapter will only provide an overview.

Here are the steps for reading CSV files with the csv module:

1. Open the file for reading.

2. Create a csv.reader object. The csv.reader object has functions that help us read CSV files.

a. Using the csv.reader object, read the data from the file, a row at a time.

b. Append every row to the variable data.

3. Close the file.

CHAPTER 1 ■ NAVIGATING THE WORLD OF DATA VISUALIZATION

Let’s try this, a step at a time:

>>> import csv

>>> f = open('../data/GPS-2008-06-04-09-03-45.csv')

>>> cr = csv.reader(f)

>>> for row in cr:

... print(row)

['$GPGSA', 'A', '3', '21', '18', '15', '24', '', '22', '', '', '', '', '', '',

'03.5', '02.2', '02.7*09']

['$GPGSV', '3', '1', '12', '21', '86', '267', '39', '18', '66', '286', '44',

'15', '51', '060', '43', '24', '45', '125', '30*7A']

['$GPGSV', '3', '2', '12', '06', '28', '300', '33', '22', '27', '265', '31',

'03', '18', '312', '27', '29', '15', '185', '31*7C']

['$GPGSV', '3', '3', '12', '09', '15', '138', '31', '16', '00', '301', '',

'19', '00', '332', '', '00', '00', '000', '*70']

['$GPRMC', '140706.24', 'A', '4455.6241', 'N', '09328.0519', 'W', '011.4',

'152.7', '040608', '001.2', 'E', 'A*25']

['$GPGGA', '140706.24', '4455.6241', 'N', '09328.0519', 'W', '1', '04', '03.0',

'00295.1', 'M', '-030.7', 'M', '', '*51']

['$GPGSA', 'A', '3', '21', '18', '15', '24', '', '', '', '', '', '', '', '',

'08.9', '03.0', '08.4*04']

>>> f.close()

First, we open the data file and assign it to variable f. The opened file can now be referred to by the variable

f. Next, we create a csv.reader object, cr. We associate the csv.reader object, cr, with the file f. We then iterate

through every row of the csv.reader object and print that row. Lastly, we close the file by calling f.close(). It is

considered good practice to close the file once you’re done with it; but if you neglect to do so, Python will close the file

automatically once the variable f is no longer in use.

Note ■ You may, after issuing the commands, receive an error similar to this: UnicodeEncodeError: 'charmap'

codec can't encode character '\uABCD'

. If this happens, open the GPS file in a text editor and make sure the file

contains proper alpha-numeric characters. Be sure to delete lines with non-alpha-numeric characters.

Python also lets you implement cascade functions, where you can call new functions based on the results of other

functions. This process can be repeated several times. Cascading (usually) adds clarity and produces more elegant

scripts. In our case, the variable f isn’t really important to us, so we discard it after we attach it to a csv.reader object.

Instead of the preceding code, we can write the following, by cascading the functions:

>>> cr = csv.reader(open('../data/GPS-2008-06-04-09-03-45.csv')):

>>> for row in cr:

... print(row)

CHAPTER 1 ■ NAVIGATING THE WORLD OF DATA VISUALIZATION

The same holds true for variable cr, for which we can cascade several functions and generate a more compact

line of code:

>>> for row in csv.reader(open('../data/GPS-2008-06-04-09-03-45.csv')):

... print(row)

While the script might be shorter, there’s no performance gain. It is therefore suggested that you cascade

functions only if it adds clarity; there’s a good chance you’ll be editing this code later on, and it’s important to be able

to understand what’s going on. In fact, not cascading functions might be useful at times because you might need

access to intermediate variables (such as f and cr in our case).

The csv.reader object converts each row we read into a row of fields, in the form of a list. That row is then

appended to a list of rows and stored in the variable data.

Note ■ By now, you’ve seen the dot symbol (.) used several times. Its use might be a bit confusing, so an explanation

is in order. The dot symbol is used to access function members of modules, as well as function members of objects

(classes). You’ve seen it in member functions of modules, such as csv.reader(), but also for objects, such as f.read().

In the latter, it means that the file object has a member function read() and that the function is called to operate on

variable f. To access these functions, we use the dot operator. We’ll touch on this again in Chapter 3. Lastly, we use the

ellipsis symbol (...) to denote line continuation when interactively entering commands in Python.

Analyzing GPS Data

Also known as NMEA 0183, the GPS format contains many header stamps, some of which hold useful information for

our task. Let’s take a closer look at the GPS data:

Each row seems to start with a text header stamp, beginning with the characters • $GP.

There are several header stamps (e.g., • $GPGSA and $GPRMC).

Additional values follow the header, most of which are numeric.•

Note ■ NMEA stands for the National Marine Electronics Association; see http://www.nmea.org for more information.

The NMEA 0183 data format is described at http://www.gpsinformation.org/dale/nmea.htm.

As mentioned earlier, several $GP header stamps appear in our data files, but we need to determine which ones

exactly are relevant to us. First, it would be nice to know which header stamps from the NMEA standard are even

present in our data files. One option would be to open the files, look for the headers, and jot down every new header

once we see it. Another, of course, would be to use Python to do that for us.

Python is a very high-level programming language. As such, it has built-in support for dictionaries (also known

as associative arrays in Perl), which are data structures that have a one-to-one relationship between a key and a value,

very much like real dictionaries. Traditional dictionaries, however, often have several values for a key; that is, they

have several interpretations (values) for one word (key). You can easily implement this in Python using the dictionary

object, dict, as well by assigning a list value to a key. That way, you can have several entries per one key, because the

key is associated with a list that can hold several values. In reality, it’s still a one-to-one relationship, but enough about

that for now. I’ll cover dictionaries in more detail in future chapters. What we want to do here is use a dictionary object

to hold the number of times a header is encountered. Our key will be the GPS header stamp, and our value will be a

number that indicates occurrence. We’ll increment the value whenever a key is encountered, as shown in Listing 1-5.

CHAPTER 1 ■ NAVIGATING THE WORLD OF DATA VISUALIZATION

Listing 1-5. Function list_gps_commands( )

def list_gps_commands(data):

"""Counts the number of times a GPS command is observed.

Returns a dictionary object."""

gps_cmds = dict()

for row in data:

try:

gps_cmds[row[0]] += 1

except KeyError:

gps_cmds[row[0]] = 1

return gps_cmds

There are few things to keep in mind about this function. First, the docstring spans multiple lines, which is one

of the key benefits of docstrings. Docstrings will display all the spaces and line breaks as shown in the function itself.

Second, we initialize a variable, gps_cmds, to be our dictionary. We then process every list in the GPS data: we only

care about the first element of every row, as that’s the value that holds the GPS header stamps. We then increment the

value associated with the key: gps_cmds[row[0]] += 1. We use the += operation to increment the value by 1, similar

to how it’s done in C (Python, however, does not use the ++ operator). If the key does not exist, which will happen

whenever we encounter a new header stamp, an exception will be raised. We catch the exception with our except

KeyError statement. In the case of an exception, we set the dictionary value associated with the key to 1.

We can write the function list_gps_commands() even more compactly using the dictionary method get();

see Chapter 3 for details.

Let’s analyze some GPS data:

>>> x = read_csv_file('../data/GPS-2008-05-30-09-00-50.csv')

>>> list_gps_commands(x)

{'$GPGSA': 282, '$GPGSV': 846, '$GPGGA': 282, '$GPRMC': 283}

It turns out there are four distinct GPS headers being generated by my GPS. Of those, only two interest us: $GPGSV,

which holds the number of satellites in view (Hey! It’s really important!); and $GPRMC, which holds location and

velocity information.

What we’d like to do is code a function that takes the GPS data and, whenever the header field is $GPGSV or

$GPRMC, extracts the information and stores it in numerical arrays that will be easier to manipulate later on. Numerical

arrays are introduced with the NumPy module, so we have to import numpy. Since we’ll be using a lot of the

functionality of NumPy, SciPy, and matplotlib, an easier approach would be to import pylab, which imports all these

modules, as follows:

>>> from pylab import *

Note ■ The name PyLab comes from Python and MATLAB. The PyLab module provides MATLAB-like functionality

in Python.

CHAPTER 1 ■ NAVIGATING THE WORLD OF DATA VISUALIZATION

Extracting GPS Data

In the case of a $GPGSV header, the number of satellites is the fourth entry. In the case of a $GPRMC header, we have a

bit more interesting information. The second field is the timestamp, the fourth field is the latitude, the sixth field is

the longitude, and the eighth field is the velocity. Again, refer to the NMEA 0183 format for more details. Table 1-1

summarizes the fields and their values in a $GPRMC line.

Table 1-1. $GPRMC Information (Excerpt)

Field Name Index Format

Header 0 $GPRMC (fixed)

Timestamp 1 hhmmss.ss

Latitude 3 DDMM.MMM

Longitude 5 DDDMM.MMM

Velocity 7 VVV.V

We need to keep in mind some caveats regarding the information in $GPRMC. For example, let’s look at the

timestamp of an arbitrary line:

>>> x[12]

['$GPRMC', '140055.00', 'A', '4454.1740', 'N', '09325.0143', 'W', '000.0',

'128.7', '300508', '001.1', 'E', 'A*28']

In this output, the timestamp appears as '140055.00'. This follows the format hhmmss.ss where hh are two digits

representing the hour (it will always consist of two digits—if the hour is one digit, say 7 in the morning, a 0 will be

added before it), mm are two digits representing the minute (again, always two digits), and ss.ss are five characters

(four digits plus the dot) representing seconds and fractions of seconds. There’s also a North/South field, as well as

an East/West field. Here, for simplicity, we assume northern hemisphere, but you can easily change these values by

reading the entire $GPRMC structure.

Note ■ In the ISO time format, we’ve used HHMMSS to denote hours minutes and seconds. In this case, we follow

the convention in NMEA, which uses hhmmss.ss for hours, minutes, and seconds, and then sets DD and MM to angular

degrees and minutes.

The timestamp string is a bit hard to work with, especially when plotting data. The first reason is that it’s a string,

not a number. But even if you translate it to a number, the system does not lend itself nicely to plotting because there

are 60 seconds in a minute, not 100. So what we want to do is “linearize” the timestamp. To achieve this, we translate

the timestamp as seconds elapsed since midnight, as follows: T = hh * 3600 + mm * 60 + ss.ss.

剩余404页未读，继续阅读

ejiageng

粉丝: 0
资源: 8

Python数据可视化入门指南

Beginning Python Visualization(2nd) 无水印pdf

英文原版-Beginning Python Visualization 1st Edition

Beginning Python Visualization1st.zip

Beginning Python Visualization (2015)

Apress - Beginning Python Visualization 2nd Edition - 2014

Beginning Python Visualization - Crafting Visual Transformation Scripts.pdf

Beginning_Python_Visualization__Crafting_Visual_Transformation_Scripts.pdf

Beginning-Python-Visualization-Crafting-Visual-Transformation-Scripts.pdf.pdf

Python经典学习资料

3d Linear Transformation Visualization:可视化3d线性变换。-开源

最新资源