列表和元祖
列表取值和切片的演示：
|
1
2
3
4
5
6
7
8
9
|
strings
=
[
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
]
print
(strings[
0
])
# 从0开始计数，所以第一个元素是0
print
(strings[
1
:
4
])
# 切片，从起点开始，但是不包括终点
print
(strings[
4
:])
# 缺省终点，则切到结尾
print
(strings[:
3
])
# 也可以缺省起点，则从头开始
print
(strings[::
2
])
# 所以头尾都省了,就是从头到尾。这里加上了步长，因为头尾步长3个参数都省了，那就是打印整个列表print(strings)
print
(strings[
0
:
5
:
2
])
# 第三个参数是步长，默认1
print
(strings[
-
2
])
# 取倒数第2个
print
(strings[
-
4
:
-
2
])
# 永远是从左往右取，所以-4放前面
|
追加列表、插入列表、修改列表：
|
1
2
3
4
5
6
7
|
strings
=
[
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
]
strings.append(
'z'
)
# 在最后追加
print
(strings)
strings.insert(
1
,
'i1'
)
# 插到1的位置
print
(strings)
strings[
4
]
=
'D2'
# 修改
print
(strings)
|
删除列表：
|
1
2
3
4
5
6
7
8
9
|
strings
=
[
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
]
strings.remove(
'c'
)
# 不能删除不存在的成员
print
(strings)
strings.pop()
# 缺省参数，删除最后一个
print
(strings)
strings.pop(
1
)
# 如果带了参数，就是删除那一个
print
(strings)
del
strings[
0
]
# 也是不能删除不存在的。这里和带参数的pop是一样的
print
(strings)
|
查找元素：
|
1
2
3
4
5
6
|
strings
=
[
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
]
strings.append(
'e'
)
print
(strings.count(
'e'
))
# 返回列表中这个元素出现的次数
print
(strings.index(
'e'
))
# 返回列表中这个元素的位置。但是只有第一个匹配项。但是如果没找到会报错
print
(
'f'
in
strings)
# in 和 not in之前已经学过了。可以做元素是否存在于列表中的判断
print
(
'h'
not
in
strings)
|
反转、合并、排序，最后清空：
|
1
2
3
4
5
6
7
8
9
10
|
strings
=
[
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
]
print
(strings)
strings.reverse()
# 反转列表
print
(strings)
strings.extend([
'2'
,
'!'
,
"AA"
])
# 合并列表，直接用+号结果也一样，但是+号有效率问题吧
print
(strings)
strings.sort()
# 排序，元素不能混有数字和字符串，否则排序会报错。这里是2是字符
print
(strings)
# 排序按ASCII码排，符号，数字，大写，小写。中文字符排最后
strings.clear()
# 清空列表
print
(strings)
|
列表的复制使用.copy()
列表里的元素也可以是另一个列表，下面一起演示
|
1
2
3
4
5
6
7
8
|
strings
=
[
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
]
strings.insert(
2
,[
'A'
,
'B'
,
'C'
])
# 插入一个元素，这个元素是另一个列表
strings2
=
strings.copy()
# 复制列表
print
(strings2)
strings[
0
]
=
'apple'
# 修改原始表的元素
strings[
2
][
1
]
=
'BOY'
# 2层列表中的元素是这样表示的
print
(strings)
print
(strings2)
# 注意1层元素没变，但是2层的元素也变了，虽然之前操作的原始表的元素
|
列表里每个元素占一个空间，1层的元素这个空间存的就是值，copy的时候就是将这个值复制了。但是二层的情况，在一层的表里也只占1个元素的位置，这里存的值就是下面二层表的内存地址。所以无论在哪张list里修改2层的元素，两张表都会变化。
列表使用赋值=和copy效果是不同的，使用=完全就是复制了内存地址，等于只是给这个列表起了一个别名
|
1
2
3
4
5
6
|
strings
=
[
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
]
strings3
=
strings
print
(strings3)
strings[
0
]
=
'apple'
# 修改原始表的元素
print
(strings)
print
(strings3)
# 虽然没修改这张表，但是内容和原始表是一样的
|
所以要向真正的复制一张表，需要import copy 这个模块
|
1
2
3
4
5
6
7
8
9
10
11
12
|
import
copy
strings
=
[
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
]
strings.insert(
2
,[
'A'
,
'B'
,
'C'
])
# 插入一个元素，这个元素是另一个列表
strings2
=
copy.copy(strings)
# 和之前的复制列表一样
strings3
=
copy.deepcopy(strings)
# 深copy，这个是我们需要的
print
(strings2)
print
(strings3)
strings[
0
]
=
'apple'
# 修改原始表的元素
strings[
2
][
1
]
=
'BOY'
# 修改2层里的元素
print
(strings)
print
(strings2)
# 1层没变，2层还是被修改了
print
(strings3)
# 这里的元素完全不受原始表变化的影响
|
元组和列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表
元组只有count和index这2个方法。
|
1
2
3
4
5
|
strings1
=
[
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
]
# 这个是列表list
strings2
=
(
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
)
# 这个是元祖tuple
print
(
type
(strings1),
type
(strings2))
print
(strings1)
print
(strings2)
|
可以把那种不希望被修改的数据，比如常量、比如连接参数，存放在元组里
enumerate()函数
可以方便的一次获得元素的下标和值，比较实用
|
1
2
3
4
5
6
7
8
9
10
11
12
|
strings
=
[
'a'
,
'b'
,
'c'
,
'd'
]
# 下标和值构成了一个元组
for
i
in
enumerate
(strings):
print
(i)
print
(
'******'
)
# 这样写，就依次输出了下标和值，而不是以元组的形式出现了
for
i,j
in
enumerate
(strings):
print
(i,j)
print
(
'******'
)
# 应用的时候还是用index和item，这样意义比较明确。另外可以带上一个参数，指定下标的起始值
for
index,item
in
enumerate
(strings,
1
):
print
(index,item)
|
字符串操作
自动填充的函数有点用处，先记一下。否则在需要用的时候很有可能要手动填充。
|
1
2
3
4
|
string
=
"hello"
print
(string.center(
10
,
'='
))
# 内容在中间，两边填充
print
(string.ljust(
10
,
'='
))
# 内容在左边，右边填充
print
(string.rjust(
10
,
'='
))
# 内容在右边，左边填充
|
参数1定义了字符串的长度，不足就用参数2的字符填充。
字典
字典是key:value的数据类型
-
字典是无序的
-
key必须唯一
|
1
2
3
4
5
6
|
# 创建字典
dic1
=
{}
# 创建一个空的字典
dic2
=
{
'name'
:
'Bob'
,
'job'
:
'engineer'
,
'gender'
:
'male'
}
print
(dic1,dic2)
|
修改和增加
|
1
2
3
4
5
6
|
dic2
=
{
'name'
:
'Bob'
,
'job'
:
'engineer'
,
'gender'
:
'male'
}
dic2[
'class'
]
=
'First'
# 如果key不存在，则增减
dic2[
'job'
]
=
'teacher'
# 如果key存在，则修改
print
(dic2)
|
还有一种增加的方法，setdefault，注意下面的参数中间使用的是逗号。只会新增没有的key，不会修改已有的key
|
1
2
3
4
5
6
|
dic2
=
{
'name'
:
'Bob'
,
'job'
:
'engineer'
,
'gender'
:
'male'
}
dic2.setdefault(
'name'
,
'Tom'
)
# 最后结果，name并不会被修改
dic2.setdefault(
'class'
,
'First'
)
# 最后结果，增加了class这项
print
(dic2)
|
删除：删除字典内的元素推荐2中方法：
|
1
2
3
4
5
6
|
dic2
=
{
'name'
:
'Bob'
,
'job'
:
'engineer'
,
'gender'
:
'male'
}
dic2.pop(
'gender'
)
del
dic2[
'job'
]
print
(dic2)
|
查找也给了2个方法，推荐用get
|
1
2
3
4
5
6
7
|
dic2
=
{
'name'
:
'Bob'
,
'job'
:
'engineer'
,
'gender'
:
'male'
}
print
(
'job'
in
dic2)
# 返回True,返回字典里是否有这个key
print
(dic2[
'job'
])
# 返回key的值（Value）。如果key不存在则会报错
print
(dic2.get(
'name'
))
# 如果key存在，返回值
print
(dic2.get(
'name2'
))
# 如果key不存在，返回None
|
可以列出所有的key或所有的value
|
1
2
3
4
5
|
dic2
=
{
'name'
:
'Bob'
,
'job'
:
'engineer'
,
'gender'
:
'male'
}
print
(dic2.values())
print
(dic2.keys())
|
还可以把字典转成列表
|
1
2
3
4
|
dic2
=
{
'name'
:
'Bob'
,
'job'
:
'engineer'
,
'gender'
:
'male'
}
print
(dic2.items())
|
update，合并更新字典。把参数中的表合并更新到前面的表。没有的key会新增，已有的key和做修改
|
1
2
3
4
5
6
7
8
9
10
|
dic2
=
{
'name'
:
'Bob'
,
'job'
:
'engineer'
,
'gender'
:
'male'
}
dic3
=
{
'job'
:
'teacher'
,
'class'
:
'First'
}
print
(dic2)
print
(dic3)
dic2.update(dic3)
print
(dic2)
print
(dic3)
|
字典初始化：第一个参数是字典的所有的key，第二个参数是所有value的默认值。这里第二个参数不要再嵌套元组或列表这类数据类型，否则默认赋的值将会是这个列表或元素的内存地址，导致所有的value都是关联的同一个值
|
1
2
3
|
dictmp
=
{}
dic
=
dictmp.fromkeys([
'name'
,
'job'
,
'gender'
],
'N/A'
)
print
(dic)
|
本文转自骑士救兵51CTO博客，原文链接：http://blog.51cto.com/steed/1977821，如需转载请自行联系原作者
