Python内置数据结构str、list、tuple、set、dict

数据结构	可变	可迭代	有序	特性
str	✖	✔	✔
list	✔	✔	✔
tuple	✖	✔	✔
set	✔	✔	✖	key不重复，且必须可hash
dict	✔	✔	✖	同上

字符串

• 一个个字符组成的有序的序列，是字符的集合
• 使用单引号、双引号、三引号引住的字符序列
• 字符串是不可变对象
• Python3，字符串就是Unicode类型

字符串定义 初始化

• 举例

  s1 = 'string'
  s2 = "string2"
  s3 = '''this`s a "string" '''
  s4 = 'hello \n magedu.com'
  s5 = r"hello \n magedu.com"
  s6 = 'c:\windows\nt'
  s7 = R"c:\windows\\nt"
  s8 = 'c:\windows\\nt'
  sql = """select * from user where name='tom'"""

字符串元素访问

• 字符串支持使用索引访问
• 有序的字符集合，字符序列
• 可迭代

字符串join连接

• "string".join(iterable) -> str

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

  lst = ['1','2','3']
  print("\"".join(lst))
  print("\n".join(lst))
  
  #返回
  
  1"2"3
  1
  2
  3
  
  lst = ['1',['a','b'],'3']
  print(" ".join(lst))    #报错，注意可迭代对象元素都是字符串

字符串 + 连接

• + > str
  
  • 将2个字符串连接在一起
  • 返回一个新字符串

字符串分割

• 分割字符串的方法分为2类
  
  • split
    
    • 将字符串按照分隔符分割成若干字符串，并返回列表
  • partition
    
    • 将字符串按照分隔符分割成2段，返回这2段和分隔符的元组

• split(sep=None,maxsplit=-1) - > list of strings

  • 从左至右
  • sep指定分割字符串，缺省的情况下空白字符串作为分隔符
  • maxsplit指定分割次数，-1表示遍历整个字符串
  • 举例

  s1 = "i`m \ta super student."
  s1.split()
  s1.split('s')
  s1.split('super')
  s1.split('super ')
  s1.split('')
  s1.split('',maxsplit=2)
  s1.split('\t',maxsplit=2)

• rsplit(sep=None,maxsplit=-1)-> list of string
  
  • 从右至左
  • sep指定分割字符串，缺省的情况下空白字符串作为分隔符
  • maxsplit指定分割次数，-1表示遍历整个字符串
• splitlines([keepends]) -> list of strings
  
  • 按照行来切分字符串
  • keepends指的是是否保留分隔符
  • 行分隔符包括\n、\r\n、\r等
• partition(sep) -> (head,sep,tail)
  
  • 从左至右，遇到分隔符酒吧字符串分割成两部分，返回头，分隔符，尾三部分；如果没有找到分隔符，就返回头，2个空元素的三元组
  • sep分割字符串，必须指定
• rpartiton(sep) -> (dead, sep, tail)
  
  • 从右至左，遇到分隔符酒吧字符串分割成两部分，返回头，分隔符，尾三部分；如果没有找到分隔符，就返回头，2个空元素的三元组

字符串大小写

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

字符串排版

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

字符串修改

• replace(old, new[,count]) -> st
  
  • 字符串中找到匹配替换为新子串，返回新字符串
  • count表示替换几次，不指定就是全部替换
• strip([chars]) -> str
  
  • 从字符串两端去除指定的字符集chars中的所有字符
  • 如果chars没有指定，去掉两端的空白字符
• lstrip([chars]) -> str
  
  • 从左开始
• rstrip([chars]) -> str
  
  • 从右开始

字符串查找

• find(sub[, strat[, end]]) -> int
  
  • 在指定的区间[start, end],从左至右，查找子串sub。找到返回索引，没找到返回-1
• rfind(sub[, strat[, end]]) -> int
• index(sub[, start[, end]]) -> int
  
  • 在指定的区间[start,end),从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
• rindex(sub[, start[, end]]) -> int
  
  • 在指定的区间[start,end),从右至左，查找子串sub。找到返回索引，没找到抛出异常ValueError
• 时间复杂度
  
  • index和count方法都是O(n)
  • 随着列表数据规模的增大，而效率下降
• len(string)
  
  • 返回字符串的长度，即字符的个数
• count(sub[,start[, end]]) -> int
  
  • 在指定区间[start, end),从左至右，统计子串sub出现的次数

字符串判断

• endswith(suffix[, start[, end]]) -> bool
  
  • 在指定的区间[start, end),字符串是否是suffix结尾
• startswith（prefix[,start[, end]]）-> bool
  
  • 在指定的区间[start, end),字符串是否是suffix开头

字符串判断is系列

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

字符串格式化

• 字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便
  
  • join拼接只能使用分隔符，且要求被拼接的是可迭代的对象
  • + 拼接字符串还算方便，但是非字符串需要先转化为字符串才能呢个拼接
• format函数格式字符串语法
  
  • ”{} {xxx}”.format(*args,**kwargs) -> str
  • args是位置参数，是一个元组
  • kwargs是关键字参数，是一个字典
  • 花括号表示占位符
  • {}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
  • {xxx}表示在关键字参数中搜索名称一致的
  • {{}}表示打印花括号

• 位置参数

  "{}:{}".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 namedttuple
  Point = namedtuple('Point','x y')
  p = Point(4,5)
  "{{{0,x},{0,y}}}".format(p)

• 对齐

  '{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')

• 进制

  "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
  "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)
  octets = [192, 168, 0, 1]
  '{:02X}{:02X}{:02X}{:02X}'.format(*octets)

列表list

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

列表list定义 初始化

• list() 生成一个新列表
• list(iterable) 可将可循环结构转化为列表
• 列表不能一开始就定义大小
• 举例
  
  • lst=list()
  • lst=[]
  • lst=[2,3,’adfa’]
  • lst=list(range(5))

列表索引访问

• 索引，也叫下标
• 正索引：从左至右，从0开始，为列表中的每一个元素编号
• 负索引：从右至左，从-1开始
• 正负索引不可以越界，否则引发异常indexError
• 列表通过索引访问
  
  • list[index],index就是索引，使用中括号访问

列表查询

• index(value,[start,[stop]])
  
  • 通过值valaue，从指定区间查找列表内的元素是否匹配
  • 匹配第一个就立即返回索引
  • 匹配不到，抛出异常ValueError
• count（value）
  
  • 返回列表中匹配value的次数
• 时间复杂度
  
  • index和count方法都是O(n)
  • 随着列表数据规模的增大，效率下降
• len()

列表元素修改

• 索引访问修改
  
  • list[index] = value
  • 索引不要越界

列表增加、插入元素

• append(object) -> None
  
  • 列表尾部追加元素，返回None
  • 不产生新列表，就地修改
  • 时间复杂度O(1)
• insert(index,object) -> None
  
  • 在指定的索引index处插入object
  • 不产生新的列表，就地修改
  • 时间复杂度是O(n)
  • 索引超出上下界
    
    • 超越上届，尾部追加
    • 超越下届，头部追加
• extend(iteratable) -> None
  
  • 将可迭代对象的元素追加进来，返回None
  • 就地修改
• + > list
  
  • 连接操作，将两个列表连接起来
  • 产生新的列表，原来列表不变
  • 本质上是调用add()方法

列表*重复的问题

pass

列表删除元素

• remove(value) -> None
  
  • 从左至右查找第一个匹配value的值，移除该元素，返回None
  • 就地修改
  • 时间复杂度是O(n)

• pop([index]) -> item

  • 不指定索引index，就从尾部弹出一个元素
  • 指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
  • 时间复杂度
    
    • 指定索引是O(n)
    • 不指定是O(1)

• clear() -> None

  • 清除列表内所有的元素

列表其他操作

• reverse() -> None
  
  • 将列表元素反转，返回None,就地修改
• sort(key=None,reverse=False) -> None
  
  • 对列表元素进行排序，就地修改，默认升序
  • reverse为True,反转，降序
  • key一个函数，指定key如何排序
• in
  
  • [3,4] in [1,2,[3,4]]
  • for x in [1,2,3,4]

列表复制

• copy() -> List
  
  • shadow copy 影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已。
• 深拷贝
  
  • copy 模块提供了deepcopy

随机数

• random模块
• randint(a,b) 返回a，b之间的整数
• choice(seq)从非空序列的元素中随机挑选一个元素
• randrange([start,] stop [,step])从指定范围内，按指定基数递增的集合中获取一个随机数
• random.shuffle(list) ->None 就地打乱列表元素
• sample(population, k)从样本空间或总体中随机取出k个不同的元素，返回一个新的列表

元组 tuple

• 一个有序的元素组成的集合
• 使用小括号() 表示
• 元组是不可变对象

元组的定义 初始化

• 定义

  • tuple() -> empty tuple
  • tuple(iterable) -> tuple initialized from iterable’s items
  • 举例

  t = tuple()
  t = ()
  t = tuple(range(1,7,2)
  t = (2,3,4,6,7)
  t = (1,)
  t = (1,2,3) * 6

元组元素的访问

• 支持索引
• 正索引：从左至右，从0开始，为列表中每一个元素编号
• 负索引：从右至左，从-1开始
• 正负索引不可以超界，否则引发异常IndexError
• 元组通过索引访问
  
  • tuple[insex],index就是索引，使用中括号访问

元组查询

• index(value,[start,[stop]])
  
  • 通过值value，从指定区域查找列表内的元素是否匹配
  • 匹配第一个就立即返回索引
  • 匹配不到，抛出异常ValueErroe
• count(value)
  
  • 返回列表中匹配value的次数
• 时间复杂度
  
  • index和count方法都是O(n)
  • 随着列表数据规模的增大，而效率下降
• len(tuple)
  
  • 返回元素的个数

元组其他操作

• 元组是只读的，所以增、改、删的方法都没有

---

字典dict

• key-value键值对的数据集合
• 可变的、无序的、key不重复

字典dict定义 初始化

d = dict() 或者 d = {}
dict(**kwargs) 使用name=value对初始化一个字典
dict(iterable, **kwarg) 使用可迭代对象和name=value 对结构字典，不过可迭代对象的元素必须是一个二元结构
d = dict(((1, 'a'), (2, 'b'))) 或者 d = dict(([1, 'a'], [2, 'b'])))
dict(mapping, **kwarg) 使用一个字典构建另一个字典
d = {'a':10, 'b':20, 'c':None, 'd':[1,2,3]}
类方法dict.fromkeys(iterable, value)
d = dict.fromkeys(range(5))
d = dict.fromkeys(range(5), 0)

字典元素的访问

• d[key]
  返回key对应的值value
  key不存在抛出KeyError异常
• get(key[, default])
  返回key对应的值value
  key不存在返回缺省值，如果没有设置缺省值就返回None
• setdefault(key[, default])
  返回key对应的值value
  key不存在，添加kv对，value为default，并返回default，如果default没有设置，缺省为None

字典增加和修改

• d[key] = value
  将key对应的值修改为value
  key不存在添加新的kv对
• update([other]) -> None
  使用另一个字典的kv对更新本字典
  key不存在，就添加
  key存在，覆盖已经存在的key对应的值
  就地修改

d.update(red=1)
d.update((('red', 2),))
d.update({'red':3})

字典删除

• pop(key[, default])
  key存在，移除它，并返回它的value
  key不存在，返回给定的default
  default未设置，key不存在则抛出KeyError异常
• popitem()
  移除并返回一个任意的键值对
  字典为empty，抛出KeyError异常
• clear()
  清空字典
• del语句
  del a[‘key’]
  本质是删除对象引用

字典遍历

for … in dict

遍历key
for k in d:
    print(k)

for k in d.keys():
    print(k)

遍历value
for k in d:
    print(d[k])

for k in d.keys():
    print(d.get(k))

for v in d.values():
    print(v)

遍历item
for item in d.items():
    print(item)

for item in d.items():
    print(item[0], item[1])

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

for k,_ in d.items():
    print(k)

for _,v in d.items():
    print(v)

总结

python3中,keys、values、items方法返回一个类似一个生成器的可迭代对象，不会吧函数的返回值复制到内存中

字典的遍历移除

错误做法
d = dict(a=1,b=2,c='abc')
for k,v in d.items():
    d.pop(k) #抛出异常，不能在遍历中改变字典长度

正确做法
d = dict(a=1,b=2,c='abc')
key = []
for k,v in d.items():
    if isinstance(v,str):
        keys.append(k)

for k in keys:
    d.pop(k)
print(d)

字典的key

• key的要求和set的元素要求一致
• set的元素可以看作key，set可以看作是dict的简化版
• hashable可哈希才可以作为key，可以使用hash()测试

deaultdict

• collections.defaultdict([default_factory[, ...]])
  第一个参数是default_factory，缺省是None，它提供一个初始化函数，当key不存在的时候，会调用这个共产函数来生成key对应的value

import random 

d1 = {}
for k in 'abcdef':
    for i in range(random.randint(1,5)):
        if k not in d1.keys():
            d1[k] = []
        d1[k].append(i)
print(d1)


form collections import defaultdict
import random

d1 = defaultdict(list)
for k in 'abcdef':
    for i in range(random.randint(1, 5)):
        d1[k].append(i)

print(d1)

OrderedDict

• collections.OrderedDict([items])
  key并不是按照加入的顺序排列，可以使用OrderedDict记录顺序

from collections import OrderedDict
import random

d = {'banana':3, 'apple':4, 'pear':1, 'orangr':2}
print(d)
keys = list(d.keys())
random.shuffle(keys)
print(keys) 89
od = OrderedDict()
for key in keys:
    od[key] = d[key]
print(od)
print(od.keys())