三元表达式：
取代双分支的if
def max(x, y):
if x > y:
return x
else:
return y
x = 11
y = 22
print(x if x > y else y)
print(“yes” if x > y else “no”)
列表生成式
案例1
l = []
for i in range(10):
l.append(i)
print(l)
l = [i for i in range(10)]
print(l)
案例2
l = []
for i in range(10):
if i > 5：
l.append(i)
print(l)
l = [i for i in range(10) if i > 5]
print(l)
案例3：
names = [“LXX”, “HXX”, “WXX”, “LILI”]
l = []
for i in names:
l.append(i + “_sb”)
print(l)
l = [i + “_sb” for i in names]
print(l)
案例4：
l = []
names = [“egon”, “lxx_sb”, “hxx_sb”, “wxx_sb”]
for i in names:
if “_sb” in i:
l.append(i)
print(l)
l = [i for i in names if “_sb” in i]
print(l)
方法2：
for i in names:
if i.endswith(“sb”):
l.append(i)
print(l)
l = [i for i in names if i.endswith(“sb”)]
print(l)
字典生成式
res = {i: i ** 2 for i in range(5)}
print(res) 0-4的平方，生成字典
items = [(“k1”, 111), (“k2”, 222), (“k3”, 333)]
print(dict(items))
res = {k: v for k, v in items}
集合生成式
res = {i for i in range(5)}
print(res)
#没有元组生成式，生成列表后直接tuple会自动生成元组
生成器表达式：
res=(i for i in range(3))
print(res)
print(next(res))
print(next(res))
print(next(res))
with open(“a.txt”, mode=“rt”, encoding=“utf-8”) as f:
res = f.read()
print(len(res))
with open(“a.txt”, mode=“rt”, encoding=“utf-8”) as f:
res = 0
for i in f:
res += len(i)
print(res)
with open(“a.txt”, mode=“rt”, encoding=“utf-8”) as f:
res = sum((len(i) for i in f)) #sum()表示把（）内所有值的和
res = sum(len(i) for i in f)
print(res)
函数的递归调用：
在调用一个函数的内部又调用自己，所有递归调用的本质就是一个循环的过程
def func():
print(“func”)
func()
func()
import sys
print(sys.getrecursionlimit()) #这两行代码查看递归调用深度，最高是1000层
import sys
sys.getrecursionlimit() #设置递归调用的深度，递归调用到一定深度后会结束，如果递归调用设置到很深的程度，会有内存溢出的风险
递归调用的前提：递归调用一定要在某一层结束
递归调用的两个阶段：
回溯：指的是向下一层一层挖井
递推:指的是向上一层一层返回
用函数表达递归调用
age(5) = age(4) + 10
age(4) = age(3) + 10
age(3) = age(2) + 10
age(2) = age(1) + 10
age(1) = 18
def age(n):
if n == 1:
return 18
return age(n - 1) + 10
res = age(5)
print(res)
案例：（递归调用列表取值，遍历列表的所有值）
nums = [1, [2, [3, [4, [5, [6, [7]]]]]]]
def get(l):
for i in l:
if type(i) is list:
get(i)
else:
print(i)
get(nums)
基本算法：二分法
nums = [-3, -2, 1, 2, 5, 8, 9, 65, 458, 558, 689]
find_num = 64
def find(nums, find_num):
print(nums)
if len(nums) == 0:
print(“not exists”)
return
mid_index = len(nums) // 2 # 计算机是以0开始计数的，len（nums）//2的结果就是计算机的中间值索引
if find_num > nums[mid_index]:
# in the right
find(nums[mid_index + 1:], find_num) # 通过切分的方式，如果取右边的值，取值顾头不顾尾，第一个值已经比较过了，索引直接+1
elif find_num < nums[mid_index]:
# in the left
find(nums[:mid_index], find_num)
else:
print(“you got it”)
find(nums, find_num)
匿名函数:没有名字的函数
特点:临时用一次,lambda自带return.
lambda体现了函数式编程的思想
def func():
print(“func”)
func()
func()
func()
res = (lambda x, y: x + y)(1, 2)
print(res)
匿名函数案例(dict改变比较参数的用法):
salaries = {
“egon”: 3000,
“tom”: 1000000,
“zxx”: 1000
}
print(max([1, 2, 3]))
print(max(salaries.values()))
def func(k):
return salaries[k]
print(max(salaries, key=func)) #遍历的参数都是salaries,key主要是为了改变比较依据,这样比较依据变成了函数func
print(max(salaries, key=lambda k: salaries[k])) #max内置函数取最大值
print(min(salaries, key=lambda k: salaries[k])) #min内置函数取最小值
print(sorted(salaries, key=lambda k: salaries[k])) #sorted按照从小到大排序
print(sorted(salaries, key=lambda k: salaries[k], reverse=True)) #sorted加上reverse=True变成从大到小排序
了解即可:
map:把一个列表映射成一个新列表
names = [“LXX”, “HXX”, “WXX”, “LILI”]
l = [name + “_sb” for name in names]
res = map(lambda name: name + “_sb”, names) #map 括号里面的开头是一个函数,后面的是用来传值的.用逗号隔开,会把后面的值用迭代的方式把值传给前面的值 ，把map的结果赋值给res,res会直接变成一个迭代器
print(list(res))
filter
names = [“lxx_sb”, “egon”, “wxx_sb”, “lili_sb”]
print([name for name in names if name.endswith(“sb”)])
res = filter(lambda name: name.endswith(“sb”), names) #filiter会把布尔值为True的结果留下,把filter的结果赋值给res,res会直接变成一个迭代器
print(list(res))
reduce
from functools import reduce
res = reduce(lambda x, y: x + y, [1,2,3]) # reduce会把所有的值合并成一个值
res = reduce(lambda x, y: x + y, [“aa”, “bb”, “cc”]) # reduce会把所有的值合并成一个值
print(res)
pow
res = pow(10, 2, 3) # 10**2 % 3
print(res)
面向过程编程
面向过程编程:
核心是"过程"二字, 过程就是解决问题的步骤, 即: 先做什么, 再做什么.
所以基于该思想编写程序就好比设计一条一条流水线
优点: 复杂的问题流程化, 进而就简单化
缺点: 牵一发而动全身,扩展性差