2.4 Python 基础

2.4.1 Python 基本数据结构:序列

所谓数据结构,指数据的组织方式,这里的数据包括数值、字符等。Python 中最基本的数据结构是 sequence,翻译为“序列”,是一组按顺序排列的元素,每一个元素都有一个编号,对应元素在序列中的位置,第一个元素的编号为0,以第一个元素为基准,向后第二个元素编号为1,向前即倒数第一个元素编号为-1,其他元素编号按照位置以此类推,这个编号称为索引。

Python 包含 6 中内建序列,常用的有字符串、列表和元组,本节后续内容将分别介绍这三种数据结构及相应的操作。

2.4.1.1 字符串(string)

(1)什么是字符串 字符串即由数字、字母、标点符号等组成的一串字符,在 Python 程序中最主要的用法就是表示一些文本,主要使用单引号‘’、双引号“”或者三引号“““”””表示字符串。三引号多用于表示非常长需要跨很多行的字符串或者包含多种特殊字符的字符串。

例 8 创建字符串


In [14]:'Text Mining with Python'
Out[14]:'Text Mining with Python'

In [15]:"Text Mining with Python"
Out[15]:'Text Mining with Python'

In [16]:"""Text Mining with Python"""
Out[16]:'Text Mining with Python'

如果需要表示的字符串内包含双引号或者单引号,定义字符串时内外引号不得相同,即内有单引号,外用双引号,内有双引号,外用单引号,否则需要在引号前加“\”进行转义


In [17]:"there's a book"
Out[17]:"there's a book"

In [18]:'there\'s a book'
Out[18]:"there's a book"

函数 str() 可以将其他数据结构转换为字符串


In [19]:str(23)
Out[19]:'23'

(2)字符串拼接

所谓拼接,即将两个独立的字符串连接起来,创建一个新的字符串,直接用加号“+”即可实现。

例 9 拼接字符串


In [20]:"Text"+"Mining"
Out[20]:'TextMining'

In [21]:a="Text"
         b="Mining"
In [22]:a+b
Out[22]:'TextMining'

也可以对空格进行拼接


In [23]:"Text"+" "+"Mining"
Out[23]:'Text Mining'

如果需要重复拼接一个字符串,可以利用乘号“*”实现。


In [24]:5*"Text"
Out[24]:'TextTextTextTextText'

(3)常用字符串方法

方法,直观来讲就是针对于某个对象的函数,对象的类型没有严格限制,比如字符串、列表、字典都有对应的方法。当需要对某个对象进行某种方法操作时,可以通过“对象.方法(参数)”实现,与调用函数类似,只是“对象”被放在“方法”前,并用“.”隔开。

(3.1)join 和 split

join 和 split 互为逆方法,join 可以用来实现字符串的拼接,将多个字符串拼接为一个字符串;相反的,split 可以用来将一个长字符串切分为多个较短的字符串,并保存在一个列表中。下面结合实例来学习这两个方法的调用。

join:“拼接符号”.join(待拼接字符串)

例 10 使用空格“ ”对字符串“a”、“b”、“c”进行拼接,得到字符串“a b c”


In [25]:s1="a","b","c"
         " ".join(s1)
Out[25]:'a b c'

split:待划分字符串.split(划分符号)

例 11 将字符串"a b c"按照空格划分为多个字符串


In [26]:s2="a b c"
         s2.split(" ")
Out[26]:['a', 'b', 'c']

(3.2)strip

strip 方法用于去除字符串首尾两端的空格,调用方式为:字符串.strip()

例 12 去除字符串两端空格


In [27]:"    Text Mining with Python    ".strip()
Out[27]:'Text Mining with Python'

(3.3)find

find 方法用于在较长的字符串中查找其子字符串,调用方式为:长字符串.find(目标子字符串),返回目标子字符串最左端字母的索引。

例 13 查找子字符串“with”


In [28]:"Text Mining with Python".find("with")
Out[28]:12

(3.4)lower

lower 方法用于返回字符串对应的小写字母,调用方式为:字符串.lower()

例 14 返回"TEXT"的小写形式


In [29]:"TEXT".lower()
Out[29]:'text'

(3.5)replace

replace 方法用于查找并替换字符串中部分内容,调用方式为:字符串.replace(查找内容,替换内容)

例 15 将“with”替换为“abcd”


In [30]:"Text Mining with Python".replace("with","abcd")
Out[30]:'Text Mining abcd Python'

2.4.1.2 列表(list)

(1)什么是列表

在实际分析过程中,列表相当于一个存储空间或者存储形式,使用者可以把要分析的数据读入到列表,也可以把分析结果添加到列表,列表用方括号“[]”括起,其中的元素用逗号分隔,元素可以是任何类型的值,如数字、字符串等,也可以是列表。

(2)创建列表

(2.1)直接创建列表

例 16 创建一个空列表


In [30]:list1=[]
In [31]:list1
Out[31]:[]

例 17 创建一个包含数值、字符串元素的列表


In [32]:list2=[1,2,"a","b"]
In [33]:list2
Out[33]:[1, 2, 'a', 'b']

例 18 创建一个包含列表的列表


In [34]:list3=[["c","a"],"r"]
In [35]:list3
Out[35]:[['c', 'a'], 'r']

(2.2)使用 list 函数创建列表

创建列表的另一个方法是用list()函数,即把括号里的序列转换成列表。

例 19 将字符串转换为列表


In [36]:list4=list("text mining")
In [37]:list4
Out[37]:['t', 'e', 'x', 't', ' ', 'm', 'i', 'n', 'i', 'n', 'g']

从结果可以看出,list 函数将字符串的每一个元素都作为列表元素保存在列表中。

例 20 将元组转换为列表(元组的概念将在下一部分介绍)


In [38]:list5=list((1,2,3))
In [39]:list5
Out[39]:[1, 2, 3]

(3)改变、删除列表元素

列表不同于其他序列(字符串、元组)的一个特点是:列表可以改变、删除其中的元素。

(3.1)改变列表元素:列表[元素索引]=更改目标

例 21 将列表 list5 中元素“2”改为“6”


In [40]:list5[1]=6
In [41]:list5
Out[41]:[1, 6, 3]

(3.2)删除列表元素:del 列表[元素索引]

例 22 删除 list5 中元素“3”


In [42]: del list5[2]
In [43]: list5
Out[43]: [1, 6]

(4)常用列表方法

(4.1)添加列表元素的方法:append、extend、insert

append 方法用于给列表末端增加新的元素,调用方式为:列表.append(待添加元素)

例 23 在 list5 末端增加元素


In [44]:list5.append(0)
In [45]:list5
Out[45]:[1, 6, 0]
In [46]:list5.append([0,1])
In [47]:list5
Out[47]:[1, 6, 0, [0, 1]]

extend 方法用于在列表末端同时添加另一个序列中的多个元素,调用方式为:列表.extend(待添加序列)

例 24 在 list5 末端添加 list4 中的元素


In [48]:list5.extend(list4)
In [49]:list5
Out[49]:[1, 6, 0, [0, 1], 't', 'e', 'x', 't', ' ', 'm', 'i', 'n', 'i', 'n', 'g']

insert 方法用于将指定元素插入到列表的指定索引位置,调用方式为:列表.insert(索引,待插入元素)

例 25 在 list5 索引位置 4 插入字符串 “Python”


In [50]:list5.insert(4,"python")
In [51]:list5
Out[51]:[1, 6, 0, [0, 1], 'python', 't', 'e', 'x', 't', ' ', 'm', 'i', 'n', 'i', 'n', 'g']

(4.2)删除列表元素的方法:pop、remove

pop 方法用于删除列表中指定索引位置的元素,默认为最后一个元素,返回值是被删除的元素,调用方式为:列表.pop(待删除元素索引位置)

例 26 删除 list5 中最后一个元素


In [52]:list5.pop()
Out[52]:'g'
In [53]:list5
Out[53]:[1, 6, 0, [0, 1], 'python', 't', 'e', 'x', 't', ' ', 'm', 'i', 'n', 'i', 'n']

例 27 删除 list5 索引位置 2 的元素


In [52]:list5.pop(2)
Out[52]:0
In [53]:list5
Out[53]:[1, 6, [0, 1], 'python', 't', 'e', 'x', 't', ' ', 'm', 'i', 'n', 'i', 'n']

remove 方法用于删除列表中指定元值的元素,若有多个相同的元素,则删除第一个,调用方式为:列表.remove(待删除元素值)

例 28 删除 list5 中的字符串 “t”


In [54]:list5.remove("t")
In [55]:list5
Out[55]:[1, 6, [0, 1], 'python', 'e', 'x', 't', ' ', 'm', 'i', 'n', 'i', 'n']

(4.3) index

index 方法用于查找列表中某一个元素的索引位置,若有多个相同的元素,则返回第一个元素的索引位置,调用方式为:列表.index(待查找元素)

例 29 查看 list5 中元素 [0,1] 和 “n" 的索引位置


In [56]:list5.index([0,1])
Out[56]:2
In [57]:list5.index("n")
Out[57]:10

(4.4)列表元素排序方法:sort、reverse

sort 方法用于将列表元素升序排列,调用方式为:列表.sort()

例 30 将列表 list6=[9,3,6] 元素升序排列


In [58]:list6=[9,3,6]
In [59]:list6.sort()
In [60]:list6
Out[60]:[3, 6, 9]

reverse 方法用于反转列表元素原有排序,调用方式为:列表.reverse()

例 31 反转列表 list6 元素排序


In [61]:list6.reverse()
In [60]:list6
Out[60]:[9, 6, 3]

(4.5)count

count 方法用于统计列表中某一元素出现的次数,调用方式为:列表.count(待计数元素值)

例 32 统计 list5 中元素 “n" 出现的次数


In [61]:list5.count("n")
Out[61]:2

2.4.1.3 元组(tuple)

(1)什么是元组

与列表不同,元组是不能修改的序列。元组用括号“()”括起,其中的元素用逗号分隔,元素可以是任何值,如数值、字符串,或者序列。

(2)创建元组

(2.1)直接创建元组

例 33 创建一个空元组


In [62]: ()
Out[62]: ()

例 34 创建一个包含数值 1、2、3 的元组


In [63]: (1,2,3)
Out[63]: (1, 2, 3)

(2.2)使用 tuple 函数创建元组

创建元组的另一个方法是用 tuple()函数,即把括号里的序列转换成元组。

例 35 将列表 list5 转换为元组


In [64]:tuple1=tuple(list5)
In [65]:tuple1
Out[65]:(1, 6, [0, 1], 'python', 'e', 'x', 't', ' ', 'm', 'i', 'n', 'i', 'n')

例 36 将字符串 “text mining” 转换为元组


In [66]:tuple2=tuple("text mining")
In [67]:tuple2
Out[67]:('t', 'e', 'x', 't', ' ', 'm', 'i', 'n', 'i', 'n', 'g')

(3)元组的用途

在处理文本数据时,元组结构用的不多,倒是一些函数或方法的返回值常以元组的形式存在,下面举一个简单的实例帮助读者理解:在做基于词性识别的情感分析时,采用 jieba 进行词性标注,结果保存在列表中,列表中的每一个元素都是一个元组,形如 pair(u'', u''),元组里的元素用 unicode 编码展示,前者为词汇,后者表示词性。

(4)常用元组方法

相比于字符串和列表,元组的方法比较少。

(4.1)count

与列表一样,count 方法用于统计元组中某一元素出现的次数,调用方式为:元组.count(待计数元素值)

例 37 统计元组 tuple2 中字符串 “t" 出现的次数


In [68]:tuple2.count("t")
Out[68]:2

(4.2)index

与列表一样,index 方法用于查找元组中某一个元素的索引位置,若有多个相同的元素,则返回第一个元素的索引位置,调用方式为:元组.index(待查找元素)

例 38 查找元组 tuple1 中字符串 “n" 的索引位置


In [69]:tuple1.index("n")
Out[69]:10

2.4.1.4 序列的通用操作

2.4.1.1 - 2.4.1.3 部分已经介绍了 Python 中三种基本序列类型(字符串、列表和元组)及其常用的方法,此外,序列还有一些通用的操作,包括索引、运算、计算长度等,下面将向读者一一介绍。

(1)索引

本节开端已经介绍过,序列中每一个元素都有对应的索引位置,根据这个索引位置可以访问序列中相应的元素值。

例 39 访问序列某个元素:序列[索引位置]


In [70]:tuple1[0]
Out[70]:1

In [71]:"Text Mining with Python"[-2]
Out[71]:'o'

例 40 访问序列多个元素:序列[初始索引:结束索引]


In [72]:list5[2:5]
Out[72]:[[0, 1], 'python', 'e']

In [73]:"Text Mining with Python"[-5:-1]
Out[73]:'ytho'

可以看出,该种索引方式包括初始索引位置的元素,不包括结束索引位置的元素。

例 41 访问序列全部元素:序列[:]


In [74]:list6[:]
Out[74]:[6, 3, 9]

(2)序列运算

(2.1)序列相加

使用加法运算符号“+”可以对同类型序列进行连接

例 42 同类型序列链接


In [75]:list5+list6
Out[75]:[1, 6, [0, 1], 'python', 'e', 'x', 't', ' ', 'm', 'i', 'n', 'i', 'n', 6, 3, 9]

In [76]:"text"+"mining"
Out[76]:'textmining'

(2.2)序列乘法

进行“n*序列”的乘法操作,可以得到一个新序列,新序列为原序列重复 n 次。

例 43 创建重复序列


In [77]:"text"*3
Out[77]:'texttexttext'

In [78]:[1,2]*4
Out[78]:[1, 2, 1, 2, 1, 2, 1, 2]

(3)len()返回序列元素数量

例 44 统计序列元素数量


In [79]:len("text")
Out[79]:4

In [80]:len(list6)
Out[80]:3

(4)max()和min()返回序列中最大和最小元素

例 45 查找序列最大值和最小值


In [81]:max(list6)
Out[81]:9

In [82]:min(list6)
Out[82]:3

2.4.2 字典(dict)

2.4.2.1 什么是字典

前面已经介绍过,不同的数据结构有不同的表示形式,列表用方括号“[]”括起, 元组用圆括号“()”括起,而本部分将要介绍的字典,是用大括号“{}”括起的,并且里面的元素以“键(key):值(value)”的形式成对出现,如 {"Lucy":"92","David":"86","Bob":"100"} 就是一个存储学生姓名及成绩的字典,学生姓名为“键”,成绩为“值”,中间用冒号“:”表示对应关系,每一对“键”和“值”之间用逗号隔开,可以通过学生姓名访问其成绩。直观来讲,字典就像小型得数据库,可以使用键高效地存储和检索数据。

2.4.2.2 创建字典

(1)直接创建字典

例 46 创建一个空字典


In [83]:dict()
Out[83]:{}

例 47 创建学生成绩字典


In [84]:score={"Lucy":"92","David":"86","Bob":"100"} 
In [85]:score
Out[85]:{'Bob': '100', 'David': '86', 'Lucy': '92'}

可以看出,键、值的顺序在字典中并不重要,只要保持对应关系,就不会影响字典的访问。

(2)用 dict 函数创建字典

创建字典的另一个方法是用 dict()函数,一种创建方式是:dict([(key,value)]),即用dict函数作用于以键、值构成的元组为元素的列表。

例 48 创建顾客电话号码字典


In [86]:tel=dict([("Alice","123456"),("Eve","456789")])
In [87]:tel
Out[87]:{'Alice': '123456', 'Eve': '456789'}

另一种创建方式是:dict(name=value)。

例 49 创建病人年龄字典


In [88]:age=dict(Alex="15",Jack="33")
In [89]:age
Out[89]:{'Alex': '15', 'Jack': '33'}

2.4.2.3 基本字典操作

(1)访问字典中键对应的值:字典[键]

例 50 查询字典 tel 中名为 Alice 的顾客的电话


In [90]:tel["Alice"]
Out[90]:'123456'

(2)为键赋值:字典[键]=值

例 51 将字典 tel 中键 Alice 对应的值修改为 “654321”


In [91]:tel["Alice"]="654321"
In [92]:tel
Out[92]:{'Alice': '654321', 'Eve': '456789'}

例 52 为字典 tel 新增一个键值对: "Tracy":"987654"


In [93]:tel["Tracy"]="987654"
In [94]:tel
Out[94]:{'Alice': '654321', 'Eve': '456789', 'Tracy': '987654'}

(3)删除键值对:del 字典[键]

例 53 删除字典 score 中 Bob 的成绩


In [95]:del score["Bob"]
In [96]:score
Out[96]:{'David': '86', 'Lucy': '92'}

(4)统计字典中键值对的个数:len(字典)

54 统计字典 age 中有多少个病人的年龄记录
In [97]:len(age)
Out[97]:2

2.4.2.4 常用字典方法

与上文介绍过其他数据结构类似,字典也有相应的方法,下面选取常用的字典方法进行简单介绍。

(1)get

get 方法用于访问字典中键对应的值,调用方式为:字典.get(键)

例 55 访问字典 score 中的值


In [98]:score.get("Lucy")
Out[98]:'92'

In [99]:print score.get("Jay")
        None

第 99 条访问命令没有任何输出结果,这是因为字典 score 中不存在键 “Jay”,利用 print 得到 None 值。

(2)has_key

has_key 方法用于检查字典是否含有某个键,返回值“True”代表包含,“False”代表不包含。调用方式为:字典.has_key(键)

例 56 检查字典 tel 是否含有某些键


In [100]:tel.has_key("Eve")
Out[100]:True
In [101]:tel.has_key("X")
Out[101]:False

(3)items

items 方法的功能与 dict 函数相反,前文介绍过,dict 函数可以将包含(键,值)元组的列表转换为字典,items 方法则可以实现这一过程的逆操作,但是这一操作并不改变原有字典结构,只是返回相应的列表结果,如果有需要可以将结果赋给新的变量。调用方式为:字典.items()

例 57 输出字典 tel 的列表形式


In [102]:tel.items()
Out[102]:[('Tracy', '987654'), ('Alice', '654321'), ('Eve', '456789')]
In [103]:tel
Out[103]:{'Alice': '654321', 'Eve': '456789', 'Tracy': '987654'}

(4)keys

keys 方法可以以列表形式返回字典的键,结果不包含重复的键,每个键有且只有一个,调用方式为:字典.keys()

例 58 创建一个新字典 d ,并查看字典包含的所有的键


In [104]:d={"one":1,"two":2,"three":1}
In [105]:d.keys()
Out[105]:['three', 'two', 'one']

(5)values

与 keys 类似,values 方法可以以列表形式返回字典的值,但是与 keys 方法不同的是,values 方法返回的值可以重复,调用方式是:字典.values()

例 59 返回字典 d 包含的所有值


In [106]:d.values()
Out[106]:[1, 2, 1]

(6)pop

pop 方法用于删除指定的键值对,返回值为指定删除的值,调用方式为:字典.pop(键)

例 60 删除字典 d 中 "one":1 键值对


In [107]:d.pop("one")
Out[107]:1
In [108]:d
Out[108]:{'three': 1, 'two': 2}

2.4.3 集合(set)

集合内包含了一系列元素,兼具列表和字典的某些特性:集合和列表一样,可以用于存储一系列元素,但是集合的元素没有重复,而且是无序的,这点和字典的键很像。在 notebook 中,集合和字典一样用大括号“{}”括起,括号中的元素用逗号分开。

2.4.3.1 创建集合

创建集合需要调用 set() 函数,调用方式是:set(序列或其他可迭代对象)

例 61


In [109]:set1=set("text")
In [110]:set1
Out[110]:{'e', 't', 'x'}

In [111]:set2=set([1,2,3])
In [112]:set2
Out[112]:{1, 2, 3}

2.4.3.2 常用集合方法与运算

(1)union 和 “|”

与数学中“集合”的概念类似,Python 中集合结构的数据也可以进行集合运算,如求并集、交集和差集。求集合的并集,可以使用 union 方法,或者直接只用“|”运算符,调用方式为:集合1.union(集合2) 或 集合1|集合2

例 62 求两个集合的并集


In [113]:set3=set([3,4,5])
In [114]:set2.union(set3)
Out[114]:{1, 2, 3, 4, 5}
In [115]:set2|set3
Out[115]:{1, 2, 3, 4, 5}

(2)intersection 和 “&”

求集合的交集,可以使用 intersection 方法,或者直接只用“&”运算符,调用方式为:集合1.intersection(集合2) 或 集合1&集合2

例 63 求两个集合的交集


In [116]:set2.intersection(set3)
Out[116]:{3}
In [117]:set2&set3
Out[117]:{3}

(3)difference 和 “-”

求集合的差集,可以使用 difference 方法,或者直接只用“-”运算符,调用方式为:集合1.difference(集合2) 或 集合1-集合2

例 64 求两个集合的差集


In [118]:set2.difference(set3)
Out[118]:{1, 2}
In [119]:set2-set3
Out[119]:{1, 2}

(4)add

add 方法用于给集合中添加新元素,调用方式为:集合.add(待添加元素)

例 65 为集合 set2 添加元素 4


In [120]:set2.add(4)
In [121]:set2
Out[121]:{1, 2, 3, 4}

(5)remove

remove 方法用于删除集合中的元素,调用方式为:集合.remove(待删除元素)

例 66 删除集合 set2 中的元素 4


In [122]:set2.remove(4)
In [123]:set2
Out[123]:{1, 2, 3}

@todo 补充数据结构的方法说明对照表 2.4.3.2

2.4.4 常用语句

2.4.4.1 if 条件语句

if 语句可以根据给定的条件,自动判断该是否执行指定的语句。if 条件语句的基本结构为:

if 条件 : 执行语句

if 语句以 if 开头,if 后面紧跟着判断条件,第一行以冒号结尾。执行语句部分需换行并缩进四个空格,在 Jupyter Notebook 中回车换行后会自动缩进光标。如果 if 后的条件为真,则执行冒号后的语句,如果 if 后的条件为假,则跳过该语句,永远不执行。

例 67 如果 "Eve" 是字典 tel 中的键,则打印其对应的值


In [124]:if "Eve" in tel: 
             print tel["Eve"]
         456789

还可以在 if 语句后增加 else 子句,在 if 条件不满足时提供其他选择:

if 条件 : 执行语句1 else: 执行语句2

也就是说,当 if 后的条件不满足时,执行语句2。

例 68 如果 "x" 是字典 tel 中的键,则打印其对应的值,否则打印 "no such key"


In [125]:if "x" in tel:
             print tel["x"]
         else:
             print "no such key"
         no such key

如果是有多个判断条件的复杂决策,可以在 if 语句后增加 elif 子句:

if 条件1 : 执行语句1 elif 条件2:
执行语句2 else: 执行语句3

例 69 如果字典 tel 长度大于 3 ,打印 a ,如果字典 tel 长度小于 3 ,打印 b ,否则,打印 len tel = 3


In [126]:if len(tel)>3:
             print "a"
         elif len(tel)<3:
             print "b"
         else:
             print "len tel = 3"
         len tel = 3

2.4.4.2 循环语句

循环语句用于重复执行满足循环条件的语句,Python 主要的两个循环语句分别为 while 循环和 for 循环

(1)while 循环

while 循环的基本结构为:

while 循环条件: 执行语句

while 循环语句以 while 开头,后面跟循环条件,以冒号结尾。执行语句另起一行并缩进四个空格,如果满足循环条件的话则执行语句,并在此检查是否满足循环条件,直到不满足条件为止并跳出循环,执行循环语句后的其他语句。

例 70


In [127]:a=1 # 初始化语句,给变量 a 赋值 1
         while a < 5: # 如果满足条件 a<5
             print a # 打印 a 值
             a+=1 # 递增语句,令 a=a+1,即将 a 的值加一
         1
         2
         3
         4

(2)for 循环

for 循环适用于为一组元素循环执行语句的情况,如一个序列中的所有元素,基本结构为:

for 循环变量 in 元素集合: 执行语句

for 循环语句以 for 开头,后面跟循环变量,此处循环变量代指元素集合中的元素,常用变量 i 、j 、k 等表示,后跟关键字 in 和待循环的元素集合,第一行以冒号结束。执行语句同样需要换行并缩进四个空格, 整个循环语句表示:对于元素集合中的每一个元素都执行第二行的语句。

例 71


In [127]:for i in [1,3,5]: 
             print i
         1
         3
         5

2.4.5 常用 Python 标准库模块

前面已经介绍过,在安装 Python 的同时也会获得一组有用的模块,即标准库,提供了丰富的外部函数为使用者自己的程序所用。本部分将为读者介绍一些常用的标准库模块。

2.4.5.1 time

time 模块下有很多函数可以实现对时间的处理,如转换常见日期格式、获取当前时间、格式化时间为字符串等,要查看 time 模块下所有的函数,可以执行 dir(time) 语句实现,下面列举几个常用函数及调用方法:

(1)time

函数 time() 可以返回当前时间,时间格式为新纪元开始后的秒数,常用来做日期运算,调用方式为 time.time()

例 72


In [128]:import time
In [129]:time.time()
Out[129]:1476239582.4023

(2)localtime

函数 localtime() 可以将当前时间(新纪元开始后的秒数)转换为元组结构的时间表示,调用方式为:time.localtime(新纪元开始后的秒数),若参数为空,则默认为 time() 返回的当前时间。

例 73


In [130]:time.localtime()
Out[130]:time.struct_time(tm_year=2016, tm_mon=10, tm_mday=12, tm_hour=10, tm_min=29, tm_sec=51, tm_wday=2, tm_yday=286, tm_isdst=0)

(3)asctime

函数 asctime() 可以将当前时间用字符串表示出来,调用方式为:time.asctime(时间元组),若参数为空,则默认为 localtime() 返回的当前时间元组。

例 74


In [131]:time.asctime()
Out[131]:'Wed Oct 12 10:33:14 2016'
In [132]:time.asctime(time.localtime(time.time()))
Out[132]:'Wed Oct 12 10:34:35 2016'

(4)strftime

函数 strftime() 可以将时间元组转换为指定的字符串时间格式,调用方法为:time.strftime(格式字符串,时间元组),如果时间元组参数为空,则默认为 localtime() 返回的当前时间元组。

例 75


In [133]:time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
Out[133]:'2016-10-12 10:58:53'

除 time 模块外,Python 还提供了 datetime、calendar 等时间处理模块,读者可以通过 2.6.3 提供的官方文档详细阅读相关内容。

2.4.5.2 random

random 模块提供了多种分布的伪随机数生成函数,如返回指定区间的随机实数、随机返回序列中的元素等,要查看 random 模块下所有的函数,可以执行 dir(random) 语句实现,下面列举几个常用函数及调用方法:

(1)random

函数 random() 返回 0~1 之间的伪随机数,调用方式为:random.random()

例 76


In [134]:import random
In [135]:random.random()
Out[135]:0.5336585385012483

(2)uniform

函数 uniform() 返回指定区间的平均分布的随机实数,调用方式为:random.uniform(区间下限,区间上限)

例 77 返回 0~90 度之间的随机角度值


In [136]:random.uniform(0,90)
Out[136]:27.722651669371373

(3)choice

函数 choice() 可以随机返回指定序列中的元素,调用方式为:random.choice(序列)

例 78


In [137]:random.choice([1,2,3])
Out[137]:1

(4)sample

函数 sample() 可以从指定序列中随机选择若干个不同元素,调用方式为:random.sample(序列,返回元素个数)

例 79


In [138]:random.sample([1,2,3],2)
Out[138]:[1, 3]

2.4.5.3 collections

上文介绍的字符串、列表、元组、字典等等都是 Python 内置的数据结构,collections 模块在这些内置数据结构的基础上,又提供了额外的特殊数据结构 container ,可以简单翻译为 容器数据结构,该模块中定义了 Counter、Hashable、Mapping、MutableSet 等类,其中 Counter 是一个非常常用的计数器,可以用于计算序列中元素出现的次数,其返回值以字典结构存在,字典中键即为元素,值对应元素出现的次数,所以常用的字典方法也适用于 Counter 类对象。Counter 类实例化方式为:实例=Counter(序列或其他可迭代对象)

例 80


In [139]:from collections import Counter
In [140]:c=Counter("text mining with python")
         print c

In [141]:Counter([1,2,3,4,3,2,1])
Out[141]:Counter({1: 2, 2: 2, 3: 2, 4: 1})
         Counter({'t': 4, ' ': 3, 'i': 3, 'n': 3, 'h': 2, 'e': 1, 'g': 1, 'm': 1, 'o': 1, 'p': 1, 'w': 1, 'y': 1, 'x': 1})

Counter 对象还支持以下三种方法:

(1)elements

elements 方法可以按照 Counter 实例中各个元素出现的次数连续重复列举所有的元素,调用方式为:实例.elements()

例 81


In [142]:c=Counter([1,2,3,4,3,2,1])
In [143]:list(c.elements())
Out[143]:[1, 1, 2, 2, 3, 3, 4]

(2)most_common

most_common 方法可以计算 Counter 实例中各个元素出现的次数,并按照出现次数从大到小的顺序返回,调用方式为:实例.most_common(n),其中参数 n 表示出现次数最多的前 n 个元素

例 82


In [144]:Counter("text mining with python").most_common(3)
Out[144]:[('t', 4), (' ', 3), ('i', 3)]

(3)subtract

subtract 方法可以对两个 Counter 实例进行减法运算,即对元素出现的次数相减,对于未出现的元素会出现计数为负数的情况。调用方式为:实例1.subtract(实例2)

例 83


In [145]:a=Counter([1,2,3,3,2])
         b=Counter([1,1,2,"t"])
         a.subtract(b)
In [146]:a
Out[146]:Counter({1: -1, 2: 1, 3: 2, 't': -1})

results matching ""

    No results matching ""