Python全栈之文件函数和函数参数

作者:熬夜泡枸杞 时间:2023-05-11 02:28:21 

目录
  • 1. 文件相关函数

  • 2. 函数_函数的参数

    • 2.1 函数

    • 2.2 函数的参数

  • 3. 收集参数

    • 4. 命名关键字_总结

      • 小提示:

    • 5. 小练习

      • 练习问题:

      • 练习答案:

    • 总结

      1. 文件相关函数


      # ### 刷新缓冲区
      """
      # 刷新缓冲区 flush
         # 当文件关闭的时候自动刷新缓冲区
         # 当整个程序运行结束的时候自动刷新缓冲区
         # 当缓冲区写满了  会自动刷新缓冲区
         # 手动刷新缓冲区
      """
      """
      fp = open("ceshi1.txt",mode="a",encoding="utf-8")
      fp.write("abc")
      # 手动刷新缓冲区,直接把内容写入到文件
      fp.flush()
      while True:
      pass
      fp.close()
      """
      # ### 文件相关的函数
      """fp这个对象本身是迭代器,可以把文件中的内容按照换行一行一行遍历出来"""
      """
      fp = open("ceshi1.txt",mode="r",encoding="utf-8")
      #readable()    功能: 判断文件对象是否可读
      print(fp.readable())
      #writable()    功能: 判断文件对象是否可写
      print(fp.writable())
      # 遍历fp文件对象
      for i in fp:
      print(i)
      """
      # 1.readline()     功能: 读取一行文件内容
      '''
      with open("ceshi1.txt",mode="r",encoding="utf-8") as fp:
      res = fp.readline()
      print(res)
      res = fp.readline()
      print(res)
      res = fp.readline()
      print(res)
      res = fp.readline()
      print(res)
      # (1)一次把所有内容都读取出来
      with open("ceshi1.txt",mode="r",encoding="utf-8") as fp:
      # 先读取一行
      res = fp.readline()
      # 判断是不是空,不是空在循环
      while res:
      print(res)
      # 在读取一行,放到循环中判断.
      res = fp.readline()
      # (2)注意点:readline(读取的字符数)
      print("<====================>")
      with open("ceshi1.txt",mode="r",encoding="utf-8") as fp:
      """
      读取的字符数量 > 实际当前行字符数量的时候 => 按照当前行读取
      读取的字符数量 < 实际当前行字符数量的时候 => 按照实际数量来读
      """
      res = fp.readline(300)
      print(res)
      '''
      print("<====================>")
      # 2.readlines()    功能:将文件中的内容按照换行读取到列表当中
      lst_new = []
      with open("ceshi1.txt",mode="r+",encoding="utf-8") as fp:
      lst = fp.readlines()
      for i in lst:
      lst_new.append(i.strip())
      print(lst_new)

      # 3.writelines()   功能:将内容是字符串的可迭代性数据写入文件中 参数:内容为字符串类型的可迭代数据
      lst = ['床前明月光', '疑是地上霜', '举头望明月', '低头想家乡']
      with open("ceshi2.txt",mode="w+",encoding="utf-8") as fp:
      fp.writelines(lst)
      # ### 实现效果:加入换行效果,并且插入一句话:王文真帅呀 , 插在低头想家乡的前面
      lst_new = []
      # 先把内容插入到原列表中
      lst.insert(-1,"王文真帅呀")
      # 循环原列表,把每一个元素拼接\n , 放到新列表
      for i in lst:
      lst_new.append(i + "\n")
      print(lst_new)
      # 把新列表中的每行内容插入到文件中
      with open("ceshi2.txt",mode="w+",encoding="utf-8") as fp:
      fp.writelines(lst_new)
      # 注意点,内容必须是字符串,不能是整型
      """
      lst = [1,2,3]
      with open("ceshi2.txt",mode="w+",encoding="utf-8") as fp:
      fp.writelines(lst)
      """
      # 4.truncate()     功能: 把要截取的字符串提取出来,然后清空内容将提取的字符串重新写入文件中 (字节)
      with open("ceshi2.txt",mode="r+",encoding="utf-8") as fp:
      fp.truncate(3)

      """
      seek(字节)
      truncate(字节)
      read(字符/字节)
      readline(字符/字节)
      """

      2. 函数_函数的参数

      2.1 函数


      # ### 函数
      """
      概念:功能 (包裹一部分代码 实现某一个功能 达成某一个目的)
      特点:可以反复调用,提高代码的复用性,提高开发效率,便于维护管理
      """
      # 1.函数基本格式
      """
      # 定义一个函数
      def 函数名():
      code1
      code
      # 调用函数
      函数名()
      """
      # 定义函数
      def func():
      print("我是一个函数 ... ")
      # 调用函数
      func()
      # 2.函数的命名
      """
      字母数字下划线,首字符不能为数字
      严格区分大小写,且不能使用关键字
      函数命名有意义,且不能使用中文哦
      驼峰命名法:
      (1) 大驼峰命名法: 每个单词的首字符要大写 (类的命名)
      mycar => MyCar
      (2) 小驼峰命名法: 除了第一个单词首字符小写外,剩下单词首字符大写 (函数或者变量)
      mycar => myCar
      _命名法:可以将不同的单词用_拼接在一起
      mycar => my_car
      symmetric_differencesymmetricDifference SymmetricDifference
      """
      # 函数定义
      def cfb_99():
      for i in range(1,10):
      for j in range(1,i+1):
      print("{:d}*{:d}={:2d} ".format(i,j,i*j) ,end="")
      print()
      # 调用函数
      for i in range(5):
      cfb_99()

      2.2 函数的参数


      # ### 函数的参数
      """
      参数: 函数运算时需要的值
      参数种类:
      (1)形参: 形式参数,在函数的定义处
      (2)实参: 实际参数,在函数的调用处
      形参的种类:
      1.普通形参(位置形参) 2.默认形参 3普通收集形参 4.命名关键字形参 5.关键字收集形参
      实参的种类:
      1.普通实参 2.关键字实参
      原则:
      形参和实参要一一的对应
      """
      # 1.普通形参(位置形参)
      # 定义函数
      """hang,lie普通形参,在函数定义处"""
      def small_star(hang,lie):
      i = 0
      while i < hang:
      j = 0
      while j < lie:
      print("*",end="")
      j +=1
      print()
      i += 1
      # 调用函数
      """10,10普通实参,在函数的调用处"""
      small_star(10,10)
      small_star(2,3)

      # 2.默认形参
      """hang,lie默认形参,在函数定义处"""
      """
      如果给予实参,那么使用实参
      如果没有给予实参,那么使用参数身上的默认值
      """
      def small_star(hang=10,lie=10):
      i = 0
      while i < hang:
      j = 0
      while j < lie:
      print("*",end="")
      j +=1
      print()
      i += 1
      small_star(4,8)
      small_star(8)
      small_star()
      # 3.普通形参 + 默认形参
      """普通形参必须写在默认形参的前面不能调换位置"""
      def small_star(hang,lie=10):
      i = 0
      while i < hang:
      j = 0
      while j < lie:
      print("*",end="")
      j +=1
      print()
      i += 1
      small_star(5,7)
      # small_star(5)
      # small_star() error
      # 4.关键字实参
      print("<=============>")
      """
      1.如果都是关键字实参,可以任意调整实参的顺序
      2.普通实参必须写在关键字实参的前面
      """
      def small_star(hang,a,b,c,lie=10):
      i = 0
      while i < hang:
      j = 0
      while j < lie:
      print("*",end="")
      j +=1
      print()
      i += 1
      # hang a ... lie 具体指定参数的值叫做关键字实参,在函数的调用处;
      # small_star(hang=3,a=4,b=5,c=6,lie=7)
      # small_star(b=5,c=6,lie=7,a=4,hang=3)
      small_star(3,4,b=5,c=6,lie=7)
      small_star(3,4,b=5,lie=7,c=6)
      # small_star(b=5,c=6,lie=7,3,4) error

      3. 收集参数


      # ### 收集参数
      """
      (1) 普通收集形参: 专门用来收集那些多余的没人要的普通实参
        收集之后,会把多余实参打包成一个元组
        参数头上1个星星
      def func(*args):
      pass
      args => arguments
      """
      def func(a,b,c,*args):
      print(a,b,c) # 1 2 3
      print(args)  # (4,5,6)
      func(1,2,3,4,5,6)

      # 任意个数值得累加和
      def mysum(*args):
      total = 0
      for i in args:
      total += i
      print(total)
      mysum(1,2,3,4,4,45,10,100)
      """
      (2) 关键字收集形参:专门用来收集那些多余的没人要的关键字实参
         收集之后,会把多余关键字实参打包成一个字典
      参数头上有2个星星
      def func(**kwargs):
      pass
      kwargs => keyword arguments
      """
      def func(a,b,c,**kwargs):
      print(a,b,c)
      print(kwargs) # {'f': 100, 'e': 200, 'z': 12}
      func(c=1,a=3,b=10,f=100,e=200,z=12)

      # 拼接任意个数值变成字符串
      """
      班长: 赵万里
      班花: 马春陪
      划水群众: 赵沈阳,李虎凌,刘子涛
      """
      def func(**kwargs):
      strvar1 = ""
      strvar2 = ""
      # 定义职位信息
      dic = {"monitor":"班长","classflower":"班花"}
      print(kwargs)
      # 共5次循环
      for k,v in kwargs.items():
      if k in dic:
      # 将2次循环的结果通过+= 拼接在一起
      strvar1 += dic[k] + ":" + v + "\n"
      else:
      # 将3次循环的结果通过+= 拼接在一起
      strvar2 += v + " , "
      print(strvar1.strip())
      print("划水群众:",strvar2.strip(" , "))
      """
      # print(k,v)
      k       v
      monitor 赵万里
      classflower 马春陪
      water1 赵沈阳
      water2 李虎凌
      water3 刘子涛
      {'monitor': '赵万里', 'classflower': '马春陪', 'water1': '赵沈阳', 'water2': '李虎凌', 'water3': '刘子涛'}
      """
      func(monitor="赵万里",classflower="马春陪",water1="赵沈阳",water2="李虎凌",water3="刘子涛")

      4. 命名关键字_总结


      # ### 命名关键字参数
      """
      (1) def func(a,b,*,c,d) 跟在*号后面的c和d是命名关键字参数
      (2) def func(*args,e,**kwargs) 加在*args和**kwargs之间的参数都是命名关键字参数
      命名关键字参数 : 在调用函数时,必须使用关键字实参的形式来进行调用;
      """
      # 定义方法一
      def func(a,b,*,c,d):
      print(a,b)
      print(c,d)
      # 必须指定关键字实参,才能对命名关键字形参进行赋值
      func(1,2,c=3,d=4)
      # 定义方法二
      def func(*args,e,**kwargs):
      print(args)   # (1, 2, 3, 4)
      print(e)      # 3
      print(kwargs) # {'a': 1, 'b': 2}
      func(1,2,3,4,a=1,b=2,e=3)
      # ### 星号的使用
      """
      * 和 ** 如果在函数的定义处使用:
      *  把多余的普通实参打包成元组
      ** 把多余的关键字实参打包成字典
      * 和 ** 如果在函数的调用处使用:
      *  把元组或者列表进行解包
      ** 把字典进行解包
      """
      def func(a,b,*,c,d):
      print(a,b)
      print(c,d)
      tup = (1,2)
      # 函数的调用处 *号用法
      func(*tup,c=3,d=4) # func(1,2,c=3,d=4)
      # 函数的调用处 **号用法
      dic={"c":3,"d":4}
      func(1,2,**dic)    # func(1,2,c=3,d=4)
      # 综合写法
      # 函数的调用处
      tup = (1,2)
      dic={"c":3,"d":4}
      func(*tup,**dic)
      # 定义成如下形式,可以收集所有的实参
      def func(*args,**kwargs):
      pass
      # 总结: 当所有的形参都放在一起的时候,顺序原则:
      """
      普通形参 -> 默认形参 -> 普通收集形参 -> 命名关键字形参 -> 关键字收集形参
      """
      def f1(a, b, c=0, *args, **kw):
         print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
      def f2(a, b, c=0, *, d, **kw):
         print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
      # 以上两个函数 打印结果
      #(一)
      f1(1, 2) # a =1 b=2 c=0 args=() kw={}
      f1(1, 2, c=3) # a=1,b=2,c=3,args=() kw={}
      f1(1, 2, 3, 'a', 'b') #a=1 b=2 c=3 args=(a,b) kw={}
      f1(1, 2, 3, 'a', 'b', x=99) # a=1 b=2 c=3 args=(a,b) kw={x:99}
      f2(1, 2, d=99, ext=None)#a=1 b=2 c=0 d=99 kw={ext:None}
      #(二)
      args = (1, 2, 3, 4)
      kw = {'d': 99, 'x': '#'}
      # f1(1,2,3,4,d=99,x=#)
      f1(*args, **kw) # a=1 b=2 c=3 args=(4,) kw={d:99,x:#}

      #(三)
      myargs = (1, 2, 3)
      mykw = {'d': 88, 'x': '#'}
      # f2(1,2,3,d=88,x=#)
      f2(*myargs, **mykw) # a=1,b=2,c=3 d=88 kw={x:#}
      #(四)
      def f1(a, b, c=0, *args,d,**kw):
         print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
         print(d)
      f1(1,2,3, 'a', 'b',d=67, x=99,y=77) # a=1 b=2 c=3 args=(a,b)  kw={x:99,y:77}
      # d=67

      小提示:


      出现网络延迟堵塞的时候,自己用flush刷一下
      strvar = alex Nb
      # 注意:这里虽然说把首字母大写了,但是会把后面的大写字母变成小写
      print(srvar.capitalize) #Alex nb

      5. 小练习

      练习问题:


      #1.有如下文件,a1.txt,里面的内容为:
      键盘敲烂,
      月薪过万.
      键盘落灰,
      狗屎一堆.
      分别完成以下的功能:
      a:将原文件全部读出来并打印。
      b:在原文件后面追加一行内容:信不信由你,反正我信了。
      c:将原文件全部读出来,并在后面添加一行内容:信不信由你,反正我信了。
      d:将原文件全部清空,换成下面的内容:
      每天坚持一点,
      每天努力一点,
      每天多思考一点,
      慢慢你会发现,
      你的进步越来越大。
      e:将原文件内容全部读取出来,
      并在'键盘落灰'这一行的前面加一行,'年薪百万'
      然后将更改之后的新内容,写入到一个新文件:a1.txt。
      #2.有如下文件,t1.txt,里面的内容为:
      葫芦娃,葫芦娃,
      一根藤上七个瓜
      风吹雨打,都不怕,
      啦啦啦啦。
      上面的内容你肯定是心里默唱出来的,对不对
      分别完成下面的功能:
      a:以r+的模式打开原文件,判断原文件是否可读,是否可写。
      b:以r的模式打开原文件,利用for循环遍历文件对象。
      c:以r的模式打开原文件,以readlines()方法读取出来,并循环遍历
      d:以r模式读取‘葫芦娃,'前四个字符。
      e:以r模式读取第一行内容,并去除此行前后的空格,制表符,换行符。
      f:以r模式打开文件,从‘风吹雨打.....'开始读取,一直读到最后。
      g:以a+模式打开文件,先追加一行:‘老男孩教育'然后在全部读取出来。
      h:截取原文件,截取内容:‘葫芦娃,葫芦娃,'

      #3.文件a.txt内容:每一行内容分别为商品名字,价钱,个数。
      apple 10 3
      tesla 100000 1
      mac 3000 2
      lenovo 30000 3
      chicken 10 3
      变成如下数据格式,并计算出总价格
      [
      {'name':'apple','price':10,'amount':3},
      {'name':'tesla','price':1000000,'amount':1}
      ]
      #4.定义函数:打印用户传入的容器类型数据长度
      #5.定义函数:参数为容器类型数据,打印所有奇数位索引对应的元素
      #6.定义函数:,接收一个参数(可迭代性数据),用_让元素相连成字符串,打印出来
      #7.输入字符串 "k:1|k1:2|k2:3|k3:4" 处理成字典 {'k':1,'k1':2....} 打印出来
      #8.输入列表li= [11,22,33,44,55,66,77,88,99,90]
      # 将大于 66 的值保存至字典的k1键中,
      # 将小于 66 的值保存至字典的k2键中。
      # 打印字典 {'k1': 大于66的所有值列表, 'k2': 小于66的所有值列表}

      练习答案:


      # a
      with open("a1.txt",mode="r",encoding="utf-8") as fp:
         print(fp.read())
      # b
      with open("a1.txt",mode="a+",encoding="utf-8") as fp:
         fp.write("\n\t信不信由你,反正我信了")
      # c
      with open("a1.txt",mode="a+",encoding="utf-8") as fp:
         print(fp.read())
         fp.write("\n\t信不信由你,反正我信了")
      # d
      strvar ="""    
         每天坚持一点,
      每天努力一点,
      每天多思考一点,
      慢慢你会发现,
      你的进步越来越大。
      """
      with open("a1.txt",mode="w+",encoding="utf-8") as fp:
         fp.write(strvar)
      # e
      with open("a2.txt",mode="r+",encoding="utf-8") as fp:
         lst = fp.readlines()    
         print(lst) # ['\t键盘敲烂,\n', '\t月薪过万.\n', '\t键盘落灰,\n', '\t狗屎一堆.\n']
         lst.insert(-2,"\t年薪百万\n")
      with open("a3.txt",mode="w+",encoding="utf-8") as fp:
         fp.writelines(lst)
      # #####################################
      # a
      with open("a4.txt",mode="r+",encoding="utf-8") as fp:
         print(fp.readable())
         print(fp.writable())
      # b
      with open("a4.txt",mode="r",encoding="utf-8") as fp:
         for i in fp:
             print(i)
      # c
      with open("a4.txt",mode="r",encoding="utf-8") as fp:
         lst = fp.readlines()
         for i in lst:
             print(i)
      # d
      with open("a4.txt",mode="r",encoding="utf-8") as fp:
         print(fp.read(4))
      # e
      with open("a4.txt",mode="r",encoding="utf-8") as fp:
         print(fp.readline().strip())
      # f
      print("<====>")
      with open("a4.txt",mode="r",encoding="utf-8") as fp:
         lst = fp.readlines()
         for i in lst[-2:]:
             print(i)
      # g
      with open("a4.txt",mode="a+",encoding="utf-8") as fp:
         fp.write("\n老男孩教育")
         fp.seek(0)
         print(fp.read())
      # h
      with open("a4.txt",mode="r+",encoding="utf-8") as fp:
         fp.truncate(24)

      # #####################################
      """
      [
      '\tapple 10 3\n',
      '\ttesla 100000 1\n',
      '\tmac 3000 2\n',
      '\tlenovo 30000 3\n',
      '\tchicken 10 3'
      ]
      """
      print("><======================?")
      lst_new = []
      total = 0
      with open("a5.txt",mode="r+",encoding="utf-8") as fp:
         lst = fp.readlines()
         # print(lst)
         for i in lst:
             # 定义空字典
             dic = {}
             # 取出字符串两边的空白
             lst = i.strip().split()
             print(lst)
             # 拼装字典
             dic["name"] = lst[0]
             dic["price"] = int(lst[1])
             dic["amount"] = int(lst[2])
             # 累计当前商品的价格总数
             res = dic["price"] * dic["amount"]
             # 累计所有的商品价格总数
             total += res
             # 把当前商品的信息字典追加到列表中
             lst_new.append(dic)
      print(total)
      print(lst_new)
      """
      [
      {'name': 'apple', 'price': 10, 'amount': 3},
      {'name': 'tesla', 'price': 100000, 'amount': 1},
      {'name': 'mac', 'price': 3000, 'amount': 2},
      {'name': 'lenovo', 'price': 30000, 'amount': 3},
      {'name': 'chicken', 'price': 10, 'amount': 3}
      ]
      """
      # 4.
      def func(container):
         return len(container)
      res = func((1,2,3,4))
      print(res)
      # 5.
      def func(container):
         # 方法一
         # for i in range(1,len(container),2):
             # print(container[i])
         # 方法二
         for i in container[1::2]:
             print(i)
      func([11,22,33,44,55,666])
      # 6.
      def func(container):
         """
         # 方法一
         strvar = ""
         for i in container:
             strvar += str(i) + "_"
         return strvar.rstrip("_")
         """
         # 方法二
         lst_new = []
         for i in container:
             lst_new.append(str(i))
         return "_".join(lst_new)

      container = [1,2,3,4,5]
      res = func(container)
      print(res)

      # 7
      strvar = "k:1|k1:2|k2:3|k3:4"
      def func(strvar):
         '''
         # 方法一
         lst = strvar.split("|")
         print(lst) # ['k:1', 'k1:2', 'k2:3', 'k3:4']
         dic = {}
         for i in lst:
             k,v = i.split(":")
             dic[k] = v
             """
             ['k', '1']
             ['k1', '2']
             ['k2', '3']
             ['k3', '4']
             """
         return dic
         '''
         # 方法二
         lst = strvar.split("|")
         lst_new = []
         for i in lst:
             lst_new.append(i.split(":"))
         return dict(lst_new)

      print(func(strvar))
      # 8
      li= [11,22,33,44,55,66,77,88,99,90]
      lst1 = []
      lst2 = []
      dic = {"k1":None,"k2":None}
      def func(li):
         for i in li:
             if i > 66:
                 lst1.append(i)
             elif i < 66:
                 lst2.append(i)
         dic["k1"] = lst1
         dic["k2"] = lst2
         return dic
      res = func(li)
      print(res)  

      总结

      本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注脚本之家的更多内容!

      来源:https://blog.csdn.net/weixin_46818279/article/details/121005991

      标签:Python,文件,函数,参数
      0
      投稿

      猜你喜欢

    • 用TensorFlow实现lasso回归和岭回归算法的示例

      2021-09-08 19:48:30
    • 使用Go语言解决Scan空格结束输入问题

      2024-04-27 15:38:37
    • mysql 8.0.12 快速安装教程

      2024-01-28 09:01:40
    • pytorch使用-tensor的基本操作解读

      2022-05-23 03:15:12
    • Java中正则表达式split()特殊符号使用详解

      2022-06-27 15:59:32
    • PHP文件上传功能实现逻辑分析

      2023-05-25 02:28:30
    • pytorch对可变长度序列的处理方法详解

      2022-11-11 23:19:39
    • MySQL基于GTID主从搭建

      2024-01-23 18:17:56
    • Python还能这么玩之用Python修改了班花的开机密码

      2023-11-23 17:38:40
    • pycharm如何设置自动生成作者信息

      2021-01-21 22:20:58
    • 缓存是如何实现的?

      2009-11-01 15:35:00
    • python提取字典key列表的方法

      2023-02-01 23:35:28
    • Python iter()函数用法实例分析

      2022-11-01 00:00:01
    • 在thinkphp5.0路径中实现去除index.php的方式

      2024-05-11 09:54:34
    • JavaScript基于Ajax实现不刷新在网页上动态显示文件内容

      2024-05-06 10:08:38
    • MySQL的数据库数据备份和恢复详解

      2012-01-29 18:19:07
    • 二级域名原理以及asp实现程序

      2007-08-03 13:08:00
    • Python编写nmap扫描工具

      2021-08-07 14:53:10
    • python实现进程间通信简单实例

      2023-11-23 08:29:37
    • 利用Python实现Shp格式向GeoJSON的转换方法

      2021-01-30 09:14:49
    • asp之家 网络编程 m.aspxhome.com