Python之常用数据类型详解

tuple 元组 

# 定义
temp = (2, )  # 规范定义，单个元素的元组
tem = 2,      # 可行，但不规范定义
tep = ()      # 空元组

tp = (1, 'ss', 3.5, [6, 'dd'])   # 元组中 可存放任何的 数据类型 int、float、str、bool、字符串、字典、列表等
# 通过索引获取元组中的元素
print(tp[3])             # 输出：[6, 'dd']
print(tp[3][1])          # 输出：'dd'
print(tp[::-1])          # 输出：([6, 'dd'], 3.5, 'ss', 1)

元组解包

# 元组解包
c1, c2, c3, c4 = (3, 'd', 5.6), 7.8, 'ee', 4 < 5
print('''
c1类型：{}，c1 = {}
c2类型：{}，c2 = {}
c3类型：{}，c3 = {}
c4类型：{}，c4 = {}
 '''.format(type(c1), c1, type(c2), c2, type(c3), c3, type(c4), c4))

# 输出：
c1类型：<class 'tuple'>，c1 = (3, 'd', 5.6)
c2类型：<class 'float'>，c2 = 7.8
c3类型：<class 'str'>，c3 = ee
c4类型：<class 'bool'>，c4 = True

list 列表

# 定义
li = [1]                                 # 单个元素的列表
ls = [1, 'ss', 3.5, [6, 'dd'], 4 < 5]    # 字典也可存放任何的数据类型

#通过索引获取列表中的元素
print(ls[3])                             # 输出：[6, 'dd']
print(ls[3][1])                          # 输出：'dd'
print(ls[::-2])                          # 输出：[True, 3.5, 1]

列表操作

name = ['妲己', '安琪拉', '嫦娥', '小乔', '周瑜']

# append()  列表最后新增1个元素，仅1个参数
name.append('高渐离')
print(name)                                #输出：['妲己', '安琪拉', '嫦娥', '小乔', '周瑜', '高渐离']

# extend()  以元组、列表的形式，可添加多个元素
name.extend(['甄姬', '嬴政', '武则天'])      # name=['妲己', '安琪拉', '嫦娥', '小乔', '周瑜', '甄姬', '嬴政', '武则天']

# insert(index, arg)  在列表中指定位置，插入元素
name.insert(3, '王昭君')                    # name=['妲己', '安琪拉', '嫦娥', '王昭君', '小乔', '周瑜']

# reverse() 列表 倒序，无参数
name.reverse()
print(name)                               # 输出：['周瑜', '小乔', '嫦娥', '安琪拉', '妲己']

# index()  查找指定字符串并返回索引，若字符串不存在，将报错
print(name.index('小乔'))                 # 输出：3

# pop(-2)  删除指定索引的元素，无参数时，默认删除列表最后一个
name.pop(-2)                             # name=['妲己', '安琪拉', '嫦娥', '周瑜']

# remove()  删除找到的第一个指定元素，没有找到要删除的元素，报错
name.remove('安琪拉')                     # 输出：['妲己', '嫦娥', '小乔', '周瑜']

# count() 返回指定元素 在列表中存在的次数
name.count('小乔')                        # 输出:1

# clear() 清空列表，无参数 
name.clear()                             # 输出：[]

# del 
del name[1:4:2]                          # 删除元素，可通过元素索引、切片
print(name)                              # 输出：['妲己', '嫦娥', '周瑜']

del name                                 # 删除列表

列表中的切片操作

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

shooter[1:4] = '百里守约'                                             # 用字符串 赋值
print(shooter)                                                       # 输出：['鲁班', '百', '里', '守', '约', '伽罗', '虞姬']

copy() 复制

# copy()   复制列表，无参数
name = ['妲己', '安琪拉', '嫦娥', '小乔', '周瑜']
name1 = name                           # name1 和 name 是同一个列表，id相同
name_copy = name.copy()                # 创建一个新列表name_copy，值同name， id 不同
print(id(name))                        # 输出：2034224161416
print(id(name1))                       # 输出：2034224161416
print(id(name_copy))                   # 输出：2034224161480

name[2] = '诸葛亮'                      # 改变原列表name的值
print("""
name = {}
name1 = {}
name_copy = {}
""".format(name, name1, name_copy))

"""
name 和 name1 的值，均为：['妲己', '安琪拉', '诸葛亮', '小乔', '周瑜']
name_copy 值为:['妲己', '安琪拉', '嫦娥', '小乔', '周瑜']
"""

sort()

# sort() 对列表中元素(相同类型：字符串、数字)，进行升序排序（ASCII）
num = [2, 5, 1, 7, 5.5]
num.sort()
print(num)                             # 输出：[1, 2, 5, 5.5, 7]

str1 = ['d', 'D', 'a', 'F', 'G', 'f']
str1.sort()
print(str1)                            # 输出：['D', 'F', 'G', 'a', 'd', 'f']

# 对列表中元素类型为 元组/列表的，元组/列表中，第一个元素的类型需相同
club = [(7, 'a', 2, 'ss'), (6, 'x'), (0, 1, 'z')]
club.sort()
print(club)                            # 输出：[(0, 1, 'z'), (6, 'x'), (7, 'a', 2, 'ss')]

# 列表中的元素需为同一种类型，才能用sort()排序，否则 报错

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

# 列表中，含有元组
list_tuple = ['诸葛亮', '张良', '王昭君', ('安琪拉', '妲己')]
list_tuple[-1][0] = '甄姬'             # 试图 将元组元素'安琪拉'，修改为‘甄姬’，程序报错
list_tuple[-1] = '貂蝉'                # 列表中的元组 只能作为一个整体被替换

# 元组中的列表
tuple_list = ('张良', '王昭君', ['安琪拉', '妲己'])
tuple_list[-1][0] = '高渐离'           # 元组中的列表，列表中的元素可被修改 ，但列表不可作为一个整体 被 替换
tuple_list[-1] = '周瑜'               # 错误操作

dict 字典

# 定义
dic = {'key1':'value1', 'key2':'value2',……}  # key 必须是唯一的

# tuple类型数据，可作为key
# list 和 dict 不能作为key

dic_name = {1: '庄周', 'key': 6, ('list', 'tuple'): ([1, 2, 'ss'], (5, 6, 'ee'))}
print(dic_name[('list', 'tuple')])           # 输出：([1, 2, 'ss'], (5, 6, 'ee'))

# hero1 = {['name', 'age']: 'ss'}            # 运行会报错

# 通过 key 获取/修改 对应的value值
hero = {'na1': '庄周', 'na2': '明世隐', 'na3': '孙膑', 'na4': '鬼谷子'}

# 获取值
print(hero['na1'])                           # 输出：庄周
print(hero.get('na3'))                       # 输出：孙膑

# 修改值
hero['na2'] = '东皇太一'
print(hero)                                  # 输出：{'na1': '庄周', 'na2': '东皇太一', 'na3': '孙膑', 'na4': '鬼谷子'}

# 获取字典中所有的键值对
print(hero.items())                           # 输出：dict_items([('na1', '庄周'), ('na2', '明世隐'), ('na3', '孙膑'), ('na4', '鬼谷子')])

#将获取的键值对 转化为 list
dict_items = list(hero.items())

# 通过索引获取
print(dict_items[1, 1])                        # 输出： 明世隐

# 获取字典中所有的key
print(hero.keys())                            # 输出：dict_keys(['na1', 'na2', 'na3', 'na4'])

# 获取字典中所有的value
print(hero.values())                          # 输出：dict_values(['庄周', '明世隐', '孙膑', '鬼谷子'])

# 清空字典
hero.clear()
print(hero)                                   # 输出：{}

# 通过key 删除字典中的 key-value 值对
hero.pop('na1')                               # 必须传一个参数key
print(hero)                                   # 输出: {'na2': '明世隐', 'na3': '孙膑', 'na4': '鬼谷子'}

# 删除字典最后一个键值对，并返回这个键值对，无需传参
print(hero.popitem())                         # 输出：（'na4': '鬼谷子'）
print(hero)                                   # 输出：{'na1': '庄周', 'na2': '明世隐', 'na3': '孙膑'}

# 复制字典
hero_copy = hero.copy()

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

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

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

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

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

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

字典中新增键值对

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

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

# 元组 字符串 是不可变类型
tup = ('s1', 's2')
tup = tup.__add__(('s3', 's4'))        # tup 元组 新增 元素，类似于  两个字符串拼接，赋值于另一个变量，元组的地址被改变
print(tup)                             # 输出：('s1', 's2', 's3', 's4')

tup[0] = 's0'                          # 运行报错，因为：元组不可被改变，通过索引 修改 元组元素的值，是不可以的

str1 = 's3 sunday'
print(id(str1))                        # 输出：2444818405680
str1 = 'ss'                            # 修改字符串str1标签的指向地址
print(id(str1))                        # a 指向的地址改变了， 输出：2444818412744

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

字符串 和 列表的区别

name = 'Lucy'
name.replace('u', 'an')
print(name)                            # 输出：Lucy
re_name = name.replace('u', 'an')
print(re_name)                         # 输出：Lancy

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

 类型判断 isinstance()

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

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

# all(object)
tuple_a = (1, 2, 'we', 'are')
tuple_b = ()

list_a = [1, 2, '', 'are']      # list_a = [1, 2, None, 'are']
list_b = []

set_a = {1, 0, 'we', 'are'}
set_b = {}

print("""
tuple_a:{}
 list_a:{}
  set_a:{}
""".format(all(tuple_a), all(list_a), all(set_a)))

print("*"*10, """空元组、空列表、空集合，返回Ture
tuple_b:{}
 list_b:{}
  set_b:{}
""".format(all(tuple_b), all(list_b), all(set_b)))

# 输出：
tuple_a:True
 list_a:False
  set_a:False

********** 空元组、空列表、空集合，返回Ture
tuple_b:True
 list_b:True
  set_b:True

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

# any(object)
tuple_a = (4, None, 'ss', 0, '')
tuple_b = ()

list_a = ['', 0, None]
list_b = []

set_a = {4, 'ss', None}
set_b = {}
print('''
tuple_a : {}
list_a  : {}
 set_a  : {}
 '''.format(any(tuple_a), any(list_a), any(set_a)))

print('*'*10, '''空元组、空列表、空集合，返回False
tuple_b : {}
list_b  : {}
 set_b  : {}
 '''.format(any(tuple_b), any(list_b), any(set_b)))

# 输出：
tuple_a : True
list_a  : False
 set_a  : True
 
********** 空元组、空列表、空集合，返回False
tuple_b : False
list_b  : False
 set_b  : False