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]

常用方法

编号	使用方式	作用
1	列表.append(元素)	向列表中追加一个元素
2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
3	列表.insert(下标, 元素)	在指定下标处，插入指定的元素
4	del 列表[下标]	删除列表指定下标元素
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	从前向后，删除此元素第一个匹配项
7	列表.clear()	清空列表
8	列表.count(元素)	统计此元素在列表中出现的次数
9	列表.index(元素)	查找指定元素在列表的下标 找不到报错ValueError
10	len(列表)	统计容器内有多少元素

# 举例
# 插入元素：
# 		语法：列表.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))

索引方式与列表相同

常用方法

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

编号	方法	作用
1	index()	查找某个数据，如果数据存在返回对应的下标，否则报错
2	count()	统计某个数据在当前元组出现的次数
3	len(元组)	统计元组内的元素个数

注意

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

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

3.字符串序列

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

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

常用方法

编号	操作	说明
1	字符串[下标]	根据下标索引取出特定位置字符
2	字符串.index(字符串）	查找给定字符的第一个匹配项的下标
3	字符串.replace(字符串1, 字符串2)	将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
4	字符串.split(字符串)	按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表
5	字符串.strip() 字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
6	字符串.count(字符串)	统计字符串内某字符串的出现次数
7	len(字符串)	统计字符串的字符个数

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)

常用方法

编号	操作	说明
1	集合.add(元素)	集合内添加一个元素
2	集合.remove(元素)	移除集合内指定的元素
3	集合.pop()	从集合中随机取出一个元素
4	集合.clear()	将集合清空
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集 原有的2个集合内容不变
6	集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变
7	集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变
8	len(集合)	得到一个整数，记录了集合的元素数量

6.字典集合

类似于Java的map集合

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

基本定义

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

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

常用方法

编号	操作	说明
1	字典[Key]	获取指定Key对应的Value值
2	字典[Key] = Value	添加或更新键值对
3	字典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
4	字典.clear()	清空字典
5	字典.keys()	获取字典的全部Key，可用于for循环遍历字典
6	len(字典)	计算字典内的元素数量

7.容器的通用操作

功能	描述
通用for循环	遍历容器（字典是遍历key）
max()	容器内最大元素
min()	容器内最小元素
len()	容器元素个数
list()	转换为列表
tuple()	转换为元组
str()	转换为字符串
set()	转换为集合
sorted(序列, [reverse=True])	排序，reverse=True表示降序 得到一个排好序的列表

三、函数进阶

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常用的三种基础访问模式

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除。 如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。 如果该文件不存在，创建新文件进行写入。

1.文件的读取

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

# 用完后关闭
f.close()

方法操作

操作	功能
文件对象 = open(file, mode, encoding)	打开文件获得文件对象
文件对象.read(num)	读取指定长度字节 不指定num读取文件全部
文件对象.readline()	读取一行
文件对象.readlines()	读取全部行，得到列表
for line in 文件对象	for循环文件行，一次循环得到一行数据
文件对象.close()	关闭文件对象
with open() as f	通过with open语法打开文件，可以自动关闭

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也提供了安装第三方包的功能