文章目录

  • 1. 内置函数
  • 2. 名称空间
  • 3. 闭包
  • 4. 列表生成式


1. 内置函数

python离散数学打印命题公式的真值表 python 真值表_名称空间


常用的内置函数

# abs绝对值
i = abs(-123)
print(i)  
# 返回123，绝对值

# all，循环参数，如果每个元素为真，那么all返回的为真，有一个为假返回的就是假的
a = all((None,123,456,False))
print(a)  
# 返回的为假的，证明中间有False值

# any  只要有一个是真的，返回的就是真
b = any([11,False])
print(b)
# 返回 True

#ascii函数 去指定对象的类中找__repr__,获取返回值
class Foo:
    def __repr__(self):
        return "zhangyanlin"
obj =Foo()
r = ascii(obj)
print(r)


# 布尔值返回真或假
print(bool(1))
print(bool(0))


# bin二进制
r = bin(123)
print(r)

# oct八进制
r = oct(123)
print(r)

# int十进制
r = int(123)
print(r)

# hex十六进制
r = hex(123)
print(r)

# 二进制转十进制
i= int("0b11",base=2)
print(i)

# 八进制转十进制
i= int("11",base=8)
print(i)

# 十六进制转十进制
i = int("0xe",base=16)
print(i)

# 数字代表字母
c = chr(66)
print(c)

# 字母代表数字
c = ord("a")
print(c)


# bytes, 字节字节和字符串的转换
a = bytes("Py小白雨",encoding="utf-8")
print(a)



# chr,把数字转换成字母,只适用于ascii码
a = chr(65)
print(a)

# ord,把字母转换成数字，只适用于ascii码
a = ord("a")
print(a)

# callable，表示一个对象是否可执行
def f1():        #看这个函数能不能执行，能发挥True
    return 123
f1()
r = callable(f1)
print(r)


# dir,查看一个类里面存在的功能
li = []
print(dir(li))
help(list)


# divmod,分页的时候使用
a = 10/3
r = divmod(10,3)
print(r)




# eval,简单的表达式，可以给算出来
b = eval（"a + 69" , {"a":99})  #a可以通过字典声明变量去写入
print(b)

# exec,不会返回值，直接输出结果
exec("for i in range(10):print(i)")


# filter,对于序列中的元素进行筛选，最终获取符合条件的序列（需要循环）
def f1(x):
    if x >22:
        return  True
    else:
        return False

ret = filter(f1,[11,22,33,44,55])
for i in ret:
    print(i)

ret = filter(lambda x: x > 22, [11, 22, 33, 44, 55, 66, 77])
for i in ret:
    print(i)

# map(函数，可以迭代的对象，让元素统一操作)
def f1(x):
    return x+123

li = [11,22,33,44,55,66]
ret = map(f1,li)
print(ret)
for i in ret:
    print(i)

ret = map(lambda x: x + 100 if x%2==1 else x, [11, 22, 33, 44])
print(ret)
for i in ret:
    print(i)

# globals,获取当前所有的全局变量 
# locals,获取当前所有的局部变量
ret = "Py小白雨"
def fu1():
    name = 123
    print(locals())
    print(globals())

fu1()


# hash，对key的优化，相当于给输出一种哈希值
li = "Py小白雨"
print(hash(li))

# isinstance，判断是不是一个类型
li = [11,22]
ret = isinstance(li,list)
print(ret)


# iter,创建一个可以被迭代的元素
obj = iter([11,22,33,44])
print(obj)

# next，取下一个值，一个变量里的值可以一直往下取，直到没有就报错
ret = next(obj)

# max,取最大的值
li = [11,22,33,44]
ret = max(li)
print(ret)

# min,取最小值
li = [11,22,33,44]
ret = min(li)
print(ret)

# 求一个数字的多少次方
ret = pow(2,10)
print(ret)

# reversed反转
a = [11,22,33,44]
b = reversed(a)
for i in b:
    print(i)

# round 四舍五入
ret = round(4.8)
print(ret)

# sum求和
ret = sum((11,22,33,44))
print(ret)

# zip，1 1对应
li1 = [11,22,33,44,55]
li2 = [99,88,77,66,89]
dic = dict(zip(li1,li2))
print(dic)


# sorted 排序
li = ["1","2sdg;l","57","a","b","A","中国人"]
lis = sorted(li)
print(lis)
for i in lis:
    print(bytes(i,encoding="utf-8"))

2. 名称空间

若变量x=1，1存放于内存中，名称空间正是存放名字x与1绑定关系的地方

python里面有很多名字空间，每个地方都有自己的名字空间，互不干扰，不同空间中的两个相同名字的变量之间没有任何联系。

名称空间有4种:

  • locals:函数内部的名字空间，一般包括函数的局部变量以及形式参数
  • enclosing function:在嵌套函数中外部函数的名字空间, 若fun2嵌套在fun1里，对fun2来说，fun1的名字空间就enclosing.
  • globals:当前的模块空间，模块就是一些py文件。也就是说，globals()类似全局变量。
  • builtins: 内置模块空间，也就是内置变量或者内置函数的名字空间，print(dir(builtins))可查看包含的值。

不同变量的作用域不同就是由这个变量所在的名称空间决定的。

作用域即范围

  • 全局范围：全局存活，全局有效
  • 局部范围：临时存活，局部有效

查看作用域方法

globals(),获取当前所有的全局变量
locals(),获取当前所有的局部变量

3. 闭包

定义

函数定义和函数表达式位于另一个函数的函数体内(嵌套函数)。而且，这些内部函数可以访问它们所在的外部函数中声明的所有局部变量、参数。当其中一个这样的内部函数在包含它们的外部函数之外被调用时，就会形成闭包

def outer():
    name = 'Py小白雨'
    def inner():
        print("在inner里打印外层函数的变量",name)
    return inner # 注意这里只是返回inner的内存地址，并未执行
f = outer()
print(f) 
f()  # 相当于执行的是inner()

# <function outer.<locals>.inner at 0x000001C85CBE5158>
# 在inner里打印外层函数的变量 Py小白雨

此时outer函数已经执行完毕，正常情况下内存都已经释放了，但由于闭包，还可以调用inner, 并且inner内部还调用了outer里的name变量。

返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

4. 列表生成式

a = [i+1 for i in range(10)]
print(a)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]