Python基础总结02——容器型数据类型
温馨提示：对于容器型数据类型在变量命名时，要做到看名知意。里面存放多个元素，变量名应用复数形式，同样避开关键字和保留字
1. 列表
1.1 何为列表
- 列表是一种可变的数据类型
- 通过“[]”存储数据，里面的每一个数据称为元素
- 列表是一种有序的序列
- 列表数据结构在编程中应用范围很广泛
1.2 如何创建列表
- 通过字面量创建列表
lis=[1,2,4,5]
print(type(lis)) # <class 'list'>
- 通过构造器创建列表
lis=list(range(5))
print(lis)
# [0, 1, 2, 3, 4]
- 通过生成式创建列表，常常采用
lis=[i for i in range(10)]
print(lis)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1.3 列表的遍历、索引和切片
- 索引，通过列表的下标获取某个元素。索引从0 开始到列表元素个减1 结束，包括正向索引和逆向索引
- 切片，获取在该范围内的列表元素。
lis=[1,2,4,5]
print(lis[2]) # 取出第3个元素 4
print(lis[:]) # 取出所有元素
print(lis[1:3]) # 取出第2个到3个元素
print(lis[::-1]) # 从后往前取出每一个元素
- 通过遍历可以将元素的一个个取出
# 遍历列表的三种方法
# 方法1
for i in range(len(list2)):
print(list2[i],end=' ')
# 方法2
for x in list2:
print(x,end=' ')
# 方法3
for i,x in enumerate(list2):
print(i,x,end=' ')
1.4 列表的常用操作
| 函数 | 功能 | 使用注意事项 |
|---|---|---|
| reverse | 对列表反转 | |
| pop | 默认删除最后一个元素 | |
| index | 返回某个元素的索引 | 元素必须存在，否则会报错 |
| count | 统计某个元素出现的次数 | |
| clear | 清空 | |
| append | 在末尾追加元素 | |
| extend | 扩展列表，相当于列表直接相加 | |
| insert | 在指定位置下插入元素 | |
| remove | 删除指定元素 | |
| sort | 对列表进行排序，可以通过key参数设定排序方式 |
# 3.列表的运算
list4 = [1, 2, 3]
# # 重复运算
# list4=[1,2,3]*5
# 判断是否存在该元素,要么返回True，要么返回False
print(10 in list4)
print(10 not in list4)
# # 合并
# list5 = [1, 3]
# list6 = [2, 4]
# print(list5 + list6)
# # 比较
# list7 = list(range(1, 8, 2))
# list8 = [1, 3, 5, 7]
# # 两个列表对应元素比较
# print(list7 == list8)
# # 第一个大就大，不再往后面比较
# print(list7 >= list8)
# 添加元素
# list8.append(1)
# list8.insert(1,3)
# 删除元素
list=[1,23,34,2]
list.pop()
list.pop(0)
list.remove(23)
list.clear()
# 查找元素是否存在,返回索引
list=['tian', 'yu', 'ping']
num=list.index('tian') # 如果该元素不存在会出现 “ValueError: 'tia' is not in list”错误
print(num)
# 防止出现报错，解决如下：
if 'tian' in list:
print(list.index('yu'))
# 统计某个元素在列表中出现的次数
print(list.count('yu'))
# 列表排序
list2=[1,23,4,5]
# reverse=True-->降序
list2.sort(reverse=True)
print(list2)
不占用其它内存，实现打乱列表元素顺序
-
random.shuffle
import random list1=[i for i in range(1,10,2)] random.shuffle(list1) print(list1) # [3, 1, 7, 9, 5] -
以上仅仅列出一些常用，还需自行研究
1.5 列表的应用
1.5-1 模拟斗地主发牌
- 用一个列表保存54张扑克牌，洗牌，按斗地主的发牌方式把牌发给三个玩家，
多的3张牌给第一个玩家（地主），把每个玩家手上的牌显示出来
import random
others = ['J', 'Q', 'K', 'A']
colors = ['♠', '♥', '♦', '♣']
# 储存牌
cards = [j + str(i) for i in range(2, 11) for j in colors] + [j + i for i in others for j in colors]
cards = cards + ['大王', '小王']
# 洗牌
random.shuffle(cards)
players = [[] for _ in range(3)]
for _ in range(17):
for player in players:
player.append(cards.pop())
players[0] += cards
for player in players:
player.sort(key=lambda x: x[1:])
for card in player:
print(card, end=' ')
print()
1.5-2 去除列表中重复元素
- 程序分析，创建一个临时列表，遍历要去重的列表判断是否在临时列表中，不在就追加到临时列表中。
list1=[1,3,4,2,1,3]
temp=[]
for lis in list1 :
if lis not in temp:
temp.append(lis)
- 不考虑顺序，可以直接通过集合的互异性特点直接去重
2. 元组
2.1 何为元组
- 通过“（）”来存储多个数据的容器
- 元组是一种不可变的数据容器，不可以修改
2.2 创建元组
- 字面量方法
tup1=(1,) # 一元组
tup2=(1,2,3,4) # 四元组
- 构造器方法
tup1=tuple(range(1,2))
print(tup1) # (1,)
tup2=tuple([1,2,4,3])
print(tup2) #(1, 2, 4, 3)
2.3 元组的遍历、索引和切片
- 索引和切片
tuples = ('hell',)
fruits1 = ('apple', 'banana', 'pitaya')
# 切片和索引
print(fruits1[::-1])
print(fruits1[:3])
print(fruits1[1:2]) # ('banana',)
- 遍历
fruits1 = ('apple', 'banana', 'pitaya')
for fru in fruits1 :
print(fru)
for i in range(len(fruits1)):
print(i)
2.4 元组的基本操作
- 元组是一种不仅可变的数据类型限制了它的操作
fruits1 = ('apple', 'banana', 'pitaya')
# 成员运算
print('apple' in fruits1)
# 不支持修改
# 'tuple' object doesn't support item deletion
# del fruits1[0]
tup2=tuple([1,2,4,3,1])
print(tup2)
print(tup2.count(1)) # 2
- 元组的应用比较少
2.5 元组的unpack/ pack
- *b :可变变量，解决元组unpack/pack变量不足问题
a, *b, c = 1, 3, 5, 4, 5
print(a)
print(b, type(b)) # [3, 5, 4] <class 'list'>
print(c)
# ValueError: too many values to unpack (expected 3)
# a,b,c=1,23,42,534
# TypeError: cannot unpack non-iterable int object
# a,b=1
3. 字符串
3.1 何为字符串
- 所谓字符串，通过字符之间自由的组合在一起构成字符串
- 字符串是不可变数据类型，也就意味着不可修改元素
- 字符串也是一个有序序列
3.2 创建字符串
- ’‘’ ‘’‘ 或“” “”“可以实现折行显示
- 转义字符，改变字符原来的意义
a='hello,world'
b='''
明天你是否想起
曾经最爱哭的你！
'''
print(a)
print(b)
a='\'add\''
b='"ddff"'
c="'ddff'"
d="\"sidhi\""
print(b)
print(a)
print(c)
print(d)
3.3 字符串的遍历、索引和切片
- 索引和切片
s='hello,world!'
print(s[2]) # l
print(s[-1]) # !
print(s[::2]) # hlowrd
- 遍历
s='hello,world!'
for i in s:
print(i)
# 方式2
for i in s:
print(i,end=' ')
3.4 字符串的基本操作
| 函数 | 功能 |
|---|---|
| count | 统计某个字符出现的次数 |
| index | 返回该字符串第一个字符出现的小标 |
| strip | 默认去除空格，可以指定 |
| find | 返回该字符第一次出现的索引 |
| join | 连接 |
| split | 将字符串按指定方式分割，返回一个列表 |
| lower | 转换为小写 |
| upper | 转换为大写 |
- 字符串的格式化输出
contexts = 'hello,world!'
print(contexts.center(80, '='))
print(contexts.rjust(80, '+'))
print(contexts.ljust(80, '+'))
print(contexts.zfill(20)) # 不够左边补0填充
a,b=12,34
print(f'{a}+{b}={a+b}')
print('{}+{}={}'.format(a,b,a+b))
print('{0}+{1}={2}'.format(a,b,a+b))
print(f'{a}/{b}={a/b:.2%}')
print(f'{a}*{b}={a*b:.2e}')
print(f'{a:<10d}')
print(f'{a:0>10d}')
- split、strip的 运用
contexts = 'hello,world!'
print(contexts.strip('!'))
print(contexts.strip('!').split(','))
print(','.join(contexts.strip('!').split(','))+'!')
a=','.join(contexts.strip('!').split(','))+'!'
print(f'\'{a}\'')
# hello,world
# ['hello', 'world']
# hello,world!
# 'hello,world!'
- 注意：字符串的比较运算规则，从左往右边依次比较，一大就大不再往后比较
3.5 字符串的应用
3.5-1 数字相加
- 求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。
例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。
程序分析： 通过字符串的拼接，然后再转换为整数
num=input('输入要相加的数范围1~9：')
n=int(input('输入要累计相加几次：'))
total=0
for _ in range(n):
total+=int(num)
num+=num
4. 集合
4.1 何为集合
- python中的集合和我们以前上高中学的数学课本几乎一样，我们通常把具有相似特征的对象归纳为某类，把这个类抽象为集合的概念。
- 集合的3大特征
- 无序性 ，每一个元素是没有顺序的
- 互异性，不允许有相同的元素
- 确定性，集合中每一个元素都是确定的，不产生歧义
- 集合不能通过下标索引取元素
4.2 创建集合
# 创建一个空集合
set1=set() # 不能直接用set1={}来表示一个空集合，这样创建出来的python解释器会解释为后面的字典数据类型
# 字面量方法
set2={1,2,4,5,3}
# 构造器方法
set3=set(range(5))
print(set3) # {0, 1, 2, 3, 4}
# 生成式方法
set4={i for i in range(1,10,2)}
print(set4) # {1, 3, 5, 7, 9}
4.3 遍历集合
set1={1,2,4,5,3}
for num in set1:
print(num)
4.4 集合的基本操作
-
python的集合运算，其实也就是我们数学上的运算用编程的思想来实现
-
常用的有交集（&）、并集（|）、差集（-）、对称差（^）
set1 = {1, 2, 3, 4, 6, 7}
set2 = {1, 3, 55, 56}
# & 交集
print(set1 & set2)
print(set1.intersection(set2))
# | 并集
print(set1 | set2)
print(set1.union(set2))
# - 差集
print(set1 - set2)
print(set1.difference(set2))
# ^ 对称差
print(set1 ^ set2)
print((set1 | set2) - (set1 & set2))
print(set1.symmetric_difference(set2))
# 判断真子集
print(set1 < set2)
# 判断子集
print(set1 <= set2)
# 判断超集
print(set1 > set2)
- 集合的成员运算
# 集合的成员运算远远高于列表的成员运算
print(1 in set1) # 体现确定性，要么在集合中，要么不在集合中。
print(1 not in set1)
4.5 集合的应用
4.5-1 去除列表中重复元素
lis=[1,2,4,5,6,3,2,2]
lis=list(set(lis))
# 如果要保证元素有序
list1= [1,2,4,5,6,3,2,2]
list2=list(set(list1))
list2.sort(key=list1.index) # 通过元素下标来设置排序
print(list2) # [1, 2, 4, 5, 6, 3]
5. 字典
5.1 何为字典
-
字典是python独有的数据结构，在c、java编程语言中没有字典这一数据结构
-
通过键值对的方式来保存数据（key:value）
-
底层用hash存储，k-value，键只能是不可变数据类型
5.2 创建字典
- 字面量方法
dict1 = {'a':1,'b':2,'c':2}
2. 构造器方法
dict1=dict(id='20181703034',name='yuping',age=23,brithday='11-09')
- 生成式方法
dict2={i:i*2 for i in range(10)}
list1=[(1,2),(3,4),(5,6)]
dict3={i[0]:i[0] for i in list1}
- 列表的生成式方法
list1 = [i for i in range(10)]
import random
list2=[random.randrange(10,100) for _ in range(10)]
- 集合的生成式方法
set1={i for i in range(10)}
print(set1,type(set1))
# {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>
5.3 遍历字典
- 通过键遍历
dict2={i:i*2 for i in range(10)}
for k in dict2 :
print(dict2[k])
# 方法二
for k in dict1.keys():
print(dict1[k])
- 通过值遍历
dict2={i:i*2 for i in range(10)}
for v in dict2.values :
print(v)
- 通过键值对遍历
dict2={i:i*2 for i in range(10)}
for k,v in dict2.items():
print(k,v)
5.4 字典的基本操作
- 添加元素
student = dict(id='2103208', name='tian', sex=True, brithday='11-9')
# 字典的索引放在赋值运算符的左边
# 如果存在对于的键,修改原来的值，否则添加新的键值对,相当于student.update()方法
student['id'] = '20181703034' # 修改原来的值
student['address'] = '贵州镇远' # 添加新的键值对
print(student)
- 删除元素
# 删除键值对
print(student.pop('id')) # 返回被删除的值
# del student['salary'] # KeyError: 'salary',必须保证键存在
del student['sex']
print(student)
- 判断元素是否存在
dict2={i:i*2 for i in range(1,10)}
print(dict2)
# 通过键来确定元素是否存在
print(2 in dict2) # True
print(5 in dict2) # True
- 获取元素
dict1 = {'a':1,'b':2,'c':3}
print(dict['a']) # 当键不存在时会报，KeyError:
print(dict1.get('a')) # 返回对应的值，但不存在的时候默认返回None。也可以指定放回指
- 更新元素
dict1 = {'a':1,'b':2,'c':3}
dict1 = {'a':1,'b':2,'c':3}
dict1.update(a=23) # 存在就修改
dict1.update(d=34) # 不存在就添加
print(dict1) # {'a': 23, 'b': 2, 'c': 3, 'd': 34}
zip()函数的使用
- 实现字典的键和值的交换
dict1={'a': 23, 'b': 2, 'c': 3, 'd': 34}
dict1=dict(zip(dict1.values(),dict1.keys()))
print(dict1) # {23: 'a', 2: 'b', 3: 'c', 34: 'd'}
- sorted()函数排序的使用
list1=['asf','123','sff','1235']
print(sorted(list1,key=list1.count,reverse=True))
print(sorted(list1,key=len,reverse=True))
5.5 字典的应用
5.5-1 初步感知网络数据采集
import requests
word=input('输入你要分类的关键词：')
# 获取请求，得到服务器的响应
resp=requests.get(
url='http://api.tianapi.com/txapi/lajifenlei/index',
params={'key':'0e2d040891cd207acfbf3da2cda513ba','word':word}
)
# 通过json转换为字典，获取字典中需要数据的键
new_list=resp.json()['newslist']
# 遍历打印结构
for new in new_list:
print(f"物品：{new['name']}")
print(f"解释：\n{new['explain']}")
print(f"放入方式：\n{new['contain']}")
print(f"提示：\n{new['tip']}")
总结
通过上述的几种用来存储数据的方式，作为后面的函数学习大小良好的基础。特别是列表和字典的应用十分广泛也非常灵活，完全掌握也是一大难点，后面还需多加练习。
语录
学习的过程是可能需要付出很多心血, 但坚持是成为一个优秀数据分析师必然要经历的过程。
数据分析的学习之路, 并不是学的越多越好, 而是要将学习的方向明确好, 再使正确的力, 这样才可以在正确的方向 做正确的事。
码字不易， 求个赞哈,
扫一扫
1254
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
