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 10² = 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': '华为'}

posted @ 2022-04-28 14:03 小家电维修阅读(129) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Python3数据类型

· Python学习之路-Python2-30天学习笔记

· Python3 基本数据类型

· 7：Python 变量类型

· Python-01基本数据类型

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？

1.Python基本数据类型简介

1.1 变量赋值

1.2 多个变量赋值

1.3 标准数据类型

1.4 Python 数字

1.5 Python字符串

1.6 Python列表

1.7 Python 元组

1.8 Python 字典

1.9 Python 集合

2.Python数据类型转换

3.数据类型内建函数操作之Number(数字)

3.1 Number 类型转换

3.2 Python math 模块、cmath 模块

3.3 Python数学函数

3.4 Python随机数函数

3.5 Python三角函数

3.6 Python数学常量

4.数据类型内建函数操作之字符串

4.1 Python 访问字符串中的值

4.2 Python 字符串连接

4.3 Python 转义字符

4.4 Python字符串运算符

4.5 Python 字符串格式化

4.6 Python 三引号

4.7 python的字符串内建函数

5.数据类型内建函数操作之列表

5.1 访问列表中的值

5.2 更新列表

5.3 删除列表元素

5.4 Python列表脚本操作符

5.5 Python列表截取

5.6 Python列表函数

5.7 Python列表方法

6.数据类型内建函数操作之元祖

6.1 访问元组

6.2 修改元组

6.3 删除元组

6.4 元组运算符

6.5 元组索引，截取

6.6 无关闭分隔符

6.7 元组内置函数

7.数据类型内建函数操作之字典

7.1 访问字典里的值

7.2 修改字典

7.3 删除字典元素

7.4 字典键的特性

7.5 字典内置函数

7.6 字典内置方法

公告

常用链接

积分与排名