day14,列表推导式，生成器表达式，内置函数

Posted 2020-10-29 zzw731862651

一、列表推导式、生成器表达式：

# li = []
# for i in range(1,101):
#     li.append(i)
# print(li)


#l1 = [python1期，python2期，python3期.....]
# l1 = []
# for i in range(1,12):
#     l1.append(‘python%s期‘ % i)
# print(l1)
#一行搞定，列表推导式：用列表推导式能够构建的任何列表，用别的都可以构建。
#一行，简单，感觉高端。但是，不易排错。
# li = [i for i in range(1,101)]
# print(li)
# l2 = [‘python%s期‘ % i for i in range(1,12)]
# print(l2)
#循环模式
#[经过加工的i for i in 可迭代对象]

l_obj = (‘python%s期‘ % i for i in range(1,12))
print(l_obj)
print(l_obj.__next__())
print(l_obj.__next__())
print(l_obj.__next__())

#列表推导式：一目了然，占内存。
#生成器表达式：不易看出，节省内容。

#循环模式
#[经过加工的i for i in 可迭代对象]
# l2 = [i*i for i in range(1,11)]
# print(l2)
#筛选模式
#[经过加工的i for i in 可迭代对象 if 条件 筛选]
# l3 = [i for i in range(1,101) if i % 3 == 0]
# print(l3)

# l3 = [i for i in range(31) if i % 3 == 0]
# print(l3)
#
# l3 = [i**2 for i in range(31) if i % 3 == 0]
# print(l3)

# names = [[‘Tom‘, ‘Billy‘, ‘Jefferson‘, ‘Andrew‘, ‘Wesley‘, ‘Steven‘, ‘Joe‘],
#          [‘Alice‘, ‘Jill‘, ‘Ana‘, ‘Wendy‘, ‘Jennifer‘, ‘Sherry‘, ‘Eva‘]]
#
# l4 = [name for i in names for name in i if name.count(‘e‘) == 2]
# print(l4)

# mcase = {‘a‘: 10, ‘b‘: 34}
# mcase_frequency = {mcase[k]: k for k in mcase}
# print(mcase_frequency)

squared = list({x**2 for x in [1, -1, 2]})
print(squared)


二、内置函数：

"""
len()
count()
print()
max()
min()
dir()
list()
eval()
open()
str()
isinstance()
format()
type()
tuple()
iter()
input()
int()
set()
frozenset()
"""
#其他相关：
#***eval:执行字符串类型的代码，并返回最终结果
# print(eval(‘3 +4‘))

# ret = eval(‘{"name":"老男孩"}‘)

# print(ret,type(ret))

# print(eval(‘3+4‘))

# ret = eval(‘{"name":"老男孩"}‘)

# print(ret,type(ret))

#***exec:执行字符串类型的代码,流程语句。
# ret1 = ‘‘‘
# li = [1,2,3]
# for i in li:
#     print(i)
# ‘‘‘

# print(exec(‘3 +4‘))

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

# compile1 = compile(code1,‘‘,‘exec‘)
# exec (compile1)

#***print()
#print(self, *args, sep=‘ ‘, end=‘\n‘, file=None)
# print(333,end=‘‘)
# print(666,)
# print(111,222,333,sep=‘|‘)

# with open(‘log‘,encoding=‘utf-8‘,mode=‘a‘) as f1:
#     print(‘5555‘,file=f1)

#*hash哈希
# print(hash(12322))  # 数字不变

# print(hash(‘123‘))   #是个地址

# print(hash(‘arg‘))    #是个地址

# print(hash(‘alex‘))  #是个地址

# print(hash(True))    #1
# print(hash(False))    #0

# print(hash((1,2,3)))    #地址


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


#***callable：函数用于检查一个对象是否是可调用的。
# 如果返回True，object仍然可能调用失败；
# 但如果返回False，调用对象ojbect绝对不会成功。
# def func1():
#     print(555)
# a = 5
# f = func1

# print(callable(f))
# print(callable(a))


#***dir
# print(dir(list))



# *next
# 首先获得Iterator对象:
# it = iter([1, 2, 3, 4, 5])
# # 循环:
# while True:
#     try:
#         # 获得下一个值:
#         x = next(it)
#         print(x)
#     except StopIteration:
#         # 遇到StopIteration就退出循环
#         break
#*iter()



# *int
# print(int())  # 0

# print(int(‘12‘))  # 12
#
# print(int(3.6))  # 3
#
# print(int(‘0100‘,base=2))  # 将2进制的 0100 转化成十进制。结果为 4


# print(type(3.14))  # float

# print(float(3))

‘‘‘

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

‘‘‘
*bin：将十进制转换成二进制并返回。

*oct：将十进制转化成八进制字符串并返回。

*hex：将十进制转化成十六进制字符串并返回。
‘‘‘
# print(bin(5))  # 0b101

# print(oct(7))  # 0o7

# print(oct(9))  # 0o11

# print(hex(10))  # 0xa

# print(hex(15))  # 0xf
# print(hex(19))  # 0x13

#*abs：函数返回数字的绝对值。
# print(abs(-20))


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

#round：保留浮点数的小数位数，默认保留整数。
# print(round(3.1415))

# print(round(3.1415,3))

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

# print(pow(2,3,5))

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

# print(sum([1,2,3],100))

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

# ret = max([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最大值
# print(ret)

#***min
# ret = min([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最小值
# print(ret)

#***reversed：将一个序列翻转，并返回此翻转序列的迭代器。
ite = reversed([‘a‘,2,3,‘c‘,4,2])
# print(ite)
# for i in ite:
#     print(i)

#slice：构造一个切片对象，用于列表的切片。

# li = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,‘g‘]
# l2 = [‘a‘,‘b‘,‘c‘,1,2,3,4,54]
# sli_obj = slice(3)
# print(li[sli_obj])
# print(l2[sli_obj])

# sli_obj = slice(7,0,-2)
# print(li[sli_obj])

#*** 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(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码中的返回该值，不是就返回
‘‘‘
# print(ord(‘a‘))

# print(ord(‘中‘))

# print(chr(98))

# print(chr(20013))

# print(ascii(‘a‘))

# print(ascii(‘中‘))  # ‘\u4e2d‘

# %r  原封不动的写出来
name = ‘taibai‘
# print(‘我叫%r‘ % name)

#*** repr 原形毕露
# print(repr(‘{"name":"alex"}‘))

# print(‘{"name":"alex"}‘)

# *** sorted  key

li = [1,-2,-7,8,5,-4,3]
# print(sorted(li,reverse=True,key=abs))


L = [(‘a‘, 1), (‘c‘, 3), (‘d‘, 4),(‘b‘, 2), ]
# sorted(L, key=lambda x:x[1])               # 利用key

# *** enumerate:枚举，返回一个枚举对象。 (0, seq[0]), (1, seq[1]), (2, seq[2]),

# li = [‘老男孩‘, ‘alex‘, ‘wusir‘, ‘嫂子‘, ‘taibai‘]
# print(enumerate(li))
# for i in enumerate(li):
#     print(i)   #打印出来是字符串

# print(‘__iter__‘ in dir(enumerate(li)))
# print(‘__next__‘ in dir(enumerate(li)))
# li = [‘老男孩‘, ‘alex‘, ‘wusir‘, ‘嫂子‘, ‘taibai‘]
# for k,v in enumerate(li):
#     print(k,v)


# 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)


#***filter 过滤 通过你的函数，过滤一个可迭代对象，返回的是True
# 类似于[i for i in range(10) if i > 3]
# 列表推导式：
# l=[i for i in range(0,10) if i > 3]
# print(l)


# def func(x):
#     return x % 2 == 0
# ret = filter(func,[1,2,3,4,5,6,7])
# print(ret)
# for i in ret:
#     print(i)


# 例题，将列表中大于10的数都打印出来
# l = [1,2,43,54,34,23]
# 方法一：filter
# ret = filter(lambda x: x>10,l)
# for i in ret:
#     print(i)
#方法二：列表推导式
# l1=[i for i in l if i >10]
# print(l1)

# li = [i for i in [1,2,3,4,5,6,7] if i % 2 == 0]
# print(li)

#***map很重要，for循环
# 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)