函数语法基础

python函数语法基础

初学者定义函数的基本流程:

第一步:确定函数功能
第二步:根据函数功能确定函数名
第三步:确定形参(看实现函数的功能需不需要额外的数据,需要几个)
第四步:实现函数的功能(将形参当成对应的数据来使用)
第五步:确定函数返回值
第六步:写函数说明文档

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()

# func1(10)     # TypeError: func1() takes 0 positional arguments but 1 was given


def func2(x):
    # x = 10
    pass


# func2()       # TypeError: func2() missing 1 required positional argument: 'x'

func2(10)

# func2(10, 20)  # TypeError: func2() takes 1 positional argument but 2 were given


def func3(x, y, z):
    pass


func3(10, 20, 30)

# func3(10, 20)       # TypeError: func3() missing 1 required positional argument: 'z'

# func3(10, 20, 30, 100)      # TypeError: func3() takes 3 positional arguments but 4 were given
3)每个实参可以是任何有结果表达式
def func4(x):
    pass


func4(10)

a = 10
func4(a)

func4(200 - 100 * 2 + 3)

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')


def sum2(num1, num2):
    # num1 = 100, num2 = 200
    print(num1 + num2)

sum2(10, 20)
sum2(100, 200)
  1. 返回值 - 将函数内部的数据传递到函数外部
    “”"

    1. 怎样将一个数据作为函数的返回值
      语法:
      return 需要返回的数据(需要从函数内部传递到函数外部的数据)
    1. 怎样在函数外部获取函数的返回值
      获取函数调用表达式的值,就是获取函数的返回值。(函数调用表达式的值就是函数的返回值)
      返回值能做的事情,函数调用表达式都可以做
      “”"
  2. def sum2(num1, num2):

    # num1 = 10, num2 = 20
       
       return num1 + num2      # return 30
    

    print(30)
    print(sum2(10, 20))

    a = 30
    b = sum2(10, 20)
    print(a, b)

    print(30 + 10)
    print(sum2(10, 20) + 10)

    x = sum2(10, 20)

    list1 = [30, 20, sum2(10, 20)]

    def get_alphabet(str1):
    result = ‘’.join(x for x in str1 if ‘a’ <= x <= ‘z’ or ‘A’ <= x <= ‘Z’)
    return result # ‘Mlskoa’

    x = get_alphabet(‘9Mlsko-=23a’)

    print(x)

    x = get_alphabet(‘9Mlsko-=23a’)[-1] # ‘Mlskoa’[-1]
    print(x)

    result = max([209, 89, 34, 5])

    
    
    
    
    
    ###### 练习:执行以下代码后控制台的打印结果是?
    
    
   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

return关键字

“”"
return的作用有两个:

  1. 确定函数返回值(将函数内部的数据传递到函数外部)
  2. 提前结束函数(在执行函数体的时候,如果遇到了return,那么函数直接结束)
    “”"
   def func1():
       print('========')
       return
       print('++++++++')
       print('--------')


   result = func1()
   print(result)

   print('---------------------------------------')


   def download(state):
       if not state:
           return
       print('连接服务器,下载数据')


   download(True)

   def odevity(num):
       if num % 2:
           return '奇数'
       return '偶数'
  1. 位置参数和关键字参数 - 根据实参提供的方式分的类
    “”"
    1)位置参数 - 直接将多个数据用逗号隔开,让实参和形参从位置上一一对应(第一个实参给第一个形参赋值,第二个实参给第二个形参赋值…)
    2)关键字参数 - 以’形参=实参’的形式传参
    3)位置参数和关键字参数混用 - 位置参数必须在关键字参数的前面

       
    
          
             def func1(x, y, z):
                 print(f'x:{x}, y:{y}, z:{z}')
          ```
    
          
    
    
       # 位置参数
    
       func1(10, 20, 30)
    
       # 关键参数
    
       func1(x=10, y=20, z=30)
       func1(y=20, z=30, x=10)
    
       # 混用
    
       func1(10, 20, z=30)
       func1(10, z=30, y=20)
    
       # func1(x=10, 20, 30)       # SyntaxError: positional argument follows keyword argument
    
       result = sorted([230, 8, 23, 5], reverse=True)
       print(result)
    

2. 参数默认值

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

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


   func2()
   func2(100)
   func2(100, 200)
   func2(100, 200, 300)
   func2(y=200)


   def func3(x, y=20, z=30):
       print(f'x:{x}, y:{y}, z:{z}')

3.参数类型说明和返回值类型说明

“”"
参数类型说明: 1) 无默认值参数: 类型名 2) 参数赋默认值
返回值类型说明: -> 类型名
“”"

   def func4(x: list, y='') -> list:
       pass

4. (了解)不定长参数 - 一个形参可以同时接受多个实参

“”"

  1. 在参数名前加*, 那么这个参数就可以同时接受多个实参(必须是位置参数)。
    原理:带的参数会变成一个元组,接受到的实参会变成元组中的元素
    注意:带
    的不定长参数在传参的时候只能用位置参数

(掌握!)重要结论:定义函数的时候,如果参数中有一个独立的*,它的作用是让你在调用这个函数的时候*后面的参数必须用关键字参数传参

  1. 在参数名前加**,那么这个参数就可以同时接受多个实参(必须是关键字参数)。
    原理:带**的参数会变成一个字典,接受到的实参会变成字典中的键值对
    “”"
练习:定义一个函数,求多个数的和
sum1(10, 20) sum1(1, 2, 30) sum1(20, 3, 4, 5)
   def sum1(*x):
       print(f'x:{x}')

   sum1()      # x:()
   sum1(20)    # x:(20,)
   sum1(10, 20)        # x:(10, 20)
   sum1(10, 20, 34, 5, 6)    # x:(10, 20, 34, 5, 6)


   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)

结论:如果定长参数在*对应的不定长参数的后面,定长参数在传参的时候必须使用关键字参数

   def func6(*x, y, z):
       print(f'x:{x}, y:{y}, z:{z}')


   func6(10, 20, 30, y=40, z=50)

   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, z):
       pass


   func8(10, y=20, z=30)

2) **

   def func9(**x):
       print(x)

   func9()     # {}
   func9(n=10)     # {'n': 10}
   func9(n=10, a=20, m=30)     # {'n': 10, 'a': 20, 'm': 30}


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

   func10()
   func10(10, 20)
   func10(a=10)
   func10(10, 20, x=10, y=20)
1. 编写一个函数,交换指定字典的key和value。
def swap_key_value(dict1):
    """
    交换指定字典的键和值(功能说明区)
    :param dict1: 一个字典(参数说明区)
    :return: None(返回值说明)
    """
    new_dict = {dict1[x]: x for x in dict1}
    print(new_dict)


swap_key_value({'a': 10, 'b': 20})
swap_key_value({100: 'a', 200: 'm'})
2.编写一个函数,提取指定字符串中所有的字母,然后拼接在一起产生一个新的字符串
def get_alphabet(str1):
    """
    打印字符串中字母
    :param str1: 指定的字符串
    :return: None
    """
    result = ''.join(x for x in str1 if 'a' <= x <= 'z' or 'A' <= x <= 'Z')
    return result


str2 = '12a&bc12d-+'
get_alphabet(str2)

str2 = '12M&bcP12d-+K'
get_alphabet(str2)
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)


capitalize('12ssh失敬失敬')
capitalize('m12ssh失敬失敬')
4.写一个自己的endswith函数,判断一个字符串是否以指定的字符串结束
def endswith(str1, str2):
    """
    判断一个字符串是否以指定的字符串结束
    :param str1: 原字符串
    :param str2: 结尾的字符串
    :return: None
    """
    len2 = len(str2)
    print(str1[-len2:] == str2)


endswith('hello world!', 'd')
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):
    """
    :param str1:
    :return:
    """
    new_str = ''.join(chr(ord(x)-32) if 'a' <= x <= 'z' else x for x in str1)
    print(new_str)


# 'am89-KLp'  ->  'AM89-KLP'

upper('am89-Klp')
7. 写一个自己的r_just函数,创建一个字符串的长度是指定长度,原字符串在新字符串中右对齐,剩下的部分用指定的字符填充
def r_just(str1, width, 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')
9.写一个自己的index函数,统计指定列表中指定元素的所有下标,如果列表中没有指定元素返回-1
def index(list1, item):
    """
    获取列表中指定元素的下标
    :param list1: 列表
    :param item: 指定元素
    :return: None
    """
    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], 10)
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([10, 34, 8, 9])
max1({10, 20, 45, 9})
max1({100: 10, 200: 30, 300: 5})
12.写一个自己的replace函数,将指定字符串中指定的旧字符串转换成指定的新字符串
def replace(str1, old, new):
    # 方法一:
    # result = new.join(str1.split(old))
    # 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('123amnaxy', 'a', 'b')    # 123bmnbxy
replace('asjdhf are sfdj!', 'you', 'me')
上一篇:【模板】计算几何


下一篇:回顾方法及加深