一、开始 Python 之旅交互模式
1.Ctrl + D 输入一个 EOF 字符来退出解释器，也可以键入 exit() 来退出
2.#!/usr/bin/env python3 中#!称为 Shebang，目的是告诉shell使用Python 解释器执行其下面的代码。
3.注意遵守以下约定：
- 使用 4 个空格来缩进
- 永远不要混用空格和制表符
- 在函数之间空一行
- 在类之间空两行
- 字典，列表，元组以及参数列表中，在 , 后添加一个空格。对于字典，: 后面也添加一个空格
- 在赋值运算符和比较运算符周围要有空格（参数列表中除外），但是括号里侧不加空格：a = f(1, 2) + g(3, 4)
4.模块是包含能复用的代码的文件，包含了不同的函数定义，变量。模块文件通常以 .py 为扩展名，在使用模块前先导入它。
二、变量和数据类型
1.关键字（不能用于通常的标识符）
2.定义变量
不需要为变量指定数据类型，操作字符串时用单引号或双引号括起来
3.从键盘读取输入
number = int(input("Enter an integer: "))4.在一行内将多个值赋值给多个变量
>>> a , b = 4, 5
>>> a
4
>>> b
5用逗号创建元组，在赋值语句的右边创建元组称这为元组封装（tuple packing），赋值语句的左边做的是元组拆封 （tuple unpacking）。
三、运算符和表达式
divmod()
divmod()函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)：
若现在通过获得用户输入的天数，算出月份数和天数，则可以使用该函数轻松get到答案：
#!/usr/bin/env python3
days = int(input("Enter days: "))
print("Months = {} Days = {}".format(*divmod(days, 30))) 用 * 运算符拆封这个元组
整除
如果要进行整除，使用 // 运算符，它将返回商的整数部分：
思考：如果是12 / 3，结果是多少呢？大家一定会说是不是傻？肯定是4啊！那试试呗：
和你想的不一样吧！所以/不管是不是整除，结果都是浮点数。
逻辑运算符
逻辑运算符 and 和 or 也称作短路运算符：它们的参数从左向右解析，一旦结果可以确定就停止 。作用于一个普通的非逻辑值时，短路运算符的返回值通常是能够最先确定结果的那个操作数。
| 运算符 | 逻辑表达式 | 描述 |
|---|---|---|
| and | x and y | 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 |
| or | x or y | 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 |
| not | not x | 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 |
>>> 5 and 4 (5为True还要往后看，所以最先确定的操作数是4)
4
>>> 0 and 4 (0为False不需往后看，所以最先确定的操作数是0)
0
>>> False or 3 or 0 (False还要往后看，3为True不需往后看，所以最先确定的操作数是3)
3运算符优先级
类型转换
类型转换中，int、float转字符串用str()就行了，非常容易理解，字符串是"数字"字符串（‘1234‘)转int也好理解，但如果是字符串‘a‘呢？可能你会想到ASCII，用int(‘a‘)可以吗？
结果显示不可以，所以，再恶补点知识吧!
1.十进制字符串转整数
int(‘12‘) ==12
2.十六进制字符转整数
int(‘a‘,16) == 10
例MAC地址转整数：
a=‘FF:FF:FF:FF:FF:FF‘.split(:)
int(a[0],16) = 255
int(a[1],16) = 255
int(a[2],16) = 255
int(a[3],16) = 255
int(a[4],16) = 255
int(a[5],16) = 255
3.字符转整数
ord(‘a‘)==97
4.整数转为字符
chr(65) == ‘A‘
四、循环
range()
range() 生成一个等差数列（并不是列表）：
>>> for i in range(3):
... print(i)
...
0
1
2
>>> range(1, 5)
range(1, 5)
>>> list(range(1, 5))
[1, 2, 3, 4]
>>> list(range(1, 15, 3))
[1, 4, 7, 10, 13]循环的 else 语句
可以在循环后面使用可选的 else 语句，它将会在循环完毕后执行，除非有 break 语句终止了循环。
斐波那契（Fibonacci）数列
Python 中赋值语句执行时会先对赋值运算符右边的表达式求值，然后将这个值赋值给左边的变量。
如果要把结果输出不换行呢？print() 除了打印提供的字符串之外，还会打印一个换行符，所以每调用一次 print() 就会换一次行。可以通过参数 end 来替换换行符：
a, b = 0, 1
while b < 100:
print(b, end=‘ ‘)
a, b = b, a + b
print()
幂级数：e^x = 1 + x + x^2 / 2! + x^3 / 3! + ... + x^n / n! （0 < x < 1）
#!/usr/bin/env python3
x = float(input("Enter the value of x: "))
n = term = num = 1
result = 1.0
while n <= 100:
term *= x / n
result += term
n += 1
if term < 0.0001:
break
print("No of Times= {} and Sum= {}".format(n, result))打印图形
print("#" * 50)字符串若是乘上整数 n，则返回由 n 个此字符串拼接起来的新字符串。如要打印出下图：
row = int(input("Enter the number of rows: "))
n = row
while n >= 0:
x = "*" * n
y = " " * (row - n)
print(y + x)
n -= 1五、数据结构
列表
列表可以写作中括号之间的一列逗号分隔的值。列表的元素不必是同一类型，通过索引来访问列表中的每一个值，列表允许修改元素，允许嵌套。
a.append() 添加元素到列表的末端
a.insert(0, 1) 在列表索引 0 位置添加元素 1
a.count(s) 返回列表中 s 元素出现的次数。
a.remove(s) 移除列表中s元素
a.pop(n) 返回索引为n的元素并把它从列表中删除，无参数时默认最后一个元素
del a[n] 删除索引为n的列表元素
a.reverse() 反转整个列表
a.sort() 给列表排序，排序的前提是列表的元素是可比较的
a.extend(b) 将b列表的所有元素添加到a列表末尾，注意是添加 b 的元素而不是 b 本身
思考：如果列表中有相同的元素，用remove删除的是前面那个还是后面那个，亦或是全删除呢？实践一下呗！
列表推导式由包含一个表达式的中括号组成，表达式后面跟随一个 for 子句，之后可以有零或多个 for 或 if 子句。结果是一个列表，由表达式依据其后面的 for 和 if 子句上下文计算而来的结果构成。以下两种方式等同：
列表推导式也可以嵌套：
>>> a=[1,2,3]
>>> z = [x + 1 for x in [x ** 2 for x in a]]
>>> z
[2, 5, 10]如果在遍历列表（或任何序列类型）的同时获得元素索引值，可以使用 enumerate()：
>>> for i, j in enumerate([‘a‘, ‘b‘, ‘c‘]):
... print(i, j)
...
0 a
1 b
2 c同时遍历两个序列类型可以使用zip() :
>>> a = [‘a‘, ‘b‘]
>>> b = [‘c‘, ‘d‘]
>>> for x, y in zip(a, b):
... print("{} and {}".format(x, y))元祖
元组是由数个逗号分割的值组成，且为不可变类型，意味着不能在元组内删除或添加或编辑任何值。
>>> a = ‘a‘, ‘b‘, ‘c‘,
>>> a
(‘a‘, ‘b‘, ‘c‘)创建只含有一个元素的元组，在值后面跟一个逗号，这是因为括号()既可以表示元组，又可以表示数学公式中的小括号，这就产生了歧义。
>>> a = (123) 这样定义的将是123这个元素，而不是一个元组。
>>> a
123
>>> type(a)
<class ‘int‘>
>>> a = (123, )
>>> b = 321,
>>> a
(123,)
>>> b
(321,)
>>> type(a)
<class ‘tuple‘>
>>> type(b)
<class ‘tuple‘>可以对任何一个元组执行拆封操作并赋值给多个变量，注意赋值时数量要匹配：
集合
集合是一个无序不重复元素的集，大括号或 set() 可以用来创建集合
>>> basket = {‘apple‘, ‘orange‘, ‘apple‘, ‘pear‘, ‘orange‘, ‘banana‘}
>>> print(basket) 可以看到重复的元素被去除
{‘orange‘, ‘banana‘, ‘pear‘, ‘apple‘}
>>> a = set(‘abracadabra‘)
>>> b = set(‘alacazam‘)
>>> a
{‘a‘, ‘r‘, ‘b‘, ‘c‘, ‘d‘} a 去重后的字母
>>> a - b a 有而 b 没有的字母
>>> a | b 存在于 a 或 b 的字母
>>> a & b a 和 b 都有的字母
>>> a ^ b 存在于 a 或 b 但不同时存在的字母
>>> a.add(‘c‘)
>>> a
{‘c‘，a‘, ‘r‘, ‘b‘, ‘c‘, ‘d‘} 不同于列表的append()，在起始位置添加
字典
字典是是无序的键值对（key:value）集合，同一个字典内的键必须是互不相同的。一对大括号 {}创建一个空字典。字典中的键必须是不可变类型，比如不能使用列表作为键。
>>> data = {‘kushal‘:‘Fedora‘, ‘kart_‘:‘Debian‘, ‘Jace‘:‘Mac‘}
>>> data[‘kart_‘]
‘Debian‘
>>> data[‘parthan‘] = ‘Ubuntu‘ 创建新的键值对
>>> data
{‘kushal‘: ‘Fedora‘, ‘Jace‘: ‘Mac‘, ‘kart_‘: ‘Debian‘, ‘parthan‘: ‘Ubuntu‘}
>>> del data[‘kushal‘] del 删除任意指定的键值对
>>> data
{‘Jace‘: ‘Mac‘, ‘kart_‘: ‘Debian‘, ‘parthan‘: ‘Ubuntu‘
>>> dict(((‘In‘,‘Del‘),(‘Bang‘,‘Dh‘))) dict() 从包含键值对的元组中创建字典
{‘In‘: ‘Del‘, ‘Bang‘: ‘Dh‘}
>>> for x, y in data.items(): items()获得由键和值组成的列表
... print("{} uses {}".format(x, y))
dic.clear()清空字典
dic.keys()获得键的列表
dic.values()获得值的列表
dic.copy()复制字典
dic.pop(k)删除键k
dic.get(k)获得键k的值
dic.update()更新成员，若成员不存在，相当于加入 很多时候需要往字典中的元素添加数据，使用dict.setdefault(key, default)：
>>> data = {}
>>> data.setdefault(‘names‘, []).append(‘Ruby‘)
>>> data
{‘names‘: [‘Ruby‘]}
>>> data.setdefault(‘names‘, []).append(‘Python‘)
>>> data
{‘names‘: [‘Ruby‘, ‘Python‘]}
>>> data.setdefault(‘names‘, []).append(‘C‘)
>>> data
{‘names‘: [‘Ruby‘, ‘Python‘, ‘C‘]}更多详见：
Python中的列表（list），元组（Tuple），字典（Dict）和集合（Set）、Python列表、元组、集合、字典的区别和相互转换
切片
切片的语法表达式为[start_index : end_index : step]：
- start_index表示起始索引
- end_index表示结束索引
- step表示步长，步长不能为0，且默认值为1
切片操作是指按照步长，截取从起始索引到结束索引，但不包含结束索引的所有元素。
- python3支持切片操作的数据类型有list、tuple、string、unicode、range
- 切片返回的结果类型与原对象类型一致
- 切片不会改变原对象，而是重新生成了一个新的对象
切片的索引可分为正向和负向两种：
举个例子：
>>> C = [‘A‘,‘B‘,‘C‘,‘D‘,‘E‘,‘F‘]
>>> C[0:5:1]
[‘A‘, ‘B‘, ‘C‘, ‘D‘，‘E‘]
省略 start_index 会从第一个元素开始，省略 end_index 会切到最后一个元素为止：
>>> C[2:]
[‘C‘, ‘D‘, ‘E‘, ‘F‘]步长为负数时即为逆着切，一定要保证start_index到end_index的方向与步长step的方向同向，否则会切出空的序列：
>>> C[0:3:-1]
[]
>>> C[3:0:1]
[]数据结构举例
1.判断学生成绩是否达标:要求输入学生数量，以及各个学生物理、数学、历史三科的成绩，如果总成绩小于 120，程序打印 “failed”，否则打印 “passed”。
n = int(input("Enter the number of students: "))
data = {} 用来存储数据的字典变量
Subjects = (‘Physics‘, ‘Maths‘, ‘History‘)
for i in range(1, n+1):
name = input(‘Enter the name of the student {}: ‘.format(i))
marks = []
for x in Subjects:
marks.append(int(input(‘Enter marks of {}: ‘.format(x))))
data[name] = marks
for x, y in data.items():
total = sum(y)
print("{}‘s total marks {}".format(x, total))
if total < 120:
print(x, "failed :(")
else:
print(x, "passed :)")运行如下：
2.用以下代码解决矩阵问题：
n = int(input("Enter the value of n: "))
print("Enter values for the Matrix A")
a = []
for i in range(n):
a.append([int(x) for x in input().split()])
print(a)
其实这里不太理解为什么最后结果为列表嵌套列表(str.split(str="", num=string.count(str))，str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等，num -- 分割次数），而且以为这是生成 n × n 的矩阵，所以进行以下实践：
可以看出，split()最后拆成的是列表，以换行符结束一次循环，并不是生成n × n 的矩阵。相对于split()，join()使用指定字符连接多个字符串，它需要一个包含字符串元素的列表作为输入，然后连接列表内的字符串元素：
>>> "-".join("GNU/Linux is great".split())基于空格分割字符串（列表），再用 "-" 连接
‘GNU/Linux-is-great‘六、字符串
三引号（triple quotes）
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
>>> h = ‘‘‘hi
Jspo‘‘‘
>>> hi
‘hi\nJspo‘
>>> print hi
hi
Jspo 三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。一个典型的用例是，当需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。
此外，在 Python 里使用文档字符串（docstrings）来说明如何使用代码：
def longest_side(a, b):
"""
Function to
"""
return True字符串常用操作
string.title() 返回字符串的标题版本，即单词首字母大写其余字母小写
string.upper() 返回字符串全部大写版本
string.lower() 返回字符串全部小写版本
string.swapcase() 返回字符串大小写交换后的版本
string.isalnum() 检查所有字符是否为字母数字
string.isalpha() 检查字符串之中是否只有字母
string.isdigit() 检查字符串是否所有字符为数字strip(chars)用来剥离字符串首尾中指定的字符，不指定参数则默认剥离掉首尾的空格和换行符。用 lstrip(chars) 或 rstrip(chars) 只对字符串左或右剥离:
>>> s = "www.foss.in"
>>> s.lstrip("cwsd.") 删除在字符串左边出现的‘c‘,‘w‘,‘s‘,‘d‘,‘.‘字符
‘foss.in‘
>>> s.rstrip("cnwdi.") 删除在字符串右边出现的‘c‘,‘n‘,‘w‘,‘d‘,‘i‘,‘.‘字符
‘www.foss‘文本搜索
find() 能帮助找到第一个匹配的子字符串，没有找到则返回 -1。string.find(str, beg=0, end=len(string))
检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1。
s.startswith(str) 检查字符串是否以 str 开头
s.endswith(str) 检查字符串是否以 str 结尾字符串更多操作详见：Python 字符串
例题（挑战：字符串操作）
String.txt文件内容为awe3fa8fa4aewfawijfa;fjaweawfeawawefargaefaef5awefasdfeargfasdcds2awea4afadszsdvzxefafzsdva7fasdczdvafedszv6zvczvdsf2awefafzsdccsea，请把该文件中所有的数字组成一个新的字符串，并且打印出来。
注：学了后面的课程发现这个挑战自己没将文件关闭（file.close()），要养成习惯，不然记得使用 with!
七、函数
def 函数名（参数列表）:
函数体不带表达式的return相当于返回 None。
参数传递
在 python 中，类型属于对象，变量是没有类型。如a=[1,2,3]和a="Jspo"，[1,2,3] 是 List 类型，"Jspo" 是 String 类型，而变量 a 是没有类型，仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
- 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a
- 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了
python 函数的参数传递：
- 不可变类型：类似值传递，传递的只是a的值，没有影响a对象本身（加
global变为全局变量） - 可变类型：类似引用传递
参数类型
- 必需参数：以正确的顺序传入函数，调用时的数量必须和声明时的一样
关键字参数：形如
keyword = value，使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
默认参数：调用函数时，如果没有传递参数，则会使用默认参数，默认参数必须放在最后。如上图如果调用者未给出 b、c 的值，那么它们的值默认为5和10
不定长参数：需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名
对不定长参数再说几句：加了星号（*）的变量名会存放所有未命名的变量参数，不能存放dict。加了星号（**）的变量名会存放所有未命名的变量参数(如果在函数调用时没有指定参数，它就是一个空元)。举个例子：
def multiple(arg, *args, **dictargs):
print("arg: ", arg)
#打印args
for value in args:
print("other args:", value)
#打印dict类型的不定长参数 args
for key in dictargs:
print("dictargs:" + key + ":" + str(dictargs[key]))
if __name__ == ‘__main__‘:
multiple(1,‘a‘,True, name=‘Amy‘,age=12)
高阶函数
map 接受一个函数和一个序列（迭代器）作为输入，然后对序列（迭代器）的每一个值应用这个函数，返回一个序列（迭代器），其包含应用函数后的结果。
>>> lst = [1, 2]
>>> def s(num):
... return num * num
...
>>> print(list(map(s, lst)))
[1, 4]
注：千万别忘了map前加list!
八、文件处理
常见操作
使用 open() 函数打开文件，需要两个参数，第一个参数是文件路径或文件名，第二个是文件的打开模式：
- "r"，以只读模式打开，你只能读取文件但不能编辑/删除文件的任何内容
- "w"，以写入模式打开，如果文件存在将会删除里面的所有内容，然后打开这个文件进行写入
- "a"，以追加模式打开，写入到文件中的任何数据将自动添加到末尾
例题
例1：拷贝给定的文本文件到另一个给定的文本文件：
import sys
if len(sys.argv) < 3:
print("Wrong parameter")
print("./copyfile.py file1 file2")
sys.exit(1)
f1 = open(sys.argv[1])
s = f1.read()
f1.close()
f2 = open(sys.argv[2], ‘w‘)
f2.write(s)
f2.close()
sys模块：sys.argv 包含所有命令行参数。
sys.argv 的第一个值是命令自身的名字：
import sys
print("First value", sys.argv[0])
print("All values")
for i, x in enumerate(sys.argv):
print(i, x)
enumerate(iterableobject)可以同时得到索引位置和对应值。
例2：对任意给定文本文件中的制表符、行、空格进行计数。
import os
import sys
def parse_file(path):
fd = open(path)
i = 0
spaces = 0
tabs = 0
for i,line in enumerate(fd):
spaces += line.count(‘ ‘)
tabs += line.count(‘\t‘)
# 现在关闭打开的文件
fd.close()
# 以元组形式返回结果
return spaces, tabs, i + 1
def main(path):
if os.path.exists(path):
spaces, tabs, lines = parse_file(path)
print("Spaces {}. tabs {}. lines {}".format(spaces, tabs, lines))
return True
else:
return False
if __name__ == ‘__main__‘:
if len(sys.argv) > 1:
main(sys.argv[1])
else:
sys.exit(-1)
sys.exit(0)小Tips:
如果要统计文件的行数，可以用count = len(open(filepath, ‘r‘).readlines())，虽然简单，但是可能比较慢，当文件比较大时甚至不能工作。因此可以利用enumerate()：
count = 0
for index, line in enumerate(open(filepath,‘r‘))：
count += 1此外，使用 with 语句处理文件对象会在文件用完后会自动关闭，就算发生异常也没关系。它是 try-finally 块的简写：
with open(‘sample.txt‘) as f:
for line in f:
print(line, end = ‘‘)九、异常
- 在 Python3 中使用 Python2 独有的语法就会发生 SyntaxError
- 当有人试图访问一个未定义的变量则会发生 NameError
- 当操作或函数应用于不适当类型的对象时引发TypeError，一个常见的例子是对整数和字符串做加法
try--except
- 首先，执行 try 子句 ，如果没有异常发生，except 子句 在 try 语句执行完毕后就被忽略了。
- 如果在 try 子句执行过程中发生了异常，那么该子句其余的部分就会被忽略。
- 如果异常匹配于 except 关键字后面指定的异常类型，就执行对应的 except 子句。然后继续执行 try 语句之后的代码。
- 如果发生了一个异常，在 except 子句中没有与之匹配的分支，它就会传递到上一级 try 语句中。
- 如果最终仍找不到对应的处理语句，它就成为一个 未处理异常，终止程序运行，显示提示信息。
except可以处理一个专门的异常，也可以处理一组圆括号中的异常，如果except后没有指定异常，则默认处理所有的异常。
raise
raise 语句抛出一个异常。如"挑战：玩转函数"中要求用户能够通过命令行输入分钟数，程序需要打印出相应的小时数和分钟数。如果用户输入的是一个负值，程序需要报错 ValueError，在屏幕上打印出ValueError： Input number cannot be negative 提示用户输入的值有误。
import sys
def ToHours(time):
print("{} H, {} M".format(*divmod(time, 60)))
time =int (sys.argv[1])
if time < 0:
try:
raise ValueError
except ValueError:
print("ValueError: Input number cannot be negative")
else:
ToHours(time)
finally
不管有没有发生异常，finally 子句在程序离开 try 后都一定会被执行。当 try 语句中发生了未被 except 捕获的异常（或者它发生在 except 或 else 子句中），在 finally 子句执行完后它会被重新抛出:
>>> try:
... raise KeyboardInterrupt
... finally:
... print(‘Goodbye, world!‘)
...
Goodbye, world!
KeyboardInterrupt
Traceback (most recent call last):
File "<stdin>", line 2, in ?在真实场景的应用程序中，finally 子句用于释放外部资源（文件或网络连接之类的），无论它们的使用过程中是否出错。
