本文共 10710 字，大约阅读时间需要 35 分钟。

环境：ubuntu16.04 Python 3.5.2

参考：

1.基础语法

1）注释

单选注释# 多选注释”“” 多行注释用三个单引号 ”’ 或者三个双引号 “”” 将注释括起来

#!/usr/bin/python3if True:    print("Hello,Python")else:    print("False")#print("test---1")  被注释掉"""print("test---2")print("test---3")"""print("end")# ./hello.py Hello,Pythonend

2）缩进

用缩进来表示代码块，不需要使用大括号 {} 缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数

#!/usr/bin/python3if True:    print("True")else:print("False")# ./hello.py   File "./hello.py", line 5    print("False")        ^IndentationError: expected an indented blockPython严格地要求代码缩进，缩进的代码块相对于上一级是从属关系

3）空行

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

#!/usr/bin/python3input("\n\n please press enter then exit")# ./hello.py  please press enter then exit 一旦用户按下 enter 键时，程序将退出

5）输出

print() 默认输出是换行的 6）模块导入import 将整个模块(somemodule)导入，格式为： import somemodule

#!/usr/bin/python3import sysprint("\n python's path:",sys.path)# ./test.py  python's path: ['/home/xxx/python3_Runoob', '/usr/lib/python35.zip', '/usr/lib/python3.5', '/usr/lib/python3.5/plat-x86_64-linux-gnu', '/usr/lib/python3.5/lib-dynload', '/usr/local/lib/python3.5/dist-packages', '/usr/lib/python3/dist-packages']打印python的路径

2.基本数据类型

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

#!/usr/bin/python3count = 100moneny = 10.5name = "Tom"print(count)print(moneny)print(name)# ./test.py 10010.5Tom

Python3 有六个标准数据类型：

不可变数据（四个）：Number（数字）、String（字符串）、Tuple（元组）、Sets（集合） 可变数据（两个）：List（列表）、Dictionary（字典） 1）Number数字 Python3 支持 int、float、bool、complex（复数）

#!/usr/bin/python3count = 100moneny = 10.5china = Trueprint(type(count))  #内置的 type() 函数可以用来查询变量所指的对象类型。print(type(moneny))print(type(china))# ./test.py 
   
    
     
    
   

2）String 字符串

Python中的字符串用单引号(‘)或双引号(“)括起来，同时使用反斜杠()转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。 加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数

#!/usr/bin/python3str = 'Runoob'print (str)          # 输出字符串print (str[0:-1])    # 输出第一个到倒数第二个的所有字符print (str[0])       # 输出字符串第一个字符print (str[2:5])     # 输出从第三个开始到第五个的字符print (str[2:])      # 输出从第三个开始的后的所有字符print (str * 2)      # 输出字符串两次print (str + "TEST") # 连接字符串# ./test.py RunoobRunooRnoonoobRunoobRunoobRunoobTEST

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

3）List 列表 List（列表） 是 Python 中使用最频繁的数据类型。 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。 列表是写在方括号([])之间、用逗号分隔开的元素列表。 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

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

变量[头下标:尾下标] 索引值以 0 为开始值，-1 为从末尾的开始位置。 加号（+）是列表连接运算符，星号（*）是重复操作

#!/usr/bin/python3list = ["abcd",123,2.2,"baby",50]print(list)print(list[0])print(list[1:2])print(list[3:])# ./test.py ['abcd', 123, 2.2, 'baby', 50]abcd[123]['baby', 50]注意：1、List写在方括号之间，元素用逗号隔开。2、和字符串一样，list可以被索引和切片。3、List可以使用+操作符进行拼接。4、List中的元素是可以改变的。

4）Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。 元组中的元素类型也可以不相同

#!/usr/bin/python3list = ("abcd",123,2.2,"baby",50)print(list)print(list[0])print(list[1:2])print(list[3:])# ./test.py ('abcd', 123, 2.2, 'baby', 50)abcd(123,)('baby', 50)注意：1、与字符串一样，元组的元素不能修改。2、元组也可以被索引和切片，方法一样。3、注意构造包含0或1个元素的元组的特殊语法规则。4、元组也可以使用+操作符进行拼接。

5）Set（集合）

集合（set）是一个无序不重复元素的序列。 基本功能是进行成员关系测试和删除重复元素。 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。 创建格式： parame = {value01,value02,…} 或者 set(value)

#!/usr/bin/python3student = {
  "Tom","Jim","Mary","Tom","Jak"}print(student)# ./test.py {
  'Jak', 'Mary', 'Jim', 'Tom'}  # 输出集合，重复的元素被自动去掉

6）Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。 字典是一种映射类型，字典用”{ }”标识，它是一个无序的键(key) : 值(value)对集合。 键(key)必须使用不可变类型。 在同一个字典中，键(key)必须是唯一的。

#!/usr/bin/python3tinydict = {
  "name":"bshui","age":20,"number":12345}print(tinydict)  # 输出完整的字典print(tinydict.keys()) # 输出所有键print(tinydict.values())  # 输出所有值# ./test.py {
  'number': 12345, 'age': 20, 'name': 'bshui'} dict_keys(['number', 'age', 'name'])dict_values([12345, 20, 'bshui'])注意：1、字典是一种映射类型，它的元素是键值对。2、字典的关键字必须为不可变类型，且不能重复。3、创建空字典使用 { }。

3.Python算术运行符

以下假设变量a为10，变量b为21：

4.条件控制if语句

if 条件1:

elif 条件2:

else:

#!/usr/bin/python3score = int(input("please input your score:"))level =int( score/10)if level<6:    print("your leve is ..very bad")elif level==6:    print("level=6 just so so")elif level==7:    print("level=7 come on")elif level>=8:    print("good level is ",level)root@bshui-virtual-machine:/home/bshui/python3_Runoob# ./test.py please input your score:50your leve is ..very badroot@bshui-virtual-machine:/home/bshui/python3_Runoob# ./test.py please input your score:75level=7 come onroot@bshui-virtual-machine:/home/bshui/python3_Runoob# ./test.py please input your score:90good level is  9

5.循环语句

1）While循环

while 判断条件： 语句

#!/usr/bin/python3n = 100sum = 0i = 1while i <= n :    sum += i    i+=1# ./test.py teh sum is: 5050

2）For语句

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串 for 变量 in 语句: 语句

#!/usr/bin/python3languages = ["C","C++","Java","Python","QT"]for x in languages:    print(x)# ./test.py CC++JavaPythonQT

break 语句可以跳出 for 和 while 的循环体

6.迭代器

迭代器是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。 迭代器有两个基本的方法：iter() 和 next()。 字符串，列表或元组对象都可用于创建迭代器：

#!/usr/bin/python3list = [1,2,3,4]it = iter(list)for x in it:  迭代器对象可以使用常规for语句进行遍历    print(x)# ./test.py 1234#!/usr/bin/python3import syslist = [1,2,3,4]it = iter(list)while True:    try:        print(next(it)) # 输出迭代器的下一个元素    except StopIteration:        sys.exit()# ./test.py 1234

7.生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。 调用一个生成器函数，返回的是一个迭代器对象

#!/usr/bin/python3import sysdef fibonacci(n):    a,b,counter = 0,1,0    while True:        if(counter > n):            return        yield a  #每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值        a,b = b, a+b        counter += 1f = fibonacci(10)while True:    try:        print(next(f),end=" ")    except StopIteration:        print()        sys.exit()# ./test.py 0 1 1 2 3 5 8 13 21 34 55

8.函数

函数能提高应用的模块性，和代码的重复利用率

简单的规则： 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。 函数内容以冒号起始，并且缩进。 return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None def 函数名（参数列表）: 函数体

#!/usr/bin/python3def area(width,height):    return width*heightw=4h=5# ./test.py width= 4  height= 5  area= 20

变量作用域

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。 变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是： L （Local） 局部作用域 E （Enclosing） 闭包函数外的函数中 G （Global） 全局作用域 B （Built-in） 内建作用域

9.数据结构

列表可以修改，而字符串和元组不能

#!/usr/bin/python3a = [66.25,333,111,111,333,1,123]print(a.count(333),a.count(111),a.count('x'))a.insert(2,-1)a.append(333)print(a.count(333),a.count(111),a.count('x'))print(a)a.sort()print(a)# ./test.py 2 2 03 2 0[66.25, 333, -1, 111, 111, 333, 1, 123, 333][-1, 1, 66.25, 111, 111, 123, 333, 333, 333]

10.模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能

#!/usr/bin/python3import sys  #引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法for i in sys.argv:    print(i)# ./test.py a b c 1./test.pyabc1

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端

# cat support.py #!/usr/bin/python3def print_func(par):    print(par)    return# cat test.py #!/usr/bin/python3import support  # 导入自定义的模块，support.py放在和test.py同一目录下support.print_func("Hello support model") #用模块里包含的函数了# ./test.py Hello support model

from…import 语句

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中 每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用 包：包是一种管理 Python 模块命名空间的形式，采用”点模块名称”。 比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B

11.输入和输出

Python两种输出值的方式: 表达式语句和 print() 函数。

第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。 如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。 如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

str()： 函数返回一个用户易读的表达形式。

repr()： 产生一个解释器易读的表达形式 格式化输出str.format() 括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换

#!/usr/bin/python3print("{}address: {}!".format("net","www.baidu.com"))# ./test.py netaddress: www.baidu.com!

读取键盘输入

Python提供了 input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。 input 可以接收一个Python表达式作为输入，并将运算结果返回。

#!/usr/bin/python3str = input("please input:")print("your input context is:", str)# ./test.py please input:hello i love pythonyour input context is: hello i love python

读和写文件

open() 将会返回一个 file 对象，基本语法格式如下:open(filename, mode) filename：filename 变量是一个包含了你要访问的文件名称的字符串值。 mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

#!/usr/bin/python3f = open("./foo.txt","w") # 打开一个文件f.write("Python is a good language very good\n")f.close # 关闭打开的文件# cat foo.txt Python is a good language very good

#!/usr/bin/python3f = open("./foo.txt","w")f.write("Python is a good language very good\n")f.closef = open("./foo.txt","r")str = f.read()print(str)f.close# ./test.py Python is a good language very good

f.readline() 会从文件中读取单独的一行。换行符为 ‘\n’。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行

f.readlines() 将返回该文件中包含的所有行

#!/usr/bin/python3f = open("./support.py","r")str = f.readlines()print(str)f.close# ./test.py ['#!/bin/usr/python3\n', 'def print_func(name)\n', '\tprint(name)\n']

另一种方式是迭代一个文件对象然后读取每行

#!/usr/bin/python3f = open("./support.py","r")for line in f:    print(line, end="")# ./test.py #!/bin/usr/python3def print_func(name)    print(name)

f.write()

f.write(string) 将 string 写入到文件中, 然后返回写入的字符数 如果要写入一些不是字符串的东西, 那么将需要先进行转换

#!/usr/bin/python3f = open("./foo.txt","w")value = ("www.baidu.com", 18)s = str(value)f.write(s)f.close# cat foo.txt ('www.baidu.com', 18)

12.File文件方法

13.错误及异常

语法分析器会指出出错的一行，并且在最先找到的错误的位置标记一个小小的箭头

异常：即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。 大多数的异常都不会被程序处理，都以错误信息的形式展现在这里: 异常处理：try语句按照如下方式工作； 首先，执行try子句（在关键字try和关键字except之间的语句） 如果没有异常发生，忽略except子句，try子句执行后结束。 如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。 如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

#!/usr/bin/python3while True:    try:        x = int(input("Please enter a number:"))        break    except ValueError:        print("Oops! That was not valid number.Try again ")# ./test.py Please enter a number:2.0Oops! That was not valid number.Try again Please enter a number:1

抛出异常：Python 使用 raise 语句抛出一个指定的异常

14 .面向对象

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。 实例变量：定义在方法中的变量，只作用于当前实例的类。 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟”是一个（is-a）”关系（例图，Dog是一个Animal）。 实例化：创建一个类的实例，类的具体对象。 方法：类中定义的函数。 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法 类定义： class ClassName: xxxxx

#!/usr/bin/python3class MyClass:    i = 12345    def f(self):        return "hello python"x = MyClass() # 实例化类print(x.i)    # 访问类的属性和方法print(x.f())# ./test.py 12345hello python

在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。