内置函数，匿名函数

内置函数---内置命名空间（68个）目前学了55个

一、作用域相关（2）
    locals()--局部作用域中的变量   #本地
    globals() --全局作用域中的变量
    在全局执行这两个方法，结果相同

def func():
    pass

func()
print(locals())
print(globals())

 

   在局部执行locals()表示函数内的名字，globals()始终不变

def func():
    a= 0
    b = 1
    print(locals())
    print(globals())

func()

 

二、迭代器和生成器相关（3）
  在python里尽量少的调用双下方法
    [].__iter__()   是列表自己有的方法
    iter()    #只接收一个内部含有__iter__()方法的对象
    统一接口
    iter() 和 __iter__()是一样的

    next(迭代器)
    next()和__next__()是一样的

    range（*****）
    range(100) 0-99   range(0,100)    range(0,100,2)可以设置步长
    range是一个可迭代对象，最好循环取结果


三、其他种类（12）
1 执行字符串数据类型的代码
    eval：有返回值-----计算（***）

print(eval("1+2+3+4"))
结果是：10

 

    exec：没有返回值-----流程控制

print(exec("1+2+3+4"))
结果：None
exec("print('hello,word')")

 

    使用这两个方法时，要做简单检测：(import 和 import os) in 要执行的代码

    compile:当需要对某一个字符串类型的python代码多次执行的时候，用compile先编译一下
        （***）
        参数：source，filename，model
            source：字符串，或AST(Abstract Syntax Trees)对象，即需要动态执行的代码段
            filename：代码文件名称，如果不是从文件读取代码传递一些可辨认的值。当传入了source参数时，filename参数传入空字符串即可
　　　　　　　model：指定编译代码的种类，可以指定为，exec，eval，single,三种，

当source中含有流程语句时，model = exec
code = "for i in range(10):print(i)"
compile1 = compile(code, "", 'exec')
exec(compile1)
当source中含有一个简单的求值表达式时，model = eval
code = "1+2+3+4"
compile1 = compile(code, "", 'eval')
print(eval(compile1))
当source中含有交互式命令语句的时候，model = single
code = "name= input('>>>')"  # ---input交互式命令语句
compile1 = compile(code, "", 'single')
exec(compile1)
print(name)

 

    直接拿来执行的方式一定不要随便使用
    如果非用不可，要做最起码的检测

2 输入和输出（2）（*****）
    input()--返回字符串类型

n = input(">>>")
print(n, type(n))

 

    print()--输出
        print("dsfd",end="")--end,每一次打印的结果，默认是\n ,设置成""--不换行
        print(123,354,sep="***")---打印多个值之间的分割符，默认空格
        print('asdodf',file=文件名) ---默认打印到屏幕上，可以指定写到一个文件里，
        flush:立即把内容输出到文件中，不做缓存
            flush=True：立即写出来
            flush=False:要等到那个时间结束后，一起写出来
　　　　　　　　　　　　　　\r是可以把光标移动到行首但不换行

import time
import sys

for i in range(0, 101, 2):
    time.sleep(2)
    char_num = i // 2  # 打印多少个#
    per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s' % (i, '*' * char_num)
    print(per_str, end='', file=sys.stdout, flush=True)

 

3 内存相关（2）
    hash() 哈希方法 快  摘要算法（*****）
        可变的数据类型（列表，字典，集合）是不能被哈希的，哈希的结果是一个数字
        同一个对象的哈希值,在python的一次执行中是一样的，但是重新执行程序后就不一样了

t = (1, 2, 3)
l = [1, 2, 3]
print(hash(t))  # 可hash
print(hash(l))  # 会报错



url = 'http://xhpfmapi.zhongguowangshi.com/share/index.html?docid=2269496&channel=weixin'
from urllib.request import urlopen

content = urlopen(url).read()
dic = {hash(url): content}
hash(url)  # 数字

 

    hashlib -- 计算出来的结果永远不会变

    id(对象)    可以查看内存地址
        身份运算  is   is not 不仅比较值的大小，还比较内存地址的大小
        ==值运算     比较值的大小

4 文件操作相关（1）（*****）
    open(文件名，编码，打开方式)

5 模块操作（*****）
   import time和 __import__("time")一样

6 help(对象) 帮助 查看功能
    进入help模式，help(),退出"q"

7 调用相关：
    callable(对象)：判断一个对象是否可以调用

8 查看内置属性（***）
    dir()
        print(dir(__builtins__))  所有内置名字

四、基础数据类型（38）

1、和数字相关（14）
1--数据类型（4）：
    bool--强转布尔类型(*****)
    int--强转整数类型(*****)
    float--强转浮点类型(*****)
    complex(实部，虚部)--转为复数类型
        print(complex(1,2))
        结果为：(1+2j)
2--进制转换（3）：
    bin--二进制
    oct--八进制
    hex--十六进制

3--数学运算（7）
　　(***)abs求绝对值

ret = abs(-99)
print(ret)

 

2 (***)divmod(被除数，除数)---返回(商，余数)
    应用：分页

print(divmod(9,5))#--返回数组

 

3 (***)round(小数，留几位小数)

print(round(2.4567432,3))

 

4 (***)pow(x,y)幂运算  x的y次幂
pow(x,y,z)    x的y次幂对z取余，z的默认值是1

print(pow(2, 3))
print(pow(3, 3, 5))

 

5(*****)sum(**可迭代对象**)  求和
sum(可迭代对象，从哪个数开始计算)--默认从0开始,其实相当于相当于求完前面的和之后再加上后面的值
    例子，求本钱加利息sum(利息，本钱)

print(sum(range(5),3))

 

6(*****)min(可迭代对象或多个值，key=函数，default=前面没有时返回的值)
key--根据函数的返回值判断值的大小

# 什么也不设置的时候：
li = [1, -2, 3, -5]
print(min(li))
# 设置key值的时候；
li = [1, -2, 3, -5]
print(min(li, key=abs))
# 设置default的时候：
li = []
print(min(li, key=abs, default=1))

 

7(*****)max(可迭代对象或多个值，key=函数，default=前面没有时返回的值)

# 什么也不设置的时候：
li = [1, -2, 3, -5]
print(max(li))
# 设置key值的时候；
li = [1, -2, 3, -5]
print(max(li, key=abs))
# 设置default的时候：
li = []
print(max(li, key=abs, default=1))

 

　　min max小结:

　　　　min max可以接收散列的值和可迭代对象
　　　　key 是一个函数名，判断的结果根据函数的返回值来确定
　　　　default 如果可迭代对象为空，设置默认返回值


2、和数据结构相关

1--序列（13）：

列表和元组
1(*****)list()--强转成列表类型

2(*****)tuple()--强转成元组类型

列表元组字符串通用的内置函数

1(***)reversed()反转--针对本身有序的，结果是一个反序迭代器

ret = reversed([1, 2, 3, 4, 5, 6, 7])
ret = reversed("sjkfndjdk")
print(list(ret))

ret = reversed("sjkfndjdk")
print("".join(list(ret)))  # ---join本来是输出列表形式，join一下就把它们放到了一起

 

2  slice(开始位置，终止位置，步长)    跟切片一样

li = [2, 3, 5, 6, 8, 9, 0, 0, 4, 1]
my_s = slice(1, 5, 2)
print(li[my_s])  # ---等价于li[1:5:2]

 

字符串
1(***)str()--强转成字符串类型

2 format("内容","对齐方式+长度")>右对齐  <左对齐  ^居中

print(format("abc", ">20"))
print(format("abc", "<20"))
print(format("abc", "^20"))

 

3(*****)bytes
by = bytes(字符串，encoding="utf-8")
by.decode("utf-8")---转换成unicode编码

by = bytes("字符", encoding="utf-8")
print(by)
# 结果：b'\xe5\xad\x97\xe7\xac\xa6'
by = bytes("字符", encoding="utf-8")
by = by.decode("utf-8")
print(by)
# 结果：字符

 

4 bytearray
    ret = bytearray(字符串，encoding="utf-8")--数组(array)
    ret里存的是ascii码

ret = bytearray("字符", encoding="utf-8")
print(ret)
结果：bytearray(b'\xe5\xad\x97\xe7\xac\xa6')

 

5  memoryview--在不开辟新的内存空间的情况下，展现字符串的一部分

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

 

6 ord字符--数字,按Unicode转

print(ord("c"))

 

7 chr数字--字母，按Unicode转

print(chr(77))

 

8  ascii 字符--ASCII

print(ascii("字符"))
结果：'\u5b57\u7b26'

 

9(***)repr(对象)---显示该对象的数据类型
    用于%r格式化输出

print(repr("123"))
结果：'123'

 

type(对象)  --返回数据类型

2--数据集合（3）

1(***)dict()---强转成字典

2(***)set()---强转成集合

3(***) frozenset---改为不可变集合

set_test = set('hello')
f_set_test = frozenset(set_test)
# dic = {set_test:1}--这样直接写会报错，因为集合是可变的
dic = {f_set_test: 1}
print(dic)

 

3--各类数据类型相关的内置函数（8）

1(*****) len()--求长度

2(***)enumerate()    #给一个可迭代对象加序号

se = {'computer': 10000, 'umbrella': 200}
for num, goods in enumerate(se, 1):
    print(num, goods, se[goods])

 

3 all(可迭代对象)--判断bool值是否有Flase的值

print(all([1,"",3,5]))

 

4 any(可迭代对象)--判断bool值是否有True的值

print(any(["",[],3]))

 

5(***)zip(可迭代对象，可迭代对象，可迭代对象.....)---得到的是迭代器，返回的是列表

li = [1, 2, 3, 4, 5, 6]
a = "faskdlfj"
print(zip(li, a))
ret = zip(li, a)
for i in ret:
    print(i)

 

filter 和 map (强大，有用，重点)
6(***)filter(函数，可迭代对象)---过滤，过滤条件是放在函数里
        从可迭代对象里取值，在函数里运行，符合条件时，就放到返回值里
            返回的是迭代器
        接收对象 = filter(函数，可迭代对象)   接受对象是一个迭代器

例一：
def func(n):
    if type(n) is str:
        return True


li = ["af", [1, 2, 3], (3, 4, 5)]
ret = filter(func, li)
for i in ret:
    print(i)
例二：
def func(n):
    if n and n.strip():
        return True


li = ['test', None, '', 'str', '  ', 'END']
ret = filter(func, li)
print(list(ret))

 

7(***)map(函数，可迭代对象)---返回的是列表
        return 的值放到新列表里

def func(n):
    return n + n


li = [1, 2, 3, 4, 5]
ret = map(func, li)
for i in ret:
    print(i)

 

8(***)sorted(对象)---排序，默认从小到大   #有返回值

li = [1, 2, 53, 1234, 3, 4, -455]
print(sorted(li))

 

    sort()--没有返回值，

li = [1, 2, 53, 1234, 3, 4, -455]
li.sort()
print(li)

 

map filter sorted max min -- 带key的---都可能跟匿名函数有关



匿名函数：lambda表达式


 一句话的python：
    三元运算
    各种推导式，生成器表达式
    lambda表达式--解决简单问题

lambda表达式
 　函数名 = lambda 参数:返回值
 　print(函数名(传值))

规则：
  参数可以有多个，用逗号隔开
  不管逻辑多复杂，lambda表达式只写一行，且逻辑执行结束后的内容就是返回值
  返回值和正常函数一样可以是任何数据类型

func = lambda x,y:x+y
print(func(2,5))
面试题
1
现有两个元祖(("a"),("b")),(("c"),("d")),请使用python中的函数生成列表[{"a":"c"},{"b":"d"}]
print(list(map(lambda t:{t[0]:t[1]},zip((("a"),("b")),(("c"),("d"))))))

2
d = lambda p:p*2
t = lambda p:p*3
x = 2
x = d(x)
x = t(x)
x = d(x)
print(x)