python数据结构大全

前言

python中基础的数据结构，如果不经常使用，很容易忘记，本文带你复习python中数据结构的所有基本操作

一. Python数据类型

1. 数字类型 int   >  1, 0
2. 字符串类型 string > '', " ", "hello world"
3. 列表	list  >  [], [1, 2, 3], [1, 2, [2, 3]]
4. 元组 tuple >  (), (1, 2, 3), (1, 2, (2, 3))
5. 字典 dict  >  {}, {"name":"jack", "age":18, "height":120}
6. 集合 set()  {1, 2,  3, 4}

二.Python基础概念

1. 查看帮助文档

for i in dir(os):
    print(i)
help(os.path)

2. 变量的使用

a = r'test\n'  # 字符串前面加了r后原样输出，适合打印一些带有特定字符的对象
b = 'test\n'  # \n 表示换行，print打印出一个新行
print(a, b)
# globals x  #应用在函数或这类方法中，global 将变量当成一个全局的变量来使用，尽量少用global，因为会导致变量的重复引用后值不相同
c = 0 or 2 or 1
# 在布尔逻辑运算中，0，空字符串''，空列表[]，空元组()，空字典{}，空集合set(),None 都是False
# 在进行判断语句中如果返回的对象中是上述几个情况那么就是False if not c: pass
print(c)
name = input("input:").strip()
print("name", name)

3. 打印相关的操作

a = 2
print("字符串:%s" % a)
print("整数:%d" % a)
print("浮点:%f" % a)
print("原样打印:%r" % a)
print('abc', )

三.数据结构

1.字符串

所谓字符串，就是由零个或多个字符组成的有限序列，一般记为$$s=a_1{a}_2\dots a_n(0\le n\le \infty )$$在Python程序中，如果我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。

str_line = "  zi\t fucuan "
print(str_line.expandtabs(tabsize=8))  # \t表示tab符号，将tab符号转换为空格，默认8个空格
print(str_line.startswith('zi'))  # 用来判断字符串是以哪个字符对象开头的，结合正则表达式来使用
print(str_line.endswith('\t'))  # 用来检测检测字符串是否以obj结束
print(str_line.strip())  # strip 获得字符串修剪左右两侧空格之后的拷贝
print(str_line.rstrip())  # rstrip 用于删除字符串末尾的指定字符串
print(str_line.lstrip())  # lstrip 和strip效果类型，lstrip用于去除左边的空格

str_list = 'ABcd244F'
print(str_list [2]) # c 字符支持下标索引取值
print(str_list[::-1], str_list[1:3])  # 字符串的倒序，字符串也支持切片操作
print(str_list.capitalize())  # 得到首字母大写的新的字符串
print(str_list.lower())  # 用于将字符串中的所有大写转换为小写
print(str_list.upper())  # 用于将字符串中所有的小写转换为大写
print(str_list.isupper())  # 字符串中的字符所有都为大写返回True
print(str_list.islower())  # 字符串中的字符所有都为小写返回True

str_space = ' '
print(str_space.isspace())  # 用于判断字符串字符是空格
print(str_list.isalnum())  # 用于判断字符串中字符至少有一个字符，并且字符都是字母或数字则返回True
print(str_line.isalpha())  # 用于判断字符串中字符至少有一个字符，并且字符都是字母则返回True
str_digit = '222'
print(str_digit)
print(str_digit.isdigit())  # 字符串中所有的字符都是数字则返回True
print(str_digit.isnumeric())  # 字符串中只包含数字时返回True
print(str_digit.isdecimal())  # 用于判断字符串中的所有字符是否是十进制的字符

print(str_list.count('4'))  # 用于计算字符串中某一个字符出现的次数
print(str_list.split('2'))  # 将字符串以obj为中心切片成一个列表
print("string format :{}".format(str_line))
print(str_list.replace('2', 'A'))  # 见明知义，将字符串中某个字符替换成另外一个字符
print(str_list.index('A'))  # 找出字符串中对应的索引下标,如果不存在则报错
print(str_list.find('9'))  # 查找字符串中是否存在该字母，如存在返回索引下表，不存在返回-1
print(':'.join(str_list))  # 以 : 作为分隔符，将所有元素合并为一个新的字符串
print(','.join(str_list))  # 以 , 作为分隔符，将所有元素合并为一个新的字符串
# 字符串在Python内部的表示是unicode编码，因此，在做编码转换时，通常需要以unicode作为中间编码
# decode 解码， encode:编码; 如果要将其他的编码转换成utf-8必须先解码成unicode，再将其(unicode)编码成utf-8
print(str_line.encode())  # 编码成utf-8;

2. 列表相关的操作

列表（list），也是一种结构化的、非标量类型，它是值的有序序列，每个值都可以通过索引进行标识，定义列表可以将列表的元素放在[]中，多个元素用,进行分隔，可以使用for循环对列表元素进行遍历，也可以使用[]或[:]运算符取出列表中的一个或多个元素。

list_line = ['apple', 'mango', 'carrot', 'banana', 'apple']
shop_list = ["cuke", "potato", "tomato"]
# 列表的for 循环用法
# 1.通过循环用下标遍历列表元素
for i in range(len(list_line)):
	print(list_line[i])
# for循环遍历列表元素
for x in list_line:
	print(x)
# 通过enumerate函数处理过后，再for循环遍历得到列表的下标及对应的元素
for i,i in enumerate(list_line):
	 print(i,j)
	
list_line.insert(0, "tencent")  # 向列表中指定位置插入一个元素
list_line.append("ali")  # 向列表中的末尾追加一个字符，也可以追加一个列表
list_line.append(shop_list)  # 向列表中的末尾追加一个列表
list_line.extend(shop_list)  # 将另一个列表中所有元素合并到该列表中组成一个新的列表
list_line += [1000, 2000]

list_line[2] = 'tcs'  # 替换列表中某个元素
print(list_line)
print(list_line.index("apple"))  # 找出列表中该元素所对应的下标。类似于字符串中string.index()。元素不存在报错
print(list_line.count("apple"))  # 找出列表中该元素的个数，字符串中也有该用法string.count()。元素不存在则为0

# print(list_line.remove("apple"))  # 用于删除列表中从左到右的第一个元素。
# print(list_line.clear())  # 清除列表中所有的元素
del list_line[0]  # 删除指定下标的元素，类似remove方法
print(list_line.pop())  # 删除列表中最后一个元素，并返回该值。类字典中的方法类型dict.pop()

# print(list_line.copy())
list_digit = [2, 3, 44, 55, 8, 9]
print(list_digit.sort(), list_digit)  # 用于排列列表中元素的顺序
print(list_digit.reverse(), list_digit)  # 将列表中的元素位置进行反转
print(list_line)

# 列表中的切片,利用列表中的下标索引进行的增加，筛选操作
list_qie = ['xiaomi', 'tencent', 'huawei', 'baidu', 'ali', 'tencent']
print(list_qie[:])  # 通过完整的切片操作来拷贝列表
print(list_qie[1:])  # 打印列表中第一个到最后一个的元素
# , list_qie[:-1], list_qie[::-1]
print(list_qie[:-1])  # 打印列表中第0个到倒数第一个的元素，即排除了最后一个元素
print(list_qie[::-1])  # 列表倒序，类似于列表中的reverse方法
list1 = sorted(list_qie)
print(list_qie.sort(reverse=True))  #该方法和sorted(list_qie, reverse=True)
list2 = sorted(list_qie, reverse=True)  # 使用sorted方法对列表进行排序，reverse=True，表示对排序后的元素进行反转
print(sorted(list_qie, key=len))  # 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
print(list_qie.reverse())
print('\t'.join(list_qie))  # 将列表转换为字符串，不同于字符串中的join方法。
print(''.join(list_qie))  # 列表转为字符串

# import sys
# sys.path[1:1] = 6
print(list(set(list_qie)))  # 首先用set集合将原有列表中的元素进行去重，然后list成列表
print(tuple(list_qie))  # 利用tuple，将列表中所有的元素转成元组
print(eval("['a',2]"))  # 将字符串当成表达式求值，得到列表
print(list_qie, list_qie.copy())  # 拷贝一个新的列表出来

生成式和生成器

f = [x for x in range(1, 10)]
print(f)
f = [x + y for x in 'ABCDE' for y in '1234567']
print(f)
# 用列表的生成表达式语法创建列表容器
# 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
f = [x ** 2 for x in range(1, 1000)]
print(sys.getsizeof(f))  # 查看对象占用内存的字节数
print(f)
# 请注意下面的代码创建的不是一个列表而是一个生成器对象
# 通过生成器可以获取到数据但它不占用额外的空间存储数据
# 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
f = (x ** 2 for x in range(1, 1000))
print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
print(f)
for val in f:
    print(val)

3. 元组相关的操作

Python中的元组与列表类似也是一种容器数据类型，可以用一个变量（对象）来存储多个数据，不同之处在于元组的元素不能修改，在前面的代码中我们已经不止一次使用过元组了。顾名思义，我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。

tuple_str = ("hello world", 2, 'a')
print(tuple_str.count(2))  # 计算出元组中的元素的个数
print(tuple_str.index('hello world'))  # 找出元组中对象的下标索引
print(tuple_str[0])
# tuple_str[1] = 3  # 不支持！！！ 元组是6个数据类型中其中一个不可变的，即不能对其进行修改，相对于列表，元组是安全的数据类型

4. 字典相关的操作

字典是另一种可变容器模型，Python中的字典跟我们生活中使用的字典是一样一样的，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。

dict_str = {
    "name": "jack",
    "age": 18,
    "weight": 120,
    "height": 180,
    "school": "qinghua"
}
# 创建字典的构造器语法
print(dict(a=1, b=2, c=3)) 
# 通过zip()函数将序列压成字典,先将序列压成zip对象，再通过dict()构造器生成字典
print(dict(zip(['a','b','c'],'123')))
# zip可以将一个序列组合成为字典
keys = ['11', '12', '13']
values = ['王大锤', '王二锤', '王三锤']
d = dict(zip(keys, values))
# 创建字典的推导式
print({i:i for i in range(1,10)})
# dict的for循环使用
for key in dict_str:
	print(f'{key}: {dict_str[key]}')
# for 循环key，value
for k,v in dict_str.items():
	print(f'{k}: {v}')

dict_str['company'] = "tencent"  # 字典中key不存在增加一个元素，如果存在将修改其值
print(dict_str.update({"country": "China"}))  # update用于更新字典中的元素，参数为字典
print(dict_str.get("company"))  # 通过key来获取字典中value值
print(dict_str.keys())  # 取出字典中所有的key
print(dict_str.values())  # 返回字典中所有的value值
print(dict_str.fromkeys("school"))  # 将字典的key分隔成一个新的字典

del dict_str['height']  # 删除字典中指定的元素
print(dict_str.pop("weight"))  # pop用于删除字典中指定的元素，并返回该字典对应的值
# print(dict_str.clear())  # 用于清除字典中所有的元素
print(dict_str.items())  # 返回一个键值对组成的元组的列表
print(dict_str.popitem())  # 返回最后一个元素的键值的元组
print(dict_str.copy())
print(dict_str.setdefault("company", "huawei"))  # 为字典创建一个值，如果key存在，则按原有的值来返回，不存在创建一个新的值
print(len(dict_str))  # 返回字典中键值的个数
print(dict_str)

5.集合的相关操作

Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。

# 集合是不可变的数据类型，是一个无序的不重复的元素序列
# 可以使用大括号或者set()函数来创建，空的集合必须用set()
# set_obj = set()
set_objs = {'a', 2, 'c'}
set_obj = {'e', 2, 'c', 'f', 5, 'a', 2, 'c'}

set_objs.add('b')  # 向集合中添加字符
print(set_objs.copy())  # 返回一个新的集合，浅拷贝
print(set_objs.clear())  # 删除集合中所有的元素
print(set_objs.pop())  # 删除集合中任意一个对象，并返回它
print(set_obj.discard(6))  #如果对象存在于集合中，则删除集合中的对象
print(set_objs.remove('a'))  # 删除集合中指定的元素，如果不存在则会报KeyError。集合的删除建议使用discard
print(set_objs.update('d'))  # 增加一个元素，并集元素到该集合中
print(set_objs.difference(set_obj))  # 返回一个新的集合，set_objs - set_obj
print(set_objs.difference_update(set_obj))   # s中的成员是属于s但不包含在t中的元素
print(set_objs.intersection(set_obj))  # 两个集合的交集
print(set_objs.intersection_update(set_obj))  # s中的成员是共用属于s和t的元素
print(set_objs.isdisjoint(set_obj))  # 判断两个集合是否无交集
print(set_objs.issubset(set_obj))  # 如果set_objs 是set_obj的子集，则返回True
print(set_obj.issuperset(set_objs))  # 如果set_obj 是set_objs 的超集则返回True
print(set_objs.symmetric_difference(set_obj))  # 集合set_obj - set_objs
print(set_objs.symmetric_difference_update(set_obj))  # 移除set_objs中与set_obj相同的元素，并将不重复的元素加入到set_objs中
print(set_objs, set_obj)