基础数据结构方法汇总

字符串方法：
mystr.capitalize() 第一个字符转换为大写，其它都转为小写（本来的大写字母也转为小写） "ab C d" --> Ab c d

 

a_str = 'hello hello'

# 1.统计字符串长度
len(a_str)  # 长度 11

# 2.统计某子字符串出现的次数
a_str.count('ll')  # 2       子字符串 ll  在 a_str 中出现了 2 次
a_str.count('abc')  # 0     子字符串 abc  在 a_str 中出现了 0 次

# 3.查找某子字符串（第一次）出现的位置
a_str.index('lo')  # 3   子字符串 lo 第一次在 a_str 中出现的索引为 3
a_str.index('abc')  # 出错 ValueError: substring not found
a_str.index('lo', 4)  # 9    起始索引为4，子字符串 lo 第一次出现的索引为 9。
a_str.index('lo', 4, 8)  # ValueError: substring not found  范围 4~8 之间找不到子字符串

# 4.判断类型的方法
a_str.isspace()  # ' \n\r\t'.isspace()  # True  空格、换行、回车、制表符  print(' \n \r\r \t'.isspace())  True
a_str.isalpha()  # 非空，且都为字母，返回 True
a_str.isalnum()  # 判断是否为 alpha 和 number
a_str.isdecimal()  # 只含数字、全角数字  print('0o12'.isdecimal())  # False    不能判断小数
a_str.isdigit()  # 只含数字、全角数字、⑴、\u00b2   不能判断小数
a_str.isnumeric()  # 只含数字、全角数字、汉字数字 一二三     不能判断小数
a_str.istitle()
a_str.islower()
a_str.isupper()

a_lst = [1, 1.1, '１', '⑴', '\u00b2', 'Ⅲ', '一千二百']  # 整数、小数、全角....
b_lst = ['isdecimal', 'isdigit', 'isnumeric']
for f in b_lst:
    for n in a_lst:
        func = f"'{n}'.{f}()"
        print(eval(func), end='\t')
    print()

# 5.查找和替换
a_str.startswith('he')  # True    # a_str.startswith('He')   False  区分大小写
a_str.endswith('he')  # False
a_str.find('li')  # 2    # a_str.find('li')  不存在的字符串，不会像 index 报错，而是返回 -1
a_str.find('li',5)  # 从5开始查找
a_str.find('li',5,9)  # 查找 5-9 之间的元素  （不含9元素：范围前闭后开）
a_str.rfind('llo')  # 8 从 右边 开始查找
a_str.index('l')
a_str.rindex('l')
new_str = a_str.replace('llo', 'new')  # 需要用变量接收结果  # henew henew

'ab' in 'abcd'

# 6.大小写转换
a_str.capitalize()
a_str.title()
a_str.lower()
a_str.upper()
a_str.swapcase()

# 7.文本对齐
a_str.center(width)  # a_str.center(width,'-') 用 - 填充
a_str.ljust(width)
a_str.rjust(width)

# 8.去除空白
a_str.strip()  # print('\n  \t \rTink this \t'.strip())  # 左右两端的空格、换行、回车、制表符被去掉。Tink this
a_str.lstrip()
a_str.rstrip()

# 9.拆分和连接
a_str.split()  # print("this\nis a\rcat\tand".split())  # ['this', 'is', 'a', 'cat', 'and'] 返回列表
a_str.split('ll')  # ['he', 'o he', 'o']  # 无参数 默认 空格分割
a_str.join()  # ''.join(序列)
a_str.splitlines()  # 按行切分
a_str.partition('ll')  # ('he', 'll', 'o hello')  返回一个3元的元组
a_str.rpartition('ll')  # ('hello he', 'll', 'o')  从右边开始

　　

另有： 'ab' in 'abcd'

　　 

列表方法：（增删查改）

新增：

lst.append(obj)  在末尾追加数据

lst.insert(下标,obj) 如果下标不存在，则会插入到列表的末尾。支持反向索引，超出范围就会在列表的头部

lst.extend(obj) 

print([1, 2] + [3, 4])  # [1, 2, 3, 4]
print(['a', 'b'] + [1, True])  # ['a', 'b', 1, True]

  

lst = list("HIL")  # ['H', 'I', 'L']
lst[1:1] = list("Tom")  # ['H', 'T', 'o', 'm', 'I', 'L']
lst[2:4] = []  # ['H', 'T', 'I', 'L']

 

　　

 

删除：

lst.pop() 删除最后一个元素 相当于lst.pop(-1)
lst.pop(下标) 若下标不存在，IndexError
lst.remove(obj) 若obj不存在，则会引发ValueError异常

del lst[下标]   若下标不存在，IndexError

lsr.clear() 清空列表

 

修改：

lst[下标] = obj

lst.count(obj) 元素obj不存在，结果为0
lst.index(obj) 元素obj不存在，则会引发ValueError异常
lst.reverse() 元素翻转
lst.sort()

列表元素查找：
in、not in
count 结合 index 使用

index = a_list.index('a') if ('a' in a_list) else -1
[x for x in test if 'a' in x]

 lst.append(obj)

 https://runestone.academy/ns/books/published/thinkcspy/index.html

ThinkCSPY

 https://runestone.academy/ns/books/published/pythonds/index.html

PythonDS 

 

# 字典：键不可变类型；键不重复，键重复会覆盖；3.6版本以后的字典是有序的

d1 = {}  # 定义空字典
d2 = dict()  # 定义空字典
d3 = {
    "name": "王大锤",  # 键必须不可变(不可变类型：int、bool、str、tuple等；可变类型：list、set、dict)
    "age": 12,
    "hobby": ['看书', '画画'],  # 值可以是列表
    123: 990,  # 键为 int 类型 123
    (123,): {"ad1": "浦西", "ad2": "浦东"},  # 键为 tuple类型。 值可以是字典
    True: "孙悟空",
    1: "齐天大圣"  # 1 会把上一条 True 覆盖掉。   True 和 1 等效
}
# 通过 dict.fromkeys(seq[, value])) 创建字典
d4: dict = dict.fromkeys(['A', 'B'])  # {'A': None, 'B': None}  默认值为None
d5: dict = dict.fromkeys(['A', 'B'], '没维护')  # {'A': '没维护', 'B': '没维护'}

# 以下 测试用，实用少。了解即可
d6 = dict([('a', 1), ('b', 2)])  # {'a': 1, 'b': 2}
d7 = dict([['a', 1], ['b', 2]])  # {'a': 1, 'b': 2}
d8 = dict((['a', 1], ['b', 2], ('c', 3)))  # {'a': 1, 'b': 2, 'c': 3}
d9 = dict(zip(list("ABCDE"), list("1234")))  # {'A': '1', 'B': '2', 'C': '3', 'D': '4'}

# 获取值
print(d3[True], d3[1])  # 齐天大圣 齐天大圣
print(d3['email'])  # KeyError: 'email'。      键不在字典中时，会触发 KeyError 异常

# get()方法语法：dict.get(key[, value])  获取值
print(d3.get('name'))  # 王大锤    get方法获取键对应的值
print(d3.get('email'))  # None    若get方法获取的键不存在，返回None。    不会引发异常
print(d3.get('email', 'hi@qq.com'))  # hi@qq.com   若email键不存在，返回指定的默认值hi@qq.com，而不再返回None。  不会修改字典
print(d3.get((123,)).get('ad1'))  # 浦西   获取嵌套字典里的值。链式调用

# 获取所有键
print(d3.keys())  # dict_keys(['name', 'age', 'hobby', 123, (123,), True])
print('age' in d3.keys())  # True   存在 age 键 。等效于 'age' in d3
print('email' in d3.keys())  # False   不存在 email 键

# 获取所有值
print(d3.values())  # dict_values(['王大锤', 12, ['看书', '画画'], 990, {'ad1': '浦西', 'ad2': '浦东'}, '齐天大圣'])
print('孙悟空' in d3.values())  # False
print('齐天大圣' in d3.values())  # True

# 获取所有键值对
d5_k_v = d5.items()  # dict_items([('A', '没维护'), ('B', '没维护')])
for k, v in d5_k_v:
    print(k, v)

for k, v in d5.items():
    print(k, v)

# setdefalt 可视为新增  若键存在，不修改；若键不存在，新增并赋值
d5.setdefault('A', 999)  # {'A': '没维护', 'B': '没维护'}     键 A 已存在，不改变原值
d5.setdefault('C', 'Hi')  # {'A': '没维护', 'B': '没维护', 'C': 'Hi'}    键 C 不存在，创建并赋值 Hi

d5.update(d4)  # {'A': None, 'B': None, 'C': 'Hi'}  用 d4 字典更新 d5
d4.setdefault(120, 'Call')  # d4 ----> {'A': None, 'B': None, 120: 'Call'}
d5.update(d4)  # d5 ----> {'A': None, 'B': None, 'C': 'Hi', 120: 'Call'}  用 d4 字典更新 d5
d5_poped = d5.pop('C')  # d5 ----> {'A': None, 'B': None, 120: 'Call'}   pop方法，移除指定键值对
print(d5_poped)  # Hi
d5.pop('hello')  # 若不存在，引发异常  KeyError: 'hello'
d5_poped = d5.popitem()  # 3.6版本以前随机删除一项；3.6(字典是有序的)及以后版本删除最后一项
print(d5)  # d5  ---->  {'A': None, 'B': None}   删除最后一项，且以元组形式返回删除的键值对
print(d5_poped)  # (120, 'Call')

print(len(d3))  # 6  字典d3的长度

print('age' in d3)  # True  和下面一句等效。判断一个值是否在字典里，是默认以key去判断
print('age' in d3.keys())  # True

print(('age', 12) in d3.items())  # True
print(('age', 16) in d3.items())  # False
print(['age', 12] in d3.items())  # False

# 存在则修改，不存在则新增
d3['age'] = 20  # d3 --> {'name': '王大锤', 'age': 20, 'hobby': ['看书', '画画'], 123: 990, (123,): {'ad1': '浦西', 'ad2': '浦东'}, True: '齐天大圣'}
d3['gender'] = '男'  # d3 --> {'name': '王大锤', 'age': 20, 'hobby': ['看书', '画画'], 123: 990, (123,): {'ad1': '浦西', 'ad2': '浦东'}, True: '齐天大圣', 'gender': '男'}
del d3['gender']  # d3 --> {'name': '王大锤', 'age': 20, 'hobby': ['看书', '画画'], 123: 990, (123,): {'ad1': '浦西', 'ad2': '浦东'}, True: '齐天大圣'}
del d3['no_have']  # 若不存在，报错  KeyError: 'no_have'。 用的比pop更多，但pop有返回值

for i in d3:  # 对键循环遍历。等效于 for i in d3.keys()
    print(i)

for i in d3.values():
    print(i)

for k, v in d3.items():
    print(k, '-->', v)
print(d3)
#####################################################


#######################################################
# 集合特性：元素无序、元素可变、元素不可重复
# 定义
s = set()  # 定义空集合

# 增加元素
s.add('小王')  # {'小王'}
s.add('小张')  # {'小张', '小王'}

s.discard('小张')  # {'小王'}  删除元素：小张     discard：丢弃

s2 = {'小王', '小刘', '小孙'}
print(s & s2)  # {'小王'}  两集合取交集
s.add('小孙')
print(s & s2)  # {'小孙', '小王'}
print(s.intersection(s2))  # {'小孙', '小王'}  取交集方法2

s.add('Tom')  # s --> {'Tom', '小孙', '小王'}

print(s)  # {'Tom', '小孙', '小王'}
print(s2)  # {'小刘', '小孙', '小王'}
print(s | s2)  # {'小刘', '小孙', '小王', 'Tom'}  并集
print(s.union(s2))  # {'小刘', '小孙', '小王', 'Tom'} 并集 方法2

print(s - s2)  # {'Tom'} 差集  s中有但s2中没有的集合
print(s2.difference(s))  # {'小刘'}差集  s2中有但s中没有的集合

print(len(s))  # 3 集合s中元素个数

for i in s:  # 遍历集合
    print(i)

astr = "上海自来水来自海上"
sstr = set(astr)  # {'水', '自', '海', '上', '来'}  # 字符串转集合

alst = ' a big black bear sat on a big black bug'.strip().split()
# ['a', 'big', 'black', 'bear', 'sat', 'on', 'a', 'big', 'black', 'bug']
slst = set(alst)  # {'sat', 'big', 'a', 'black', 'bear', 'bug', 'on'}   列表转集合
print(slst)

w_lst = [11, 22, ['Mon', 'Fri'], 44]  # 列表嵌套
set(w_lst)  # 转换失败 TypeError: unhashable type: 'list'  集合元素不能是list
# 和字典一样，查询速度快(依赖于哈希存储)
# 若判断一个元素在不在一个序列里面，尽可能使用集合，因集合效率更高

s3 = {True, 1}  # True 和 False 本质上存储的是 1 和 0
print(s3)  # {True}  经过去重，只保留最先出现的 True

s4 = {1, True, False, 0}
print(s4)  # {False, 1}  只保留最先出现的值
########################################################


####################################################
# 利用 集合、列表 统计
d_str = 'asdfghgfdedacsw'
set5 = set()
lst_a = []
for i in d_str:
    if i in set5:
        lst_a.append(i)
    else:
        set5.add(i)
for i in set5:
    print("%s-->%s " % (i, lst_a.count(i) + 1), end=' ')
    # e-->1  g-->2  d-->3  s-->2  a-->2  f-->2  c-->1  h-->1  w-->1

d0: dict = dict.fromkeys(set5, 1)   # 通过集合创建字典，且赋初始值为 1
for i in d0:
    d0[i] += lst_a.count(i)
print(d0)  # {'e': 1, 'g': 2, 'd': 3, 's': 2, 'a': 2, 'f': 2, 'c': 1, 'h': 1, 'w': 1}

 

　　

 

a_str.center(width)