1.1.3.2.1 修改列表:给元素赋值

x = [1,2,3]
x

## [1, 2, 3]

x[2] = 5
x

## [1, 2, 5]

1.1.3.2.2 删除列表中的元素

使用del语句可以删除列表中的某个元素.

names = ["alice", "beth", "cecil"]
del names[1]
names

## ['alice', 'cecil']

1.1.3.2.3 使用切片对多个元素进行修改

name = list("name")
name

## ['n', 'a', 'm', 'e']

name[2:] = list("shen")
name

## ['n', 'a', 's', 'h', 'e', 'n']

name[4:] = list("wa")
name

## ['n', 'a', 's', 'h', 'w', 'a']

需要注意的是,使用切片进行赋值或者修改,是可以将其替换为不同长度的东西的.

test = list("wang")
test

## ['w', 'a', 'n', 'g']

test[2:] = list("shen")
test

## ['w', 'a', 's', 'h', 'e', 'n']

test[2:3]

## ['s']

test[2:3] = list("shen")
test

## ['w', 'a', 's', 'h', 'e', 'n', 'h', 'e', 'n']

还可以使用这个特性进行元素的插入:

numbers = [1, 5]
numbers

## [1, 5]

numbers[1:1]##这是一个空列表

## []

numbers[1:1] = [2, 3, 4]#在第二个位置开始,插入新的list
numbers

## [1, 2, 3, 4, 5]

当然,还可以利用这个特性删除切片.

numbers

## [1, 2, 3, 4, 5]

numbers[1:4]

## [2, 3, 4]

numbers[1:4] = []
numbers

## [1, 5]

当然,删除仍然可以使用del语句实现,最后结果是一致的.

1.1.3.2.4 列表方法

方法是与某列对象联系紧密的函数,一般使用下列方法进行调用:

object.method(arguments)

这也是跟R不同的一点,R中并没有这类方法.

1. append

用于将一个对象添加到列表末尾.

test = [1,2,3]
test

## [1, 2, 3]

test.append(2)
test

## [1, 2, 3, 2]

test.append([5,6,7])
test

## [1, 2, 3, 2, [5, 6, 7]]

test.append(10)
test

## [1, 2, 3, 2, [5, 6, 7], 10]

test + [20]

## [1, 2, 3, 2, [5, 6, 7], 10, 20]

test + [10,20]

## [1, 2, 3, 2, [5, 6, 7], 10, 10, 20]

2. clear

用来清空列表的内容.

test = [1,2,3]
test.clear()
test

## []

完全清空所有的内容.

3. copy

用来复制列表.在Python中,直接使用=将一个列表赋值给另外一个对象名,其实只是关联而已,也就是说其实同一个列表关联到了两个名字而已.

a = [1,2,3]
b = a
b[1] = 10
b

## [1, 10, 3]

a##a也会改变,和b保持一致

## [1, 10, 3]

想要把a和b指向两个独立的不同的列表,需要使用copy,将b关联到a的副本.

a = [1,2,3]
b = a.copy()
b[1] = 10
b

## [1, 10, 3]

a

## [1, 2, 3]

4. count

用来统计指定的元素在列表中出现的次数.

a = [1,2,3,4,4]
a.count(1)

## 1

a.count(4)

## 2

count()一共有两个参数,第一个参数为’self’,也就是前面的对象,后买你的参数为value指定要统计的元素.

5. extend

这个方法跟append的区别在于,它可以将一个独立的列表添加到列表后面.

a = [1,2,3]
b = [4,5,6]
a.extend(b)
a

## [1, 2, 3, 4, 5, 6]

a.append(b)
a

## [1, 2, 3, 4, 5, 6, [4, 5, 6]]

a + b

## [1, 2, 3, 4, 5, 6, [4, 5, 6], 4, 5, 6]

a

## [1, 2, 3, 4, 5, 6, [4, 5, 6]]

需要注意这几种方法的区别.

6. index

用于查找列表中指定值第一次出现的索引.

test = list("shen")
test

## ['s', 'h', 'e', 'n']

test.index("h")

## 1

7. insert

将一个对象插入到列表中.

a = [1,2,3]
a

## [1, 2, 3]

a.insert(1, "four")
a

## [1, 'four', 2, 3]

a.insert(0, [1, "shen"])
a

## [[1, 'shen'], 1, 'four', 2, 3]

insert第一个参数用来指定需要插入的位置(索引),第二个参数用来指定需要插入的内容.插入的内容可以是单个元素,也可以是列表.

8. pop

删除一个元素,默认为最后一个.修改原列表,并返回删除的元素.

x = [1,2,3]
x.pop()

## 3

x

## [1, 2]

当然,也可以使用index'参数,指定需要删除的元素.

9. remove

用于删除第一个为指定值的元素.

test = list("shen")
test.remove("h")
test

## ['s', 'e', 'n']

需要注意的是,只删除第一个符合要求的元素,其他的不会删除.

10. reverse

将元素顺序按相反顺序重新排列.

11. sort

对列表元素重新进行排列.

x = ['aardvark', 'abalone', 'acme', 'add', 'aerate', "shen", "wang", "china", "us"]
x.sort()
x

## ['aardvark', 'abalone', 'acme', 'add', 'aerate', 'china', 'shen', 'us', 'wang']

sort函数还可以通过设置key参数来自定义排列规则,如可以将key设置为函数len,从而将列表按照元素的长度进行排序.

x.sort(key = len)
x

## ['us', 'add', 'acme', 'shen', 'wang', 'china', 'aerate', 'abalone', 'aardvark']

1.1.3.3.1 创建元组

使用小括号(())可以创建元组.

x = (1,2,3)
x

## (1, 2, 3)

type(x)

## <class 'tuple'>

()#空元组

## ()

创建只含有一个元素的元组比较特殊,需要在元素后面加上逗号.如果不加逗号,不能常见元组.

x = (42)
x

## 42

type(x)

## <class 'int'>

y = (x, )
y

## (42,)

type(y)

## <class 'tuple'>

3 * (10+3)

## 39

3 * (10+3,)

## (13, 13, 13)

看了上面的例子,可以很好的明白为什么需要加上逗号,因为小括号在数学运算中还表示运算优先级的意思,所以需要使用逗号来区分是进行数学运算,还是要创建元组.

当然,和列表一样,我们还可以使用tuple()函数来创建元组.

tuple([1, 2, 3])

## (1, 2, 3)

tuple("shen")

## ('s', 'h', 'e', 'n')

你可能意识到了,元组并不太复杂,而且除创建和访问其元素外,可对元组执行的操作不多.元组的创建及其元素的访问方式与其他序列相同.

那为什么要单独出来一个元组类型呢?有两个原因:

1. 它们用作映射中的键(以及集合的成员),而列表不行.

2. 有些内置函数和方法返回元组,这意味着必须跟它们打交道.只要不尝试修改元组,与元组打交道通常意味着像处理列表一样处理它们(需要使用元组没有的index和count等方法时例外).

1.2.1.2.1 center

通过在两边添加填充字符(默认为空格)让字符串居中.

"The Middle by Jimmy Eat World".center(40)

## '     The Middle by Jimmy Eat World      '

"The Middle by Jimmy Eat World".center(40, "*")

## '*****The Middle by Jimmy Eat World******'

1.2.1.2.2 find

在字符串中查找子串,如果找到,就返回字串的第一个字符的索引,否则返回-1.

'With a moo-moo here, and a moo-moo there'.find('moo')

## 7

'With a moo-moo here, and a moo-moo there'.find('shen')

## -1

你还可指定搜索的起点和终点.

subject = '$$$ Get rich now!!! $$$'
subject

## '$$$ Get rich now!!! $$$'

subject.find('$$$')

## 0

subject.find('$$$', 1) # 只指定了起点

## 20

subject.find('!!!', 0, 16) # 同时指定了起点和终点

## -1

请注意,起点和终点值(第二个和第三个参数)指定的搜索范围包含起点,但不包含终点.这是Python惯常的做法.

另外的和find相关的方法还包括:

rfind,index,rindex,count,startswith和endswith.

1.2.1.2.3 join

join是一个非常重要的字符串方法,其作用与split相反,用于合并序列的元素.

seq = list("shen")
seq

## ['s', 'h', 'e', 'n']

sep = '+'
sep

## '+'

sep.join(seq)

## 's+h+e+n'

这个方法跟R中的paste函数非常类似.

注意,所合并序列的元素必须都是字符串.如果list元素都是数字,是会报错的.

1.2.1.2.4 lower

返回字符串的小写版本.

'Trondheim Hammer Dance'.lower()

## 'trondheim hammer dance'

类似或者同一类方法还有:

islower,istitle,isupper,translate,capitalize,casefold,swapcase,title,upper.

1.2.1.2.5 replace

将指定子串都替换为另一个字符串,并返回替换后的结果.

'This is a test'.replace('is', 'eez')

## 'Theez eez a test'

一共两个参数,第一个是需要替换的内容,第二个是替换之后的内容.

到这里应该发现,其实这就是R中的stringr包所要做的工作.

另外还需要参考的函数:

tranlate和expandtabs.

1.2.1.2.6 split

其和join作用相反,用于将字符串拆分为序列.

'1+2+3+4+5'.split('+')

## ['1', '2', '3', '4', '5']

'Using the default'.split()

## ['Using', 'the', 'default']

可以看到,默认拆分的标识符是空格( ).

1.2.1.2.7 strip

用于将字符串的开头和末尾的空白删除.

' internal whitespace is kept '.strip()

## 'internal whitespace is kept'

当然,还可以通过设置参数,来指定删除的字符类型.

'*** SPAM * for * everyone!!! ***'.strip(' *!')

## 'SPAM * for * everyone'

但是还是只能删除开头和末尾.

相似函数或者方法:

lstrip和rstrip.

1.2.1.2.8 translate

方法translate与replace一样替换字符串的特定部分,但不同的是它只能进行单字符替换.这个方法的优势在于能够同时替换多个字符,因此效率比replace高.

使用translate前必须创建一个转换表.这个转换表指出了不同Unicode码点之间的转换关系.要创建转换表,可对字符串类型str调用方法maketrans,这个方法接受两个参数:两个长度相同的字符串,它们指定要将第一个字符串中的每个字符都替换为第二个字符串中的相应字 符.

table = str.maketrans('cs', 'kz')
table

## {99: 107, 115: 122}

type(table)

## <class 'dict'>

可以看到,转换表是一个字典类型.

'this is an incredible test'.translate(table)

## 'thiz iz an inkredible tezt'

1.2.1.2.9 判断字符串是否满足某些特定的条件

很多字符串方法都以is打头,如isspace,isdigit和isupper,它们判断字符串是否具有特定的性质(如包含的字符全为空白,数字或大写).如果字符串具备特定的性质,这些方法就返回True,否则返回False.

参考其他函数:

isalnum,isalpha,isdecimal,isdigit,isidentifier,islower,isnumeric,isprintable,isspace,istitle,isupper.

1.2.2.1.1 使用dict函数

items = [('name', 'Gumby'), ('age', 42)]
items

## [('name', 'Gumby'), ('age', 42)]

type(items)

## <class 'list'>

d = dict(items)
d

## {'name': 'Gumby', 'age': 42}

type(d)

## <class 'dict'>

d["name"]

## 'Gumby'

d["age"]

## 42

items是一个列表,然后包含两个元组,每个元组都包含两个元素,然后每个元组的第一个元素作为键,第二个元素作为值.

还可以使用另外一种形式,使用dict创建字典.

d = dict(name='Gumby', age=42)
d

## {'name': 'Gumby', 'age': 42}

len(d)

## 2

1.2.2.1.2 字典的基本操作

字典的基本行为在很多方面都类似于序列.

1. len(d)返回字典d包含的项(键-值对)数.
2. d[k]返回与键k相关联的值.
3. d[k] = v将值v关联到键k.
4. del d[k]删除键为k的项.

虽然字典和列表有多个相同之处,但也有一些重要的不同之处.

1. 键的类型:字典中的键可以是整数,但并非必须是整数.字典中的键可以是任何不可变的类型,如浮点数(实数),字符串或元组.
2. 自动添加:即便是字典中原本没有的键,也可以给它赋值,这将在字典中创建一个新项.然而,如果不使用append或其他类似的方法,就不能给列表中没有的元素赋值.

d = dict(name='Gumby', age=42)
d

## {'name': 'Gumby', 'age': 42}

d["sex"] = "male"
d

## {'name': 'Gumby', 'age': 42, 'sex': 'male'}

3. 成员资格:表达式k in d(其中d是一个字典)查找的是键而不是值,而表达式v in l(其中l是一个列表)查找的是值而不是索引.这看似不太一致,但你习惯后就会觉得相当自然.毕竟如果字典包含指定的键,检查相应的值就很容易.

4. k in d检查字典d是否包含键为k的项.

创建空的字典,使用大括号进行.

x = {}
x

## {}

x['name'] = "shen"
x

## {'name': 'shen'}

x = {"name":"shen", "age":29}
x

## {'name': 'shen', 'age': 29}

1.2.2.1.3 适用于字典的方法

1. clear

方法clear删除所有的字典项,这种操作是就地执行的(就像list.sort一样),因此什么都不返回(或者说返回None).

d = {}
d['name'] = 'Gumby'
d['age'] = 42
d

## {'name': 'Gumby', 'age': 42}

d.clear()
d

## {}

2. copy

方法copy返回一个新字典,其包含的键-值对与原来的字典相同(这个方法执行的是浅复制,因为值本身是原件,而非副本).

x = {'username':'admin', 'machines':['foo', 'bar', 'baz']}
x

## {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}

y = x.copy()
y

## {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}

y['username'] = 'mlh'
y['machines'].remove('bar')
x

## {'username': 'admin', 'machines': ['foo', 'baz']}

y

## {'username': 'mlh', 'machines': ['foo', 'baz']}

如你所见,当替换副本中的值时,原件不受影响.然而,如果修改副本中的值(就地修改而不是替换),原件也将发生变化,因为原件指向的也是被修改的值(如这个示例中的’machines’列表所示).

为避免这种问题,一种办法是执行深复制,即同时复制值及其包含的所有值,等等.为此,可使用模块copy中的函数deepcopy.

from copy import deepcopy
d = {}
d['names'] = ['Alfred', 'Bertrand']
d

## {'names': ['Alfred', 'Bertrand']}

c = d.copy()
dc = deepcopy(d)
d['names'].append('Clive')
d

## {'names': ['Alfred', 'Bertrand', 'Clive']}

c

## {'names': ['Alfred', 'Bertrand', 'Clive']}

dc

## {'names': ['Alfred', 'Bertrand']}

3. fromkeys

方法fromkeys创建一个新字典,其中包含指定的键,且每个键对应的值都是None.

{}.fromkeys(['name', 'age'])

## {'name': None, 'age': None}

这个示例首先创建了一个空字典,再对其调用方法fromkeys来创建另一个字典.

4. get

方法get为访问字典项提供了宽松的环境.通常,如果你试图访问字典中没有的项,将引发错误.

d = {}
print(d['name'])

而使用get不会这样:

print(d.get('name'))

## None

d.get('name', 'N/A')

## 'N/A'

5. items

方法items返回一个包含所有字典项的列表,其中每个元素都为(key, value)的形式.字典项在列表中的排列顺序不确定.

d = {'title':'Python Web Site', 'url':'http://www.python.org', 'spam':0}
d

## {'title': 'Python Web Site', 'url': 'http://www.python.org', 'spam': 0}

d.items()

## dict_items([('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 0)])

test = d.items()
test

## dict_items([('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 0)])

type(test)

## <class 'dict_items'>

返回值属于一种名为字典视图的特殊类型.字典视图可用于迭代.另外,你还可确定其长度以及对其执行成员资格检查.其中每一个元素都是一个元组.

it = d.items()
it

## dict_items([('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 0)])

len(d)

## 3

len(it)

## 3

6. kyes

方法keys返回一个字典视图,其中包含指定字典中的键.

d

## {'title': 'Python Web Site', 'url': 'http://www.python.org', 'spam': 0}

d.items()

## dict_items([('title', 'Python Web Site'), ('url', 'http://www.python.org'), ('spam', 0)])

d.keys()

## dict_keys(['title', 'url', 'spam'])

7. pop

方法pop可用于获取与指定键相关联的值,并将该键-值对从字典中删除.

d = {'x':1, 'y':2}
d

## {'x': 1, 'y': 2}

d.pop('x')

## 1

d

## {'y': 2}

8. popitem

方法popitem类似于list.pop,但list.pop弹出列表中的最后一个元素,而popitem随机地弹出一个字典项,因为字典项的顺序是不确定的,没有“最后一个元素”的概念.如果你要以高效地方式逐个删除并处理所有字典项,这可能很有用,因为这样无需先获取键列表.

d = {'url':'http://www.python.org', 'spam':0, 'title':'Python Web Site'}
d

## {'url': 'http://www.python.org', 'spam': 0, 'title': 'Python Web Site'}

d.popitem()

## ('title', 'Python Web Site')

d

## {'url': 'http://www.python.org', 'spam': 0}

9. setdefault

方法setdefault有点像get,因为它也获取与指定键相关联的值,但除此之外,setdefault还在字典不包含指定的键时,在字典中添加指定的键-值对.

d = {}
d.setdefault('name', 'N/A')

## 'N/A'

d

## {'name': 'N/A'}

d['name'] = 'Gumby'
d.setdefault('name', 'N/A')

## 'Gumby'

d

## {'name': 'Gumby'}

10. update

方法update使用一个字典中的项来更新另一个字典.

d = {
 'title':'Python Web Site',
 'url':'http://www.python.org',
 'changed':'Mar 14 22:09:15 MET 2016'
}
d

## {'title': 'Python Web Site', 'url': 'http://www.python.org', 'changed': 'Mar 14 22:09:15 MET 2016'}

x = {'title':'Python Language Website'}
d.update(x)
d

## {'title': 'Python Language Website', 'url': 'http://www.python.org', 'changed': 'Mar 14 22:09:15 MET 2016'}

对于通过参数提供的字典,将其项添加到当前字典中.如果当前字典包含键相同的项,就替换它.

11. values

方法values返回一个由字典中的值组成的字典视图.不同于方法keys,方法values返回的视图可能包含重复的值.

d = {"a":1, "b":2, "c":3}
d

## {'a': 1, 'b': 2, 'c': 3}

d.values()

## dict_values([1, 2, 3])

1.2.2.2.1 新的函数

1.2.2.2.2 适用于字典的方法