Python基础：Python函数、文件操作、递归

函数参数

函数参数包括位置参数，关键字参数，动态参数（*args, **args）三种。

传参的过程是形式参数的赋值。

*args传入的参数是元组形式，**args传入的参数是字典形式。

示例代码如下：(这部分直接看代码实例会更清楚静态参数与动态参数如何混用)

  1 #!/usr/bin/env python
  2 # -*- coding:utf-8 -*-
  3 # def story(**kwargs):
  4 #     return ‘Once upon a time,there was a ‘  5 #             ‘%(job)s called %(name)s.‘ % kwargs
  6 # print(story(job = ‘king‘,name = ‘bolen‘))
  7 #
  8 # def power(x,y,*others):
  9 #     if others:
 10 #         print(‘received redundant parameters:‘,others)
 11 #     return pow(x,y)
 12 # power(2,3,)
 13
 14 def interval(start,stop = None,step = 1):
 15     if stop is None:
 16         start,stop=0,start
 17     result = []
 18     i = start
 19     while i < stop:
 20         result.append(i)
 21         i+=step
 22     return  result
 23
 24 -----------------------shell excute-------------------------------
 25 >>> story(job = ‘king‘,name = ‘bolen‘)
 26 ‘Once upon a time,there was a king called bolen.‘
 27 >>> parms = {‘job‘:‘engineer‘,‘name‘:‘jack‘}
 28 >>> story(**parms)
 29 ‘Once upon a time,there was a engineer called jack.‘
 30 >>> del parms[‘job‘]
 31 >>> parms
 32 {‘name‘: ‘jack‘}
 33 >>> story(job = ‘小王子‘,**parms)
 34 ‘Once upon a time,there was a 小王子 called jack.‘
 35
 36 >>> power(2,3)
 37 8
 38 >>> power(y=3,x=2)
 39 8
 40 >>> parms = (5,)*2
 41 >>> type(parms)
 42 <class ‘tuple‘>
 43 >>> power(*parms)
 44 3125
 45 >>> parms
 46 (5, 5)
 47
 48
 49 >>> interval(10)
 50 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 51 >>> interval(1,6)
 52 [1, 2, 3, 4, 5]
 53 >>> interval(2,12,3)
 54 [2, 5, 8, 11]
 55 >>> power(*interval(3,7))
 56 received redundant parameters: (5, 6)
 57 81
 58

函数参数示例

变量作用域

函数内部的变量称为局部变量，全局无法访问局部变量，函数内部正常也无法访问全局变量，除非以如下方式：

函数内读取全局变量：(慎重引用全局变量，容易出错)

  1 >>> def com(para):
  2 	print(para+globals()[‘para‘])
  3 >>> com(‘yingying‘)
  4 yingyingbolen

函数内声明全局变量：

  1 >>> def ch_global():
  2 	global x
  3 	x +=1
  4 >>> x =  1
  5 >>> ch_global()
  6 >>> x
  7 2

Python内置函数

详细介绍请点击：官网内置函数详解

Python文件操作：open函数和with open(管理上下文)

open函数用于文件处理。一般步骤是打开文件，然后操作文件。

  1 文件句柄 = open(‘文件路径‘,‘模式‘)
  句柄是WONDOWS用来标识被应用程序所建立或使用的对象的唯一整数，WINDOWS使用各种各样的句柄标识诸如应用程序实例，窗口，控制，位图，GDI对象等等。
句柄是一个标识符，是拿来标识对象或者项目的，它就象我们的姓名一样，每个人都会有一个，不同的人的姓名不一样，但是，也可能有一个名字和你一样的人。从数据类型上来看它只是一个16位的无符号整数。应用程序几乎总是通过调用一个WINDOWS函数来获得一个句柄，之后其他的WINDOWS函数就可以使用该句柄，以引用相应的对象。  


  文件句柄在文件I/O中，要从一个文件读取数据，应用程序首先要调用操作系统函数并传送文件名，并选一个到该文件的路径来打开文件。该函数取回一个顺序号，即文件句柄（file handle），该文件句柄对于打开的文件是唯一的识别依据。要从文件中读取一块数据，应用程序需要调用函数ReadFile，并将文件句柄在内存中的地址和要拷贝的字节数传送给操作系统。当完成任务后，再通过调用系统函数来关闭该文件。




打开后获得该文件句柄，后面通过此文件句柄对文件操作。


一、打开文件


打开文件的模式有：


    

  • r ，只读模式【默认】
    • 

  • w，只写模式【不可读；不存在则创建；存在则清空内容；】
    • 

  • x， 只写模式【不可读；不存在则创建，存在则报错】
    • 

  • a， 追加模式【可读；   不存在则创建；存在则只追加内容；】
    • 



"+" 表示可以同时读写某个文件


    

  • r+， 读写【可读，可写】
    • 

  • w+，写读【可读，可写】
    • 

  • x+ ，写读【可读，可写】
    • 

  • a+， 写读【可读，可写】
    • 



"b"表示以字节的方式操作


    

  • rb  或 r+b
    • 

  • wb 或 w+b
    • 

  • xb 或 w+b
    • 

  • ab 或 a+b
    • 



注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型。


二、文件操作




  1 class TextIOWrapper(_TextIOBase):
  2     """
  3     Character and line based layer over a BufferedIOBase object, buffer.
  4
  5     encoding gives the name of the encoding that the stream will be
  6     decoded or encoded with. It defaults to locale.getpreferredencoding(False).
  7
  8     errors determines the strictness of encoding and decoding (see
  9     help(codecs.Codec) or the documentation for codecs.register) and
 10     defaults to "strict".
 11
 12     newline controls how line endings are handled. It can be None, ‘‘,
 13     ‘\n‘, ‘\r‘, and ‘\r\n‘.  It works as follows:
 14
 15     * On input, if newline is None, universal newlines mode is
 16       enabled. Lines in the input can end in ‘\n‘, ‘\r‘, or ‘\r\n‘, and
 17       these are translated into ‘\n‘ before being returned to the
 18       caller. If it is ‘‘, universal newline mode is enabled, but line
 19       endings are returned to the caller untranslated. If it has any of
 20       the other legal values, input lines are only terminated by the given
 21       string, and the line ending is returned to the caller untranslated.
 22
 23     * On output, if newline is None, any ‘\n‘ characters written are
 24       translated to the system default line separator, os.linesep. If
 25       newline is ‘‘ or ‘\n‘, no translation takes place. If newline is any
 26       of the other legal values, any ‘\n‘ characters written are translated
 27       to the given string.
 28
 29     If line_buffering is True, a call to flush is implied when a call to
 30     write contains a newline character.
 31     """
 32     def close(self, *args, **kwargs): # real signature unknown
 33         关闭文件
 34         pass
 35
 36     def fileno(self, *args, **kwargs): # real signature unknown
 37         文件描述符
 38         pass
 39
 40     def flush(self, *args, **kwargs): # real signature unknown
 41         刷新文件内部缓冲区
 42         pass
 43
 44     def isatty(self, *args, **kwargs): # real signature unknown
 45         判断文件是否是同意tty设备
 46         pass
 47
 48     def read(self, *args, **kwargs): # real signature unknown
 49         读取指定字节数据
 50         pass
 51
 52     def readable(self, *args, **kwargs): # real signature unknown
 53         是否可读
 54         pass
 55
 56     def readline(self, *args, **kwargs): # real signature unknown
 57         仅读取一行数据
 58         pass
 59
 60     def seek(self, *args, **kwargs): # real signature unknown
 61         指定文件中指针位置
 62         pass
 63
 64     def seekable(self, *args, **kwargs): # real signature unknown
 65         指针是否可操作
 66         pass
 67
 68     def tell(self, *args, **kwargs): # real signature unknown
 69         获取指针位置
 70         pass
 71
 72     def truncate(self, *args, **kwargs): # real signature unknown
 73         截断数据，仅保留指定之前数据
 74         pass
 75
 76     def writable(self, *args, **kwargs): # real signature unknown
 77         是否可写
 78         pass
 79
 80     def write(self, *args, **kwargs): # real signature unknown
 81         写内容
 82         pass
 83
 84     def __getstate__(self, *args, **kwargs): # real signature unknown
 85         pass
 86
 87     def __init__(self, *args, **kwargs): # real signature unknown
 88         pass
 89
 90     @staticmethod # known case of __new__
 91     def __new__(*args, **kwargs): # real signature unknown
 92         """ Create and return a new object.  See help(type) for accurate signature. """
 93         pass
 94
 95     def __next__(self, *args, **kwargs): # real signature unknown
 96         """ Implement next(self). """
 97         pass
 98
 99     def __repr__(self, *args, **kwargs): # real signature unknown
100         """ Return repr(self). """
101         pass
102
103     buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
104
105     closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
106
107     encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
108
109     errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
110
111     line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
112
113     name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
114
115     newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
116
117     _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
118
119     _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
120
121 3.x


Python3中的文件操作


三、管理上下文


由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现：


  1 try:
  2     f = open(‘/path/to/file‘, ‘r‘)
  3     print(f.read())
  4 finally:
  5     if f:
  6         f.close()
  7 


但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法：


  1 with open(‘/path/to/file‘, ‘r‘) as f:
  2     print(f.read())
  3 


这和前面的try ... finally是一样的，但是代码更佳简洁，并且不必调用f.close()方法。


在Python 2.7 及以后，with又支持同时对多个文件的上下文进行管理，即：


  1 with open(‘log1‘) as obj1, open(‘log2‘) as obj2:
  2 	pass
  3 




  1 import sys
  2 import json
  3 with open (‘c:/Users/zliyong/filo.txt‘,‘a+‘,encoding=‘utf-8‘) as f:
  4     #f.write(‘first line\nsecondline\n3rd line\n 4rd line‘)
  5     # f.tell()#查看当前指针位置
  6     # f.seek(2)#指定当前指针位置
  7     ret = f.truncate(100) #从指定位置向前截取
  8     print(f.tell())
  9     print(f.read())
 10     for line in f.readlines():
 11         print(line.strip())


Python3中的文件操作实例


如果文件很小，read()一次性读取最方便；如果不能确定文件大小，反复调用read(size)比较保险；如果是配置文件，调用readlines()最方便。


像open()函数返回的这种有个read()方法的对象，在Python中统称为file-like Object。除了file外，还可以是内存的字节流，网络流，自定义流等等。file-like Object不要求从特定类继承，只要写个read()方法就行。


StringIO就是在内存中创建的file-like Object，常用作临时缓冲。


二进制文件


前面讲的默认都是读取文本文件，并且是UTF-8编码的文本文件。要读取二进制文件，比如图片、视频等等，用‘rb‘模式打开文件即可：


  1 >>> f = open(‘/Users/michael/test.jpg‘, ‘rb‘)
  2 >>> f.read()
  3 b‘\xff\xd8\xff\xe1\x00\x18Exif\x00\x00...‘ # 十六进制表示的字节
  4 



字符编码


要读取非UTF-8编码的文本文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件：


  1 >>> f = open(‘/Users/michael/gbk.txt‘, ‘r‘, encoding=‘gbk‘)
  2 >>> f.read()
  3 ‘测试‘
  4 


遇到有些编码不规范的文件，你可能会遇到UnicodeDecodeError，因为在文本文件中可能夹杂了一些非法编码的字符。遇到这种情况，open()函数还接收一个errors参数，表示如果遇到编码错误后如何处理。最简单的方式是直接忽略：


  1 >>> f = open(‘/Users/michael/gbk.txt‘, ‘r‘, encoding=‘gbk‘, errors=‘ignore‘)


写文件注意事项：


可以反复调用f.write来进行写文件，但是一定要记得用f.close来关闭文件。因为操作系统在往磁盘里写文件时，往往不会立即写入磁盘，而是放在内存中缓存起来，待空闲了再慢慢进行写操作，所以只有调用f.close()方法才能保证操作系统文件完整写入到磁盘，否则经常会使文件部分写入磁盘，剩下的丢失了。


操作文件和目录


Python中的内置os模块提供了调用系统接口函数的功能，实现简单的系统操作。


  1 >>>import os
  2 >>>os.name()  #获取操作系统名字
  3 ‘nt‘
  4 >>> os.environ #获取操作系统全部的环境变量
  5 >>> os.environ.get(‘PATH‘)#获取操作系统中某个环境变量的值
  6
  7
  8 


注意：操作文件和目录的函数一部分放在os模块中，一部分放在os.path模块中。创建、删除目录，路径拼接等可以如下调用：


  1 >>> os.path.abspath(‘.‘)
  2 ‘C:\\Users\\zliyong\\AppData\\Local\\Programs\\Python\\Python35‘
  3 >>> os.path.join(‘Users/zliyong‘,‘test.dir‘) #路径拼接
  4 ‘Users/zliyong\\test.dir‘
  5 >>> os.mkdir(‘c:/Users/zliyong/test.dir‘)
  6 >>> os.rmdir(‘c:/Users/zliyong/test.dir‘)
  7 >>> os.path.split(‘c:/Users/zliyong/test.dir‘)
  8 (‘c:/Users/zliyong‘, ‘test.dir‘)
  9 >>> os.path.splitext(‘c:/Users/zliyong/test.dir/test.txt‘)
 10 (‘c:/Users/zliyong/test.dir/test‘, ‘.txt‘)
 11 >>> os.rename(‘c:/Users/zliyong/test.dir‘,‘c:/Users/zliyong/pyrename.dir‘)


但是复制文件的函数居然在os模块中不存在！原因是复制文件并非由操作系统提供的系统调用。理论上讲，我们通过上一节的读写文件可以完成文件复制，只不过要多写很多代码。


幸运的是shutil模块提供了copyfile()的函数，你还可以在shutil模块中找到很多实用函数，它们可以看做是os模块的补充。


  1 import shutil
  2 >>> shutil.copyfile(‘c:/Users/zliyong/pyrename.dir/test.txt‘,‘c:/Users/zliyong/pyrename.dir/test2.txt‘)
  3 ‘c:/Users/zliyong/pyrename.dir/test2.txt‘


最后看看如何利用Python的特性来过滤文件。比如我们要列出当前目录下的所有目录，只需要一行代码：


  1 >>> [x for x in os.listdir(‘.‘) if os.path.isdir(x)]
  2 [‘DLLs‘, ‘Doc‘, ‘include‘, ‘Lib‘, ‘libs‘, ‘Scripts‘, ‘tcl‘, ‘Tools‘]
  3 >>> [x for x in os.listdir(‘.‘) if os.path.isfile(x) and os.path.splitext(x)[1]==‘.py‘]
  4 []



lambda表达式


lambda表达式又称为匿名函数，适用于某些简单函数的语法糖。如下这个lambda表达式结合列表推导式的例子是很tricky的：


  1 >>> result = [lambda x: x + i for i in range(10)]
  2 >>> print(result[0](10))
  3 19
  4 >>> print(result)
  5 [<function <listcomp>.<lambda> at 0x000001D664C7C7B8>, <function <listcomp>.<lambda> at 0x000001D667100F28>, <function <listcomp>.<lambda> at 0x000001D667105048>, <function <listcomp>.<lambda> at 0x000001D6671050D0>, <function <listcomp>.<lambda> at 0x000001D667105158>, <function <listcomp>.<lambda> at 0x000001D6671051E0>, <function <listcomp>.<lambda> at 0x000001D667105268>, <function <listcomp>.<lambda> at 0x000001D6671052F0>, <function <listcomp>.<lambda> at 0x000001D667105378>, <function <listcomp>.<lambda> at 0x000001D667105400>]


首先执行range函数，然后生成10个lamda函，当调用result函数时i=9，所以result是一个10个元素都是19的列表。


递归
				


				
时间： 2024-08-07 04:31:11 

		


		


	

	
	

		


		
Python基础：Python函数、文件操作、递归的相关文章


						

		

			

                python学习笔记-（七）python基础--集合、文件操作&amp;函数
			

		

		

									

				本节内容 1.集合操作 2.文件操作 3.字符编码与转码 4.函数操作 1.集合操作 集合是一个无序的.不重复的数据组合: 1.1 常用操作 它的作用是: 1)自动去重:列表变成集合,自动去重: 1 2 3 4 >>> list_1 = [1,4,4,5,6,7,9,10] >>> list_1 =set(list_1) >>> print(list_1) {1, 4, 5, 6, 7, 9, 10} 2)关系测试:测试两组数据之间的关系,交集.并集.			

		

	

				

		

			

                Python Day3 集合 函数 文件操作
			

		

		

									

				set集合 set是一个无序且不重复的元素集合 class set(object):    """     set() -> new empty set object     set(iterable) -> new set object          Build an unordered collection of unique elements.    """     def add(self, *args, **kwargs			

		

	

				

		

			

                【python基础】之文件操作
			

		

		

									

				一.文件操作的基本流程 #打开文件,得到文件句柄并赋值给一个变量 f = open('小重山','r',encoding='utf-8') #通过句柄对文件进行操作 print(f.read()) #关闭文件 f.close() 二.文件打开模式 r,只读模式(默认).w,只写模式.[不可读:不存在则创建:存在则删除内容:]a,追加模式.[可读: 不存在则创建:存在则只追加内容] "+" 表示可以同时读写某个文件 r+,可读写文件 [可读:可写:可追加] :光标默认在0位置,最后位置开			

		

	

				

		

			

                Python学习之路（四）：基础知识之文件操作
			

		

		

									

				1.文件操作的函数 文件操作的函数大致为:f = open(文件名(路径), mode = "?", encoding="字符集") f 可写成任意变量等,它被称作:文件句柄,文件操作符,或者文件操作对象 其中文件的路径有两种: 绝对路径,从磁盘的根目录寻找路径,或者从互联网上找路径 相对路径(相对于当前程序所在的文件夹),在同一个文件夹互相访问,如下面的例子 文件操作的encoding应该是utf-8,这是因为在Python中默认编码为utf-8. 2.mode:			

		

	

				

		

			

                Python基础之一：文件类型及运算符
			

		

		

									

				一.PYTHON文件类型 1.源代码 Python源代码的文件以"py"为扩展名,由Python解释,不需要编译: 2.字节代码 Python源文件经编译后生成的扩展名为"pyc"的文件: 编译方法:     importpy_compile     py_compile.compile("hello world.py") 3.优化代码 经过优化的源文件,扩展名为".pyo"  python –O –m py_compile 			

		

	

				

		

			

                Python基础07 函数
			

		

		

									

				Python基础07 函数 作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 函数最重要的目的是方便我们重复使用相同的一段程序. 将一些操作隶属于一个函数,以后你想实现相同的操作的时候,只用调用函数名就可以,而不需要重复敲所有的语句. 函数的定义 首先,我们要定义一个函数, 以说明这个函数的功能. def square_sum(a,b): c = a**2 + b**2 return c 这个函数的功能是求两个数的平方和. 首先			

		

	

				

		

			

                python字符串处理与文件操作
			

		

		

									

				1.strip函数 strip是trim(裁剪)掉字符串两边的空格或字符.(lstrip/rstrip) 如: 空格 theString = ' abcdbcyesornoabcbacdd ' print theString.strip() abcdbcyesornoabcbacdd 字符 theString = 'abcdbcyesornoabcbacdd' print theString.strip('abcd') #去掉两端的abcd字符 yesorno 问题:如何去掉中间空格. theS			

		

	

				

		

			

                python基础——匿名函数及递归函数
			

		

		

									

				python基础--匿名函数及递归函数 1 匿名函数语法 匿名函数lambda x: x * x实际上就是: def f(x): return x * x 关键字lambda表示匿名函数,冒号前面的x表示函数参数. 匿名函数有个限制,就是只能有一个表达式,不用写return,返回值就是该表达式的结果. 2 匿名函数举例 用匿名函数有个好处,因为函数没有名字,不必担心函数名冲突.此外,匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量,再利用变量来调用该函数: >>> f = lam			

		

	

				

		

			

                python基础知识六 文件的基本操作+菜中菜
			

		

		

									

				基础知识六 文件操作 ? open():打开 ? file:文件的位置(路径) ? mode:操作文件模式 ? encoding:文件编码方式 ? f :文件句柄 f = open("1.txt",mode = 'r',encoding = 'utf-8') print(f.read()) f.close 1.文件操作模式: ? r,w,a(重要) ? rb,wb,ab(次要) ? r+,w+,a+ 1.1 r/w/a 1. r操作: f = open('1.txt','r') pri			

		

	

				

		

			

                python基础——sorted()函数
			

		

		

									

				python基础——sorted()函数 排序算法 排序也是在程序中经常用到的算法.无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小.如果是数字,我们可以直接比较,但如果是字符串或者两个dict呢?直接比较数学上的大小是没有意义的,因此,比较的过程必须通过函数抽象出来. Python内置的sorted()函数就可以对list进行排序: >>> sorted([36, 5, -12, 9, -21]) [-21, -12, 5, 9, 36] 此外,sorted()函数也是一个