Python学习笔记-一些常用的内置函数

1. 类型转换相关函数

1）字符和编码转换

ord()/chr()

ord(): 将字符转换成对应的unicode编码中代表的数字

chr(): 将unicode编码中代表的数字转换成对应的字符

小tips：ASCII编码、主要用于表示基本的拉丁字母和数字；而Unicode编码则更广泛，旨在涵盖全球所有的字符和符号。ASCII编码与Unicode编码兼容，即0到127的ASCII字符在Unicode中也有相同的表示。

print(ord('A'))   #65
print(chr(65))    #A
print(ord('啊'))  #21834
print(ord('Ω'))   #937

2）基本数据类型转换

int()

将其他类型的元素转换成int类型

int(x [,base])

 x：要转换的元素，可以为数字或字符串，字符串要是数字字符串，且是整数

base：如果要转换的元素是其他进制用base说明，然后转换成10进制输出，当有base参数时，x只能为字符串

print(int(1.2))          #1
print(int('123'))        #123
print(int('1.2'))        #ValueError: invalid literal for int() with base 10: '1.2'
print(int('a'))          #ValueError: invalid literal for int() with base 10: 'a'
print(int('0xAB', 16))   #171
print(int('12', 16))     #18
print(int(12, 16))       #TypeError: int() can't convert non-string with explicit base

float()

将其他类型的元素转换成浮点型

要转换的元素，可以为数字或字符串，字符串要是数字字符串

print(float('1.222'))    #1.222
print(float(1))          #1.0

bool()

将其他类型的元素转换成布尔型

元素可以是数值、字符串、列表、元组等，返回只能是True或者False

print(bool(0))      #False
print(bool(1))      #True
print(bool(2))      #True
print(bool(''))     #False
print(bool(None))   #False

str()

将其他类型的元素转换成str类型

a=123 
print(str(a))                   #123
print(type(str(a)))             #<class 'str'>
list1 = ['A', 'B', 'C', 'D']
print(str(list1))               #['A', 'B', 'C', 'D']
print(type(str(list1)))         #<class 'str'>

list()

将其他类型的元素转换成list类型

要转换的元素必须为可迭代对象，转换后的单个元素与原类型一致，对于字典来说，转换的元素是键

a='123'
print(list(a))          #['1', '2', '3']
print(type(list(a)))    #<class 'list'>
b={'a':1,2:2}
print(list(b))          #['a', 2]
c=(1,2,3)
print(list(c))          #[1, 2, 3]
d=123
print(list(d))          #TypeError: 'int' object is not iterable    

tuple()

将其他类型的元素转换成tuple类型

要转换的元素必须为可迭代对象，转换后的单个元素与原类型一致，对于字典来说，转换的元素是键

a='123'
print(tuple(a))          #('1', '2', '3')
print(type(tuple(a)))    #<class 'tuple'>
b={'a':1,2:2}
print(tuple(b))          #('a', 2)
c=(1,2,3)
print(tuple(c))          #(1, 2, 3)
d=123
print(tuple(d))          #TypeError: 'int' object is not iterable

dict()

将其他类型的元素转换成tuple类型

要转换的元素必须是键值对序列

a=(('a',1),('b',2))
print(dict(a))          #{'a': 1, 'b': 2}
print(type(dict(a)))    #<class 'dict'>

3）进制转换

bin()

将一个整数转换成二进制字符串，二进制字符串有前缀“0b”

a=123
print(bin(a))        #0b1111011
print(type(bin(a)))  #<class 'str'>
b=0x123
print(bin(b))        #0b100100011
c=0o123
print(bin(c))        #0b1010011

oct()

将一个整数转换成八进制字符串，八进制字符串有前缀“0o”

a=123
print(oct(a))        #0o173
print(type(oct(a)))  #<class 'str'>
b=0x123
print(oct(b))        #0o443
c=0b010111
print(oct(c))        #0o27

hex()

将一个整数转换成十六进制字符串，十六进制字符串有前缀“0x”

a=123
print(hex(a))        #0x7b
print(type(hex(a)))  #<class 'str'>
b=0o123
print(hex(b))        #0x53
c=0b010111
print(hex(c))        #0x17

2. input()

从标准输入读取字符串，并去掉结尾的换行符

1）一个输入

a=input()
print(a)        #1
print(type(a))  #<class 'str'>

运行结果如下：

 

还可以加入一些提示文字，对于结果输出没有影响，增加了可读性

a=input('请输入一个数字：')
print(a)                #1
print(type(a))          #<class 'str'>

运行结果如下： 

2）多个输入

假如多个输入以某个符号（换行符除外）间隔，就需要用到字符串的方法split()来分隔输入

a=input().split()   #默认以空格间隔，其他符号则加上对应参数如逗号间隔：split(',')
print(a)        #['1', '2', '3', '4', '5']
print(type(a))  #<class 'list'>

运行结果如下：

 也可以将多个输入分别存放到不同的变量中，需注意，输入数据的个数必须和变量个数一致

a,b,c=input().split()
print(a,b,c)
print(type(a))

 运行结果如下：

如果要以换行符来间隔输入，则需要用到循环

n=int(input())      #先输入一共要输入的数据个数，使用int()将字符串转换成整型，用于下面的循环
list1=[]            #定义一个列表接收即将要输入的数据
for i in range(n):  #定义一个循环，依次接收n个数据
    i=input()       #接收数据
    list1.append(i) #每接收一个数据，将数据放到列表中
print(list1)

运行结果如下：

 

3. print()

将需打印的内容输出到指定位置

基本语法：

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

objects：需输出的对象，可以有多个，用','分隔

sep： 间隔符，用来间隔已输出的对象，默认为' '(一个空格)

end：结束符，即以什么结束输出，默认为'\n'(换行符)

file：输出位置，默认是标准输出，即控制台

flush：缓冲输出设置，True=立即刷新缓冲区

str1='abcd'
a=123
list1=[1,2]
print(str1, a, list1)                     #abcd 123 [1, 2]
print(str1, a, list1, sep=',')            #abcd,123,[1, 2]
print(str1, a, list1, end='*')            #abcd 123 [1, 2]*
with open('./practice.txt','w') as file1:
    print(str1, a, list1, file=file1)

控制台输出结果如下：

practice.txt文件中结果如下：

import time

with open('./practice.txt','w') as file1:
    print("Loading", end="",file=file1)
    for i in range(20):
        print(".", end='', file=file1,flush=True)
        time.sleep(0.5)

当flush=True时，执行上面代码过程中，多次查看practice.txt文件，会发现，每次查看时都会往里写入一些内容；而当flush=False时，执行上面代码过程中，多次查看practice.txt文件，会发现，每次查看时该文件都没有内容，直到执行完毕才写入全部内容。这就是因为flush=False时，是将数据先放在了缓冲区。

4. map()

 基本语法：

map(function, iterable)

对序列 iterable 中每一个元素调用 function 函数

• function：一个函数或方法
• iterable：一个或多个序列（可迭代对象），当有多个对象时，function也要能够接收多个参数
• 返回值：返回一个map对象，其本质上也是一个迭代器

def square(value):
    return value**2

map1=map(square,[1,2,3,4,5,6,7,8,9,10])
print(map1)        #<map object at 0x000001422575F1F0>
list1=list(map1)
print(list1)       #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 5. join()

将元素通过拼接符连接成新的字符串

str.join(Iterable)

str：拼接符，是一个字符串

Iterable：元素必须为一个可迭代对象（有__iter__方法的对象），比如字符串，列表，元组，字典，同时列表和元组里的元素要为str类型，字典里的键要为str类型，否则会报错

str1='abc'
print(' '.join(str1))         #a b c
list1=['a','b','c']  
print(' '.join(list1))        #a b c
tuple1=('a','b','c') 
print(' '.join(tuple1))       #a b c
dict1={'hello':1,'world':2}
print(' '.join(dict1))        #a b c
int1=123
print(' '.join(int1))     #TypeError: can only join an iterable
list1=[1,2,3]
print(' '.join(list1))   #TypeError: sequence item 0: expected str instance, int found
 

6. sorted()

对可迭代对象进行排序，包括字符串，列表，元组，字典等，返回一个新的列表，不会改变原来的对象

基本语法：

sorted(iterable, *, key=None, reverse=False)

 iterable：可迭代对象

key：可选参数，定义排序时用到的函数，此函数将作用于每一个元素上，并根据返回的结果进行排序

reverse：可选参数，定义排序顺序，False是升序，True是降序，默认升序

list1=['1','a','A']      #比较的元素需为同一个类型
list1_new=sorted(list1)
print(list1_new)          #['1', 'A', 'a']
str1='jdkei137A@'          #以ascii码大小进行排序
str1_new=sorted(str1)
print(str1_new)           #['1', '3', '7', '@', 'A', 'd', 'e', 'i', 'j', 'k']
dict1={'d':4,'b':2, 'a':1, 'c':3}  
key=sorted(dict1.keys())         #对键进行排序
print(key)                       #['a', 'b', 'c', 'd']
value=sorted(dict1.values())     #对值进行排序
print(value)                     #[1, 2, 3, 4]
item=sorted(dict1.items())       #对键值对进行排序，默认以键进行排序
print(item)                      #[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

list1=[1,-2,-5,4]
list1_new=sorted(list1,key=abs)
print(list1_new)                   #[1, -2, 4, -5]
str1='jdkeiACB'
str1_new=sorted(str1,key=str.lower)
print(str1_new)                    #['A', 'B', 'C', 'd', 'e', 'i', 'j', 'k']

list1=[1,-2,-5,4]
list1_new=sorted(list1)
print(list1_new)                      #[-5, -2, 1, 4]
list1_new=sorted(list1,reverse=True)
print(list1_new)                      #[4, 1, -2, -5]