二分法
算法：是高效解決問題的辦法
算法之二分法
需求：有一個按照從小到大順序排列的數(shù)字列表
需要從數(shù)字列表中找到我們想要的那一個數(shù)字如何高效椒舵？？
nums=[-3,4,7,10,13,21,43,77,89]
find_num=10
nums=[-3,4,6,8,,45,-12,55]
nums.sort()
print(nums)
方案一:整體遍歷效率太低
for num in nums:
if num == find_num:
print('find it')
break
方案二：二分法
def binary_search(find_num,列表)：
mid_val=找到列表中間的值
if find_num > mid_val:
# 接下來的查找應該是在列表的右半部分
列表=列表切片右半部分
binary_search(find_num,列表)
elif find_num < mid_val:
# 接下來的查找應該是在列表的左半部分
列表=列表切片左半部分
binary_search(find_num,列表)
else:
print('find it')
nums=[-3,4,7,10,13,21,42,43,77,89]
find_num=8
def binary_search(find_num,l):
print(l)
if len(l) == 0:
print('找的值不存在')
return
mid_index=len(l) //2
if find_num > l[mid_index]:
# 接下來的查找應該是在列表的右半部分
l=l[mid_index+1:]
binary_srarch(find_num,l)
elif find_num < l[mind_index]:
# 接下來的查找應該是在列表的左半部分
l=l[:mid_index]
binary_search(find_num,l)
else:
print('find it')
binary_search(find_num,nums)
面向過程編程思想
編程思想/范式
面向過程的編程思想：
核心是‘過程’二字洪鸭，過程即流程蒲列，指的是做事的步驟：先什么颜屠，再什么后干什么
基于該思想編寫程序就好比在設計一條流水線
優(yōu)點：復雜的問題流程化，進而簡單化
缺點：擴展性差
面向過程的編程思想應用場景解析：
1.不是所有的軟件都需要頻繁更迭：比如編寫腳本
2.即便是一個軟件需要頻繁更迭康嘉，也并不代表這個軟件所有的組成部分都需要一起更迭
匿名函數(shù)
def用于定義有名函數(shù)
def func(x,y):
return x+y
print(func)
lambda用于定義匿名函數(shù)
print(lambda x,y:x+y)
調(diào)用匿名函數(shù)
方式一：
res=(lambda x,y:x+y)(1,2)
print(res)
方式二：
func = lambda x,y:x+y
res=func(1,2)
print(res)
匿名用于臨時調(diào)用一次的場景：更多的是將匿名與其他函數(shù)配合使用
匿名函數(shù)的應用
salaries={
'siry':3000,
'tom':7000,
'lili':10000,
'jack':2000
}
# 需求1：找出薪資最高的那個人=》lili
res=max([3,200,11,300,399])
print(res)
res=max(salaries)
print(res)
salaries={
'siry':3000,
'tom':7000,
'lili':10000,
'jack':2000
}
# 迭代出的內(nèi)容 比較的值
# 'siry' 3000
# 'tom' 7000
# 'lili' 10000
# 'jack' 2000
def func(k):
return salaries[k]
# ========================max的應用
res=max(salaries,key=func) # 返回值 =func('siry')
print(res)
res=max(salaries,key=lambda k:salaries[k])
print(res)
# ========================min的應用
res=min(salaries,key=lambda k:salaries[k])
print(res)
# ========================sorted排序
salaries={
'siry':3000,
'tom':7000,
'lili':10000,
'jack':2000
}
res=sorted(salaries,key=lambda k:salaries[k],reverse=True)
print(res)
# ========================map的應用(了解)
l=['alex','lxx','wxx','薛賢妻']
new_l=(name+'_dsb' for name in l)
print(new_l)
res=map(lambda name:name+'_dsb',l)
print(res) # 生成器
# ========================filter的應用（了解）
l=['alex_sb','lxx_sb','wxx','薛賢妻']
res=(name for name in l if name.endswith('sb'))
print(res)
res=filter(lambda name:name.endswith('sb'),l)
print(res)
# ========================reduce的應用(了解)
from functools import reduce
res=reduce(lambda x,y:x+y,[1,2,3],10) # 16
print(res)
res=reduce(lambda x,y:x+y,['a','b','c']) # 'a','b'
print(res)
模塊
一、什么是模塊：
模塊就是一系列功能的集合體籽前，分為三大類
1.內(nèi)置的模塊
2.第三方的模塊
3.自定義的模塊
一個python文件本身就是一個模塊亭珍，文件名m.py，模塊名叫m
ps:模塊有四種形式
1.使用python編寫的.py文件
2.已被編譯為共享庫或dll的c或c++擴展
3.把一系列模塊組織到一起的文件夾(注：文件夾下有一個init.py文件枝哄，該文件夾稱之為包)
4.使用c編寫并鏈接到python解釋器的內(nèi)置模塊
二肄梨、為何有用模塊
1.內(nèi)置與第三方的模塊拿來就用，無需定義挠锥，這種拿來主義众羡，可以極大地提升自己的開發(fā)效率
2.自定義的模塊
可以將程序的各部分功能提取出來放到一模塊中為大家共享使用
好處是減少了代碼冗余，程序組織結構更加清晰
三蓖租、怎么用
y=333
z=444
import foo
1.首次導入模塊會發(fā)生3件事
- 執(zhí)行foo.py
- 產(chǎn)生foo.py的名稱空間粱侣，將foo.py運行過程中產(chǎn)生的名字都丟到foo的名稱空間中
- 在當前文件中產(chǎn)生的有一個名字foo，該名字指向2中產(chǎn)生的名稱空間
之后的導入菜秦，都是直接引用首次導入產(chǎn)生的foo.py名稱空間甜害，不會重復執(zhí)行代碼
import foo
import foo
import foo
import foo
2.引用：
print(foo.x)
print(foo.get)
print(foo.change)
強調(diào)1：模塊名.名字，是指名道姓地問某一個模塊要名字對應的值球昨，不會與當前名稱空間的名字發(fā)生沖突
x=1111111
print(x)
print(foo.x)
強調(diào)2：無論是查看還是修改操作的都是模塊本身尔店，與調(diào)用位置無關
import foo
x=33333
foo.get()
foo.change()
print(x)
print(foo.x)
foo.get()
3.可以以逗號為分隔符在一行導入多個模塊
import time
import foo
import m
不建議在一行同時導入多個模塊
import time ,foo,m
4.導入模塊的規(guī)范
1.python內(nèi)置模塊
2.第三方模塊
3.程序員自定義模塊
import time
import sys
import 第三方1
import第三方2
import 自定義模塊1
import自定義模塊2
import自定義模塊3
5.import....as....
import foo as f # f=foo
f.get()
import abcdefgadfadfa
abcdefgadfadfa.f1
abcdefgadfadfa.f2
abcdefgadfadfa.f3
import abcdefgadfadfa as mmm
mmm.f1
mmm.f2
mmm.f3
6.模塊是第一類對象
import foo
7.自定義模塊的命名應該采取純小寫+下劃線的風格
8.可以在函數(shù)內(nèi)導入模塊
def func():
import foo
