LearnDevOps
  • Home
  • About Me
  • Categories
  • Tags
  • Archives

python-training

Contents

  • re模块
    • re的方法
    • re语法介绍:
  • 递归
  • 装饰器
    • 简单装饰器
    • 传参装饰器
  • 迭代器 & 生成器
  • 生成器generator
  • 队列
    • 单向队列
      • Queue.Queue()先进先出
      • Queue.LifoQueue 后进先出 先进后出
      • 在python3中模块名有变化,
    • 双向队列
  • collections 系列练习
    • Counter
  • set()
    • 1.set.add
    • 2.set.clear
    • 3.set.copy
    • 4.set.difference
    • 5.set.difference_update
    • 6.set.discard
    • 7.set.intersection 两个集合的交集
    • 8.set.intersection_update
    • 集合练习
  • 函数练习
    • 1.无参数
    • 2.有参数
    • 3.默认参数
    • 4.指定参数
    • 5.动态参数
  • dict() 方法练习
    • 1.dict.clear
    • 2.dict.copy
    • 3.dict.fromkeys
    • 4.dict.get
    • 5.dict.items
    • 6.dict.keys
    • 7.dict.pop
    • 8.dict.popitem
    • 9.dict.setdefau
    • 10.dict.update
    • 11.dict.values
  • list()
    • 1.list.append
    • 2.list.clear
    • 3.list.copy
    • 4.list.count
    • 5.list.extend
    • 6.list.index
    • 7.list.insert
    • 8.list.pop
    • 9.list.remove
    • 10.list.reverse
    • 11.list.sort
  • tuple()
    • 1.tuple.count
    • 2.tuple.index
  • str()的方法
    • 1.str.capitalize
    • 2.str.casefold
    • 3.str.center
    • 4.str.count
    • 5.str.encode
    • 6.str.endswith
    • 7.str.expandtabs
    • 8.str.find
    • 9.str.format
    • 10.str.format_map
    • 11.str.index
    • 12.str.isalnum
    • 13.str.isalpha
    • 14.str.isdecimal
    • 15.str.isdigit
    • 16.str.isidentifier
    • 17.str.islower
    • 18.str.isnumeric
    • 19.str.isprintable
    • 20.str.isspace
    • 21.str.istitle
    • 22.str.isupper
    • 23.str.join
    • 26.str.lstrip
    • 27. str.translate / str.maketrans
    • 28.str.partition
    • 29.str.replace
    • 36.str.split
    • 37.str.splitlines
    • 38.str.startswith
    • 39.str.strip
    • 40.str.swapcase
    • 41.str.title
    • 43.str.upper
    • 44.str.zfill
  • builtins Python内置函数

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个要求:

  1. 每次递归在规模上都要减少(通常减半)
  2. 前一次递归的结果为后一次递归的输入
  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     #得到属性信息

Published

1月 11, 2016

Category

python

Tags

  • python 7
  • python基础 4
  • Powered by Pelican. Theme: Elegant by Talha Mansoor