2.1学习总结

函数基础

一、字符串的常用方法

# 1.zfill
# 方法    字符串.zfill(宽度)
num = 3
result = str(num).zfill(4)
print(result)           # 0003

result1 = f'{num:0>4}'
print(result1)          # 0003

# 2.split --切割
# 字符串1.split(字符串2)  --将字符串1中字符串2作为切割点，返回列表
str1 = 'dsajkadhadsajkdak'
result2 = str1.split('a')       # 切割点就消失了
print(result2)      # ['ds', 'jk', 'dh', 'ds', 'jkd', 'k']
# 注意：如果切割点在边上，海德欧返回一个空的元素，总共的段数，是等于切割点数加一

# 3.replace - 替换
# 字符串1.replace(字符串2，字符串3)   --将1中的2，全部替换成3
# 字符串1.replace(字符串2，字符串3，count)  --替换指定次数

# 4.
str1 = 'adjkhsadsajka'
table = str1.maketrans('adk', '12$')   # 先生成一张表，将a变成1，b变成2。一一对应
result = str1.translate(table)
print(result)       # 12j$hs12s1j$1

# 5.join
# 字符串.join(序列)      --将序列中的所有元素拼接成一个新字符串
result = '+'.join(['abc', '123', '小明'])
print(result)       # abc+123+小明

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

result = '*'.join('小明')
print(result)       # 小*明

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

# 6.eval()    --函数  将''内的内容转化为指定格式的内容
str2 = '{"name": "小明"}'
result = eval(str2)
print(result, type(result))     # {'name': '小明'} <class 'dict'>

# 7.zip(序列1,序列2)     --将两个序列合并成一个序列，新序列元素是由同一位置上对应的元素。
result = zip('axd', '123')
print(list(result))     # [('a', '1'), ('x', '2'), ('d', '3')]

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

二、创建函数

# 1.什么是函数
# 函数就是对实现某一特定功能的代码的封装(就相当于具有某种功能的机器)

# 2.函数的分类(由谁来创建)
# 系统函数：由系统(python)创建好的函数
# 自定义函数：由程序员自己创建的函数
# 3.定义函数(创造函数)
"""
def 函数名(形参列表):
    函数说明文档
    函数体

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


# 练习
# 练习1：定义一个函数实现求任意两个数的和的功能。
def sum2(num1, num2):
    """
    (功能说明区)求两个数的和
    :param num1: (参数说明区)数字1
    :param num2: 数字2
    :return:(返回值说明区)None
    """
    print(num1 + num2)


sum2(8, 9)

# 练习2：定义一个函数求一个数的阶乘。（n! = 1*2*3*n-1*n）


def factorial(n):
    """
    求n的阶乘
    :param n:
    :return:
    """
    factorial1 = 1
    for x in range(1, n+1):
        factorial1 *= x
    print(factorial1)


factorial(5)
# 练习3：定义一个函数可以统计一个字符串中空格出现的次数


def count1(str1):
    count0 = 0
    for x in str1:
        if x == ' ':
            count0 += 1
    print(count0)


count1('da ad ad sa d sa  ds d ')
# 练习4：定义一个函数可以统计一个字符串中另外一个字符串出现的次数


def string_count(str1, str2):
    l1 = len(str1)
    l2 = len(str2)
    index = 0
    count = 0
    while True:
        if str1[index: index + l2] == str1:
            index += l2
            count += 1
        else:
            index += 1

        if index >= l1:
            break
    print(count)


# 4.重要结论：定义函数的时候不会执行函数体，调用函数的时候才会使用
# 5.调用函数（使用机器）
"""
函数名(实参列表)
函数      ————必须是定义好的函数
实参      ————实际要进行操作的，传递到函数内部的实际参数
"""

三、函数的参数

# 1.位置参数和关键字参数(实参的分类)
"""
位置参数：以'数据1，数据2，数据3。。。。'的形式存在，传参数的时候一一对应
关键字参数(python特有)：形参名=数据1，形参名2=数据2
混用：位置参数必须在关键字参数前面
"""

# 2.参数默认值(形参)
"""
定义参数的时候，可以通过'形参名=值'的方式给参数赋默认值
有默认值的参数，在调用可以不用赋值
注意：定义函数的时候可以给任意参数赋默认值，没有赋默认值的参数，必须放前面
"""


def func2(a, b, c=20):
    print(f'a:{a}, b:{b}, c:{c}')


func2(10, 20)       # a:10, b:20, c:20
# func2(c=20, a , b)      # SyntaxError: positional argument follows keyword argumen

# 3.参数类型说明
# 方法一 给参数赋默认值，值的类型就是对应的参数类型
# 方法二 以'形参名：类型名'的方式说明类型
# 注意：方法一和二不能同时使用


def func5(names: list, obj: str, count=0):
    names.append(10)

# 4.不定长参数(python特有)
# 写一个函数求多个数的和
"""
第一种：在参数前加*,这个带*的参数会变成元组
注意：a.在调用的时候只能使用位置参数传参

第二种：在参数前面加**
会变成一个字典，代用的时候使用关键字参数传参，每个参数会有对应的键值对
"""
# 第一种：


def sum2(*nums):        # 参数在内存中以元组形式，接收实参
    s = 0
    for x in nums:
        s += x
    print(s)


sum2()
sum2(100)       # (100,)
sum2(1, 2, 5, 8, 5)     # (1, 2, 5, 8, 5)


# 如果定义函数的时候，不定长参数在定长的前面，后面定长的参数要用关键字传参
def sum4(*score, name):
    print(name, score)


sum4(18, 98, 36, name='小花')


# 第二种：
def func6(**nums):
    print(nums)


func6()     # {}
func6(x=10)     # 关键字参数  {'x': 10}


# 经常是一个*和两个*一起使用
def func7(*args, **kwargs):
    print(args, kwargs)


func7()             # () {}
func7(12, 23)       # (12, 23) {}
func7(a=89, b=33)      # () {'a': 89, 'b': 33}
func7(12, 23, a=45, b=66)       # (12, 23) {'a': 45, 'b': 66}