1，基本概念
1.1，python序列类型包括：
容器类型：list，tuple，collections.deque，存放引用，可嵌套
扁平序列：str，bytes，bytearray，memoryview，array.array，存放值，只包含原子数据
可变序列：list，bytearray，array.array，collections.deque，memoryview
不可变序列：tupe，str，bytes
2，str
1）格式化：
%s：‘%s plus %s equals %s‘ % (1, 1, 2)
2）find/rfind：返回最左边/最右边索引，没有返回-1，例如路径中提取文件名
s1 =‘c:/../../text.txt‘ s1[s1.rfind(‘/‘)+1: s1.find(‘.txt‘)] # s1结果是text
3）lower/upper：小写/大写
4）startswith/endswith：判断开始/判断结尾，例如endswith(‘com‘)
5）strip/lstrip/rstrip：去除两边/左边/右边的空格字符串，也可以传参指定去除的内容
6）join：合项
‘,‘.join([‘a‘, ‘b‘, ‘c‘]) # 结果是a,b,c
7）split：裂项，不传参就对空格、制表、换行进行分割
‘a b \nc‘.split()，# 结果是[‘a‘, ‘b‘, ‘c‘]
8）count：统计出现次数
9）index：判断索引位置
10）replace：替换，默认全替，但可以传第3参数指定替换几个
‘aba‘.replace(‘a‘, ‘b‘, 1) # 指定替换1个，结果是‘bba‘，
11）center：居中打印
‘title‘.center(50, ‘-‘) # 结果是‘----------------------title-----------------------‘
12）isdigit：判断数字
‘322‘.isdigit() # 结果是True
3，bytes
码位：每个字符占若干字节，python3（str），python2（unicode）
字节序列：每个字符占一个字节，python3（bytes），python2（str/bytes）
4，列表
4.1，list函数
功能一：用于将可迭代对象iterator转换为列表
功能二：实现浅拷贝
例如：
list(‘hello‘) # 结果是[‘h‘,‘e‘,‘l‘,‘l‘,‘o‘]
list(range(5)) # 结果是[1, 2, 3, 4, 5]
list({‘a‘: 1, ‘b‘: 2}) # 结果是[‘a‘, ‘b‘]，因为对字典迭代获取到的是key
4.2，list基本操作
1）增：lista.append(4)，就地添加返回None
2）删：删元素用del、remove、pop；删列表用del、clear
3）改：lista[2] = 2
4）插：lista.insert[3, ‘insert_value‘]，或者：lista[3:3] = [‘insert_value‘]
7）切片：访问切片：y=x[1:3]；插入序列x[1:1] = [2,3,4]；删除序列：x[1:4]=[]；替换序列：x[1:4]=[2,3,4]
8）extend追加：就地加lista.extend(listb)，等效于lista = lista + listb，或者lista[len(lista):] = listb
9）列表相加：lista + listb，原序列不会变
10）乘法：[1,2,3] * 2，结果为[1,2,3,1,2,3]，原序列不变
11）创建5个空序列：
lists = [[] for i in range(5)] # 5个不同的空序列 lists = [[]] * 5 # 5个id相同的空序列
12）reverse / reserved：反向存放，lista.reverse()就地反向无返回值，reversed(list)有返回值（原序列不变）
13）sort / sorted：排序，x.sort()就地排序无反向值，sorted(list)有返回值（原序列不变）
14）copy：浅拷贝，list.copy()
15）enumerate：遍历index和value
for i,v in enumerate(lista):
print(i, v) # i索引，v值
16）in，len，max，min，index，count：略
4.3，列表的拷贝
t = [1, [2, 3], (4, 5)]
起别名，连第一层都不拷贝：
a = t
浅拷贝：拷贝第一层：
b = list(t) b = t[:] b = t.copy() b = copy.copy()
深拷贝：拷贝所有层：
c = copy.deepcopy(t)
看看有什么区别：
t[0] = 0 t[1].append(0) t[2] += (0, )
输出结果：
t : [0, [2, 3, 0], (4, 5, 0)] a : [0, [2, 3, 0], (4, 5, 0)] # 别名，全跟着变 b : [1, [2, 3, 0], (4, 5)] # 浅拷贝，第一层以及第二层内的不可变序列不变，第二层的可变序列跟着变 c : [1, [2, 3], (4, 5)] # 深拷贝，全都不变
总结：
判断时可以用is或者id()，看下不同的变量名，是否指向同一引用对象
a和t的id完全相同，b/c和t的id不同
如果列表内部有“可变的引用对象”(例如字典、集合、列表，元组算不可变的引用对象)，t发生改变时，会影响到浅拷贝b，但不会影响到深拷贝c
5，元组
5.1，tupple函数
和list函数一样，将某个序列转换为tupple
5.2，元组基本操作
1）切片：只支持切片访问即查，不支持插，删，改
2）元组相加：tu1 + tu2，原序列不会变
3）乘法：(1,2,3) * 2，结果为(1,2,3,1,2,3)，原序列不变
4）in，len，max，min，index，count，enumerate：略
5.3，元组和列表的区别
列表不建议存放不同类型的东西，否则无法排序
元组经常用来存放不同类型的东西
5.4，具名元组
具有名字的元组
from collections import namedtuple TU = namedtuple(‘manincity‘, ‘name city‘) tu1 = TU(‘guxh‘, ‘shanghai‘) print(tu1) # manincity(name=‘guxh‘, city=‘shanghai‘)
6，字典
6.1，字典的创建
d = {‘a‘:1, ‘b‘:2, ‘c‘:3}
d = dict(a=1, b=2, c=3)
d = dict([(‘a‘,‘1‘), (‘b‘,2), (‘c‘,3)]) # 元组列表，列表列表都可以，只要是2个值的小序列组成的大序列，不用写字典推导了!!!
################################待修订######################
6.2，字典的方法
1）增和改：d[‘d‘] = 4，有改/无增
2）d.update(d2)，用字典d2区更新d，有改/无增
3）删除
d.pop(‘d‘) # 删除key-values键值对
del d[‘a‘] # 删除key-values键值对
popitem() # 删最后一个，由于字典是无序的所以实际上是随机删一个
清空整个列表：
清除字典，无返回值（即返回None）
d = {}
d[‘name‘] = ‘gumby‘
d.clear()
直接赋空值也可以清
d = {}
d[‘name‘] = ‘gumby‘
d = {}
但关联了其他字典请不掉：
d = {}
d[‘name‘] = ‘gumby‘
y = d
d = {} /如果用这个方法，虽然d清掉了，但是y请不掉
d.clear() /d和y都清掉了
4）查
‘dd‘ in dict1 # 判断是否含有键为K的项，list中是判断的是值
len(dict1) # 返回键值对数量
dict1[‘dd‘] # 返回关联键K的value，如果不存在会报错KeyError
dict1.get(‘dd‘) # 有就返回value，没有则返回默认值None（可以修改），比上面直接写key好
get的使用举例：
统计某列出现的项目（key），以及该项目出现的次数（values）
所有key即是该列去重后的项
以df的A列为例：
list=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘a‘,‘a‘,‘b‘,‘e‘,‘f‘]
dic={}
for element in list:
if dic.get(element,0)==0 :
dic[element]=1 #如果没有该key，则创建列表并赋值1
else:
dic[element]=dic[element]+1 #如果有该key，则该key的值加1
备注：
len(dic) #dic字典的个数，相当于excel中的dic.count
key=dictall.keys() #字典的所有key列表
item=dictall.values() #字典的所有项列表
用dic获取维护单位列表：
dic={ u‘东区分公司‘:u‘浦东‘,
u‘南区分公司‘:u‘南区‘,
u‘西区分公司‘:u‘西区‘,
u‘北区分公司‘:u‘北区‘,
}
for i in xx:
list.append(dic.get(i,None))
5）copy
d2 = d1.copy()
是浅拷贝，替换值时原始字典不受影响，但是修改值是原始字典也会改变。
深拷贝的方法：
d2 = d1.deepcopy() /需要from copy import deepcopy
6）fromkeys
从给定的key创建新字典，可以指定values，默认为None
d1 = dict.fromkeys([‘east‘, ‘west‘], 20) # dict可以改成任何已经存在的字典，但是结果和该字典无任何关系
输出结果：
{‘west‘: 20, ‘east‘: 20}
如果创建了嵌套字典，相当于潜copy，改一个会全跟着改
7）has_key
检查字典中是否有key
d.has_key(‘south‘) /有返回True，无返回False
8）items/iteritems, keys/iterkeys, values/itervalues
d1 = {‘west‘: 10, ‘east‘: 20, ‘south‘:30, ‘north‘:40}
print d1.items() /[(‘west‘, 10), (‘east‘, 20), (‘north‘, 40), (‘south‘, 30)]，即字典转列表
print d1.keys() /[‘west‘, ‘east‘, ‘north‘, ‘south‘]
print d1.values() /[10, 20, 40, 30]
iteritems/iterkeys/itervalues返回迭代对象，用迭代时可以用它们。
5，字典的循环
for i in dict1:
print(i, dict1[i]) # i是key，dict1[i]是value
备注：对dict1循环打印的是key，for i in dict1和for i in dict1.keys()，效果是一样的
for k,v in dict1.items()：
print(k, v)
两种方法打印结果一样，但是后面一种效率低，因为有个中间转换至列表的过程
备注：series也能向字典那样遍历，for index,value in series.items()
3，字典的格式化字符串
phonebook = {‘cecil‘ : 56845 }
"cecil‘s phone number is %(cecil)s." % phonebook
输出：cecil‘s phone number is 56845.
6，字典应用举例
6.1，字典遍历有值追加，无值建[]
方法一：用if
if key not in dict:
dict[key] = []
dict[key]append(new_value)
方法二：用get
temp = index.get(key, [])
temp.append(new_value)
index[key] = temp
方法三：用setdefault
dict.setdefault(key, [])
dict[key].append(new_value)
可以进一步合并为一句：强烈推荐，只需一次查找，效率高
dict.setdefault(key,[]).append(new_value)
7，根据value找到key
方法一：list
dicxx = {‘a‘:‘001‘, ‘b‘:‘002‘}
list(dicxx.keys())[list(dicxx.values()).index("001")]
方法二：反向做字典
dicxx = {‘a‘:‘001‘, ‘b‘:‘002‘}
new_dict = {v:k for k,v in dicxx.items()}
new_dict[‘001‘]
8，setdefault
defaultdict
1，集合
集合最重要的2个内容：去重（把列表变成集合就自动去重了）、关系测试（测试2组数据的交集、差集、并集）
去重
list1 = [1, 3, 5, 6, 7, 8, 1, 3, 5, 7, 2, 3]
list1 = set(list1) # {1, 2, 3, 5, 6, 7, 8} 集合也是无序的
list2 = {1, 3, 11, 22, 55, 78, 90, 90, 1, 3} # 实际结果是{1, 3, 11, 78, 22, 55, 90}
print(list1.intersection(list2)) # 取交集，结果是{1，3}
print(list1.union(list2)) # 取并集，结果是{1, 2, 3, 5, 6, 7, 8, 11, 78, 22, 55, 90}
print(list1.difference(list2)) # 取差集，结果是{2, 5, 6, 7, 8}，list1里有的，但是list2里没有的
print(list1.issubset(list2)) # 判断list1是否是list2的子集
print(list1.issuperset(list2)) # 判断list2是否是list1的父集
& 交集
| 并集
- 差集
^ 对称差集
如果集合是空集，必须写成set()
2，集合的增删改查
2.1，增
t.add(5) # 增加一项，注意增加是add，不是append
t.update(5，6，7) # 增加多项
2.2，删
t.remove(5) # 删除5，如果set中不存在5则会报错
t.discard(5) # 删除5，如果set中不存在5则不会报错
a = t.pop() # 随机删除一个值，并且把该值返回给a
2.3，查
len(t)
x in t
2.4，copy
浅复制
其他
数字（略）
布尔类型（略）
原文：https://www.cnblogs.com/guxh/p/10247390.html