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 需要返回的数据(需要从函数内部传递到函数外部的数据)
2. 2. 怎样在函数外部获取函数的返回值
      获取函数调用表达式的值，就是获取函数的返回值。（函数调用表达式的值就是函数的返回值）
      返回值能做的事情，函数调用表达式都可以做
      “”"

3. 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. 在参数名前加*， 那么这个参数就可以同时接受多个实参(必须是位置参数)。
   原理：带的参数会变成一个元组，接受到的实参会变成元组中的元素
   注意：带的不定长参数在传参的时候只能用位置参数

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

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

练习：定义一个函数，求多个数的和

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