文章目录

1. 列表（list）
- 1.1 特点
- - 1.2 定义
- 1.3 基本操作
- - a）切片对象（slice函数）
  - b）增加
  - c）删除
  - d )切片修改
  - e )反转、排序
  - f）复制
  - g )查找统计
2. 元组（tuple）
- 2.1 特点
- 2.2 基本操作
- - a ) 切片对象（slice 函数）
  - b ) 统计
  - c ) 遍历
  - d ) list和tuple的相互转换
  - e) 用户检测小工具
- 2.3 列表和元组比较
3. 字典（dict）
- 3.1 定义
- 3.2 特点
- 哈希
- 字典的原理
- 3.5 基本操作
- - 取值
  - 增加/修改
  - 删除
  - 合并字典
  - 遍历
4. 集合（set）
- 特点
- 创建
- 添加
- 移除
- 集合转换
- 其他操作
- - 并集
  - 交集
  - 差集
  - 对称差集

存储大量数据的容器，在Python中称之为 内置数据结构

 不可变数据（3个）：Number（数字）、String（字符串）、Tuple（元组）； 
 可变数据（3个）：List（列表）、Dictionary（字典）、Set（集合）。

1. 列表（list）

是处理一组有序项目的数据结构，用数组和链表实现的
list只是存放的索引，底层是存放指针的数组

1.1 特点

可相加相乘
可以放任何数据类型对象
有序项目集合：有下标，可以获取
可变数据类型：在原地址内存空间里能修改的，即这种类型的值可以被修改

1.2 定义

>>> lst = []  #定义空列表
>>> lst2 = list() # 定义空列表(工厂函数)
>>> lst3 = [1,2,3]  #定义非空列表
>>> lst4 = list('123')# #字符串转列表(工厂函数) 
['1', '2', '3']

>>> lst5 = list(range(4)) 
结果：[0, 1, 2, 3]

>>> lst6 = [print, None, 1,"abc", True ]  #任意类型
[<built-in function print>, None, 1, 'abc', True,]
>>> lst6[0] = 'xxyyyyyy' 
['xxyyyyyy', None, 1, 'abc', True]
>>> lst6[-2:2:-2] #从右至左，步长为2  
['abc']
>>> lst6[:-2]  #切到倒数第二个，不包含第二个
['xxyyyyyy', None, 1]

1.3 基本操作

a）切片对象（slice函数）

slice函数用途：生成一个slice对象，相当于可以给要切的内容取个名字
help(slice) 查看函数用法

>>> lst2 = [1,2,3,'sf','safwer']
>>> s = slice(0,3,1)   # 把切片规则赋给一个对象slice函数
>>> print(type(s))
<class 'slice'>
>>> print(lst2[s])    # 切片时引用切片规则对象
[1, 2, 3]

b）增加

append（）：在末尾，作为整体追加，类型不限

>>> lst5.append("q")    # 追加一个元素
>>> lst5
['xxyyyyyy', None, 1, 'abc', True, 2, 'q']
>>> lst5.append(['bbb','aaa'])   # 追加俩个元素
>>> lst5
['xxyyyyyy', None, 1, 'abc', True, 2, 'q', ['bbb', 'aaa']]
>>> lst5[7]     
['bbb', 'aaa']
>>> lst5[7][1]
'aaa'

insert（）：在index位置插入元素

>>> lst5.insert(2,"hhhhhhhhhh")
>>> lst5
['xxyyyyyy', None, 'hhhhhhhhhh', 1, 'abc', True]

extend（）：扩展列表
扩展，将1个列表里的内容扩展到另外一个列表里去

注：只限可转为list的类型( str, list, tuple )
因为extend扩展列表是会先将要扩展的元素转成列表后再追加到另一个列表的末尾
“+” 列表和列表可以相加，列表和字符串不能直接相加

c）删除

pop（）：删除元素，默认最后一个（也可以指定index删除）

remove（）：删除指定的元素（要删除的数据不存在时，会出错）

del（）：根据下标删除
del是python的一个关键字，用于删除变量(的引用)

clear（）：清空列表

>>> lst.clear()
>>> lst
[]

d )切片修改

前提是赋值内容是可迭代的
如果查找出来的列表不为空，则替换查找出来的内容
如果查找出来的列表start、end一致，则在start的位置添加相应的值

>>> lst
[1, 2, 'aa', 'bb']
>>> lst[2:4]   #切片
['aa', 'bb']
>>> del lst[2:4]  #删除切片
>>> lst
[1, 2]
>>> a = 10  
>>> del a   #删除变量
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

>>> lst = ["e","d","c","b","a"]
>>> lst[2:2] ="rrrrr"   #在列表里面添加列表
>>> lst
['e', 'd', 'r', 'r', 'r', 'r', 'r', 'c', 'b', 'a']
>>> lst = ["e","d","c","b","a"]
>>> lst[2:2] =["rrrrr"] #在列表里面添加元素
>>> lst
['e', 'd', 'rrrrr', 'c', 'b', 'a']

总结：修改

修改元素主要是利用下标和切片来修改和增加、删除
利用切片修改，如果切片得到的list为空，则在start位置开始插入相应的list值
如果切片得到的list不为空，则替换找出来的list元素

e )反转、排序

reverse（）、sort（）默认升序

>>> lst = [2,42,24234,1,24,34,3,3]
>>> lst.sort()  #升序排序，会改列表本身的值
>>> lst
[1, 2, 3, 3, 24, 34, 42, 24234]
>>> lst.reverse()  #反转 
>>> lst
[24234, 42, 34, 24, 3, 3, 2, 1]  
>>> lst.sort(reverse = True) #降序排序
>>> lst
[24234, 42, 34, 24, 3, 3, 2, 1]

注：

.sort() 默认按utf-8 编码排序
排序的列表里面数据类型需要一致，不支持int和str的混合排序，否则会报错

>>> lst = ["a","abc","defef","cc","tyu"]
>>> sorted(lst)            # 默认排序方式是  字符的ASCII码升序排列
['a', 'abc', 'cc', 'defef', 'tyu']
>>> sorted(lst,key=len)    # 指定排序方式为 长度
['a', 'cc', 'abc', 'tyu', 'defef']

f）复制

copy（）：返回复制后的新列表

>>> lst1 = ['a','b','c']
>>> lst2 = lst1
>>> lst2
['a', 'b', 'c']
>>> lst1[1] = 'hhh'
>>> lst1
['a', 'hhh', 'c']
>>> lst2         #引用赋值存在的问题，指向了原来的来对象了
['a', 'hhh', 'c']

如何解决？

lst2 = lst1[::] 通过切片获取全新的列表
lst2 = lst1.copy() 赋值列表

g )查找统计

len（）、count（）：查找统计类

>>> lst = [1,2,3,4,5,6]
>>> len(lst)
6
>>> lst.count(3)
1

2. 元组（tuple）

2.1 特点

有序的项目集合
可以存放任何数据类型
长度不可变，只有index和count函数

只有一个元素，需要在元素后面加逗号；
元组里面包含列表。列表是可以改变的。列表里面的元素更改不会改变列表本身

2.2 基本操作

a ) 切片对象（slice 函数）

生成slice对象，相当于可以给要切的内容取个名字

>>> my_tuple = ('apple','banana','orange',1,3.14,False)
>>> print(my_tuple[0:3])
('apple', 'banana', 'orange')
>>> friut = slice(0,3)
>>> print(type(friut))
<class 'slice'>
>>> print(my_tuple[friut])
('apple', 'banana', 'orange')

b ) 统计

>>> my_tuple = ('apple','banana','orange',1,3.14,False)
>>> print(len(my_tuple))     #统计元组长度
6
>>> print(my_tuple.index('orange'))   #查找下标位置
2
>>> print(my_tuple.count('orange'))   #统计元素出现次数
1

c ) 遍历

一个变量接收，得到的是元组

>>> a = [1,2,3]  
>>> for i in enumerate(a):
...     print(i)
... 
(0, 1)		#（注：返回值 是 元组）
(1, 2)
(2, 3)

俩个变量接收

>>> for i,j in enumerate(a):  
...     print(f"{i}---{j}")		#（注：用两个参数 来接收 返回值）
... 
0---1
1---2
2---3

d ) list和tuple的相互转换

list转tuple

>>> temp_list = [1,2,3,4,'a','b']
>>> tup = tuple(temp_list)
>>> print(tup,type(tup))
(1, 2, 3, 4, 'a', 'b') <class 'tuple'>

tuple转list

>>> temp_tuple = (1,2,3,'a','b')
>>> li = list(temp_tuple)
>>> print(li,type(li))
[1, 2, 3, 'a', 'b'] <class 'list'>

e) 用户检测小工具

print("欢迎使用用户检测系统")
lst = [('root', '123456'), ('admin', 'admin')]
username = input("请输入用户名：")
passwd = input("请输入密码：")
if (username, passwd) in lst:		#（注：* ）
    print("登录成功！")
else:
    print("登录失败！")

2.3 列表和元组比较

相同点
• 序列的两个主要特点是索引操作符和切片操作符
• 索引操作符让我们可以从序列中抓取一个特定项目。
• 切片操作符让我们能够获取序列的一个切片，即一部分序列。
不同点
• list: 可变对象
• tuple: 不可变对象，不能增加修改删除
• tuple中嵌套list时，list是可修改的

3. 字典（dict）

3.1 定义

• 字典是Python中一个键值映射的数据结构
• 字典的key必须是可hash对象（list不可以tuple可以作为key。可hash对象一般指不可变数据类型）
• python中所有字符串、数字、元组、布尔值、None都是可hash对象
• 字典的value可以是任何值

3.2 特点

• 字典是无序的
• 字典是可变对象
• key必须是唯一的, so 天生去重

>>> d1 = dict(a=1,b=2,c=3) 
>>> d1  # 转换的对象要有 键值映射的格式
{'a': 1, 'b': 2, 'c': 3}
>>> d3 = dict([('root','123456'),('admin','admin123')])
>>> d3  # 列表转换成字典（工厂函数）
{'root': '123456', 'admin': 'admin123'}

哈希

hash是一类算法的统称，将任意长度的输入变成固定长度的输出
hash是一项单项加密技术，可以通过原文得到hash值，但是不能反推
常常用在验证文件的完整性，有没有被篡改；传输过程中有没有传输完整

字典的原理

字典的本质就是空闲的散列 hash表，字典存放的key和value都是地址，以空间换时间。
以查找为例：
先对key进行散列值的求取，key 必须是hash对象（不可变数据类型），并且唯一。求取后根据后几位确定key存放的地址在表的那个位置，后再比较存放的key是不是我们要找的key，不是的话再多取几位试试确定下一个哈希是在这个表里面所存放的位置

[root@192 ~]# echo "abc"|md5sum
0bee89b07a248e27c83fc3d5951213c1  - #哈希值

3.5 基本操作

取值

dict[key] 当key不存在的时候就会报错
dict.get(key) 当key不存在的时候默认返回空，也可以自己定义返回值（dict.get(key,returnvalue) ）

d1.keys() 获取所有key
d1.values() 获取所有值

增加/修改

dict[key] = value 不存在就新建，存在就修改
dict(d1,key=value) 字典的添加

>>> d1 = {'a':1,'b':2}
>>> d1.get('a')
1
>>> d1.get('aaa')
>>> d1.get('aaa',444)
444
>>> d1['a'] =2
>>> d1
{'a': 2, 'b': 2}
>>> d1['c'] = 3
>>> d1
{'a': 2, 'b': 2, 'c': 3}

删除

d1.pop(key) 删除key，返回对应的value
d1.popitem() 删除最后一个键值对，返回键值对

合并字典

d1.update(d2) 将d2的更新到d1，没有就添加，有就覆盖

>>> a.update(d)	#（注：key为 字符串和数字 混合  不会报错）
>>> a
{'x': 1, 'y': 3, 3: 'a', 4: 'b'}

dict(d1, ** d3) 将d1和d2 合并生成一个新字典

>>> a = {"x":1,"y":3}
>>> d = {3:'a',4:'b'}
>>> dict(a,**d)	#（注：key为 字符串和数字 混合  会报错）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

**d的含义：
**d ==> 3=‘a’,4=‘b’
标识符不能数字开头

>>> dict(a,3='a',4='b')
  File "<stdin>", line 1
SyntaxError: keyword can't be an expression

>>> dict(a,str1 = 2)
{'x': 1, 'y': 3, 3: 'a', 4: 'b', 'str1': 2}

遍历

lst(d1.keys())、lst(d1.values()) 字典转list
d1.items() 以列表返回可遍历的(键, 值) 元组数组

>>> d1
{'b': 2, 'a': 3}
>>> dict(d1,f=0,u=9)  #添加字典
{'b': 2, 'a': 3, 'f': 0, 'u': 9}
>>> d3 = {'r':8}
>>> dict(d1,**d3)  ##添加字典 相当于d3解包成r=8
{'b': 2, 'a': 3, 'r': 8}

4. 集合（set）

集合元素必须是可hash对象，跟字典一样
set和dict的唯一区别仅在于没有存储对应的value

特点

无序
可变
集合是一个只含有key的字典
天生去重

创建

>>> a = {1,2,3}	#（注：第1种方式）
>>> type(a)
<class 'set'>
>>> a = set()	#（注：第2种方式）
>>> a
set()
>>> type(a)
<class 'set'>

# 创建一个数值集合
s = set([3, 5, 9, 10])
# 创建一个唯一字符的集合
t = set("Hello")
print(s)  # {9, 10, 3, 5}
print(t)  # {'H', 'e', 'l', 'o'}

添加

set1.add(item) 没有就添加，有就覆盖
set1.update(someitems) 添加多项，若添加的是列表，会自动将列表转成多个item

移除

s.remove(item) item不存在会报错
s.discard(item) item不存在不报错，

>>> s1 = {'g','3','j','g','d','s'}
>>> s2 = {'g','4','5','1'}
>>> s1&s2  #交集
{'g'}
>>> s1|s2  #并集
{'d', '1', '5', '4', 'j', '3', 's', 'g'}
>>> s1-s2  # 差集
{'3', 's', 'd', 'j'}
>>> s1^s2   #对称差集  s 和 t 中不重复的元素（在t或s中，但不会同时出现在二者中）
{'s', '4', '1', '5', 'd', 'j', '3'}

集合转换

>>> a = set("abc")	#（注：str转换成set）
>>> a
{'c', 'b', 'a'}
>>> a = set([1,2,3])	#（注：list转换成set）
>>> a
{1, 2, 3}
>>> a = set((1,2,3,4))	#（注：tuple转换成set）
>>> a
{1, 2, 3, 4}
>>> a = set({'x':1,'y':2})	#（注：dict转换成set）
>>> a
{'y', 'x'}	#（注：返回key值）

其他操作

并集

t 和 s的并集 ,返回一个新的 set 包含 s 和 t 中的每一个元素

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 | s2
{1, 2, 3, 4}
>>> s1.union(s2)
{1, 2, 3, 4}

交集

t 和 s的交集 , 返回一个新的 set 包含 s 和 t 中的公共元素

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

差集

返回一个新的 set 包含 s 中有但是 t 中没有的元素

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 - s2
{1}

对称差集

返回一个新的 set 包含 s 和 t 中不重复的元素（在t或s中，但不会同时出现在二者中）

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 ^ s2
{1, 4}

更多推荐

Python数据类型（容器类型）