Python学习 Day2-2 Python3的基本数据类型、数据内置类型转换函数
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))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
此外还可以用 isinstance（isinstance是Python中的一个内建函数。是用来判断一个对象的变量类型，类似 type()） 来判断：
>>>a = 111
>>> isinstance(a, int)
True
>>>
isinstance() 与 type() 区别：
- type() 不会认为子类是一种父类类型，不考虑继承关系。
- isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
class A:
pass
class B(A):
pass
isinstance(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 = 1
var2 = 10
您也可以使用del语句删除一些对象引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]]
您可以通过使用del语句删除单个或多个对象。例如：
del var
del var_a, var_b
数值运算
>>>5 + 4 # 加法 9 >>> 4.3 - 2 # 减法 2.3 >>> 3 * 7 # 乘法 21 >>> 2 / 4 # 除法，得到一个浮点数 0.5 >>> 2 // 4 # 除法，得到一个整数 0 >>> 17 % 3 # 取余 2 >>> 2 ** 5 # 乘方 32
注意：
- 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')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>
另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 '''或者 ... 跨越多行
>>> a='aaaa'\
... 'bbbbbb'
>>> print a
aaaabbbbbb
>>> a = '''
... 123
... 456
... '''
>>> print(a)
123
456
>>>
(),[],{},'''可以不用续行
>>> b=('bbbbbb'
... 'ssssss')
>>> print b
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 "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>>
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
>>> tup = (1,[1,2,3]) >>> print tup (1, [1, 2, 3]) >>> tup[1][0]=0 >>> print tup (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' in student) : print('Rose 在集合中') else : print('Rose 不在集合中') # set可以进行集合运算 a = set('abracadabra') b = set('alacazam') print(a) print(a - b) # a和b的差集 print(a | b) # a和b的并集 print(a & b) # a和b的交集 print(a ^ b) # a和b中不同时存在的元素
以上实例输出结果：
{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}
Dictionary（字典）
字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
实例：
#!/usr/bin/python3 dict = {} dict['one'] = "1 - 菜鸟教程" dict[2] = "2 - 菜鸟工具" tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'} print (dict['one']) # 输出键为 'one' 的值 print (dict[2]) # 输出键为 2 的值 print (tinydict) # 输出完整的字典 print (tinydict.keys()) # 输出所有键 print (tinydict.values()) # 输出所有值
以上实例输出结果：
1 - 菜鸟教程 2 - 菜鸟工具 {'name': 'runoob', 'site': 'www.runoob.com', 'code': 1} dict_keys(['name', 'site', 'code']) dict_values(['runoob', 'www.runoob.com', 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到底是什么呢？
看下边这个例子：
def fmap(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的传入参数了，从而得到一个字典。
def f_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) |
将一个整数转换为一个八进制字符串 |
Python int() 函数
描述
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
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)
Python str() 函数
描述
str() 函数将对象转化为适于人阅读的形式。
语法
以下是 str() 方法的语法:
class str(object='')
参数
- object -- 对象。
返回值
返回一个对象的string格式。
实例
以下展示了使用 str() 方法的实例：
>>>s = 'RUNOOB' >>> str(s) 'RUNOOB' >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'}; >>> str(dict) "{'google': 'google.com', 'runoob': 'runoob.com'}" >>>
Python repr() 函数
描述
repr() 函数将对象转化为供解释器读取的形式。
语法
以下是 repr() 方法的语法:
repr(object)
参数
- object -- 对象。
返回值
返回一个对象的 string 格式。
实例
以下展示了使用 repr() 方法的实例：
>>>s = 'RUNOOB' >>> repr(s) "'RUNOOB'" >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'}; >>> repr(dict) "{'google': 'google.com', 'runoob': 'runoob.com'}" >>>
Python eval() 函数
描述
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) <type 'str'> >>> b = eval(a) >>> print b [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]] >>> type(b) <type 'list'> ################################################# 字符串转换成字典 >>> a = "{1: 'a', 2: 'b'}" >>> type(a) <type 'str'> >>> b = eval(a) >>> print b {1: 'a', 2: 'b'} >>> type(b) <type 'dict'> ################################################# 字符串转换成元组 >>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))" >>> type(a) <type 'str'> >>> b = eval(a) >>> print b ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0)) >>> type(b) <type 'tuple'>
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=1 g={'a':20} eval("a+1",g)
返回21
#test eval() and locals() x = 1 y = 1 num1 = eval("x+y") print (num1) def g(): x = 2 y = 2 num3 = 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=0 def f(): 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')")
>>> import os >>> 'os' in globals() True >>> os.system('whoami') root 0
怎么避免安全问题？
- 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')
Python3 tuple 函数
描述
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']) # 创建不可变集合
Python 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
Python 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
Python 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'> # 字符串
Python oct() 函数
描述
oct() 函数将一个整数转换成8进制字符串。
语法
oct 语法：
oct(x)
参数说明：
- x -- 整数。
返回值
返回8进制字符串。
实例
以下实例展示了 oct 的使用方法：
>>>oct(10) '012' >>> oct(20) '024' >>> oct(15) '017'
浙公网安备 33010602011771号