阿里龙珠python训练营学习笔记

• is和==的区别
• type和isinstance
• 关键词assert——断言
• while循环的特别之处
• for循环与dict、enumerate
• 推导式
• 生成器
• 迭代器
• 异常处理 try except

1. is对比的是两个变量的内存地址
2. ==对面的是两个变量的值

a = "hello" 
b = "hello" 
print(a is b, a == b)
# True True
a = ["hello"] 
b = ["hello"] 
print(a is b, a == b)
# False True

1. type() 不会认为子类是一种父类类型，不考虑继承关系。
2. isinstance() 会认为子类是一种父类类型，考虑继承关系。

print(type(1)) #  
print(type(5.2)) #  
print(type(True)) # 
print(type('5.2')) # 

print(isinstance(1, int)) # True 
print(isinstance(5.2, float)) # True 
print(isinstance(True, bool)) # True
print(isinstance('5.2', str)) # True

1. assert这个关键词我们称之为“断言”，当这个关键词后边的条件为False时，程序自动崩溃并抛出AssertionError的异常。
2. 在进行单元测试时，可以用来在程序中置入检查点，只有条件为 True才能让程序正常工作。

assert 3 > 7
#AssertionError

1. 可以写入str、list或任何序列，长度非零则视为真值，执行循环体；否则视为假值，不执行循环体。
2. while可以接else，跳出循环后执行else
3. while中执行break的话，else不执行

string = 'abcd'
while string:
    print(string)
    string = string[1:]
else:
	print('over')
# abcd
# bcd
# cd
# d
# over

1. for循环是迭代循环，在Python中相当于一个通用的序列迭代器，可以遍历任何有序序列，如str、list、tuple等，也可以遍历任何可迭代对象，如dict。

dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

for key, value in dic.items():
    print(key, value, sep=':', end=' ')
# a:1 b:2 c:3 d:4 

for value in dic.values():
	print(value, end=' ')
# 1 2 3 4

for key in dic.keys():
    print(key, end=' ')
# a b c d 

2. 当对一个列表需要按顺序产生索引时，可以用enumerate

a = ['a','b','c','d']
for n, value in enumerate(a,1):
    print(n, value, sep=':', end=' ')
# 1:a 2:b 3:c 4:d 

3. 当for循环正常执行完的情况下，执行else输出，如果for循环中执行了跳出循环的语句，比如 break，将不执行else代码块的内容，与while - else语句一样。

#求10-20之间的质数
for num in range(10, 20):  # 迭代 10 到 20 之间的数字
    for i in range(2, num):  # 根据因子迭代
        if num % i == 0:  # 确定第一个因子
            j = num / i  # 计算第二个因子
            print('%d 等于 %d * %d' % (num, i, j))
            break  # 跳出当前循环
    else:  # 循环的 else 部分
        print(num, '是一个质数')

# 10 等于 2 * 5
# 11 是一个质数
# 12 等于 2 * 6
# 13 是一个质数
# 14 等于 2 * 7
# 15 等于 3 * 5
# 16 等于 2 * 8
# 17 是一个质数
# 18 等于 2 * 9
# 19 是一个质数

1. 列表推导式
[ expr for value in collection [if condition] ]

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x)
# [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99]

x = [[i, j] for i in range(0, 3) for j in range(0, 3)]
print(x)
# [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]
x[0][0] = 10
print(x)
# [[10, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]

2. 字典推导式
{ key_expr: value_expr for value in collection [if condition] }

b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0}
print(b)
# {0: True, 3: False, 6: True, 9: False}

• 使用字典推导式将字符串变为字典格式

str1 = 'name=zhangsan;age=17;gender=boy;phone=1309998890'
dict1 = {temp.split('=')[0]:temp.split('=')[1] for temp in str1.split(';')}
print(dict1)
# {'name': 'zhangsan', 'age': '17', 'gender': 'boy', 'phone': '1309998890'}

• ( expr for value in collection [if condition] )，是生成器，不是“元组推导式”
• 生成器自动创建了_iter_()和_next_()内置方法仅仅保存了一套生成数值的算法，调用时，才去计算然后返回一个值。生成器一定是迭代器，而迭代器不一定是生成器，一边循环一边计算的机制称为生成器，含有yield语句的函数,可以减少内存空间。

a=(n for n in range(1,7))
print(a)
print(next(a))
for n in a:
    print(n,end='...')
print('n',tuple(a))# 前面循环已经遍历完了
#  at 0x000002342D1E8270>
#1
#2...3...4...5...6...
# ()

• 还有一种生成器是yield，特性如下

def fun():
    "函数生成器"
    yield 100
    print("python")
    yield 1000
    print("hello")
    yield 10000

print(fun())   #
res = fun()
print(next(res)) #函数运行到yield,输出100，在此处暂停
print(next(res)) #再次运行,从第一个yield处释放，运行print("python")，继续运行到yield输出数据，又暂停
print(next(res)) #同理，从第二个yield处释放，运行到最后。函数生成器的全部数据已经取完，再执行就会报错。
#
# 100
# python
# 1000
# hello
# 10000

• 举个例子：用生成器实现费布那契数列（1，1，2，3，5，8，13，21……）

#费布那契数列的实现
def Fibonacci():
    a = 0
    b = 1
    while True:
        a,b = b,a + b
        yield a

for i in Fibonacci():
    if i < 100:   #100以内的费布那契数列
        print(i)

• 迭代器是一个可以记住遍历的位置的对象。
• 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
• 迭代器有两个基本的方法：iter() 和 next()。
• 使用时首先判断是否是可以迭代，用isinstance()方法判断或者可以for循环的遍历的对象是可迭代对象,可以被next()函数调用，并不断返回下一个值得对象。
• 任何实现了 __next__ 方法 （python2 是 next）的对象都可以称为迭代器。

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
print(next(it))
for x in it:
    print (x, end=" ")
# 1
# 2 3 4

异常就是运行期检测到的错误。计算机语言针对可能出现的错误定义了异常类型，某种错误引发对应的异常时，异常处理程序将被启动，从而恢复程序的正常运行。

1. Python 标准异常总结

• baseException：所有异常的 基类

• Exception：常规异常的 基类

• StandardError：所有的内建标准异常的基类

• ArithmeticError：所有数值计算异常的基类

• FloatingPointError：浮点计算异常

• OverflowError：数值运算超出最大限制

• ZeroDivisionError：除数为零

• AssertionError：断言语句（assert）失败

• AttributeError：尝试访问未知的对象属性

• EOFError：没有内建输入，到达EOF标记

• EnvironmentError：操作系统异常的基类

• IOError：输入/输出操作失败

• OSError：操作系统产生的异常（例如打开一个不存在的文件）

• WindowsError：系统调用失败

• importError：导入模块失败的时候

• KeyboardInterrupt：用户中断执行

• LookupError：无效数据查询的基类

• IndexError：索引超出序列的范围

• KeyError：字典中查找一个不存在的关键字

• MemoryError：内存溢出（可通过删除对象释放内存）

• NameError：尝试访问一个不存在的变量

• UnboundLocalError：访问未初始化的本地变量

• ReferenceError：弱引用试图访问已经垃圾回收了的对象

• RuntimeError：一般的运行时异常

• NotImplementedError：尚未实现的方法

• SyntaxError：语法错误导致的异常

• IndentationError：缩进错误导致的异常

• TabError：Tab和空格混用

• SystemError：一般的解释器系统异常

• TypeError：不同类型间的无效操作

• ValueError：传入无效的参数

• UnicodeError：Unicode相关的异常

• UnicodeDecodeError：Unicode解码时的异常

• UnicodeEncodeError：Unicode编码错误导致的异常

• UnicodeTranslateError：Unicode转换错误导致的异常
  异常体系内部有层次关系，Python异常体系中的部分关系如下所示：
  
  2. Python标准警告总结

• Warning：警告的基类

• DeprecationWarning：关于被弃用的特征的警告

• FutureWarning：关于构造将来语义会有改变的警告

• UserWarning：用户代码生成的警告

• PendingDeprecationWarning：关于特性将会被废弃的警告

• RuntimeWarning：可疑的运行时行为(runtime behavior)的警告

• SyntaxWarning：可疑语法的警告

• importWarning：用于在导入模块过程中触发的警告

• UnicodeWarning：与Unicode相关的警告

• BytesWarning：与字节或字节码相关的警告

• ResourceWarning：与资源使用相关的警告

3. try except
【例一】
try-except-else语句尝试查询不在dict中的键值对，从而引发了异常。这一异常准确地说应属于KeyError，但由于KeyError是LookupError的子类，且将LookupError置于KeyError之前，因此程序优先执行该except代码块。所以，使用多个except代码块时，必须坚持对其规范排序，要从最具针对性的异常到最通用的异常。

dict1 = {'a': 1, 'b': 2, 'v': 22}
try:#检测范围
    x = dict1['y']
except LookupError:
    print('查询错误')
except KeyError:
    print('键错误')
else:#没有错误执行else
    print(x)

# 查询错误

【例2】
一个 except 子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。

try:
    s = 1 + '1'
    int("abc")
    f = open('test.txt')
    print(f.read())
    f.close()
except (OSError, TypeError, ValueError) as error:
    print('出错了！n原因是：' + str(error))

# 出错了！
# 原因是：unsupported operand type(s) for +: 'int' and 'str'

4. try except finally

• 不管try子句里面有没有发生异常，finally子句都会执行。
• 如果一个异常在try子句里被抛出，而又没有任何的except把它截住，那么这个异常会在finally子句执行后被抛出。

def divide(x, y):
    try:
        result = x / y
        print("result is", result)
    except ZeroDivisionError:
        print("division by zero!")
    finally:
        print("executing finally clause")


divide(2, 1)
# result is 2.0
# executing finally clause
divide(2, 0)
# division by zero!
# executing finally clause
divide("2", "1")
# executing finally clause
# TypeError: unsupported operand type(s) for /: 'str' and 'str'

5. raise
Python 使用raise语句抛出一个指定的异常。

try:
    raise NameError('HiThere')
except NameError:
    print('An exception flew by!')
    
# An exception flew by!