Python语法_python语法书

1.切片

a = [1,2,3,4,5]
print(a[2:4])#表示从索引2开始取，到索引4为止，不包括索隐4，这里就,3,4，返回还是list，所以是[3,4]
print(a[-2:])#表示取最后两个
print(a[::2])#表示每2个数取一个

输出：
[3, 4]
[4, 5]
[1, 3, 5]
1
2
3
4
5
6
7
8
9

注：切片list返回依然是list，切片元组tuple返回tuple

2.匿名函数，map()函数，filter()函数

foo = [1,2,3,4]
print(list(map(lambda x:x*x,foo)))
print(list(filter(lambda x:x%2 == 0,foo)))
输出：
[1, 4, 9, 16]
[2, 4]
1
2
3
4
5
6

lambda匿名函数

lambda作为一个表达式，定义了一个匿名函数，上例的代码x为入口参数，x*x为函数体。在这里lambda简化了函数定义的书写形式。

map()

参数：map(function, iterable, …)
操作：根据函数function对序列iterable做映射
注：Python3返回迭代器，Python2返回list

filter()函数

参数：filter(function,iterable)
操作：把提供的序列iterable中的元素一次传递给函数function，做真假判断，若返回Turn，则加入到新的list中
返回：新的list

3.生成器

python中一边循环一边计算的机制，称为生成器：generator

简单的生成器

list占用空间大，改为generator可以减少空间占用，将list的[ ]改为( )

复杂生成器

使用yield，可以使一个函数变成negerator。
generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。但是实际应用中不常使用next()一一访问generator的元素，而是使用for循环。它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。

def foo(max):
    n = 0
    while n<max:
        yield n*n  #生成器，函数foo由普通的函数变为generator
        n+=1
for i in foo(3):  #这里就是使用for循环返回函数结果，每次循环做一次计算，输出结果
    print (i)
1
2
3
4
5
6
7

4.函数传参

def foo(a,b,*args,**kwargs):
    print(a,b,args,kwargs)
foo(1,2,3,4,x=5,y=6)
1
2
3

*args：表示的就是将实参中按照 位置传值，多出来的值都给args，且以 元祖 的方式呈现
**kwargs：表示的就是形参中按照 关键字传值把多余的传值以 字典的方式呈现

5.类继承

语法：

class 子类名(父类名):
    ...
1
2

class Parent(object):
    x=1 #是一个类变量，它的值将在这个类的所有实例之间共享
class Child1(Parent):
    pass
class Child2(Parent):
    pass

print (Parent.x,Child1.x,Child2.x)
Child1.x=2
print (Parent.x,Child1.x,Child2.x)
Parent.x=3
print (Parent.x,Child1.x,Child2.x)
1
2
3
4
5
6
7
8
9
10
11
12

类变量 在继承中取值：
1.如果该变量在该类中有定义，则使用该值。
2.如果没有，将搜索父类,多继承时采用C3方法，一般不存在交叉的类都是从左到右顺序搜索。搜索过程中如果前面父类的值被重新赋值，则类变量值将改变成该值
注：类名 mro()可以查看搜索顺序
实例变量在继承中的取值：
1.搜索方式和类变量一样，先找自己，在找父类，多继承也是使用C3,一般不存在交叉的类时按照从左到右顺序搜索
2.实例变量只会继承最开始的初始值，即使父类中的实例变量值被重新赋值，子类的值也不会跟着改变，仍会选择最开始的初始值

6.修饰符

class makeHtmlTag(object):
    """docstring for makeHtmlTag"""
    def __init__(self, tag):
        self.tag = tag  
    def __call__(self,fn):  #__call__()方法可以使一个类实例变成一个可调用对象
        def wrapped():
            return "<" + self.tag + ">" + fn() + "</" + self.tag + ">"
        return wrapped

@makeHtmlTag('b')
@makeHtmlTag('i')
def hello():
    return "hello world"
print(hello())
输出：
<b><i>hello world</i></b>   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

修饰符

修饰符实现了函数的嵌套功能，
例子这里，将被修饰函数func作为参数传递给dec1,且func=dec1(func())，再将新的func作为参数传递给dec2.

@dec2  
@dec1  
    def func(arg1, arg2, ...):  
        pass 
1
2
3
4

等价于：

def func(arg1, arg2, ...):  
    pass  
func = dec2(dec1(func)) 
1
2
3

7. unix时间戳

（从1970-01-01 00:00:00开始）
时间戳和正常时间的转换

import time
def timestamp_datetime(value):
'''时间戳转日期'''
    format = '%Y-%m-%d %H:%M:%S'
    value = time.localtime(value)
    ## 经过localtime转换后变成
    ## time.struct_time(tm_year=2019, tm_mon=2, tm_mday=11, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=42, tm_isdst=0)
    # 最后再经过strftime函数转换为正常日期格式。
    dt = time.strftime(format, value)
    return dt
def datetime_timestamp(dt):
'''日期装时间戳'''
     #dt为字符串
     #中间过程，一般都需要将字符串转化为时间数组
     time.strptime(dt, '%Y-%m-%d %H:%M:%S')
     ## time.struct_time(tm_year=2012, tm_mon=3, tm_mday=28, tm_hour=6, tm_min=53, tm_sec=40, tm_wday=0, tm_yday=42, tm_isdst=0)
     s = time.mktime(time.strptime(dt, '%Y-%m-%d %H:%M:%S'))
     return int(s)
if __name__ == '__main__':
    ts = 1549814400
    s = timestamp_datetime(ts)
    print("Current local time in China: " + s)

输出：Current local time in China:2019-02-11 00:00:00
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

8.Python中执行系统命令

os.popen() 方法

Open a pipe to or from command cmd.可以实现在Python代码中执行系统命令，会从一个命令打开一个管道。The return value is an open file object connected to the pipe, which can be read or written depending on whether mode is ‘r’ (default) or ‘w’.返回一个文件描述符号为fd的打开的文件对象参考
Python中用此方法使用ffmpeg完成视频分帧和帧合并：

command = 'ffmpeg -i ' + video_signed_url + ' -c:v libx264 ' + video_signed_url.split('.')[0]+'.mp4'
print(command)
process = os.popen(command) # 返回一个文件描述符号为fd的打开的文件对象
output = process.read()
process.close()
1
2
3
4
5

9.多进程

Python中multiprocessing库支持实现多进程任务。

Process()类

是一个进程对象，用来创建子进程参考

class multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
1

target是回调函数，args是函数的参数

Pool()类

提供指定数量的进程

class multiprocessing.pool.Pool([processes[, initializer[, initargs[, maxtasksperchild[, context]]]]])
1

processes指定进程数。

pool.apply_async()方法

用来同步执行进程，允许多个进程同时进入池子

pool.join()方法

设置timeout时间，默认是等待主线程的所有子线程结束

pool = multiprocessing.Pool(processes=6)
for i in range(10):
# p = multiprocessing.Process(target=tryx, args=(1, ))
    pool.apply_async(tryx, (i, ))
pool.close()
pool.join()
1
2
3
4
5
6