python常见函数-笔记

lambda函数用法

匿名函数lambda：是指一类无需定义标识符（函数名）的函数或子程序。
所谓匿名函数，通俗地说就是没有名字的函数，lambda函数没有名字，是一种简单的、在同一行中定义函数的方法。
lambda函数一般功能简单：单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。由于其实现的功能一目了然，甚至不需要专门的名字来说明。
lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。
lambda 表达式只允许包含一个表达式，不能包含复杂语句，该表达式的运算结果就是函数的返回值。
lambda 函数实际生成了一个lambda对象。
lambda 表达式的基本语法如下：
lambda arg1,arg2,arg3… :<表达式> arg1/arg2/arg3为函数的参数（函数输入），表达式相当于函数体，运算结果是表达式的运算结果。
例如：
lambda x, y: xy；函数输入是x和y，输出是它们的积xy
lambda:None；函数没有输入参数，输出是None
lambda *args: sum(args); 输入是任意个数的参数，输出是它们的和(隐性要求是输入参数必须能够进行加法运算)
lambda **kwargs: 1；输入是任意键值对参数，输出是1
由于lambda语法是固定的，其本质上只有一种用法，那就是定义一个lambda函数。
在实际中，根据这个lambda函数应用场景的不同，可以将lambda函数的用法扩展为以下几种：
1.将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。
例如，执行语句add=lambda x, y: x+y，定义了加法函数lambda x, y: x+y，并将其赋值给变量add，这样变量add便成为具有加法功能的函数。
例如，执行add(1,2)，输出为3。
2.将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。
例如，为了把标准库time中的函数sleep的功能屏蔽(Mock)，我们可以在程序初始化时调用：time.sleep=lambda x:None。
这样，在后续代码中调用time库的sleep函数将不会执行原有的功能。
例如，执行time.sleep(3)时，程序不会休眠3秒钟，而是什么都不做。
3.将lambda函数作为参数传递给其他函数。
函数的返回值也可以是函数。例如return lambda x, y: x+y返回一个加法函数。
这时，lambda函数实际上是定义在某个函数内部的函数，称之为嵌套函数，或者内部函数。
对应的，将包含嵌套函数的函数称之为外部函数。内部函数能够访问外部函数的局部变量，这个特性是闭包(Closure)编程的基础，在这里我们不展开。
部分Python内置函数接受函数作为参数,典型的此类内置函数有这些:
filter函数 此时lambda函数用于指定过滤列表元素的条件。
例如filter(lambda x: x % 3 == 0, [1, 2, 3])指定将列表[1,2,3]中能够被3整除的元素过滤出来，其结果是[3]。
sorted函数 此时lambda函数用于指定对列表中所有元素进行排序的准则。
例如sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))将列表[1, 2, 3, 4, 5, 6, 7, 8, 9]
按照元素与5距离从小到大进行排序，其结果是[5, 4, 6, 3, 7, 2, 8, 1, 9]。
map函数 此时lambda函数用于指定对列表中每一个元素的共同操作。
例如map(lambda x: x+1, [1, 2,3])将列表[1, 2, 3]中的元素分别加1，其结果[2, 3, 4]。
reduce函数 此时lambda函数用于指定列表中两两相邻元素的结合条件。
例如reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])
将列表 [1, 2, 3, 4, 5, 6, 7, 8, 9]中的元素从左往右两两以逗号分隔的字符的形式依次结合起来，其结果是’1, 2, 3, 4, 5, 6, 7, 8, 9’。

Tkinter

# coding=utf-8
import Tkinter
top=Tkinter.Tk()
label=Tkinter.Label(top,text='Hello World')
label.pack()
Tkinter.mainloop()

1.文件操作[处理一个大小10G的文件，但内存只有4G如何实现---生成器的好处]
 

def get_lines():
    l=[]
    with open('file.txt','rb') as f:
        data=f.readlines(60000)   # 设置读取的行数
    l.append(data)
    yield l
if __name__=='__main__':
    for e in get_lines():
        process(e)  # 处理每一行数据

时间 # # 输入日期， 判断这一天是这一年的第几天？

import datetime
def dayofyear():
    year,month,day=input(),input(),input()
    date1=datetime.date(year=int(year),month=int(month),day=int(day))
    date2=datetime.date(year=int(year),month=1,day=1)
    return (date1-date2).days+1

文件获取

#设计实现遍历目录与子目录，抓取.pyc文件
import os
def get_files(dir,suffix):
    res = []
    for root,dirs,files in os.walk(dir):  # 输出在文件夹中的文件名
        for filename in files:
            name,suf = os.path.splitext(filename)  # 分离文件名与扩展名；默认返回(fname,fextension)元组
            if suf == suffix:
                res.append(os.path.join(root,filename))  #os.path.join('c:\\', 'csv', 'test.csv')    'c:\\csv\\test.csv
    print(res)        
get_files("./",'.pyc')

字典排序

#现有字典 d= {'a':24,'g':52,'i':12,'k':33}请按value值进行排序?
sorted(d.items(),key=lambda x:x[1])
#x[0] 代表key排序，x[1] 代表value排序

d={key:value for (key,value) in iterable} # 字典推导式

#请按alist中元素的age由大到小排序

alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
def sort_by_age(alist):
    return sorted(alist,key=lambda x:x['age'],reverse=True)
 
# 字典
# 将字符串 "k:1 |k1:2|k2:3|k3:4"，处理成字典 {k:1,k1:2,...}
str1 = "k:1|k1:2|k2:3|k3:4"
def str2dict(str1):
    dict1 = {}
    for iterms in str1.split('|'):
        key,value = iterms.split(':')    
        dict1[key] = value
    return dict1    
#字典推导式
d = {k:int(v) for t in str1.split("|") for k, v in (t.split(":"), )} 

1. 用两个元素之间有对应关系的list构造一个dict
答：
a =['study', 'learn']    
b = [1,2]    
m =dict(zip(a,b))

排序

# 打乱排序
import random
alist=[1,2,3,4]
random.shuffle(alist)
print(alist)

集合

# 给定两个list A，B ,请用找出A，B中相同与不同的元素
A,B 中相同元素： print(set(A)&set(B))
A,B 中不同元素: print(set(A)^set(B))

正则

a = “abbbccc”，用正则匹配为abccc,不管有多少b，就出现一次？思路：不管有多少个b替换成一个
re.sub(r'b+', 'b', a)
re.sub(pat,newpat,s)
对字符串中s的包含的所有符合pat的连续字符串进行替换，如果newpat为str,那么就是替换为newpat,
如果newpat是函数，那么就按照函数返回值替换。
sub函数两个有默认值的参数分别是count表示最多只处理前几个匹配的字符串，默认为0表示全部处理；
最后一个是flags，默认为0

队列

队列
特征：
     先进先出 FIFO（First in First out）
     只能从队头离开队列
     只能从队尾进入队列
    缺点：
     队列的查找慢，从头到尾一个一个查找
python队列的三种实现
     队列：Queue
     列表：list
     双端队列：deque
     性能：list最慢，Queue较慢，deque比Queue快10倍以上
     
 Queue的操作
     q.put() 从队尾插入 
     q.get() 从队头删除，并返回 
     q.qsize() 队列大小 
     q.empty() 队列是否为空 

优先队列

定义：一种特殊的队列，特点是最优数据（最大值或最小值）始终位于队列头部。
特点：效率高。
     新数据插入队列后，计算新的最优队头，计算复杂度是O(logn);
     弹出最优队头后，计算新的最优队头，计算复杂度也是O(logn).
     python优先队列PriorityQueue
基本操作：
     pq=queue.PriorityQueue() #定义 
     pq.put([priority,value]) #进队列 
     pq.get() #取出队首 
     pq.empty() #判断空 
     pq.qsize() #队列大小 
     注意：put()的第一个参数priority表示数据的优先级，第二个参数value是值，
     如果只有一个参数，同时表示优先级和值，值越小优先级越高，队首总是最小值
# 代码 如下:
import queue
pq=queue.PriorityQueue()
pq.put(1)
pq.put(7)
pq.put(5)
print(pq.qsize())
while not pq.empty():
    print(pq.get(),end=' ')

#输出结果： 只一个参数，同时代表优先级和值，依次输出队首，从小到大
3
1 5 7 

# 代码如下：
import queue
pq=queue.PriorityQueue()
pq.put([1,'abc'])
pq.put([7,998])
pq.put([5,True])
print(pq.qsize())
while not pq.empty():
    print(pq.get(),end=' ')

#输出结果：  两个参数，value可以是各种数据类型
3
[1, 'abc'] [5, True] [7, 998] 
            

+=和=+的区别

n,m=1,2
n+=m
print(n)
n=+m
print(n)

# 输出
3
2


总结：+=简单的说就是累加，=+就是赋值

map reduce filter 三兄弟

map

对可迭代对象中的每个元素进行相同的操作

elist=map(int,['1','2','3'])
print(elist)

reduce

从左到右对一个序列的项累计地应用有两个参数的函数，以此合并序列到一个单一值。（例如累加或累乘列表元素等等）

def fn(x,y):
    return x*y
print(reduce(fn,[1,2,3]))

filter

filter函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。该接收两个参数: 第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def fn(a):
    return a%2 == 1

newlist = filter(fn, a)
newlist = [i for i in newlist]
print(newlist)
## 输出: [1, 3, 5, 7, 9]