python内置方法怎么使用_python中的常用内置方法

s='sdfsdfsd'

# # lista=[1,2,3,4,5]

# # l2=reversed(lista)

sli=slice(1,4,2)

print(s[sli])

# # print(lista)

# for i in l2:

# print(i)

#format() 调整输出

# print(format('test','<20'))

# print(format('test','>20'))

# print(format('test','^20'))

# bytearray 修改字节编码

# s1=bytearray('你好',encoding='utf-8')

# print(s1)

# s1[0]=128

# print(s1)

# memoryview 将切片返回成字节 不占内存空间，但是转成字符串依然占内存空间

# str01='sdfsdfvcc'

# str02=str01[:3]

# l2=memoryview(bytes(str02,encoding='utf-8'))

# print(list(l2))

#转成

# ord 字符按照unicode转数字(可以理解成字符在unicode中的位置)

# chr 数字按照unicode转成对应字符

# ascii 入参只要实在ascii中就打印出来，不是就转换成'\uxxxx'

# print(ord('a'))

# print(ord('1'))

# print(ord('袁'))

#

# print(chr(34945))

#

# print(ascii('袁'))

# print(ascii('A'))

#all(iterable) any(interable)

#all可迭代对象中有一个是false就是返回false

#any可迭代对象中有一个是True就是返回True

# print(all(['a','',123]))

# print(all(['a',123]))

# print(all([1,123]))

# print(all([0,123]))

#

# print(any(['',0,1]))

# print(any({'i'}))

#zip拉链 传入对象元素需要相等 如果不等则能匹配几个就匹配几个

# l=[12,14,56,55]

# l2=['a','b','c']

# l3={'k1':1,'k2':55}

# for i in zip(l,l2,l3):

# print(i)

#filter 执行了filter之后，结果结合小于执行执行之前的个数

#filter只管筛选，并不会改变原来的值

# def is_odd(x):

# return x%2==1

# ret=filter(is_odd,[1,2,4,5,67,7])

# print(ret)

# print(list(ret))

# rets=[i for i in [1,2,4,5,67,7] if i%2==1]

# print(rets)

#

#

# def is_str(x):

# return type(x)==str

#

# ret01=filter(is_str,['nihao',12,'xu','yuanniu'])

# for j in ret01:

# print(j)

#利用filter()过滤出1-100的平方根是整数的数

#[1,4,5,16,25,36,49,64,81,100]

#

# import math

# def sqrt_01(x):

# # x1=math.sqrt(x)%1

# # if x1==0:

# # print(x1)

# # return x

# print(math.sqrt(x))

# return math.sqrt(x)%1==0

#

# # s=sqrt_01(100)

# # print(s)

# rs01=filter(sqrt_01,range(1,101))

# print(list(rs01))

#map 函数 执行前后 元素个数不变 值可能发生变化

# ret04=map(abs,[1,-9,8,-90])

# print(ret04)

# # for a in ret04:

# # print(a)

#

# ret05=[abs(a) for a in [1,-9,8,-90]]

# print(ret05)

# print(list(ret04))

#sort和sorted区别

# sort实在元列表的基础上进行排序 不占内存

# sorted是直接重新生成一份列表 不改变原列表，占内存

# listb=[1,2,-6,-8,]

# # # listb.sort(key=abs)

# # # print(listb)

# # # listb1=[1,2,-6,-8,10]

# # # print(sorted(listb1,reverse=True,key=abs))

#列表按照每个一个元素的len排序

# listc=['sdfsdf','524dsf','sdf55666666','abc']

# ret=sorted(listc,key=len)

# print(ret)

#

#

# def sort_01(x):

# ret=sorted(x,key=len)

# return ret

#

# print(sort_01(listc))

匿名函数和内置函数的配合使用

'''

匿名函数

函数名=lambda 入参 ：返回值

参数可以有多个，用逗号隔开

匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束之后内荣就是返回值

返回值和正常函数一样可以是任意的数据类型

'''

# calc=lambda n:n*n

# print(calc(10))

#

# add01=lambda a,b:a+b

# print(add01(1,2))

'''

带有key参数的 函数 有 min max map filter sorted经常和lambda配合使用,这些函数实现功能首先会对入参做某些操作，

例如sorted(lista,key=len) 一定是先遍历列表lista 在调用len函数计算元素长度

'''

#带有key参数的 函数 有 min max map filter sorted经常和lambda配合使用

#字典排序 max先回判断入参是什么类型 在根据类型采用对应的取值方法判断

# dic={'k1':10,'k2':100,'k3':30}

# print(max(dic,key=lambda k:dic[k]))

# lista=[4,2,3,1]

# print(max(lista,key=lambda x:lista[x-1]))

#

# listb=[3,2,100,888,999,213,1111]

# res=map(lambda x:x**2,[1,2,6,8])

# print(list(res))

#筛选列表中大于10的数字

# res1=filter(lambda n:n>10,listb)

# print(list(res1))

# d=lambda p:p*2

# t=lambda p:p*3

# x=2

# x=d(x)

# x=t(x)

# x=d(x)

# print(x)

#现有两个元组((('a'),('b')),(('c'),('d')))

# 请用python中的匿名函数成成列表[{'a':'c','b':'d'}]

tup_01=zip((('a'),('b')),(('c'),('d')))

print(list(tup_01))

#

# def func_01(tup):

# return {tup[0]:tup[1]}

# #ret=map(func_01,tup_01)

# ret01=map(lambda tup:{tup[0]:tup[1]},tup_01)

# #print(list(ret))

# print(list(ret01))

# # for i in tup_01:

# print(i)

# def multipliers(x):

# return [lambda x:i*x for i in range(4)]

# ret=multipliers(2)

# print((ret))

# #

# for i in ret:

# r=i(4)

# print(r)

#print([i for i in range(4)])

# print((ret))

# print([m(2) for m in multipliers()])

#

#

#

# def multipliers():

# return (lambda x:i*x for i in range(4))

# ret=multipliers()

# print(ret)

# print([m(4) for m in multipliers()])

filter和map函数

# # 1 用map函数来处理字符串列表 把列表中所有人都变成ss例如alex_ss

# name=['alex','wupeiq','wang','yong','mei']

# print(list(map(lambda x:x+'_ss',name)))

#

# #2 用filter函数处理数字列表，将列表中所有的偶数筛选出来

# num=[1,2,3,5,6,8,10]

# print(list(filter(lambda x:x%2==0,num)))

#3一写一个20行以上的文件

#运行程序，现将内容读取的内容中，用列表储存

#模拟用户输入页码，每页5条，仅输出当前页的内容

# def file_read(filename):

# with open(filename,encoding='utf-8')as f:

# ret=f.readlines()

# return ret

#

#

# def filter_num(ret_num):

# if ret_num>0:

# ret_num=ret_num*5-5

# ret_con=file_read('examtest')

# #ret=[x for x in ret_con lambda x:x[ret_num:ret_num+5]]

# ret=filter(lambda x:ret_con[ret_num::],ret_con)

# return ret

#

# ret=filter_num(2)

# print(list(ret))

# with open('examtest',encoding='utf-8')as f1:

# l=f1.readlines()

# page_num=input('页码')

# page_num=int(page_num)

# pages,mod=divmod(len(l),5)

# if mod:

# pages+=1

# if page_num>pages or page_num<=0:

# print('输入有误')

# elif page_num==pages and mod!=0:

# for i in range(mod):

# print(l[(page_num-1)*5+i].strip())

# else:

# for i in range(5):

# print(l[(page_num-1)*5+i].strip())

# 4 如下 每个小字典的name对应股票名字 shares对应多少股 price对应价格

# portfolio=[{'name':'IBM','shares':100,'price':91.1},

# {'name':'AAPL','shares':50,'price':543.22},

# {'name':'FB','shares':200,'price':21.09},

# {'name':'HPQ','shares':35,'price':31.75},

# {'name':'YHOO','shares':45,'price':16.35},

# {'name':'ACME','shares':75,'price':115.65}]

# # 4.1 计算购买每只股票的的总价

# ret=map(lambda dic:{dic['name']:dic['shares']*dic['price']},portfolio)

# print(list(ret))

#

# #4.2 用filter过滤出 单价大于100的股票有那些

# ret0=filter(lambda dict:dict['price']>100,portfolio)

# print(list(ret0))