1，基本概念
1.1，数据类型
基本数据类型：字符串，数字，布尔等
引用数据类型：相对不可变（元组），可变（列表，字典，集合等）
基本数据类型存放实际值，引用数据类型存放对象的地址（即引用）
==：判断值是否相等
is：判断id是否相等，即内存地址，id()可以返回内存地址
1.2，序列类型
容器类型：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')，接受多个参数时必须用元组name.endswith(('.c', '.h'))
5）strip/lstrip/rstrip：去除两边/左边/右边的空格字符串，也可以传参指定去除的内容
6）join：合项
','.join(['a', 'b', 'c']) # 结果是a,b,c
7）split：裂项，不传参就对空格、制表、换行进行分割
'a b c'.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(t)
深拷贝：拷贝所有层：
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() # 删最后一个，由于字典是无序的所以实际上是随机删一个
4）清空字典
y = d
d.clear() # 无返回值，d和y都能清掉
d = {} # 直接赋空值也可以清，只能清d
5）查
'a' in d # 判断是否含有键为K的项，list中是判断的是值
d['a'] # 返回关联键K的value，如果不存在会报错KeyError
d.get('a', 123) # 有就返回value，没有则返回缺省值123
6）copy
d2 = d1.copy() # 是浅拷贝，替换值时原始字典不受影响，但是修改值是原始字典也会改变。 d2 = d1.deepcopy() # 深拷贝
7）fromkeys
从给定的key创建新字典，可以指定values，默认为None
d = dict.fromkeys(['east', 'west'], 20) # dict可以改成任何已经存在的字典，但是结果和该字典无任何关系
print(d) # {'west': 20, 'east': 20}
8）has_key：检测是否有key
9）items/iteritems, keys/iterkeys, values/itervalues：返回值/迭代对象
d = {'west': 10, 'east': 20, 'south':30, 'north':40}
print d.items() # [('west', 10), ('east', 20), ('north', 40), ('south', 30)]，即字典转列表
print d.keys() # ['west', 'east', 'north', 'south']
print d.values() # [10, 20, 40, 30]
直接对字典进行循环获取的是keys
10）len：略
6.3，字典应用-统计单词出现的位置
sentence = """I'm a big big girl
in a big big world
It's not a big big thing if you leave me
but I do do feel
that I too too will miss you much"""
sentence = sentence.split()
d = {}
方法一：
for index, word in enumerate(sentence): if word not in d: d[word] = [] d[word].append(index)
方法二：get
for index, word in enumerate(sentence): temp = d.get(word, []) temp.append(index) d[word] = temp
方法三：setdefault
for index, word in enumerate(sentence): d.setdefault(word, []) d[word].append(index)
方法三（合一句）：setdefault
for index, word in enumerate(sentence): d.setdefault(word, []).append(index)
方法四：defaultdict
from collections import defaultdict d = defaultdict(list) for index, word in enumerate(sentence): d[word].append(index)
6.4，其他
1）字符串格式化时可以使用字典
phonebook = {'cecil' : 56845 }
"cecil's phone number is %(cecil)s." % phonebook
2）根据values求最小值，最大值，排序
d = {'a': 10, 'b':6, 'c': 5, 'd':17, 'e':12}
方法一：zip
min(zip(d.values(), d.keys())) # (5, 'c') max(zip(d.values(), d.keys())) # (17, 'd') sorted(zip(d.values(), d.keys())) # [(5, 'c'), (6, 'b'), (10, 'a'), (12, 'e'), (17, 'd')]
方法二：lambda
d[min(d, key=lambda k: d[k])] # 5 d[max(d, key=lambda k: d[k])] # 17 [d[i] for i in sorted(d, key=lambda k: d[k])] # [5, 6, 10, 12, 17]
3）对字典使用集合的操作：字典的keys()和items()支持集合操作，但values()不支持
d1 = {'a': 1, 'b': 2, 'c': 3}
d2 = {'b': 4, 'c': 3, 'd': 6}
d1.keys() & d2.keys() # {'b', 'c'}
d1.keys() - d2.keys() # {'d'}
d1.items() & d2.items() # {('c', 3)}
{key: d1[key] for key in d1.keys() - {'c'}} # {'b': 2, 'a': 1}
7，集合
集合最重要的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()，写成{}是字典
7.1，集合运算的符号
& 交集
| 并集
- 差集
^ 对称差集
7.2，集合操作
1）增
t.add(5) # 增加一项，注意增加是add，不是append t.update(5，6，7) # 增加多项
2）删
t.remove(5) # 删除5，如果set中不存在5则会报错 t.discard(5) # 删除5，如果set中不存在5则不会报错 a = t.pop() # 随机删除一个值，并且把该值返回给a
3）len，in，copy：略
7.3，集合去重
a = [1, 3, 5, 1, 7, 3, 9, 2, 6, 1, 3]
去重：
set(a) # {1, 2, 3, 5, 6, 7, 9}
去重保持顺序不变，序列中的元素可hash：
def dedupe(items):
seen = set()
for item in items:
if item not in seen:
yield item # 不用generator的话，还要在新建个列表，然后用该列表append并返回值
seen.add(item)
list(dedupe(a)) # [1, 3, 5, 7, 9, 2, 6]
去重保持顺序不变 ，序列中的元素不可hash，要先想办法转成可哈希（待补充）
8，其他类型
数字（略）
布尔类型（略）
9，数据运算
9.1，运算符
+，-， *， /：加减乘除
%：取模
**：次方，即幂
//：整除，返回商的整数部分
9.2，比较运算
==：等于
!= : 不等于
<>：不等于
>：大于
<：小于
>=：大于等于
<=：小于等于
9.3，赋值运算
=：等于
+=：A+=B即A=A+B，下同
-=：
*=：
/=：
%=：
**=：
//=：
9.4，逻辑运算
and
or
not
and或者or可以连接多个，例如 a and b and c，还可以加or，例如a and b and c or d，即(a and b and c) or d
9.5，成员运算
in：判断值是否在序列中
not in：判断值是否在序列中
9.6，身份运算
is：id是否一样，类型是否是XXX等等，例如type(a) is list
is not
9.7，位运算
&：与
|：或
^：异或
~：反
<<：左移动
>>：右移动
9.8，三元运算
result = value1 if condition else value2
9.9，boolean表达式
result = a or b # 如果a是真result=a，如果a是假result=b
备注：写boolean可能会代码难以阅读，建议使用三元运算，或者辅助函数
10，操作数据
10.1，各类推导式
列表推导：
[i for i in range(10) if i > 5]
生成器表达式：
(i for i in range(10) if i > 5)
集合推导：
{i for i in range(10) if i > 5}
字典推导：
prices = {'ACME': 31, 'AAPL': 26, 'IBM': 29, 'HPQ': 35, 'FB': 33}
items = ('ACME', 'IBM', 'FB')
{key: value for key, value in prices.items() if value > 30} # {'ACME': 31, 'HPQ': 35, 'FB': 33}
{key: value for key, value in prices.items() if key in items} # {'ACME': 31, 'IBM': 29, 'FB': 33}
# 另一种形式：
dict((key, value) for key, value in prices.items() if value > 30) # {'ACME': 31, 'HPQ': 35, 'FB': 33}
注意：没有元组推导
11，切片
11.1，切片原理
“[]”运算符是交给__getitem__和__setitem处理的（详见guxh的python笔记：类的属性）
class Seq:
def __init__(self, components):
self.components = components
def __getitem__(self, index):
return self.components[index]
s = Seq([1, 2, 3, 4, 5, 6])
print(s[0]) # 1
print(s[0:3]) # [1, 2, 3]
对s[0]，s[0:3]的取值委托给了self.components[index]处理，看看self.components拿到的index到底是什么？
class Seq:
def __getitem__(self, index):
return index
s = Seq()
print(s[0]) # 0
print(s[0:3]) # slice(0, 3, None)
print(type(s[0:3])) # <class 'slice'>
print(dir(s[0:3])) # 有'indices', 'start', 'step', 'stop'这些方法
S.indices(len) —> (start, stop, stride)
给定长度为len的序列，计算start，stop，stride，超出边界的索引被截掉。
11.2，切片技巧
序列反转：
>>> s = [1, 2, 3, 4] >>> s[::-1] [4, 3, 2, 1]