菜鸟教程 Python 手记 1
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了菜鸟教程 Python 手记 1相关的知识，希望对你有一定的参考价值。
Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。
编码
编码默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：
# -*- coding: cp-1252 -*-
多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠(\)来实现多行语句，例如：
total = item_one + item_two + item_three
在 [], {}, 或 () 中的多行语句，不需要使用反斜杠(\)，例如：
total = [‘item_one‘, ‘item_two‘, ‘item_three‘,
‘item_four‘, ‘item_five‘]
同一行显示多条语句
Python可以在同一行中使用多条语句，语句之间使用分号(;)分割，以下是一个简单的实例：
#!/usr/bin/python3
import sys; x = ‘runoob‘; sys.stdout.write(x + ‘\n‘)
执行以上代码，输入结果为：
$ python3 test.py runoob
多个变量赋值
a = b = c = 1
a, b, c = 1, 2, "runoob"
数值计算
>>>5 + 4 # 加法 9 >>> 4.3 - 2 # 减法 2.3 >>> 3 * 7 # 乘法 21 >>> 2 / 4 # 除法，得到一个浮点数 0.5 >>> 2 // 4 # 除法，得到一个整数 0 >>> 17 % 3 # 取余 2 >>> 2 ** 5 # 乘方 32
Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
Set（集合）
集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
实例：
#!/usr/bin/python3
student = {‘Tom‘, ‘Jim‘, ‘Mary‘, ‘Tom‘, ‘Jack‘, ‘Rose‘}
print(student) # 输出集合，重复的元素被自动去掉
# 成员测试
if(‘Rose‘ in student) :
print(‘Rose 在集合中‘)
else :
print(‘Rose 不在集合中‘)
# 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中不同时存在的元素
以上输出结果：
{‘Mary‘, ‘Jim‘, ‘Rose‘, ‘Jack‘, ‘Tom‘}
Rose 在集合中
{‘b‘, ‘a‘, ‘c‘, ‘r‘, ‘d‘}
{‘b‘, ‘d‘, ‘r‘}
{‘l‘, ‘r‘, ‘a‘, ‘c‘, ‘z‘, ‘m‘, ‘b‘, ‘d‘}
{‘a‘, ‘c‘}
{‘l‘, ‘r‘, ‘z‘, ‘m‘, ‘b‘, ‘d‘}
Python数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
| 函数 | 描述 |
|---|---|
|
将x转换为一个整数 |
|
|
将x转换为一个长整数 |
|
|
将x转换到一个浮点数 |
|
|
创建一个复数 |
|
|
将对象 x 转换为字符串 |
|
|
将对象 x 转换为表达式字符串 |
|
|
用来计算在字符串中的有效Python表达式,并返回一个对象 |
|
|
将序列 s 转换为一个元组 |
|
|
将序列 s 转换为一个列表 |
|
|
转换为可变集合 |
|
|
创建一个字典。d 必须是一个序列 (key,value)元组。 |
|
|
转换为不可变集合 |
|
|
将一个整数转换为一个字符 |
|
|
将一个整数转换为Unicode字符 |
|
|
将一个字符转换为它的整数值 |
|
|
将一个整数转换为一个十六进制字符串 |
|
|
将一个整数转换为一个八进制字符串 |
脚本式编程
将如下代码拷贝至 hello.py文件中：
print ("Hello, Python!");
通过以下命令执行该脚本：
python3 hello.py
输出结果为：
Hello, Python!
在Linux/Unix系统中，你可以在脚本顶部添加以下命令让Python脚本可以像SHELL脚本一样可直接执行：
#! /usr/bin/env python3
然后修改脚本权限，使其有执行权限，命令如下：
$ chmod +x hello.py
执行以下命令：
./hello.py
输出结果为：
Hello, Python!
Python算术运算符
以下假设变量a为10，变量b为21：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 31 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -11 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 210 |
| / | 除 - x 除以 y | b / a 输出结果 2.1 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 1 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的21次方 |
| // | 取整除 - 返回商的整数部分 | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
Python位运算符
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
下表中变量 a 为 60，b 为 13二进制格式如下：
a = 0011 1100 b = 0000 1101 ----------------- a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 |
Python 支持三种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
Python 数字类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
-
int(x) 将x转换为一个整数。
-
float(x) 将x转换到一个浮点数。
-
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
-
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
数学函数
| 函数 | 返回值 ( 描述 ) |
|---|---|
| abs(x) | 返回数字的绝对值，如abs(-10) 返回 10 |
| ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
|
cmp(x, y) |
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃 。使用 使用 (x>y)-(x<y) 替换。 |
| exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 返回数字的绝对值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回数字的下舍整数，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10为基数的x的对数，如math.log10(100)返回 2.0 |
| max(x1, x2,...) | 返回给定参数的最大值，参数可以为序列。 |
| min(x1, x2,...) | 返回给定参数的最小值，参数可以为序列。 |
| modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 |
| pow(x, y) | x**y 运算后的值。 |
| round(x [,n]) | 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 |
| sqrt(x) | 返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j |
随机数函数
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
Python包含以下常用随机数函数：
| 函数 | 描述 |
|---|---|
| choice(seq) | 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。 |
| randrange ([start,] stop [,step]) | 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1 |
| random() | 随机生成下一个实数，它在[0,1)范围内。 |
| seed([x]) | 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。 |
| shuffle(lst) | 将序列的所有元素随机排序 |
| uniform(x, y) | 随机生成下一个实数，它在[x,y]范围内 |
三角函数
Python包括以下三角函数：
| 函数 | 描述 | |
|---|---|---|
| acos(x) | 返回x的反余弦弧度值。 | |
| asin(x) | 返回x的反正弦弧度值。 | |
| atan(x) | 返回x的反正切弧度值。 | |
| atan2(y, x) | 返回给定的 X 及 Y 坐标值的反正切值。 | |
| cos(x) | 返回x的弧度的余弦值。 | |
| hypot(x, y) | 返回欧几里德范数 sqrt(x*x + y*y)。 | |
| sin(x) | 返回的x弧度的正弦值。 | |
| tan(x) | 返回x弧度的正切值。 | |
| degrees(x) | 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0 | |
| radians(x) | 将角度转换为弧度 |
数学常量
| 常量 | 描述 |
|---|---|
| pi | 数学常量 pi（圆周率，一般以π来表示） |
| e | 数学常量 e，e即自然常数（自然常数）。 |
Python转义字符
在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：
| 转义字符 | 描述 |
|---|---|
| \(在行尾时) | 续行符 |
| \\ | 反斜杠符号 |
| \‘ | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \e | 转义 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other |
python字符串格式化符号:
<tbody
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
Python 的字符串内建函数
Python 的字符串常用内建函数如下：
| 序号 | 方法及描述 |
|---|---|
| 1 |
capitalize() |
| 2 |
返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 |
count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| 4 |
bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
| 5 |
encode(encoding=‘UTF-8‘,errors=‘strict‘) 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是‘ignore‘或者‘replace‘ |
| 6 |
endswith(suffix, beg=0, end=len(string)) |
| 7 |
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 |
| 8 |
find(str, beg=0 end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
| 9 |
index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常. |
| 10 |
如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
| 11 |
如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
| 12 |
如果字符串只包含数字则返回 True 否则返回 False.. |
| 13 |
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| 14 |
如果字符串中只包含数字字符，则返回 True，否则返回 False |
| 15 |
如果字符串中只包含空白，则返回 True，否则返回 False. |
| 16 |
如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| 17 |
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| 18 |
以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| 19 |
返回字符串长度 |
| 20 |
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
| 21 |
转换字符串中所有大写字符为小写. |
| 22 |
截掉字符串左边的空格或指定字符。 |
| 23 |
创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| 24 |
返回字符串 str 中最大的字母。 |
| 25 |
返回字符串 str 中最小的字母。 |
| 26 |
把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。 |
| 27 |
rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找. |
| 28 |
rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始. |
| 29 |
返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
| 30 |
删除字符串字符串末尾的空格. |
| 31 |
split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串 |
| 32 |
按照行(‘\r‘, ‘\r\n‘, \n‘)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| 33 |
startswith(str, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| 34 |
在字符串上执行 lstrip()和 rstrip() |
| 35 |
将字符串中大写转换为小写，小写转换为大写 |
| 36 |
返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| 37 |
translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| 38 |
转换字符串中的小写字母为大写 |
| 39 |
返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| 40 |
检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
Python列表函数&方法
Python包含以下函数:
| 序号 | 函数 |
|---|---|
| 1 | len(list) 列表元素个数 |
| 2 | max(list) 返回列表元素最大值 |
| 3 | min(list) 返回列表元素最小值 |
| 4 | list(seq) 将元组转换为列表 |
Python包含以下方法:
| 序号 | 方法 |
|---|---|
| 1 | list.append(obj) 在列表末尾添加新的对象 |
| 2 | list.count(obj) 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) 将对象插入列表 |
| 6 | list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) 移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() 反向列表中元素 |
| 9 | list.sort([func]) 对原列表进行排序 |
| 10 | list.clear() 清空列表 |
| 11 | list.copy() 复制列表 |
字典内置函数&方法
Python字典包含了以下内置函数：
| 序号 | 函数及描述 | 实例 |
|---|---|---|
| 1 | len(dict) 计算字典元素个数，即键的总数。 |
>>> dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
>>> len(dict)
3
|
| 2 | str(dict) 输出字典，以可打印的字符串表示。 |
>>> dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
>>> str(dict)
"{‘Name‘: ‘Runoob‘, ‘Class‘: ‘First‘, ‘Age‘: 7}"
|
| 3 | type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 |
>>> dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
>>> type(dict)
<class ‘dict‘>
|
Python字典包含了以下内置方法：
| 序号 | 函数及描述 |
|---|---|
| 1 | radiansdict.clear() 删除字典内所有元素 |
| 2 | radiansdict.copy() 返回一个字典的浅复制 |
| 3 | radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
| 4 | radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值 |
| 5 | key in dict 如果键在字典dict里返回true，否则返回false |
| 6 | radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组 |
| 7 | radiansdict.keys() 以列表返回一个字典所有的键 |
| 8 | radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9 | radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里 |
| 10 | radiansdict.values() 以列表返回字典中的所有值 |
| 11 | pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 12 | popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。 |
end 关键字
关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，实例如下：
#!/usr/bin/python3
# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 1000:
print(b, end=‘,‘)
a, b = b, a+b
执行以上程序，输出结果为：
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
break和continue语句及循环中的else子句
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 实例如下：
实例
执行以上脚本输出结果为：
当前字母为 : R
当前字母为 : u
当前字母为 : n
当前字母为 : o
当前字母为 : o
当期变量值为 : 10
当期变量值为 : 9
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 6
Good bye!
continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
实例
执行以上脚本输出结果为：
当前字母 : R
当前字母 : u
当前字母 : n
当前字母 : b
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!
生成器
在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行 next()方法时从当前位置继续运行。
以下实例使用 yield 实现斐波那契数列：
实例(Python 3.0+)
#!/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()
0 1 1 2 3 5 8 13 21 34 55
global 和 nonlocal关键字
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
以下实例修改全局变量 num：
#!/usr/bin/python3
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num)
num = 123
print(num)
fun1()
以上实例输出结果：
1
123
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：
#!/usr/bin/python3
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()
以上实例输出结果：
100
100
另外有一种特殊情况，假设下面这段代码被运行：
#!/usr/bin/python3
a = 10
def test():
a = a + 1
print(a)
test()
以上程序执行，报错信息如下：
Traceback (most recent call last):
File "test.py", line 7, in <module>
test()
File "test.py", line 5, in test
a = a + 1
UnboundLocalError: local variable ‘a‘ referenced before assignment
错误信息为局部作用域引用错误，因为 test 函数中的 a 使用的是局部，未定义，无法修改。
列表
Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。
以下是 Python 中列表的方法：
| 方法 | 描述 |
|---|---|
| list.append(x) | 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。 |
| list.extend(L) | 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。 |
| list.insert(i, x) | 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。 |
| list.remove(x) | 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。 |
| list.pop([i]) | 从列表的指定位置删除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被删除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。） |
| list.clear() | 移除列表中的所有项，等于del a[:]。 |
| list.index(x) | 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。 |
| list.count(x) | 返回 x 在列表中出现的次数。 |
| list.sort() | 对列表中的元素进行排序。 |
| list.reverse() | 倒排列表中的元素。 |
| list.copy() | 返回列表的浅复制，等于a[:]。 |
下面示例演示了列表的大部分方法：
>>> a = [66.25, 333, 333, 1, 1234.5] >>> print(a.count(333), a.count(66.25), a.count(‘x‘)) 2 1 0 >>> a.insert(2, -1) >>> a.append(333) >>> a [66.25, 333, -1, 333, 1, 1234.5, 333] >>> a.index(333) 1 >>> a.remove(333) >>> a [66.25, -1, 333, 1, 1234.5, 333] >>> a.reverse() >>> a [333, 1234.5, 1, 333, -1, 66.25] >>> a.sort() >>> a [-1, 1, 66.25, 333, 333, 1234.5]
注意：类似 insert, remove 或 sort 等修改列表的方法没有返回值。
遍历技巧
在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：
>>> knights = {‘gallahad‘: ‘the pure‘, ‘robin‘: ‘the brave‘}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：
>>> for i, v in enumerate([‘tic‘, ‘tac‘, ‘toe‘]): ... print(i, v) ... 0 tic 1 tac 2 toe
同时遍历两个或更多的序列，可以使用 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.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：
>>> for i in reversed(range(1, 10, 2)): ... print(i) ... 9 7 5 3 1
要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：
>>> basket = [‘apple‘, ‘orange‘, ‘apple‘, ‘pear‘, ‘orange‘, ‘banana‘] >>> for f in sorted(set(basket)): ... print(f) ... apple banana orange pear
-------->
模块......
以上是关于菜鸟教程 Python 手记 1的主要内容，如果未能解决你的问题，请参考以下文章