Python基础(下篇)

本篇文章主要内容:异常处理,函数,模块和包

在开始正篇之前我们先来看看上一篇可乐留下的题目。

题目:

变量 a= {"name": "可乐", "age": 18, "hello": "python"},现在要将 a 所有的 key 放入到 b 列表中,所有的 value 放到 c 列表中。

实现方法有很多种,可乐在这里用两种方式来实现:

代码实现1:

a = {"name": "可乐", "age": 18, "hello": "python"}
b = []
c = []
for key, value in a.items():
    b.append(key)
    c.append(value)
print(f"存储key的b列表是{b}")
print(f"存储value的c列表是{c}")

代码实现2:

a = {"name": "可乐", "age": 18, "hello": "python"}
b = [key for key in a.keys()]
c = [value for value in a.values()]
print(f"存储key的b列表是{b}")
print(f"存储value的c列表是{c}")

注:第二种是列表推导式,上篇可乐没有提出来,大家可以自行百度或者私聊可乐。

接下来就是我们本篇的主角异常处理,函数,模块和包

一、异常处理

何谓异常呢 就是我们IT界鼎鼎有名的 " bug " 兄。bug 也就是指程序没有按照我们所期望的去运行而出现的一些错误情况。比如一个除法表达式 a / b ,如果我们不加处理,那么就会出现 a / 0 的情况,此时程序就会出现异常。那么这就是一个 bug 。

何谓异常处理呢 顾名思义就是当程序出现异常的时候,我们针对这些异常进行处理的机制。在 python 中默认的处理方法是出现异常后,程序会在出现异常的地方终止,然而这可能不是我们想要的。所以我们可以通过几个内置的关键字来进行自定义处理方式。

我们先来了解两个 python 的异常处理类:
- BaseException
- Exception

1.1 BaseException

这个异常处理类是所有 python 异常处理的基类。我们在自定义异常处理时,可以继承这个类。(官方不推荐)

1.2 Exception

这个异常处理类是常规处理的基类,但是 Exception 也继承于 BaseException ,官方推荐我们自定义异常类时,继承于 Exception 。(官方文档)

1.3 异常处理关键字

关键字:

try except else finally raise

语法 - try、except、else、finally:

try:
 可能异常的代码
except Error... as e:
 当出现 Error 后处理的代码
else:
 如果不出现异常,执行的代码
finally:
 无论是否发生异常都执行的代码
注意:一般时候只需要 try / except 即可,try 不可以单独使用。

示例1:

try:
    a = 1 / 0
except Exception as e:
    print(f"异常是{e}")
​
输出: 异常是division by zero

示例2:

try:
    a = 1 / 0
except Exception as e:
    print(f"异常是{e}")
else:
    print("没有异常执行")
finally:
    print("执行了finally")
​
输出: 异常是division by zero(执行了finally)

语法 - raise:

raise 异常类(描述信息)
注:raise 用于主动抛出异常。

示例:

try:
    a = 2
    raise ValueError("a不能等于2")
except Exception as e:
    print(f"异常是{e}")
​
输出 异常是a不能等于2

可乐会在下一篇python高级之面向对象中详细解释。

二、函数

2.1 语法

def func_name(参数):
 代码部分
 return 返回值
注:函数可以有返回值,可以没有返回值。

我们先来看看一个简单的示例:在函数当中计算 1 + 2 + ... + 9 的和,并且返回

2.1.1 无参数,无返回值

示例:

def num_sum():
    sum = 0
    for i in range(10):
        sum += i
    print(sum)

那么函数写好后,我们怎么调用它呢?

语法:

func_name(参数)

调用函数示例:

num_sum()
​
输出 45

2.1.2 无参数,有返回值

示例:

​def num_sum():
    sum = 0
    for i in range(10):
        sum += i
    return sum

我们再来打印一下函数返回的数值:

def num_sum():
    sum = 0
    for i in range(10):
        sum += i
    return sum
print(num_sum)
​
输出 45

2.1.3 有参数,无返回值

示例:

def num_sum(number):
    sum = 0
    for i in range(number):
        sum += i
    print(sum)

在上述函数中我们可以实现1到任何数之间所相加的和,只需要把期望的值传递给函数即可。

2.1.4 有参数,有返回值

示例:

def num_sum(number):
    sum = 0
    for i in range(number):
        sum += i
    return sum
total = num_sum(10)
print(total)

在这里我们用一个变量 total 来接收函数 num_sum 的返回值。

在函数这里有下面一些重点需要注意(每一个注意点可乐都会有一个示例)。

2.2 注意点

2.2.1 全局变量和局部变量

全局变量:在函数外部定义的变量。
局部变量:在函数内部定义的变量。
- 如果局部变量定义的名字和全局变量定义的名字相同,那么在函数体内局部变量会覆盖全局变量。
- 函数体内变量的作用域或者说生命周期,仅在函数体内有。

示例:

def scope():
    name = "可乐"
    print(f"我是函数体内的{name}")
scope()
print(f"我是函数体外的{name}")

结果如下图:
Python基础(下篇)
我们在函数体内定义的 name 变量是可以正常打印的,但是在函数体外抛出了 name 没有被定义。

2.2.2 修改全局变量

- 如果是不可变类型,需要通过 global 来声明操作全局变量;
- 如果是可变类型,那么可以直接操作全局变量不需要通过 global 来声明。

示例:

a = [1, 2, 3]
b = "可乐"
def scope():
    a.append(4)
    print(f"函数体内a的值是{a}")
    global b
    b = "可乐很帅"
    print(f"函数体内b的值是{b}")
scope()
print(f"全局变量a的值是{a}")
print(f"全局变量b的值是{b}")

结果如下图:
Python基础(下篇)
在函数传参时,实际情况下无论是可变类型还是不可变类型,传递的都是引用。但是由于不可变类型改变值后是用新的内存地址来存储,所以网上有很多这样一个结论:函数接收参数时,如果参数是可变类型,那么传递的是参数的引用;如果参数是不可变类型,那么传递的是参数的值。

所以结论是:在 python 函数传参,无论是可变类型还是不可变类型本质上都是引用传递,但是由于不可变类型不能直接修改原有的值,所以在表现上不可变类型是传值。

示例:

a = 10
b = ["可乐"]
​
def scope(change):
    print(f"改变前s_change的内存地址是{id(change)}")
    change = 20
    print(f"改变后s_change的内存地址是{id(change)}")
    print(f"改变后s_change的值是{change}")
​
def scope2(change):
    print(f"改变前s2_change的内存地址是{id(change)}")
    change.append("很帅")
    print(f"改变后s2_change的内存地址是{id(change)}")
    print(f"改变后s2_change的值是{change}")
​
scope(a)
print(f"a的值是{a},a的内存地址是{id(a)}")
scope2(b)
print(f"b的值是{b},b的内存地址是{id(b)}")

结果如下图:
Python基础(下篇)
2.2.3 函数的不定长参数和关键字参数

不定长参数:*args
关键字参数:**kwargs
在正常情况下,参数接收几个参数我们就写几个参数名就可以了,可是在实际开发中有的函数的参数并不是固定的,那么我们就可以用关键字参数和可变参数来替代。

2.2.3.1 不定长参数

示例:

def scope(*args):
    print(args)
scope(1, 2, 3)
​
输出: (1,2,3)

在这里的时候需要注意,如果我们在调用函数的时候传递的是一个元组,而不是 1,2,3 这三个参数,那么这个元组就是一个参数,如果需要达到上述函数的效果,需要对他解包

示例:

a = (1, 2, 3)
def scope(*args):
    print(args)
scope(a)
scope(*a)

结果如下图:
Python基础(下篇)
重申:如果我们在传递函数参数时是一个元组、列表、字典等时,如果不对他解包,那么传递的是该元组、列表、字典的整体。如果需要对他的每个元素进行分别传参,则需要对其解包。

2.2.3.2 关键字参数

关键字参数是针对字典这键值对类型的。

示例:

a = {"name": "可乐", "age": 18}
def scope(**kwargs):
    print(kwargs)
scope(name="可乐", age=18)
scope(**a)

注意:函数参数的匹配顺序(指定参数名除外)为从左往右

示例:

​def scope(name1, name2, name3):
    print(name1)
    print(name2)
    print(name3)
scope("可乐", "python", "是可乐呀")
print()
scope(name3="可乐", name2="是可乐呀", name1="python")

结果如下图:
Python基础(下篇)
注意:如果在函数的参数既有不定长参数和关键字参数又有普通参数,那么一定要将普通参数放在最前面。

2.2.4 默认参数

顾名思义:默认参数就是如果我们没有传值给这个参数的话,那他就是默认值。

示例1:

def scope(name="可乐"):
    print(name)
scope()
​
输出: 可乐

示例2:

def scope(name="可乐"):
    print(name)
scope("是可乐呀")
​
输出: 是可乐呀

2.2.5 匿名参数

解释:匿名函数也就是这个函数是没有名字的,不过匿名函数的关键字不是通过def来定义,而是 lambda

语法:

lambda 参数(可以多个) : 表达式(只能有一个)
注:返回一个新的函数

示例:

b = lambda x, y: y + x
print(b(1, 2))
​
输出: 3

解读:① 定义一个匿名函数用来计算 x+y 的值并且返回。② 匿名函数定义完后返回新的函数给变量 b,b 调用这个匿名函数并且将参数 1,2 传递。③ 打印 x+y 表达式的值。

函数更高层次的理解和使用例如:装饰器,闭包。可乐会在高级部分讲解。

三、模块和包

模块:我们可以通俗的理解模块就是一个 py 文件包(若干个 py 文件 + ini.py 组成的文件夹就是一个包)。

init.py 文件的作用:用于初始化这个包。

如下图:
Python基础(下篇)
如果我们有一个函数或者变量需要从另外的一个包当中引用过来,那么我们应该怎么做呢?答案就是导包

3.1 导包

语法:

① import module_name
② from xxx import module_name
③ from module_name import *

示例如下图:
Python基础(下篇)
Python基础(下篇)
输出:hello world
其他的两种方式大家可自己线下测试。

3.2 模块的搜索路径顺序

当前主目录 > PTYHONPATH 目录(开始安装 python 时设置的环境变量路径,忘记可往回看 python 安装) > 标准的连接库路径 > .pth 文件 > 第三方包(site-package 目录)

我们也可以通过 sys.path 来查看搜索路径。

如下图:
Python基础(下篇)
注意:我们根据模块的搜索路径顺序得知,我们在给包或者模块取名的时候,一定不要和系统包或者第三方包同名,否则会找不到对应的方法。

3.3 相对路径和绝对路径

相对路径:相对于你的工作目录的路径
绝对路径:以系统的根路径为为根目录,如:windows C: linux /

到此Python基础篇的内容就全部结束了,大家在学习过程中遇到疑问可以私聊可乐,可乐看到了都会一一回复的( •̀ ω •́ )。


< END>

Python基础(下篇)

发表评论

评论已关闭。

相关文章