逆袭之路——python学习笔记【day08】

最新推荐文章于 2024-09-29 14:13:49 发布

絵飛·的魚

最新推荐文章于 2024-09-29 14:13:49 发布

阅读量564

点赞数

文章标签： python 学习开发语言

本文链接：https://blog.csdn.net/weixin_46349820/article/details/123401172

版权

今日内容概要

字典内置方法
元组内置方法
集合内置方法
垃圾回收机制
总结（小练习）

今日内容详细

一、字典内置方法

定义：在{ }内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型（整型、浮点型、字符串（使用频率最高）），通常key应该是字符串类型，因为字符串类型会对value有描述性的功能
类型转换符：dict( )

1、按 key 取值

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(d1['name'])  # jason  键存在，不会报错
print(d1['xxx'])  # 键不存在直接报错

涉及到字典取值更加推荐下面的方式，就是 get 方法

print(d1.get('name'))  # jason  键存在
print(d1.get('xxx'))  # None  键不存在不会报错 而是返回None
print(d1.get('xxx', '这个键不存在'))  # 第二个参数不写默认返回None 写了则返回写了的
print(d1.get('name', '这个键不存在'))  # 如果键存在 则不需要使用到第二个参数

2、修改值字典也是可变类型

print(id(d1))            # 先看下它的内存地址为1552479568320
d1['name'] = 'jasonDSB'  # 键存在是修改值
print(d1, id(d1))        # 修改之后再查看内存地址1552479568320，发现内存地址没有变化，可知字典也是可变类型

3、添加键值对

d1['pwd'] = 123  # 键不存在则是在末尾新增一个键值对
print(d1)

4、统计字典中键值对的个数 len

print(len(d1))  # 3

5、成员运算也只能判断key而已

print('jason' in d1)  # False
print('name' in d1)  # True

6、删除键值对 del

del d1['name'] # 通用删除方式，删除它的键值
print(d1)  # {'age': 18, 'hobbies': ['play game', 'basketball']}

print(d1.pop('age'))  # 18  弹出
print(d1)  # {'name': 'jason', 'hobbies': ['play game', 'basketball']}
d1.popitem()  # 随机弹出一个(使用频率很低 可以忽略)
print(d1)

7、获取所有的键 .keys( )，所有的值 .values( )，所有的键值对 .items( )

print(d1.keys())  # dict_keys(['name', 'age', 'hobbies'])  可以看成是列表
print(d1.values())  # dict_values(['jason', 18, ['play game', 'basketball']])  可以看成是列表
print(d1.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])  可以看成是列表套元组

"""在python2中上述三个方法就是直接返回一个列表 """

8、更新字典 updata ( )

dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
dic.update({'k1': 'JN', 'k4': 'xxx'}) # {'k1': 'JN', 'k2': 'Tony', 'k3': 'JY', 'k4': 'xxx'}
print(dic)  # 键存在则修改 键不存在则新增

9、快速生成字典 fromkeys( )

dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
print(dic)  # {'k1': [], 'k2': [], 'k3': []}

10、设置默认值 setdefault( )

dic = {'k1': 111, 'k2': 222}
print(dic.setdefault('k3', 333))  # 键不存在则新增键值对 并且有返回结果是新增的v
print(dic)
print(dic.setdefault('k1', '嘿嘿嘿'))  # 键存在 则返回对应的值 不做修改
print(dic)

在这里插入图片描述

二、元组内置方法

可以看成是不可变的列表

1、类型转换

支持 for 循环的数据类型都可以转成元组

	# 除整型int、浮点型float、布尔值bool 以外的都可以
	
	# print(tuple(11))  # 报错
    # print(tuple(11.11))  # 报错
    print(tuple('jason'))
    print(tuple([11,22,33,44]))
    print(tuple({'name':'jason'}))
    print(tuple({11,22,33,44}))
    # print(tuple(True))  # 报错

2、元组的特性

"""当元组内只有一个元素的时候 一定要在元素的后面加上逗号，不然它的数据类型还是本身的数据类型"""

t1 = (11, 22, 33, 44)
print(type(t1))  # <class 'tuple'>
t2 = (11)
print(type(t2))  # int
t2 = (11.11)
print(type(t2))  # float
t2 = ('jason')
print(type(t2))  # str
t2 = (11,)
print(type(t2))  # tuple
t2 = (11.11,)
print(type(t2))  # tuple
t2 = ('jason',)
print(type(t2))  # tuple

"""
一般情况下 我们会习惯性的将所有可以存储多个数据的数据类型的数据
如果内部只有一个元素 也会加逗号
    (1,)
    [1,]
    {1,}
    {'name':'jason',}
"""

3、进索引取值

t1 = (11, 22, 33, 44, 55, 66)
print(t1[0])           # 11
print(t1[-1])		   # 66

4、切片操作

t1 = (11, 22, 33, 44, 55, 66)
print(t1[1:4])      # (22, 33, 44)
print(t1[-1:-4:-1]) # (66, 55, 44)
print(t1[-4:-1])    # (33, 44, 55)

5、间隔

t1 = (11, 22, 33, 44, 55, 66)
print(t1[1:4:2])  # (22, 44)

6、统计元组内元素的个数

print(len(t1))  # 6

7、成员运算

print(11 in t1)  # True

8、统计某个元素出现的次数

print(t1.count(22))

9、元组内元素不能"修改": 元组内各个索引值指向的内存地址不能修改

t1[0] = 111

请添加图片描述

三、集合内置方法

定义：在{ }内用逗号分隔开多个元素，集合具备以下三个特点：

每个元素必须是不可变类型
集合内没有重复的元素
集合内元素无序

注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系运算，根本没有取出单个指定值的这种需求。
注意2:{ }既可以用于定义字典，也可以用于定义集合，但是字典内的元素必须是key:value键值对的格式

d = {} # 默认是空字典 
s = set() # 这才是定义空集合

1、类型转换

支持 for 循环的数据类型都可以转成集合，并且集合内元素只能是不可变类型
两大功能：
1）. 去重:集合内不能出现重复的元素(自带去重特性),如果出现了会被集合自动去重
2）.关系运算：判断两个群体内的差异，就好比如我们之间的共同好友、共同关注、共同点赞之类的

print(set(11))  # 报错
print(set(11.11))  # 报错
print(set('jason'))
print(set([11,22,33,44]))
print(set({'name':'jason'}))
print(set((11,22,33)))
print(set(True))  # 报错

# 去重操作，去除了重复但是打乱了顺序
l = ['a', 'b', 1, 'a', 'a']
print(set(l))      # {1, 'a', 'b'}

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=['a','b',1,'a','a']
new_l=[]
for dic in l:
    if dic not in new_l:
        new_l.append(dic)
print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重

2、关系运算

f1 = {'jason', 'kevin', 'tony', 'jerry'}  # 小李的好友列表
f2 = {'jason', 'tom', 'jerry', 'jack'}  # 小王的好友列表
# 1.求两个人的共同好友
print(f1 & f2)  # {'jerry', 'jason'}
# 2.求小李的单独好友
print(f1 - f2)  # {'kevin', 'tony'}
# 3.求两个人所有的好友
print(f1 | f2)  # {'kevin', 'jack', 'tom', 'jason', 'jerry', 'tony'}
# 4.求两个人各自的好友
print(f1 ^ f2)  # {'jack', 'tony', 'tom', 'kevin'}

四、垃圾回收机制

"""python底层针对空间的申请和释放都是设计好的 不需要程序员操心"""
1.引用计数
	python会将引用计数为0的数据清除
    	name = 'jason'  # jason引用计数为1
        a = name        # jason引用计数为2
        '''内存中数据身上绑定的变量名的个数'''
        # ps:还可以了解一下循环引用的情况
2.标记清除
	当内存空间即将溢出(满了)的时候 python会自动启动应急机制
    停止程序的运行 挨个检查值的引用计数并给计数为0的数据打上标记
    然后一次性清理掉
3.分代回收
	根据值存在的时间长短 将值划分为三个等级(1,2,3)
    	等级1 检测机制每隔5s来一次
        等级2 检测机制每隔1min来一次
        等级3 检测机制每隔5min来一次

具体讲解也可参考：Python垃圾回收机制详解

五、今日作业

练习昨日注册登录作业
去重列表元素并保留原来的顺序
l = [‘a’, ‘b’, 1, ‘a’, ‘a’]
解答：

l = ['a', 'b', 1, 'a', 'a']
data = []
for i in l:
    if i not in data:
        data.append(i)
print(data)

去重下列数据字典并保留原来的顺序
针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
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’},
]
解答：

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'},
    ]
data = []
for i in l:
    if i not in data:
        data.append(i)
print(data)

关系运算，有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={‘jason’,‘oscar’,‘kevin’,‘ricky’,‘gangdan’,‘biubiu’}
　　linuxs={‘oscar’,‘tony’,‘gangdan’}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合
解答：

pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
linuxs={'oscar','tony','gangdan'}
print(pythons & linuxs)
print(pythons | linuxs)
print(pythons - linuxs)
print(pythons ^ linuxs)

# 打印结果如下：
{'oscar', 'gangdan'}
{'oscar', 'ricky', 'tony', 'jason', 'kevin', 'gangdan', 'biubiu'}
{'kevin', 'ricky', 'biubiu', 'jason'}
{'ricky', 'tony', 'jason', 'kevin', 'biubiu'}

Process finished with exit code 0