Python之常用数据类型详解

tuple 元组

 1 # 定义
 2 temp = (2, )  # 规范定义，单个元素的元组
 3 tem = 2,      # 可行，但不规范定义
 4 tep = ()      # 空元组
 5
 6 tp = (1, 'ss', 3.5, [6, 'dd'])   # 元组中 可存放任何的 数据类型 int、float、str、bool、字符串、字典、列表等
 7 # 通过索引获取元组中的元素
 8 print(tp[3])             # 输出：[6, 'dd']
 9 print(tp[3][1])          # 输出：'dd'
10 print(tp[::-1])          # 输出：([6, 'dd'], 3.5, 'ss', 1)

元组解包

 1 # 元组解包
 2 c1, c2, c3, c4 = (3, 'd', 5.6), 7.8, 'ee', 4 < 5
 3 print('''
 4 c1类型：{}，c1 = {}
 5 c2类型：{}，c2 = {}
 6 c3类型：{}，c3 = {}
 7 c4类型：{}，c4 = {}
 8  '''.format(type(c1), c1, type(c2), c2, type(c3), c3, type(c4), c4))
 9
10 # 输出：
11 c1类型：<class 'tuple'>，c1 = (3, 'd', 5.6)
12 c2类型：<class 'float'>，c2 = 7.8
13 c3类型：<class 'str'>，c3 = ee
14 c4类型：<class 'bool'>，c4 = True

list 列表

1 # 定义
2 li = [1]                                 # 单个元素的列表
3 ls = [1, 'ss', 3.5, [6, 'dd'], 4 < 5]    # 字典也可存放任何的数据类型
4
5 #通过索引获取列表中的元素
6 print(ls[3])                             # 输出：[6, 'dd']
7 print(ls[3][1])                          # 输出：'dd'
8 print(ls[::-2])                          # 输出：[True, 3.5, 1]

列表操作

 1 name = ['妲己', '安琪拉', '嫦娥', '小乔', '周瑜']
 2
 3 # append()  列表最后新增1个元素，仅1个参数
 4 name.append('高渐离')
 5 print(name)                                #输出：['妲己', '安琪拉', '嫦娥', '小乔', '周瑜', '高渐离']
 6
 7 # extend()  以元组、列表的形式，可添加多个元素
 8 name.extend(['甄姬', '嬴政', '武则天'])      # name=['妲己', '安琪拉', '嫦娥', '小乔', '周瑜', '甄姬', '嬴政', '武则天']
 9
10 # insert(index, arg)  在列表中指定位置，插入元素
11 name.insert(3, '王昭君')                    # name=['妲己', '安琪拉', '嫦娥', '王昭君', '小乔', '周瑜']
12
13 # reverse() 列表 倒序，无参数
14 name.reverse()
15 print(name)                               # 输出：['周瑜', '小乔', '嫦娥', '安琪拉', '妲己']
16
17 # index()  查找指定字符串并返回索引，若字符串不存在，将报错
18 print(name.index('小乔'))                 # 输出：3
19
20 # pop(-2)  删除指定索引的元素，无参数时，默认删除列表最后一个
21 name.pop(-2)                             # name=['妲己', '安琪拉', '嫦娥', '周瑜']
22
23 # remove()  删除找到的第一个指定元素，没有找到要删除的元素，报错
24 name.remove('安琪拉')                     # 输出：['妲己', '嫦娥', '小乔', '周瑜']
25
26 # count() 返回指定元素 在列表中存在的次数
27 name.count('小乔')                        # 输出:1
28
29 # clear() 清空列表，无参数
30 name.clear()                             # 输出：[]
31
32 # del
33 del name[1:4:2]                          # 删除元素，可通过元素索引、切片
34 print(name)                              # 输出：['妲己', '嫦娥', '周瑜']
35
36 del name                                 # 删除列表

列表中的切片操作

1 # 索引1-3的元素，被指定字符替换
2 shooter = ['鲁班', '后羿', '孙尚香', '黄忠', '伽罗', '虞姬']
3 shooter[1:4] = ['马可波罗', '狄仁杰', '李元芳', '百里守约', '成吉思汗']    # 可以用元组、列表 赋值
4 print(shooter)                                                       # 输出：['鲁班', '马可波罗', '狄仁杰', '李元芳', '百里守约', '成吉思汗', '伽罗', '虞姬']
5
6 shooter[1:4] = '百里守约'                                             # 用字符串 赋值
7 print(shooter)                                                       # 输出：['鲁班', '百', '里', '守', '约', '伽罗', '虞姬']

copy() 复制

 1 # copy()   复制列表，无参数
 2 name = ['妲己', '安琪拉', '嫦娥', '小乔', '周瑜']
 3 name1 = name                           # name1 和 name 是同一个列表，id相同
 4 name_copy = name.copy()                # 创建一个新列表name_copy，值同name， id 不同
 5 print(id(name))                        # 输出：2034224161416
 6 print(id(name1))                       # 输出：2034224161416
 7 print(id(name_copy))                   # 输出：2034224161480
 8
 9 name[2] = '诸葛亮'                      # 改变原列表name的值
10 print("""
11 name = {}
12 name1 = {}
13 name_copy = {}
14 """.format(name, name1, name_copy))
15
16 """
17 name 和 name1 的值，均为：['妲己', '安琪拉', '诸葛亮', '小乔', '周瑜']
18 name_copy 值为:['妲己', '安琪拉', '嫦娥', '小乔', '周瑜']
19 """

sort()

 1 # sort() 对列表中元素(相同类型：字符串、数字)，进行升序排序（ASCII）
 2 num = [2, 5, 1, 7, 5.5]
 3 num.sort()
 4 print(num)                             # 输出：[1, 2, 5, 5.5, 7]
 5
 6 str1 = ['d', 'D', 'a', 'F', 'G', 'f']
 7 str1.sort()
 8 print(str1)                            # 输出：['D', 'F', 'G', 'a', 'd', 'f']
 9
10 # 对列表中元素类型为 元组/列表的，元组/列表中，第一个元素的类型需相同
11 club = [(7, 'a', 2, 'ss'), (6, 'x'), (0, 1, 'z')]
12 club.sort()
13 print(club)                            # 输出：[(0, 1, 'z'), (6, 'x'), (7, 'a', 2, 'ss')]
14
15 # 列表中的元素需为同一种类型，才能用sort()排序，否则 报错

列表中的元组，元组中的列表

1 # 列表中，含有元组
2 list_tuple = ['诸葛亮', '张良', '王昭君', ('安琪拉', '妲己')]
3 list_tuple[-1][0] = '甄姬'             # 试图 将元组元素'安琪拉'，修改为‘甄姬’，程序报错
4 list_tuple[-1] = '貂蝉'                # 列表中的元组 只能作为一个整体被替换
5
6 # 元组中的列表
7 tuple_list = ('张良', '王昭君', ['安琪拉', '妲己'])
8 tuple_list[-1][0] = '高渐离'           # 元组中的列表，列表中的元素可被修改 ，但列表不可作为一个整体 被 替换
9 tuple_list[-1] = '周瑜'               # 错误操作

dict 字典

 1 # 定义
 2 dic = {'key1':'value1', 'key2':'value2',……}  # key 必须是唯一的
 3
 4 # tuple类型数据，可作为key
 5 # list 和 dict 不能作为key
 6
 7 dic_name = {1: '庄周', 'key': 6, ('list', 'tuple'): ([1, 2, 'ss'], (5, 6, 'ee'))}
 8 print(dic_name[('list', 'tuple')])           # 输出：([1, 2, 'ss'], (5, 6, 'ee'))
 9
10 # hero1 = {['name', 'age']: 'ss'}            # 运行会报错

 1 # 通过 key 获取/修改 对应的value值
 2 hero = {'na1': '庄周', 'na2': '明世隐', 'na3': '孙膑', 'na4': '鬼谷子'}
 3
 4 # 获取值
 5 print(hero['na1'])                           # 输出：庄周
 6 print(hero.get('na3'))                       # 输出：孙膑
 7
 8 # 修改值
 9 hero['na2'] = '东皇太一'
10 print(hero)                                  # 输出：{'na1': '庄周', 'na2': '东皇太一', 'na3': '孙膑', 'na4': '鬼谷子'}

1 # 获取字典中所有的键值对
2 print(hero.items())                           # 输出：dict_items([('na1', '庄周'), ('na2', '明世隐'), ('na3', '孙膑'), ('na4', '鬼谷子')])
3
4 #将获取的键值对 转化为 list
5 dict_items = list(hero.items())
6
7 # 通过索引获取
8 print(dict_items[1, 1])                        # 输出： 明世隐

 1 # 获取字典中所有的key
 2 print(hero.keys())                            # 输出：dict_keys(['na1', 'na2', 'na3', 'na4'])
 3
 4 # 获取字典中所有的value
 5 print(hero.values())                          # 输出：dict_values(['庄周', '明世隐', '孙膑', '鬼谷子'])
 6
 7 # 清空字典
 8 hero.clear()
 9 print(hero)                                   # 输出：{}
10
11 # 通过key 删除字典中的 key-value 值对
12 hero.pop('na1')                               # 必须传一个参数key
13 print(hero)                                   # 输出: {'na2': '明世隐', 'na3': '孙膑', 'na4': '鬼谷子'}
14
15 # 删除字典最后一个键值对，并返回这个键值对，无需传参
16 print(hero.popitem())                         # 输出：（'na4': '鬼谷子'）
17 print(hero)                                   # 输出：{'na1': '庄周', 'na2': '明世隐', 'na3': '孙膑'}
18
19 # 复制字典
20 hero_copy = hero.copy()

fromkeys([key, ……], '默认值')   字典重定义

1 # 重定义的单个/多个key,  都是相同的默认值
2 hero_redefined = hero.fromkeys(['key1', 'key2', 'key3'], 'default_value')
3 print(hero_redefined)                         # 输出：{'key1': 'default_value', 'key2': 'default_value', 'key3': 'default_value'}
4 print(hero)                                   # 输出：{'na1': '庄周', 'na2': '明世隐', 'na3': '孙膑', 'na4': '鬼谷子'}

setdefault("key", "default_value")  为字典中单个key 赋默认值， 参数为 单个键值对，default_value 值可省略

1 # 若 key 在字典中存在，则不覆盖默认值；若key在字典中不存在，则创建key,并赋初始值
2 hero.setdefault('na1', '鲁班大师'）
3 hero.setdefault('new_key', '蔡文姬'）
4 print(hero)                                  # 输出： {'na1': '庄周', 'na2': '明世隐', 'na3': '孙膑', 'na4': '鬼谷子', 'new_key': '蔡文姬'}

update(dict)  将字典参数更新到目标字典中

1 # update(dict)   参数：字典，将hero_temp字典 更新到 hero字典
2 hero_temp = {'na1': '妲己'， 'na_new': '安琪拉'}
3 hero.update(hero_temp)
4 print(hero)                                # 输出：{'na1': '妲己', 'na2': '明世隐', 'na3': '孙膑', 'na4': '鬼谷子', 'ne': '安琪拉'}

字典中新增键值对

1 hero['诗人'] = '李白'                       # 新增键值对
2 print(hero)                               # 输出：{'na1': '庄周', 'na2': '明世隐', 'na3': '孙膑', 'na4': '鬼谷子', '诗人': '李白'}

Python中 可变类型 与 不可变类型

 1 # 元组 字符串 是不可变类型
 2 tup = ('s1', 's2')
 3 tup = tup.__add__(('s3', 's4'))        # tup 元组 新增 元素，类似于  两个字符串拼接，赋值于另一个变量，元组的地址被改变
 4 print(tup)                             # 输出：('s1', 's2', 's3', 's4')
 5
 6 tup[0] = 's0'                          # 运行报错，因为：元组不可被改变，通过索引 修改 元组元素的值，是不可以的
 7
 8 str1 = 's3 sunday'
 9 print(id(str1))                        # 输出：2444818405680
10 str1 = 'ss'                            # 修改字符串str1标签的指向地址
11 print(id(str1))                        # a 指向的地址改变了， 输出：2444818412744

1 # 列表 字典 是可变类型，可修改列表、字典的元素，地址id不会变
2 ls = [1, 'ss', 3.5, [6, 'dd'], 4 < 5]
3 print(id(ls))                           # 输出：2674034238152
4 ls[1] = 5                               # 修改列表元素
5 print(id(ls))                           # 输出：2674034238152
6 print(ls)                               # 输出：[1, 5, 3.5, [6, 'dd'], True]

字符串 和 列表的区别

1 name = 'Lucy'
2 name.replace('u', 'an')
3 print(name)                            # 输出：Lucy
4 re_name = name.replace('u', 'an')
5 print(re_name)                         # 输出：Lancy

1 str1 = "lucy"
2 str1[1:3] = 'a'   # 报错 TypeError: 'str' object does not support item assignment

类型判断 isinstance()

1 # isinstance(object, type)  类型判断，输出结果：True, False
2 int_num = 8
3 print(isinstance(int_num, int))     # 判断int_num 类型是否为 int类型，输出：True
4 print(isinstance(int_num, float))   # 输出：False

all() 判断元组、列表、集合中，是否存在元素的值为假（即：'', None, 0），是则返回False，否则返回True

 1 # all(object)
 2 tuple_a = (1, 2, 'we', 'are')
 3 tuple_b = ()
 4
 5 list_a = [1, 2, '', 'are']      # list_a = [1, 2, None, 'are']
 6 list_b = []
 7
 8 set_a = {1, 0, 'we', 'are'}
 9 set_b = {}
10
11 print("""
12 tuple_a:{}
13  list_a:{}
14   set_a:{}
15 """.format(all(tuple_a), all(list_a), all(set_a)))
16
17 print("*"*10, """空元组、空列表、空集合，返回Ture
18 tuple_b:{}
19  list_b:{}
20   set_b:{}
21 """.format(all(tuple_b), all(list_b), all(set_b)))
22
23 # 输出：
24 tuple_a:True
25  list_a:False
26   set_a:False
27
28 ********** 空元组、空列表、空集合，返回Ture
29 tuple_b:True
30  list_b:True
31   set_b:True
32 

any() 判断元组、列表、集合中，是否所有的元素值都为假（即：'', None, 0），是则返回False， 否则返回True

 1 # any(object)
 2 tuple_a = (4, None, 'ss', 0, '')
 3 tuple_b = ()
 4
 5 list_a = ['', 0, None]
 6 list_b = []
 7
 8 set_a = {4, 'ss', None}
 9 set_b = {}
10 print('''
11 tuple_a : {}
12 list_a  : {}
13  set_a  : {}
14  '''.format(any(tuple_a), any(list_a), any(set_a)))
15
16 print('*'*10, '''空元组、空列表、空集合，返回False
17 tuple_b : {}
18 list_b  : {}
19  set_b  : {}
20  '''.format(any(tuple_b), any(list_b), any(set_b)))
21
22 # 输出：
23 tuple_a : True
24 list_a  : False
25  set_a  : True
26
27 ********** 空元组、空列表、空集合，返回False
28 tuple_b : False
29 list_b  : False
30  set_b  : False
31