标签：求和 containe put 赋值 fence xe7 拉链 container 方案
eval ：剥去字符串的外衣，运算里面的代码，有返回值
s1 = ‘1 + 3‘
print(s1) # 1+3
print(eval(s1)) # 4
s = ‘{"name": "alex"}‘
print(s,type(s)) #{"name": "alex"} <class ‘str‘>
#print(dict(s)) # 不行
print(eval(s),type(eval(s))) #{‘name‘: ‘alex‘} <class ‘dict‘>
网络传输str input 输入的时候，sql注入等等绝不能使用eval
exec 与eval几乎一样，代码流
msg = """
for i in range(10):
print(i)
"""
print(msg)
#结果就是注释里面内容
exec(msg)
#可计算内部，0~9循环输出
hash：获取一个对象的哈希值
print(hash(‘fsjkdafsda‘))
# -2847953170711602116
?
help：打印、获取一个方法的说明
print(help(list))
print(help(str.split))
callable：函数用于检查一个对象是否是可调用的
name = ‘alex‘
def func():
pass
print(callable(name)) # False
print(callable(func)) # True
bin：将十进制转换成二进制并返回。
oct：将十进制转化成八进制字符串并返回。
hex：将十进制转化成十六进制字符串并返回。
print(bin(10),type(bin(10))) # 0b1010 <class ‘str‘>
print(oct(10),type(oct(10))) # 0o12 <class ‘str‘>
print(hex(10),type(hex(10))) # 0xa <class ‘str‘>
name = ‘alex‘
def func():
pass
print(callable(name)) # False
print(callable(func)) # True
int 整型，取整
print(int()) # 0
print(int(‘12‘)) # 12
print(int(3.6)) # 3 取整
print(int(‘0100‘,base=2)) # 将2进制的 0100 转化成十进制。结果为 4
float ：函数用于将整数和字符串转换成浮点数。
print(float(2)) # 2.0
print(type(3.6)) # <class ‘float‘>
complex :函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
print(complex(1,2)) # (1+2j)
print(complex(‘12‘)) # (12+0j)
divmod :计算除数与被除数的结果 **
返回一个包含商和余数的元组(a // b, a % b)
print(divmod(10,3)) # (3, 1)
round ：保留浮点数的小数位数 **
print(round(3.141592653, 2)) # 3.14
pow ：求x**y次幂（三个参数为对x**y结果对z取余） **
print(pow(2,3)) # 8
print(pow(2,3,3)) # 2 就是2的3次方再对3取余
bytes ：用于不同编码之间的转化 ***
s1 = ‘太白‘
b = s1.encode(‘utf-8‘)
print(b) # b‘\xe5\xa4\xaa\xe7\x99\xbd‘
b = bytes(s1,encoding=‘utf-8‘)
print(b) # b‘\xe5\xa4\xaa\xe7\x99\xbd‘
ord ：输入字符找该字符编码的位置 **
chr ：输入位置数字找出其对应的字符 **
? 超出ASCII用Unicode
print(ord(‘a‘)) # 97
print(ord(‘中‘)) # 20013 Unicode
?
print(chr(97)) # a
print(chr(20013)) # 中 Unicode
repr ：返回一个对象的string形式（原形毕露）***
s1 = ‘太白‘
print(s1) # 太白
print(repr(s1)) #‘太白‘
?
msg = ‘我叫%s‘%(s1) # 我叫太白
msg = ‘我叫%r‘%(s1) # 我叫‘太白‘
print(msg)
all ：可迭代对象中，全部是True才是True
any ：可迭代对象中，有一个是True就是True
l1 = [1, 2, ‘太白‘, True, [1,2,3], ‘‘]
print(all(l1)) # False
?
l2 = [ 0, ‘太白‘, False, [], ‘‘,()]
print(any(l2)) # True
# print(self, *args, sep=‘ ‘, end=‘\n‘, file=None)
print(1,2,3,4) # 1 2 3 4
print(1,2,3,4,sep=‘&‘) # 1&2&3&4
print(1,end=‘ ‘) # 1 下次输出不换行，以空格分开
print(2)
list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
l1 = [1,2,3,4]
l2 = list()
l2 = list(‘sadsaff‘)
print(l2) # [‘s‘, ‘a‘, ‘d‘, ‘s‘, ‘a‘, ‘f‘, ‘f‘]
?
tu1 = tuple(‘abcd‘)
print(tu1) # (‘a‘, ‘b‘, ‘c‘, ‘d‘)
dict
dic = dict([(1,‘one‘),(2,‘two‘),(3,‘three‘)])
print(dic) # {1: ‘one‘, 2: ‘two‘, 3: ‘three‘}
?
#把列表转化字典
l1 = [(1,‘one‘),(2,‘two‘),(3,‘three‘)]
dic = dict(l1)
print(dic) # {1: ‘one‘, 2: ‘two‘, 3: ‘three‘}
?
dic = dict(one=1,two=2)
print(dic) # {‘one‘: 1, ‘two‘: 2}
abs() 绝对值 ***
print(abs(-7)) # 7
最重要的内置函数（面试、工作都用得到）
sum() 求和
可设置初始值
要是int型
l1 = [i for i in range(10)]
print(sum(l1)) # 45
print(sum(l1,100)) # 145 设置100为初始值
?
s1 = ‘12345‘
print(sum(s1)) # s1 是str，不是int，会报错
reversed 返回的是一个翻转的迭代器 ***
l1 = [i for i in range(10)]
l1.reverse() # 列表的方法
print(l1) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
?
l1 = [i for i in range(10)]
obj = reversed(l1)
print(l1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(obj)) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
zip() 拉链方法
函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,
然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回，
l1 = [1,2,3,4,5]
tu1 = (‘太白‘,‘b哥‘,‘德刚‘)
s1 = ‘abcd‘
obj = zip(l1,tu1,s1)
#print(obj) #<zip object at 0x000001177EA77A08>,就是个地址
# 迭代对象取值：for next list
?
# 第一种for迭代对象
for i in obj:
print(i)
?
# 第二种list迭代对象
print(list(obj))
*************** 以下方法更重要
min max
凡是可以加key的：它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中，以返回值比较大小
min默认会按照字典的键去比较大小
l1 = [33, 2, 3, 54, 7, -1, -9]
print(min(l1)) # -9
?
?
# 以绝对值的方式去最小值
l1 = [33, 2, 3, 54, 7, -1, -9]
l2 = []
func = lambda a:abs(a)
for i in l1:
l2.append(func(i))
print(min(l2)) # 1
?
l1 = [33, 2, 3, 54, 7, -1, -9]
def abss(a):
# ‘‘‘
# 第一次：a = 33 以绝对值取最小值 33
# 第二次：a = 2 以绝对值取最小值 2
# 第三次：a = 3 以绝对值取最小值 2
# ......
# 第六次：a = -1 以绝对值取最小值 1
#
# ‘‘‘
return abs(a)
print(min(l1,key=abss)) # -1
?
print(min(l1,key=abs)) # -1
# 凡是可以加key的：它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中，
# 以返回值比较大小。
?
?
# min默认会按照字典的键去比较大小。
dic = {‘a‘: 3, ‘b‘: 2, ‘c‘: 1}
print(min(dic)) # a
# 求出值最小的键？
dic = {‘a‘: 3, ‘b‘: 2, ‘c‘: 1}
def func(a):
return dic[a]
func = lambda a:dic[a]
print(min(dic,key=func))
?
dic = {‘a‘: 3, ‘b‘: 2, ‘c‘: 1}
print(min(dic,key=lambda a:dic[a]))
sorted 排序 （也可以加key）
返回一个列表，默认从低到高
l1 = [11,22,33,1,2,8,7,6,5]
l2 = sorted(l1)
print(l1) # [11,22,33,1,2,8,7,6,5]
print(l2) # [1,2,5,6,7,8,11,22,33]
?
l1 = [(‘大壮‘,76)，(‘雪飞‘,70)，(‘张程‘,98)，(‘b哥‘,96)]
print(sorted(l1,key= lambda x:x[1])) # 返回的是一个列表
# [(‘雪飞‘,70)，(‘大壮‘,76)，(‘b哥‘,96)，(‘张程‘,98)]
print(sorted(l1,key= lambda x:x[1]，reverse = True))
# 默认从低到高，加reverse是从高到低
filter 筛选，类似列表推导式的筛选模式
l1 = [2,3,4,1,6,7,8]
print([i for i in l1 if x > 3]) # [4,6,7,8]返回的是一个列表
ret = filter(lambda x:x>3,l1) # 返回的是一个迭代器
print(ret) # 迭代器
print(list(ret)) # [4,6,7,8]
map 映射函数，类似列表推导式的循环模式
# map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function
# 想要得到这样的列表 l1 = [1,4,9,16,25]
print([i**2 for i in range(1,6)])
ret = map(lambda x:x**2,range(1,6))
print(ret)
print(list(ret))
reduce 累加效果，第一次取两个值
from functools import reduce
# reduce
from functools import reduce
def func(x,y):
‘‘‘
第一次：x y : 11 2 x + y = 记录： 13
第二次：x = 13 y = 3 x + y = 记录： 16
第三次 x = 16 y = 4 .......
‘‘‘
return x + y
?
l = reduce(func,[11,2,3,4])
print(l)
整个历史中的某个商品的平均收盘价。什么叫平局收盘价呢？就是从这个商品一出现开始，每天记录当天价格，然后计算他的平均值：平均值要考虑直至目前为止所有的价格。
比如大众推出了一款新车：小白轿车。
第一天价格为：100000元，平均收盘价：100000元
第二天价格为：110000元，平均收盘价：（100000 + 110000）/2 元
第三天价格为：120000元，平均收盘价：（100000 + 110000 + 120000）/3 元
封闭的东西：保证数据的安全
# 封闭的东西： 保证数据的安全。
?
# 方案一：
# l1 = [] # 全局变量 数据不安全
# li = []
# def make_averager(new_value):
# l1.append(new_value)
# total = sum(l1)
# averager = total/len(l1)
# return averager
# print(make_averager(100000))
# print(make_averager(110000))
# # 很多代码.....
# l1.append(666)
# print(make_averager(120000))
# print(make_averager(90000))
?
# 方案二： 数据安全，l1不能是全局变量。
# 每次执行的时候，l1列表都会重新赋值成[]
# li = []
# def make_averager(new_value):
# l1 = []
# l1.append(new_value)
# total = sum(l1)
# averager = total/len(l1)
# return averager
# print(make_averager(100000))
# print(make_averager(110000))
# # 很多代码.....
# print(make_averager(120000))
# print(make_averager(90000))
?
# 方案三： 闭包
?
#
def make_averager():
l1 = []
def averager(new_value):
l1.append(new_value)
print(l1)
total = sum(l1)
return total/len(l1)
return averager
?
# avg = make_averager() # averager
# print(avg(100000))
# print(avg(110000))
# print(avg(120000))
# print(avg(190000))
?
# def func():
# return 666
#
# ret = func()
# print(globals())
闭包： 多用于面试题： 什么是闭包？ 闭包有什么作用。
闭包只能存在嵌套函数中
定义：内层函数对外层函数非全局变量的引用（使用），就会形成闭包。被引用的非全局变量也称作自由变量，这个自由变量会与内层函数产生一个绑定关系，自由变量不会在内存中消失
作用：保证数据的安全
如何判断一个嵌套函数是不是闭包？
# 1，闭包只能存在嵌套函数中。
# 2， 内层函数对外层函数非全局变量的引用（使用），就会形成闭包。
# 例一：
# def wrapper():
# a = 1
# def inner():
# print(a)
# return inner
# ret = wrapper()
?
#
# # 例二：
# a = 2
# def wrapper():
# def inner():
# print(a)
# return inner
# ret = wrapper()
?
?
# # 例三：
# 也是闭包！
# def wrapper(a,b):
# def inner():
# print(a)
# print(b)
# return inner
# a = 2
# b = 3
# ret = wrapper(a,b)
# print(ret.__code__.co_freevars) # (‘a‘, ‘b‘)
# 如何代码判断闭包？
?
def make_averager():
l1 = []
def averager(new_value):
l1.append(new_value)
print(l1)
total = sum(l1)
return total/len(l1)
return averager
?
avg = make_averager() # averager
print(avg.__code__.co_freevars)
标签：求和 containe put 赋值 fence xe7 拉链 container 方案
原文地址：https://www.cnblogs.com/yangzm/p/10921745.html
