python内置数据类型

时间复杂度分析

str：

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