Python函数Day6

一、内置函数

list()　　　　　　将一个可迭代对象转化为列表

字典转为列表：会将所有键转化为列表

字符串转为列表：键每个字符转化为列表

s = 'abc'
dic = {'a':1,'b':2,'c':3}
print(list(s))              # 字符串的字符逐个转为列表
print(list(dic))            # 将字典的键转为列表

# 结果
['a', 'b', 'c']
['a', 'b', 'c']

tuple()　　　　　　将一个可迭代对象转化为元组

字典转为元组：会将所有键转化为元组

字符串转为元组：键每个字符转化为元组

s = 'abc'
dic = {'a':1,'b':2,'c':3}
print(tuple(s))             # 字符串的字符逐个转为元组
print(tuple(dic))           # 将字典的键转为列表

# 结果
('a', 'b', 'c')
('a', 'b', 'c')

slice()　　　　实现切片对象

制作了切片的规则，方便其他的切片可以调用

调用方法跟切片相似，列表[切片对象]

li = [i for i in range(1,11)]
section = slice(0,9,2)
print(li[section])

# 结果
[1, 3, 5, 7, 9]

str()　　　　　　将数据类型转化为字符串

s = str(123456789)
print(s,type(s))

# 结果
123456789 <class 'str'>

可以将bytes类型的字符转为str，需要加编码encoding

s = str(b'\xe4\xbd\xa0\xe5\xa5\xbd',encoding='utf-8')
print(s)

# 结果
你好

format()　　　　　　与数据相关，一般用于科学计算

print(format('右对齐','>20'))          # 第一参数是任何类型，第二参数>右对齐和字符串的长度
print(format('左对齐','<20'))          # 第一参数是任何类型，第二参数<左对齐和字符串的长度
print(format('居中','^20'))            # 第一参数是任何类型，第二参数^居中和字符串的长度

# 结果
                 右对齐
左对齐
         居中         

print(format(99,'b'))                  # 第一参数转化为二进制
print(format(99,'d'))                  # 第一参数转化为十进制
print(format(99,'o'))                  # 第一参数转化为八进制
print(format(99,'x'))                  # 第一参数转化为十六进制，小写字母表示
print(format(99,'X'))                  # 第一参数转化为十六进制，大写字母表示
print(format(99,'n'))                  # 第一参数转化为十进制
print(format(99,'c'))                  # 第一参数转化为unicode字符
print(format(''))                   # 默认

# 结果
1100011
99
143
63
63
99
c
123

bytes()            将unicode转化为bytes类型

格式：bytes(字符串,encoding=编码)

s = '哈哈哈'
b = bytes(s,encoding='utf-8')
print(b)

# 结果
b'\xe5\x93\x88\xe5\x93\x88\xe5\x93\x88'

将整型转化为bytes类型（不能加encoding）

b = bytes(10)
print(b,type(b))

# 结果
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' <class 'bytes'>

将可迭代对象转化为bytes类型（不能加encoding）

b = bytes([1,2,3])
print(b,type(b))

# 结果
b'\x01\x02\x03' <class 'bytes'>

bytearray()　　　　返回一个新字节数组

可以将字符串转化为unicode码，通过切片或者索引替换值，改变原来的值，id不变

ret1 = bytearray('你好',encoding='utf-8')
print(id(ret1))              #
print(ret1)                  # bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbd')
print(ret1[:3])              # bytearray(b'\xe4\xbd\xa0')
ret1[:3] = b'\xe6\x82\xa8'   # 通过切片替换值
print(ret1)                  # bytearray(b'\xe6\x82\xa8\xe5\xa5\xbd')
print(id(ret1))              #

memoryview() 　　　　函数返回给定参数的内存查看对象(Momory view)。

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

v = memoryview(bytearray('abc',encoding='utf-8'))
print(v[0])                 #
print(v[-1])                #

ret2 = memoryview(bytes('你好',encoding='utf-8'))
print(id(ret2))                             #
print(ret2)                                 # <memory at 0x0000019657A51048>
print(bytes(ret2).decode('utf-8'))          # 你好

ord()　　　　输入字符找该字符编码的位置，unicode的字符编码或者ascii的字符编码

print(ord('好'))            #

chr()　　　　输入位置数字找出对应的字符，unicode的字符编码或者ascii的字符编码，跟ord相反

print(chr(22909))           # 好

ascii　　　　函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符

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

repr()　　　　返回一个对象的string形式

dic = {'baidu':'baidu.com','google':'google.com'}
print(repr(dic),type(repr(dic)))            # {'baidu': 'baidu.com', 'google': 'google.com'} <class 'str'>

s = 'google'
print(repr(s))                              # 'google'

用途：① 研究json pickle序列化模块，特殊字符串与python字符串的区别

② 格式化输出 %r

print("I'll do a %r search" % ('Google'))

# 结果
I'll do a 'Google' search

dict()　　　　创建一个字典

dic = dict(zip(['a','b','c'],[1,2,3]))
# {'a': 1, 'b': 2, 'c': 3}

set()　　　　创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等

frozenset()　 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

li = frozenset([1,2,3,4,5])
# frozenset({1, 2, 3, 4, 5})

len()　　　　返回对象中元素的个数

print(len([i for i in range(10)]))
#

sorted()　　对所有可迭代的对象进行排序操作

通过原对象排序后形成新的对象，对原对象无影响

默认按对象的元素的索引0的元素排序

dic = {'b':1,'c':3,'a':2}
print(sorted(dic))

# 结果
['a', 'b', 'c']

参数key可以添加函数来比较。

dic = {'b':1,'c':3,'a':2}
def func(x):                                    # 字典的是传入键
    return dic[x]                               # 返回键对应的值
print(sorted(dic,key=func,reverse=True))        # 通过函数的返回值来排序，reverse是倒序

# 结果
['c', 'a', 'b']

all()　　　　可迭代对象里的元素全是True才返回True

any()　　　 可迭代对象里的元素有一个True就返回True

li = [1,2,3,'',()]
print(all(li))
print(any(li))

# 结果
False
True

zip()　　　　函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

拉链方法：以长度最短的可迭代对象为主，写多个可迭代对象，将纵向组成一个个元组，按顺序排列；组合是一个迭代器。

li = [1,2,3,4,5]
tu = ('a','b','c')
dic = {'i':10,'k':20,'j':30}
print(zip(li,tu,dic))               # <zip object at 0x000002452FD4AFC8> 迭代器

for i in zip(li,tu,dic):
    print(i)

# 结果
(1, 'a', 'i')
(2, 'b', 'k')
(3, 'c', 'j')

filter() 　　　　函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

类似于筛选模式下的列表推导式

格式：filter(function or None, iterable)

def func(x):return x % 2 == 1
l1 = [i for i in range(10)]
f1 = filter(func,l1)
print(f1)                       # <filter object at 0x0000026A61F47908>  迭代器
print(list(f1))                 # [1, 3, 5, 7, 9]

# 结果
<filter object at 0x0000026A61F47908>
[1, 3, 5, 7, 9]

map() 　　会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

类似于列表推导式的循环模式，根据提供的函数对指定序列做映射

def func(x):return pow(x,3)
li = [1,3,5,8,9]
l2 = map(func,li)
print(l2)                   # <map object at 0x0000022EE54A7A20> 迭代器
print(list(l2))             # [1, 27, 125, 512, 729]

# 结果
<map object at 0x0000022EE54A7A20>
[1, 27, 125, 512, 729]

重点掌握：print、min、max、sum、map、sorted、reversed、filter、zip

有key的内置函数：min、max、map、sorted、filter、zip

二、匿名函数

lambda 表达式 就是匿名函数，一行函数

普通函数，有且只有返回值的函数才可以使用匿名函数进行简化，一行函数。

匿名函数一般不单独使用，多余内置函数配合使用。

格式：

func = lambda x:x*2

函数名 = lambda 参数 ：返回值

func = lambda x : pow(x,3)
print(func(2))              #

匿名函数的返回值可以放三元运算

func = lambda x : x > 13 and x or x**2
print(func(10))              #

三、递归函数

函数的自我调用，就称为递归函数。

递归能解决的函数也能解决，而且递归算法解题的运行效率较低。

使用递归函数一定要用 return

# 求 8！
def func(x):
    if x == 1:
        return x
    return x * func(x-1)
print(func(8))

python默认递归深度有限制的，默认998次，以免消耗尽内存

def func(x):
    print(x)
    x += 1
    return func(x)
func(1)

# 结果
1
2
...
...
...
996
997
998
Traceback (most recent call last):
  File "D:/Day14/review.py", line 256, in <module>
    func(1)
  File "D:/Day14/review.py", line 255, in func
    return func(x)
  File "D:/Day14/review.py", line 255, in func
    return func(x)
  File "D:/Day14/review.py", line 255, in func
    return func(x)
  [Previous line repeated 993 more times]
  File "D:/Day14/review.py", line 253, in func
    print(x)
RecursionError: maximum recursion depth exceeded while calling a Python object

可以对深度进行修改，导入sys模块

import sys
sys.setrecursionlimit(100000)
def func(x):
    print(x)
    x += 1
    return func(x)
func(1)

# 结果
1
2
3
...
...
...
3219
3220
3221