names = ['jmz','qqq','egon']
names = [name.upper() for name in names]
print(names)

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz# min max 与匿名函数的运用
l = [1,2,3,4,5,6,7,8,9]
dic = {'x':11,'y':32,'z':3}print(max(l))
print(min(l))print(max(dic))  # z  这个取的是key的最大值
print(max(dic,key=lambda k:dic[k]))  # y   # 这个取的是value最大值的那个keyprint(min(dic)) # x  这个取的是key的最小值
print(min(dic,key=lambda k:dic[k]))  # z   # 这个取的是value最小值的那个keyprint(max([-11,1,21,-31],key=abs))   # -31    # 比较谁的绝对值最大   abs 内置函数取绝对值# sorted 与 匿名函数的运用
salaries={'egon':3000,'alex':100000000,'wupeiqi':10000,'yuanhao':2000
}# 将姓名已工资排序
print(sorted(salaries,key=lambda k:salaries[k]))   # 默认升序
# ['yuanhao', 'egon', 'wupeiqi', 'alex']
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))   # 降序了
# ['alex', 'wupeiqi', 'egon', 'yuanhao']

salaries_t = zip(salaries.keys(),salaries.values()) # 迭代器
print(salaries_t)  # <zip object at 0x0000000002502E88>
#list(salaries_t)  == >  [('egon', 3000), ('alex', 100000000), ('wupeiqi', 10000), ('yuanhao', 2000)]# zip 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表或者字典
print(sorted(salaries_t,key=lambda v:v[1]))    # 表示已每个元组的第2个数排序
# [('yuanhao', 2000), ('egon', 3000), ('wupeiqi', 10000), ('alex', 100000000)]# map 与匿名函数运用（重要）
names = [' jMZ',' jaCk  ','   jIm ']
# 将名字 转成 首字母 大写，并去除两边空格
names = map(lambda x:x.strip().title(),names)
print(list(names))
# ['Jmz', 'Jack', 'Jim']# filter与匿名函数运用    函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
names=['alex_sb','wupeiqi_sb','egon','yuanhao_sb','liuqingzheng_sb']
res=filter(lambda x:x.endswith('sb'),names)
print(list(res))print((i for i in range(10)))  # <generator object <genexpr> at 0x00000000021E00A0>  生成器

# # 数据类型函数
# set()    # 集合类型
# list()   # 列表类型
# int()    # 整型类型
# str()    # 字符串类型
# tuple()  # 元组类型
# dict()   # 字典类型
# float()  # 浮动型
# bool()   # 布尔类型
# # long()  # python 2 中有长整型类型，Python3 统一都是int类型
info = bool('1')
print(info,type(info))info1 = set(['jmz',12,('11',23,1)])    # set([元素])   每一个元素都必须是不可变类型，即可hash类型
print(info1,type(info1))info2 = str(123.1)    # 集合类型内部必须是可hash 类型，即不可变类型
print(info2,type(info2))info3 = int("1231")   # 内部必须是可以转化成整型的其他类型
print(info3,type(info3))info4 = list([1,23,34,(1,2,3)])
print(info4,type(info4))info5 = dict([('name','jmz'),('age',13)])
# info5 = dict(name='jmz',age=12)
# info5 = dict([['name','jmz'],['age',12]])
# info5 = dict({'name':'jmz','age':12})
print(info5,type(info5))info6 = tuple((1,2,3))
# info6 = tuple([1,2,3])
# info6 = tuple({1,2,3})
print(info6,type(info6))info7 = float(12)
# info7 = float('12')
print(info7,type(info7))

# # 类有关的方法
# isinstance()
# issubclass()
# hasattr()
# getattr()
# setattr()
# delattr()class A:def __init__(self):passclass A1(A):def get(self):print('A1')@staticmethoddef cat(self):print('我是静态方法')# issubclass()
if issubclass(A1,A):print('A1 是 A 的子类')# isinstance()
obj = A1()
if isinstance(obj,A1):print('obj 是 A1的实例')# hasattr()
if hasattr(A1,"get"):print('A1 存在get 方法会属性')
if hasattr(obj,"get"):print('obj实例 存在get 方法会属性')# setattr()
setattr(A1,"name","jmz")
print(A1.__dict__)
# {'__module__': '__main__', 'get': <function A1.get at 0x00000000025099D8>, '__doc__': None, 'name': 'jmz'}# getattr()
get_func = getattr(obj,"get")
get_func()
# A1# delattr
delattr(A1,"name")
print(A1.__dict__)
# {'__module__': '__main__', 'get': <function A1.get at 0x00000000021799D8>, '__doc__': None}# callable()   #  函数用于检查一个对象是否是可调用的
if not callable(obj):print('obj 实例不可再调用了')if callable(A1):print('A1 类可以调用')

# # 其他类型
# divmod()  #
# input()   # 输入数据，
# open()    # 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
# enumerate() # 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
# pow()      # 方法返回 xy（x的y次方） 的值。pow(x,y)
# sum()      # 求和 sum(iterable)  如：sum([1,2,3])
# print()    # 打印
# super()    # 用于调用父类(超类)的一个方法
# filter()   # 过滤主要与匿名函数配合使用，过滤出符合条件的数据
# len()      # 获取数据长度
# range()    # 函数可创建一个整数列表，一般用在 for 循环中。  range(start, stop[, step])
# type()     # 1 可创建类（元类中介绍），2 可返回数据类型
# format()  # 格式化数据
# map()     # 主要和内置函数一起使用，map(func,iter)
# globals() # 返回所以的全局变量
# locals()  # 返回所有的局部变量
# help()    # 函数用于查看函数或模块用途的详细说明。如：help('getattr')
# iter()    # 函数用来生成迭代器
# next()    # 返回迭代器的下一个项目。
# id()      # 返回数据的内存地址# 测试一下，未见过的
# bin()      #返回一个整数 int 或者长整数 long int 的二进制表示。
# bytearray()
# slice()
# dir()
# hex()
# hash()
# complex()
# __import__()
# compile()
# memoryview()
# round()
# zip()
# repr()
# vars()    # 函数返回对象object的属性和属性值的字典对象。
# frozenset()
# callable()
# divmod()  # 函数把除数和余数运算结果结合起来，# bin()      #返回一个整数 int 或者长整数 long int 的二进制表示。
print(bin(10))
# 0b1010
print(bin(2))
# 0b10# bytearray()   # 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
# class bytearray([source[, encoding[, errors]]])
print(bytearray([1,2,3]))
# bytearray(b'\x01\x02\x03')
print(bytearray('中国', 'utf-8'))
# bytearray(b'\xe4\xb8\xad\xe5\x9b\xbd')# slice()   # 切片
arr = range(10)
print(arr[0:5:2])
print(arr[slice(None,5,2)])
# range(0, 5, 2)  两个都一样
print(arr[5])
# 5
print(arr[slice(5)])  # ==> slice(5)  == slice(None,5)
# range(0, 5)# dir()    # 获取当前模块的属性列表。
print(dir())# hex()   # 函数用于将10进制整数转换成16进制，以字符串形式表示
print(hex(10))
# 0xa
print(hex(1))
# 0x1
print(hex(16))
# 0x10# hash()   # 用于获取取一个对象（字符串或者数值等）的哈希值。
print(hash('test'))
# -8237931458019123489
print(hash('dsjaidhadiaidhaishodiahodhaohdo'))
# -7824806465354315596
# print(hash([1,1,3]))    #  可变类型不可hash# complex()  #函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
# class complex([real[, imag]])
# real -- int, long, float或字符串；
# imag -- int, long, float；# __import__()
# 函数用于动态加载类和函数 。
# 如果一个模块经常变化就可以使用 __import__() 来动态载入。# 和Python import 导入模块用法相同
# import sys <==>sys = __import__('sys')。
# import作用:
# 导入/引入一个python标准模块，其中包括.py文件、带有__init__.py文件的目录# compile()   # 函数将一个字符串编译为字节代码。
str = 'for i in range(10):print(i)'
c = compile(str,'','exec')
exec(c)
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9# memoryview()  # 函数返回给定参数的内存查看对象(Momory view)
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])  # b
# 98
print(v[2])  # c
# 99# round()  # 方法返回浮点数x的四舍五入值。 必须是数值
print(round(2.3))
# 2
print(round(3.6))#

# zip()  # 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
data = zip([1,2,3,4],['jmz','fff'])
print(data)  # <zip object at 0x000000000233E388> 迭代器
print(list(data))
# [(1, 'jmz'), (2, 'fff')]# repr()  # 函数将对象转化为供解释器读取的形式。# vars()    # 函数返回对象object的属性和属性值的字典对象。
class test:def __init__(self,name):self.name = namedef set(self,name,value):self.name = valueprint(test.__dict__)
print(vars(test))     # 两个一样
'''{'__module__': '__main__', '__init__': <function test.__init__ at 0x00000000024D99D8>,
'set': <function test.set at 0x00000000024D9A60>, '__dict__': <attribute '__dict__' of 'test' objects>,
'__weakref__': <attribute '__weakref__' of 'test' objects>, '__doc__': None}
'''# frozenset()   # 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
a =frozenset(range(10))
print(a)
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
b = frozenset('runoob')
print(b)
# frozenset({'o', 'u', 'r', 'n', 'b'})# divmod()  # 函数把除数和余数运算结果结合起来，
# divmod(a,b)
# a: 数字
# b: 数字
print(divmod(2,4))
# (0, 2)
print(divmod(5,4))
# (1, 1)