容器型数据

最新推荐文章于 2024-11-15 10:17:44 发布

独独孤嘟咕噜嘟噜将军803

最新推荐文章于 2024-11-15 10:17:44 发布

阅读量62

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_64569035/article/details/132674358

版权

容器型数据

为什么会使用容器型数据？
变量：变化的数据
在编程中的操作：定义一个标识符来记录变化的数据
有些时候，需要记录数据的变化，变化的数据都保存起来，就需要容器型的数据来进行数据储存

列表

列表list:

可变的有序型容器

可变：数据的值可以发生变化，可以修改、增加、删除

有序：容器存储放数据的时候，容器中有多少个数据，会给数据设置编号，编号是从0开始
可以通过编号定位获取这个位置的数据，也可以修改删除等
这个编号被称为下表、索引等

数据在进行定义的时候，数据标识是[]，在[]中可定义多个数据，数据之间使用逗号分隔
比如[19,24,26,22,34]
数据中的编号为 0,1,2,3,4

air_temp = 19

air_temp = 24
print(air_temp)

air_temp = 26
print(air_temp)

air_temp = 22
print(air_temp)

air_temp_list = [19, 24, 26, 22, 19, 37]
print(air_temp_list)

"""
1.获取列表中元素的个数
    len(数据/变量名)
"""
print(len(airtemp_list))  # 7
"""
2. 下标：数据的一个编号，可以通过这个编号获取数据，也可以修改、删除等
    一般的编程语言中，编号就是从左到右，从0开始，加1递增
    Python对于下标有两种表达形式
        1. 正向索引 --- 从左到右
            1,2,3,4,5,6,7，··· -len(数据)
        2. 负向索引 --- 从右向左
            -1,-2,-3,-4,-5,··· -len(数据)
    获取数据的时候可以使用正向索引，也可以使用负向索引
    格式：
        列表数据[下标] ====> 代表的是获取这个位置的数据
        列表数据[下标] = 数据值 ====> 代表的是修改这个位置的数据
    注意：
        下标不能超过编号的界限，否则会报错    
"""

7点  9点  11点  1点  2点  3点  6点
0    1    2     3   4    5   6  正向索引
-7   -6   -5   -4   -3  -2   -1 负向索引

airtemp_list = [17, 19, 22, 26, 30, 28, 26]
# 获取9点  【第二个位置的数据】
print(airtemp_list[1])    # 正向索引获取的
# 使用负向索引
print(airtemp_list[-len(airtemp_list) + 1])

# 获取左边的使用正向，获取右边的使用负向
# airtemp_list.pop()  # 把最后一个删除了   [17, 19 22, 26, 30, 28]
# airtemp_list[6]   # IndexError: list index out if range
# 获取倒数第一个位置
print(airtemp_list[len(airtemp_list) - 1])  # 正向索引
print(airtemp_list[-1])   # 负向索引

# 修改这个数据的位置
airtemp_list[-3] = 33
print(airtemp_list)  # [17, 19, 22, 26, 33, 28, 26]
# 列表是可变的，所有的操作都影响数据列表本身
# 操作完查看数据变化，直接打印列表本身即可

切片(slice): 提取子序列

本质上根据下标定位到容器相应的位置，从指定的启示位置按照步长取元素去
格式：

列表数据[启示下标:结束下标:步长]

步长为整数，代表的是正向切片【根据位置从左向右按照步长取值】
注意：起始下标定位的位置，要在结束下标定位的位置，的左边

步长为负数，代表的是负向切片【根据位置从右向左按照步长取值】
注意：起始下标定位的位置，要在结束下标定位的位置，的右边

解读：

:步长可以省略，步长默认为1
列表数据[起始下标:结束下标]
代表从起始下标对应的元素开始，逐个取值，到结束下标对应的位置[结束下标不包含]

:起始下标可以省略
看步长为正还是负
步长为正，代表从最左边开始
步长为负，代表从最右边开始

:结束下标也可以省略
看步长为正还是负
步长为正，代表到最右边结束
步长为负，代表到最右边结束

scores = [76, 28, 39, 45, 57, 82, 91, 68]  # 8个数据
# 0 1 2 3 4 5 6 7
sub_scores = scores[1:7:1]
print(sub_scores)

# 等价于
sub_scores = scores[1:7]
print(sub_scores)
# 等价于 只是按照下标定位到列表相应的位置范围
sub_scores = scores[1:-1]
print(sub_scores)

# 前三个
sub_scores = scores[:3]
print(sub_scores)

# 后三个
sub_scores = scores[-3:]
print(sub_scores)

# 翻转
sub_scores = scores[::-1]
print(sub_scores)

sub_scores = scores[::2]
print(sub_scores)

增加数据的操作：

1.列表数据.append(数据) 把数据追加到列表的末尾

2.列表数据.insert(指定位置，数据) 在指定位置添加数据，原位置及其之后的数据否向后移一个

course_list = ['语文', '数学', '英语', '体育']
# 增加一门Python课程
course_list.append('Python')
print(course_list)
# 在1的位置添加政治
course_list.insert(1, '政治')
print(course_list)

删除数据的操作：

1.列表数据.remove(数据) 将数据在列表中移除，如果数据有多个的话，只会移除出现的第一个

2.列表数据.pop() 将列表中最后一个元素移除

3.列表数据.pop(位置) 将列表中指定位置的元素移除

4.列表数据.clear() 清空列表

course_list.remove('英语')
print(course_list)

course_list.pop()
print(course_list)

course_list.pop(0)
print(course_list)

course_list.clear()
print(course_list)

关于列表遍历的操作

1.获取下标序列，根据下标提取数据值

2.遍历列表，获取列表中的元素

nums = [18, 29, 33, 56, 71, 28, 42, 56, 37 ]

for pos in range(len(nums)):  # 0 1 2 3 4 5 6··· 长度-1
    print(nums[pos])

print('=============')
for ele in nums:
    print(ele)
print('==========')
# 获取列表中所有的偶数
# 定义一个新的列表 用来存储所有的偶数
even_list = []
for n in nums:
    if n % 2 == 0:
        even_list.append(n)
print(even_list)
print('====================')
# 获取所有偶数所在的位置
pos_list = []
for i in range(len(nums)):
    if nums[i] % 2 == 0:
        pos_list.append(i)
print(pos_list)

# 获取所有偶数及其对应的位置
# 遍历位置
for j in range(len(nums)):
    if nums[j] % 2 == 0:
        print(j,nums[j])
print('==============')

enumerate(有序容器数据)====> 产生一个新的容器 ====> [(位置，元素),(位置，元素),(位置，元素)···]

# 二维结构 列表嵌套
for item in enumerate(nums):
    print(item)

拆包：把容器中的数据赋值给N个变量：把容器拆解，这个过程叫做拆包

a,b = [11,23]
print(a,b)
print('===============')
# 利用拆包的原理
for m, n in enumerate(nums):
    # m接受的位置，n接受的元素
    if n % 2 == 0:
        print(m,n)

列表推导式

列表推导式

产生新列表 — 遍历简化的格式
[循环体 for 变量 in 容器型数据 if 判断条件]

even_list = []
for n in nums:
    if n % 2 == 0:
        even_list.append(n)
print(even_list)
# 列表推导式等价如下
result = [n for n in nums if n % 2 == 0]
print(result)

# 有些需求不一定是有判断的，if判断条件的存在是按照需求来决定有或没有的
values = [1, 2, 3, 4, 5]
# ====> [1, 4, 9, 16, 25]
pow_list = []
for d in values:
    pow_list.append(d ** 2)
print(pow_list)

print([d ** 2 for d in values])

"""
max(容器型数据)  获取容器中的最大值
min(容器型数据)  获取容器中的最小值
sum(容器型数据)  对容器型数据求和
"""
scores = [18, 29, 33, 56, 71, 28, 42, 56, 37 ]
print(max(scores))
print(min(scores))
print(sum(scores))

元组

元组(tuple)

和列表是类似的

列表是可变的有序序列，元组是不可变的有序序列

什么时候使用元组？数据元素确定，且不会发生变化，就可以使用元组
31天的月份 1，3,5,7,8,10,12

元组的数据标记是()，列表是[]
提高运算符优先级也用的()

注意：一元组[元组中只有1个数据]定义的时候，元素后面必须加逗号，否则会被识别成提高运算符优先级

nums = (11)
nums1 = (11,)
print(type(nums), type(nums1))  # int , tuple

# 判断输入的月份是否有30天
month = int(input('请输入月份:'))
year = int(input('请输入年份：'))
# if month == 4 or month == 6 or month == 9 or month == 11:
#     print(month,'有30天')

if month in (4,6,9,11):
    print(year,'年',month,'月有30天')
elif month in (1,3,5,7,8,10,12):
    print(year,'年',month,'月有30天')
else:
    if (year % 4 == 0 and year % 100 != 0)or (year % 400 == 0):
        print(year, '年', month, '月有29天')
    else:
        print(year, '年', month, '月有28天')

nums = (11, 23, 45, 67, 78, 89)
print(nums[:3])

nums[0] = 19  # 不支持元素修改

print(nums[-1]) # 可以访问

# 当给一个变量，赋值的时候使用逗号分隔开多个数据，这个多个数据进行打包的操作
values = 11, 23, 45, 56, 76, 87
print(type(values))  # tuple

# 解包：把一个容器中多个数据赋值给多个变量
a, b, c = 11, 22, 33
print(a, b, c)

for item in enumerate([12, 34, 56, 71]):
    print(item)  # (0,12)  将位置和该位置的元素结合成元组，放在一个新的容器A中，这个A就是一个二维容器

字符串

字符串：容器型数据，里面的元素都是字符[长度为1的字符串]

比如 ‘a’ ‘b’ ‘0’ 是不可变的有序序列

s = 'hello everyone'
# 获取元素个数
print(len(s))

# 可以通过下标获取字符
print(s[0])
print(s[-1])

print(s[:3])
print(s[-3:])

# s[0] = 'H'   字符串不可修改

"""
获取的操作
    1.字符串数据.find(子串)
        查找子串第一次出现的位置
    2.字符串数据.rfind(子串)
        查找子串最后一次出现的位置
    3.字符串数据.count(子串)
        统计子串出现的次数
"""

# 上方实例
s = 'hello everyone'
pos = s.find('e')
print(pos) # 1

pos = s.rfind('e')
print(pos) # 13

count = s.count('e')
print(count)

"""
转换的操作：
    将字符串中的相关符号进行转换【因为字符串不可变，产生的数据是影响不了原字符串的，都是产生一个新的数据】
    
    字符串数据.upper() 将字母大写
    字符串数据.lower() 将字母小写
    字符串数据.swapcase() 将大写变小写，将小写变大写
    字符串数据.title()  每个单词首字母大写 【单词：没连接在一起的就视为一个单词】
    字符串数据.capitalize() 首字母大写，其他小写
"""

# 上方实例
s = 'hello everyone'
new_s = s.upper()
print(s, new_s)

new_s1 = new_s.lower()
print(new_s1)

new_s2 = new_s.title()
print(new_s2)  # Hello Everyone

new_s3 = new_s2.swapcase()
print(new_s3)

new_s4 = new_s3.capitalize()
print(new_s4)

"""
判断的操作
    1. 是否以指定内容开头
        字符串数据.startswith(指定内容)
    2. 是否以指定内容结尾
        字符串数据.endswith(指定内容)
    3. 判断是否是纯数字
        字符串数据.isdigit()
    4. 判断字符串的内容是否为纯字母
        字符串数据.isalpha()
    5. 判断字符串的内容是否为数字或字母
        字符串数据.isalnum()
    6. 判断字符串中的字母是否为大写
        字符串数据.isupper()
    7. 判断字符串中的字母是否为小写
        字符串数据.islower()
"""

# 上方实例
s = 'Hello Everyone'
print(s.startswith('H'))
print(s.endswith('one'))

print(s.isalnum())  # False
print(s.isalpha())  # False
print(s[0].isupper())  # True
print(s[-3:].islower())  # True

print('123'.isdigit())

print('abc12'.isdigit())

字符串的切割与拼接

切割：

字符串数据.split(切割符)

将指定切割符为切割点，把字符串切割成N份，结果是一个列表

拼接：

‘拼接符’.join(容器型数据)

使用拼接符将容器中的元素拼接在一起

注意：容器中的元素必须是字符串类型的底层实现的时候使用的是 +号运算
+在字符串中完成的字符串拼接只能拼接字符串类型的

data = "hello my age is 18, my birthday is Swptember 5th"
print(data)
print(data.split(' '))  # ['hello', 'my', 'age', 'is', '18,', 'my', 'birthday', 'is', 'Swptember', '5th']

print(data.split('e'))  # ['h', 'llo my ag', ' is 18, my birthday is Swpt', 'mb', 'r 5th']

nums = [18,34,56,71,29]
# 使用+将其拼接在一起
print('+',join(nums))
# 报错，join要的是字符串类型，这个传递的是整形

# 拼接前转化为字符串
str(nums)   # 将攒紧的数据转化为字符串 ====>  '[18,34,56,71,29]'
str_nums = [str(ele) for ele in nums] ====> ['18','34','56','71','29']

"""
字符串格式化
        在指定宽度中居中显示  字符串.center(宽度，用什么填充)
        在指定宽度中居左显示  字符串.ljust(宽度，用什么填充)
        在指定宽度中居右显示  字符串.rjust(宽度，用什么填充)
"""

# 上方实例
s = 'hello'
print(s.center(10,'*'))
print(s.ljust(10,'*'))
print(s.rjust(10,'*'))

"""
将位置的数据格式化拼接在字符串文本中
    目的：将为字符串类型的数据与字符串类型的数据进行拼接
"""

# 上方实例
print('年龄' + 17)  # TypeError: can only concatenate str (not "int") to str
 # 只能字符串与字符串进行拼接

# 方式1: 将数据转化为字符串类型
print('年龄' + str(17))
# 方式2：使用字符串中 % 运算符  【% 在数字运算中是取余】

"""
先生成文本，在未知的位置使用站位符进行站位，再对字符串进行 % ，给占位的符号赋值
    占位符：
        %s --- 可以填充任意类型的数据
        %d --- 填充整形数据
            可以单独再进行格式化操作
                %0nd === n代表的是数字显示的宽度，不足n位，左边填充0
                    %05d ====> 10 ====> 显示：00010
        %f --- 填充的浮点型数据
            可以再单独格式化
                %.nf === n代表的是保留小数的位数
                    %.3f === 3.1415926 ===>显示：3.142
"""

# 上方实例
year = 2020
month = 4
if month in (4,6,9,11):
    day = 30
elif month in (1,3,5,7,8,10,12):
    day = 31
else:
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        day = 29
    else:
        day = 28
# 有几个占位符，就赋予几个值，值和占位符之间是一一对应的
content = '%s年%s月有%s天' % (year,month,day)
print(content)


# 学号，显示的时候按照6位来显示
sid = 1
# 姓名
name = '张三'
# 年龄
age = 17
# 成绩，显示的时候保留一位小数
score = 89.65
info = '学号为%06d的%s,年龄是%s,考试成绩为%.1f' % (sid,name,age,score)
print(info)

# 方式3：字符串数据.format()
"""
先生成字符串文本数据，未知数据的地方使用{}进行占位，调用字符串的format操作，给占位符进行赋值
有几个占位符，就传递几个值
    如果对数据有特殊的格式要求，在{}里操作
        {:0nd} 按照n位填充
        {:.nf} 保留n位小数
"""
info1 = '学号为{:06d}的{},年龄是{},考试成绩为{:.1f}'.format(sid,name,age,score)
print(info1)


# 方式4：是方式3的简化，使用f修饰字符串
# f修饰完字符串，可以直接在{}的位置填充对应的数据值
# 要修饰数据：{数据:0nd}    {数据:.nf}
info2 = f'学号为{sid:06d}的{name},年龄是{age},考试成绩是{score:.1f}'
print(info2)

字典

"""
储存一天温度变化记录，使用的一个列表进行存储的

7点，9点，11点，2点，4点，6点
为了更方便表达数据的含义，可以使用字典来进行春初
    {key:value, key:value}
    会给每一个数据设置标记，通过标记名获取对应的数据值

字典是使用键值对进行数据的储存，是通过键定位值的，要求键是不允许重复的，键的内容一旦确定不允许发生变换

字典是无序的可变序列
    无序：代表元素没有位置编号，也就是不同过下标获取数据 只能通过键获取数据值
    可变：数据值可以修改  可以增加新的键值对  删除键值对
"""

字典方法

air_temp = {'7点': 17, '9点': 20, '11点': 26, '14点': 30, '16点': 25, '18点': 22}
# 获取数据的话通过键取值
print(air_temp['11点'])
# 如果键不存在就报错
# print(air_temp['10点'])
# KeyError: '10点'

# 获取数据值的推荐方式
print(air_temp.get('11点'), air_temp.get('10点'))  # 26 None\

# 获取键值对的个数
print(len(air_temp))  # 6

# 添加新的键值对
air_temp.setdefault('19点', 20)  # 影响的是原数据
print(air_temp)

# 移除键值对
air_temp.pop('11点')
print(air_temp)

# 修改
air_temp['19点'] = 18
print(air_temp)

# air_temp.clear()  清空字典

# 遍历
# 直接遍历字典，便利的是字典中的键 [直接对字典进行成员操作，获取的是键]
for ele in air_temp:
    print(ele, air_temp.get(ele))

# 等价于
print(air_temp.keys())  # 字典中所有的键
for k in air_temp.keys():
    print(k)

print('========')
# 单独拿值
print(air_temp.values())  # dict_values([17, 20, 30, 25, 22, 20])
for v in air_temp.values():
    print(v)

print('========')
# 获取字典中键值组合
print(air_temp.items())  # dict_items([('7点', 17), ('9点', 20), ('14点', 30), ('16点', 25), ('18点', 22), ('19点', 20)])
for item in air_temp.items():
    print(item)
print('========')
for k, v in air_temp.items():
    print(k, v)

字典的使用案例

"""
词频统计：
    词/字符/数字  出现的个数，或者对数据进行归类
"""

# 词频统计
s = 'good good study day day up'
count_dict = {}  # 空字典，因为不知道最终有多少个键值对
for ch in s:  # 遍历获取每个字符
    # 逻辑
    if ch not in count_dict:  # 直接对字典使用成员运算，获取的是键
        # 代表第一次出现
        count_dict.setdefault(ch,1)
    else:
        # 次数+1
        count_dict[ch] = count_dict.get(ch) + 1
print(count_dict)

"""
统计每个字符出现的个数  字符-个数===> 使用字典类型展示数据
思路：
    1.遍历字符串，获取每个字符
    2.把字符出现的个数存储字典中，字符与个数的信息 【字符为键，个数为值】
        把遍历到的字符作为键，个数作为值存放与字典中
"""

# 归类
nums = [19,27,38,41,25,66,24,32,51]
# 偶数为一类，奇数为一类
# 字典中会有两组键值对,值为什么是[]，因为偶数和奇数有几个不知道
# 但是一定是多个的，所以干一个可变的容器
classify_dict = {'even':[],'odd':[]}
# 遍历
for ele in nums:
    if ele % 2 == 0:
        classify_dict['even'].append(ele)
    else:
        classify_dict['odd'].append(ele)
print(classify_dict)


# 每一类的数据的个数
classify_dict = {'even':0,'odd':0}
# 遍历
for ele in nums:
    if ele % 2 == 0:
        classify_dict['even'] += 1
    else:
        classify_dict['odd'] += 1
print(classify_dict)

# 字典数据的过滤
dict0 = {'hello': 1, 'nice': 3, 'to': 2, 'meet': 2, 'you': 2, 'too': 1, 'good': 1, 'fine': 1}
print(dict0)
# 找到次数为1的单词信息  以键值对形式展示
new_dict = {}
for k, v in dict0.items():
    if v == 1:
        new_dict.setdefault(k, v)
print(new_dict)

字典推导式

# 字典推导式   注意：字典中存放的是键值对  key:value
print({k: v for k, v in dict0.items() if v == 1})

# 单词中包含e的词频信息
new_dict1 = {}
for k, v in dict0.items():
    if 'e' in k:
        new_dict1.setdefault(k, v)
print(new_dict1)

# 上方用字典推导式：
print({k: v for k, v in dict0.items() if 'e' in k})