函数之基本结构

Posted 2022-04-09 dpsy921

4.1 基本结构

1. 本质：

   • 将多行代码拿到别处并起个名字，以后通过名字就可以找到这行代码并执行

2. 应用场景：

   • 代码重复执行

   • 代码量很多超过一屏，可以选择通过函数进行代码的分割

   • 写代码方式：面向过程----函数式编程（多）----面向对象编程

3. 基本结构

   # 函数的定义
   def 函数名():
       函数内容
       pass
   # 函数的执行
   函数名()

   

   # 示例一
   def list_data():
       v = [11,54,52]
       print(v[1])
   list_data() # 54

   View Code

    

   • 函数如果不被调用，则内部永远不会被执行

   

   # 练习题
   # 1.请写一个函数，函数计算列表 info = [11,22,33,44,55]中所有元素的和
   def list_data():
       s = 0
       info = [11, 22, 33, 44, 55]
       for i in info:
           s = s + i
       print(s)
   list_data()     # 165
   # 2.请写一个函数，用函数将列表拼接起来
   def new_list(a,b):
       c = []
       c.extend(a)
       c.extend(b)
       print(c)
   a1 = [555,4,6,5,6]
   a2 = [5646,86,6,]
   new_list(a1,a2)     # [555, 4, 6, 5, 6, 5646, 86, 6]
   # 3.计算一个列表的长度
   def list_len(age):
       conten = 0
       for i in age:
           conten +=1
       print(conten)
   v = [11,2,‘rtffd‘,‘r‘,‘g‘,‘fsd‘,77]
   list_len(v)     # 7

   练习题

    

4. 返回值

   • 函数没有返回值，默认返回：None

   • 函数内部执行过程中遇到return，就终止。

   • return 可以返回任意类型

   • 如果return后面写了多个结果,,返回给调用者一个tuple(元祖),调用者可以直接使用解构获取多个变量

   def func():
       return (1,2,3)
   ?
   v = func()
   print(v)    # (1, 2, 3)
   ?
   # 特殊:多个返回值，返回值为元组
   def func():
       return 5,8,"alex"
   ?
   v = func()
   print(v)    # (5, 8, ‘alex‘)

   def func(age):
       #函数
       return 9    # 返回默认值为9，默认：return None
   val = func(‘asdfghj‘)

   

   # 示例一
   1.让用户输入一段字符串，计算字符串中有多少个A字符的个数，有多少就在a.txt中写多少个"大王八"
   def jisuan_a(aa):
       s = 0
       for i in aa:
           if i ==‘A‘:
               s+=1
       return s
   def xieru_d(bb):
       if len(bb) == 0:
           return False
       with open(‘a.txt‘,mode=‘w‘,encoding=‘utf-8‘) as f:
           f.write(bb)
       return True
   a = input("请用户输入")
   a1 = jisuan_a(a)
   b = "大王八" * a1
   b1 = xieru_d(b)
   print(b1)
   ?
   # 示例二
   2. 写函数，计算一个列表中有多少个数字，打印： 列表中有%s个数字。
   # #    提示：type(‘x‘) == int 判断是否是数字。
   def a_list(b):
       s = 0
       for i in b:
           if type(i) == int:
               s = s + 1
       print(s)
   ?
   a = input("请输入列表")
   a = a_list(a)
   ?
   # 示例三
   2. 写函数，计算一个列表中偶数索引位置的数据构造成另外一个列表，并返回。
   def a_list(b):
       b1 = b[::2]
       return b1
   a = input("请输入列表")
   a = a_list(a)
   ?
   # 示例三
   3. 读取文件，将文件的内容构造成指定格式的数据，并返回。
   a.log文件
       alex|123|18
       eric|uiuf|19
       ...
   目标结构：
   a.  ["alex|123|18","eric|uiuf|19"] 并返回。
   b. [[‘alex‘,‘123‘,‘18‘],[‘eric‘,‘uiuf‘,‘19‘]]
   c. [
       ‘name‘:‘alex‘,‘pwd‘:‘123‘,‘age‘:‘18‘,
       ‘name‘:‘eric‘,‘pwd‘:‘uiuf‘,‘age‘:‘19‘,
   ]
   # a
   ?
   def a_1(a):
       b = []
    #   a = open(‘log.txt‘,mode=‘r‘,encoding=‘utf-8‘)
       for i in a:
           i = i.strip()
           b.append(i)
       print(b)
       return
   a1 = a_1(open(‘log.txt‘,mode=‘r‘,encoding=‘utf-8‘))
   ?
   # b
   ?
   def a_1(a):
       b = []
       for i in a:
           i = i.strip()
           i = i.split(‘|‘)
           b.append(i)
       print(b)
       return
   a1 = a_1(open(‘log.txt‘,mode=‘r‘,encoding=‘utf-8‘))
   ?
   # c
   def a_1(a):
       b = []
       c = 
       for i in a:
           i = i.strip()
           i = i.split(‘|‘)
           c[‘name‘] = i[0]
           c[‘pwd‘] = i[1]
           c[‘age‘] = i[2]
       b.append(c)
       print(b)
       return
   a1 = a_1(open(‘log.txt‘,mode=‘r‘,encoding=‘utf-8‘))

   示例

    

5. 总结

   # 情况一
   def f1():
       pass
   f1()
   ?
   # 情况二
   def f2(a1):
       pass
   f2(123)
   ?
   # 情况三
   def f3()：
       return 1
   v1 = f3()
   ?
   # 情况四
   def f4(a1,a2):
       #....
       return 333
   v2 = f4(1,22)

   • 　
     总结一：
     
     定义：def 关键词开头，空格之后接函数名称和圆括号()，最后还有一个":"。
     
     　　　def 是固定的，不能变，必须是连续的def三个字母，不能分开。。。它们要相亲相爱的在一起。
     
     　　　空格 为了将def关键字和函数名分开，必须空(四声)，当然你可以空2格、3格或者你想空多少都行，但正常人还是空1格。
     
     　　　函数名：函数名只能包含字符串、下划线和数字且不能以数字开头。虽然函数名可以随便起，但我们给函数起名字还是要尽量简短，并能表达函数功能
     
     　　　括号：是必须加的，先别问为啥要有括号，总之加上括号就对了！
     
     注释：每一个函数都应该对功能和参数进行相应的说明，应该写在函数下面第一行。以增强代码的可读性。
     
     调用：就是 函数名() 要记得加上括号，好么好么好么。

      

6. if__name__ == ‘__main__‘

   • __name__ == ‘__main__‘ 执行的文件就是__name__所在的文件

     • 控制当这个py文件被当作脚本直接执行的时候，就执行这里面的代码

   • __name__ == ‘文件名‘ __name__就是所在文件被导入的时候

     • 当这个py文件被当作模块导入的时候，就不执行这里面的代码