python之内置函数(二)与匿名函数、递归函数初识

一、内置函数(二)
1、和数据结构相关（24）
列表和元祖（2）
list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
tuple：将一个可迭代对象转化成元组（如果是字典，默认将key作为元组的元素）

2、相关内置函数（2）
reversed：将一个序列翻转，并返回此翻转序列的迭代器。 *****
slice：构造一个切片模板，用于列表的切片。***

2-1、reversed()与列表的reverse()区分：
列表的reverse()只能列表使用：列表.reverse()，对原列表进行翻转，结果返回的还是列表。
内置函数reversed()，将一个序列翻转，结果是返回一个迭代器。

列表的reverse()

l1 = [1,3,4,2,6]
l1.reverse() #将列表进行翻转
print(l1)    #返回修改后的列表[6, 2, 4, 3, 1]

内置函数reversed()

reversed(l1) #生成一个迭代器
print(reversed(l1))  #一个地址
for i in reversed(l1):
    print(i)
# 结果：
# 用for循环输出迭代器的值
# 6 2 4 3 1

# 字符串使用reversed()
s1 = ‘abcdefg‘
for i in reversed(s1):
    print(i)
结果：
g f e d c b a

# 字典使用reversed() 报错
dic = {‘name‘:‘xiaoming‘,‘age‘:1000,‘hobby‘:‘oldwomen‘} # 不行

2-2、slice：构造一个切片模板，用于列表的切片。 ***
l3 = [1,2,3,4,5,6,7,8,9,10]
sli_obj = slice(0,5,2)     #制作切片模板，索引从0到4，间隔取值
print(l3[sli_obj])            # [1 3 5]

l4 = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]
print(l4[sli_obj])            # [‘a‘, ‘c‘, ‘e‘]

3、字符串相关（9）
3-1、str：将数据转化成字符串。

3-2、format:与具体数据相关，用于计算各种小数，精算等。 **
平常使用format情况较少，下面这种形式已经是最多的了，剩下的科学运算，需要用到的可自行研究。
字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format(‘test‘, ‘<20‘)) # 左对齐 (20是长度)
print(format(‘test‘, ‘>20‘)) # 右对齐
print(format(‘test‘, ‘^20‘)) # 居中对齐

3-3、bytes：unicode ---> bytes类型(单向的编码) ****

# 编码encode():
s1 = ‘小明‘
b1 = s1.encode(‘utf-8‘)
print(b1)  # b‘\xe5\xb0\x8f\xe6\x98\x8e‘

# 解码decode():
s2 = b1.decode(‘utf-8‘)
print(s2) # 小明

# 用bytes()方法编码(单向)
a1 = ‘小白‘
b1 = bytes(a1,encoding=‘utf-8‘)
print(b1)  # b‘\xe5\xb0\x8f\xe7\x99\xbd‘

# 不能用bytes()方法解码
a2 = bytes(b1,encoding=‘utf-8‘)
print(a2) # 报错

# 只能用decode()解码
a2 = b1.decode(‘utf-8‘)
print(a2) #小白

3-4、bytearry：返回一个字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
(bytearray其实也是一种编码的方法，不过bytearray可对编码后的字节进行修改，即对原数据进行修改)
例如：字符串 小明
b1 = bytearray(‘小明‘,encoding=‘utf-8‘)       #对小明进行编码，生成一串字节码(utf-8一个中文代表三个字节)
print(b1)           # bytearray(b‘\xe5\xb0\x8f\xe6\x98\x8e‘)
print(b1[0])       # 229
b1[0] = 65        #对前三个字节进行修改(即修改中文‘小‘)
b1[1] = 97
b1[2] = 104
print(b1)          # bytearray(b‘Aah\xe6\x98\x8e‘)
print(b1.decode(‘utf-8‘))     # 解码出来：Aah明

例如：字符串 hot
ret = bytearray(‘hot‘,encoding=‘utf-8‘)
print(id(ret))         # 2997820203056
print(ret)              # bytearray(b‘hot‘)
print(ret[0])         # h的ASCII:104
ret[0] = 65          # 把索引0的ASCII值改为65(A)
print(ret)             # bytearray(b‘Aot‘) hot索引0就改成了A
print(id(ret))       # 2997820203056 内存地址不变

3-5、memoryview
ret = memoryview(bytes(‘你好‘,encoding=‘utf-8‘))
print(len(ret))   # 6
print(ret)         # <memory at 0x000001D3D6FCD048> # [\xe4,\xbd,\xa0,\xe5,\xa5,\xbd]
print(bytes(ret[:3]).decode(‘utf-8‘))   # 你
print(bytes(ret[3:]).decode(‘utf-8‘))   # 好

3-6、ord:输入字符找该字符unicode编码的位置 **
print(ord(‘a‘))    # 97
print(ord(‘中‘))  # 20013

3-7、chr:输入位置数字找出其对应的unicode编码的字符 **
print(chr(97))         # a
print(chr(20013))   # 中

3-8、ascii:在ascii码中的就返回该值，不是则返回它在unicode的位置（16进制。） **
print(ascii(‘a‘))     # ‘a‘
print(ascii(‘中‘))   # ‘\u4e2d‘

3-9、repr:返回一个对象的string形式（原形毕露） *****

print(repr(‘{"name":"xiaoming"}‘))  #‘{"name":"xiaoming"}‘
print(‘{"name":"xiaoming"}‘)        # {"name":"xiaoming"}

格式化输出%r--->原封不动的写出来(基础数据类型都可接收)
字符串单双引号都默认是单引号
msg = ‘xiaoming是%r的人‘ % (‘德高望重‘)
print(msg) # xiaoming是‘德高望重‘的人

msg = ‘xiaoming是%r的人‘ % ("德高望重")
print(msg) # xiaoming是‘德高望重‘的人

msg = ‘xiaoming是%r的人‘ %(18)
print(msg) # xiaoming是18的人

msg = ‘xiaoming是%r的人‘ %(True)
print(msg) # xiaoming是True的人

msg = ‘xiaoming是%r的人‘ %({‘name‘:‘xiaming‘,‘age‘:18})
print(msg)  # xiaoming是{‘name‘: ‘xiaming‘, ‘age‘: 18}的人

repr():可用于判断json pickle序列化模块 特殊字符串，python字符串的区别

4、数据集合（3）
4-1、dict：创建一个字典。
4-2、set：创建一个集合。
4-3、frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

5、相关内置函数（8）
5-1、len:返回一个对象中元素的个数。

5-2、sorted：对所有可迭代的对象进行排序操作。 *****
与列表的sort区分：
列表的sort方法是对原列表进行排序修改，并没有生成新的列表
内置函数sorted方法会形成一个新列表

l1 = [2,3,5,3,1,9,8,6]
l1.sort()
print(l1)   

print(sorted(l1)) # 形成了一个新列表
print(l1)         # 原列表不变

内置函数sorted还可以与函数结合使用
l2 = [(1,1000),(2,18),(4,250),(3,500)]

def func1(x):
    return x[1]

print(sorted(l2,key=func1))
#按第二个元素升序排序 [(2, 18), (4, 250), (3, 500), (1, 1000)]

print(sorted(l2,key=func1,reverse=True))
#按第二个元素降序排序 [(1, 1000), (3, 500), (4, 250), (2, 18)]

5-3、enumerate:枚举，返回一个枚举对象。****
一个值接收枚举对象，返回的每个元素是元组，元组第一个元素是索引(默认从0开始)
第二个元素是可迭代对象的每个元素。
for i in enumerate([1,2,3]):
　　print(i)
结果：
(0, 1)
(1, 2)
(2, 3)

for i in enumerate([1,2,3],100):
　　print(i)
结果：
(100, 1)
(101, 2)
(102, 3)

for i,j in enumerate([1,2,3],100):
　　print(i,j)
结果：
100 1
101 2
102 3

5-4、all：可迭代对象中，全都是True才是True *** 多做条件判断
l1 = [1,‘‘,[1,3],(2,4)]
print(all(l1))      #False 有一个元素是空

5-5、any：可迭代对象中，有一个True就是True *** 多做条件判断
l2 = [1,0,‘‘,()]
print(any(l2))   #True

5-6、拉链方法：zip() 将多个iter纵向组成元素为元组的迭代器，以长度最小的iterable为标准长度 *****

l1 = [1,2,3,4]
tu1 = (‘a‘,‘b‘,‘c‘)
dic = {‘name‘:‘xiaoming‘,‘age‘:18,‘hobby‘:‘girl‘,‘hometown‘:‘guangzhou‘}

zip(l1,tu1,dic)  #迭代器(生成器对象)

print(zip(l1,tu1,dic)) #迭代器地址：<zip object at 0x000002C878E6A6C8>

for i in zip(l1,tu1,dic):
    print(i)

#循环输出迭代器的内容：
(1, ‘a‘, ‘name‘)
(2, ‘b‘, ‘age‘)
(3, ‘c‘, ‘hobby‘)

5-7、filter：过滤，通过你的函数，过滤一个可迭代对象(类似于生成器表达式的筛选模式) 生成一个迭代器。 *****

l1 = [1,2,3,4,5,6]
def fun(x):
    return x % 2 == 0 #筛选出偶数
g = filter(fun,l1)  # filter(fun,l1)生成的是一个迭代器
print(g)
for i in g:
    print(i)
结果：
2 4 6

l2 = [(2,1),(3,4),(4,5)]
def fun2(x):
    return x[1] % 2 == 1 #筛选出第二个元素为奇数的元组
g = filter(fun2,l2)
for i in g:
    print(i)
结果：
(2, 1)
(4, 5)

5-8、map:会根据提供的函数对指定序列做映射。(循环修改并返回) 生成一个迭代器*****

l1 = [1,2,3,4,5,6]
def fun(x):
    return x**2 #返回每个元素的平方
g = map(fun,l1)
for i in g:
    print(i)
结果：1 4 9 16 25 36

 (min max filter返回的都是遍历的参数，map返回的是return的值)

二、匿名函数：有且只有返回值的函数才可以用匿名函数进行简化，一行函数，多与内置函数结合使用。
1、匿名函数表达式：
函数名 = lambda 参数 ：返回值

参数可以有多个，用逗号隔开
匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
返回值和正常的函数一样可以是任意数据类型

2、
def func2(x):
　　return x**2
上面函数就有且只有返回值，所以可以写成匿名函数：
func2 = lambda x: x*2      #func2是函数名，func2(参数)才是调用
print(func2(6))                  #调用并打印结果

3、匿名函数 不单独使用，多与内置函数结合。
l2 = [(1,1000),(2,18),(4,250),(3,500)]
print(sorted(l2,key=lambda x:x[1]))

4、例子

1,利用内置函数匿名函数将dic按照值进行排序。
dic={‘k1‘:10,‘k2‘:100,‘k3‘:30}
print(sorted(dic.items(),key=lambda x:x[1]))

2,利用内置函数匿名函数 计算列表的每个数的2倍。
l1 = [1,5,7,4,8]
print(list(map(lambda x:x*2,l1)))

3,利用内置函数匿名函数，将值大于10的留下来
l2 = [5,8,11,9,15]
print(list(filter(lambda x:x > 10,l2)))

4,匿名函数可与三元运算结合
func = lambda x:x if x > 2 else x * 2

三、递归函数(自己调用自己)
1、人理解函数，神理解递归。
def func():
　　print(666)
　　func()
func()
结果：输出一段时间后会报错，因为
默认递归深度为998次，(官方给出的默认深度是1000，但实际上只有998次左右)
超过了就会报错

2、引用模块修改递归次数
import sys
sys.setrecursionlimit(100000)
n = 1
def func(x):
　　print(x)
　　x += 1
　　func(x)
func(n)
结果：3222
虽然设置了100000次，但是电脑跑不起呀，
一般电脑就跑3222次左右，这个会根据电脑性能而定。

3、
小明比小白大两岁 n = 4
小白比小狗大两岁 n= 3
小狗比小红大两岁 n = 2
小红24岁 n = 1
小明多少岁？

def age(n):
　　if n == 1:
　　　　return 24
　　else:
　　　　return age(n-1) + 2
age(4)   # 30

详解：
age(4)传进参数n=4：

def age(4):
　　if n == 1:
　　　　return 24
　　else:
　　　　return age(4-1) + 2
结果：age(3)+2

def age(3):
　　if n == 1:
　　　　return 24
　　else:
　　　　return age(3-1) + 2
结果：age(2)+2+2

def age(2):
　　if n == 1:
　　　　return 24
　　else:
　　　　return age(2-1) + 2
结果：age(1)+2+2+2

def age(1):
　　if n == 1:
　　　　return 24
　　else:
　　　　return age(n-1) + 2
结果：age(1)+2+2+2 ---> 24+2+2+2--->30

原文地址：https://www.cnblogs.com/yidashi110/p/10092273.html

时间： 2024-10-13 18:09:57

python之内置函数(二)与匿名函数、递归函数初识的相关文章

python之内置函数、匿名函数、递归

一.内置函数 内置函数详解:http://www.runoob.com/python/python-built-in-functions.html 二.匿名函数 匿名函数就是不需要显式的指定函数 1 #这段代码 2 def calc(n): 3 return n**n 4 print(calc(10)) 5 6 #换成匿名函数 7 calc = lambda n:n**n 8 print(calc(10)) 特点: 1.lambda只是一个表达式,函数体比def简单很多 2.lambda的主体是

python学习-day16：函数作用域、匿名函数、函数式编程、map、filter、reduce函数、内置函数r

一.作用域 作用域在定义函数时就已经固定住了,不会随着调用位置的改变而改变 二.匿名函数 lambda:正常和其他函数进行配合使用.正常无需把匿名函数赋值给一个变量. f=lambda x:x*x print(f) #打印指向该函数的内存地址 print(f(5)) #内存地址(5) 调用运行该函数 def cala(x): y=x*x return y z=cala(5) print(z) >>> <function <lambda> at 0x10137d950&g

what&#39;s the python之内置函数

what's the 内置函数? 内置函数,内置函数就是python本身定义好的,我们直接拿来就可以用的函数.(python中一共有68中内置函数.)     Built-in Functions     abs() dict() help() min() setattr() all() dir() hex() next() slice() any() divmod() id() object() sorted() ascii() enumerate() input() oct() static

内置函数filter()和匿名函数lambda解析

一.内置函数filter filter()函数是 Python 内置的一个高阶函数,filter()函数接收一个函数 f 和一个list,这个函数 f 的作用是对每个元素进行判断,返回由符合条件迭代器(python3以下版本返回是列表). 语法:filter(function or None, iterable) --> filter object 实例: #获取数字100以内的奇数 def even_num(n): return n % 2 ==1 res = filter(even_num,

内置函数随笔及匿名函数

1.作用域相关:globals()和locals() globals():全局作用域中的变量,无论放在全局命名空间还是在局部命名空间,输出结果一样,都是全局中的变量 locals():放在全局命名空间时和globals()效果一致,放在局部命名空间输出局部空间的变量 def func(): x = 1 y = 2 func() print(locals()) print(globals()) def func(): x = 1 y = 2 print(locals()) print(global

Python学习笔记__4.3章 匿名函数（简洁函数）

# 这是学习廖雪峰老师python教程的学习笔记 1.概览 关键字lambda表示匿名函数 list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])) # 列表生成式中的 lambda 实际就是 def f(x): return x * x 但匿名函数有个限制,就是只能有一个表达式. 匿名函数不用写return,返回值就是该表达式的结果 匿名函数因为函数没有名字,不必担心函数名冲突. 此外,匿名函数也是一个函数对象,可以把匿名函数赋值给一个变量

内置函数补充、匿名函数及闭包

内置函数.匿名函数及闭包 匿名函数 def func(x,y): return (x,y) print(func(1,2)) # 结果: (1,2) f = lambda x,y:(x,y) # lambda关键字 print(f(1,2)) # 结果: (1,2) print((lambda x,y:(x,y))(1,2)) # 结果: (1,2) # 一行代码实现匿名函数的定义及调用 print(lambda :1) print((lambda :1)()) # 匿名函数可以不写参数,但必须

函数递归和匿名函数（它们的应用）

一.函数递归 函数递归调用(是一种特殊的嵌套调用):在调用一个函数的过程中,又直接或间接地调用了该函数本身 递归必须要有两个明确的阶段: 递推:一层一层递归调用下去,强调每进入下一层递归问题的规模都必须有所减少 回溯:递归必须要有一个明确的结束条件,在满足该条件时结束递推 开始一层一层回溯 递归的精髓在于通过不断地重复逼近一个最终的结果. #直接调用本身 def f1(): print('from f1') f1() f1() #间接调用本身 def f1(): print('from f1')

函数声明、函数表达式、匿名函数

函数声明.函数表达式.匿名函数 ()先碰到了(),然后碰到function关键字就会自动将()里面的代码识别为函数表达式而不是函数声明 函数声明:function fnName () {-};使用function关键字声明一个函数,再指定一个函数名,叫函数声明. 函数表达式 var fnName = function () {-};使用function关键字声明一个函数,但未给函数命名,最后将匿名函数赋予一个变量,叫函数表达式,这是最常见的函数表达式语法形式. 匿名函数:function ()