一：Python3 操作符（大全）

Python3 操作符（大全）

二：函数带括号与不带括号的区别

• （1）不带括号：调用的是这个函数本身 ，是整个函数体，是一个函数对象，不需等该函数执行完成。
• （2）带括号(参数或者无参)：调用的是函数的执行结果，须等该函数执行完成的结果。

def fuc_temp(x):
    print("come here")
    return x
 
 
print(fuc_temp)  		
# 不带括号调用的结果：<function fuc_temp at 0x>

print(fuc_temp(10))  	
# 带括号调用的结果：come here
# 带括号调用的结果：10

三：不可变数据类型与可变数据类型

• 不可变数据类型： 元组，布尔类型（bool），整型（int）、字符串（str）
• 可变数据类型： 字典（dict）、列表（list）、集合（set）

四：Python3 内置函数（大全）

Python3 内置函数（大全）

---

1、input()：用于获取控制台的输入。

【Python】input()函数用法小结

2、print() ：用于打印输出。

【Python】print()函数的用法

3、int() ：将一个字符串或数字转换为整型（强转）。

【Python】int()用法详解

函数说明：int(x, base=10)
输入参数：

• x：字符串或数字。
• base：参数x为（二进制、八进制、十进制、十六进制）数，默认十进制数。
  备注：若带参数base，则输入必须是整数，且整数必须以字符串的形式进行输入。如：整数12转化为16进制，int('12', base=16)
  10进制转化为16进制的算法

输入	返回值
int()	整数 0
int(整数)	整数
int(浮点数)	浮点数的整数
int(字符串(整数))	将字符串类型转换为int类型转换
int(字符串(浮点数))	需先转换为float类型，再进行int转换，否则报错。
–	–
int('整数', base=16)	将输入的16进制整数转换为10进制整数（同理：其余进制）

print(int())                    # 【输出结果】0
print(int(2))                   # 【输出结果】2
print(int(-2.9))                # 【输出结果】-2
print(int('-2'))                # 【输出结果】-2
print(int(float('-2.9')))       # 【输出结果】-2

print(int('20', 16))       		# 【输出结果】32
print(int('0XAA', 16))       	# 【输出结果】170

4、float() ：将一个整数、字符串或布尔值转化为浮点数（强转）。只支持十进制输入和输出。

函数说明：float(object)
输入参数：

• object：整数、字符串、布尔值（若没有输入参数，则float=0.0）
  备注1：当非十进制的字符串作为参数时，若超出数字字符时会报错。比如：float('2a1')
  备注2：不能进行不同进制之间的转换，否则系统报错。与int()完全不同。

print('空输入参数', float())
print('整数转换为浮点数', float(5))
print('浮点数转换为浮点数', float(-5.5))
print('字符串转换为浮点数', float('-5.5'))
print('布尔值转换为浮点数', float(True))
'''
空输入参数 0.0
整数转换为浮点数 5.0
浮点数转换为浮点数 -5.5
字符串转换为浮点数 -5.5
布尔值转换为浮点数 1.0
'''

5、str() ：将参数转换成字符串类型（强转）。

函数说明：int(x, base=10)

print('返回空字符串:', str())
print('整数转换为字符串:', str(-23))
print('浮点数转换为字符串:', str(1.3e2))
print('列表转换为字符串:', str([12, '-23.1', 'Python']))
print('元组转换为字符串:', str((23, '9we', -8.5)))
print('字典转换为字符串:', str({'Huawei': 'China', 'Apple': 'USA'}))
print('集合转换为字符串:', str({'China', 'Japan', 'UK'}))
'''
返回空字符串: 
整数转换为字符串: -23
浮点数转换为字符串: 130.0
列表转换为字符串: [12, '-23.1', 'Python']
元组转换为字符串: (23, '9we', -8.5)
字典转换为字符串: {'Huawei': 'China', 'Apple': 'USA'}
集合转换为字符串: {'China', 'UK', 'Japan'}
'''

（1）str.join()：将序列（即字符串、元组、列表、字典）中的元素以指定的字符连接，并返回一个新的字符串。

函数说明：'Separator'.join(Sequence)
功能说明：以Separator为分隔符，对Sequence所有元素进行逐个分割，并返回一个新的字符串。
输入参数：

• Separator：代表分隔符。 可以是单个字符（如：','、'.'、'-'、'*'等），也可以是字符串（如: 'abc'）。
• Sequence：代表要连接的元素序列。可以是字符串、元组、列表、字典。
  备注1：Separator和Sequence都只能是string型，不能是int型和float型，否则系统报错。
  备注2：字典的读取是随机的。

a1 = 'I Love China !'
print('字符串: ', ' '.join(a1))

a2 = ['I', 'Love', 'China', '!']
print('列表: ', ' '.join(a2))

a3 = ('I', 'Love', 'China', '!')
print('元祖: ', ' '.join(a3))

a4 = {'I': 1, 'Love': 2, 'China': 3, '!': 4}
print('字典: ', ' '.join(a4))
'''
字符串:  I   L o v e   C h i n a   !
列表:  I Love China !
元祖:  I Love China !
字典:  I Love China !
'''

import os     	# 导入路径模块
os.getcwd()   	# 获取当前路径
data_save = os.path.join(os.getcwd(), 'data_save')  # 获取当前路径并组合新的路径
print(data_save)

（2）split()：通过指定分隔符（默认为空格）对字符串进行切片，并返回分割后的字符串列表（list）。

函数说明：str.split(str=".", num=string.count(str))[n]
参数说明：

• str： 表示分隔符，默认为空格，但是不能为空。若字符串中没有分隔符，则把整个字符串作为列表的一个元素。
• num：表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量。
• [n]： 表示选取第n个切片。
  • 注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略。

s = 'www.dod.com.cn'
print('分隔符(默认): ', s.split())                    # 【输出结果】分隔符(默认):  ['www.dod.com.cn']
print('分隔符(.): ', s.split('.'))                   # 【输出结果】分隔符(.):  ['www', 'dod', 'com', 'cn']
print('分割1次, 分隔符(.): ', s.split('.', 1))        # 【输出结果】分割1次, 分隔符(.):  ['www', 'dod.com.cn']
print('分割2次, 分隔符(.): ', s.split('.', 2))        # 【输出结果】分割2次, 分隔符(.):  ['www', 'dod', 'com.cn']
print('分割2次, 分隔符(.), 取出分割后下标为1的字符串: ', s.split('.', 2)[1])      # 【输出结果】分割2次, 分隔符(.), 取出分割后下标为1的字符串:  dod
print(s.split('.', -1))                             # 【输出结果】['www', 'dod', 'com', 'cn']
###########################################
# 分割2次, 并分别保存到三个变量
s1, s2, s3 = s.split('.', 2)
print('s1:', s1)                                    # 【输出结果】s1: www
print('s2:', s1)                                    # 【输出结果】s2: www
print('s3:', s2)                                    # 【输出结果】s3: dod
###########################################
# 连续多次分割
a = 'Hello<[www.dodo.com.cn]>Bye'
print(a.split('['))                                 # 【输出结果】['Hello<', 'www.dodo.com.cn]>Bye']
print(a.split('[')[1].split(']')[0])                # 【输出结果】www.dodo.com.cn
print(a.split('[')[1].split(']')[0].split('.'))     # 【输出结果】['www', 'dodo', 'com', 'cn']

（3）count()：统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。

函数说明：str.count("char", start, end) 或 str.count("char")
参数说明：

• str：为要统计的字符（可以是单字符，也可以是多字符）。
• start：为索引字符串的起始位置，默认参数为0。
• end：为索引字符串的结束位置，默认参数为字符串长度即len(str)。

str_temp = "i love python, i am learning python"
print(str_temp.count("i"))              # 【输出结果】3           # 单字符统计：start和end为默认参数
print(str_temp.count("i", 2))           # 【输出结果】2           # 单字符统计：star=2，end值为默认参数
print(str_temp.count("i", 0, 5))        # 【输出结果】1           # 单字符统计：star=2，end=5
################################################################################################
print(str_temp.count("py"))             # 【输出结果】2           # 多字符统计：start和end为默认参数

（4）strip()：用于移除字符串头 / 尾指定的字符（默认为空格或换行符）或字符序列，但不能删除中间部分的字符。

函数说明：str3 = str1.strip(str2)
其中，str1是操作字符串，str2是待移除指定的字符或字符序列。str3是移除后生成的新字符串。

str_temp1 = "  123 ABCDEFG 321"
str_temp2 = "  123 ABCDEFG 321"
str_temp3 = "  123 ABCDEFG 321"
print(str_temp1.strip())            # 【输出结果】"123 ABCDEFG 321"
print(str_temp2.strip('12'))        # 【输出结果】"  123 ABCDEFG 321  "
print(str_temp3.strip('3'))         # 【输出结果】"  123 ABCDEFG 321  "

（5）lstrip()：用于截取掉字符串左边的空格或指定字符。

txt_temp1 = "_hello_world_"
print(txt_temp1.rstrip('_'))        # 【输出结果】"_hello_world"

（6）rstrip()：用于截取掉字符串右边的空格或指定字符。

txt_temp2 = "  _hello_world_  "
print(txt_temp2.rstrip(' '))        # 【输出结果】"  _hello_world_"

（7）upper()：将字符串中的所有小写字母转换为大写字母。

str_temp = "I Love python"
print(str_temp.upper())         # 【输出结果】I LOVE PYTHON

（8）lower()：将字符串中的所有大写字母转换为小写字母。

str_temp = "I Love PYTHON"
print(str_temp.lower())         # 【输出结果】i love python

（9）ljust()：左对齐文本。向指定字符串的右侧填充指定字符。

函数说明：str.ljust(width, fillchar)
输入参数：

• str：表示要进行填充的字符串；
• width：表示包括 str 本身长度在内，字符串要占的总长度；
• fillchar：指定填充字符串时所用的字符，默认情况使用空格（可选参数）。

S = 'www.baidu.com'
addr = 'http://www.baidu.com'
print(S.ljust(35,'-'))			# 【输出结果】www.baidu.com--------------------
print(addr.ljust(35,'-'))		# 【输出结果】http://www.baidu.com-------------

（10）rjust()：右对齐文本。向指定字符串的左侧填充指定字符。

函数说明：str.rjust(width, fillchar)
输入参数：

• str：表示要进行填充的字符串；
• width：表示包括 str 本身长度在内，字符串要占的总长度；
• fillchar：指定填充字符串时所用的字符，默认情况使用空格（可选参数）。

S = 'http://www.baidu.com/python'
addr = 'http://www.baidu.com'
print(S.rjust(35,'-'))			# 【输出结果】-----http://www.baidu.com/python
print(addr.rjust(35,'-'))		# 【输出结果】------------http://www.baidu.com

（11）center()：居中对齐文本。

函数说明：str.center(width, fillchar)
输入参数：

• str：表示要进行填充的字符串；
• width：表示包括 str 本身长度在内，字符串要占的总长度；
• fillchar：指定填充字符串时所用的字符，默认情况使用空格（可选参数）。

S = 'http://www.baidu.com/python/'
addr = 'http://www.baidu.com'
print(S.center(35, '-'))			# 【输出结果】----http://www.baidu.com/python/---
print(addr.center(35, '-'))			# 【输出结果】--------http://www.baidu.com-------

（12）str.index()：检测指定范围内的字符串中是否包含子字符串str。若没有检测到，则系统报错。

函数说明：str.index(str, beg=0, end=len(string))]
输入参数：

• str：指定检索的字符串
• beg：开始索引，默认为0。
• end：结束索引，默认为字符串的长度。

A = '123xyzzaraabc'
print(A.index('xyz'))  	# 结果 3
print(A.index('zzz'))  	# 报错 ：ValueError: substring not found

6、数据结构 list()：创建列表。将任何可迭代序列转换为列表类型，并返回转换后的列表。

函数说明list(object)

• object：待转换为列表的数据类型。object可省略，若参数为空，则创建一个空列表。

备注1：参数必须是可迭代序列对象，否则系统报错。
备注2：将字典转换为列表时，默认只输出key，而舍去value。若想将字典的值转换为列表，可以使用dict.values()、默认dict.keys()

# （1）创建一个空列表
test1 = list()
print(test1)                            # 【输出结果】[]
#################################################################
# （2）将字符串转换为列表
test2 = list('cat')
print(test2)                            # 【输出结果】['c', 'a', 't']
#################################################################
# （3）将元组转换为列表
test3 = list(('I love Python.', 'I also love HTML.'))
print(test3)                            # 【输出结果】['I love Python.', 'I also love HTML.']
#################################################################
# （4）将字典转换为列表
test4 = list({'China': 'Beijing', 'Russia': 'Moscow'})
test44 = list({'China': 'Beijing', 'Russia': 'Moscow'}.keys())      
test444 = list({'China': 'Beijing', 'Russia': 'Moscow'}.values())
print(test4)                            # 【输出结果】['China', 'Russia']
print(test44)                           # 【输出结果】['China', 'Russia']
print(test444)                          # 【输出结果】['Beijing', 'Moscow']
#################################################################
# （5）将集合转换为列表
test5 = list({1, 4, 'sdf'})
print(test5)                            # 【输出结果】[1, 4, 'sdf']
#################################################################
# （6）将列表转换为列表
test6 = list(["a", "b", "c", "d"])
print(test6)                            # 【输出结果】['a', 'b', 'c', 'd']
#################################################################
# （7）将可迭代序列（range类型）转换为列表
test7 = list(range(10))
print(test7)                            # 【输出结果】[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#################################################################
# （8）将可迭代序列（map类型）转换为列表
test8 = list(map(int, [23.2, 33.1]))
print(test8)                            # 【输出结果】[23, 33]

（1）list.index() ：用于找出某个值在列表中第一个匹配项的索引位置。若没有找到对象，则系统报错。

函数说明list.index(obj)

• object：待查找的对象。

A = [123, 'xyz', 'zara', 'abc']
print(A.index('xyz'))  	# 结果 1
print(A.index('zzz'))  	# 报错 ：ValueError: 'zzz' is not in list

7、数据结构 set() ：创建集合。其表示一个无序不重复元素的序列。

【Python】集合set的使用详解

无序：无论序列中的元素在赋值给变量之前是什么顺序，赋值后各元素位置都将会随机显示。
不重复：对序列中的重复元素，赋值给变量后系统会自动去除重复元素，只保留一个。

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
  备注1：不可变就是变量赋值 / 定义后不可改变，但可以通过拼接操作符等的方式改变。
  备注2：【列表、元组和字符串】都属于序列。

集合的创建方法：

• （1）创建空集：set()
• （2）创建集合：set((A,B))
• （3）创建集合：{}
• 备注1：创建空集合必须用 set() 而不能是 { }，因为 { } 是用来表示空字典类型的。
• 备注1：set() 对字符串也会去重，因为字符串属于序列。

# （1）创建空集：set()
person1 = set()         # 空集合
print(len(person1))     # 【输出结果】0
print(person1)          # 【输出结果】set()

# （2）创建集合：set((A,B))
person2 = set(("student", "teacher", "babe", 123, 321, 123))
print(len(person2))     # 【输出结果】5
print(person2)          # 【输出结果】{321, 'teacher', 'babe', 123, 'student'}

# （3）创建集合：{}
person = {"student", "teacher", "babe", 123, 321, 123}
print(len(person))      # 【输出结果】5
print(person)           # 【输出结果】{'student', 321, 'teacher', 123, 'babe'}

# 字符串去重
str1 = set("abcde")
str2 = set("abcd")
print(str1, str2)                                    	# 【输出结果】{'b', 'c', 'a', 'd', 'e'} {'b', 'c', 'd', 'a'}
print(str1 - str2)      # set()之间可以使用减号运算     	# 【输出结果】{'e'}
print(str2-str1)        # 空值                        	# 【输出结果】set()
# print(str1+str2)      # set()之间不能使用加号运算

（1）set.add() ：用于向集合中添加元素。

函数说明集合名.add(添加的元素)

• （1）添加的元素只能是不可变数据类型，因此不能向集合中添加列表、元组、集合。
• （2）如果添加的元素已经存在集合中，则不执行添加操作，程序也不会报错。因为集合是一个无序不重复元素的序列。
• （3）每次只能添加一个元素，否则系统报错。

set_city = {'北京', '上海', '广州'}
print('添加前的集合：', set_city)      # 【输出结果】添加前的集合： {'上海', '北京', '广州'}

set_city.add('重庆')
print('添加后的集合：', set_city)      # 【输出结果】添加后的集合： {'上海', '北京', '重庆', '广州'}

set_city.add('上海')
print('添加后的集合：', set_city)      # 【输出结果】添加后的集合： {'上海', '北京', '重庆', '广州'}

8、数据结构 dict() ：创建字典（键值对）。字典的key是不可变数据类型，而value的数据类型可以任意。

两种创建字典的方法：
（1）dict_temp1 = {key1: value1, key2: value1, key3: value1}
（2）dict_temp2 = dict({key1: value1}) 或 dict(key1=x, value1=10)

• 不可变数据类型： 元组，布尔类型（bool），整型（int）、字符串（str）
• 可变数据类型： 字典（dict）、列表（list）、集合（set）

备注1：字典是一个无序的数据集合，即输出的顺序和定义的顺序是不一致的。
备注2：字典不支持索引号索引，不支持切片，重复和连接无意义。
备注3：for循环（默认循环遍历字典的key值）。
备注4：成员操作符(默认判断key值是否存在)

11、方法1的使用案例：{}

print('dict0:', {})                                   # 1、传入一个空字典
print('dict1:', {'name': 'li', 'age': 24})            # 2、传入一个字典

'''
dict0: {}
dict1: {'name': 'li', 'age': 24}
'''

22、方法2的使用案例：dict()

print('dict0:', dict())                                     # 1、传入一个空字典
print('dict1:', dict({'name': 'li', 'age': 24}))            # 2、传入一个字典
print('dict2:', dict(user='admin', password=123456))        # 3、传入关键字
print('dict3:', dict([('student', 1), ('teacher', 2)]))     # 4、传入一个包含一个或多个元组的列表
print('dict4:', dict(zip(['a', 'A'], [3, 4])))              # 5、传入一个zip()函数

'''
dict0: {}
dict1: {'name': 'li', 'age': 24}
dict2: {'user': 'admin', 'password': 123456}
dict3: {'student': 1, 'teacher': 2}
dict4: {'a': 3, 'A': 4}
'''

33、查看字典的元素：dict1.keys、dict1.values、dict1.items、dict1.get

dict1 = {'http': 80, 'ftp': 21, 'ssh': 22, 1: 22}
print('查看字典里面所有的key值: ', dict1.keys())
print('查看字典里面所有的value值: ', dict1.values())
print('查看字典里面所有的key-value值: ', dict1.items())

print('查看指定key对应的value值: ', dict1['ftp'])                # 若key值不存在,程序会报错
print('get方法获取指定key对应的value值: ', dict1.get('ftp'))      # 若key值不存在,返回None

'''
查看字典里面所有的key值:  dict_keys(['http', 'ftp', 'ssh', 1])
查看字典里面所有的value值:  dict_values([80, 21, 22, 22])
查看字典里面所有的key-value值:  dict_items([('http', 80), ('ftp', 21), ('ssh', 22), (1, 22)])
查看指定key对应的value值:  21
get方法获取指定key对应的value值:  21
'''

44、添加字典中的元素：updata()、setdefault()

• 如果key值存在，更新value值
• 如果key值不存在，添加key-value值

dict1 = {'http': 80, 'ftp': 21, 'ssh': 22}
dict1['http'] = 3
dict1['h'] = 3
print('如果key值存在，则更新对应的value值: ', dict1)
print('如果key值不存在，则添加对应的key-value值: ', dict1)

'''
如果key值存在，则更新对应的value值:  {'http': 3, 'ftp': 21, 'ssh': 22}
如果key值不存在，则添加对应的key-value值:  {'http': 3, 'ftp': 21, 'ssh': 22, 'h': 3}
'''

##############################################################
dict2 = {1: 88, 2: 66}
dict1.update(dict2)
print('updata()添加元素: ', dict1)
# updata()添加元素:  {'http': 3, 'ftp': 21, 'ssh': 22, 'h': 3, 1: 88, 2: 66}

##############################################################
dict1.setdefault(3, 99)
print('setdefault()添加元素: ', dict1)
# setdefault()添加元素:  {'http': 3, 'ftp': 21, 'ssh': 22, 'h': 3, 1: 88, 2: 66, 3: 99}

55、删除字典中的元素：del、pop()、popitem()、clear()

dict1 = {'http': 80, 'ftp': 21, 'ssh': 22, 1: 22}
#####################################################
del dict1['http']
print('del 删除指定的key-value值: ', dict1)
#####################################################
dict1.pop('ftp')
print('pop() 弹出指定的key-value值: ', dict1)
#####################################################
dict1.popitem()
print('popitem() 删除最后一个key-value: ', dict1)
#####################################################
dict1.clear()
print('clear() 清空字典内容: ', dict1)

'''
del 删除指定的key-value值:  {'ftp': 21, 'ssh': 22, 1: 22}
pop() 弹出指定的key-value值:  {'ssh': 22, 1: 22}
popitem() 删除最后一个key-value:  {'ssh': 22}
clear() 清空字典内容:  {}
'''

66、for循环（默认循环遍历字典的key值）

for key in dict1:
    print('for循环：', key)
'''
for循环： http
for循环： ftp
for循环： ssh
for循环： h
'''    

（1）dict.get()：返回指定字典中键的值。若键不在字典中，则返回默认值None。

函数说明：dict.get(key, default=None)
输入参数:

• key：字典中要查找的键。
• default：如果指定键的值不存在时，返回该默认值。

dict1 = {'国家': '中国', '首都': '北京'}
print(dict1.get('国家'))
print(dict1.get('首都'))
print(dict1.get('省会'))

print(dict1.get('省', 0))

'''
中国
北京
None
0
'''

【】range() ：输出指定范围内的所有值（前闭后开）。

函数说明：range(start=0，stop，step=1)
输入参数：

• start：序列的起始点，默认值0。
• stop：序列的终止点。
• step：滑动步长，默认为1。正数表示迭代上升，负数表示迭代下降。

备注：前闭后开[A，B)，即可以取到A值，但取不到B值。

# （1）指定stop=9, start默认为0，step默认为1
for i in range(9):
    print('A =', i)
'''
A = 0
A = 1
A = 2
A = 3
A = 4
A = 5
A = 6
A = 7
A = 8
'''
# （2）指定start=2, stop=9, step默认为1
for i in range(2, 9):
    print('B =', i)
'''
B = 2
B = 3
B = 4
B = 5
B = 6
B = 7
B = 8
'''
# （3）指定start=2, stop=9, step=-2
for i in range(9, 2, -2):
    print('C =', i)
'''
C = 9
C = 7
C = 5
C = 3
'''

【】len()：返回字符串、列表、字典、元组等长度。

str_temp = "Hello, boy !"
print(len(str_temp))                    # 【输出结果】12
#############################################
list_temp = ['h', 'e', 'l', 'l', 'o']
print(len(list_temp))                   # 【输出结果】5
#############################################
dict_temp = {'num': 520, 'name': "do do"}
print(len(dict_temp))                   # 【输出结果】2
#############################################
tuple_temp = ('G', 'o', 'o', 'd')
print(len(tuple_temp))                  # 【输出结果】4

【】sorted() ：对所有可迭代类型进行排序。不改变原始序列，返回排序后的新序列。

函数说明：sorted(iterable, key=None, reverse=False)
输入参数：

• iterable：可迭代的对象（如：字典、列表）。
• key：可迭代类型中某个属性，对指定函数进行排序。默认=None
• reverse：升序reverse=False（默认）或降序reverse=Ture。

备注：字符串按照ASCII的大小进行排序。默认先排序大写字母，后排序小写字母。

lst1 = (5, 4, 3, -2, 1)
L1 = sorted(lst1)                       # 【输出结果】[-2, 1, 3, 4, 5]
L2 = sorted(lst1, key=abs)              # 【输出结果】[1, -2, 3, 4, 5]
L3 = sorted(lst1, reverse=True)         # 【输出结果】[5, 4, 3, 1, -2]
print(L1)
print(L2)
print(L3)
###################################################################################
lst2 = ('F', 'D', 'Y', 'e', 'a', 'v')
L4 = sorted(lst2)                       # 【输出结果】['D', 'F', 'Y', 'a', 'e', 'v']
L5 = sorted(lst2, key=str.lower)        # 【输出结果】['a', 'D', 'e', 'F', 'v', 'Y']
print(L4)
print(L5)

【】math.sqrt()：开根号运算（四种方法）。

方法一

函数说明：math.sqrt(数字)

import math

x = math.sqrt(int(input('数字:')))      # 数字:50
print(x)                                # 7.0710678118654755
print(type(x)) 	                        # <class 'float'>

方法二

函数说明：cmath.sqrt(数字)

import cmath

x = cmath.sqrt(int(input('数字:')))         # 数字:50
print(x)                                    # (7.0710678118654755+0j)
print(type(x))                              # <class 'complex'>

方法三

函数说明：pow(数字，次方)

x = pow(int(input('数字:')), 0.5)        # 数字:50
print(x)                                # 7.0710678118654755
print(type(x))                          # <class 'float'>

方法四

函数说明：数字**0.5

x = int(input('数字:'))**0.5         	# 数字:50
print(x)                                # 7.0710678118654755
print(type(x))                          # <class 'float'>

【】map()：据提供的函数对指定序列做映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。

函数说明：map(function, iterable, ...)
输入参数：

• function：自定义函数。
• iterable - - - ：一个或多个序列

print('将元组转换为list（返回一个迭代器）: ', map(int, (1, 2, 3)))
print('将元组转换为list（使用list()转换为列表）: ', list(map(int, (1, 2, 3))))
print('将字符串转换为list: ', list(map(int, '1234')))
print('将字典中的key转换为list: ', list(map(int, {1: 2, 2: 3, 3: 4})))
'''
将元组转换为list（返回一个迭代器）:  <map object at 0x0000018507A34130>
将元组转换为list（使用list()转换为列表）:  [1, 2, 3]
将字符串转换为list:  [1, 2, 3, 4]
将字典中的key转换为list:  [1, 2, 3]
'''

---

文献参考

02.Python3 内置函数（大全）
01.Python3 操作符（大全）
0.【Python】函数带括号和不带括号的区别
1.【Python】strip()方法使用
2.【Python】strip()、lstrip()、rstrip()方法使用
3.【Python】split()函数介绍
4.【Python】len()函数
5.【Python】encode()函数
6.【Python】decode()与encode()详解
7.【Python】字符串常用方法大全
8.【Python】集合set的使用详解
9.【Python】int() 用法详解
10.【Python】range函数
11.【Python】add()方法
12.【Python】sorted()函数用法
13.【Python】list()函数
14.【Python】字符串对齐方法（ljust()、rjust()和center()）详解
15.【Python】开根号的几种方式
16.【Python】str()函数
17.【Python】float()函数
18.【Python】map()函数
19.【Python】get()用法
20.【Python】dict()用法
21.【Python】str.join()函数的用法
22.【Python】list.index() 方法详解
23.【Python】str.index()函数