python 线性结构.png

一.列表

• 一个队列，一个排列整齐的队伍
• 列表内的个体称为元素
• 元素可以是任意对象（数字，字符串，对象，列表等）
• 列表内元素有顺序，可以使用索引,支持负索引
• 线性的数据结构
• 使用[ ] 表示
• 列表是可变的

1.列表初始化

• lst = list()
• lst = []
• lst = list(range(5))
• lst = list(str) #遍历字符串里面的字符

2.列表常用的方法

①index(value, [start, [stop]])

• 从指定区间查看列表内的元素是否匹配。区间[ )
• 匹配到第一个值就返回该值的索引
• 匹配不到就会出现ValueError错误
• 时间复杂度是O(n).

②count(value)

• 返回列表中value 的出现的次数。
• 时间复杂度是O(n).

③append(value)

• 列表尾部追加元素，返回None
• 直接修改列表
• 只接受一个参数，并且直接将该参数作为一个元素追加到列表尾部
• 时间复杂度是O(1)

④ 索引访问修改元素

• list[index] = value
• 索引不能超界

⑤insert(index,value)

• 在指定的的索引index前插入新的元素
• 直接修改列表，返回None
• 时间复杂度O(n)
• 越界，就近追加

⑥ extend(iteratable)

• 就地追加，返回None
• 遍历可迭代对象中元素追加到列表尾部（extend list by appending elements from the iterable ）
• 时间复杂度O(1)
• 通过"+=" 就地修改列表，增加元素

⑦ 通过 “+” 生成一个新的列表

• 连接两个列表
• 产生新的列表，原列表不变
• 本质上调用了add()方法
• 消耗内存空间

⑧ 通过 “*” 生成一个新的列表

• 将列表内的元素重复n次，返回新列表
• 元素如果是单值：数字，整型，字符串等，简单重复
• 元素如果是引用类型：列表等。重复n次，复制n个引用元素，每个元素指向同一个内存地址。如果修改某一个元素里面的数据，即其他指向同一个内存地址的元素的值也会改变。

>>> li1 = [1,2]*3
>>> li1
[1, 2, 1, 2, 1, 2]
>>> li1[2] = 4
>>> li1
[1, 2, 4, 2, 1, 2]
>>> li2 = [[1,2]] * 3
>>> li2
[[1, 2], [1, 2], [1, 2]]
>>> id(li2[0])
140329691450248
>>> id(li2[1])
140329691450248
>>> id(li2[2])
140329691450248
>>> li2[1][0] = 4
>>> li2
[[4, 2], [4, 2], [4, 2]]
>>> li2[0] = 100
>>> li2
[100, [4, 2], [4, 2]]
>>> id(li2[0])
9095328
>>> id(li2[1])
140329691450248
>>> id(li2[2])
140329691450248

⑨remove(value)

• 从左到右查找，并删除第一个匹配的value
• 就地修改
• 时间复杂度O(n)

⑩pop([index])

• 不指定index，pop()默认从列表尾部弹出一个元素，返回该元素。O(1)
• 指定index，弹出该元素，索引超界则报错IndexError. O(n),将改变列表其他元素的索引

⑪clear()

• 清除列表所有元素
• lst.clear() 等价 lst = []
• 返回None

⑫reverse()

• 直接修改列表，返回None
• 将列表元素反转
• 挪动全部元素，不建议，效率比遍历差

⑬sort(key =None,reverse=False)

• 元素排序，默认升序
• 直接修改列表，返回None
• reverse=True ，降序
• key 一个函数，指定key 如果排序。会按照key 指定的类型，做隐式转换，才能比较大小。
  lst.sort(key=functionname)

⑭ in 遍历列表

• [3,4] in [1,2,[3,4] -> True
• for i in [1,2,3,4]

⑮copy()

• shadow copy 返回一个新的列表
  遇到引用类型，只是复制了一个引用
• 可以使用copy.deepecopy(lst) 深拷贝

二.元组

• 一个有序的元素组成的，可索引，支持负索引
• 元素可以是任意对象
• 使用() 表示
• 元组定义后是不可以改变的

1.元组初始化

• t = tuple()
• t = tuple(iterable)
• t = (1,) #单个元素后一定要加上‘,’

2.元组常用方法

①index(value, [start, [stop]])

• 从指定区间查看列表内的元素是否匹配。区间[ )
• 匹配到第一个值就返回该值的索引
• 匹配不到就会出现ValueError错误
• 时间复杂度是O(n).

②count(value)

• 返回列表中value 的出现的次数
• 时间复杂度是O(n)

元组只读，只有查询方法

3.namedtuple 命名元组

• 在collections 模块中存在namedtuple 函数。该函数返回一个元组的子类，并定义了字段
• namedtuple(typename, field_names, verbose=False, rename=False)
  field_names可以是空白符或逗号分割的字段的字符串，可以是字段的列表

>>> from collections import namedtuple
>>> Point = namedtuple('_Point',['x','y']
... )
>>> from collections import namedtuple
>>> Point = namedtuple('_Point',['x','y'])  #Point 是类型名，_Point 是标识符
>>> type(Point)
<class 'type'>
>>> p = Point(11, 22)
>>> type(p)
<class '__main__._Point'>
>>> p
_Point(x=11, y=22)
>>> p.x

三.字符串

• 字符串是一组有序的字符组成的序列
• 是线性结构，可以索引，支持索引
• 字符串是不可以改变的
• Python3 字符串默认是Unicode类型

1.str初始化

• s = 'str1'
• s= "str2 "
• s= """long str3 """
• s = r"hello \n magedu.com" #raw string，不要在意字符串中的特殊符号
• s = R"c:\windows\nt" #raw string不要在意字符串中的特殊符号

2.str常用的方法

①.index(value, [start, [end]])

• 在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
• rindex(value, [start, [end]])
  在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
• O(n)

②count(value)

③ in 遍历字符

④"string".join(iterable)

• 将可迭代对象连接起来，使用string作为分隔符
• 可迭代对象本身元素都是字符串
• 返回一个新字符串

⑤通过 “+” 生成一个新的str

• 产生新的str，原str不变

⑥split(sep=None, maxsplit=-1)

• 从左到右分割
• sep 指定分割字符串，缺省的情况下空白字符串（一个或者多个）作为分隔符
• maxsplit 指定分割的次数，-1 代表遍历整个字符串
• 返回新列表
• rsplit(从右到左）
• splitlines([keepends])
  1.按照行分割字符串
  2. keepends 指是否保留换行符[True|False],默认为 False，不包含换行符
     3.换行符：\n、\r\n、\r等

⑧partition(sep)

• seq 指定分隔符
• 从左到右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组(head, sep, tail)
• 如果没有找到分隔符，就返回头、2个空元素的三元组
• rpartition(sep)
  从右至左，遇到分隔符就把字符串分割成两部分，返回头，分隔符，尾三部分的三元组，如果没有找到分隔符，就返回2个空元素的三元组

⑨replace(old,new,[count])

• 字符串中找到匹配的oldstr 替换成newstr，返回新的字符串
• count 默认全部替换，可以指定替换几次

⑩strip([chars])

• 从字符串两端去除指定的字符集chars中的所有字符，默认去除两端的空白字符
• 返回一个新的字符串
• 效率较高
• lstrip 从左开始
• rstrip 从右开始

⑪find(sub,[start,[end]])

• 在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到返回-1
• rfind(sub[, start[, end]])
  在指定的区间[start, end)，从右至左，查找子串sub。找到返回索引，没找到返回-1

⑫字符串大小写

• upper()，全大写
• lower()，全小写
• swapcase()，交互小大写

⑬ 字符串排版

• title() -> str 标题每个单词大写
• capitalize() -> str 首个单词大写
• center(width,[fillchar]) -> str
  width 宽度
  fillchar 填充的字符
  （菱形打印)
• zfill(width) -> str 指定宽度右对齐，左边用0填充
• ljust(width,[fillchar]) -> str 左对齐
• rjust(width,[fillchar]) -> str 右对齐

n = 7
for i in range(-n//2,n//2+1):
    if i < 0:
        i = -i
    s = '*'*(n-2*i)
    print(s.center(n,' '))

   *
  ***
 *****
*******
 *****
  ***
   *

⑭ endswith(suffix,[start,[end]]) -> bool

• 在[start,end) 区间判断字符串是否以suffix 结尾
• startswith(prefix,[start,[end]]),判断字符是否以prefix 开头

⑮字符串判断

• isalnum() -> bool 是否是字母和数字组成
• isalpha() 是否是字母
• isdecimal() 是否只包含十进制数字
• isdigit() 是否全部数字(0~9)
• isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线  islower() 是否都是小写
• isupper() 是否全部大写
• isspace() 是否只包含空白字符

四. bytes,bytearray (python3)

• bytes 是不可变的字节序列
• bytearry 是可变的字节数组
• 所有的文件都是字节序列，所有的数据都可以当文本处理

1. 编码和解码

• 字符串按照不同的字符集编码encode返回字节序列bytes
• 字节序列按照不同的字符集解码decode 返回字符串

2.bytes定义

• bytes() 空bytes
• bytes(int) 指定bytes 的长度，以b'0 填充
• bytes(iterable of ints) 指定bytes字节的内容 # int 范围在[0,255]之间
• bytes(string,encoding,[errors]) 等价string.encode() 返回新bytes
• bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer 从一个字节序列或者buffer复制出一个新的不可变的bytes对象
• 使用b前缀定义
  如果字符存在ASCII中即以字符形式存在，否则用16进制表示 。

3.bytes常用的方法

• replace()
  b'abcdef'.replace(b'f',b'k')
• find()
  b'abc'.find(b'b')
• bytes.fromhex(string)
  string必须是2个字符的16进制的形式，'6162 6a 6b'，空格将被忽略
• hex()
  返回16进制表示的字符串
  'abc'.encode().hex()
• 索引
  b'abcdef'[2] 返回该字节对应的十进制的数字，int类型

4.bytearray 定义

• bytearray() 空bytearray
• bytearray(int) 指定字节的bytearray，被0填充
• bytearray(iterable_of_ints) -> bytearray [0,255]的int组成的可迭代对象
• bytearray(string, encoding[, errors]) -> bytearray 近似string.encode()，不过返回可变对象
• bytearray(bytes_or_buffer) 从一个字节序列或者buffer复制出一个新的可变的bytearray对象

3.bytearray 操作

• append(int) int 是字节的整型
• insert(index, int) 在指定索引位置插入元素
• extend(iterable_of_ints) 将一个可迭代的整数集合追加到
  当前bytearray
• pop(index=-1) 从指定索引上移除元素，默认从尾部移除
• remove(value) 找到第一个value移除，找不到抛ValueError异常
• clear() 清空bytearray
• reverse() 翻转bytearray，就地修改

4.int和bytes

• int.from_bytes(bytes, byteorder)
  将一个字节数组表示成整数
• int.to_bytes(length, byteorder)
  byteorder字节序 （一般是'big')
  将一个整数表达成一个指定长度的字节数组