本文介绍了Python常用内置函数(zip/map/abs/ord/hex/bin/pow/eval等)的应用场景，包括数据打包、类型转换、数学运算等。
通过示例讲解了自定义函数的开发方法，包括参数处理(*args/**kwargs)、递归调用和变量作用域。
最后演示了冒泡排序和快速排序两种经典算法的Python实现，并附有记忆口诀。
文章还涵盖了字符串判断(isalpha/isdigit)、格式化输出、全局变量声明等实用技巧，适合Python初学者系统学习核心语法和算法基础。
这是《Python 7 天入门》系列文章集合中的第五篇
先去复习第四天的内容
#zip() 是 Python 的内置函数，用于将多个可迭代对象打包成元组组成的迭代器。
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
scores = [85, 92, 78]
result = list(zip(names, ages, scores))
print(result)
# [('Alice', 25, 85), ('Bob', 30, 92), ('Charlie', 35, 78)]
#NP70 首都
# 创建字典
cities_dict = {
'Beijing': {'Capital': 'China'},
'Moscow': {'Capital': 'Russia'},
'Paris': {'Capital': 'France'}
}
# 遍历排序后的键并输出
for city in sorted(cities_dict.keys()):
country = cities_dict[city]['Capital']
print(f'{city} is the capital of {country}!')
#NP77
x=input().split(" ")
#map() 是 Python 的内置函数，用于将指定的函数应用于可迭代对象的每个元素，返回一个迭代器。
x1=list(map(int,x))
print(sum(x1))
#牛牛想要这样一个程序，只要是输入一个整数，不管正负，它一定转换为正数，即获取该数字的绝对值，你能用abs函数实现吗？
n=int(input())
#abs() 是 Python 的内置函数，用于返回一个数的绝对值。
print(abs(n))
#牛牛刚学习了ASCII码，他知道计算机中的字母很多用的都是这个编码方式，现在输入一个字母，你能使用ord函数将其转换为ASCII码对应的数字吗？
s=input()
#ord() 是 Python 的内置函数，用于返回单个字符的 Unicode 码点（整数）。
#chr() 是 ord() 的反函数，将 Unicode 码点转换为字符。
print(ord(s))
#NP80
#牛妹刚学习进制转换，对这方面掌控还不太熟练，她想请你帮她写一个十进制到十六进制的进制转换器，你能使用hex函数帮助她完成这个任务吗？
n=int(input())
#hex() 是 Python 的内置函数，用于将整数转换为十六进制字符串。
print(hex(n))
#NP81
# 计算机内部都由二进制组成，但是早就习惯使用十进制的牛牛根本不知道这个数字的二进制是什么，你能使用bin函数帮助他将十进制数字转换成二进制吗？
n=int(input())
#bin() 是 Python 的内置函数，用于将整数转换为二进制字符串。
print(bin(n))
#NP82
# 在Python中，除了使用两个乘号相连外，还能使用pow函数表示幂运算。
# 现牛牛输入正整数x与y，请你使用两种方法分别计算xy与yx。
#内置函数 pow(base, exp, mod=None)
# 幂运算：base ** exp
# print(pow(2, 3)) # 8
# print(pow(5, 2)) # 25
# print(pow(4, 0.5)) # 2.0（支持浮点数）
# 计算 (base ** exp) % mod，效率更高
print(pow(2, 10, 100)) # 24
print(pow(3, 4, 5)) # 1
# 等价于 (2**10) % 100，但 pow() 更高效
# 特别适合大数运算
print(pow(1234567, 1000000, 1000000007)) # 快速模幂运算
#Python有内置函数isalpha、isdigit、isspace可以分别判断字符串是否只包含字母、数字、空格，现在输入一个字符串，请分别输出这三个函数的判断结果。
i=input()
print(i.isalpha())
print(i.isdigit())
print(i.isspace())
# join 的正确格式
#分隔符.join(可迭代对象)
# join() 应该是分隔符调用，而不是被拼接的字符串调用
# 正确写法：' '.join(列表) 或 分隔符.join(可迭代对象)
#NP89 单词造句
words = []
while True:
word = input().strip()
if word == '0':
break
words.append(word)
print(' '.join(words))
#round() 是 Python 的内置函数，用于对数字进行四舍五入。
#round(number, ndigits=None)
# number：要四舍五入的数字
# ndigits：保留的小数位数（可选，默认为 0）
# 返回值：四舍五入后的数字
#NP91 小数位修正
n=float(input())
print(round(n,2))
#NP92 公式计算器
#牛牛听说Python中有一个很神奇的函数eval()，只要输入的字符串是一个公式，它能够直接计算这个公式的值。
s=input()
print(eval(s))第五天示例代码如下
#自定义函数 关键字 def
def hello(w):
print(f"hello {w}")
#return 返回值
#调用函数
hello("world")
#示例 开发函数 实现 '%.2f'%num
def num_round(num,f):
#如果num是数字
if num>0:
s='%.'+str(f)+'f'
print(s % num)
else:
print("只支持大于0的正值")
num_round(3.1415926,2)
num_round(3,2)
num_round(0,2)
#开发函数 big_num 找出两个数值中最大的那个
def big_num(num1,num2):
if num1>num2:
return num1
else:
return num2
print(big_num(3,2))
#开发函数 返回列表中 Int数值元素的个数
def list_int(list1):
l=len(list1)
for i in list1:
try:
x=i+1
except:
l-=1
return l
print(list_int([1,2,"3",4,5,6,7,8,"a"]))
#isinstance() 是 Python 的内置函数，用于判断一个对象是否属于某个指定的数据类型（或类型元组）。
#isinstance(object, type)
# object：要判断的对象
# type：类型（可以是单个类型，也可以是类型的元组）
# 返回值：True 或 False
#isinstance(i,int)
# 判断是否为整数或浮点数
num = 3.14
print(isinstance(num, (int, float))) # True
#练习 返回列表x中的偶数的个数
x=[1,3,4,5,6]
def n(x):
s = 0
for i in x:
if i%2==0:
s+=1
return s
print(n(x))
#练习 返回列表x中质数的个数
#质数（也称素数）是指在大于1的自然数中，除了1和它自身以外，不再能被其他任何自然数整除的数。
x=[1,2,3,4,5,6]
def z(x):
s = 0
for i in x:
for j in range(2,i):
if i%j==0:
s+=1
return s
print(n(x))
# 举例：
# 2 是质数（因数只有 1 和 2）。
# 3 是质数（因数只有 1 和 3）。
# 4 不是质数（因数有 1、2、4，除了1和自身还有2，因此是合数）。
# 特别说明：
# 1 不是质数，也不是合数（因为它只有一个正因数）。
# 2 是最小的质数，也是唯一的偶质数。
#是否是质数
def zhi(num):
s=0
for i in range(2,num):
if num%i==0:
s+=1
if s==0:
return True
else:
return False
print(zhi(2))
#当函数的入参个数是未知的，可以用 *args 表示
#示例 返回n个数的和
def sum_num(*nums):
s=0
for i in nums:
s+=i
return s
print(sum_num(1,2,3,4,5,6))
#返回平均值
def avg_num(*nums):
s=0
for i in nums:
s+=i
return '%.2f'%(s/len(nums))
print(avg_num(1,2,3,4,5,6))
#当函数的入参是未知的个数（类似于字典的格式的时候） **abc
def dict_val(**dict1):
r=[]
for i in dict1.keys():
r.append(i)
return r
print(dict_val(name="mumu",age=18))
#练习 将所有入参中的偶数生成列表作为返回值
def o(*args):
l=[]
for i in args:
if isinstance(i,int):
if i%2==0:
l.append(i)
return l
print(o(3,6,"a",555,True,None,8))
#练习 返回所有入参属性的value的最大值
def max_num(**dict1):
li=dict1["score"]
return max(li)
print(max_num(name="mumu",score=[77,88,99]))
#匿名函数 lambda 理解成一个f(x)
#匿名函数（lambda函数）：lambda函数是一种快速定义单行的最小函数，是从Lisp借用来的，可以用在任何需要函数的地方。
#临时函数 简单逻辑
jiafa=lambda a,b:a+b
print(jiafa(1,2))
#变量 全局变量 局部变量
x=1024#全局变量
def abc():
x=999#局部变量
return x
print(x)
print(abc())
m=1024
def ddd():
global m #使用 global 关键字，引用全局变量
m=999
return m
print(m)
print(ddd())
print(m)
#递归引用
def sum_total(num):
if num==1:
return 1
else:
return sum_total(num - 1) + num
print(sum_total(100))
#排序算法 冒泡排序 升序
def maopao(a):
l=len(a)
for i in range(l-1):#定义循环多少轮
for j in range(l-1-i):#每一轮循环多少次
if a[j]>a[j+1]:
a[j],a[j+1]=a[j+1],a[j]
return a
print(maopao([1,5,5,8,6,3]))
#冒泡排序 升序 记忆口诀
# 外层循环 n-1，
# 内层循环逐次减。
# 相邻元素相比较，
# 大的往后小的前。
# 一轮冒出一个大，
# 直到全部排好序。
#快速排序
def fast(a):
l=len(a)
if l==1:
return a
else:
flag=a[0]
left=[]
mid=[]
right=[]
for i in a:
if i>flag:
right.append(i)
elif i==flag:
mid.append(i)
else:
left.append(i)
if len(left)==0 and len(right)==0:
return mid
elif len(left)!=0 and len(right)==0:
return fast(left)+mid
elif len(left) == 0 and len(right) != 0:
return mid+fast(right)
else:
return fast(left)+mid+fast(right)
print(fast([1,5,5,8,6,3]))关联阅读推荐
Python 常用的内置函数（补充了命名规律/词源方便记忆）
扫一扫
38
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
