Python学习笔记（7）
（一）函数的定义：
编程中的函数是用最基础的指令来实现比较复杂的功能，在此期间可以把该过程中的众多子程序封装成另一个高一级的“指令”，我们可以给这个“指令”起一个名字，方便在以后调用.这个过程可以无限的抽象循环，创造更高一级的“指令”.
另外重要的一点，函数即变量
(二)使用函数的好处
- 把经常使用的功能封装，减少代码量
- 便于统一维护和修改
- 具有更加良好的可扩展性
（三）函数与过程的区别
过程就是没有返回值的函数，但是在Python里面如果没有返回值的话，就会自动返回None.因此严格来说，在Python里面只有函数，而没有过程.
当return值的数量为0时，返回None；数量为1时，返回object；数量大于1时，返回tuple类型
（四）函数
>>>def 函数名（形参）：
>>> """ 注释 """
>>> [指令过程]
>>> return ##也可以不用return
##########可以在函数里面添加默认的参数##########
#在执行的过程中，没有传入参数覆盖默认的参数设置，就返回默认的值
>>>def 函数名（形参, 形参 = 某值）： ##默认形参必须放在参数群的最后面
>>> """ 注释 """
>>> [指令过程]
>>> return ##也可以不用return
位置参数和关键字参数
>>>def 函数名（形参）：
>>> """ 注释 """
>>> [指令过程]
>>> return res
#####调用#####
#####位置参数
>>>def 函数名(实参，实参，实参)
#####关键字参数
>>>def 函数名(关键字 = 值，关键字 = 值)
#####位置参数与关键字参数混用
>>>def 函数名(实参，关键字 = 值，关键字 = 值) ##实参必须在关键字参数的前面
接收多个参数
>>>def 函数名（形参,*args,**kwargs）：
>>> """ 注释 """
>>> [指令过程]
>>> return res
## 其中*args表示接收多余的位置参数，**kwargs表示接收多余的关键字参数，但是不能重复传值
（五）嵌套函数和作用域，局部变量与全局变量
局部变量即指只能在局部被调用变量，即在函数内部被定义的变量，这种变量只能被该一级的函数或低级的子程序调用.
全局变量即指能在任何一级都能被调用的，这种变量基本都是函数外面被定义的.
函数的封装可以函数里面再调用函数，外面的变量也可以被里面的使用，但是里面的变量却不能被外面所调用.如果在这一级找不到所对应的变量，那么就会不断地自动到外面去找对应的变量，直到找到相关的变量为止.如果要把里面封装的变量作为全局变量，即在任何地方都能被调用的话，就可以使用如下方法：
>>>def func():
>>> ………………
>>> def func():
>>> global 变量名 ##这样之后，变量就会变成全局变量
>>> 变量名 = 值
>>> nonlocal 变量名
>>> 变量名 = 值 ##变量替代上一级的变量
作用域在定义函数时就已经固定住了，本身不会随着调用位置的改变而改变
>>> def test():
print("Good morning!"
>>> def test1():
return test
>>> bar = test1() ##获得函数test()的内存地址
>>> bar() ##运行test()
Good morning!
>>> name = "YuanMing"
>>> def func1():
name = "Hermaeus"
def func2():
name = "Duke_Yuan"
def func3():
print(name)
return func3
return func2
#####执行方式一
>>> test1 = func1
>>> test1 = func1()
>>> test2 = test1()
>>> test2()
Duke_Yuan ##随着定义域不断向上级找变量
#####执行方式二
>>> func1()()()
Duke_Yuan
（六）递归函数
在嵌套函数中，可以对函数自身无限再调用，而构成了一个无限调用的过程，这种函数被称之为递归函数.但是递归函数必须满足以下条件：
- 必须有一个明确的结束条件
- 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
- 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
>>> def calc(n):
if n == 10:
return n
print(n)
calc(n+1)
>>> calc(0)
0
1
2
3
4
5
6
7
8
9
（七）匿名函数
>>>lambda 形参：[表达式]
##########该匿名函数表示
>>>def 函数名()：
>>> return 表达式
##########调用
>>> func = lambda x,y:x*y
>>> func(1,2)
2
##########要返回多个值
>>> func = lambda x, y, z:(x+1, y+1, z+1) ##必须要加括号
>>> func(1,2,3)
(2, 3, 4)
（八）函数式编程
高阶函数
满足下面两个任意条件之一的都叫做“高阶函数”：
- 函数的传入参数是一个函数名
- 函数的返回值是一个函数名
map()函数
map(func, *iterables)
处理序列里面每一个值，返回迭代器
>>> test = [1, 2, 3, 4, 5, 6]
>>> print(list(map(lambda x:x**2, test)))
[1, 4, 9, 16, 25, 36]
filter()函数
filter(function or None, iterable)
判断筛序列里面的元素，如果是True就保留，返回迭代器
>>> lis = ["ADC", "AD", "ad", "ae"]
>>> print(list(filter(lambda n:n.startswith("A"), lis)))
['ADC', 'AD']
>>> print(list(filter(lambda n:n.isupper(), lis)))
['ADC', 'AD']
>>> print(list(filter(lambda n:n.islower(), lis)))
['ad', 'ae']
reduce()函数
在Python 3里已经把reduce方法放入functools工具包里面了
reduce(function, sequence[, initial])
整体处理列表里面的值，如让所有元素相加相乘，返回值
>>> from functools import reduce
>>> lis = [1,2,3,4,5]
>>> print(reduce(lambda x,y:x*y, lis, 10))
1200
（九）内置函数
[官方解释链接](https://docs.python.org/3/library/functions.html?highlight=built#func-bytes)
-
abs（x ）
返回数字的绝对值.参数可以是整数或浮点数。如果参数是复数，则返回其大小.
>>> abs(-1) 1 >>> abs(-12) 12 -
all(iterable)
返回True如果的所有元素迭代是真的（或者如果可迭代为空）,为False的有0，空，None
>>> print(all([0, [], 1])) False >>> print(all([1, 2, 3])) True -
any(iterable)
返回True如果iterable的任何一个元素为bool时是True。如果iterable为空，则返回False
>>> print(any([0, None, []])) False >>> print(any([1, 0, None])) True -
ascii(object)
-
bin（x ）
将整数转换为前缀为“0b”的二进制字符串
>>> bin(3) '0b11' >>> bin(-10) '-0b1010 -
bool(x)
返回bool值，如果为0，空，None则为False
>>> bool(0) False >>> bool(None) False >>> bool([]) False >>> bool(12) True -
bytes([source[, encoding[, errors]]])
把source编译成指定编码
>>> name = "YuanMing" >>> print(bytes(name, encoding = "UTF-8")) b'YuanMing' >>> print(bytes(name, encoding = "GBK")) b'YuanMing' -
callable(object)
1、方法用来检测对象是否可被调用，可被调用指的是对象能否使用()括号的方法调用.
2、可调用对象，在实际调用也可能调用失败；但是不可调用对象，调用肯定不成功.
3、类对象都是可被调用对象，类的实例对象是否可调用对象，取决于类是否定义了__call__方法.
>>> name = "YuanMing" >>> callable(bool) True >>> callable(name) False >>> callable(1) False -
chr(i)
返回表示Unicode代码点为整数i的字符的字符串
>>> chr(13) '\r' >>> chr(374) 'Ŷ' >>> chr(45) '-' -
complex([real[, imag]])
创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数
>>> print(complex(1,2)) (1+2j) >>> print(complex(1)) (1+0j) >>> print(complex("1+2j")) (1+2j) -
dict()
创建字典
-
dir([object])
函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表
>>> dir() ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'bar', 'func', 'func1', 'lis', 'name', 'reduce', 'test', 'test1', 'test2', 'x'] >>> dir(bar) ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'] -
divmod(a, b)
返回一个包含商和余数的元组(a // b, a % b)
>>> divmod(4,3) (1, 1) >>> divmod(7,2) (3, 1) -
enumerate(sequence, [start=0])
把可迭代序列变为一个索引序列
>>> name = ["YuanMing", "Marsh", "Jack"] >>> for i,k in enumerate(name,2): print(i,k) 2 YuanMing 3 Marsh 4 Jack -
eval(expression[, globals[, locals]])
执行一个字符串表达式，并返回表达式的值
expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象>>> print(eval("1+2")) 3 >>> n = 3 >>> print(eval("n+1")) 4 -
exec(object[, globals[, locals]])
执行储存在字符串或文件中的 Python 语句
object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。
globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。>>> func_program = "print('You are so good')" >>> exec(func_program) You are so good >>> exec("print('Good!')") ##冒号数量不能一样 Good! -
filter()
pass
-
float([x])
将整数和字符串转换成浮点数
>>> float(2) 2.0 >>> float(2.13) 2.13 -
format()
pass
-
frozenset
pass
-
globals()
pass
-
hash(object)
获取一个对象（字符串或者数值等）的hash值
>>> hash("YuanMing") 5942654411917565357 -
help([object])
查看函数或模块用途的详细说明
>>> help(help) Help on _Helper in module _sitebuiltins object: class _Helper(builtins.object) | Define the builtin 'help'. | | This is a wrapper around pydoc.help that provides a helpful message | when 'help' is typed at the Python interactive prompt. | | Calling help() at the Python prompt starts an interactive help session. | Calling help(thing) prints help for the python object 'thing'. | | Methods defined here: | | __call__(self, *args, **kwds) | Call self as a function. | | __repr__(self) | Return repr(self). | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) -
hex(x)
将10进制整数转换成16进制，以字符串形式表示
>>> hex(17) '0x11' >>> hex(21481) '0x53e9' -
id([object])
获取对象的内存地址
>>> name = 'YuanMing' >>> id(name) 1725836378160 >>> number = 23 >>> id(number) 1674538704 -
input([prompt])
接受一个标准输入数据，返回为 string 类型
-
int(x, base=10)
将一个字符串或数字转换为整型，base是以什么为基础处理
>>> int("3") 3 >>> int(2.41) 2 -
isinstance(object, classinfo)
判断一个对象是否是一个已知的类型
isinstance() 与 type() 区别：
- type() 不会认为子类是一种父类类型，不考虑继承关系。
- isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()
>>> test = "1" >>> isinstance(test,str) True >>> isinstance(test,int) False -
iter(object[, sentinel])
用来生成迭代器
>>> lis = [1,2,3] >>> for i in iter(lis): print(i) 1 2 3 -
len(s)
测量数量
>>> name = ["Jack", "Marsh", "Ada"] >>> len(name) 3 >>> len("akhfajfal") 9 -
list( seq )
pass
-
local()
pass
-
map()
pass
-
max( x, y, z, … )
求最大值
>>> max(15, 17, 1, 28) 28 >>> max([1,4,27,83]) 83 -
min( x, y, z, … )
求最小值
>>> min(15, 17, 1, 28) 1 >>> min([1,4,27,83]) 1 -
next(iterator[, default])
返回迭代器的下一个项目
-
oct(x)
将一个整数转换成8进制字符串
>>> oct(14) '0o16' >>> oct(6472) '0o14510 -
open(name[, mode[, buffering]])
打开文本
-
print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)
- objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
- sep – 用来间隔多个对象，默认值是一个空格。
- end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
- file – 要写入的文件对象。
>>> print("y","m",sep="-",end='%%') y-m%% -
range(start, stop[, step])
返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表
>>> range(1,6) range(1, 6) >>> for i in range(1,6): print(i) 1 2 3 4 5 -
repr(object)
将对象转化为供解释器读取的形式
>>> name = "YuanMing" >>> repr(name) "'YuanMing'" -
reversed(seq)
返回一个反转的迭代器
>>> lis = [1,2,3,4] >>> reversed(lis) <list_reverseiterator object at 0x00000191D3DD6E48> >>> for i in reversed(lis): print(i) 4 3 2 1 -
round( x [, n] )
返回浮点数x的四舍五入值
>>> round(15.2174113,4) 15.2174 -
set()
pass
-
slice(start, stop[, step])
实现切片对象，主要用在切片操作函数里的参数传递
>>> myslice = slice(1,7,2) >>> arr = range(10) >>> arr[myslice] range(1, 7, 2) -
sorted(iterable, key=None, reverse=False)
排序
>>> lis = [3,2,9,5,4,6,7,1] >>> print(sorted(lis, key = lambda x:x**-1, reverse=True)) [1, 2, 3, 4, 5, 6, 7, 9] -
str(object=’’)
转换为str类型
>>> str(1) '1' -
sum(iterable[, start])
求和
>>> sum([1,2,3,4,5]) 15 -
tuple(seq)
pass
-
type(name, bases, dict)
判断是什么类型
>>> type("1") <class 'str'> >>> type(1) <class 'int'> >>> type([1,2]) <class 'list'> -
zip([iterable, …])
将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象
>>> a = [1,2,3] >>> b = [4,5,6] >>> c = [4,5,6,7,8] >>> zipped = zip(a,b) >>> print(list(zipped)) [(1, 4), (2, 5), (3, 6)] >>> print(list(zip(a,c))) [(1, 4), (2, 5), (3, 6)] >>> a1, a2 = zip(*zip(a,b)) ## *zip为解压 >>> print(list(a1), list(a2)) [1, 2, 3] [4, 5, 6] -
vars([object])
没有object时，就相当于local()；有object时，就返回当前object所有的方法
>>> def print_hello(): msg = "Hello, World!" print(locals()) print(vars()) >>> print_hello() {'msg': 'Hello, World!'} {'msg': 'Hello, World!'} {'msg': 'Hello, World!'} {'msg': 'Hello, World!'} >>> print(vars(int)) {'__repr__': <slot wrapper '__repr__' of 'int' objects>, '__hash__': <slot wrapper '__hash__' of 'int' objects>, '__str__': <slot wrapper '__str__' of 'int' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'int' objects>, '__lt__': <slot wrapper '__lt__' of 'int' objects>, '__le__': <slot wrapper '__le__' of 'int' objects>, '__eq__': <slot wrapper '__eq__' of 'int' …………………………………………………………
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
