Python基础-第三天

Posted 2020-09-12

本篇内容：

1.集合（set）

2.文件操作

3.字符编码与转码

4.函数

一、集合（set）

1.集合的特点

集合是一个无序的、不重复的数据组合，它的主要作用如下：

  ●去重，把列表变成集合后，自动会去重；

  ●关系测试，测试两组数据之间的交集、并集、差集、子集、父集、对称差集；

2.集合的定义

①直接定义

>>> set_name = set([1, 1, 2, "a", "a", "b"])

>>> print(set_name)
{1, 2, ‘b‘, ‘a‘}

>>> print(type(set_name))
<class ‘set‘>

②将列表转集合

>>> list_1 = [1, 2, 3, 4, 5, 1]

>>> set_1 = set(list_1)

>>> print(set_1, type(set_1))
{1, 2, 3, 4, 5} <class ‘set‘>

3.关系测试

①交集：即属于集合1也属于集合2的元素

>>> set_1 = set([1, 2, "a", "b"])

>>> set_2 = set([2, 3, "b", "c"])

>>> print(set_1.intersection(set_2))
{‘b‘, 2}

>>> print(set_1 & set_2)  # 使用运算符求交集
{‘b‘, 2}

②并集：集合1的元素加上集合2的元素，重复元素只算做一个

>>> set_1 = set([1, 2, "a", "b"])

>>> set_2 = set([2, 3, "b", "c"])

>>> print(set_1.union(set_2))
{1, 3, 2, ‘a‘, ‘c‘, ‘b‘}

>>> print(set_1 | set_2)  # 使用运算符求并集
{1, 2, 3, ‘c‘, ‘a‘, ‘b‘}

③差集

>>> set_1 = set([1, 2, "a", "b"])

>>> set_2 = set([2, 3, "b", "c"])

>>> print(set_1.difference(set_2))  # 属于集合1且不属于集合2的元素
{1, ‘a‘}

>>> print(set_1 - set_2)  # 使用运算符求属于集合1且不属于集合2的元素
{1, ‘a‘}

>>> print(set_2.difference(set_1))  # 属于集合2且不属于集合1的元素
{‘c‘, 3}

>>> print(set_2 - set_1)  # 使用运算符求属于集合2且不属于集合1的元素
{‘c‘, 3}

④判断是否为子集或父集关系

>>> set_1 = set([1, "a"])

>>> set_2 = set([1, "b"])

>>> set_3 = set([1, 2, "a"])

>>> print(set_1.issubset(set_3))  # 判断集合1是不是集合3的子集
True

>>> print(set_2.issubset(set_3))  # 判断集合2是不是集合3的子集
False

>>> print(set_3.issuperset(set_1))  # 判断集合3是不是集合1的父集
True

>>> print(set_3.issuperset(set_2))  # 判断集合3是不是集合2的父集
False

⑤对称差集：集合1所有的元素加上集合2所有的元素，但不包含两个集合的交集

>>> set_1 = set([1, 2, "a", "b"])

>>> set_2 = set([1, 3, "a", "c"])

>>> print(set_1.symmetric_difference(set_2))
{2, 3, ‘c‘, ‘b‘}

>>> print(set_1 ^ set_2)  # 使用运算符求对称差集
{2, 3, ‘c‘, ‘b‘}

⑥判断有没有交集

>>> set_1 = set([1, "a"])

>>> set_2 = set(["b"])

>>> set_3 = set([1, 2, "a"])

>>> print(set_1.isdisjoint(set_3))  # 此处注意，当有交集则返回False
False

>>> print(set_3.isdisjoint(set_1))
False

>>> print(set_2.isdisjoint(set_3))  # 此处注意，当没有交集则返回True
True

4.集合的修改

①添加

>>> set_1 = set([1, "a"])

>>> set_1.add(2)  # 添加一项内容

>>> set_1.add("b")

>>> set_1.update([3, 4, "c", "d"])  # 添加多项内容

>>> print(set_1)
{1, 2, 3, 4, ‘c‘, ‘d‘, ‘b‘, ‘a‘}

②删除

>>> set_1 = set([1, 2, "a", "b"])

>>> set_1.remove(1)  # 指定删除1元素

>>> print(set_1.pop())  # 随意删除一个元素，并显示出删除的元素
2

>>> set_1.discard("c")  # discard与remove不同的是，当discard指定的元素不存在时，不会报错

>>> print(set_1)
{‘b‘, ‘a‘}

二、文件操作

1.对文件的操作流程

  ●打开文件，得到文件句柄并赋值给一个变量

  ●通过文件句柄对文件进行操作

  ●关闭文件 

2.打开文件的方法

①对单一文件操作的语法格式：（通过此方法打开文件后，一定要关闭文件，不然就一直占用内存）

>>> 文件句柄 = open("文件名", "打开文件模式", encoding="打开文件的字符编码")
>>> 代码
>>> 文件句柄.close

②对单一文件操作的语法格式：（推荐写法，当with代码块执行完后，文件自动关闭了）

>>> with open("文件名", "打开文件模式", encoding="打开文件的字符编码") as 文件句柄:
>>>     with代码块

③对多个文件操作的语法格式：

>>> with open("文件名1", "打开文件模式", encoding="打开文件的字符编码") as 文件句柄1,             open("文件名2", "打开文件模式", encoding="打开文件的字符编码") as 文件句柄2:
>>>     with代码块

注：

  ●文件句柄是打开文件的内存对象，一般用f表示。文件句柄包括：文件名、字符集、文件大小、文件在硬盘上的起始位置等；

  ●文件名部分可以使用相对路径或绝对路径加文件名方式表示；

  ●打开文件模式有：

           r：只读模式，没有写明打开文件模式时默认是以只读方式打开；

    w：只写模式。当文件不存在时会创建文件，存在时会擦掉文件中的内容；

    a：追加模式，不能读。当文件不存在时会创建文件，存在时不会擦掉文件中的内容。往文件中写内容时，是追加写。

    r+：读写模式。当文件不存在时会报错；

    w+：写读模式。当文件不存在时会创建文件，存在时会擦掉文件中的内容；

    a+：追加读模式。当文件不存在时会创建文件，存在时不会擦掉文件中的内容。往文件中写内容时，是追加写。

  ●打开文件的字符编码：Python的默认字符编码是Unicode，所以用utf-8字符编码打开文件。

3.读取文件内容

①文件指针

打开一个文件后，文件指针在文件最开头，读完整个文件后，文件指针停留在文件内容末尾处，可以理解成光标。

>>> print(文件句柄.tell())  # 打印出文件指针的位置

# 移动文件指针。例如number位5时，表示将文件指针移送到文件内容开始处往后第5个字符处
>>> 文件句柄.seek(number)

②读取文件所有内容，或指定数量字符

>>> print(文件句柄.read())  # 读取文件中的所有内容。当文件太大时，有可能会撑爆内存。

>>> print(文件句柄.read(5))  # 只读取5个字符。

③按行读取，只读取一行

>>> print(文件句柄.readline())

④将文件所有内容变成列表，每一行为列表的一个元素

>>> print(文件句柄.readlines())

注：当文件太大时，有可能会撑爆内存。

⑤读文件的推荐做法

>>> for line in 文件句柄:
        print(line)

注：读取文件所有内容，但内次只读取一行内容，当读取新的一行时，会覆盖之前的一行的内容，从而降低了内存的占用率，效率高。

4.往文件中写内容

>>> 文件句柄.write("内容")

5.关闭文件

>>> 文件句柄.close()

>>> 文件句柄.closed  # 判断文件是否关闭，已关闭则返回True，未关闭则返回False。

三、字符编码与转码

1.Python 2.X版本中字符编码转换方法

#-*-coding:utf-8-*-

>>> import sys
>>> print(sys.getdefaultencoding())  # 显示出python默认使用的字符编码

>>> variable = "你好"

# 从utf-8解码（decode）成unicode，要告诉unicode当前使用的字符编码是utf-8
>>> utf8_to_unicode = variable.decode("utf-8")

# 从unicode编码（encode）成GBK，要告诉unicode想要转的字符编码是gbk
>>> unicode_to_gbk = utf8_to_unicode.encode("gbk")

2.Python 3.X版本中字符编码转换方法

# 注意，Python 3.X版本中，不管文件开头声明的字符编码是什么，变量使用的字符编码为unicode
>>> variable = "你好"

# 转成gbk字符编码
# 注意的是，Python 3.X版本多了个bytes类型，encode编码时str类型会转成bytes类型
>>> unicode_to_gbk = variable.encode("gbk")

# 通过decode编码，将bytes类型转成str类型，同时字符编码也转成了unicode
>>> gbk_to_unicode = unicode_to_gbk.decode("gbk")

四、函数

1.函数是什么

定义：函数是指将一组语句的集合通过一个名字（函数名）封装起来，调用函数名即执行了这个函数。

函数的特性：

  ●减少重复代码

  ●使程序变的可扩展

  ●使程序变的易维护

2.定义函数

>>> def function():  # 函数名
        """函数的功能描述"""
        代码快
        return 返回值
        
>>> function()  # 调用函数

传递参数和接收返回值：

>>> def function(x):
        """This is a test function"""
        print(x)
        return 0  # 定义返回值为数字0
        
# 将函数的返回值赋给变量variable
# 调用函数时，传递的参数是数字1
>>> variable = function(1)

>>> print(variable)
1
0

3.函数的参数

  形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

  实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

①位置参数

>>> def function(x, y):
        """This is a test function"""
        print(x)
        print(y)
        return 0

>>> function(1, 2)
1
2

形参和实参是从左到右一一对应，个数不能多不能少

②关键参数

只有关键参数：

>>> def function(x, y):
        """This is a test function"""
        print(x)
        print(y)
        return 0

>>> function(y=1, x=2)  # 顺序可以颠倒
2
1

和位置参数混用：

>>> def function(x, y, z):
        """This is a test function"""
        print(x)
        print(y)
        print(z)
        return 0

>>> function(4, z=6, y=5)  # 关键参数要放在位置参数后面
4
5
6

③默认参数

>>> def function1(x, y, z=3):  # 注意，默认参数要写在最后面
        """This is a test function1"""
        print("这是函数一", x)
        print("这是函数一", y)
        print("这是函数一", z)
        return 0

# 默认函数不是必须得传递值，如果没有传递值时那就为默认值，传递值了就用传递的值
>>> function1(1, y=2)
这是函数一 1
这是函数一 2
这是函数一 3


>>> def function2(x, y=7, z=8):
        """This is a test function2"""
        print("这是函数二", x)
        print("这是函数二", y)
        print("这是函数二", z)
        return 0

# 通过位置参数和关键参数都可以传递值
>>> function2(4, 5, z=6)
这是函数二 4
这是函数二 5
这是函数二 6

④上面的位置参数、关键参数、默认参数它们的实参数目不能比形参数目多。当实参数目不固定时，就要使用非固定参数，即参数组定义形参。

●*args

>>> def function(x, y="a", *args):  # *args要放在默认参数后面
        """This is a test function"""
        print(x)
        print(y)
        print(args)
        return 0

# *args只能接收位置参数
# 多传递部分的参数，会变成一个元组
>>> function("d", 2, 3, 4, 5, [6, 7, 8])
d
2
(3, 4, 5, [6, 7, 8])

●**kwargs

>>> def function(x, y, z=10, *args, **kwargs):  # **kwargs要放在*args后面
        """This is a test function"""
        print("这是函数七", x)
        print("这是函数七", y)
        print("这是函数七", z)
        print("这是函数七", args)
        print("这是函数七", kwargs)
        return 0

# **kwargs只能接收关键参数
# 多传递部分参数，会变成一个字典
>>> function(1, 2, 3, 4, 5, name="zl", age=26)
1
2
3
(4, 5)
{‘name‘: ‘zl‘, ‘age‘: 26}

4.函数的返回值

①返回值的类型和数量

  ●返回值可以是任意的数据类型，例如数字、字符串、列表、字典等等都行。

  ●如果return后面没有定义返回值时，默认返回None。 

  ●当return后面定义的返回值有多个时，会把所有的值放进元组中并返回。

5.全局变量和局部变量

①什么是全局变量和局部变量，以及他们的作用域

  ●在函数中定义的变量称为局部变量，在程序的顶层（也可以理解为第一级）定义的变量称为全局变量。

  ●全局变量作用域是整个程序，局部变量作用域是定义该变量的函数。

  ●当全局变量与局部变量同名时：在定义局部变量的函数内，局部变量起作用。在其它地方全局变量起作用。

例子：

>>> name = "xiaoming"


>>> def function(name):
        """This is a test function"""
        print(name)
        name = "xiaohong"
        print(name)
        return 0

>>> function(name)
xiaoming
xiaohong

>>> print(name)
xiaoming

②函数内使用global修改全局变量内容（知道有这么个东西就行，不建议这样干）

>>> name = "xiaoming"


>>> def function():
        """This is a test function"""
        global name
        name = "xiaohong"
        print(name)
        return 0

>>> print(name)
xiaoming

>>> function()
xiaohong

>>> print(name)
xiaohong

③在函数内修改列表内容

>>> variable = [1, 2, "a", ‘b‘]


>>> def function():
        """This is a test function"""
        print(variable)
        variable[0] = 3
        variable[1] = 4
        return 0

>>> function()
[1, 2, ‘a‘, ‘b‘]

>>> print(variable)
[3, 4, ‘a‘, ‘b‘]

  ●变量内容为字符串、整数的数据类型，在不使用global情况下，更改局部变量后，全局变量不会改变。

  ●变量内容为列表、字典、集合、类，在不使用global情况下，更改局部变量后，全局变量也跟着改变。

6.递归函数

①什么是递归函数

如果一个函数在内部调用自身本身，这个函数就是递归函数。

②递归函数的特点

  ●必须有一个明确的结束条件，最大的递归次数是999次；

  ●每次进入更深一层递归时，问题规模相比上次递归都应有所减少。

  ●递归效率不高

③例子

>>> def calc(n):
        print(n)
        if n > 0:
            return calc(int(n/2))
        print("函数结束，此时n的值为：%s" % n)

>>> calc(10)
10
5
2
1
0
函数结束，此时n的值为：0

7.高阶函数

①什么是高阶函数

一个函数可以接收另一个函数作为参数，这种函数就称之为高阶函数。

②例子

>>> def add(x, y, z):
        return z(x) + z(y)

>>> result = add(3, -6, abs)

>>> print(result)
9

本文出自 “12031302” 博客，谢绝转载！