失眠网 > python内置数字类型转换函数_Python学习 Day2-2 Python3的基本数据类型数据内置类型转换函数...

python内置数字类型转换函数_Python学习 Day2-2 Python3的基本数据类型数据内置类型转换函数...

时间：2019-08-17 07:16:23

Python3的基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号(=)用来给变量赋值。

等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。

多个变量赋值

Python允许你同时为多个变量赋值。例如：

a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "runoob"

以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

标准数据类型

Python3 中有六个标准的数据类型：

Number(数字)

String(字符串)

List(列表)

Tuple(元组)

Sets(集合)

Dictionary(字典)

Number(数字)

Python3 支持int(整型)、float(双精度浮点型)、bool(布尔型)、complex(复数)。

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

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

>>> a, b, c, d = 20, 5.5, True, 4+3j

>>> print(type(a), type(b), type(c), type(d))

此外还可以用 isinstance(isinstance是Python中的一个内建函数。是用来判断一个对象的变量类型，类似 type()) 来判断：

>>>a = 111

>>>isinstance(a, int)

True

>>>

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

classA:

pass

classB(A):

passisinstance(A(), A) # returns True

type(A()) == A # returns True

isinstance(B(), A) # returns True

type(B()) == A # returns False

注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

当你指定一个值时，Number 对象就会被创建：

var1 = 1var2 = 10

您也可以使用del语句删除一些对象引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]]

您可以通过使用del语句删除单个或多个对象。例如：

delvar

del var_a, var_b

数值运算

>>>5 + 4 # 加法

>>> 4.3 - 2 # 减法

2.3

>>> 3 * 7 # 乘法

>>> 2 / 4 # 除法，得到一个浮点数

0.5

>>> 2 // 4 # 除法，得到一个整数

>>> 17 % 3 # 取余

>>> 2 ** 5 # 乘方

注意：

1、Python可以同时为多个变量赋值，如a, b = 1, 2。

2、一个变量可以通过赋值指向不同类型的对象。

3、数值的除法(/)总是返回一个浮点数，要获取整数使用//操作符。

4、在混合计算时，Python会把整型转换成为浮点数。

String(字符串)

Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 (+) 是字符串的连接符，星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。实例如下：

#!/usr/bin/python3

str = 'Runoob'

print (str) # 输出字符串

print (str[0:-1]) # 输出第一个到倒数第二个的所有字符

print (str[0]) # 输出字符串第一个字符

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

print (str[2:]) # 输出从第三个开始的后的所有字符

print (str[0:]) # 输出第一个到最后一个的所有字符

print (str * 2) # 输出字符串两次

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

Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('Ru\noob')

oob

>>> print(r'Ru\noob')

Ru\noob

>>>

另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 '''或者...跨越多行

>>> a='aaaa'\

... 'bbbbbb'

>>> printa

aaaabbbbbb

>>> a = '''

... 123

... 456

... '''

>>> print(a)

123

456

>>>

(),[],{},'''可以不用续行

>>> b=('bbbbbb'... 'ssssss')

>>> printb

bbbbbbssssss

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

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

注意：

1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。

2、字符串可以用+运算符连接在一起，用*运算符重复。

3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。

4、Python中的字符串不能改变。

List(列表)

List(列表) 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表(所谓嵌套)。

列表是写在方括号([])之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号(+)是列表连接运算符，星号(*)是重复操作。如下实例：

#!/usr/bin/python3

list= [ 'abcd', 786 , 2.23, 'runoob', 70.2]

tinylist= [123, 'runoob']print (list) #输出完整列表

print (list[0]) #输出列表第一个元素

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

print (list[2:]) #输出从第三个元素开始的所有元素

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

print (list + tinylist) #连接列表

以上实例输出结果：

['abcd', 786, 2.23, 'runoob', 70.2]

abcd

[786, 2.23]

[2.23, 'runoob', 70.2]

[123, 'runoob', 123, 'runoob']

['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

与Python字符串不一样的是，列表中的元素是可以改变的：

>>>a = [1, 2, 3, 4, 5, 6]>>> a[0] = 9

>>> a[2:5] = [13, 14, 15]>>>a

[9, 2, 13, 14, 15, 6]>>> a[2:5] = [] #将对应的元素值设置为 []

>>>a

[9, 2, 6]

List内置了有很多方法，例如append()、pop()等等，这在后面会讲到。

注意：

1、List写在方括号之间，元素用逗号隔开。

2、和字符串一样，list可以被索引和切片。

3、List可以使用+操作符进行拼接。

4、List中的元素是可以改变的。

Tuple(元组)

元组(tuple)与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

#!/usr/bin/python3

tuple= ( 'abcd', 786 , 2.23, 'runoob', 70.2)

tinytuple= (123, 'runoob')print (tuple) #输出完整元组

print (tuple[0]) #输出元组的第一个元素

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

print (tuple[2:]) #输出从第三个元素开始的所有元素

print (tinytuple * 2) #输出两次元组

print (tuple + tinytuple) #连接元组

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取(看上面，这里不再赘述)。

其实，可以把字符串看作一种特殊的元组。

>>>tup = (1, 2, 3, 4, 5, 6)>>> print(tup[0])1

>>> print(tup[1:5])

(2, 3, 4, 5)>>> tup[0] = 11 #修改元组元素的操作是非法的

Traceback (most recent call last):

File"", line 1, in TypeError:'tuple' object does notsupport item assignment>>>

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

>>> tup = (1,[1,2,3])>>> printtup

(1, [1, 2, 3])>>> tup[1][0]=0>>> printtup

(1, [0, 2, 3])

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = () #空元组

tup2 = (20,) #一个元素，需要在元素后添加逗号

string、list和tuple都属于sequence(序列)。

注意：

1、与字符串一样，元组的元素不能修改。

2、元组也可以被索引和切片，方法一样。

3、注意构造包含0或1个元素的元组的特殊语法规则。

4、元组也可以使用+操作符进行拼接。

Set(集合)

集合(set)是一个无序不重复元素的序列。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号{ }或者set()函数创建集合，注意：创建一个空集合必须用set()而不是{ }，因为{ }是用来创建一个空字典。

创建格式：

parame ={value01,value02,...}

或者

set(value)

实例：

#!/usr/bin/python3

student= {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}print(student) #输出集合，重复的元素被自动去掉

#成员测试

if('Rose' instudent) :print('Rose 在集合中')else:print('Rose 不在集合中')#set可以进行集合运算

a = set('abracadabra')

b= set('alacazam')print(a)print(a - b) #a和b的差集

print(a | b) #a和b的并集

print(a & b) #a和b的交集

print(a ^ b) #a和b中不同时存在的元素

以上实例输出结果：

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}

Rose 在集合中

{'b', 'a', 'c', 'r', 'd'}

{'b', 'd', 'r'}

{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}

{'a', 'c'}

{'l', 'r', 'z', 'm', 'b', 'd'}

Dictionary(字典)

字典(dictionary)是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

实例：

#!/usr/bin/python3

dict={}

dict['one'] = "1 - 菜鸟教程"dict[2] = "2 - 菜鸟工具"tinydict= {'name': 'runoob','code':1, 'site': ''}print (dict['one']) #输出键为 'one' 的值

print (dict[2]) #输出键为 2 的值

print (tinydict) #输出完整的字典

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

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

以上实例输出结果：

1 -菜鸟教程2 -菜鸟工具

{'name': 'runoob', 'site': '', 'code': 1}

dict_keys(['name', 'site', 'code'])

dict_values(['runoob', '', 1])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

实例：

>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])

{'Taobao': 3, 'Runoob': 1, 'Google': 2}>>> {x: x**2 for x in (2, 4, 6)}

{2: 4, 4: 16, 6: 36}>>> dict(Runoob=1, Google=2, Taobao=3)

{'Taobao': 3, 'Runoob': 1, 'Google': 2}

Python字典的构造函数有三个，dict()、dict(**args)、dict(mapping)

1、dict()构造函数可以返回一个空的字典

>>> d=dict()>>> print(d)

{}

2、dict(**arg)构造函数，传入参数用赋值表达式，可多个复制表达式，用逗号间隔即可。

>>> d = dict(a=12,b=13,c=15)>>> print(d)

{'a': 12, 'b': 13, 'c': 15}

3、dict(mapping)构造python字典构造函数，怎么传入这个mapping参数呢？Python下的mapping到底是什么呢？

看下边这个例子：

deffmap(a, b):return(a, b)

lik= range(1, 11)

liv= list("abcdefghij")print map(fmap, lik, liv)

运行结果如下：

[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g'), (8, 'h'), (9, 'i'), (10, 'j')]

map函数的作用是：每次从可迭代对象(这里是列表lik和liv)取出一个元素值，经过fmap自定义函数的处理后作为新的(返回)列表的元素，故这个map函数的操作方式很像列表解析的概念。

理解了map函数后，便可将返回值作为dict的传入参数了，从而得到一个字典。

deff_map(a, b):return(a, b)

lik= range(1, 11)

liv= list("abcdefghij")print(dict(map(f_map, lik, liv)))

执行结果如下所示：

{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j'}

以上的实现也用zip来构造一个mapping对象,代码如下所示：

k = list("abcdefghij")print(k)

v= range(11, 21)print(list(v))print(dict(zip(k, v)))

执行结果如下所示：

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

{'a': 11, 'b': 12, 'c': 13, 'd': 14, 'e': 15, 'f': 16, 'g': 17, 'h': 18, 'i': 19, 'j': 20}

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。

注意：

1、字典是一种映射类型，它的元素是键值对。

2、字典的关键字必须为不可变类型，且不能重复。

3、创建空字典使用{ }。

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数描述

int(x [,base])

将x转换为一个整数

float(x)

将x转换到一个浮点数

complex(real [,imag])

创建一个复数

str(x)

将对象 x 转换为字符串

repr(x)

将对象 x 转换为表达式字符串

eval(str)

用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s)

将序列 s 转换为一个元组

list(s)

将序列 s 转换为一个列表

set(s)

转换为可变集合

dict(d)

创建一个字典。d 必须是一个序列 (key,value)元组。

frozenset(s)

转换为不可变集合

chr(x)

将一个整数转换为一个字符

ord(x)

将一个字符转换为它的整数值

hex(x)

将一个整数转换为一个十六进制字符串

oct(x)

将一个整数转换为一个八进制字符串

Pythonint() 函数

描述

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进制

>>> int('0xa',16)10

>>> int('10',8)8

Python 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

Python 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)

Pythonstr() 函数

描述

str() 函数将对象转化为适于人阅读的形式。

语法

以下是 str() 方法的语法:

class str(object='')

参数

object -- 对象。

返回值

返回一个对象的string格式。

实例

以下展示了使用 str() 方法的实例：

>>>s = 'RUNOOB'

>>>str(s)'RUNOOB'

>>> dict = {'runoob': '', 'google': ''};>>>str(dict)"{'google': '', 'runoob': ''}"

>>>

Pythonrepr() 函数

描述

repr() 函数将对象转化为供解释器读取的形式。

语法

以下是 repr() 方法的语法:

repr(object)

参数

object -- 对象。

返回值

返回一个对象的 string 格式。

实例

以下展示了使用 repr() 方法的实例：

>>>s = 'RUNOOB'

>>>repr(s)"'RUNOOB'"

>>> dict = {'runoob': '', 'google': ''};>>>repr(dict)"{'google': '', 'runoob': ''}"

>>>

Pythoneval() 函数

描述

eval() 函数用来执行一个字符串表达式，并返回表达式的值。官方文档里面给出来的功能解释是：将字符串string对象转化为有效的表达式参与求值运算返回计算结果。

语法

以下是 eval() 方法的语法:

eval(expression[, globals[, locals]])

参数

expression -- 表达式(是一个参与计算的python表达式)。

globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象(可选，必须是dictionary)。

locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象(可选，任意map对象)。

返回值

返回表达式计算结果。

实例

以下展示了使用 eval() 方法的实例：

>>>x = 7

>>> eval( '3 * x')21

>>> eval('pow(2,2)') #pow()方法返回 xy(x的y次方) 的值。4

>>> eval('2 + 2')4

>>> n=81

>>> eval("n + 4")85

可以把list,tuple,dict和string相互转化。#################################################

字符串转换成列表>>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"

>>>type(a)

>>> b =eval(a)>>> printb

[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]>>>type(b)

#################################################

字符串转换成字典>>> a = "{1: 'a', 2: 'b'}"

>>>type(a)

>>> b =eval(a)>>> printb

{1: 'a', 2: 'b'}>>>type(b)

#################################################

字符串转换成元组>>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))"

>>>type(a)

>>> b =eval(a)>>> printb

([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))>>>type(b)

eval() 函数扩展

python是用命名空间来记录变量的轨迹的，命名空间是一个dictionary，键是变量名，值是变量值。

当一行代码要使用变量x的值时，Python会到所有可用的名字空间去查找变量，按照如下顺序:

1)局部名字空间 - 特指当前函数或类的方法。如果函数定义了一个局部变量x, 或一个参数x，Python将使用它，然后停止搜索。

2)全局名字空间 - 特指当前的模块。如果模块定义了一个名为x的变量，函数或类，Python将使用它然后停止搜索。

3)内置名字空间 - 对每个模块都是全局的。作为最后的尝试，Python将假设x是内置函数或变量。

python的全局名字空间存储在一个叫globals()的dict对象中；局部名字空间存储在一个叫locals()的dict对象中。我们可以用print (locals())来查看该函数体内的所有变量名和变量值。

eval()使用原因：

1)在编译语言里要动态地产生代码，基本上是不可能的，但动态语言是可以，意味着软件已经部署到服务器上了，但只要作很少的更改，只好直接修改这部分的代码，就可立即实现变化，不用整个软件重新加载。

2)在machin learning里根据用户使用这个软件频率，以及方式，可动态地修改代码，适应用户的变化。

实例：

a=1g={'a':20}

eval("a+1",g)

返回21

#test eval() and locals()

x = 1y= 1num1= eval("x+y")print(num1)defg():

x= 2y= 2num3= eval("x+y")print(num3)

num2= eval("x+y",globals())#num2 = eval("x+y",globals(),locals())

print(num2)

g()print locals()["x"]print locals()["y"]print globals()["x"]print globals()["y"]

num1的值是2；num3的值也很好理解，是4；num2的值呢？由于提供了globals()参数，那么首先应当找全局的x和y值，也就是都为1，那么显而易见，num2的值也是2。如果注释掉该句，执行下面一句呢？根据第3)点可知，结果为4

locals()对象的值不能修改，globals()对象的值可以修改

#test globals() and locals()

z=0deff():

z= 1

print(locals())

locals()["z"] = 2

print(locals())

f()

globals()["z"] = 2

print (z)

可以得出，两个print (locals())的结果是一样的，说明没有修改成功。而print (z)的值是2，说明修改成功了

eval()安全性问题

eval有安全性问题,比如用户恶意输入就会获得当前目录文件

eval("__import__('os').system('dir')")

>>> importos>>> 'os' inglobals()

True>>> os.system('whoami')

root

怎么避免安全问题？

1、自行写检查函数；

2、使用ast.literal_eval

一般来说Python的eval()函数可以把字符串“123”变成数字类型的123，但是PP3E上说它很危险，还可以执行其他命令！

对此进行一些试验。果然，如果python写的cgi程序中如果使用eval()而非int()来转换诸如年龄这样的输入框中的内容时是非常危险的。不仅可以看见列出系统的全部文件，还可以执行删除文件，察看文件源代码等危险操作！

网页里有一个提交名字的窗口，这里只是以改它为例，否则名字是不会用eval函数转换的，不过年龄到是很容易出问题。这个文件(http://localhost/tutor4.html)导入了os。

line1 = "Hello, %s." % eval(form['user'].value)

(1)删除当前目录下所有文件

os.system('del * /q') #删除当前目录下所有文件(不包括文件夹)。

os.system调用当前系统的命令(如windows)

/q 指定强制状态。不提示您确认删除。

(2)若删除文件夹，使用rmdir

os.system('rmdir d:/workspace /s/q')

/s 删除指定目录和所有子目录以及包含的所有文件。使用 /s 来删除目录树。

/q 在安静模式中运行 rmdir。不经确认即删除目录。

(3)列出所有文件os.system('dir')。因为成功执行了dir命令后，系统返回0，所以看到的返回内容只能是Hello,0.而在服务器上，倒是真的列出来了，如果有日志，可能被发现。提交os.system('dir >dir.txt')，那么访问http://localhost/dir.txt那么所有的文件和文件夹都暴露了，想看源代码吗？如果再使用os.system('type target.py').命令如果成功完成同样会返回Hello, 0.的。难道再放进一个文件，再访问那个文件吗？open('target.py').read()

由此，可以在列出和察看其他文件夹里面的内容了。

如果没干别的坏事，那么可删除dir.txt以免被人发现了。os.system('del dir.txt /q')

导入os并执行命令：

__import__('os').system('dir >dir.txt')

Python3tuple 函数

描述

tuple 函数将列表转换为元组。

语法

以下是 tuple 的语法:

tuple( seq )

参数

seq -- 要转换为元组的序列。

返回值

返回元组。

实例

以下展示了使用 tuple 的实例：

>>>list1= ['Google', 'Taobao', 'Runoob', 'Baidu']>>> tuple1=tuple(list1)>>>tuple1

('Google', 'Taobao', 'Runoob', 'Baidu')

Python3 List list()方法

描述

list() 方法用于将元组转换为列表。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

语法

list()方法语法：

list( seq )

参数

list -- 要转换为列表的元组。

返回值

返回列表。

实例

以下实例展示了 list()函数的使用方法：

#!/usr/bin/python3

aTuple= (123, 'Google', 'Runoob', 'Taobao')

list1=list(aTuple)print ("列表元素 :", list1)

str="Hello World" #字符串可以看作是元组list2=list(str)print ("列表元素 :", list2)

以上实例输出结果如下：

列表元素 : [123, 'Google', 'Runoob', 'Taobao']

列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

Python set() 函数

描述

set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

语法

set 语法：

class set([iterable])

参数说明：

iterable -- 可迭代对象对象；

返回值

返回新的集合对象。

实例

以下实例展示了 set 的使用方法：

>>>x = set('runoob')>>> y = set('google')>>>x, y

(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) #重复的被删除

>>> x & y #交集

set(['o'])>>> x | y #并集

set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])>>> x - y #差集

set(['r', 'b', 'u', 'n'])>>>

Python dict() 函数

描述

dict()函数用于创建一个字典。

语法

dict 语法：

class dict(**kwarg)class dict(mapping, **kwarg)class dict(iterable, **kwarg)

参数说明：

**kwargs -- 关键字

mapping -- 元素的容器。

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}

Python 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('runoob')>>>b

frozenset(['b', 'r', 'u', 'o', 'n']) #创建不可变集合

Pythonchr() 函数

描述

chr() 用一个范围在 range(256)内的(就是0～255)整数作参数，返回一个对应的字符。

语法

以下是 chr() 方法的语法:

chr(i)

参数

i -- 可以是10进制也可以是16进制的形式的数字。

返回值

返回值是当前整数对应的ascii字符。

实例

以下展示了使用 chr() 方法的实例：

>>>print chr(0x30), chr(0x31), chr(0x61) #十六进制

0 1a>>> print chr(48), chr(49), chr(97) #十进制

0 1 a

Pythonord() 函数

描述

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