关键词：
一、列表推导式、生成器表达式：
# 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)
三元表达式列表推导式生成器表达式递归匿名函数内置函数
介绍三元表达式、列表推导式、生成器表达式递归与二分法匿名函数一、三元表达式、列表推导式、生成器表达式 1.1三元表达式（三目运算）格式：[为真时的结果if判定条件else为假时的结果]name=input(‘姓名>>:‘)res=‘SB... 查看详情
三元表达式列表推导式生成器表达式递归匿名函数内置函数
一三元表达式、列表推导式、生成器表达式 1、三元表达式name=input(‘姓名>>:‘)res=‘SB‘ifname==‘alex‘else‘NB‘print(res) 2、列表推导式#1、示例egg_list=[]foriinrange(10):egg_list.append(‘鸡蛋%s‘%i)egg_list=[‘鸡蛋%s‘%iforiinrange... 查看详情
列表推导式,生成器表达式,内置函数(代码片段)
找到嵌套列表中名字含有两个‘e‘的所有名字1names=[[‘Tom‘,‘Billy‘,‘Jefferson‘,‘Andrew‘,‘Wesley‘,‘Steven‘,‘Joe‘],2[‘Alice‘,‘Jill‘,‘Ana‘,‘Wendy‘,‘Jennifer‘,‘Sherry‘,‘Eva‘]]3l4=[nameforiinnamesfornameiniifname.count(‘e‘)==2]4 查看详情
(列表推导式,生成器表达式,内置函数)(代码片段)
一，列表生成式示例一：生成1~100的列表生成1～100的列表12345li = []for i in range(1,101): li.append(i) print(li)执行输出：[1,2,3...] 生成python1期~11期li=[]foriinrange(1,12):l 查看详情
三元表达式列表推导式生成器表达式递归内置函数匿名函数(代码片段)
...es=‘SB‘ifname==‘alex‘else‘NB‘print(res)二、列表推导式和生成器表达式#老男孩由于峰哥的强势加盟很快走上了上市之路,alex思来想去决定下几个鸡蛋来报答峰哥egg_list=[‘鸡蛋%s‘%iforiinrange(10)]#列表解析#峰哥瞅着alex下的一筐鸡蛋... 查看详情
三元表达式列表推导式生成器表达式递归匿名函数内置函数(代码片段)
一三元表达式、列表推导式、生成器表达式一三元表达式name=input(‘姓名>>:‘)res=‘SB‘ifname==‘alex‘else‘NB‘print(res)#1、示例egg_list=[]foriinrange(10):egg_list.append(‘鸡蛋%s‘%i)egg_list=[‘鸡蛋%s‘%iforiinrange(10)]#2、语法[expressionforit... 查看详情
十内置函数
列表和生成器表达式#一行搞定，列表推导式：用列表推导式能够构建的任何列表，用别的都可以构建。#一行，简单，感觉高端。但是，不易排错。#li=[iforiinrange(1,101)]#print(li)#l2=[‘python%s期‘%iforiinrange(1,12)]列表生成表达式#print(l... 查看详情
12练习题：生成器列表推导式内置函数ⅰ
#用列表推导式做下列小题#1.过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母l1=[‘string‘,‘str‘,‘st‘]li=[i.upper()foriinl1iflen(i)<3]#2.求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元祖列表li=[(x,y)forxinrange(0,6,2)f... 查看详情
day4-函数进阶
目录：一、迭代器二、生成器三、面向过程编程四、三元表达式、列表推导式、生成器表达式五、第归与二分法六、匿名函数七、内置函数练习一、迭代器一、迭代的概念#迭代器即迭代的工具，那什么是迭代呢？#迭代是一个重... 查看详情
函数之三元表达式，递归，匿名函数，内置函数(代码片段)
...xelse:returnyres=xifx>yelsey#三元表达式print(res)列表推导式，生成器表达式 #列表推导式egg_list=[]foriinrange(10):egg_list.append(‘鸡蛋%s‘%i)egg_list=[‘鸡蛋%s‘%iforiin 查看详情
day23面向对象
...#函数的命名空间和作用域#内置函数#闭包：装饰器函数#生成器函数：生成器表达式，各种推导式，迭代器#匿名函数#递归函数：二分查找算法#作业1#基础数据类型#文件操作#函数# 查看详情
生成器列表推导式生成器表达式(代码片段)
知识要点：1、生成器定义：就是自己用Python代码写的迭代器，生成器的本质就是迭代器。可以用以下两种方法构建一个生成器：1、通过生成器函数2、生成器表达式 一、生成器函数：我们之前学的一般的函数：deffun(x):x+=1retu... 查看详情
各种推导式玩法(代码片段)
推导式套路之前我们已经学习了最简单的列表推导式和生成器表达式。但是除此之外，其实还有字典推导式、集合推导式等等。下面是一个以列表推导式为例的推导式详细格式，同样适用于其他推导式。variable=[out_exp_resforout_expin... 查看详情
生成器的表达式列表推导式
列表推导式egg_list=["鸡蛋%s"%iforiinrang(10)]print(egg_list) 生成器表达式g=(iforiinrange(10))#生成器foriing: print(i) #这两个的不同 括号不一样，返回值不一样，生成器表达式不占用内存1.列表推导式["一个或者多个元素操作"for... 查看详情
python--demo13--高级特性匿名函数推导式迭代器生成器(代码片段)
学完函数，我们还需要知道一些让我们能够提高效率的高级特性：使用lambda关键字来创建匿名函数：lambda表达式只是一个表达式，而不是是一个代码块，函数体比def简单很多；lambda表达式仅仅能够封装一些简单的逻辑；lambda表达... 查看详情
2.2.2生成器推导式(代码片段)
从形式上看，生成器推导式与列表推导式非常接近，只是生成器推导式使用圆括号而不是列表推导式使用的方括号。与列表推导式不同的是，生成器推导式的结果是一个生成器对象，而不是列表，也不是元组。使用生成器对... 查看详情
列表推导式生成器表达式(代码片段)
...导的作用：生成列表，如果要生成其他类型的数据，使用生成器表达式#生成器表达式：生成器表达式遵循了迭代器协议，元素是逐一生成的，而不是和列表推导一样一次性生成完整的数据集，这样的方式效率较高，并且节省了... 查看详情
python入门-4控制语句：10推导式创建序列-列表推导式-字典推导式-集合推导式-生成器推导式(代码片段)
推导式创建序列： 推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合，从而避免冗长的代码。推导式是典型的Python风格，会使用它代表你已经超过Python初学者的水平。一：列表推导式 ... 查看详情