文末有福利领取哦~
👉一、Python所有方向的学习路线
Python所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照上面的知识点去找对应的学习资源,保证自己学得较为全面。
👉二、Python必备开发工具
👉三、Python视频合集
观看零基础学习视频,看视频学习是最快捷也是最有效果的方式,跟着视频中老师的思路,从基础到深入,还是很容易入门的。
👉 四、实战案例
光学理论是没用的,要学会跟着一起敲,要动手实操,才能将自己的所学运用到实际当中去,这时候可以搞点实战案例来学习。(文末领读者福利)
👉五、Python练习题
检查学习结果。
👉六、面试资料
我们学习Python必然是为了找到高薪的工作,下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料,并且有阿里大佬给出了权威的解答,刷完这一套面试资料相信大家都能找到满意的工作。
👉因篇幅有限,仅展示部分资料,这份完整版的Python全套学习资料已经上传
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
l = ['a', 'c', 'b', 'd']
l.sort()
print(l) # ['a', 'b', 'c', 'd']
l.sort(reverse=True)
print(l) # ['d', 'c', 'b', 'a']
我们来看看key参数怎么使用:
l = ['abc', 'cae', 'edg', 'ffh']
l.sort(key=lambda x: x[1])
print(l) # ['cae', 'abc', 'edg', 'ffh']
通过key指定以每个元素中的索引为1的元素排序。
需要补充的是sorted(key=None, reverse=False)函数,它是Python内置的对于所有序列类型进行排序的函数,而不像sort()方法是列表独有的排序方法。
二者区别是:
- sort方法仅能对列表进行原地排序,没有返回值。
- sorted函数对所有序列类型进行排序,并且并不是原地排序,它会返回排序结果,也就是说我们可以通过一个变量接收排序结果。
需要注意的是,无论使用哪种排序方式,排序对象必须是同类型的,也就是说,如果排序对象是列表,那么列表内的元素都为同一类型,因为不同类型无法比较。
转换为字符串
3. 列表的嵌套
如果嵌套层数过多,可以使用递归的方法,扩展项
前文介绍列表时说的元素类型丰富,就是说列表不仅能存储数字、字符串,还能存储列表。
>>> l = [1, 2, [3, 4]]
>>> for i in l:
... print(i)
...
1
2
[3, 4]
>>> l[2]
[3, 4]
>>> l[2].pop()
4
>>> l
[1, 2, [3]]
>>> l[2].insert(0,'a')
>>> l
[1, 2, ['a', 3]]
可以看到,列表对嵌套部分处理也同样的简单,可以使用我们学过的方法, 不仅如此,列表还可以存储别的数据结构,如字典、元组、集合。
>>> l = [1,(2, 3), [4,[5, 6]], {'a':'b'}, {7, 8}]
>>> for i in l:
... print(i)
...
1
(2, 3)
[4, [5, 6]]
{'a': 'b'}
{8, 7}
>>> l[1][1]
3
>>> l[2][1][1] = 'c'
>>> l[3]['a']
'b'
>>> l[-1]
{8, 7}
>>> l
[1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7}]
先不管元组、字典、集合的是什么。但并不推荐这么用,因为这样操作起来太不方便,只是演示列表可以各种嵌套,一般使用中,更多的是嵌套一种数据类型,如列表嵌套元组,列表嵌套字典,但很少有同时嵌套元组和字典的。
那么,我们如何展示列表中的所有元素呢?这里我们可以使用嵌套循环完成。
>>> for i in [1, [2, 3], 4]:
... if isinstance(i, list):
... for j in i:
... print(j)
... else:
... print(i)
...
1
2
3
4
上例中,第1行for循环列表,第2行判断每次循环中的元素是否为列表,如果是列表,那么就再用for循环循环打印其内的列表中的元素。否则执行第5行的else语句直接打印列表内的元素。
需要强调的是,Python中并没有二维数组的概念,但是列表嵌套列表同样能够达到相同的目的
4.元组tuple
资料链接:https://www.cnblogs.com/Neeo/articles/11212374.html
Python的元组与列表类似,不同之处在于元组的元素不能修改。
元组使用小括号,列表使用方括号。
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
创建空元组
tup1 = ()
元组中只包含一个元素时,需要在元素后面添加逗号
tup1 = (50,)
元组与字符串类似,下标索引从0开始,可以进行截取,组合等。
4.1 元组的基本操作
创建元组
Python中,元组(tuple)用一对小括号
()
表示,元组内的各元素以逗号分隔。
t = ()
print(type(t)) # <type 'tuple'>
t1 = ('name', )
print(t1) # ('name',)
print(type(t1)) # <type 'tuple'>
元组中特别注意逗号的使用,一不小心创建的元组就会成为字符串。
t = ('name')
print(t, type(t)) # ('name', <type 'str'>)
t1 = ('name', )
print(t1, type(t1)) # (('name',), <type 'tuple'>)
索引和切片
元组中索引和切片的用法跟列表和字符串类似,或者取范围内的值,或者可以指定在一段范围内,每几个取一个:
t = ('a', 'b', 'c', 'd', 'e')
# 按照索引取值
print(t[1]) # b
print(t[-1]) # e
# 取两者之间(范围)的值
print(t[0:4]) # ('a', 'b', 'c', 'd')
print(t[0:5:2]) # ('a', 'c', 'e')
# 反转元组,返回反转后的新的元组,原本的元组不变
print(t[::-1]) # ('e', 'd', 'c', 'b', 'a')
# for循环取值
for i in t:
print(i)
'''
a
b
c
d
e
'''
但与列表不同的是,元组身为不可变类型,无法原地修改其中的值。
t = ('a', 'b', 'c', 'd', 'e')
t[2] = 'w'
'''
TypeError: 'tuple' object does not support item assignment
'''
拼接: +
虽然元组无法原地修改其中的元素,但是,通过
+
号可以把两个元组合并为一个新的元组。
t1 = ('a', 'b')
t2 = ('c', 'd', 'e')
t3 = t1 + t2
print(t3) # ('a', 'b', 'c', 'd', 'e')
元组的重复:*
简单来说,正如字符串的重复一样,当对元组使用
*
时,复制指定次数后合并为一个新的元组。
t1 = ('a', 'b')
t2 = t1 \* 2
print(t2) # ('a', 'b', 'a', 'b')
成员资格测试: in,not in
与字符串、列表的成员资格测试在元组中同样适用:
t1 = ('a', 'b', 'abc')
print('a' in t1) # True
print('b' not in t1) # False
需要注意的是,成员资格判断,只是会判断某个元素是否存是元组的一级元素,比如上例中的
a
是元组的一级元素。而c
不是元组的一级元素。在元组中,c
是元组一级元素字符串abc
的子串。所以判断结果为False。
序列(元组)类型的打包与解包
t = 1, 2, 3
x, y, z = t
print(x, y, z) # 1 2 3
上例第1行,将1、2、3打包赋值给变量t,相当于将3个苹果打包到一个盒子内。第2行,从盒子t中将3个苹果取出来,分别交给x、y、z,我们称为解包。解包这里需要注意的是,盒子里有几个苹果,必须有几个对应的变量接收。多了不行,少了也不行。
平行赋值
>>> x, y = 1, 2
>>> x,y
(1, 2)
>>> x
1
>>> type(x)
<class 'int'>
>>> a = x,y
>>> a
(1, 2)
>>> type(a)
<class 'tuple'>
如上例第1行所示,平行赋值就是等号右边的1,2分别赋值给等号左边的x,y。第2行就是打包了(只是打包,并没有赋值给某个变量),并且打包后的结果是元组类型。而在第8行将x,y打包并赋值给变量a。此时a就是打包后的元组了。
通过打印斐波那契序列来练习平行赋值:
x, y = 0, 1
while x < 8:
x, y = y, x + y
print(x)
'''
1
1
2
3
5
8
'''
首先定义x,y两个变量并赋值。在每次循环中,x和y值都会重新赋值。
删除元组
注意,这里说的删除仅是删除整个元组,而不是删除元组中某个元素。
>>> t = (1, 2, 3)
>>> del t[1]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion
>>> del t
>>> t
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 't' is not defined
上例第2行,通过删除元组内的元素导致报错,又一次的证明元组为不可变类型。但我们可以删除整个元组(第6行)。
4.1.1 总结,元组中常用的操作符:
操作符(表达式) | 描述 | 重要程度 |
---|---|---|
+ | 合并 | ** |
* | 重复 | ** |
in | 成员资格 | **** |
for i in (1, 2, 3):print(i) | 迭代 | ***** |
t[2] | 索引取值 | ***** |
t[start:stop:step] | 切片(截取) | ***** |
另外,还有几个内置的函数可以应用于元组:
方法 | 描述 | 重要程度 |
---|---|---|
max(tuple) | 返回元组内最大的元素 | ** |
min(tuple) | 返回元组内最小的元素 | ** |
tuple(seq) | 将序列转换为元组 | ***** |
len(tuple) | 返回元组长度 | ***** |
4.2 元组的嵌套
与列表一样,元组也能嵌套存储数据:
t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
for item in t:
print(item)
'''
1
(2, 3)
[4, [5, 'c']]
{'a': 'b'}
{8, 7}
'''
元组内可以存储的数据类型相当丰富,也可以发现,嵌套元素也会当成一个整体称为元组的子元素。但是我们说元组是不可更改的,但我们发现其中是由列表的,这是怎么回事?
t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
t[0] = 'x' # TypeError: 'tuple' object does not support item assignment
通过上例,可以发现,元组内的普通元素不允许修改,但是列表是可变,我们能否把列表替换为别的元素呢?
t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
print(t[2]) # [4, [5, 'c']]
t[2] = 'w' # TypeError: 'tuple' object does not support item assignment
通过上例也可以发现,如果列表被当成了元组的普通元素,那么它也是不可以修改的,遵循元组不可变特性。但是我们如果试图修改列表中的子元素呢?
t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
t[2][0] = 'w'
print(t) # (1, (2, 3), ['w', [5, 'c']], {'a': 'b'}, {8, 7})
上例,可以发现,
t[2][0]
指的是列表中的第一个元素,我们在第2行修改它,然后发现是可以修改成功的。这是为什么呢?元组内的普通元素不允许修改,嵌套的子元素是否能够修改取决于这个子元素本身属于什么数据类型,如这个子元素是列表,那就可以修改,如果是元组,就可不以修改。那么,了解完元组,你可能更有疑问了,除了不可变之外,元组跟列表没啥区别么?我们通过与列表的对比,来证明存在即是真理!
需要注意的是,元组并没有增、删功能。那么元组如此设计,以放弃增、删为代价换来了什么呢?
性能!是的,换来了性能!不信请看,以下演示代码由IPython(Python的另一个发行版本)完成。
4.3 list列表与元组tuple的对比
4.3.1 list VS tuple:创建(生成)速度
我们通过创建同样大小的list和tuple,来观察有什么变化:
In [1]: % timeit [1, 2, 3, 4, 5]
139 ns ± 2.34 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
In [2]: % timeit (1, 2, 3, 4, 5)
17.3 ns ± 0.161 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
上例的意思是说我们创建一个长度为5的列表,大概执行了7次大循环,每次大循环中进行
10000000
次小循环。这个7次大循环,每次耗时(平均值)139 ns
,每次(标准)偏差2.34 ns
。而创建同样长度的元组,每次仅耗时17.3 ns
,对比创建列表的耗时139 ns
,可以看到创建元组的速度快很多。
4.3.2 list VS tuple:存储开销
再来看他们的存储开销:
from sys import getsizeof
l = [1, 2, 3, 4, 5]
t = (1, 2, 3, 4, 5)
print(getsizeof(l)) # 56
print(getsizeof(t)) # 48
可以看到,元组在存储空间上面也占优势。
4.3.3 list VS tuple:遍历速度
元组的遍历性能相比列表也是快很多了
4.3.4 list VS tuple:哈希比较
l = [1, 2, 3, 4, 5]
t = (1, 2, 3, 4, 5)
print(hash(t)) # -1883319094
print(hash(l)) # TypeError: unhashable type: 'list'
简单来说,Hash,一般翻译做“散列”,也有直接音译为“哈希”的,就是把任意长度的输入(又叫做预映射, pre-image),通过散列算法,变换成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
Python中可哈希(hashable)类型:字符串、元组、对象。可哈希类型就是我们常说的不可变类型,优点是性能经过优化,多线程安全,不需要锁,不担心被恶意篡改或者不小心修改了。
不可哈希类型:字典、列表、集合。相对于可哈希类型,使用起来相对灵活。
4.4 为数组添加元组
5. 字典dict
资料链接:https://www.cnblogs.com/Neeo/articles/11212385.html
我们知道,无论字符串、列表、元组都是将数据组织到一个有序的结构中,然后通过下标索引处理数据,这几种数据结构虽然已经满足大多数场景了,但是依然不够丰满,现在了解一种通过名字(key)来处理数据的数据类型,这种名字对应数值的关系我们称之为映射关系,而这种数据类型就是前文或多或少的了解过的——字典(dict)。字典是目前为止,Python唯一的内建的映射类型的数据类型。需要说明的是,从Python 3.6开始,字典元素的存储顺序由各键值对根据存储时的顺序而定(但依然不支持索引取值),并优化了空间上的开销,更节省内存占用。
通过存储同样的数据,利用列表和字典的不同之处来学习字典。比如存储商品的名称和编号,可以用列表来存。
有三个商品,对应三个价钱,那想要知道banana的价钱怎么办?
goods = ['apple', 'orange', 'banana']
price = ['20', '24', '32']
banana = price[goods.index('banana')]
print(banana) # 32
如上例这样取值很麻烦,而且,你可能要问为什么价钱要存成字符串类型?
goods = ['apple', 'orange', 'banana']
price = [20, 24, 32]
banana = price[goods.index('banana')]
print(banana) # 32
上例虽然可以存储为int类型。但要是存个电话号码呢?比如存010998998
这样的数字怎么存?
number = [010, 998, 998] # SyntaxError: invalid token
这个问题告诉我们,碰到类似的数据,或者是0开头的数据,尽量存储为字符串类型,而不是整型。另外,虽然列表能存储多种数据类型,但是通过上面的商品和价钱的例子,在用列表的时候,应该尽量存储数据为单一的类型。
好,言归正传,再来看看更好的选择。
goods = {'apple': '20', 'orange': '24', 'banana': '32'}
print(goods['banana']) # 20
上例采用了字典来存储数据,接下来就学习一下字典的用法。
5.1 字典基本操作
字典详细讲解:https://www.cnblogs.com/Neeo/articles/11212385.html
字典是无序(Python 3.6版本之前)的可变类型数据类型。我们通过一对
{}
来创建字典(dict),字典内的值是通过:
来存储的,也就是key:value
的格式。
d1 = {}
d2 = dict()
print(d1, d2) # {} {}
d3 = {'apple': 20}
print(d3) # {'apple': 20}
print(d3['apple']) # 20
5.1.1 使用内建函数dict()来创建字典
d = dict(apple='20', orange='24')
print(d) # {'apple': '20', 'orange': '24'}
5.1.2 字典的增删改查
d = dict(apple=20, orange=24)
print(d['apple']) # 字典取值
d['apple'] = 40 # 为字典的apple键重新赋值
print(d)
d['banana'] = 32 # 为字典新添加一对键值对
print(d)
del d['apple']
del d['orange'], d['banana']
del d
我们可以通过字典加中括号的形式,来对字典进行增删改查的操作。但需要注意的是,通过中括号取值的时候和
del
声明删除字典的key时,该key必须存在,否则报错(KeyError)。
列表的成员资格测试是不稳定的,而字典稳定。这是因为列表的成员资格判断取决于判断元素处于列表的什么位置,如果是列表的靠前位置,速度肯定快,如果是末尾,就要从头到尾挨着判断,速度就慢下来了。
而字典的存储结构是由key
、哈希表
、value
三部分组成的,字典在创建一个键值对的时候,首先将key通过哈希得到结果,结果的位置上就是value,然后这个对应关系被保存在哈希表上。查询的时候,无论该key在何方,只要哈希后根据结果去哈希表上就能找到对应的value。所以查询速度快而且稳定,但由于要维护哈希表,在存储和修改时可能会相对麻烦些。
不是什么元组都能成为字典的key
需要注意的是,如果字典的key是元组,那么这个元组就不能是普通的元组了。我们知道元组是可哈希的数据类型,这种说法是基于元组内的元素都是不可变类型才成立的。
print(hash((1, 'a', 2.3, (4, 5)))) # -1680772126
t1 = (1, 'a', 2.3, (4, 5), [6, 7])
print(t1) # (1, 'a', 2.3, (4, 5), [6, 7])
print(hash(t1)) # TypeError: unhashable type: 'list'
5.2 字典的常用操作
遍历字典
d = {'a': 1, 'b': 2, 'c': 3}
for k in d:
print(k)
'''
a
b
c
'''
由上例可以看到,遍历的时候,字典默认返回key,那么怎么分别取key和value呢?
d = {'a': 1, 'b': 2, 'c': 3}
print(d.keys()) # dict\_keys(['a', 'b', 'c'])
for k in d.keys():
print(k)
'''
a
b
c
'''
print(d.values()) # dict\_values([1, 2, 3])
for k in d.values():
print(k)
'''
1
2
3
'''
上例中,d.keys()
取出来的是字典所有的key,而d.values()
取出的是所有的value。
那怎么同时取key和value呢:
d = {'a': 1, 'b': 2, 'c': 3}
for k in d.items():
print(k)
'''
('a', 1)
('b', 2)
('c', 3)
'''
for k, v in d.items():
print(k, v)
'''
a 1
b 2
c 3
'''
第一个for循环,我们通过d.items()
以元组的形式拿到key和value。第二个循环,相当于平行赋值,每次从d.items()
中取出一个元组,然后平行赋值给k v
两个变量。
dict.get(key, None)
之前说,我们通过字典加中括号取值的时候,当key不存在的时候,会报错:
d = {'a': 1, 'b': 2, 'c': 3}
print(d['a']) # 1
print(d['w']) # KeyError: 'w'
报错~嗯2333333,很明显是不行滴,怎么办呢,我们可以通过dict.get()
方法来避免这个问题:
d = {'a': 1, 'b': 2, 'c': 3}
print(d['a']) # 1
print(d.get('a')) # 1
print(d.get('w')) # None
print(d.get('w', 'hi man, 你想要的键不存在呀')) # hi man, 你想要的键不存在呀
dict.get()
可以获取指定的key,当key不存在的时候,默认会返回一个None
,意思是没取到key,而且我们可以修改这个返回值,更加灵活。
dict.setdefault(key, None)
d = {'a': 1, 'b': 2, 'c': 3}
print(d.setdefault('a')) # 1
print(d.setdefault('x', 'y')) # y
print(d) # {'a': 1, 'b': 2, 'c': 3, 'x': 'y'}
dict.setdefault()
方法跟dict.get()
方法类似,获取字典指定的key,存在则返回对应的value,如果key不存在的话,它会将我们指定的key添加到字典中,默认的value是None,该value也可以自己指定。
dict.update(obj)
字典可以拼接(+)吗?
d1 = {'a': 1, 'b': 2}
d2 = {'c': 3, 'd': 4}
d3 = d1 + d2 # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
显然是不行的!
但我们可以通过dict.upate()
方法来完成类似的操作:
d1 = {'a': 1, 'b': 2}
d2 = {'c': 3, 'd': 4}
d2.update(d1)
print(d2) # {'c': 3, 'd': 4, 'a': 1, 'b': 2}
此方法将一个字典(d1)的键值对一次性的更新到当前字典(d2),如果两个字典中存在同样的键,更新的时候,对应的值以另一个字典(d1)的值为准。
注意,字典的键是唯一的,但是值可以是相同的。
dict.pop() & dict.popitem()
我们在上面也了解过了del来删除字典以及删除字典的键,这里我们再介绍两个方法删除字典的键。
d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(d.pop('a'), d) # 1 {'b': 2, 'c': 3, 'd': 4}
# print(d.pop('w')) # KeyError: 'w'
print(d.popitem()) # ('d', 4)
d.pop()
方法删除字典指定的key,返回对应的value,如果key不存在,则抛出KeyError
错误。
而d.popitem()
在Python2.7(Python 2.x的最后一个版本)和Python3.6(及以上版本)删除的是最后一个key。而其他版本(如Python2.4和Python3.5版本)则是随机删除一对键值对。另外,如果字典为空,上述两个方法都将抛出KeyError
的错误。
dict.clear()
要清空一个字典,使用dict.clear()
方法,这没啥好解释的:
d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
d.clear()
print(d) # {}
### 最后
不知道你们用的什么环境,我一般都是用的Python3.6环境和pycharm解释器,没有软件,或者没有资料,没人解答问题,都可以免费领取(包括今天的代码),过几天我还会做个视频教程出来,有需要也可以领取~
给大家准备的学习资料包括但不限于:
Python 环境、pycharm编辑器/永久激活/翻译插件
python 零基础视频教程
Python 界面开发实战教程
Python 爬虫实战教程
Python 数据分析实战教程
python 游戏开发实战教程
Python 电子书100本
Python 学习路线规划
![](https://img-blog.csdnimg.cn/d29631674929476f9c3b30f7ff58dff0.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaTM0Nzc5NTc5MA==,size_16,color_FFFFFF,t_70)
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
**[需要这份系统化学习资料的朋友,可以戳这里获取](https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0)**
**一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!**