1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2018/10/11 9:01
# @Author : Ropon
# @File : 15_01.py
# lambda #匿名函数
# 为了解决简单需求而设计一句话函数
# 比如计算n的n次幂
# def func(n):
# return n**n
# print(func(2))
#
# f = lambda n: n**n
# print(f(2))
# 语法：函数名 = lambda 参数: 返回值
# 1、函数的参数可以多个，多个参数用逗号隔开
# 2、匿名函数不管复杂程度，只能写一行，且逻辑结束后直接返回数据
# 3、返回值和正常函数一样，可以是任意数据类型
# 匿名函数并不是说一定没有名字，前面的变量就是函数名，说他是匿名函数是因为通过__name__查看没有名字，所以统称为lambda
# sorted() #排序函数
# 语法：sorted(iterable, key=None, reverse=False)
# iterable:可迭代对象
# key:排序规则或排序函数，在sorted内部会将可迭代对象中每一个元素传给这个函数的参数，根据函数运算结果进行排序
# reversed:是否倒序，True:倒序，False:正序
# lst = [7, 3, 2, 5, 4]
# lst1 = sorted(lst)
# print(lst)
# print(lst1)
# dic = {1: 'A', 2: 'B'}
# print(sorted(dic)) #字典排序，返回排序后的key
# def func(s):
# return len(s)
#
# lst = ["测试", "再次测试", "字符长度是多少", "我"]
# print(sorted(lst, key=func))
# print(sorted(lst, key=lambda s: len(s)))
# lst = [{"id": 1, "name": 'ropon', "age": 20},
# {"id": 2, "name": 'luo', "age": 16},
# {"id": 3, "name": 'peng', "age": 18}]
# print(sorted(lst, key=lambda e: e['age'], reverse=True)) #按年龄排序
# filter() #筛选函数
# 语法：filter(function ,iterable)
# function：用来筛选的函数，在filter中会自动将iterable对象中元素传递给function
# 然后根据function返回的True或False判断是否保留此项数据
# iterable:可迭代对象
#返回迭代器
# lst = [1, 2, 3, 4, 5, 6, 7, 8]
# ll = filter(lambda x: x%2==0, lst)
# print(list(ll))
# lst = [{"id": 1, "name": 'ropon', "age": 20},
# {"id": 2, "name": 'luo', "age": 16},
# {"id": 3, "name": 'peng', "age": 18}]
#
# ll = filter(lambda e: e['age'] > 16, lst) #筛选年龄大于16
# print(list(ll))
# map() #映射函数
# 语法：map(function ,iterable)
# function：对可迭代对象每一个元素进行映射，分别取出来执行function
# iterable:可迭代对象
#返回迭代器
# def func(e):
# return e*e
#
# mp = map(func, [1, 2, 3, 4, 5])
# print(mp)
# print(list(mp))
# print(list(map(lambda x: x * x, [1, 2, 3, 4, 5])))
# 计算2个列表相同位置的值之和
# lst1 = [1, 2, 3, 4, 5]
# lst2 = [2, 4, 6, 8, 10]
# print(list(map(lambda x, y: x + y, lst1, lst2)))
# 递归
# 在函数中调用函数本身，就是递归。
# 一直输出hello world
# 在python中递归最大深度为998
# def func():
# print("hello world")
# func()
# func()
# def func(n):
# print(n)
# n += 1
# func(n)
# func(1)
#递归应用
# 一般使用递归遍历各种树形结构，比如文件系统
# import os
#
# def readdir(filepath, n):
# files = os.listdir(filepath) #获取当前文件夹中所有文件及文件夹
# for fi in files: #遍历本层所有文件夹及文件
# # print(fi)
# fi_d = os.path.join(filepath, fi) #以/拼接路径
# if os.path.isdir(fi_d): #如果是文件夹，就输出，递归编译文件夹，否则结束递归，输出文件
# print("\t"*n, fi_d)
# readdir(fi_d, n+1)
# else:
# print("\t"*n, fi_d)
#
# readdir("D:\Ropon\Seafile\Work\python\code" , 0)
# 二分查找
# 每次查找都能排查一半的数据，效率高，但局限性大，必须是有序的序列才能使用二分查找
#判断n是否在lst列表中，若在返回其位置
#非递归算法，使用二分查找
# lst = [22, 33, 44, 55, 66, 77, 88, 99, 345, 444, 567, 789, 555]
# 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 += 1
# else:
# print("不存在")
# lst = [22, 33, 44, 55, 66, 77, 88, 99, 345, 444, 567, 789, 555]
#递归二分法
# 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)
# else:
# return -1
#
# print(binary_search(567, 0, len(lst) - 1))
|