2、数据类型

目录


1、数据类型的基本分类

  • Python3 中有六个标准的数据类型：
数据类型 是否可变 包含子类型
Number（数字） 不可变 包含了int、bool、float、complex
String（字符串） 不可变
List（列表） 可变
Tuple（元组） 不可变
Set（集合） 可变
Dictionary（字典） 可变

2、Number（数字）

2.1、数字的四种类型

  • Python3中数字有四种类型：整数、布尔型、浮点数和复数。
类型 示例 说明
int (整数) 1,2,255 int(x) 将x转换为一个整数
bool (布尔) False,True
float (浮点数) 1.23,3E-2 float(x) 将x转换到一个浮点数
complex (复数) 1 + 2j 
a = 3.6
b = 3

print(int(a))
print(float(b))

# 3
# 3.0

2.2、数字的运算

d = 17
e = 5
f = 3

print("d+e=", d+e)
print("d-e=", d-e)
print("e*f=", e*f)
print("d/e=", d/e)      # / 结果是浮点数
print("d//e=", d//e)    # //取整
print("d%e=", d % e)    # %取余
print("e**f=", e**f)    # **幂运算

# d+e= 22
# d-e= 12
# e*f= 15
# d/e= 3.4
# d//e= 3
# d%e= 2
# e**f= 125

3、String（字符串）

var1 = 'Hello World!'
var2 = "Runoob"

print(var1)
print(var2)

# Hello World!
# Runoob

3.1、索引与切片

字符串的索引与切片遵循：左闭右开的原则

title

str1 = "ABCDEF"

print(str1)          # 输出字符串
print(str1[0])       # 输出字符串第一个字符
print(str1[0:-1])    # 索引 0（含索引 0，从前往后的索引）到索引 -1（不含索引 -1，从后往前的索引）
print(str1[:-1])     # 同上

# ABCDEF
# A
# ABCDE
# ABCDE

print(str1[2:5])            # 输出从第三个开始到第五个的字符
print(str1[2:])             # 输出从第三个开始的后的所有字符
print(str1 * 2)             # 输出字符串两次
print(str1 + 'GH')          # 连接字符串

# CDE
# CDEF
# ABCDEFABCDEF
# ABCDEFGH

3.2、字符串更新

var3 = 'ABCDEFG'
print("已更新字符串 : ", var3[:3] + 'abc')

# 已更新字符串 :  ABCabc

3.3、转义符

转义字符 描述
\ (在行尾时) 续行符
\\ 反斜杠符号
\' 单引号
\" 双引号
\a 响铃
\b 退格(Backspace)
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出 
print('hello\nrunoob')      # 换行
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

# hello
# runoob
# hello\nrunoob

3.4、字符串运算符

a = "Hello"
b = "Python"

print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)

# a + b 输出结果： HelloPython
# a * 2 输出结果： HelloHello

if("H" in a):
    print("H 在变量 a 中")
else:
    print("H 不在变量 a 中")

# H 在变量 a 中

3.5、字符串格式化

字符串格式化：如 你xx月的话费是xx，余额是xx 之类的字符串，而 xx 的内容是变化的。

占位符的格式化方法
占位符 替换内容
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数 
txt = 'world'
'Hello, %s' % txt

# 'Hello, world'

'Hi, %s, you have $%d' % ('Michael', 1000000)

# 'Hi, Michael, you have $1000000'

'%4d-%03d' % (3, 1)      # %4d表示：最少4位数，本例子中数值是3，故补充3个空位
                         # %03d表示：最少三位数，如果不够三位数，则在前面补充0

# '   3-001'

'%.2f' % 3.1415926      # %.2f表示：保留两位小数点

# '3.14'

# 有些时候，字符串里面的 % 是一个普通字符怎么办？这个时候就需要转义，用 %% 来表示一个 %
'growth rate: %d %%' % 7

# 'growth rate: 7 %'
format()的格式化方法

另一种格式化字符串的方法是format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……，不过这种方式写起来比%要麻烦得多：

'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)

# 'Hello, 小明, 成绩提升了 17.1%'

练习：

小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，并用字符串格式化显示出'xx.x%'，只保留小数点后1位

s1 = 72
s2 = 85
r = (s2-s1)/s1*100

print("小明成绩提升的百分点为：%.1f%%" % r)

# 小明成绩提升的百分点为：18.1%

3.6、字符串内建函数

序号 方法 描述
1 capitalize() 将字符串的第一个字符转换为大写
2 center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3 count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4 bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5 encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
6 endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
7 expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8 find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9 index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常.
10 isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
11 isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
12 isdigit() 如果字符串只包含数字则返回 True 否则返回 False..
13 islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14 isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
15 isspace() 如果字符串中只包含空白，则返回 True，否则返回 False.
16 istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False
17 isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18 join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19 len(string) 返回字符串长度
20 ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21 lower() 转换字符串中所有大写字符为小写.
22 lstrip() 截掉字符串左边的空格或指定字符。
23 maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24 max(str) 返回字符串 str 中最大的字母。
25 min(str) 返回字符串 str 中最小的字母。
26 replace(old, new [, max]) 把将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
27 rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找.
28 rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始.
29 rjust(width,[, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30 rstrip() 删除字符串字符串末尾的空格.
31 split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
32 splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33 startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34 strip([chars]) 在字符串上执行 lstrip()和 rstrip()
35 swapcase() 将字符串中大写转换为小写，小写转换为大写
36 title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37 translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38 upper() 转换字符串中的小写字母为大写
39 zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0
40 isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

4、List（列表）

list是一种有序的集合，可以随时添加和删除其中的元素，列表的数据项不需要具有相同的类型。

4.1、创建列表

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = ["a", "b", "c", "d"]

4.2、访问列表中的值

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等

print("list1[0]: ", list1[0])
# list1[0]:  Google

print("list1[:-1]: ", list1[:-1])  # 从第一个到倒数第二个
# list1[:-1]:  ['Google', 'Runoob', 1997]

print("list2[1:5]: ", list2[1:5])
# list2[1:5]:  [2, 3, 4, 5]

4.3、更新列表

list4 = ['Google', 'Runoob', 1997, 2000]
print("第三个元素为 : ", list4[2])

list4[2] = "python"  # 更新第3个元素，变成python
print(list4)
# ['Google', 'Runoob', 'python', 2000]

4.4、删除列表元素

del list4[2]  # 删除python这个元素
print(list4)
# ['Google', 'Runoob', 2000]

4.5、列表的运算

print(len(list1))   # len获取元素的个数
print(list1+list2)  # +组合列表
print(list1*3)      # *表示重复
print(3 in list2)   # 元素是否存在于列表中

# 4
# ['Google', 'Runoob', 1997, 2000, 1, 2, 3, 4, 5]
# ['Google', 'Runoob', 1997, 2000, 'Google', 'Runoob', 1997, 2000, 'Google', 'Runoob', 1997, 2000]
# True

for x in list1:
    print(x)  # 迭代

# Google
# Runoob
# 1997
# 2000

4.6、列表截取与拼接

L = ['Google', 'Runoob', 'Taobao', 'Python']
print(L[2])   # 截取第3个元素
print(L[-1])  # 截取倒数第1个元素
print(L[1:])  # 截取第2个开始的所有元素

# Taobao
# Python
# ['Runoob', 'Taobao', 'Python']

S = [1, 4, 9, 16, 25]
S = S+[36, 49, 64, 81, 100]
print(S)

# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

4.7、嵌套列表

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]

print(x)
print(x[0])

# [['a', 'b', 'c'], [1, 2, 3]]
# ['a', 'b', 'c']

4.8、列表函数

序号 函数 描述
1 len(list) 列表元素个数
2 max(list) 返回列表元素最大值
3 min(list) 返回列表元素最小值
4 list(seq) 将元组转换为列表

4.9、列表的方法

序号 方法 描述
1 list.append(obj) 在列表末尾添加新的对象
2 list.count(obj) 统计某个元素在列表中出现的次数
3 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4 list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj) 将对象插入列表
6 list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7 list.remove(obj) 移除列表中某个值的第一个匹配项
8 list.reverse() 反向列表中元素
9 list.sort(key=None,reverse=False) 对原列表进行排序
10 list.clear() 清空列表
11 list.copy() 复制列表

5、Tuple（元组）

元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号()，列表使用方括号[]

5.1、创建元组

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5)
tup3 = "a", "b", "c", "d"  # 不需要括号也可以

print(tup3)
print(type(tup3))  # 输出tup3的类型

# ('a', 'b', 'c', 'd')
# <class 'tuple'>

# 创建空元组
tup1 = ()
print(tup1)

print("-----------------------------------------")

# 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
tup2 = (50)
print(tup2, type(tup2))

print("-----------------------------------------")

tup3 = (50,)
print(tup3, type(tup3))

# ()
# -----------------------------------------
# 50 <class 'int'>
# -----------------------------------------
# (50,) <class 'tuple'>

5.2、访问元组

元组与字符串类似，下标索引从0开始，可以进行截取，组合等

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7)

print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])

# tup1[0]:  Google
# tup2[1:5]:  (2, 3, 4, 5)

5.3、修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

# 以下修改元组元素操作是非法的。
tup1 = (12, 34.56)
tup1[0] = 100
print(tup1)

# TypeError: 'tuple' object does not support item assignment

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1+tup2

print(tup3)

# (12, 34.56, 'abc', 'xyz')

5.4、删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup = ('Google', 'Runoob', 1997, 2000)
print(tup)

del tup
print("删除后的元组 tup : ")

# ('Google', 'Runoob', 1997, 2000)
# 删除后的元组 tup : 

print(tup)  # 会出错，因为元组已经删除

# NameError: name 'tup' is not defined

5.5、元组运算符

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7)

print(len(tup1), len(tup2))
print(tup1+tup2)
print(tup2*2)
print(3 in tup2)
print("------------------------------")
for x in tup2:
    print(x, end="、")

# 4 7
# ('Google', 'Runoob', 1997, 2000, 1, 2, 3, 4, 5, 6, 7)
# (1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7)
# True
# ------------------------------
# 1、2、3、4、5、6、7、

5.6、元组索引，截取

T = ('Google', 'Taobao', 'Runoob')

print(T[2])
print(T[-2])
print(T[1:])

# Runoob
# Taobao
# ('Taobao', 'Runoob')

5.7、元组内置函数

序号 方法 描述
1 len(tuple) 计算元组元素个数
2 max(tuple) 返回元组中元素最大值
3 min(tuple) 返回元组中元素最小值
4 tuple(seq) 将列表转换为元组

6、Dictionary（字典）

  • 字典是另一种可变容器模型，且可存储任意类型对象，
  • 字典使用键-值（key-value）存储，具有极快的查找速度:d = {key1 : value1, key2 : value2 }
  • 键必须是唯一的，但值则不必
  • 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组

6.1、创建字典

dict1 = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict2 = {'abc': 456}
dict3 = {'abc': 123, 98.6: 37}

print(dict1)
print(dict2)
print(dict3)

# {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
# {'abc': 456}
# {'abc': 123, 98.6: 37}

6.2、访问字典里的值

dict4 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print(dict4['Name'])
print(dict4['Age'])
print(dict4['Alice'])  # 如果用字典里没有的键访问数据，会输出错误

# Runoob
# 7
# KeyError: 'Alice'

6.3、修改字典

dict5 = {'name': 'zhan', 'age': 25, 'hight': 170}
print(dict5)

print("----------")

dict5['age'] = 30  # 更改age
dict5['school'] = 'bit'  # 添加键-值对，school-bit
print(dict5)

# {'name': 'zhan', 'age': 25, 'hight': 170}
# ----------
# {'name': 'zhan', 'age': 30, 'hight': 170, 'school': 'bit'}

6.4、删除字典元素

dict1 = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict2 = {'abc': 456}
dict3 = {'abc': 123, 98.6: 37}

del dict1['Alice']  # 删除键 'Alice'
print(dict1)

print("----------")

dict2.clear()  # 清空字典
print(dict2)  # 清空字典，即空字典

print("----------")

del dict3  # 删除字典
print(dict3)  # 因为删除，故此时会出错

# {'Beth': '9102', 'Cecil': '3258'}
# ----------
# {}
# ----------
# NameError: name 'dict3' is not defined

6.5、字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

# 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
dict1 = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
print("dict1['Name']: ", dict1['Name'])

# dict1['Name']:  小菜鸟

# 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
dict1 = {'name': 'zhan', 'age': 7}
dict2 = {('name',): 'zhan', 'age': 7}
print(dict1)
print(dict2)

print("----------")

dict3 = {['name']: 'zhan', 'age': 7} # 出错
print(dict3)

# {'name': 'zhan', 'age': 7}
# {('name',): 'zhan', 'age': 7}
# ----------
# TypeError: unhashable type: 'list'

6.6、字典的内置函数

dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(len(dict1))  # 计算字典元素个数，即键的总数
print(str(dict1))  # 输出字典，以可打印的字符串表示
print(type(dict1))  # 返回输入的变量类型，如果变量是字典就返回字典类型

# 3
# {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# <class 'dict'>

6.7、字典的内置方法

序号 函数 描述
1 radiansdict.clear() 删除字典内所有元素
2 radiansdict.copy() 返回一个字典的浅复制
3 radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4 radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5 key in dict 如果键在字典dict里返回true，否则返回false
6 radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
7 radiansdict.keys() 返回一个迭代器，可以使用 list() 来转换为列表
8 radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10 radiansdict.values() 返回一个迭代器，可以使用 list() 来转换为列表
11 pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12 popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。

7、Set（集合）

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以在set中，没有重复的key

7.1、创建集合

# 可以使用大括号 { }或者set() 函数创建集合
s = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

# 注意此时set()里面是列表，也可以是元组
t = set(['apple', 'orange', 'apple', 'pear', 'orange', 'banana'])

print(s)  # 去重
print(t)  # 去重

# {'apple', 'orange', 'pear', 'banana'}
# {'apple', 'orange', 'pear', 'banana'}

print('orange' in s) # 快速判断元素是否在集合内

# True

# 创建一个空集合必须用 set()而不是{ }，因为 { } 是用来创建一个空字典
s1 = {}
s2 = set()

print(type(s1))
print(type(s2))

# <class 'dict'>
# <class 'set'>

a = set('abracadabra')
b = set('alacazam')

print(a)
print(b)

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

7.2、集合之间的运算

print(a-b)  # a含b不含

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

print(a | b)  # 集合a或b中包含的所有元素（并集）

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

print(a & b)  # 集合a和b中都包含了的元素 （交集）

# {'c', 'a'}

print(a ^ b)  # a b不同时含有的元素

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

7.3、添加元素

s.add( x )方法
# 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作
s = set(('a', 'b', 'c', 'd'))
s.add('a')
print(s)
print("----------")
s.add('e')
print(s)

# {'c', 'a', 'b', 'd'}
# ----------
# {'c', 'b', 'd', 'a', 'e'}
s.update(x)方法
thisset = set(("Google", "Runoob", "Taobao"))
thisset.update({"baidu", "tengxun"})
print(thisset)

# {'baidu', 'Runoob', 'Google', 'tengxun', 'Taobao'}

7.4、移除元素

s.remove( x )方法
# 将元素 x 从集合 s中移除，如果元素不存在，则会发生错误
thisset = set(("Google", "Runoob", "Taobao"))
thisset.remove("Google")
print(thisset)

print("----------")

thisset.remove("python")
print(thisset)

# {'Runoob', 'Taobao'}
# ----------
# KeyError: 'python'
s.discard( x )方法

这个方法，也可以移除集合中的元素，且如果元素不存在，不会发生错误。

thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Google")
print(thisset)

# {'Runoob', 'Taobao'}
s.pop() 方法

设置随机删除集合中的一个元素

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
thisset.pop()
print(thisset)

# {'Facebook', 'Runoob', 'Taobao'}

7.5、判断元素是否在集合中存在

thisset = set(("Google", "Runoob", "Taobao"))
"Runoob" in thisset

# True

7.6、集合内置方法完整列表

方法 描述
add() 为集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
difference() 返回多个集合的差集
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
discard() 删除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 返回集合的交集。
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset() 判断指定集合是否为该方法参数集合的子集。
issuperset() 判断该方法的参数集合是否为指定集合的子集
pop() 随机移除元素
remove() 移除指定元素
symmetric_difference() 返回两个集合中不重复的元素集合。
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union() 返回两个集合的并集
update() 给集合添加元素
len() 计算集合元素个数

8、数据类型的转化

函数格式 使用示例 描述
int(x) int("8") 可以转换的包括String类型和其他数字类型，但是会丢失精度
float(x) float(1)或者float("1") 可以转换String和其他数字类型，不足的位数用0补齐，例如1会变成1.0
str(x) str(1) 将数字转化为String
repr(x) repr(Object) 返回一个对象的String格式
eval(str) eval("12+23") 执行一个字符串表达式，返回计算的结果,如例子中返回35
tuple(seq) tuple((1,2,3,4)) 参数可以是元组、列表或者字典，wie字典时，返回字典的key组成的集合
list(s) list((1,2,3,4)) 将序列转变成一个列表，参数可为元组、字典、列表，为字典时，返回字典的key组成的集合
set(s) set(['b', 'r', 'u', 'o', 'n'])
或者
set("asdfg")		 将一个可以迭代对象转变为可变集合，并且去重复，返回结果可以用来计算差集x - y、并集x
frozenset(s) frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 将一个可迭代对象转变成不可变集合，参数为元组、字典、列表等，
chr(x) chr(0x30) chr()用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。返回值是当前整数对应的ascii字符。





posted @ 2022-03-22 22:44  taoshushu  阅读(95)  评论(0)  编辑  收藏  举报