数据结构

数据结构

◆ List

list：定义

lst1=[]括号里为具体元素
lst2=list()括号里为可迭代对象

list：可索引、计数

例list1=[1,2,3,2,[1,2],4]
知道序列号查询列表元素,从左到右查，从0开始，从右到左查，从-1开始；如list1[0]和list1[-6]结果一样为1
知道列表元素查询序列号为list1.index(3)结果为2，若列表元素有重复，则从左取第一个
查询列表里元素的重复数为list1.count(2)结果为2
查询列表里元素总数为len(list1)为6

list：可迭代

for i in list1:
    print(i)
1
2
3
2
[1, 2]
4

可变类型：内部元素可以增删改

> 内部元素重新赋值：list1[0]=22,列表list1结果为[22,2,3,2,[1,2],4]
> 列表尾部追加为list1.append(5)结果为[1,2,3,2,[1,2],4,5]，list1.append每次只能增加一个元素
> list1.extend(可迭代对象或列表)增加多个元素，如list1.extend(range(10))或者list1.extend([1,2,3]）
> 列表相加list1+[1,2,3]=list2表示创建一个新的列表,耗费内存
> 列表中间插入为list1.insert(1,7)表示在第2位后插入元素7
> 列表copy--分浅引用list2=copy(alist1)和深引用(需导入copy模块）list2=copy.deepcopy(list1)，则list2=[1,2,3,2,[1,2],4],浅引用和深引用区别，当原列表里有嵌套列表时，修改嵌套列表里的元素，浅引用和copy的新列表一样，深引用和copy的新列表不一样。
> 列表乘list1*n，如list3=alist1*2,新列表c相当于浅引用了list1列表一次，修改list1列表里嵌套列表的元素，则list3列表里的嵌套列表元素都修改。
> 列表删除元素remove(列表里的元素)，list1.remove([1,2])结果为[1,2,3,2,4];
> 列表删除元素pop（列表里元素的序列号）,list1.pop(4)结果同样为[1,2,3,2,4]
> 列表排序元素sort，list1.sort()里面元素应为同一类型，可以用指定类型转换排序，key=int或str，list1.sort(key=int或str)
> 列表元素倒叙排列reverse,list1.reverse()

时间复杂度O（n）：index和count和a.insert都是把列表里的元素都统计一遍，时间复杂度高，为O(n)，效率低。list1[]和len(list1)和list1.append()和list.entend()的时间复杂度小为O（1）

列表类型有：列表、链表、队、栈

  列表里的元素有顺序（即元素在内存里是有序排列的），要求连续内存，线性的数据结构。列表优势在于搜索索引修改，劣势在于增删元素（因为增删元素，会导致剩下在内存里重新排序）
  链表link.list不要求内存连续，链表里的元素在内存里是无序排列的，优势在于元素增删，劣势在于搜索索引。
  queue队，要求内存连续,里面中间元素不能增删，只能操作两端元素，为先进先出
  stack栈，要求内存连续,里面中间元素不能增删，只能操作两端元素，为后进先出

◆ tuple

tuple: 定义

t1=tuple()括号里为可迭代对象
t2=()括号里为具体元素
例t3=tuple（range（5））或者t3=(0,1,2,3,4)

可以索引、计数：和list索引一样，从左开始以0，从右开始以-1

t3[2]为2
t3.index(3)为3
t3.count(1)为1
len(t3)为5

可迭代

For I in t3:
    print(i)
0
1
2
3
4

不可变对象–里面元素不能增删改：

但如果是嵌套格式如t3=(1,2,[1,2],5),t3[0]=1,如重新赋值t3[0]=2,则会报错。但t3[2][1]结果为2，如重新赋值t3[2][1]=55，则t3=(1,2,[1,55],5).原理-相当于列表里的浅引用，元组里的[1,2]为一个整体为一个房间号，改里面的数据不影响整体的房间号，所以整体来说，元组是没有改变

namedtuple

 帮助文档中，查阅namedtuple，有使用例程
 namedtuple(typename, field_names, verbose=False, rename=False)
field_names表示方法：一用单引号' '里面的两个字符用，或者空格隔开,二用列表[ ]，里面的字符必须为字符串，且必须用，隔开
 命名元组，返回一个元组的子类，并定义了字段
 field_names可以是空白符或逗号分割的字段的字符串，可以是字段的列表

用法

    from collections import namedtuple
    Point = namedtuple('S',['x','y']) # Point为返回的类
    p = Point(11, 22),print(p),结果为S(x=11,y=22)
    Student = namedtuple('Student', 'name age')
    tom = Student('tom', 20)
    jerry = Student('jerry', 18)
    print(tom,jerry)，结果为student(name='tom',age=20)        student(name='jerry',age=18)
    print(tom.name, jerry.age)输出结果为'tom'  20

定义完成之后，不可重新赋值修改。

   如输出tom.age结果为20，若重新定义tom.age=33，则会报错

◆ str

str：定义

s1=' '
s2=" "
S3='''  '''
r/R前缀：取消字符串里的转义
f前缀(只在Python3.6以后的版本存在）：
如：x=4  y=5
s1=f"{x}-->{y}"结果s1为'4-->5'
s1="{x}-->{y}"结果s1为'{x}-->{y}'
相当于引用变量，{}里填标识符

可索引、计数：和list、tuple索引、计数方法一样

S1="{x}-->{y}"
S1[0]结果为'{'，S1[-2]结果为'y'
S1.Index('x')结果为1找不到报错
S1.find()找不到返回值为负数
S1.count('-')结果为2
Len(s1)结果为9

可迭代:

For i in s1:
    print(i)
{
x
}
-
-
>
{
y
}

不可变对象：

S1="{x}-->{y}"
S1[0]='m'则会报错

str用法

'str'.join()括号里为可迭代对象，且对象里的元素只能为字符串，意思是在可迭代对象里用字符串连接。如'*'.join(list('asdf'))结果'a*s*d*f'，如果元素 是其他类型用map(str,range(10))函数强制转换  

Str+str字符串拼接创建一个新的字符串，如sta='abc12',stb='ef+1',则sta+stb结果为'abc12ef+1'  

Str.split(sep,maxsplit=-1)，sep分割为符，默认以空格符分割，分割完后分割符会被割掉。maxsplit为分割次数，默认为最大值。默认从左到右切。分割以后会立即形成一个新的列表。如sta='superpstar',sta.split('p')结果为['su','er','star']。从右向左切用rsplit,但返回的列表元素顺序不会变。  

Str.partition(sep),sep为分割符。必须指定分割符，把字符分割成头部，分割符，尾部并形成一个新的三元组。如sta='superpstar'，sta.partition('p')结果为（'su','p','erpstar')  

Str.upper(),字符串转换为大写   

Str.lower(),字符串转换为小写  

Str.replace(old,new,[count]):字符串替换，count为替换次数，默认为全替换。  

Str.strip([chars]):chars为字符集。从字符串两端开始除去指定chars中的所有字符，默认为去除空白字符。如sta='I am very sorry',  sta.strip('ir')结果为' am very sorry'字符I被去掉，r字符没有被去掉因为y后面还有y

字符串格式化

 位置参数
"{}:{}".format('192.168.1.100',8888)，这就是按照位置顺序用位置参数替换前面的格式字符串的占位符中
 关键字参数或命名参数
"{server} {1}:{0}".format(8888, '192.168.1.100', server='Web Server Info : ') ，位置参数按照序号匹配，关键字参数按照名词匹配
 访问元素
"{0[0]}.{0[1]}".format(('magedu','com'))
 对象属性访问
from collections import namedtuple
Point = namedtuple('Point','x y')
p = Point(4,5)
"{{{0.x},{0.y}}}".format(
 对齐
'{0}*{1}={2:<2}'.format(3,2,2*3)
'{0}*{1}={2:<02}'.format(3,2,2*3)
'{0}*{1}={2:>02}'.format(3,2,2*3)
'{:^30}'.format('centered')
'{:*^30}'.format('centered')
对齐格式":<2"---：为格式。2为宽度，<表示向左靠，>表示向右靠。0表示宽度不够补0也可以用别的符号, ^表示居中。