Python入门课程系列：

• Python学习 day1：认识Python
• Python学习 day2：判断语句与循环控制
• Python学习 day3：高级数据类型
• Python学习 day4：函数基础
• Python学习 day5：函数

主要内容：四种类型的内置函数的用法

1. 内置函数简介

任何一门编程语言的核心操作都是操作内存中的数据，但内存中的数据又是通过编程语言的API来实现。所谓API，就是系统提供给我们的函数，有一种函数是系统预先定义的函数，也就是我们安装python就自带的函数，这种我们把它称为内置函数，也叫内嵌函数。

Python官方内置函数表：https://docs.python.org/zh-cn/3/library/functions.html

2. 数据运算

常用的数学运算函数：
abs() round() pow() divmed() max() min() sum() eval()

#eval() 执行表达式
a,b,c=1,2,3
print(eval('a+b+c'))
#6
def testfun():
    print('我执行了吗')
    pass
eval('testfun()')
#我执行了吗
# divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
print(divmod(7, 2))
#(3, 1)

3. 类型转换

常用的类型转换函数：
int() float() str() ord() chr() bool() bin() hex() oct() list() tuple() dict() bytes()

print(bin(10)) #转换为二进制
print(oct(10)) #转换为八进制
print(hex(10)) #转换为十六进制

#将元组转换成列表
tup=(1,2,3,4)
print(type(tup))
#<class 'tuple'>
li=list(tup)
print(type(li))
#<class 'list'>

#将列表转换成元组
tuplist=tuple(li)
print(type(tuplist))
#<class 'tuple'>

#dict() 创建字典
dic=dict()
dic['name']='hui'
dic['age']=24
print(dic)
#{'name': 'hui', 'age': 24}

#bytes()转为字节数组
print(bytes('我喜欢python',encoding='utf-8'))
#b'\xe6\x88\x91\xe5\x96\x9c\xe6\xac\xa2python'

4. 序列操作⚠️

str、元组、list统称为序列

常用的序列操作函数：
all() any() sorted() reverse() range() zip() enumerate()

1. all()函数用于判断给定的可迭代参数iterable中的所有元素是否全部 为True，如果是返回True，否则返回False元素。除了 0、空、False外都算True。

• 语法：all(iterable)
• 参数：iterable--元组或列表
• 返回值：如果iterable的所有元素不为0、‘’、False或者 iterable为空，all(iterable)返回True，否则返回False;
  ❗️注意：空元组、空列表 返回值为True

#函数等价于：
def all(iterable):
       for element in iterable:
              if not element:
                  return False
              return True
#案例
li = [1, 2, 3]
print(all(li))
#True
li = [1, 2, 3, 0]
print(all(li))
#False

2. any()函数用于判断给定的可迭代参数iterable中的所有元素是否全部为False，如果是返回True，否则返回False元素。只要有一个为True，则返回True。元素除了 0、空、False外都算True。

• 语法：any(iterable)
• 参数：iterable--元组或列表
• 返回值：如果iterable的所有元素都为0、‘’、False或者 iterable为空，则返回False，否则返回True;

#函数等价于：
def any(iterable):
       for element in iterable:
              if element:
                  return True
              return False
#案例
li = [1, 2, 3, 0]
print(any(li))
#True
li = ['', False, 0]
print(any(li))
#False

3. sorted()函数对所有可迭代对象进行排序操作

• sort()与sorted()区别：
  sort()是应用在list上的方法，sorted可以对所有可迭代对象进行排序操作；
  list的sort方法返回的是对已经存在的列表进行操作，而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作
• 语法：sorted(iterable[, cmp[, key[, reverse]]])
• 参数：
  iterable：可迭代对象
  cmp：比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则是：大于则返回1，小于则返回-1，等于则返回0
  key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自可迭代对象中，指定可迭代对象中的一个元素来进行排序
  reverse：排序规则；reverse=True降序，reverse=False升序（默认）
• 返回值：返回重新排序的列表

li=[3,1,7,8,6,2,9]
li.sort()#list的排序方法  直接修改原始对象
print(li)
#[1, 2, 3, 6, 7, 8, 9]
print(sorted([3,1,7,8,6,2,9]))
#[1, 2, 3, 6, 7, 8, 9]
print(sorted([3,1,7,8,6,2,9],reverse=False))
#[1, 2, 3, 6, 7, 8, 9]
print(sorted([3,1,7,8,6,2,9],reverse=True))
#[9, 8, 7, 6, 3, 2, 1]
print(sorted(['c','P','E','a','z','B','m']))#先排大写再排小写
#['B', 'E', 'P', 'a', 'c', 'm', 'z']
print(sorted(['c','P','E','a','z','B','m'],key=str.lower)) #字符串无关大小写排序
#['a', 'B', 'c', 'E', 'm', 'P', 'z']

4. reverse()函数用于反向列表中的元素

• 语法：list.reverse()
• 返回值：该方法没有返回值，但会对列表的元素进行反向排序

5. range()函数可创建一个整数列表，一般用在for循环中

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

print(range(0,5))
#range(0, 5)
print(list(range(0,5)))
#[0, 1, 2, 3, 4]

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

• 语法：zip([iterable,...])
• 参数：iterable：一个或多个迭代器
• 返回值：返回元组列表

a=zip([1,2,3])
print(a)
print(list(a))
#<zip object at 0x7f96b61a8900>
#[(1,), (2,), (3,)]  返回的是元组
a=zip([1,2,3],['a','b','c']) #zip就是用来打包的，会把序列中对应的索引位置的元素存储为一个元组再输出
print(list(a))
#[(1, 'a'), (2, 'b'), (3, 'c')]  
a= ([1,2,3],['a','b','c','d','e'],['jing','hui','yuan'])
print(list(a))
#[(1, 'a', 'jing'), (2, 'b', 'hui'), (3, 'c', 'yuan')]

#遍历图书信息进行存储
def  peintBookInfo():
   books=[] #存储所有的图书信息
   id = input('请输入编号，每个编号以空格分隔：') #str
   bookName = input('请输入书名，每个项以空格分隔：')  # str
   bookPro = input('请输入位置，每个项以空格分隔：')  # str
   idList=id.split(' ')
   nameList = bookName.split(' ')
   proList = bookPro.split(' ')

   bookInfo=zip(idList,nameList,proList) #进行打包处理
   for bookItem in bookInfo:
       '''
       遍历图书信息进行存储
       '''
       dictInfo={'编号':bookItem[0],'书名':bookItem[1],'位置':bookItem[2]}
       books.append(dictInfo) #将字典对象添加到list容器中
       pass
   for item in books:
       print(item)
       pass
   pass

peintBookInfo() #函数调用

应用：有一份人员名单和一份工作内容，利用这个函数，可以直接给每个人分配好对应的任务。

7. enumerate()函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中

• 语法：enumerate(sequence,[start=0])
• 参数：
  sequence：一个序列，迭代器或其他支持迭代对象
  start：下标起始位置
• 返回值：返回enumerate（枚举）对象

listObj=['a','b','c']
for index,item in enumerate(listObj):
    print(index,item)
#0 a
#1 b
#2 c

seasons=['spring','summer','fall','winter']
print(list(enumerate(seasons)))
#[(0, 'spring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]
seasons=['spring','summer','fall','winter']
print(list(enumerate(seasons,start=5)))
#[(5, 'spring'), (6, 'summer'), (7, 'fall'), (8, 'winter')]

#遍历字典
dicObj={'name':'菲菲','爱好':'画画','职业':'学前班班长'}
print(dicObj)
#{'name': '菲菲', '爱好': '画画', '职业': '学前班班长'}
for item in enumerate(dicObj):
    print(item)
#(0, 'name')
#(1, '爱好')
#(2, '职业')

5. Set集合⚠️

set（集合）是python中的一种数据类型，是一个无序且不重复的元素集合（容器）。基于它这种特性，常被用来做去重操作。set不支持索引和切片。

集合操作函数
add() clear() difference() intersection() union() pop() discard() update()

• 创建集合数据集的方法：

#方法1:直接用大括号创建
set1={'1','2'}  #类似于字典，但只有key，没有value。
#方法2:强制类型转换
list1=['1','5','4','3']
set2=set(list)

dict1={}
set1={1,2,3}  
print(type(dict1))
print(type(set1))
#<class 'dict'>
#<class 'set'>

#1.add()添加元素
set1.add('python')
print(set1)
#{'python', 1, 2, 3}

#2.clear()请空操作
set1.clear()
print(set1)
#set()

#3.difference()取差集
a={32,34,66}
b={12,66,51}
print(a.difference(b))
#{32, 34}
print(a-b)
#{32, 34}  #和difference等价

#4.intersection()取交集
a={32,34,66}
b={12,66,51}
print(a.intersection(b))
#{66}
print(a & b) #和intersection等价
#{66}

#5.union()取交集
a={32,34,66}
b={12,66,51}
print(a.union(b))
#{32, 34, 66, 51, 12}
print(a | b)
#{32, 34, 66, 51, 12}

#6. pop()函数随机移除某个元素并获取那个参数，集合pop没有参数
a={32,34,66}
print(a.pop())
#32
print(a)
#{34, 66}

#7.discard()函数移除指定元素
a={32,34,66}
a.discard(32)
print(a)
#{34, 66}

#8.update()函数更新集合
a={32,34,66}
b={12,66,51}
a.update(b)
print(a)
#{32, 34, 66, 51, 12}

作业

1. 求三组连续自然数的和：求出1到10、20到30和35到45的和
2. 100个和尚吃馒头，大和尚一人吃3个馒头，小和尚三人吃1个馒头。请问大小和尚各多少个
3. 指定一个列表，列表里含有唯一一个只出现过一次的数字。写程序找出这个“独一无二”的数字

答案

#题1：
def sumRange(m,n):
   '''
   求从a到b的连续自然数的和
   :param a: 开始值 int
   :param b: 结束值 int
   :return:
   '''
   return sum(range(m,n+1))
   pass
print(sumRange(1,10))
print(sumRange(25,30))
print(sumRange(35,45))
#55
#165
#440

#题2:
def PersonCount():
    '''
    计算各有多少个和尚
    假设大和尚a个 小和尚就是100-a
    :return:
    '''
    for a in range(1,100):
        if a*3+(100-a)*(1/3)==100:
            return(a,100-a)
        pass
rsObj=PersonCount()
print('大和尚{}人，小和尚{}人'.format(rsObj[0],rsObj[1])
#大和尚25人，小和尚75人

#题3:
li=[1,3,4,3,3,5,2,4,2,5,2]
set1=set(li)
print(set1)
#{1, 2, 3, 4, 5}
for i in set1:
    li.remove(i)
    pass
set2=set(li) #set2中为原来li中有重复的数字集合
for i in set1: #set1中 数据全部去重后形成的集合
    if i not in set2:
        print(i)
        pass
    pass
pass
#1