笨方法学Python 习题37

使用Python 获取帮助

查看关键字
在终端运行 help 命令

help("keywords")
help("open")
help("def")

del 的用法

# 查看关键字
# 在终端运行 help 命令
# help("keywords")
# help("open")
# help("def")

# 新命令 del
A = ['a','b','c','d','e','f']
print(A)
#删除制定的索引值
del A[2]
print("删除索引 2：", A)

# 切片删除. 注意什么是切片
del A[1:3]
print("删除切片 1-3：", A)

#比较 pop 和 del。 pop 返回值，而 del 不返回值
A_pop= A.pop(-1)
print("pop -1: ", A_pop)

# 删除变量
del A  # 变量A 不再有定义，print(A) 将返回错误。
print(A)

from 和 import 的区别

import sys # 引入 sys 库
print(sys.argv)  # 调用 sys 库中 argv 脚本

from sys import argv # 引入 sys 库中 argv 脚本
print(argv)

# 总之，from 用来帮助 import 精确引用

as 关键字

# as 用来重命名

import sys as my_sys
print(my_sys.argv)

from sys import argv as av
print(av)

global 关键字

x = 6

def my_fun0():
    print("全局变量 x: ",x)

def my_fun1():
    x = "局部变量"
    print("局部变量 x: ", x)

def my_fun2():
    global x
    x = "全局变量"
    print("改变全局变量 x: ", x)

print("全局变量 x")
my_fun0()
my_fun2()

print("函数中的局部变量 x 的值不影响全局变量 x 的值.")
my_fun1()
my_fun0()

with 关键字

详见：大神关于 with 的总结

assert 关键字

assert 用来断言，声明它的布尔值为真，否则会报错。我们可以自定义它的报错信息。

assert 1+1 == 2, "1+1 不等于 2"
assert 1+1 != 2, "1+1 等于 2" 

第一个例子：断言 1+1 = 2, 否则返回错误信息 1+1 不等于 2.

pass 关键字

在程序不完整的情形运行 pass, 会忽略代码的缺失，不会报错.

# path 关键字
if 1+1 > 5:
    print("宇宙要毁灭了.")
else:
    # 宇宙不会毁灭，但是我们不知道会发生什么
    pass     
    # 一般情形 else 之后应该有其他的输出，这里使用了 pass， 程序忽略了 else 的不完整性。

yield 关键字

yield 关键字讲函数返回一个生成器。生成器是一个可迭代的对象。可迭代的对象: 凡是可以使用 for xx in xxx 逐个获取其中元素的对象. 例如: 列表、字符串. 但是和列表、字符串不同，一个生成器实例只能迭代一次，并且在内存中只占用一个位置而不像列表有多少个元素就占用多少位置。因此，生成器节省内存.

def my_yield():
    for i in range(10):
        yield "{:c}".format(i+97)        # format 的用法，可选择另外一种：" %c " % i+97

y = my_yield() # 实例化生成器

print(y) # 生成器无法打印其中内容, 因为未迭代时，其中不包含元素，而生产新的元素时旧的元素被抛弃。所以占用内存低。

# 通过迭代打印生成器
for i in y:
    print(i)

# 在此迭代无法在此获取，只能迭代一次.
print("再次迭代:")

for i in y:
    print(i)

print("迭代结束.")

break 和 continue 关键字

这两个关键字都是用来打断循环的。不同点在于 break 是跳出整个循环， 而 continue 是跳出本次循环.

# break 关键字
print("break: ")
for i in range(10):
    if i == 5:
        break
    print(i)

# continue 关键字
print("continue: ")
n = 12
while n > 0:
    n -= 1
    if n == 10:
        print("开始倒数！")
        continue
    print(n)

try-except-finally 关键字

这三个关键字通常在异常处理的时候会用到。它们的作用是当程序出现错误的时候获取并处理异常，从而避免因为异常而中断运行

try-except 代码块是异常处理时最常用的。我们把可能出现错误的代码放在 try 缩进中运行，在异常发生时捕获异常信息。
而 except 则负责处理异常信息，可以选择 pass 忽略， 或者打印一些信息。不过需要注意的是，except 可以在其后指定错误的类型，以便在该类型的错误被捕获时做出反应.
finally 语句无论是否有错误都会被执行。

# try except finally
try:
    print(Name)   # 变量 Name 不存在，运行的时候回提示 NameError 错误
except NameError: # 让电脑忽略 NameError 错误
    print("变量名 name 不存在，将引发 NameError 错误")

# 可以使用 try-except-else 代码块在无错误的时候引发 else 语句
try:
    print("没有问题吧？") # 没有错误则运行该命令，有错误则不运行
except NameError:         # 忽略错误中的 NameError 错误类型，
                            #但是打印出 NameError 错误类型
    print(NameError)
else:
    print("运行正常")  # 上文没有错误则运行该命令

# 有时候我们不知道会是什么错误类型的情况下，可以不指定 except 的错误类型

try:
    print(int(name))
except:
    print("出错啦，捕获到某种错误")

# 也可以用 as 把错误信息打印出来
try:
    print(1/0)
except Exception as e:
    print("错误信息: ", e)


# 可以使用多行 except 获取不同的错误（前面的错误触发后，后面的将不会再触发）
# 或者某几种错误放在一个括号中，使用一个应对策略
try:
    foo()
except(NameError, TypeError) as e:
    print("发生意料之内的错误: ",e)
except Excetion as e:
    print("发生意料之外的错误: ",e)

raise关键字

raise手动抛出错误，后跟错误类型

raise("哈哈，名字错了 ")

is 关键字

is 用于判断两个元素是否是引用内存中同一个对象. 相当于 id(a) == id(b). id() 返回对象在内存中的身份编号.

a = 2
b = a
print(a is b)

lambda关键字

lambda 可以间接明了的定义一个函数.

x = 10
f =lambda x:x*3
x = f(x)
print(x)

# 相当于
x = 10
def x3(x):
    x *=3
    return x
x = x3(x)
print(x)
print('lambda 表达式可以简介表达一个函数.')

参考1: https://blog.youkuaiyun.com/aaazz47/article/details/79821223.