第三周 Day1 —— Python函数

第三周 Day1

一、 字符串常用方法

1. zfill——填充字符

字符串.zfill(宽度)

num = '123'
print(num.zfill(5))        # 00123

2. split——切割

字符串1.split(字符串2) — 将字符串1中所有的字符串2作为切割点，对字符串1进行切割，返回列表

str1 = 'abcd123abhjbf'
result = str1.split('b')
print(result)           # ['a', 'cd123a', 'hj', 'f']

3. replace——替换

字符串1.replace(字符串2, 字符串3) — 将字符串1中所有的字符串2都替换成字符串3

字符串1.replace(字符串2, 字符串3 ,count) — 替换指定次数

str1 = 'how are you? i am fine, thank you! and you?'
result = str1.replace('you', 'me')
print(result)             # how are me? i am fine, thank me! and me?

str1 = 'how are you? i am fine, thank you! and you?'
result = str1.replace('you', 'me', 2)
print(result)             # how are me? i am fine, thank me! and you?

4. maketrans —— 替换

字符串.maketrans()

str1 = 'abcdhowarb'
table = str.maketrans('ab', '12')       # 创建替换的时候字符和字符之间的对应关系表
result = str1.translate(table)          # 根据替换的对应关系表对字符串中的字符进行替换
print(result)            # 12cdhow1r2

5. join

字符串.join(序列) — 将序列中所有元素用字符串连接产生一个新的字符串

result = '+'.join(['abc', '小明', '123'])
print(result)               # abc+小明+123

nums = [10, 20, 30]
result = '+'.join([str(x) for x in nums])
print(result)               # 10+20+30

6. eval

eval(字符串) — 将内容是指定格式内容的字符串转换成对应类型的数据。（将内容是字典的字符串转换成字典，将内容是列表的字符串转换成列表，…）

str1 = '[10, 20, 30]'
result = eval(str1)
print(result, type(result))        # [10, 20, 30] <class 'list'>

7. zip

zip(序列) — 将两个序列合并成一个序列，新序列中的元素就是相同位置上的元素对应的元组，返回一个序列

result = zip('abc', '123')
print(list(result))          # [('a', '1'), ('b', '2'), ('c', '3')]

keys = ['name', 'age', 'sex']
values = ['小明', 18, '男']
result = dict(zip(keys, values))
print(result)                # {'name': '小明', 'age': 18, 'sex': '男'}

交换字典的key和value

dict1 = {‘a’: ‘b’, ‘c’: ‘d’, ‘age’: 18} -> {‘b’: ‘a’, ‘d’: ‘c’, 18: ‘age’}

dict1 = {'a': 'b', 'c': 'd', 'age': 18}
list1 = list(dict1.keys())
list2 = list(dict1.values())
result = dict(zip(list2, list1))
print(result)

# 方法二：
result = {dict1[x]: x for x in dict1}
print(result)                       # {'b': 'a', 'd': 'c', 18: 'age'}
# 方法三：
result = {dict1[x]: x for x in dict1}
print(result)                       # {'b': 'a', 'd': 'c', 18: 'age'}
# 方法四：
result = dict(zip(dict1.values(), dict1.keys()))
print(result)                       # {'b': 'a', 'd': 'c', 18: 'age'}

二、函数

1. 什么是函数

​ 函数就是对实现某一特定功能的代码进行封装（就相当于具有某种功能的机器）。

2. 函数的分类（由谁来创建）

1. 系统函数

   由系统（Python）创建好的函数就是系统函数，程序员只需要在需要这个函数功能的时候使用函数，例：print、input、type、max、min…

2. 自定义函数

   由程序员自己创建的函数，就是自定义函数。（自己造机器）

3. 定义函数（创建函数）— 造机器

1. 语法：

def 函数名(形参列表):

​ 函数说明文档

​ 函数体

2. 说明：

def、()、冒号 —— 固定写法

函数名 —— 程序员自己定义；标识符，不是关键字；见名知义（看到函数名，大概知道函数的功能）

形参列表 —— 以“变量名1,变量名2,变量名3,…”形式存在。形参可以一个都没有，也可以有多个。

形参的作用是将函数外部的数据传递到函数里面。（传递数据的通道）

函数说明文档 —— 本质就是文档注释（’’’ ‘’’,""" “”"）

函数体 —— 和def保持一个缩进的一条或者多条语句，函数体就是实现函数功能的代码。

3. 步骤

   第一步：确定函数功能

   第二步：根据功能确定函数名

   第三步：确定参数。看实现函数的功能需不需要额外的数据，需要几个。

   第四步：实现函数的功能

   第五步：写函数说明文档

练习1：定义一个函数实现求任意两个数的和的功能

def sum1(num1, num2):
    """
    求两个数的和
    :param num1: 数字1
    :param num2: 数字2
    :return: 返回值
    """
    return num1 + num2

练习2：定义一个函数求一个数的阶乘。

def factorial(num):
    """
    求一个数的阶乘
    :param num:所求数
    :return: 阶乘值
    """
    if num != 1:
        return num * factorial(num - 1)
    else:
        return num

练习3：定义一个函数统计一个字符串中空格出现的次数

def count_space(s):
    """
    求一个字符串中空格出现的次数
    :param s: 字符串
    :return: 返回值，空格的数量
    """
    count = 0
    for word in s:
        if word == ' ':
            count += 1
    return count

练习4：定义一个函数统计一个字符串中另一个字符串出现的次数

def count_str(str1, str2):
    """
    求一个字符串在另一个字符串中出现的次数
    :param str1: 字符串1，被匹配字符串
    :param str2: 字符串2，匹配字符串
    :return: 字符串2在字符串1中出现的次数
    """
    length2 = len(str2)
    count = 0
    for index in range(len(str1) - length2 + 1):
        if str1[index:index+length2] == str2:
            count += 1
    return count

重要结论：定义函数的时候不会执行函数体，调用函数的时候才会执行函数中的函数体。

4. 调用函数

1. 语法

   函数名(实参列表)

2. 说明

   函数名 — 必须是已定义好的函数的函数名

   实参列表 — 以“数据1,数据2,数据3,…”形式存在。实参就是通过形参传递到函数内部的具体数据

3. 函数调用过程

   第一步：回到函数定义的位置

   第二步：传参（用实参给形参赋值）

   第三步：执行函数体

   （第四步：确定函数返回值）

   第五步：回到函数调用的文职，接着往后执行

   sum1(10, 20)           # 30
   factorial(10)          # 3628800
   

5. 函数的参数

1. 实参的分类

   1）位置参数

   以“数据1,数据2,数据3,…”的形式存在，传参的时候直接和形参从位置上一一对应

   def func1(a, b, c):
       print(f'a:{a}, b:{b}, c:{c}')
   
   func1(10, 20, 30)      # a:10, b:20, c:30
   

   2）关键字参数：以“形参名1 = 数据1,形参名2 = 数据2 …”形式存在

   func1(a=10, b=20, c=30)  # a:10, b:20, c:30
   func1(b=20, a=10, c=30)  # a:10, b:20, c:30
   

   3）关键字参数与位置参数混用

   ​ 混用的时候关键字参数必须在未知参数后面

   func1(10, 20, c=30)      # a:10, b:20, c:30
   

2. 参数的默认值（形参）

   定义函数的时候，可以通过“形参名 = 值”的方式给参数赋默认值，有默认值的参数在调用的时候可以不用传参。

   注意：定义函数的时候所有参数都可以有默认值，也可以部分参数有默认值。如果部分参数有默认值，没有默认值的参数必须放在前面

   def func2(a, b, c=10):  # 这里参数c有默认值
       print(f'a:{a}, b:{b}, c:{c}')
   
   func2(10, 20, 30)     # a:10, b:20, c:30
   func2(10, 20)         # a:10, b:20, c:10
   
   ##########################################
   def func4(a=30, b=20, c=10):
       print(f'a:{a}, b:{b}, c:{c}')
   
   func4()               # a:30, b:20, c:10
   func4(100)            # a:100, b:20, c:10
   func4(c=300)          # a:30, b:20, c:300
   

3. 参数类型说明（方法1和方法2不能同时使用）

   1）给参数赋默认值，默认值的类型就是对应的参数类型

   def func5(names=[]):
       names.append(100)
       print(names)
   
   func5([1, 2])     # [1, 2, 100]
   

   2）以“形参名:类型名”的方式说明类型

4. 不定长参数（了解）

   1）在参数前面加星号*

   ​ 这个带*的参数会变成一个元组，会将对应的实参作为元组中的元素。

   注：在调用的时候只能使用位置参数传参

   例：写一个函数求多个数的和

   def sum4(*nums):
       s = 0
       for x in nums:
           s += x
       print(s)
       
   sum4(1, 24, 45, 67)
   print(s)       # 137
   

   如果定义函数的时候定长的参数在不定长的参数后面，定长的参数传参必须使用关键字参数。

   2）在参数前，加两个*

   ​ 带**的参数会变成一个字典，调用的时候使用关键字参数传参，每个关键字参数会作为字典中的一个键值对。

   def func6(**nums):
       print(nums)
   
   
   func6()   # {}
   func6(x=10)    # {'x': 10}
   func6(x=10, y=20, a=30)    # {'x': 10, 'y': 20, 'a': 30}