如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费学习大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。
一、Python所有方向的学习路线
Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
二、学习软件
工欲善其必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。
三、全套PDF电子书
书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。
四、入门学习视频
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
四、实战案例
光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
五、面试资料
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
成为一个Python程序员专家或许需要花费数年时间，但是打下坚实的基础只要几周就可以，如果你按照我提供的学习路线以及资料有意识地去实践，你就有很大可能成功！
最后祝你好运！！！
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
例如：first_name、last_name、qq_number、qq_password
2.4驼峰命名法
当 变量名 是由二个或多个单词组成时，还可以利用驼峰命名法来命名
小驼峰式命名法
第一个单词以小写字母开始，后续单词的首字母大写
例如：firstName、lastName
大驼峰式命名法
每一个单词的首字母都采用大写字母
例如：FirstName、LastName、CamelCase
3.1运算符
3.1.1. 算数运算符
是完成基本的算术运算使用的符号，用来处理四则运算
>>> a=10
>>> b=5
>>> print(a+b)
15
>>> print(a-b)
5
>>> print(a*b)
50
>>> print(a/b)
2.0
>>> print(a**b)
100000
>>> print(a//b)
2
>>> print(a%b)
0
3.1.2. 比较（关系）运算符
>>> a=10
>>> b=20
>>> a==b
False
>>> a!=b
True
>>> a>b
False
>>> a<b
True
>>> a>=b
False
>>> a<=b
True
3.1.3. 逻辑运算符
>>> a=True
>>> b=False
>>> a and b
False
>>> a or b
True
>>> not a
False
>>> not -1
False
>>> not 0
True
3.1.4. 赋值运算符
在 Python 中，使用 = 可以给变量赋值
在算术运算时，为了简化代码的编写，Python 还提供了一系列的 与 算术运算符 对应的 赋值运算符
注意：赋值运算符中间不能使用空格
>>> a=10
>>> b=20
>>> c=0
>>> c=a+b
>>> print(c)
30
>>> c+=10
>>> print(c)
40
>>> c-=a
>>> print(c)
30
>>> c*=a
>>> print(c)
300
>>> c/=a
>>> print(c)
30.0
>>> c%=a
>>> print(c)
0.0
>>> c=a**5
>>> print(c)
100000
>>> c//=b
>>> print(c)
5000
>>> print(b)
20
3.1.5. 运算符的优先级
以下表格的算数优先级由高到最低顺序排列
4.1. 条件语句
Python 条件语句跟其他语言基本一致的，都是通过一条或多条语句的执行结果（ True 或者 False ）来决定执行的代码块。
Python 程序语言指定任何非 0 和非空（None）值为 True，0 或者 None为 False。
4.1.1. if 语句的基本形式
Python 中，if 语句的基本形式如下：
if 判断条件：
执行语句……
else：
执行语句……
前面也提到过，Python 语言有着严格的缩进要求，因此这里也需要注意缩进，也不要少写了冒号 : 。
if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。
例如：
# -*-coding:utf-8-*-
results=59
if results>=60:
print ('及格')
else :
print ('不及格')
输出的结果为：
不及格
上面也说道，非零数值、非空字符串、非空 list 等，判断为True，否则为False。因此也可以这样写：
num = 6
if num :
print('Hello Python')
4.1.2. if 语句多个判断条件的形式
有些时候，我们的判断语句不可能只有两个，有些时候需要多个，比如上面的例子中大于 60 的为及格，那我们还要判断大于 90 的为优秀，在 80 到 90 之间的良好呢？
这时候需要用到 if 语句多个判断条件，
用伪代码来表示：
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
实例：
# -*-coding:utf-8-*-
results = 89
if results > 90:
print('优秀')
elif results > 80:
print('良好')
elif results > 60:
print ('及格')
else :
print ('不及格')
输出的结果：
良好
4.1.3. if 语句多个条件同时判断
Python 不像 Java 有 switch 语句，所以多个条件判断，只能用 elif 来实现，但是有时候需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。
# -*-coding:utf-8-*-
java = 86
python = 68
if java > 80 and python > 80:
print('优秀')
else :
print('不优秀')
输出结果：
不优秀
注意：if 有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于 >（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。
java = 86
python = 68
if (80 <= java < 90) or (80 <= python < 90):
print('良好')
输出结果：
良好
课上练习1
我想买车，买什么车决定于我在银行有多少存款
如果我的存款超过500万，我就买路虎
否则，如果我的存款超过100万，我就买宝马
否则， 如果我的存款超过50万，我就买迈腾
否则， 如果我的存款超过10万，我就买福特
否则， 如果我的存款10万以下 ，我买比亚迪
课上练习2
输入小明的考试成绩，显示所获奖励
成绩==100分，爸爸给他买辆车
成绩>=90分，妈妈给他买MP4
90分>成绩>=60分，妈妈给他买本参考书
成绩<60分，什么都不买
4.2. 循环语句
一般编程语言都有循环语句，循环语句允许我们执行一个语句或语句组多次。
循环语句的一般形式如下：
Python 提供了 for 循环和 while 循环，当然还有一些控制循环的语句：
4.2.1. While 循环语句
count = 1
sum = 0
while count <= 100:
sum = sum + count
count = count + 1
print(sum)
输出的结果：
5050
当然 while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于跳出本层循环
比如，上面的例子是计算 1 到 100 所有整数的和，当我们需要判断 sum 大于 1000 的时候，不在相加时，可以用到 break ，退出整个循环
count = 1
sum = 0
while count <= 100:
sum = sum + count
if sum > 1000: #当 sum 大于 1000 的时候退出循环
break
count = count + 1
print(sum)
输出的结果：
1035
有时候，我们只想统计 1 到 100 之间的奇数和，那么也就是说当 count 是偶数，也就是双数的时候，我们需要跳出当次的循环，不想加，这时候可以用到 continue
count = 1
sum = 0
while count <= 100:
if count % 2 == 0: # 双数时跳过输出
count = count + 1
continue
sum = sum + count
count = count + 1
print(sum)
输出的语句：
2500
在 Python 的 while 循环中，还可以使用 else 语句，while … else 在循环条件为 false 时执行 else 语句块
比如：
count = 0
while count < 5:
print (count)
count = count + 1
else:
print (count)
输出的结果：
0
1
2
3
4
5
4.2.2. for 循环语句
for循环可以遍历任何序列的项目，如一个字符串
它的流程图基本如下：
基本的语法格式：
for iterating_var in sequence:
statements(s)
实例：
for letter in 'www.neuedu.com':
print(letter)
输出的结果如下：
w
w
w
.
n
e
u
e
d
u
.
c
o
m
range()函数
Python函数range()让你能够轻松地生成一系列的数字。例如，可以像下面这样使用函数range()来打印一系列的数字：
for value in range(1,5):
print(value)
上述代码好像应该打印数字1~5，但实际上它不会打印数字5：
1
2
3
4
在这个示例中，range()只是打印数字1~4，这是你在编程语言中经常看到的差一行为的结果。函数range()让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值（这里为5）。
要打印数字1~5，需要使用range(1,6)：
for value in range(1,6):
print(value)
这样，输出将从1开始，到5结束：
1
2
3
4
5
4.2.3. 嵌套循环
Python 语言允许在一个循环体里面嵌入另一个循环。上面的实例也是使用了嵌套循环的。
具体的语法如下：
for 循环嵌套语法
for iterating_var in sequence:
for iterating_var in sequence:
statements(s)
statements(s)
while 循环嵌套语法
while expression:
while expression:
statement(s)
statement(s)
除此之外，你也可以在循环体内嵌入其他的循环体，如在 while 循环中可以嵌入 for 循环， 反之，你可以在 for 循环中嵌入 while 循环
有 while … else 语句，当然也有 for … else 语句啦，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
for num in range(10,20): # 迭代 10 到 20 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0: # 确定第一个因子
j=num/i # 计算第二个因子
print ('%d 是一个合数' % num)
break # 跳出当前循环
else: # 循环的 else 部分
print ('%d 是一个质数' % num)
输出的结果：
10 是一个合数
11 是一个质数
12 是一个合数
13 是一个质数
14 是一个合数
15 是一个合数
16 是一个合数
17 是一个质数
18 是一个合数
19 是一个质数
课上案例 打印九九乘法表
# 打印九九乘法表
for i in range(1, 10):
for j in range(1, i+1):
print('{}x{}={}\t'.format(i, j, i*j), end='')
print()
1x1=1
2x1=2 2x2=4
3x1=3 3x2=6 3x3=9
4x1=4 4x2=8 4x3=12 4x4=16
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
4.3. 随机数的处理
在 Python 中，要使用随机数，首先需要导入 随机数 的 模块 —— “工具包”
import random
导入模块后，可以直接在 模块名称 后面敲一个 . ，会提示该模块中包含的所有函数
random.randint(a, b) ，返回 [a, b] 之间的整数，包含 a 和 b
例如：
random.randint(12, 20) # 生成的随机数n: 12 <= n <= 20
random.randint(20, 20) # 结果永远是 20
random.randint(20, 10) # 该语句是错误的，下限必须小于上限
综合练习—猜数字
计算机要求用户输入数值范围的最小值和最大值。计算机随后“思考”出在这个范围之内的一个随机数，并且重复地要求用户猜测这个数，直到用户猜对了。在用户每次进行猜测之后，计算机都会给出一个提示，并且会在这个过程的最后显示出总的猜测次数。这个程序包含了几种类型的我们学过的 Python 语句，例如，输入语句、输出语句、赋值语句、循环和条件语句。
一个可能的游戏过程如下：
Enter the smaller number: 1
Enter the larger number: 20
Enter your guess: 5
Too small
Enter your guess: 9
Too small
Enter your guess: 15
Too small
Enter your guess: 17
Too large
Enter your guess: 16
You've got it in 5 tries!
import random
smaller = int(input("Enter the smaller number: "))
larger = int(input("Enter the larger number: "))
myNumber = random.randint(smaller, larger)
count = 0
while True:
count += 1
userNumber = int(input("Enter your guess: "))
if userNumber < myNumber:
print("Too small")
elif userNumber > myNumber:
print("Too large")
else:
print("You've got it in", count, "tries!")
break
5.1. 列表定义
列表是Python中内置有序可变序列，列表的所有元素放在一对中括号“[]”中，并使用逗号分隔开；
一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、字典以及其他自定义类型的对象。
例如：
[1,2,3,2.4,5]
[0.01,"zhangsan",[1,2,3]]
创建
使用“=”直接将一个列表赋值给变量即可创建列表对象。例如：a_list = []，b_list = [1，2,3]
使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。
例如：a_list = list(“Hello”) 将字符串 “hello” 转换成列表 [‘H’，‘e’，‘l’，‘l’，‘o’]
删除 当不再使用时，使用del命令删除整个列表 例如：
>>>x =[1,2,3]
>>>del x[1] #删除指定位置元素
>>>x
[1，3]
>>>del x #删除整个列表
>>>x
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
x
NameError: name 'x' is not defined
5.2. 列表元素的增加
5.2.1. append()
向列表尾部追加一个元素，不改变其内存首地址，属于原地操作。 例如：
>>>x = [1,2,3]
>>>x.append(4)
>>>x
[1,2,3,4]
5.2.2. insert()
向列表任意位置插入一个元素，不改变其内存首地址，属于原地操作。
例如：
>>>x = [1,3,4]
>>>x.insert(1,2)
>>>x
[1,2,3,4]
5.2.3. extend()
将另一个迭代对象的所有元素添加至该列表对象尾部，不改变其内存首地址，属于原地操作。
例如：
>>>x = [1,2]
>>>x.extend([3,4])
>>>x
[1,2,3,4]
5.3. 运算符" + " 和" * "
并不是真的为列表添加元素，而是创建一个新列表,不属于原地操作，而是返回新列表。
>>> x = [1,2,3]
>>>y = x + [4]
>>>y
[1,2,3,4]
>>>y = x*2
>>>y
[1,2,3,4,1,2,3,4]
此时x保持不变，依旧是[1,2,3]
5.4. 列表元素的删除
5.4.1. pop()
使用列表的pop()方法删除并返回指定（默认为最后一个）位置上的元素，如果给定的索引超出了列表的范围则抛出异常。
>>>x = [1,2,3,4]
>>>x.pop() #弹出并返回尾部元素
4
>>>x.pop(1) #弹出并返回指定位置的元素
>>>2
5.4.2. remove()
删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。
例如：
>>>x = [1,2,2,3,4]
>>>x.remove(2)
>>>x
[1,2,3,4]
5.4.3. clear()
清空列表。
例如：
>>>x = [1,2,3,4]
>>>x.clear()
>>>x
[ ]
5.4.4. del
删除列表中的指定位置上的元素。
例如：
>>>x = [1,2,3,4]
>>>del x[1]
>>>x
[1,3,4]
5.5. 列表元素访问与计数
5.5.1. count()
统计指定元素在列表对象中出现的次数。
例如：
>>> x =[1,2,3,3,4,5]
>>>x.count(3)
2
>>>x.count(0)
0
1.5.2. index()
获取指定元素首次出现的下标，若列表对象中不存在指定元素，则抛出异常。
例如：
>>>x = [1,2,3,2,2,4]
>>>x.index(2)
1
5.5.3. in
测试列表中是否存在某元素
例如：
>>>x = [1,2,3,4]
>>>3 in x
True
>>>5 in x
False
5.6. 列表排序
5.6.1. sort()
按照指定规则对所有元素进行排序，默认规则是直接比较规则大小。
例如：
>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> import random
>>> random.shuffle(aList) #随机降序
>>> aList
[3, 4, 15, 11, 9, 17, 13, 6, 7, 5]
>>> aList.sort() #默认是升序排序
>>> aList.sort(reverse = True) #降序排序
>>> aList
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
5.6.2. reverse()
将列表中所有元素原地逆序排列。
例如：
>>>x = [1,3,2,4,6,5]
>>>x.reverse()
>>>x
[5,6,4,2,3,1]
5.6.3. sorted()
使用内置函数sorted对列表进行排序并返回新列表，不对原列表做任何修改。
例如：
>>>x = [6,4,2,4,1]
>>> sorted(x) #升序排序
[1,2,4,4,6]
>>> sorted(aList,reverse = True) #降序排序
[6,4,4,2,1]
>>>x
[6,4,2,4,1]
5.6.4. reversed()
返回一个逆序排列后的迭代对象，不对原列表做任何修改。
>>>x =[1,5,3,6,2]
>>>list(reversed(x))
[2,6,3,5,1]
>>>x
[1,5,3,6,2]
5.7. 用于序列操作的常用内置函数
5.7.1. len()
返回列表中的元素个数，同样适用于元组、字典、集合、字符串等。
5.7.2. max()、 min()
返回列表中的最大或最小元素，同样适用于元组、字典、集合、range对象等。
5.7.3. sum()
对列表的元素进行求和运算。
5.7.4. zip()
返回可迭代的zip对象。
例如：
>>> aList = [1, 2, 3]
>>> bList = [4, 5, 6]
>>> cList = zip(a, b) #返回zip对象
>>> cList
<zip object at 0x0000000003728908>
>>> list(cList) #把zip对象转换成列表
[(1, 4), (2, 5), (3, 6)]
5.7.5. enumerate()
枚举列表元素，返回枚举对象，其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。
例如：
>>> for item in enumerate('abcdef'):
print(item)
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
(5, 'f')
5.8. 遍历列表的三种方式
a = ['a','b','c','d','e','f']
for i in a:
print(i)
for i in range(len(a)):
print(i,a[i])
for i,ele in enumerate(a):
print(i,ele)
5.9. 列表推导式
列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性。
语法形式：[表达式 for 变量 in 序列或迭代对象]
列表推导式在逻辑上相当于一个循环，只是形式更加简洁。
lis = [i for i in range(100)]
print(lis)
使用列表推导式实现嵌套列表的平铺
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
相当于：
>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> result = []
>>> for elem in vec:
for num in elem:
result.append(num)
>>> result
[1, 2, 3, 4, 5, 6, 7, 8, 9]
过滤不符合条件的元素 从列表中选择符合条件的元素组成新的列表
>>> aList = [-1,-4,6,7.5,-2.3,9,-11]
>>> [i for i in aList if i>0]
[6, 7.5, 9]
在列表推导式中使用多个循环，实现多序列元素的任意组合，并且可以结合条件语句过滤特定元素
>>> [(x, y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
>>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
列表综合练习
写一个循环，不断的问用户想买什么，用户选择一个商品编号，就把对应的商品添加到购物车里，最终用户输入q退出时，打印购物车里的商品列表
products = [['iphone',6888],['三星',3000],['小米',2500]]
shopping_car = []
flag = True
while flag:
print("******商品列表******")
for index,i in enumerate(products):
print("%s. %s| %s" %(index,i[0],i[1]))
choice = input("请输入您想购买的商品的编号：")
if choice.isdigit():#isdigit()判断变量是什么类型
choice = int(choice)
if choice>=0 and choice<len(products):
shopping_car.append(products[choice])
print("已经将%s加入购物车" %(products[choice]))
else:
print("该商品不存在")
elif choice == "q":
if len(shopping_car)>0:
print("您打算购买以下商品：")
for index,i in enumerate(shopping_car):
print("%s. %s| %s" %(index,i[0],i[1]))
else:
print("您的购物车中没有添加商品")
flag = False
5.10. 列表切片
使用索引获取列表的元素（随机读取）
列表元素支持用索引访问，正向索引从0开始
colors=["red","blue","green"]
colors[0] =="red"
colors[1]=="blue"
同时，也可以使用负向索引(python中有序序列都支持负向索引)
colors[-1]=="green"
5.10.1. 列表的切片操作
切片操作不是列表特有的，python中的有序序列都支持切片，如字符串，元组。
切片的返回结果类型和切片对象类型一致，返回的是切片对象的子序列，如：对一个列表切片返回一个列表，字符串切片返回字符串。
li=["A","B","C","D"]
格式： li[start : end : step]
start是切片起点索引，end是切片终点索引，但切片结果不包括终点索引的值。step是步长默认是1。
t=li[0:3] ["A","B","C"] #起点的0索引可以省略，t=li[:3]
t=li[2: ] ["C","D"] #省略end，则切到末尾
t=li[1:3] ["B","C"]
t=li[0:4:2] ["A","C"] #从li[0]到li[3],设定步长为2。
如何确定start和end，他们是什么关系？ 在step的符号一定的情况下，start和end可以混合使用正向和反向索引，无论怎样，你都要保证 start和end之间有和step方向一致元素 间隔，否则会切出空列表
t=li[0:2]
t=li[0:-2]
t=li[-4:-2]
t=li[-4:2]
上面的结果都是一样的；t为[“A”,“B”]
t=li[-1:-3:-1]
t=li[-1:1:-1]
t=li[3:1:-1]
t=li[3:-3:-1]
上面的结果都是一样的；t为[“D”,“C”]
t=li[-1:-3]
t=li[-1:1]
t=li[3:1]
t=li[3:-3]
都切出空列表
同时，step的正负决定了切片结果的元素采集的先后
省略start 和 end表示以原列表全部为目标
t=li[::-1] t--->["C","B","A"] #反向切，切出全部
t=li[:] t--->["A","B","C","D"] #正向切全部
5.10.2. 使用切片来原地修改列表内容
>>> aList = [3, 5, 7]
>>> aList[len(aList):] = [9] #在尾部追加元素
>>> aList
[3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3] #替换前3个元素
>>> aList
[1, 2, 3, 9]
>>> aList[:3] = [] #删除前3个元素
>>> aList
[9]
5.10.3. 使用del与切片结合来删除列表元素
>>> aList = [3,5,7,9,11]
>>> del aList[:3] #删除前3个元素
>>> aList
[9, 11]
>>> aList = [3,5,7,9,11]
>>> del aList[::2] #删除偶数位置上的元素
>>> aList
[5, 9]
5.10.4. 切片返回的是列表元素的浅复制
所谓浅复制，是指生成一个新的列表，并且把原列表中所有元素的引用都复制到新列表中。
例如：
>>> aList = [3, 5, 7]
>>> bList = aList #bList与aList指向同一个内存
>>> bList
[3, 5, 7]
>>> bList[1] = 8 #修改其中一个对象会影响另一个
>>> aList
[3, 8, 7]
>>> aList == bList #两个列表的元素完全一样
True
>>> aList is bList #两个列表是同一个对象
True
>>> id(aList) #内存地址相同
19061816
>>> id(bList)
19061816
>>> aList = [3, 5, 7]
>>> bList = aList[::] #切片，浅复制
>>> aList == bList #两个列表的元素完全一样
True
>>> aList is bList #但不是同一个对象
False
>>> id(aList) == id(bList) #内存地址不一样
False
>>> bList[1] = 8 #修改其中一个不会影响另一个
>>> bList
[3, 8, 7]
>>> aList
[3, 5, 7]
5.11. 元组
元组属于不可变序列（元素集合），一旦创建，用任何方法都不可以修改其元素。从形式上，元组的所有元素放在一对圆括号中，元素之间用逗号分隔。
5.11.1. 元组的创建与删除
创建 使用“=”将一个元组赋值给变量
例如：
>>>x = (1,2,3) #直接把元组赋值给一个变量
>>>x
(1,2,3)
创建只有一个元素的元组
x =(3)
print(type(x))
x =(3,)
print(type(x))
输出
<class 'int'>
<class 'tuple'>
创建空元组的方法
>>>x = () #空元组
>>>x
()
>>>x = tuple() #空元组
>>>x
()
使用tuple函数将其他序列转换为元组
>>>tuple(range(5))
(0,1,2,3,4)
>>> tuple('abcdefg') #把字符串转换为元组
('a', 'b', 'c', 'd', 'e', 'f', 'g')
>>> aList
[-1, -4, 6, 7.5, -2.3, 9, -11]
>>> tuple(aList) #把列表转换为元组
(-1, -4, 6, 7.5, -2.3, 9, -11)
删除 使用del可以删除元组对象，不能删除元组中的元素
5.11.2. 元组与列表的区别
1.元组中的数据一旦定义就不允许更改。
2.元组没有append()、extend()和insert()等方法，无法向元组中添加元素。
3.元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。
4.从效果上看，tuple( )冻结列表，而list( )融化元组。
5.12. 元组的优点
1.元组的速度比列表更快。
2.元组对不需要改变的数据进行“写保护”将使得代码更加安全。
3.元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。元组有时还作为函数的返回值返回（返回多个值）。
6.1. 字符串的常用操作方法
6.1.1. 字符串切片
获取Python字符串中的某字符可以使用索引：
lang = '小朱学长'
print(lang[0])
print(lang[3])
小
学
截取字符串中的一段字符串可以使用切片，切片在方括号中使用冒号:来分隔需要截取的首尾字符串的索引，方式是包括开头，不包括结尾
lang[2:4]
# 学长
当尾索引没有给出时，默认截取到字符串的末尾
lang[2:]
# 学长
当头索引没有给出的时候默认从字符串开头开始截取
lang[:3]
# 小朱学
当尾索引和头索引都没有给出的时候，默认返回整个字符串，不过这只是一个浅拷贝
lang[:]
# 小朱学长
当尾索引大于总的字符串长度时，默认只截取到字符串末尾，很明显使用这种方法来截取一段到字符串末尾的子字符串是非常不明智的，应该是不给出尾索引才是最佳实践
lang[3:100]
# 长
当头索引为负数时，则是指从字符串的尾部开始计数，最末尾的字符记为-1，以此类推，因此此时应该注意尾索引的值，尾索引同样可以为负数，如果尾索引的值指明的字符串位置小于或等于头索引，此时返回的就是空字符串
lang[-2:]
# 学长
lang[-2,2]
# ''
切片的第三个参数是步长
s = 'www.neuedu.com'
#### 切片取出来的字符串与原字符串无关，原字符串不变
print(s[6: 10])
print(s[7:: 2])
uedu
eucm
反向取数字需要加上反向步长
print(s[-1: -4: -1])
print(s[-1: 2]) #### 取不到数据，因为步长默认-1
print(s[-1: 2: -1])#### 可以
moc
moc.udeuen.
6.1.2. 把字符串全部大写或小写upper， lower
s = 'www.NEUEDU.com'
print(s.upper()) #### 全部大写
print(s.lower()) #### 全部小写
6.1.3. 判读以xx开头或结尾startswith，endswith
s = 'www.neuedu.com'
print(s.startswith('www')) #### 判断是否以www开头
print(s.endswith('com')) #### 判断是否以com结尾
True
True
6.1.4. 查找元素find ，index
s = 'chhengt'
print(s.find('h')) #### 通过元素找索引找到第一个就返回（可切片）
print(s.find('b')) #### 找不到返回 -1
print(s.index('b')) #### 找不到会报错
Traceback (most recent call last):
1
File "C:/Users/Administrator/PycharmProjects/textgame/tests/test_bag.py", line 4, in <module>
-1
print(s.index('b')) #### 找不到会报错
ValueError: substring not found
做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。
别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。
我先来介绍一下这些东西怎么用，文末抱走。
* * *
**（1）Python所有方向的学习路线（新版）**
这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
最近我才对这些路线做了一下新的更新，知识体系更全面了。
**（2）Python学习视频**
包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。
**（3）100多个练手项目**
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。
**（4）200多本电子书**
这些年我也收藏了很多电子书，大概200多本，有时候带实体书不方便的话，我就会去打开电子书看看，书籍可不一定比视频教程差，尤其是权威的技术书籍。
基本上主流的和经典的都有，这里我就不放图了，版权问题，个人看看是没有问题的。
**（5）Python知识点汇总**
知识点汇总有点像学习路线，但与学习路线不同的点就在于，知识点汇总更为细致，里面包含了对具体知识点的简单说明，而我们的学习路线则更为抽象和简单，只是为了方便大家只是某个领域你应该学习哪些技术栈。
**（6）其他资料**
还有其他的一些东西，比如说我自己出的Python入门图文类教程，没有电脑的时候用手机也可以学习知识，学会了理论之后再去敲代码实践验证，还有Python中文版的库资料、MySQL和HTML标签大全等等，这些都是可以送给粉丝们的东西。
**这些都不是什么非常值钱的东西，但对于没有资源或者资源不是很好的学习者来说确实很不错，你要是用得到的话都可以直接抱走，关注过我的人都知道，这些都是可以拿到的。**
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
