python基础11_类型转换函数

类型转换函数

类型转换函数主要有诸如list()、int()、bool()等转换数据类型的函数，还包括一些字节转换和编码转换的函数，有少数类调用函数，因为还没学习过类的知识，只能简单了解。

函数名称和功能语法列表

序号	函数名	功能	语法
1	bool()	用于将给定参数转换为布尔类型，如果没有参数，返回 False。	bool([x]) x – 要进行转换的参数。
2	int()	用于将一个字符串或数字转换为整型。	int(x, base=10) x – 字符串或数字。 base – 进制数，默认十进制。
3	float()	用于将整数和字符串转换成浮点数。	float([x]) x – 整数或字符串
4	complex()	用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。	complex([real[, imag]]) real – int, long, float或字符串； imag – int, long, float；
5	str()	将对象转换为字符串。	str(object) object：可以是整数、字符、列表、字典等
6	ord()	是 chr() 函数（对于8位的ASCII字符串 或 对于Unicode对象）的配对函数，以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。	ord© c – 字符。
7	chr()	用一个范围内整数作参数，返回ASCII或 Unicode的一个对应的字符。	chr(i) i – 可以是10进制也可以是16进制的形式的数字。
8	bytearray()	返回一个新字节数组。 列表内必须是range(0,256)的整数，字符串必须声明encoding类型	bytearray([source[, encoding[, errors]]]) source–列表或字符串
9	bytes()	返回一个新字节数组。可参考bytearray()	bytes([source[, encoding[, errors]]]) source–列表或字符串
10	memoryview()	返回给定参数的内存查看对象(memory view)。	memoryview(obj) obj – Readable Buffer
11	bin()	返回二进制数	bin(x)，x为整数 二进制数0b开头
12	oct()	返回八进制数	oct(x)，x为整数 八进制数0o开头
13	hex()	返回十六进制数	hex(x)，x为整数 十六进制数0x开头
14	tuple()	创建元组，或把对象转化为元组	tuple(对象)
15	list()	创建列表，或把对象转化为列表	list(对象)
16	dict()	创建字典，或把对象转化为字典	dict(对象)
17	set()	创建集合，或把对象转化为集合	set(对象)
18	frozenset()	返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。 返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。	frozenset([iterable]) iterable – 可迭代的对象，比如列表、字典、元组等等。可参考set()用法
19	enumerate()	用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。	enumerate(sequence,[start=0]) sequence – 一个序列、迭代器或其他支持迭代对象。start – 下标起始位置的值。
20	range()	可创建一个整数列表，一般用在 for 循环中。	range(start, stop[, step])
21	iter()	用来生成迭代器。	iter(object[, sentinel]) object – 支持迭代的集合对象。 sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
22	slice()	定义切片方法，以参数的形式传递给需要切片的对象。	slice(stop) slice(start, stop[, step])
23	super()	用于调用父类(超类)的一个方法	super(type[, object-or-type]) type – 类。 object-or-type – 类，一般是 self
24	object()	返回一个空对象，我们不能向该对象添加新的属性或方法。	object()

单个函数的用法示例

bool()转成布尔数据

# bool()用于将给定参数转换为布尔类型，如果没有参数，返回False。
print(bool())
print(bool(0))
print(bool(1))
print(bool(2))
print(issubclass(bool,(int)))#bool是int子类

运行结果：（略）

int()转成整数

# int()用于将一个字符串或数字转换为整型。
# 如果指定数进制的话，转换为十进制整数。
# 注意小数在转换时的结果，相当于只要小数点右边数值，舍去小数点左边所有数。
print(int())#不传入参数时，得到结果0
print(int(3))
print(int(3.6))
print(int('12',16)) # 如果是带参数base的话，12要以字符串的形式进行输入，12为16进制
print(int('0xa',16))   # 0xa是十六进制数的写法，相当于十六进制数a
print(int('10',8))   # 这里的10是一个两位的八进制数
# print(int('aaa1111'))   # 这句是会报错的。未加参数base的值时，默认base=10，报错原因即十进制数码里是没有a的。

运行结果：

0
3
3
18
10
8

float()转成浮点数

# float()用于将整数和字符串转换成浮点数。
print(float()) #不传入参数时，得到结果0
print(float(3))
print(float(3.6))
print(float('12.123')) 
print(float('10'))   
# print(float('0xa'))   # 这句是会报错的。参数不能是十进制以外的数

运行结果：

0.0
3.0
3.6
12.123
10.0

complex()创建复数

# complex()用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
# 如果第一个参数为字符串，则不需要指定第二个参数。。
print(complex(1, 2))
print(complex(1))    # 数字
print(complex("1")) # 当做字符串处理
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
print(complex("1+62j"))
print(complex("1+j"))
print(complex("+j"))
print(complex("j")) # 字符串里不能有除j以外的字母

运行结果:

(1+2j)
(1+0j)
(1+0j)
(1+62j)
(1+1j)
1j
1j

str()转为字符串

# str()将对象转换为字符串，转化对象基本上没太多限制，数字、列表、字典等都行
i = 123.55
print(type(i))
print(type(str(i)))
print(str(i))

b = True
print(type(b))
print(type(str(b)))
print(str(b))

print(type(str('1234asdf')))
print(str('1234asdf'))

运行结果:

<class 'float'>
<class 'str'>
123.55
<class 'bool'>
<class 'str'>
True
<class 'str'>
1234asdf

ord()返回字符编码的十进制数

ord、chr、bytearray和bytes几个函数都与编码有关，这里似乎涉及python的默认编码问题，我了解不多，所以有些对基本功能的描述应该是有问题的。

暂时可以认为python默认编码是utf-8，遵循的是Unicode标准，在这个标准中是可以正常显示ASCII的，也就是ANSI标准。

# ord()返回对应字符的 ASCII 数值，或者 Unicode 数值的十进制数
print(ord('a'))
print(ord('A'))
print(ord('1'))
print(ord('+'))
print(ord('我'))

运行结果:

# 97
# 65
# 49
# 43
# 25105

chr()与ord函数的作用相反

#chr()用一个范围在 range（1114112）内的（就是0～1114111）整数作参数，
# 返回一个ASCII或Unicode数值对应的字符。
# 功能与ord()函数的作用相反

print(chr(0x30), chr(0x31), chr(0x61))   # 十六进制
print(chr(48), chr(49), chr(97))         # 十进制
print(chr(97), chr(65), chr(49), chr(43), chr(25105))  
print(chr(0))   # 结合下一条指令结果，应该是返回一个空的字符串。
print(type(chr(0)))
print(int('0x110000', 16))  # 参数取值范围的最大整数值，但是取不到0x110000
print(chr(1114111))

运行结果:

# 0 1 a
# 0 1 a
# a A 1 + 我
# 
# <class 'str'>
# 1114112
# 􏿿

bytearray()转为字节序列

# bytearray()返回一个新字节数组。
# 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列； 
# 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数； 
# 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。 
print(bytearray()) # 如果没有输入任何参数，默认就是初始化数组为0个元素。
print(bytearray([1,2,255,0])) # 列表里元素必须小于256的整数,byte must be in range(0, 256)
print(bytearray('runoob123', 'utf-8'))
print(bytearray('1',encoding= 'utf-8'))
print(bytearray(10)) # 如果 source 为整数，则返回一个长度为 source 的初始化数组；
b = True
print(bytearray([1,2,255,b]))  # 这里的b其实是整数1

运行结果:

bytearray(b'')
bytearray(b'\x01\x02\xff\x00')
bytearray(b'runoob123')
bytearray(b'1')
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
bytearray(b'\x01\x02\xff\x01')

bytes()返回字节数组

# bytes(),与bytearray差不多吧？
print(bytes()) # 如果没有输入任何参数，默认就是初始化数组为0个元素。
print(bytes([1,2,255,0])) # 列表里元素必须小于256的整数,byte must be in range(0, 256)
print(bytes('runoob123', 'utf-8'))
print(bytes('1',encoding= 'utf-8'))
print(bytes(10)) # 如果 source 为整数，则返回一个长度为 source 的初始化数组；
b = True
print(bytes([1,2,255,b]))  # 这里的b其实是整数1

运行结果:

b''
b'\x01\x02\xff\x00'
b'runoob123'
b'1'
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
b'\x01\x02\xff\x01'

memorryview()返回对象的memory view

暂时不知道这玩意儿有啥用……可以用[]索引和切片

# memorryview()返回给定的参数是Readable Buffer对象的memory view。
# 对象为str和int时，返回情况是不一样的。
st = 'abcefg'   # 对象为str时情况
# v = memoryview('abcefg')
v = memoryview(bytearray(st, 'utf-8'))
print(bytearray(st, 'utf-8'))
print(v)
print(st[1], ord(st[1]))  # 用来对照v[1]是哪个字符，ASCII码值
print(v[1])  # 
print(st[-1], ord(st[-1]))  # 用来对照v[-1]是哪个字符，ASCII码值
print(v[-1])
print(st[1:4])  # 对照v[1: 4]是哪些字符
print(v[1:4])
print(v[1:4].tobytes())
# 这是一条分割线
print("-----------------------------------------------------")
nmub = [1, 2, 3, 4, 5, 6]   # 列表里的对象时int
v_nmub = memoryview(bytearray(nmub))
print(bytearray(nmub))
print(v_nmub)
print(nmub[1], ord('2'))
print(v_nmub[1])
print(nmub[-1], ord('6'))
print(v_nmub[-1])
print(nmub[1:4])
print(v_nmub[1:4])
print(v_nmub[1:4].tobytes())

运行结果：

bytearray(b'abcefg')
<memory at 0x000001F7A9CFE380>
b 98
98
g 103
103
bce
<memory at 0x000001F7A9CFE5C0>
b'bce'
-----------------------------------------------------
bytearray(b'\x01\x02\x03\x04\x05\x06')
<memory at 0x000001F7A9CFE5C0>
2 50
2
6 54
6
[2, 3, 4]
<memory at 0x000001F7A9CFE680>
b'\x02\x03\x04'

bin()\oct()\hex()数字的进制转换

# bin()、oct()、hex()分别返回二进制、八进制、十六进制数
print(bin(10))
print(bin(0o12))  # 八进制数0o开头
print(bin(0xa))   # 十六进制数0x开头
print(oct(0b1010))  # 二进制数0b开头
print(oct(10))  
print(hex(10))  

运行结果：

0b1010
0b1010
0b1010  # 0b开头表示二进制
0o12
0o12    # 0o开头表示八进制
0xa     # 0x开头表示十六进制

tuple(),list(),dict(),set()元组、列表、字典、集合转换

# tuple(),list(),dict(),set()分别是元组，列表，字典，集合
# 具体示例略，参看前边内容

frozenset()把集合冻结

# frozenset()创建一个不可修改的集合
a = frozenset(range(10))     # 生成一个新的不可变集合
b = frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
c = frozenset('runoob') 
d = frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
print('\t', a, '\n\t', b, '\n\t',c, '\n\t',d)

运行结果:

         frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
         frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
         frozenset({'r', 'u', 'n', 'o', 'b'})
         frozenset({'r', 'u', 'n', 'o', 'b'})

enumerate()根据可迭代对象创建枚举类型

#enumerate()返回列表、元组、字符串等有序可迭代对象的元素下标和元素
en = enumerate('abc')
# print(en)得到这个<enumerate object at 0x0000025BAECF4440>
for i, j in en:
    print(i,j)
    d[i] = j   # 向空字典里增加键值对

运行结果:

0 a
1 b
2 c

iter()生成迭代器

# iter()用来生成迭代器
lst = [1, 2, 3]
print(iter(lst))
for i in iter(lst):
    print(i)

运行结果：

<list_iterator object at 0x000001EFF9318640>  #list_iterator列表生成的迭代器
1
2
3

slice()传参给对象切片

# slice()定义切片方法，以参数的形式传递给需要切片的对象。
lst = [1, 2, 3, 4, 5, 6]
t = slice(1,4)
t1 = slice(4)
t2 = slice(-2,1,-1)
print(lst[t])
print(lst[t1])
print(lst[t2])
print(t2)

运行结果：

[2, 3, 4]
[1, 2, 3, 4]
[5, 4, 3]
slice(-2, 1, -1)    #（star, end, step)

super()调用父类(超类)的一个方法

# super()用于调用父类(超类)的一个方法
class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)  # 3

运行结果：

3

object()返回一个空对象

# object()返回一个空对象，不知道有什么用。没任何参数。
t = object()
print(t)
print(object)
print(dir(t))

运行结果：

<object object at 0x00000269E2898460>
<class 'object'>
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']