目录
1.匿名函数
匿名 -->没有名字 -->没办法调用 -->只能和某些方法联用
def f1()
pass
匿名函数的语法(通常与max() sorted() filter() sorted()方法联用)
lambda # 参数:返回值
# 如果非要用,也可以用,但是会变成有名函数
f = lambda x, y:x * y
res = f(1,2)
print(res)
max 返回最大值
res = max([1,2,3,4,5])
print(res)
res = max(1,2,3,4,5)
print(res)
min返回最小值
salary_dict = {
'nick': 3000,
'jason': 100000,
'tank': 5000,
'sean': 2000,
}
def func(name): # nick/jason/tank/sean
return salary_dict[name] # 3000/100000/5000/2000
res = max(salary_dict,key=func) # 默认key的首字符
res = max(salary_dict,key= lambda name:salary_dict[name]) # 默认key的首字符
print(res)
key = func # 默认做的事
# 循环遍历salary_dict,会取到所有的key值
# 然后把所有的key值一次丢到func中,返回薪资
# 通过返回薪资排序,得到最大值
res = min(salary_dict, key = lambda name: salary_dict[name])
print(res)
fileter -->筛选
# 首先将可迭代对象变成迭代器对象
# res = next(迭代器对象),将res当做参数传给第一个指定的函数,然后filter会判断函数的返回值的真假,如果为真则留下.
def function(item): # 1/2/3/4
if item < 5:
return True
else:
return False
# res = filter(function, [1,2,3,4])
res = filter(lambda item:item > 2, [1,2,3,4])
print(rse) # 迭代器
print(list(res))
salary_dict = {
'nick': 3000,
'jason': 100000,
'tank': 5000,
'sean': 2000,
}
res = filter(lambda item: salary_dict[item] > 3000, salary_dict)
print(list(res))
map -->映射 --> y = x+1
# 首先将可迭代对象变成迭代器对象
# res = next(迭代器对象),将res当作参数传给第一个参数的指定函数,然后将该函数的返回值作为map()方法的结果之一
def function1(item):
return item + 2
res = map(function1,[1,2,3])
print(res)
print(list(res))
sorted --> 排序
# 首先将可迭代对象变成迭代器对象
# res=next(迭代器对象),将res当作参数传给第一个参数指定的函数,然后该函数的返回值当作判断依据
def function2(item):
return salary_dict[item]
salary_dict = {
'nick': 3000,
'jason': 100000,
'tank': 5000,
'sean': 2000,
}
# res = sorted([2,3,4,5,1,5],key=function2,reverse=True)
res = sorted(salary_dict,key=function2, reverse=True)
print(list(res))
def sorted(iter,key=None,reverse=None):
iter,sort()
if key:
# key 是一个函数对象
lt = []
lt2 = []
for i in iter:
res = key(i)
lt.append(res)
lt2.append(i)
lt.sort()
lt3 = []
for i in lt:
for j in lt2:
if j[1] == i:
lt3.append(j)
if reverse:
lt3.reverse()
return lt3
if reverse:
iter.reverse()
return iter
salary_list = list(salary_dict.items())
print(salary_list)
print(sorted(salary_list, key=lambda i: i[1],reverse=None))
2.内置函数
bytes
解码字符
res = bytes('中国',encoding='utf8')
print(res)
chr/ord
chr()参考Ascall码表将数字转换成对应字符;ord()将字符转换成对应的数字
print(chr(97))
print(ord('a'))
divmod
分栏
print(divmod(10,4))
enumerate
带有索引的迭代
lt = [1,2,3]
for i in range(len(lt)
print(i,lt[i])
print(tp)
for ind,val in enumerate(lt):
print(ind,val)
eval
把字符串翻译成数据类型
s = '"abc"'
print(type(eval(s)),eval(s))
hash
可变不可哈希
print(hash(123123))
了解
abs
绝对值
print(abs(-1))
all
可迭代对象内的元素全部为True则为True
print(all([1,2,3,4]))
any
可迭代对象中有一元素为真,则为真
print(any([0,0, ]))
bin/oct/hex
二进制/八进制/十六进制转换
print(bin(123))
print(oct(123))
print(hex(123))
dir
列出模块的所有方法
import time
print(dir(time))
frozenset
不可变化的集合,类似于元组
s = frozenset({1,2,4})
pritn(s)
gloabals/locals
查看全局名字;查看局部名字
print(globals()) # 列出所有全局变量
print('locals():',locals())
def func():
s = 's1'
print(globals()) # 列出所有全局变量
print('locals():',locals()) # 列出当前位置所有变量
func()
pow
print(pow(3,2,3))
round
print(round(10.333))
slice
s = slice(1, 5, 2) # 1start,5stop,2step
lt = [1, 2, 3, 4, 5, 6, 7]
print(lt[s])
print(lt[1:5:2])
sum
print(sum(range(100)))
__import()__
import 'time'
time = __import__('time')
print(time.time())
3.异常处理
异常就是程序运行时发生错误的信号(在程序出现错误时,会产生一个异常,若程序没有处理它,则会抛出该异常,程序的运行也随之终止
1.语法错误
语法错误根本过不了python解释器的语法检测,必须在程序执行前就改正
# 语法错误示范一
if
# 语法错误示范二
def test:
pass
# 语法错误示范三
class Foo
pass
2.逻辑错误
# TypeError:int类型不可迭代
for i in 3:
pass
# ValueError
num = input('>>:') # 输入hello
int(num)
# NameError
aaa
# IndexError
l = ['egon','aa']
l[3]
# AttributeError
class Foo:pass
Foo.x
# ZeroDivisionError:无法完成计算
res1 = 1/0
res2 = 1+'str'
异常的种类
在python中不同的异常可以用不用的类型(python中统一了类与类型,类型即类)去标识,一个异常标识一种错误
1.常用的异常
-
AttributeError试图访问一个对象没有的树形,比如foo.x,但是foo没有属性x
-
IOError输入/输出异常;基本上是无法打开的文件
- ImportError 无法引入模块或包；基本上是路径问题或名称错误
- IndentationError 语法错误（的子类） ；代码没有正确对齐
- IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
- KeyError 试图访问字典里不存在的键
- KeyboardInterrupt Ctrl+C被按下
- NameError 使用一个还未被赋予对象的变量
- SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
- TypeError 传入对象类型与要求的不符合
- UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
- ValueError 传入一个调用者不期望的值，即使值的类型是正确的
2.其他异常
- ArithmeticError
- AssertionError
- AttributeError
- BaseException
- BufferError
- BytesWarning
- DeprecationWarning
- EnvironmentError
- EOFError
- Exception
- FloatingPointError
- FutureWarning
- GeneratorExit
- ImportError
- ImportWarning
- IndentationError
- IndexError
- IOError
- KeyboardInterrupt
- KeyError
- LookupError
- MemoryError
- NameError
- NotImplementedError
- OSError
- OverflowError
- PendingDeprecationWarning
- ReferenceError
- RuntimeError
- RuntimeWarning
- StandardError
- StopIteration
- SyntaxError
- SyntaxWarning
- SystemError
- SystemExit
- TabError
- TypeError
- UnboundLocalError
- UnicodeDecodeError
- UnicodeEncodeError
- UnicodeError
- UnicodeTranslateError
- UnicodeWarning
- UserWarning
- ValueError
- Warning
- ZeroDivisionError
异常的处理
为了保证程序的健壮性与容错性,即在遇到错误时系统不会崩溃,我们需要对异常进行处理
1.提前预防
如果发生错误的条件是可以预知的,我们需要用if进行处理:在错误发生之前进行预防
AGE = 10
while True:
age = input('>>:').strip()
if age.isdigit(): # 只有在age为字符串形式的整数时,下列代码才不会出错,该条件是可预知的
age = int(age)
if age == AGE:
print('you got it')
break
2.之后的预防
如果发生错误的条件是不可预知的,则需要用到try...except:在错误发生之后进行处理
try:
被检测代码块
except 异常类型:
try中一旦检测到异常,就执行这个位置的逻辑
异常类只能用来处理指定的异常情况,如果非指定异常则无法处理.
s1 = 'hello'
try:
int(s1)
except IndexError as e: # 为捕获到异常,程序直接报错
print(e)
多分支
s1 = 'hello'
try:
int(s1)
except IndexError as e:
print(e)
except KeyError as e:
print(e)
except ValueError as e:
print(e)
万能的异常Exception
s1 = 'hello'
try:
int(s1)
except Exception as e:
print(e)
异常的最终执行
s1 = 'hello'
try:
int(s1)
except IndexError as e:
print(e)
except KeyError as e:
print(e)
except ValueError as e:
print(e)
# except Exception as e:
# print(e)
else:
print('try内代码块没有异常则执行我')
finally:
print('无论是否异常,都会执行该模块,通常是进行清理工作')
try...except总结
1.把错误处理和真正的工作分开来
2.代码更易组织,更清晰,复杂的工作任务更容易实现;
3.毫无疑问,更安全了,不至于由于一些小的疏忽而是程序意外崩溃了
抛出异常raise
try:
raise TypeError('抛出异常,错误类型')
except Exception as e:
print(e)
断言assert
assert 1 == 1
try:
assert 1 == 2
except Exception as e:
print(e)
4.面向过程编程
面条版--> 面向过程编程 --> 思想 -->面向对象编程
思想没有好坏
面向(代词-->使用) 过程 (流程-->步骤) 编程 (写代码,写文件)
面向过程编程:类似于流水线,一步一步往下走
优点:逻辑非常清晰
缺点:上一步错了,下一步就跟着错
为什么会报错
逻辑--> 控制变量改变的方向出错了
检查错误--> 打印变量的变化状态-->
x = 10
y = 20
z = x + y
print(1,z) # 30
z = z + 10
print(2,z) # 40
z = z - 20
print(z)
debug