python计算e的值当通项小于_Python科学计算与数据处理5：数据类型之非数值类型...

python-dictionary.jpg

上一节主要介绍了数值类型及其相关函数，这一节将介绍非数值类型，包括：字符、元组、列表和字典。

字符串

Python中的字符串是一个包含零个或多个字符的序列，因此它既包括了空字符，也包括了单个字符。字符串的定义方法我们之前已经介绍了，你可以通过len()函数来查看字符串的长度：

s1 = 'magpie bridge'; s2 = ''

print len(s1), len(s2)

输出为：

13 0

字符串索引

字符串采用下标[]的方式进行索引。例如

name = 'Monty Python'

len(name), name[0], name[11], name[-1], name[-3]

输出为：

(12, 'M', 'n', 'n', 'h')

下标可正可负，但是不能超过其长度范围，注意下标的起始值是0，而不是1。参考下图：

string_index.jpg

我们可以看到，对于一个长度为12的字符串，其下标范围是

~

，或

~

。也可以使用切片(slice)操作来一次性索引多个下标：

# 下面两种索引方法效果一样

name[0:3], name[:3]

注意索引的时候，[0:3]指的是第0、1、2个元素，而不包含第3个元素。

# 利用负下标进行索引，注意第二个表达式不会包含最后一个元素(第-1个元素)

name[-5:], name[-5:-1]

输出为：

('ython', 'ytho')

也可以指定步长，比如要索引第0、2、4个元素，可以使用下面任何一个表达式

name[0:5:2], name[0:6:2], name[:5:2]

输出为：

('Mny', 'Mny', 'Mny')

也可以利用负的步长从后向前倒序索引

name[-1:-5:-1]

输出为：

'noht'

切片操作是Python中对序列元素进行索引最常用的方法，对于字符串、列表和元组等都是可以使用。

字符串方法

字符串作为一个实例，提供了许多有用的方法。关于实例与方法具体是什么，会在介绍类的时候进行讲解，在这里你可以先将方法理解为一个函数。比如我们定义一个字符串，并统计其中出现了多少个't'，可以使用count()方法；如果要知道这个元素第一次出现时的下标，可以用index()方法：

name = 'Monty Python'

name.count('t'), name.index('t')

(2, 3)

或者我们希望找到某个元素的下标是多少，用find()函数会返回这个元素第一次出现的下标，如果这个元素不存在于字符串中，那么返回-1：

name.find('t'), name.find('Py'), name.find('w')

(3, 6, -1)

下面我们介绍几种特别有用的字符串方法。

大小写

name = 'david CHRISTOPHER'

print name.upper() # 全部大写

print name.lower() # 全部小写

print name.swapcase() # 交换大小写

print name.title() # 每个单词首字母大写

DAVID CHRISTOPHER

david christopher

DAVID christopher

David Christopher

字符串修剪(strip)

name = ' There are some extra spaces '

print r'original----%s----' % name

print r'rstrip()----%s----' % name.rstrip() # 清除右侧空格

print r'lstrip()----%s----' % name.lstrip() # 清除左侧空格

print r' strip()----%s----' % name.strip() # 清除两侧空格

original---- There are some extra spaces ----

rstrip()---- There are some extra spaces----

lstrip()----There are some extra spaces ----

strip()----There are some extra spaces----

分解字符串(split)

date = '2019-01-05'

date.split('-')

['2019', '01', '05']

连接字符串(join)

date = ['2019', '01', '05']

'-'.join(date)

'2019-01-05'

替换元素(replace)

sentence = 'Time is great and time is money.'

print sentence.replace('is', 'was')

print sentence.replace('is', 'was', 1)

Time was great and time was money.

Time was great and time is money.

布尔方法

str1 = 'abcd'; str2 = '1234'; str3 = 'abcd1234';

str4 = 'abcd*%232'; str5 = ' '; str6 = 'ABC'

print str1.isalpha() # 判断字符串是否全部由字母构成

print str2.isdigit() # 判断字符串是否全部由数字构成

print str3.isalnum() # 判断字符串是否全部由字母或数字构成

print str4.isalnum()

print str5.isspace() # 判断字符串是否全部由空格构成

print str6.isupper() # 判断字符串是否全部由大写字母构成

True

True

True

False

True

True

字符串函数

前面介绍了字符串方法，下面我们来介绍Python自带的字符串相关函数，这些函数大多数不仅可以接受字符串作为实参，往往也可以接受列表和元组等作为实参。

最大最小值

str1 = 'abcdefg'; a = [1, 2, 3]

min(str1), max(str1), max(a)

('a', 'g', 3)

类型

type(str1), type(a)

(str, list)

元组

元组是一种序列，可以混合存放不同类型的数据。元组用圆括号()来标识，在定义时也可以省略圆括号：

tup1 = (1, 2, 3.5, 'hello', 'a')

tup2 = 1, 2, 3.5, 'hello', 'a'

tup1, tup2

((1, 2, 3.5, 'hello', 'a'), (1, 2, 3.5, 'hello', 'a'))

索引和元素提取(unpack)

对元组中元素的索引，与字符串操作类似，也是按下标进行索引，也可以进行切片操作。

tup1 = ('Li Jing', 'Guo Ziyi', 'Li Shuo', 'Gao Xianzhi')

tup1[-1:-3:-1]

('Gao Xianzhi', 'Li Shuo')

可以将元组中的元素赋值给其他变量，但是要注意，所赋值的变量数目必须等于元组的长度。

tup1 = (1, 2, 3, 4)

a, b, c, d = tup1

print a, b, c, d

1 2 3 4

元组方法和函数

元组实例只有2个方法，即count()和index()，它们和字符串的相应方法一样。前面介绍过的字符串函数，大都也可以用于对元组进行操作，例如len()，max()，min()等，使用方法也一样。

元组运算

元组和字符串都可以进行两种运算，即+和*，其中+运算是将两个元组或字符串合并，而*运算是将元组或字符串重复一定的次数并组成新的元组或字符串。

tup1 = (1,2,3); tup2 = (1,'a', 'b')

s1 = 'abcd'; s2 = '2345'

print tup1 + tup2, tup1*2

print s1 + s2, s1 * 2

(1, 2, 3, 1, 'a', 'b') (1, 2, 3, 1, 2, 3)

abcd2345 abcdabcd

注意

元组相对于我们后面要讲的列表有一个重要的特点，那就是元组是不可更改的，也就是一旦被赋值，那么不能够通过索引来修改它的元素，或者增加删除元素。如果强行修改，系统会提示TypeError错误。

tup1 = (1, 2, 3, 4)

tup1[1] = 9

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

in ()

1 tup1 = (1, 2, 3, 4)

----> 2 tup1[1] = 9

TypeError: 'tuple' object does not support item assignment

列表

列表使用中括号[]来定义，也是一种序列。列表的使用基本和元组类似，但是如前所述，元组的元素不可更改，但是列表则可以通过索引修改任意元素。因此，列表具有更加灵活的应用，它所对应的方法更丰富。列表的创建、索引和元素提取都与元组类似，这里不在赘述，我们将重点介绍列表不同于元组的一些特性。

names = ['Li Jing', 'Gao Xianzhi', 'Li Shuo', 'Guo Ziyi']

names[0], names[-1]

('Li Jing', 'Guo Ziyi')

更新列表

可以通过索引更新列表的元素：

fruits = ['apple', 'banana', 'melon']

print fruits

fruits[0] = 'avocado'

print fruits

fruits[1:] = ['cherries', 'pear']

print fruits

['apple', 'banana', 'melon']

['avocado', 'banana', 'melon']

['avocado', 'cherries', 'pear']

也可以通过del()函数来删除列表中的某个元素，例如：

fruits = ['apple', 'banana', 'melon']

del fruits[0]

print fruits

['banana', 'melon']

成员判断(in)

可以用Python关键字in来判断某个值是否存在于列表中，这是一个特别有用的功能，例如：

fruits = ['berries', 'cherries', 'pear']

a = 'cherries'; b = 'pomegranate'

print a in fruits

print b in fruits

True

False

列表函数

之前介绍的对字符串和元组操作的函数同样可以操作列表，这里给大家介绍有个非常有用的排序函数sorted()，它同样可以操作各种序列，但无论它操作的是什么序列，其返回值都是列表：

str1 = 'CAT'; lis1 = [3,1,6,2]; tup1 = ('d', 'b', 'c', 'a')

print sorted(str1), sorted(lis1), sorted(tup1)

['A', 'C', 'T'] [1, 2, 3, 6] ['a', 'b', 'c', 'd']

列表方法

相比于元组，列表的方法更多：

count

index

append

extend

insert

remove

pop

reverse

sort

其中前两个方法与元组的方法类似，我们将简要介绍其他方法。

append()

用于向列表添加元素，新加入的元素放在列表尾部。

fruits = ['berries', 'cherries', 'pear']

fruits.append('pomegranate')

print fruits

['berries', 'cherries', 'pear', 'pomegranate']

extend()

用于将其他序列合并到列表中，例如：

str1 = 'CAT'; lis1 = [1, 2, 3]; tup1 = ('b', 'c', 'a')

print lis1

lis1.extend(str1)

print lis1

lis1.extend(tup1)

print lis1

[1, 2, 3]

[1, 2, 3, 'C', 'A', 'T']

[1, 2, 3, 'C', 'A', 'T', 'b', 'c', 'a']

insert()

用于向列表中特定位置插入元素。

fruits = ['berries', 'cherries', 'pear']

fruits.insert(1, 'orange')

print fruits

['berries', 'orange', 'cherries', 'pear']

remove()

用于删除列表中的某个元素，没有返回值。

fruits = ['berries', 'cherries', 'pear']

a = fruits.remove('berries')

print fruits, a

['cherries', 'pear'] None

pop()

同样是删除列表中的元素，但是会将这个元素作为返回值返回。

fruits = ['berries', 'cherries', 'pear']

a = fruits.pop(0)

print fruits, a

['cherries', 'pear'] berries

reverse()

用于将列表倒序。

lis1 = ['a', 'b', 'c', 'd']

lis1.reverse()

print lis1

['d', 'c', 'b', 'a']

sort()

用于对列表进行排序。

lis1 = [3,1,6,2]

lis1.sort()

print lis1

[1, 2, 3, 6]

列表解析(List comprehensions)

特别有用的列表操作方法，可以遍历列表中的元素并根据相应的表达式生成新的列表。例如，我们要生成一个平方数构成的序列：

a = range(1,10)

print a

a_square = [i*i for i in a]

print a_square

[1, 2, 3, 4, 5, 6, 7, 8, 9]

[1, 4, 9, 16, 25, 36, 49, 64, 81]

字典

字典是一系列用逗号分隔的键-值对(key-value)，使用花括号{}来定义。每个键-值对称为一个项(item)，键和值之间用冒号:分隔，而项之间用逗号,分隔。例如：

port = {22: 'SSH', 23: 'Telnet', 53: 'DNS', 80: 'HTTP', (3,2):3}

port

{22: 'SSH', 23: 'Telnet', 53: 'DNS', 80: 'HTTP', (3, 2): 3}

字典有如下特点：

键是不能更改的

字符串、整型数字和浮点型数字都可以用作键

不包含列表的元组也可以用作键

键不能重复

值可以是任何类型，如列表、字符串、整型等等

值是可以重复的

值可以被改变

字典是一个无序集合，也就是定义字典时的顺序没有意义

字典的操作

字典是可以修改的，可以添加或删除项，也可以更新某个键的值。

访问值

需要通过键来访问值，例如下面的例子：

port = {22: 'SSH', 23: 'Telnet', 53: 'DNS', 80: 'HTTP', 443: 'HTTPS'}

port[23]

'Telnet'

port[443]

'HTTPS'

删除项

可以使用del来删除整个字典或者字典中的具体项。例如：

port

{22: 'SSH', 23: 'Telnet', 53: 'DNS', 80: 'HTTP', 443: 'HTTPS'}

del port[22]

port

{23: 'Telnet', 53: 'DNS', 80: 'HTTP', 443: 'HTTPS'}

更新值

更新字典中某一项的值非常简单，只要知道这一项的键，使用如下语法即可：

dict[key] = new_value

添加项

添加项也非常简单，直接指定新的键与值即可：

dict[new_key] = value

字典函数

len()

用来获取字典的项数，例如：

port = {22: 'SSH', 23: 'Telnet', 53: 'DNS', 80: 'HTTP', 443: 'HTTPS'}

len(port)

5

str()

可以将字典整体转换为字符串，例如：

dic1 = {1:'a', 2:'b'}

str(dic1)

"{1: 'a', 2: 'b'}"

max()和min()

如果将字典作为实参传入max()或min()函数，那么将返回字典中键的最大值或最小值，例如：

port = {22: 'SSH', 23: 'Telnet', 53: 'DNS', 80: 'HTTP', 443: 'HTTPS'}

max(port), min(port)

(443, 22)

dict()

可以将列表或元组转换为字典，要求列表或元组中要有成对出现的元素(空列表或元组也可以，那么转换后的字典为空字典)，例如：

t1 = ()

t2 = ((1,'a'), (2,'b'))

t3 = (('Bob', 98),)

l4 = [['age',25], ['gender', 'male']]

d1 = dict(t1)

d2 = dict(t2)

d3 = dict(t3)

d4 = dict(l4)

print d1, d2, d3, d4

{} {1: 'a', 2: 'b'} {'Bob': 98} {'gender': 'male', 'age': 25}

注意上例中的t3 = (('Bob', 98),)中，最后一个逗号是不可省略的！

字典方法

copy()

copy()方法用于复制字典，复制后的字典与原字典是两个相互独立的字典，也就是所谓的“深拷贝”，这时候原字典更改不会影响新字典，反之亦然。而使用赋值语句将原字典赋予新字典，则是“浅拷贝”，两个字典指向同一个内存地址，因此会出现一改全改的情况。

A1 = {1: 'a', 2: 'b'}

A2 = A1

CW = A1.copy()

print A1, A2, CW

{1: 'a', 2: 'b'} {1: 'a', 2: 'b'} {1: 'a', 2: 'b'}

print id(A1), id(A2), id(CW)

86794584 86794584 86926472

A1[3] = 'new value'

print A1, A2, CW

{1: 'a', 2: 'b', 3: 'new value'} {1: 'a', 2: 'b', 3: 'new value'} {1: 'a', 2: 'b'}

get()

get()方法的用法如下：

dict.get(key, default=None)

用于获得字典中某个键对应的值，如果这个键不存在，则返回默认值。

port = {22: 'SSH', 23: 'Telnet', 53: 'DNS', 80: 'HTTP', 443: 'HTTPS'}

port.get(22, 'not found'), port.get(24, 'not found')

('SSH', 'not found')

has_key()

用于检测字典中是否包含某个键。

port = {22: 'SSH', 23: 'Telnet', 53: 'DNS', 80: 'HTTP', 443: 'HTTPS'}

port.has_key(22), port.has_key(19)

(True, False)

keys()，values()和items()

用于返回字典中所有的键、值和项。

port = {22: 'SSH', 23: 'Telnet', 53: 'DNS', 80: 'HTTP', 443: 'HTTPS'}

port.keys()

[80, 443, 53, 22, 23]

port.values()

['HTTP', 'HTTPS', 'DNS', 'SSH', 'Telnet']

port.items()

[(80, 'HTTP'), (443, 'HTTPS'), (53, 'DNS'), (22, 'SSH'), (23, 'Telnet')]

for k, v in port.iteritems():

print k, v

80 HTTP

443 HTTPS

53 DNS

22 SSH

23 Telnet

clear()

清空字典。

port = {22: 'SSH', 23: 'Telnet', 53: 'DNS', 80: 'HTTP', 443: 'HTTPS'}

print port

port.clear()

print port

{80: 'HTTP', 443: 'HTTPS', 53: 'DNS', 22: 'SSH', 23: 'Telnet'}

{}