Python常用内置函数（全）

文章目录

• 一、函数带括号与不带括号的区别
• 二、Python的数据类型、数据结构
• 三、不可变数据类型、可变数据类型
• 四、有序序列、无序序列、可迭代序列
• 五、可迭代对象（iterable）、迭代器（iterator）、生成器（yield）
• 六、Python3 常见运算符（算术运算符、关系运算符、逻辑运算符、位运算符、成员运算符、身份运算符）
• • （1）算术运算符
• 七、Python3 函数
• • < 1 > 数据结构：列表、元祖、集合、字典、链表
  • • 1、list列表的常用操作（15+9函数）—— 列表是一个有序可变序列。
    • 2、tuple元组的常用操作（7+9函数）—— 元组是一个有序不可变序列。
    • 3、set集合的常用操作（7+4函数）—— 集合是一个不重复元素的无序可变序列。
    • 4、dict字典的常用操作（14+4函数）—— 字典是一个无序可变序列。
    • 5、链表的常用操作（8个函数）—— 链表是一个非连续存储的线性表（节点 = 数据域 + 指针域）。
  • < 2 > 数据类型：数值类型 + 字符串
  • • 2.1、数值类型（包括：整型、浮点型、复数类型、布尔类型）
    •   2.1.1、整型int() ：将指定进制（默认十进制）的一个字符串或数字（向下取整）转换为十进制整型（强转）。
    •   1.1、bin()：十进制整数转换为二进制码。返回值为字符串。
    •   1.2、ord()： ASCII字符转换为十进制整数（Unicode字符 —— Unicode数值）。
    •   1.3、chr()：将10进制或16进制数转换为ASCII字符。（Unicode数值 —— Unicode字符）。
    •   2.1.2、浮点型float() ：将数字、字符串或布尔值转化为浮点数（强转） —— 只支持十进制输入和输出。
    •   2.1.3、复数complex()：将数字、字符串或布尔值转化为复数类型（强转）。
    • 2.2、字符串str() ：将参数转换成字符串类型（强转）—— 字符串是有序不可变序列。
  • 【字符串的常用函数】
  • • 1.1、str.join()：将序列（字符串、元组、列表、字典）中的元素以指定字符连接，并返回一个新的字符串。
    • 1.2、str.split()：通过指定分隔符（默认为空格）对字符串进行切片，并返回分割后的字符串列表（list）。
    • 1.3、str.count()：统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。
    • 1.4、str.strip()：删除字符串（开头 / 结尾）指定字符（默认空格）或字符序列，但不能删除中间部分的字符。
    • 1.5、str.lstrip()：删除字符串左边指定字符（默认空格）。
    • 1.6、str.rstrip()：删除字符串右边指定字符（默认空格）。
    • 1.7、str.upper()：将字符串中所有小写字母转换为大写字母。若存在非字母字符，则正常显示。
    • 1.8、str.lower()：将字符串中所有大写字母转换为小写字母。若存在非字母字符，则正常显示。
    • 1.9、str.title()：将字符串中所有英文单词的首字母转换为大写，其余转字母换为小写。若存在非字母字符，则正常显示。
    • 1.10、str.ljust()：左对齐文本。向指定字符串的右侧填充指定字符。
    • 1.11、str.rjust()：右对齐文本。向指定字符串的左侧填充指定字符。
    • 1.12、str.center()：居中对齐文本。
    • 1.13、str.find()：查找字符串中，指定子串在指定范围内第一次出现的位置。若无，则返回-1。
    • 1.14、str.rfind()：查找字符串中，指定子串在指定范围内最后一次出现的位置。若无，则返回-1。
    • 1.15、str.index()：检测指定范围内的字符串中是否包含子串。若无，则系统报错。
    • 1.16、str.replace()：将指定字符或子串替换为另一种字符。原字符串不改变。
    • 1.17、str.endswith()：判断字符串中（可指定范围）是否以指定字符或子串结尾。返回bool值。
  • 【字符串的判断函数】
  • • 1.1、str.isdigit()，str.isnumeric()，str.isdecimal()：检查字符串是否只包含十进制数字，返回布尔值。
    • 1.2、str.isupper()，str.islower()，str.istitle()：检测字符串的大小写，返回布尔值。
    • 1.3、str.isalpha()：检测字符串是否只有字母，返回布尔值。
    • 1.4、str.isalnum()：检测字符串是否只有字母和数字，返回布尔值。
    • 1.5、str.isspace()：判断字符串中是否只有空白字符（可以有多个空白字符），返回布尔值。
  • < 3 > 高阶函数：sorted + map + filter + reduce + lambda + enumerate + zip + iter + next
  • • 3.1、sorted() ：对所有可迭代类型进行排序，不改变原始序列。按照ASCII的大小进行排序（数字 >> 大写字母 >> 小写字母）。
    • 3.2、map()：将指定函数依次作用于序列中的每一个元素 —— 返回一个迭代器，结果需指定数据结构进行转换后输出。
    • 3.3、filter()：过滤序列。过滤掉不符合条件的元素 —— 返回一个迭代器，结果需指定数据结构进行转换后输出。
    • 3.4、reduce()：取序列的前2个元素，执行指定函数，然后将结果与第3个元素继续传入函数，循环到最后一个元素 —— 返回一个数值。
    • 3.5、匿名函数 – lambda：对输入参数进行表达式计算
    • 3.6、枚举函数 – enumerate()：输入可迭代对象，可同时获取对象的索引和值。与for循环一起使用。
    • 3.7、zip()：组合序列。将多个可迭代对象的第 i 个元素组合在一起（压缩），得到一个元祖，最后输出N个元组。—— 返回一个迭代器，结果需指定数据结构进行转换后输出。
    • 3.8、iter()：输入一个可迭代对象，将其转换成一个迭代器。与next() 或 for一起使用。
    • 3.9、next()：检索迭代器的下一个元素。若给定默认值，则在迭代器耗尽返回此默认值，否则会引发StopIteration。与 iter()、yield() 一起使用
  • < 4 > 通用函数
  • • 1、input()：获取控制台（任意形式）的输入。输出均为字符串类型。
    •   1.1、int(input()) 与 map(int, input().spilt()) 的区别
    •   1.2、input() 与 list(input()) 的区别、及其相互转换方法
    • 2、print() ：打印输出。
    • 3、range() ：输出指定范围内的所有值（前闭后开）。
    • 4、len()：返回字符串、列表、字典、元组等的长度。
    • 5、eval()：去掉字符串表达式的引号，并返回表达式的值。输入可以是任意类型，输出类型与输入等同。
  • < 5 > 数学函数 +随机数函数 + 三角函数 + 数学常量
  • • 1、数学函数
    •   1.1、round()：返回浮点数x的四舍五入值。可指定保留几位小数，只对浮点数有效。
    •   1.2、sum()：计算指定参数（默认0）与可迭代对象的和
    •   1.3、abs()与fabs()的区别（返回输入x的绝对值）
    •   1.4、开根号的四种运算方法
    • 2、随机数函数
    • 3、三角函数
    • 4、数字常量
• 文献参考

一、函数带括号与不带括号的区别

• （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

二、Python的数据类型、数据结构

数据类型：数值类型、字符串类型

• （1）数值类型：整型、浮点型、复数、布尔、空值

  • 整型(int)：也称整数，是正或负整数，不带小数点。
  • 浮点型(float)：由整数加小数组成，带小数点，可以使用科学记数法计数：3.14E2 = 3.14*10^2^ = 314。
  • 复数(complex)：由实部和虚部构成，可以用a + bj 或 complex(a. b)表示。
  • 布尔类型(bool)：两个值：True和False。整型的一种。True==1，False==0。
  • 空值(None)： 不支持任何运算，也没有任何内置函数方法。

• （2）字符串类型(str)：python中最常见的数据类型，使用（单 / 双）引号来创建字符串。Python只有字符串没有字符，字符是字符串的一种。

数据结构：列表list、元祖tuple、字典dict、集合set
（数据结构是计算机存储数据的方式）

三、不可变数据类型、可变数据类型

不可变：即变量的值定义后不可再次修改，但可以通过拼接等操作符改变。

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

四、有序序列、无序序列、可迭代序列

序列（sequence）：即可以存放多个值的连续内存空间。

• 序列是python中最基本的数据结构。
• 序列中每个元素都分配到一个数字，即它的位置或索引，默认从0开始。
• 一般来说，有序序列类型都支持索引，切片，相加，相乘，成员操作，确定序列长度、确定最大最小元素等。。

❤️ 有序序列：

• 字符串（有序不可变序列）
• 元组（有序不可变序列）
• 列表（有序可变序列）：
  • range类型list(range(10))
  • map类型list(map(int, [23.2, 33.1]))

❤️ 无序序列：

• 字典（无序可变序列）
• 集合（无序可变序列）

五、可迭代对象（iterable）、迭代器（iterator）、生成器（yield）

（1）可迭代对象不是迭代器。
（2）函数iter()将可迭代对象转为迭代器。
迭代器的对象通过调用 函数next() 并不断返回下一个数据，当迭代器耗尽，且未指定默认值时，将提示 StopIteration 异常。

• 如何判断对象为可迭代对象 or 迭代器

# 使用内置函数isinstance 判断，例如判断列表是否可迭代
from collections import Iterable, Iterator
print(isinstance([], Iterable))		# True
print(isinstance([], Iterator))		# False。因为list还没有被转为迭代器，仅是可迭代对象

python之迭代器和生成器全解

可迭代对象（iterable）：list、tuple、dict、set、str

• 可迭代对象是指存储了元素的一个容器对象，且容器中的元素可以通过 __ iter __ ( )方法迭代或 __ getitem __ ( )方法访问。
  • （1）__ iter __ ( )方法：可迭代对象。让对象可以用for … in obj遍历元素。
  • （2）__ getitem __ ( )方法：可访问对象。让对象可以用[index]访问元素。
• 可迭代对象是不能独立进行迭代。凡是可迭代对象都可以通过for循环访问。
  • 访问过程分两个步骤：一是调用 __ iter __ ( )获得一个可迭代器，二是循环调用 __ next __ ( ) 获得元素。

"""1、只实现__getitem__"""
class A:
    def __init__(self):
        self.data=[1,2,3]
 
    def __getitem__(self,index):
        return self.data[index]
a=A()
for i in a:
    print(i)		# 输出: 1、2、3
 
####################################
"""2、实现__getitem__和__iter__"""
class A:
    def __init__(self):
        self.data=[1,2,3]
        self.data1=[4,5,6]
    
    def __iter__(self):
        return iter(self.data1)    
 
    def __getitem__(self,index):
        return self.data[index]
 
a=A()
for i in a:
    print(i)		# 输出: 4、5、6

"""
（1）如果只实现__getitem__，for in 循环体会自动调用__getitem__函数；
		并自动从Index=0开始自增，并将对应索引位置的值赋值给 i，直到引发IndexError错误。
（2）如果实现__getitem__和__iter__，则会忽略__getitem__，只调用__iter__；
		并对__iter__返回的迭代器进行成员遍历，并自动将遍历的成员逐次赋值给 i，直到引发StopIteration。
"""

迭代器（iterator）：迭代器就是可以通过 next() 不断返回下一个值的对象，其本质是一个实现了支持__ iter __ ( )、__ next __ ( )或next()方法的对象。

• （0）所以，如果想创建一个迭代器，则需要定义一个类（自定义），并在该类中实现__iter__和__next__魔法函数。
• （1） __ next __ ( )方法或内置函数 next( )：可调用对象。逐个返回数据流中的元素。
• （2）但我们不能提前知道序列的长度，只有在需要返回下一个数据时它才会计算。
• （3）当迭代器耗尽，且未指定默认值时，将提示 StopIteration 异常。

class My_iter:
    # 初始化实例变量值，便于在__next__中使用
    def __init__(self):
        self.a=1
        
    # 该函数必须返回一个迭代器
    def __iter__(self):
        return self
    
    # 该值返回每次next调用，需要返回的下一个值。即实现数值推演算法
    def __next__(self):
        self.a += 1
        return self.a
        

it = My_iter()		# 实例化迭代器
print(next(it))
print(next(it))

生成器（yield）：生成器就是用关键字 yield 来返回值，函数被调用时会返回一个生成器对象。

• 生成器本质上还是一个迭代器。
• 生成器用关键字 yield 返回值，而普通函数用 return 返回值。
• 唯一的区别：实现方式不一样，yield更加简洁，没有冗长代码。

yield与return对比

相同点：

• （1）均在函数体内使用，并且向调用方返回结果
• （2）均可返回一个值或多个值，如果是多个值，则是以元组格式返回

不同点：

• （1）yield函数调用时，最终返回的是一个生成器。—— return函数调用时，最终返回的是一个值。
• （2）yield执行并返回值后，不会退出函数体，而是挂起，待下次next()调用时，再从挂起点恢复运行。—— return 执行并返回值后，便会直接退出函数体，且释放函数的内存空间。
• （4）yield语句可以接受通过生成器 send 方法传入的参数并赋值给一个变量，以动态调整生成器的行为表现。
• （5）yield语句的返回值，可以通过关键词 from 指定 返回源。

return在生成器中的作用：
在一个生成器函数中，如果没有 return，则默认执行至函数完毕；
如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。

def generator(a, b):
	yield a+b


g = generator(1, 2)		# 实例化生成器
print(next(g, 00))		# 调用生成器：3

print(generator)		# 函数对象：<function generator at 0x00000214BC9BF0D0>
print(g)				# 生成器对象：<generator object generator at 0x00000214BC9CCEB0>

yield与return对比（代码演示）

# 1、yield和return共存
def gene1(maxcount):
    a, b = 0, 1
    count = 1
    while True:
        if count > maxcount:
            # 直接退出函数体
            return 
        else:
            # 返回值后，函数在该处挂起，下次再从该处恢复运行
            yield a+b
            a, b = b, a+b
            count += 1
############################################################
# 2、yield接受通过send传入的参数并动态调整生成器行为
def gene2(maxcount):
    a, b = 0, 1
    count = 1
    while True:
        if count>maxcount:
            return 
        else:
            msg = yield a+b
            if msg == 'stop':
                return
            a, b = b, a+b
            count += 1
g = gene2(10)
next(g)
g.send('msg') 	# 生成器终止，并抛出一个StopIteration异常
############################################################
# 3、通过from关键词，接受另外一个生成器，并通过该生成器返回值
ge = (i for i in range(10))
def gene3(gene):
    yield from gene
g = gene3(ge)

六、Python3 常见运算符（算术运算符、关系运算符、逻辑运算符、位运算符、成员运算符、身份运算符）

Python3 常见运算符（算术运算符、关系运算符、逻辑运算符、位运算符、成员运算符、身份运算符

（1）算术运算符

七、Python3 函数

Python3 内置函数（大全）

< 1 > 数据结构：列表、元祖、集合、字典、链表

1、list列表的常用操作（15+9函数）—— 列表是一个有序可变序列。

一般来说，有序序列类型都支持索引，切片，相加，相乘，成员操作。

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

2、tuple元组的常用操作（7+9函数）—— 元组是一个有序不可变序列。

（1）Python 的元组与列表类似，不同之处在于元组的元素不能修改（不可变）。所谓元组不可变是指元组所指向的内存中的内容不可变。
（2）元组使用小括号 ( )，列表使用方括号 [ ]。
（3）一般来说，有序序列类型都支持索引，切片，相加，相乘，成员操作。
（4）元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。 如：整型：tup1 = (50) 、元组：tup1 = (50,)

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

3、set集合的常用操作（7+4函数）—— 集合是一个不重复元素的无序可变序列。

无序：赋值后，各元素位置将随机输出。
不重复：赋值变量时，若存在重复元素，系统会自动去除，只保留一个。

• set(str) 对字符串去重
• set(tuple)对元组去重
• set(list)对列表去重。
  备注：字符串、元祖、列表是有序序列。
  备注：无法对无序序列进行去重。

4、dict字典的常用操作（14+4函数）—— 字典是一个无序可变序列。

（2）键必须是唯一的（不可变数据类型），但值可以取任意数据类型。
（3）不支持索引、切片、重复和连接操作。

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

5、链表的常用操作（8个函数）—— 链表是一个非连续存储的线性表（节点 = 数据域 + 指针域）。

• 在C/C++中，通常采用指针+结构体来实现链表；而在Python中，则采用引用+类来实现链表。
• 常用的数据结构：数组、链表(一对一)、栈和队列、哈希表、树(一对多)、图(多对多)。列表与链表的对比

链表（Linked List）是一种线性表数据结构，使用一组任意的存储单元（不是进行连续存储的。），来存储一组具有相同类型的数据。

链表：由多个元素组成，每个元素都是一个对象，每个对象称为一个节点。每个节点包含两个部分：左边存储着自定义数据（数据域），右边存储着下一个节点的链接地址（指针域）。

• 通过各个节点之间的相互连接，最终串联成一个链表。

• （1）单链表：它的每个链节点指向下一个链节点。
• （2）双向链表（Doubly Linked List）：它的每个链节点中有两个指针，分别指向直接后继和直接前驱。
• （3）循环链表（Circular Linked List）：它的最后一个链节点指向第一个链节点，形成一个环。
  

链表的常见操作

具体代码：

class Node(object):
    """单链表的节点类，即 ListNode 类。定义了两个实例变量"""

    def __init__(self, elem):
        self.elem = elem
        self.next = None


class SingleLinkList(object):
    """单链表的链表类，即 LinkedList 类。定义了常用操作"""

    def __init__(self, node=None):
        self.__head = node

    def is_empty(self):
        """判断链表是否为空"""
        return self.__head is None

    def length(self):
        """链表长度"""
        cursor = self.__head
        count = 0
        while cursor is not None:
            count += 1
            cursor = cursor.next
        return count

    def travel(self):
        """遍历链表"""
        cursor = self.__head
        while cursor is not None:
            print(cursor.elem, end=' ')
            cursor = cursor.next

    def add(self, elem):
        """链表头部添加元素"""
        node = Node(elem)
        node.next = self.__head
        self.__head = node

    def append(self, elem):
        """链表尾部添加元素"""
        node = Node(elem)
        if self.is_empty():
            self.__head = node
        else:
            cursor = self.__head
            while cursor.next is not None:
                cursor = cursor.next
            cursor.next = node

    def insert(self, pos, elem):
        """在指定位置插入元素"""
        node = Node(elem)
        if pos <= 0:
            self.add(elem)
        elif pos > (self.length() - 1):
            self.append(elem)
        else:
            cursor = self.__head
            count = 0
            while count < pos - 1:
                count += 1
                cursor = cursor.next
            node.next = cursor.next
            cursor.next = node

    def remove(self, elem):
        """删除元素"""
        cursor = self.__head
        pre = None
        while cursor is not None:
            if cursor.elem == elem:
                if cursor == self.__head:
                    self.__head = cursor.next
                    break
                else:
                    pre.next = cursor.next
                    break
            else:
                pre = cursor
                cursor = cursor.next

    def search(self, elem):
        """查找元素"""
        cursor = self.__head
        while cursor is not None:
            if cursor.elem == elem:
                return True
            else:
                cursor = cursor.next
        else:
            return False


if __name__ == "__main__":
    link1 = SingleLinkList()
    print(link1.is_empty())
    print(link1.length())
    
    link1.append(1)
    link1.append(2)
    link1.add(6)
    link1.insert(1, 7)
    link1.insert(-1, 8)
    link1.travel()
    print()
    print(link1.travel())
    
    link1.remove(9)
    link1.travel()
    print()
    print(link1.travel())


"""
True
0
8 6 7 1 2
8 6 7 1 2 None
8 6 7 1 2
8 6 7 1 2 None
"""

< 2 > 数据类型：数值类型 + 字符串

2.1、数值类型（包括：整型、浮点型、复数类型、布尔类型）

  2.1.1、整型int() ：将指定进制（默认十进制）的一个字符串或数字（向下取整）转换为十进制整型（强转）。

import math

• 向上取整：math.ceil(5.1) == 6
• 向下取整：int(5.6) == 5、math.floor(5.6) == 5
• 四舍五入：round(5.6) == 6

• Python2 有 long int 类型，而Python3 整型没有范围限制，故可以当作 long int 使用。
• 布尔类型 bool 是整型的子类型，包括两种：True == 1、False == 0。

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

• x：字符串或数字（整数、浮点数）。
• base：默认十进制。
  备注1：若带参数base，表示将 （二进制、十进制、十六进制）的 x 转换为十进制。
  备注2：若带参数base，则输入必须是整数，且整数必须以字符串的形式进行输入。

十进制转换为16进制

十六进制范围：0 ~ 65536（0000 ~ FFFF）
方法：

• （1）十进制数除16（取余数1），得商1
• （2）商1除16（取余数2），得商2
• （3）商2除16（取余数3），得商3
• （4）最后商3等于0（取余数4）。
• 最终结果为倒序余数= [余数4, 余数3, 余数2, 余数1]。

举例（整数：65036）：
（1）65036 除 16，商4064，余数 12（十六进制C）
（2）4064 除 16，商254，余数 0（十六进制0）
（3）254 除 16，商15，余数 14（十六进制E）
（4）15除16，商0，余数 15（十六进制F）。
（5）结束：得16进制为 = FE0C

  1.1、bin()：十进制整数转换为二进制码。返回值为字符串。

函数说明：bin(整型)

print(bin(-3))
print(type(bin(-3)))

'''
-0b11
<class 'str'>
'''

  1.2、ord()： ASCII字符转换为十进制整数（Unicode字符 —— Unicode数值）。

函数说明：ord(字符)

print(ord('A'))
print(type(ord('A')))

'''
65
<class 'int'>
'''

  1.3、chr()：将10进制或16进制数转换为ASCII字符。（Unicode数值 —— Unicode字符）。

函数说明：chr(number)

print(chr(97))
print(type(chr(97)))

'''
a
<class 'str'>
'''

  2.1.2、浮点型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
'''

  2.1.3、复数complex()：将数字、字符串或布尔值转化为复数类型（强转）。

复数由实数和虚数构成，其实部a和虚部b都是浮点型。返回值是复数类型。
函数说明：a + bj 或 complex(a,b)

2.2、字符串str() ：将参数转换成字符串类型（强转）—— 字符串是有序不可变序列。

函数说明：str(x, base=10)
一般来说，有序序列类型都支持索引，切片，相加，相乘，成员操作。

print('返回空字符串:', str())
print('整数转换为字符串:', str(-23))
print('浮点数转换为字符串:', str(1.3e2))

print('返回空字符串:', type(str()))
print('整数转换为字符串:', type(str(-23)))
print('浮点数转换为字符串:', type(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

返回空字符串: <class 'str'>
整数转换为字符串: <class 'str'>
浮点数转换为字符串: <class 'str'>

列表转换为字符串: [12, '-23.1', 'Python']
元组转换为字符串: (23, '9we', -8.5)
字典转换为字符串: {'Huawei': 'China', 'Apple': 'USA'}
集合转换为字符串: {'China', 'UK', 'Japan'}
'''

【字符串的常用函数】

1.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))

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

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 !
字典:  I Love China !
'''

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

1.2、str.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']

1.3、str.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为默认参数

1.4、str.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'))        # 【输出结果】"3 ABCDEFG 321  "
print(str_temp3.strip('3'))         # 【输出结果】"123 ABCDEFG 321  "

1.5、str.lstrip()：删除字符串左边指定字符（默认空格）。

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

1.6、str.rstrip()：删除字符串右边指定字符（默认空格）。

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

1.7、str.upper()：将字符串中所有小写字母转换为大写字母。若存在非字母字符，则正常显示。

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

1.8、str.lower()：将字符串中所有大写字母转换为小写字母。若存在非字母字符，则正常显示。

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

1.9、str.title()：将字符串中所有英文单词的首字母转换为大写，其余转字母换为小写。若存在非字母字符，则正常显示。

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

1.10、str.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-------------

1.11、str.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

1.12、str.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-------

1.13、str.find()：查找字符串中，指定子串在指定范围内第一次出现的位置。若无，则返回-1。

函数说明：str.find(sub, start, end)
输入参数：

• sub：指定的子串
• start：索引的起始位置。默认值为0。
• end：索引的结束位置。默认值为字符串长度len(str)。

str1 = '123xyzzaraabc'
print(str1.find('z'))  	# 结果 5

1.14、str.rfind()：查找字符串中，指定子串在指定范围内最后一次出现的位置。若无，则返回-1。

函数说明：str.find(sub, start, end)
输入参数：

• sub：指定的子串
• start：索引的起始位置。默认值为0。
• end：索引的结束位置。默认值为字符串长度len(str)。

str1 = '123xyzzaraabc'
print(str1.rfind('z'))  	# 结果 6

1.15、str.index()：检测指定范围内的字符串中是否包含子串。若无，则系统报错。

函数说明：str.index(sub, start, end)
输入参数：

• sub：指定的子串
• start：索引的起始位置。默认值为0。
• end：索引的结束位置。默认值为字符串长度len(str)。

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

1.16、str.replace()：将指定字符或子串替换为另一种字符。原字符串不改变。

函数说明：str.replace('old_str', 'new_str', count)
输入参数：

• old_str：指定待替换的字符或子串
• new_str：替换的字符或子串
• count：替换的次数，默认全部替换。
  备注：当查看字符串时，发现原字符串并没有发生改变，说明str.replace()函数并不对原有的字符串进行改变。

str1 = '1112 QQQ QQQ 444 QQQ'
str1.replace('1', '5')				# 不改变原字符串		
print(str1)

str2 = str1.replace('1', '5')		# 默认全部替换
print(str2)

str3 = str1.replace('Q', 'g', 7)	# 指定替换次数
print(str3)

'''
1112 QQQ QQQ 444 QQQ
5552 QQQ QQQ 444 QQQ
1112 ggg ggg 444 gQQ
'''

1.17、str.endswith()：判断字符串中（可指定范围）是否以指定字符或子串结尾。返回bool值。

函数说明：str.endswith(suffix, start, end)
输入参数：

• suffix：后缀。可以是字符、字符串、元组（常用于判断文件类型）。
• start：索引字符串的起始位置。默认0。
• end：索引字符串的结束位置。默认字符串的长度。

备注：空字符的情况。返回值通常为True。

str = "i love python"
print("1:",str.endswith("")) 			# 空字符
print("2:",str.endswith("n")) 
print("3:",str.endswith("python"))
print("4:",str.endswith("n",0, 6))		# 索引 'i love' 是否以 'n' 结尾。
print("5:",str.endswith(("n","z")))		# 遍历元组，任意一个满足条件即返回True
print("6:",str.endswith(("k","m")))		# 遍历元组，任意一个满足条件即返回True
 
# 判断文件类型
file = "python.txt"
if file.endswith("txt"):					# 字符串类型
    print("该文件为文本。")
elif file.endswith(("AVI","WMV","RM")):		# 元祖类型
    print("该文件为视频。")
else:
    print("文件格式未知。")

'''
1: True
2: True
3: True
4: False
5: True
6: False
该文件为文本。
'''

【字符串的判断函数】

1.1、str.isdigit()，str.isnumeric()，str.isdecimal()：检查字符串是否只包含十进制数字，返回布尔值。

中文汉字和英文数字的unicode编码范围

str = '123'
print(str.isdecimal())  	
print(str.isdigit())  	
print(str.isnumeric())  

'''
True
True
True
'''

1.2、str.isupper()，str.islower()，str.istitle()：检测字符串的大小写，返回布尔值。

• （1）str.isupper()：判断字符串中，含有字母的部分是否全大写。
• （2）str.islower()：判断字符串中，含有字母的部分是否全小写。
• （3）str.istitle()：检测字符串中，所有单词拼写的首字母是否为大写，且其他字母为小写。

str = '123aaa'
print(str.islower())  	
print(str.isupper())  	

str = 'This Is All'
print(str.istitle())  
str = 'This Is ALL'
print(str.istitle())  

'''
True
False
True
False
'''

1.3、str.isalpha()：检测字符串是否只有字母，返回布尔值。

str = '12 aaAA'
print(str.isalpha())  	

str = ' aaAA'
print(str.isalpha())  
	
str = 'aaAA'
print(str.isalpha())  	

'''
False
False
True
'''

1.4、str.isalnum()：检测字符串是否只有字母和数字，返回布尔值。

str = '12aaAA'
print(str.isalnum())  	

str = '12aa AA'
print(str.isalnum())  

'''
True
False
'''

1.5、str.isspace()：判断字符串中是否只有空白字符（可以有多个空白字符），返回布尔值。

str = ' 123aaa'
print(str.isspace())  	

str = ' '
print(str.isspace())  
	
str = '   '
print(str.isspace())  	

'''
False
True
True
'''

< 3 > 高阶函数：sorted + map + filter + reduce + lambda + enumerate + zip + iter + next

3.1、sorted() ：对所有可迭代类型进行排序，不改变原始序列。按照ASCII的大小进行排序（数字 >> 大写字母 >> 小写字母）。

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

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

备注：字符串按照ASCII的大小进行排序。默认先排序数字（0 ~ 9），再排序大写字母（A ~ Z），后排序小写字母（a ~ z）。

lst1 = (5, 4, 3, -2, 1)
L1 = sorted(lst1)                       
L2 = sorted(lst1, key=abs)              
L3 = sorted(lst1, reverse=True)         
print(L1)			# 【输出结果】[-2, 1, 3, 4, 5]
print(L2)			# 【输出结果】[1, -2, 3, 4, 5]				
print(L3)			# 【输出结果】[5, 4, 3, 1, -2]
###################################################################################
lst2 = ('F', 'D', 'Y', 'e', 'a', 'v', '9', '6')
L4 = sorted(lst2)                       
L5 = sorted(lst2, key=str.lower)		# 对指定函数进行排序（将所有字母转换为小写，然后排序。不改变原字符串。）
print(L4)			# 【输出结果】['6', '9', 'D', 'F', 'Y', 'a', 'e', 'v']
print(L5)			# 【输出结果】['6', '9', 'e', 'F', 'v', 'Y']

3.2、map()：将指定函数依次作用于序列中的每一个元素 —— 返回一个迭代器，结果需指定数据结构进行转换后输出。

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

• function：指定函数。
• iterable：可迭代对象

print('返回一个迭代器: ', map(int, (1, 2, 3)))
# 返回一个迭代器:  <map object at 0x0000018507A34130>

结果需指定数据结构进行转换后输出

• 数据结构：list、tuple、set。可转换后输出结果
• 数据结构：str。返回一个迭代器
• 数据结构：dict。ValueError，需输入两个参数

print('将元组转换为list: ', list(map(int, (1, 2, 3))))
print('将字符串转换为list: ', tuple(map(int, '1234')))
print('将字典中的key转换为list: ', set(map(int, {1: 2, 2: 3, 3: 4})))

'''
将元组转换为list:  [1, 2, 3]
将字符串转换为list:  (1, 2, 3)
将字典中的key转换为list:  {1, 2, 3}
'''

################################################################################
dict_a = [{'name': 'python', 'points': 10}, {'name': 'java', 'points': 8}]
print(list(map(lambda x : x['name'] == 'python', dict_a)))
print(dict(map(lambda x : x['name'] == 'python', dict_a)))

"""
[True, False]
TypeError: cannot convert dictionary update sequence element #0 to a sequence
"""

3.3、filter()：过滤序列。过滤掉不符合条件的元素 —— 返回一个迭代器，结果需指定数据结构进行转换后输出。

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

• function：判断函数
• iterable：可迭代对象

函数功能：将序列中的每个元素循环传递给判断函数，并返回结果为True的元素组合成的新列表。

print('返回一个迭代器: ', filter(lambda x: x, list_num))
# 返回一个迭代器:  <filter object at 0x000002144BFB3130>

结果需指定数据结构进行转换后输出

• 数据结构：list、tuple、set。可转换后输出结果
• 数据结构：str。返回一个迭代器
• 数据结构：dict。需输入两个参数，否则系统报错：ValueError

list_num = [1, 2, 3, 0, 8, 0, 3]
print(list(filter(lambda x: x, list_num)))					# 过滤：数字0

list_word = ['a', 'B', 'c', 'd', 'E']
print(tuple(filter(lambda x: x.isupper(), list_word)))		# 过滤：小写字母
print(set(filter(lambda x: x.islower(), list_word)))		# 过滤：大写字母
"""
[1, 2, 3, 8, 3]
('B', 'E')
{'c', 'd', 'a'}
"""

################################################################################
dict_a = [{'name': 'python', 'points': 10}, {'name': 'java', 'points': 8}]
print(list(filter(lambda x : x['name'] == 'python', dict_a)))
print(dict(filter(lambda x : x['name'] == 'python', dict_a)))

"""
[{'name': 'python', 'points': 10}]
{'name': 'points'}
"""

3.4、reduce()：取序列的前2个元素，执行指定函数，然后将结果与第3个元素继续传入函数，循环到最后一个元素 —— 返回一个数值。

reduce函数在python2中是个内置函数，但在python3中已被移到functools模块。

函数说明：reduce(function, iterable, initializer)
输入参数：

• function：指定函数（输入为两个元素）
• iterable：可迭代对象
• initializer：初始参数（可选），即指定第一个元素的值，然后与序列的第一个元素执行指定函数。

# 常与匿名函数lambda同时使用
from functools import reduce

print(reduce(lambda x,y: x+y, [1,2,3]))
print(reduce(lambda x,y: x+y, [1,2,3], 10))					# 表达式：取和
print(reduce(lambda x,y: x if x < y else y, [1,2,3]))		# 表达式：取最小值

"""
6
16
1
"""

性能对比：reduce相较于for循环，结构更简洁，但运行速度更慢。

from functools import reduce
import time


def test_for(arr):
    out = arr[0]
    for i in arr[1:]:
        out += i
    return out


def test_reduce(arr):
    out = reduce(lambda x, y: x + y, arr)
    return out


a = [i for i in range(100000)]
t1 = time.perf_counter()		# 起始时间
print(test_for(a))

t2 = time.perf_counter()		# for循环运行时间
print(test_reduce(a))

t3 = time.perf_counter()		# reduce运行时间
print('for循环耗时:', (t2 - t1))
print('reduce耗时:', (t3 - t2))


"""
4999950000
4999950000

for循环耗时： 0.0089341
reduce循环耗时： 0.0122448
"""

3.5、匿名函数 – lambda：对输入参数进行表达式计算

函数说明1：函数名 = lambda argument_list: expression
函数说明2：函数名 = lambda 参数: 表达式（更容易理解，固定语法）
输入参数：

• lambda：Python关键字
• argument_list：（输入）参数列表，即输入可以是多个参数。
• expression：变量表达式。只能是单行，而def可以有多个。
• 返回值：变量表达式的计算结果即为lambda函数的返回值。

特点1：匿名函数，即没有名字的函数。Python中的lambda
特点2：功能简单：只能单行expression决定了lambda函数不可能完成复杂的逻辑，甚至不需要专门的名字来说明。

❤️ 常用实例

a0 = lambda x: 1 if x > 10 else 0		# 判断输入参数的大小，大于取1，小于取0
a1 = lambda x, y: x*y					# 函数输入是x和y，输出是它们的积x*y
a2 = lambda : None						# 函数没有输入参数，输出是None
a3 = lambda *args: sum(args)			# 输入是任意个数的参数，输出是它们的和(隐性要求是输入参数必须能够进行加法运算)
a4 = lambda **kwargs: 1					# 输入是任意键值对参数，输出是1

print(a0(2))
print(a1(2, 3))
print(a2())
print(a3(2, 3, 4))
print(a4())

"""
0
6
None
9
1
"""

❤️ 四个用法

（1）将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。

• 如：add0 = lambda x, y: x+y，返回两个变量的和。与add(1,2)==3等效。

（2）将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。

• 如：time.sleep = lambda x: None。返回None，即调用标准库time中的sleep函数不执行。

（3）将lambda函数作为其他函数的返回值，返回给调用者。

• 如：return lambda x, y: x+y，返回一个加法函数。此时lambda函数实际上是定义在某个函数内部的函数，称为嵌套函数或内部函数。

（4）将lambda函数作为参数传递给其他函数。如：sorted()、filter()、map()、reduce()。

• 11、sorted()：此时lambda函数用于对列表中所有元素进行排序。

  • 如：sorted([1, 2, 3, 4, 5], key=lambda x: abs(3-x))。
    将列表[1, 2, 3, 4, 5]中元素与3的距离，从小到大进行排序，其结果是列表：[3, 2, 4, 1, 5]。

• 22、filter()：此时lambda函数用于过滤列表元素。

  • 如：list(filter(lambda x: x%3==0, [1, 2, 3]))。
    将列表[1,2,3]中能够被3整除的元素过滤出来，其结果是列表：[3]。

• 33、map()：此时lambda函数用于对列表中每一个元素的共同操作。

  • 如：list(map(lambda x: x+1, [1, 2, 3]))。
    将列表[1, 2, 3]中的元素分别加1，其结果是列表：[2, 3, 4]。

• 44、reduce()：此时lambda函数用于列表中两两相邻元素的结合。

  • from functools import reduce
  • reduce(lambda a, b: a+b, [1, 2, 3, 4])。
    将列表[1, 2, 3, 4]中的元素，从左往右取出2个元素并执行指定函数，然后将输出结果与第3个元素传入指定函数，…，循环到最后一个元素。其结果是整型：10。
    备注：reduce函数原本在python2中也是个内置函数，不过在python3中被移到functools模块中。

3.6、枚举函数 – enumerate()：输入可迭代对象，可同时获取对象的索引和值。与for循环一起使用。

函数说明：index, value = enumerate(iteration, start)
输入参数：

• iteration：可迭代对象。
• start：自定义起始索引值，可选参数，默认为0。
  备注：指定起始点，改变的只是可迭代对象中每个元素对应的索引的变化。即无论是否指定起始点，可迭代对象都是从第一个元素读取。

输出参数：

• index：索引值。
• value：可迭代对象中索引对应的元素值。
  特点1：匿名函数，即没有名字的函数。

list1 = [1,2,3,4,5,6]
for index, value in enumerate(list1):			# 默认起始点
    print(indx, value)
########################################
print('*'*10)
########################################
for indx, value in enumerate(list1, 2):			# 指定起始点
    print(indx, value)

"""
0 1
1 2
2 3
**********
5 1
6 2
7 3
"""

3.7、zip()：组合序列。将多个可迭代对象的第 i 个元素组合在一起（压缩），得到一个元祖，最后输出N个元组。—— 返回一个迭代器，结果需指定数据结构进行转换后输出。

函数说明：res = zip(iterable_1, iterable_2,..., iterable_n)
输入参数：

• iteration：n个可迭代对象。
• res：返回一系列元组的迭代器，第 i 个元组包含各输入iterables的第 i 个元素。

解压缩：unzip（把组合序列进行反向分解） —— python没有unzip函数
函数说明：zip(*res)
输入参数：

• *：表示解包运算符。
• res：由zip()生成的结果。

# （1）不传递参数，返回空的迭代器
print('1:', zip())									# <zip object at 0x00000205F02A3480>
print('1:', list(zip()))							# []
######################################################################
# （2）传递一个参数，返回tuple的迭代器。
print('2:', list(zip([1, 2, 3])))					# [(1,), (2,), (3,)]
######################################################################
# （3）传递两个参数，返回tuple的迭代器。
a3 = ['a', 'c', 'b']
b3 = ['2', '1']
print('3:', list(zip(a3, b3)))						# [('a', '2'), ('c', '1')]
print('3:', dict(zip(a3, b3)))						# {'a': '2', 'c': '1'}
######################################################################
# 4.1、传递长度不等的参数（截取最短，删除冗余）
print('4:', list(zip(range(3), range(100))))		# [(0, 0), (1, 1), (2, 2)]

# 4.2、传递长度不等的参数，若想要以最长的进行迭代处理，缺少部分补None
import itertools as it
fruits = ['apple', 'banana', 'melon', 'strawberry']
prices = [10, 20, 30]
print(list(it.zip_longest(fruits, prices)))			# [('apple', 10), ('banana', 20), ('melon', 30), ('strawberry', None)]
######################################################################
# （5）并行排序（以第一个输入参数进行排序）
print('5:', sorted(list(zip(a3, b3))))				# [('a', '2'), ('c', '1')]
print('5:', sorted(list(zip(b3, a3))))				# [('1', 'c'), ('2', 'a')]
######################################################################
# （6）解压缩序列：解包运算符*。
result = zip(a3, b3)
origin = list(zip(*result))		# 创建两个不同的元祖（数字和字母）
print('6:', origin[0])								# ('a', 'c')
print('6:', origin[1])								# ('2', '1')
######################################################################
# （7）将数据成对进行计算
total_sales = [52000.00, 51000.00, 48000.00]
prod_cost = [46800.00, 45900.00, 43200.00]
for sales, costs in zip(total_sales, prod_cost):
	profit = sales - costs
	print(f'Total profit: {profit}')
	
"""
Total profit: 5200.0
Total profit: 5100.0
Total profit: 4800.0
"""

3.8、iter()：输入一个可迭代对象，将其转换成一个迭代器。与next() 或 for一起使用。

• （1）__ iter __ ( )方法：可迭代对象。让对象可以用for … in obj遍历元素。
• （2）__ getitem __ ( )方法：可访问对象。让对象可以用[index]访问元素。
• （3）__ next __ ( ) 或 next( )方法：可调用对象。逐个返回数据流中的元素。

函数说明：iter(object, sentinel)
输入参数：

• object：可迭代对象，但不一定可调用。若传入 sentinel 则必须是可调用对象。
  • 可迭代对象：支持迭代协议（即定义有 __ iter __ ( )函数），或者支持序列访问协议（即定义有 __ getitem __ ( )函数），否则会返回TypeError异常。
• sentinel（哨符, 又叫标记符）：（可选参数） 当枚举到的值等于sentinel时，则自动停止。且不会输出sentinel值。
  • 可调用对象（即定义有__ next __ ( ) 或支持 next( )方法）。

输出参数：返回迭代器对象

# 1、iter迭代器与next一起使用
a = [1, 2]
a_iter = iter(a)
print(a_iter)				# <list_iterator object at 0x00000259E484A340>
print(next(a_iter))			# 1
print(next(a_iter))			# 2
# print(next(a_iter))		# 迭代器耗尽，未指定默认值，提示 StopIteration 异常

###################################################################
# 2、iter迭代器与（自定义）函数一起使用
from random import randint
def d10():
    return randint(1, 10)


# 随机产生1~10之间的整数，遇到5就停止
for i in iter(d10, 5):
    print(i)

3.9、next()：检索迭代器的下一个元素。若给定默认值，则在迭代器耗尽返回此默认值，否则会引发StopIteration。与 iter()、yield() 一起使用

函数说明：next(iterator, default)
输入参数：

• iteration：迭代器（不是可迭代对象，可迭代对象不是迭代器）
• default：（可选参数）如果迭代器耗尽则返回此默认值。 如果没有给出此默认值，则抛出 StopIteration 异常。

输出参数：返回下一个输入行

a = [1, 2]
it = iter(a)
print(next(it))					# 1
print(next(it))					# 2
# print(next(it))				# 迭代器耗尽，未指定默认值，提示StopIteration 异常。
print(next(it, 5))				# 5
print(next(it, 5))				# 5
######################################################################
b = [1, 3, 5]
it = iter(b)
while True:
    try:
        x = next(it)
        print (x, end=" ")
    except StopIteration:		# 遇到StopIteration就退出循环
        break
"""
1 3 5
"""

< 4 > 通用函数

1、input()：获取控制台（任意形式）的输入。输出均为字符串类型。

str1 = input()
print(str1)
print('提示语句:', str1)
print(type(str1))

'''
asd123!#
提示语句: asd123!#
<class 'str'>
'''

  1.1、int(input()) 与 map(int, input().spilt()) 的区别

  1.2、input() 与 list(input()) 的区别、及其相互转换方法

• 相同点：两个方法都可以进行for循环迭代提取字符，提取后都为字符串类型。
• 不同点：str = list(input()) 将输入字符串转换为list类型，可以进行相关操作。如： str.append()

• 将列表转换为字符串：str_list = ['A', 'aA', 2.0, '', 1]

• 方法一：print(''.join(str))
• 方法二：print(''.join(map(str, str_list)))

备注：若list中包含数字，则不能直接转化成字符串，否则系统报错。

• 方法一：print(''.join([str(ii) for ii in str_list]))
• 方法二：print(''.join(map(str, str_list)))
  map()：根据给定函数对指定序列进行映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。

（1） 举例说明：若list中包含数字，则不能直接转化成字符串，否则系统报错。

str = ['25', 'd', 19, 10]
print(' '.join(str))

'''
Traceback (most recent call last):
 File "C:/Users/Administrator/Desktop/test.py", line 188, in <module>
   print(' '.join(str))
TypeError: sequence item 3: expected str instance, int found
'''

（2）举例说明：若list中包含数字，将list中的所有元素转换为字符串。

str_list = ['A', 'aA', 2.0, '', 1]
print(''.join(str(ii) for ii in str_list))
print(''.join([str(ii) for ii in str_list]))
print(''.join(map(str, str_list))) 		# map()：根据给定函数对指定序列进行映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。

'''
AaA2.01
AaA2.01
AaA2.01
'''

2、print() ：打印输出。

【Python】print()函数的用法

x, y = 1, 9
print('{},{}' .format(x, y))	# 打印方法一
print('*'*10)					# 打印分割符
print(x, ',', y)				# 打印方法二

'''
1,9
**********
1 , 9
'''

3、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
'''

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

函数说明：len(object)

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

5、eval()：去掉字符串表达式的引号，并返回表达式的值。输入可以是任意类型，输出类型与输入等同。

函数说明：eval(expression, globals, locals)
输入参数：

• expression：字符串表达式。输入可以是任意类型。
• globals：变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
• locals：变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

优先级：locals > globals > expression。若三个参数有相同的变量，则按照优先级进行赋值。

print(type(eval('1')))
print(type(eval('1.0')))
print(type(eval("'1'")))
print(type(eval('{1}')))
print(type(eval('[1,2]')))
print(type(eval('{2:2}')))
print(type(eval('(1,2)')))

"""
<class 'int'>
<class 'float'>
<class 'str'>
<class 'set'>
<class 'list'>
<class 'dict'>
<class 'tuple'>
"""
##########################
# （1）expression参数示例
a1 = 10
temp1 = eval("a1+1")			# a1=10
print(temp1)
print(type(temp1))
##########################
# （2）globals参数示例
a2 = 10
g = {'a2': 4}
temp2 = eval("a2+1", g)			# a2=4
print(temp2)
print(type(temp2))
##########################
# （3）locals参数示例
a3 = 10
b3 = 20
c3 = 30
g = {'a3': 6, 'b3': 8}
t = {'b3': 100, 'c3': 10}
temp3 = eval("a3+b3+c3", g, t)	# a3=6、b3=100、c3=10
print(temp3)
print(type(temp3))
##########################
"""
11
<class 'int'>
5
<class 'int'>
116
<class 'int'>
"""

< 5 > 数学函数 +随机数函数 + 三角函数 + 数学常量

Python标准库：import math（常量 + 数学函数 + 幂与对数 + 三角函数）

1、数学函数

  1.1、round()：返回浮点数x的四舍五入值。可指定保留几位小数，只对浮点数有效。

函数说明：round(x, n)
输入参数：

• x：浮点数。
• n：保留小数点的位数。
  备注：若为整数，则即使指定了保留小数点的位数，也直接输出整数。

四舍五入的规则：
（1）要求保留位数的后一位 <=4，则进位。如：round(5.214,2)，结果为5.21。
（2）要求保留位数的后一位 =5，且该位数后面没有数字，则不进位，如：round(5.215, 2)，结果为5.21。
（3）要求保留位数的后一位 =5，且该位数后面有数字，则进位，如：round(5.2151, 2)，结果为5.22。
（4）要求保留位数的后一位 >=6，则进位。如：round(5.216,2)，结果为5.22。

print(round(5, 2))			# 5				# 整数
print(round(5.214, 2))		# 5.21			# <=4，则进位
print(round(5.215, 2))		# 5.21			# =5，且该位数后面没有数字，则不进位
print(round(5.2151, 2))		# 5.22			# =5，且该位数后面有数字，则进位
print(round(5.216, 2))		# 5.22			# >=6，则进位

  1.2、sum()：计算指定参数（默认0）与可迭代对象的和

函数说明：sum(iterable, start)
输入参数：

• iterable：可迭代对象（如：列表、元组、集合）
• start：指定相加的参数，默认为0。

print(sum([1,2,3]))			# 6
print(sum((1,2,3)))			# 6
print(sum({1,2,3}))			# 6
print(sum(range(5)))		# 10
##########################
print(sum([1,2,3], 2))		# 8
print(sum((1,2,3), 2))		# 8
print(sum({1,2,3}, 2))		# 8
print(sum(range(5), 2))		# 12

  1.3、abs()与fabs()的区别（返回输入x的绝对值）

import math

# 输入整型
print(abs(10))						# 10
print(math.fabs(10))				# 10.0

# 输入浮点型
print(abs(10.125))					# 10.125
print(math.fabs(10.125))			# 10.125

# 输入复数类型
print(abs(10.125+12j))				# 15.62850460696736
# print(math.fabs(10.125+12j))		# TypeError: can't convert complex to float

  1.4、开根号的四种运算方法

方法1：数字**0.5

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

方法2：pow(数字，次方)

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

方法3：math.sqrt(数字)

import math

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

方法4：cmath.sqrt(数字)

import cmath

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

2、随机数函数

3、三角函数

4、数字常量

文献参考

1.【Python3】内置函数（大全）
2.【Python3】字符串常用方法（大全）
3.【Python】encode()函数
4.【Python】decode()与encode()详解
5.【Python】字符串isdecimal() isdigit()isnumeric()等判断方法的区分。
6.TypeError: sequence item 0: expected str instance, int found的解决办法