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 \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(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]