课时34:异常处理及测试

syntaxError:语法错误，多了一个逗号，少了一个括号

语义处理

ZeroDivisionError

AttributeError:属性异常

finally的作用：

相当于有提醒意义的占位符

总结：

测试一个方法：

测试一个类：

利用函数创建一个测试实例：

timedelta 时间差

choice 选择一个值

sample 获得特定数量的序列

shuffle 打乱一个序列

randint 在一个区间随机取一个数

random 随机得到一个浮点数

getrandbits 得到一个随机的比特位

trunc截断，只保留整数部分，舍掉了小数点后面的内容

floor 向下取整

cell 向上取整

定义一个实例，让类以下的方法都能共用这个实例

测试结构：

总结

assertTrue

assertIn

测试方法：

测试功能是否完备或者正确

课时31:面向对象编程

属性

继承，可以多继承

基类

派生类继承基类

多继承（但是容易混乱）

多态：属于同一类型的不同实例（员工：程序员、hr）对同一消息作出不同的响应（喊一声开始，程序员开始做项目，hr开始招人）

课时30：面向对象编程

面向对象的特征：封装、继承、多态

封装：把一个行为写成方法，把一个对象写成类

repr是给开发人员用的，直接写b

__str__是调用print时候用的，给普通用户看的

两个本质是一样的

统计实例数量

静态方法，第二个不能用实例去调用，第一个是未绑定方法

可以删除名字

课时27:面向对象编程

先关注事物，再考虑代码，代码为分析结果服务

乘客、驾驶员、车

数不清的对象在交互，梳理好关系，再用代码去实现

图书：利用字典封装信息

步骤：实现

1. ooa 面向对象分析：分析对象特征行为

聚合关系：经理和下属的关系

复合关系：衣领和衣服

依赖关系：驾驶员开车

集成关系：人分为驾驶员和乘客

关联关系：老师和50个学生

2. ood面向对象设计：类定义对象代码模块

注意类的命名，不要下划线，第一个字母大写

定义了对象的不同特征

self表示不同实例

3.oop 面向对象编程：实例化（内存对象），模拟过程

这一行意味着实例化，这叫“构造函数”

实际使用中，self不用传值

系统当前时间

设定默认值

修改信息：

from main import Book

这个对象在这个地址上

定义在交互式提示符中怎么显示信息

import main

id()显示地址

任务23:函数应用与工具

传值不能写在第一个？

lambda方便嵌套在函数里

或者可以这样写

代码改进版本：委托

如果输入了一个不存在的键就会报错，所以

输入了一个不存在的键时，自动调用中文版

委托：表象上是将一个函数当成一个参数传递给另外一个函数

用lambda：

让列表里值每个都加5

map（函数，可迭代对象）返回的结果是一个map类型

可以通过list()函数把结果转换成list

filter（函数，可迭代对象），返回的结果是filter的对象，可以转换成列表

也可以通过for循环查看

课时22:函数与lambda表达式

提高重用效率并且可以降低冗余

def hello(name): #name是形式参数，没有实际的值

print('hello'，name)

def add(x,y)

return x+y

这个函数有返回的结果，上面的函数只有执行，没有结果

所以可以声明一个新的变量

result = add(3,4)

因为定义函数时没有定义数据类型，所以只要是兼容的都可以、

result = add(‘adi', 'das')

def func(a,b,c):

print(a,b,c)

参数默认情况下，不做任何处理，按照位置匹配

func(c=1,a=2,b=3)

output: 2 3 1

这是按名称匹配

按默认值（调用时省略传值）

def func(a,b= 2,c =3):

print(a,b,c)

func(1)

混合使用：

def func(a,b= 2,c =3):

print(a,b,c)

func(1, c= 5)

output：1 2 5

* 传递元组

def avg(*scores)#接收一个元组类型

return sum(scores)/len(scores)

result = avg(98.2,88,79,93)

如果传递一个空的元组，会返回异常，所以

def avg(score, *scores)#接收一个元组类型

return sum(score,scores)/(len(scores)+1)

** 传递dict

注意括号里是（键=值）而不是（键：值）

解包：

*：args

**kwargs

lambda表达式：定义匿名函数

有些只用一次的函数，可以用lambda表达式（只是一个语句，不是函数），不用起函数名称

f是对象引用的名称

委托：

任务21:每日练习

for x in[1,2,3]

print(x)

哪些可以遍历？

可迭代的对象就支持遍历，支持迭代协议的对象，特征是包含一个叫__next__()的方法，用来移动指针关联到下一个对象上

f.__next__()

全局函数

next(f)

迭代工具：for语句、推导、map等等

分为迭代器对象（已经实现__next__()的功能）、可迭代对象（需要额外加一个iter() -> __iter__()的方法：用于生成迭代器）

判断是否已经应用了迭代器功能？

iter(f) is f

结果返回true即为已经实现迭代器

利用iter()生成迭代器

使用for语句时，list是可迭代的对象

内置可迭代对象

range

row = 1
col = 1
while row <= 3:
    col = 1
    while col <= row:
        print(col * row, end=",")
        col += 1
    print('\n')
    row += 1

函数

最大化代码重用

最小化代码冗余

过程分解

为什么要使用函数

声明参数时，是在本地定义了一个变量，函数执行完毕后，就没有了，变量作用域为local, 不影响全局

如果要使用全局的变量，需要加上 global，函数执行后，全局的x就被重新赋值

函数嵌套 enclousure封装

其中，

这个顺序只跟执行顺序有关

如果想用外侧的变量，需要加上nonlocal

在python已经内置了一个函数的时候，如果定义的函数名称和它重复，则会覆盖掉该内置的函数

默认情况下，变量向实际值传递的时候，不可变类型有：int、float、字符串、元组，传递副本给函数，函数内操作不影响原始值

可改变类型（list、字典表）传递地址引用，函数内操作会影响原始值

代码格式指南 插件pep8

[a,b,c] = (1,2,3) #序列的赋值可以接受任意格式的

s = 'youxiu'

a,b,c = s[0],s[1],s[2:]

扩展序列解包赋值

a,b,*c = s

a,*b,c = s

解包后返回的是list

b= ''.join(b) #变成string

a = [1,2,3]

''.join(a)#报错

a= ['a','b','c']

''.join(a)

a,b,c,d = 'usc'#报错

a,b,c,*d = 'usc'

因为解包后返回的是list

短的字符串（一般是3个）缓存在电脑里共用，字面值相同的时候，会指向同一位置

多目标赋值:a=b=0

参数化赋值

x=5

y=6

x=x+y

a,b=1,2

a += b

列表

l= [1,2]

l += [9,10]#第一个列表连接第二个列表

l.append()#加一个列表元素

l.extend()#加一个列表，相比+=，效率更高

表达式

1. 函数调用

len()全局函数

2. 方法调用

l.append()

3. print()

参数：

1. sep = '分隔符'

2. end = '终止符‘

3. file = 指定文件

print(s,end = '...\n', file = open('result.txt','w',encoding = 'utf8'))

流程控制

if语句 条件判断

利用字典表来实现多重分支

定义一个函数

三元运算符

a = yes if x else no

while循环

while True:

print('ctrl_x')

字符串、列表里有元素就是true，int >0为true，none为false

while x:

print(x, end=' ')#往右排就加end

x = x[1:]

break：整个跳出循环

else

print('循环结束')不是循环的一部分

不会打印‘循环结束’是因为else也是循环的一部分

continue：跳回循环的第一行，进行下一次循环

print 偶数

pass：相当于占位符

while a<b:

pass

def add(x,y):

pass

循环里面做标记

for 循环：是序列的都可以遍历

for x in[1,2,3]:

for x in ['sd','ss','we']:

for x in 'sdsfsdfsd':

pass

sum=0

for x in [1,2,3,4,5]

    sum += x

print(sum)

for x in （1,2,3,4,5）

emp = {'name': 'tom', 'dept': 'tech', 'job':'dev'}

for k in emp:

    print('{} => {}'.format(key,emp[key]))

for k in emp:

    print('{} => {}'.format(key,emp.get(key,'未找到‘))

for k in emp.keys()

print(k)

type(emp.values())

不是列表，但是是可迭代的结构

dict.values() returns a view, rather than a list\

两个序列中是否有重叠的部分？

s1 = 'sdsfas.com'

s2 = 'sfasfsa.com'

result = []

for x in s1:

    if x in s2: result.append(x)

print(result)

推导：

l = [x for x in s1 if x in x2]

for x in range(1,100,2):#每两个取一个值

print(x)

enumerate()：获取正在循环的是第几项

s = 'jintianshigehaorizi'

for idx,item in enumerate(s):

print('{}) {}'.format(idx + 1,item))