Python编程——数据结构

String

可以像列表一样对字符串进行切片,使用下标访问字符串中的字符

常用操作

str1 + str2                     # 字符串连接
'a' * 3                         # 字符串重复
'''...'''                       # 输入多行内容
'xxx' in str                    # 判断是否包含字符
str.lower()                     # str.upper()
str.ljust(width,fillchar)       # 左对齐 '111'.ljust(5,'0') -> '11100' 右对齐str.rjust同理
str.count(substr,start,end)     # 返回字符串从start到end中substr出现的次数
str.find(substr,start,end)      # 从左侧查找,返回substr第一次出现的下标,未找到返回-1,备注:从右边查找使用str.rfind()
str.split(seq, maxsplit)        # 从左往右 使用seq对str进行切分(默认使用空白符),maxsplit为分割次数(默认全部切分),返回列表 备注:从右侧切割 str.rsplit(seq, maxsplit)
str.strip(chars)                # 移除头尾指定字符char 默认为空格或空白符(\n\r\t) 备注:str.lstrip()/str.rstrip()
str.replace(old,new[, count])   # 用new替换old,替换前count个

其他操作

a = 1,b = 2,eval('a+b')         # 将字符串str当成有效的表达式来求值并返回计算结果
str.swapcase()                  # 大写字母转为小写字母,小写字母转换为大写字母
str.capitalize()                # 首字母大写,其他小写
str.title()                     # 每个单词首字母大写,其他小写
str.center(width[, fillchar])   # 返回一个指定宽度的居中字符串,fillchar为填充的字符,默认使用空格  
str.index(substr,start=0,end=len(str)) # 返回substr第一次出现的下标,未找到报错,从右边查找使用 str.rindex()
str.zfill(width)                # 相当于 str.rjust(width,'0')
​
str.isupper()                   # 都是大写返回True str.islower()
str.isalpha()                   # 所有的字符都是字母返回True
str.isalnum()                   # 所有的字符都是字母或数字返回True
str.istitle()                   # 每个首字母大写返回True
str.isdigit()                   # True: Unicode数字,byte数字(单字节),全角数字(双字节)
str.isnumeric()                 # True: Unicode数字,全角数字(双字节),汉字数字 
str.isdecimal()                 # True: Unicode数字,全角数字(双字节)
str.isspace()                   # 字符串只包含空白符返回True
str.startswith(str1, start=0, end=len(str)) # 在给定的范围内[start,end)判断字符串是否以给定的字符串开头,默认整个字符串 
str.endswith(str, start=0, end=len(str)) 

List

列表是有序集,元素类型可以不同,可以嵌套(嵌套列表可用多维数组访问方式访问)

查找和插入的时间随着元素的增加而增加,占用空间小,浪费内存很少。

元素操作

list.index(obj) # obj第一次出现的位置
list.append(obj) # 在列表末尾增加obj
list.count(obj) # 元素obj出现的次数
list.insert(pos,obj) # 在pos插入obj
list.pop(下标值) # 删除数据,默认为最后一个
list.remove(obj) # 第一个匹配项

列表操作

list.reverse() # 反转列表
list.sort(reverse=False) # 排序,默认False升序排序
"符号".join(list) # 用符号连接列表
list.extend(seq) # 在列表末尾追加另一个列表
list.clear() # 清除列表中所有数据  
list3 = list1 + list2 # 列表组合  
list2 = list1 * 3 # 列表重复  
​
# 引用拷贝、浅拷贝、深拷贝
list2 = list1 # 引用拷贝
list2 = list1.copy() # 浅拷贝(二维列表下的一维列表为引用)
list2 = copy.deepcopy(list1) # 深拷贝  

其他操作

for index,item in enumerate(list) # 同时遍历下标与元素  
envelopes.sort(key=lambda x:(x[0],-x[1])) # 排序:通过lambda返回元组,根据多个值排序

Tuple

元组与列表类似,不同之处在于元组的元素不能修改(元素的指向不变

常用操作

tup1 = () # 创建空元组
tup1 = (50,) # 元组中只包含一个元素时,需要在元素后面添加逗号
s1,s2 # 任意无符号的对象,以逗号隔开,默认为元组

其他操作

tup3 = tup1 + tup2 # 创建一个新的元组
tup2 = tup1 * 3 # 复制
del tup1 # 删除整个元组

Dict

字典是一种无序的、可变的序列,它的元素以键值对(key-value)的形式存储

根据key来计算value的存储位置(Hash),作为key的对象就不能变(只能是字符串、元组或数字,不能是列表)

查找和插入的速度极快,不会随着key的增加而变慢,需要占用大量的内存,内存浪费多

创建

d = dict() # 创建空字典
d = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen} # 使用{}创建字典
d = dict.fromkeys(list,value) #  使用fromkeys()方法创建字典,value默认为None
d = dict(zip(keys,values)) # 两个列表转换为对应的字典

访问

d[key] # 访问字典元素   
d.get(key[,default]) # default 用于指定要查询的键不存在时,此方法返回的默认值,如果不手动指定,会返回 None
d.setdefault(key, default=None) # 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
d.items() # 以列表返回可遍历的(键, 值)元组数组
d.keys() # 以列表返回一个字典所有的键
d.values() # 以列表返回字典中的所有值

新增

d[key]=value
d.update(dict2) # 把字典dict2的键/值对更新到dict里

删除

del d # 删除字典  
del d['Name']  # 删除键是'Name'的条目
d.clear()      # 清空字典所有条目
d.pop(key[,default]) # 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。否则返回default值
d.popitem() # 返回并删除字典中的最后一对键和值

遍历

for key in d:
for value in d.values(): 
for kv in d.items():  
for key,value in d.items():

其他

str(d) # 函数将值转化为适于人阅读的形式,以可打印的字符串表示
d.copy() # 返回一个字典的浅复制
if key in d # 如果键在字典dict里返回true
sort_list = sorted(d.items(), key=lambda x: x[1],reverse=False) # 对values升序排序
list(d.keys())[list(d.values()).index('value')] # 根据value取key
pd.DataFrame(d).to_csv('d.csv') # 字典存储为csv
eval(str) # str格式转为字典

Set

集合是一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等

集合存放不可变类型(字符串、数字、元组)

创建集合

s = set() # 创建空集合
s = {'123'} # {'123'}
s = set([1,2,3]) # {1, 2, 3}
s = set('123') # {'1', '2', '3'}
s = frozenset('a', 'b') # 定义不可变集合

元素操作

set.add(x) # 将元素添加到集合里
set.update(x) # 添加新的元素或集合到当前集合中
set.remove(x) # 移除集合中元素x,x不在集合中将报错
set.discard(x) # 移除集合中元素x,x不在集合中不报错
set.pop() # 随机删除集合中元素
set.clear() # 清空集合

集合操作

# 求差集 在s1中不在s2中
s1-s2 
s1.difference(s2)
# 求交集 同时在s1和s2中
s1.intersection(s2) 
s1&s2
# 求并集
s1.union(s2) 
s1|s2 
# 求对称差集 除集合s1和集合s2共有的以外的元素
s1.symmetric_difference(s2)
s1^s2
set.issubset(x) # 判断一个set是否是x的子集
set.isuperset(x)  # 判断一个set是否是x的父集
s1.symmetric_difference_update(s2) # 对称差集更新 求对称差集更新到s1
s1.isdisjoint(s2) # s1与s2存在交集返回False
s1.intersection_update(s2) #  交集更新 求交集更新到s1

heapq 小顶堆

# 位置i处的元素总是大于位置i // 2处的元素
# 根结点的键值是所有堆结点键值中最小者
# 大顶堆,所有值取负加入小顶堆
from heaqp import *
heap = []
heappush(heap,x)
x = heappop(heap)
​
heap = [1,1,3,2,2,1]
heapify(heap) # 让列表具备堆特征
nlargest(n,heap) # 返回heap中最大n个,不会修改heap
nsmallest(n,heap)

插入heap中的元素还可以是元组、列表

heap = [(2,'a'),(1,'b')]
heapify(heap) 
# [(1, 'b'), (2, 'a')]

发表评论