Python2的数据类型
1.Python基本数据类型简介
1.1 变量赋值
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：
#!/usr/bin/python # -*- coding: UTF-8 -*- counter = 100 # 赋值整型变量 miles = 1000.0 # 浮点型 name = "John" # 字符串 print (counter) print (miles) print (name) 以上实例中，100，1000.0和"John"分别赋值给counter，miles，name变量。 执行以上程序会输出如下结果： 结果输出: 100 1000.0 John
1.2 多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "john"
以上实例，两个整型对象 1 和 2 分别分配给变量 a 和 b，字符串对象 "john" 分配给变量 c。
1.3 标准数据类型
Python3 中有六个标准的数据类型：
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
1.4 Python 数字
数字数据类型用于存储数值。
他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
当你指定一个值时，Number 对象就会被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些对象的引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]
您可以通过使用del语句删除单个或多个对象的引用。例如：
del var del var_a, var_b
Python支持四种不同的数字类型：
- int（有符号整型）
- long（长整型，也可以代表八进制和十六进制）
- float（浮点型）
- complex（复数）
实例
一些数值类型的实例：
- 长整型也可以使用小写 l，但是还是建议您使用大写 L，避免与数字 1 混淆。Python使用 L 来显示长整型。
- Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
注意：long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。
1.5 Python字符串
字符串或串(String)是由数字、字母、下划线组成的一串字符。
一般记为 :
s = "a1a2···an" # n>=0
它是编程语言中表示文本的数据类型。
python的字串列表有2种取值顺序:
- 从左到右索引默认0开始的，最大范围是字符串长度少1
- 从右到左索引默认-1开始的，最大范围是字符串开头
如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
比如:
>>> s = 'abcdef' >>> s[1:5] 'bcde'
当使用以冒号分隔的字符串，python 返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。
上面的结果包含了 s[1] 的值 b，而取到的最大范围不包括尾下标，就是 s[5] 的值 f。
加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：
str = 'Hello World!' print (str) # 输出完整字符串 print (str[0]) # 输出字符串中的第一个字符 print (str[2:5]) # 输出字符串中第三个至第六个之间的字符串 print (str[2:]) # 输出从第三个字符开始的字符串 print (str * 2) # 输出字符串两次 print (str + "TEST") # 输出连接的字符串 #+号被称为万恶的加号，每次使用+号，都会在内存从从新开辟一块空间 以上实例输出结果： Hello World! H llo llo World! Hello World!Hello World! Hello World!TEST
Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
1.6 Python列表
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：
list = [ 'lizexiong', 786 , 2.23, 'john', 70.2 ] tinylist = [123, 'john'] print (list) # 输出完整列表 print (list[0]) # 输出列表的第一个元素 print (list[1:3]) # 输出第二个至第三个元素 print (list[2:]) # 输出从第三个开始至列表末尾的所有元素 print (tinylist * 2) # 输出列表两次 print (list + tinylist) # 打印组合的列表 结果输出: ['lizexiong', 786, 2.23, 'john', 70.2] lizexiong [786, 2.23] [2.23, 'john', 70.2] [123, 'john', 123, 'john'] ['lizexiong', 786, 2.23, 'john', 70.2, 123, 'john']
1.7 Python 元组
元组是另一个数据类型，类似于 List（列表）。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
tuple = ( 'lizexiong', 786 , 2.23, 'john', 70.2 ) tinytuple = (123, 'john') print (tuple) # 输出完整元组 print (tuple[0]) # 输出元组的第一个元素 print (tuple[1:3]) # 输出第二个至第四个（不包含）的元素 print (tuple[2:]) # 输出从第三个开始至列表末尾的所有元素 print (tinytuple * 2) # 输出元组两次 print (tuple + tinytuple) # 打印组合的元组 结果输出: ('lizexiong', 786, 2.23, 'john', 70.2) lizexiong (786, 2.23) (2.23, 'john', 70.2) (123, 'john', 123, 'john') ('lizexiong', 786, 2.23, 'john', 70.2, 123, 'john')
以下对元组的操作是无效的，因为元组不允许更新，而列表是允许更新的：
#!/usr/bin/python # -*- coding: UTF-8 -*- tuple = ( 'lizexiong', 786 , 2.23, 'john', 70.2 ) list = [ 'lizexiong', 786 , 2.23, 'john', 70.2 ] tuple[2] = 1000 # 元组中是非法应用 list[2] = 1000 # 列表中是合法应用 元组是不允许更新的，所以以上代码执行错误，结果如下： Traceback (most recent call last): File "test.py", line 6, in <module> tuple[2] = 1000 # 元组中是非法应用 TypeError: 'tuple' object does not support item assignment
但是元祖的元素的元素可以修改，如以下:
tuple = ( 'lizexiong', {'k2':"wuxinzhe"}) new_tuple = tuple[1]['k2']='wuxinzhesb' print (new_tuple) 结果输出 #如以下,元祖中字典的值已经发生了改变 wuxinzhesb
1.8 Python 字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
dict = {} dict['one'] = "This is one" dict[2] = "This is two" tinydict = {'name': 'lizexiong','code':9150, 'dept': 'sd2'} print (dict['one']) # 输出键为'one' 的值 print (dict[2]) # 输出键为 2 的值 print (tinydict) # 输出完整的字典 print (tinydict.keys()) # 输出所有键 print (tinydict.values()) # 输出所有值 结果输出: This is one This is two {'name': 'lizexiong', 'code': 9150, 'dept': 'sd2'} dict_keys(['name', 'code', 'dept']) dict_values(['lizexiong', 9150, 'sd2'])
1.9 Python 集合
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,...} 或者 set(value) #实例 #!/usr/bin/python3 sites = {'Google', 'Taobao', 'Lizexiong', 'Facebook', 'Zhihu', 'Baidu'} print(sites) # 输出集合，重复的元素被自动去掉 # 成员测试 if 'Lizexiong' in sites : print('Lizexiong 在集合中') else : print('Lizexiong 不在集合中') # 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', 'Lizexiong', 'Google', 'Facebook'} Lizexiong 在集合中 {'b', 'c', 'a', 'r', 'd'} {'r', 'b', 'd'} {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'} {'c', 'a'} {'z', 'b', 'm', 'r', 'l', 'd'}
2.Python数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
- int(x [,base])
描述
int() 函数用于将一个字符串或数字转换为整型。
语法
以下是 int() 方法的语法:
class int(x, base=10)
参数
x -- 字符串或数字。
base -- 进制数，默认十进制。
返回值
返回整型数据。
实例
以下展示了使用 int() 方法的实例：
>>>int() # 不传入参数时，得到结果0 0 >>> int(3) 3 >>> int(3.6) 3 >>> int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制 18 >>> int('0xa',16) 10 >>> int('10',8) 8
- long() 函数
描述
long() 函数将数字或字符串转换为一个长整型。
Python3.x 版本已删除 long() 函数。
语法
long() 函数语法：
class long(x, base=10)
参数
x -- 字符串或数字。
base -- 可选，进制数，默认十进制。
返回值
返回长整型数。
实例
以下实例展示了 long() 的使用方法：
>>>long() 0L >>> long(1) 1L >>> long('123') 123L >>>
- float() 函数
描述
float() 函数用于将整数和字符串转换成浮点数。
语法
float()方法语法：
class float([x])
参数
x -- 整数或字符串
返回值
返回浮点数。
实例
以下实例展示了 float() 的使用方法：
>>>float(1) 1.0 >>> float(112) 112.0 >>> float(-123.6) -123.6 >>> float('123') # 字符串 123.0
- complex() 函数
描述
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
语法
complex 语法：
class complex([real[, imag]])
参数说明：
real -- int, long, float或字符串；
imag -- int, long, float；
返回值
返回一个复数。
实例
以下实例展示了 complex 的使用方法：
>>>complex(1, 2) (1 + 2j) >>> complex(1) # 数字 (1 + 0j) >>> complex("1") # 当做字符串处理 (1 + 0j) # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 >>> complex("1+2j") (1 + 2j)
- str() 函数
描述
str() 函数将对象转化为适于人阅读的形式。
语法
以下是 str() 方法的语法:
class str(object='')
参数
object -- 对象。
返回值
返回一个对象的string格式。
实例
以下展示了使用 str() 方法的实例：
>>>s = 'LIZEXIONG' >>> str(s) 'LIZEXIONG' >>> dict = {'lizexiong': 'lizexiong.com', 'google': 'google.com'}; >>> str(dict) "{'google': 'google.com', 'lizexiong': 'lizexiong.com'}" >>>
- repr() 函数
描述
repr() 函数将对象转化为供解释器读取的形式。
语法
以下是 repr() 方法的语法:
repr(object)
参数
object -- 对象。
返回值
返回一个对象的 string 格式。
实例
以下展示了使用 repr() 方法的实例：
>>> s = 'LIZEXIONG' >>> repr(s) "'LIZEXIONG'" >>>dict = {'lizexiong': 'lizexiong.com', 'google': 'google.com'}; >>> repr(dict) "{'google': 'google.com', 'lizexiong': 'lizexiong.com'}" >>> 示例2 s="物品\t单价\t数量\n包子\t1\t2" print(s) print(repr(s)) 运行结果： 物品 单价 数量 包子 1 2 '物品\t单价\t数量\n包子\t1\t2'
- eval() 函数
描述
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
语法
以下是 eval() 方法的语法:
eval(expression[, globals[, locals]])
参数
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值
返回表达式计算结果。
实例
以下展示了使用 eval() 方法的实例：
>>>x = 7 >>> eval( '3 * x' ) 21 >>> eval('pow(2,2)') 4 >>> eval('2 + 2') 4 >>> n=81 >>> eval("n + 4") 85
- tuple()方法
描述
Python 元组 tuple() 函数将列表转换为元组。
语法
tuple()方法语法：
tuple( iterable )
参数
iterable -- 要转换为元组的可迭代序列。
返回值
返回元组。
实例
以下实例展示了 tuple()函数的使用方法：
实例1 >>>tuple([1,2,3,4]) (1, 2, 3, 4) >>> tuple({1:2,3:4}) #针对字典 会返回字典的key组成的tuple (1, 3) >>> tuple((1,2,3,4)) #元组会返回元组自身 (1, 2, 3, 4) 实例2 aList = [123, 'xyz', 'zara', 'abc']; aTuple = tuple(aList) print "Tuple elements : ", aTuple 结果输出: Tuple elements : (123, 'xyz', 'zara', 'abc')
- list()方法
描述
list() 方法用于将元组转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
语法
list()方法语法：
list( tup )
参数
tup -- 要转换为列表的元组。
返回值
返回列表。
实例
以下实例展示了 list() 函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- aTuple = (123, 'lizexiong', 'google', 'abc'); aList = list(aTuple) print ("列表元素 : ") print(aList) 以上实例输出结果如下： 列表元素 : [123, 'lizexiong', 'google', 'abc']
- set() 函数
描述
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
语法
set 语法：
class set([iterable])
参数说明：
iterable -- 可迭代对象对象；
返回值
返回新的集合对象。
实例
以下实例展示了 set 的使用方法：
交集 & : x&y，返回一个新的集合，包括同时在集合 x 和y中的共同元素。 并集 | : x|y，返回一个新的集合，包括集合 x 和 y 中所有元素。 差集 - : x-y，返回一个新的集合,包括在集合 x 中但不在集合 y 中的元素。 补集 ^ : x^y，返回一个新的集合，包括集合 x 和 y 的非共同元素。 >>> x = set('lizexiong') >>> y = set('google') >>> x,y ({'l', 'o', 'g', 'z', 'x', 'n', 'e', 'i'}, {'e', 'l', 'o', 'g'}) # 重复的被删除 >>> x & y # 交集 {'e', 'l', 'o', 'g'} >>> set(['o']) {'o'} >>> x | y # 并集 {'l', 'o', 'g', 'z', 'x', 'n', 'e', 'i'} >>> x - y # 差集 {'n', 'z', 'x', 'i'} >>>
- dict() 函数
描述
dict() 函数用于创建一个字典。
语法
dict 语法：
class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg)
参数说明：
**kwargs -- 关键字。
mapping -- 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
iterable -- 可迭代对象。
返回值
返回一个字典。
实例
以下实例展示了 dict 的使用方法：
>>>dict() # 创建空字典 {} >>> dict(a='a', b='b', t='t') # 传入关键字 {'a': 'a', 'b': 'b', 't': 't'} >>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典 {'three': 3, 'two': 2, 'one': 1} >>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典 {'three': 3, 'two': 2, 'one': 1} >>>
只使用关键字参数创建字典
numbers = dict(x=5, y=0) print('numbers =', numbers) print(type(numbers)) empty = dict() print('empty =', empty) print(type(empty)) 以上实例输出结果为： numbers = {'y': 0, 'x': 5} <class 'dict'> empty = {} <class 'dict'>
使用可迭代对象创建字典
# 没有设置关键字参数 numbers1 = dict([('x', 5), ('y', -5)]) print('numbers1 =',numbers1) # 设置关键字参数 numbers2 = dict([('x', 5), ('y', -5)], z=8) print('numbers2 =',numbers2) # zip() 创建可迭代对象 numbers3 = dict(dict(zip(['x', 'y', 'z'], [1, 2, 3]))) print('numbers3 =',numbers3) 以上实例输出结果为： numbers1 = {'y': -5, 'x': 5} numbers2 = {'z': 8, 'y': -5, 'x': 5} numbers3 = {'z': 3, 'y': 2, 'x': 1}
使用映射来创建字典
映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
# 没有设置关键字参数 numbers1 = dict([('x', 5), ('y', -5)]) print('numbers1 =',numbers1) # 设置关键字参数 numbers2 = dict([('x', 5), ('y', -5)], z=8) print('numbers2 =',numbers2) # zip() 创建可迭代对象 numbers3 = dict(dict(zip(['x', 'y', 'z'], [1, 2, 3]))) print('numbers3 =',numbers3) 以上实例输出结果为： numbers1 = {'y': -5, 'x': 5} numbers2 = {'z': 8, 'y': -5, 'x': 5} numbers3 = {'z': 3, 'y': 2, 'x': 1}
- frozenset() 函数
描述
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法
frozenset() 函数语法：
class frozenset([iterable])
参数
iterable -- 可迭代的对象，比如列表、字典、元组等等。
返回值
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
实例
以下实例展示了 frozenset() 的使用方法：
>>>a = frozenset(range(10)) # 生成一个新的不可变集合 >>> a frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> b = frozenset('lizexiong') >>> b frozenset({'l', 'o', 'g', 'z', 'x', 'n', 'e', 'i'}) # 创建不可变集合 >>>
为什么需要冻结的集合（即不可变的集合）呢？因为在集合的关系中，有集合的中的元素是另一个集合的情况，但是普通集合（set）本身是可变的，那么它的实例就不能放在另一个集合中（set中的元素必须是不可变类型）。
所以，frozenset提供了不可变的集合的功能，当集合不可变时，它就满足了作为集合中的元素的要求，就可以放在另一个集合中了。
- chr() 函数
描述
chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
语法
以下是 chr() 方法的语法:
chr(i)
参数
i -- 可以是10进制也可以是16进制的形式的数字。
返回值
返回值是当前整数对应的 ASCII 字符。
实例
以下展示了使用 chr() 方法的实例：
>>>print (chr(0x30), chr(0x31), chr(0x61)) # 十六进制 0 1 a >>> print (chr(48), chr(49), chr(97)) # 十进制 0 1 a
- unichr() 函数
描述
unichr() 函数 和 chr() 函数功能基本一样， 只不过是返回 unicode 的字符。
注意： Python3 不支持 unichr()，改用 chr() 函数。
语法
以下是 unichr() 方法的语法:
unichr(i)
参数
i -- 可以是10进制也可以是16进制的形式的数字。
返回值
返回 unicode 的字符。
实例
以下展示了使用 unichr() 方法的实例：
>>>unichr(97) u'a' >>> unichr(98) u'b' >>> unichr(99) u'c'
- ord() 函数
描述
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
语法
以下是 ord() 方法的语法:
ord(c)
参数
c -- 字符。
返回值
返回值是对应的十进制整数。
实例
以下展示了使用 ord() 方法的实例：
>>>ord('a') 97 >>> ord('b') 98 >>> ord('c') 99
- hex() 函数
描述
hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
语法
hex 语法：
hex(x)
参数说明：
x -- 10进制整数
返回值
返回16进制数，以字符串形式表示。
实例
以下实例展示了 hex 的使用方法：
>>>hex(255) '0xff' >>> hex(-42) '-0x2a' >>> hex(1L) '0x1L' >>> hex(12) '0xc' >>> type(hex(12)) <class 'str'> # 字符串
- oct() 函数
描述
oct() 函数将一个整数转换成 8 进制字符串。
-
- Python2.x 版本的 8 进制以 0 作为前缀表示。
- Python3.x 版本的 8 进制以 0o 作为前缀表示。
语法
oct 语法：
oct(x)
参数说明：
x -- 整数。
返回值
返回 8 进制字符串。
实例
以下实例展示了 oct 的使用方法：
实例(Python 2.0+) >>> oct(10) '012' >>> oct(20) '024' >>> oct(15) '017' 实例(Python 3.0+) >>> oct(10) '0o12' >>> oct(20) '0o24' >>> oct(15) '0o17'
3.数据类型内建函数操作之Number(数字)
Python Number 数据类型用于存储数值。
数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些 Number 对象引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]]
您可以通过使用del语句删除单个或多个对象，例如：
del var del var_a, var_b
Python 支持四种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
- 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
- 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
- 长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。Python没有L了。
- Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
3.1 Number 类型转换
int(x [,base ]) 将x转换为一个整数
long(x [,base ]) 将x转换为一个长整数
float(x ) 将x转换到一个浮点数
complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串
3.2 Python math 模块、cmath 模块
Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。
Python math 模块提供了许多对浮点数的数学运算函数。
Python cmath 模块包含了一些用于复数运算的函数。
cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。
要使用 math 或 cmath 函数必须先导入：
import math
查看 math 查看包中的内容:
>>> import math >>> dir(math) ['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc'] >>>
下文会介绍各个函数的具体应用。
查看 cmath 查看包中的内容
>>> import cmath >>> dir(cmath) ['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
实例
>>> import cmath >>> cmath.sqrt(-1) 1j >>> cmath.sqrt(9) (3+0j) >>> cmath.sin(1) (0.8414709848078965+0j) >>> cmath.log10(100) (2+0j) >>>
3.3 Python数学函数
- abs() 函数
描述
abs() 函数返回数字的绝对值。
语法
以下是 abs() 方法的语法:
abs( x )
参数
x -- 数值表达式。
返回值
函数返回x（数字）的绝对值。
实例
以下展示了使用 abs() 方法的实例：
#!/usr/bin/python3 print ("abs(-45) : ", abs(-45)) print ("abs(100.12) : ", abs(100.12)) 以上实例运行后输出结果为： abs(-45) : 45 abs(100.12) : 100.12
- ceil() 函数
描述
ceil() 函数返回数字的上入整数。
语法
以下是 ceil() 方法的语法:
import math math.ceil( x )
注意：ceil()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
函数返回数字的上入整数。
实例
以下展示了使用 ceil() 方法的实例：
#!/usr/bin/python import math # This will import math module print ("math.ceil(-45.17) : ", math.ceil(-45.17)) print ("math.ceil(100.12) : ", math.ceil(100.12)) print ("math.ceil(100.72) : ", math.ceil(100.72)) print ("math.ceil(math.pi) : ", math.ceil(math.pi)) 以上实例运行后输出结果为： math.ceil(-45.17) : -45.0 math.ceil(100.12) : 101.0 math.ceil(100.72) : 101.0 math.ceil(math.pi) : 4.0
- cmp() 函数
描述
cmp(x,y) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
语法
以下是 cmp() 方法的语法:
cmp( x, y )
参数
x -- 数值表达式。
y -- 数值表达式。
返回值
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
实例
#以下是python2 #!/usr/bin/python print "cmp(80, 100) : ", cmp(80, 100) print "cmp(180, 100) : ", cmp(180, 100) print "cmp(-80, 100) : ", cmp(-80, 100) print "cmp(80, -100) : ", cmp(80, -100) 以上实例运行后输出结果为： cmp(80, 100) : -1 cmp(180, 100) : 1 cmp(-80, 100) : -1 cmp(80, -100) : 1 Python 3.X 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象，包含的方法有： >>> import operator >>> operator.eq('hello', 'name'); False >>> operator.eq('hello', 'hello'); True
- exp() 函数
描述
exp() 方法返回x的指数,ex。
语法
以下是 exp() 方法的语法:
import math math.exp( x )
math.exp( x )
注意：exp()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回x的指数,ex。
实例
以下展示了使用 exp() 方法的实例：
#!/usr/bin/python import math # 导入 math 模块 print ("math.exp(-45.17) : ", math.exp(-45.17)) print ("math.exp(100.12) : ", math.exp(100.12)) print ("math.exp(100.72) : ", math.exp(100.72)) print ("math.exp(math.pi) : ", math.exp(math.pi)) 以上实例运行后输出结果为： math.exp(-45.17) : 2.4150062132629406e-20 math.exp(100.12) : 3.0308436140742566e+43 math.exp(100.72) : 5.522557130248187e+43 math.exp(math.pi) : 23.140692632779267
- fabs() 函数
描述
fabs() 方法返回数字的绝对值，如math.fabs(-10) 返回10.0。
语法
以下是 fabs() 方法的语法:
import math math.fabs( x )
注意：fabs()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回数字的绝对值。
实例
以下展示了使用 fabs() 方法的实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- import math # 导入数学模块 print ("math.fabs(-45.17) : ", math.fabs(-45.17)) print ("math.fabs(100.12) : ", math.fabs(100.12)) print ("math.fabs(100.72) : ", math.fabs(100.72)) print ("math.fabs(math.pi) : ", math.fabs(math.pi)) 以上实例运行后输出结果为： math.fabs(-45.17) : 45.17 math.fabs(100.12) : 100.12 math.fabs(100.72) : 100.72 math.fabs(math.pi) : 3.14159265359
Python 中 fabs(x) 方法返回 x 的绝对值。虽然类似于 abs() 函数，但是两个函数之间存在以下差异：
- abs() 是一个内置函数，而 fabs() 在 math 模块中定义的。
- fabs() 函数只适用于 float 和 integer 类型，而 abs() 也适用于复数。
#!/usr/bin/python # -*- coding: UTF-8 -*- import math a = -1 b = -1.3232 c = b d = 1+1.0j e = 3+4.0j print "a的绝对值是:", abs(a) print "b的绝对值是:", abs(b) print "c的绝对值是:", math.fabs(c) print "d的的绝对值是:", abs(d) """print "e的绝对值是:", math.fabs(e) """
最后一行代码如果去掉注释就会编译报错：
TypeError: can't convert complex to float // fabs 无法将复数转换为浮点型
Python3.x 测试代码：
import math a = -1 b = -1.3232 c = b d = 1+1.0j e = 3+4.0j print("a的绝对值是:",abs(a)) print("b的绝对值是:",abs(b)) print("c的绝对值是:",math.fabs(c)) print("d的的绝对值是:",abs(d)) """print("e的绝对值是:",math.fabs(e))"""
- floor() 函数
描述
floor() 返回数字的下舍整数。
语法
以下是 floor() 方法的语法:
import math math.floor( x )
注意：floor()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回数字的下舍整数。
实例
以下展示了使用 floor() 方法的实例：
#!/usr/bin/python import math # This will import math module print ("math.floor(-45.17) : ", math.floor(-45.17)) print ("math.floor(100.12) : ", math.floor(100.12)) print ("math.floor(100.72) : ", math.floor(100.72)) print ("math.floor(math.pi) : ", math.floor(math.pi)) 以上实例运行后输出结果为： math.floor(-45.17) : -46 math.floor(100.12) : 100 math.floor(100.72) : 100 math.floor(math.pi) : 3
- log() 函数
描述
log() 返回 x 的自然对数。
语法
以下是 log() 方法的语法:
import math math.log(x[, base])
注意：log()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
base -- 可选，底数，默认为 e。
返回值
返回 x 的自然对数，x>0。
实例
以下展示了使用 log() 方法的实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- import math # 导入 math 模块 print ("math.log(100.12) : ", math.log(100.12)) print ("math.log(100.72) : ", math.log(100.72)) print ("math.log(math.pi) : ", math.log(math.pi)) # 设置底数 print ("math.log(10,2) : ", math.log(10,2)) 以上实例运行后输出结果为： math.log(100.12) : 4.6063694665635735 math.log(100.72) : 4.612344389736092 math.log(math.pi) : 1.1447298858494002 math.log(10,2) : 3.3219280948873626
- log10() 函数
描述
log10() 方法返回以10为基数的x对数。
语法
以下是 log10() 方法的语法:
import math math.log10( x )
注意：log10()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回以10为基数的x对数，x>0。
实例
以下展示了使用 log10() 方法的实例：
#!/usr/bin/python import math # 导入 math 模块 print ("math.log10(100.12) : ", math.log10(100.12)) print ("math.log10(100.72) : ", math.log10(100.72)) print ("math.log10(math.pi) : ", math.log10(math.pi)) 以上实例运行后输出结果为： math.log10(100.12) : 2.0005208409361854 math.log10(100.72) : 2.003115717099806 math.log10(math.pi) : 0.49714987269413385
- max() 函数
描述
max() 方法返回给定参数的最大值，参数可以为序列。
语法
以下是 max() 方法的语法:
max( x, y, z, .... )
参数
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。
返回值
返回给定参数的最大值。
实例
以下展示了使用 max() 方法的实例：
#!/usr/bin/python print ("max(80, 100, 1000) : ", max(80, 100, 1000)) print ("max(-20, 100, 400) : ", max(-20, 100, 400)) print ("max(-80, -20, -10) : ", max(-80, -20, -10)) print ("max(0, 100, -400) : ", max(0, 100, -400)) 以上实例运行后输出结果为： max(80, 100, 1000) : 1000 max(-20, 100, 400) : 400 max(-80, -20, -10) : -10 max(0, 100, -400) : 100 以下还有列表和字典的对比 >>> a=[1,2,3,4] >>> type(a) #类型是列表 <type 'list'> >>> max(a) #max函数也返回了最大值 4 >>> >>> >>> a=[(1,2),(2,3),(3,4)] #假设列表里面是元组构成元素呢 >>> max(a) #按照元素里面元组的第一个元素的排列顺序，输出最大值（如果第一个元素相同，则比较第二个元素，输出最大值）据推理是按ascii码进行排序的 (3, 4) >>> a=[('a',1),('A',1)] #实验推测是按ascii码进行排序，比较 a 和 A 的值，得出a > A , 因为ascii 码里面，按照排列顺序 小 a在 A的后面 >>> max(a) ('a', 1) >>> a=[(1,2),(2,3),(3,1)] >>> a=[(1,3),(2,2),(3,1)] #列表里面的元素都由元组构成，元组都由数字组成，输出最大值 >>> max(a) (3, 1) >>> a={1:2,2:2,3:1,4:'aa'} #比较字典里面的最大值，会输出最大的键值 >>> max(a) 4
- min() 函数
描述
min() 方法返回给定参数的最小值，参数可以为序列。
语法
以下是 min() 方法的语法:
min( x, y, z, .... )
参数
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。
返回值
返回给定参数的最小值。
实例
以下展示了使用 min() 方法的实例：
#!/usr/bin/python print ("min(80, 100, 1000) : ", min(80, 100, 1000)) print ("min(-20, 100, 400) : ", min(-20, 100, 400)) print ("min(-80, -20, -10) : ", min(-80, -20, -10)) print ("min(0, 100, -400) : ", min(0, 100, -400)) 以上实例运行后输出结果为： min(80, 100, 1000) : 80 min(-20, 100, 400) : -20 min(-80, -20, -10) : -80 min(0, 100, -400) : -400 #列表和字典和max()一样可以比较，这里就不举例了
- modf() 函数
描述
modf() 方法返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
语法
以下是 modf() 方法的语法:
import math math.modf( x )
注意：modf()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回x的整数部分与小数部分，
实例
以下展示了使用 modf() 方法的实例：
import math # This will import math module print ("math.modf(100.12) : ", math.modf(100.12)) print ("math.modf(100.72) : ", math.modf(100.72)) print ("math.modf(math.pi) : ", math.modf(math.pi)) 以上实例运行后输出结果为： math.modf(100.12) : (0.12000000000000455, 100.0) math.modf(100.72) : (0.7199999999999989, 100.0) math.modf(math.pi) : (0.14159265358979312, 3.0)
- pow() 函数
描述
pow() 方法返回 xy（x 的 y 次方） 的值。
语法
以下是 math 模块 pow() 方法的语法:
import math math.pow( x, y )
内置的 pow() 方法
pow(x, y[, z])
函数是计算 x 的 y 次方，如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) %z。
注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
参数
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。
返回值
返回 xy（x的y次方） 的值。
实例
以下展示了使用 pow() 方法的实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- import math # 导入 math 模块 print ("math.pow(100, 2) : ", math.pow(100, 2)) # 使用内置，查看输出结果区别 print ("pow(100, 2) : ", pow(100, 2)) print ("math.pow(100, -2) : ", math.pow(100, -2)) print ("math.pow(2, 4) : ", math.pow(2, 4)) print ("math.pow(3, 0) : ", math.pow(3, 0)) 以上实例运行后输出结果为： math.pow(100, 2) : 10000.0 pow(100, 2) : 10000 math.pow(100, -2) : 0.0001 math.pow(2, 4) : 16.0 math.pow(3, 0) : 1.0
- round() 函数
描述
round() 方法返回浮点数x的四舍五入值。
语法
以下是 round() 方法的语法:
round( x [, n] )
参数
x -- 数值表达式。
n -- 数值表达式，表示从小数点位数。
返回值
返回浮点数x的四舍五入值。
实例
以下展示了使用 round() 方法的实例：
实例 #!/usr/bin/python print "round(80.23456, 2) : ", round(80.23456, 2) print "round(100.000056, 3) : ", round(100.000056, 3) print "round(-100.000056, 3) : ", round(-100.000056, 3) 以上实例运行后输出结果为： round(80.23456, 2) : 80.23 round(100.000056, 3) : 100.0 round(-100.000056, 3) : -100.0 在实际使用中发现round函数并不总是如上所说的四舍五入。如： In [14]: round(2.355, 2) Out[14]: 2.35 注：环境为 python3.5.2 因为该函数对于返回的浮点数并不是按照四舍五入的规则来计算，而会收到计算机表示精度的影响。 关于该问题搜索后解释比较清楚的文章地址如下：http://www.runoob.com/w3cnote/python-round-func-note.html
- sqrt() 函数
描述
sqrt() 方法返回数字x的平方根。
语法
以下是 sqrt() 方法的语法:
import math math.sqrt( x )
注意：sqrt()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回数字x的平方根。
实例
以下展示了使用 sqrt() 方法的实例：
#!/usr/bin/python import math # This will import math module print ("math.sqrt(100) : ", math.sqrt(100)) print ("math.sqrt(7) : ", math.sqrt(7)) print ("math.sqrt(math.pi) : ", math.sqrt(math.pi)) 以上实例运行后输出结果为： math.sqrt(100) : 10.0 math.sqrt(7) : 2.6457513110645907 math.sqrt(math.pi) : 1.7724538509055159
3.4 Python随机数函数
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
Python包含以下常用随机数函数：
- choice() 函数
描述
choice() 方法返回一个列表，元组或字符串的随机项。
语法
以下是 choice() 方法的语法:
import random random.choice( seq )
注意：choice()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
seq -- 可以是一个列表，元组或字符串。
返回值
返回随机项。
实例
以下展示了使用 choice() 方法的实例：
#!/usr/bin/python import random print ("choice([1, 2, 3, 5, 9]) : ", random.choice([1, 2, 3, 5, 9])) print ("choice('A String') : ", random.choice('A String')) 以上实例运行后输出结果为： choice([1, 2, 3, 5, 9]) : 2 choice('A String') : n
- randrange() 函数
描述
randrange() 方法返回指定递增基数集合中的一个随机数，基数默认值为1。
语法
以下是 randrange() 方法的语法:
import random random.randrange ([start,] stop [,step])
注意：randrange()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
start -- 指定范围内的开始值，包含在范围内。
stop -- 指定范围内的结束值，不包含在范围内。
step -- 指定递增基数。
返回值
从给定的范围返回随机项。
实例
以下展示了使用 randrange() 方法的实例：
#!/usr/bin/python import random # 输出 100 <= number < 1000 间的偶数 print ("randrange(100, 1000, 2) : ", random.randrange(100, 1000, 2)) # 输出 100 <= number < 1000 间的其他数 print ("randrange(100, 1000, 3) : ", random.randrange(100, 1000, 3)) 以上实例运行后输出结果为 randrange(100, 1000, 2) : 836 randrange(100, 1000, 3) : 922
- random() 函数
描述
random() 方法返回随机生成的一个实数，它在[0,1)范围内。
语法
以下是 random() 方法的语法:
import random random.random()
注意：random()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
无
返回值
返回随机生成的一个实数，它在[0,1)范围内。
实例
以下展示了使用 random() 方法的实例：
实例 #!/usr/bin/python # -*- coding: UTF-8 -*- import random # 生成第一个随机数 print ("random() : ", random.random()) # 生成第二个随机数 print ("random() : ", random.random()) 以上实例运行后输出结果为： random() : 0.281954791393 random() : 0.309090465205
- seed() 函数
描述
seed() 方法改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数。
语法
以下是 seed() 方法的语法:
import random random.seed ( [x]
我们调用 random.random() 生成随机数时，每一次生成的数都是随机的。但是，当我们预先使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个。
注意：seed()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
x -- 改变随机数生成器的种子 seed。如果你不了解其原理，你不必特别去设定 seed，Python会帮你选择 seed。
返回值
本函数没有返回值。
实例
以下展示了使用 seed() 方法的实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- import random print (random.random()) print (random.random()) print ("------- 设置种子 seed -------") random.seed( 10 ) print ("Random number with seed 10 : ", random.random()) # 生成同一个随机数 random.seed( 10 ) print ("Random number with seed 10 : ", random.random()) # 生成同一个随机数 random.seed( 10 ) print ("Random number with seed 10 : ", random.random()) 以上实例运行后输出结果为： 0.6910176594268757 0.29928825859537667 ------- 设置种子 seed ------- Random number with seed 10 : 0.5714025946899135 Random number with seed 10 : 0.5714025946899135 Random number with seed 10 : 0.5714025946899135
- shuffle() 函数
描述
shuffle() 方法将序列的所有元素随机排序。
语法
以下是 shuffle() 方法的语法:
import random random.shuffle (lst )
注意：shuffle()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
lst -- 可以是一个列表。
返回值
该函数没有返回值。
实例
以下展示了使用 shuffle() 方法的实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- import random list = [20, 16, 10, 5] random.shuffle(list) print ("随机排序列表 : ", list) random.shuffle(list) print ("随机排序列表 : ", list) 以上实例运行后输出结果为： 随机排序列表 : [16, 5, 10, 20] 随机排序列表 : [16, 5, 20, 10]
- uniform() 函数
描述
uniform() 方法将随机生成下一个实数，它在 [x, y] 范围内。
语法
以下是 uniform() 方法的语法:
import random random.uniform(x, y)
注意：uniform()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
x -- 随机数的最小值，包含该值。
y -- 随机数的最大值，包含该值。
返回值
返回一个浮点数 N，取值范围为如果 x<y 则 x <= N <= y，如果 y<x 则y <= N <= x。
实例
以下展示了使用 uniform() 方法的实例：
实例 #!/usr/bin/python # -*- coding: UTF-8 -*- import random print ("uniform(5, 10) 的随机数为 : ", random.uniform(5, 10)) print ("uniform(7, 14) 的随机数为 : ", random.uniform(7, 14)) 以上实例运行后输出结果为： uniform(5, 10) 的随机数为 : 6.98774810047 uniform(7, 14) 的随机数为 : 12.2243345905 #当然这里是浮点类型，也可以改成整数类型 a=int(random.uniform(10,100))
3.5 Python三角函数
Python包括以下三角函数：
- acos() 函数
描述
acos() 返回x的反余弦弧度值。
语法
以下是 acos() 方法的语法:
import math math.acos(x)
注意：acos()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- -1到1之间的数值。如果x是大于1，会产生一个错误。
返回值
返回x的反余弦弧度值。
实例
以下展示了使用 acos() 方法的实例：
#!/usr/bin/python import math print ("acos(0.64) : ", math.acos(0.64)) print ("acos(0) : ", math.acos(0)) print ("acos(-1) : ", math.acos(-1)) print ("acos(1) : ", math.acos(1)) 以上实例运行后输出结果为： acos(0.64) : 0.8762980611683406 acos(0) : 1.5707963267948966 acos(-1) : 3.141592653589793 acos(1) : 0.0
- asin() 函数
描述
asin() 返回x的反正弦弧度值。
语法
以下是 asin() 方法的语法:
import math math.asin(x)
注意：asin()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x : -1 到 1 之间的数值。如果 x 是大于 1，会产生一个错误。
返回值
返回x的反正弦弧度值。
实例
以下展示了使用 asin() 方法的实例：
#!/usr/bin/python import math print ("asin(0.64) : ", math.asin(0.64)) print ("asin(0) : ", math.asin(0)) print ("asin(-1) : ", math.asin(-1)) print ("asin(1) : ", math.asin(1)) 以上实例运行后输出结果为： asin(0.64) : 0.694498265626556 asin(0) : 0.0 asin(-1) : -1.5707963267948966 asin(1) : 1.5707963267948966
- atan() 函数
描述
atan() 返回x的反正切弧度值。
语法
以下是 atan() 方法的语法:
import math math.atan(x)
注意：atan()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
返回值
返回x的反正切弧度值。
实例
以下展示了使用 atan() 方法的实例：
#!/usr/bin/python import math print ("atan(0.64) : ", math.atan(0.64)) print ("atan(0) : ", math.atan(0)) print ("atan(10) : ", math.atan(10)) print ("atan(-1) : ", math.atan(-1)) print ("atan(1) : ", math.atan(1)) 以上实例运行后输出结果为： atan(0.64) : 0.5693131911006619 atan(0) : 0.0 atan(10) : 1.4711276743037347 atan(-1) : -0.7853981633974483 atan(1) : 0.7853981633974483
- atan2() 函数
描述
atan2() 返回给定的 X 及 Y 坐标值的反正切值。
语法
以下是 atan2() 方法的语法:
import math math.atan2(y, x)
注意：atan2()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
y -- 一个数值。
返回值
返回给定的 X 及 Y 坐标值的反正切值。
实例
以下展示了使用 atan2() 方法的实例：
#!/usr/bin/python import math print ("atan2(-0.50,-0.50) : ", math.atan2(-0.50,-0.50)) print ("atan2(0.50,0.50) : ", math.atan2(0.50,0.50)) print ("atan2(5,5) : ", math.atan2(5,5)) print ("atan2(-10,10) : ", math.atan2(-10,10)) print ("atan2(10,20) : ", math.atan2(10,20)) 以上实例运行后输出结果为： atan2(-0.50,-0.50) : -2.356194490192345 atan2(0.50,0.50) : 0.7853981633974483 atan2(5,5) : 0.7853981633974483 atan2(-10,10) : -0.7853981633974483 atan2(10,20) : 0.4636476090008061
- cos() 函数
描述
cos() 返回x的弧度的余弦值。
语法
以下是 cos() 方法的语法:
import math math.cos(x)
注意：cos()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
返回值
返回x的弧度的余弦值,-1 到 1 之间。
实例
以下展示了使用 cos() 方法的实例：
#!/usr/bin/python import math print ("cos(3) : ", math.cos(3)) print ("cos(-3) : ", math.cos(-3)) print ("cos(0) : ", math.cos(0)) print ("cos(math.pi) : ", math.cos(math.pi)) print ("cos(2*math.pi) : ", math.cos(2*math.pi)) 以上实例运行后输出结果为： cos(3) : -0.9899924966004454 cos(-3) : -0.9899924966004454 cos(0) : 1.0 cos(math.pi) : -1.0 cos(2*math.pi) : 1.0
- hypot() 函数
描述
hypot() 返回欧几里德范数 sqrt(x*x + y*y)。
语法
以下是 hypot() 方法的语法:
import math math.hypot(x, y)
注意：hypot()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
y -- 一个数值。
返回值
返回欧几里德范数 sqrt(x*x + y*y)。
实例
以下展示了使用 hypot() 方法的实例：
#!/usr/bin/python import math print ("hypot(3, 2) : ", math.hypot(3, 2)) print ("hypot(-3, 3) : ", math.hypot(-3, 3)) print ("hypot(0, 2) : ", math.hypot(0, 2)) 以上实例运行后输出结果为： hypot(3, 2) : 3.605551275463989 hypot(-3, 3) : 4.242640687119285 hypot(0, 2) : 2.0
- sin() 函数
描述
sin() 返回的x弧度的正弦值。
语法
以下是 sin() 方法的语法:
import math math.sin(x)
注意：sin()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
返回值
返回的x弧度的正弦值，数值在 -1 到 1 之间。
实例
以下展示了使用 sin() 方法的实例：
#!/usr/bin/python import math print ("sin(3) : ", math.sin(3)) print ("sin(-3) : ", math.sin(-3)) print ("sin(0) : ", math.sin(0)) print ("sin(math.pi) : ", math.sin(math.pi)) print ("sin(math.pi/2) : ", math.sin(math.pi/2)) 以上实例运行后输出结果为： sin(3) : 0.1411200080598672 sin(-3) : -0.1411200080598672 sin(0) : 0.0 sin(math.pi) : 1.2246467991473532e-16 sin(math.pi/2) : 1.0
- tan() 函数
描述
tan() 返回x弧度的正切值。
语法
以下是 tan() 方法的语法:
import math math.tan(x)
注意：tan()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
返回值
返回x弧度的正切值，数值在 -1 到 1 之间。
实例
以下展示了使用 tan() 方法的实例：
#!/usr/bin/python import math print ("tan(3) : ", math.tan(3)) print ("tan(-3) : ", math.tan(-3)) print ("tan(0) : ", math.tan(0)) print ("tan(math.pi) : ", math.tan(math.pi)) print ("tan(math.pi/2) : ", math.tan(math.pi/2)) print ("tan(math.pi/4) : ", math.tan(math.pi/4)) 以上实例运行后输出结果为： tan(3) : -0.1425465430742778 tan(-3) : 0.1425465430742778 tan(0) : 0.0 tan(math.pi) : -1.2246467991473532e-16 tan(math.pi/2) : 1.633123935319537e+16 tan(math.pi/4) : 0.9999999999999999
- degrees() 函数
描述
degrees() 将弧度转换为角度。
语法
以下是 degrees() 方法的语法:
import math math.degrees(x)
注意：degrees()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
返回值
返回一个角度值。
实例
以下展示了使用 degrees() 方法的实例：
#!/usr/bin/python import math print ("degrees(3) : ", math.degrees(3)) print ("degrees(-3) : ", math.degrees(-3)) print ("degrees(0) : ", math.degrees(0)) print ("degrees(math.pi) : ", math.degrees(math.pi)) print ("degrees(math.pi/2) : ", math.degrees(math.pi/2)) print ("degrees(math.pi/4) : ", math.degrees(math.pi/4)) 以上实例运行后输出结果为： degrees(3) : 171.88733853924697 degrees(-3) : -171.88733853924697 degrees(0) : 0.0 degrees(math.pi) : 180.0 degrees(math.pi/2) : 90.0 degrees(math.pi/4) : 45.0
- radians() 函数
描述
radians() 方法将角度转换为弧度。
语法
以下是 radians() 方法的语法:
角度和弧度关系是：2π 弧度 = 360°。从而 1°≈0.0174533 弧度，1 弧度≈57.29578°。
1) 角度转换为弧度公式：弧度=角度÷180×π
2) 弧度转换为角度公式： 角度=弧度×180÷π
import math math.radians(x)
注意：radians()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个角度数值，默认单位是角度 °。
返回值
返回一个角度的弧度值。
实例
以下展示了使用 radians() 方法的实例：
#!/usr/bin/python import math print ("radians(90) : ", math.radians(90)) print ("radians(45) : ", math.radians(45)) print ("radians(30) : ", math.radians(30)) 以上实例运行后输出结果为: radians(90) : 1.5707963267948966 radians(45) : 0.7853981633974483 radians(30) : 0.5235987755982988
3.6 Python数学常量
4.数据类型内建函数操作之字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号 ( ' 或 " ) 来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：
var1 = 'Hello World!' var2 = "Python Lizexiong"
4.1 Python 访问字符串中的值
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号来截取字符串，如下实例：
#!/usr/bin/python var1 = 'Hello World!' var2 = "Python Lizexiong" print ("var1[0]: ", var1[0]) print ("var2[1:5]: ", var2[1:5]) 以上实例执行结果： var1[0]: H var2[1:5]: ytho
4.2 Python 字符串连接
我们可以对字符串进行截取并与其他字符串进行连接，如下实例：
#字符串拼接 #!/usr/bin/python # -*- coding: UTF-8 -*- var1 = 'Hello World!' print ("输出 :- ", var1[:6] + 'Lizexiong!') 以上实例执行结果 输出 :- Hello Lizexiong!
4.3 Python 转义字符
在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表：
4.4 Python字符串运算符
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
#!/usr/bin/python # -*- coding: UTF-8 -*- a = "Hello" b = "Python" print ("a + b 输出结果：", a + b) #万恶的加号，使用加号会在内存中重新申请空间 print ("a * 2 输出结果：", a * 2 ) print ("a[1] 输出结果：", a[1]) print ("a[1:4] 输出结果：", a[1:4]) if( "H" in a) : print ("H 在变量 a 中") else : print ("H 不在变量 a 中") if( "M" not in a) : print ("M 不在变量 a 中") else : print ("M 在变量 a 中") print (r'\n') print (R'\n') 以上程序执行结果为： a + b 输出结果： HelloPython a * 2 输出结果： HelloHello a[1] 输出结果： e a[1:4] 输出结果： ell H 在变量 a 中 M 不在变量 a 中 \n \n
4.5 Python 字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
如下实例：
#!/usr/bin/python print ("My name is %s and weight is %d kg!" % ('LiZeXiong', 62)) 以上实例输出结果： My name is LiZeXiong and weight is 62 kg! 但是如果python后面格式化函数方法，就需要有点小小改动，这个需要特别注意，比如时间模块。如果还使用%就会报错 import time print ("time.localtime() : %s", % time.localtime()) 以上实例输出结果为： time.localtime() : %s time.struct_time(tm_year=2022, tm_mon=4, tm_mday=26, tm_ho ur=8, tm_min=55, tm_sec=46, tm_wday=1, tm_yday=116, tm_isdst=0)
python 字符串格式化符号:
格式化操作符辅助指令:
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
4.6 Python 三引号
Python 中三引号可以将复杂的字符串进行赋值。
Python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。
>>> hi = '''hi there''' >>> hi # repr() 'hi\nthere' >>> print hi # str() hi there
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。
一个典型的用例是，当你需要一块HTML或者SQL时，这时当用三引号标记，使用传统的转义字符体系将十分费神。
errHTML = ''' <HTML><HEAD><TITLE> Friends CGI Demo</TITLE></HEAD> <BODY><H3>ERROR</H3> <B>%s</B><P> <FORM><INPUT TYPE=button VALUE=Back ONCLICK="window.history.back()"></FORM> </BODY></HTML> ''' cursor.execute(''' CREATE TABLE users ( login VARCHAR(8), uid INTEGER, prid INTEGER) ''')
4.7 python的字符串内建函数
字符串方法是从python1.6到2.0慢慢加进来的——它们也被加到了Jython中。
这些方法实现了string模块的大部分方法，如下表所示列出了目前字符串内建支持的方法，所有的方法都包含了对Unicode的支持，有一些甚至是专门用于Unicode的。
Pyhton3默认就是UTF8编码。
- capitalize()方法
描述
Python capitalize() 将字符串的第一个字母变成大写,其他字母变小写。对于 8 位字节编码需要根据本地环境。
语法
capitalize()方法语法：
str.capitalize()
参数
无。
返回值
该方法返回一个首字母大写的字符串。
实例
以下实例展示了capitalize()方法的实例：
>>>s = 'a, B' >>> s.capitalize() 'A, b' >>> s = ' a, B' # a 前面有空格 >>> s.capitalize() ' a, b' >>> s = 'a, BCD' >>> s.capitalize() 'A, bcd'
- center()方法
描述
Python center() 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。
语法
center()方法语法：
str.center(width[, fillchar])
参数
width -- 字符串的总宽度。
fillchar -- 填充字符。
返回值
该方法返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。
实例
以下实例展示了center()方法的实例：
>>> str = 'lizexiong' >>> str.center(20,'*') '*****lizexiong******' >>> str.center(20) ' lizexiong ' >>>
- count()方法
描述
Python count() 方法用于统计字符串里某个字符或子字符串出现的次数。可选参数为在字符串搜索的开始与结束位置。
语法
count()方法语法：
str.count(sub, start= 0,end=len(string))
参数
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
返回值
该方法返回子字符串在字符串中出现的次数。
实例
以下实例展示了count()方法的实例：
#!/usr/bin/python str = "this is string example....wow!!!"; sub = "i"; print ("str.count(sub, 4, 40) : ", str.count(sub, 4, 40)) sub = "wow"; print ("str.count(sub) : ", str.count(sub)) 以上实例输出结果如下： str.count(sub, 4, 40) : 2 str.count(sub) : 1
- decode()方法
- encode()方法
decode和encode篇章参考本人其它博客，这里因为大部分是记录python3的学习过程，这里不做详细描述。
- endswith()方法
描述
Python endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
语法
endswith()方法语法：
str.endswith(suffix[, start[, end]])
参数
suffix -- 该参数可以是一个字符串或者是一个元素。
start -- 字符串中的开始位置。
end -- 字符中结束位置。
返回值
如果字符串含有指定的后缀返回True，否则返回False。
实例
以下实例展示了endswith()方法的实例：
#!/usr/bin/python str = "this is string example....wow!!!"; suffix = "wow!!!"; print (str.endswith(suffix)) print (str.endswith(suffix,20)) suffix = "is"; print (str.endswith(suffix, 2, 4)) print (str.endswith(suffix, 2, 6)) 以上实例输出结果如下： True True True False
- expandtabs()方法
描述
expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16...等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。
语法
expandtabs()方法语法：
str.expandtabs(tabsize=8)
参数
tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。
返回值
该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串。
实例
以下实例展示了expandtabs()方法的实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- str = "zxiong\t12345\tabc" print('原始字符串: {}'.format(str)) # 默认 8 个空格 # zxiong 有 6 个字符，后面的 \t 填充 2 个空格 # 12345 有 5 个字符，后面的 \t 填充 3 个空格 print('替换 \\t 符号: {}'.format(str.expandtabs())) # 2 个空格 # zxiong 有 6 个字符，刚好是 2 的 3 倍，后面的 \t 填充 2 个空格 # 12345 有 5 个字符，不是 2 的倍数，后面的 \t 填充 1 个空格 print('使用 2 个空格替换 \\t 符号: {}'.format(str.expandtabs(2))) # 3 个空格 print('使用 3 个空格: {}'.format(str.expandtabs(3))) # 4 个空格 print('使用 4 个空格: {}'.format(str.expandtabs(4))) # 5 个空格 print('使用 5 个空格: {}'.format(str.expandtabs(5))) # 6 个空格 print('使用 6 个空格: {}'.format(str.expandtabs(6))) 以上实例输出结果如下： 原始字符串: zxiong 12345 abc 替换 \t 符号: zxiong 12345 abc 使用 2 个空格替换 \t 符号: zxiong 12345 abc 使用 3 个空格: zxiong 12345 abc 使用 4 个空格: zxiong 12345 abc 使用 5 个空格: zxiong 12345 abc 使用 6 个空格: zxiong 12345 abc
- find()方法
描述
Python find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
语法
find()方法语法：
str.find(str, beg=0, end=len(string))
参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
返回值
如果包含子字符串返回开始的索引值，否则返回-1。
实例
以下实例展示了find()方法的实例：
实例1 #!/usr/bin/python str1 = "this is string example....wow!!!"; str2 = "exam"; print (str1.find(str2)) print (str1.find(str2, 10)) print (str1.find(str2, 40)) 以上实例输出结果如下： 15 15 -1 实例2 >>>info = 'abca' >>> print (info.find('a')) # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0 0 >>> print (info.find('a',1)) # 从下标1开始，查找在字符串里第一个出现的子串：返回结果3 3 >>> print (info.find('3')) # 查找不到返回-1 -1 >>>
- format 格式化函数
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序 'hello world' >>> "{0} {1}".format("hello", "world") # 设置指定位置 'hello world' >>> "{1} {0} {1}".format("hello", "world") # 设置指定位置 'world hello world'
也可以设置参数：
print("网站名：{name}, 地址 {url}".format(name="huawei", url="www.lizexiong.com")) # 通过字典设置参数 site = {"name": "huawei", "url": "www.lizexiong.com"} print("网站名：{name}, 地址 {url}".format(**site)) # 通过列表索引设置参数 my_list = ['huawei', 'www.lizexiong.com'] print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的 输出结果为： 网站名：huawei, 地址 www.lizexiong.com 网站名：huawei, 地址 www.lizexiong.com 网站名：huawei, 地址 www.lizexiong.com
也可以向 str.format() 传入对象：
#!/usr/bin/python # -*- coding: UTF-8 -*- class AssignValue(object): def __init__(self, value): self.value = value my_value = AssignValue(6) print('value 为: {0.value}'.format(my_value)) # "0" 是可选的 输出结果为： value 为: 6
数字格式化
下表展示了 str.format() 格式化数字的多种方法：
>>> print("{:.2f}".format(3.1415926)) 3.14
^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
此外我们可以使用大括号 {} 来转义大括号，如下实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- print ("{} 对应的位置是 {{0}}".format("lizexiong")) 输出结果为： lizexiong 对应的位置是 {0}
- index()方法
描述
Python index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
语法
index()方法语法：
str.index(str, beg=0, end=len(string))
参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
返回值
如果包含子字符串返回开始的索引值，否则抛出异常。
实例
以下实例展示了index()方法的实例：
#!/usr/bin/python str1 = "this is string example....wow!!!"; str2 = "exam"; print (str1.index(str2)) print (str1.index(str2, 10)) print (str1.index(str2, 40)) 以上实例输出结果如下： 15 15 Traceback (most recent call last): File "test.py", line 8, in print str1.index(str2, 40); ValueError: substring not found shell returned 1
- isalnum()方法
描述
Python isalnum() 方法检测字符串是否由字母和数字组成。
语法
isalnum()方法语法：
str.isalnum()
参数
无。
返回值
如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
实例
以下实例展示了isalnum()方法的实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- str = "this2009"; # 字符中没有空格 print (str.isalnum()) str = "this is string example....wow!!!"; print (str.isalnum()) 以上实例输出结果如下： True False
- isalpha()方法
描述
Python isalpha() 方法检测字符串是否只由字母组成。
语法
isalpha()方法语法：
str.isalpha()
参数
无。
返回值
如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。
实例
以下实例展示了isalpha()方法的实例：
#!/usr/bin/python # coding=utf-8 str = "lizexiong"; print (str.isalpha()) str = "lizexiong华为"; print (str.isalpha()) str = "this is string example....wow!!!"; print (str.isalpha()) 以上实例输出结果如下： True True #这里在python2中会变成false False
- isdecimal()方法
描述
Python isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。
注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。
语法
isdecimal()方法语法：
str.isdecimal()
参数
无
返回值
如果字符串是否只包含十进制字符返回True，否则返回False。
实例
以下实例展示了 isdecimal()函数的使用方法：
#!/usr/bin/python str = u"this2017"; print (str.isdecimal()); str = u"23443434"; print (str.isdecimal()); 以上实例输出结果如下： False True
- isdigit()方法
描述
Python isdigit() 方法检测字符串是否只由数字组成。
语法
isdigit()方法语法：
str.isdigit()
参数
无。
返回值
如果字符串只包含数字则返回 True 否则返回 False。
实例
以下实例展示了isdigit()方法的实例：
#!/usr/bin/python str = "123456"; # Only digit in this string print (str.isdigit()); str = "this is string example....wow!!!"; print (str.isdigit()); 以上实例输出结果如下： True False
- islower()方法
描述
Python islower() 方法检测字符串是否由小写字母组成。
语法
islower()方法语法：
str.islower()
参数
无。
返回值
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
实例
以下实例展示了islower()方法的实例：
#!/usr/bin/python str = "THIS is string example....wow!!!"; print (str.islower()); str = "this is string example....wow!!!"; print (str.islower()); 以上实例输出结果如下： False True
- isnumeric()方法
描述
Python isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象。
注：定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可，具体可以查看本章节例子。
语法
isnumeric()方法语法：
str.isnumeric()
参数
无。
返回值
如果字符串中只包含数字字符，则返回 True，否则返回 False
实例
以下实例展示了isnumeric()方法的实例：
#!/usr/bin/python str = u"this2017"; print (str.isnumeric()); str = u"23443434"; print (str.isnumeric()); 以上实例输出结果如下： False True
- isspace()方法
描述
Python isspace() 方法检测字符串是否只由空格组成。
语法
isspace()方法语法：
str.isspace()
参数
无。
返回值
如果字符串中只包含空格，则返回 True，否则返回 False.
实例
以下实例展示了isspace()方法的实例：
#!/usr/bin/python str = " "; print (str.isspace()); str = "This is string example....wow!!!"; print (str.isspace()); 以上实例输出结果如下： True False
- istitle()方法
描述
Python istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
语法
istitle()方法语法：
str.istitle()
参数
无。
返回值
如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.
实例
以下实例展示了istitle()方法的实例：
#!/usr/bin/python str = "This Is String Example...Wow!!!"; print (str.istitle()); str = "This is string example....wow!!!"; print (str.istitle()); 以上实例输出结果如下： True False
- isupper()方法
描述
Python isupper() 方法检测字符串中所有的字母是否都为大写。
语法
isupper()方法语法：
str.isupper()
参数
无。
返回值
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
实例
以下实例展示了 isupper() 方法的实例：
#!/usr/bin/python str = "THIS IS STRING EXAMPLE....WOW!!!"; print ( str.isupper() ); str = "THIS is string example....wow!!!"; print ( str.isupper() ); 以上实例输出结果如下： True False
- join()方法
描述
Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
语法
join()方法语法：
str.join(sequence)
参数
sequence -- 要连接的元素序列。
返回值
返回通过指定字符连接序列中元素后生成的新字符串。
实例
以下实例展示了join()的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- str = "-"; seq = ("a", "b", "c"); # 字符串序列 print (str.join( seq )); 以上实例输出结果如下： a-b-c
- ljust()方法
描述
Python ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
语法
ljust()方法语法：
str.ljust(width[, fillchar])
参数
width -- 指定字符串长度。
fillchar -- 填充字符，默认为空格。
返回值
返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
实例
以下实例展示了ljust()的使用方法：
#!/usr/bin/python str = "this is string example....wow!!!"; print (str.ljust(50, '0')); 以上实例输出结果如下： this is string example....wow!!!000000000000000000
- lower()方法
描述
Python lower() 方法转换字符串中所有大写字符为小写。
语法
lower()方法语法：
str.lower()
参数
无。
返回值
返回将字符串中所有大写字符转换为小写后生成的字符串。
实例
以下实例展示了lower()的使用方法：
#!/usr/bin/python str = "THIS IS STRING EXAMPLE....WOW!!!"; print (str.lower()); 以上实例输出结果如下： this is string example....wow!!!
- lstrip()方法
描述
Python lstrip() 方法用于截掉字符串左边的空格或指定字符。
语法
lstrip()方法语法：
str.lstrip([chars])
参数
chars --指定截取的字符。
返回值
返回截掉字符串左边的空格或指定字符后生成的新字符串。
实例
以下实例展示了lstrip()的使用方法：
#!/usr/bin/python str = " this is string example....wow!!! "; print (str.lstrip()); str = "88888888this is string example....wow!!!8888888"; print (str.lstrip('8')); 以上实例输出结果如下： this is string example....wow!!! this is string example....wow!!!8888888
- maketrans() 方法
描述
Python maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
注：两个字符串的长度必须相同，为一一对应的关系。
语法
maketrans()方法语法：
str.maketrans(intab, outtab)
参数
intab -- 字符串中要替代的字符组成的字符串。
outtab -- 相应的映射字符的字符串。
返回值
返回字符串转换后生成的新字符串。
实例
以下实例展示了使用 maketrans() 方法将所有元音字母转换为指定的数字：
#!/usr/bin/python # -*- coding: UTF-8 -*- from string import maketrans # 必须调用 maketrans 函数。 intab = "aeiou" outtab = "12345" trantab = maketrans(intab, outtab) str = "this is string example....wow!!!"; print (str.translate(trantab)); 以上实例输出结果如下： th3s 3s str3ng 2x1mpl2....w4w!!!
- max()方法
描述
Python max() 方法返回字符串中最大的字母。
语法
max()方法语法：
max(str)
参数
str -- 字符串。
返回值
返回字符串中最大的字母。
实例
以下实例展示了max()函数的使用方法：
#!/usr/bin/python str = "this is really a string example....wow!!!"; print ("Max character: " + max(str)); str = "this is a string example....wow!!!"; print ("Max character: " + max(str)); 以上实例输出结果如下： Max character: y Max character: x
- min()方法
描述
Python min() 方法返回字符串中最小的字母。
语法
min()方法语法：
min(str)
参数
str -- 字符串。
返回值
返回字符串中最小的字母。
实例
以下实例展示了min()函数的使用方法：
#!/usr/bin/python str = "this-is-real-string-example....wow!!!"; print ("Min character: " + min(str)); str = "this-is-a-string-example....wow!!!"; print ("Min character: " + min(str)); 以上实例输出结果如下： Min character: ! Min character: !
- partition() 方法
描述
partition() 方法用来根据指定的分隔符将字符串进行分割。
如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
partition() 方法是在2.5版中新增的。
语法
partition()方法语法：
str.partition(str)
参数
str : 指定的分隔符。
返回值
返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
实例
以下实例展示了使用 partition() 方法的使用：
#!/usr/bin/python str = "www.lizexiong.com" print (str.partition("."))
输出结果为： ('www', '.', 'lizexiong.com')
- replace()方法
描述
Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
语法
replace()方法语法：
str.replace(old, new[, max])
参数
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次
返回值
返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
实例
以下实例展示了replace()函数的使用方法：
#!/usr/bin/python str = "this is string example....wow!!! this is really string"; print (str.replace("is", "was")); print (str.replace("is", "was", 3)); 以上实例输出结果如下： thwas was string example....wow!!! thwas was really string thwas was string example....wow!!! thwas is really string
- rfind()方法
描述
Python rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
语法
rfind()方法语法：
str.rfind(str, beg=0 end=len(string))
参数
str -- 查找的字符串
beg -- 开始查找的位置，默认为 0
end -- 结束查找位置，默认为字符串的长度。
返回值
返回字符串最后一次出现的位置，如果没有匹配项则返回-1。
实例
以下实例展示了rfind()函数的使用方法：
#!/usr/bin/python str = "this is really a string example....wow!!!"; substr = "is"; print (str.rfind(substr)); print (str.rfind(substr, 0, 10)); print (str.rfind(substr, 10, 0)); print (str.find(substr)); print (str.find(substr, 0, 10)); print (str.find(substr, 10, 0)); 以上实例输出结果如下： 5 5 -1 2 2 -1
- rindex()方法
描述
Python rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
语法
rindex()方法语法：
str.rindex(str, beg=0 end=len(string))
参数
str -- 查找的字符串
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。
返回值
返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常。
实例
以下实例展示了rindex()函数的使用方法：
#!/usr/bin/python str1 = "this is string example....wow!!!"; str2 = "is"; print (str1.rindex(str2)); print (str1.index(str2)); 以上实例输出结果如下： 5 2
- rjust()方法
描述
Python rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
语法
rjust()方法语法：
str.rjust(width[, fillchar])
参数
width -- 指定填充指定字符后中字符串的总长度.
fillchar -- 填充的字符，默认为空格。
返回值
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
实例
以下实例展示了rjust()函数的使用方法：
#!/usr/bin/python str = "this is string example....wow!!!"; print (str.rjust(50, '0')); 以上实例输出结果如下： 000000000000000000this is string example....wow!!!
- rpartition() 方法
描述
rpartition() 方法类似于 partition() 方法，只是该方法是从目标字符串的末尾也就是右边开始搜索分割符。。
如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
语法
rpartition()方法语法：
str.rpartition(str)
参数
str : 指定的分隔符。
返回值
返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
实例
以下实例展示了使用 rpartition() 方法的使用：
#!/usr/bin/python str = "www.lizexiong.com" print (str.rpartition(".")) 输出结果为： ('www.lizexiong', '.', 'com')
- rstrip()方法
描述
Python rstrip() 删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。
语法
rstrip()方法语法：
str.rstrip([chars])
参数
chars -- 指定删除的字符（默认为空白符）
返回值
返回删除 string 字符串末尾的指定字符后生成的新字符串。
实例
以下实例展示了 rstrip() 函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- random_string = 'this is good ' # 字符串末尾的空格会被删除 print(random_string.rstrip()) # 'si oo' 不是尾随字符，因此不会删除任何内容 print(random_string.rstrip('si oo')) # 在 'sid oo' 中 'd oo' 是尾随字符，'ood' 从字符串中删除 print(random_string.rstrip('sid oo')) # 'm/' 是尾随字符，没有找到 '.' 号的尾随字符, 'm/' 从字符串中删除 website = 'www.lizexiong.com/' print(website.rstrip('m/.')) # 移除逗号(,)、点号(.)、字母 s、q 或 w，这几个都是尾随字符 txt = "banana,,,,,ssqqqww....." x = txt.rstrip(",.qsw") print(x) # 删除尾随字符 * str = "*****this is string example....wow!!!*****" print (str.rstrip('*')) print(x) 以上实例输出结果如下： this is good this is good this is g www.lizexiong.co banana *****this is string example....wow!!! banana
- split()方法
描述
Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串
语法
split() 方法语法：
str.split(str="", num=string.count(str)).
参数
str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。默认为 -1, 即分隔所有。
返回值
返回分割后的字符串列表。
实例
以下实例展示了 split() 函数的使用方法：
实例1 #!/usr/bin/python # -*- coding: UTF-8 -*- str = "Line1-abcdef \nLine2-abc \nLine4-abcd"; print (str.split( )); # 以空格为分隔符，包含 \n print (str.split(' ', 1 )); # 以空格为分隔符，分隔成两个 以上实例输出结果如下： ['Line1-abcdef', 'Line2-abc', 'Line4-abcd'] ['Line1-abcdef', '\nLine2-abc \nLine4-abcd'] 以下实例以 # 号为分割符，指定第二个参数为 1，返回两个参数列表。 实例2 #!/usr/bin/python # -*- coding: UTF-8 -*- txt = "Google#lizexiong#Taobao#Facebook" # 第二个参数为 1，返回两个参数列表 x = txt.split("#", 1) print (x) 以上实例输出结果如下： ['Google', 'lizexiong#Taobao#Facebook'] 实例3 #!/usr/bin/python # -*- coding: UTF-8 -*- import re a='Beautiful, is; better*than\nugly' # 四个分隔符为：, ; * \n x= re.split(',|; |\*|\n',a) print(x) 以上实例输出结果如下： ['Beautiful', ' is', 'better', 'than', 'ugly'] 实例4 以下演示以 + 和 _ 符号为分隔符： # -*- coding: utf-8 -*- str = "Chris_iven+Chris_jack+Chris_lusy" print (str.split("+")) print (str.split("_")) 输出结果为： ['Chris_iven', 'Chris_jack', 'Chris_lusy'] ['Chris', 'iven+Chris', 'jack+Chris', 'lusy']
- splitlines()方法
描述
Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
语法
splitlines()方法语法：
str.splitlines([keepends])
参数
keepends -- 在输出结果里是否保留换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。
返回值
返回一个包含各行作为元素的列表。
实例
以下实例展示了splitlines()函数的使用方法：
#!/usr/bin/python str1 = 'ab c\n\nde fg\rkl\r\n' print (str1.splitlines()) str2 = 'ab c\n\nde fg\rkl\r\n' print (str2.splitlines(True)) 以上实例输出结果如下： ['ab c', '', 'de fg', 'kl'] ['ab c\n', '\n', 'de fg\r', 'kl\r\n']
- startswith()方法
描述
Python startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
语法
startswith()方法语法：
str.startswith(str, beg=0,end=len(string));
参数
str -- 检测的字符串。
strbeg -- 可选参数用于设置字符串检测的起始位置。
strend -- 可选参数用于设置字符串检测的结束位置。
返回值
如果检测到字符串则返回True，否则返回False。
实例
以下实例展示了startswith()函数的使用方法：
#!/usr/bin/python str = "this is string example....wow!!!"; print (str.startswith( 'this' )); print (str.startswith( 'is', 2, 4 )); print (str.startswith( 'this', 2, 4 )); 以上实例输出结果如下： True True False
- strip()方法
描述
Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
语法
strip()方法语法：
str.strip([chars]);
参数
chars -- 移除字符串头尾指定的字符序列。
返回值
返回移除字符串头尾指定的字符生成的新字符串。
实例
以下实例展示了strip()函数的使用方法：
实例1 #!/usr/bin/python # -*- coding: UTF-8 -*- str = "00000003210lizexiong01230000000"; print (str.strip( '0' )); # 去除首尾字符 0 str2 = " lizexiong "; # 去除首尾空格 print (str2.strip()); 以上实例输出结果如下： 3210lizexiong0123 lizexiong 从结果上看，可以注意到中间部分的字符并未删除。 以上下例演示了只要头尾包含有指定字符序列中的字符就删除： 实例2 #!/usr/bin/python # -*- coding: UTF-8 -*- str = "123abclizexiong321" print (str.strip( '12' )) # 字符序列为 12 以上实例输出结果如下： 3abclizexiong3
- swapcase()方法
描述
Python swapcase() 方法用于对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母。
语法
swapcase() 方法语法：
str.swapcase();
参数
NA。
返回值
返回大小写字母转换后生成的新字符串。
实例
以下实例展示了 swapcase() 函数的使用方法：
#!/usr/bin/python str = "LIZEXIONG!!!"; print ( str.swapcase() ); str = "lizexiong!!!"; print ( str.swapcase() ); str = "abCDE--LiZeXiong!!!"; print ( str.swapcase() ); 以上实例输出结果如下： lizexiong!!! LIZEXIONG!!! ABcde--lIzExIONG!!!
- title()方法
描述
Python title() 方法返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。
语法
title()方法语法：
str.title();
参数
NA。
返回值
返回"标题化"的字符串,就是说所有单词都是以大写开始。
实例
以下实例展示了 title()函数的使用方法：
#!/usr/bin/python str = "this is string example....wow!!!"; print (str.title()); 以上实例输出结果如下： This Is String Example....Wow!!!
- translate()方法
描述
Python translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。
语法
translate()方法语法：
str.translate(table[, deletechars]);
参数
table -- 翻译表，翻译表是通过maketrans方法转换而来。
deletechars -- 字符串中要过滤的字符列表。
返回值
返回翻译后的字符串。
实例
以下实例展示了 translate()函数的使用方法：
实例1 #!/usr/bin/python from string import maketrans # 引用 maketrans 函数。 intab = "aeiou" outtab = "12345" trantab = maketrans(intab, outtab) str = "this is string example....wow!!!"; print (str.translate(trantab)); 以上实例输出结果如下： th3s 3s str3ng 2x1mpl2....w4w!!!
- upper()方法
描述
Python upper() 方法将字符串中的小写字母转为大写字母。
语法
upper()方法语法：
str.upper()
参数
NA。
返回值
返回小写字母转为大写字母的字符串。
实例
以下实例展示了 upper()函数的使用方法：
#!/usr/bin/python str = "this is string example....wow!!!"; print ("str.upper() : ", str.upper()) 以上实例输出结果如下： str.upper() : THIS IS STRING EXAMPLE....WOW!!!
- zfill()方法
描述
Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
语法
zfill()方法语法：
str.zfill(width)
参数
width -- 指定字符串的长度。原字符串右对齐，前面填充0。
返回值
返回指定长度的字符串。
实例
以下实例展示了 zfill()函数的使用方法：
#!/usr/bin/python str = "this is string example....wow!!!"; print (str.zfill(40)); print (str.zfill(50)); 以上实例输出结果如下： 00000000this is string example....wow!!! 000000000000000000this is string example....wow!!! #基本跟 string.rjust(width,'0') 输出结果一样
5.数据类型内建函数操作之列表
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
list1 = ['physics', 'chemistry', 1997, 2000] list2 = [1, 2, 3, 4, 5 ] list3 = ["a", "b", "c", "d"]
与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。
5.1 访问列表中的值
使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：
#!/usr/bin/python list1 = ['physics', 'chemistry', 1997, 2000] list2 = [1, 2, 3, 4, 5, 6, 7 ] print ("list1[0]: ", list1[0]) print ("list2[1:5]: ", list2[1:5]) 以上实例输出结果： list1[0]: physics list2[1:5]: [2, 3, 4, 5]
5.2 更新列表
你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：
#!/usr/bin/python # -*- coding: UTF-8 -*- list = [] ## 空列表 list.append('Google') ## 使用 append() 添加元素 list.append('lizexiong') print (list) 注意：我们会在接下来的章节讨论append()方法的使用 以上实例输出结果： ['Google', 'lizexiong']
5.3 删除列表元素
可以使用 del 语句来删除列表的元素，如下实例：
#!/usr/bin/python list1 = ['physics', 'chemistry', 1997, 2000] print list1 del list1[2] print ("After deleting value at index 2 : ") print (list1) 以上实例输出结果： ['physics', 'chemistry', 1997, 2000] After deleting value at index 2 : ['physics', 'chemistry', 2000] 注意：我们会在接下来的章节讨论remove()方法的使用
5.4 Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
5.5 Python列表截取
Python 的列表截取实例如下：
>>>L = ['Google', 'lizexiong', 'Taobao'] >>> L[2] 'Taobao' >>> L[-2] 'lizexiong' >>> L[1:] ['lizexiong', 'Taobao'] >>>
5.6 Python列表函数
Python包含以下函数:
- List cmp()方法
描述
cmp() 方法用于比较两个列表的元素。
语法
cmp()方法语法：
cmp(list1, list2)
参数
list1 -- 比较的列表。
list2 -- 比较的列表。
返回值
如果比较的元素是同类型的,则比较其值,返回结果。
如果两个元素不是同一种类型,则检查它们是否是数字。
-
- 如果是数字,执行必要的数字强制类型转换,然后比较。
- 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
- 否则,通过类型名字的字母顺序进行比较。
如果有一个列表首先到达末尾,则另一个长一点的列表"大"。
如果我们用尽了两个列表的元素而且所 有元素都是相等的,那么结果就是个平局,就是说返回一个 0。
实例
以下实例展示了 cmp()函数的使用方法：
#!/usr/bin/python list1, list2 = [123, 'xyz'], [456, 'abc'] print cmp(list1, list2); print cmp(list2, list1); list3 = list2 + [786]; print cmp(list2, list3) 以上实例输出结果如下： -1 1 -1 以上是python2的做法。 Python 3.X 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象，包含的方法有： operator.lt(a, b) operator.le(a, b) operator.eq(a, b) operator.ne(a, b) operator.ge(a, b) operator.gt(a, b) operator.__lt__(a, b) operator.__le__(a, b) operator.__eq__(a, b) operator.__ne__(a, b) operator.__ge__(a, b) operator.__gt__(a, b) 实例 >>> import operator >>> operator.eq('hello', 'name'); False >>> operator.eq('hello', 'hello'); True 或者如果你真的需要 cmp() 函数，你可以用表达式 (a > b) - (a < b) 代替 cmp(a,b)。
- List len()方法
描述
len() 方法返回列表元素个数。
语法
len()方法语法：
len(list)
参数
list -- 要计算元素个数的列表。
返回值
返回列表元素个数。
实例
以下实例展示了 len()函数的使用方法：
#!/usr/bin/python list1, list2 = [123, 'xyz', 'zara'], [456, 'abc'] print ("First list length : ", len(list1)) print ("Second list length : ", len(list2)) 以上实例输出结果如下： First list length : 3 Second lsit length : 2
- List max()方法
描述
max() 方法返回列表元素中的最大值。
语法
max()方法语法：
max(list)
参数
list -- 要返回最大值的列表。
返回值
返回列表元素中的最大值。
实例
以下实例展示了 max()函数的使用方法：
#!/usr/bin/python list1, list2 = ['123', 'xyz', 'zara', 'abc'], [456, 700, 200] print ("Max value element : ", max(list1)) print ("Max value element : ", max(list2)) 以上实例输出结果如下： Max value element : zara Max value element : 700 #这里有很重要的一点，看到123，用引号标识起来，是因为只能比较同类型的值，如果是str和int，max函数会报错。
- List min()方法
描述
min() 方法返回列表元素中的最小值。
语法
min()方法语法：
min(list)
参数
list -- 要返回最小值的列表。
返回值
返回列表元素中的最小值。
实例
以下实例展示了 min()函数的使用方法：
#!/usr/bin/python list1, list2 = [123, 'xyz', 'zara', 'abc'], [456, 700, 200] print ("min value element : ", min(list1)) print ("min value element : ", min(list2)) 以上实例输出结果如下： min value element : 123 min value element : 200
- List list()方法
描述
list() 方法用于将元组转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
语法
list()方法语法：
list( tup )
参数
tup -- 要转换为列表的元组。
返回值
返回列表。
实例
以下实例展示了 list() 函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- aTuple = (123, 'lizexiong', 'google', 'abc'); aList = list(aTuple) print ("列表元素 : ") print(aList) 以上实例输出结果如下： 列表元素 : [123, 'lizexiong', 'google', 'abc']
5.7 Python列表方法
- List append()方法
描述
append() 方法用于在列表末尾添加新的对象。
语法
append()方法语法：
list.append(obj)
参数
obj -- 添加到列表末尾的对象。
返回值
该方法无返回值，但是会修改原来的列表。
实例
以下实例展示了 append()函数的使用方法：
#!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc']; aList.append( 2017 ); print ("Updated List : ", aList) 以上实例输出结果如下： Updated List : [123, 'xyz', 'zara', 'abc', 2017]
- List count()方法
描述
count() 方法用于统计某个元素在列表中出现的次数。
语法
count()方法语法：
list.count(obj)
参数
obj -- 列表中统计的对象。
返回值
返回元素在列表中出现的次数。
实例
以下实例展示了 count()函数的使用方法：
#!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc', 123]; print ("Count for 123 : ", aList.count(123)) print ("Count for zara : ", aList.count('zara')) 以上实例输出结果如下： Count for 123 : 2 Count for zara : 1
- List extend()方法
描述
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
语法
extend()方法语法：
list.extend(seq)
参数
seq -- 元素列表。
返回值
该方法没有返回值，但会在已存在的列表中添加新的列表内容。
实例
以下实例展示了 extend()函数的使用方法：
#!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc', 123]; bList = [2017, 'manni']; aList.extend(bList) print "Extended List : ", aList ; 以上实例输出结果如下： Extended List : [123, 'xyz', 'zara', 'abc', 123, 2017, 'manni']
- List index()方法
描述
index() 函数用于从列表中找出某个值第一个匹配项的索引位置。
语法
index()方法语法：
list.index(x[, start[, end]])
参数
x-- 查找的对象。
start-- 可选，查找的起始位置。
end-- 可选，查找的结束位置。
返回值
该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
实例
以下实例展示了 index()函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- aList = [123, 'xyz', 'lizexiong', 'abc'] print ("xyz 索引位置: ", aList.index( 'xyz' )) print ("lizexiong 索引位置 : ", aList.index( 'lizexiong', 1, 3 )) 以上实例输出结果如下： xyz 索引位置: 1 lizexiong 索引位置 : 2 补充案例场景 如果 list 存储了若干复杂结构的值，比如这样的一个列表： temp = [('a', 1, 1.5), ('b', 2, 5.1), ('c', 9, 4.3)] 你想找到其中是 ('b', XX, XX) 这样的元素，其中 XX 可以为任意值。这种情况无法通过 index 函数来获得，我们可以利用 sort 的 key 参数来实现。 list.sort（或者 sorted 函数）有一个 key 参数，你可以提供一个函数来作为排序的依据。此时我们可以传入以下值： temp.sort(key = lambda x:x[0]!='b') 随后我们会发现，所有形如 ('b', XX, XX) 的元素全部浮动到了列表的头部，此时我们访问 temp[0] 就可以获得想要查找的值了。 我们也可以写一个简单的函数： findindex = lambda self,i,value:sorted(self,key=lambda x:x[i]!=value)[0] 那我们只需要这样调用： >>> findindex(temp,0,'b') 就会返回它找到的第一个值： >>> ('b',2)
- List insert()方法
描述
insert() 函数用于将指定对象插入列表的指定位置。
语法
insert()方法语法：
list.insert(index, obj)
参数
index -- 对象 obj 需要插入的索引位置。
obj -- 要插入列表中的对象。
返回值
该方法没有返回值，但会在列表指定位置插入对象。
实例
以下实例展示了 insert()函数的使用方法：
#!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc'] aList.insert( 3, 2017) print ("Final List : ", aList) 以上实例输出结果如下： Final List : [123, 'xyz', 'zara', 2017, 'abc'] #列表为空时，位置参数无效
- List pop()方法
描述
pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
语法
pop()方法语法：
list.pop([index=-1])
参数
obj -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。
返回值
该方法返回从列表中移除的元素对象。
实例
以下实例展示了 pop()函数的使用方法：
#!/usr/bin/python3 #coding=utf-8 list1 = ['Google', 'lizexiong', 'Taobao'] list_pop=list1.pop(1) print "删除的项为 :", list_pop print "列表现在为 : ", list1 以上实例输出结果如下： 删除的项为 : lizexiong 列表现在为 : ['Google', 'Taobao']
- List remove()方法
描述
remove() 函数用于移除列表中某个值的第一个匹配项。
语法
remove()方法语法：
list.remove(obj)
参数
obj -- 列表中要移除的对象。
返回值
该方法没有返回值但是会移除列表中的某个值的第一个匹配项。
实例
以下实例展示了 remove()函数的使用方法：
#!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc', 'xyz']; aList.remove('xyz'); print ("List : ", aList) aList.remove('abc'); print "List : ", aList; 以上实例输出结果如下： List : [123, 'zara', 'abc', 'xyz'] List : [123, 'zara', 'xyz']
- List reverse()方法
描述
reverse() 函数用于反向列表中元素。
语法
reverse()方法语法：
list.reverse()
参数
NA。
返回值
该方法没有返回值，但是会对列表的元素进行反向排序。
实例
以下实例展示了 reverse()函数的使用方法：
#!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc', 'xyz'] aList.reverse() print ("List : ", aList) 以上实例输出结果如下： List : ['xyz', 'abc', 'zara', 'xyz', 123]
- List sort()方法
描述
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
语法
sort()方法语法：
list.sort(cmp=None, key=None, reverse=False)
参数
cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
返回值
该方法没有返回值，但是会对列表的对象进行排序。
实例
以下实例展示了 sort() 函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- aList = ['123', 'Google', 'lizexiong', 'Taobao', 'Facebook']; aList.sort(); print("List : ") print(aList) 以上实例输出结果如下： List : ['123', 'Facebook', 'Google', 'lizexiong', 'Taobao']
以下实例降序输出列表：
#!/usr/bin/python # -*- coding: UTF-8 -*- # 列表 vowels = ['e', 'a', 'u', 'o', 'i'] # 降序 vowels.sort(reverse=True) # 输出结果 print('降序输出:') print( vowels ) 以上实例输出结果如下： 降序输出: ['u', 'o', 'i', 'e', 'a']
以下实例演示了通过指定列表中的元素排序来输出列表：
#!/usr/bin/python # -*- coding: UTF-8 -*- # 获取列表的第二个元素 def takeSecond(elem): return elem[1] # 列表 random = [(2, 2), (3, 4), (4, 1), (1, 3)] # 指定第二个元素排序 random.sort(key=takeSecond) # 输出类别 print('排序列表：') print(random) 以上实例输出结果如下： 排序列表： [(4, 1), (2, 2), (1, 3), (3, 4)]
6.数据类型内建函数操作之元祖
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
如下实例：
tup1 = ('physics', 'chemistry', 1997, 2000) tup2 = (1, 2, 3, 4, 5 ) tup3 = "a", "b", "c", "d"
创建空元组
tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,)
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
6.1 访问元组
元组可以使用下标索引来访问元组中的值，如下实例:
#!/usr/bin/python tup1 = ('physics', 'chemistry', 1997, 2000) tup2 = (1, 2, 3, 4, 5, 6, 7 ) print ("tup1[0]: ", tup1[0]) print ("tup2[1:5]: ", tup2[1:5]) 以上实例输出结果： tup1[0]: physics tup2[1:5]: (2, 3, 4, 5)
6.2 修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
#!/usr/bin/python # -*- coding: UTF-8 -*- tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print (tup3) 以上实例输出结果： (12, 34.56, 'abc', 'xyz')
6.3 删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
#!/usr/bin/python tup = ('physics', 'chemistry', 1997, 2000) print (tup) del tup print ("After deleting tup : ") print (tup) 以上实例元组被删除后，输出变量会有异常信息，输出如下所示： ('physics', 'chemistry', 1997, 2000) After deleting tup : Traceback (most recent call last): File "test.py", line 9, in <module> print tup NameError: name 'tup' is not defined
6.4 元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
6.5 元组索引，截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
元组：
L = ('spam', 'Spam', 'SPAM!')
6.6 无关闭分隔符
任意无符号的对象，以逗号隔开，默认为元组，如下实例：
#!/usr/bin/python print ('abc', -4.24e93, 18+6.6j, 'xyz') x, y = 1, 2 print ("Value of x , y : ", x,y) print type(x,y) 以上实例运行结果： abc -4.24e+93 (18+6.6j) xyz Value of x , y : 1 2
6.7 元组内置函数
Python元组包含了以下内置函数
- Tuple(元组) cmp()方法
描述
Python 元组 cmp() 函数用于比较两个元组元素。
语法
cmp()方法语法：
cmp(tuple1, tuple2)
参数
tuple1 -- 比较的元组。
tuple2 -- 比较的另外一个元组。
返回值
如果比较的元素是同类型的,则比较其值,返回结果。
如果两个元素不是同一种类型,则检查它们是否是数字。
-
- 如果是数字,执行必要的数字强制类型转换,然后比较。
- 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
- 否则,通过类型名字的字母顺序进行比较。
如果有一个列表首先到达末尾,则另一个长一点的列表"大"。
如果我们用尽了两个列表的元素而且所 有元素都是相等的,那么结果就是个平局,就是说返回一个 0。
实例
以下实例展示了 cmp()函数的使用方法：
#!/usr/bin/python2 tuple1, tuple2 = (123, 'xyz'), (456, 'abc') print cmp(tuple1, tuple2); print cmp(tuple2, tuple1); tuple3 = tuple2 + (786,); print cmp(tuple2, tuple3) tuple4 = (123, 'xyz') print cmp(tuple1, tuple4) 以上实例输出结果如下： -1 1 -1 0 Python 3.X 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象，包含的方法有： operator.lt(a, b) operator.le(a, b) operator.eq(a, b) operator.ne(a, b) operator.ge(a, b) operator.gt(a, b) operator.__lt__(a, b) operator.__le__(a, b) operator.__eq__(a, b) operator.__ne__(a, b) operator.__ge__(a, b) operator.__gt__(a, b) 实例 >>> import operator >>> operator.eq('hello', 'name'); False >>> operator.eq('hello', 'hello'); True
- Tuple(元组) len()方法
描述
Python 元组 len() 函数计算元组元素个数。
语法
len()方法语法：
len(tuple)
参数
tuple -- 要计算的元组。
返回值
函数返回元组元素个数。
实例
以下实例展示了 len()函数的使用方法：
#!/usr/bin/python tuple1, tuple2 = (123, 'xyz', 'zara'), (456, 'abc') print ("First tuple length : ", len(tuple1)) print ("Second tuple length : ", len(tuple2)) 以上实例输出结果如下： First tuple length : 3 Second tuple length : 2
- Tuple(元组) max()方法
描述
Python 元组 max() 函数返回元组中元素最大值。
语法
max()方法语法：
max(tuple)
参数
tuple -- 指定的元组。
返回值
返回元组中元素最大值。
实例
以下实例展示了 max()函数的使用方法：
#!/usr/bin/python tuple1, tuple2 = ('123', 'xyz', 'zara', 'abc'), (456, 700, 200) print ("Max value element : ", max(tuple1)) print ("Max value element : ", max(tuple2)) 以上实例输出结果如下： Max value element : zara Max value element : 700 #这里有很重要的一点，看到123，用引号标识起来，是因为只能比较同类型的值，如果是str和int，max函数会报错。
- Tuple(元组) min()方法
描述
Python 元组 min() 函数返回元组中元素最小值。
语法
min()方法语法：
min(tuple)
参数
tuple -- 指定的元组。
返回值
返回元组中元素最小值。
实例
以下实例展示了 min()函数的使用方法：
#!/usr/bin/python tuple1, tuple2 = ('123', 'xyz', 'zara', 'abc'), (456, 700, 200) print ("min value element : ", min(tuple1)) print ("min value element : ", min(tuple2)) 以上实例输出结果如下： min value element : 123 min value element : 200
- Tuple(元组) tuple()方法
描述
Python 元组 tuple() 函数将列表转换为元组。
语法
tuple()方法语法：
tuple( iterable )
参数
iterable -- 要转换为元组的可迭代序列。
返回值
返回元组。
实例
以下实例展示了 tuple()函数的使用方法：
#实例1 >>>tuple([1,2,3,4]) (1, 2, 3, 4) >>> tuple({1:2,3:4}) #针对字典 会返回字典的key组成的tuple (1, 3) >>> tuple((1,2,3,4)) #元组会返回元组自身 (1, 2, 3, 4) 实例 2 #!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc']; aTuple = tuple(aList) print "Tuple elements : ", aTuple 以上实例输出结果为： Tuple elements : (123, 'xyz', 'zara', 'abc')
7.数据类型内建函数操作之字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
>>> tinydict = {'a': 1, 'b': 2, 'b': '3'}
>>> tinydict['b']
'3'
>>> tinydict
{'a': 1, 'b': '3'}
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
tinydict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此创建字典：
tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }
7.1 访问字典里的值
把相应的键放入熟悉的方括弧，如下实例:
#!/usr/bin/python tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} print ("tinydict['Name']: ", tinydict['Name']) print ("tinydict['Age']: ", tinydict['Age']) 以上实例输出结果： tinydict['Name']: Zara tinydict['Age']: 7
如果用字典里没有的键访问数据，会输出错误如下：
#!/usr/bin/python tinydict = {'Name': 'Lizexiong', 'Age': 7, 'Class': 'First'} print "tinydict['Alice']: ", tinydict['Alice'] 以上实例输出结果： tinydict['Alice']: Traceback (most recent call last): File "test.py", line 5, in <module> print "tinydict['Alice']: ", tinydict['Alice'] KeyError: 'Alice'
7.2 修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
#!/usr/bin/python # -*- coding: UTF-8 -*- tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} tinydict['Age'] = 8 # 更新 tinydict['School'] = "LIZEXIONG" # 添加 print ("tinydict['Age']: ", tinydict['Age']) print ("tinydict['School']: ", tinydict['School']) 以上实例输出结果： tinydict['Age']: 8 tinydict['School']: LIZEXIONG
7.3 删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} del tinydict['Name'] # 删除键是'Name'的条目 tinydict.clear() # 清空字典所有条目 del tinydict # 删除字典 print ("tinydict['Age']: ", tinydict['Age']) print ("tinydict['School']: ", tinydict['School']) 但这会引发一个异常，因为用del后字典不再存在： tinydict['Age']: Traceback (most recent call last): File "test.py", line 10, in <module> print "tinydict['Age']: ", tinydict['Age'] NameError: name 'tinydict' is not defined
注：del() 方法后面也会讨论。
7.4 字典键的特性
字典值可以没有限制地取任何 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
#!/usr/bin/python tinydict = {'Name': 'LIZEXIONG', 'Age': 7, 'Name': 'Manni'} print ("tinydict['Name']: ", tinydict['Name']) 以上实例输出结果： tinydict['Name']: Manni
2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：
#!/usr/bin/python tinydict = {['Name']: 'Zara', 'Age': 7} print ("tinydict['Name']: ", tinydict['Name']) 以上实例输出结果： Traceback (most recent call last): File "test.py", line 3, in <module> tinydict = {['Name']: 'Zara', 'Age': 7} TypeError: unhashable type: 'list'
7.5 字典内置函数
Python字典包含了以下内置函数：
- 字典(Dictionary) cmp()方法
描述
Python 字典的 cmp() 函数用于比较两个字典元素。
语法
cmp()方法语法：
cmp(dict1, dict2)
参数
dict1 -- 比较的字典。
dict2 -- 比较的字典。
返回值
如果两个字典的元素相同返回0，如果字典dict1大于字典dict2返回1，如果字典dict1小于字典dict2返回-1。
实例
以下实例展示了 cmp()函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- dict1 = {'Name': 'Zara', 'Age': 7}; dict2 = {'Name': 'Mahnaz', 'Age': 27}; dict3 = {'Name': 'Abid', 'Age': 27}; dict4 = {'Name': 'Zara', 'Age': 7}; print "Return Value : %d" % cmp (dict1, dict2) print "Return Value : %d" % cmp (dict2, dict3) print "Return Value : %d" % cmp (dict1, dict4) 以上实例输出结果为： Return Value : -1 Return Value : 1 Return Value : 0 Python 3.X 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象，包含的方法有： operator.lt(a, b) operator.le(a, b) operator.eq(a, b) operator.ne(a, b) operator.ge(a, b) operator.gt(a, b) operator.__lt__(a, b) operator.__le__(a, b) operator.__eq__(a, b) operator.__ne__(a, b) operator.__ge__(a, b) operator.__gt__(a, b) 实例 >>> import operator >>> operator.eq('hello', 'name'); False >>> operator.eq('hello', 'hello'); True
- 字典(Dictionary) len()方法
描述
Python 字典(Dictionary) len() 函数计算字典元素个数，即键的总数。
语法
len()方法语法：
len(dict)
参数
dict -- 要计算元素个数的字典。
返回值
返回字典的元素个数。
实例
以下实例展示了 len() 函数的使用方法：
#!/usr/bin/python tinydict = {'Name': 'LIZEXIONG', 'Age': 7}; print ("Length : %d" % len (tinydict)) 以上实例输出结果为： Length : 2
- 字典(Dictionary) str()方法
描述
Python 字典(Dictionary) str() 函数将值转化为适于人阅读的形式，以可打印的字符串表示。
语法
str()方法语法：
str(dict)
参数
dict -- 字典。
返回值
返回字符串。
实例
以下实例展示了 str()函数的使用方法：
#!/usr/bin/python tinydict = {'Name': 'Zara', 'Age': 7}; print ("Equivalent String : %s" % str (tinydict)) 以上实例输出结果为： Equivalent String : {'Age': 7, 'Name': 'Zara'}
- 字典(Dictionary) type()方法
描述
Python 字典(Dictionary) type() 函数返回输入的变量类型，如果变量是字典就返回字典类型。
语法
type()方法语法：
type(dict)
参数
dict -- 字典。
返回值
返回输入的变量类型。
实例
以下实例展示了 type()函数的使用方法：
#!/usr/bin/python tinydict = {'Name': 'Zara', 'Age': 7}; print ("Variable Type : %s" % type (tinydict)) 以上实例输出结果为： Variable Type : <type 'dict'>
7.6 字典内置方法
Python字典包含了以下内置方法：
- 字典(Dictionary) clear()方法
描述
Python 字典(Dictionary) clear() 函数用于删除字典内所有元素。
语法
clear()方法语法：
dict.clear()
参数
NA。
返回值
该函数没有任何返回值。
实例
以下实例展示了 clear()函数的使用方法：
#!/usr/bin/python tinydict = {'Name': 'Zara', 'Age': 7}; print ("Start Len : %d" % len(tinydict)) tinydict.clear() print ("End Len : %d" % len(tinydict)) 以上实例输出结果为： Start Len : 2 End Len : 0
- 字典(Dictionary) copy()方法
描述
Python 字典(Dictionary) copy() 函数返回一个字典的浅复制。
语法
copy()方法语法：
dict.copy()
参数
NA。
返回值
返回一个字典的浅复制。
实例
以下实例展示了 copy()函数的使用方法：
#!/usr/bin/python dict1 = {'Name': 'Zara', 'Age': 7}; dict2 = dict1.copy() print ("New Dictinary : %s" % str(dict2)) 以上实例输出结果为： New Dictinary : {'Age': 7, 'Name': 'Zara'}
直接赋值和 copy 的区别
可以通过以下实例说明：
#!/usr/bin/python # -*- coding: UTF-8 -*- dict1 = {'user':'LIZEXIONG','num':[1,2,3]} dict2 = dict1 # 浅拷贝: 引用对象 dict3 = dict1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用 # 修改 data 数据 dict1['user']='root' dict1['num'].remove(1) # 输出结果 print(dict1) print(dict2) print(dict3) 实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。 {'num': [2, 3], 'user': 'root'} {'num': [2, 3], 'user': 'root'} {'num': [2, 3], 'user': 'LIZEXIONG'}
- 字典(Dictionary) fromkeys()方法
描述
Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
语法
fromkeys()方法语法：
dict.fromkeys(seq[, value])
参数
seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）的值。
返回值
该方法返回一个新字典。
实例
以下实例展示了 fromkeys() 函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- seq = ('Google', 'LIZEXIONG', 'Taobao') thisdict = dict.fromkeys(seq) print "新字典为 : %s" % str(dict) thisdict = dict.fromkeys(seq, 10) print "新字典为 : %s" % str(thisdict) 以上实例输出结果为： 新字典为 : {'Google': None, 'Taobao': None, 'LIZEXIONG': None} 新字典为 : {'Google': 10, 'Taobao': 10, 'LIZEXIONG': 10}
- 字典(Dictionary) get()方法
描述
Python 字典(Dictionary) get() 函数返回指定键的值。
语法
get()方法语法：
dict.get(key[, value])
参数
key -- 字典中要查找的键。
value -- 可选，如果指定键的值不存在时，返回该默认值。
返回值
返回指定键的值，如果键不在字典中返回默认值 None 或者设置的默认值。
实例
以下实例展示了 get() 函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- tinydict = {'Name': 'LIZEXIONG', 'Age': 27} print ("Age : %s" % tinydict.get('Age')) # 没有设置 Sex，也没有设置默认的值，输出 None print ("Sex : %s" % tinydict.get('Sex')) # 没有设置 Salary，输出默认的值 0.0 print ('Salary: %s' % tinydict.get('Salary', 0.0)) 以上实例输出结果为： Age : 27 Sex : None Salary: 0.0
get() 方法 Vs dict[key] 访问元素区别
get(key) 方法在 key（键）不在字典中时，可以返回默认值 None 或者设置的默认值。
dict[key] 在 key（键）不在字典中时，会触发 KeyError 异常。
实例 >>> lizexiong = {} >>> print('URL: ', lizexiong.get('url')) # 返回 None URL: None >>> print(lizexiong['url']) # 触发 KeyError Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'url' >>>
嵌套字典使用
get() 方法对嵌套字典的使用方法如下：
#!/usr/bin/python # -*- coding: UTF-8 -*- tinydict = {'LIZEXIONG' : {'url' : 'www.lizexiong.com'}} res = tinydict.get('LIZEXIONG', {}).get('url') # 输出结果 print("LIZEXIONG url 为 : %s" % str(res)) 以上实例输出结果为： LIZEXIONG url 为 : www.lizexiong.com
- 字典(Dictionary) has_key()方法
描述
Python 字典(Dictionary) has_key() 函数用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。
注意：Python 3.X 不支持该方法。
语法
has_key()方法语法：
dict.has_key(key)
参数
key -- 要在字典中查找的键。
返回值
如果键在字典里返回true，否则返回false。
实例
以下实例展示了 has_key()函数的使用方法：
#!/usr/bin/python tinydict = {'Name': 'Zara', 'Age': 7} print ("Value : %s" % tinydict.has_key('Age')) print ("Value : %s" % tinydict.has_key('Sex')) 以上实例输出结果为： Value : True Value : False Python 3.X 里不包含 has_key() 函数，被 __contains__(key) 替代: dict3 = {'name':'z','Age':7,'class':'First'}; print("Value : ",dict3.__contains__('name')) print("Value : ",dict3.__contains__('sex')) 执行结果： Value : True Value : False Python 3.X 里不包含 has_key() 函数之外，在 3.X 中还可以使用 in 操作符： dict3 = {'name': 'z', 'Age': 7, 'class': 'First'} if "user_id" in dict3: print(dict3["user_id"]) if "name" in dict3: print(dict3["name"])
- 字典(Dictionary) items()方法
描述
Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组。
语法
items()方法语法：
dict.items()
参数
NA。
返回值
返回可遍历的(键, 值) 元组数组。
实例
以下实例展示了 items()函数的使用方法：
#!/usr/bin/python # coding=utf-8 tinydict = {'Google': 'www.google.com', 'lizexiong': 'www.lizexiong.com', 'taobao': 'www.taobao.com'} print "字典值 : %s" % tinydict.items() # 遍历字典列表 for key,values in tinydict.items(): print key,values 以上实例输出结果为： 字典值 : [('Google', 'www.google.com'), ('taobao', 'www.taobao.com'), ('lizexiong', 'www.lizexiong.com')] Google www.google.com taobao www.taobao.com lizexiong www.lizexiong.com
- 字典(Dictionary) keys()方法
描述
Python 字典(Dictionary) keys() 函数以列表返回一个字典所有的键。
语法
keys()方法语法：
dict.keys()
参数
NA。
返回值
返回一个字典所有的键。
实例
以下实例展示了 keys()函数的使用方法：
#!/usr/bin/python tinydict = {'Name': 'Zara', 'Age': 7} print ("Value : %s" % tinydict.keys()) 以上实例输出结果为： Value : ['Age', 'Name']
- 字典(Dictionary) setdefault()方法
描述
Python 字典 setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
语法
setdefault() 方法语法：
dict.setdefault(key, default=None)
参数
key -- 查找的键值。
default -- 键不存在时，设置的默认键值。
返回值
如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。
实例
以下实例展示了 setdefault() 函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- tinydict = {'lizexiong': '华为', 'google': 'Google 搜索'} print ("Value : %s" % tinydict.setdefault('lizexiong', None)) print ("Value : %s" % tinydict.setdefault('Taobao', '淘宝')) 以上实例输出结果为： Value : 华为 Value : 淘宝
- 字典(Dictionary) update()方法
描述
Python 字典(Dictionary) update() 函数把字典 dict2 的键/值对更新到 dict 里。
语法
update()方法语法：
dict.update(dict2)
参数
dict2 -- 添加到指定字典dict里的字典。
返回值
该方法没有任何返回值。
实例
以下实例展示了 update()函数的使用方法：
#!/usr/bin/python tinydict = {'Name': 'Zara', 'Age': 7} tinydict2 = {'Sex': 'female' } tinydict.update(tinydict2) print ("Value : %s" % tinydict) 以上实例输出结果为： Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}
用 update 更新字典 a，会有两种情况：
（1）有相同的键时：会使用最新的字典 b 中 该 key 对应的 value 值。
（2）有新的键时：会直接把字典 b 中的 key、value 加入到 a 中。
>>> a = {1: 2, 2: 2}
>>> b = {1: 1, 3: 3}
>>> a.update(b)
>>> print(a)
{1: 1, 2: 2, 3: 3}
- 字典(Dictionary) values()方法
描述
Python 字典(Dictionary) values() 函数以列表返回字典中的所有值。
语法
values()方法语法：
dict.values()
参数
NA。
返回值
返回字典中的所有值。
实例
以下实例展示了 values()函数的使用方法：
#!/usr/bin/python tinydict = {'Name': 'lizexiong', 'Age': 7} print ("Value : %s" % tinydict.values()) 以上实例输出结果为： Value : [7, 'lizexiong']
- 字典 pop() 方法
描述
Python 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。
语法
pop() 方法语法：
pop(key[,default])
参数
key - 要删除的键
default - 当键 key 不存在时返回的值
返回值
返回被删除的值：
-
- 如果 key 存在 - 删除字典中对应的元素
- 如果 key 不存在 - 返回设置指定的默认值 default
- 如果 key 不存在且默认值 default 没有指定 - 触发 KeyError 异常
实例
以下实例展示了 pop() 方法的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- site= {'name': '华为', 'alexa': 10000, 'url': 'www.lizexiong.com'} element = site.pop('name') print('删除的元素为:') print(element) print('字典为:') print(site) 输出结果为： 删除的元素为:华为 字典为:{'url': 'www.lizexiong.com', 'alexa': 10000}
如果删除的键不存在会触发异常：
#!/usr/bin/python # -*- coding: UTF-8 -*- site= {'name': '华为', 'alexa': 10000, 'url': 'www.lizexiong.com'} element = site.pop('nickname') print('删除的元素为:') print(element) print('字典为:') print(site) 输出结果为： Traceback (most recent call last): File "test.py", line 6, in <module> element = site.pop('nickname') KeyError: 'nickname'
可以设置默认值来避免异常：
#!/usr/bin/python # -*- coding: UTF-8 -*- site= {'name': '华为', 'alexa': 10000, 'url': 'www.lizexiong.com'} element = site.pop('nickname', '不存在的 key') print('删除的元素为:') print(element) print('字典为:') print(site) 输出结果为： 删除的元素为:不存在的 key 字典为:{'url': 'www.lizexiong.com', 'alexa': 10000, 'name': '华为'}
- 字典 popitem() 方法
描述
Python 字典 popitem() 方法返回并删除字典中的最后一对键和值。
如果字典已经为空，却调用了此方法，就报出 KeyError 异常。
语法
popitem()方法语法：
popitem()
参数
无
返回值
返回一个键值对(key,value)形式。
实例
以下实例展示了 popitem() 方法的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- site= {'name': '华为', 'alexa': 10000, 'url': 'www.lizexiong.com'} pop_obj=site.popitem() print(pop_obj) print(site) 输出结果为： ('url', 'www.lizexiong.com') {'alexa': 10000, 'name': '华为'}
