python内置函数os_python内置函数

一.lamda匿名函数

定义:为了解决一些简单的需求而设计的函数.

语法:函数名=lambda 参数 : 返回值

1,函数的声明

def func(n):

'''

此函数接收一个参数n

计算n的n次方

:param n: 传递进来的n

:return: n的n次方

shijian

zuozhe

'''

return n**n

r = func(3) # 函数的调用

print(r)

#print(func.__name__) #查看函数名

#print(func.__doc__) #查看注释文档

例一:

a = lambda n: n**n # 匿名函数, 一般不会用来做复杂的操作

r=a

print(r)

例二

# 写一个lambda 计算字符串长度并返回 # len()

a = lambda s: len(s)

例三:

# 写一个lambda 给函数传递两个参数, a, b 计算a+b的结果

a = lambda m, n: m + n

注意:

1. 函数的参数有多个,多个参数之间用逗号隔开

2. 匿名函数不管有多复杂,只能写一行,且逻辑结束后直接返回数据

3.返回值和正常的函数一样,可以是任意数据类型

二:排序函数sorted()

语法:sorted(Iterable, key=None, reverse=False)

Iterable: 可迭代对象

key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每⼀个元素传递给这个函

数的参数. 根据函数运算的结果进⾏排序

reverse: 是否是倒叙. True: 倒叙, False: 正序

例一

list=[1,5,3,4,6]

lst=sorted(list)

print(lst)

print(list)

例二

dic={1:'A',3:'c',2:'b'}

print(sorted(dic))

例三和函数一起使用

lst=["麻花藤","冈本次郎","中央情报局","狐仙"]

def func(s):

return len(s)

print(sorted(lst,key=func))

例四 和函数组合使用

lst=["麻花藤","冈本次郎","中央情报局","狐仙"]

def func(s):

return len(s)

print(sorted(lst, key= lambda s:len(s)))

例五:

lst=[{"id":1,"name":'alex',"age":18},

{"id":2,"name":"wusir","age":16},

{"id":3,"name":"taibai","age":17}

]

print(sorted(lst,key=lambda e:e["age"]))

三fitter()筛选函数

语法: filter(function. Iterable)

function: ⽤来筛选的函数. 在filter中会⾃动的把iterable中的元素传递给function. 然后

根据function返回的True或者False来判断是否保留此项数据

Iterable: 可迭代对象

例一

lst=[1,2,3,4,5,6,7,8,9,10]

ll=filter(lambda x: x%2==0,lst)

print(ll)

print(list(ll))

例二

lst=[{"id":1,"name":'alex',"age":18},

{"id":2,"name":"wusir","age":16},

{"id":3,"name":"taibai","age":17}

]

fl =filter(lambda e: e[age]>16,lst)

print(list(f1))

例三

c=lambda a,b: a+b

r=c(3,4)

print(r)

例四

lst=["麻花藤","冈本次郎","中央情报局","狐仙"]

ll=lambda s: len(s)

r=ll

print(r)

例五

lst=["精卫填海","放羊的星星","年轮","灵魂摆渡","蜗居","第八号当铺","惊魂"]

f=filter(lambda s: len(s)>2,lst)

print(f)

print("__iter__" in dir(f))

for i in f:

print(i)

例六

lst=[{"id":1,"name":'alex',"age":18},

{"id":2,"name":"wusir","age":16},

{"id":3,"name":"taibai","age":34},

{"id": 3, "name": "太白", "age": 49},

{"id": 3, "name": "太黑", "age": 26},

{"id": 3, "name": "骚逼", "age": 17}

]

f2=filter(lambda e:e["age"]>=30,lst)

print(f2)

print("__iter__" in dir(f2))

for j in f2:

print(j)

四map函数(映射函数)

语法: map(function, iterable) 可以对可迭代对象中的每一个元素进行映射,分别取执行function

例一:计算列表中每个元素的平方返回新列表

lst=[2,3,4,5,6,7]

m=map(lambda s:s**2,lst)

print("__iter__" in dir(m))

for i in m:

print(i)

n=filter(lambda x:x**2,lst)

for j in n:

print(j)

例二:查找是否在列表里面

用户:alex

密码:456

lst=["alex_123", "alex_456", "wusir_123", "wusir_456", "alex_789"]

m=list(map(lambda s:"yes" if s=="alex_456" else "false" ,lst))

print(m)

m=list(map(lambda s:s.split("_")[0]=="alex" and s.split("_")[1] =="123" ,lst))

print(m)

print("__iter__" in dir(list))

例三:计算两个列表相同位置的数据的和

lst1 = [1, 2, 3, 4, 5]

lst2 = [2, 4, 6, 8, 10]

print(list(map(lambda x, y: x+y, lst1, lst2)))

五;递归:在函数中调用函数本身,就是递归(python中最大递归深度998)

例一

def func():

print("我是谁")

func()

func()

def foo(n):

print(n)

n += 1

foo(n)

foo(1)

递归的应⽤:

我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统.

可以使用递归来遍历该文件夹中的所有文件

def func(path, ceng): # path: d:/a

lst = os.listdir(path)

for el in lst: # 哈哈

# el 文件名

rp = os.path.join(path, el) # d:/a/哈哈

if os.path.isdir(rp):

print("\t"*ceng, el, sep="")

func(rp, ceng+1)

else:

print("\t"*ceng,el, sep="")

func("e:/哈哈", 0)

lst = os.listdir(path) # 打开一个文件夹. 获取到文件夹内的所有内容 ["a","b"]

for el in lst: # 当前文件夹内的所有的文件名(包括文件夹名字)

# 拼接文件的真实路径

file_real_path = os.path.join(path, el)

# 判断这个路径是文件还是文件夹

if os.path.isdir(file_real_path):

# 递归的入口

print(el)

func(file_real_path) # 重新执行刚才的操作

else: # 不是文件夹, 是文件

# 递归的出口

print(el)

六. 二分查找

二分查找. 每次能够排除掉⼀半的数据. 查找的效率非常⾼. 但是局限性比较大. 必须是有

序序列才可以使用二分查找

要求: 查找的序列必须是有序序列.

判断n是否在lst中出现,如果出现请返回n所在的位置

1.二分法查找-----非递归算法

lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]

n = 567

left = 0

right = len(lst) - 1

count = 1

while left <= right:

middle = (left + right) // 2

if n < lst[middle]:

right = middle - 1

elif n > lst[middle]:

left = middle + 1

else:

print(count)

print(middle)

break

count = count + 1

else:

print("不存在")

2. 普通递归版本⼆分法

def binary_search(n, left, right):

if left <= right:

middle = (left+right) // 2

if n < lst[middle]:

right = middle - 1

elif n > lst[middle]:

left = middle + 1

else:

return middle

return binary_search(n, left, right)

# 这个return必须要加. 否则接收到的永远是None.

else:

return -1

print(binary_search(567, 0, len(lst)-1))

3. 另类⼆分法, 很难计算位置.

def binary_search(ls, target):

left = 0

right = len(ls) - 1

if left > right:

print("不在这⾥")

middle = (left + right) // 2

if target < ls[middle]:

return binary_search(ls[:middle], target)

elif target > ls[middle]:

return binary_search(ls[middle+1:], target)

else:

print("在这⾥")

binary_search(lst, 567)