python第二周day6

python第二周day6(9.28)

1、review

# 1.r语法
str1 = r'\abc\n123'
# 2.字符串格式化
name = 'chenlai'
age = 12
str1 = '姓名：' + name + '年龄：' + str(age)
str1 = '姓名：%s,年龄：%d岁' % (name, age)
str1 = f'姓名：{name} 年龄：{age}'
# 3.字符串相关方法
# 字符串.join(序列)
# 字符串1.split(字符串2)/字符串1.split(字符串2,N)
# 字符串1.replace(字符串2，字符串3)/字符串1.replace(字符串2，字符串3,N)
# 字符串.strip()

# 4.函数(重要)
# 1）什么是函数：就是实现某一特定功能的代码的封装
# 2）函数的分类
"""
系统函数  -  max/min/sum/sorted/print/input/type/id/chr/ord等
自定义函数
"""
# 3) 定义函数（创建函数） - 造机器
"""
语法：
def 函数名（形参列表）：
    函数说明文档
    函数体
    
"""

2、day10字符串函数作业更改版

# 初学者定义函数的基本流程：
# 第一步：确定函数功能
# 第二步：根据函数功能确定函数名
# 第三步：确定形参（看实现函数的功能需不需要额外的数据，需要几个）
# 第四步：实现函数的功能（将形参当成对应的数据来使用）
# 第五步：确定函数返回值
# 第六步：写函数说明文档
# 所有的代码再看一遍
# 1.编写一个函数，交换指定字典的key和value。

def swap_key_value(dict1):
    """
    交换指定字典的键和值(功能说明区)
    :param dict1:字典（参数说明区）
    :return:None（返回值说明）
    """
    new_dict1 = {dict1[x]:x for x in dict1}
    print(new_dict1)
dict1 = {'a': 1, 'b': 2, 'c': 3}
swap_key_value(dict1)
# 2.编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串

# str2 = ''
# for x in str1:
#     if 'a' <= x <= 'z' or 'A' <= x <= 'Z':
#         str2 += x
# print(str2) # abcd

def get_alphabet(str1):
    """
    打印字符串中字母
    :param str1:指定的字符串
    :return:None
    """
    result = ''.join(x for x in str1 if 'a' <= x <= 'z' or 'A' <= x <= 'Z') #推导式+join(重要)
    print(result)
str1 = '12a&bc12d-+'
get_alphabet(str1)
# **3.写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母
def capitalize(str1):
    """
    将第一个字符是小写字母的字符串转换成对应的大写字母
    :param str1: 字符串
    :return: None
    """
    first = str1[0]
    if first.islower():
        result = first.upper() + str1[1:]
        print(result)
    else:
        print(str1)
str1 = 'abc'
capitalize(str1)  # Abc
# 4.写一个自己的endswith函数，判断一个字符串是否以指定的字符串结束
def endswith(str1, str2):
    """
    判断一个字符串是否以指定的字符串结束
    :param str1: 原字符串
    :param str2: 结尾的字符串
    :return:None
    """
    len2 = len(str2)
    print(str1[-len2:] == str2)
endswith('abc231ab', 'ab')
# 5.写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串
def isdigit(str1):
    """
    判断一个字符串是否是纯数字字符串
    :param str1:指定字符串
    :return:None
    """
    for x in str1:
        if not '0' <= x <= '9':
            print(False)
            break
    else:
        print(True)
# 6.写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母
def upper(str1):
    new_str = ''.join(chr(ord(x)-32) if 'a' <= x <= 'z' else x for x in str1)#join三目运算符+join
    print(new_str)
str1 = 'abH23好rp1'
upper(str1)  #bABH23好RP1
# 'am89'-->'AM89'
# 7.写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充
def r_just(str1, width, fill_char):
    """

    :param str1:
    :param width:
    :param fill_char:
    :return: None
    """
    len1 = len(str1)
    diff = width - len1
    if diff <= 0:
        result = str1
    else:
        result = fill_char * diff + str1
    print(result)
r_just('abc', 2, 0) # abc
# 8.写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1
def index(list1, item):
    """
    统计指定列表中指定元素的所有下标(所有提取可以用推导式+join)
    :param list1:
    :param item:
    :return:
    """
    result = ','.join(str(i) for i in range(len(list1)) if list1[i] == item)
    if not result:
        result = -1
    print(result)
index([1, 2, 45, 'abc', 1, '你好', 1, 0], 1)
# 9.写一个自己的len函数，统计指定序列中元素的个数
def len1(y):
    count = len(y)
    print(count)
len1([1, 3, 5, 6]) # 4
len1((1, 34, 'a', 45, 'bbb')) # 5
len1('hello w')# 7
# 10.写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
def max1(seq): # [序列] 先统一转换成列表
    if type(seq) == dict:
        seq = list(seq.values())
    else:
        seq = list(seq)

    m = seq[0]
    for x in seq[1:]:
        if x > m:
            m = x
    print(m)
max1({'小明':90, '张三': 76, '路飞':30, '小花': 98})
max1([-7, -12, -1, -9])
# 11.
# 12.写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串
# 工具用的好，方法用的好（反复去敲）
def replace(str1, old ,new):
    # 方法一
    result = new.join(str1.split(old)) # join+切割
    print(result)
    # 方法二（遍历+新的长度取）
    index = 0
    len1 = len(old)
    result = ''
    while index < len(str1):
        if str1[index: index+len1] == old:
            result += new
            index += len1
        else:
            result += str1[index]
            index += 1
    print(result)


replace('how are you? and you?','you','me')

3、调用函数

1.调用函数（使用机器）

1）重要结论

定义函数的时候不会执行函数体，调用数据才会执行函数体（重要），调用多少次执行多少次

2）调用函数

语法：函数名（实参列表）

说明:

a.函数名 - 需要使用的函数的名字。（函数名必须是已经定义过的函数的函数名）

b.（） - 固定写法

c.实参列表 - 多个数据用逗号隔开：数据1，数据2，数据3，。。。（任何有结果的表达式，除赋值语句）

​ 原则上定义函数的时候有多少个形参，调用函数就需要多少个实参

3）函数调用过程

当代码执行到函数调用表达式的时候：

第一步：回到函数定义的位置，用实参给形参赋值（传参）

第二步：执行函数体

第三步：确定函数返回值

第四步：回到函数调用的位置，接着往后执行

1）调用函数会执行函数体（调用多少次就执行多少次）

def func1():
    # print([10, 20][100])
    print('=====')
    print('-----')
func1()
func1()
# 2)
def func1():
    pass
# func1(1)  # TypeError: func1() takes 0 positional arguments but 1 was given
def func2(x):
    pass
# func2()  # TypeError: func2() missing 1 required positional argument: 'x'
# func2(10, 20)  # TypeError: func2() takes 1 positional argument but 2 were given
func2(12)
def func3(x,y,z):
    pass
func3(1, 3, 4)

3. 每个实参可以是任何有结果的表达式(一步一步的解析)

def func4(x):
    pass
a = 10
func4(a)
func4(200-100*2+1)
func4('abc')

str1 = 'hello'
func4(str1)
func4(str1[1:])
func4(str1.upper()) # func4('HELLO')
func4(str1.upper()+'123') # func4('HELLO123')
func4(f'你好：{str1}') # func4('你好：hello')
# 举例补充：

4、返回值

掌握+熟悉
1.返回值 - 将函数内部的数据传递到函数外部(产生了一个新的数据，并且需要继续使用)
“”"
1）怎样将一个数据作为函数的返回值
语法：
return 需要返回的数据（需要从函数内部传递到函数外部的数据）
return (数据1，数据2，。。。)
2）怎样在函数外部获取函数的返回值
获取函数调用表达式的值，就是获取函数的返回值。（函数调用表达式的值就是函数的返回值）
返回值能做的事情，函数调用表达式都可以做
“”"

def sum2(num1,num2):
    # print(num1+num2)
    # num1 = 1,num2 = 2
    return(num1+num2) # return 3
print(3)
print(sum2(1, 2))
b = sum2(1,2)
list1 = [9, 0, sum2(1,2)]
print(b) # 返回值是什么，调用函数就可以做什么。
x = 'ABLOTebk'[-1]
print(x)

result = max([9, 12, 20, 65])

# 练习
# 练习：执行以下代码后控制台的打印结果是？
def func(x, y):
    # x=[10,20],y=30
    x.append(y*2) # x= [10,20,60]
    return x      # return [10,20,60]


list1 = [func([10, 20], 30), 'abc'] # list1= [[10,20,60],'abc']
print(list1[0][-1]) #[10,20,60][-1] --> 60

5、return关键字

1.return 关键字
“”"
return的作用有两个：
1）确定函数返回值（将函数内部的数据传递到函数外部）
2）提前结束函数（在执行函数体的时候，如果遇到return,那么函数直接结束）
“”"

def func1():
    print('====')
    return 10
    return  # None返回空什么都没有
    print('----')
    print('++++')
result = func1()
print(result)

print('---------------------')
def download(state):
    if not state:
        return
    print('连接服务器，下载数据')
download(True)   # 连接服务器，下载数据
download(False)  # 什么都没有

def odevity(num):
    if num % 2:
        return '奇数'
    return '偶数'

6、函数的参数（重要）

1.位置参数和关键字参数 - 根据实参提供的方式分的类
“”"
1）位置参数 - 直接将多个数据用逗号隔开，让实参和形参从位置上一一对应（第一个实参给第一个形参赋值，第二个实参给第二个形参赋值，）
2) 关键字参数 - 以’形参=实参’的形式传参
3）位置参数和关键字参数混用 - 位置参数必须在关键字参数的前面
“”"

def func1(x,y,z):
    print(f'x:{x},y:{y},z:{z}')
# 位置参数
func1(1,2,3)

# 关键参数
func1(x=10, y=20, z=30)
func1(z=30, y=20, x=10)
# 混用
func1(10, 20, z=30)
func1(10, z=30, y=20)
#func1(x=10,20,z=30)  #报错，必须位置参数在前面，关键字参数在后面  SyntaxError: positional argument follows keyword argument
result = sorted([23, 1, 12], reverse=True)#混用？？
print(result)

2.参数默认值
“”"
定义函数的时候可以通过’形参=数据’给参数赋默认值，调用函数的时候有默认值的参数可以不用传参；
定义函数的时候可以只给部分参数赋默认值，那么这个时候没有默认值的参数必须在有默认值的前面。
“”"

def func2(x=10, y=20, z=30):
    # x=100
    # x=100，y=200
    print(f'x:{x},y:{y},z:{z}')
func2()
func2(100)
func2(100, 200)
func2(100, 200, 300)
func2(y=201)
def func3(x, y, z=30):
    print(f'x:{x},y:{y},z:{z}')
def func3(x, y=20, z=30):
    print(f'x:{x},y:{y},z:{z}')

3.参数类型说明和返回值类型说明
“”"
参数类型说明：
1）无默认值参数：类型名
2）参数赋默认值
返回值类型说明：->类型名
“”"

# def func4(x:str, y = '')-> list:
#     return [1, 2, 3]
# func4()

def func5(x:list ,y =10)->list:
    pass

4.（了解）不定长参数 - 一个形参可以同时接受多个实参
“”"
1)在参数名前加*,那么这个参数就可以同时接受多个实参（必须是位置参数）。
原理：带的参数会变成一个元组，接受到的实参会变成元组中的元素
注意：带的不定长参数传数只能用位置参数传参
（掌握！）重要结论：结论：定义函数的时候，如果参数中有一个独立的*，它的作用是让你在调用这个函数的时候，*后面的参数必须用关键字参数传参。遇到的比较多

2）在参数名前加**，那么这个参数就可以同时接受多个实参（必须是关键字参数）
原理：带**的参数会变成一个字典，接受到的实参会变成字典中的键值对。

“”"

# 练习：定义一个函数，求多个数的和
# sum1(10, 20)  sum1(10, 20, 30) sum1(10, 20, 30, 40)

def sum1(*x):
    print(f'x:{x}')
sum1()       # x:()
sum1(20)     # x:(20,)
sum1(20, 12, 13)   # x:(20, 12, 13)

def func5(*x, y):
    pass
# *x,y = 12, 13, 24先给Y=24再给x
def func5(x,y,*z):
    print(f'x:{x},y:{y},z:{z}')
func5(10,20) # x:10,y:20,z:()
func5(10,20,30,40) # x:10,y:20,z:(30, 40)
#1. 结论：如果定长参数在*对应的不定长参数的后面，定长参数在传参的时候必须使用关键字参数
def func5(*x,y,z):
    print(f'x:{x},y:{y},z:{z}')
func5(10,20,30,y=40,z=10)
def func7(x,*y,z):
    print(f'x:{x},y:{y},z:{z}')
func7(10, z=100) # x:10,y:(),z:100
func7(10,20,30, z=100) # x:10,y:(20, 30),z:100

# 结论：定义函数的时候，如果参数中有一个独立的*，它的作用是让你在调用这个函数的时候，*后面的参数必须用关键字参数传参。【遇到的比较多】
def func8(x,*,y):
    pass
func8(8, y=20) # 只有两个形参，前面一个位置参数，后面一个关键字参数
# 2）**
def func9(**x):
    print(x)
func9() # {}
func9(n=10) # {'n': 10}
func9(n=9, y=0, z=10) # {'n': 9, 'y': 0, 'z': 10}
# 没有任何约束
def func10(*args,**kwargs):
    pass
func10()
func10(10,20)
func10(a=10)
func10(10,20,x=10,y=20)
# 高阶函数（重要），返回值（重要）