re模块
re的方法
re.match() #从str的起始位置匹配模式,匹配不成功返回none,使用s.group() or s.groups()获取返回内容。 re.search() #扫描字符串,找到这个 RE 匹配的位置 re.findall() #找到 RE 匹配的所有子串,并把它们作为一个列表返回 re.finditer() #找到 RE 匹配的所有子串,并把它们作为一个迭代器返回
re语法介绍:
# 正则语法 re.match(pattern, string, flags=0) pattern '匹配的正则表达式' string '要匹配的字符串' flags '标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等' # 返回匹配对象 group(num=0) #匹配的整个表达式的字符串, group() #可以一次输入多个组号,在这种情况下它将返回一个包含那些组所对应值的元组。 groups() #返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。
例子:
In [1]: import re In [2]: s = 'abc,234,dwd,dwd' In [3]: m = re.match('abc',s,2) In [7]: m.group() Out[7]: 'abc'
递归
递归简单来讲就是定义一个函数,自己调用自己。 递归的特点: 1. 在过程中调用自己 2. 必须有一个结束条件,称为递归出口 3. 递归每一层系统会为返回的所有内容开辟栈来存储,多次递归易造成栈溢出等, 4. 运行效率低,但简洁。
使用递归的3个要求:
- 每次递归在规模上都要减少(通常减半)
- 前一次递归的结果为后一次递归的输入
- 有递归结束条件,否则就成为死循环。
例子: 做一个除法计算,返回每次的计算结果
def clac(n): print(n) if n/2 > 1: res = clac(n/2) #print('res',res) #res接受returen的返回值 print('N',n) #每退出一层n跟随每层的变化 return n #return返回给res clac(10)
例子:通过二分查找来观察递归
装饰器
有这样一个场景,公司内部的运维基础服务最初设计是完全开放的,任何人只要调用即可。而内容逐渐完善后需要增加用户登录验证功能。各部门要改调用接口是比较麻烦的,要自己修改基础代码也是比较麻烦,并且有很多重复的代码,装饰器就是解决这类的问题。
简单装饰器
代码例子: #注释了执行步骤
def login(arg1): #1.python由上往下解释代码;4进入函数(sqlAPI被arg1传入) def outer(arg): #5.进入函数内部;7进入函数arg带入sqlAPI函数的参数 print('outer') #8.执行函数内部代码块 arg1(arg) #9.执行sqlAPI函数 return outer #6.直接把函数return回去 def home(name): #2.遇到函数做标记 print('Welcome [%s] to home page'%name) @login #3.遇到@符装饰器 回到装饰器 def sqlAPI(name): print('Welcome [%s] to sqlApi'%name) #10.跳过函数头直接执行函数内部代码块 sqlAPI('Peter') #6调用函数
传参装饰器
装饰器可以传递任何类型和数量的参数,包括函数在内也可以被传递。
def login(user,password): def outer(sqlAPI): def wrapper(name): #执行主体函数和处理装饰器传递的参数 print('username: [%s], password: [%s]'%(user,password)) sqlAPI(name) return wrapper return outer @login('afei','123') #可以传递任意数量和形式的参数包括函数也可以被传递 def sqlAPI(name): print('Welcome [%s] to sqlApi'%name) sqlAPI('peter')
迭代器 & 生成器
迭代器
迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。 迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素,而在这之前或之后,元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合,比如几个G的文件,或是斐波那契数列等等。
In [1]: names = iter(['Peter','Alex','Jack']) #使用工厂函数iter生成一个迭代器 In [2]: names.__next__() #python2.7中是names.next()方法 Out[2]: 'Peter' In [3]: names.__next__() Out[3]: 'Alex' In [4]: names.__next__() Out[4]: 'Jack' In [5]: names.__next__() #迭代器为空时抛出StopIteration:异常 --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-5-317938fc3664> in <module>() ----> 1 names.__next__() StopIteration:
python中迭代器是非常常用的一个方式,python专门为for关键字做了迭代器的语法糖。在for循环中,Python将自动调用工厂函数iter()获得迭代器,自动调用next()获取元素,还完成了检查StopIteration异常的工作。比如常用的文件读取:
f = open('test.log','r') for i in f: print(i) ------ In [6]: l = (1, 2, 3, 4) In [7]: for i in l: ...: print(i) ...: 1 2 3 4
生成器generator
想象一个场景,需要生成一个1百万个元素的列表。直接创建列表会消耗很大的内存空间。如果我们只需要访问列表中间的几个元素那整个列表空间资源就浪费了。 python中提供了生成器generator来解决这个问题,只要是列表中的元素是能推算出来的,那就可以使用生成器,访问的时候通过迭代方式,就可以轻松的访问到我们所需的内容。看起来生成器是一边循环一边计算循环对象值。
创建一个生成器
In [1]: import time In [3]: def con(arg): print('准备生产杯子啦') while True: arg = yield print('生产了 [%s] 个杯子,被[%s]个人买走了'%(arg1,arg2)] In [4]: def producer(arg1,arg2): ...: c = con(arg1) ...: c2 = con(arg2) ...: c.__next__() ...: c2.__next__() ...: print('开始生产杯子啦') ...: for i in range(10): ...: time.sleep(1) ...: print('生产了 [%s] 个杯子'%i) ...: c.send(i) ...: c2.send(i) ...: In [5]: producer('xxx','aaa') 准备生产杯子啦 开始生产杯子啦 生产了 [0] 个杯子 生产了 [xxx] 个杯子,被[0]个人买走了 生产了 [aaa] 个杯子,被[0]个人买走了 生产了 [1] 个杯子 生产了 [xxx] 个杯子,被[1]个人买走了 生产了 [aaa] 个杯子,被[1]个人买走了 生产了 [2] 个杯子 生产了 [xxx] 个杯子,被[2]个人买走了 生产了 [aaa] 个杯子,被[2]个人买走了 生产了 [3] 个杯子 生产了 [xxx] 个杯子,被[3]个人买走了 生产了 [aaa] 个杯子,被[3]个人买走了
In [7]: def cas(mo): while mo >0: mo -= 10 yield 10 print('--------' ...: ...: ...: ...: ) ...: In [8]: a = cas(50) In [9]: for i in a: ...: print(9) ...: 9 -------- 9 -------- 9 -------- 9 -------- 9 --------
yield 理解: 函数中 return 是返回并退出函数,而yield是返回并中断函数,当再次执行函数时继续从中断的位置往下执行。
队列
Python中,队列是线程间最常用的交换数据的形式。python中队列区分单向队列和双向队列。单向队列在python2中模块是 import Queue
,在python3中是import queue
单向队列
python2中演示:
Queue.Queue()先进先出
# 创建一个队列,指定长度为2,长度小于0为不限制长度 >>> import Queue >>> s = Queue.Queue(maxsize = 2) >>>
s.put() 将值放入队列中
- put()方法将值插入到队尾,
-
put()方法有3个参数,item,block=True,timeout=None
-
item是必须的,为插入项目的值,
-
block是可选的,值为False,当队列满了之后引发Full异常,值为True时,将一直等待队列空出一个单元数据(貌似默认值就是True)
-
timeout 可选, 等待时间,当不指定时间时,队列满了程序会一直等待队列空出一个数据单元,当指定timeout超时时间时,在指定时间内队列没有空出一个数据单元将引发Full异常。
>>> s.put(1,block=False) >>> s.put(2,block=False) >>> s.put(3,block=False) Traceback (most recent call last): File "<input>", line 1, in <module> File "/usr/lib/python2.7/Queue.py", line 123, in put raise Full Full >>> >>> s.put(1,block=True) >>> s.put(2,block=True) >>> s.put(3,block=True) >>> s.put(1,timeout=2) >>> s.put(2,timeout=2) >>> s.put(3,timeout=2) Traceback (most recent call last): File "<input>", line 1, in <module> File "/usr/lib/python2.7/Queue.py", line 134, in put raise Full Full >>>
s.get() 将值从队列中取出
- get()方法重队列头删除并返回一个数据单元,参数可选block,timeout
- block参数值为True和False,当队列为空时,参数True会一直等待直到有数据单元返回,参数False会直接引发Empty异常。
- timeout指定等待时间
>>> s.get() 1 >>> s.get() 2 >>> s.get(block=False) Traceback (most recent call last): File "<input>", line 1, in <module> File "/usr/lib/python2.7/Queue.py", line 165, in get raise Empty Empty >>> s.get(timeout=2) Traceback (most recent call last): File "<input>", line 1, in <module> File "/usr/lib/python2.7/Queue.py", line 176, in get raise Empty Empty >>>
s.qsize() 返回队列的大小
>>> s.qsize() 0
s.empty() 队列为空时返回True
>>> s.empty() True
s.full()队列满时返回True
>>> s.full() False
Queue.LifoQueue 后进先出 先进后出
>>> s2 = Queue.LifoQueue(maxsize=2) >>> s2.put(1) >>> s2.put(2) >>> s2.put(3,block=False) Traceback (most recent call last): File "<input>", line 1, in <module> File "/usr/lib/python2.7/Queue.py", line 123, in put raise Full Full #注意取值和存值的顺序 >>> s2.get() 2 >>> s2.get() 1 >>> #再观察先进先出的取值和存值 >>> s = Queue.Queue(maxsize=2) >>> s.put(1) >>> s.put(2) >>> s2 = Queue.LifoQueue(maxsize=2) >>> s2.put(1) >>> s2.put(2) >>> s.get() 1 >>> s.get() 2 >>> s2.get() 2 >>> s2.get() 1 >>>
python3
在python3中模块名有变化,
In [1]: import queue In [2]: s = queue.Queue(maxsize=2) In [3]: s. s.all_tasks_done s.get_nowait s.not_empty s.qsize s.empty s.join s.not_full s.queue s.full s.maxsize s.put s.task_done s.get s.mutex s.put_nowait s.unfinished_tasks In [3]: s.put(1) In [4]: s.put(2) In [5]: s.put(3,block=False) --------------------------------------------------------------------------- Full Traceback (most recent call last) <ipython-input-5-8ebc2086f968> in <module>() ----> 1 s.put(3,block=False) /usr/lib/python3.4/queue.py in put(self, item, block, timeout) 131 if not block: 132 if self._qsize() >= self.maxsize: --> 133 raise Full 134 elif timeout is None: 135 while self._qsize() >= self.maxsize: Full:
双向队列
python3中 deque在collections中 deque,全名double-ended queue)是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出,其限定插入和删除操作在表的两端进行
>>> a = collections.deque([]) #创建空列表 >>> a.append(1) #从后添加 >>> a deque([1]) >>> a.append(2) >>> a.append('a') >>> a deque([1, 2, 'a']) >>> a.appendleft('b') #从头添加 >>> a deque(['b', 1, 2, 'a']) >>> >>> a.pop() #从后取 'a' >>> a deque(['b', 1, 2]) >>> a.popleft() #从前取 'b' >>> a deque([1, 2]) >>> >>> a.remove(2) #删除指定元素 >>> a deque([1]) >>> >>> a.extend(['b', 1, 2, 'a']) #从前扩展队列 >>> a deque([1, 'b', 1, 2, 'a']) >>> a.extendleft(['d', 1, 2, 'd']) #从后扩展队列 >>> a deque(['d', 2, 1, 'd', 1, 'b', 1, 2, 'a']) >>> >>> a.reverse() #反转队列 >>> a deque(['a', 2, 1, 'b', 1, 'd', 1, 2, 'd']) >>> a.clear() #清空队列 a.count(n) #在队列中统计元素的个数,n表示统计的元素 a.rotate(n) #旋转队列,默认时值为1,由右边开始旋转,负值代表左边旋转,n代表从队列的第一个元素开始,n从1开始计数
collections 系列练习
Counter
set()
集合练习
1.set.add
# 2.set.clear #添加元素 In [51]: s = set([1,2,3,4,'s']) In [52]: s.add('d') In [53]: s Out[53]: {1, 2, 3, 4, 's', 'd'}
2.set.clear
# 2.set.clear #从set中移除所有元素 In [54]: s.clear() In [55]: s Out[55]: set()
3.set.copy
#3.set.copy #返回set的浅拷贝
4.set.difference
#4.set.difference #返回由两个或多个set中不同的元素(差集)组成一个新set In [56]: s1 = set([1,2,3,4,5,6]) In [57]: s2 = set(['a','b','c','d']) In [58]: s1.dif s1.difference s1.difference_update In [60]: s3 = s1.difference(s2) In [61]: s3 Out[61]: {1, 2, 3, 4, 5, 6} In [63]: s2 Out[63]: {'a', 'b', 'c', 'd'} # 上面s1里面的元素在s2中没有,所以s3得到的元素为s1本身 In [64]: s4 = s2.difference(s1) In [65]: s4 Out[65]: {'a', 'b', 'c', 'd'} # s4 用s2得到和s3相反的结果
5.set.difference_update
#5.set.difference_update #从当前set中移除其它set中所有所有元素。 In [66]: s4.difference_update(s1) In [67]: s4 Out[67]: {'a', 'b', 'c', 'd'} In [68]: s4.difference_update(s2) In [69]: s4 Out[69]: set()
6.set.discard
#6.set.discard #从set中删除一个元素,如果set中存在该元素 In [70]: s3 Out[70]: {1, 2, 3, 4, 5, 6} In [71]: s3.discard('a') In [72]: s3 Out[72]: {1, 2, 3, 4, 5, 6} In [73]: s3.discard(4) In [74]: s3 Out[74]: {1, 2, 3, 5, 6}
7.set.intersection 两个集合的交集
#7.set.intersection #返回两个或多个set的交集,即两个或多个set中都存在的元素 In [91]: s1 Out[91]: {1, 2, 3, 4, 5, 6, 'b', 'a'} In [92]: s2 Out[92]: {'a', 'b', 'c', 'd'} In [94]: s3 = s1.intersection(s2) In [95]: s3 Out[95]: {'a', 'b'}
8.set.intersection_update
#8.set.intersection_update #更新当前set,只保留那些在当前set和其他set中都存在的 In [106]: s1 Out[106]: {1, 2, 3, 4, 5, 6, 'b', 'a'} In [107]: s2 Out[107]: {'a', 'b', 'c', 'd'} In [108]: s1.intersection_update(s2) In [109]: s1 Out[109]: {'a', 'b'}
9.set.isdisjoint
#9.set.isdisjoint #如果两个set没有交集,返回true In [111]: s1 Out[111]: {'a', 'b'} In [112]: s2 Out[112]: {'a', 'b', 'c', 'd'} In [113]: s2.isdisjoint(s1) Out[113]: False --------- In [115]: s2 Out[115]: {'a', 'b', 'c', 'd'} In [116]: s3 Out[116]: {1, 2, 3, 4, 5} In [117]: s3.isdisjoint(s2) Out[117]: True
10.set.issubset #判断是否另外一个set包含当前set。 In [118]: s2 Out[118]: {'a', 'b', 'c', 'd'} In [119]: s3 Out[119]: {1, 2, 3, 4, 5} In [120]: s2.issu s2.issubset s2.issuperset In [120]: s2.issubset(s3) Out[120]: False -------- In [125]: s2 Out[125]: {'a', 'b', 'c', 'd'} In [126]: s4 Out[126]: {'a', 'b'} In [127]: s4.issubset(s2) Out[127]: True In [128]: s2.issubset(s4) Out[128]: False
集合练习
下面是一个集合的小练习
def trset(): ''' -- set --- set练习 将下面两个字典的key来用set来做比较,找出交集,差集, 1. 要删除 # new里面没有old里面有的删除 2. 要更新 # new里面没有old里面有的增加 3. 要添加 # new 和old都有的更新 ''' old_dict = { "#1":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 80 }, "#2":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 80 }, "#3":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 80 }, } new_dict = { "#1":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 800 }, "#3":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 80 }, "#4":{ 'hostname':"c2", 'cpu_count': 2, 'mem_capicity': 80 }, } old = set(old_dict.keys()) new = set(new_dict.keys()) update_set = old.intersection(new) delete_set = old.difference(new) add_set = new.difference(old) print('update:',update_set) print('delte:',delete_set) print('add:',add_set)
函数练习
python函数根据参数来区分可以分为5种形式:
1.无参数
In [1]: def show(): ...: print('a') ...: In [2]: show() a
2.有参数
1个参数
In [3]: def show(arg): ...: print(arg) ...: In [4]: show('hello') hello
2个参数
In [5]: def show(arg0,arg1): ...: print(arg0,arg1) ...: In [6]: show('hello','world') hello world
3.默认参数
In [7]: def show(arg,arg0='88'): ...: # 默认的参数必须放在最后 ...: print(arg,arg0) ...: In [8]: show('dd') dd 88 In [9]: show('dd','aa') dd aa
4.指定参数
In [10]: def show(arg,arg0,arg1): ....: print(arg,arg0,arg1) ....: In [11]: show('a','b','c') a b c In [12]: show(arg1='a',arg0='b',arg='c') c b a
5.动态参数
参数转换为元组
In [29]: def show(*arg): #参数转换为元组 ....: print(arg,type(arg)) ....: In [30]: show('a') ('a',) <class 'tuple'> In [31]: show(1,23,4,'sdf') (1, 23, 4, 'sdf') <class 'tuple'>
参数转换为字典
In [37]: def show(**arg): #参数转换为字典 pass print(arg,type(arg)) ....: In [38]: show(a='v') {'a': 'v'} <class 'dict'> In [39]: show(a='v',k1='v1',k2='v2') {'a': 'v', 'k1': 'v1', 'k2': 'v2'} <class 'dict'>
同时转换为tuple和dict
#传参形式1 In [45]: def show(*args,**kwargs): pass print(args,type(args)) print(kwargs,type(kwargs)) ....: In [46]: show(2,3,4,5,'a','d',k1='v1',k2='v2') (2, 3, 4, 5, 'a', 'd') <class 'tuple'> {'k1': 'v1', 'k2': 'v2'} <class 'dict'> 传参形式2 In [47]: li = [2,3,4,5,'a'] In [48]: d = {'k1':'v1','k2':'v2'} In [49]: In [49]: show(li,d) ([2, 3, 4, 5, 'a'], {'k1': 'v1', 'k2': 'v2'}) <class 'tuple'> {} <class 'dict'> #传参形式3 In [50]: show(*li,**d) (2, 3, 4, 5, 'a') <class 'tuple'> {'k1': 'v1', 'k2': 'v2'} <class 'dict'>
dict() 方法练习
1.dict.clear
dict.clear #删除dictionary中的所有key-value对 >>> a = {'k1':'v1'} >>> a {'k1': 'v1'} >>> a.clear()
2.dict.copy
dict.copy #浅拷贝dictionary >>> b = a.copy() >>> b {'k1': 'v1'}
3.dict.fromkeys
dict.fromkeys #返回一个新的dictionary,key由iterable的元素组成,value等于value >>> a = dict.fromkeys(['k1','k2','k3'],'vvv') >>> a {'k3': 'vvv', 'k2': 'vvv', 'k1': 'vvv'}
4.dict.get
dict.get #返回dictionary中key为指定值k对应的value, >>> a.get('k3') 'vvv' >>> b = {'k1':a} >>> b {'k1': {'k3': 'vvv', 'k2': 'vvv', 'k1': 'vvv'}} >>> b.get('k1')['k3'] 'vvv' >>>
5.dict.items
dict.items #返回dictionary所有key-value对组成的集合 >>> b.items() [('k1', {'k3': 'vvv', 'k2': 'vvv', 'k1': 'vvv'})]
6.dict.keys
dict.keys #返回dictionary所有key组成的集合 >>> b.keys() ['k1']
7.dict.pop
dict.pop #从dictionary中删除指定key,返回指定key对应的value。如果dictionary中不存在指定key,如果指定了d,返回d,否则抛出例外 >>> c = b.pop('k1') >>> c {'k3': 'vvv', 'k2': 'vvv', 'k1': 'vvv'} >>> b {} >>>
8.dict.popitem
dict.popitem #删除并返回key-value对(key, value)作为2-tuple,如果dictionary为空,抛出例外 >>> e = c.popitem() >>> e ('k3', 'vvv') >>> c {'k2': 'vvv', 'k1': 'vvv'} >>>
9.dict.setdefau
dict.setdefault #如果dictionary中不存在k,设置D[k]=d >>> c {'k2': 'vvv', 'k1': 'vvv'} >>> c.setdefault('k1','v1') 'vvv' >>> c {'k2': 'vvv', 'k1': 'vvv'} >>> c.setdefault('k4','v4') 'v4' >>> c {'k2': 'vvv', 'k1': 'vvv', 'k4': 'v4'} >>>
10.dict.update
dict.update #使用E(dict/iterable)和F的数据更新dicti >>> a = {'ak1':'av1'} >>> b = {'bk1':'bv1'} >>> b.update(a) >>> b {'ak1': 'av1', 'bk1': 'bv1'}
11.dict.values
dict.values #返回dictionary所有value组成的集合 >>> b.values() ['av1', 'bv1'] >>>
list()
列表练习
1.list.append
list.append #附加一个对象到list >>> a = ['a','b',1,3,4] >>> a ['a', 'b', 1, 3, 4] >>> a.append('d') >>> a ['a', 'b', 1, 3, 4, 'd']
2.list.clear
list.clear #删除list中的所有元素 >>> a.clear() >>> a []
3.list.copy
list.copy #浅拷贝list >>> a = ['a','b',1,3,4] >>> a ['a', 'b', 1, 3, 4] >>> b = a.copy() >>> b ['a', 'b', 1, 3, 4]
4.list.count
list.count #返回指定参数在list中出现的次数 >>> a.count('b') 1
5.list.extend
list.extend #附加指定iterable中的元素到list >>> b = [6,6,5,4,2,4] >>> a.extend(b) >>> a ['a', 'b', 1, 3, 4, 'd', 6, 6, 5, 4, 2, 4] >>>
6.list.index
list.index #返回指定值在list中第一次出现的位置,如果list上存在指 >>> a ['a', 'b', 1, 3, 4, 'd', 6, 6, 5, 4, 2, 4] >>> a.index(1) 2
7.list.insert
list.insert #在list的指定位置index插入object >>> a.insert(2,'sddsds') >>> a ['a', 'b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2, 4]
8.list.pop
list.pop #删除并返回指定位置index的元素,默认为最后位置,如果index超过范围或list为空,抛出错误 >>> a ['a', 'b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2, 4] >>> b = a.pop() >>> b 4 >>> a ['a', 'b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2] >>>
9.list.remove
list.remove #从list中删除第一次出现的指定值,如果指定值不存在,抛出例外 >>> a ['a', 'b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2] >>> a.remove('a') >>> a ['b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2]
10.list.reverse
list.reverse #反转list中的元素 >>> a ['b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2] >>> a.reverse() >>> a [2, 4, 5, 6, 6, 'd', 4, 3, 1, 'sddsds', 'b']
11.list.sort
list.sort #对list进行排序 >>> a [2, 4, 5, 6, 6, 'd', 4, 3, 1, 'sddsds', 'b'] >>> a.sort() >>> a [1, 2, 3, 4, 4, 5, 6, 6, 'b', 'd', 'sddsds'] >>>
tuple()
元组练习
1.tuple.count
tuple.count #返回指定参数在tuple中出现的次数 >>> b (1, 2, 3, 4, 4, 5, 6, 6, 'b', 'd', 'sddsds') >>> b.count(4) 2
2.tuple.index
tuple.index #返回指定值在tuple中第一次出现的位置,如果tuple中不 >>> b (1, 2, 3, 4, 4, 5, 6, 6, 'b', 'd', 'sddsds') >>> b.count(4) 2 >>> b.index(2) 1 >>> b.index(1) 0 >>>
str()的方法
字符串练习
1.str.capitalize
str.capitalize #返回首字母大写,其他字母小写的字符串 >>> a = 'peter' >>> a.capitalize() 'Peter' >>>
2.str.casefold
str.casefold #字符串转换成小写,用于不区分大小写的字符串比较 >>> a = 'peter' >>> b = a.capitalize() >>> b 'Peter' >>> b.casefold() 'peter'
3.str.center
str.center #返回指定长度的字符串,字符串内容居中,并使用指定字符填充 >>> b.center(40,'-') '-----------------Peter------------------'
4.str.count
str.count #返回子字符串在字符串中出现的次数 >>> b.count('a') 0 >>> b.count('e') 2 >>> b 'Peter'
5.str.encode
str.encode #对字符串进行编码,返回字节对象 >>> b.encode('gbk') b'Peter'
6.str.endswith
str.endswith #判断字符串是否以指定的后缀结尾 >>> b 'Peter' >>> b.endswith('r') True >>> b.endswith('d') False
7.str.expandtabs
str.expandtabs #使用空格替换tab >>> str.expandtabs('hello\tworld') 'hello world'
8.str.find
str.find #返回子字符串在字符串中第一次出现的位置;如没找到,返回-1 >>> c.find('wo') 8 >>> c 'hello world'
9.str.format
str.format #执行字符串格式化操作,替换字段使用{}分隔,替换字段可以是表 >>> str.format('hello {}','world') 'hello world'
10.str.format_map
str.format_map #执行字符串格式化操作,替换字段使用{}分隔,同str.for
11.str.index
str.index #同find(),但如果在字符串中没找到子字符串,会抛出错误 >>> a = 'peter' >>> a.index('e') 1 >>> a.index('a') Traceback (most recent call last): File "<input>", line 1, in <module> ValueError: substring not found
12.str.isalnum
12.str.isalnum #判断字符串中是否至少有一个字符,并且所有字符都是字母或数字 In [202]: a = 'asf23234d' In [203]: a.isalnum() Out[203]: True In [204]: b = 'asf' In [205]: b.isalnum() Out[205]: True In [206]: c = 'a*sf32' In [207]: c.isalnum() Out[207]: False In [208]: d = '' In [209]: d.isalnum() Out[209]: False
13.str.isalpha
13.str.isalpha #判断字符串中是否至少有一个字符,并且所有字符都是字母 In [194]: a Out[194]: '123' In [195]: a.isa a.isalnum a.isalpha In [195]: a.isalpha() Out[195]: False In [196]: b Out[196]: '1a' In [197]: b.isa b.isalnum b.isalpha In [197]: b.isalpha() Out[197]: False In [198]: c Out[198]: '' In [199]: c.isalpha() Out[199]: False In [200]: d = 'adsf' In [201]: d.isalpha() Out[201]: True
14.str.isdecimal
14.str.isdecimal #判断字符串中是否至少有一个字符,并且所有字符都是十进制数字 In [183]: a = '123' In [184]: b = '1a' In [185]: c = '' In [189]: e = '1.3' In [190]: a.isdecimal() Out[190]: True In [191]: b.isdecimal() Out[191]: False In [192]: c.isdecimal() Out[192]: False In [193]: e.isdecimal() Out[193]: False
15.str.isdigit
15.str.isdigit #判断字符串中是否至少有一个字符,并且所有字符都是数字 In [183]: a = '123' In [184]: b = '1a' In [185]: c = '' In [186]: a.isdigit() Out[186]: True In [187]: b.isdigit() Out[187]: False In [188]: c.isdigit() Out[188]: False
16.str.isidentifier
16.str.isidentifier #判断字符串中是否是有效标识符 In [172]: a Out[172]: 'peter' In [173]: b Out[173]: 'ASDF' In [174]: a Out[174]: 'peter' In [175]: b = '12' In [176]: c = '' In [178]: d = '*' In [179]: a.isidentifier() Out[179]: True In [180]: b.isidentifier() Out[180]: False In [181]: c.isidentifier() Out[181]: False In [182]: b.isidentifier() Out[182]: False
17.str.islower
17.str.islower #判断字符串中是否小字并且至少有一个字符 In [166]: a = 'peter' In [167]: b = 'ASDF' In [168]: c = '' In [169]: a.islower() Out[169]: True In [170]: b.islower() Out[170]: False In [171]: c.islower() Out[171]: False
18.str.isnumeric
18.str.isnumeric #判断字符串中是否至少有一个字符,并且所有字符都是数字字符 In [159]: a = '124' In [160]: b = 'as234' In [161]: c = '' In [162]: a.isnumeric() Out[162]: True In [163]: b.isnumeric() Out[163]: False In [164]: c.isnumeric() Out[164]: False
19.str.isprintable
19.str.isprintable #判断字符串的所有字符都是可打印字符或字符串为空 In [151]: a = "\tPuppy" In [152]: b = "PUPPY\a" In [153]: c = "puppy" In [154]: d = "a puppy\b" In [155]: a.isprintable() Out[155]: False In [156]: b.isprintable() Out[156]: False In [157]: c.isprintable() Out[157]: True In [158]: d.isprintable() Out[158]: False
20.str.isspace
20.str.isspace #判断字符串中是否至少有一个字符,并且所有字符都是空白字符 In [144]: t2 Out[144]: '' In [145]: t2.isspace() Out[145]: False In [146]: t3 = ' ' In [147]: t3.isspace() Out[147]: True In [149]: t Out[149]: 'peter is a student' In [150]: t.isspace() Out[150]: False
21.str.istitle
21.str.istitle #判断字符串中是否至少有一个字符,并且所有字符都是titlecase字符 In [135]: t = 'peter is a student' In [137]: t1 = t.title() In [138]: t.istitle() Out[138]: False In [139]: t1.istitle() Out[139]: True In [142]: t2 = '' In [143]: t2.istitle() Out[143]: False
22.str.isupper
22.str.isupper #判断字符串中是否全部是大写字母,空字符串为false In [124]: a = 'Peter' In [125]: a.isupper() Out[125]: False In [126]: a = 'PETER' In [127]: a.isupper() Out[127]: True In [128]: b = '' In [129]: b.isupper() Out[129]: False
23.str.join
23.str.join #使用字符串作为分隔符串连多个数据为一个字符串 In [116]: a Out[116]: 'peter' In [117]: e = ['a','b','c','d'] In [118]: ''.join(e) Out[118]: 'abcd' In [119]: '*'.join(e) Out[119]: 'a*b*c*d' In [120]: '*'.join(a) Out[120]: 'p*e*t*e*r' In [121]: ''.join(a) Out[121]: 'peter'
### 24.str.ljust
24.str.ljust #返回指定长度的字符串,字符串内容居左,并使用指定字符填充 In [88]: a.ljust(10,'-') Out[88]: 'peter-----' In [89]: a.ljust(1,'-') Out[89]: 'peter' In [90]: a.ljust(6,'0') Out[90]: 'peter0'
### 25.str.lower
25.str.lower #字符串转换成小写 In [81]: a = 'peter' In [82]: a.upper() Out[82]: 'PETER' In [83]: b = a.upper() In [84]: b Out[84]: 'PETER' In [85]: b.lower() Out[85]: 'peter'
26.str.lstrip
26.str.lstrip #去掉字符串前面的空格,或参数中的字符
27. str.translate / str.maketrans
str.translate #根据table表的映射关系,将字符串中的每个字符转换成另一个#返回一个转换表 In [32]: m = str.maketrans('e','b') In [33]: a.translate(m) Out[33]: 'pbtbr'
28.str.partition
28.str.partition #返回包含字符串中分隔符之前、分隔符、分隔符之后的子字符串的tuple #指定的分隔符,则返回一个3元的元组,第一个为分隔符左边的子串,第二个为分隔符本身,第三个为分隔符右边的子串 In [77]: g = 'www.google.com' In [79]: g.partition('.') Out[79]: ('www', '.', 'google.com') In [80]: g.partition('g') Out[80]: ('www.', 'g', 'oogle.com')
29.str.replace
29.str.replace #替换字符串中所有的子字符串old为新的字符串new >>> a.replace('e','A') 'pAtAr' >>>
30.str.rfind #返回子字符串在字符串中最后一次出现的位置;如没找到,返回-1 31.str.rindex #同rfind(),但如果在字符串中没找到子字符串,会抛出错误 32.str.rjust #返回指定长度的字符串,字符串内容居右,并使用指定字符填充 33.str.rpartition #从后往前查找,返回包含字符串中分隔符之前、分隔符、分隔符之后 34.str.rsplit #从后往前拆分字符串,返回一个列表 35.str.rstrip #去掉字符串后面的空格,或参数中的字符
36.str.split
36.str.split #拆分字符串,返回一个列表 In [58]: a = ' peter is a student ' In [59]: a.split() Out[59]: ['peter', 'is', 'a', 'student']
37.str.splitlines
37.str.splitlines #字符串以换行符为分隔符拆分,去掉换行符;如果keepends In [54]: a Out[54]: 'peter\n is \na student' In [55]: print(a) peter is a student In [56]: print(a.splitlines()) ['peter', ' is ', 'a student'] )
38.str.startswith
38.str.startswith #判断字符串是否以指定的前缀开始 In [47]: a Out[47]: ' peter is a student ' In [48]: a.startswith(' ') Out[48]: True In [49]: a.startswith('a') Out[49]: False
39.str.strip
39.str.strip #去掉字符串前后的空格,或指定的所有字符 In [41]: a = ' peter is a student ' In [42]: a Out[42]: ' peter is a student ' In [43]: a.strip() Out[43]: 'peter is a student'
40.str.swapcase
40.str.swapcase #大写字符转换成小写字符,小写字符转换成大写字符 In [38]: b = a.title() In [39]: b Out[39]: 'Peter Is A Student' In [40]: b.swapcase() Out[40]: 'pETER iS a sTUDENT'
41.str.title
41.str.title #每个单词的第一个字符转换成titlecase字符,其他字符转 In [34]: a = 'peter is a student' In [35]: a.title() Out[35]: 'Peter Is A Student'
43.str.upper
43.str.upper #字符串转换成大写 In [26]: a.upper() Out[26]: 'PETER'
44.str.zfill
44.str.zfill #在字符串的左边填充0,不会截断字符串 In [24]: a.zfill(10) Out[24]: '00000peter' In [25]: a.zfill(5) Out[25]: 'peter'
builtins Python内置函数
1.abs #求绝对值 2.all #判断迭代器中的所有数据是否都为true 3.any #判断迭代器中的是否有一个数据为true 4.bin #转换整数为一个二进制字符串 5.bool #转换一个数据为布尔值 6.bytearray #将数据转换为字节数组 7.bytes #将数据转换为字节数组 8.callable #判断一个对象是否可调用 9.chr #将整数转成字符 10.classmethod #得到function的classmethod 11.compile #编译source为code或AST对象 12.complex #创建一个复数 13.delattr #删除指定的属性 14.dict #创建一个字典dictionary 15.dir #返回对象的属性列表 16.divmod #得到两个数字相除的结果和余数 17.enumerate #得到一个枚举对象 18.eval #执行一个表达式 19.exec #动态执行Python代码 20.filter #过滤数据得到一个迭代器 21.float #将字符串或数字转为浮点数 22.format #格式化数据 23.frozenset #得到新的frozenset对象 24.getattr #得到对象属性的值 25.globals #得到当前模块的全局符号表的字典 26.hasattr #判断对象是否存在属性 27.hash #得到对象的哈希值 28.help #显示帮助信息 29.hex #整数转换为十六进制表示 30.id #得到对象的id 31.input #输出提示符,读取用户输入 32.int #将数字或字符串转为整数 33.isinstance #判断object是否是classinfo的实例 34.issubclass #判断一个类是否是另一个类的父类 35.iter #得到一个迭代器 36.len #返回对象的长度或集合的数据个数 37.list #创建一个列表 38.locals #得到当前符号表字典 39.map #更改迭代器中的每个数据得到一个新的迭代器 40.max #得到迭代器中最大的或两个或多个参数中最大的 41.min #得到迭代器中最小的或两个或多个参数中最小的 42.next #得到迭代器的下一个数据 43.object #得到object的实例 44.oct #整数转换为八进制表示 45.open #打开文件并返回一个流 46.ord #得到字符的整数表示 47.pow #乘方运算 48.print #输出数据到流 49.property #得到属性 50.range #创建一个范围对象 51.repr #得到对象的字符串表示 52.reversed #反转序列得到一个迭代器 53.round #浮点数按小数位数做舍入操作 54.set #创建一个集合对象 55.setattr #更改属性的值 56.slice #得到分片对象 57.sorted #排序可迭代的数据得到一个列表 58.staticmethod #得到function的staticmethod 59.str #得到对象的str版本 60.sum #计算可迭代数据的合计 61.tuple #创建一个元组 62.type #返回对象的类型或创建一个新的类型对象 63.vars #得到属性信息