第一章重置

程序是什么

程序是一系列定义计算机如何执行计算 (computation) 的指令。这种计算可以是数学上的计算，例如寻找公式的解或多项式的根，也可以是一个符号计算 (symbolic compu-tation)，例如在文档中搜索并替换文本或者图片，就像处理图片或播放视频。

不同编程语言所写程序的细节各不一样，但是一些基本的指令几乎出现在每种语言当中：

输入 (input)：从键盘、文件、网络或者其他设备获取数据。
输出 (output)：在屏幕上显示数据，将数据保存至文件，通过网络传送数据，等等。
数学 (math)：执行基本的数学运算，如加法和乘法。
有条件执行 (conditional execution): 检查符合某个条件后，执行相应的代码。
重复 (repetition): 检查符合某个条件后，执行相应的代码。

因此，你可以认为编程就是将庞大、复杂的任务分解为越来越小的子任务，直到这些子任务简单到可以用这其中的一个基本指令执行。

Python 的解释器是一个读取并执行 Python 代码的程序。根据你的电脑环境不同，你可以通过双击图标，或者在命令行输入 python 的方式来启动解释器。

>>>   #这个是提示符prompt

表明你可以在解释器中输入代码了。如果你输入一行代码然后按回车 (Enter)，解释器就会显示结果

>>>print('hello,world!') #这里引号不会出现在结尾中，括号说明print是一个函数
hello,world!

Python 提供了许多代表加法和乘法等运算的特殊符号，叫做运算符(operators)。运算符 + 、 − 和 * 分别执行加法、减法和乘法， / 执行浮点除法运算。^属于一种位运算符，叫做XOR。

值 (value) 是程序处理的基本数据之一，一个单词或一个数字都是值的实例。不同的值属于不同的类型（type）， 2 是一个整型数 (integer)， 42.0 是一个浮点型数(floating point number)，而 'Hello, ␣ World!' 则是一个字符串 (string)，这么称呼是因为其中的字符被串（strung together/string together）在了一起。

>>>1,000,000
(1,0,0)

自然语言 (natural language) 是人们交流所使用的语言，例如英语、西班牙语和法语。
它们不是人为设计出来的（尽管有人试图这样做）；而是自然演变而来。

形式语言 (formal languages) 是人类为了特殊用途而设计出来的。例如，数学家使用的
记号 (notation) 就是形式语言，特别擅长表示数字和符号之间的关系。化学家使用形式
语言表示分子的化学结构。

编程语言是被设计用于表达计算的形式语言。

形式语言通常拥有严格的语法规则，规定了详细的语句结构。例如，3 + 3 = 6 是语法
正确的数学表达式，而 3 + = 3$6 则不是；H 2 O 是语法正确的化学式，而 2 Zz 则不是。
语法规则有两种类型，分别涉及记号 (tokens) 和结构。记号是语言的基本元素，例如单
词、数字和化学元素。3 + = 3$6 这个式子的问题之一，就是 $ 在数学中不是一个合法
的记号（至少据我所知）。类似的， 2 Zz 也不合法，因为没有一个元素的简写是 Zz 。

第二种语法规则与标记的组合方式有关。3 + = 3 这个方程是非法的，因为即使 + 和 =
都是合法的记号，但是你却不能把它们俩紧挨在一起。类似的，在化学式中，下标位于
元素之后，而不是之前。

This is @ well-structured Engli$h sentence with invalid t*kens in it. This sentence allvalid tokens has, but invalid structure with.
两句英文都是不符合语法的，一个包含非法标记，另一个结构不符合语法。
当你读一个用英语写的句子或者用形式语言写的语句时，你都必须要理清各自的结构
（尽管在阅读自然语言时，你是下意识地进行的）。这个过程被称为解析 (parsing)。

	自然语言	形式语言
歧义性	充满歧义	无歧义
冗余性	冗长	简洁
字面性	有隐喻，典故	字面意思
相同点	都具有标记语法结构

术语表

问题求解 (problem solving)：将问题形式化、寻找并表达解决方案的过程。
高级语言 (high-level language)：像 Python 这样被设计成人类容易阅读和编写的编
程语言。
低级语言 (low-level language)：被设计成计算机容易运行的编程语言；也被称为
‘‘机器语言” (machine language ) 或 ‘‘汇编语言” (assembly language)。
可移植性 (portability)：程序能够在多种计算机上运行的特性。
解释器 (interpreter)：读取另一个程序并执行该程序的程序。
提示符 (prompt)：解释器所显示的字符，表明已准备好接受用户的输入。
程序 (program)：一组定义了计算内容的指令。
打印语句 (print statement)：使 Python 解释器在屏幕上显示某个值的指令。

运算符 (operator)：代表类似加法、乘法或者字符串连接 (string concatenation) 等简
单计算的特殊符号。
值 (value)：程序所处理数据的基本元素之一，例如数字或字符串。
类型 (type)：值的类别。我们目前接触的类型有整型数（类型为 int ）、浮点数（类型
为 float ）和字符串（类型为 str ）。
整型数 (integer)：代表整数的类型。
浮点数 (floating-point)：代表一个有小数点的数字的类型。
字符串 (string)： A type that represents sequences of characters.
自然语言 (natural language)：任何的人们日常使用的、由自然演变而来的语言。
形式语言 (formal language)：任何由人类为了某种目的而设计的语言，例如用来表示
数学概念或者电脑程序；所有的编程语言都是形式语言。
记号 (token)：程序语法结构中的基本元素之一，与自然语言中的单词类似。
语法 (syntax)：规定了程序结构的规则。
解析 (parse)：阅读程序，并分析其语法结构的过程
故障 (bug)：程序中的错误。
调试 (debugging)：寻找并解决错误的过程。

python基础教程

Python 是一种解释型、面向对象、动态数据类型的高级程序设计语言。

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

ipython 是一个 python 的交互式 shell，比默认的 python shell 好用得多，支持变量自动补全，自动缩进，支持 bash shell 命令，内置了许多很有用的功能和函数。

此 ipython 中的 i 代表 “交互(interaction)”。

官方地址：https://ipython.org/install.html

使用:

ipython

标识符

第一个字符必须是字母表中字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
标识符对大小写敏感。

在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()，例如：

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

数字(Number)类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
bool (布尔), 如 True。
float (浮点数), 如 1.23、3E-2
complex (复数), 如 1 + 2j、 1.1 + 2.2j

字符串(String)

python中单引号和双引号使用完全相同。
使用三引号('''或""")可以指定一个多行字符串。
转义符 ''
反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。如 r"this is a line with \n" 则\n会显示，并不是换行。
按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
字符串可以用 + 运算符连接在一起，用 * 运算符重复。
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
Python中的字符串不能改变。
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

str='Runoob'
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

hello
runoob
hello\nrunoob

空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

等待用户输入

执行下面的程序在按回车键后就会等待用户输入：

input("\n\n按下 enter 键后退出。")

以上代码中，"\n\n"在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出。

Python可以在同一行中使用多条语句，语句之间使用分号(;)分割，

缩进相同的一组语句构成一个代码块，我们称之代码组。

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

如下实例：

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

Print 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

实例(Python 3.0+)

x="a"

y="b" # 换行输出

print( x )

print( y )

print('---------') #

不换行输出

print( x, end=" " )

print( y, end=" " )

print()

以上实例执行结果为：

a
b
---------
a b

import 与 from...import

在 python 用 import 或者 from...import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

关于注释，也可以使用 ''' ''' 的格式在三引号之间书写较长的注释；

''' ''' 还可以用于在函数的首部对函数进行一个说明：

def example(anything):
    '''形参为任意类型的对象，
       这个示例函数会将其原样返回。
    '''
    return anything

help() 函数

调用 python 的 help() 函数可以打印输出一个函数的文档字符串：

# 如下实例，查看 max 内置函数的参数列表和规范的文档
>>> help(max)
……显示帮助信息……

按下 : q 两个按键即退出说明文档

如果仅仅想得到文档字符串：

>>> print(max.__doc__)    # 注意，doc的前后分别是两个下划线
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value

With a single iterable argument, return its biggest item. The
default keyword-only argument specifies an object to return if
the provided iterable is empty.
With two or more arguments, return the largest argument.

要善用 help() 方法

通过命令 help(print) 我们知道这个方法里第三个为缺省参数 sep=' '。

这里表示我们使用分隔符为一个空格。

>>> help(print)
Help on built-in function print in module builtins:
print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

清屏

“Windows 命令行窗口”下清屏，可用下面两种方法。

第一种方法，在命令行窗口输入：

>>> import os
>>> i=os.system("cls")

第二种方法，在命令行窗口输入：

>>> import subprocess
>>> i=subprocess.call("cls", shell=True)

关于 import 的小结

以 time 模块为例：

1、将整个模块导入，例如：import time，在引用时格式为：time.sleep(1)。

2、将整个模块中全部函数导入，例如：from time import *，在引用时格式为：sleep(1)。

3、将模块中特定函数导入，例如：from time import sleep，在引用时格式为：sleep(1)。

4、将模块换个别名，例如：import time as abc，在引用时格式为：abc.sleep(1)。

当字符串内容为浮点型要转换为整型时，无法直接用 int() 转换：

a='2.1'  # 这是一个字符串
print(int(a))

会报错 "invalid literal for int() "。

需要把字符串先转化成 float 型再转换成 int 型：

a='2.1'
print(int(float(a)))

输出 2。

Python 中也可以所用 sys 的 sys.argv 来获取命令行参数：

sys.argv 是命令行参数列表。
len(sys.argv) 是命令行参数个数。

注：sys.argv[0] 表示脚本名。

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

标准数据类型

Python3 中有六个标准的数据类型：

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外还可以用 isinstance 来判断：

实例

>>> a = 111
>>> isinstance(a, int)
True
>>>

isinstance 和 type 的区别在于：

type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

您可以通过使用del语句删除单个或多个对象。例如：

del var
del var_a, var_b

1、Python可以同时为多个变量赋值，如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 ** 转义特殊字符。

Python 使用反斜杠 ** 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru \n oob
>>>

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2、字符串可以用+运算符连接在一起，用*运算符重复。
3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
4、Python中的字符串不能改变。

List（列表）

List（列表）是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
print (list[2:]) # 输出从第三个元素开始的所有元素
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

与Python字符串不一样的是，列表中的元素是可以改变的：

实例

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []  # 将对应的元素值设置为 []
>>> a
[9, 2, 6]

List 内置了有很多方法，例如 append()、pop() 等等，这在后面会讲到。

def reverseWords(input):

# 通过空格将字符串分隔符，把各个单词分隔为列表
inputWords = input.split(" ")

# 翻转字符串
# 假设列表 list = [1,2,3,4],
# list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
# inputWords[-1::-1] 有三个参数
# 第一个参数 -1 表示最后一个元素
# 第二个参数为空，表示移动到列表末尾
# 第三个参数为步长，-1 表示逆向
inputWords=inputWords[-1::-1]

# 重新组合字符串
output = ' '.join(inputWords)

return output

if name == "main":
input = 'I like runoob'
rw = reverseWords(input)
print(rw)

输出结果为：

runoob like I

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')

print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组

('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}
或者
set(value)

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

print(sites) # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites :
print('Runoob 在集合中')
else :
print('Runoob 不在集合中')

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)

print(a - b) # a 和 b 的差集

print(a | b) # a 和 b 的并集

print(a & b) # a 和 b 的交集

print(a ^ b) # a 和 b 中不同时存在的元素

以上实例输出结果：

{'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
Runoob 在集合中
{'b', 'c', 'a', 'r', 'd'}
{'r', 'b', 'd'}
{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
{'c', 'a'}
{'z', 'b', 'm', 'r', 'l', 'd'}

#!/usr/bin/python3

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值

以上实例输出结果：

1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

实例

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>>

一般来说，函数的返回值一般为一个。

而函数返回多个值的时候，是以元组的方式返回的。

示例（命令行下）：

>>>def example(a,b):
...     return (a,b)
...
>>>type(example(3,4))
<class 'tuple'>
>>>

针对楼上的字典拓展，做测试的时候，想要输出 kye:value的组合发现可以这样：

for c in dict:
    print(c,':',dict[c])

或者

for c in dict:
    print(c,end=':');
    print(dict[c])

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
print (list[2])
print (list[2:3])

这两句话打印的内容其实是一样的:

2.23
[2.23]

但注意是不同的类型，用变量接收一下：

a = list[2]
b = list[2:3]
type(a) -> <class 'float'>
type(b) -> <class 'list'>

字典（小拓展）

输入 dict 的键值对，可直接用 items() 函数：

dict1 = {'abc':1,"cde":2,"d":4,"c":567,"d":"key1"}
for k,v in dict1.items():
    print(k,":",v)

>>> dict_1 = dict([('a',1),('b',2),('c',3)]) #元素为元组的列表
>>> dict_1
{'a': 1, 'b': 2, 'c': 3}
>>> dict_2 = dict({('a',1),('b',2),('c',3)})#元素为元组的集合
>>> dict_2
{'b': 2, 'c': 3, 'a': 1}
>>> dict_3 = dict([['a',1],['b',2],['c',3]])#元素为列表的列表
>>> dict_3
{'a': 1, 'b': 2, 'c': 3}
>>> dict_4 = dict((('a',1),('b',2),('c',3)))#元素为元组的元组
>>> dict_4
{'a': 1, 'b': 2, 'c': 3}

Python 中布尔值使用常量 True 和 False 来表示。

1、在数值上下文环境中，True 被当作 1，False 被当作 0，例如：

>>> True+3
4
>>> False+2
2

>>> def example(a,b):
...     return (a,b)
... 
>>> type(example(3,4))
<type 'tuple'>
>>> def example(a,b):
...     return a,b
... 
>>> type(example(3,4))
<type 'tuple'>
>>> def example(a,b):
...     return [a,b]
... 
>>> type(example(3,4))
<type 'list'>

列表和元组不会把相同的值合并，但是集合会把相同的合并。

>>> clist = ['tom','tom','jerry']                #测试列表功能
>>> print (clist）
['tom','tom','jerry']

>>>ctuple = ('tom','tom','jerry')           #测试元组功能
>>>print(ctuple)
('tom','tom','jerry') 

>>>cset = {'tom','tom','jerry'}                #测试集合功能
>>>print(cset)
{'tom','jerry'}

>>> o = {1, 2, 3}
>>> type(o)
<class 'set'>
>>> o = {}
>>> type(o)
<class 'dict'>

x = ['A','B','C','D']
y = ['a','b','c','d']
n = {i:j for i,j in zip(x,y)}
print("n:",n)
'''
n: {'A': 'a', 'B': 'b', 'C': 'c', 'D': 'd'}
'''

s = {x:x.strip() for x in ('he','she','I')}
print("s:",s)
'''
s: {'he': 'he', 'she': 'she', 'I': 'I'}
'''