python 数字转换成列表

转载

云端小梦 2024-11-30 07:47:05

文章标签 python 数字转换成列表 python 笔记开发语言嵌套 文章分类 Python 后端开发

一、定义

用于表示一组有序的元素，可以包含任意类型的元素，可以使用方括号来定义列表。

一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、字典以及其它自定义类型的对象。

my_list = [1, 2, 3, 'a', 'b', 'c']
print(my_list) # [1, 2, 3, 'a', 'b', 'c']

my_list2 = list((4, 5, 6))
print(my_list2) # [4, 5, 6]

my_list3 = list({4, 5, 6})
print(my_list3) # [4, 5, 6]

二、相关操作

1、添加元素

1.1、append

用于在列表的末尾添加一个元素。

# 定义变量 my_list，默认有3个元素
my_list = [1, 'b', 'c']
print(my_list)
# 提示、并添加元素
name = input('请输入：')
my_list.append(name)
print(my_list)
# [1, 'b', 'c']
# 请输入：zs
# [1, 'b', 'c', 'zs']

1.2、extend

用于将一个可迭代对象的元素逐个添加到列表的末尾，不会创建新的列表。

my_list = [1, 2]
my_list2 = [3, 4]
my_list.append(my_list2) # [1, 2, [3, 4]]
my_list.extend(my_list2) # [1, 2, 3, 4]
print(my_list)
# [1, 2, [3, 4], 3, 4]

1.3、insert

insert(index, object) 在指定位置 index 前插入元素 object。

my_list = [1, 2, 3, 4]
my_list.insert(2, 'b') # 在下标为2的位置插入'b'
print(my_list)
# [1, 2, 'b', 3, 4]

2、修改元素

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改。

my_list = [1, 'zs', 3]
my_list[0] = 'ls'
print(my_list)
# ['ls', 'zs', 3]

3、查找元素

所谓的查找，就是看看指定的元素是否存在。

3.1、in、not in

in（存在），如果存在那么结果为 true，否则为 false。
not in（不存在），如果不存在那么结果为 true，否则 false。

待查找的列表

my_list = [‘a’, ‘b’, ‘c’]
print(‘b’ in my_list) # True
print(‘b’ not in my_list) # False

获取用户要查找的名字

name = input(‘需要查找的名字是：’)

查找是否存在

if name in my_list:
print(‘找到了’)
else:
print(‘找不到’)

3.3、index

索引（index）：-
列表中的每个元素都有一个索引，用于标识元素在列表中的位置。列表的索引从0开始，依次递增。可以使用索引来访问列表中的特定元素。-
当索引超出了范围时，Python 会报一个 IndexError 错误，所以，要确保索引不要越界。

my_list = ['a', 'b', 'c']
print(my_list[0]) # a
print(my_list[1]) # b
print(my_list[2]) # c
print(my_list[3]) # IndexError: list index out of range


my_list = ['a', 'b', 'c', 'd']
# 在索引范围从 1（包括）到 3（不包括）之间查找元素 'c' 的索引
print(my_list.index('c', 1, 3)) # 2
# 在索引范围从 1（包括）到 3（不包括）之间查找元素 'a' 的索引
print(my_list.index('a', 1, 3))
# 报错：ValueError: 'a' is not in list

3.4、count

计数（count）：-
用于计算列表中某个元素的出现次数。该方法接受一个参数，即要计数的元素，并返回该元素在列表中出现的次数。

my_list = ['a', 'b', 'c', 'a', 'd']
print(my_list.count('a')) # 2
print(my_list.count('b')) # 1

4、删除元素

4.1、del

用于删除对象或对象的元素。-
删除变量

x = 5
print(x) # 5

del x
print(x) # 报错：NameError: name 'x' is not defined

删除列表中的元素

my_list = ['a', 'b', 'c', 'd']
print(my_list) # ['a', 'b', 'c', 'd']
del my_list[1]
print(my_list) # ['a', 'c', 'd']

4.2、pop

删除最后一个元素。

my_list = ['a', 'b', 'c', 'd']
print(my_list) # ['a', 'b', 'c', 'd']
my_list.pop()
print(my_list) # ['a', 'b', 'c']

4.3、remove

根据元素的值进行删除。

my_list = ['a', 'b', 'c', 'd']
print(my_list) # ['a', 'b', 'c', 'd']
my_list.remove('c')
print(my_list) # ['a', 'b', 'd']

4.4、clear

用于清空列表，即移除列表中的所有元素，使其变为空列表。

my_list = [1, 2, 3, 4, 5]
print(my_list) # [1, 2, 3, 4, 5]

my_list.clear()
print(my_list) # []

使用 clear() 方法后，列表对象仍然存在，只是列表变为空列表。如果需要完全删除列表对象，可以使用 del 语句将其删除，例如 del my_list。

5、排序

5.1、sort

用于对列表进行就地排序，即直接修改原始列表，使其按照升序进行排序。

my_list = [3, 1, 5, 2, 4]
my_list.sort()
print(my_list) # [1, 2, 3, 4, 5]

参数 reverse=True 可改为倒序。

my_list = [3, 1, 5, 2, 4]
my_list.sort(reverse=True)
print(my_list) # [5, 4, 3, 2, 1]

5.2、reverse

用于将列表中的元素反转，即将列表中的第一个元素移动到最后一个位置，第二个元素移动到倒数第二个位置，依此类推。

my_list = [1, 3, 4, 2, 5]
my_list.reverse()
print(my_list) # [5, 2, 4, 3, 1]

5.3、sorted

sort() 和 reverse() 方法都是在原始列表上进行修改，而不是返回新的列表。-
如果需要对列表进行排序或反转操作，并且希望保留原始列表的副本，可以使用 sorted() 函数和切片操作。

my_list = [3, 1, 5, 2, 4]

# 使用 sorted() 函数排序并返回新列表
sorted_list = sorted(my_list)
print(sorted_list) # [1, 2, 3, 4, 5]
print(my_list) # [3, 1, 5, 2, 4]

# 使用切片操作反转列表并返回新列表
reversed_list = my_list[::-1]
print(reversed_list) # [4, 2, 5, 1, 3]
print(my_list) # [3, 1, 5, 2, 4]

6、其它

6.1、len

返回列表中元素的个数。

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length) # 5

6.2、max

返回列表中最大的元素。

my_list = [3, 8, 2, 5, 1]
maximum = max(my_list)
print(maximum) # 8

6.3、min

返回列表中最小的元素。

my_list = [3, 8, 2, 5, 1]
minimum = min(my_list)
print(minimum) # 1

6.4、sum

返回列表中所有元素的和（要求列表中的元素是可相加的）。

my_list = [1, 2, 3, 4, 5]
total = sum(my_list)
print(total) # 15

三、列表嵌套

在 Python 中，列表可以嵌套在另一个列表中，形成二维或多维的数据结构。这种列表的嵌套结构允许在一个列表中存储其它列表，从而创建更复杂的数据结构。

# 列表嵌套
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(nested_list) # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 访问嵌套列表中的元素
print(nested_list[0]) # [1, 2, 3]
print(nested_list[1][2]) # 6

# 修改嵌套列表中的元素
nested_list[2][1] = 10
print(nested_list) # [[1, 2, 3], [4, 5, 6], [7, 10, 9]]

# 迭代遍历嵌套列表
for sublist in nested_list:
    for item in sublist:
        print(item, end=' ')
    print()
# 1 2 3 
# 4 5 6 
# 7 10 9

四、列表推导式

列表推导式（List Comprehensions）是一种简洁且强大的方式，用于根据现有的列表创建新的列表。它允许我们在一行代码中定义列表，并可以在创建过程中应用筛选条件、变换操作和循环逻辑。

基本形式：

[表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件]

1、创建一个包含1到5的平方的列表

squares = [x**2 for x in range(1, 6)]
print(squares) # [1, 4, 9, 16, 25]

2、创建一个仅包含偶数的列表

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers) # [2, 4, 6, 8, 10]

3、创建一个字符串列表，包含每个单词的首字母

words = ['apple', 'banana', 'cherry']
first_letters = [word[0] for word in words]
print(first_letters) # ['a', 'b', 'c']

4、创建一个列表，包含两个列表中的元素对

list1 = [1, 2, 3]
list2 = [4, 5, 6]
pairs = [(x, y) for x in list1 for y in list2]
print(pairs) # [(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]

5、将一个字符串列表中的所有元素转换为大写形式

words = ['hello', 'world', 'python']
upper_words = [word.upper() for word in words]
print(upper_words) # ['HELLO', 'WORLD', 'PYTHON']

6、使用两个列表的元素组合成一个新列表

numbers = [1, 2, 3]
letters = ['a', 'b', 'c']
combinations = [(number, letter) for number in numbers for letter in letters]
print(combinations) # [(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c'), (3, 'a'), (3, 'b'), (3, 'c')]

7、将一个列表中的偶数元素加倍，奇数元素保持不变

numbers = [1, 2, 3, 4, 5]
modified_numbers = [x*2 if x % 2 == 0 else x for x in numbers]
print(modified_numbers) # [1, 4, 3, 8, 5]

五、使用 for 循环遍历

my_list = ['a', 'b', 'c']
for i in my_list:
    print(i)
# a
# b
# c

六、enumerate 枚举

当我们需要遍历列表并获取每个元素的索引时，可以使用枚举（enumerate）函数。枚举函数会返回一个可迭代对象，其中每个元素是由索引和对应的元素值组成的。

my_list = ['a', 'b', 'c']
for index, value in enumerate(my_list):
    print(index, value)
# 0 a
# 1 b
# 2 c

七、使用 while 循环

my_list = ['a', 'b', 'c']
my_list_len = len(my_list)
i = 0
while i < my_list_len:
    print(my_list[i])
    i += 1
# a
# b
# c

八、应用

1、一个学校，有3个办公室，现在有6位老师等待工位的分配，请编写程序，完成随机的分配。

# 模块，用于生成随机数
import random
# 定义一个列表用来保存3个办公室
offs = [[], [], []]
# 定义一个列表用来存储6位老师的名字
names = ['a1', 'b1', 'c1', 'd1', 'e1', 'f1']

# 将每位老师随机分配到一个办公室中
for i in names:
    # 生成一个随机数，范围是0到2，表示3个办公室之间的选择
    index = random.randint(0, 2)
    # 将当前老师名字添加到选定的办公室列表中
    offs[index].append(i)

# 打印每个办公室的人员情况
print(offs)

# 定义一个计数器变量
f = 1

# 遍历每个办公室的列表
for offname in offs:
    # 打印办公室编号和人数
    print('办公室%d的人数为:%d' % (f, len(offname)))
    # 增加计数器变量的值
    f += 1
    # 打印当前办公室的所有人员名字
    for name in offname:
        print('%s' % name, end=' ')
    # 换行
    print('')

2、要求：提供十道加减乘除运算的题目，根据题目输入答案，自动判断答案是否正确，进行测验。-
思路：-
1、10道题目，做了几道，正确几道题 while-
2、题目随机，运算符随机，数字随机 random-
3、用户输入答案，判断各种情况，计算正确结果 if-
4、比较结果是否正确，正确的话+1-
5、显示结果，打印正确个数

# 模块，用于生成随机数
import random
# 题目数
cou = 0
# 正确数
rig = 0

while cou < 10:
    # 定义运算符列表
    op = ['+', '-', '*', '/']
    # 随机选择一个运算符
    rop = random.choice(op)
    # 随机生成两个操作数
    n1 = random.randint(0, 100)
    # 除数不能为0
    n2 = random.randint(1, 100)

    # 打印表达式
    print('%d %s %d = ' % (n1, rop, n2))

    # 判断随机生成的运算符，并计算正确结果
    if rop == '+':
        res = n1 + n2
    elif rop == '-':
        res = n1 - n2
    elif rop == '*':
        res = n1 * n2
    elif rop == '/':
        # 计算除法结果并保留两位小数
        res = n1 / n2
        res = round(res, 2)

    # 打印正确结果
    print(res)

    # 获取用户输入的答案
    question = float(input('请输入你的答案，退出请输入12345：'))

    # 判断用户输入的结果是否正确
    if question == res:
        print('回答正确')
        rig += 1
        cou += 1
    elif question == 12345:
        break
    else:
        print('回答错误，答案是：', res)
        cou += 1

# 打印测试结果
print('测试结束，共回答%d道题，正确的有%d道题' % (cou, rig))

# 计算正确率
if cou == 0:
    percent = 0
else:
    percent = rig / cou

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：PreparedStatement executeBatch 打印sql

下一篇：java的可移植性技术是什么

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯