预习
集合
- python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.
- sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing, slicing, 或其它类序列（sequence-like）的操作。
- 下面来点简单的小例子说明把。
- >>> x = set('spam')
- >>> y = set(['h','a','m'])
- >>> x, y
- (set(['a', 'p', 's', 'm']), set(['a', 'h', 'm']))
- 再来些小应用。
- >>> x & y # 交集
- set(['a', 'm'])
- >>> x | y # 并集
- set(['a', 'p', 's', 'h', 'm'])
- >>> x - y # 差集
- set(['p', 's'])
- 记得以前个网友提问怎么去除海量列表里重复元素，用hash来解决也行，只不过感觉在性能上不是很高，用set解决还是很不错的，示例如下：
- >>> a = [11,22,33,44,11,22]
- >>> b = set(a)
- >>> b
- set([33, 11, 44, 22])
- >>> c = [i for i in b]
- >>> c
- [33, 11, 44, 22]
- 很酷把，几行就可以搞定。
- 1.8 集合
- 集合用于包含一组无序的对象。要创建集合，可使用set()函数并像下面这样提供一系列的项：
- s = set([3,5,9,10]) #创建一个数值集合
- t = set("Hello") #创建一个唯一字符的集合
- 与列表和元组不同，集合是无序的，也无法通过数字进行索引。此外，集合中的元素不能重复。例如，如果检查前面代码中t集合的值，结果会是：
- >>> t
- set(['H', 'e', 'l', 'o'])
- 注意只出现了一个'l'。
- 集合支持一系列标准操作，包括并集、交集、差集和对称差集，例如：
- a = t | s # t 和 s的并集
- b = t & s # t 和 s的交集
- c = t – s # 求差集（项在t中，但不在s中）
- d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）
- 基本操作：
- t.add('x') # 添加一项
- s.update([10,37,42]) # 在s中添加多项
- 使用remove()可以删除一项：
- t.remove('H')
- len(s)
- set 的长度
- x in s
- 测试 x 是否是 s 的成员
- x not in s
- 测试 x 是否不是 s 的成员
- s.issubset(t)
- s <= t
- 测试是否 s 中的每一个元素都在 t 中
- s.issuperset(t)
- s >= t
- 测试是否 t 中的每一个元素都在 s 中
- s.union(t)
- s | t
- 返回一个新的 set 包含 s 和 t 中的每一个元素
- s.intersection(t)
- s & t
- 返回一个新的 set 包含 s 和 t 中的公共元素
- s.difference(t)
- s - t
- 返回一个新的 set 包含 s 中有但是 t 中没有的元素
- s.symmetric_difference(t)
- s ^ t
- 返回一个新的 set 包含 s 和 t 中不重复的元素
- s.copy()
- 返回 set “s”的一个浅复制
- 请注意：union(), intersection(), difference() 和 symmetric_difference() 的非运算符（non-operator，就是形如 s.union()这样的）版本将会接受任何 iterable 作为参数。相反，它们的运算符版本（operator based counterparts）要求参数必须是 sets。这样可以避免潜在的错误，如：为了更可读而使用 set('abc') & 'cbs' 来替代 set('abc').intersection('cbs')。从 2.3.1 版本中做的更改：以前所有参数都必须是 sets。
- 另外，Set 和 ImmutableSet 两者都支持 set 与 set 之间的比较。两个 sets 在也只有在这种情况下是相等的：每一个 set 中的元素都是另一个中的元素（二者互为subset）。一个 set 比另一个 set 小，只有在第一个 set 是第二个 set 的 subset 时（是一个 subset，但是并不相等）。一个 set 比另一个 set 打，只有在第一个 set 是第二个 set 的 superset 时（是一个 superset，但是并不相等）。
- 子 set 和相等比较并不产生完整的排序功能。例如：任意两个 sets 都不相等也不互为子 set，因此以下的运算都会返回 False：a<b, a==b, 或者a>b。因此，sets 不提供 __cmp__ 方法。
- 因为 sets 只定义了部分排序功能（subset 关系），list.sort() 方法的输出对于 sets 的列表没有定义。
- 运算符
- 运算结果
- hash(s)
- 返回 s 的 hash 值
- 下面这个表列出了对于 Set 可用二对于 ImmutableSet 不可用的运算：
- 运算符（voperator）
- 等价于
- 运算结果
- s.update(t)
- s |= t
- 返回增加了 set “t”中元素后的 set “s”
- s.intersection_update(t)
- s &= t
- 返回只保留含有 set “t”中元素的 set “s”
- s.difference_update(t)
- s -= t
- 返回删除了 set “t”中含有的元素后的 set “s”
- s.symmetric_difference_update(t)
- s ^= t
- 返回含有 set “t”或者 set “s”中有而不是两者都有的元素的 set “s”
- s.add(x)
- 向 set “s”中增加元素 x
- s.remove(x)
- 从 set “s”中删除元素 x, 如果不存在则引发 KeyError
- s.discard(x)
- 如果在 set “s”中存在元素 x, 则删除
- s.pop()
- 删除并且返回 set “s”中的一个不确定的元素, 如果为空则引发 KeyError
- s.clear()
- 删除 set “s”中的所有元素
- 请注意：非运算符版本的 update(), intersection_update(), difference_update()和symmetric_difference_update()将会接受任意 iterable 作为参数。从 2.3.1 版本做的更改：以前所有参数都必须是 sets。
- 还请注意：这个模块还包含一个 union_update() 方法，它是 update() 方法的一个别名。包含这个方法是为了向后兼容。程序员们应该多使用 update() 方法，因为这个方法也被内置的 set() 和 frozenset() 类型支持。
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此创建字典：
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
访问字典里的值
把相应的键放入熟悉的方括弧，如下实例:
#!/usr/bin/python3
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])
以上实例输出结果：
dict['Name']: Runoob dict['Age']: 7
如果用字典里没有的键访问数据，会输出错误如下：
#!/usr/bin/python3
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'};
print ("dict['Alice']: ", dict['Alice'])
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 5, in <module>
print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
#!/usr/bin/python3
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8; # 更新 Age
dict['School'] = "菜鸟教程" # 添加信息
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
以上实例输出结果：
dict['Age']: 8 dict['School']: 菜鸟教程
删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
#!/usr/bin/python3
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear() # 删除字典
del dict # 删除字典
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
但这会引发一个异常，因为用执行 del 操作后字典不再存在：
Traceback (most recent call last):
File "test.py", line 9, in <module>
print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable
注：del() 方法后面也会讨论。
字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
#!/usr/bin/python3
dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
print ("dict['Name']: ", dict['Name'])
以上实例输出结果：
dict['Name']: 小菜鸟
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
#!/usr/bin/python3
dict = {['Name']: 'Runoob', 'Age': 7}
print ("dict['Name']: ", dict['Name'])
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 3, in <module>
dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list' 总结
python序列包含列表[]、元组()、字符串三种
-------列表--------------
一、列表基本内容
1、建立：a=[1,2,3,5]，通过[ ， ，],
>>>b=[6,7,8,9]
2、索引：a[0]=1
3、切片：a[0:2],a[:]
4、删除：del a[索引]; a.remove(5) ；a.pop(索引），会返回删除的值
5、列表操作符： ‘+’表示拼接列表；*表示重复
>>> a+b
[1, 2, 3, 5, 6, 7, 8, 9]
>>> a*2
[1, 3, 1, 3]
二、列表方法
1、len(列表)——返回列表的长度
2、max(list)——返回列表的最大值
3、min(list)——返回列表的最小值
4、list(seq)——将元组转换为列表，返回该列表
>>> list((1,2,3,4))
[1, 2, 3, 4]
5、list.append(列表，或单独一个数或字符)——在列表末尾添加新元素（作为一个元素加入），返回值：无。
>>> a.append(b)
>>> a
[1, 2, 3, 5, [6, 7, 8, 9]]
6、list.extend(seq)——在列表后面一次性添加多个值(类似append直接改变该列表)，seq必须是列表或者range()，返回值：无。
>>> a.extend(b)
>>> a
[1, 2, 3, 5, 6, 7, 8, 9]
7、list.index(元素值)——找出第一个匹配到参数obj（值）的索引，返回值：返回索引值
>>> a.index(5)
3
8、list.count(元素)——统计某个元素（列表中的值）在列表中出现的次数，返回值：返回该次数。
9、list.insert(index,obj)——将值(obj)插入到指定索引(index)，返回值：无。
>>> a.insert(8,10)
>>> a
[1, 2, 3, 5, 6, 7, 8, 9, 10]
10、list.pop(obj=list[-1])——删除列表中的元素（默认删除最后项），返回值：返回该删除项的值。
11、list.remove(obj)——删除第一个值为obj的匹配项，返回值：无。
12、list.reverse()——列表反向排序，无参数，无返回值
>>> a.reverse()
>>> a
[10, 9, 8, 7, 6, 5, 3, 2, 1]
13、list.sort([func])——对列表进行排序,根据字母和数字由小到大，列表数据类型要一致（同数字或同字符串），func为指定方法（可 选参数）
>>> a.sort()
>>> a
[1, 2, 3, 5, 6, 7, 8, 9, 10]
sort修改了原序列，可以使用sorted,b=sorted(a,reverse=True,key=len)
14、list.clear()——清空列表，类似于del a[:],返回值：无。
15、list.copy()——复制列表并返回，返回值：被复制的列表。
16、cmp(m,n)——比较两个元素大小，返回1或-1或0
17、set()——列出列表中不重复的元素（去重）集合。
-------------元组--------------------
一、元组的基本内容：元组不可变序列
1、建立：逗号分隔一些值，或( , , )建立，或者tuple(),
>>> tuple([1,2,3])
(1, 2, 3)
2、切片和索引：与列表相同,但是不能修改元组
3、连接——'+'连接2个元组形成一个新的元组
4、重复——'*'重复一个元组加在末尾
5、删除——元组不能删除其中的元素，但是元组可以整个删除，del tup
6、.len(tup)——返回元组的长度
7、tuple(seq)——将列表转换为元组
8、max(tup)——返回元组最大值
-----------字符串---------------
一、字符串格式化操作符%,转换说明符，标记了需要插入转换值的位置
左侧是需要格式化的字符串 % 右侧是希望格式化的值（可以是一个字符串或数值或多个值的元组） ,%s,s 表示被格式化为字符串,%.nf表示格式化为保存n位小数的浮点数
>>> "hello,%s,welcome %.1f" %('python',2.72)
'hello,python,welcome 2.7'
二、字符串方法
1、find方法，在字符串中查找子字符串，返回子串所在位置的最左端索引
>>> f="hello,python"
>>> f.find('python')
6
2、join方法，是split方法的逆方法，来子啊队列中添加元素
>>> q=list('abcd')
>>> p='-'
>>> p.join(q)
'a-b-c-d'
3、lower方法返回字符串的小写字母版
4、replace 返回某字符串的所有匹配项均被替换后得到的字符串
5、split（‘分隔’）将字符串分割成序列
6、strip去除两侧的空格
扫一扫
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
