本文是个人python学习笔记，学习资料为廖雪峰python教程，如需更多内容，请移步廖老师官方网站。
一 安装
官网下载安装包安装，安装好之后，在命令提示符输入python进入Python交互模式：
输入exit()退出交互模式。
执行python程序文件，需先切换到文件所在目录下，再执行python 文件名:
二 语法基础
2.1 IO
输入：name=input() ; name=input('请输入姓名：') ；
输出：print('name',name),多个输出内容用逗号间隔；
2.2 编写基础
python用#开头标识注释单行，多行注释用三引号'''...'''，python大小写敏感。一行语句以冒号:结尾时，接下来缩进的语句是代码块，缩进使用4个空格。
字符串文本用单引号、双引号括起来，如果字符串内本身包含单引号（或双引号），则需要使用双引号（或单引号）括起字符串，如果既有'，也有“，则用\转义。
1 name = input('请输入姓名:') 2 print('I"am',name) 3 print("I'am",name) 4 print('I\'am "',name,'\"')
输出多行时，在交互模式下，用三引号'''开头，系统自动换行，提示符从>>>变为...，结束时用'''。
代码中，直接用换行，或用换行符\n。
1 print('''a1 2 a2 3 a3''') 4 5 print('b1\nb2\nb3')
Python中的控制None，相当于数据库中的null。
变量：变量名是大小写、数字、下划线_的组合，不能用数字开头。不需要定义变量的数据类型，变量的数据类型随赋值的数据类型而定，故变量的数据类型是可以更改的。
常量：常量用大写字母定义，但仅为书写习惯，常量的值可以改变。
list:相当于数组，但是可以追加，也可以倒叙访问元素，-1访问最后一个，-2访问倒数第二个。。。
>>> name = ['张三','李四','王五'] >>> name ['张三', '李四', '王五'] >>> name[0] '张三' >>> name[-1] '王五'
>>> name.append('杨7') >>> name[-1] '杨7' >>> len(name) 4
insert()将元素插入指定位置：
>>> name.insert(1,'lily') >>> name ['张三', 'lily', '李四', '王五', '杨7']
pop()删除list末尾元素，pop(i)删除指定位置元素。
注：list元素可以是不同类型，list可以多维
tuple:元祖，初始化之后就不可以改变。当只有一个元素时需用逗号,与数学表达式区分。当元素的list时，list元素可修改。
>>> tmp = (1,) >>> tmp (1,) >>> name2 = ('张三','李四',['lily','may']) >>> name2 ('张三', '李四', ['lily', 'may']) >>> name2[2][0]='莉莉' >>> name2 ('张三', '李四', ['莉莉', 'may'])
dict:键-值（key-value）存储。使用in或get()函数判断key是否存在，通过赋值直接增加键值对，使用pop()函数删除键值对。key不能放入可变对象。
#dict初始化 score = {'张三':89,'李四':59,'王五':92} #使用in判断key是否存在 if '张三' in score: print('张三的成绩是',score['张三']) #使用get(key,returnvalue)函数判断key是否存在，存在则返回value，不存在则返回returnvalue print('李四的成绩是:',score.get('李四','没有李四的成绩')) print('lily的成绩是:',score.get('lily','没有lily的成绩')) #增加一个键值对，放入杨7的成绩 score['杨7'] = 100 print('杨7的成绩是:',score.get('杨7','没有杨7的成绩')) #删除一个键值对 print('目前成绩单是：',score) score.pop('张三') print('删除后的成绩单是：',score)
set:一组无序且不重复的key，创建时需用list输入集合。key不能放入可变对象。可做交集(&)、并集(|)计算。使用add()函数增加key，使用remove()函数删除key。
#set level = set(['A','B','C','D']) print('set level:',level) #增加一个key level.add('E') print('增加后level:',level) #删除一个key level.remove('B') print('删除后level:',level) level2 = set(['A','B']) print('set level2:',level2) print('level与level2的交集：',level&level2) print('level与level2的并集：',level|level2)
除法：/ ; 地板除：// （/的整数部分） ; 取余数：%
不可变对象：str是不变对象，而list是可变对象。对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
a = 'abc' print('替换a：',a.replace('a','A')) print('a:',a) b=a.replace('a','A') print('b:',b)
2.3 字符串与编码
python 3使用Unicode编码字符串，字符串类型str，如果要在网络上传输或保存到磁盘上，需要将str变为字节为单位的bytes类型，数据用带b前缀的单引号或双引号表示。
相关函数：
- ord()：查看单个字符的编码
- chr()：把编码转化为字符
也可用十六进制表示str：
>>> '\u597d' '好' >>>
- encode()：将Unicode编码的str编码为指定的bytes。（中文无法用ascii编码）
>>> 'ABC'.encode('ascii') b'ABC' >>> '大家好'.encode('utf-8') b'\xe5\xa4\xa7\xe5\xae\xb6\xe5\xa5\xbd'
- decode():将网络或磁盘上读取的字节流转变为str
>>> b'ABC'.decode('utf-8') 'ABC' >>> b'ABC'.decode('ascii') 'ABC' >>> b'\xe5\xa4\xa7\xe5\xae\xb6\xe5\xa5\xbd'.decode('utf-8'，errors='ignore') '大家好'
- len()：计算str包含的字符，或bytes包含的字节数
>>> len(b'ABC') 3 >>> len('ABC') 3 >>> len('大家好') 3 >>> len(b'\xe5\xa4\xa7\xe5\xae\xb6\xe5\xa5\xbd') 9 >>> len('大家好'.encode('utf-8')) 9
.py文件包含中文时，需要在文件开头注释使用utf-8编码，并将文件保存为UTF-8 without BOM编码格式：
# -*- coding: utf-8 -*-
占位符：
使用%做占位符：
| 占位符 | 替换内容 |
|---|---|
| %d | 整数 |
| %f | 浮点数 |
| %s | 字符串 |
| %x | 十六进制整数 |
>>> print('%s=%d' % ('1+2',3)) 1+2=3
format():逐一替换字符串占位符{0},{1}...
>>> '{0}={1}'.format('1+2',3) '1+2=3'
2.4 条件判断
遇到第一个为true的判断之后，执行相应的程序块，后续的elif、else将不再执行。
if <条件判断1>: <执行1> elif <条件判断2>: <执行2> elif <条件判断3>: <执行3> else: <执行4>
2.5 循环
for i in ...:
input = input('请输入数值：') max = int(input) #range(max)生成0到max-1的整数序列，再通过list()转化为list list = list(range(max)) print(list) sum = 0 for i in list: sum = sum + i print(sum)
while ...:
input = input('请输入数值：') max = int(input) #range(max)生成0到max-1的整数序列，再通过list()转化为list list = list(range(max)) print(list) sum = 0 n = 0 while n < len(list): sum = sum + list[n] n = n + 1 print(sum)
三 函数
可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”
- 函数定义：def定义，执行之return返回，若不写return，则返回None。交互环境调用时，需要先切换到源程序文件所在目录，执行from abstest import my_abs，然后再调用。
def func1(x): return x*x
- 空函数：如果还没想好代码怎么写，可以用pass占位符，避免运行时的语法错误
def func1(x): pass
- 参数检查：可使用isinstance()做参数的数据类型检查
- 返回多个值：返回一个元组tuple，而多个变量可以同时接收一个tuple，按位置赋给对应的值
1 #一元二次方程求解 2 def quadratic(a, b, c): 3 #b*b也可以写成b**2，表示b的2次方 4 p = b*b - 4*a*c 5 if p >=0: 6 aws = math.sqrt(p)/(2*a) 7 aws1 = (-1)*b/(2*a) + aws 8 aws2 = (-1)*b/(2*a) - aws 9 return aws1,aws2 10 else: 11 #共轭复根 12 aws = math.sqrt(-1*p)/(2*a) 13 aws1 = str((-1)*b/(2*a)) + '+i'+ str(aws) 14 aws2 = str((-1)*b/(2*a)) + '-i'+ str(aws) 15 return aws1,aws2 16 17 print(quadratic(3, 3, 1)) 18 print(quadratic(1, 3, -4))
- 参数：位置参数、默认参数（调用时按顺序赋值，也可以写上参数名）、可变参数（参数前面加了一个
*号，在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数。实参如果是list或tuple，可在前面加个*号，把list或tuple的元素变成可变参数传进去）、关键字参数（关键字参数前面加**表示，允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict）、命名关键字参数（可以传入任意不受限制的关键字参数，同时显示关键字参数名称。*，*后面的参数被视为命名关键字参数）、参数组合（参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数）
1 #-------可变参数 求平方和-------- 2 def cal(*num): 3 sum = 0 4 for n in num: 5 sum = sum + n**2 6 7 return sum 8 9 #调用时参数可变 10 print(cal()) 11 print(cal(1,2)) 12 print(cal(1,2,3)) 13 14 #实参为list的调用方式 15 list = [1,3,5] 16 print(cal(*list))
#--------关键字参数----------- def person(name,sex,age=20,**kw): #kw在函数内部为dict print('name:',name,'sex:',sex,'age:',age,'other:',kw) #调用时可传入0或任意个含参数名的参数,age为默认参数 person('甲','F',city='beijing',grade = 3) person('甲','F',30,city='beijing',grade = 4)
1 #-------------命名关键字参数------------- 2 #city,grade为命名关键字参数，使用标识符,*, 3 def person1(name,sex,*,city,grade): 4 print('name:',name,'sex:',sex,'city:',city,'grade:',grade) 5 6 #调用时命名关键字参数必须传入参数名,用来和位置参数区别 7 person1('甲','F',city='beijing',grade = 3) 8 9 #前面有可变参数时，不需要再使用标识符,*, 10 def person2(name,sex,*args,city,grade): 11 print('name:',name,'sex:',sex,'args:',args,'city:',city,'grade:',grade) 12 13 person2('乙','F',15,20,city='beijing',grade = 3) 14 15 #命名关键字参数有缺省值的，可以简化调用 16 def person3(name,sex,*,age = 20,city,grade): 17 print('name:',name,'sex:',sex,'age:',age,'city:',city,'grade:',grade) 18 #调用时，age有缺省值，可以不给出 19 person3('丙','F',city='beijing',grade = 3)
对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。
递归函数：递归的函数调用通过栈实现，如果调用次数过多会导致栈溢出，python解释器没有对尾递归（在函数返回的时候，调用自身本身，并且，return语句不能包含表达式）进行优化，故python即便使用了尾递归，仍然会栈溢出。
1 #汉诺塔问题 2 def hanoi(n,a,b,c): 3 if n ==1 : 4 print(a,'->',c) 5 else: 6 hanoi(n-1,a,c,b) 7 print(a,'->',c) 8 hanoi(n-1,b,a,c) 9 10 11 hanoi(3,'A','B','C')
四 高级特性
4.1 切片
list、tuple、字符串都可以切片，从而简化代码。例：[0:3]表示取索引0、1、2；默认从0开始，所以也可以写为[:3]；[1:3]表示取1、2；[-2:]表示取-2，-1；[-2]表示取-2。
range()可创建一个整数列表，一般用在for循环中。range(start, stop[, step])，计数从start开始，默认为0，计数到stop-1，不包含stop，step默认为1。
1 #去除字符串首尾的空格 2 def trim(s): 3 while s[0] == ' ': 4 s = s[1:] 5 if len(s) ==0: 6 return s 7 while s[-1] == ' ': 8 s = s[:-2] 9 if len(s) ==0: 10 return s 11 return s
4.2 迭代
判断对象是否可迭代：
>>> from collections import Iterable >>> isinstance('abc', Iterable) # str是否可迭代 True >>> isinstance([1,2,3], Iterable) # list是否可迭代 True >>> isinstance(123, Iterable) # 整数是否可迭代 False
迭代方式：
dict：默认迭代key：for key in d；迭代value：for value in d.values()；同时迭代key-value：for k, v in d.items()
字符串：for ch in 'ABC'迭代每一个字符
Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：for i, value in enumerate(['A', 'B', 'C'])
也支持同时引用了两个变量：for x, y in [(1, 1), (2, 4), (3, 9)]
1 #迭代查找一个list中最小和最大值，并返回一个tuple 2 def findMinAndMax(L): 3 min = L[0] if len(L) != 0 else None 4 max = L[0] if len(L) != 0 else None 5 if len(L) == 0: 6 return (min,max) 7 else: 8 for i in L: 9 if i > max: 10 max = i 11 if i < min: 12 min = i 13 return (min,max)
4.3 列表生成式
列表生成式即List Comprehensions，用户创建list。range(a,b)可生成a到b-1的list。可与for、if配合使用
>>> l = [x * x for x in range(1, 11)] >>> l [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] >>> l = [x * x for x in range(1, 11) if x * x %2 ==0] >>> l [4, 16, 36, 64, 100] >>> l = [x + y for x in 'ABC' for y in 'XY'] >>> l ['AX', 'AY', 'BX', 'BY', 'CX', 'CY']
#list中的字符串字母变小写
L1 = ['Hello', 'World', 18, 'Apple', None] L2 = [x.lower() for x in L1 if isinstance(x,str)]
4.4 生成器
如果list元素特别多时，若直接创建list会占用过多空间。若列表元素可根据某种算法推算出来，则可以在循环的过程中推算出后续的元素。Python中，一边循环一边计算的机制，称为生成器：generator。
创建方法一：将list的[]改为()
>>> l = [x * x for x in range(11)] >>> l [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100] >>> g = (x * x for x in range(11)) >>> g <generator object <genexpr> at 0x0000000000B5B308>
访问元素时，可使用next(g)逐一计算下一个元素，直至没有更多元素时，返回StopIteration错误。也可以使用for n in g访问。
若算法比较复杂，可使用函数实现，并用yield关键字，将函数变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
1 #把杨辉三角每一行看做一个list，试写一个generator，不断输出下一行的list： 2 def triangles(): 3 L = [1] 4 while True: 5 yield L 6 L = [1] + [L[i] + L[i + 1] for i in range(len(L)-1)] + [1]
4.5 迭代器
凡是可作用于for循环的对象都是Iterable类型；
可以使用isinstance()判断一个对象是否是Iterable对象：
1 >>> from collections import Iterable 2 >>> isinstance([],Iterable) 3 True 4 >>> from collections import Iterator
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
可以使用isinstance()判断一个对象是否是Iterator对象：
1 >>> isinstance([],Iterator) 2 False 3 >>> isinstance((x for x in range(0,10)),Iterator) 4 True
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
>>> isinstance(iter([]),Iterator)
True