day8---基础数据类型扩展二

1. 数据类型知识补充

元组(tuple)

  • 如果元组中只有一个元素，这个元素是那种类型，那整个变量就是什么数据类型，已经不再是元组。如果是数字就是数值型，如果是字符串就是字符串型，如果是是布尔值就是布尔型，如果是列表或字典也是一样

  • 如果元组中有多个元素以逗号隔开，哪怕是空的元素，只要有多个的就是元组

  • 示例：

tuple1 = ('yan')
tuple2 = (10)
tuple3 = (False)
tuple4 = ([1, 'aaa', True])
tuple5 = ({'name': 'yy', 'age': 18})
tuple6 = ('yan',)
print(tuple1, type(tuple1))
print(tuple2, type(tuple2))
print(tuple3, type(tuple3))
print(tuple4, type(tuple4))
print(tuple5, type(tuple5))
print(tuple6, type(tuple6))
>>>
yan <class 'str'>
10 <class 'int'>
False <class 'bool'>
[1, 'aaa', True] <class 'list'>
{'name': 'yy', 'age': 18} <class 'dict'>
('yan',) <class 'tuple'>

列表(list)

在循环列表时，如果在循环的过程中删除列表中的某个元素，列表的元素个数会改变，即列表索引改变，容易出错

# 删除列表中索引下标为基数的元素
lst = [11, 22, 33, 44, 55, 66, 77]
# 方法一：
new_list = []
for i in enumerate(lst):
		if i[0] % 2 == 0:
			new_list.append(i[1])
print(new_list)
# 方法二：
lst = lst[1::2]
print(lst)
# 方法三：
for i in range(len(lst)-1, 0, -1):
		if i % 2 == 1:
			lst.pop(i)
print(lst)

字典(dict)

  • dict.fromkeys：创建多个字典，把不同的键对应相同的值，声明时，键对应的数据类型必须是可迭代对象，如果对应的值是列表，那所有的字典值对应的列表的内存地址是同一个，修改一个所有都会修改。

dic = dict.fromkeys([1, 2, 3], 'aaa')
print(dic)
>>>
{1: 'info', 2: 'info', 3: 'info'}

dic_list = dict.fromkeys('abc', [])
print(dic_list)
dic_list['a'].append('11')
print(dic_list)
dic_list['b'].append('22')
print(dic_list)
dic_list['b'].append('33')
print(dic_list)
>>>
{'a': [], 'b': [], 'c': []}
{'a': ['11'], 'b': ['11'], 'c': ['11']}
{'a': ['11', '22'], 'b': ['11', '22'], 'c': ['11', '22']}
{'a': ['11', '22', '33'], 'b': ['11', '22', '33'], 'c': ['11', '22', '33']}

  • 在循环字典时，如果在循环的过程中删除某个键值对，字典的键值对个数会改变，即字典长度改变，容易出错

# 删除字典中键包含'k'的键值对
dic = {'k1': 'alex', 'k2': 'wusir', 'name': 'taibai'}
# 方法一：
new_list = []
for i in dic:
		new_list.append(i)
for j in new_list:
		if 'k' in j:
			dic.pop(j)
print(dic)
# 方法二：
dic_list= dic.keys()
for i in list(dic_list):
		if 'k' in i:
			dic.pop(i)
print(dic)
# 方法三：
for i in dic.copy():
		if 'k' in i:
			dic.pop(i)
print(dic)

数据类型之间的转换

  • 数字转字符串：直接转成字符串的数字

  • 字符串转数字：只有数字组成的字符串可以转为对应的数字

  • 数字转布尔值：0转换为False，其他所有数字转为True

  • 布尔值转数字：False转为0，True转为1

  • 布尔型转字符串：直接转成字符串的'True'和'False'

  • 字符串转布尔型：空字符串转False，其他所有转True

  • 字符串转列表：spilt分隔，也可以使用list直接转，但是list只能迭代转换，不能指定符号分割

  • 列表转字符串：join连接

  • 元组转列表：list直接转

  • 列表转元组：tuple直接转

  • 字符串转元组：tuple直接转

  • 其他类型转为布尔型的Fasle：数字0、空字符串''、空列表[]、空元组()、空字典{}、空集合set()。剩下的全部都会转为True

2. 集合

  • 集合的特点：

    • 集合是无序的
    • 集合是不重复的
    • 集合里的元素是可哈希的(不可变类型)
    • 集合本身是不可哈希的
    • 集合无法做字典的键
    • 集合去重，把一个列表变成集合，会自动去重

  • 集合的创建：

    • set1 = {}
    • set2 = set({})

  • 集合的增加：

    • add：直接增加
    • update：迭代增加

  • 集合的删除：

    • remove：删除一个指定元素，没有返回值
    • pop：随机删除一个元素，返回删除的元素
    • clear：清空集合
    • del：删除集合

  • 集合的修改：集合不能修改

  • 集合的查询：集合只能通过for循环的方式查找

  • 集合的关系测试：

    • 交集：& 或者 intersection
    • 并集：| 或者 union
    • 差集：- 或者 difference
    • 反交集：^ 或者 symmetric_difference
    • 子集与超集：issubset、issuperset
    • 不可变集合：frozenset，让集合变成不可变类型

3. 深浅拷贝

  • 赋值：把一个数据类型的变量，重新赋值给另外一个，这种操作不叫复制，交赋值，从始至终用的都是同一个内存地址，随便修改其中一个，则另外一个也会跟着修改，以列表为例：

l1 = [1, ['a', 'b', 'c'], 2, 3, 4, 5]
l2 = l1
print(l1, id(l1))
print(l2, id(l2))
print('-' * 20)
l1[-1] = 10
print(l1, id(l1))
print(l2, id(l2))
print('-' * 20)
l2[1].append('d')
print(l1, id(l1))
print(l2, id(l2))
>>>
[1, ['a', 'b', 'c'], 2, 3, 4, 5] 2106259423560
[1, ['a', 'b', 'c'], 2, 3, 4, 5] 2106259423560
--------------------
[1, ['a', 'b', 'c'], 2, 3, 4, 10] 2106259423560
[1, ['a', 'b', 'c'], 2, 3, 4, 10] 2106259423560
--------------------
[1, ['a', 'b', 'c', 'd'], 2, 3, 4, 10] 2106259423560
[1, ['a', 'b', 'c', 'd'], 2, 3, 4, 10] 2106259423560

  • 浅copy：第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性，以列表为例：

l1 = [1, ['a', 'b', 'c'], 2, 3, 4, 5]
l2 = l1.copy()
print(l1, id(l1))
print(l2, id(l2))
print('-' * 20)
l1[-1] = 10
print(l1, id(l1))
print(l2, id(l2))
print('-' * 20)
l2[1].append('d')
print(l1, id(l1), id(l1[1]))
print(l2, id(l2), id(l2[1]))
>>>
[1, ['a', 'b', 'c'], 2, 3, 4, 5] 2177538461576
[1, ['a', 'b', 'c'], 2, 3, 4, 5] 2177539290504
--------------------
[1, ['a', 'b', 'c'], 2, 3, 4, 10] 2177538461576
[1, ['a', 'b', 'c'], 2, 3, 4, 5] 2177539290504
--------------------
[1, ['a', 'b', 'c', 'd'], 2, 3, 4, 10] 2177538461576 2177538460168
[1, ['a', 'b', 'c', 'd'], 2, 3, 4, 5] 2177539290504 2177538460168

  • 深copy：使用深copy需要导入copy模块，深copy出来的数据类型变量是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变，以列表为例：

import copy
l1 = [1, ['a', 'b', 'c'], 2, 3, 4, 5]
l2 = copy.deepcopy(l1)
print(l1, id(l1))
print(l2, id(l2))
print('-' * 20)
l1[-1] = 10
print(l1, id(l1))
print(l2, id(l2))
print('-' * 20)
l2[1].append('d')
print(l1, id(l1), id(l1[1]))
print(l2, id(l2), id(l2[1]))
>>>
[1, ['a', 'b', 'c'], 2, 3, 4, 5] 2577027301000
[1, ['a', 'b', 'c'], 2, 3, 4, 5] 2577027417032
--------------------
[1, ['a', 'b', 'c'], 2, 3, 4, 10] 2577027301000
[1, ['a', 'b', 'c'], 2, 3, 4, 5] 2577027417032
--------------------
[1, ['a', 'b', 'c'], 2, 3, 4, 10] 2577027301000 2577027300808
[1, ['a', 'b', 'c', 'd'], 2, 3, 4, 5] 2577027417032 2577027416968

  • 不管是列表、字典、元组、集合嵌套的数据类型，赋值、浅copy和深copy的原理都是一样的。

posted @ 2017-10-30 19:15  _岩哥  阅读(145)  评论(0)    收藏  举报