Python系列之 - python数据类型(二)

我会带着你远行 2022-08-19 08:26 219阅读 0赞

前面我们讲完了数据类型中的整型、字符串型，这章接着来说数据类型：列表、元组、字典

### 列表( list ) ###

python中的列表是一个具有灵活性的有序集合对象类型，与字符串不同,列表可以包含任何类型的对象、数字、字符串甚至其他列表。

列表的声明方式

>>> a=[1,2,3,4]
    >>> b=list('1234')
    >>> c=list(range(4))
    >>> a
    [1, 2, 3, 4]
    >>> b
    ['1', '2', '3', '4']
    >>> c
    [0, 1, 2, 3]

#### 列表常用方法 ####

**append  extend **扩展列表，追加

>>> a
    [1, 2, 3, 4]
    >>> b
    ['1', '2', '3', '4']
    >>> a.extend(b)
    >>> a
    [1, 2, 3, 4, '1', '2', '3', '4']
    >>> a.append('10')
    >>> a
    [<span style="font-family: Arial, Helvetica, sans-serif;">1, 2, 3, 4, '1', '2', '3', '4'</span>, '10']

**clear**  清空列表

>>> a
    [1, 2, 3, 4, '1', '2', '3', '4']
    >>> a.clear()
    >>> a
    []

**copy  **拷贝列表

>>> a
    []
    >>> a = b.copy()
    >>> a
    ['1', '2', '3', '4']

**count**  获取列表中某元素个数

>>> a
    ['1', '2', '3', '4', '2', '4', '4', '1', '3']
    >>> a.count('2')
    2

**index**  获取列表中指定元素数显的第一个的位置下标

>>> a
    ['1', '2', '3', '4', '2', '4', '4', '1', '3', '10']
    >>> a.index('2')
    1

**insert(index,obj)**  在指定位置index插入指定元素obj

>>> a.insert(2,'99')
    >>> a
    ['1', '2', '99', '3', '4', '2', '4', '4', '1', '3', '10']

**pop(index)**   将指定位置的元素取出，并从列表中删除

>>> a
    ['2', '3', '4', '2', '4', '4', '1', '3']
    >>> a.pop(2)
    '4'
    >>> a
    ['2', '3', '2', '4', '4', '1', '3']

**remove(value)** 将指定的元素删除,,如果列表有多个指定的值,则从下标0开始的第一个元素删除

>>> a
    ['2', '3', '2', '4', '1', '3']
    >>> a.remove('2')
    >>> a
    ['3', '2', '4', '1', '3']

**reverse** 列表元素反转

>>> a
    [1, 2, 3, 4, 5, 6]
    >>> a.reverse()
    >>> a
    [6, 5, 4, 3, 2, 1]

**sort**  列表元素正序排序,如果列表中所有元素的类型不一样,则报错

>>> a
    [6, 5, 4, 3, 2, 1]
    >>> a.sort()
    >>> a
    [1, 2, 3, 4, 5, 6]

#### 应用中的列表 ####

1.分片 和字符串的分片类似，通过  \[start:end\]  来获取列表中的一段元素

>>> a
    [1, 2, 3, 4, 5, 6]
    >>> a[0:3]
    [1, 2, 3]

2.运算  列表也支持"+" "\*"的运算，和字符类似表示列表的合并和重复

>>> a = [1,2,3]
    >>> b = [4,5,6]
    >>> a+b
    [1, 2, 3, 4, 5, 6]
    >>> a*2
    [1, 2, 3, 1, 2, 3]

3.矩阵  矩阵就是相当于一个多维数组，在列表中嵌套列表

>>> a
    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    >>> a[1][0]
    4

4.更改值, 直接对指定的下标值修改

>>> b
    [4, 5, 6]
    >>> b[1]=100
    >>> b
    [4, 100, 6]

5.列表的遍历

>>> a=[1,2,3,4,5]
    >>> for i in a:
    	print(i)	
    1
    2
    3
    4
    5

### 元组(tuple) ###

元组和列表类似，我们可以把元组认为是列表的只读形式。既然是只读方式,元组肯定就比列表的方法要少,不能进行删除、添加等操作

#### 元组的声明 ####

>>> a = ()
    >>> b = tuple()
    >>> a
    ()
    >>> b
    ()

#### 元组的方法 ####

通过dir(tuple)查看元组的方法，会发现元组就支持: count()   index()两种内置方法，与列表类似

### 字典(dict) ###

除了列表之外，字典是python中最灵活的数据结构类型。不过不同于列表的是,字典是一个无序的集合，而且字典是通过键值来获取值,而不是通过偏移来获取值。字典的表示形式为 \{ key：value\} 的形式进行保存

#### 字典的声明 ####

>>> a = {'key1':'value1','key2':'value2'}
    >>> a
    {'key1': 'value1', 'key2': 'value2'}
    >>> b=dict(key1='value1',key2='value2')
    >>> b
    {'key1': 'value1', 'key2': 'value2'}

也可以通过两个列表的zip方式来实现

>>> a=['key1','key2']
    >>> b=['value1','value2']
    >>> d=dict(zip(a,b))
    >>> d
    {'key1': 'value1', 'key2': 'value2'}

#### 字典的常用方法 ####

1 get(key,default) 取值

>>> d
    {'key1': 'value1', 'key2': 'value2'}
    >>> d['key1']  直接通过可以获取值,可以不存在则报错
    'value1'
    >>> d.get('key3','aaa') 通过get可以获取不存在的key,没有返回默认值
    'aaa'

2 fromkeys(obj,value)  将obj作为可以，value作为默认值生成一个默认字典，obj可以为字典、元组、列表

>>> aaa = dict.fromkeys((1,2),0) 将元组的值作为key
    >>> aaa
    {1: 0, 2: 0}
    >>> d
    {'key1': 'value1', '1': 'aa', 'key2': 'value2'}
    >>> aaa = dict.fromkeys(d,'123')  将字典d的key作为key
    >>> aaa
    {'key1': '123', '1': '123', 'key2': '123'}

注意：通过fromkey获取生成的字典,有多个key时,每个key的值是一样的,都是指向内存中的同一个地址,所以当修改其中的一个值时,所有的值都会修改

3 clear()  清空字典

4 items()  将字典的key,value作为元组的方式返回成一个列表

>>> d.items()
    dict_items([('key1', 'value1'), ('1', 'aa'), ('key2', 'value2')])
    >>> for k,v in d.items():
    	print(k,v)
    	
    key1 value1
    1 aa
    key2 value2

4. keys() 将字典的所有key 作为一个列表返回

>>> d
    {'key1': 'value1', '1': 'aa', 'key2': 'value2'}
    >>> d.keys()
    dict_keys(['key1', '1', 'key2'])

5.pop(k,\[,d\])  删除字典的指定键k，并返回k对应的值,如果k不存在,如果指定默认值d则返回d，否则报错

>>> d
    {'1': 'aa', 'key2': 'value2'}
    >>> d.pop(2,'aaa')  2为key值
    'aaa'

6.popitem() 删除字典中的(key:value),并将结果以元组的方式返回.如果字典为空将报错KeyError

>>> d
    {1: '1', 3: '3', 4: '4', 5: '5', 2: '2'}
    >>> d.popitem()
    (3, '3')
    >>> d
    {1: '1', 4: '4', 5: '5', 2: '2'}

由于字典为无序的集合,popitem是也不会按照顺序进行删除

7.values() 与keys方法类似，将字典的结果以列表方式返回

8.update(dict) 字典更新函数， 相当于合并函数，如dic1.update(dic2),将dic2的所有值复制到dic1中，如果有重复键，则将值更新为dic2中健值。

>>> a1={1:'a',2:'b',3:'c'}
    >>> a2={4:'d',5:'e',2:'f'}
    >>> a1.update(a2)
    >>> a1
    {1: 'a', 2: 'f', 3: 'c', 4: 'd', 5: 'e'}

9. setdefault(k\[,d\]) 与get类似，只是这个函数用来给字典赋值，如果指定的k在字典中存在则返回字典中的对应值，如果不存在则给字典增加一个K值，value为d

>>> a1
    {1: 'a', 2: 'f', 3: 'c', 4: 'd', 5: 'e'}
    >>> a1.setdefault(3,'dd')
    'c'
    >>> a1
    {1: 'a', 2: 'f', 3: 'c', 4: 'd', 5: 'e'}
    >>> a1.setdefault(6,'ddd')
    'ddd'
    >>> a1
    {1: 'a', 2: 'f', 3: 'c', 4: 'd', 5: 'e', 6: 'ddd'}

#### 排序字典键 ####

我们说字典是无序的，如果要给字典排序该怎么做呢，只能通过键值key开操作，将获取的键变为列表排序后再显示。我们看一下下面的实现方法：

test_dict = {3:'a',1:'b',8:'d',2:'i',5:'s'}
    key_list = test_dict.keys()
    key_list.sort()
    for key in key_list:
        print(key,test_dict[key])

### 集合(set） ###

set是一个无序且不重复的元素集合

集合的常用方法

a1 = [1,2,4,3,4,2,6,1,9]
    a2 = [1,3,7,8,9,0,7,8,9]
    
    set_1 = set(a1)
    set_2 = set(a2)
    
    print('set1:', set_1)    # set1: {1, 2, 3, 4, 6, 9}
    print('set2:', set_2)    # set2: {0, 1, 3, 7, 8, 9}
    
    #  add ： 添加元素到集合,若元素存在则不添加
    set_1.add(0)
    print('添加(add):',set_1)  # 添加(add): {0, 1, 2, 3, 4, 6, 9}
    
    # clear ： 清空集合元素
    set_1.clear()
    print('清空集合(clear):', set_1)  # 清空集合(clear): set()
    
    # copy ： 拷贝集合
    tmpset = set_1.copy()
    print('拷贝(copy):', tmpset)  # 拷贝(copy): {1, 2, 3, 4, 6, 9}
    
    # difference : 差集(set_1中存在而set_2中没有的元素) ,此方法是返回一个新的结果,原集合不更新
    print('差集(difference):', set_1.difference(set_2))  # 差集(difference): {2, 4, 6}
    
    # difference_update : 差集,原集合更新
    set_1.difference_update(set_2)
    print(set_1)      # set([2, 4, 6]) 
    
    # discard: 删除集合中的元素,如果元素不存在不报错,什么也不做
    set_1.discard(100)
    print(set_1)   #{1, 2, 3, 4, 6, 9}
     # pop 删除一个元素,从左边删除
    set_1.pop()
    print(set_1)  # {2, 3, 4, 6, 9}
    
    #  remove 删除集合中的一个元素, 删除的元素必须存在于集合中,不存在则报错KeyError
    set_1.remove(4)
    print(set_1) # {1, 2, 3, 6, 9} # intersection 交集,返回一个新集合,自身不更新print('交集(intersection):', set_1.intersection(set_2)) # 交集(intersection): {1, 9, 3}# intersection_update 取交集,自身更新,set_1.intersection_update(set_2)print(set_1) # {1, 9, 3}# isdisjoint 如果两个集合的交集为空，返回Trueprint(set_1.isdisjoint(set_2))
     # Falsea = set([1,2,3])b = set([4,5,6])print(a.isdisjoint(b)) #True# issubset 若集合A包含于B，返回True ,也就是集合B是集合A的子集A = set([2,3])B = set([1,2,3,4])print(A.issubset(B)) #True# issuperset 与issubset相反，如果A包含于B即 A是B的子集,返回TrueA = set([2,3])B = set([1,2,3,4])print(B.issuperset(A))
     #True#symmetric_difference 对称差(将两个集合的相同元素删除后的并集),返回一个新集合,原集合不改变set1: {1, 2, 3, 4, 6, 9}set2: {0, 1, 3, 7, 8, 9}print(set_1.symmetric_difference(set_2)) # {0, 2, 4, 6, 7, 8}# symmetric_difference_update 同symmetric_difference,原集合值改变set1: {1, 2, 3, 4, 6, 9}set2:
     {0, 1, 3, 7, 8, 9}set_1.symmetric_difference_update(set_2)print(set_1) # {0, 2, 4, 6, 7, 8}#union 并集 ,返回一个新集合,原集合不变print('并集:(union)', set_1.union(set_2)) # 并集:(union) {0, 1, 2, 3, 4, 6, 7, 8, 9}# update 并集,不返回值, 原集合更新
     
    
    
    取交集、差集、并集、对称差集的时候，除了使用函数方式来实现，还可以另一种方式

a = t | s  并集

a= t & s 交集

a= t - s 差集

a= t ^ s 对称差集 (两个集合互相取差集)