print(globals()) # 字典形式返回全局变量
print(locals()) # 字典形式返回当前位置局部变量
# eval() 执行字符串
s = "{'k1': '1', 'k2': '2'}"
dic1 = eval(s) # 字符串去掉了引号
print(dic1, type(dic1)) # {'k1': '1', 'k2': '2'} <class 'dict'>
print(eval('2+2')) # 4
print(eval('print("test")')) # test None 内层print去掉引号输出test，没有返回值故外层print输出None
# exec() 执行字符串内部代码，不返回结果
print('exec', exec('2+2')) # exec None
# 输入输出
number = input('请%s输入金额：' % 'Jerry') # input支持字符串格式化
print(number)
print('a', 'b', 3, sep='*', end='!') # sep设置输出字符连接符，end设置结束符
print('c') # a*b*3!c
f1 = open('log', encoding='utf-8', mode='w')
print('test2', file=f1) # 输出内容到文件
f1.close()
help(int()) # 帮助，显示函数所有方法
print(hash('test')) # 6406571659857012385 不可变对象通过hash算法转换成hash值
print(hash((1, 2, 3))) # 529344067295497451
print(hash(1)) # 1 数字hash还是原数字
# print(hash([1, 2, 3]))# 列表是可变对象，不可hash
print(id('test')) # 140574420681904 返回对象内存地址
def F1():
pass
print(callable(F1)) # True callable()检查对象是否可调用
print(callable('test')) # False
# dir() 不带参数时，返回当前范围内的变量、方法和定义的类型列表
print(
dir()) # ['F1', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'dic1', 'f1', 'number', 's']
# 带参数时，返回参数的属性、方法列表
print(
dir(F1())) # ['__bool__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
# 迭代器相关： range() iter() next()
# len() 返回可迭代对象的长度
print(len(range(3))) # 3
# iter() 等于 __iter__()
L1 = [1, 2, 3, 4]
L1_obj = iter(L1)
print(L1_obj) # <list_iterator object at 0x7fc12e1b70a0>
# next() 等于__next__()
print(L1_obj.__next__()) # 1
print(next(L1_obj)) # 2
# 数据类型
# int 转换数字/整型
print(int('123')) # 123
print(int(1.543)) # 1 截断转换整型
# print(int('1.543'))#***int 不能直接将小数点字符转换整型
print(float('1.543')) # 1.543 float可直接转换
# bin 十进制转二进制字符串
print(bin(10), type(bin(10))) # 0b1010 <class 'str'> 0b代表二进制
# oct 十进制转八进制字符串
print(oct(10), type(oct(10))) # 0o12 <class 'str'> 0o代表八进制
# hex 十进制转十六进制字符串
print(hex(13), type(hex(13))) # 0xd <class 'str'> 0x代表十六进制
# str() 将数据转换为字符串
# 数学运算
# 绝对值
print(abs(-3)) # 3
# 除法运算，返回一个包含 商和余数 的元组
print(divmod(10, 3)) # (3, 1)
# 对浮点数四色五入，默认保留整数
print(round(1.2355, 3)) # 1.236
# pow() 求x的y次幂； 三个参数时表示 x**y/z 取余
print(pow(2, 3)) # 8
print(pow(2, 3, 3)) # 2
# sum() 返回可迭代对象的和
print(sum([1, 2, 3], 10)) # 16
# min() 返回可迭代对象的最小值，可加key，key为函数名，通过函数的规则返回最小值
# 与sum略有不同，min第一个参数为可迭代对象，第二个参数为函数key，函数可自定义
print(min([1, 2, 3, -4])) # -4
print(min([1, 2, 3, -4], key=abs)) # 1
# max() 返回可迭代对象的最大值，与min()相同，可加key
print(max([1, 2, 3, -4], key=abs)) # -4
# 数据结构
# list() 将可迭代对象转换为列表，如果是字典默认将key作为列表元素
tu1 = (1, 2, 3)
print(list(tu1)) # [1, 2, 3]
l1 = list((1, 2, 3))
print(l1) # [1, 2, 3]
l2 = list({'key1': 'value', 'key2': 2})
print(l2) # ['key1', 'key2']
# tuple() 将可迭代对象转换为元组，如果是字典默认将key作为元组的元素
# reversed() 列表翻转，并返回翻转后的迭代器
tu2 = (1, 2, 3)
print(reversed(tu2)) # <reversed object at 0x7f9c2f694ee0>
for i in reversed(tu2):
print(i) # 3 2 1
# slice() 构造切片对象，用于列表的切片规则
L3 = [1, 2, 3, 4, 5]
L4 = [6, 7, 8, 9, 10]
rule = slice(1, 4, 2)
print(L3[rule]) # [2, 4]
print(L4[rule]) # [7, 9]
# format() 数据处理，精计算等
print(format('test', '<20')) # 设置输出字符长度，左对齐
print(format('test', '>20')) # 右对齐
print(format('test', '^20')) # 居中
# bytes() 数据类型转换
s1 = 'test'
b1 = s1.encode('utf-8')
b2 = bytes(s1, encoding='utf-8')
print(b1, b2) # b'test' b'test' 两种方式相同
# ord() 查找字符的编码位置
print(ord('a')) # 97 ASCII码位置
print(ord('王')) # 29579 unicode位置
# chr() 输入位置查找字符
print(chr(97)) # a
print(chr(666)) # ʚ
# ascii() 返回表示对象的字符串，对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符
print(ascii('test')) # 'test'
print(ascii(123)) # 123
print(type(ascii(123))) # <class 'str'>
print(ascii('王')) # '\u738b'
# repr() 返回一个对象的str形式
print('{"key1": "value"}') # {"key1": "value"}
print(repr('{"key1": "value"}')) # '{"key1": "value"}'
# 可将格式字符保留
print("物品\t单价\t数量\n包子\t1\t2") # 物品 单价 数量 包子 1 2
print(repr("物品\t单价\t数量\n包子\t1\t2")) # '物品\t单价\t数量\n包子\t1\t2'
# %r repr字符串格式化，同样是str形式
s2 = 'Jerry'
print('hello, %r' % s2) # hello, 'Jerry'
# sorted() 对可迭代对象进行排序， 可使用key添加规则， 返回列表
print(sorted((1, 2, 3, -1))) # [-1, 1, 2, 3]
print(sorted((1, 2, 3, -1), key=abs)) # [1, -1, 2, 3] 绝对值排序
dic2 = {'a': 1, 'c': 2, 'd': 4, 'b': 3}
def F2(f):
return dic2[f]
print(sorted(dic2)) # ['a', 'b', 'c', 'd'] 按key排序
print(sorted(dic2, key=F2)) # ['a', 'c', 'b', 'd'] 按value排序
# all() 可迭代对象中全 都是 True时返回True
# any() 可迭代对象中有 一个 True时返回True
print(all([1, 2, True, (0, 1)])) # True
print(all([1, 2, True, (0)])) # False
print(any([0, False, ''])) # False 空字符串为假
print(any([0, False, '0'])) # True 字符串0为真
# zip() 拉链方法，对多个可迭代对象纵向拼接，返回一个迭代器， 迭代器长度由最短迭代对象决定
L1 = [1, 2, 3, 4]
L2 = ['test1', 'test2', 'test3']
tu1 = ('菜鸡', '入门', '高手')
new_obj = zip(L1, L2, tu1)
for i in new_obj:
print(i)
"""
(1, 'test1', '菜鸡')
(2, 'test2', '入门')
(3, 'test3', '高手')
"""
# map() 循环模式：对可迭代对象元素按函数逻辑处理，返回迭代器
def F3(a):
return a ** 2
obj = map(F3, [1, 2, 3])
for i in obj:
print(i) # 1 4 9
# 与推导式类似
obj1 = [i ** 2 for i in range(1, 4)]
print(obj1) # [1, 4, 9]
# 例二：
def F4(x, y):
return x + y
obj2 = map(F4, [1, 2, 3], [4, 5, 6])
for i in obj2:
print(i) # 5 7 9
# filter() 过滤器，对可迭代对象元素进行筛选，对满足函数条件的值添加到迭代器中
def F5(a):
return a % 2 == 0
obj3 = filter(F5, [1, 2, 3, 4, 5, 6])
for i in obj3:
print(i) # 2 4 6
# 类似推导式筛选
obj4 = [i for i in [1, 2, 3, 4, 5, 6] if i % 2 == 0]
print(obj4) # [2, 4, 6]
# lambda 匿名函数,格式：函数名 = lambda 形参: 返回值
def F6(x, y):
return x + y
re = lambda x, y: x + y
print(F6(2, 3), re(2, 3)) # 5 5
re1 = filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6])
for i in re1:
print(i) # 2 4 6
re2 = map(lambda x: x ** 2, [1, 2, 3, 4, 5, 6])
for i in re2:
print(i) # 1 4 9 16 25 36
L5 = [('test1', 5), ('test2', 3), ('test3', 4)]
print(sorted(L5, key=lambda x: x[1], reverse=True)) # [('test1', 5), ('test3', 4), ('test2', 3)] reverse=True倒序
# 例题
# 1、给所有name加上姓氏.Wang，得到新的列表
dic3 = [{'name': 'Tom'}, {'name': 'Jerry'}]
# 方法一：
L6 = list(map(lambda X: X['name'] + '.Wang', dic3))
print(L6)
# 方法二：
L7 = [i['name']+'.Wang' for i in dic3]
print(L7)
# 2、筛选价格大于20的商品
shop = {
'computer': 5000,
'phone': 4000,
'book': 15
}
# 方法一：
L8 = filter(lambda X: shop[X] > 20, shop)
for i in L8:
print(i)
# 方法二：
L9 = {(k, v) for k, v in shop.items() if v > 20}
print(L9)
# 3、计算购买每种商品的总价格
shop_L = [
{'name': 'computer', 'shares': 3, 'price': 5000},
{'name': 'phone', 'shares': 5, 'price': 4000},
{'name': 'book', 'shares': 10, 'price': 15},
]
# 方法一：
count_L = list(map(lambda X: {X['name']: X['shares'] * X['price']}, shop_L))
print(count_L)
# 方法二：
count_l = [{i['name']: i['shares'] * i['price']} for i in shop_L]
print(count_l)
# 4、将列表按照value分别从大到小、从小到大排序
L10 = [{'age': 1},
{'age': 44},
{'age': 94},
{'age': 12},
{'age': 32},
{'age': 11}
]
print(sorted(L10, key=lambda x: x['age']))
print(sorted(L10, key=lambda x: x['age'], reverse=True))
