runoob.com python3教程结构提要

原站地址：http://www.runoob.com/python3/python3-tutorial.html

本文目的： 1. 提供更深层次的资料查询目录； 2. 快速复习python的简单知识

一、基础语法

1. 编码：Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。

2. 标识符：

2.1 第一个字符必须是字母表中字母或下划线 _

2.2 标识符对大小写敏感。

3. 注释： (1) #  (2) '''  xxx  ''' (3) """ xxx """

4. 多行语句：

4.1 可以使用反斜杠(\)来实现多行语句

total = item_one + \
        item_two

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

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

5. 数字(Number)类型：

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

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

6. 字符串(String)：

6.1 python中单引号和双引号使用完全相同

6.2 使用三引号('''或""")可以指定一个多行字符串

paragraph = """这是一个段落，
可以由多行组成"""

6.3 使用r可以让反斜杠不发生转义 ：      如 r"this is a line with \n" 则\n会显示，并不是换行。

6.4 "this " "is " "string"会被自动转换为 this is string。

6.5  可以用 + 运算符连接在一起，用 * 运算符重复

6.6 有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

     比如： str[0:-1]  输出第一个到倒数第二个的所有字符

6.7 不能直接改变字符串的其中一个字符

6.8 没有单独的字符类型，一个字符就是长度为 1 的字符串。

7 等待用户输入： input函数。比如：

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

8. 同一行显示多条语句：Python可以在同一行中使用多条语句

9. Print 输出：  不换行需要在变量末尾加上 end=""

# 换行输出
print( x )
# 不换行输出
print( x, end=" " )

10. import 与 from...import：

10.1 将整个模块(somemodule)导入： import somemodule

10.2 从某个模块中导入某个函数： from somemodule import somefunction

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

10.4 将某个模块中的全部函数导入： from somemodule import *

二、基本数据类型

1. 多个变量赋值： a, b, c = 1, 2, "runoob"

2. 标准数据类型：

2.1 不可变数据：Number（数字）、String（字符串）、Tuple（元组）

2.2 List（列表）、Dictionary（字典）、Set（集合）

3. Number：

3.1 支持 int、float、bool、complex（复数）

3.2 只有 int，表示为长整型，没有 Long。

3.3  type() 函数可以用来查询变量所指的对象类型

3.3 / 返回一个浮点数，// 返回一个整数(向下取整)。

4. String：

print (str[2:5]) # 输出从第三个开始到第五个的字符

print (str + "TEST") # 连接字符串

5. List：

print (list[1:3]) # 从第二个开始输出到第三个元素

print (list + tinylist) # 连接列表

print (tinylist * 2) # 输出两次列表

6. Tuple：

7. Set： 元素不会重复

8.Dictionary：

8.1 print (tinydict.keys()) # 输出所有键

8.2 print (tinydict.values()) # 输出所有值

9. 数据类型转换

三、运算符

1. 逻辑运算符： and,  or,  not

2. 成员运算符： in , not in

3. 身份运算符：is ,is not

4. 运算符优先级：

4.1 ** (指数) > ~ (按位翻转) > * / % // (乘除取模和取整除) > + - (加法减法) > = %= /= (赋值运算符) > 

      is is not (身份运算符) > in not in (成员运算符) > not (逻辑运算符) > and(逻辑运算符)   > or(逻辑运算符)

4.2 注意： not  and or  三个逻辑运算符不是同级

四、数字

1. 内存空间：数据类型是不允许改变, 如果改变值，将重新分配内存空间

2. 浮点型： 可以使用科学计数法表示（2.5e2 = 250）

3. 十六进制和八进制： 0xA0F # 十六进制  和  0o37 # 八进制

4. 数字类型转换

5. 数字运算

6. 数学函数

7. 随机数函数

8. 三角函数

9. 数学常量

五、字符串

1. 访问字符串中的值

2. 转义字符

3. 字符串运算符

4. 字符串格式化

5. 三引号(多行字符串)

6. Unicode 字符串： u'xxxabcxxx'

7. 字符串内建函数

7.1 count(str)：返回指定范围内 str 出现的次数

7.2 bytes.decode(encoding="utf-8")：bytes结构转字符串

7.3 encode(encoding='UTF-8)：字符串转bytes结构

7.4 xxx.join(seq)：以xxx作为分隔符，将 seq 中所有的元素合并为一个新的字符串

7.5 lower()： 转换字符串为小写

7.6 upper()：转换字符串为大写

7.7 lstrip([chars])：截掉左边的空格或指定字符

7.8 rstrip([chars])：删除末尾的空格或指定字符

7.7 strip()： 在字符串上执行 lstrip()和 rstrip()

六、列表

1. 访问列表中的值：第一个索引是0，第二个索引是1

2. 列表脚本操作符：+ 号用于组合列表，* 号用于重复列表。

3. 列表函数&方法

3.1 append(obj)：在末尾添加对象

3.2 extend(seq)：在末尾一次性追加另一个序列中的多个值

3.3 index(obj)：找出某个值第一个匹配项的索引位置

3.4 insert(index, obj)：将对象插入列表

3.5 pop([index=-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

3.6 remove(obj)：移除列表中某个值的第一个匹配项

3.7 reverse()：反向列表中元素

3.8 sort( key=None, reverse=False)：对原列表进行排序

七、元组

1. 创建元组：

   tup1 = (50)   # 不加逗号，类型为整型，不是元组

   tup2 = (50,)  # 加上逗号，类型为元组

2. 元组内置函数:

2.1 tuple(seq)： 将列表转换为元组

八、字典

1. 格式： d = {key1 : value1, key2 : value2 }     注意：是冒号和逗号

2. 访问字典里的值：dict['Name']

3. 删除字典元素：del dict # 删除字典

4. 字典内置函数&方法：

4.1 len(dict)：计算字典元素个数

4.2 str(dict)：输出字典，以字符串表示。

5.字典内置函数&方法

5.1 key in radiansdict：如果键在字典dict里返回true，否则返回false

5.2 radiansdict.items()：以列表返回可遍历的(键, 值) 元组数组

5.3 radiansdict.keys()：返回键内容，是一个迭代器，可以使用 list() 来转换为列表

5.4 radiansdict.values()：返回值内容，是一个迭代器，可以使用 list() 来转换为列表

九、集合

1. 集合的创建

1.1  可以使用大括号 { } 或者 set() 函数创建集合

1.2 创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

2. 添加元素：s.add( x )

3. 移除元素：s.remove( x )

十、if、for、while

1. if  格式： (注意，后面有 冒号 “：” )

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

2. while格式：(注意，后面有 冒号 “：” )

while 判断条件：
    语句
else: (可选)
    语句

3. for 格式：(注意，后面有 冒号 “：” )

for <variable> in <sequence>:
    <statements>
else:
    <statements>

4. for range格式：(注意，后面有 冒号 “：” )

for i in range(起始, 结尾(不包含), 步长) 

5. pass 语句： python不能有空行，不需要处理的话，需要加一句 pass

十一、迭代器与生成器

1. 迭代器

1.1 迭代器只能往前不会后退

1.2 创建迭代器对象：t = iter(list) 

1.3 迭代器前进：next(it)

1.4 迭代器对象可以在for语句中遍历（注意：这里不需要执行next(it)）

list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
    print (x, end=" ")

1.5 在while中遍历

list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
while True:
    print (next(it))

2. 生成器

2.1 使用了 yield 的函数被称为生成器

2.2 生成器是一个返回迭代器的函数，只能用于迭代操作。生成器就是一个迭代器。

2.3 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

2.4 调用一个生成器函数，返回的是一个迭代器对象。

2.5 以下实例使用 yield 实现斐波那契数列：

#!/usr/bin/python3
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        yield a
        a, b = b, a + b
        counter += 1

f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

十二、函数

1. 语法

def 函数名（参数列表）:
    函数体

2. 参数传递

2.1  不可变类型参数，如 整数、字符串、元组， 是值传递

2.2  可变类型参数，如列表，字典，集合，是引用传递

3. 不定长参数

3.1 语法:

def functionname(*var_args_tuple ):
   return

3.2 加了星号 * 的参数会以 元组 的形式导入

def printinfo( arg1, *vartuple ):
    print (arg1)
    print (vartuple)

printinfo( 70, 60, 50 )

输出：
70
(60, 50)

3.3 加了两个星号 ** 的参数会以字典的形式导入

def printinfo( arg1, **vardict ):
    print (arg1)
    print (vardict)

printinfo(1, a=2,b=3)

输出：
1
{'a': 2, 'b': 3}

十三、匿名函数

1. lambda的主体是一个表达式，而不是一个代码块。仅仅能封装有限的逻辑进去。

2. lambda 函数拥有自己的命名空间，且不能访问参数列表之外或全局命名空间里的参数。

3. 语法：   lambda [arg1 [,arg2,.....argn]]:expression

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))

4. global 和 nonlocal关键字

1. 当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了

2. 修改全局变量 num：

num = 1
def fun1():
    global num # 需要使用 global 关键字声明
    num = 123

3. 修改嵌套作用域num：

def outer():
    num = 10

    def inner():
        nonlocal num # nonlocal关键字声明
        num = 100
        print(num)

    inner()
    print(num)

outer()

十四、数据结构

1. 将列表当做堆栈使用：append() 和 pop()

2. 将列表当作队列使用：

from collections import deque    #导入deque类

queue = deque(["Eric", "John", "Michael"])   #创建队列
queue.append("Terry")    #从最右边添加
strName = queue.popleft() #从最左边弹出  

3. 列表推导式

3.1 理解：每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句

3.2 几个例子

基本类型：
vec = [2, 4, 6]
[3*x for x in vec]
输出：[6, 12, 18]

两元素：
[[x, x**2] for x in vec]
输出：[[2, 4], [4, 16], [6, 36]]

if语句：
[3*x for x in vec if x > 3]
输出：[12, 18]

两个for：
vec1 = [2, 4, 6]
vec2 = [4, 3, -9]
[x*y for x in vec1 for y in vec2]
输出：[8, 6, -18, 16, 12, -36, 24, 18, -54]

嵌套for：
matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12] ]
[i for row in matrix for i in row]
输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

4. 遍历技巧:

4.1 遍历dick

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)

4.2 遍历list (需要提供索引I的方式)

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

4.3 同时遍历两个或更多的序列，可以使用 zip() 组合：

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
    print('What is your {0}?  It is {1}.'.format(q, a))

输出：What is your name?  It is lancelot.

4.4 反向遍历一个序列，调用 reversed() 函数：

for i in reversed(range(1, 10)):
    print(i)

十五、模块

1. 搜索路径： sys.path 输出是一个列表，其中第一项是空串 ''，代表当前目录

import sys; print(sys.path)

2. import 语句：

2.1 语法：

   import module1[, module2[,... moduleN]

2.2 一个模块只会被导入一次

2.3 import fibo 并没有把fibo中的函数名称写入到当前符号表里，只是把模块fibo写进去。

     访问里面的函数时，需要 ： fibo.fib()

3. from … import 语句： 从模块中导入一个指定的部分到当前命名空间中，

3.1 语法如下：

from modname import name1[, name2[, ... nameN]]

3.2  例子：

from fibo import fib, fib2
fib(500)

   不会把整个fibo模块导入，它只会将fibo里的fib函数导入。

4. from … import * 语句： 把一个模块的所有内容全都导入到当前的命名空间

4.1 语法： from modname import *

4.2 限定只导入特定成员：  __all__ = ["echo", "surround", "reverse"]

5. __name__属性：模块被引入时，其主程序将运行。如果想某一程序块不执行，可以用__name__属性来限制：

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

6. dir() 函数： 找到模块内定义的所有成员的名称

7. 包：

7.1 包可以理解为一个文件夹 （非官方说辞）

7.2 目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包

7.3 例子：

from sound.effects import echo

十六、输入和输出

1. 输出格式美化：

1.1  rjust()，ljust() ，center() 方法：

    str.rjust(4): 字符串以空格填充为4个字符，并且右对齐；ljust() 左对齐；center() 居中

1.2  zfill 方法：

    str.zfill (4):数字构成的字符串，以0填充为4位

1.3 str.format() 方法：可以以索引号指定，也可以以关键字指定。

print('{0} 和 {1}'.format('Google', 'Runoob'))
输出：Google 和 Runoob
print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
输出：菜鸟教程网址： www.runoob.com

1.4 可以添加  ':'  和格式标识符，进行更好的格式化：

print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))  
输出：3.142

table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
for name, number in table.items():
    print('{0:10} ==> {1:10d}'.format(name, number))
输出：Runoob     ==>          2

 

2. 旧式字符串格式化： 注意是 % 号

print('常量 PI 的值近似为：%5.3f。' % math.pi)

3. 读取键盘输入： str = input("请输入：");

4. 读和写文件：

open() 将会返回一个 file 对象，基本语法格式如下:     (读写mode：w+)

f = open(filename, mode)     
f.write("xxxxx")
f.close()
f.read()
f.readline()

5. pickle 模块

5.1 pickle模块实现了基本的数据序列和反序列化。 

    通过序列化操作能够将对象信息保存到文件中去，永久存储。

   pickle.dump  ，  pickle.load

import pickle
data1 = {'a': [1, 2.0, 3, 4+6j]}
output = open('data.pkl', 'wb')
pickle.dump(data1, output)


pkl_file = open('data.pkl', 'rb')
data2 = pickle.load(pkl_file)

十七、File(文件) 方法

十八、OS 文件/目录方法

十九、错误和异常

while(True):
    try:
        x = int(input("Please input a number:"))
        break
    #except ValueError:
    except:
        print("Oops! That was no valid number. Try again ")

二十、面向对象

1. 类对象。 

1.1 一个简单的类实例：

class MyClass:
    i = 12345       //成员变量
    def f(self):    //成员函数
        return 'hello world'

# 实例化类
x = MyClass()
print("MyClass 类的属性 i 为：", x.i)    # 访问类的属性
print("MyClass 类的方法 f 输出为：", x.f())    # 访问类的方法

1.2 类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用

def __init__(self):
    self.data = []

1.3  __init__() 方法可以有参数

class Complex:
def __init__(self, realpart, imagpart):
    self.r = realpart
    self.i = imagpart

x = Complex(3.0, -4.5)

2. 类的每个成员函数的第一个参数都需要有self

2.1 self 代表的是类的实例，代表当前对象的地址，

2.2 self.class 则指向类。

3. 继承

class DerivedClassName(BaseClassName1):
    <statement-1>

4. 多继承：继承顺序从左到右

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>

5. 私有属性：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。

class JustCounter:
    __secretCount = 0 # 私有变量

print (counter.__secretCount) # 报错，实例不能访问私有变量

6. 运算符重载

class Vector:
def __init__(self, a, b):
    ....
def __add__(self,other):
    return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

二十一、实例

• Python Hello World 实例
• Python 数字求和
• Python 平方根
• Python 二次方程
• Python 计算三角形的面积
• Python 随机数生成
• Python 摄氏温度转华氏温度
• Python 交换变量
• Python if 语句
• Python 判断字符串是否为数字
• Python 判断奇数偶数
• Python 判断闰年
• Python 获取最大值函数
• Python 质数判断
• Python 输出指定范围内的素数
• Python 阶乘实例
• Python 九九乘法表
• Python 斐波那契数列
• Python 阿姆斯特朗数
• Python 十进制转二进制、八进制、十六进制
• Python ASCII码与字符相互转换
• Python 最大公约数算法
• Python 最小公倍数算法
• Python 简单计算器实现
• Python 生成日历
• Python 使用递归斐波那契数列
• Python 文件 IO
• Python 字符串判断
• Python 字符串大小写转换
• Python 计算每个月天数
• Python 获取昨天日期
• Python list 常用操作
• Python 约瑟夫生者死者小游戏
• Python 实现秒表功能