python中的数据类型

Python的组合数据类型有四种，分别是：列表(list)、元组(tuple)、集合(set)、字典(dict)
这里就简单介绍一下

列表（list）

什么是列表

列表是python中可以存储多个数据的数据类型。

列表的声明

变量=list（)
变量=[ ]
这两种都可以声明一个空的列表

>>> s=list()
>>> type(s)
<class 'list'>
>>>jobs=[]
>>> type(jobs)
<class 'list'>

list的操作：

1. 增加数据

• list.append() 默认在list末尾添加一个数据
• list.insert() 插入，可指定位置
• list.extend() 在末尾添加，可追加多个数据，也可以实现两个列表的组合

2. 删除数据

• del list[index] 直接删除
• list.clear() 清空所有数据

3. 修改数据

• list[index]=数据

4. 查询

• 通过index（下标）查询

5. 其它操作

• list.copy() 列表的拷贝，结果是一个列表
• list.count() 统计元素出现的次数
• list.index() 查看元素的下标/索引
• list.reverse 反转
• list.sort 按自然数排列，只能排列纯数字或者纯字符的列表，不能排列各种数据类型混合的列表

g1=[1000,'可口可乐（罐装）',2.5,100]
>>> print(g1)
[1000, '可口可乐（罐装）', 2.5, 100]
>>> g1.append("密封")    #添加一个数据，在最后添加
>>> print(g1)
[1000, '可口可乐（罐装）', 2.5, 100, '密封']
>>> g1.insert(1,'美国')    #指定位置的添加
>>> print(g1)
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封']
>>> g2=[1001,'可口可乐（瓶装）',3.0,100]
>>> g1.append(g2)     #把g2当做有个数据添加到最后
>>> g1
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封', [1001, '可口可乐（瓶装）', 3.0, 100]]
>>> g1.extend(g2)    #添加多个数据
>>> g1
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封', [1001, '可口可乐（瓶装）', 3.0, 100], 1001, '可口可乐（瓶装）', 3.0, 100]
>>> del g1[6]      #删除指定的数据
>>> g1
[1000, '美国', '可口可乐（罐装）', 2.5, 100, '密封', 1001, '可口可乐（瓶装）', 3.0, 100]
g1[0]=1
>>> g1
[g1[2]
'可口可乐（罐装）'
>>> g3=g1.copy()      #拷贝
>>> g3
[1, '美国', '可口可乐（罐装）', 2.5, 100, '密封', 1001, '可口可乐（瓶装）', 3.0, 100]1, '美国', '可口可乐（罐装）', 2.5, 100, '密封', 1001, '可口可乐（瓶装）', 3.0, 100]
g1.count(2.5)      #统计一个元素出现的次数
1
>>> g1.reverse()    #翻转列表
>>> g1
[100, 3.0, '可口可乐（瓶装）', 1001, '密封', 100, 2.5, '可口可乐（罐装）', '美国', 1]

元组

什么是元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组的声明

元组使用小括号，元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
t=tuple()
t1=()
t2=(1,2,3,4,)
但是t3=('hello') ->type(t3)->str
可以t4=('hello',) 在后面加一个逗号
元组的方法：count，index
元组中的操作类型只有这两个方法

>>> t=tuple()
>>> type(t)
<class 'tuple'>
>>> t1=()
>>> type(t1)
<class 'tuple'>
>>> t3=('hello')
>>> type(t3)
<class 'str'>
>>> t4=("hello",)
>>> type(t4)
<class 'tuple'>

其中tuple.count() 是统计一个元素出现的次数
tuple.index() 是查看一个元素在元组中的下标

集合

什么是集合

需求场景：我们需要存放一组数据，但是不希望存放重复的数据！用户的账号！
集合：通过哈希(hash)算法在一个容器中存放多个没有顺序的不可以重复的数据

声明集合：

s1 = set() <class ‘set’>
s2 = {“a”} <class ‘set’>
s3 = {} <class ‘dict’>
应为集合和字典都是使用{}表示，但是s3={}声明的是一个字典

集合的操作

set.add   增加
set.clear   清空
set.copy   复制
set.difference   两个集合之间求差集
set.difference_update   求差集并且用不一样的数据重新给自己赋值
set.discard   移除元素
set.intersection   求交集
set.intersection_update   求交集并给自己赋值
set.pop   随机删除一个
set.remove   指定删除某个数据
set.union   求并集
set.update   求并集并给自己赋值

>>> s1={1,2,3,4,5,6}
>>> s2={4,5,6,7,8,9}
>>> s1
{1, 2, 3, 4, 5, 6}
>>> s2
{4, 5, 6, 7, 8, 9}
>>> s1.add(0)   #添加一个元素
>>> s1
{0, 1, 2, 3, 4, 5, 6}
>>> s1.difference(s2)   #s1与s2求差集
{0, 1, 2, 3}
>>> s1.difference_update(s2)   #s1与s2求差集，并把自己等于所得差集
>>> s1
{0, 1, 2, 3}
s1.discard(0)      #删除一个指定元素，若元素不存在，则不报错
>>> s1
{1, 2, 3}
>>>s1
{1, 2, 3, 4, 5, 6}
>>> s1.intersection(s2)  #s1与s2取交集
{4, 5, 6}
>>> s1.intersection_update(s2)    #s1与s2取交集，并把自己等于交集
>>> s1
{4, 5, 6}
>>> s1.pop()    #随机删除一个元素
4
>>> s1
{5, 6}
>>> s1.remove(5)    #删除一个指定元素，若元素不存在，则报错
>>> s1
{6}
>>> s1={2,3,4,5,6}
>>> s1
{2, 3, 4, 5, 6}
>>> s1.union(s2)      #s1与s2取并集
{2, 3, 4, 5, 6, 7, 8, 9}
>>> s1
{2, 3, 4, 5, 6}
>>> s2
{4, 5, 6, 7, 8, 9}
>>> s1.update(s2)    #s1与s2取并集，并把自己等于并集
>>> s1
{2, 3, 4, 5, 6, 7, 8, 9}

字典

什么是字典

可以存储多个key:value 键值对数据的组合数据类型

字典的声明

d1 = dict()    # 空字典
d2 = {}     # 空字典

>>> d1  = dict()    # 空字典
>>> d2 = {}
>>> type(d1)    # 空字典
<class 'dict'>
>>> type(d2)
<class 'dict'>
>>> d1
{}
>>> d2
{}

字典的操作

doct.clear   清空
doct.copy   复制
doct.fromkeys   通过制定的key生成一个值为None的字典
doct.get   根据key获取对应的值
doct.items   获取所有的k:v键值对
doct.keys   获取所有的键
doct.pop   根据key值删除一个键值对
doct.popitem   随机删除一个键值对
doct.setdefault    增加一个数据，如果数据存在~修改
doct.update   把字典dict2的键/值对更新到dict里
doct.values   获取所有的值
字典中，增加数据
f[key] = value
f.setdefault(key, value)
f.update(key, value)
删除数据:删除一个键值对
f.pop(key)    删除制定的key:value键值对
f.popitem()    随机删除一个键值对
def f[key]    删除制定的key:value键值对
修改数据
f[key] = value
f.update({key, value})
查询数据
v = f[key]
v = f.get(key)

>>> d1={1:'a',2:'b',3:'c','dict':'字典','list':'列表','tuple':'元组',}
>>> d1
{1: 'a', 2: 'b', 3: 'c', 'dict': '字典', 'list': '列表', 'tuple': '元组'}
>>> d2={1:100,2:200,3:300,4:400,5:500,6:600}
>>> d2
{1: 100, 2: 200, 3: 300, 4: 400, 5: 500, 6: 600}
>>> d3=dict.fromkeys('1,2,3,4,5,6')    #通过制定的key生成一个值为None的字典
>>> d3
{'1': None, ',': None, '2': None, '3': None, '4': None, '5': None, '6': None}
>>> d1.get('dict')    #t通过键查找值
'字典'
>>> d1.items()      #返回所有键值对
dict_items([(1, 'a'), (2, 'b'), (3, 'c'), ('dict', '字典'), ('list', '列表'), ('tuple', '元组')])
>>> d1.keys()    #返回所有键
dict_keys([1, 2, 3, 'dict', 'list', 'tuple'])
>>> d1.values()    返回所有值
dict_values(['a', 'b', 'c', '字典', '列表', '元组'])
>>> d2
{1: 100, 2: 200, 3: 300, 4: 400, 5: 500, 6: 600}
 d2.pop(1)      #删除指定键的键值对
100
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500, 6: 600}
 d2.popitem()    #随机删除键值对
(6, 600)
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500}
>>>d2.setdefault(7)    #增加一个数据，如果数据存在~修改
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500, 7: None}
d1
{1: 'a', 2: 'b', 3: 'c', 'dict': '字典', 'list': '列表', 'tuple': '元组'}
>>> d2
{2: 200, 3: 300, 4: 400, 5: 500, 7: None}
>>> d1.update(d2)     #把字典2整合到字典1中
>>> d1
{1: 'a', 2: 200, 3: 300, 'dict': '字典', 'list': '列表', 'tuple': '元组', 4: 400, 5: 500, 7: None}

遍历字典

for k in f.keys():# 直接循环字典中的key数据
    print(k, f.get(k)) # value数据通过key数据获取

for k, v in f.items():# 直接循环字典中的key和value数据
    print(k, v)

>>> for k in d1.keys():
...     print(k,d1.get(k))      # value数据通过key数据获取
...
1 a
2 200
3 300
dict 字典
list 列表
tuple 元组
4 400
5 500
7 None
>>> for k,v in d1.items():      # 直接循环字典中的key和value数据
...     print(k,v)
...
1 a
2 200
3 300
dict 字典
list 列表
tuple 元组
4 400
5 500
7 None