210201课内整理

210201课内整理

字符串内建函数

1， zfill 填充

语法：

字符串.zfill(宽度)

# 将1位数变为4位数
num = 1
# 方法一
result = str(num).zfill(4)
print(result)  # 0001
# 方法二：f(string)
result = f'{num:0>4}'
print(result)  # 0001

2， split 切割

语法：

字符串1.split(字符串2)

将字符串1中所有的字符串2作为切割点，对字符串1进行切割，返回列表（列表中没有字符串2）

str1 = 'abcd123abhkmlbmn'
result = str1.split('b')
print(result)    # ['a', 'cd123a', 'hkml', 'mn']

result = str1.split('123')
print(result)    # ['abcd', 'abhkmlbmn']
# 返回空字符串的情况有3中
# 切割点在前
result = str1.split('abc')
print(result)      # ['', 'd123abhkmlbmn']
#切割点在末尾
str1 = 'abcd123abhkmlbmn'
result = str1.split('n')
print(result)  # ['abcd123abhkmlbm', '']
# 切割点相连且重复
str1 = 'abcd123123abhkmlbmn'
result = str1.split('123')
print(result)    # ['abcd', '', 'abhkmlbmn']

3， replace 替换

语法1：

字符串1.replace(字符串2，字符串3)

将字符串1中所有的字符串2都替换成字符串3

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?

语法2：

字符串1.replace(字符串2，字符串3，count)

替换指定次数

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

4, maketrans() 和 translate 组合使用，同时替换多个元素

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

5, join

语法：

字符串.join(序列)

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

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

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

result = '*'.join('abc')
print(result)   # 'a*b*c'

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

# result = '+'.join([10, 20, 30])
# print(result)    # TypeError: sequence item 0: expected

6, eval()

将指定格式内容的字符串转换成对应类型的数据

# 将字符串中的列表直接转换成列表
str1 = '[10, 20, 30]'
result = list(str1)
print(result)   # ['[', '1', '0', ',', ' ', '2', '0', ',', ' ', '3', '0', ']']
str1 = '[10, 20, 30]'
result = eval(str1)
print(result, type(result))    # [10, 20, 30]  <class 'list'>
# 将字符串中的字典转换成字典
str2 = '{"name": "小明", "age": 18}'
result = eval(str2)
print(result, type(result))    # {'name': '小明', 'age': 18} <class 'dict'>

7， zip(序列)

将2个或多个序列合并成相互对应的一个序列

result = zip('ab', '12')
print(list(result))    # [('a', '1'), ('b', '2')]

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

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

# 练习: 交换字典的key和value
# dict1 = {'a': 'b', 'c': 'd', 'age': 18}   ->  {'b':'a', 'd': c, 18: 'age'}
# 方法一：直接遍历
dict1 = {'a': 'b', 'c': 'd', 'age': 18}
result = {}
for x in dict1:
    result[dict1[x]] = x    # 字典[key] = 值
print(result)   # {'b': 'a', 'd': 'c', 18: 'age'}
# 方法二：列表推导式
# 第一种
result = [(dict1[x], x) for x in dict1]
print(dict(result))   # {'b': 'a', 'd': 'c', 18: 'age'}
# 第二种
result = dict((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'}
# 方法四：zip函数
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， 创建函数

语法：

def 函数名(形参列表):

​ 函数说明文档

​ 函数体

说明：

def () 冒号 -->固定写法

函数名 -->命名要求同变量命名

形参列表 -->以’变量名1，变量名2，…‘形式存在，范围[0,n]
作用：将函数外部的数据传递到函数里面的通道
函数说明文档 --> 以三个引号开头和结尾的文本注释，解释函数的使用功能
函数体 -->实现函数功能的代码，和def保持一个缩进的一条或多条语句
步骤：
第一步：确定函数功能
第二步：根据功能确定函数名
第三步：确定形参；根据实现函数功能需要额外数据的个数来确定形参个数
第四步：实现函数功能，写函数体
第五步：写函数说明文档

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


# 练习2：定义一个函数求一个数的阶乘。（n! = 1*2*3*n-1*n）
def factorial(n):
    # n = 10
    s = 1
    for x in range(1, n+1):
        s *= x
    print(s)


# 练习3：定义一个函数可以统计一个字符串中空格出现的次数
def space_count(string):
    count = 0
    for x in string:
        if x == ' ':
            count += 1
    print(count)


# 练习4：定义一个函数可以统计一个字符串中另外一个字符串出现的次数
# str1 = 'how are you? i am fine, thank you! and you?'
# str2 = 'you'
def string_count(str1, str2):
    l1 = len(str1)
    l2 = len(str2)
    index = 0
    count = 0
    while True:
        if str1[index: index+l2] == str2:
            count += 1
            index += l2
        else:
            index += 1

        if index >= l1:
            break
    print(count)

重要结论：定义函数时不会执行函数体；调用函数时才会执行函数体

4,调用函数

语法：
函数名(实参列表)
说明：
函数名 -->必须是已经定义好的函数的函数名
实参列表 -->具体需要运算的数据，以‘数据1，数据2，…’形式存在
函数调用过程：
第一步：回到函数定义位置
第二步：传参（用实参给形参赋值）
第三步：执行函数体
第四步：确定函数返回值
第五步：回到函数调用位置，接着往后执行

sum2(10, 30)
# sum2(100)   # TypeError: sum2() missing 1 required positional argument: 'num2'
# sum2(1, 2, 3) # TypeError: sum2() takes 2 positional arguments but 3 were given
# 求10的阶乘
factorial(10)

# 求8的阶乘
factorial(8)

# 统计str1中空格的个数
str1 = 'how are you?'
space_count(str1)

# 统计str1中'are'的个数
string_count(str1, 'are')

# 统计str1中'a'的个数
string_count(str1, 'a')

函数的参数

1，实参的分类

1）位置参数

传参调用时与形参位置对应

2）关键字参数

以‘形参名1=数据1，形参名2=数据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
func1(20, 10, 30)   # a:20, b:10, c:30

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

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

2，形参的参数默认值

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

**注意：**定义函数时所有参数都可以有默认值，也可以部分参数有默认值
有默认值的参数在无默认值参数后面

def func2(a, b, c=10):
    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 func3(a=10, b, c):               # SyntaxError: non-default argument follows default argument
#     print(f'a:{a}, b:{b}, c:{c}')


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


func4()   # a:10, b:20, c:30
func4(100)  # a:100, b:20, c:30
func4(100, 200)     # a:100, b:200, c:30
func4(c=300)    # a:10, b:20, c:300

3，参数类型说明

1）方法一：给参数赋默认值，默认值的类型对应参数类型

2）方法二：在形参名后面加冒号 ‘形参名:类型名’

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

4，不定长参数

1）在参数前加*号, 返回元组,对应实参作为元组中的元素

在调用时，只能使用位置参数传参
如果定义函数时定长的参数在不定长参数的后面，定长参数传参必须使用关键字参数

2）在参数前加**号，返回字典，对应实参作为字典中的键值对

在调用时，使用关键字参数传参，每个关键字参数会作为字典中的一个键值对
**注意：**两种方式可以组合使用，作用：2种传参方式都可以使用，使传参更加灵活

# 第一种：
# 写一个函数求多个数的和
def sum2(*nums):
    s = 0
    for x in nums:
        s += x
    print(s)


sum2()    # ()
sum2(100)   # (100,)
sum2(10, 20)    # (10, 20)
sum2(10, 20, 30, 40)    # (10, 20, 30, 40)
sum2(1, 23, 5)      # (1, 23, 5)


def sum3(name, *scores):
    print(name, scores)


sum3('小明', 19, 89, 78)


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


sum4(19, 78, 34, name='小花')


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


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


def func7(*args, **kwargs):
    pass


func7()
func7(12)
func7(12, 23)
func7(a=90, b=23)
func7(12, 23, a=23, b=34)


def func8(a, *, b, c):
    print(a, b, c)


func8(10, b=23, c=9)

​