内置函数


#数据类型中的数字
int()
num = 1
num = int(1)

print(type(num)) #查看num的数据类型
print(isinstance(num,int)) #判段num的数据类型

print(num is 1)   #身份运算  根据id判断

print(float(6))     #变为浮点数

complex()           #复数
x = complex(1-2j)
print(x.real)      #查看复数的实部
print(x.imag)      #查看复数的虚部

#对数字的处理
print(abs(-1.1))     #取绝对值
#四舍六入五留双       取整函数
print(round(10.5))
print(round(10.6))

pow(3,2,2)              #3**2%2
#divmod                    应用：前端 分页
print(divmod(100,33))          #100//33  , 100%33

print(bytes(‘gggggggggggggg‘,encoding = ‘utf8‘))
print(ord(‘A‘))     #查ASCII码表   返回对应十进制数
print(chr(67))      #查ASCII码表  返回对应字符
print(hex(10))     #  十进制转十六进制   0x 开头
print(bin(3))      #  十进制转二进制     0b
print(oct(55))     #   十进制转八进制    0o

str
x = ‘dddddddd‘
x = str([1])
x = str({‘x‘:1})
print(type(x))

#对字符串的处理
s = ‘print([x for x in range(10)])‘
s = ‘[1,2,3,4,5,6]‘
print(eval(s))       #将字符串中的内容拿出来运行

print(hash(s))
# 查看字符串的哈希值       内含哈希算法
# 1校验数据完整性：字符串相同，哈希值相同   字符串被改变，哈希值也改变
# 2只要使用的哈希算法相同，得到的哈希值的长度相同，不会随着文件大小的改变而改变
# 3不能逆推

list #   列表解析 ：list后面可以跟任何可迭代对象，将之变为列表
x = list((1,2,3,4))
print(x)
x = list(i for i in range(10))
print(x)
s = slice(2,3,1)
print(x[s])    #相当于切片的功能，但是所有列表都可以使用

l = list({‘x‘:1})   #list将字典转为列表形式
print(l)            #结果为[‘x‘]   只保留了原本字典的key

dict
d = dict(x=1,y=2)
d = dict({‘x‘:1,‘y‘:2})
#可哈希的：不可变的
#字典的键值对是按照哈希算法的压缩映射原理存储的，所以字典的键必须是可哈希的，其他的数据类型都是不可哈希的
#所以dict不能将其他类型的数据转为字典，因为存储原理不同
print(d)
set
frozenset#不可变集合
f = frozenset({1,2,3,4,5})
#f.add(7)  #报错
print(f)
print(type(f))

#总结
id
a = 258
b = 258
print(id(a))
print(id(b))
print(a is b)    #inode地址相同
#列表，字典，集合是可变的数据类型，变量l指向内存中一个列表的地址，列表中保存了它的元素的内存地址id
# 向列表中添加元素时，并不会改变列表的id,只是向列表中添加了一个新的元素的地址
# l = [1,2,3,4,5]
# print(id(l))
# l.append(6)
# print(l)

#整形，字符串，元组是不可变的数据类型，变量x,y都指向同一个数据，所以id是相同的，改变变量x指向的数据，就是在内存中重新建了一块地址
#将x指向新的内存地址，x的id随之改变，若x本来指向的数据没有变量引用，内存就会回收数据
x = 1
print(id(x))
y = 1
print(id(y))
x = 2
print(id(x))
# 当一个数据的引用计数 = 0  时，即没有变量引用它时，触发内存回收机制，将数据从内存中回收
# 函数就相当于一个变量，就是一个具体数据的名字，链接数据的内存地址

# 工厂函数 int  list   set tuple  str    可以通过这些函数造出很多实例出来的具体对象








#对数据的处理

#枚举 拉链  默认返回元组形式
#排序       默认返回列表形式
#反转  映射  过滤 默认返回迭代器
#max min reduce 返回一个值



#枚举     返回元组形式
for i in enumerate([‘a‘,‘b‘,‘c‘]):
    print(list(i))     #本来返回多个元组形式，加了list之后返回多个列表

for i in enumerate({‘x‘:1,‘y‘:2}):
    print(i)       #以元组的形式返回序号和字典的key

salaries={
    ‘egon‘:3000,
    ‘alex‘:100000000,
    ‘wupeiqi‘:10000,
    ‘yuanhao‘:2000
}

def get_value(k):
    return salaries[k]

#匿名函数   传入参数：返回值     自带return功能
# 匿名函数    一次性函数
# 匿名函数就相当于一个没有变量引用的数据，一般与内置函数联合使用，调用时生效，调用完回收
lambda k:salaries[k]

#max 和min
#查找字典中所有的values中最大的值，返回它对应的key
print(max(salaries,key = lambda k:salaries[k]))
print(min(salaries,key = lambda k:salaries[k]))
# 将salaries变为迭代器 ，执行next函数将结果给key后面的函数，再讲函数的返回值做比较,最后返回字典的key


#sorted()   排序
salaries={
    ‘egon‘:3000,
    ‘alex‘:100000000,
    ‘wupeiqi‘:10000,
    ‘yuanhao‘:2000
}
print(sorted(salaries))  #默认是按照字典salaries的key去排序     以列表的形式返回
print(sorted(salaries.values()))      #将字典的值排序输出
#根据字典的值进行排序，但输出的是字典的key
print(sorted(salaries,key = lambda x:salaries[x]))
print(sorted(salaries,key = lambda x:salaries[x],reverse = True))
# 将salaries变为迭代器 ，执行next函数将结果给key后面的函数，再讲函数的返回值进行排序,最后返回排序后的字典的key


l = [3,4,5,6,8,0,1]
print(sorted(l))    #可以对可迭代对象进行排序，返回值是列表 默认升序
print(sorted(l,reverse = True))    #降序

s = ‘hello‘
print(sorted(s))    #返回值是列表，按ASCII码排序

#反转  是一个迭代器
g = reversed(l)         #结果是一个迭代器
for i in g:
    print(i)

#zip  拉链    迭代器
l = [1,2,3,4]
s = ‘hello‘
g = zip(l,s)
for i in g:        #zip(l,s)   同时迭代2个参数，将其元素以元组的形式一一对应的返回成一个迭代器
    print(i)              #以元组的形式返回
#应用：
g = zip(salaries.keys(),salaries.values())  #可以返回多个键值对元组
for i in  g:
    print(i)
g1 = zip(salaries.values(),salaries.keys())   #可以返回多个值键对元组

print(sorted(g1))      #以元组的形式排序
print(max(g1))         #返回value值最大的那个元组

#map()  #映射   迭代器      大数据中的对数据进行处理 map_reduce
#将一个列表的元素一一对应的改变，映射出的内容以迭代器的形式触发展现
l = [1,2,3,4,5]
m = map(lambda item:item**2,l)        #将列表变为一个迭代器，每次迭代的结果给匿名函数进行运算返回一个迭代器
for i in m:
    print(i)
print(list(m))      #以列表的形式展现

name_l = [‘alex‘,‘zhejiang‘,‘yuanhao‘,‘wupaiqi‘]

m = map(lambda name:name+‘sb‘,name_l)
for i in m:
    print(i)
print(list(m))

#reduce() 合并
#利用一个匿名函数将一个列表中的元素合并成为一个值
from functools import reduce
l = list(range(100))    #list后面跟一个可迭代对象，将迭代出的数据以列表的形式呈现
print(reduce(lambda x,y:x+y,l))        #将列表变为一个迭代器，每次迭代的结果给匿名函数进行运算返回一个值

#filter   过滤   迭代器
#利用一个匿名函数将列表中符合条件的字典返回到一个迭代器里面
name_l = [
    {‘name‘:‘egon‘,‘age‘:18},
    {‘name‘:‘dragon‘,‘age‘:1000},
    {‘name‘:‘gaoluchuan‘,‘age‘:5000},
    {‘name‘:‘fsw‘,‘age‘:100000}
]
f = filter(lambda d:d[‘age‘] > 100,name_l)      #将列表变为一个迭代器，每次迭代的结果给匿名函数进行判断，
                                                  #函数返回值为True，则过滤出来列表内元素，将元素以迭代器的方式输出
print(f)
for i in f:
    print(i)

杂七杂八：
print(callable(list))  #可调用的
print(callable([1,2]))

print(all(‘‘))
print(all(i for i in range(1,10)))

print(type(i for i in range(10)))      #生成器  ： 边运行边计算
print(type(range(10)))

print(any([]))
print(any([None,0,[],{},9]))

s = ‘kkkkkkkkkk‘
print(dir(s))       # 查看对象的全部方法

import time
time.sleep(3)
h = __import__(‘time‘)   #以字符串的形式导入模块
h.sleep(3)

vars() is locals()      #vars无参的情况下和locals的功能相同

#=====================作业一
#用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb
name=[‘alex‘,‘wupeiqi‘,‘yuanhao‘]
g = map(lambda x:x+‘_sb‘,name)
print(list(g))

#用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
l=[{‘name‘:‘alex‘},{‘name‘:‘y‘}]
g = map(lambda x:{‘name‘:x[‘name‘]+‘sb‘},l)
print(list(g))

#=====================作业二
#用filter来处理,得到股票价格大于20的股票名字
shares={
   ‘IBM‘:36.6,
   ‘Lenovo‘:23.2,
   ‘oldboy‘:21.2,
   ‘ocean‘:10.2,
}
g = filter(lambda d : shares[d]> 20,shares)
print(list(g))
#=====================作业三
#如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格
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}
]

#1:map来得出一个包含数字的迭代器，数字指的是：购买每支股票的总价格
g = map(lambda x:x[‘price‘]*x[‘shares‘],portfolio)
# print(list(g))
#2:基于1的结果，用reduce来计算，购买这些股票总共花了多少钱
from functools import reduce
l = list(g)
print(reduce(lambda x,y:x+y,l,0))

#3：用filter过滤出，单价大于100的股票有哪些
g = filter(lambda x :x[‘price‘] > 100,portfolio)
print(list(g))

函数6—内置函数