day 14小结

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

posted @ 2019-09-25 16:41 LZF_GD 阅读(101) 评论(0) 编辑收藏举报

刷新页面返回顶部