task5-字典、集合和序列

1 字典

1.1 可变类型与不可变类型

• 序列是以连续的整数为索引，与此不同的是，字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值。
• 字典是 Python 唯一的一个 映射类型，字符串、元组、列表属于序列类型。

那么如何快速判断一个数据类型 X 是不是可变类型的呢？两种方法：

• 麻烦方法：用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。
• 便捷方法：用 hash(X)，只要不报错，证明 X 可被哈希，即不可变，反过来不可被哈希，即可变。

i=1
print(id(i))
i+=1
print(id(i))

140706987876752
140706987876784

i=[1,2,3]
print(id(i))
i.append(4)
print(id(i))

2801539148744
2801539148744

• 整数 i 在加 1 之后的 id 和之前不一样，因此加完之后的这个 i (虽然名字没变)，但不是加之前的那个 i 了，因此整数是不可变类型。
• 列表 l 在附加 ‘Python’ 之后的 id 和之前一样，因此列表是可变类型。

i=1
print(hash(i))
i=(1,2,3)
print(hash(i))
i=[1,2]
print(hash(i))

1
2528502973977326415



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

TypeError                                 Traceback (most recent call last)

<ipython-input-6-784ae897205d> in <module>
      4 print(hash(i))
      5 i=[1,2]
----> 6 print(hash(i))


TypeError: unhashable type: 'list'

• 数值、字符和元组 都能被哈希，因此它们是不可变类型。
• 列表、集合、字典不能被哈希，因此它是可变类型。

1.2 字典的定义

字典 是无序的 键:值（key:value）对集合，键必须是互不相同的（在同一个字典之内）。

• dict 内部存放的顺序和 key 放入的顺序是没有关系的。
• dict 查找和插入的速度极快，不会随着 key 的增加而增加，但是需要占用大量的内存。

字典 定义语法为 {元素1, 元素2, ..., 元素n}

• 其中每一个元素是一个「键值对」-- 键:值 (key:value)
• 关键点是「大括号 {}」,「逗号 ,」和「冒号 :」
• 大括号 – 把所有元素绑在一起
• 逗号 – 将每个键值对分开
• 冒号 – 将键和值分开

1.3 创建和访问字典

id1=[1,2,3,4,5]
name=['zhang','wang','li','zhao','liu']
print("5号学生是：",name[id1.index(5)])

5号学生是： liu

dic={1:'zhang',2:'wang',3:'li',4:'zhao',5:'liu'}
print("5号学生是：",dic[5])

5号学生是： liu

• 创建空字典

dic={}
dic['a']=5
dic['b']=7
dic['c']=9
print(dic)
dic['a']=100
print(dic)
dic2=dict()
print(dic2,type(dic2))

{'a': 5, 'b': 7, 'c': 9}
{'a': 100, 'b': 7, 'c': 9}
{} <class 'dict'>

dic1=dict(((1,'zhang'),(2,'wang'),(3,'li')))
print(dic1,type(dic1))

{1: 'zhang', 2: 'wang', 3: 'li'} <class 'dict'>

dic2=dict([(1,'zhang'),(2,'wang'),(3,'li')])
print(dic2,type(dic2))

{1: 'zhang', 2: 'wang', 3: 'li'} <class 'dict'>

dic1=dict(id=1,name='zhang',age=81)#这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上就会直接报语法错误。
print(dic1,type(dic1))

{'id': 1, 'name': 'zhang', 'age': 81} <class 'dict'>

1.4 字典的内置方法

• dict.fromkeys(seq[, value]) 用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

seq=('name','socre','item')
dict1=dict.fromkeys(seq)
print(dict1)

{'name': None, 'socre': None, 'item': None}

seq=('name','score','item')
dict1=dict.fromkeys(seq,10)
print(dict1)

{'name': 10, 'score': 10, 'item': 10}

seq=('name','score','item')
dict1=dict.fromkeys(seq,(10,20,30))
print(dict1)

{'name': (10, 20, 30), 'score': (10, 20, 30), 'item': (10, 20, 30)}

• dict.keys()返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键。

dict1={'name':'zhang','sex':'female','age':20}
a=dict1.keys()
print(a)
b=list(a)
print(b)

dict_keys(['name', 'sex', 'age'])
['name', 'sex', 'age']

• dict.values()返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。

dict1={'name':'zhang','sex':'female','age':11}
a=dict1.values()
print(a)
b=list(a)
print(b)

dict_values(['zhang', 'female', 11])
['zhang', 'female', 11]

• dict.items()以列表返回可遍历的 (键, 值) 元组数组。

dict1={'name':'zhang','sex':'female','age':11}
a=dict1.items()
print(a)
b=list(a)
print(b)

dict_items([('name', 'zhang'), ('sex', 'female'), ('age', 11)])
[('name', 'zhang'), ('sex', 'female'), ('age', 11)]

• dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回默认值。

dict1={'name':'zhang','sex':'female','age':11}
a=dict1.get('name')
print(a)
b=dict1['name']
print(b)
c=dict1.get('time')
print(c)
d=dict1.get('time','ww')
print(d)
print(dict1)
print(dict['time'])

zhang
zhang
None
ww
{'name': 'zhang', 'sex': 'female', 'age': 11}



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

TypeError                                 Traceback (most recent call last)

<ipython-input-39-34dbaacaf626> in <module>
      9 print(d)
     10 print(dict1)
---> 11 print(dict['time'])


TypeError: 'type' object is not subscriptable

• dict.setdefault(key, default=None)和get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

dict1={'name':'zhang','sex':'female','age':11}
a=dict1.setdefault('name')
print(a)
b=dict1.setdefault('time')
print(b)
c=dict1.setdefault('table','eee')
print(c)
print(dict1)

zhang
None
eee
{'name': 'zhang', 'sex': 'female', 'age': 11, 'time': None, 'table': 'eee'}

• key in dict in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回true，否则返回false。而not in操作符刚好相反，如果键在字典 dict 里返回false，否则返回true。

dict1={'name':'zhang','sex':'female','age':11}
if 'age' in dict1:
    print(dict1['age'])
else:
    print("键age不存在")
    
if 'time' in dict1:
    print(dict['time'])
else:
    print('键不存在')

if 'time' not in dict1:
    print('键不存在')
else:
    print(dict['time'])

11
键不存在
键不存在

• dict.pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出。若key不存在，则返回 default 值。
• del dict[key] 删除字典给定键 key 所对应的值。

dict1={'name':'zhang','sex':'female','age':11}
print(dict1.pop('sex'))
print(dict1)
print(dict1.pop('time','www'))
print(dict1)
del dict1['name']
print(dict1)

female
{'name': 'zhang', 'age': 11}
www
{'name': 'zhang', 'age': 11}
{'age': 11}

• dict.popitem()随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常。

dict1={'name':'zhang','sex':'female','age':11}
print(dict1.popitem())
print(dict1)

('age', 11)
{'name': 'zhang', 'sex': 'female'}

• dict.clear()用于删除字典内所有元素。

dict1={'name':'zhang','sex':'female','age':11}
dict1.clear()
print(dict1)

{}

• dict.copy()返回一个字典的浅复制。

dict1={'name':'zhang','sex':2,'age':[11,12,13]}
dict2=dict1.copy()
print(dict2)
dict3=dict1
print(dict3)
#print(id(dict1))
#print(id(dict2))
#print(id(dict3))
dict1['name']='wang'
print(dict1)
print(dict2)
print(dict3)
dict1['age'].remove(11)
print(dict1)
print(dict2)
print(dict3)      

{'name': 'zhang', 'sex': 2, 'age': [11, 12, 13]}
{'name': 'zhang', 'sex': 2, 'age': [11, 12, 13]}
{'name': 'wang', 'sex': 2, 'age': [11, 12, 13]}
{'name': 'zhang', 'sex': 2, 'age': [11, 12, 13]}
{'name': 'wang', 'sex': 2, 'age': [11, 12, 13]}
{'name': 'wang', 'sex': 2, 'age': [12, 13]}
{'name': 'zhang', 'sex': 2, 'age': [12, 13]}
{'name': 'wang', 'sex': 2, 'age': [12, 13]}

• dict.update(dict2)把字典参数 dict2 的 key:value对 更新到字典 dict 里。

dict1={'name':'zhang','sex':'female','age':11}
dict2={'time':123,'name':'xiao'}
dict1.update(dict2)
print(dict1)
print(dict2)

{'name': 'xiao', 'sex': 'female', 'age': 11, 'time': 123}
{'time': 123, 'name': 'xiao'}

练习题：

• 1、字典基本操作

字典内容如下:

dic = {
    'python': 95,
    'java': 99,
    'c': 100
    }

用程序解答下面的题目

• 字典的长度是多少
• 请修改’java’ 这个key对应的value值为98
• 删除 c 这个key
• 增加一个key-value对，key值为 php, value是90
• 获取所有的key值，存储在列表里
• 获取所有的value值，存储在列表里
• 判断 javascript 是否在字典中
• 获得字典里所有value 的和
• 获取字典里最大的value
• 获取字典里最小的value
• 字典 dic1 = {‘php’: 97}， 将dic1的数据更新到dic中

dic = {
    'python': 95,
    'java': 99,
    'c': 100
    }
#字典的长度是多少
print(len(dic))
#请修改'java' 这个key对应的value值为98
dic['java']=98
print(dic)
#删除 c 这个key
dic.pop('c')
print(dic)
#增加一个key-value对，key值为 php, value是90
dic.setdefault('php',90)
print(dic)
#获取所有的key值，存储在列表里
a=list(dic.keys())
print(a)
#获取所有的value值，存储在列表里
a=list(dic.values())
print(a)
#判断 javascript 是否在字典中
if 'javascript' in dic:
    print("javascript在字典中")
else:
    print("javascript不存在")
#获得字典里所有value 的和
print(sum(dic.values()))
#获取字典里最大的value
print(max(dic.values()))
#获取字典里最小的value
print(min(dic.values()))
#字典 dic1 = {'php': 97}， 将dic1的数据更新到dic中
dic1={'php':97}
dic.update(dic1)
print(dic)

3
{'python': 95, 'java': 98, 'c': 100}
{'python': 95, 'java': 98}
{'python': 95, 'java': 98, 'php': 90}
['python', 'java', 'php']
[95, 98, 90]
javascript不存在
283
98
90
{'python': 95, 'java': 98, 'php': 97}

• 2、字典中的value

有一个字典，保存的是学生各个编程语言的成绩，内容如下

data = {
        'python': {'上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{'月考':'90', '期中考试': '94', '期末考试': '98'}]
        }

各门课程的考试成绩存储方式并不相同，有的用字典，有的用列表，但是分数都是字符串类型，请实现函数transfer_score(score_dict)，将分数修改成int类型

   
def transfer_score(data):
    # your code here
    for i in list(data.values()):
        if isinstance(i,dict):
            #i.values()=int(list(i.values()))
            for j in int(i.keys()):
                i[j]=int(i[j])
        elif isinstance(i,list):
            i=int(i)
        else:
            i=int(i)

data1 = {
        'python': {'上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97']
        }
print(data1)
a=list(data1.values())
print(a[0]) 
print(isinstance(a[0],dict))
b=list(a[0].values())
print(b)
b=[int(i) for i in b]
print(b)
print(data1)

print(list(data1.values()))
for i in list(data.values()):
    if isinstance(i,dict):
    #i.values()=int(list(i.values()))
        for j in list(i.keys()):
            i[j]=int(i[j])

print(data1)
#print(transfer_score(data1))
            
            

{'python': {'上学期': '90', '下学期': '95'}, 'c++': ['95', '96', '97']}
{'上学期': '90', '下学期': '95'}
True
['90', '95']
[90, 95]
{'python': {'上学期': '90', '下学期': '95'}, 'c++': ['95', '96', '97']}
[{'上学期': '90', '下学期': '95'}, ['95', '96', '97']]
{'python': {'上学期': '90', '下学期': '95'}, 'c++': ['95', '96', '97']}

2 集合

Python 中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

注意，key为不可变类型，即可哈希的值。

num={}
print(num,type(num))
num={1,2,3,4}
print(num,type(num))

{} <class 'dict'>
{1, 2, 3, 4} <class 'set'>

2.1 集合的创建

• 先创建对象再加入元素。
• 在创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典。

set1=list()
print(set1,type(set1))
set1=set()
print(set1,type(set))
set1.add(1)
set1.add(2)
print(set1,type(set1))

[] <class 'list'>
set() <class 'type'>
{1, 2} <class 'set'>

• 直接把一堆元素用花括号括起来{元素1, 元素2, …, 元素n}。
• 重复元素在set中会被自动被过滤。

set1={'a',1,'apple',1,2,3,4,3,2}
print(set1,type(set1))

{1, 2, 3, 4, 'apple', 'a'} <class 'set'>

• 使用set(value)工厂函数，把列表或元组转换成集合。

a=[1,2,3]
print(a,type(a))
b=set(a)
print(b,type(b))

[1, 2, 3] <class 'list'>
{1, 2, 3} <class 'set'>

a='aabcdefg'
b=set(a)
print(b,type(b))

{'c', 'g', 'e', 'a', 'd', 'f', 'b'} <class 'set'>

a=[1,2,6,4,3,4,7,5,1]
b=[]
for i in a:
    if i not in b:
        b.append(i)
print(b)

d=set(a)
print(list(d))

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

从结果发现集合的两个特点：无序 (unordered) 和唯一 (unique)。

由于 set 存储的是无序集合，所以我们不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值，但是可以判断一个元素是否在集合中。

a={1,2,3,4,1}
print(a)
print(a[1])

{1, 2, 3, 4}



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

TypeError                                 Traceback (most recent call last)

<ipython-input-21-16f0d29b49ef> in <module>
      1 a={1,2,3,4,1}
      2 print(a)
----> 3 print(a[1])


TypeError: 'set' object is not subscriptable

2.2 访问集合中的值

• 可以使用len()內建函数得到集合的大小。

set1={1,2,3,4,1}
print(set1,type(set1))
print(len(set1))

{1, 2, 3, 4} <class 'set'>
4

• 可以使用for把集合中的数据一个个读取出来。

set1={1,2,3,4,5,6,5,4}
for i in set1:
    print(i)

1
2
3
4
5
6

• 可以通过in或not in判断一个元素是否在集合中已经存在

set1={1,2,3,2,1}
print(4 in set1)
print(1 not in set1)

False
False

2.3 集合的内置方法

• set.add(elmnt)用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

set1={1,2,3,2,5}
set1.add(5)
print(set1)
set1.add(7)
print(set1)

{1, 2, 3, 5}
{1, 2, 3, 5, 7}

• set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

set1={1,2,3,2}
set2={1,2,6,7,1}
set2.update(set1)
print(set2)
set2.update([5,6])
print(set2)

{1, 2, 3, 6, 7}
{1, 2, 3, 5, 6, 7}

• set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误。

set1={1,2,4,3}
set1.remove(1)
print(set1)

{2, 3, 4}

• set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

set1={1,2,3,4}
set1.discard(1)
print(set1)
set1.discard(5)
print(set1)

{2, 3, 4}
{2, 3, 4}

• set.pop() 用于随机移除一个元素。

set1={1,2,3,5}
a=set1.pop()
print(set1)
print(a)

{2, 3, 5}
1

由于 set 是无序和无重复元素的集合，所以两个或多个 set 可以做数学意义上的集合操作。

• set.intersection(set1, set2) 返回两个集合的交集。
• set1 & set2 返回两个集合的交集。
• set.intersection_update(set1, set2) 交集，在原始的集合上移除不重叠的元素。

set1={1,2,3,4}
set2={4,5,6,7}
print(set1&set2)
print(set.intersection(set1,set2))
print(set1)
print(set.intersection_update(set1,set2))#没有返回值。
print(set1)

{4}
{4}
{1, 2, 3, 4}
None
{4}

• set.union(set1, set2) 返回两个集合的并集。
• set1 | set2 返回两个集合的并集。

set1={1,2,3,4}
set2={4,5,6,7}
print(set1|set2)
print(set.union(set1,set2))

{1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7}

• set.difference(set) 返回集合的差集。
• set1 - set2 返回集合的差集。
• set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值。

set1={1,2,3,4,5}
set2={4,5,6,7}
print(set1.difference(set2))
print(set1-set2)
print(set1.difference_update(set2))#没有返回值。
print(set1)
print(set2)

{1, 2, 3}
{1, 2, 3}
None
{1, 2, 3}
{4, 5, 6, 7}

• set.symmetric_difference(set)返回集合的异或。
• set1 ^ set2 返回集合的异或。
• set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

set1={1,2,3,4,5}
set2={4,5,6,7}
print(set1^set2)
print(set1.symmetric_difference(set2))
print(set1.symmetric_difference_update(set2))#没有返回值。
print(set1)

{1, 2, 3, 6, 7}
{1, 2, 3, 6, 7}
None
{1, 2, 3, 6, 7}

• set.issubset(set)判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
• set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。

set1={1,2,3,4,5,6,7}
set2={4,5,6,7}
print(set2.issubset(set1))
print(set2<=set1)
print(set1.issubset(set2))
print(set1<=set2)

True
True
False
False

• set.issuperset(set)用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
• set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。

set1={1,2,3,4,5,6,7}
set2={4,5,6,7}
print(set2.issuperset(set1))
print(set2>=set1)
print(set1.issuperset(set2))
print(set1>=set1)

False
False
True
True

• set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

set1={1,2,3,4,5,6,7}
set2={4,5,6,7}
print(set1.isdisjoint(set2))
set3={1,2,3}
set4={7,8,9}
print(set3.isdisjoint(set4))

False
True

2.4 集合的转换

a=set(range(1,10,2))
print(a,type(a))
print(list(a),type(list(a)))
print(tuple(a),type(tuple(a)))

{1, 3, 5, 7, 9} <class 'set'>
[1, 3, 5, 7, 9] <class 'list'>
(1, 3, 5, 7, 9) <class 'tuple'>

2.5 不可变的集合

Python 提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫frozenset。需要注意的是frozenset仍然可以进行集合操作，只是不能用带有update的方法。

• frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

a=frozenset(range(1,10,2))
print(a,type(a))
a.update([1,2])

frozenset({1, 3, 5, 7, 9}) <class 'frozenset'>



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

AttributeError                            Traceback (most recent call last)

<ipython-input-58-cd79029c8da4> in <module>
      1 a=frozenset(range(1,10,2))
      2 print(a,type(a))
----> 3 a.update([1,2])


AttributeError: 'frozenset' object has no attribute 'update'

练习题：

1. 怎么表示只包含⼀个数字1的元组。

a=(1,)
print(a,type(a))

(1,) <class 'tuple'>

2. 创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。

a=set()
a.add('x')
a.add('y')
a.add('z')
print(a)         

{'z', 'y', 'x'}

3. 列表[‘A’, ‘B’, ‘A’, ‘B’]去重。

a=['A','B','A','B']
b=set(a)
print(list(b))

['A', 'B']

4. 求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素（差集指的是两个集合交集外的部分）。

a={6,7,8}
b={7,8,9}
print(a-b)
print(b-a)
print(a^b)

{6}
{9}
{9, 6}

5. 求{‘A’, ‘B’, ‘C’}中元素在 {‘B’, ‘C’, ‘D’}中出现的次数。

a={'A','B','C'}
b={'B','C','D'}
c=a&b
print(c)
print(len(c))

{'C', 'B'}
2

3 序列

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

3.1 针对序列的内置函数

• list(sub) 把一个可迭代对象转换为列表。

a=list()
print(a)
b=(1,2,3)
print(list(b))
c='awer'
print(list(c))

[]
[1, 2, 3]
['a', 'w', 'e', 'r']

• tuple(sub) 把一个可迭代对象转换为元组。

a=[1,2,3]
b={1,2,3}
c='123'
print(tuple(a))
print(tuple(b))
print(tuple(c))
print(tuple())

(1, 2, 3)
(1, 2, 3)
('1', '2', '3')
()

• str(obj) 把obj对象转换为字符串

a=str()
print(a)
b=1
print(str(b),type(str(b)))

1 <class 'str'>

• len(s) 返回对象（字符、列表、元组等）长度或元素个数。
• s – 对象。

a='12345awe'
b=[1,2,3,4,'e']
c=(1,2,3,'w')
d={1,2,3}
e={1:'w',2:'r'}
print(len(a))
print(len(b))
print(len(c))
print(len(d))
print(len(e))

8
5
4
3
2

• max(sub)返回序列或者参数集合中的最大值

a=[1,2,34,5,6,7]
print(max(a))

34

• min(sub)返回序列或参数集合中的最小值

a=[1,2,34,5,6,7]
print(min(a))

1

• sum(iterable[, start=0]) 返回序列iterable与可选参数start的总和。

a=[1,2,34,5,6,7]
print(sum(a))

55

• sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。
• iterable – 可迭代对象。
• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
• 返回重新排序的列表。

a=[1,2,34,5,6,7]
print(sorted(a))
print(sorted(a,reverse=True))

[1, 2, 5, 6, 7, 34]
[34, 7, 6, 5, 2, 1]

a=({'age':11,'name':'zhao'},{'age':12,'name':'wang'})
print(a)
b=sorted(a,key=lambda b:b['name'])
print(b)
print(a)

({'age': 11, 'name': 'zhao'}, {'age': 12, 'name': 'wang'})
[{'age': 12, 'name': 'wang'}, {'age': 11, 'name': 'zhao'}]
({'age': 11, 'name': 'zhao'}, {'age': 12, 'name': 'wang'})

• reversed(seq) 函数返回一个反转的迭代器。
• seq – 要转换的序列，可以是 tuple, string, list 或 range。

a=[1,2,34,5,6,7]
b=reversed(a)
print(b,type(b))
print(list(b),type(list(b)))
print(a)

<list_reverseiterator object at 0x0000029BE8439AC8> <class 'list_reverseiterator'>
[7, 6, 5, 34, 2, 1] <class 'list'>
[1, 2, 34, 5, 6, 7]

• enumerate(sequence, [start=0])用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

a=['a','c','d']
b=list(enumerate(a))
print(b)
c=list(enumerate(a,1))
print(c)
for i,j in c:
    print(i,j)

[(0, 'a'), (1, 'c'), (2, 'd')]
[(1, 'a'), (2, 'c'), (3, 'd')]
1 a
2 c
3 d

• zip(iter1 [,iter2 […]])
• 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
• 我们可以使用 list() 转换来输出列表。
• 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a=[1,2,3]
b=[4,5,6]
c=[7,8,9,1]
print(list(zip(a,b)))
print(list(zip(a,c)))
a1,a2=zip(*zip(a,b))
print(list(a1),list(a2))

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

练习题：

1. 怎么找出序列中的最⼤、⼩值？

a=[1,4,5,3,8,7,5]
print(max(a))
print(min(a))

8
1

2. sort() 和 sorted() 区别

区别：

• 1、sort()只能应用在列表list上，而sorted可以对所有可迭代的对象进行排序的操作
• 2、sort方法会在原list上直接进行排序，不会创建新的list。而sorted方法不会对原来的数据做任何改动，排序后的结果是新生成的。如果我们不需要原来的数据而且数据是list类型，可以用sort方法，能够节省空间。否则要用sorted方法。

3. 怎么快速求 1 到 100 所有整数相加之和？

a=sum(range(1,100))
print(a)

4950

4. 求列表 [2,3,4,5] 中每个元素的立方根。

"""
ans:立方根 y:搜索值 hight:值域上界 lower:值域下界 epsilion:精确度 num:步长
二分查找，搜索立方根，使用while循环实现查找域(ans，abs(y))
平方根位于 (-1，1)区间时，查找值域不在搜索上界 (ans，y)内，
故需要手动提高上界
"""

ans = 0.0
y = -8000990 #求取
num = 0 #记录步长
hight = max(abs(y),1) #比对y与1，确定上界
lower = ans
epsilion  = 0.001 #精确度
while abs(ans**3 - abs(y)) > epsilion and ans <= max(abs(y),1):
    if ans**3 > abs(y):
        hight = ans
    else:
        lower = ans
    print(ans)
    ans = (hight + lower)/2
    num += 1
if abs(ans**3 - abs(y)) > epsilion:
    print('It not variables!')
if y < 0:
    ans = -ans
print(num)
print(ans)

0.0
4000495.0
2000247.5
1000123.75
500061.875
250030.9375
125015.46875
62507.734375
31253.8671875
15626.93359375
7813.466796875
3906.7333984375
1953.36669921875
976.683349609375
488.3416748046875
244.17083740234375
122.08541870117188
183.1281280517578
213.64948272705078
198.3888053894043
206.01914405822754
202.20397472381592
200.2963900566101
199.3425977230072
199.81949388980865
200.05794197320938
199.93871793150902
199.9983299523592
200.0281359627843
200.01323295757174
200.00578145496547
200.0095072062686
200.00764433061704
200.00857576844282
200.00811004952993
200.00834290898638
200.00822647925816
200.00828469412227
200.0082555866902
200.00824103297418
200.0082483098322
200.0082519482612
200.0082501290467
200.00824921943945
200.00824967424307
200.00824944684126
200.00824956054217
200.0082496173926
200.00824964581784
49
-200.00824966003046

def square3(x):
higher=x
lower=1
step=
    return

a=[2,3,4,5]
for i in a:
    print(square2(i))

5. 将[‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式。

a=['x','y','z']
b=[1,2,3]
c=list(zip(a,b))
print(c)

[('x', 1), ('y', 2), ('z', 3)]