python数据类型列表 集合 字典 元组

写在前面 关于数据类型需要记得东西
可变的数据类型 ：列表 字典
不可变 字符串: 数字 元组
顺序访问类型： 字符串 列表 元组
映射: 字典
容器数据类型: 列表,元组 字典
原子: （只可以存一个值）数字 字符串

列表

列表的基本操作

列表的创建

列表名= []
特点就是用中括号把元素值给括起开，每个元素之间需需要用逗号隔开

>>> a = []
>>> type(a)
<class 'list'>

存放的数据

列表中可以存 数据，字符串，列表，元祖，字典，集合，布尔值

>>> aa =[1,'a',[1,2,3,4],(1,2,4,5),{'k1':123},True]
>>> aa
[1, 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True]

列表的访问

对列表中元素进行访问是可通过索引，切片（加上步长），的形式
需要注意的是索引是从0开始的，也就是第一个元素下标为0，关于切片需要注意的就是包头不包尾，也就是从开始下标取到结束下标的前一个元素。

    >>> aa =[1,'a',[1,2,3,4],(1,2,4,5),{'k1':123},True，1]
    >>> aa
    [1, 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True，1]
    >>> aa[0]
    1
    #切片操作
    >>> aa[0:2]
    [1, 'a']
    #取步长操作，有结果可以看出从第一个元素开始，每数两个元素就会输出一个
    
        >>> aa[0:5:2]
        [1, [1, 2, 3, 4], {'k1': 123}]

#取步长操作，有结果可以看出从第一个元素开始，每数两个元素就会输出一个，
#注意当未指定结束下表失，它会取整个列表

    >>> aa[0::3]
    [1, (1, 2, 4, 5), 1]

#二级查询

    aa[2][0]

添加列表元素

1 append（）在末尾添加元素。

 >>> aa.append('new ele')
    >>> aa
    [1, 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True, 1, 2, 'new ele']

2 insert（下标，值）添加元素，注意他是在指定下标之前进行插入

>>> aa
['aa', 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True, 1, 2, 
'new ele']
>>> aa.insert(0,'new')
>>> aa
['new', 'aa', 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123},
 True, 1, 2, 'new ele']
>>> aa.insert(1,'123')
>>> aa
['new', '123', 'aa', 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, 
True, 1, 2, 'new ele']1, 2, 'new ele']

删除元素

1 del 列表名[删除元素下标]

>>> aa
['new', '123', 'aa', 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, 
True, 1, 2, 'new ele']
>>> del aa[0]
>>> aa
['123', 'aa', 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, 
True, 1, 2, 'new ele']

2 pop（）出栈法 它默认弹出最后一个元素，也可以指定位置删除

>>> aa
    ['123', 'aa', 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True, 1, 2, 'new ele']
    >>> aa.pop()
    'new ele'

3 删除指定下标的元素

   >>> aa
    ['aa', 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True, 1, 2]
    >>> aa.remove('aa')
    >>> aa
    ['a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True, 1, 2]

修改元素值

   >>> aa
    [1, 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True, 1, 2, 'new ele']
    >>> aa[0]= 'aa'
    >>> aa
    ['aa', 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True, 1, 2, 'new ele']

列表其他操作

排序
使用方法 sort() 对列表进行永久性排序，如果对一串字母进行排序，那么他会按照这字母表顺序进行排序，数字的话按大小进行反洗，
也可以进行反向排序，方法：sort(reverse=True)

>>> a = ['q','g','h','d']
>>> a.sort()
>>> a
['d', 'g', 'h', 'q']

数字排序

>>> num = [2,4,6,74,8]
>>> num.sort()
>>> num
[2, 4, 6, 8, 74]

反向排序

>>> num.sort(reverse=True)
>>> num
[74, 8, 6, 4, 2]

返回列表长度
len(列表)

>>> num
[74, 8, 6, 4, 2]
>>> len(num)
5

遍历列表
for循环遍历

>>> num
[74, 8, 6, 4, 2]
>>> for i in num :
	i
=====结果=====	
74
8
6
4
2

判断元素是否在列表中
使用in方法 如果在列表中就返回真，不在则返回假 in操

>>> 1 in aa
True
>>> 123 in aa
False

清空列表
clear（）

>>> a2 = [1,2,3,45,6,678,8]
>>> a2.clear()
>>> a2
[]

拷贝列表 （浅拷贝）

>>> a3 = aa.copy()
>>> a3
[1, 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True, 1, 2, 'new ele']
>>> aa
[1, 'a', [1, 2, 3, 4], (1, 2, 4, 5), {'k1': 123}, True, 1, 2, 'new ele']

需要注意点

列表访问越界问题
a = [1,2,3,4,5,6,7]
当你访问a[10]时元素是，他会报一个超出访问范围的错误，但是当时用切片对其进行访问的时候他不会报错，他会返回一个空列表。也不会报错，可能会让人很头痛。

元组

元祖其实和列表差不多，唯一不同的就是[]换成了（），就功能而言他只能进行读取操作。

创建元组

它可以存放数字，字符串，列表，元组，布尔值，字典
好习惯：在创建的时候需要注意在最后一个元素后边加一个逗号
元组名 = （元素1，元素2，。。。。。。。。，）

>>> t1 = (1,'aa',[1,2,3],(1,2),True,{'aa':1},)
>>> type(t1)
<class 'tuple'>
>>> t1
(1, 'aa', [1, 2, 3], (1, 2), True, {'aa': 1})

访问

因为和列表相似，所以他是有序的，对他可以以索引的方式进行元素访问，访问方式和列表一样吖，支持切边 步长
格式 元组[下标]

 >>> t1
    (1, 'aa', [1, 2, 3], (1, 2), True, {'aa': 1})
    >>> t1[0]
    1
    >>> t1[0:3]
    (1, 'aa', [1, 2, 3])
    >>> t1[0::2]
    (1, [1, 2, 3], True)

for 遍历元组

   >>> for i in t1:
    	i
    ---------结果-----	
    1
    'aa'
    [1, 2, 3]
    (1, 2)
    True
    {'aa': 1}

类型转换

字符串转换元组
tuple(要转换的字符串)

>>> s= '1234567'
>>> tuple(s)
('1', '2', '3', '4', '5', '6', '7')

列表转换字符串

>>> li = [1,2,4]
>>> tuple(li)
(1, 2, 4)

需要注意的是 元组的一级元素是不可以被修改，添加，删除，但是呢，耳机元素如果是可变类型比如列表就可
对它动手哦
看招：

>> t1
(1, 'aa', [1, 2, 3], (1, 2), True, {'aa': 1})
>>> t1[2][0]=123
>>> t1
(1, 'aa', [123, 2, 3], (1, 2), True, {'aa': 1})

其他的一些操作
统计元素出现个数

>>> tu = (11,11,23,22,33,45)
>>> tu.count(11)
2

返回元素第一次出现的位置上

>>> tu = (11,11,23,22,33,45)
>>> tu.index(22)

3

字典

特点就是键值对，因为字典的保存是以哈希形式，所以字典是无序的
他可以存储，数字，布尔值，列表，元组，字典
格式 字典名 = {‘k1`:'v1’,‘k2’:v2}

>>> info = {
	'k1':1,
	'k2':'qwe',
	'k3':[1,23,5],
	'k4':(1,2,3,4)
	}
>>> info
{'k1': 1, 'k2': 'qwe', 'k3': [1, 23, 5], 'k4': (1, 2, 3, 4)}

字典的key可以用数字 字符串 ，元组，布尔值（注意他代替0 1） 只要是不可变类型就可以

>>> i = {
	12:'qwer',
	'k1':'asdf',
	True:'zxcv',
	(12,11):'werty'}
>>> i
{12: 'qwer', 'k1': 'asdf', True: 'zxcv', (12, 11): 'werty'}

取键值

>>> info
{'k1': 1, 'k2': 'qwe', 'k3': [1, 23, 5], 'k4': (1, 2, 3, 4)}
>>> info['k1']
1

get（键）特点是当取得键不存在的时候他不会报错.

>>> i.get(12)
'qwer'
>>> i.get(1234)

删除键值

del 字典[键]

>>> info
{'k1': 1, 'k2': 'qwe', 'k3': [1, 23, 5], 'k4': (1, 2, 3, 4)}
>>> info['k1']
1
>>> del info['k1']
>>> info
{'k2': 'qwe', 'k3': [1, 23, 5], 'k4': (1, 2, 3, 4)}

pop(指定键）

>>> i = {
	12:'qwer',
	'k1':'asdf',
	True:'zxcv',
	(12,11):'werty'}
>>> i
{12: 'qwer', 'k1': 'asdf', True: 'zxcv', (12, 11): 'werty'}
>>> i.pop(True)
'zxcv'
>>> i
{12: 'qwer', 'k1': 'asdf', (12, 11): 'werty'}


字典遍历
>>> for i  in info:
	i	
'k2'
'k3'
'k4'

>>> for i in info.values():
	i
'qwe'
[1, 23, 5]
(1, 2, 3, 4)

>>> for k,v in info.items():
	k,v
('k2', 'qwe')
('k3', [1, 23, 5])
('k4', (1, 2, 3, 4))

>>> for k,v in info.items():
	k	
'k2'
'k3'
'k4'

>>> for k, v in info.items():
	v

'qwe'
[1, 23, 5]
(1, 2, 3, 4)
>>> 

更新字典

>>> dic = {
	'k1':123,
	'k2':234}
>>> dic.update(k1='qwer')
>>> dic
{'k1': 'qwer', 'k2': 234}

集合

特点 当中不能包含重复元素 无序 元素类型必须是不可变的
创建集合 集合名 = set()
创建一个空集合

a = set()

从这也可以看出他的特点 元素是不可以重复的

>>> aa={1,2,1,2,'aa','aa'}
>>> aa
{1, 2, 'aa'}
>>> aa
{1, 2, 'aa'}
>>> aa.add('cc')

>>> aa.add((1,2,3,4,))
>>> aa
{1, 2, (1, 2, 3, 4), 'cc', 'aa'}

>>> aa.add([1,2,3])
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    aa.add([1,2,3])
TypeError: unhashable type: 'list'

在列表中可以添加元组，字符串，数字，这些不可变类型，而不可变类型是添加不进去的哦

清空列表 集合.clear()

>>> a
{'h', 'e', 'l', 'o'}
>>> a.clear()
>>> a
set()

复制集合 是浅拷贝呀

>>> a1 = aa.copy()
>>> a1
{1, 2, (1, 2, 3, 4), 'aa', 'cc'}
>>> aa
{1, 2, (1, 2, 3, 4), 'cc', 'aa'}

删除元素
pop()

>>> aa.pop()
1
>>> aa
{2, (1, 2, 3, 4), 'cc', 'aa'}

删除指定元素
方法有两种 remove() discard()
需要注意的是 当remove删除指定元素在别表中不存在的时候，是会报错的吖，但discard（）就会回报错，所以在选择方法的时候需要注意。如果保证程序可以正常运行下去的话，在移除元素时可以选择discard（）

>>> aa
{2, (1, 2, 3, 4), 'cc', 'aa'}
>>> aa.remove(23457)
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    aa.remove(23457)
KeyError: 23457
>>> aa.discard(234575)
>>> aa
{2, (1, 2, 3, 4), 'cc', 'aa'}

交叉并补

关于这个东西建议回想初中数学中的交叉互补运算 哈哈哈哈
求交集 集合1&集合2 集合1.intersection(集合2)

>>> s1 = {1,2,3,4,6}
>>> s2 = {2,6,7,4,8,3}
>>> s1&s2
{2, 3, 4, 6}
>>> s1.intersection(s2)
{2, 3, 4, 6}

求并集 集合1|集合2

>>> s1 = {1,2,3,4,6}
>>> s2 = {2,6,7,4,8,3}
>>> s1|s2
{1, 2, 3, 4, 6, 7, 8}

求差集 用 集合1-集合 2

>>> s1-s2
{1}
>>> s2-s1
{8, 7}

补集 ^ 集合1.symmetric_difference(集合2)

 >>> s1 = {1,2,3,4,6}
    >>> s2 = {2,6,7,4,8,3}
    >>> s1^s2
    {1, 7, 8}
    >>> s1.symmetric_difference(s2)
    {1, 7, 8}