java的for循环取出数据只是拿到最后一个_python数据类型（字符串，列表已单独成两篇文章）...

96 阅读 0 评论 64 点赞

我是靠谱客的博主满意指甲油，这篇文章主要介绍java的for循环取出数据只是拿到最后一个_python数据类型（字符串，列表已单独成两篇文章）...，现在分享给大家，希望可以做个参考。

数据存储

运算符

常用及不常用函数

len（）

复制代码

1
2
字符串

复制代码

1
2
3
4
5
6
7
8
9
10
11
列表
list = [10, 20, 30, 40]
print(min(list))    # 10

# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):        # for i in range(10)
    print(i)

# 1 3 5 7 9
for i in range（1，10， 2）
    print（i）

enumerate(可遍历对象， start=0）

注：start参数用来设置遍历数据的下标和起始值，默认为0

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
list = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list, start=1):
    print(i)


运行结果
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
(5, 'e')


e·g：
list = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list):
    print(i)
for index, char in enumerate(list, start=1):
    print(f'下标是{index},对应的字符是{char}')


运行结果
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
下标是1,对应的字符是a
下标是2,对应的字符是b
下标是3,对应的字符是c
下标是4,对应的字符是d
下标是5,对应的字符是e

元组

复制代码

1
2
tuple = (2, )
元组必须有逗号

变量名[索引]

复制代码

1
tuple

元组可以遍历

元组的查询

复制代码

1
2
查询数字1有多少个

可变类型和不可变类型

可变类型：列表，集合，字典，对象

不可变类型：数值，字符串，布尔，元组

内存地址未改变说明是可变类型

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
list1 = [1, 2, 3]
print(id(list1))
tuple = (1, 2, 3)
print(id(tuple))
list1.append(4)
print(id(list1))
tuple = (1, 2, 3, 4)
print(id(tuple))

运行结果
225 381 644 6664          
225 381 824 4480
225 381 644 6664        
225 381 827 4664

1,3行相同地址

元组与列表互相转换

列表转元组

复制代码

1
tuple = tuple(list1)

元组转列表

复制代码

1
list1 = list1(tuple)

字典

字典是使用名称与实体 —— 对应数据存储机制

名称：键（key）—— 唯一

实体：值（value）—— 不限制

字典就是名称实体对，简称键值对

创建格式：

变量名 = {键1：值1，键2：值2.。。。。}

字典没有索引的概念，通过‘键’去寻找

取单个数据

复制代码

1
dict["b"]

如果键名存在，则修改数据，如果键名不存在，则在字典鄂最后添加新的键值对

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 键名存在
dict = {"a":"a1", "b":"b1"}
dict["a"] = "a2"
print(dict)


运行结果
{"a":"a2", "b":"b1"}

# 键名不存在
dict = {"a":"a1", "b":"b1"}
dict["c"] = "c1"
print(dict)


运行结果
{"a":"a2", "b":"b1", "c":"c1"}

字典的数据调用格式

使用字典数据：

变量名[键]

修改/添加字典数据：

变量名[键] = 值

字典遍历

复制代码

1
2
3
4
5
6
7
8
9
dict = {"a":"a1", "b":"b1"}
for i in dict:
    print(i, end = ":")
    print(dict[i])


运行结果
a: a1
b: b1

注：使用for循环迭代字典取出的是键key，再根据键key取出对应的值value。

复制代码

1
2
3
4
5
6
7
8
9
dict1 = {"a": "a1", "b": "b1"}
for i in dict1:
    print(i, end = ":")
    print(dict1[i])


运行结果
a: a1
b: b1

即使键名不存在，也会返回None，不会报错影响程序的执行

复制代码

1
2
3
4
5
6
dict1 = {"a": "a1", "b":"b1"}
print(dict1.get("d")


运行结果
None

pop去删除指定的键值对，拿到该键值对的值

复制代码

1
2
3
4
5
6
7
8
9
dict1 = {"a": "a1", "b":"b1"}
a = dict1.pop("a")
print(a)
print(dict1)


运行结果
a1
{"b":"b1"}

popitem删除字典中最后一个键值对，将他们数据拿到

复制代码

1
2
3
4
5
6
7
8
9
dict1 = {"a": "a1", "b":"b1"}
b = dict1.popitem()
print(b)
print(dict1)


运行结果
("b":"b1")
{"a": "a1"}

添加

复制代码

1
2
3
4
5
6
7
dict1 = {"a": "a1", "b":"b1"}
dict1["d"] = "d1"
print(dict1)


运行结果
{"a": "a1", "b":"b1", "d": "d1"}

添加键值对，如果键名存在，而是作为无效的方式存在

键名不存在，则在最后添加键值对信息

复制代码

1
2
dict1.setdefault("d", "d1")
print(dict1)

键名存在视为无效，不会报错

复制代码

1
2
dict1.setdefault("a", "a2")
print(dict1)

添加一个字典到另一个字典

复制代码

1
2
3
4
5
6
7
8
dict1 = {"a": "a1"}
dict2 = {"b": "b1"}
dict1.update(dict2)
print(dict1)


运行结果
{"a": "a1", "b": "b1"}

键名相同会修改原有的value值

复制代码

1
2
3
4
5
6
7
8
dict1 = {"a": "a1"}
dict2 = {"a": "a2", "b":"b1"}
dict1.update(dict2)
print(dict)


运行结果
{"a": "a2", "b":"b1"}

keys()可以拿到一个列表，列表里是所有的键名

复制代码

1
2
3
4
5
6
7
dict1 = {"a": "a2", "b":"b1", "c": "c1"}
a = dict1.keys()
print(a)


运行结果
dict_keys(["a", "b", "c"])

是否可以拿到所有的值（value）

复制代码

1
2
3
4
5
6
7
dict1 = {"a": "a1", "b":"b1"}
b = dict1.values()
print(b)


运行结果
dict_values(["a1", "b1"])

拿出所有的键值对，一个以键值对为单个元组的列表

复制代码

1
2
3
4
5
6
dict1 = {"a": "a1", "b":"b1"}
print(dict1.items())


运行结果
dict_items([("a": "a1"), ("b":"b1")])

clear 全部清除

复制代码

1
2
3
4
5
6
dict1 = {"a": "a1", "b":"b1"}
print(dict1.clear())


运行结果
None

字典推导式

如果有如下两个列表

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
list1 = ['name','age','gender']
list2 = ['tom',20,'man']
dict = {list1[i]: list2[i] for i in range(len(list1))}
print(dict)


运行结果
{'name': 'tom', 'age': 20, 'gender': 'man'}

总结：
1.如果两个列表数据个数相同，len统计任何一个列表的长度都可以
2.如果两个列表数据个数不同，len统计数据多的列表数据个数会报错，
len统计数据少的列表数据个数不会报错

如何快速合并为一个字典

答：字典推导式

字典推导式作用：快速合并列表为字典或提取字典中目标数据

复制代码

1
2
3
4
5
6
7
8
# 创建字典key是1-5的数字，v是这个数字的平方
# dict1 = {k: v for i in range(1, 5)}
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1)


运行结果
{1: 1, 2: 4, 3: 9, 4: 16}

集合

注：1.集合可以快速完成列表去重 2.集合不支持下标

集合创建格式：

变量名 = {数据1，数据2。。。}

特点：

集合中数据是无序的，无法使用索引进行操作

集合中的数据是不重复的，重复数据将被过滤

数据不重复，有去重的效果（比如，网址重复）

复制代码

1
2
3
4
5
6
7
list = [1, 2, 3, 1, 2]
set = set(list)
print(set)


运行结果
{1, 2, 3}

如果创建空集合：set（）

复制代码

1
2
3
# 增加
parame.add(5)
print(parame)

删除

复制代码

1
2
3
parame.remove(6)    # 元素不存在会 报错
parame.discard(6)    # 元素不存在不会报错
print(parame)

集合推导式

复制代码

1
2
3
4
5
6
7
8
list = [1, 1, 2]
set = {i ** 2 for i in list}
print(set)


运行结果
{1, 4}
注：集合有去重功能所以只有两个数据

最后

以上就是满意指甲油最近收集整理的关于java的for循环取出数据只是拿到最后一个_python数据类型（字符串，列表已单独成两篇文章）...的全部内容，更多相关java内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：java的for循环取出数据只是拿到最后一个
浏览次数：96 次浏览
发布日期：2023-05-11 02:21:01
本文链接：https://www.kaopuke.com/article/k-p-k_14_ujo_2_fw_14_z_14_3.html

java的for循环取出数据只是拿到最后一个_python数据类型（字符串，列表已单独成两篇文章）...

数据存储

运算符

常用及不常用函数

len（）

元组

可变类型和不可变类型

元组与列表互相转换

字典

字典遍历

添加

集合

最后

评论列表共有 0 条评论

发表评论取消回复

java的for循环取出数据只是拿到最后一个_python数据类型（字符串，列表已单独成两篇文章）...

数据存储

运算符

常用及不常用函数

len（）

元组

可变类型和不可变类型

元组与列表互相转换

字典

字典遍历

添加

集合

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

微信扫一扫：分享

发表评论取消回复