str.split(sep=None, maxsplit=-1) 分割字符串。sep指定分隔符；maxsplit指定分割次数，默认全部拆分，给定则最多有maxsplit+1个元素。返回列表
str.strip([chars]) 最外侧的前导和末尾 chars 参数值将从字符串中移除。返回字符串
str.replace(old,new)
str.count() 统计元素个数
str.find() str.index() 返回索引
str.join(iterable) iterable是一个可迭代对象，迭代着插入，可以是列表，但是所有元素都要是字符串。str作为iterable的分隔，返回字符串。
str.format() 格式化输出。 {}可以指定index和关键字
str.isalnum() 判断是否由字母和数字组成
str.isalpha() 判断是否只由字母组成
str.isdecimal() 判断是否由十进制数组成
str.title()
str.capitalize() 首字母大写
str.swapcase() 大小写转换，大写变小写，小写变大写
str.upper() str.lower()
str == str[::-1] 切片判断回文
tuple：(不可变序列)
'a','b' 会将这种视为元组
type((a)) 单个元素不是元组，是str
type((a,))
元组拆包赋值 k,v=('one', 1)
tuple.index()
tuple.count()
tuple[0]
拼接
list:（循环一个列表时最好不要改变列表大小，倒序删除）
list.append()
list.insert(i, x) 指定位置i处插入元素x
list.extend() 迭代着追加，扩展到列表里面，而不是整体添加（注意和append的区别）
list.pop() 指定位置删除，返回这个元素；默认删除最后一个
list.remove() 指定元素删除；有重复元素则默认删除左起第一个
list.clear() 删除整个列表元素
del list[i] 无返回值 删除列表中的偶数位置元素del list[1::2]、从后往前删、取出来
list.sort() 排序，无返回值
list.reverse() 翻转，无返回值
list.index() 找出第一个匹配项的索引
list.count()
# reversed() 和 list.reverse() 的区别 # reversed 返回一个反转的迭代器，可以反转 str、tuple、range、list # list.reverse 没有返回值，在原 list 上直接反转 for i in reversed('123'): print(i) a=[1,2,3] a.reverse() print(a) # sorted() 和 list.sort() 的区别 # sorted(iterable, cmp=None, key=None, reverse=False) # sorted 返回一个排好序的列表 cmp为比较函数、reverse=False默认升序 # list.sort 没有返回值 print(sorted('1432930')) a=[3,2,1] a.reverse() print(a)
dict：(存储在散列表中，键必须是可散列的；循环字典时，不能改变字典大小)
key必须是不可变数据类型(int，str，bool, tuple等)，且唯一
创建dict
1.dict((('one',1),('two',2),('three',3)))
2.dict({'one':1,'two':2,'three':3})
3.dict(one=1,two=2,three=3)
4.dict(zip(['one','two','three'],[1,2,3]))
5.{k:v for k, v in [('one',1),('two',2),('three',3)]}
dict.fromkeys(it, [initial]) # 将迭代器it里面的作为键，将initial里面的作为值(如果没有的话设置为None)
增
dict['four']=4
dict.setdefault('four',4) 会返回键对应的值
dict.setdefault('one',2) 有此键则不会改变
dict.update(five=5)
删
dict.pop('one') 返回键对应的值，然后移除键值对
dict.popitem() 以元组的形式随机返回键值对
dict.clear()
del dict['one']
改
dict.update(four=4)
dict.update([( ),( ),( )])
dict.update({' ':' '})
查
dict.get(k, [default]) 返回键对应的值，如果没有该键则返回default
dict.keys()
dict.values()
dict.items() 可用于对字典遍历输出key和value；for k,v in dict.items() 循环遍历返回键和值组成的元组
# 注意返回值类型，并不是返回一个列表，不过可以用list取值 dic = {'a':1, 'b':[1,2,3]} print(dic.values()) # dict_values([1, [1, 2, 3]]) print(type(dic.values())) # <class 'dict_values'> print(type(dic.keys())) # <class 'dict_keys'>
获取第一个值对应的键
a = {3: 1, 4: 1, 5: 2, 6: 9}
# 获取值1对应的第一个键
b = list(a.keys())[list(a.values()).index(1)]
print(b) # 3
set:（无序，不支持索引、切片；里面的元素要求不可变(必须是可散列的)，但是集合又可变）
用于列表去重
数据集关系测试：并集、交集、差集 | & ^
判断是否为子集：s<=z(子集) s<z(真子集)
创建set
set({1,2,3}) 空集合要用set
{1,2,'a'}
增
set.add()
set.update() 迭代着增加
删
set.remove(e) 没有的话会报错
set.pop() 有返回值
set.clear()
set.discard(e) 有的话移除，没有话也不会报错
计算机的数据结构
1.队列（先进先出）
2.栈（后进先出）
自定义队列和栈
class Foo: def __init__(self): self.lst=[] def put(self,x): self.lst.append(x) def get(self): if len(self.lst)==0: return None else: return self.lst.pop() if self.index else self.lst.pop(0) class Queue(Foo): # 先进先出 def __init__(self): self.index=0 Foo.__init__(self) class Stake(Foo): # 后进先出 def __init__(self): self.index=1 Foo.__init__(self)
queue
from queue import Queue, Empty from queue import LifoQueue # 先进后出 from queue import PriorityQueue # 优先级队列 q=Queue(maxsize=3) try: q.get_nowait() # 可进行异常处理 # q.get() except Empty: pass # 不是内置的错误类型 q=PriorityQueue() q.put(('a', '97')) q.put(('0', '48')) q.put(('A', '65')) for i in range(3): print(q.get()) ''' ('0', '48') ('A', '65') ('a', '97') '''
内置数据类型：int、float、bool、complex