基本数据类型
字符串 String
字符串是不可变类型
字符串的分割：
s.split(sep)以给定的sep为分隔符对s进行分割。
In [4]:
s = "hello world" s.split()
Out[4]:
['hello', 'world']
In [11]:
line = "1,2,3,4,5"
numbers = line.split(',')
连接
与分割相反，s.join(str_sequence)的作用是以s为连接符将字符串序列str_sequence中的元素连接起来，并返回连接后得到的新字符串：
In [13]:
s = ',' s.join(numbers)
Out[13]:
'1,2,3,4,5'
替换
s.replace(part1, part2)将字符串s中指定的部分part1替换成想要的部分part2，并返回新的字符串。 每个部分都会替换 不止是第一个 s的值本身没有发生变化 只是生成一个新的字符串
In [17]:
s = "hello world"
s.replace('l', ' python ')
Out[17]:
'he python python o wor python d'
In [19]:
s
Out[19]:
'hello world'
大小写转换
s.upper()方法返回一个将s中的字母全部大写的新字符串。
s.lower()方法返回一个将s中的字母全部小写的新字符串。
这两种方法也不会改变原来s的值：
In [20]:
"hello world".upper()
Out[20]:
'HELLO WORLD'
数字
取整
In [7]:
round(21.6)
Out[7]:
22
列表
删除元素
Python提供了删除列表中元素的方法 'del'。
删除列表中的第一个元素：
In [22]:
a = [1002, 'a', 'b', 'c'] del a[1] a
Out[22]:
[1002, 'b', 'c']
In [25]:
a = [1002, 'a', 'b', 'c'] del a[1:] a
Out[25]:
[1002]
删除间隔的元素
In [24]:
a = ['a', 1, 'b', 2, 'c'] del a[::2] a
Out[24]:
[1, 2]
列表方法
不改变列表的方法
列表中某个元素个数count
l.count(ob) 返回列表中元素 ob 出现的次数。
a = [11, 12, 13, 12, 11] a.count(11)
列表中某个元素位置index
l.index(ob) 返回列表中元素 ob 第一次出现的索引位置，如果 ob 不在 l 中会报错。
In [25]:
a.index(12)
Out[25]:
1
不存在的元素会报错：
In [26]:
a.index(1) --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-26-ed16592c2786> in <module>() ----> 1 a.index(1) ValueError: 1 is not in list
改变列表的方法
向列表添加单个元素
l.append(ob) 将元素 ob 添加到列表 l 的最后。
In [27]:
a = [10, 11, 12] a.append(11) print a [10, 11, 12, 11]
append每次只添加一个元素，并不会因为这个元素是序列而将其展开：
In [28]:
a.append([11, 12]) print a [10, 11, 12, 11, [11, 12]]
向列表添加序列
l.extend(lst) 将序列 lst 的元素依次添加到列表 l 的最后，作用相当于 l += lst。
In [29]:
a = [10, 11, 12, 11] a.extend([1, 2]) print a [10, 11, 12, 11, 1, 2]
插入元素
l.insert(idx, ob) 在索引 idx 处插入 ob ，之后的元素依次后移。
In [30]:
a = [10, 11, 12, 13, 11] # 在索引 3 插入 'a' a.insert(3, 'a') print a [10, 11, 12, 'a', 13, 11]
移除元素
l.remove(ob) 会将列表中第一个出现的 ob 删除，如果 ob 不在 l 中会报错。
In [31]:
a = [10, 11, 12, 13, 11] # 移除了第一个 11 a.remove(11) print a [10, 12, 13, 11]
弹出元素
l.pop(idx) 会将索引 idx 处的元素删除，并返回这个元素。
In [32]:
a = [10, 11, 12, 13, 11] a.pop(2)
Out[32]:
12
排序
l.sort() 会将列表中的元素按照一定的规则排序：
In [33]:
a = [10, 1, 11, 13, 11, 2] a.sort() print a [1, 2, 10, 11, 11, 13]
如果不想改变原来列表中的值，可以使用 sorted 函数：
In [34]:
a = [10, 1, 11, 13, 11, 2] b = sorted(a) print a print b [10, 1, 11, 13, 11, 2] [1, 2, 10, 11, 11, 13]
list.sort(cmp=None, key=None, reverse=False)
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond)
# 输出类别
print '排序列表：', random
输出：排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]
列表反向
l.reverse() 会将列表中的元素从后向前排列。
In [35]:
a = [1, 2, 3, 4, 5, 6] a.reverse() print a [6, 5, 4, 3, 2, 1]
如果不想改变原来列表中的值，可以使用这样的方法：
In [36]:
a = [1, 2, 3, 4, 5, 6] b = a[::-1] print a print b [1, 2, 3, 4, 5, 6] [6, 5, 4, 3, 2, 1]
元组
基本操作
与列表相似，元组Tuple也是个有序序列，但是元组是不可变的，用()生成。
In [1]:
t = (10, 11, 12, 13, 14) t (10, 11, 12, 13, 14)
但是元组是不可变的：
单个元素的元组生成
由于()在表达式中被应用，只含有单个元素的元组容易和表达式混淆，所以采用下列方式定义只有一个元素的元组：
In [5]:
a = (10,) print a print type(a) (10,) <type 'tuple'>
In [6]:
a = (10) print type(a) <type 'int'>
将列表转换为元组：
In [7]:
a = [10, 11, 12, 13, 14] tuple(a)
Out[7]:
(10, 11, 12, 13, 14)
元组方法
由于元组是不可变的，所以只能有一些不可变的方法，例如计算元素个数 count 和元素位置 index ，用法与列表一样。
a.count(10) a.index(12)
字典
空字典
Python 使用 {} 或者 dict() 来创建一个空的字典：
In [1]:
a = {}
type(a)
dict
a = dict()
type(a)
dict
b = {'one': 'this is number 1', 'two': 'this is number 2'}
b['one']
'this is number 1'
字典没有顺序
当我们 print 一个字典时，Python并不一定按照插入键值的先后顺序进行显示,因为字典中的键本身不一定是有序的。
print(a)
{'two': 'this is number 2', 'one': 'this is number 1, too'}
因此，Python中不能用支持用数字索引按顺序查看字典中的值，而且数字本身也有可能成为键值，这样会引起混淆：
键必须是不可变的类型 ,而值可以是任意的Python对象。
使用 dict 初始化字典
除了通常的定义方式，还可以通过 dict() 转化来生成字典：
inventory = dict(
[('foozelator', 123),
('frombicator', 18),
('spatzleblock', 34),
('snitzelhogen', 23)
])
inventory
{'foozelator': 123, 'frombicator': 18, 'snitzelhogen': 23, 'spatzleblock': 34}
利用索引直接更新键值对：
In [15]:
inventory['frombicator'] += 1
inventory
{'foozelator': 123, 'frombicator': 19, 'snitzelhogen': 23, 'spatzleblock': 34}
适合做键的类型
在不可变类型中，整数和字符串是字典中最常用的类型；而浮点数通常不推荐用来做键，原因：浮点数的精度问题
有时候，也可以使用元组作为键值，例如，可以用元组做键来表示从第一个城市飞往第二个城市航班数的多少：
In [19]:
connections = {}
connections[('New York', 'Seattle')] = 100
connections[('Austin', 'New York')] = 200
connections[('New York', 'Austin')] = 400
元组是有序的，因此 ('New York', 'Austin') 和 ('Austin', 'New York') 是两个不同的键：
字典方法
get 方法
用索引可以找到一个键对应的值，但是当字典中没有这个键的时候，Python会报错，这时候可以使用字典的 get 方法来处理这种情况，其用法如下：
`d.get(key, default = None)`
返回字典中键 key 对应的值，如果没有这个键，返回 default 指定的值（默认是 None ）。
In [21]:
a = {}
a["one"] = "this is number 1"
a["two"] = "this is number 2"
a["three"]
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-22-8a5f2913f00e> in <module>()
----> 1 a["three"]
KeyError: 'three'
print a.get("three")
None
pop 方法删除元素
pop 方法可以用来弹出字典中某个键对应的值，同时也可以指定默认参数：
d.pop(key, default = None)`
删除并返回字典中键 key 对应的值，如果没有这个键，返回 default 指定的值（默认是 None ）。
与列表一样，del 函数可以用来删除字典中特定的键值对，例如：
In [30]:
del a["one"] a
update方法更新字典
之前已经知道，可以通过索引来插入、修改单个键值对，但是如果想对多个键值对进行操作，这种方法就显得比较麻烦，好在有 update 方法：
d.update(newd)
将字典newd中的内容更新到d中去。
In [31]:
person = {}
person['first'] = "Jmes"
person['last'] = "Maxwell"
person['born'] = 1831
print person
{'born': 1831, 'last': 'Maxwell', 'first': 'Jmes'}
把'first'改成'James'，同时插入'middle'的值'Clerk'：
In [32]:
person_modifications = {'first': 'James', 'middle': 'Clerk'}
person.update(person_modifications)
print person
{'middle': 'Clerk', 'born': 1831, 'last': 'Maxwell', 'first': 'James'}
in查询字典中是否有该键
In [33]:
barn = {'cows': 1, 'dogs': 5, 'cats': 3}
'chickens' in barn
False
keys 方法，values 方法和items 方法
d.keys()
返回一个由所有键组成的列表；
d.values()
返回一个由所有值组成的列表；
d.items()
返回一个由所有键值对元组组成的列表；
In [36]:
barn.keys()
['cows', 'cats', 'dogs']
barn.values()
[1, 3, 5]
barn.items()
[('cows', 1), ('cats', 3), ('dogs', 5)]
集合
列表和字符串都是一种有序序列，集合 set 是一种无序的序列。
因为集合是无序的，所以当集合中存在两个同样的元素的时候，Python只会保存其中的一个（唯一性）；同时为了确保其中不包含同样的元素，集合中放入的元素只能是不可变的对象（确定性）。
集合生成
可以用set()函数来显示的生成空集合：
In [1]:
a = set() type(a)
也可以使用一个列表来初始化一个集合：
In [2]:
a = set([1, 2, 3, 1])
a
{1, 2, 3}
集合会自动去除重复元素 1。
可以看到，集合中的元素是用大括号{}包含起来的，这意味着可以用{}的形式来创建集合：
In [3]:
a = {1, 2, 3, 1}
a
{1, 2, 3}
但是创建空集合的时候只能用set来创建，因为在Python中{}创建的是一个空的字典：
集合操作
并
两个集合的并，返回包含两个集合所有元素的集合（去除重复）。
可以用方法 a.union(b) 或者操作 a | b 实现。
交
两个集合的交，返回包含两个集合共有元素的集合。
可以用方法 a.intersection(b) 或者操作 a & b 实现。
差
a 和 b 的差集，返回只在 a 不在 b 的元素组成的集合。
可以用方法 a.difference(b) 或者操作 a - b 实现。
对称差
a 和b 的对称差集，返回在 a 或在 b 中，但是不同时在 a 和 b 中的元素组成的集合。
可以用方法 a.symmetric_difference(b) 或者操作 a ^ b 实现（异或操作符）。
包含关系
两个集合A、B，集合A中任意一个元素都是集合B中的元素，我们就说这两个集合有[包含]关系，称集合A为集合B的子集
要判断 b 是不是 a 的子集，可以用 b.issubset(a) 方法，或者更简单的用操作 b <= a ：
方法只能用来测试子集，但是操作符可以用来判断真子集：( 如果集合A是集合B的子集，并且集合B不是集合A的子集 )
a <= a True
自己不是自己的真子集：
a < a False
集合方法
add 方法向集合添加单个元素
跟列表的 append 方法类似，用来向集合添加单个元素。
s.add(a)
将元素 a 加入集合 s 中。
t = {1, 2, 3}
t.add(5)
t
{1, 2, 3, 5}
如果添加的是已有元素，集合不改变：
update 方法向集合添加多个元素
跟列表的extend方法类似，用来向集合添加多个元素。
s.update(seq)
将seq中的元素添加到s中。
t.update([5, 6, 7])
t
{1, 2, 3, 5, 6, 7}
remove 方法移除单个元素
s.remove(ob)
从集合s中移除元素ob，如果不存在会报错。
pop方法弹出元素
由于集合没有顺序，不能像列表一样按照位置弹出元素，所以pop 方法删除并返回集合中任意一个元素，如果集合中没有元素会报错。
t.pop()
{3, 5, 6, 7}
discard 方法
作用与 remove 一样，但是当元素在集合中不存在的时候不会报错。
difference_update方法
a.difference_update(b)
从a中去除所有属于b的元素：
不可变集合
对应于元组（tuple）与列表（list）的关系，对于集合（set），Python提供了一种叫做不可变集合（frozen set）的数据结构。
使用 frozenset 来进行创建：
s = frozenset([1, 2, 3, 'a', 1])
s
frozenset({1, 2, 3, 'a'})
与集合不同的是，不可变集合一旦创建就不可以改变。
不可变集合的一个主要应用是用来作为字典的键，例如用一个字典来记录两个城市之间的距离：
In [2]:
flight_distance = {}
city_pair = frozenset(['Los Angeles', 'New York'])
flight_distance[city_pair] = 2498
flight_distance[frozenset(['Austin', 'Los Angeles'])] = 1233
flight_distance[frozenset(['Austin', 'New York'])] = 1515
flight_distance
Out[2]:
{frozenset({'Austin', 'New York'}): 1515,
frozenset({'Austin', 'Los Angeles'}): 1233,
frozenset({'Los Angeles', 'New York'}): 2498}
由于集合不分顺序，所以不同顺序不会影响查阅结果：
In [3]:
flight_distance[frozenset(['New York','Austin'])]
Out[3]:
1515
In [4]:
flight_distance[frozenset(['Austin','New York'])]
Out[4]:
1515