Python学习笔记（在廖雪峰的网站学习过程中整理而成

！！！申明：本学习笔记基于廖雪峰的官方网站，由笔者在学习过程中整理而成，不是搬运工
附廖雪峰的官方网站：廖雪峰的官方网站

Python基础：

1.list和tuple

list和tuple：list又称列表，类似C语言或C++中的数组，但与C系列语言存在一定区别，区分度高。
list的定义：

> test = [‘test1’ , 666 , true]

此变量test即为一个list，可见list变量由中括号定义而成，且不提前对其直接进行类型定义，这是python所独有的特点；list变量也可同时存储任意类型变量，如字符、整型、布尔类型等。
list利用索引直接访问其中的元素，类似于数组下标，同数组一样，其索引也是从0开始的，访问示例如下：

test[0]
test[1]
test[2]

超出list中元素个数的范围会报IndexError错误

需要直接获取list的长度可直接使用：len( )函数

len(test)

Python支持直接访问list最后一个元素，知不知道此list的长度均可访问，访问最后一个元素和倒数第二个元素的示例如下：

test[-1]
test[-2]

list最主要的特点也是和tuple的主要区别：list是一个可变的有序表，tuple是定长的有序表，tuple可以大致等价于其他语言中的数组，当定义完成后不可更改其长度（大小）。也不可更改其中的内容，仅允许进行访问。
在list中可使用append( XXX )方法直接向list末尾添加元素XXX；也可使用insert( i , XXX )方法向该list的第 i 个位置插入XXX ， 注意：索引下标从0开始；可使用pop( i )方法删除该list第 i 个元素 ； 可直接向list的指定位置赋值；所有示例如下所示：

test.append(XXX)
test.insert(2 , flase)
test.pop()#删除test末尾元素
test.pop(1)#删除test中的666
test[0] = test2

list中的元素可以是list，类似于二维数组，依次可衍生出三维数组、四维数组……

tuple又称元组，list和tuple的主要区别即为：tuple定义完成后其长度不可修改，且tuple中的元素一旦定义完成就只能访问，不能对其进行修改
tuple用小括号进行定义，tuple定义如下：

test666 = (‘test2’ , 888 , flase)

---

此处补充一些Python内置的关于 list 和 tuple 的函数和方法：

1.1关于list的函数：

• len( list )
  ：返回列表元素个数

• max( list )
  ：返回列表元素最大值

• min( list )
  ：返回列表元素最小值

• list( tuple )
  ：将元组 tuple 强转为列表 list

1.2关于list的方法

• list.append( abc )
  ：在列表 list 末尾添加新的对象(元素)

• list.count( abc)
  ：统计元素abc在列表中出现的次数

• list.extend( list1 )
  ：将 list1 中的所有元素整体嵌入至 list 后面

• list.index( xxx , start , end )
  其中 start 和 end 为可选参数，satrt 表示查找的起始位置， end 为查找的结束位置
  ：从此列表中找出元素 abc 第一次出现的位置，可利用 start 和 end 限制查找范围

• list.insert( index , abc )
  ：将元素 abc 插入到此 list 中下标为 index 位置上，其中指定位置 index 不可省略

• list.pop( index )
  ：移除 list 中的元素。此方法中 index 为可选，没有index这个参数是默认最后一个元素，如有 index 则要小心越界

• list.remove( abc )
  ：移除列表中值与 abc 第一个匹配的项

• list.reverse( )
  ：将列表整体逆置，此方法无参数

• list.sort( reverse = True | False , key = listLong)
  ：sort 方法对 list 进行排序 ，reverse 和 key 两个参数均为可选参数
  其中 reverse 仅有两个取值 Ture 和 False ，选取 reverse = True 为参数时，list 进行降序排列，不选此参数时默认 reverse = False
  key 为：指定一个仅代有一个参数的函数；将元素进行排序前，先送入此函数进行处理，再进行排序，下面给一个示例：

def listLong(elem):
   return len(elem)
#自定义一个函数，此函数仅带有一个参数elem，此函数的作用时返回elem的长度
   
name = ['Tom' , 'Jack' , 'K' , 'Brown']
#定义一个list
name.sort(key = listLong)
#调用sort方法，默认reverse参数 ，选取key参数
print(name)
#输出排序后的结果

选取 key 参数后，会将 key 所调用的函数结果用于 sort 排序
运行结果如下图所示：

1.3关于tuple的函数：

• len( tuple )
  ：计算元组元素个数
• max( tuple )
  返回元组中元素最大值
• min( tuple )
  返回元组中最小值
• tuple( list )
  将列表 list 强转为元组 tuple

---

2. 条件判断

Python不同于其他语言，不用大括号进行封装，采取缩进规则；if-else语言的大致用法同其他语言基本一致，示例如下：

num = 100
if num < 50:
	print("Yes, num =" , num)
else:
	print("NO , num = " , num)

在Python中利用冒号“ ：” 和四个空格符即一个制表符进行封装（大家注意，不同编辑环境下，一个制表符可能不是表示4个空格，可能是2个也可能是4个甚至是8个，在封装时，也就是表示缩进时，最好用4个空格表示，以避免造成不必要的麻烦。且注意，一段代码里面不要将制表符和空格混用，出现错误后很难排除，也会极大降低工作效率）

也可使用if-elif-else语句进行细致判断：

num = 100
if num < 50:
	print("num1")
elif num < 100:
	print("num2")
else:
	print("num3")

---

3.模式匹配

如果条件判断出口太多，过于冗长，可使用match( ) 语句进行改写，有过C语言基础的小伙伴知道switch，match的功能大致与switch相似，示例如下：

num = 100
match num:
	case 10:
		print("num1")
	case 30 | 40 | 50 | 60 | 70:
		print("num2")
	case 100:
		print("num3")
	case _:  #注意空格
		print("Error")

第二个case利用 | 进行分隔，可匹配多个值
注意最后一个case与_下划线间有一个空格

---

4. 循环

此节开始前先理解 range( ) 函数的用法：
函数：range( i ) ， 可生成一个小于 i 的正整数序列，即生成一个0 ~ i - 1的整数序列

熟悉range( )函数后可实现0~100的正整数求和

利用 list(range( 101 )) 可生成一个包含100个元素的list

使用 for-in 可对其进行遍历，也可进行求和，示例如下：
类似于C++中的for循环

for x in list(range( 101 )):
	print(x)
#上述代码实现顺序输出0~100

sum = 0 
for x in list(range( 101 )):
    sum = sum + x	
print(sum)
#上述代码实现对0~100求和

使用 while循环 也可实现100以内的正整数求和，和其他语言类似，只要 while 条件1 中的条件1 始终成立，则执行循环内容
利用while进行100以内正整数求和示例如下：

sum = 0 
i = 100
while i > 0:
    sum = sum + i
    i = i - 1
print(sum)

相信很多学习过其它语言的小伙伴对break语句和continue语句的区别还是有些模糊，在下面的例子中笔者用Python给大家解释解释

break和continue的区别：
break语句会结束当前循环，跳出循环；continue语句会结束此轮循环进入下一轮循环，直到循环条件不成立才会跳出循环。此处的循环常见的有for和while
通常提到break时需要与contiune进行对比，两者有明显区别
示例代码以输出10以内的奇数为例
下面是break示例：

n = 0
while n < 10:
    n += 1
    if n % 2 == 0:
    	break
    print(n)
print('END')

if 语句判断的是当n为偶数时就会执行break，当while循环结束后输出END表示此段代码结束，执行结果如下图所示：

可以看到当 n 为 2 时执行了 if 判断下的break语句，此后while循环结束，输出了END；break语句使得while循环提前结束，直接跳出了循环，循环结束时 n 的值为 2，并没有执行到循环条件不成立

下面是continue示例：

n = 0
while n < 10:
    n += 1
    if n % 2 == 0:
    	continue
    print(n)
print('END')

此段代码与上述 break 示例一致，只是break替换成了continue，执行结果如下图所示：

当 n 第一次为偶数 2 时执行了 if 判断下的continue 其后并未执行 print(n) 跳出了此轮 while 循环，而是回到了对 n 的判断，此时 n 为 2 ， n < 10 任然成立，随后进入while循环内部 ，首先自加 1 ，然后用 if 进行偶数判断，此时不成立，执行 print(n) , 此轮循环结束……循环往复直至 while 判断条件 n < 10 不成立，随后输出END，此段代码结束

注意！break语句和continue语句通常必须配合 if 语句使用

5.dict 和 set

5.1 dict

dict 全程 dictionary ，为Python内置的字典，在有些编程语言中也称之为map。
使用键—值(key-value，也可以理解成索引)，所具备的优势是其查找速度极快。
其大致原理如同使用字典一样，通常情况下使用字典查字我们会使用拼音或部首查字法，不认识的字大多使用部首查字法，先查偏旁部首，再通过除偏旁部首以外部分的笔画进行进一步查找，最后找到该字，再进入相关页码查看关于这个字的相关信息。
在语文课上使用的字典，其中的偏偏旁部首就可以看作是此处的 key ， 用偏旁部首查到的字就是我们需要的 value ，可以理解为就是常说的 索引。
dict 的特点：

• 查找和插入速度快，不会因元素数量的增加而降低查找和插入的速度
• 需要占用大量内存空间

dict 的初始化定义日下所示：

dic1 = {key1 : value1, key2 : value2 }
dic2 = {'A' : 10, 123: 20 , 'B': (1 , 2),'C': True , 'D': 'abcd' , 'E':[1 , 2] }

dict 为Python内置的关键字，所以不要以 dict 命名变量
其定义方式为：用大括号定义，其中的关键字和值用 ：(也就是冒号) 分隔开，元素与元素之间用 ，(逗号) 分隔

注意事项：dict 的关键字，也就是key是唯一且不可变的对象

dict 的关键字，又称键值，即 key 可以是任意的不可变数据类型(字符，数字，字符串，元组……)， key 定义完成后不可变且在此 dict 中唯一
每个关键字所对应的 值(value) 也可以是任意数据类型(数字，字符，字符串，布尔类型 ， list(列表)，tuple(元组)……)
回忆前面的知识点我们可以知道，list 是可变的 ， 而 tuple 也就是元组，一经定义完成后就不可变了。所以在字典中，list只能充当value的角色，不能用作key的定义；而tuple可实现两个角色

dict 的访问如下所示：

dic2 = {'A' : 10, 123: 20 , 'B': (1 , 2),'C': True , 'D': 'abcd' , 'E':[1 , 2] }

dic2['A'] , dic2[123] , dic2['E']
#访问字典中的关键字所对应的值

#输出示例
print(dic2['A'])

print(dic2[123])

print(dic2['B'])

dict 的访问格式：名字+方括号，方括号中放 key
输出结果如下：

除了初始化定义 key 所对应的 value 外，也可以通过 key 插入 value，示例如下：

dic2['A'] = True

也可用过此方式修改某 key 所对应的 value，但一定切记！key 值不可变！
添加元素的操作类似（会默认将添加的元素衔接至末尾）：

dic2[(22,22)] = 1024

删除字典中的元素，清空所有项，删除字典

del dic2['A']
#删除dict中指定的key和其对应的value
print(dic2)

dic2.clear()
#清空dict中的所有项
print(dic2)

del dic2
#删除dict

前两个方法运行后的结果如下所示：

注意事项：dict 字典的特性

• dict 的定义中不允许同时出现两个一样的 key ， 如果有两个或更多一样的 key 定义完成，默认会记录最后一个 key
• dict 的 key 一定是不可变对象，可用 list 和 tuple 加深记忆

要查询某个 key 是否存在此 dict 中两种方法：
1.用in 进行判断，返回值为False 或 True；例如：'Z' in dic2
2.用 get 方法进行查询

关于 dict 的内置方法和函数

1.函数

• len(dict)
  ：计算字典中元素的个数，即 key 的个数

• str(dict)
  ：将字典强转为字符串

• type(elem)
  ：返回 elem 的类型，如果 elem 为 dict 则会返回dict

2.方法

• dict.clear()
  ：清空字典中的所有元素

• dict.copy()
  ：浅拷贝dict；具体解释即样例见链接：菜鸟教程对直接赋值和copy的解释

• dict.fromkeys(seq[, value])
  ：有一个名为 seq 的元组，用此方法声明了一个 dict ，其中 dict 的 key 用的是 seq 中的元素 ；value为可选参数，当不选 value 时默认用 None 作为新字典每个 key 所对应的 value ，选上了value就用此值作为所有key所对应的值

• dict.get(key , elem)
  ：elem为可选参数，查找 dict 中 key 所对应的 value ，如果 dict 中没有这个 key 就返回 elem ，elem可为任意值

• dict.items()
  ：返回一个数组，这个数组中的元素是元组tuple ， 数组中的每个元组元素包含字典中的 key 及其对应的 value

• dict.keys()
  ：返回一个 列表list ，此 list 是由 dict 中的所有 key 所组成的；也就是提取 dict 中的所有 key ，用 list 进行封装并返回

• dict.values()
  ：返回一个 列表list ，此 list 是由 dict 中的所有 value 所组成的；也就是提取 dict 中的所有 value ，用 list 进行封装并返回

• dict.setdefault(key, elem)
  ：在 dict 中查找 key 所对用的 value ，找到了则返回此 value；如果没找到，就将此 key 和 elem(也就是此key所对用的value)嵌入至 dict 的末尾，并返回 elem

• dict.update(dict403)
  ：将 dict403 嵌入到 dict 的后面

• dict.pop(key , elem)
  ：删除 dict 中 key 所对应的 value ，并返回此value；如果 key 不存在，则返回elem

• dict.popitem()
  ：删除 dict 中最后面的 key 及其对应的 value， 并返回此 key 和 value；如果dict已经为空了，则报KeyError异常

5.2 set

set 和 dict 类似，但 set 只是一组 key 的集合，没有 value ；和 dict 一样，存放在 set 中的元素只能是 不可变对象！
创建 set 如下所示：

text = set( [1 , 2 , 3] )
#创建一个set ，是用小括号括起来一个list
print(text)

上诉代码段运行结果：

可以使用 add 方法添加元素：

text.add(4)

如果添加了原 set 中已有的元素，则不会有任何效果

可以使用 remove 方法删除元素

text.remove(2)

在数学定义中，我们可以将 set 看作是无序且无重复元素的集合
因此，set 与 set 之间可以做交集、并集等数学计算，下面给出示例：

text1 = set( [1 , 2 , 3] )
text2 = set( [1 , 3 , 5] )

print("交集运算:" ,  text1 & text2)
#交集运算
print("并集运算:" , text1 | text2)
#并集运算

运行结果：

不可变对象

Python 中常见的
可变对象：list ，dict ，set
不可变对象：tuple ，string ，int ，float ，bool
要说到可变对象和不可变对象，绕不开的就必须得讲到地址问题 ， 如果有学过C系列语言的同学觉得很难理解或基本理解，可跳过此小节

1.可变对象：

text1 = [1 , 3 , 5]
#text1是一个可变对象list

text2 = text1
#text2和text1指向同一地址
print("原text1的地址：", id(text1))
print("原text2的地址：", id(text2))
print("原text1: " , text1)
print("原text2: " , text2)


text1[1] = 2
#改变可变对象text1中的某个元素
print("改变元素后text1的地址：", id(text1))
print("改变后的text1: " , text1)
print("text1改变后text2的的值" , text2)
print("text1内的元素改变后，text2的地址：", id(text2))

上述代码运行结果：

可以看到，两个不同的 可变对象 同指一个地址时，当此地址上的保存的内容都发生改变后，两个 可变对象 里的内容都会发生相应改变
而两个 可变对象 的地址都没有发生任何变化

2.不可变对象：

abc1 = (2 , 4 , 6)
#abc1是一个不可变对象tuple

abc2 = abc1
#abc2和abc1指向同一地址
print("原abc1的地址：", id(abc1))
print("原abc2的地址：", id(abc2))
print("原abc1: " , abc1)
print("原abc2: " , abc2)

#因为此处的变量均为不可变对象tuple，所以定义完成后无法改变其中的元素
#所以要改变abc1中的元素只能进行如下操作
abc1 = (1 , 2 , 3)

print("改变元素后abc1的地址：", id(abc1))
print("改变后的abc1: " , abc1)
print("text1改变后abc2的的值" , abc2)
print("text1内的元素改变后，abc2的地址：", id(abc2))

上述代码运行结果：

不可变对象 所指地址上的内容在定义完成后无法进行改变，想要改变已经定义完成的 不可变对象 里的内容，只能重新进行定义，此时这个不可变对象 中的内容和其地址都发生了改变

---

函数：

如果有C系列语言 (笔者对C系列语言最熟悉，所以以此为例) 学习经历的小伙伴对函数应该是比较熟悉了。除了有库中自带的函数，例如数学库中带有一系列数学函数，仅需了解输入值也就是要传递进函数的参数，以及输出值，可以直接进行调用。
除此之外，我们也可以自定义一系列需要的函数，提前将一段代码段进行封装，后面有需要直接进行调用即可。
Python作为主流编程语言的一种，也支持函数，除了自带库中的函数，也可以进行自定义。

1.调用函数

此处给出Python官方函数文档，如有需要可自行查阅
不论是调用已有的库函数，还是调用自定义函数，都需要了解此函数需要传进去的参数个数及参数的具体含义及类型
如果传入的参数数量不对，会报 TypeError 错误；如果参数类型错误，同样会报 TypeError 错误
Python内置函数中，常用的函数也包括数据类型转换函数，也有称之为强制类型转换，下面给出一些简单示例：

a = int(10.2222)
#将浮点类型值10.2222转换成整型，并赋值给a
print(a)

b = float('101.101')
#将字符串值101.101转换成浮点型，并赋值给b
print(b)

c = bool(1)
#将整型1转换成布尔类型，并赋值给c
print(c)

下图为上述代码段输出结果：

2.定义函数

在 Python 中使用 def 语句进行函数定义，格式为：def + 函数名 + 括号 + 括号内为此函数的参数 (参数可以没有，此时可以自定义函数功能，例如延时等）+ 冒号；然后使用缩进格式进行封装
通常情况下自定义函数都需要有返回值，也就是说要使用 return语句 返回此函数得到的结果，所以一旦执行到 return语句 时此自定义函数即执行完毕
也可以不返回任何值，不使用 return语句 ，但此时函数执行完毕后也会返回一个None ，不使用 return 等价于 return None 等价于 return (此return后面没有任何参数)
下面给出一个自定义判断偶数的函数：

def evenNumber(x):
	if(x % 2 == 0)
		return True

前面说到，在调用Python自带的函数时，也就是库中的函数时，Python解释器能够判断用户在调用函数的过程中，传进去的参数个数是不是正确，参数的类型是不是符合所调用函数的要求；这两个要求有一个不满足，就会抛出 TypeError
但是在调用自定义函数时，Python解释器只能判断函数的个数是否符合要求，并不能判断其类型是否满足
所以我们可以说现在的自定义函数不健全
以上述自定义判断偶数的函数为例，我们可以进行如下修改：

def evenNumber(x):
	if not isinstance(x , int):
		raise TypeError('Type error')
	if(x % 2 == 0):
		return True

isinstance(object, classinfo) 函数是用来判断对象 object 是否是已知的类型 classinfo ；其中 classinfo 可以是直接或间接的类名，可以是基本数据类型，也可以是由它们组成的元组；返回值是布尔类型
**raise:**在Python中使用raise可以抛出一个用户指定的异常，只有一个参数，这个参数就是用户指定的异常，在上述例子中 TypeError(‘Type error’) 就是参数
函数返回多个参数时
用户自定义的函数可以返回多个值，下面给出示例：

def abc(x):
	a = 2 * x
	b = 3 * x
	return a , b
#自定义一个函数abc，传入一个参数x，可以返回2*x和3*x的结果

x1 , x2 = abc(20)
#当函数有多个返回值时，可以用相应个数的变量接收
print(x1)
print(x2)

print(abc(10))
#当函数的返回值有多个时，实质上返回的是一个元组tuple

上述实例代码段运行结果：

当函数返回多个参数时，可以用相应数量的变量去接收；但实质上，当一个函数返回多个参数时，此函数返回的是一个元组tuple
不仅限于自定义函数，调用Python自带的函数也是同样的结果

---

持续更新中……