Python 基础第十四天(内置函数和匿名函数)

今天主要内容

1.生成器补充--生成器推导式

2.内置函数

3.匿名函数

1.生成器推导式

(1)列表推导式:一行搞定 ,简单，感觉高端。但是，不易排错。

例:

l1 = []
 for i in range(1,12):
　　 l1.append(‘python%s期‘ % i)
 print(l1)

生成式:

l2 = [‘python%s期‘ %i  i  for i in range(1,12)]

print(l2)

结构:

循环模式
[经过加工的i for i in 可迭代对象]

筛选模式

[经过加工的i for i in 可迭代对象 if 条件 筛选]

生成器推导式

(1)跟列表生成器结构基本相似

列表推导式：一目了然，占内存。
生成器表达式：不易看出，节省内容。

例:

l2 = (i*i for i in range(1,11))

print(l2.__next__())

print(l2.__next__())

print(l2.__next__())

总结:

循环模式

(经过加工的i for i in 可迭代对象)

筛选模式

(经过加工的i for i in 可迭代对象 if 条件 筛选)

2.内置函数

内置函数共有68个内置函数

abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
delattr() hash() memoryview() set()

下面分别进行分类介绍

其他相关

1.eval():执行字符串类型的代码，并返回最终结果

print(eval(‘4 + 6‘))

ret = eval(‘{"name":"老男孩"}‘)
print(ret,type(ret))

2.exec:执行字符串类型的代码,流程语句

ret1 = ‘‘‘
li = [1,2,3]
for i in li:
    print(i)
‘‘‘
print(exec(‘3 +4‘))
print(exec(ret1))

3.compile:将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。

1 code1 = ‘for i in range(0,10): print (i)‘
2 compile1 = compile(code1,‘‘,‘exec‘)
3 exec (compile1)

4.print()打印

end 表示 用什么来分割多个打印输出的值.  sep 表示一个打印里多个输出时,用什么隔开

file表示打印输出到一个文件中

print(self, *args, sep=‘ ‘, end=‘\n‘, file=None)
print(333,end=‘‘)
print(666,)
print(111,222,333,sep=‘|‘)
with open(‘log‘,encoding=‘utf-8‘,mode=‘a‘) as f1:
    print(‘5555‘,file=f1)

5.hash 哈希

print(hash(12322))  # 数字不变
print(hash(‘123‘))
print(hash(‘arg‘))
print(hash(‘alex‘))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))

6.help：函数用于查看函数或模块用途的详细说明

print(help(list))

7.callable：函数用于检查一个对象是否是可调用的。

如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

def func1():
    print(555)
a = 3
f = func1
print(callable(f))
print(callable(a))

8.dir() #查看内置数据类型的内置方法

print(dir(list))

9.next() ,iter() 与迭代器方法__iter__ ,__next__方法相同

it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
*iter()

10.

int() 将字符串数字转换成整数类型

bin()：将十进制转换成二进制并返回

oct()：将十进制转化成八进制字符串并返回。

hex()：将十进制转化成十六进制字符串并返回

abs()：函数返回数字的绝对值。

float(): 将整数转换成浮点数

print(int())  # 0

print(int(‘12‘))  # 12

print(int(3.6))  # 3

print(int(‘0100‘,base=2))  # 将2进制的 0100 转化成十进制。结果为 4

print(type(3.14))  # float

print(float(3))

print(bin(5))  # 0b101
print(oct(7))  # 0o7
print(oct(9))  # 0o11
print(hex(10))  # 0xa
print(hex(15))  # 0xf
print(hex(19))  # 0x13

print(abs(-20))

11.divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)

print(divmod(11,3))  #结果  (3, 1)

12.round：保留浮点数的小数位数，默认保留整数

print(round(3.1415))
print(round(3.1415,3))

13.pow 求 x**y次幂 （三个参数为x**y的结果对z取余）

print(sum([1,2,3]))

print(sum([1,2,3],100))

14.

max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）

ret = max([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最大值
print(ret)

sum：对可迭代对象进行求和计算（可设置初始值）

print(sum([1,2,3]))
print(sum([1,2,3],100))

min:对可迭代对象进行求差和计算

ret = min([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最小值
print(ret)

reversed：将一个序列翻转，并返回此翻转序列的迭代器。

ite = reversed([‘a‘,2,3,‘c‘,4,2])
ormat 用于格式化输出很重要print(ite)
for i in ite:
    print(i)

17.

slice：构造一个切片对象，用于列表的切片。

li = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,‘g‘]
l2 = [‘a‘,‘b‘,‘c‘,1,2,3,4,54]
sli_obj = slice(3)
print(li[sli_obj])
print(l2[sli_obj])

sli_obj = slice(7,0,-2)
print(li[sli_obj])

18

format 用于格式化输出很重要

s1 = format(‘test‘, ‘<30‘)
print(format(‘test‘, ‘<30‘))
print(format(‘test‘, ‘>20‘))
print(format(‘test‘, ‘^20‘))
print(len(s1))

19

bytes：只能编码，将unicode ---> 非unicode  bytes(s1,encoding=‘utf-8‘)。

s1 = ‘老男孩‘
s2 = s1.encode(‘utf-8‘)
s22 = bytes(s1,encoding=‘utf-8‘)
print(s2)
print(s2.decode(‘utf-8‘))

20.

bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256

# ret = bytearray(‘alex‘,encoding=‘utf-8‘)  # [65,108,101,120]
# print(id(ret))
# print(ret)
# print(ret[0])  # 97
# ret[0] = 65
# print(ret)
# ret = memoryview(bytes(‘你好‘,encoding=‘utf-8‘))
# print(len(ret))  # 6 utf-8的bytes类型，放在一个list中 [\xe4,\xbd,\xa0,\xe5,\xa5,\xbd]
# print(ret)
# print(bytes(ret[:3]).decode(‘utf-8‘))
# print(bytes(ret[3:]).decode(‘utf-8‘))
# print(‘你好‘.encode(‘utf-8‘))

21

ord:输入字符找该字符编码的位置 unicode
chr:输入位置数字找出其对应的字符 unicode
ascii:是ascii码中的返回该值，不是就返回

print(ord(‘a‘))
print(ord(‘中‘))
print(chr(98))
print(chr(20013))

print(ascii(‘a‘))
print(ascii(‘中‘))  # ‘\u4e2d‘

%r  原封不动的写出来
name = ‘taibai‘
print(‘我叫%r‘ % name)

22. repr() 原形毕露,repr里面是什么类型的就是什么类型

print(repr(‘{"name":"alex"}‘))
print(‘{"name":"alex"}‘)

23. sorted 对可迭代的对象元素进行升序排序, key 可以自定义

li = [1,-2,-7,8,5,-4,3]
print(sorted(li,reverse=True,key=abs))

#[8, -7, 5, -4, 3, -2, 1]
L = [(‘a‘, 1), (‘c‘, 3), (‘d‘, 4),(‘b‘, 2), ]
print(sorted(L, key=lambda x:x[1]))               # 利用key

#按数字排序
#[(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)]

24.

enumerate:枚举，返回一个枚举对象。 (0, seq[0]), (1, seq[1]), (2, seq[2]),

li = [‘老男孩‘, ‘alex‘, ‘wusir‘, ‘嫂子‘, ‘taibai‘]
print(enumerate(li))
print(‘__iter__‘ in dir(enumerate(li)))
print(‘__next__‘ in dir(enumerate(li)))

for k,v in enumerate(li):
    print(k,v)
for k,v in enumerate(li,1):
    print(k,v)

‘‘‘
<enumerate object at 0x0000000001EA9948>
True
True
0 老男孩
1 alex
2 wusir
3 嫂子
4 taibai
1 老男孩
2 alex
3 wusir
4 嫂子
5 taibai
‘‘‘

25.

* all 可迭代对象中，全都是True才是True
 * any 可迭代对象中，有一个True 就是True

print(all([1,2,True,0]))
print(any([1,‘‘,0]))

26.zip 拉链方法 形成元组的个数与最短的可迭代对象的长度一样，然后......

l1 = [1, 2, 3, 4]
l2 = [‘a‘, ‘b‘, ‘c‘, 5]
l3 = (‘*‘, ‘**‘, (1,2,3), 777)
l4= (‘0‘, ‘99‘, (1,2,3), 777)
print(‘__iter__‘ in dir(zip(l1,l2,l3,l4)))
print(‘__next__‘ in dir(zip(l1,l2,l3,l4)))
for i in zip(l1,l2,l3,l4):
    print(i)

‘‘
True
True
(1, ‘a‘, ‘*‘, ‘0‘)
(2, ‘b‘, ‘**‘, ‘99‘)
(3, ‘c‘, (1, 2, 3), (1, 2, 3))
(4, 5, 777, 777)
‘‘

27.

filter 过滤 通过你的函数，过滤一个可迭代对象，返回的是True
类似于[i for i in range(10) if i > 3]

def func(x):
    return x % 2 == 0
ret = filter(func,[1,2,3,4,5,6,7])
print(ret)
for i in ret:
    print(i)



28.


map 创建一个迭代器，它使用来自每个迭代器的参数计算函数。当最短的迭代器耗尽时停止


map(函数,可迭代对象)


def square(x) :            # 计算平方数
    return x ** 2
print(map(square,[1,2,3,4,5]))
for i in map(square,[1,2,3,4,5]):
    print(i)


匿名函数的应用:


匿名函数:lambda


例:
#正规函数
def func1(x):
    return x**2
#使用匿名函数和结构
func = lambda x:x**2
print(func(5))


lambda 函数与内置函数的结合。


内置函数中,可以添加key 的函数都可以与lambda合作


sorted，map，fiter，max，min，reversed


dic={‘k1‘: 10, ‘k2‘: 100, ‘k3‘: 30}
print(max(dic))
print(max(dic, key=lambda x: dic[x]))  # k2
print(dic[max(dic, key=lambda x: dic[x])]) 


例题:


#找出列表中大于10的值,并打印
l1 = [1,2,3,11,12,40,20,50,79]

l2 = [i for i in l1 if i > 10]
print(l2)

def func2(x):
    return x > 10
ret = filter(lambda x: x > 10,l1)
for i in ret:
    print(i)
func = lambda x,y: x if x > y else y



原文地址：https://www.cnblogs.com/tom2ling/p/8718852.html
				


				
时间： 2024-10-10 05:04:08 

		


		


	

	
	

		


		
Python 基础第十四天(内置函数和匿名函数)的相关文章


								

		

			

                Python学习之旅 —— 基础篇（四）内置函数、装饰器
			

		

		

									

				本篇要点: 内置函数 装饰器 一.内置函数 # abs() :取绝对值 >>> res = abs(-10) >>> print(res) 10 # 0,None,"",{},[],() 布尔值都为空 # all(),any() 判断值的真假 # all() 所有为真才为真 p = all([0,1,2,3]) # 0为False,所有p 是False print(p) # any() 任意一个为真即为真 p = any((0,""			

		

	

				

		

			

                Python基础（十四）-并发编程
			

		

		

									

				一.操作系统 参考文档:https://www.cnblogs.com/yuanchenqi/articles/6248025.html 二.进程与线程 2.1.进程简介 进程:一个程序在一个数据集上的一次动态执行过程,一般由程序.数据集.进程控制块三部分组成 程序:用来描述进程要完成哪些功能以及如何完成 数据集:程序在执行过程中所需要使用的资源 进程控制块:记录进程的外部特征,描述进程的执行变化过程,系统可以利用它来控制和管理进程,它是系 统感知进程存在的唯一标志 2.2.线程 线程:轻量级进			

		

	

				

		

			

                python基础7之python3的内置函数
			

		

		

									

				官方介绍: python3:https://docs.python.org/3/library/functions.html?highlight=built#ascii python2:https://docs.python.org/2/library/functions.html?highlight=built#ascii 下面介绍python3中具体每个内置函数的使用方法及含义: abs()			

		

	

				

		

			

                Python基础【day04】：内置函数
			

		

		

									

				一.内置函数表格 1.表格 二.内置函数详情 1.abs(x) 功能:取数的绝对值 1 2 >>> abs(-1)  #取-1的绝对值 1 2.all(iterable) 功能:如果这个可迭代的元素都为真,则返回真(非0的就为真,负数也是为真) 1 2 3 4 >>> all([0,1,3])   #有0,说明为假 False >>> all([1,-5,6])  #负数也是为真 True 3.any(iterable) 功能:可迭代的元素中,有一个为			

		

	

				

		

			

                十四、内置函数
			

		

		

									

				一. 简介 python内置了一系列的常用函数,以便于我们使用,python英文官方文档详细说明:点击查看, 为了方便查看,将内置函数的总结记录下来. 二. 使用说明 以下是Python3版本所有的内置函数: 1. abs() 获取绝对值 1 >>> abs(-10) 2 10 3 >>> abs(10) 4 10 5 >>> abs(0) 6 0 7 >>> a = -10 8 >>> a.__abs__() 9			

		

	

				

		

			

                Python学习（十六）内置函数，递归
			

		

		

									

				1.递归 def test1(): num=int(input('输入数字')) if num%2==0: #判断输入数字是不是偶数 return True #是偶数,程序退出,返回true print('不是偶数请重新输入') return test1() #不是偶数的话继续调用自己,输入值 print(test1()) 递归的效率不高,最多递归999次 2.内置函数 python自带的函数 id()#看内存地址type()#看数据类型print()#打印input()#输入list() #转			

		

	

				

		

			

                python基础学习4-函数、内置函数、os模块、time模块
			

		

		

									

				  1       函数 1.1     字符串格式化方法 Python中字符串格式化输出的几种方法: https://www.cnblogs.com/hongzejun/p/7670923.html 字符串格式化另外一种方式format方式 #字符串format()方法 #第一种 import datetime msg = '欢迎光临{name},今天的日期是{today}' msg = msg.format(name = 'zhangsan',today = datetime.datetim			

		

	

				

		

			

                Python基础（10）_内置函数、匿名函数、递归
			

		

		

									

				一.内置函数 1.数学运算类 abs:求数值的绝对值 divmod:返回两个数值的商和余数,可用于计算页面数 >>> divmod(5,2) (2, 1) max:返回可迭代对象中的元素中的最大值或者所有参数的最大值 语法:max(iterable,key,default) 1 salaries={ 2 'egon':3000, 3 'alex':100000000, 4 'wupeiqi':10000, 5 'yuanhao':2000 6 } 7 8 print(max(salari			

		

	

				

		

			

                Python基础（十四）
			

		

		

									

				今日主要内容 装饰器扩展 有参装饰器 多个装饰器装饰一个函数 递归 一.装饰器扩展 (一)含有参数的装饰器 先来回顾一下装饰器的标准模式 def wrapper(fn): def inner(*args, **kwargs): """扩展内容""" ret = fn(*args, **kwargs) """扩展内容""" return inner @wrapper def func():