函数语法基础

最新推荐文章于 2022-11-10 16:38:43 发布

雪球滚滚滚

最新推荐文章于 2022-11-10 16:38:43 发布

阅读量137

点赞数 1

文章标签： python

本文链接：https://blog.csdn.net/weixin_60148315/article/details/120536873

版权

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

确定函数返回值(将函数内部的数据传递到函数外部)
提前结束函数(在执行函数体的时候，如果遇到了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）位置参数 - 直接将多个数据用逗号隔开，让实参和形参从位置上一一对应(第一个实参给第一个形参赋值，第二个实参给第二个形参赋值…)
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. （了解）不定长参数 - 一个形参可以同时接受多个实参

“”"

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

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

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

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

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

雪球滚滚滚

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
函数语法基础

python函数语法基础初学者定义函数的基本流程：第一步：确定函数功能第二步：根据函数功能确定函数名第三步：确定形参（看实现函数的功能需不需要额外的数据，需要几个）第四步：实现函数的功能(将形参当成对应的数据来使用)第五步：确定函数返回值第六步：写函数说明文档1. 调用函数（使用机器）“”"1）重要结论定义函数的时候不会执行函数体，调用数据才会执行函数体（重要!）2）调用函数语法: 函数名(实参列表)说明:a. 函数名 - 需要使用的函数的名字。（函数名必须是已经定义过的
复制链接

扫一扫