内置函数
#数据类型中的数字
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))