Python之内置函数

#!/usr/bin/env python
# -*- coding:utf8 -*-

print('ans:')
# abs
#绝对值
print(abs(-1))
print(abs(1))

print('\nall:')
# all
#将序列中的每一个元素拿出来做布尔运算
#
#情况一(如果可迭代对象不为空):
#所有元素的布尔值为True,则输出True
#只要这些元素中有一个元素的布尔值为False,就输出False
#情况二(如果可迭代对象为空):
#直接返回True
#
#布尔值为False的元素:0 None  ""-空字符 ()-空元祖 []-空列表 {}-空字典
print(all([1,3,'3']))
print(all([1,2,'']))
print(all('120'))
print(all(''))
#只能出现一个参数
#print(all({},''))  #会出错

print('\nany:')
# any
#只要元素中有一个元素的布尔值为True,就返回True
print(any([0,'']))
print(any([0,'',1]))

print('\nbin:')
# bin
#把十进制转化为二进制
print(bin(12))  # 0b 就代表二进制

print('\nhex:')
# hex
#把十进制转换为十六进制
print(hex(12))

print("\noct:")
# oct
#把十进制转换为八进制
print(oct(12))

print('\nbool:')
# bool
#判断布尔值
#布尔值为False的元素:0 None  ""-空字符 ()-空元祖 []-空列表 {}-空字典
print(bool(''))
print(bool('asd'))

print('\nbytes:')
# bytes
#把一个字符串转换为字节的形式
name = '爱坤'
print(bytes(name,encoding = 'utf-8'))
print(bytes(name,encoding = 'gbk'))
# encoding = 'utf-8' 保存中文字符,编码为二进制
# print(bytes(name,encoding = 'ascii'))
# ASCII码不能编译中文

print('\ndecode:')
# decode
# 解码,将二进制从新转换为字符
print(bytes(name,encoding = 'utf-8').decode('utf-8'))
#用什么编码,就要用什么解码
print(bytes(name,encoding = 'gbk'))
# print(bytes(name,encoding = 'gbk').decode('utf-8'))  #会出错
print(bytes(name,encoding = 'gbk').decode('gbk'))

print('\nchr:')
# chr
#输出与ASCII码对应的字符
print(chr(97))

print("\ndir:")
# dir
#输出某一个对象下面都有哪些方法
print(dir(all))
print(dir(dict))

print('\ndivmod:')
# dicmod
# 用来做分页功能
# 括号里第一个参数是 总共有多少个记录,
# 第二个参数代表 一页该放多少个记录
print(divmod(10,3))
# 得出的结果:
#第一个参数是 可以分出多少页
#第二个参数不为0 代表还需要再多分一页

print('\nstr:')
#str
#把字符串中的数据结构给提取出来
d = {'name':'alex'}  #将字典转换成字符串
d_str = str(d)
print(d_str)

print('\neval:')
# eval
#把字符串内的表达式运算出结果输出
'''
eval(expression, globals=None, locals=None)  
--- 官方文档中的解释是,将字符串str当成有效的表达式来求值并返回计算结果。
    globals和locals参数是可选的,
    如果提供了globals参数,那么它必须是dictionary类型;
    如果提供了locals参数,那么它可以是任意的map对象。

python是用命名空间来记录变量的轨迹的,命名空间是一个dictionary,键是变量名,值是变量值。

当一行代码要使用变量 x 的值时,Python 会到所有可用的名字空间去查找变量,按照如下顺序:
1)局部名字空间 
    特指当前函数或类的方法。如果函数定义了一个局部变量 x, 或一个参数 x,Python 将使用它,然后停止搜索。
2)全局名字空间 
    特指当前的模块。如果模块定义了一个名为 x 的变量,函数或类,Python 将使用它然后停止搜索。
3)内置名字空间 
    对每个模块都是全局的。作为最后的尝试,Python 将假设 x 是内置函数或变量。

python的全局名字空间存储在一个叫globals()的dict对象中;
    局部名字空间存储在一个叫locals()的dict对象中。
    我们可以用print (locals())来查看该函数体内的所有变量名和变量值。

eval()使用原因:
1)在编译语言里要动态地产生代码,基本上是不可能的,
    但动态语言是可以,意味着软件已经部署到服务器上了,
    但只要作很少的更改,只好直接修改这部分的代码,就可立即实现变化,不用整个软件重新加载。
2)在machin learning里根据用户使用这个软件频率,以及方式,可动态地修改代码,适应用户的变化。
 
'''
# 使用示例一:
x = '1 + 7 * 3'
print(x)
print(eval(x))
# 使用示例二:
data = input('请输入你要修改的对象:').strip()
'''
输入下面的字典列表
[{'backend':'www.oldboy1.org','record':{'server':'2.2.2.4','weight':20,'maxconn':3000}},{'backend':'www.oldboy1.org','record':{'server':'2.2.2.5','weight':30,'maxconn':4000}}]
'''
print(data)
data = eval(data)
# 如果不使用该项命令,会报错:string indices must be integers
# 作用:把用户输入的字符串里的数据结构提取出来
print(data)
print(data[0]['backend'])
old_server_record = '%sserver %s %s weight %s maxconn %s\n' %(' '*8,data[0]['record']['server'],
                                                                data[0]['record']['server'],
                                                                data[0]['record']['weight'],
                                                                data[0]['record']['maxconn'])
print(old_server_record)
new_server_record = '%sserver %s %s weight %s maxconn %s\n' % (' ' * 8, data[1]['record']['server'],
                                                                 data[1]['record']['server'],
                                                                 data[1]['record']['weight'],
                                                                 data[1]['record']['maxconn'])
print(new_server_record)

print('\nhash:')
#hash
#可用于判断文件是否被改过
# 可hash的数据类型即不可变数据类型
# 不可hash的数据类型即可变数据类型
#
#特性1,不论传入的参数有多长,最后得出的结果的长度都是固定的
#特性2,不能根据最终hash值的结果去反推出字符串是什么
#特性3,在同个程序中,相同字符串每次求hash值的时候的出来的来的值都是一样的,如果字符串改变,hash值也会改变
print(hash('adkasd'))
name = 'alex'
print(hash(name))
print(hash(name))
print(hash(name))
name = 'gbk'
print(hash(name))
#用处
#下载软件时,在下载过程当中,进行数据传输,数据被第三方的人截取到了
#把软件包中的某个文件改了改,把一段木马程序写进去了,这你就会连同木马和软件都下载到了本地中
#一执行,电脑就会中毒
#规避方法,软件在网站上挂着的时候,对这个软件的整体做一个hash运算,得出一个非常短的值
#把这个值连同软件一块下载,一块发给你,这样你下载到本地的时候
#你也用hash算法对这个软件也做一次hash运算,最后得到一个编码
#如果编码是一样的话,意味着软件中没有被改过,这个软件就可以放心使用

print('\nhelp:')
# help
# 查看目录,查看某命令的详细使用方法
# 区别于 dir ,dir只输出名字,而help输出详细信息,详细解释
print(help(all))

print('\nisinstance:')
# isinstance
#判断 第一参数 是否为 第二参数 所指的数据类型
print(isinstance(1,int))
print(isinstance('abc',str))
print(isinstance('abc',list))
print(isinstance('abc',dict))
print(isinstance([],list))  #就算是空列表也是列表

print('\nglobals:')
# globals
# 输出全局变量 (包括系统给你提供的全局变量和你自己定义的全局变量)
print(globals())

print('\nlocals:')
# locals
# 打印当前级别的局部变量
print(locals())

print('\nglobals() VS locals()')
def test():
    age = 123
    print(globals())
    print(locals())
test()

print('\nlen:')
# len
#计算字符串或元素的长度
print(len('auksdfg'))
print(len(['sdaf',23,'asd']))
#type 'int' has no len()
#print(len(867))

print('\nmax and min:')
# max
# 取最大值
# min
# 去最小值
# 注意,不能出现字符串
# 1.max函数处理的是可迭代对象,相当于一个for循环取出每一个元素进行比较,
#   注意:不同类型之间不能比较
# 2.每一个元素间进行比较,是从每一个元素的第一个位置依次比较
#   如果这一个位置分出大小。后面的就不需要比较了,直接 得出这两元素的大小
i = [21,3,45,67]
print(max(i))
print(min(i))

print('\nzip:')
# zip
# 像拉链一样,左边一个对应右边一个 组成一个元组
# 只要是序列都可以进行一一对应执行 zip
print(list(zip(('a','n','f'),(1,3,5))))
# 不论是左边的多了一个还是右边的多了一个,都因为没有与之对应的值而被舍弃不输出
# 像拉链一样,缺了一边就拉不上了
print(list(zip(('a','n','f'),(1,3,5,8))))
print(list(zip(('a','n','f','l'),(1,3,5))))
# 将字典的keys和calues提出来组成一一对应的元组
p = {'name':'alex','age':18}
print(list(zip(p.keys(),p.values())))
l = 'asdsdf'
k = '93ujhwe9'
x = [23,'2asd']
print(list(zip(l,k)))
print(list(zip(l,x)))

print('\nax and min and zip拓展:')
age = {'age1':12,'age16':34,'age3':63,'age4':100}
#字典中的 values 的大小的比较
print(max(age.values()))
print(min(age.values()))
#字典中的 keys 的大小的比较
#如果是字符串的话,按照ASCII码表的顺序排大小(按一个一个字符对应进行比较的,所以 age4 比 age16 大)
print(max(age))  #默认比较的是字典的key
for i in zip(age.values(),age.keys()):
    print(i)
print('对列表中的元组进行比较')
i = [
    (5,'a'),
    (30,'c'),
    (1,'e'),
]
print(max(i))
#不同的数据类型不能进行比较
i = [
    ('b5','a'),
    ('a30','c'),
    ('d1','e'),
]
print(max(i))
# 比较是从第一个元素开始比较的
#取出values的最大值,同时输出对应的key
#与 zip 一起使用
age = {'age1':12,'age16':34,'age3':63,'age4':100}
print('***************\n',age)
print('从上面的字典中取出values的最大值,同时输出对应的key:')
print(max(list(zip(age.values(),age.keys()))))
#
people = [
    {'name':'aj','age':14},
    {'name':'jk','age':56},
    {'naem':'ak','age':345},
    {'name':'cs','age':345},
]
print('只比较某个key对应的值,并输出所对应的people的所有信息:')
max_people = max(people,key = lambda dic:dic['age'])
print(max_people)

print('\nord:')
# ord
# 输出字符对应的ASCII码的数字
print(chr(97))
print(ord('a'))

print('\npow')
# pow(x,y,z)
# x 的 y 次方
# x 的 y 次方对 z 的取余
print(pow(2,3))  #相当于2**3
print(pow(2,3,3))   #相当于2**3%3

print('\nreversed:')
# reversed
# 反转字符串或列表
l = [1,2,3,4]
print(l)
print(reversed(l))
print(list(reversed(l)))
print(l)
k = 'dfdssdfa'
print(k)
print(reversed(k))
print(list(reversed(k)))
print(k)
# j = {'name':'asd','age':23}
# print(j)
# print(reversed(j))
# print(list(reversed(j)))
# print(j)

print('\nround:')
# round
# 四舍五入
print(round(3.6))
print(round(3.5))
print(round(4.5))

print('\nset')
# set
# 变成一个集合
print(set('kuasdh'))

print('\nslice:')
# slice(x,y,z)
# 切片
# 从第 x 个开始(输出第 x 位) 到第 y 个结束(不输出第 y 位) ,步长为 z
i = 'abcdef'
s1 = slice(3,5)
s2 = slice(1,5,2)
print(i[s1])
print(i[s2])
print(s2.start) #求开始的位置
print(s2.stop)  #求结束的位置
print(s2.step)  #求步长

print('\nsorted:')
# sorted
# 排序(比较大小,不能为不同类型)
l = [43,5,23,6,56]
l1 = sorted(l)
# 对列表中的字典进行排序
student = [
    {'name':'abc','id':123,'age':17},
    {'name':'jbk','id':54,'age':15},
    {'name':'sdg','id':789,'age':23},
    {'name':'hgj','id':234,'age':20},
]
print(sorted(people,key = lambda dic:dic['age']))
# 对字典进行排序
name_age = {
    'asdd':123,
    'asdf':553,
    'dfdsa':120,
}
# 对values的值进行排序,并输出对应的valu
print(sorted(name_age.values()))
# 对key的值进行排序,并输出对应额key
print(sorted(name_age))
# ***对values的值进行排序,并输出对应的key***
print(sorted(name_age,key = lambda key:name_age[key]))
# ***对values的值进行排序,并输出key和values的值***
print(sorted(zip(name_age.values(),name_age.keys())))

print('\nsum:')
# sum
# 将所有数字加起来输出值
j = [1,2,5]
print(sum(j))
print(sum(range(5)))

print('\ntype:')
# type
# 得出变量的类型
# 用法:
# 1 用type判断是否为字符串,如果是,就将其转换为数字进行所要的计算
msg = '123'
if type(msg) is str:
    msg = int(msg)
    res = msg + 1
    print(res)

print('\nvars:')
# vars
# vars([object]) -> dictionary
def test():
    msg = 'kaushfash'
    print(locals())
    print(vars())
test()
print(vars(int))

print("\nimport:")
# import
# ***导入模块
# ***将其他 .py 文件的函数导入该文件中
# ***import 不能导入字符串
# import 匿名函数
# #***运行时会将该文件里的所有函数都运行一次
# # ***所以在导入其他模块时,要注意该模块只有函数没有一些执行的命令
# print(匿名函数.pf(2))
import import_test
print(import_test.pf(2))

print('\n__import__():')
# __import__()
#
DR_name = 'import_test'
m = __import__(DR_name)
m.say_hi()

 

posted @ 2019-04-27 18:05  Jony-2018  阅读(174)  评论(0编辑  收藏  举报