利用Python进行数据分析(第二版)_部分2（精选文档）

下面是小编为大家整理的利用Python进行数据分析(第二版)_部分2（精选文档）,供大家参考。

　sequence

　=

　[1,

　2,

　0,

　4,

　6,

　5,

　2,

　1]total_until_5

　=

　0for

　value

　in

　sequence:

　if

　value

　==

　5:

　break

　total_until_5

　+=

　valuebreak只中断for循环的最内层，其余的for循环仍会运⾏：In

　[121]:

　for

　i

　in

　range(4):

　.....:

　for

　j

　in

　range(4):

　.....:

　if

　j

　>

　i:

　.....:

　break

　.....:

　print((i,

　j))

　.....:(0,

　0)(1,

　0)(1,

　1)(2,

　0)(2,

　1)(2,

　2)(3,

　0)(3,

　1)(3,

　2)(3,

　3)如果集合或迭代器中的元素序列（元组或列表），可以⽤for循环将其⽅便地拆分成变量：for

　a,

　b,

　c

　in

　iterator:

　#

　do

　somethingWhile循环while循环指定了条件和代码，当条件为False或⽤break退出循环，代码才会退出：64

　x

　=

　256total

　=

　0while

　x

　>

　0:

　if

　total

　>

　500:

　break

　total

　+=

　x

　x

　=

　x

　//

　2passpass是Python中的⾮操作语句。代码块不需要任何动作时可以使⽤（作为未执⾏代码的占位符）；因为Python需要使⽤空⽩字符划定代码块，所以需要pass：if

　x

　<

　0:

　print("negative!")elif

　x

　==

　0:

　#

　TODO:

　put

　something

　smart

　here

　passelse:

　print("positive!")rangerange函数返回⼀个迭代器，它产⽣⼀个均匀分布的整数序列：In

　[122]:

　range(10)Out[122]:

　range(0,

　10)In

　[123]:

　list(range(10))Out[123]:

　[0,

　1,

　2,

　3,

　4,

　5,

　6,

　7,

　8,

　9]range的三个参数是（起点，终点，步进）：In

　[124]:

　list(range(0,

　20,

　2))Out[124]:

　[0,

　2,

　4,

　6,

　8,

　10,

　12,

　14,

　16,

　18]65

　In

　[125]:

　list(range(5,

　0,

　-1))Out[125]:

　[5,

　4,

　3,

　2,

　1]可以看到，range产⽣的整数不包括终点。range的常⻅⽤法是⽤序号迭代序列：seq

　=

　[1,

　2,

　3,

　4]for

　i

　in

　range(len(seq)):

　val

　=

　seq[i]可以使⽤list来存储range在其他数据结构中⽣成的所有整数，默认的迭代器形式通常是你想要的。下⾯的代码对0到99999中3或5的倍数求和：sum

　=

　0for

　i

　in

　range(100000):

　#

　%

　is

　the

　modulo

　operator

　if

　i

　%

　3

　==

　0

　or

　i

　%

　5

　==

　0:

　sum

　+=

　i虽然range可以产⽣任意⼤的数，但任意时刻耗⽤的内存却很⼩。三元表达式Python中的三元表达式可以将if-else语句放到⼀⾏⾥。语法如下：value

　=

　true-expr

　if

　condition

　else

　false-exprtrue-expr 或 false-expr 可以是任何Python代码。它和下⾯的代码效果相同：if

　condition:

　value

　=

　true-exprelse:

　value

　=

　false-expr66

　下⾯是⼀个更具体的例⼦：In

　[126]:

　x

　=

　5In

　[127]:

　"Non-negative"

　if

　x

　>=

　0

　else

　"Negative"Out[127]:

　"Non-negative"和if-else⼀样，只有⼀个表达式会被执⾏。因此，三元表达式中的if和else可以包含⼤量的计算，但只有True的分⽀会被执⾏。虽然使⽤三元表达式可以压缩代码，但会降低代码可读性。67

　第3章 Python的数据结构、函数和⽂件本章讨论Python的内置功能，这些功能本书会⽤到很多。虽然扩展库，⽐如pandas和Numpy，使处理⼤数据集很⽅便，但它们是和Python的内置数据处理⼯具⼀同使⽤的。我们会从Python最基础的数据结构开始：元组、列表、字典和集合。然后会讨论创建你⾃⼰的、可重复使⽤的Python函数。最后，会学习Python的⽂件对象，以及如何与本地硬盘交互。3.1 数据结构和序列Python的数据结构简单⽽强⼤。通晓它们才能成为熟练的Python程序员。元组元组是⼀个固定⻓度，不可改变的Python序列对象。创建元组的最简单⽅式，是⽤逗号分隔⼀列值：In

　[1]:

　tup

　=

　4,

　5,

　6In

　[2]:

　tupOut[2]:

　(4,

　5,

　6)当⽤复杂的表达式定义元组，最好将值放到圆括号内，如下所示：In

　[3]:

　nested_tup

　=

　(4,

　5,

　6),

　(7,

　8)In

　[4]:

　nested_tupOut[4]:

　((4,

　5,

　6),

　(7,

　8))⽤ tuple 可以将任意序列或迭代器转换成元组：In

　[5]:

　tuple([4,

　0,

　2])Out[5]:

　(4,

　0,

　2)68

　In

　[6]:

　tup

　=

　tuple("string")In

　[7]:

　tupOut[7]:

　("s",

　"t",

　"r",

　"i",

　"n",

　"g")可以⽤⽅括号访问元组中的元素。和C、C++、JAVA等语⾔⼀样，序列是从0开始的：In

　[8]:

　tup[0]Out[8]:

　"s"元组中存储的对象可能是可变对象。⼀旦创建了元组，元组中的对象就不能修改了：In

　[9]:

　tup

　=

　tuple(["foo",

　[1,

　2],

　True])In

　[10]:

　tup[2]

　=

　False---------------------------------------------------------------------------TypeError

　Traceback

　(most

　recent

　call

　last)<ipython-input-10-c7308343b841>

　in

　<module>()---->

　1

　tup[2]

　=

　FalseTypeError:

　"tuple"

　object

　does

　not

　support

　item

　assignment如果元组中的某个对象是可变的，⽐如列表，可以在原位进⾏修改：In

　[11]:

　tup[1].append(3)In

　[12]:

　tupOut[12]:

　("foo",

　[1,

　2,

　3],

　True)可以⽤加号运算符将元组串联起来：In

　[13]:

　(4,

　None,

　"foo")

　+

　(6,

　0)

　+

　("bar",)Out[13]:

　(4,

　None,

　"foo",

　6,

　0,

　"bar")69

　元组乘以⼀个整数，像列表⼀样，会将⼏个元组的复制串联起来：In

　[14]:

　("foo",

　"bar")

　*

　4Out[14]:

　("foo",

　"bar",

　"foo",

　"bar",

　"foo",

　"bar",

　"foo",

　"bar")对象本身并没有被复制，只是引⽤了它。拆分元组如果你想将元组赋值给类似元组的变量，Python会试图拆分等号右边的值：In

　[15]:

　tup

　=

　(4,

　5,

　6)In

　[16]:

　a,

　b,

　c

　=

　tupIn

　[17]:

　bOut[17]:

　5即使含有元组的元组也会被拆分：In

　[18]:

　tup

　=

　4,

　5,

　(6,

　7)In

　[19]:

　a,

　b,

　(c,

　d)

　=

　tupIn

　[20]:

　dOut[20]:

　7使⽤这个功能，你可以很容易地替换变量的名字，其它语⾔可能是这样：tmp

　=

　aa

　=

　bb

　=

　tmp70

　但是在Python中，替换可以这样做：In

　[21]:

　a,

　b

　=

　1,

　2In

　[22]:

　aOut[22]:

　1In

　[23]:

　bOut[23]:

　2In

　[24]:

　b,

　a

　=

　a,

　bIn

　[25]:

　aOut[25]:

　2In

　[26]:

　bOut[26]:

　1变量拆分常⽤来迭代元组或列表序列：In

　[27]:

　seq

　=

　[(1,

　2,

　3),

　(4,

　5,

　6),

　(7,

　8,

　9)]In

　[28]:

　for

　a,

　b,

　c

　in

　seq:

　....:

　print("a={0},

　b={1},

　c={2}".format(a,

　b,

　c))a=1,

　b=2,

　c=3a=4,

　b=5,

　c=6a=7,

　b=8,

　c=9另⼀个常⻅⽤法是从函数返回多个值。后⾯会详解。Python最近新增了更多⾼级的元组拆分功能，允许从元组的开头“摘取”⼏个元素。它使⽤了特殊的语法 *rest ，这也⽤在函数签名中以抓取任意⻓度列表的位置参数：In

　[29]:

　values

　=

　1,

　2,

　3,

　4,

　571

　In

　[30]:

　a,

　b,

　*rest

　=

　valuesIn

　[31]:

　a,

　bOut[31]:

　(1,

　2)In

　[32]:

　restOut[32]:

　[3,

　4,

　5]rest 的部分是想要舍弃的部分，rest的名字不重要。作为惯⽤写法，许多Python程序员会将不需要的变量使⽤下划线：In

　[33]:

　a,

　b,

　*_

　=

　valuestuple⽅法因为元组的⼤⼩和内容不能修改，它的实例⽅法都很轻量。其中⼀个很有⽤的就是 count （也适⽤于列表），它可以统计某个值得出现频率：In

　[34]:

　a

　=

　(1,

　2,

　2,

　2,

　3,

　4,

　2)In

　[35]:

　a.count(2)Out[35]:

　4列表与元组对⽐，列表的⻓度可变、内容可以被修改。你可以⽤⽅括号定义，或⽤ list 函数：In

　[36]:

　a_list

　=

　[2,

　3,

　7,

　None]In

　[37]:

　tup

　=

　("foo",

　"bar",

　"baz")In

　[38]:

　b_list

　=

　list(tup)In

　[39]:

　b_listOut[39]:

　["foo",

　"bar",

　"baz"]72

　In

　[40]:

　b_list[1]

　=

　"peekaboo"In

　[41]:

　b_listOut[41]:

　["foo",

　"peekaboo",

　"baz"]列表和元组的语义接近，在许多函数中可以交叉使⽤。list 函数常⽤来在数据处理中实体化迭代器或⽣成器：In

　[42]:

　gen

　=

　range(10)In

　[43]:

　genOut[43]:

　range(0,

　10)In

　[44]:

　list(gen)Out[44]:

　[0,

　1,

　2,

　3,

　4,

　5,

　6,

　7,

　8,

　9]添加和删除元素可以⽤ append 在列表末尾添加元素：In

　[45]:

　b_list.append("dwarf")In

　[46]:

　b_listOut[46]:

　["foo",

　"peekaboo",

　"baz",

　"dwarf"]insert 可以在特定的位置插⼊元素：In

　[47]:

　b_list.insert(1,

　"red")In

　[48]:

　b_listOut[48]:

　["foo",

　"red",

　"peekaboo",

　"baz",

　"dwarf"]插⼊的序号必须在0和列表⻓度之间。警告：与 append 相⽐， insert 耗费的计算量⼤，因为对后续元素的引⽤必须在内部迁移，以便为新元素提供空间。如果73

　要在序列的头部和尾部插⼊元素，你可能需要使⽤ collections.deque ，⼀个双尾部队列。insert的逆运算是pop，它移除并返回指定位置的元素：In

　[49]:

　b_list.pop(2)Out[49]:

　"peekaboo"In

　[50]:

　b_listOut[50]:

　["foo",

　"red",

　"baz",

　"dwarf"]可以⽤ remove 去除某个值， remove 会先寻找第⼀个值并除去：In

　[51]:

　b_list.append("foo")In

　[52]:

　b_listOut[52]:

　["foo",

　"red",

　"baz",

　"dwarf",

　"foo"]In

　[53]:

　b_list.remove("foo")In

　[54]:

　b_listOut[54]:

　["red",

　"baz",

　"dwarf",

　"foo"]如果不考虑性能，使⽤ append 和 remove ，可以把Python的列表当做完美的“多重集”数据结构。⽤ in 可以检查列表是否包含某个值：In

　[55]:

　"dwarf"

　in

　b_listOut[55]:

　True否定 in 可以再加⼀个not：In

　[56]:

　"dwarf"

　not

　in

　b_listOut[56]:

　False在列表中检查是否存在某个值远⽐字典和集合速度慢，因为74

　Python是线性搜索列表中的值，但在字典和集合中，在同样的时间内还可以检查其它项（基于哈希表）。串联和组合列表与元组类似，可以⽤加号将两个列表串联起来：In

　[57]:

　[4,

　None,

　"foo"]

　+

　[7,

　8,

　(2,

　3)]Out[57]:

　[4,

　None,

　"foo",

　7,

　8,

　(2,

　3)]如果已经定义了⼀个列表，⽤ extend ⽅法可以追加多个元素：In

　[58]:

　x

　=

　[4,

　None,

　"foo"]In

　[59]:

　x.extend([7,

　8,

　(2,

　3)])In

　[60]:

　xOut[60]:

　[4,

　None,

　"foo",

　7,

　8,

　(2,

　3)]通过加法将列表串联的计算量较⼤，因为要新建⼀个列表，并且要复制对象。⽤ extend 追加元素，尤其是到⼀个⼤列表中，更为可取。因此：everything

　=

　[]for

　chunk

　in

　list_of_lists:

　everything.extend(chunk)要⽐串联⽅法快：everything

　=

　[]for

　chunk

　in

　list_of_lists:

　everything

　=

　everything

　+

　chunk排序你可以⽤ sort 函数将⼀个列表原地排序（不创建新的对象）：75

　In

　[61]:

　a

　=

　[7,

　2,

　5,

　1,

　3]In

　[62]:

　a.sort()In

　[63]:

　aOut[63]:

　[1,

　2,

　3,

　5,

　7]sort 有⼀些选项，有时会很好⽤。其中之⼀是⼆级排序key，可以⽤这个key进⾏排序。例如，我们可以按⻓度对字符串进⾏排序：In

　[64]:

　b

　=

　["saw",

　"small",

　"He",

　"foxes",

　"six"]In

　[65]:

　b.sort(key=len)In

　[66]:

　bOut[66]:

　["He",

　"saw",

　"six",

　"small",

　"foxes"]稍后，我们会学习 sorted 函数，它可以产⽣⼀个排好序的序列副本。⼆分搜索和维护已排序的列表bisect 模块⽀持⼆分查找，和向已排序的列表插⼊值。

　bisect.bisect 可以找到插⼊值后仍保证排序的位置， bisect.insort 是向这个位置插⼊值：In

　[67]:

　import

　bisectIn

　[68]:

　c

　=

　[1,

　2,

　2,

　2,

　3,

　4,

　7]In

　[69]:

　bisect.bisect(c,

　2)Out[69]:

　4In

　[70]:

　bisect.bisect(c,

　5)Out[70]:

　676

　In

　[71]:

　bisect.insort(c,

　6)In

　[72]:

　cOut[72]:

　[1,

　2,

　2,

　2,

　3,

　4,

　6,

　7]注意：

　bisect 模块不会检查列表是否已排好序，进⾏检查的话会耗费⼤量计算。因此，对未排序的列表使⽤ bisect 不会产⽣错误，但结果不⼀定正确。切⽚⽤切边可以选取⼤多数序列类型的⼀部分，切⽚的基本形式是在⽅括号中使⽤ start:stop ：In

　[73]:

　seq

　=

　[7,

　2,

　3,

　7,

　5,

　6,

　0,

　1]In

　[74]:

　seq[1:5]Out[74]:

　[2,

　3,

　7,

　5]切⽚也可以被序列赋值：In

　[75]:

　seq[3:4]

　=

　[6,

　3]In

　[76]:

　seqOut[76]:

　[7,

　2,

　3,

　6,

　3,

　5,

　6,

　0,

　1]切⽚的起始元素是包括的，不包含结束元素。因此，结果中包含的元素个数是 stop

　-

　start 。start 或 stop 都可以被省略，省略之后，分别默认序列的开头和结尾：In

　[77]:

　seq[:5]Out[77]:

　[7,

　2,

　3,

　6,

　3]In

　[78]:

　seq[3:]Out[78]:

　[6,

　3,

　5,

　6,

　0,

　1]77

　负数表明从后向前切⽚：In

　[79]:

　seq[-4:]Out[79]:

　[5,

　6,

　0,

　1]In

　[80]:

　seq[-6:-2]Out[80]:

　[6,

　3,

　5,

　6]需要⼀段时间来熟悉使⽤切⽚，尤其是当你之前学的是R或MATLAB。图3-1展示了正整数和负整数的切⽚。在图中，指数标示在边缘以表明切⽚是在哪⾥开始哪⾥结束的。图3-1 Python切⽚演示在第⼆个冒号后⾯使⽤ step ，可以隔⼀个取⼀个元素：In

　[81]:

　seq[::2]Out[81]:

　[7,

　3,

　3,

　6,

　1]⼀个聪明的⽅法是使⽤ -1 ，它可以将列表或元组颠倒过来：In

　[82]:

　seq[::-1]Out[82]:

　[1,

　0,

　6,

　5,

　3,

　6,

　3,

　2,

　7]序列函数Python有⼀些有⽤的序列函数。78

　enumerate函数迭代⼀个序列时，你可能想跟踪当前项的序号。⼿动的⽅法可能是下⾯这样：i

　=

　0for

　value

　in

　collection:

　#

　do

　something

　with

　value

　i

　+=

　1因为这么做很常⻅，Python内建了⼀个 enumerate 函数，可以返回 (i,

　value) 元组序列：for

　i,

　value

　in

　enumerate(collection):

　#

　do

　something

　with

　value当你索引数据时，使⽤ enumerate 的⼀个好⽅法是计算序列（唯⼀的）

　dict 映射到位置的值：In

　[83]:

　some_list

　=

　["foo",

　"bar",

　"baz"]In

　[84]:

　mapping

　=

　{}In

　[85]:

　for

　i,

　v

　in

　enumerate(some_list):

　....:

　mapping[v]

　=

　iIn

　[86]:

　mappingOut[86]:

　{"bar":

　1,

　"baz":

　2,

　"foo":

　0}sorted函数sorted 函数可以从任意序列的元素返回⼀个新的排好序的列表：In

　[87]:

　sorted([7,

　1,

　2,

　6,

　0,

　3,

　2])Out[87]:

　[0,

　1,

　2,

　2,

　3,

　6,

　7]In

　[88]:

　sorted("horse

　race")79

　Out[88]:

　["

　",

　"a",

　"c",

　"e",

　"e",

　"h",

　"o",

　"r",

　"r",

　"s"]sorted 函数可以接受和 sort 相同的参数。zip函...