python基础-day14

# 列表推导式！！！
l = [i for i in range(10)]
print(l)    #打印结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l = (i for i in range(10))
print(l)    #打印结果：<generator object <genexpr> at 0x0000019A903FCF10>
#中括号代表的是列表推导式
#员括弧代表的是生成器表达式，这种方式更加省内存些，
#上面是列表推导式，
#其实还有字典推导式，集合推导式，不过这两种几乎不用，
#用推导式的方式，坏处就是不易排错，因为都写在一起了，


names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
         ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
print([name for lst in names for name in lst if name.count('e') >= 2 ])
#运行结果：['Jefferson', 'Wesley', 'Steven', 'Jennifer']
#我们要关注的是这个复合的用法，以及if判断！！！后面应该是不能加else等...



mcase = {'a': 10, 'b': 34}
mcase_frequency = {mcase[k]: k for k in mcase}
print(mcase_frequency)
#这个怎么换的有点看不明白，可能和a，b = b，a互换相似吧？？？


mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys()}
print(mcase_frequency)
#这个有点怪，我就解释下吧，小写a对应10，大写A对应7，所以10+7=17，
#小写b对应34，没有大写B，所以34+0=34

开始内置函数了啊，老长老长了，

"""
len()
count()
print()
max()
min()
dir()
list()
eval()
open()
str()
isinstance()
format()
type()
tuple()
iter()
input()
int()
set()
frozenset()
"""
# def eval(*args, **kwargs):#执行字符串类型的代码，并返回最终结果#侧重点在求值
print(eval('2+2'))  #打印4
eval('print(666)')  #打印666

#def exec(*args, **kwargs):执行字符串类型的代码,流程语句。#侧重点在执行，
ret1 = '''
li = [1,2,3]
for i in li:
    print(i)
'''
print(exec(ret1))

#compile:将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
#compile() 函数将一个字符串编译为字节代码。
code1 = 'for i in range(0,10): print (i)'
compile1 = compile(code1,'','exec')
exec (compile1)

# def print(self, *args, sep=' ', end='\n', file=None):
with open('log',encoding='utf-8',mode='a') as f1:
    print('5555',file=f1)   #打印的5555也会被写入f1对应的文件，

#def hash(*args, **kwargs):
print(hash(12322))  # 数字不变



#def help():：函数用于查看函数或模块用途的详细说明。
print(help(list))

#callable：函数用于检查一个对象是否是可调用的。
# 如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
# def callable(i_e_, some_kind_of_function):  # real signature unknown; restored from __doc__
#     """
#     Return whether the object is callable (i.e., some kind of function).
#
#     Note that classes are callable, as are instances of classes with a
#     __call__() method.
#     """
#     pass
def func1():
    print(555)
a = 3
f = func1
print(callable(f))  #打印：True，这个是函数，function，
print(callable(a))  #打印：False，而这个不是，function，


#def dir(p_object=None):
print(dir(list))

# def next(iterator, default=None): #内部实际使用了__next__方法，返回迭代器的下一个项目。
it = iter([1, 2, 3, 4, 5])
# # 循环:
while True:
    try:
        x = next(it)
        print(x)
    except StopIteration:
        break

# def iter(source, sentinel=None):

#int
print(int())  # 0
print(int('0100',base=2))  # 将2进制的 0100 转化成十进制。结果为 4


# type
print(type(3.14))

#float
print(float(3))

#complex
# complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
# 如果第一个参数为字符串，则不需要指定第二个参数
complex(3,4)



#def bin(*args, **kwargs):
#def oct(*args, **kwargs):
#def hex(*args, **kwargs):
print(bin(5))  # 0b101
print(oct(7))  # 0o7
print(hex(10))  # 0xa


# def abs(*args, **kwargs): 函数返回数字的绝对值。
print(abs(-20))

# def divmod(x, y): 计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
print(divmod(11,3))  # (3, 1)

#def round(number, ndigits=None):保留浮点数的小数位数，默认保留整数。
print(round(3.1415,3))


# def pow(*args, **kwargs): 求x**y次幂。（三个参数为x**y的结果对z取余）
print(pow(2,3,5))

# def sum(*args, **kwargs):对可迭代对象进行求和计算（可设置初始值）。
print(sum([1,2,3],100))

#def max(*args, key=None):返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
print(max([1,2,3]))

# def min(*args, key=None):
ret = min([1,2,-5,],key=abs)


# class reversed(object):将一个序列翻转，并返回此翻转序列的迭代器。
ite = reversed(['a',2,3,'c',4,2])


#slice：构造一个切片对象，用于列表的切片。
li = ['a','b','c','d','e','f','g']
l2 = ['a','b','c',1,2,3,4,54]
sli_obj = slice(3)  #切前3个元素


#format 用于格式化输出很重要，数字是用于设定宽度，<代表坐对齐，>代表右对齐,^代表居中对齐，
s1 = format('test', '<30')
print(format('test', '<30'))
print(format('test', '>20'))
print(format('test', '^20'))
print(len(s1))


#bytes：只能编码，将unicode ---> 非unicode  bytes(s1,encoding='utf-8')
s1 = '老男孩'
s2 = s1.encode('utf-8')
s22 = bytes(s1,encoding='utf-8')
print(s2)
print(s22)
print(s2.decode('utf-8'))


#bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
#看看运行结果就明白了，
ret = bytearray('alex',encoding='utf-8')  # [65,108,101,120]
print(id(ret))
print(ret)
print(ret[0])  # 97
ret[0] = 65
print(ret)
ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret))  # 6 utf-8的bytes类型，放在一个list中 [\xe4,\xbd,\xa0,\xe5,\xa5,\xbd]
print(ret)
print(bytes(ret[:3]).decode('utf-8'))
print(bytes(ret[3:]).decode('utf-8'))
print('你好'.encode('utf-8'))


'''
*ord:输入字符找该字符编码的位置 unicode
*chr:输入位置数字找出其对应的字符 unicode
ascii:是ascii码中的返回该值，不是就返回
ps：自己看运行结果吧，不想多解释
'''
print(ord('a'))
print(ord('中'))
print(chr(98))
print(chr(20013))
print(ascii('a'))
print(ascii('中'))  # '\u4e2d'


# %r原封不动的写出来，\n，就直接打印出来，而不是换行，
name = 'taibai'
print('我叫%r' % name)    #打印结果：我叫'taibai'
print(repr('{"name":"alex"}'))      #打印：'{"name":"alex"}'
print('{"name":"alex"}')        #打印：{"name":"alex"}


#def sorted(*args, **kwargs):
li = [1,-2,-7,8,5,-4,3]
print(sorted(li,reverse=True,key=abs))      #key可以利用lambda表达式，
L = [('a', 1), ('c', 3), ('d', 4),('b', 2), ]
sorted(L, key=lambda x:x[1])               # 利用key


#enumerate:枚举，返回一个枚举对象,简单的说，就是为你提供的数据增加一个数字的标签，枚举中的每个元素都是元组，
li = ['老男孩', 'alex', 'wusir', '嫂子', 'taibai']
print(enumerate(li))
print('__iter__' in dir(enumerate(li)))
print('__next__' in dir(enumerate(li)))
for k,v in enumerate(li,1):
    print(k,v)

# * all  可迭代对象中，全都是True才是True
# * any  可迭代对象中，有一个True 就是True
print(all([1,2,True,0]))
print(any([1,'',0]))


#zip 拉链方法，我基本上把打印结果的规律，用下面四个数据的排班，表现出来了，
#元素中个数最少的的个数，就是最终打印结果的个数，
l1 = [ 1,    2,    3,      4]
l2 = ['a', 'b',  'c',     5]
l3 = ('*', '**', (1,2,3), 777)
l4=  ('0', '99', (1,2,3), 777)
print('__iter__' in dir(zip(l1,l2,l3,l4)))
print('__next__' in dir(zip(l1,l2,l3,l4)))
for i in zip(l1,l2,l3,l4):
    print(i)

#class filter(object):以你提供的函数为条件，过滤可迭代对象，
# 类似于[i for i in range(10) if i > 3]
def func(x):
    return x % 2 == 0
ret = filter(func,[1,2,3,4,5,6,7])


# map，根据前面提供的函数，对后面提供的数据处理后，进行映射，
#后面提供的数据，可以是2个列表，其它情况还没试，
def square(x) :            # 计算平方数
    return x ** 2
print(map(square,[1,2,3,4,5]))
for i in map(square,[1,2,3,4,5]):
    print(i)


#匿名函数，特别简单的函数，完全可以用一句话写出来的，就用这个，
func = lambda x:x**2
func = lambda x,y: x if x > y else y


#lambda 函数与内置函数的结合，sorted，map，fiter，max，min，reversed
res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)