python内置函数，匿名函数

***locals:函数会以字典的类型返回当前位置的全部变量
***globals:函数以字典的类型返回全部全局变量。

a=1
b=2
print(locals())
print(globals())#这两个完全一样，都是在全局执行的

def func(argv):
    c=2
    print(locals())#{ 'c':2  'argv':3  }
    print(globals())
func(3)
'''{'__builtins__': <module 'builtins' (built-in)>,
'__doc__': None, '__spec__': None, '__loader__': <_frozen_importlib_external.
SourceFileLoader object at 0x0000026DF0E2DE10>, 'func': <function func at 0x0000026DF0C48F28>,
'__package__': None, '__cached__': None, '__name__': '__main__', '__file__': 'D:/untitled3/day14/练习.py'}
'''
q = 666
def wrapper(argv):
    a = 3
    print(locals())  # 1 {a:3,argv:2}
    def inner(argv1):
        b = 4
        c = 5
        print(locals())  # 2 {b:4 c:5,argv1:6}
    inner(6)

wrapper(2)
print(globals())  # 3

其他相关
1.2.1 字符串类型代码的执行 eval，exec，complie
***eval 去除字符串的引号，返回相应内部的值

s='{"a":1,"b":3}'
dic=eval(s)
print(dic,type(dic))
print(eval('2+2'))#4
print(eval('print(666)'))#666 None print(666)没有返回值。

***exec 执行字符串内部的代码

print(exec('2+2'))#None
ret='''
username=input('请输入你的账号:').strip()
if username=='alex':
    print(666)

'''
print(exec(ret))#666 None

complie: pass
1.2.2 输入输出相关 input，print

name=input('请%s输入账号' % 'alex')
print(name)
print(1,2,3,sep='*')#sep设定打印元素的连接方式，默认空格分开
print('bbb',end='')#控制换行
print('aaa')
print('boss_jin')
***文件句柄
f1=open('log',encoding='utf-8',mode='w')
print('666',file=f1)#file 文件句柄 写入文件
f1.write('333')
f1.close()

1.2.3内存相关 hash id
*hash 将不可变的数据通过hash算法转化成hash值

print(hash('name'))#hash值一直在变化
print(hash('age'))
print(hash((1, 2, 3,)))
print(hash(1))#hash 值就是本身
print(hash(100))# *hash 将不可变的数据通过hash算法转化成hash值
print(hash('name'))
print(hash('age'))
print(hash((1, 2, 3,)))
print(hash(1))
print(hash(1))
print(hash(456))

*id

print(id('name'))
print(id(0))#-5~256不变 存在小数据池
a='abc'
b='abc'
print(id(a))#a和b在不断变化，但是a和b始终保持一致       2108804970792 # 2627940333864
print(id(b))                                     # 2108804970792 # 2627940333864

1.2.3文件操作相关

open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

1.2.4模块相关__import__　

　　__import__：函数用于动态加载类和函数 。

1.2.5帮助
*help 用于查看函数和模块用途的详细说明
print(help(str))#非常实用
print(help(dict))

1.2.6调用相关

*** callable：函数用于检查一个对象是否是可调用的。

如果返回True,object可能调用失败，如果返回False,调用对象object肯定不会成功。
def func():
    print(666)

age=18
print(callable(func))#True
print(callable(age))#False
print(callable('name'))#False

1.2.7查看内置属性
**dir:函数不带参数时，返回当前范围内的定义，方法和变量的类型列表
带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，
该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
print(dir(str))

1.3 迭代器生成器相关
*** range  iter() next()

print(len(range(100)))
l=[1,2,3.4,5]
l_obj=l.__iter__() #l_obj=iter(l)
print(l_obj)#迭代器
print(l_obj.__next__())
print(next(l_obj))

1.4.1数字相关（14）
　　数据类型（4）：
　　　　
bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。
　　　　int：函数用于将一个字符串或数字转换为整型。
print(int('123'))
print(int(1.2345))#取整

float：函数用于将整数和字符串转换成浮点数。

　　　complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
如果第一个参数为字符串，则不需要指定第二个参数。。

i = 3.1415#<class 'float'>
print(i, type(i))
s = '1.234'
print(int(1.234))
print(float(s))
print(float(100))#100.0自动保留一位小数

bin：将十进制转换成二进制并返回。
print(bin(100))
oct：将十进制转化成八进制字符串并返回。
print(oct(10))
hex：将十进制转化成十六进制字符串并返回。
print(hex(13))
print(hex(18))

数学运算（7）：
**abs：函数返回数字的绝对值。
print(abs(-5))
***divmod 计算除数与被除数的结果，返回一个包含商和余数的元祖(a // b, a % b)

print(divmod(11,3))#(3, 2)
print(11//3)#返回商(整除）
print(11%3)#返回余数
print(11//3,11%3)#3 2 返回商和余数

***round保留浮点数的小数位数，默认保留整数。
print(round(123.456,2))

*pow：求x**y次幂。（三个参数为x**y的结果对z取余）
print(pow(2,3))#2的3次幂
print(pow(2,3,2))#2的3次幂对2取余
***sum：对可迭代对象进行求和计算（可设置初始值）。
print(sum([1, 2, 3, 4]))
print(sum([1, 2, 3, 4], 100))
*** min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
print(min([1, 3, 5, 7, -4]))
print(min([1, 3, 5, 7, -4], key=abs))
*** max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
print(max([1, 3, 5, 7, -4]))
print(max([1, 3, 5, 7, -9], key=abs))
1.4.2和数据结构相关（24）
列表和元祖（2）
　　list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
　　tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。

tu = (1, 2, 3)
print(list(tu))
l1 = list((1, 2, 3))
print(l1)
l1 = list({'name':'aaa','age':1000})
print(l1)

相关内置函数（2）
***reversed 翻转,将一个序列翻转，并返回该翻转序列的迭代器

l1=[11,22,33,44,55,66]
obj=reversed(l1)
print(obj)
for i in obj:
    print(i)

slice：构造一个切片对象，用于列表的切片。

l1 = [11, 22, 33, 44, 77, 66]
l2 = [111, 222, 333, 444, 777, 666]
# print(l1[1::2])
rule = slice(1, len(l2), 2)
print(l2[rule])

字符串相关（9）
str：将数据转化成字符串。
format:与具体数据相关，用于计算各种小数，精算等。
print(format('test', '<20'))  # 左对齐
print(format('test', '>20'))  # 右对齐
print(format('test', '^20'))  # 居中

***bytes  str-->bytes

l1=[11,22,33,44,55,66]
obj=reversed(l1)
print(obj)
for i in obj:
    print(i)

bytearray

ret = bytearray('aaa', encoding='utf-8')  # 类比：[97,103,....]
print(id(ret))
print(ret)  # bytearray(b'aaa')
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))

分字节去转换成str

b1 = bytes('你好',encoding='utf-8')
print(b1)
ret = memoryview(b1)
print(len(ret))
print(ret)
print(bytes(ret[:3]).decode('utf-8'))
print(bytes(ret[3:]).decode('utf-8'))

ord:输入字符找该字符编码的位置
print(ord('a'))#97
print(ord('中'))  # unicode  20013
# chr:输入位置数字找出其对应的字符
print(chr(65))#A
print(chr(20013)) # unicode
# ascii:是ascii码中的返回该值，不是就返回/u...
print(ascii('a'))
print(ascii(1))
print(ascii('中'))

***repr 返回一个对象的string形式，原形毕露

msg='小数%f' % (1.234)
print(msg)#小数1.234000
msg='姓名：%r' % 'alex' # %r 保留原来的格式
print(msg)#姓名：'alex'
print('{"name":"aaa"}')#{"name":"aaa"}
print(repr('{"name":"aaa"}'))#'{"name":"aaa"}'

数据集合（3）
　　　　dict：创建一个字典。
　　　  set：创建一个集合。
　　　　frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

dic = dict({'name': 'aaa'})
print(dic)
set1 = set(('aaa','bbb'))
print(set1)

　相关内置函数（8）
***len: 返回一个对象中元素的个数。
sorted:对所有可迭代的进行排序操作，返回的是列表

print(sorted([1,2,5,4,3,-6]))
print(sorted([1,2,5,4,3,-6],key=abs))#[1, 2, 3, 4, 5, -6]
L = [('a', 1), ('c', 2), ('d', 4), ('b', 3), ]
print(sorted(L))#[('a', 1), ('b', 3), ('c', 2), ('d', 4)]
def func(x):
    return x[1]
print(sorted(L,key=func))#[('a', 1), ('c', 2), ('b', 3), ('d', 4)]

*all：可迭代对象中，全都是True才是True
*any：可迭代对象中，有一个True 就是True
print(all([1, 'aaa', True, (1,2,3)]))
print(all([0, 'aaa', True, (1,2,3)]))
print(any([0, '', False, (1,2,3)]))
print(any([0, '', False, ()]))

***zip 拉链方法 返回的是一个迭代器

l1 = [1, 2, 3, 4]
tu1 = ('aaa', 'bbb', 'ccc')
l2 = ['*', '**', '***', "****"]
obj=zip(l1,l2,tu1)
for i in obj:
    print(i)

***map 循环模式

def func(x):
    return x*x
obj=map(func,[1,2,3])
for i in obj:
    print(i)

def func1(x,y):
    return x+y
obj=map(func1,[1,2,3,4,5],(6,7,8))#以最短的长度为准
for i in obj:
    print(i)

***filter 筛选模式

def func(x):
    return x%2==0
ret=filter(func,[1,2,3,4,5,6])
print(ret)
for i in ret:
    print(i)
print((i for i in [1,2,3,4,5,6] if i%2==0))

***lambda 匿名函数，一句话函数

def func(x): return x % 2 == 0
def func1(x, y):
    return x + y
ret=lambda x,y:x+y
print(ret(2,3))

def func1(x, y):
    return x if x > y else y
ret=lambda x,y:x if x>y else y
print(ret(2,3))

def func(x):
    return x % 2 == 0
ret=filter(lambda x:x % 2==0,[1,2,3,4,5,6])
for i in ret:
    print(i)

[1, 2, 3, 4, 5, 6, 7]  [1,4,9,16...]  map  lambda
ret=map(lambda x: x*x,[1, 2, 3, 4, 5, 6, 7])
for i in ret:
    print(i)

def func1(x):
    return x[1]
L = [('a', 1), ('c', 2), ('d', 4),('b', 3), ]
print(sorted(L, key=func1))

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students,key=lambda x: x[2]))
print(sorted(students,key=lambda x: x[2] ,reverse=True))

tast

1，用map来处理字符串列表,把列表中所有人都变成sb,比方aa_sb

name=['aa','bb','cc']
ret=map(lambda x: x+'_sb' ,['aa','bb','cc'])
for i in ret:
    print(i)

name=['aa','bb','cc']
print([i+'_sb' for i in name])

2，用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾

l=[{'name':'aa'},{'name':'y'}]
ret=list(map(lambda x: x['name']+'sb',l ))#列表
print(ret)

ret=map(lambda x: x['name']+'sb',l )#迭代器
for i in ret:
    print(i)

print([i['name']+'_sb' for i in l])

3，用filter来处理,得到股票价格大于20的股票名字  # 多揣摩揣摩字典的含义

shares={
   'IBM':36.6,
   'Lenovo':23.2,
   'oldboy':21.2,
   'ocean':10.2,
}

ret=list(filter(lambda x: shares[x]>20 ,shares))    #x相当于字典的键，shares[x]相当于值
print(ret)

print([i for i in shares if shares[i]>20])

4.有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。
结果：list一下[9110.0, 27161.0,......]

portfolio=[
    {'name':'IBM','shares':100,'price':91.1},
    {'name':'AAPL','shares':50,'price':543.22},
    {'name':'FB','shares':200,'price':21.09},
    {'name':'HPQ','shares':35,'price':31.75},
    {'name':'YHOO','shares':45,'price':16.35},
    {'name':'ACME','shares':75,'price':115.65}
]

set=list(map(lambda x: x['shares']*x['price'] ,portfolio))
print(set)

print([i['shares']*i ['price'] for i in portfolio])

还是上面的字典，用filter过滤出单价大于100的股票。

portfolio=[
    {'name':'IBM','shares':100,'price':91.1},
    {'name':'AAPL','shares':50,'price':543.22},
    {'name':'FB','shares':200,'price':21.09},
    {'name':'HPQ','shares':35,'price':31.75},
    {'name':'YHOO','shares':45,'price':16.35},
    {'name':'ACME','shares':75,'price':115.65}
]
ret=list(filter(lambda x: x['name'] if x['price']>100 else None ,portfolio ))
print(ret)

print([ i for i in portfolio if i['price']>100]  )
print([i['name'] for i in portfolio if i['price']>100] )#过滤出单价大于100的股票的名字

5.有下列三种数据类型，
l1 = [1,2,3,4,5,6]
l2 = ['aaa','bbb','ccc','ddd','eee']
tu = ('**','***','****','*******')
写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是4个。）
   [(3, 'ccc', '****'), (4, 'ddd', '*******')]这样的数据。

obj=zip(l1,l2,tu)
for i in obj:
    print(i)

l4=list(zip(l1,l2,tu))
print(l4)

ret=filter(lambda x: x[0]>2 and x[2]>='****',list(zip(l1,l2,tu)))
for i in ret:
    print(i)

ret=list([i for i in list(zip(l1,l2,tu))if i[0]>2 and i[2]>='****'])#列表表达式
print(ret)

6.有如下数据类型：
将l1按照列表中的每个字典的values大小进行排序，形成一个新的列表。

l1 = [{'sales_volumn': 0},
     {'sales_volumn': 108},
     {'sales_volumn': 337},
     {'sales_volumn': 475},
     {'sales_volumn': 396},
     {'sales_volumn': 172},
     {'sales_volumn': 9},
     {'sales_volumn': 58},
     {'sales_volumn': 272},
     {'sales_volumn': 456},
     {'sales_volumn': 440},
     {'sales_volumn': 239}]
l2=sorted(l1,key=lambda x: x['sales_volumn'])
print(l2)
print(sorted(l1,key=lambda x: x['sales_volumn'],reverse=True))#从大到小排序

键的值从小到大排序
l = [{1: 'A'},
     {5: 'B'},
     {3: 'C'},
     {2: 'D'},
     {4: 'E'}]
print(sorted(l,key=lambda x: list(x.keys())))

for 循环查询

dic={'name':'aaa','age':18,'hobby':'girl'}
print(dic.keys(),type(dic.keys()))#dict_keys(['hobby', 'name', 'age']) <class 'dict_keys'>类似于列表，却不是列表
print(dic.values(),type(dic.values()))#dict_values(['girl', 'alex', 18]) <class 'dict_values'>类似于列表，却不是列表

for  key in dic.keys():#for i in dic:打印出来的也是键。
    print(key)
for i in dic:
    print(i)
l_key=list(dic.keys())
print(l_key)

for value in dic.values():
    print(value)
l_value=list(dic.values())
print(l_value)

分别赋值概念
a, b = 1, 2
a, b = ('aaa', '34')
a, b = ['aaa', '34']
有 如下 a = 1 b = 3,用一行代码将a b值互换。#面试题
a=1
b=3
a,b=b,a
print(a,b)

print(dic.items(),type(dic.items()))#dict_items([('hobby', 'girl'), ('name', 'aaa'), ('age', 18)]) <class 'dict_items'>
for i in dic.items():
    print(i)#('hobby', 'girl') ('name', 'aaa')   ('name', 'a')aa

for k,v in dic.items():#([('name', 'bbb'), ('hobby', 'women'), ('age', 45)])
    print(k,v)
print(k,v)#的结果：
name bbb
hobby women
age 45

for k,v in dic.items():
    print(k,type(k),v,type(v))#键是不可变得，值是任意数据类型
name <class 'str'> alex <class 'str'>
hobby <class 'str'> girl <class 'str'>
age <class 'str'> 18 <class 'int'>