Python _内置函数3_45

reversed：

#reversed()
l = [1,2,3,4,5]
l.reverse()
print(l) #改变了原来的列表

l = [1,2,3,4,5]
l2 = reversed(l)
print(l2)
# 保留原列表，返回一个反向的迭代器

slice：

l = (1,2,23,213,5612,342,43)
sli = slice(1,5,2)  #sli 是一个切片的规则
print(l[sli])

print(l[1:5:2])   #不用slice 直接切片的效果是一样的

format：

print(format('test', '<20')) #左对齐
print(format('test', '>40'))
print(format('test', '^40'))

补充：https://www.cnblogs.com/LXL616/p/10684538.html

bytes：

#bytes 转换成bytes类型
# 我拿到的是gbk编码的，我想转成utf-8编码

print(bytes('你好',encoding='GBK'))     # unicode转换成GBK的bytes
print(bytes('你好',encoding='utf-8'))   # unicode转换成utf-8的bytes
print(bytes('你好',encoding='GBK').decode('GBK'))   #unicode转化为GBK

# 网络编程 只能传二进制
# 照片和视频也是以二进制存储
# html网页爬取到的也是编码

bytearray：

b_array = bytearray('你好',encoding='utf-8')
print(b_array)
'''
b'\xc4\xe3\xba\xc3'
b'\xe4\xbd\xa0\xe5\xa5\xbd'
bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
'''
print(b_array[0]) #

s1 = 'alexa'
s2 = 'alexb' #当字符串很大时，希望改变某一个值同时可以不用在内存中再生成一个变量，节省内存的空间，可以通过bytearray来改变某个字节从而来改变一个字符串，不在重新产生新的变量节省了内存的空间

memoryview：

l = 'ahfjskjlyhtgeoahwkvnadlnv'
l2 = l[:10]
# 字节 —— 字符串 占内存
# memoryview
# 切片 —— 字节类型  不占内存

ord 和 chr：

print(ord('a')) # 查看字符a的编码

print(ord('好')) 
print(ord('')) 
print(chr(97)) #查看编码为97的字符

asvii：

print(ascii('好')) #'\u597d'
print(ascii('')) # '1'

repr：

name = 'egg'
print('你好%s'%name) #你好egg
print('你好%r'%name) #你好'egg' # %r 使用的是repr方法
print(repr('')) # '1'  #repr 将原有的数据类型展示出来
print(repr(1)) # 1

 # %r 用于格式化输出 

dict：

set： 可以作为字典的 key

frozenset：可以作为字典的 key

len：

enumerate：

http://www.runoob.com/python3/python3-func-enumerate.html

all & any：

#all 只要列表中有一个值为false最后的值就位false

print(all(['a','',123])) #False
print(all(['a',123])) #True
print(all([0,123])) #False

#any 只要有一个为true 结果就位true
print(any(['',True,0,[]]))  #True

zip：

print(zip((1,12))) #<zip object at 0x000002687BD7B088>

l = [1,2,3,4,5]
l2 = ['a','b','c','d']
for i in zip(l,l2):
    print(i)
'''
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
'''

l = [1,2,3,4,5]
l2 = ['a','b','c','d']
l3 = ('*','**',[1,2])
d = {'k1':1,'k2':2} #只有两个key所以只能配对两组
for i in zip(l,l2,l3,d):
    print(i)
'''
(1, 'a', '*', 'k1')
(2, 'b', '**', 'k2')
'''

filter & map：

Eva_J

https://www.cnblogs.com/Eva-J/articles/7266192.html

filter

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：

def is_odd(x):
    return x % 2 == 1 #判断奇偶性，偶数传入后返回True，基数传入后返回的是False

然后，利用filter()过滤掉偶数：

>>>list(filter(is_odd, [1, 4, 6, 7, 9, 12, 17]))

ret = filter(is_odd, [1,  6, 7, 12, 17]) #第一个参数传的是函数的地址所以函数不用加括号，第二个参数传的是一个可迭代的的
print(ret) #<filter object at 0x0000017A8FB22D30> #返回的是迭代器

for i in ret:
    print(i)
'''

1
7
17

'''

ret = list(filter(is_odd, [1,  6, 7, 12, 17]))

print(ret) #[1, 7, 17]

a = [i for i in [1, 4, 6, 7, 9, 12, 17] if i % 2 == 1]
print(a) #[1, 7, 9, 17] 这里的for循环和以上效果类似，不过filter可以更复杂，可以再函数中定义更多的内容

#过滤出列表中的字符串

def is_str(s):
    if type(s) == str:
        return True
ret = filter(is_str, [1, 'hello','','  ',None,[], 6, 7, 'world', 12, 17])
print(ret)
for i in ret:
    print(i)

def is_str(s):
    return type(s) == str
ret = filter(is_str, [1, 'hello','','  ',None,[], 6, 7, 'world', 12, 17])
print(ret)
for i in ret:
    print(i)

def is_str(s):
    return s and str(s).strip()
ret = filter(is_str, [1, 'hello','','  ',None,[], 6, 7, 'world', 12, 17])
print(ret)
for i in ret:
    print(i)

利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：

def is_not_empty(s):
    return s and len(s.strip()) > 0
>>>list(filter(is_not_empty, ['test', None, '', 'str', '  ', 'END']))

结果：

['test', 'str', 'END']

注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。

当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下：

>>> a = ' 123'
>>> a.strip()
'123'

>>> a = '\t\t123\r\n'
>>> a.strip()
'123'

练习：

请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：

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

方法：

from math import sqrt
def func(num):
    res = sqrt(num)
    return res % 1 == 0
ret = filter(func,range(1,101))
for i in ret:
    print(i)

'''
1
4
9
16
25
36
49
64
81
100

'''

import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
print(list(filter(is_sqr, range(1, 101))))

结果：

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

map：

Python中的map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理。

>>> L = [1,2,3,4,]
>>> def pow2(x):
... return x*x
...
>>> list(map(pow2,L))
[1, 4, 9, 16] 

ret = map(abs,[1,-4,6,-8])
print(ret)
for i in ret:
    print(i)

# filter 执行了filter之后的结果集合 <= 执行之前的个数
#filter只管筛选，不会改变原来的值
# map 执行前后元素个数不变
# 值可能发生改变

sort：

l = [1,-4,6,5,-10]
l.sort()   # 在原列表的基础上进行排序
print(l) # [-10, -4, 1, 5, 6]
l.sort(key = abs)
print(l) # [1, -4, 5, 6, -10]

sorted：

对List、Dict进行排序，Python提供了两个方法
对给定的List L进行排序，
方法1.用List的成员函数sort进行排序，在本地进行排序，不返回副本
方法2.用built-in函数sorted进行排序（从2.4开始），返回副本，原始输入不变

--------------------------------sorted---------------------------------------

sorted(iterable, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customise the sort order, and the
reverse flag can be set to request the result in descending order.

-----------------------------------------------------------------------------
参数说明：
iterable：是可迭代类型;
key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序;
reverse：排序规则. reverse = True  降序 或者 reverse = False 升序，有默认值。
返回值：有序列表

 

例：

列表按照其中每一个值的绝对值排序

l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l1)
print(l2)

l = [1,-4,6,5,-10]
print(sorted(l))  #生成一个新的列表 不改变原有的列表 占内存
print(l)

l = [1,-4,6,5,-10]
print(sorted(l,key=abs)) #关键字 根据绝对值排序
print(l)

l = [1,-4,6,5,-10]
print(sorted(l,key=abs,reverse=True)) #从大到小排
print(l)

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

l = [[1,2],[3,4,5,6],(7,),'']
print(sorted(l,key=len))

l = ['   ',[1,2],'hello world']
new_l = sorted(l,key=len)
print(new_l)

l = ['   ',[1,2],'hello world']
def func(item):
    return len(item)
new_l = sorted(l,key=func)
print(new_l)