Python学习三天计划-2

一、函数

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。

优点：

• 可供重复利用的代码段
• 提高程序的复用性
• 减少重复性代码
• 提高开发效率

1.定义

def func1():
    print(\"函数\")
    return 1

注意

参数、返回值可以省略

返回值可以有多个（后续说）

2.参数

• 可以不传参；可以传入多个参数：使用逗号分隔开
• 函数定义中的参数，称之为形式参数
• 函数调用中的参数，称之为实际参数
• 传入参数的时候，要和形式参数一一对应，逗号隔开；也可以以key-value形式传入

3.返回值

返回值可以有多个，也可以返回None

4.说明

def func2():
	print(\"我是一个函数\")
	return 1

使用时，当鼠标悬浮函数时出现提示

5.嵌套执行

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

6.作用域

变量作用域指的是变量的作用范围

下图num变量为testA()函数的局部变量

使用 global关键字 可以在函数内部声明变量为全局变量

二、数据容器

Python中的数据容器：

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

1.列表序列

基本语法

# 定义变量,内部数据类型可以不同；支持嵌套
list = [1,2,3,\"gyb\"]

# 空列表
list = []
list = list()

下标索引

1.正常顺序

name_list = [\"郜宇博\"，\"123\", \"456\"]
# 使用下标索引取出列表内元素
name1  = name_list[0]
print(name1)

2.反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3......）

3.嵌套列表（二维）

# 2维嵌套列表
my_list = [[1,2,3],[4,5,6]]
# 获取其中的一个元素
num = my_list[0][0]

常用方法

# 举例
# 插入元素：
# 		语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素
my_list = [1, 2, 3]
# 在第1个索引位，插入0元素
my_list.insert(1,0)
print(my_list)

特点

• 可以容纳多个元素（上限为2**63-1个）
• 可以容纳不同类型的元素（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修改（增加或删除元素等）

2.元组序列

列表是可以修改的。

元组一旦定义完成，就不可修改

基本语法

# 定义元组使用小括号
my_tuple = (1, 2, 3, 4)

# 不同元素类型
my_tuple = (1, \"gy\")
# 嵌套
my_tuple = ((1,2,3),(4,5,6))

索引方式与列表相同

常用方法

因为不能修改，所以操作少

注意

不可以修改元组的内容，但是可以修改元组内列表中的元素，如下

# 可以修改列表中元素
my_t = (1, 2, [\"gg\",\"cc\"])
# 修改
my_t[2][1] = \"aa\"
print(my_t)

3.字符串序列

同元组一样，字符串是一个：无法修改的数据容器。不可变

因此当修改字符串中字符时，会获得一个新字符串

常用方法

4.序列的切片

序列是指：内容连续、有序，可使用下标索引的一类数据容器

序列支持切片

切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长] -----》 左闭右开区间

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔

my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]	# 下标1开始，下标4（不含）结束，步长1
print(new_list)			# 结果：[2, 3, 4]

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]	# 从头开始，到最后结束，步长1
print(new_tuple)		# 结果：(1, 2, 3, 4, 5)

my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]		# 从头开始，到最后结束，步长2
print(new_list)				# 结果：[1, 3, 5]

my_str = \"12345\"
new_str = my_str[::-1]	# 从头（最后）开始，到尾结束，步长-1（倒序）
print(new_str) 			# 结果：\"54321\"

5.set集合

列表和元组都支持重复元素，因此需要不支持的容器---》set

最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序

定义语法

# 定义
nums = {1,2,3,5,5,2}
print(nums)

常用方法

6.字典集合

类似于Java的map集合

以键值对的形式存储数据：key:value

基本定义

# 定义,支持嵌套
my_dictionary = {\"name1\":10,\"name2\":20,\"name3\":30}
print(my_dictionary)

# 字典值的获取，通过key获取
print(my_dictionary[\"name1\"])

常用方法

7.容器的通用操作

三、函数进阶

1.返回值

如果一个函数要有多个返回值，该如何书写，如下

def func1():
    return 1,2
x, y = func1()
# 使用x,y接受返回值
print(x)
print(y)

2.参数

位置参数

x与1对应，y与2对应，根据位置对应

关键字参数

在实参传入时，将形参的关键字填写

注意：

​ 函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

def func2(name, age):
    print(f\"name={name},age={age}\")

func2(name=\"gyb\",age=21)

缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值

（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）

def func2(name, age=19):
    print(f\"name={name},age={age}\")

func2(name=\"gyb\")

不定长参数

不定长参数也叫可变参数. 用于不确定调用的时候会传递多少个参数(不传参也可以)的场景.

# 定义  *args放入形参中 代表 不定长参数
def func2(*args):
    print(args)

func2(\"gyb\",2)

此时将多个参数加入到了 元组序列 中，转为元组了（相当于*arg就是元组类型的形参）

# 定义  **args放入形参中 代表 不定长参数为字典集合
def func2(**args):
    print(args)

func2(name=\"gyb\",age=11,g=\"m\")

此时将多个参数传入转为字典集合了（相当于**arg就是字典类型的形参）

函数作为参数

这是一种，计算逻辑的传递，而非数据的传递。

匿名函数

函数的定义中

• def关键字，可以定义带有名称的函数
• lambda关键字，可以定义匿名函数（无名称）

def func(compute):
    return compute(1,2)

#在调用func时，传入的实参为；lambda x, y: x + y         ------》代表一个匿名函数
print(func(lambda x, y: x + y))

四、文件操作

0.基本介绍

语法

open(name, mode, encoding)

• name：是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。
• mode：设置打开文件的模式(访问模式)：只读、写入、追加等。
• encoding:编码格式（推荐使用UTF-8）

mode常用的三种基础访问模式

1.文件的读取

# 打开文件（f为文件对象，后续学）
f = open(\'python.txt\', \'r\', encoding=”UTF-8)
content = f.readline()
print(f\'第一行：{content}\')

# 用完后关闭
f.close()

方法操作

2.文件的写入

# 1. 打开文件
f = open(\'python.txt\', \'w\')

# 2.文件写入
f.write(\'hello world\')

# 3. 内容刷新
f.flush()

注意：

直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区

当调用flush的时候，内容会真正写入文件

这样做是避免频繁的操作硬盘，导致效率下降（攒一堆，一次性写磁盘）

文件如果不存在，使用”w”模式，会创建新文件

文件如果存在，使用”w”模式，会将原有内容清空

3.文件的追加

# 1. 打开文件，通过a模式打开即可
f = open(\'python.txt\', \'a\')

# 2.文件写入
f.write(\'hello world\')

# 3. 内容刷新
f.flush()

注意：

a模式，文件不存在会创建文件

a模式，文件存在会在最后，追加写入文件

五、异常

当检测到一个错误时，Python解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的“异常”, 也就是我们常说的BUG

1.捕获

捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。

\"\"\"
try:
    可能发生错误的代码
except:
    如果出现异常执行的代码
\"\"\"

# 需求：尝试以`r`模式打开文件，如果文件不存在，则以`w`方式打开。
try:
    f = open(\'linux.txt\', \'r\')
except:
    f = open(\'linux.txt\', \'w\')
# 需求：未定义捕获
try:
    print(name)
except NameError as e:
    print(\'name变量名称未定义错误\')

注意：

① 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。

② 一般try下方只放一行尝试执行的代码。

捕获多个异常

try:
    print(1/0)
except (NameError, ZeroDivisionError):
    print(\'ZeroDivision错误...\')

捕获并输出

try:
    print(num)
except (NameError, ZeroDivisionError) as e:
    print(e)

捕获所有异常

try:
    print(name)
except Exception as e:
    print(e)

2.异常else

else表示的是如果没有异常要执行的代码

try:
    print(1)
except Exception as e:
    print(e)
else:
    print(\'我是else，是没有异常的时候执行的代码\')

3.异常的finally

finally表示的是无论是否异常都要执行的代码，例如关闭文件

try:
    f = open(\'test.txt\', \'r\')
except Exception as e:
    f = open(\'test.txt\', \'w\')
else:
    print(\'没有异常，真开心\')
finally:
    f.close()

4.传递性

当函数func01中发生异常, 并且没有捕获处理这个异常的时候, 异常

会传递到函数func02, 当func02也没有捕获处理这个异常的时候

main函数会捕获这个异常, 这就是异常的传递性

注意：

当所有函数都没有捕获异常的时候, 程序就会报错

六、模块

Python 模块(Module)，是一个 Python 文件，以 .py 结尾. 模块能定义函数，类和变量，模块里也能包含可执行的代码.

作用：python中有很多各种不同的模块, 每一个模块都可以帮助我们快速的实现一些功能,

1.导入

模块在使用前需要先导入，导入的语法如下:

常用的组合形式如：

• import 模块名
• from 模块名 import 类、变量、方法等
• from 模块名 import *
• import 模块名 as 别名
• from 模块名 import 功能名 as 别名

\"\"\"
import 模块名
import 模块名1，模块名2

模块名.功能名()
\"\"\"
# 1.import模块名
# 导入时间模块
import time
print(\"开始\")
# 让程序睡眠1秒(阻塞)
time.sleep(1)
print(\"结束\")

# 2.from 模块名 import 功能名
# 导入时间模块中的sleep方法
from time import sleep
print(\"开始\")
# 让程序睡眠1秒(阻塞)
sleep(1)
print(\"结束\")

2.自定义模块

新建一个Python文件，别的模块就可以导入了

注意

在my_module1.py文件中添加测试代码test(1,1),那么在别的模块导入时，会自动执行test方法

def test(a, b):
    print(a + b)


test(1, 1)

如果想不执行test方法，则需要在被导入的模块中加入if name == \'main\': 这句话的意思是只有从本程序执行（右键执行、右上角执行）时才调用

def test(a, b):
    print(a + b)

# 只在当前文件中调用该函数，其他导入的文件内不符合该条件，则不执行test函数调用
if __name__ == \'__main__\':
    test (1, 1)

当导入多个模块的时候，且模块内有同名功能. 当调用这个同名功能的时候，调用到的是后面导入的模块的功能

如果一个模块文件中有__all__变量，当使用from xxx import *导入时，只能导入这个列表中的元素

七、包

如果Python的模块太多了，就可能造成一定的混乱，那么使用包管理

• 从物理上看，包就是一个文件夹，在该文件夹下包含了一个 init.py 文件，该文件夹可用于包含多个模块文件
• 从逻辑上看，包的本质依然是模块

创建包：右键新建软件包；或者创建目录，加入__init__.py

1.导入包

\"\"\"
方式一：
import 包名.模块名
调用：包名.模块名.目标

方式二：
from 包名 import 模块名
调用：模块名.目标
\"\"\"

2.安装第三方包

一、Pip方式

只需要使用Python内置的pip程序即可

**pip****的网络优化

我们可以通过如下命令，让其连接国内的网站进行包的安装：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称

https://pypi.tuna.tsinghua.edu.cn/simple 是清华大学提供的一个网站，可供pip程序下载第三方包

二、PyCharm方式

PyCharm也提供了安装第三方包的功能

来源：https://www.cnblogs.com/Gao-yubo/p/16815149.html
本站部分图文来源于网络，如有侵权请联系删除。