python组合数据类型

最新推荐文章于 2023-08-10 15:39:35 发布
最新推荐文章于 2023-08-10 15:39:35 发布
阅读量619 收藏 1
点赞数
文章标签： python 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44981672/article/details/120482005
版权

python组合数据类型

1.列表

1.1列表的表达

  1. 序列类型：内部元素有位置关系，能通过位置序号访问其中元素
  2. 列表是一个可以使用多种类型元素，支持元素的增、删、查、改操作的序列类型
ls = ["Python", 1989, True, {"version": 3.7}]
print（ls）#['Python', 1989, True, {'version': 3.7}]
  1. 另一种产生方式：list(可迭代对象)， 可迭代对象包括：字符串、元组、集合、range()等
    字符串转列表
a=list("人工智能是未来的趋势")
print(a)#['人', '工', '智', '能', '是', '未', '来', '的', '趋', '势']

元组转列表

a=list(("我", "们", "很", "像"))
print(a)#['我', '们', '很', '像']

集合转列表

a=list({"李雷", "韩梅梅", "Jim", "Green"})
print(a)#['Green', 'Jim', '李雷', '韩梅梅']

特殊的range()

for i in [0, 1, 2, 3, 4, 5]:
    print(i)
'''
0
1
2
3
4
5
'''

for i in range(6):
    print(i)
'''
0
1
2
3
4
5

'''

range(起始数字,中止数字,数字间隔)
如果起始数字缺省，默认为0
必须包含中止数字
数字间隔缺省，默认为1

for i in range(1, 11, 2):
    print(i)
'''
1
3
5
7
9
'''

range()转列表

a=list(range(1, 11, 2))
print(a)#[1, 3, 5, 7, 9]

1.2列表的性质

列表的长度——len(列表)

ls = [1, 2, 3, 4, 5]
print(len(ls))

列表的索引------与同为序列类型的字符串完全相同
变量名[位置编号]
正向索引从0开始
反向索引从-1开始

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]
print(cars[0])
print(cars[-1])
#BYD
#TOYOTA

列表的切片
变量名[开始位置：结束位置：切片间隔]

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]

正向切片

print(cars[:3])     # 前三个元素，开始位置缺省，默认为0；切片间隔缺省，默认为1
#['BYD', 'BMW', 'AUDI']
print(cars[1:4:2])  # 第二个到第四个元素 前后索引差为2
#['BMW', 'TOYOTA']
print(cars[:])      # 获取整个列表，结束位置缺省，默认取值到最后
#['BYD', 'BMW', 'AUDI', 'TOYOTA']
print(cars[-4:-2])  # 获取前两个元素
#['BYD', 'BMW']

反向切片

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]
print(cars[:-4:-1])      # 开始位置缺省，默认为-1
print(cars[::-1])        # 获得反向列表
#['TOYOTA', 'AUDI', 'BMW']
#['TOYOTA', 'AUDI', 'BMW', 'BYD']

1.3列表的操作符

用 list1+lis2 的形式实现列表的拼接

a = [1, 2]
b = [3, 4]
print(a+b)            # 该用法用的不多
#[1, 2, 3, 4]

用 nlist 或 listn 实现列表的成倍复制
初始化列表的一种方式

a=[0]*10
print(a)
#[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

1.4 列表的操作方法

1、增加元素
在末尾增加元素——列表.append(待增元素)

languages = ["Python", "C++", "R"]
languages.append("Java")
languages.append("Java")
print(anguages)
#['Python', 'C++', 'R', 'Java']

在任意位置插入元素——列表.insert(位置编号，待增元素)
在位置编号相应元素前插入待增元素

languages.insert(1, "C")
print(languages)
#['Python', 'C', 'C++', 'R', 'Java']

在末尾整体并入另一列表——列表1.extend(列表2)
append 将列表2整体作为一个元素添加到列表1中

languages.append(["Ruby", "PHP"])
print(languages)
#['Python', 'C', 'C++', 'R', 'Java', ['Ruby', 'PHP']

extend 将待列表2内的元素逐个添加到列表1中

languages = ['Python', 'C', 'C++', 'R', 'Java']
languages.extend(["Ruby", "PHP"])
print(languages)
#['Python', 'C', 'C++', 'R', 'Java', 'Ruby', 'PHP']

2、删除元素

删除列表i位置的元素  列表.pop(位置)

languages = ['Python', 'C', 'C++', 'R', 'Java']
languages.pop(1)
print(languages)
#['Python', 'C++', 'R', 'Java']

不写位置信息，默认删除最后一个元素

languages.pop()
print(languages)
#['Python', 'C++', 'R']

删除列表中的第一次出现的待删元素 列表.remove(待删元素)

languages = ['Python', 'C', 'R', 'C', 'Java']
languages.remove("C")    
print(languages)
#['Python', 'R', 'C', 'Java']

languages = ['Python', 'C', 'R', 'C', 'Java']
while "C" in languages:
    languages.remove("C")    
print(languages)
#['Python', 'R', 'Java']

3、查找元素

列表中第一次出现待查元素的位置 列表.index(待查元素)

languages = ['Python', 'C', 'R','Java']
idx = languages.index("R") 
print(idx)
#2

4、修改元素

通过"先索引后赋值"的方式，对元素进行修改 列表名[位置]=新值

languages = ['Python', 'C', 'R','Java']
languages[1] = "C++"
print(languages)
#['Python', 'C++', 'R', 'Java']

5、列表的复制

方法1：列表.copy()

languages = ['Python', 'C', 'R','Java']
languages_2 = languages.copy()
languages.pop()
print(languages)
print(languages_2)
#['Python', 'C', 'R']
#['Python', 'C', 'R', 'Java']

方法2：列表[ : ]

languages = ['Python', 'C', 'R','Java']
languages_3 = languages[:]
languages.pop()
print(languages)
print(languages_3)
#['Python', 'C', 'R']
#['Python', 'C', 'R', 'Java']

6、列表的排序

使用列表.sort()对列表进行永久排序
直接在列表上进行操作，无返回值

ls = [2, 5, 2, 8, 19, 3, 7]
ls.sort()
print(ls)
#[2, 2, 3, 5, 7, 8, 19]

递减排列

ls = [2, 5, 2, 8, 19, 3, 7]
ls.sort(reverse = True)
print(ls)
#[19, 8, 7, 5, 3, 2, 2]

使用sorted(列表)对列表进行临时排序
原列表保持不变，返回排序后的列表

ls = [2, 5, 2, 8, 19, 3, 7]
ls_2 = sorted(ls)
print(ls)
print(ls_2)
#[2, 5, 2, 8, 19, 3, 7]
#[19, 8, 7, 5, 3, 2, 2]
sorted(ls, reverse = True)
#[19, 8, 7, 5, 3, 2, 2]

7、列表的翻转

使用列表.reverse()对列表进行永久翻转
直接在列表上进行操作，无返回值

ls = [1, 2, 3, 4, 5]
print(ls[::-1])
print(ls)
#[5, 4, 3, 2, 1]
#[1, 2, 3, 4, 5]
ls.reverse()
print(ls)
#[5, 4, 3, 2, 1]

8、使用for循环对列表进行遍历

ls = [1, 2, 3, 4, 5]
for i in ls:
    print(i)
'''
1
2
3
4
5
'''

2 元组

2.1 元组的表达

元组是一个可以使用多种类型元素，一旦定义，内部元素不支持增、删和修改操作的序列类型,通俗的讲，可以将元组视作“不可变的列表”

names = ("Peter", "Pual", "Mary")

2.2 元组的操作

不支持元素增加、元素删除、元素修改操作
其他操作与列表的操作完全一致

2.3 元组的常见用处

打包与解包
例1

def f1(x):              # 返回x的平方和立方
    return x**2, x**3   # 实现打包返回

print(f1(3))
print(type(f1(3)))      # 元组类型
#(9, 27)
#<class 'tuple'>
a, b = f1(3)            # 实现解包赋值 
print(a)#9
print(b)#27

例2

numbers = [201901, 201902, 201903]
name = ["小明", "小红", "小强"]
list(zip(numbers,name))
#[(201901, '小明'), (201902, '小红'), (201903, '小强')]
for number,name in zip(numbers,name):   # 每次取到一个元组，立刻进行解包赋值
    print(number, name)
#201901 小明
#201902 小红
#201903 小强

3 字典

3.1 字典的表达
映射类型： 通过“键”-“值”的映射实现数据存储和查找
常规的字典是无序的

students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(students)
#{201901: '小红', 201903: '小强'}

字典键的要求
1、字典的键不能重复

students = {201901: '小明', 201901: '小红', 201903: '小强'}
print(students)
#{201901: '小红', 201903: '小强'}

2、字典的键必须是不可变类型，如果键可变，就找不到对应存储的值了
不可变类型：数字、字符串、元组。  一旦确定，它自己就是它自己，变了就不是它了。
可变类型：列表、字典、集合。  一旦确定，还可以随意增删改。
3.2 字典的性质
字典的长度——键值对的个数

students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(len(students))#3

字典的索引
通过 字典[键] 的形式来获取对应的值

students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(students[201902])
#'小红'

3.3 字典的操作方法
1、增加键值对
变量名[新键] = 新值

students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201904] = "小雪"
print(students)
#{201901: '小明', 201902: '小红', 201903: '小强', 201904: '小雪'}

2、删除键值对
通过del 变量名[待删除键]

students = {201901: '小明', 201902: '小红', 201903: '小强'}
del students[201903]
print(students)
#{201901: '小明', 201902: '小红'}

通过变量名.pop(待删除键)

students = {201901: '小明', 201902: '小红', 201903: '小强'}
value = students.pop(201903)   # 删除键值对，同时获得删除键值对的值
print(value)
print(students)
#小强
#{201901: '小明', 201902: '小红'}

变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对

students = {201901: '小明', 201902: '小红', 201903: '小强'}
key, value = students.popitem()
print(key, value)
print(students)
#201903 小强
#{201901: '小明', 201902: '小红'}

3、修改值
通过先索引后赋值的方式对相应的值进行修改

students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201902] = "小雪"
print(students)
#{201901: '小明', 201902: '小雪', 201903: '小强'}

4、d.get( )方法
d.get(key,default) 从字典d中获取键key对应的值，如果没有这个键，则返回default
小例子：统计"牛奶奶找刘奶奶买牛奶"中字符的出现频率

s = "李静华"
d = {}
print(d)
for i in s:
    d[i] = d.get(i, 0)+1
    print(d)
# print(d)
'''
{}
{'李': 1}
{'李': 1, '静': 1}
{'李': 1, '静': 1, '华': 1}
'''

5、d.keys( ) d.values( )方法

students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(list(students.keys()))
print(list(students.values()))
#[201901, 201902, 201903]
#['小明', '小红', '小强']

6、d.items( )方法及字典的遍历

print(list(students.items()))
for k, v in students.items():
    print(k, v)
'''
[(201901, '小明'), (201902, '小红'), (201903, '小强')]
201901 小明
201902 小红
201903 小强
'''

4 集合

4.1 集合的表达
一系列互不相等元素的无序集合
元素必须是不可变类型：数字，字符串或元组，可视作字典的键
可以看做是没有值，或者值为None的字典

students = {"小明", "小红", "小强", "小明"}   #可用于去重
print(students)
#{'小强', '小明', '小红'}

4.2 集合的运算
通过集合进行交集并集的运算

Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"}

语文和数学两门均为A的学员
S & T 返回一个新集合，包括同时在集合S和T中的元素

Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"}
Chinese_A & Math_A
#{'刘德华', '张曼玉', '林青霞'}

语文或数学至少一门为A的学员
S | T 返回一个新集合，包括集合S和T中的所有元素

Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"}
Chinese_A | Math_A
#{'刘德华', '古天乐', '张学友', '张曼玉', '林青霞', '王祖贤', '郭富城', '钟楚红', '黎明'}

语文数学只有一门为A的学员
S ^ T 返回一个新集合，包括集合S和T中的非共同元素

Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"}
Chinese_A ^ Math_A
#{'古天乐', '张学友', '王祖贤', '郭富城', '钟楚红', '黎明'}

语文为A，数学不为A的学员
S - T 返回一个新集合，包括在集合S但不在集合T中的元素

Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"}
Chinese_A - Math_A
#{'古天乐', '张学友', '钟楚红'}

数学为A，语文不为A的学员

Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"}
Math_A - Chinese_A
#{'王祖贤', '郭富城', '黎明'}

4.3 集合的操作方法

增加元素——S.add(x)

stars = {"刘德华", "张学友", "张曼玉"}
stars.add("王祖贤")
print(stars)
#{'刘德华', '张学友', '张曼玉', '王祖贤'}

移除元素——S.remove(x)

stars = {"刘德华", "张学友", "张曼玉"}
stars.remove("王祖贤")
print(stars)

集合的长度——len(S)

stars = {"刘德华", "张学友", "张曼玉"}
print(len(stars))
#3

集合的遍历——借助for循环

stars = {"刘德华", "张学友", "张曼玉"}
for star in stars:
    print(star)
#张学友
#张曼玉
#刘德华

----------------学习笔记

qq_44981672
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深度之眼 - Python学习笔记——第四章 组合数据类型
Faye_Gu的博客
02-05 796
第四章 组合数据类型 4.1 列表 列表是可变的！ 4.1.1 列表的表达 序列类型：内部元素有位置关系，能通过位置序号访问其中元素 列表是一个可以使用多种类型元素，支持元素的增、删、查、改操作的序列类型 ls = ["Python", 1989, True, {"version": 3.7}] ls ['Python', 1989, True, {'version': 3.7}] ...
计算机二级Python真题（三）
weixin_57506250的博客
01-22 7758
第三套真题 1、按照“后进先出”原则组织数据的数据结构是____ A.栈 B.双向链表 C.二叉树 D.队列 正确答案： A 2、以下选项的叙述中，正确的是 A.在循环队列中，只需要队头指针就能反映队列中元素的动态变化情况 B.在循环队列中，只需要队尾指针就能反映队列中元素的动态变化情况 C.循环队列中元素的个数是由队头指针和队尾指针共同决定 D.循环队列有队头和队尾两个指针，因此，循环队列是非线性结构 正确答案： C 3、关于数据的逻辑结构，以下选项中描述正确的是 A.
python中in什么意思_python中5in什么意思
weixin_33249666的博客
03-02 2753
python中的for in是什么意思python中的for in是一个语句循环固定格式；Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言；Python在设计上坚持了清晰划一的风格，这使得Python成为一门易读、易维护，并且被大量用户所欢迎的、用途广泛的语谁能给我讲讲，python里for in中的in究竟是什么意for i in range(1,10) 说的是i 等于...
# python语法学习笔记3（与C++的一些不同）
qq_45942107的博客
08-27 338
序列是一种数据存储方式，类似于数组，但拥有更丰富的功能。常见的序列：字符串、列表、元组、字典、集合。定义a=[10,20,30,40],实际上是存了各数值的地址。
python基础知识Day5
Triumphant1的博客
09-24 264
python基础知识Day5 序列 序列是一种数据存储方式，用来存放一系列的数据。 常用的序列结构有L字符串、列表、元组、字典、集合 列表：用于存储任意数目、任意类型的数据集合 如：a=[10,20,‘abc','True'] 常用方法：list.append(x) 增加元素 list.extend(aList)将alist所有元素增加 list.insert(index,x)在index处插入元素x list.remove(x)删除首次出现的x list.clear()清楚列表内容
实验7 Python组合数据类型.pdf
05-25
Python组合数据类型是Python编程语言中用于存储多个数据值的内置数据结构。在Python中，组合数据类型包括列表（List）、元组（Tuple）和字典（Dictionary）。这三种类型各有其特点，可以存储不同类型的数据，包括...
Python组合数据类型.pptx
04-15
"Python 组合数据类型" Python 组合数据类型是 Python 编程语言中的一种基本数据类型，它包括列表、元组、字典和集合四种类型。组合数据类型可以存储多个元素，并提供了多种操作和处理方法，非常有利于数据处理和...
python range函数返回的是什么_python3中的range函数返回的是列表吗
weixin_39704971的博客
11-28 2857
今天白月黑羽和大家说说python3中的range函数返回对象的问题注意，这里说的Python3里面的range函数，和Python2是不同的，返回的不是列表，是可迭代对象。在python3中，如果执行下面的语句print(range(10))得到结果是 range(0,10) ，而不是期望的[0,1,2,3,4,5,6,7,8,9]。但是如果换一种方式print(list(range(10)))...
五、 组合数据类型
weixin_61966260的博客
07-18 302
1. 组合数据类型的基本概念。 2. 列表类型:定义、索引、切片。 3. 列表类型的操作:列表的操作函数、列表的操作方法。 4. 字典类型:定义、索引。 5.字典类型的操作:字典的操作函数、字典的操作方法。
Python实用技法第15篇：筛选序列中的元素
weixin_33849942的博客
10-22 235
上一篇文章：Python实用技法第14篇：根据字段将记录分组：itertools.groupby()下一篇文章：Python实用技法第16篇：从字典中提取子集 1、需求
【Python】05 - Python组合数据类型（列表、集合、元组、字典）
cyairhp的博客
01-27 5493
一、组合数据类型概述 (1)适用场合 很多时候，计算机需要对一组数据进行批量处理， 例如：给定一组单词{python, data, function, list, loop}，计算并输出每个单词的长度 (2) 什么是组合数据类型 将多个同类型或不同类型的数据组织起来，通过单一的表示使数据操作更有序更容易。 根据数据之间的关系，组合数据类型可以分为三类： 序列类型：是一个元素向量，元素之间存在先后关系，通过序号访问，元素之间不排他 集合类型：是一个元素集合，元素之间无序，不允许出现重复元素 ...
2.5 组合数据类型
Louisiana12的博客
01-19 121
未来教育计算机二级
第五章组合数据类型
2301_77273933的博客
08-10 101
有序列关系支持双向索引。
【全国计算机二级】python的jieba模块，你真的了解吗？
knighthood2001
05-12 4565
带你了解python的jieba模块
2.python的基本语法元素_组合数据类型
Andy
12-19 737
#-*- coding: utf-8 -*- #组合数字类型 列表 元组 字典 集合 print("============列表============") #2.1 列表 序列类型 数据有位置顺序 能够通过位置序号访问其中元素 #列表是一个可以使用多种类型元素，支持元素都增，删，改，查操作都序列类型 a = ["Python",1989,True,{"version":3.7}] pri...
python-eval函数
weixin_30436891的博客
03-18 239
eval函数 eval()函数十分强大 ——将字符串当成有效的表达式来求值 并返回计算结果 # 基本的数学计算 In [1]: eval("1 + 1") Out[1]: 2 # 字符串重复 In [2]: eval("'*' * 10") Out[2]: '**********' # 将字符串转换成列表 In [3]: type(eval("[1, 2, ...
python中list()函数和tuple()函数用法
Thewei666的博客
04-27 742
列表与元组最大的区别在于：元组是不可改变的，列表是可改变的。元组支持的操作，列表基本上都支持；列表支持对元素的修改，而元组则不支持 从这个角度来看，可以认为列表是增强版的元组 虽然大部分时候都可使用列表来代替元组，但如果程序不需要修改列表所包含的元素，那么使用元组代替列表会更安全 list()函数 除前面介绍的方括号语法来创建列表之外，python还提供了一个内置的list()函数来创建列表 list()函数可用于将元组、区间（range）等对象转换为列表 #元组转换为列表 a_tup
Python学习（五）——数据类型之列表、元组、字典和集合
mport的博客
10-03 1803
创建空集合时，必须使用set()，不能是{}；因为{}默认为空字典。 list1 = [] # 空列表 tuple1 = () # 空元祖 str1 = "" # 空字符串 dict1 = {} # 空字典 set1 = set() # 空集合
Python组合数据类型
最新发布
12-14
Python中常用的组合数据类型有列表、元组、集合和字典。 1. 列表：列表是一种有序的数据集合，可以存储任意类型的数据，使用方括号 [] 来表示，每个元素之间用逗号分隔。列表支持索引、切片、添加、删除、修改等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值