一，列表生成式
示例一：
生成1~100的列表
生成1～100的列表
|
1
2
3
4
5
|
li
=
[]
for
i
in
range
(
1
,
101
):
li.append(i)
print
(li)
|
执行输出：
[1,2,3...]
生成python1期~11期
li = []
for i in range(1,12):
li.append('python{}期'.format(i))
print(li)
执行输出：
['python1期', 'python2期', 'python3期'...]
第二种写法
|
1
2
3
4
|
li
=
[]
for
i
in
range
(
1
,
12
):
li.append(
'python%s'
%
i)
print
(li)
|
执行输出，效果同上
推导式
上面的代码，一行搞定，用列表推到式就可以了。
用列表推到式能构建任何列表，用户别的可以构建，比如for循环
特点：
1.一行简单，感觉高端，但是不易排错
使用debug模式，每发一次查看每一个值
第一个例子：
li = [i for i in range(1,101)]
print(li)
第二个例子：
li = ['python%s期' %i for i in range(1,12)]
print(li)
循环模式
#循环模式
[经过加工的i for i in 可迭代对象]
比如python1期~python12期，是加工的也可以不加工，比如1~100
实例一：
li = [ i ** 2 for i in range(1,11) ]
print(li)
筛选模式
|
1
|
[经过加工的i
for
i
in
可迭代对象
if
条件 筛选]
|
30以内所有能被3整除的数
l3 = [i for i in range(1,31) if i % 3 == 0]
print(l3)
执行输出：
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
找到嵌套列表中名字含有两个‘e’的所有名字
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)
列表推导式，最多不超过3个for循环
判断只能用一个
常用的是列表推导式
常用的列表推导式
字典推导式
将一个字典的key和value对调
mcase = {'a':10,'b':34}
mcase_frequency = {mcase[k]:k for k in mcase}
print(mcase_frequency)
执行输出：
{10: 'a', 34: 'b'}
如果key和value 是一样的，不适合上面的代码。
计算列表中的每个值的平方，自带去重功能。
squared = {x ** 2 for x in [1,-1,2]}
print(squared)
执行输出：
{1, 4}
二，生成器表达式
l_obj = ('python%s期' % i for i in range(1,12))
print(l_obj)
执行输出
at 0x00000190FEF4C3B8>
结果是一个生成器对象
如何取值呢？
使用__next__方法
|
1
2
3
4
5
|
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__())
|
执行输出：
python1期
python2期
python3期
列表推导式：一目了然，占内存
生成器表达式： 不便看出，节省内存。
三，内置函数
什么是内置函数？就是python给你提供的，拿来直接用的函数，比如：print，input 等等。截至到python版本3.6.2，现在python一共为我们提供了68个内置函数。它们就是python提供给你直接可以拿来使用的所有函数。
✴✴✴ 表示很重要
✴ 表示一般
作用域相关
locals：函数会以字典的类型返回当前位置的全局局部变量。
globals：函数以字典的类型返回全部全局变量。
其他相关
字符串类型代码的执行 evel，exec，compile
✴✴✴eval：执行字符串类型的代码，并返回最终结果。
|
1
|
print
(
eval
(
'3+4'
))
|
执行输出： 7
|
1
2
|
ret
=
eval
(
'{"name":"老司机"}'
)
print
(ret)
|
执行输出： {'name': '老司机'}
eval 的作用相当于拨开字符串2边的引号，执行里面的代码
✴✴✴exec:执行字符串类型的代码，流程语句
|
1
|
print
(
exec
(
'3+4'
))
|
执行输出：None
|
1
2
3
4
5
6
|
ret1
=
'''
li = [1,2,3]
for i in li:
print(i)
'''
print
(
exec
(ret1))
|
执行输出：
1
2
3
None
eval和exec 功能是类似的
区别：
1.eval有返回值,exec没有没有值
2.exec适用于有流程控制的,比如for循环。eval只能做一些简单的。
compile：将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
code1 = 'for i in range(0,3):print(i)'
compile1 = compile(code1,'','exec')
exec(compile1)
执行输出：
0
1
2
compile这个函数很少用，未来几年都不会用得到
输入输出相关 input，print
✴✴✴input:函数接受一个标准输入数据，返回为 string 类型。
✴✴✴print:打印输出。
print(333,end='**')
print(666,)
执行输出：
333**666
默认是用空格拼接
sep 将每一个字符串拼接起来，这里指定使用|
|
1
|
print
(
11
,
22
,
33
, sep
=
'|'
)
|
执行输出：
11|22|33
写入文件
|
1
2
|
with
open
(
'log.txt'
,encoding
=
'utf-8'
,mode
=
'w'
) as f1:
print
(
'5555'
,
file
=
f1)
|
执行程序，查看log.txt文件内容为: 555
内存相关 hash id
✴✴✴id:用于获取对象的内存地址。
a = 123
print(id(a))
执行输出：
1640522336
✴✴✴hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
|
1
2
|
print
(
hash
(
123
))
#数字不变
print
(
hash
(
'123'
))
|
执行输出：
123
4876937547014958447
true和False 的哈希值对应1和0
|
1
2
|
print
(
hash
(
True
))
print
(
hash
(
False
))
|
执行输出：
1
0
模块相关__import__
__import__：函数用于动态加载类和函数 。
✴help：函数用于查看函数或模块用途的详细说明。
调用相关
✴✴✴callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
判断对象是否可调用的，就判断它是不是一个函数名
函数名返回True,其他，返回False
def func1():
print(555)
a = 3
f = func1
print(callable(f))
print(callable(a))
执行输出：
True
False
callable其实就是判断一个对象是否是函数，是就返回True，其他类型直接返回False
查看内置属性
✴✴✴dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
print(dir(list))
执行输出：
['__add__', '__class__', '__contains__'...]
迭代器生成器相关
✴✴✴range：函数可创建一个整数对象，一般用在 for 循环中。
✴next：内部实际使用了__next__方法，返回迭代器的下一个项目。
#首先获得Iterator对象：
it = iter([1,2,3,4,5])
#循环：
while True:
try:
#获得下一个值：
x = next(it) #next内部封装了__next__方法，都是求下一个值
print(x)
except StopIteration:
#遇到StopIteration就退出循环
break
执行输出：
1
2
3
4
5
✴iter：函数用来生成迭代器（讲一个可迭代对象，生成迭代器）。
from collections import Iterable
from collections import Iterable
l = [1,2,3]
print(isinstance(l,Iterable)) #判断是否可迭代
print(isinstance(l,Iterable)) #判断是否为可迭代器
数字相关
数据类型：
✴✴✴bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。
✴✴✴int：函数用于将一个字符串或数字转换为整型。经常用
|
1
2
3
4
|
print
(
int
())
print
(
int
(
'12'
))
print
(
int
(
3.6
))
print
(
int
(
'0100'
,base
=
2
))
# 将2进制的 0100 转化成十进制。结果为 4
|
print(int())
print(int('12'))
print(int(3.6))
print(int('0100',base=2)) #将2进制的 0100转化成十进制。结果为 4
float：函数用于将整数和字符串转换成浮点数。
complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数
将数字转换为浮点型，默认保留小数点1位
print(type(3.14))
print(float(3))
执行输出：
3.0
进制转换：
✴bin：将十进制转换成二进制并返回。
✴oct：将十进制转化成八进制字符串并返回。
✴hex：将十进制转化成十六进制字符串并返回。
print(bin(5))
print(oct(7))
print(hex(10)) #10 用a表示
执行输出：
0b101
0o7
0xa
数学运算：
✴abs：函数返回数字的绝对值。
✴divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
round：保留浮点数的小数位数，默认保留整数。
pow：求x**y次幂。（三个参数为x**y的结果对z取余）
print(abs(-20)) #绝对值
执行输出： 20
print(divmod(10,2))
执行输出：
(5, 0)
divmod 在分页功能中，会用用到此函数
print(round(3.1415))
执行输出：3
print(pow(2,3,5))
执行输出： 2
解释：这里为3个参数，2的3次方，结果为8。用8和5做除法，取余为3，最终输出3
✴✴✴sum：对可迭代对象进行求和计算（可设置初始值）。
✴✴✴min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
✴✴✴max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
|
1
|
print
(
sum
([
1
,
2
,
3
,
4
]))
|
执行输出： 10
sum最多只有2个参数
|
1
|
print
(
max
([
1
,
2
,
3
,
4
]))
|
执行输出： 4
ret = max([1,2,-5],key=abs)
print(ret)
执行输出： -5
key表示定义规则
和数据结构相关
列表和元祖
✴✴✴list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
✴✴✴tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。
相关内置函数
✴✴✴reversed：将一个序列翻转，并返回此翻转序列的迭代器。
slice：构造一个切片对象，用于列表的切片。
|
1
2
3
|
ite
=
reversed
([
'a'
,
2
,
3
,
'c'
,
4
,
2
])
for
i
in
ite:
print
(i)
|
执行输出：
2
4
c
3
2
a
li = ['a','b','c','d','e','f','g']
sli_obj = slice(3)
print(li[sli_obj])
执行输出：
['a', 'b', 'c']
如果有10个列表，统一切前3个，sli_obj可能有点用
slice几乎用不到
slice可以定义一个切片规则
字符串相关
✴✴✴str：将数据转化成字符串。
✴✴✴format:用于格式化输出。
字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
|
1
2
3
|
print
(
format
(
'test'
,
'<20'
))
print
(
format
(
'test'
,
'>20'
))
print
(
format
(
'test'
,
'^20'
))
|
执行输出：
|
1
2
3
|
test
test
test
|
✴✴✴bytes：用于不同编码之间的转化。
编码转换，将unicode转换为utf-8
s1 = '老司机'
s2 = s1.encode('utf-8')
print(s2)
执行输出：
b'\xe8\x80\x81\xe5\x8f\xb8\xe6\x9c\xba'
第二种方法：
s1 = '老司机'
print(bytes(s1,encoding='utf-8'))
执行输出：
b'\xe8\x80\x81\xe5\x8f\xb8\xe6\x9c\xba'
bytes：只能编码，将unicode ---> 非unicode bytes(s1,encoding='utf-8')。
它不能解码
bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
bytearry很少用
|
1
2
3
4
5
6
7
|
ret
=
bytearray(
'alex'
,encoding
=
'utf-8'
)
#4个字母对应的ascii顺序[97,108,101,120]
print
(
id
(ret))
print
(ret)
print
(ret[
0
])
#97 是ascii码的顺序
ret[
0
]
=
65
#65是大写a的位置
print
(ret)
print
(
id
(ret))
|
执行输出：
2177653717736
bytearray(b'alex')
97
bytearray(b'Alex')
2177653717736
memoryview：本函数是返回对象obj的内存查看对象。所谓内存查看对象，就是对象符合缓冲区协议的对象，为了给别的代码使用缓冲区里的数据，而不必拷贝，就可以直接使用。
|
1
2
3
4
5
6
|
ret
=
memoryview(bytes(
'你好'
,encoding
=
'utf-8'
))
print
(
len
(ret))
# 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'
))
|
执行输出：
6
你
好
b'\xe4\xbd\xa0\xe5\xa5\xbd'
✴ord:输入字符找该字符编码的位置
✴chr:输入位置数字找出其对应的字符
ascii:是ascii码中的返回该值，不是就返回\u...
|
1
2
3
4
|
print
(
ord
(
'a'
))
#ascii码的位置
print
(
chr
(
98
))
#98对应a
print
(
ord
(
'中'
))
#按照unicode查找
print
(ascii(
'中'
))
#不是ascii码就返回\u...
|
执行输出：
97
b
20013
'\u4e2d'
#%r 原封不动的写出来
name = 'taibai'
print('我叫%r' % name)
#repr原形毕露
print(repr('{"name":"alex"}'))
print('{"name":"alex"}')
执行输出：
我叫'taibai'
'{"name":"alex"}'
{"name":"alex"}
repr在面向对象中会用到
数据集合
✴✴✴dict：创建一个字典。
✴✴✴set：创建一个集合。
frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
相关内置函数
✴✴✴len:返回一个对象中元素的个数。
✴✴✴sorted：对所有可迭代的对象进行排序操作。
li = [1,2,3,4,5,6,7,8]
print(sorted(li))
执行输出：
[1, 2, 3, 4, 5, 7, 8]
按照绝对值排序
|
1
2
|
li
=
[
1
,
-
2
,
-
7
,
8
,
5
,
-
4
,
3
]
print
(
sorted
(li,reverse
=
True
,key
=
abs
))
|
执行输出：
[8, -7, 5, -4, 3, -2, 1]
#enumerate 枚举，返回一个枚举对象
li = ['jack', 'rose', 'wusir', '嫂子', '老司机']
print(enumerate(li))
print('__iter__' in dir(enumerate(li)))
print('__next__' in dir(enumerate(li)))
执行输出：
True
True
enumerate是一个迭代器
|
1
2
3
|
li
=
[
'jack'
,
'rose'
,
'wusir'
,
'嫂子'
,
'老司机'
]
for
i
in
enumerate
(li):
print
(i)
|
执行输出：
(0, 'jack')
(1, 'rose')
(2, 'wusir')
(3, '嫂子')
(4, '老司机')
返回结果为：列表元素的索引以及对应的值
|
1
2
3
|
li
=
[
'jack'
,
'rose'
,
'wusir'
,
'嫂子'
,
'老司机'
]
for
k,v
in
enumerate
(li):
print
(k,v)
|
执行输出：
0 jack
1 rose
2 wusir
3 嫂子
4 老司机
enumerate的第2个参数，表示从多少开始。默认从1开始
|
1
2
3
|
li
=
[
'jack'
,
'rose'
,
'wusir'
,
'嫂子'
,
'老司机'
]
for
k,v
in
enumerate
(li,
10
):
print
(k,v)
|
执行输出：
10 jack
11 rose
12 wusir
13 嫂子
14 老司机
✴all：可迭代对象中，全都是True才是True
✴any：可迭代对象中，有一个True 就是True
print(all([1,2,True,0]))
print(any([1,'',0]))
执行输出：
False
True
✴✴✴zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
print
(
'__iter__'
in
dir
(
zip
(l1,l2,l3,l4)))
print
(
'__next__'
in
dir
(
zip
(l1,l2,l3,l4)))
|
执行输出：
True
True
zip也是一个迭代器
zip 拉链方法 形成元组的个数与最短的可迭代对象的长度一样
|
1
2
3
4
5
6
|
l1
=
[
1
,
2
,
3
,
4
]
l2
=
[
'a'
,
'b'
,
'c'
,
5
]
l3
=
(
'*'
,
'**'
, (
1
,
2
,
3
),
777
)
z
=
zip
(l1,l2,l3)
for
i
in
z:
print
(i)
|
执行输出：
(1, 'a', '*')
(2, 'b', '**')
(3, 'c', (1, 2, 3))
(4, 5, 777)
我们把list当做列向量来看就很好理解了，zip就是拉链，把一件挂着的衣服拉起来。这就是zip的功能。所以
当做列向量看，就是拉起来的拉链了。
而转置的z就是把拉链放水平，多形象！
zip结果取决于最短的一个,返回的数据是元组
面试题，必考zip
✴✴✴filter：过滤·。
filter 过滤 通过你的函数，过滤一个可迭代对象，返回的是True
类似于[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])
print(ret)
for i in ret:
print(i) 执行输出：
2
4
6
使用列表生成式完成上面的功能
li = [i for i in [1,2,3,4,5,6,7] if i % 2 == 0]
print(li)
执行输出，效果同上
✴✴✴map:会根据提供的函数对指定序列做映射。
map相当于列表生成式循环模式
def square(x): #计算平方数
return x ** 2
ret = map(square,(1,2,3,4,5))
for i in ret:
print(i) 执行输出：
1
4
9
16
25
map也是迭代器
匿名函数
匿名函数：为了解决那些功能很简单的需求而设计的一句话函数。
返回一个数的平方
使用函数方式
def func1(x)
return x ** 2
使用匿名函数一行搞定
func = lambda x:x ** 2
print(func(5))
执行输出：25
上面是我们对calc这个匿名函数的分析，下面给出了一个关于匿名函数格式的说明
|
1
2
3
4
5
|
函数名
=
lambda
参数 ：返回值
#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型
|
def func2(x+y):
return x + y
改成匿名函数
fun = lambda x,y:x+y
print(fun(1,3))
执行输出：4
lambda单独拿出来，没有啥意义
主要是和内置函数结合使用
lambda函数与内置函数的结合
sorted, map, fiter, max, min, reversed
比较字典值的大小，并输出key的值
|
1
2
|
dic
=
{
'k1'
:
10
,
'k2'
:
100
,
'k3'
:
30
}
print
(
max
(dic, key
=
lambda
x: dic[x]))
|
执行输出： k2