内置函数2

Posted 2020-12-31 ning-123

# 元祖和列表
# list:将一个可迭代对象转化成列表，（如果是字典，默认将key作为列表的元素）
# tuple：将一个可迭代对象转化成元祖，（如果是字典，默认将key作为元祖的元素）
# reversed:将一个序列翻转，并返回此翻转序列的迭代器。

# li=[1,6,2,9,4,5]
# reversed(li)
# print(reversed(li))
# for i in reversed(li):
#     print(i)
#
# s1=‘sgdshh‘
# for i in reversed(s1):
#     print(i)
# dic={‘name‘:‘alex‘,‘age‘:10000,‘hobby‘:‘oldwomen‘}
# reversed(dic)                  #字典不可翻转
# for i in reversed(dic):
#     print(i)

# slice: 构造一个切片对象，用于列表的切片

# li=[i for i in range(10)]
# print(li)
# li=[1,2,3,4,0,9,8,7,6,5]
# for i in range(li):
#     print(i)
# for i,j in enumerate(li,1):
#     print(i,j)
# range
# li=[i for i in range(10)]
# l2=li[:5:2]
# l3=[i for i in range(10,20)]
# sli_obj=slice(0,5,2)     #构造一个切片对象，用于列表的切片
# print(l3[sli_obj])
# l4=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
# print(l4[sli_obj])

# bytes: unicode-->bytes类型

# a1=‘太白‘
# print(a1.encode(‘utf-8‘))     #编码
# print(a1.encode(‘utf-8‘).decode(‘utf-8‘))  #解码
# bytes: unicode-->bytes类型
# a1=‘太白‘
# b1=bytes(a1,encoding=‘utf-8‘)   #编码
# print(b1)

# ord:输入字符找到该字符的字符编码 unicode 的位置

# print(ord(‘a‘))
# print(ord(‘中‘))

# chr：输入位置数字找到其对应的字符 unicode

# print(chr(97))
# print(chr(20013))

# ascii:在ascii码中，则返回该值，不在则返回他在unicode的位置（十六进制）

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

# repr:返回一个对象的string形式

# print(repr(‘alex‘))            #打印括号内全部的内容
# print(repr("{‘alex‘:‘SB‘}"))

# 重点：repr(),json pickle 序列化模块 特殊字符串，python 字符串的区别
# 格式化输出
# msg=‘alex 是 %r 的人‘%(‘德高望重‘)  #格式化输出，r 输出括号内全部的内容
# print(msg)

# sorted：对所有可迭代对象进行排序操作

# l1=[4,2,1,5,9,0,7,9,5,4,2]
# # l1.sort()    #对原列表操作
# # print(l1)    #
# print(sorted(l1))    #形成一个新列表
# print(l1)         #原列表不变

# l2=[(1,1000),(2,18),(4,250),(3,500)]
# print(sorted(l2))                #根据列表元素内元素的首个数字排列

# def func(x):
#     return x
# print(sorted(l2,key=func))
# def func(x):
#     return x[1]
# print(sorted(l2,key=func))     #根据列表元素内元素的第二个数字排列

# def func(x):
#     return x[1]
# print(sorted(l2,key=func,reverse=True))   #根据列表元素内元素的第二个数字反转排列

#zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元祖
# ，然后返回一个个元祖组成的列

# # 拉链方法表
# l1=[1,2,3,4,5]
# l2=(‘alex‘,‘日天‘,‘wusir‘)
# l3={‘name‘:‘日天‘,‘age‘:18,‘hobby‘:‘tea‘,‘weight‘:100}
# print(zip(l1,l2,l3))     #迭代器
# print(next(zip(l1,l2,l3)))   #迭代器取值
# for i in zip(l1,l2,l3):
#     print(i)                #迭代器 for 循环
#
# print(list(zip(l1,l2,l3)))    #得到一个个元祖组成的列表

# filter  :过滤，迭代器

# li=[i for i in range(10)]
# def func1(x):
#     return x%2==0
# print(list(filter(func1,li)))   #用法：filter（调用函数，迭代对象）

# map 会根据提供的函数对指定的序列做映射，循环模式

# li=[1,2,3,4]
# print(i for i in li)
# def func(x):return x**2
# print(list(map(func,li)))     #用法：map（调用函数，迭代对象

 

# print() sum reversed
# key: min max map sorted filter zip

 

#匿名函数 lambda 表达式
# 普通函数 有且只有返回值的函数才可以用匿名函数进行简化，一行代码

# func2=lambda x:x*2
# def func2(x):
#     return x*2
# print(func2(6))

# func2=lambda x,y:x+y
# print(func2(1,2))

# l2 = [(1,1000),(2,18),(4,250),(3,500)]
# def func(x):
#     return x
# print(sorted(l2,key=func))
# print(sorted(l2,key=lambda x:x))      #匿名函数，根据第一个元素的第一个数字排列
# print(sorted(l2,key=lambda x:x[1]))

 

#   匿名函数格式： 函数名=lambda x:条件

# dic={‘k1‘:10,‘k2‘:100,‘k3‘:30}
#1,利用内置函数匿名函数将dic按照值进行排序。
# l1=[1,5,7,4,8]
# 利用内置函数匿名函数 计算列表的每个数的2倍。
# l2=[5,8,11,9,15]
# 利用内置函数匿名函数，将值大于10的留下来。

# def func(x):
#     return x[1]
# print(sorted(dic.items(), key= func))

# print(sorted(dic.items(), key=lambda x:x[1]))

# def func(x):
#     return x*2
# print(list(map(func,l1)))

# print(list(map(lambda x:x*2,l1)))

# def func(x):
#     return  x>10
# print(list(filter(func,l2)))

# print(list(filter(lambda x:x>10,l2)))

# 递归函数

# def func():
#     print(666)
#     func()
# func()

# 查看循环了多少次

# def func(n):
#     print(n)
#     n+=1
#     func(n)
# func(1)

# alex  比 wusir 大两岁 n = 4
# wusir 比日天 大两岁  n= 3
# 日天 比太白 大两岁  n = 2
# 太白 24岁 n = 1

# def age(n):
#     if n==1:
#         return 24
#     else:
#         return age(n-1)+2
# print(age(4))