声明：该博客参考深度之眼的视频课程，如有侵权请联系小编删除博文，谢谢！若总结有所失误，还请见谅，并欢迎及时指出。

组合数据类型

1.1 列表

1.1.1 列表的表达

列表类型：内部元素有位置关系，能通过位置序号访问其中元素
列表是一个可以使用多种类型元素，支持元素的增、删、查、改操作的序列类型

ls = ["Python",1989,True,{"version":3.7}]
ls   #结果：['Python', 1989, True, {'version': 3.7}]

另一种产生方式：list（可迭代对象）
可迭代对象包括：字符串、元组、集合、rang()等

#字符串转列表
list("人工智能是未来的趋势")  #运行结果 ['人', '工', '智', '能', '是', '未', '来', '的', '趋', '势']#元组转列表
list(("我","们","很","像"))  #运行结果 ['我', '们', '很', '像']#集合转列表
list({"李雷","韩梅梅","Jim","Green"}) #运行结果 ['李雷', 'Jim', 'Green', '韩梅梅']#特殊的range()
for i in [0,1,2]:print(i)         #输出 0 1 2
for i in range(3):print(i)        #输出 0 1 2
# range(起始数字，终止数字，数字间隔)  如果起始数字缺省，默认为0    数字间隔缺省。默认为1#range()转列表
list(range(1,6,2))  #输出结果 [1, 3, 5]

1.1.2 列表的性质

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

ls = [1,2,3,4,5]
len(ls)   #输出结果 5

列表的索引——与同为序列类型的字符串完全相同

#变量名[位置编号]
#正向索引从0开始  反向索引从-1开始
cars = ["BYD","BWM","AUDI","TOTOTA"]
print(cars[0])  #输出结果 BYD
print(cars[1])  #输出结果 BWM#列表的切片
#变量名[开始位置：结束位置：切片间隔]
print(cars[:3])  #开始位置缺省，默认为0；切片间隔缺省，默认为1  结果 ['BYD', 'BWM', 'AUDI']
print(cars[1:4:2])  #第二个到第四个元素 前后索引差为2   结果 ['BWM', 'TOTOTA']
print(cars[:])      #获取整个列表，结束位置缺省，默认取到最后   结果 ['BYD', 'BWM', 'AUDI', 'TOTOTA']
print(cars[-4:-2])  #获取前两个元素   结果 ['BYD', 'BWM']#反向切片
print(cars[:-4:-1])  #开始位置缺省，默认为-1   结果 ['TOTOTA', 'AUDI', 'BWM']
print(cars[::-1])    #获得反向列表   结果 ['TOTOTA', 'AUDI', 'BWM', 'BYD']

1.1.3 列表的操作符

# 用list1+list2的形式实现列表的拼接
a = [1,2]
b = [2,3]
a+b      #该用法用的不多 结果 [1, 2, 2, 3]#用n*list 或 list*n 实现列表的成倍复制 是初始化列表的一种方式
[0]*10    #结果 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

1.1.4 列表的操作方法

增加元素

#在末尾增加元素——列表.append(待增元素)
languages = ["Python","C++","R"]
languages.append("Java")
languages          #结果 ['Python', 'C++', 'R', 'Java']#在任意位置插入元素——列表.insert(位置编号，待增元素)    插入该位置的前面
languages.insert(1,"C")
languages      #结果 ['Python', 'C', 'C++', 'R', 'Java']#在末尾整体并入另一列表——列表1.extend(列表2)
languages.append(["Rudy","PHP"])           #append将列表2整体作为一个元素添加到列表1中
languages      #结果 ['Python', 'C', 'C++', 'R', 'Java', ['Rudy', 'PHP']]
languages.extend(["Rudy","PHP"])           #extend将列表2内的元素逐个添加到列表1中
languages      #结果 ['Python', 'C', 'C++', 'R', 'Java', ['Rudy', 'PHP'], 'Rudy', 'PHP']

删除元素

#删除列表i位置的元素 列表.pop(位置)
languages = ['Python', 'C', 'C++', 'R', 'Java']
languages.pop(1)
languages       #结果 ['Python', 'C++', 'R', 'Java']
#不写位置信息，默认删除最后一个元素
languages.pop()
languages           #结果 ['Python', 'C++', 'R'] #删除列表中的第一次出现的待删除元素 列表.remove(待删除元素)
languages = ['Python', 'C', 'C++','C', 'R', 'Java']
languages.remove("C")
languages     #结果 ['Python', 'C++', 'C', 'R', 'Java']    注意只删除第一次出现的待删元素
#如何将列表中重复出现的待删除元素删除
languages = ['Python', 'C', 'C++','C', 'R', 'Java']
while "C" in languages:languages.remove("C")
languages               #结果 ['Python', 'C++', 'R', 'Java']

查找元素

#列表中第一次出现待查元素的位置 列表.index(待查元素)
languages = ['Python', 'C', 'R', 'Java']
index = languages.index("R")
index               #结果  2

修改元素

#通过“先索引后赋值”的方式，对元素进行修改  列表名{位置}=新值
languages = ['Python', 'C', 'R', 'Java']
languages[1] = "C++"
languages    #结果  ['Python', 'C++', 'R', 'Java']

列表的复制

#错误的复制方式
languages = ['Python', 'C', 'R', 'Java']
languages_2 = languages
languages.pop()
print(languages)     #结果  ['Python', 'C', 'R']
print(languages_2)   #结果  ['Python', 'C', 'R']   这样操作时，会发现对原来的列表进行修改，同时也对复制的列表进行了修改，相当于同一个列表有两个名字#正确的方式——浅拷贝
#方法1：列表.copy()
languages = ['Python', 'C', 'R', 'Java']
languages_3 = languages.copy()
languages.pop()
print(languages)     #结果  ['Python', 'C', 'R']
print(languages_3)   #结果  ['Python', 'C', 'R', 'Java']
#方法2：列表[:]
languages = ['Python', 'C', 'R', 'Java']
languages_4 = languages[:]
languages.pop()
print(languages)     #结果  ['Python', 'C', 'R']
print(languages_3)   #结果  ['Python', 'C', 'R', 'Java']

列表的排序

#使用列表.sort()对列表进行永久排序
#直接在列表上进行操作，无返回值
ls = [2,5,2,8,19,3,7]
ls.sort()
ls        #结果  [2, 2, 3, 5, 7, 8, 19]
#递减排列
ls.sort(reverse = True)
ls        #结果  [19, 8, 7, 5, 3, 2, 2]#使用sorted(列表)对列表进行临时排序
#原列表保持不变，返回排序后的列表
ls = [2,5,2,8,19,3,7]
ls_2 = sorted(ls)
print(ls)     #结果  [2, 5, 2, 8, 19, 3, 7]
print(ls_2)   #结果  [2, 2, 3, 5, 7, 8, 19]
sorted(ls,reverse = True)     #结果  [19, 8, 7, 5, 3, 2, 2]   递减排序

列表的翻转

#使用列表.reverse()对列表进行永久翻转
#直接在列表上进行操作，无返回值
ls = [1,2,3,4,5]
print(ls[::-1])         #结果 [5, 4, 3, 2, 1]
ls                     #结果 [1, 2, 3, 4, 5]ls.reverse()
ls                     #结果 [5, 4, 3, 2, 1]

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

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

1.2 元组

1.2.1 元组的表达

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

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

1.2.2 元组的操作

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

1.2.3 元组的常见用处

#打包与解包
#eg1
def f(x):                     #返回x的平方和立方return x**2, x**3        #实现打包返回print(f(3))         #结果  (9, 27)
print(type(f(3)))   #结果  <class 'tuple'>    元组类型
a, b = f(3)         #实现解包赋值
print(a)            #结果 9
print(b)            #结果 27#eg2
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 小强

1.3 字典

1.3.1 字典的表达

映射规则：通过“键”-“值”的映射实现数据存储和查找
映射的字典是无序的

students = {201901: '小明', 201902: '小红', 201903: '小强'}
students         #结果   {201901: '小明', 201902: '小红', 201903: '小强'}

字典键的要求

字典的键不能重复
字典的键必须是不可变类型，如果键可变，就找不到对应存储的值了
不可变类型：数字、字符串、元组。一旦确定，他自己就是他自己，变了就不是他了
可变类型：列表、字典、集合。一旦确定，还可以随意增删改

d1 = {1: 3}         #数字
d2 = {"s": 3}       #字符串
d3 = {(1,2,3): 3}   #元组d = {[1,2]: 3}      #列表
d = {{1:2}: 3}      #字典
d = {{1,2}: 3}      #集合

1.3.2 字典的性质

#字典的长度——键值对的个数
students = {201901: '小明', 201902: '小红', 201903: '小强'}
len(students)    #结果 3#字典的索引
#通过 字典[键] 的形式来获取对应的值
students[201901]    #结果  '小明'

1.3.3 字典的操作方法

增加键值对

#变量名[新建] = 新值
students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201904] = "小雪"
students       #结果 {201901: '小明', 201902: '小红', 201903: '小强', 201904: '小雪'}

删除键值对

# 通过del 变量名[待删除键]
students = {201901: '小明', 201902: '小红', 201903: '小强'}
del students[201903]
students    #结果  {201901: '小明', 201902: '小红'}# 通过变量名.pop(待删除)
value = students.pop(201902)
print(value)      #结果  小红
print(students)   #结果  {201901: '小明'}

# 变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对
students = {201901: '小明', 201902: '小红', 201903: '小强'}
key, value = students.popitem()
print(value)      #结果  小强
print(students)   #结果  {201901: '小明', 201902: '小红'}

修改值

#通过先索引后赋值的方式对相应的值进行修改
students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201902] = "小雪"
students       #结果 {201901: '小明', 201902: '小雪', 201903: '小强'}

d.get( )方法

#d.get(key,default)  从字典d中获取键key对应的值，如果没有这个键，则返回default
# eg：统计“牛奶奶找刘奶奶买牛奶”中字符出现频率
s = "牛奶奶找刘奶奶买牛奶"
d = {}
for i in s:d[i] = d.get(i, 0)+1
print(d)      #结果 {'牛': 2, '奶': 5, '找': 1, '刘': 1, '买': 1}

d.key( ) d.value( )方法

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

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

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

1.4 集合

1.4.1 集合的表达

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

students = {"小明","小红","小强","小明"}    #可用于去重
students    #结果   {'小强', '小明', '小红'}

1.4.2 集合的运算

# eg 通过集合进行交集并集的运算
Chinese_A = {"刘德华","钟楚红","张学友","张曼玉","古天乐","林青霞"}
Math_A = {"林青霞","郭富城","王祖贤","刘德华","张曼玉","黎明"}#语文和数学两门均为A的学员
#S&T返回一个新集合，包括同时在集合S和T中的元素
Chinese_A & Math_A    #结果   {'刘德华', '张曼玉', '林青霞'}#语文和数学至少有一个为A的学员
#S|T返回一个新集合，包括集合S和T中的所有元素
Chinese_A | Math_A    #结果  {'刘德华', '古天乐', '张学友', '张曼玉', '林青霞', '王祖贤', '郭富城', '钟楚红', '黎明'}#语文和数学只有一个为A的学员
#S^T返回一个新集合，包括集合S和T中的非共同元素
Chinese_A ^ Math_A    #结果  {'古天乐', '张学友', '王祖贤', '郭富城', '钟楚红', '黎明'} #语文为A，数学不为A的学员
#S-T返回一个新集合，包括集合S和不在集合T中的元素
Chinese_A - Math_A     #结果  {'古天乐', '张学友', '钟楚红'}#数学为A，语文不为A的学员
Math_A -  Chinese_A    #结果  {'王祖贤', '郭富城', '黎明'}

1.4.3 集合的操作方法

#增加元素——S.add(x)
stars = {"刘德华","张学友","张曼玉"}
stars.add("王祖贤")
stars      #结果    {'刘德华', '张学友', '张曼玉', '王祖贤'}#移除元素——S.remove(x)
stars.remove("王祖贤")
stars      #结果    {'刘德华', '张学友', '张曼玉'}#集合的长度——len(S)
len(stars)     #结果    3#集合的遍历——借助for循环
for star in stars:print(star)
'''
输出结果
张学友
刘德华
张曼玉
'''

总结

Python基础+数据科学入门（三）组合数据类型相关推荐

【深度之眼Python基础+数据科学入门训练营】第四章组合数据类型
第四章组合数据类型 4.1 列表 4.1.1 列表的表达序列类型:内部元素有位置关系,能通过位置序号访问其中元素列表是一个可以使用多种类型元素,支持元素的增.删.查.改操作的序列类型 ls = ...
【深度之眼Python基础+数据科学入门训练营】第八章文件、异常和模块
第八章文件.异常和模块实际应用中,我们绝大多数的数据都是通过文件的交互完成的 8.1 文件的读写 8.1.1 文件的打开文件的打开通用格式 with open("文件路径", ...
Python基础+数据科学入门（七）
声明:该博客参考深度之眼的视频课程,如有侵权请联系小编删除博文,谢谢! 若总结有所失误,还请见谅,并欢迎及时指出. 文件.异常和模块 1.1 文件的读写 1.1.1 文件的打开文件的打开通用格式 w ...
Python基础+数据科学入门（六）类
声明:该博客参考深度之眼的视频课程,如有侵权请联系小编删除博文,谢谢! 若总结有所失误,还请见谅,并欢迎及时指出. 类-面向对象编程 #创建类 class Cat(): #初始化属性def __ini ...
Python基础总结（五）组合数据类型
目录第五章:组合数据类型一.列表: (一)列表元素查找: (二)列表元素添加: (三)列表元素排序: (四)列表元素修删: (五)列表生成式(推导式): (六):zip() 和enumerate( ...
使用Python进行数据科学入门
数据科学是计算领域一个令人兴奋的新领域,它围绕分析,可视化,关联和解释我们的计算机收集的有关世界的无限信息而建立. 当然,称其为"新"领域有点不屑一顾,因为该学科是统计,数据分析和 ...
python loadtxt_Python 数据科学入门2：Matplotlib
第七章从文件加载数据很多时候,我们想要绘制文件中的数据. 有许多类型的文件,以及许多方法,你可以使用它们从文件中提取数据来图形化. 在这里,我们将展示几种方法. 首先,我们将使用内置的csv模块加 ...
有前途的人工智能大数据分析相关职业：Python数据科学入门之路
2019独角兽企业重金招聘Python工程师标准>>> 为什么学习Python数据科学? Python是数据科学职业所需的宝贵技能之一.Python是数据科学的首选编程语言. 201 ...
Python 数据科学入门教程：机器学习：回归
Python 数据科学入门教程:机器学习:回归原文:Regression - Intro and Data 译者:飞龙协议:CC BY-NC-SA 4.0 引言和数据欢迎阅读 Python 机器 ...

Python基础+数据科学入门（三）组合数据类型