垃圾回收机制与基本数据类型的内置方法

今日学习内容总结

今天我们就把所有的基本数据类型内置方法学完了。然而学完了不代表学会了。实际应用，长期敲代码才是真确的。实践出真理。

字典的内置方法

字典的内置方法非常重要，但是相对字符串和列表，它没有那么多。至于这么多的内置方法要如何去记忆。我只能说多敲了。

1.类型转换

不多说，直接尝试，代码示例：

    # 整型
    print(dict(10))  # 报错 'int' object is not iterable

    # 浮点型
    print(dict(10.11))  # 报错 'float' object is not iterable

    # 字符串
    print(dict('jason'))  # 报错 dictionary update sequence element #0 has length 1; 2 is required

    # 列表
    print(dict(['jason', 'handsome']))  # 报错 dictionary update sequence element #0 has length 5; 2 is required 但是，并不是列表型不能转换成字典，而是写法必须符合字典
    print(dict([['name', 'jason'],  ['age', 18], ['hobby', 'run']]))  # {'name': 'jason', 'age': 18, 'hobby': 'run'} 除了这种方法外，还有一种方式，那就是使用dict.fromkeys方法
    user_list = ['jason', 18, 'run']
    new_list = dict.fromkeys(user_list, 'name')
    print(new_list)  # # {'jason': 'name', 18: 'name', 'run': 'name'} 这就是dict.fromkeys方法的使用
    
    # 元组
    print(dict((('name', 'jason'), ('age', 18))))  # {'name': 'jason', 'age': 18} 元组与列表一样，直接写是会报错的，只有类似这种情况才能转换类型 当然，元组也可以使用dict.fromkeys方法
    user_tuple = ('jason', 18, 'run')
    new_tuple = dict.fromkeys(user_tuple, 'name')
    print(new_tuple)   # {'jason': 'name', 18: 'name', 'run': 'name'}

    # 集合 因为集合是去重，无序，且不可变性的所以我只知道一个用dict.fromkeys方法的转换
    user_set = {'jason', 18, 'run'}
    new_set = dict.fromkeys(user_set, 'name')
    print(new_set)  # {'run': 'name', 18: 'name', 'jason': 'name'}

    # 布尔值 也不可以转换
    print(dict(True))  # 'bool' object is not iterable

2.取值方法

我们知道在字典中取值是按照键取值的，若键存在，则取值成功。若键不存在，则直接报错，停止运行，取值失败。为了我们的程序不会因为取值失败而停止运行，所以我们要学习get取值方法。代码示例：

    a = {'name' : 'jason', 'age' : 18, 'hobby' : 'run'}
    print(a['name'])  # jason
    print(a['user'])  # 报错 'user' 提示你没有user这个键
    # get方法的使用
    print(a.get('name'))  # jason
    print(a.get('user'))  # None  键不存在只会告诉你为空值，不会报错
    print(a.get('user', '这个键不存在'))  # 这个键不存在 当键不存在时，默认打印为None 但是你也可以自己设置

3.字典的增删改

之所以只有增删改是因为我们之前就讲了查询的方法了。这里我们统一说明字典的增删改的使用方法。代码示例：

    a = {'name' : 'jason', 'age' : 18, 'hobby' : 'run'}
    # 增加键值对
    a['pwd'] = 666 # 这里是键不存在，所以直接新增一个键值对，可见字典也是一个可变类型
    print(a)  # {'name': 'jason', 'age': 18, 'hobby': 'run', 'pwd': 666}
    
    # 删除键值对
    # 1.通用方法
    del a['name']  # 因为通用，所以不常用  滑稽
    print(a)  # {'age': 18, 'hobby': 'run'}
    # 2.弹出，也就是与列表中的延迟删除类似
    print(a.pop('hobby'))  # run 与列表一样，先取出来，这个时候还可以用，但一会儿就删除了
    print(a)  # {'name': 'jason', 'age': 18} 
    # 3.随机弹出。使用频率很低，不建议使用
    a.popitem()
    print(a)  # {'name': 'jason', 'age': 18}

    # 修改值
    a['hobby'] = 'study'
    print(a)  # {'name': 'jason', 'age': 18, 'hobby': 'study'} 只要键存在，我们就可以修改值，不存在则添加键值对

    # 字典的更新 update方法
    a.update({'name':'老刘', 'age': 20})
    print(a)  # {'name': '老刘', 'age': 20, 'hobby': 'run'} 键存在则修改 键不存在则新增

4.字典的统计与获取

因为都是记忆行的方法，所以直接代码示例：

    a = {'name' : 'jason', 'age' : 18, 'hobby' : 'run'}
    # 统计字典中键值对的个数
    print(len(a))  # 3 与字符串，列表一样，用len查询，不过需要注意的是，字典的最小单位是键值对
    
    # 成员运算
    print('jason' in a)  # False
    print('name' in a)  # True  成员运算也是，判断的是键

    # 获取所有的键 所有的值 所有的键值对
    print(a.keys())  # dict_keys(['name', 'age', 'hobby']) 可以看做成一个列表
    print(a.values())  # dict_values(['jason', 18, 'run']) 可以看做成一个列表
    print(a.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobby', 'run')]) 可以看做成列表套元组

    # 上述方法，在python3中实现。若在python2中实现，返回的就是一个列表。同时除了这些方法的使用，还可以自己写循环取值

元组内置方法

元组可以看成是不可变的列表，其内置方法的使用介绍如下

1.类型转换

支持for循环的都可以转换成元组，和列表一样。代码示例：

    # 整型
    print(tuple(10))   # 报错 'int' object is not iterable
    # 浮点型
    print(tuple(10.1))  # 报错 'float' object is not iterable
    # 字符串
    print(tuple('jason'))  # ('j', 'a', 's', 'o', 'n')
    # 列表
    print(tuple(['jason', 'handsome', 'nb']))  # ('jason', 'handsome', 'nb')
    # 字典
    print(tuple({'name':'jason', 'age':18}))  # ('name', 'age')
    # 集合
    print(tuple({'jason', 'handsome', 'nb'}))  # ('handsome', 'nb', 'jason')
    # 布尔值
    print(tuple(True))  # 报错 'bool' object is not iterable

2.元组的特性

当元组内只有一个元素的时候一定要在元素的后面加上逗号，否则打印数据类型时会打印该元素的数据类型。而一般情况下，我们会将所有可以存储多个数据的类型的数据，若只有一个元素，也会加上逗号。代码示例：

    a = (1, 2, 3)
    print(type(a))  # <class 'tuple'>
    b = (10)
    print(type(b))  # <class 'int'>
    c = (10.11)
    print(type(c))  # <class 'float'>
    d = ('jason')
    print(type(d))  # <class 'str'>
    
    # 如果加了逗号，结果就不一样了
    a = (1, 2, 3)
    print(type(a))  # <class 'tuple'>
    b = (10,)
    print(type(b))  # <class 'tuple'>
    c = (10.11,)
    print(type(c,))  # <class 'tuple'>
    d = ('jason',)
    print(type(d))  # <class 'tuple'>

3.元组的内置方法

因为都是常用方法，我直接代码举例了：

    a = ('jason', 'handsome', 'NB', '666')
    # 1.索引取值
    print(a[0])  # jason
    print(a[-1])  # 666

    # 2.切片与步长 其操作，与含义，与列表中的切片与步长一致
    print(a[1:3])  # ('handsome', 'NB')
    print(a[-1:-3:-1])  # ('666', 'NB')
    print(a[0:3:2])  # ('jason', 'NB')

    # 统计元素与成员运算
    # 统计元组内元素的个数
    print(len(a))  # 4
    # 统计元素出现的次数
    b = (1, 1, 1, 1, 2, 3, 4, 1 ,1 ,5 ,2)
    print(b.count(1))  # 6
    # 成员运算
    print('jason' in a)  # True
    print('jas' in a)  # False

集合内置方法

集合的特性是无序，去重，不可变的，同时集合内的元素只能是不可变类型，也就是说，类似于列表这种可变的数据类型，是不能作为集合的元素存入的。代码示例：

    a = {[1, 2], 'fs'}  # 甚至不需要打印结果，直接运行就会报错  unhashable type: 'list'

因为集合的特性，我们也是直接对集合的内置方法进行总结。：

    # 类型转换
    # 整型
    print(set(10)) # 报错 'int' object is not iterable
    
    # 浮点型
    print(set(10.11)) # 报错 'float' object is not iterable

    # 字符串
    print(set('jason '))  # {'n', 'o', 's', ' ', 'j', 'a'}

    # 列表
    print(set([1, 2, 3]))  # {1, 2, 3}

    # 字典
    print(set({'name':'jason', 1:2}))  # {1, 'name'}

    # 元组
    print(set((1, 2, 3)))  # {1, 2, 3}

    # 布尔值
    print(set(True)) # 报错 'bool' object is not iterable

    # 2.两大功能
    # 1.去重 集合内不能出现重复的元素(自带去重特性)，如果出现了 会被集合自动去重
    a = {1, 1, 1, 1, 1, 1, 2, 2, 3}
    print(a)  # {1, 2, 3}
    # 关系运算 判断两个群体内的差异，类似于数学上的并集，交集，补集
    a = {'jason', 'handsome', 666}
    b = {'jason', 'NB', 666}
    print(a & b)  # {'jason', 666}
    print(a - b)  # {'handsome'}
    print(b - a)  # {'NB'}
    print(a | b)  # {'jason', 'handsome', 666, 'NB'}
    print(a ^ b)  # {'handsome', 'NB'}