python全栈开发 * 15知识点汇总 * 180621

#15   函数二  与  匿名函数
1.dir() # 查看内置属性,将对象所有方法名放在另一个列表中.
dic={"水果":"香蕉",'蔬菜':"土豆"}
print(dir(dic))
2.迭代器相关  range()  next()  iter()
# range()   # 一般用于for 循环中
#    next  首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
#   iter()    判断对象是迭代器
from collections import Iterable
from collections import Iterator
l = [1,2,3]
print(isinstance(l,Iterable))  # True
print(isinstance(l,Iterator))  # False

l1 = iter(l)
print(isinstance(l1,Iterable))  # True
print(isinstance(l1,Iterator))  # True

3.基础数据类型相关   bool    int      complex    (real  + imag *j)
bool()  #  用于将给定参数转换为布尔类型，如果没有参数，返回 False.
int()# 三种用法:
#(1).直接转化.
s="1234"
print(int(s))     #1234
#(2).小数取整  浮点型转换成整数
print((int(12.23)))    #  结果  12
#补充  :float;将字符转成浮点数
# (3).  将二进制转成十进制
print(int("0100",base=2))
complex  复数  (real  + imag *j)
print(complex(1,2)) #  结果  (1+2j)
4.进制转换  bin()十转二进制  oct()十转八进制   hex()十转十六进制
print(bin(3))   #0b11  十转二进制
print(oct(8))    # 0o11  十转八进制
print(hex(20))    #0x14   十转十六进制
5.数学运算abs()  绝对值   divmod()   round()  pow()  sum()  min()  max()
#abs()
li=[-5,-6,-7,55,66]
print(abs(li[1]))     # 6    求元素的绝对值
#divmod()    计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)
print(divmod(7,3))    #  (2, 1)
#round(小数,位数)   保留浮点数的小数位数，默认保留整数
print(round(3.1415926,4))     #3.1416
# pow()  求x**y次幂。（三个参数为x**y的结果对z取余）
print(pow(2,3))   #8   2的三次幂
print(pow(3,3,5))  #三个参数  先算3的3次幂 ,结果对第三个参数5 取余   # 结果   2
# sum() 两种用法
#1.求和
li=[1,2,3,4,5]
print(sum(li))    #  15  返回列表元素的和
print(sum(li,100))     #115  后面的参数是它的初始值
# 2.设置初始值
print(sum(li,100))     #115  后面的参数是它的初始值
print(sum(li,sum(li)))  #初始值也可以是sum函数   结果30
# min()求最小值  可以加函数名
li2=[-3,-4,-5,55,77]
print(min(li2,key=abs))      # 结果 -3
# max()求最大值 也可以加函数名
dic={'a':3,"b":2,"c":1}
print(max(dic))    #结果  c
def func(x):
    return dic[x]
print(max(dic,key=func))           #  a
print(dic[max(dic,key=func)])      # 结果3
# 用匿名函数
print(max(dic,key=lambda x:dic[x]))    #  a
print(dic[max(dic,key=lambda x:dic[x])])   #   3
6.list() tuple() reversed() slice() str() format() bytes() bytearry() memoryview()
# list() 创建列表  也可以转化
l = list((1,2,3))
print(l)     #  [1, 2, 3]
l = list({'k1':1,'k2':2})
print(l)     #['k1', 'k2']     将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）
# tuple()
tu = tuple((1,2,3))
print(tu)     #(1, 2, 3)
tu = tuple({'k1':1,'k2':2})
print(tu)           #('k1', 'k2') 将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素
# reversed()  将一个序列翻转，并返回此翻转序列的迭代器
li=[22,33,44,55,66]
print(reversed(li))    #  <list_reverseiterator object at 0x000002522EC0CCC0>   返回一个地址
for i in reversed(li):
    print(i)     # 得到它里面的每一个元素
# slice()  构造一个切片对象，用于列表的切片
li=[1,2,3,4,5,6,7]
li2=[2,-3,4,-5,6,-7]
print(li[1:4])          # [2, 3, 4]
print(li2[1:4])         #[[-3, 4, -5]
rule=slice(1,4,2)       #第三个参数为步长
print(li[rule])         # [2, 3, 4]
print(li2[rule])        #  [-3, 4, -5]
# str()  将数据转化成字符串

# 与具体数据相关，用于计算各种小数，精算等
# 字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('1234', '<20'))  #左对齐
print(format('test', '>20'))  #右对奇
print(format('abcd', '^20'))  #居中对齐
#  bytes()   把unicode 转换成 bytes
s = '你好'
bs = s.encode('utf-8')
print(bs)   #  b'\xe4\xbd\xa0\xe5\xa5\xbd'
bs = bytes(s, encoding='utf-8')
print(bs)   #  b'\xe4\xbd\xa0\xe5\xa5\xbd'
# bytearry()
ret = bytearray('alex',encoding='utf-8')
print(id(ret))   #  2249729581216  内存地址
print(ret)      #bytearray(b'alex')
print(ret[0])   # 97  utf-8编码的第一位  a   序号97
ret[0] = 65
print(ret)         #bytearray(b'Alex')
print(id(ret))   #   32249729581216
#  memoryview()
ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret))   # 字节的长度
print(ret)   #<memory at 0x000001E263235F48>  地址
print(bytes(ret[:3]).decode('utf-8'))  # 解码字节,范围是[0:3]   你
print(bytes(ret[3:]).decode('utf-8'))   #解码字节 范围是[3:]    好
 7.ord() chr() ascii()
# ord:输入字符找该字符编码的位置
print(ord('我'))   # 25105
# chr:输入位置数字找出其对应的字符
print(chr(100))     #d
# ascii:是ascii码中的返回该值，不是就返回/u..
print(ascii('a'))   #'a'
print(ascii('中'))  #'\u4e2d'
# 8.repr() dict() set() frozenset()  len() sorted()
#  repr()  返回一个对象的string形式（原形毕露）
name = 'taibai'
print('我叫%r'%name)   #  我叫'taibai'
print(repr('{"name":"alex"}'))   #'{"name":"alex"}'   有引号
print('{"name":"alex"}')   #{"name":"alex"}      无引号
# set()   创建一个集合
# dict()   创建一个字典
# frozenset()   返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
# len()   返回一个对象中元素的个数

sorted()

l = [('a', 1), ('c', 3), ('d', 4),('b', 2) ]
print(sorted(l,key=lambda x:x[1]))    #  [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students,key=lambda x:x[2]))   #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
print(sorted(students,key=lambda x:x[2],reverse=True ))   #[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
9.all()  any()  zip()  filter()  map()
# all()  可迭代对象中，全都是True才是True
print(all([1, 2, True, 0]))   #   False   最后一项是0
# any()  可迭代对象中，有一个True 就是True
print(any([1, '', 0]))     #True
# zip()  函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
# 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同
li1=["1","2","3",]
li2=["a","b","c","d"]
li3=["*","**",(1,2,3),"2","4"]
print(zip(li,li2,li3))     #<zip object at 0x0000019722FE32C8>
for i in zip(li,li2,li3):
    print(i)   #(1, 'a', '*')
# filter()  过滤
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)    #2,4,6
# map()  会根据提供的函数对指定序列做映射
li=[1,2,3,4,5]
def func1(x):return x*x
ret=map(func1,li)    #<map object at 0x0000026608732470>
print(ret)
for i in ret:
    print(i)
print(map(lambda x:x**2,[1,2,3,4,5]))
for i in map(lambda x:x**2,[1,2,3,4,5]):
    print(i)

 10.匿名函数 一句话函数   变量=lambda 参数,参数冒号 返回值.
calc = lambda n:n**n
print(calc(10))
# 匿名函数 格式说明
#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型
res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)
res = filter(lambda x: x > 10, [5, 8, 11, 9, 15])
for i in res:
     print(i)