python内置函数小确幸

#判断类型和值
number=22
print(isinstance(number,str))   #False,判断number变量是不是字符串
print(number is 10) #False

print(all((1,0)))   #有一个为假，返回假  #False
print(any((1,0)))   #有一个为真，返回真  #True

#判断函数是否可调用
def hello():
    pass
print(callable(hello))    #True

#可变集合，不可变集合，有add方法
s={1,2,3,4,5}
s.add(9)
print(s) #{1, 2, 3, 4, 5, 9}
f=frozenset({1,4,3,5,2})
print(type(f),f)
# <class 'frozenset'> frozenset({1, 2, 3, 4, 5})

# 列表拥有append方法，字典没有append方法
list1=[1,2,3,4,5]
list1.append(9)
print(list1)   #[1, 2, 3, 4, 5, 9]
x=list(i for i in range(10))
print(x)


# 字典可以用键值对传参数,可以利用dict方法将键值对参数变成字典
dict1={"name":"alex","age":25}
d=dict(x=1,y=2,z=3)
print(d)


#复数
x=complex(1-2j)
print(x.real)
print(x.imag)
x=1-2j
print(x.real)
print(x.imag)
# 1.0
# -2.0
# 1.0
# -2.0


# 可看对象下面的方法
print(dir(sum))  #能查看sum所拥有的所有内置方法,相当强大啊
print(help(sum))  #查看帮助信息


#取余,结果，余数
print(divmod(10,3))
# (3, 1)  返回元组形式
x,y = divmod(10,3)
print(x,y)
# 3 1 可以进行拆分了


#enumerrate是枚举的意思， 迭代器,循环返回索引和列表值的元组
for i in enumerate([1,2,3,4]):
    print(i)

# (0, 1)
# (1, 2)
# (2, 3)
# (3, 4)

for i in enumerate(['三叔','hello','哈哈','北京']):
    print(i)

# (0, '三叔')
# (1, 'hello')
# (2, '哈哈')
# (3, '北京')


# 哈希用来校验数据的准确性，得出的值作为哈希值
# 下载哈西值和初始哈西值不一致说明代码被改过或者下载不完整，
# 哈西算法长度固定，不变，哈西值不能逆推

s="hello"
print(hash(s))
s="h"
print(hash(s))


# 10转16进制
print(hex(10))

# 唯一标志身份号码
a=1
b=2
print(id(a))
print(id(b))
print(a is b)

# 指向同一值，同一id
x=1
y=1
print(id(x))
print(id(y))
print(x is y)
# True

# 把可迭代对象变成迭代器
# iter()


# 计算大小写，计算最大值
print(max(1,2,4,5,6,8,23))
sa={
    'ada':3000,
    'aman':100000000,
    'antonio':10000,
    'tony':2000
}
# 自动计算字典最大值
print(max(sa.keys()))
print(max(sa.values()))
# tony  max(sa)的结果竟然是tony,因为键是字母，根据首字母对ascii码从小到大排
# 100000000  根据值的最大进行对比

# 默认max的sa将key 传给k，迭代值，返回key
def get_values(k):
    return sa[k]
print(max(sa,key=get_values))
# aman

# 匿名函数
f=lambda k:sa[k]
f("aman")


# 最简洁语法,lambda表达式
print(max(sa,key=lambda k:sa[k]))
# aman  对值进行排序。返回值最大者
print(min(sa,key=lambda k:sa[k]))
# tony


# zipper。返回元组
he=[1,2,3]
s="hello"
for i in zip(he,s):
    print(i)


# (1, 'h')
# (2, 'e')
# (3, 'l')

print(sa.keys(),sa.values())
# dict_keys(['ada', 'antonio', 'aman', 'tony']) dict_values([3000, 10000, 100000000, 2000])
#默认比较第一个大小，根据values，z返回元祖

z=zip(sa.values(),sa.keys())
print(z)   #<zip object at 0x10de4d788>


print("maxz",max(z))   #maxz (100000000, 'aman') 以元组形式返回


# 排序,返回值为列表，默认升
str="hello 哈哈哈"
print(sorted(str))
print(sorted(sa.values()))
# [' ', 'e', 'h', 'l', 'l', 'o', '哈', '哈', '哈']
# [2000, 3000, 10000, 100000000]


# 排序,返回值为列表，降序排列
str="hello 哈哈哈"
print(sorted(str,reverse=True))
print(sorted(sa.values(),reverse=True))
# ['哈', '哈', '哈', 'o', 'l', 'l', 'h', 'e', ' ']
# [100000000, 10000, 3000, 2000]


sa={
    'ada':3000,
    'alex':100000000,
    'antonio':10000,
    'tony':2000
}
print(sorted(sa,key=lambda k:sa[k]))
print(sorted(sa,key=lambda k:sa[k],reverse=True))
# ['tony', 'ada', 'antonio', 'alex']
# ['alex', 'antonio', 'ada', 'tony']

# map映射，把右边的传给左边
y=[3,4,4,3,1]
m=map(lambda item:item**2,y)
print(list(m))
# [9, 16, 16, 9, 1]
# for i in m:
#     print(i)

l=[{'name':'alex'},{'name':'y'}]
# 得到只有名字的列表,map直接根据键取值组成list
lm=map(lambda i:i['name'],l)
print(list(lm))
# ['alex', 'y']


y=["alex","ada","tony","antonio"]
m=map(lambda name:name+"sb",y)
print(list(m))
# ['alexsb', 'adasb', 'tonysb', 'antoniosb']


#reduce合并求和, 记住导入方式在functools
from functools import reduce
l=list(range(100))
print(reduce(lambda x,y:x+y,l,100))
# 5050



#filter,过滤，true返回
filter_list=[
    {'name':'素还真','age':18},
    {'name':'一页书','age':1000},
    {'name':'秦假仙','age':2000},
    {'name':'玄同','age':10},
]
# 返回包含字典的列表
f=filter(lambda d:d['age']>18,filter_list)
print(list(f))
# [{'age': 1000, 'name': '一页书'}, {'age': 2000, 'name': '秦假仙'}]

# 返回字典
f=filter(lambda d:d['age']>18,filter_list)
for i in f:
    print(i)
# {'age': 1000, 'name': '一页书'}
# {'age': 2000, 'name': '秦假仙'}

sha={
	'IBM':36.6,
	'Lenovo':23.2,
	'apple':21.2,
	'micro':10.2,
}
f=filter(lambda k:sha[k]>20,sha)
print(list(f))
# ['apple', 'IBM', 'Lenovo']


print(oct(10))  #0o12   10->8
print(hex(10))  #0xa    10->16

#平方  第三个参数取余数
print(pow(3,2,1))
print(pow(4,2))
#反转列表
print(list(reversed([1,3,8,4])))
# [4, 8, 3, 1]

#5舍6入
print(round(10.5))   #10
print(round(10.6))   #11

#切片＝＝l[2:4]，左取右不取
l=[1,2,3,4,5,6,7,8]
x=slice(2,4)
print(l[x])
# [3, 4]


print(vars() is locals())  #True
globals()
# 返回当前全局符号表, 通常在是返回当前模块下的全局符号表, 比如全局内建的函数,
#
# 以及模块里的全局符号(定义声明的变量,类, 实例等), 在函数或者类方法中, globals()
#
# 返回的模块符号表是其所在模块, 而不是调用模块.
#
# locals() 更新并以字典形式返回当前局部符号表. 自由变量由函数块的locals() 返回, 而
#
# 不会由 class 块来返回. 需要注意的是, locals() 字典不应该被修改; 在解释器中对修改行为
#
# 可能对 local 值或者自由变量无效.
#
# vars() 返回 __dict__ 属性, 比如模块, 类, 实例, 或者其他 带有 __dict__ 属性的 object.
#
# 比如 模块和实例拥有可更新的 __dict__ 属性;然而其他 objects 可能会对 __dict__ 属性
#
# 的写操作限制(例如 类使用 dictproxy 阻止直接对字典更新).
#
# vars() 如果不传参数, 那么作用与 locals() 一样. 需要注意的是, locals 字典只在读操作
#
# 时使用, 因为对 locals 的更新会被忽略.

import time
#自己干的事，pycharm已经定义了，其他工具没有的，自己写


m = __import__('time')
# 内建模块
print(m)
# <module 'time' (built-in)>

　　

 

基本练习

转载于:https://www.cnblogs.com/adamans/articles/7506903.html