内置转换函数

bool()

  • 根据传入的参数的逻辑值创建一个新的布尔值
>>> bool()
False
>>> bool('str')
True

int()

  • 根据传入的参数创建一个新的整数
>>> int() #不传入参数时，得到结果0
0
>>> int(1)
1
>>> int(1.1) #浮点数转整数
1

#字符串 转 整数，有限制 也有便利的地方
>>> int("1.1") 
#报错
>>> int('02') #去掉'0'  ⭐当然转换字符串其中不能含有非数字的字符
2
>>> int('  2  ')#去掉空格
2
>>>int('12\n') #回车也能去掉
12
>>> int('23',8)#八进制转十进制，base可以随意取，如 int('23',2)
19

float()

  • 根据传入的参数创建一个新的浮点数
>>> float()
0.0
>>> float(3)
3.0
>>> float(' 12 ') #对字符串的操作类似int()
12.0

complex()

  • 根据传入参数创建一个新的复数
>>> complex(1,2)
(1+2j)

str()

  • 将数字类型的数据（整数、浮点数和复数）转换成字符串，有下列三种方法。
>>> str()
''
>>> a = 1
>>> b = 1.2
>>> c = 1+2j
>>> print(str(a),str(b),str(c))
1 1.2 (1+2j)
>>> print('asd ' + str(a) + ' as')
asd 1 as

注:不能写成：print(‘asd ’ + a + ’ as’)

ord()

  • 返回Unicode字符对应的整数（Unicode编码是在基本的 ASCII码上的一个改进，对于ASCII码的部分与Unicode码中 是一样的）
>>> ord('a') # ord('中') 中文也行=>20013
97

chr()

  • 返回整数所对应的Unicode字符
>>> chr(97)
'a'

bin()

  • 将整数转换成二进制字符串
>>> bin(1) #chr(20013) 获得中文'中'
'0b1'

oct()

  • 将整数转换成八进制字符串
>>> oct(1)
'0o1'

hex()

  • 将整数转换成十六进制字符串
>>> hex(1)
'0x1'

list()

  • 根据传入的参数（字符串）创建一个新的列表，将每个字符分开
>>> list()
[]
>>> list('abcd')
['a', 'b', 'c', 'd']

其他内置函数

map(func, iter, …)

  • 参数：
  • func：为功能函数，也可以是lambda表达式
  • iter：表示可迭代参数序列，后面还可以传入多个可迭代序列进行映射
  • 作用：将func作用于参数列表的每个元素上，并返回一个新的list列表。
>>> def square(item:int)->int:#定义了函数
    return item**2
	list(map(square,[1,2,3,4]))#func参数传入函数

[1, 4, 9, 16]
>>> list(map(lambda x:x*x,[1,2,3,4]))
[1, 4, 9, 16]
#当函数需要多个参数列表时，直接按顺序进⾏填充即可
>>> a = [1,2,3,4]
>>> b = [1,2,3,4]
>>> list(map(lambda x,y:x+y,a,b))
[2, 4, 6, 8]
#当各个参数列表的参数个数不⼀致时，python会取最短的那个进⾏截断
>>> a = [1,2,3,4]
>>> b = [2,3,4]
>>> list(map(lambda x,y:x*y,a,b))
[2, 6, 12]

常用用法：

  • 输入时，input的字符串在split后，直接转换成指定的类型
>>> a,b = map(int,input().split())
1 2 #这是输入
>>> print(a,b)
1 2 #这是输出

⭐ 注意点：

map，即映射无法直接输出内部信息，其就相当于一个封装的包

>>> a = map(int,["2","12"]) >>> print(a) <map object at 0x000002C48EEC5150>

这里我们可以将其转换为其他的类型（列表、元组、集合）获取内部信息：

>>> list(map(int,["2","12"])) [2, 12] >>> tuple(map(int,["2","12"])) (2, 12) >>> set(map(int,["2","12"])) {2, 12}

divmod(x,y)

返回 x 和 y 的商和余数

>>> divmod(7,3) # 整数 求商和余数 结果为 整数
(2, 1)
>>> divmod(7.0,3)# 浮点数参与 求商和余数 结果为 浮点数
(2.0, 1.0)

sum(iter, [start=0])

  • 描述：sum() 方法对可迭代对象进行求和计算。
  • 语法：sum(iterable[, start])
  • 参数：
  • iterable – 可迭代对象，如：列表、元组、集合、字典(针对键)、map()、range()。⭐注意：对象的元素(dict的键)必须是数值类型
  • start – 指定相加的参数（可以是变量、常量），如果没有设置这个值，默认为0。
  • 实例
>>>sum([0,1,2])  
3  
>>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
12
>>> sum({1:1,2:2})
3

type(x)

  • x：为变量
  • type函数返回 x变量的 类型
>>> b = (1,)
>>> b
(1,)
>>> type(b)
<class 'tuple'>

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

执行一个字符串表达式，并返回表达式的值。

  • 参数
  • expression – 表达式，str类型
  • globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
  • locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
  • 返回：返回表达式计算结果。
  • 函数执行的过程：
    先去掉字符串最外层的引号，在计算剩下的表达式。

实例：

>>>x = 7
>>> eval（ '3 * x' )
21
>>> eval（'pow(2,2)')
4
>>> eval（'2 + 2')
4
>>> n=81
>>> eval（"n + 4")
85
>>> a = eval（"'aa'")
>>> a
'aa'

len(x) | x._len_()：

对所有组合数据类型都可以使用，返回其元素的数量

>>> len([2,3,5,7])
4
>>> len('hello world')
11
>>> len({"asd":1,"as":2})
2
>>> (1,2).__len__()
2
>>> {1,2}.__len__()
2
>>> [1,2].__len__()
2
>>> "12".__len__()
2

min(x) 和 max(x)：

参数：任何组合数据类型（字符串、列表、元组、集合、字典(比较键)）

⭐规则：组合数据类型中的最小元素必须是同一类型，其实就是 数值类型 或者 字符串类型。

计算序列中的最小值和最大值，字符串的大小是按照其Unicode 编码来比较的。

>>> min([2,3,5,7,11,13])
2
>>> min('好好学习天天向上')
'上'
>>> max((1,2))
2
>>> max({1,2})
2
>>> max({"a":2,"A":1})
'a'
>>> min({1,2,3,"ss"})  #当元素类型混用的时候，函数就用不了了
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
>>> min({(1,3),("a",'g')}) #当然比较元组这里类型的时候，也要符合元组之间比较的要求---元素同类型
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'

zip([iterable, …])

  • zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
    如果各个迭代器的元素个数不一致，则**返回列表长度与最短的对象相同，利用 *** 号操作符，可以将元组解压为列表。

zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

  • 实例：
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 返回一个对象(并非list)
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> zipped = zip(a,b,c)  # 元素个数与最短的列表一致
>>> list(zipped)
[(1, 4, 4), (2, 5, 5), (3, 6, 6)]

# zip(*)可理解为解压，返回二维矩阵式,与zip()相反
>>> a1, a2 = zip(*zip(a,b))          
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

range(start,stop,step)

  • start：可选
    计数从start开始。默认是从0开始。
    例如：range(5) 等价于 range(0,5)
  • stop：必选
    计数到stop结束，但不包括stop。 [start,stop-1]
    例如：list(range(0,5)) 是 [0,1,2,3,4] 没有5
  • step：可选
    步长，默认为1.
    例如：range(0,5) 等价于 range(0,5,1)

range函数类似于map函数，同样是返回新的列表，但是它是一个封装，不能直接访问其中的信息，需要进行转换（list，set，tuple）

>>> range(3) range(0, 3) >>> list(range(3)) [0, 1, 2] >>> set(range(3)) {0, 1, 2} >>> tuple(range(3)) (0, 1, 2)

例子：

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1,11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0,-10,-1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

例子：输入n （n>=10），求 1+2+…+n之和

n = int(input())
s = sum(list(range(n+1)))
print(s)

例子：输入n （n>=5），求n!

n = int(input())
factor = list(range(1,n+1))
f=1
for i in factor:
    f=f*i
print(f)

id(x)

  • x：变量名
  • 可以显示对象的地址。

变量是将名字和对象进行关联，不同于C，先声明为变量申请空间，再将内容存入申请的空间。

>>> a = 100
>>> b = 100.0
>>> id(a)
1741322718544
>>> id(b)
1741322718544
>>> a = 60
>>> b = 10
>>> a = b
>>> id(a)
1741322715664
>>> id(b)
1741322715664

根据上面的情况，在a，b进行运算的时候，原先的值并没有改变，而是指向了别的存储有与结果相同值的空间