【深度之眼Python基础+数据科学入门训练营】第四章 组合数据类型
第四章 组合数据类型
4.1 列表
4.1.1 列表的表达
- 序列类型:内部元素有位置关系,能通过位置序号访问其中元素
- 列表是一个可以使用多种类型元素,支持元素的增、删、查、改操作的序列类型
ls = ["Python", 1989, True, {"version": 3.7}]
print(ls)
['Python', 1989, True, {'version': 3.7}]
- 另一种产生方式:list(可迭代对象)
- 可迭代对象包括:字符串、元组、集合、range()等
字符串转列表
print(list("人工智能是未来的趋势"))
['人', '工', '智', '能', '是', '未', '来', '的', '趋', '势']
元组转列表
print(list(("我", "们", "很", "像")))
['我', '们', '很', '像']
集合转列表
print(list({"李雷", "韩梅梅", "Jim", "Green"}))
['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()转列表
print(list(range(1, 11, 2)))
[1, 3, 5, 7, 9]
4.1.2 列表的性质
- 列表的长度——len(列表)
ls = [1, 2, 3, 4, 5]
len(ls)
5
- 列表的索引——与同为序列类型的字符串完全相同
变量名[位置编号]
正向索引从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']
4.1.3 列表的操作符
- 用list1+list2的形式实现列表的拼接
a = [1, 2]
b = [3, 4]
a+b # 该用法用的不多
[1, 2, 3, 4]
- 用 n*list 或 list*n 实现列表的成倍复制
初始化列表的一种方式
[0]*10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
4.1.4 列表的操作方法
1、增加元素
- 在末尾增加元素——列表.append(待增元素)
languages = ["Python", "C++", "R"]
languages.append("Java")
print(languages)
['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、列表的复制
- 错误的方式
languages = ['Python', 'C', 'R','Java']
languages_2 = languages
print(languages_2)
['Python', 'C', 'R', 'Java']
languages.pop()
print(languages)
print(languages_2)
['Python', 'C', 'R']
['Python', 'C', 'R']
正确的方式——浅拷贝
方法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.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
4.2 元组
4.2.1 元组的表达
- 元组是一个可以使用多种类型元素,一旦定义,内部元素不支持增、删和修改操作的序列类型
通俗的讲,可以将元组视作“不可变的列表”
names = ("Peter", "Pual", "Mary")
4.2.2 元组的操作
- 不支持元素增加、元素删除、元素修改操作
- 其他操作与列表的操作完全一致
4.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)
print(b)
9
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 小强
4.3 字典
4.3.1 字典的表达
- 映射类型: 通过“键”-“值”的映射实现数据存储和查找
- 常规的字典是无序的
students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(students)
{201901: '小明', 201902: '小红', 201903: '小强'}
字典键的要求
- 1、字典的键不能重复
students = {201901: '小明', 201901: '小红', 201903: '小强'}
print(students)
{201901: '小红', 201903: '小强'}
2、字典的键必须是不可变类型,如果键可变,就找不到对应存储的值了
不可变类型:数字、字符串、元组。 一旦确定,它自己就是它自己,变了就不是它了。
可变类型:列表、字典、集合。 一旦确定,还可以随意增删改。
d1 = {1: 3}
d2 = {"s": 3}
d3 = {(1,2,3): 3}
d = {[1, 2]: 3}
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)<ipython-input-68-bf7f06622b3f> in <module>
----> 1 d = {[1, 2]: 3}TypeError: unhashable type: 'list'
d = {{1:2}: 3}
---------------------------------------------------------------------------TypeError Traceback (most recent call last)<ipython-input-69-188e5512b5fe> in <module>
----> 1 d = {{1:2}: 3}TypeError: unhashable type: 'dict'
d = {{1, 2}: 3}
---------------------------------------------------------------------------TypeError Traceback (most recent call last)<ipython-input-70-c2dfafc1018a> in <module>
----> 1 d = {{1, 2}: 3}TypeError: unhashable type: 'set'
4.3.2 字典的性质
- 字典的长度——键值对的个数
students = {201901: '小明', 201902: '小红', 201903: '小强'}
len(students)
3
- 字典的索引
通过 字典[键] 的形式来获取对应的值
students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(students[201902])
'小红'
4.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)+1print(d)
# print(d)
{}
{'牛': 1}
{'牛': 1, '奶': 1}
{'牛': 1, '奶': 2}
{'牛': 1, '奶': 2, '找': 1}
{'牛': 1, '奶': 2, '找': 1, '刘': 1}
{'牛': 1, '奶': 3, '找': 1, '刘': 1}
{'牛': 1, '奶': 4, '找': 1, '刘': 1}
{'牛': 1, '奶': 4, '找': 1, '刘': 1, '买': 1}
{'牛': 2, '奶': 4, '找': 1, '刘': 1, '买': 1}
{'牛': 2, '奶': 5, '找': 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 集合
4.4.1 集合的表达
- 一系列互不相等元素的无序集合
- 元素必须是不可变类型:数字,字符串或元组,可视作字典的键
- 可以看做是没有值,或者值为None的字典
students = {"小明", "小红", "小强", "小明"} #可用于去重
print(students)
{'小强', '小明', '小红'}
4.4.2 集合的运算
- 小例子 通过集合进行交集并集的运算
Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
print(Chinese_A)
{'刘德华', '古天乐', '张学友', '张曼玉', '林青霞', '钟楚红'}
Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"}
print(Math_A)
{'刘德华', '张曼玉', '林青霞', '王祖贤', '郭富城', '黎明'}
- 语文和数学两门均为A的学员
- S & T 返回一个新集合,包括同时在集合S和T中的元素
print(Chinese_A & Math_A)
{'刘德华', '张曼玉', '林青霞'}
- 语文或数学至少一门为A的学员
- S | T 返回一个新集合,包括集合S和T中的所有元素
print(Chinese_A | Math_A)
{'刘德华', '古天乐', '张学友', '张曼玉', '林青霞', '王祖贤', '郭富城', '钟楚红', '黎明'}
- 语文数学只有一门为A的学员
- S ^ T 返回一个新集合,包括集合S和T中的非共同元素
print(Chinese_A ^ Math_A)
{'古天乐', '张学友', '王祖贤', '郭富城', '钟楚红', '黎明'}
- 语文为A,数学不为A的学员
- S - T 返回一个新集合,包括在集合S但不在集合T中的元素
print(Chinese_A - Math_A)
{'古天乐', '张学友', '钟楚红'}
- 数学为A,语文不为A的学员
print(Math_A - Chinese_A)
{'王祖贤', '郭富城', '黎明'}
4.4.3 集合的操作方法
- 增加元素——S.add(x)
stars = {"刘德华", "张学友", "张曼玉"}
stars.add("王祖贤")
print(stars)
{'刘德华', '张学友', '张曼玉', '王祖贤'}
- 移除元素——S.remove(x)
stars.remove("王祖贤")
print(stars)
{'刘德华', '张学友', '张曼玉'}
- 集合的长度——len(S)
len(stars)
3
- 集合的遍历——借助for循环
for star in stars:print(star)
张学友
张曼玉
刘德华
【深度之眼Python基础+数据科学入门训练营】第四章 组合数据类型相关推荐
- 【深度之眼Python基础+数据科学入门训练营】第八章 文件、异常和模块
第八章 文件.异常和模块 实际应用中,我们绝大多数的数据都是通过文件的交互完成的 8.1 文件的读写 8.1.1 文件的打开 文件的打开通用格式 with open("文件路径", ...
- Python基础+数据科学入门(七)
声明:该博客参考深度之眼的视频课程,如有侵权请联系小编删除博文,谢谢! 若总结有所失误,还请见谅,并欢迎及时指出. 文件.异常和模块 1.1 文件的读写 1.1.1 文件的打开 文件的打开通用格式 w ...
- Python基础+数据科学入门(三)组合数据类型
声明:该博客参考深度之眼的视频课程,如有侵权请联系小编删除博文,谢谢! 若总结有所失误,还请见谅,并欢迎及时指出. 组合数据类型 1.1 列表 1.1.1 列表的表达 列表类型:内部元素有位置关系,能 ...
- Python基础+数据科学入门(六)类
声明:该博客参考深度之眼的视频课程,如有侵权请联系小编删除博文,谢谢! 若总结有所失误,还请见谅,并欢迎及时指出. 类-面向对象编程 #创建类 class Cat(): #初始化属性def __ini ...
- 深度之眼 - Python学习笔记——第四章 组合数据类型
第四章 组合数据类型 4.1 列表 列表是可变的! 4.1.1 列表的表达 序列类型:内部元素有位置关系,能通过位置序号访问其中元素 列表是一个可以使用多种类型元素,支持元素的增.删.查.改操作的序列 ...
- 使用Python进行数据科学入门
数据科学是计算领域一个令人兴奋的新领域,它围绕分析,可视化,关联和解释我们的计算机收集的有关世界的无限信息而建立. 当然,称其为"新"领域有点不屑一顾,因为该学科是统计,数据分析和 ...
- python中系列的含义_python中四种组合数据类型的含义、声明、增删改查,遍历
一.列表 列表:list 可以存储多个有顺序的可以重复的数据的类型 其他语言:数据:python中~提供的是列表[不说数组] 列表:操作数据:增加.删除.修改.查询 [CRUD] append/ins ...
- python loadtxt_Python 数据科学入门2:Matplotlib
第七章 从文件加载数据 很多时候,我们想要绘制文件中的数据. 有许多类型的文件,以及许多方法,你可以使用它们从文件中提取数据来图形化. 在这里,我们将展示几种方法. 首先,我们将使用内置的csv模块加 ...
- 有前途的人工智能大数据分析相关职业:Python数据科学入门之路
2019独角兽企业重金招聘Python工程师标准>>> 为什么学习Python数据科学? Python是数据科学职业所需的宝贵技能之一.Python是数据科学的首选编程语言. 201 ...
最新文章
- Python数据类型判断常遇到的坑
- 正则基础学习1 这俩天补上正则全部内容,让你简单的学会正则,欢迎收藏当文档
- Flink 1.11 SQL 十余项革新大揭秘,哪些演变在便捷你的使用体验?
- java htmlparser 使用教程_HTMLParser使用详解(1)
- 【OpenCV 例程200篇】99. 修正阿尔法均值滤波器
- 一个很不错的技术网站
- json过滤某些属性 之@jsonignore
- Presto?还是 Hive? 你们知道大数据查询性能谁更强吗?
- Go语言学习笔记(八)
- iperf3 网络探测详解(android、iOS、windows)
- 消费者运营咨询顾问认证
- IDM下载器Windows系统是最快的下载工具
- html仿QQ资料卡,JS实现的模仿QQ头像资料卡显示与隐藏效果
- 多项创新功能驱动,Galaxy S9必将引爆2018智能手机市场
- win10 语言栏跳出来,如何调回去
- 小世界效应:从凯文·贝肯到六度分隔理论(1)
- 图解Adobe Flash Player 浏览器插件安装
- 研究生学php丢不丢人,研究生压力过大?导师给研究生朋友的一些建议
- java 服务器文件下载
- 联通云服务器安全性能怎么样,云安全解决方案