Python 学习计划

学习链接

lijin-THU Python笔记
 Python练手项目
 如何系统的自学python
自己动手开发网络服务器
 简明python教程
 你是如何自学python的
 廖雪峰python教程


学习计划
廖雪峰Python3教程

python基础 ——————————————————(1)[完成率:0/6]

函数 ————————————————————–(1)[完成率:0/4]

高级特性 ———————————————————(1)[完成率:0/5]

函数式编程 ——————————————————(1)[完成率:0/8]

模块 ————————————————————–(1)[完成率:0/2]

面向对象编程 —————————————————(1)[完成率:0/5]

面向对象高级编程 ———————————————(1)[完成率:0/6]

错误、调试和测试 ———————————————(1)[完成率:0/4]

IO编程 ———————————————————–(1)[完成率:0/4]

进程和线程 ——————————————————(1)[完成率:0/5]

正则表达式 ——————————————————(1)[完成率:0/1]

常用內建模块 —————————————————(1)[完成率:0/10]

常用第三方模块 ————————————————(1)[完成率:0/1]

virtualenv ——————————————————–(1)[完成率:0/1]

GUI —————————————————————(1)[完成率:0/1]

网络编程 ———————————————————(1)[完成率:0/3]

电子邮件 ———————————————————(1)[完成率:0/2]

访问数据库 ——————————————————(1)[完成率:0/3]

Web开发 ———————————————————(1)[完成率:0/5]

自己动手开发网络服务器

自己动手开发网络服务器(一) ———————————-(1)[完成率:0%]

自己动手开发网络服务器(二) ———————————-(1)[完成率:0%]

自己动手开发网络服务器(三) ———————————-(1)[完成率:0%]

笔记

python简介

Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间，为了打发无聊的圣诞节而编写的一个编程语言。
任何编程语言都有缺点，Python也不例外。优点说过了，那Python有哪些缺点呢？

第一个缺点就是运行速度慢。
第二个缺点就是代码不能加密。

输入输出

用print()输出

1
2
3

>>> print("hello,world")
hello world

print()会依次打印每个字符串，遇到逗号“,”会输出一个空格
print 也可以打印整数，或者计算结果。

用input()输入
1
2
>>> name = input()
Michale

练习

请利用print()输出1024 * 768 = xxx：

>>>print ('1024*768 =',1024*768)
('1024*768 =', 786432)
***Repl Closed***

python基础

缩进

例如

# print absolute value of an integer:
a = 100
if a >= 0:
    print(a)
else:
    print(-a)

ps: 缩进为4个空格，大小写敏感

数据类型

整数
浮点数
字符串
转义字符：\n表示换行，\t表示制表符
Python还允许用r’’表示’’内部的字符串默认不转义

例如：

>>> print('\\\t\\')
\       \
>>> print(r'\\\t\\')
\\\t\\

布尔值
布尔值可以用and、or和not运算。

例如：

if age >= 18:
    print('adult')
else:
    print('teenager')

空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值
变量

1 2	x = 10 x = x + 2

如果从数学上理解x = x + 2那无论如何是不成立的，在程序中，赋值语句先计算右侧的表达式x + 2，得到结果12，再赋给变量x。由于x之前的值是10，重新赋值后，x的值变成12。

理解变量在计算机内存中的表示也非常重要
当：

a = 'ABC'

Python解释器干了两件事情：
1.在内存中创建了一个’ABC’的字符串；
2.在内存中创建了一个名为a的变量，并把它指向’ABC’。

a = 'ABC'
b = a
a = 'XYZ'
print(b)

解释：
1.执行a = ‘ABC’，解释器创建了字符串’ABC’和变量a，并把a指向’ABC’
2.执行b = a，解释器创建了变量b，并把b指向a指向的字符串’ABC’
3.执行a = ‘XYZ’，解释器创建了字符串’XYZ’，并把a的指向改为’XYZ’，但b并没有更改
4.所以，最后打印变量b的结果自然是’ABC’了

常量

练习

请打印出以下变量的值：

n = 123
f = 456.789
s1 = ‘Hello, world’
s2 = ‘Hello, \’Adam\’’
s3 = r’Hello, “Bart”‘
s4 = r’’’Hello,
Lisa!’’’

n = 123
f = 456.789
s1 = '\'Hello,world\''
s2 = '\'Hello,\\\'Adam\"'
s3 = 'r\'Hello,"Bart"\''
s4 = 'r\"\'Hello,\nLisa!\"\''
print(n, f, s1, s2, s3, s4)
(123, 456.789, "'Hello,world'", '\'Hello,\\\'Adam"', 'r\'Hello,"Bart"\'', 'r"\'Hello,\nLisa!"\'')
***Repl Closed***

Python支持多种数据类型，在计算机内部，可以把任何数据都看成一个“对象”，而变量就是在程序中用来指向这些数据对象的，对变量赋值就是把数据和变量给关联起来。

注意：Python的整数没有大小限制，而某些语言的整数根据其存储长度是有大小限制的，例如Java对32位整数的范围限制在-2147483648-2147483647。

Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。

字符串和编码

在最新的python3版本中，字符串是以unicode编码的，也就是说，Python的字符串支持多语言，例如：

1 2	>>> print('包含中文的str') 包含中文的str

对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换成对应的字符：

>>> ord('中')
20013
>>> ord('A')
65
>>> chr(66)
'B'
>>> chr(25991)
'文'
>>>

如果知道字符的整数编码，还可以用十六进制这么写：

1 2	>>> '\u4e2d\u6587' '中文'

两种写法是等价的

以Unicode表示的str可以通过encode()方法编码为指定的bytes，例如：

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> '中文'.encode('ascii')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

反过来，如果我们从网络或磁盘中读取到了字节流，那么读到的数据就是bytes,要把bytes编程str,就要用到decode()方法：

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'

要计算str包含了多少个字符，可以用len()函数：

>>> len('ABC')
3
>>> len('中文')
2

len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：

>>> len(b'ABC')
3
>>> len(b'\xe4\xb8\xad\xe6\x96\x87')
6
>>> len('中文'.encode('utf-8'))
6

由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

1 2	#!/usr/bin/env python3 # -- coding: utf-8 --

格式化

如何输出格式化的字符串
我们经常会输出类似’亲爱的xxx你好！你xx月的话费是xx，余额是xx’之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的方式。

在Python中，采用的格式化方式和C语言是一致的，用%实现，举例如下：

>>> 'Hello,%s'%'world'
'Hello,world'
>>> 'Hi,%s,you have $%d.'%('Michael',100000)
'Hi,Michael,you have $100000.'

在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。

常见的占位符有：

%d   -----  整数
%s   ----- 字符串
%f   ----- 浮点数
%x  -----  十六进制整数

其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

>>> '%2d-%02d' % (3, 1)
' 3-01'
>>> '%.2f' % 3.1415926
'3.14'

如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：

1 2	>>> 'Age:%s,Gender:%s'%(25,True) 'Age:25,Gender:True'

有些时候，字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%：

1 2	>>> 'growth rate:%d %%'%7 'growth rate:7 %'

练习：
小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，并用字符串格式化显示出’xx.x%’，只保留小数点后1位：

s1 = 72
s2 = 85
r = ???
print('???' % r)
s1 = int(72)
s2 = int(85)
r = (s2-s1)/s1*100
print ('小明成绩提升的百分点为:%.1f %%'%r)
>>> print ('小明成绩提升的百分点为:%.1f %%'%r)
小明成绩提升的百分点为:18.1 %

使用list和tuple

list
python內置的的一种数据类型是列表：list.
list是一种有序的集合，可以随时添加和删除其中的元素。
比如列出班上的所有同学：

1
2
3

>>> classmate = ['Michael','Bob','Tracy']
>>> classmate
['Michael', 'Bob', 'Tracy']

变量classmate就是一个list,用len()函数可以获得list元素的个数：

1 2	>>> len(classmate) 3

用索引来访问list中的每一个元素：

>>> classmate[0]
'Michael'
>>> classmate[1]
'Bob'
>>> classmate[2]
'Tracy'
>>> classmate[-1]
'Tracy'
>>> classmate[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> classmate[-2]
'Bob'
>>> classmate[-3]
'Michael'
>>> classmate[-4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

list是一个可变的有序列表，所以可以往list中追加元素至列表末尾：

1
2
3

>>> classmate.append('Adam')
>>> classmate
['Michael', 'Bob', 'Tracy', 'Adam']

也可以把元素插入到指定的位置，比如索引号为1的位置：

1
2
3

>>> classmate.insert(1,'Jack')
>>> classmate
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要删除list末尾的元素，用pop()方法：

>>> classmate.pop()
'Adam'
>>> classmate
['Michael', 'Jack', 'Bob', 'Tracy']

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

>>> classmate.pop(1)
'Jack'
>>> classmate
['Michael', 'Bob', 'Tracy']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

1
2
3

>>> classmate[1]='Sarah'
>>> classmate
['Michael', 'Sarah', 'Tracy']

list里面的元素的数据类型也可以不同，比如：

1	>>> L = ['Apple', 123, True]

list元素也可以是另一个list，比如：

>>> p = ['asp','php']
>>> s = ['python','java',p,'scheme']
>>> s
['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

如果一个list中一个元素也没有，就是一个空的list，它的长度为0：

1
2
3

>>> L = []
>>> len(L)
0

tuple
另一种有序列表叫元组：tuple。tuple和list类似，但tuple一旦初始化就不能修改。
要定义一个只有1个元素的tuple，如果你这么定义：

1
2
3

>>> t = (1)
>>> t
1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

1
2
3

>>> t = (1,)
>>> t
(1,)

最后来看一个“可变的”tuple：

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

练习
请用索引取出下面list的指定元素：

# -*- coding: utf-8 -*-
L = [
    ['Apple', 'Google', 'Microsoft'],
    ['Java', 'Python', 'Ruby', 'PHP'],
    ['Adam', 'Bart', 'Lisa']
]

答案：

>>> L[0][0]
'Apple'
>>> L[1][1]
'Python'
>>> L[2][2]
'Lisa'

条件判断

if
比如，输入用户年龄，根据年龄打印不同的内容，在Python程序中，用if语句实现：

>>> age = 20
>>> if age >= 18:
...     print('your age is',age)
...     print('adult')
... 
your age is 20
adult
age = 3
if age >= 18:
    print('your age is', age)
    print('adult')
else:
    print('your age is', age)
    print('teenager')

当然上面的判断是很粗略的，完全可以用elif做更细致的判断：

>>> age = 3
>>> if age >= 18:
...     print('adult')
... elif age >= 6:
...     print('teenager')
... else:
...     print('kid')
... 
kid

if判断条件还可以简写，比如写：

1 2	if x: print('True')

只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False

再议input

>>> if birth < 2000:
...     print('00前')
... else:
...     print('00后')
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() < int()

这是因为input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。Python提供了int()函数来完成这件事情：

>>> birth = int(input('birth:'))
birth:1994
>>> if birth < 2000:
...     print('00前')
... else:
...     print('00后')
... 
00前

练习

小明身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮小明计算他的BMI指数，并根据BMI指数：

低于18.5：过轻
18.5-25：正常
25-28：过重
28-32：肥胖
高于32：严重肥胖
用if-elif判断并打印结果：

答案：

>>> height = 1.75
>>> weight = 80.5
>>> BMI = weight/height**2
>>> BMI
26.285714285714285
>>> if BMI > 32 :
...     print('严重肥胖')
... elif 28 < BMI < 32:
...     print('肥胖')
... elif 25 < BMI < 28:
...     print('过重')
... elif 18.5 < BMI < 25:
...     print('正常')
... else:
...     print('过轻')
... 
过重

循环

Python的循环有两种，一种是for…in循环，依次把list或tuple中的每个元素迭代出来，看例子：

>>> name = ['Michael','Bob','Tracy']
>>> for names in name:
...     print(names)
... 
Michael
Bob
Tracy

所以for x in …循环就是把每个元素代入变量x，然后执行缩进块的语句。

再比如我们想计算1-10的整数之和，可以用一个sum变量做累加：

>>> x = [1,2,3,4,5,6,7,8,9,10]
>>> for i in x:
...     sum = sum + i
...     print(sum)
... 
1
3
6
10
15
21
28
36
45
55

如果要计算1-100的整数之和，从1写到100有点困难，幸好Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数：

>>> list(range(5))
[0, 1, 2, 3, 4]
>>> sum = 0
>>> for x in range(101):
...     sum = sum + x
...     print(sum)
... 
......
......
4753
4851
4950
5050

第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。比如我们要计算100以内所有奇数之和，可以用while循环实现：

>>> while n > 0:
...     sum = sum + n 
...     n = n - 2
...     print (sum)
... 
2484
2491
2496
2499
2500

练习
请利用循环依次对list中的每个名字打印出Hello, xxx!：

1	L = ['Bart','Lisa','Adam']

答案

>>> L = ['Bart','Lisa','Adam']
>>> for i in L:
...     print('Hello,',i,'!')
... 
Hello, Bart !
Hello, Lisa !
Hello, Adam !

break

在循环中，break语句可以提前退出循环。例如，本来要循环打印1～100的数字
如果要提前结束循环，可以用break语句：

>>> n = 1
>>> while n <=100:
...     if n >10:
...             break
...     print(n)
...     n = n + 1
...     print('END')
... 
1
END
2
END
3
END
4
END
5
END
6
END
7
END
8
END
9
END
10
END

continue

在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。

>>> n = 0
>>> while n < 10:
...     n = n+1
...     if n % 2 == 0:
...             continue
...     print(n)
... 
1
3
5
7
9

小结

循环是让计算机做重复任务的有效的方法。

break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，并直接开始下一轮循环。这两个语句通常都必须配合if语句使用。

要特别注意，不要滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句，上面的两个例子，都可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。

有些时候，如果代码写得有问题，会让程序陷入“死循环”，也就是永远循环下去。这时可以用Ctrl+C退出程序，或者强制结束Python进程。

请试写一个死循环程序。

使用dict和set

如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：

>>> d = {'Michael':85,'Bob':75,'Tracy':85}
>>> d
{'Bob': 75, 'Michael': 85, 'Tracy': 85}
>>> d['Michael']
85

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88
>>> d['Jack']
88

如果key不存在，dict就会报错：

>>> d['Thomas']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Thomas'

要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

1 2	>>> 'Thomas' in d False

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

>>> d.pop('Bob')
75
>>> d
{'Michael': 85, 'Tracy': 85}

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

>>> key = [1, 2, 3]
>>> d[key] = 'a list'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

set
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

要创建一个set，需要提供一个list作为输入集合：

1
2
3

>>> s = set([1,2,3])
>>> s
{1, 2, 3}

重复元素在set中自动被过滤:

1
2
3

>>> s = set([1,1,2,2,3,3])
>>> s
{1, 2, 3}

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

通过remove(key)方法可以删除元素：

1
2
3

>>> s.remove(1)
>>> s
{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}

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。

再议不可变对象

对于可变对象，比如list，对list进行操作，list内部的内容是可以变化的，而对于不可变对象，例如str

>>> a.replace('a','A')
'Abc'
>>> a
'abc'

要始终牢记的是，a是变量，而’abc’才是字符串对象！有些时候，我们经常说，对象a的内容是’abc’，但其实是指，a本身是一个变量，它指向的对象的内容才是’abc’.
所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。