1、組み込み関数
（1）のeval（）：コードが実行される文字列の種類、および最終結果アーティファクトを返します
a = "88 + 99"
print(eval(a))
eval("n + 4") # 85
eval('print(666)') # 666注意：禁止覚えていますか
（2）のexec（）：実行文字列アーチファクトコードの二種類
def func():
print(111)
func()
exec(func())注意：禁止覚えていますか
（3）ハッシュ（）関数は、不変変数のデータ・タイプとデータ・タイプを区別することです
print(hash("123"))
print(hash(12))
print(hash(-1))
print(hash(-10))
print(hash((2,1)))
dic = {[1,2,3]:2}
print(hash([1,2,3]))（4）ヘルプ（）：ヘルプ情報を表示するために、目的のために詳細に説明された機能またはモジュールを参照
help(list) （5）呼び出し可能（）：オブジェクトを呼び出すことができるかどうかをチェックします
def func():
print(1)
lst = [1,23,4,]
print(callable(lst))（6）INT（）は：文字列または整数に変換します
print(int())
print(int('12'))
print(int(3.6)) （7）フロート（）：文字列を整数に変換し、浮動小数点
print(float(3))
print(int(3))（8）錯体（）：複数
print(complex(20))（9）ビン（）：10進数のバイナリ0Bを回します
print(bin(100))
（10）オクト（）：10進数ターンの8進0°
print(oct(10))
（11）進（）：10進数ターンの六角0X
print(hex(17))
（12）divmod（）：商と剰余（商、余り）
print(divmod(5,2))
（13）ラウンド（）：予約小数点以下の桁数
print(round(3.534232,2))
（14）POWは、（）：POWのべき乗の3つのパラメータは、べき乗剰余であるときに、2つのパラメータは、べき乗である場合であります
print(pow(2,2)) #幂 pow 两个参数是求幂
print(pow(2,2,3)) #幂 pow 两个参数是求幂后的余
（15）バイト（）：異なる符号間の変換のための文字列エンコーディング、
s = "你好"
s1 = bytes(s,encoding="utf-8")
print("s1")
（16）ORD（）：要素エピトープを流れる電流の数を取得します
print(ord("你"))
（17）CHR（）：要素ルックアップテーブルのビット数によって
print(chr(20320))
（18）のrepr（）：プログラマのための生態学的ビュー・データ・ソース、
a = 'alex'
print(repr(a)) #查看你数据的原生态 -- 给程序员使用的
print(a) # 给用户使用的
（19）すべての（）：コンテナ要素が真であるかどうかを決定する（と）
lst = [1,2,0,4,5]
print(all(lst))
（20）任意の（）：コンテナ要素が真を有するかどうかを決定します
lst = [1,2,3,0,1,23]
print(any(lst))
（21）グローバル（）：グローバル変数を参照してください
print(globals())
（22）地元の人々（）：現在の空間の変数を見ます
a = 10
def func():
a = 1
print(locals()) # 查看当前空间变量
print(1)
func()
（23）のfrozenset（）：フリーズコレクション
2、2つの組み込み関数
（1）一般的な機能：
<1>印刷（）画面出力
''' 源码分析
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
"""
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
sep: 打印多个值之间的分隔符，默认为空格
end: 每一次打印的结尾，默认为换行符
flush: 立即把内容输出到流文件，不作缓存
"""
'''
sep : 每一个元素之间分割的方法 默认 " " ****
print(1,2,3,sep="|")
end :print执行完后的结束语句 默认\n ****
print(1,2,3,end="")
print(4,5,6,end="")
file : 文件句柄 默认是显示到屏幕
print(1,2,3,4,file=open("test","w",encoding="utf-8"))
print() # flush 刷新
print(111,222,333,sep='*') # 111*222*333
print(111,end='')
print(222) #两行的结果 111222
f = open('log','w',encoding='utf-8')
print('写入文件',fle=f,flush=True
<2> DIR（）現在のオブジェクトのメソッドを表示するには、すべてのリストを返します
print(dir(list)) # 查看当前对象所有方法 返回的是列表print(dir(str)) # 查看当前对象所有方法
<3>フォーマット（）フォーマット変換
# 对齐方式
print(format("alex",">20")) # 右对齐
print(format("alex","<20")) # 左对齐
print(format("alex","^20")) # 居中
# 进制转换
print(format(10,"b")) # bin 二进制
print(format(10,"08b"))
print(format(10,"08o")) # oct 八进制
print(format(10,"08x")) # hex 十六进制
print(format(0b1010,"d")) # digit 十进制
<4>バイトの文字列にSTR（）
byte_str = bytes("你好",encoding="utf")
print(byte_str)
print(str(byte_str,encoding="utf-8"))
リスト反復にオブジェクト〜<5>のリスト（）
print(list("alex"))
<6>タプル（）イテレータオブジェクトがタプルに話すことができます
print(tuple([1,2,3,4]))
<7>セット（）セットイテラブルに変換されます
print(set("alex"))
<8>辞書（）は、対応する方法の辞書を作成します
print(dict([(1,2),(3,4)]))
print(dict(k=1,v=2,c=3))
dic1 = {"key1":1,"key2":2}
dic2 = {"a":1,"b":2}
dic2.update(dic1)
print(dic2)
print(dict(**dic1,**dic2))
<9> ABS（）は絶対値を返します
i = -5
print(abs(i)) # 5
<10>和（）合計
print(sum([1,2,3]))
print(sum((1,2,3),100)) # 从100开始加
<11>（）逆反転の配列となり、反転配列はイテレータを返します
print(list(reversed("alex")))
lst = [1,2,3,4,5]
print(list(reversed(lst))) 反转
print(lst)
<12>ジッパー（）ファスナー
反復が一貫性のない各イテレータの要素の数は、最短復帰の長さに応じた場合、タプルに充填要素に対応するオブジェクトの最初のパラメータとして使用され、これらのタプル組成物の内容を返すことができます。
lst1 = [1,2,3]
lst2 = ['a','b','c','d']
lst3 = (11,12,13,14,15)
for i in zip(lst1,lst2,lst3):
print(i)
结果:
(1, 'a', 11)
(2, 'b', 12)
(3, 'c', 13)
（2）次関数：
<1>分（）最低
rint(min([1,2,3])) # 返回此序列最小值
ret = min([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最小值
print(ret)
# 加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，然后通过你设定的返回值比较大小，返回最小的传入的那个参数。
print(min(1,2,-5,6,-3,key=lambda x:abs(x))) # 可以设置很多参数比较大小
dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x:dic[x]))
# x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键
<2> MAX（）は最大値を選択します
print(max(10,12,13,15,16))
print(max([10,12,13,15,-16],key=abs))
<3>ソート（）関数をソートします
语法:sorted(iterable,key=None,reverse=False)
iterable : 可迭代对象
key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序
reverse :是否是倒序,True 倒序 False 正序
lst = [1,3,2,5,4]
lst2 = sorted(lst)
print(lst) #原列表不会改变
print(lst2) #返回的新列表是经过排序的
lst3 = sorted(lst,reverse=True)
print(lst3) #倒叙
结果:
[1, 3, 2, 5, 4]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
字典使用sorted排序
dic = {1:'a',3:'c',2:'b'}
print(sorted(dic)) # 字典排序返回的就是排序后的key
结果:
[1,2,3]
和函数组合使用
# 定义一个列表,然后根据一元素的长度排序
lst = ['天龙八部','西游记','红楼梦','三国演义']
# 计算字符串的长度
def func(s):
return len(s)
print(sorted(lst,key=func))
# 结果:
# ['西游记', '红楼梦', '天龙八部', '三国演义']
和lambda组合使用
lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst,key=lambda s:len(s)))
结果:
['西游记', '红楼梦', '天龙八部', '三国演义']
lst = [{'id':1,'name':'alex','age':18},
{'id':2,'name':'wusir','age':17},
{'id':3,'name':'taibai','age':16},]
# 按照年龄对学生信息进行排序
print(sorted(lst,key=lambda e:e['age']))
结果:
[{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]
<4>フィルタ（）フィルタリングフィルタリング
def func(a):
return a == 1
print(list(filter(func,[1,2,3,4,6])))
1,指定过滤规则(函数名[函数的内存地址]) 2,要过滤的数据
自己模拟
def filter(func,argv):
lst = []
for i in argv:
ret = func(i)
if ret:
lst.append(i)
return lst
def foo(a):
return a>2
print(filter(foo,[1,2,3,4])) # filter(foo,[1,2,3,4])
def func(a):
return a>1
print(list(filter(func,[1,2,3,4,5])))
print(list(filter(lambda a:a>1,[1,2,3,4,5])))
语法: filter(function,iterable)
function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据
iterable:可迭代对象
lst = [{'id':1,'name':'alex','age':18},
{'id':1,'name':'wusir','age':17},
{'id':1,'name':'taibai','age':16},]
ls = filter(lambda e:e['age'] > 16,lst)
print(list(ls))
结果:
[{'id': 1, 'name': 'alex', 'age': 18},
{'id': 1, 'name': 'wusir', 'age': 17}]
<5>マップ（）マッピング（反復オブジェクト指定された機能を実行するための各要素）
def func(a,b):
return a+b
print(list(map(func,[1,2,3,4,5],[33,22,44,55])))
def map(argv,args):
lst = []
num = len(args) if len(args) < len(argv) else len(argv)
for i in range(num):
lst.append(argv[i] + args[i])
return lst
print(map([1,2,3,4],[3,4,5,6,7,8,9,0]))
print(list(map(lambda x,y:x+y,[1,2,3,4,5],[33,22,44,55])))
语法: map(function,iterable) 可以���可迭代对象中的每一个元素进映射,分别取执行function
计算列表中每个元素的平方,返回新列表
lst = [1,2,3,4,5]
def func(s):
return s*s
mp = map(func,lst)
print(mp)
print(list(mp))
改写成lambda
lst = [1,2,3,4,5]
print(list(map(lambda s:s*s,lst)))
计算两个列表中相同位置的数据的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x, y: x+y, lst1, lst2)))
结果:
[3, 6, 9, 12, 15]
forループ内の高次機能を実行するために私たちを助けます
3、算出された疲れ軽減
from functools import reduce # 累计算
从 functools工具箱中拿来了reduce工具
def func(x,y):
return x+y
print(reduce(func,[1,2,3,4,5]))
print(reduce(lambda x,y:x+y,[1,2,3,4,5]))
from functools import reduce
def func(x,y):
return x + y
# reduce 的使用方式:
# reduce(函数名,可迭代对象) # 这两个参数必须都要有,缺一个不行
ret = reduce(func,[3,4,5,6,7])
print(ret) # 结果 25
reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,
接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始
临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推
注意:我们放进去的可迭代对象没有更改
以上这个例子我们使用sum就可以完全的实现了.我现在有[1,2,3,4]想让列表中的数变成1234,就要用到reduce了.
普通函数版
from functools import reduce
def func(x,y):
return x * 10 + y
# 第一次的时候 x是1 y是2 x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了
# 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了
# 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了
l = reduce(func,[1,2,3,4])
print(l)
匿名函数版
l = reduce(lambda x,y:x*10+y,[1,2,3,4])
print(l)
在Python2.x版本中recude是直接 import就可以的, Python3.x版本中需要从functools这个包中导入
龟叔本打算将 lambda 和 reduce 都从全局名字空间都移除, 舆论说龟叔不喜欢lambda 和 reduce
最后lambda没删除是因为和一个人给龟叔写了好多封,进行交流然后把lambda保住了.