python之数据类型的内置方法(set、tuple、dict)与简单认识垃圾回收机制

目录

• 字典的内置方法
  • 类型转换
  • 字典取值
  • 修改值
  • 计算字典长度
  • 成员运算
  • 删除元素
  • 获取元素
  • 更新字典
  • 快速生成字典
  • setdefault()方法
• 元组的内置方法
  • 类型转换
  • 索引与切片操作
  • 统计长度
  • 成员运算
  • 统计某个元素出现的次数
  • 元组特性
• 集合内置方法
  • 类型转换
  • 集合去重
  • 关系运算
• 简单认识垃圾回收机制
  • 前言
  • 引用计数
  • 标记清除
  • 分代回收
• 作业
• 答案
  • 第一题
  • 第二题
  • 第三题

字典的内置方法

类型转换

# dict()用于转换成字典
print(dict(name='tom', age=18))  # 输出结果：{'name': 'tom', 'age': 18}

字典取值

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

# 按key取值，这种方式最简单，但是如果找不到key所对应的值会报错，所以不推荐
print(d1['name'])  # 输出结果：jason
print(d1['xxx'])  # 报错

# 用get()方法，推荐使用
print(d1.get('name'))  # 输出结果：jason
print(d1.get('xxx'))  # 输出结果：None
# get()方法可以填两个变量，第一个填key，第二个填写如果key不存在则会返回的值
print(d1.get('xxx', '不存在'))  # 输出结果：不存在

修改值

ps:字典是可变类型

# 直接用key索引直接赋值修改
d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
d1['age'] = 20
print(d1['age'])  # 输出结果：20

# 如果赋值时key不存在于字典内，则会新增值
d1['sex'] = 'boy'
print(d1)  # 输出结果：{'name': 'jason', 'age': 20, 'hobbies': ['play game', 'basketball'], 'sex': 'boy'}

计算字典长度

# len()计算长度，有按照key的数量计算
d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(len(d1))  # 输出结果：3

成员运算

# in 和 not in，只能判断key是否存在，不能判断value
d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print('name' in d1)  # 输出结果：True

删除元素

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
# del通用方式
del d1['hobbies']
print(d1)  # 输出结果：{'name': 'jason', 'age': 18}

# pop()，括号内要有key值
print(d1.pop('age'))  # 输出结果：18

获取元素

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
# 以下方法获取到的值都可以看作列表
# 获取所有的key
for key in d1.keys():
    print(key)

# 获取所有的value
for value in d1.values():
    print(value)

# 获取所有的key:value
for item in d1.items():
    print(item)

更新字典

# update() 可以同时更新字典中多个数据
d = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
# key存在则修改 key不存在则新增
d.update({'k1':'tom', 'k4':'aaa'})
print(d)  # 输出结果：{'k1': 'tom', 'k2': 'Tony', 'k3': 'JY', 'k4': 'aaa'}

快速生成字典

# fromkeys()可以快速生成字典,但key都会对应同一个value
d = dict.fromkeys(['k1', 'k2', 'k3'], [11])
print(d)  # 输出结果：{'k1': [11], 'k2': [11], 'k3': [11]}

d['k1'].append(22)
print(d)  # 输出结果：{'k1': [11, 22], 'k2': [11, 22], 'k3': [11, 22]}

setdefault()方法

# key不存在则新增key:value，并且返回是新增的value
d = {'k1': 111, 'k2': 222}
print(d.setdefault('k3', 333))  # 输出结果：333
print(d)  # 输出结果：{'k1': 111, 'k2': 222, 'k3': 333}

# key存在，则返回对应的value，不做修改
d = {'k1': 111, 'k2': 222}
print(d.setdefault('k1', '嘿嘿嘿'))    # 输出结果：111
print(d)  # 输出结果：{'k1': 111, 'k2': 222}

元组的内置方法

类型转换

# tuple()和list()一样
# tuple()可以将除整型、浮点型、布尔值以外的类型转换成元组
print(tuple('jason'))  # 输出结果：('j', 'a', 's', 'o', 'n')
print(tuple({'name': 'jason', 'pwd': 123}))  # 输出结果：('name', 'pwd')
print(tuple((11, 22, 33, 44, 55)))  # 输出结果：(11, 22, 33, 44, 55)
print(tuple({1, 2, 3, 4, 5}))  # 输出结果：(1, 2, 3, 4, 5)

索引与切片操作

t = ('jason', 'tom', 123, 'abc')

# 索引取值
print(t[2])  # 输出结果：123
print(t[-1])  # 输出结果：abc

# 切片操作
print(t[1:3])  # 输出结果：('tom', 123)
print(t[-4:-2])  # 输出结果：('jason', 'tom')

# 切片操作之步长
print(t[::2])  # 输出结果：('jason', 123)
print(t[3:1:-1])  # 输出结果：('abc', 123)

统计长度

# len()用来统计长度
t = ('jason', 'tom', 123, 'abc')
print(len(t))  # 输出结果：4

成员运算

# 成员运算
t = ('jason', 'tom', 123, 'abc')
print('j' in t)  # 输出结果：False
print('jason' in t)  # 输出结果：True

统计某个元素出现的次数

# 统计出现次数使用count()
l = (1, 2, 1, 5, 1, 4, 6, 7, 1)
print(l.count(1))  # 输出结果：4

元组特性

# 当元组内只有一个值时，数据类型会是括号内的数据类型
t2 = (11)
print(type(t2))  # 输出结果：<class 'int'>
t2 = (11.11)
print(type(t2))  # 输出结果：<class 'float'>
t2 = ('jason')
print(type(t2))  # 输出结果：<class 'str'>

# 所以我们在定义时会在值的后面加一个逗号
t2 = (11,)
print(type(t2))  # 输出结果：<class 'tuple'>
t2 = (11.11,)
print(type(t2))  # 输出结果：<class 'tuple'>
t2 = ('jason',)
print(type(t2))  # 输出结果：<class 'tuple'>

# 无法修改元组内的字符串、整型、浮点型、布尔值
# 但可以修改元素为可变类型的值
tt = (11, 22, 33, [11, 22])
tt[-1][0] = 33
print(tt)  # 输出结果：(11, 22, 33, [33, 22])

集合内置方法

集合的用处比起其他的数据类型较少，主要还是用于去重和关系运算

类型转换

# set()和list()一样
# set()可以将除整型、浮点型、布尔值以外的类型转换成集合
print(set('jason'))  # 输出结果：{'o', 'n', 's', 'j', 'a'}
print(set({'name': 'jason', 'pwd': 123}))  # 输出结果：{'name', 'pwd'}
print(set((11, 22, 33, 44, 55)))  # 输出结果：{33, 11, 44, 22, 55}
print(set({1, 2, 3, 4, 5}))  # 输出结果：{1, 2, 3, 4, 5}

集合去重

因为集合内不能出现重复的元素，自带去重特性，所以集合可以用于去重

# 自带去重
s = {1,1,1,1,1,2,2,2,2,2,1,2,3,2,2,1,2,3,2,3,4,3,2,3}
print(s)  # 输出结果：{1, 2, 3, 4}

# 列表去重
l = ['a', 'b', 1, 'a', 'a']
s = set(l)
l = list(s)
print(l)  # 输出结果：['a', 1, 'b']

"""列表如果用转集合的方式去重，返回的值不会是列表原来的顺序"""

关系运算

# 判断两个群体内的差异，如:共同好友、共同关注、共同点赞

f1 = {'jason', 'kevin', 'tony', 'jerry'}
f2 = {'jason', 'tom', 'jerry', 'jack'}
# 查询共同元素
print(f1 & f2)  # 输出结果：{'jason', 'jerry'}
# 查询f1中f2没有的元素
print(f1 - f2)  # 输出结果：{'tony', 'kevin'}
# 查询f1和f2所有元素
print(f1 | f2)  # 输出结果：{'jerry', 'kevin', 'jack', 'tom', 'tony', 'jason'}
# 查询各自的独立元素
print(f1 ^ f2)  # 输出结果：{'jack', 'kevin', 'tom', 'tony'}

简单认识垃圾回收机制

前言

在有些其他的编程语言中，针对内存空间的操作都是需要程序员自己操作，而在python中，python底层针对空间的申请和释放都是设计好的，不需要程序员操心。

引用计数

在内存空间中，一个数据赋予一个变量时，这个数据身上的标记就会加1，这个标记就是引用计数，而python会清除引用计数为0的数据。

a = 'jason'  # 'jason'引用计数+1
b = a  # 'jason'引用计数+1

标记清除

当内存空间即将溢出(满了)的时候，python会自动启动应急机制，停止程序的运行，挨个检查值的引用计数并给计数为0的数据打上标记，然后一次性清理掉

分代回收

根据值存在的时间长短，将值划分为三个等级，存在时间越长，等级越高，等级越高检查间隔时间越长。

作业

1. 去重列表元素并保留原来的顺序

l = ['a', 'b', 1, 'a', 'a']

1. 去重下列数据字典并保留原来的顺序

l = [
	{'name': 'lili', 'age': 18, 'sex': 'male'},
	{'name': 'jack', 'age': 73, 'sex': 'male'},
	{'name': 'tom', 'age': 20, 'sex': 'female'},
	{'name': 'lili', 'age': 18, 'sex': 'male'},
	{'name': 'lili', 'age': 18, 'sex': 'male'},
]

1. 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合

pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'oscar', 'tony', 'gangdan'}

'''
要求：
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
'''

答案

第一题

点击查看代码

l = ['a', 'b', 1, 'a', 'a']
# 用于存储新列表
final_list = []
# 遍历旧列表
for s in l:
	# 如果新列表中没有这个值，则给新列表添加进去
    if s not in final_list:
        final_list.append(s)
print(final_list)

第二题

点击查看代码

l = [
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'jack', 'age': 73, 'sex': 'male'},
    {'name': 'tom', 'age': 20, 'sex': 'female'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
]
# 用于存储新列表
final_list = []
# 遍历旧列表
for s in l:
	# 如果新列表中没有这个值，则给新列表添加进去
    if s not in final_list:
        final_list.append(s)
print(final_list)

第三题

点击查看代码

pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'oscar', 'tony', 'gangdan'}

'''
要求：
    1. 求出即报名python又报名linux课程的学员名字集合
    2. 求出所有报名的学生名字集合
    3. 求出只报名python课程的学员名字
    4. 求出没有同时这两门课程的学员名字集合
'''
# 要求1
print("即报名python又报名linux课程的学员:{}".format((pythons & linuxs)))
# 要求2
print("所有报名的学生名字:{}".format((pythons | linuxs)))
# 要求3
print("只报名python课程的学员名字:{}".format((pythons - linuxs)))
# 要求4
print("没有同时这两门课程的学员名字集合:{}".format((pythons ^ linuxs)))