注:本只为学习廖雪峰老师的教程所做笔记,方便个人以后查找。如需学习,请移步到下列网站链接,禁止转载。
https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000
1 Python简介
Python为我们提供了非常完善的基础代码库,覆盖了网络、文件、GUI、数据库、文本等大量内容,被形象地称作“内置电池(batteries included)”。用Python开发,许多功能不必从零编写,直接使用现成的即可。
除了内置的库外,Python还有大量的第三方库,也就是别人开发的,供你直接使用的东西。当然,如果你开发的代码通过很好的封装,也可以作为第三方库给别人使用。
2 Python解释器
2.1 CPython
当我们从Python官方网站下载并安装好Python 3.5后,我们就直接获得了一个官方版本的解释器:CPython。这个解释器是用C语言开发的,所以叫CPython。在命令行下运行python就是启动CPython解释器。
CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。
2.2 IPython
IPython是基于CPython之上的一个交互式解释器,也就是说,IPython只是在交互方式上有所增强,但是执行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同,但内核其实都是调用了IE。
CPython用>>>作为提示符,而IPython用In [序号]:作为提示符。
2.3 PyPy
PyPy是另一个Python解释器,它的目标是执行速度。PyPy采用JIT技术,对Python代码进行动态编译(注意不是解释),所以可以显著提高Python代码的执行速度。
绝大部分Python代码都可以在PyPy下运行,但是PyPy和CPython有一些是不同的,这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行,就需要了解PyPy和CPython的不同点。
2.4 Jython
Jython是运行在Java平台上的Python解释器,可以直接把Python代码编译成Java字节码执行。
2.5 IronPython
IronPython和Jython类似,只不过IronPython是运行在微软.Net平台上的Python解释器,可以直接把Python代码编译成.Net的字节码。
3 输入与输出
3.1 输出
用print()
在括号中加上字符串,就可以向屏幕上输出指定的文字。比如输出'hello, world'
,用代码实现如下:
>>> print('hello, world')
3.2 输入
Python提供了一个input()
,可以让用户输入字符串,并存放到一个变量里。
>>> name = input()
input()可以让你显示一个字符串来提示用户:
>>> name = input('please enter your name: ')
4 Python基础
(1)Python的语法比较简单,采用缩进方式。
(2)以#开头的语句是注释。
(3)Python程序是大小写敏感的。
4.1 数据类型
(1)整数:十六进制0xff00、0xa5b4c3d2.
(2)浮点数:科学计数1.23e9、1.2e-5.
(3)布尔值:true、false。
(4)字符串:单引号、双引号、‘\’转义字符、多行字符串”’…”’、r”表示”内部的字符串默认不转义。
(5)空值None
。
(6)变量:这里处理方式和C很不一样。
a = 'ABC'
b = a
a = 'XYZ'
print(b)
4.2 字符串和编码
(1)ASCII编码是1个字节,而Unicode编码通常是2个字节。
(2)本着节约的精神,又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符,用UTF-8编码就能节省空间。
(3)UTF-8编码有一个额外的好处,就是ASCII编码实际上可以被看成是UTF-8编码的一部分,所以,大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。
(4)在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。
(5)用记事本编辑的时候,从文件读取的UTF-8字符被转换为Unicode字符到内存里,编辑完成后,保存的时候再把Unicode转换为UTF-8保存到文件:
4.3 Python字符串
(1)在最新的Python 3版本中,字符串是以Unicode编码的。
(2)Python提供了ord()
函数获取字符的整数表示,chr()
函数把编码转换为对应的字符:
>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'
(3)由于Python的字符串类型是str
,在内存中以Unicode表示。Python对bytes
类型的数据用带b前缀的单引号或双引号表示:
x = b'ABC'
(4)以Unicode表示的str
通过encode()
方法可以编码为指定的bytes
:
>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
(5)要把bytes变为str,就需要用decode()方法:
>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'
(6)要计算str包含多少个字符,可以用len()函数:
>>> len('ABC')
3
>>> len('中文')
2
(7)当Python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
(8)格式化
常见的占位符有:
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数
4.4 list
list是一种有序的集合,可以随时添加和删除其中的元素。
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']
(1)用len()函数可以获得list元素的个数:len(classmates)
(2)用索引来访问list中每一个位置的元素,记得索引是从0开始的:classmates[0]
(3)如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素:classmates[-1]
(4)往list中追加元素到末尾:classmates.append('Adam')
.
(5)把元素插入到指定的位置,比如索引号为1的位置:classmates.insert(1, 'Jack')
(6)删除list末尾的元素,用pop()方法:classmates.pop()
(7)删除指定位置的元素,用pop(i)方法,其中i是索引位置:classmates.pop(1)
(8)把某个元素替换成别的元素,可以直接赋值给对应的索引位置:classmates[1] = 'Sarah'
(9)list里面的元素的数据类型也可以不同,比如:>>> L = ['Apple', 123, True]
(10)list元素也可以是另一个list,比如:s = ['python', 'java', ['asp', 'php'], 'scheme']
4.5 tuple
另一种有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改,
>>> classmates = ('Michael', 'Bob', 'Tracy')
classmates这个tuple不能变了,它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用classmates[0],classmates[-1],但不能赋值成另外的元素。
“可变的tuple”:
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
4.6 条件判断
在Python程序中,用if
语句实现:注意不要少写了冒号:
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>
4.7 循环
(1)一种是for x in ...
循环,依次把list或tuple中的每个元素迭代出来
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)
常用的range()
函数,可以生成一个整数序列,再通过list()
函数可以转换为list。比如range(5)
生成的序列是从0开始小于5的整数:
>>> list(range(5))
[0, 1, 2, 3, 4]
(2)第二种循环是while循环,只要条件满足,就不断循环,条件不满足时退出循环。
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print(sum)
4.8 dict
Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
(1)把数据放入dict的方法,除了初始化时指定外,还可以通过key放入:
>>> d['Adam'] = 67
>>> d['Adam']
67
(2)如果key不存在,dict就会报错:
>>> d['Thomas']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Thomas'
(3)要避免key不存在的错误,有两种办法
①通过in判断key是否存在:
>>> 'Thomas' in d
False
②通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value:
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
(4)要删除一个key,用pop(key)方法,对应的value也会从dict中删除:
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}
4.9 set
set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。
(1)要创建一个set,需要提供一个list作为输入集合:
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
(2)通过add(key)
方法可以添加元素到set中,可以重复添加,但不会有效果:
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
(3)通过remove(key)方法可以删除元素:
>>> s.remove(4)
>>> s
{1, 2, 3}
(4)set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
str是不变对象,而list是可变对象。
5 函数
5.1 调用函数
Python内置了很多有用的函数,我们可以直接调用。
http://docs.python.org/3/library/functions.html#abs
也可以在交互式命令行通过help(abs)
查看abs
函数的帮助信息。
类型数据转换:
>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False
5.2 定义函数
定义一个函数要使用def
语句,依次写出函数名、括号、括号中的参数和冒号:
,然后,在缩进块中编写函数体,函数的返回值用return
语句返回。
def my_abs(x):
if x >= 0:
return x
else:
return -x
return None
可以简写为return
。
5.3 函数的参数
5.3.1 位置参数
对于power(x)
函数,参数x就是一个位置参数。power(x, n)
函数,可以计算任意n次方:
5.3.2 默认参数
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
有多个默认参数时,调用的时候,既可以按顺序提供默认参数,比如比如调用enroll('Bob', 'M', 7)
;
也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时,需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin')
,意思是,city参数用传进去的值,其他默认参数继续使用默认值。
注:定义默认参数要牢记一点:默认参数必须指向不变对象!
这里的例子,感觉廖雪峰老师讲的不太明白。
可以用None这个不变对象来实现:
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
5.3.3 可变参数
可变参数就是传入的参数个数是可变的。
(1)传入lsit或者tuple
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
调用时,组装一个list或者tuple:
>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84
(2)如果利用可变参数,我们把函数的参数改为可变参数:
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
调用函数的方式可以简化成这样:
>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84
注:定义可变参数和定义一个list或tuple参数相比,仅仅在参数前面加了一个*
号。!
(3)如果已经有一个list或者tuple,要调用一个可变参数怎么办?
>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14
或者:Python允许你在list或tuple前面加一个*
号,把list或tuple的元素变成可变参数传进去:
>>> nums = [1, 2, 3]
>>> calc(*nums)
14
注:可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple。
5.3.4 关键字参数
注:关键字参数在函数内部自动组装为一个dict。
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
函数person
除了必选参数name
和age
外,还接受关键字参数kw
。
(1)在调用该函数时,可以只传入必选参数:
>>> person('Michael', 30)
name: Michael age: 30 other: {}
(2)也可以传入任意个数的关键字参数:
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
(3)和可变参数类似,也可以先组装出一个dict,然后,把该dict转换为关键字参数传进去:
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
(4)上面复杂的调用可以用简化的写法:
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
注:**extra
表示把extra
这个dict
的所有key-value用关键字参数传入到函数的**kw
参数,kw
将获得一个dict,注意kw
获得的dict是extra
的一份拷贝,对kw
的改动不会影响到函数外的extra
。
5.3.5 命名关键字参数
如果要限制关键字参数的名字,就可以用命名关键字参数,例如,只接收city和job作为关键字参数。
def person(name, age, *, city, job):
print(name, age, city, job)
(1)和关键字参数**kw
不同,命名关键字参数需要一个特殊分隔符*
,*
后面的参数被视为命名关键字参数。
调用方式如下:
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
(2)如果函数定义中已经有了一个可变参数,后面跟着的命名关键字参数就不再需要一个特殊分隔符*
了:
def person(name, age, *args, city, job):
print(name, age, args, city, job)
(3)命名关键字参数必须传入参数名,这和位置参数不同。如果没有传入参数名,调用将报错:
(4)命名关键字参数可以有缺省值,从而简化调用:
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)
注:使用命名关键字参数时,要特别注意,如果没有可变参数,就必须加一个*
作为特殊分隔符。如果缺少*
,Python解释器将无法识别位置参数和命名关键字参数
5.3.6 关键字组合
默认参数一定要用不可变对象,如果是可变对象,程序运行时会有逻辑错误!
要注意定义可变参数和关键字参数的语法:
*args
是可变参数,args接收的是一个tuple;
**kw
是关键字参数,kw接收的是一个dict。
定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*
,否则定义的将是位置参数。
5.4 递归函数
(1)fact(n)用递归的方式写出来就是:
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
使用递归函数需要注意防止栈溢出
(2)解决递归调用栈溢出的方法是通过尾递归优化,事实上尾递归和循环的效果是一样的。
注:尾递归是指,在函数返回的时候,调用自身本身,并且,return语句不能包含表达式
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)