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)

二十一、实例

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值