Python学习笔记5：字典、集合、序列

最新推荐文章于 2024-09-14 08:25:16 发布
最新推荐文章于 2024-09-14 08:25:16 发布
阅读量324 收藏
点赞数
分类专栏： Python 文章标签： python 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/evenw_/article/details/107700306
版权

字典、集合、序列

可变类型与不可变类型

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

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

  • 用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。
  • 用 hash(X)，只要不报错，证明 X 可被哈希，即不可变，反过来不可被哈希，即可变。
a=2
print(id(a))
# 140708864382016
a=a+1
print(id(a))
# 140708864382048

l=[1,2,3,4,5]
print(id(l))
# 2283131856328
l.remove(2)
print(id(l))
# 2283131856328
  • 整数a在加 1 之后的 id 变了，因此整数是不可变类型。
  • 列表 l 在删除 2 之后的 id 不变，因此列表是可变类型。
print(hash(5))
# 5
print(hash('hello'))
# -1588137811634571395
print(hash((1,2,3,'a')))
# 1145584121287932706
print(hash([1,2,3,4,5]))
# Traceback (most recent call last):
#   File "<pyshell#12>", line 1, in <module>
#     print(hash([1,2,3,4,5]))
# TypeError: unhashable type: 'list'
print(hash({1,2,3,4,5}))
# Traceback (most recent call last):
#   File "<pyshell#13>", line 1, in <module>
 #    print(hash({1,2,3,4,5}))
# TypeError: unhashable type: 'set'
print(hash({1:'a',2:'b',3:'c'}))
# Traceback (most recent call last):
#   File "<pyshell#16>", line 1, in <module>
#     print(hash({1:'a',2:'b',3:'c'}))
# TypeError: unhashable type: 'dict'
  • 数值、字符和元组 都能被哈希，因此它们是不可变类型。
  • 列表、集合、字典不能被哈希，因此它是可变类型。

一、字典

字典：无序的 键:值（key:value）对集合，键必须是唯一的（在同一个字典之内）。
d = {key1 : value1, key2 : value2 }

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

1.创建和访问

  • 通过字符串或数值作为key来创建字典
dic = {'李宁': '一切皆有可能', '耐克': 'Just do it', '阿迪达斯': 'Impossible is nothing'}
print('耐克的口号是:', dic['耐克'])  
# 耐克的口号是: Just do it

dic1 = {1: 'one', 2: 'two', 3: 'three'}
print(dic1)  
# {1: 'one', 2: 'two', 3: 'three'}
print(dic1[1])  
# one
print(dic1[4])  
# KeyError: 4

如果我们取的键在字典中不存在，会直接报错KeyError。

  • 通过元组作为key来创建字典，但一般不这样使用
dic = {(1, 2, 3): "Tom", "Age": 12, 3: [3, 5, 7]}
print(dic,type(dic))
# {(1, 2, 3): 'Tom', 'Age': 12, 3: [4, 5, 6]} <class 'dict'>
  • 通过构造函数dict()来创建字典
    通过key直接把数据放入字典中，但一个key只能对应一个value，多次对一个key放入 value，后面的值会覆盖前面的值。
dic = dict()
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3

print(dic)
# {'a': 1, 'b': 2, 'c': 3}

dic['a'] = 11
print(dic)
# {'a': 11, 'b': 2, 'c': 3}

dic['d'] = 4
print(dic)
# {'a': 11, 'b': 2, 'c': 3, 'd': 4}

dict(mapping) new dictionary initialized from a mapping object’s (key, value) pairs

dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
print(dic1)  
# {'cherry': 4098, 'apple': 4139, 'peach': 4127}

dic2 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2) 
 # {'peach': 4127, 'cherry': 4098, 'apple': 4139}

dict(**kwargs) new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)
这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上就会直接报语法错误。

dic = dict(name='Tom', age=10)
print(dic,type(dic))  
# {'name': 'Tom', 'age': 10} <class 'dict'>

2.字典的内置方法

  • dict.fromkeys(seq[, value]) 用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
seq = ('name', 'age', 'sex')
dic1 = dict.fromkeys(seq)
print(dic1)
# {'name': None, 'age': None, 'sex': None}

dic2 = dict.fromkeys(seq, 10)
print(dic2)
# {'name': 10, 'age': 10, 'sex': 10}

dic3 = dict.fromkeys(seq, ('小明', '10', '男'))
print(dic3)
# {'name': ('小明', '10', '男'), 'age': ('小明', '10', '男'), 'sex': ('小明', '10', '男')}
  • dict.keys()返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键。
  • dict.values()返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
  • dict.items()以列表返回可遍历的 (键, 值) 元组数组。
dic = {'Name': '小明', 'Age': 10}
print(dic.keys())  
# dict_keys(['Name', 'Age'])
lst = list(dic.keys())  
# 转换为列表
print(lst)  
# ['Name', 'Age']

print(dic.values())
# dict_values(['小明', 10])
lst=list(dic.values())
print(lst)
# ['小明', 10]

print(dic.items())
# dict_items([('Name', '小明'), ('Age', 10)])
print(list(dic.items()))
# [('Name', '小明'), ('Age', 10)]
print(tuple(dic.items()))
# (('Name', '小明'), ('Age', 10))
  • dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回默认值。
  • dict.setdefault(key, default=None)和get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
dic={'Name':'小明','Age':10,'Sex':'男'}
print(dic.get('Age'))
# 10
print(dic.get('School'))
# None

print(dic.setdefault('Name',None))
# 小明
print(dic.setdefault('School',None))
# None
print(dic)
# {'Name': '小明', 'Age': 10, 'Sex': '男', 'School': None
  • key in dict、key not in dict：判断键是否存在于字典中。
dic={'Name':'小明','Age':10,'Sex':'男','School': None}
print('Name' in dic)
# True
print('weight' in dic)
# False
print('Age' not in dic)
# False
  • dict.pop(key[,default])删除字典给定键 key 所对应的值，并返回被删除的值。key 值必须给出，若key不存在，则返回 default值。
  • del dict[key] 删除字典给定键 key 所对应的值。
  • dict.popitem()随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常。
  • dict.clear() 删除字典内所有元素。
dic={'Name':'小明','Age':10,'Sex':'男','School': None}
print(dic.pop('School'))
# None
print(dic)
# {'Name': '小明', 'Age': 10, 'Sex': '男'}
print(dic.pop('Weight'))
# Traceback (most recent call last):
#   File "<pyshell#23>", line 1, in <module>
#     print(dic.pop('Weight'))
# KeyError: 'Weight'

del dic['Age']
print(dic)
# {'Name': '小明', 'Sex': '男'}

print(dic.popitem())
# ('Sex', '男')
print(dic)
# {'Name': '小明'}

print(dic.clear())
# None
print(dic.popitem())
# Traceback (most recent call last):
#   File "<pyshell#30>", line 1, in <module>
#     print(dic.popitem())
# KeyError: 'popitem(): dictionary is empty'
  • dict.copy()返回一个字典的浅拷贝
dic={'Name': '小明', 'Age': 10, 'Sex': '男'}
dic1=dic.copy()
print(dic1)
# {'Name': '小明', 'Age': 10, 'Sex': '男'}

直接赋值和浅拷贝

dic={'Name': '小明', 'Age': 10, 'Sex': '男'}
dic1=dic.copy()
dic2=dic
print(id(dic))      # 2292380500256
print(id(dic1))     # 2292381296752
print(id(dic2))     # 2292380500256
dic['Age']=11
print(dic)
# {'Name': '小明', 'Age': 11, 'Sex': '男'}
print(dic1)
# {'Name': '小明', 'Age': 10, 'Sex': '男'}
print(dic2)
# {'Name': '小明', 'Age': 11, 'Sex': '男'}
  • dict.update(dict2)把字典参数 dict2 的key:value对 更新到字典 dict 里。
dic={'Name': '小明', 'Age': 10, 'Sex': '男'}
dic2={'Weight':40}
dic.update(dic2)
print(dic)
# {'Name': '小明', 'Age': 10, 'Sex': '男', 'Weight': 40}

练习题

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中
print(len(dic))
# 3

dic['java']=98
print(dic)
# {'python': 95, 'java': 98, 'c': 100}

print(dic.pop('c'))
# 100
print(dic)
# {'python': 95, 'java': 98}

dic1={'php':90}
dic.update(dic1)
print(dic)
# {'python': 95, 'java': 98, 'php': 90}

lst=list(dic.keys())
print(lst)
# ['python', 'java', 'php']

lst=list(dic.values())
print(lst)
# [95, 98, 90]

print('javascript' in dic)
# False
print(sum(dic.values()))
# 283

print('javascript' in dic)
# False

print(sum(dic.values()))
# 283

print(max(dic.values()))
# 98

print(min(dic.values()))
# 90

dic1={'php':97}
dic.update(dic1)
print(dic)
# {'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):
    lst=list(data.keys())
    for i in lst:
        v=data.get(i)
        if isinstance(v,dict):
            transfer_score(v)
        if isinstance(v,list):
            n=0
            for k in v:
                if isinstance(k,dict):
                    transfer_score(k)
                if isinstance(k,str):
                    data[i][n]=int(k)
                    n=n+1
        if isinstance(v,str):
            data[i]=int(v)

transfer_score(data)
print(data)

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

二、集合

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

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

num = {}
print(type(num))  
# <class 'dict'>
num = {1, 2, 3, 4}
print(type(num))  
# <class 'set'>

1.创建

  • 先创建对象再加入元素。
  • 在创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典。
basket = set()
basket.add('apple')
basket.add('banana')
print(basket)  
# {'banana', 'apple'}
  • 直接把所有元素用花括号括起来{元素1, 元素2, ..., 元素n}。
  • 重复元素在set中会被自动被过滤。
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)  
# {'banana', 'apple', 'pear', 'orange'}

# 去掉列表中重复的元素
lst=[1,2,3,4,5,2,3]
x=set(lst)
lst1=list(x)
print(lst1)
# [1, 2, 3, 4, 5]
  • 使用set(value)工厂函数，把列表或元组转换成集合。
a=set('agergvdvrbbgt')
print(a)
# {'t', 'd', 'r', 'a', 'v', 'e', 'g', 'b'}
x=set(('a','b','c'))
print(x)
# {'a', 'b', 'c'}
x=set(['a','b','c'])
print(x)
# {'a', 'b', 'c'}

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

2.访问

  • len()返回集合的大小
s=set([1,2,3,4,5,6])
print(len(s))
# 6

# 把集合中的数据一个个读取出来。
for i in s:
	print(i)	
# 1
# 2
# 3
# 4
# 5
# 6
  • in或not in判断一个元素在集合中是否存在
print('d' in s)
# False
print('a' not in s)
# False

3.集合的内置方法

  • set.add(elmnt)用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。
fruits = {"apple", "banana", "cherry"}
fruits.add("orange")
print(fruits)  
# {'orange', 'cherry', 'banana', 'apple'}
fruits.add("apple")
print(fruits)  
# {'orange', 'cherry', 'banana', 'apple'}
  • set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。
x={"apple", "banana", "cherry"}
y={"pear","peach","banana"}
x.update(y)
print(x)
# {'banana', 'cherry', 'pear', 'peach', 'apple'}
  • set.remove(item) 用于移除集合中的指定元素。如果元素不存在，则会发生错误。
  • set.discard(value) 用于移除指定的集合元素。如果元素不存在，则不执行任何操作。
x={"apple", "banana", "cherry"}
x.remove("cherry")
print(x)
# {'banana', 'apple'}
x.remove("cheryy")
# Traceback (most recent call last):
#   File "<pyshell#35>", line 1, in <module>
#     x.remove("cheryy")
# KeyError: 'cheryy'

x.discard("apple")
print(x)
# {'banana'}
x.discard("apple")
print(x)
# {'banana'}
  • set.pop() 用于随机移除一个元素，并返回该元素。
fruits = {"apple", "banana", "cherry"}
x = fruits.pop()
print(x)  
# banana
print(fruits)  
# {'cherry', 'apple'}

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

  • set1.intersection(set2) 返回两个集合的交集。
  • set1 & set2 返回两个集合的交集。
  • set1.intersection_update(set2) 交集，在原始的集合上移除不重叠的元素。
x=set('pear')
y=set('peach')
print(x)
# {'r', 'a', 'e', 'p'}
print(y)
# {'a', 'e', 'c', 'h', 'p'}

print(x.intersection(y))
# {'a', 'e', 'p'}
print(x & y)
# {'a', 'e', 'p'}
x.intersection_update(y)
print(x)
# {'a', 'e', 'p'}
  • set1.union(set2) 返回两个集合的并集。
  • set1 | set2 返回两个集合的并集。
x=set('pear')
y=set('peach')
print(x)
# {'r', 'a', 'e', 'p'}
print(y)
# {'a', 'e', 'c', 'h', 'p'}

print(x.union(y))
# {'r', 'a', 'e', 'c', 'h', 'p'}
print(x | y)
# {'r', 'a', 'e', 'c', 'h', 'p'}
  • set.difference(set) 返回集合的差集。
  • set1 - set2 返回集合的差集。
  • set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值。
x=set("pear")
y=set("peach")
print(x)
# {'r', 'a', 'e', 'p'}
print(y)
# {'a', 'e', 'c', 'h', 'p'}

print(x.difference(y))
# {'r'}
print(x-y)
# {'r'}
x.difference_update(y)
print(x)
# {'r'}
  • set1.symmetric_difference(set2)返回集合的异或。
  • set1 ^ set2 返回集合的异或。
  • set1.symmetric_difference_update(set2)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
x=set("pear")
y=set("peach")
print(x)
# {'r', 'a', 'e', 'p'}
print(y)
# {'a', 'e', 'c', 'h', 'p'}
print(x.symmetric_difference(y))
# {'c', 'h', 'r'}
print(x^y)
# {'c', 'h', 'r'}
x.symmetric_difference_update(y)
print(x)
# {'c', 'h', 'r'}
  • set1.issubset(set2)判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
  • set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
  • set1.issuperset(set2)用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
  • set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
x={"a","b","c"}
y={"a","b","c","d","e","f"}
print(x.issubset(y))
# True
print(x<=y)
# True

print(y.issuperset(x))
# True
print(y>=x)
# True
  • set1.isdisjoint(set2) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。
x={'a','b','c'}
y={'e','f','g'}
print(x.isdisjoint(y))
# True
z={'a','e','f','g'}
print(x.isdisjoint(z))
# False

4.集合的转换

se = set(range(4))
li = list(se)
tu = tuple(se)

print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>

5.不可变集合

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

  • frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
x=frozenset([1,2,3,4,5])
print(x)
# frozenset({1, 2, 3, 4, 5})
x.remove(2)
# Traceback (most recent call last):
#   File "<pyshell#133>", line 1, in <module>
#     x.remove(2)
# AttributeError: 'frozenset' object has no attribute 'remove'
x.update(6)
# Traceback (most recent call last):
#   File "<pyshell#134>", line 1, in <module>
#     x.update(6)
# AttributeError: 'frozenset' object has no attribute 'update'

练习题

  1. 怎么表示只包含⼀个数字1的元组。
t=(1,)
print(t,type(t))
# (1,) <class 'tuple'>
  1. 创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。
s=set()
s.add('x')
s.add('y')
s.add('z')
print(s)
# {'y', 'x', 'z'}
  1. 列表[‘A’, ‘B’, ‘A’, ‘B’]去重。
lst=['A','B','A','B']
lst=list(set(lst))
pprint(lst)
# ['A', 'B']
  1. 求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素（差集指的是两个集合交集外的部分）。
s1=set([6,7,8])
s2=set([7,8,9])
print(s1.symmetric_difference(s2))
# {9, 6}
  1. 求{‘A’, ‘B’, ‘C’}中元素在 {‘B’, ‘C’, ‘D’}中出现的次数。
s1={'A','B','C'}
s2={'B','C','D'}
for i in s1:
    if i in s2:
        print(i,'出现次数：1')

# B 出现次数：1
# C 出现次数：1
# (集合的元素是无序、不重复的）

三、序列

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

1.序列的内置函数

  • list(sub) 把一个可迭代对象转换为列表。
  • tuple(sub) 把一个可迭代对象转换为元组。
  • str(obj)把obj对象转换为字符串。
s={1,3,5,7,9}
s1=list(s)
print(s1,type(s1))       # [1, 3, 5, 7, 9] <class 'list'>

s2=tuple(s)
print(s2,type(s2))       # (1, 3, 5, 7, 9) <class 'tuple'>

s3=str(s)
print(s3,type(s3))       # {1, 3, 5, 7, 9} <class 'str'>
  • len(s)返回对象（字符、列表、元组等）长度或元素个数。
  • max(sub)返回序列或者参数集合中的最大值。
  • min(sub)返回序列或者参数集合中的最小值。
  • sum(iterable[, start=0]) 返回序列iterable与可选参数start的总和。
  • reversed(seq) 函数返回一个反转的迭代器。要转换的序列，可以是 tuple, string, list 或 range。
s=[1,3,5,7,9]
print(len(s))
# 5
print(max(s))
# 9
print(min(s))
# 1
 print(sum(s[1:4]))
# 15

x=reversed(s)
print(list(x))
# [9, 7, 5, 3, 1]
  • sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作,并返回重新排序的列表。
  1. iterable ：可迭代对象。
  2. key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  3. reverse ：排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
x=[1,5,8,12,3,6,9,11,25]
print(sorted(x))
# [1, 3, 5, 6, 8, 9, 11, 12, 25]
print(sorted(x,reverse=True))
# [25, 12, 11, 9, 8, 6, 5, 3, 1]

x=[('Age', 15),('Age',70),('Age',20)]
x2=sorted(x,key=lambda x:x[1])
print(x2)
# [('Age', 15), ('Age', 20), ('Age', 70)]
  • enumerate(sequence, [start=0])用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
fruits=['apple','pear','peach','orange']
for i in enumerate(fruits,1):
	print(i)
# (1, 'apple')
# (2, 'pear')
# (3, 'peach')
# (4, 'orange')
  • zip(iter1 [,iter2 [...]])
    1.用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
    2.可以使用 list() 转换来输出列表。
    3.如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
x=[1,2,3]
y=[4,5,6]
z=[1,2,3,4,5]
t=zip(x,y)
print(t)
# <zip object at 0x000001FD3765A948>
print(list(t))
# [(1, 4), (2, 5), (3, 6)]

t=zip(x,z)
print(list(t))
# [(1, 1), (2, 2), (3, 3)]

a,b=zip(*zip(x,y))
print(list(a))
# [1, 2, 3]
print(list(b))
# [4, 5, 6]

练习题

  1. 怎么找出序列中的最⼤、⼩值？
    max()、min()函数
  2. sort() 和 sorted() 区别
  • sort() 是应用在list上的方法，属于列表的成员方法，sorted() 可以对所有可迭代的对象进行排序操作。
  • sort() 方法会在原list上直接进行排序，不会创建新的list。而sorted()方法不会对原来的数据做任何改动，排序后的结果是新生成的。
  • sort()使用方法为list.sort()，而sorted()使用方法为sorted(obj)
  1. 怎么快速求 1 到 100 所有整数相加之和？
print(sum(range(101)))
# 5050
  1. 求列表 [2,3,4,5] 中每个元素的立方根。
x=[2,3,4,5]
>>> for i in x:
	print(i,'的立方根:',pow(i,3))
# 2 的立方根: 8
# 3 的立方根: 27
# 4 的立方根: 64
# 5 的立方根: 125
  1. 将[‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式。
a=['x','y','z']
b=[1,2,3]
c=zip(a,b)
print(list(c))
# [('x', 1), ('y', 2), ('z', 3)]
evenw_
关注
专栏目录
字典、集合 、序列
weixin_49485675的博客
07-31 1083
字典、集合 、序列 一、字典 可变类型与不可变类型 1.序列是以连续的整数为索引，与此不同的是，字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值。 2.字典是 Python 唯一的一个 映射类型，字符串、元组、列表属于序列类型。 判断一个数据类型 X 是不是可变类型？ 方法一： 麻烦方法：用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。 方法二： 便捷方法：用 hash(X)，只要不报错，证明 X 可被哈希，即不可
【学习笔记】python-字典、集合和序列
weixin_43869610的博客
07-28 110
字典 dict.fromkeys(seq[, value]) 用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。 seq = ('name', 'age', 'sex') dic1 = dict.fromkeys(seq) print("新的字典为 : %s" % str(dic1)) # 新的字典为 : {'name': None, 'age': None, 'sex': None} dic2 = dict.fromkeys(seq, 10) print("
序列——字典、集合
pitaohhh的博客
07-04 124
字典、集合
Python——字典与集合的基本使用
weixin_45054387的博客
04-13 454
字典的概述： 字典是一个无序的，可以修改的，元素呈键值对的形式，以逗号分割的，以大括号包围的数据类型； 字典和列表一样，可以存储多个数据，但是字典中的值并没有什么特殊顺序；列表中，查找某个元素时，是通过下标进行的，但是如果下标很多，查找元素不方便，这时就需要用到字典。 字典的每个元素由两部分组成，键:值。例如：‘name’:‘hu’ , name为键，hu为值。 字典是Python基础数据类...
Python基础-字典、集合、序列
qq_42722145的博客
07-31 184
一、字典 1.1 字典的定义 字典 是无序的 键:值（key:value）对集合，键必须是互不相同的（在同一个字典之内）。 dict 内部存放的顺序和 key 放入的顺序是没有关系的。 dict 查找和插入的速度极快，不会随着 key 的增加而增加，但是需要占用大量的内存。 字典 定义语法为 {元素1, 元素2, …, 元素n} 其中每一个元素是一个「键值对」-- 键:值 (key:value) 关键点是「大括号 {}」,「逗号 ,」和「冒号 :」 大括号 – 把所有元素绑在一起 逗号 – 将每个键值对
Python学习：字典、集合、序列
weixin_44041479的博客
07-31 187
字典 1.可变类型与不可变类型 序列是以连续的整数为索引，与此不同的是，字典以“关键字”为索引，关键字可以是任意不可变类型，通常用字符串或数值。 字典是Python唯一的一个映射类型，字符串、元组、列表属于序列类型。 如何快速判断一个数据类型 X 是不是可变类型的呢？ 麻烦方法：用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。 便捷方法：用 hash(X)，只要不报错，证明 X 可被哈希，即不可变，反过来不可被哈希，即可变。
【python学习】字典、集合和序列
love_fish_eat的博客
07-31 703
一、字典 字典可以理解为一种映射，类似C++中STL模板里的map。 比如整形数组建立了一种从数字到数字的映射，字符串数组建立了一种从数字到字符串的映射。 而字典则可建立更广泛的映射。比如可以建立字符串到数字的映射、元祖到字符串的映射。 映射中有一对关键概念，即：键（key）与值（value），其中键用来索引，值就是存储的对象。例如，字符串数组的键是数字，值就是字符串。这一对键值以二元组（key，value）的形式构成了字典的基本元素。在python里，需要注意的是，键只能是数字、字符串或元祖等不可变类型，
python学习笔记：字典的使用示例详解
01-21
经典字典使用函数dict：通过其他映射（比如其他字典）或者（键，值）这样的序列对建立字典。当然dict成为函数不是十分确切，它本质是一种类型。如同list。 复制代码 代码如下:items=[(‘name’,’zhang’),(‘age’,...
python学习笔记之数组，集合，列表,字典的区别和应用（一）
01-20
任意对象的有序集合。列表是一组任意类型的值，按照一定顺序组合而成的。组成列表的值叫做元素(Elements)。每一个元素被标识一个索引，第一个索引是0，序列的功能都能实现。 特点：可重复，类型可不同。 运用方法 ...
Python学习笔记：集合数据类型
Rumou的博客
03-17 2203
Python学习笔记：集合数据类型。包括列表，元组，集合，字典
Python列表、元祖、字典、集合学习笔记文档（附Python源码）
07-25
在 Python 编程中，我们既需要独立的变量来保存一份数据，也需要序列来保存大量数据。 列表（list）和元组（tuple）比较相似，...本资源是我在学习Python时，记录的列表、元祖、字典、集合学习笔记，供大家参考学习。
python学习笔记
12-17
在Python学习笔记中，我们主要探讨以下几个核心知识点： 1. **数据类型与数据结构** Python支持多种数据类型，包括基本的整型、浮点型、字符串等。其中，数据结构是Python的一大特色，特别是容器类型。容器可以...
Python基础学习——序列、集合和字典（下篇）
m0_61906853的博客
10-03 336
Python基础学习——序列、集合和字典（下篇）
Python学习 Task5：字典、集合和序列
chutu2018的博客
07-25 442
Task5：字典、集合和序列1、字典1.1 访问字典1.2 修改字典1.3 删除字典元素1.4 字典的内置函数1.5 字典的内置方法2 集合2.1 1、字典 序列是以连续的整数为索引，而字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值。字典是 Python 唯一的一个 映射类型，字符串、元组、列表属于序列类型。字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,
python 嵌套数组_python列表、元组、字典的区别
weixin_39519798的博客
11-20 994
一、列表 1任意对象的有序集合列表是一组任意类型的值，按照一定顺序组合而成的2通过偏移读取组成列表的值叫做元素(Elements)。每一个元素被标识一个索引，第一个索引是0，序列的功能都能实现3可变长度，异构以及任意嵌套列表中的元素可以是任意类型，甚至是列表类型，也就是说列表可以嵌套4可变的序列支持索引、切片、合并、删除等等操作，它们都是在原处进行修改列表5对象引用数组列...
字典 集合及序列
QSC24的博客
07-31 376
1、字典 字典 是无序的 键:值（key:value）对集合，键必须是互不相同的（在同一个字典之内）。 dict 内部存放的顺序和 key 放入的顺序是没有关系的。 dict 查找和插入的速度极快，不会随着 key 的增加而增加，但是需要占用大量的内存。 字典 定义语法为 {元素1, 元素2, …, 元素n} 其中每一个元素是一个「键值对」-- 键:值 (key:value) 关键点是「大括号 {}」,「逗号 ,」和「冒号 :」 大括号 – 把所有元素绑在一起 逗号 – 将每个键值对分开 冒号 – 将键和值
第7章 字典
moving
11-25 902
本文主要介绍了如下内容：        1、创建        2、索引和赋值        3、运算符            3.1 集合操作            3.2 字典方法        4、Python指针：使用zip创建字典         字典是一种集合，但它不是序列。字典经常被视为映射集合，有时又被视为关
字典、集合和序列
csdnshenjiaye的博客
07-31 1654
字典 1. 可变类型与不可变类型 序列是以连续的整数为索引，与此不同的是，字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值。 字典是 Python 唯一的一个 映射类型，字符串、元组、列表属于序列类型。 那么如何快速判断一个数据类型X是不是可变类型的呢？两种方法： 麻烦方法：用id(X)函数，对 X 进行某种操作，比较操作前后的id，如果不一样，则X不可变，如果一样，则X可变。 便捷方法：用hash(X)，只要不报错，证明X可被哈希，即不可变，反过来不...
Python办公自动化案例（二）：对比两个Excel数据内容并标出不同
最新发布
衍生星球的博客
09-14 512
在数据处理和分析的日常工作中，我们经常需要比较两个Excel文件的差异。这可能是为了验证数据的一致性、检查数据的准确性，或者在版本控制中追踪更改。手动比较这些文件不仅耗时，而且容易出错。幸运的是，Python的openpyxl库提供了一种自动化这一过程的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值