python3常用基础三

最新推荐文章于 2022-12-30 10:51:16 发布

Calm_1024

最新推荐文章于 2022-12-30 10:51:16 发布

阅读量410

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/Calm_1024/article/details/100826976

版权

python 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

一、逻辑控制与函数

一、条件控制语句

if 语句单分支

# python中的 if语句
a = 10
# if 空格后跟判断条件，以:结尾 ，真则往下执行，假则不执行，python中语句使用缩进区分，4个空格为一个缩进，缩进写错要么执行其他语句，要么报错，要非常注意这一点
if a > 10 :   # 条件语句
	print(1)  # 条件为真执行的语句

if-else 双分支

a = 10
if a % 2 == 0: # 条件为真则执行下面语句
	return True
else: # 上面条件不成立则执行下面语句
	return False

if-elif-else 多分支

# 适用于多分组的情况
a = 75
if a >= 90 :
	return "A"
elif a >= 80:
	return "B"
elif a >= 70:
	return "C"
else:
	return "D"

嵌套语句

# 嵌套一般用在需要对分组后的数据在细分时使用
a = 50
if a > 0:
	if a % 2 == 0:
		return "正偶数"
	else:
		return "正奇数"
else
	return "负数"

二、循环语句

1. while循环

i = 0
s = 0
while i < 101: # 循环条件
	# 循环体
	s += i     
	i += 1	   
print(s)   	   # 5050

# 死循环
while True:
	print("hello python")

# 乘法表 
row = 1  # 外层循环控制行
while row < 10:
    col = 1  # 内层循环控制列
    while col <= row:
    	# %s 字符串中表示占位符，在字符串结尾用%()填写元素
        print("%s * %s = %s"%(col,row,row * col),end="\t")  # \t 制表符，对齐
        col += 1
    row += 1
    print() # 内层循环结束一次，换行，换言之，外层循环一次，换行一次
"""
1 * 1 = 1	
1 * 2 = 2	2 * 2 = 4	
1 * 3 = 3	2 * 3 = 6	3 * 3 = 9	
1 * 4 = 4	2 * 4 = 8	3 * 4 = 12	4 * 4 = 16	
1 * 5 = 5	2 * 5 = 10	3 * 5 = 15	4 * 5 = 20	5 * 5 = 25	
1 * 6 = 6	2 * 6 = 12	3 * 6 = 18	4 * 6 = 24	5 * 6 = 30	6 * 6 = 36	
1 * 7 = 7	2 * 7 = 14	3 * 7 = 21	4 * 7 = 28	5 * 7 = 35	6 * 7 = 42	7 * 7 = 49	
1 * 8 = 8	2 * 8 = 16	3 * 8 = 24	4 * 8 = 32	5 * 8 = 40	6 * 8 = 48	7 * 8 = 56	8 * 8 = 64	
1 * 9 = 9	2 * 9 = 18	3 * 9 = 27	4 * 9 = 36	5 * 9 = 45	6 * 9 = 54	7 * 9 = 63	8 * 9 = 72	9 * 9 = 81	
"""

2. for循环

s = 0
for i in range(101):  # for后跟变量，该变量是从后面的迭代对象中挨个遍历出来的元素
	s += i			  # 循环体
print(s)			  # 5050

# 乘法表
for i in range(1,10):
	for j in(1,i+1):
		# {} 字符串中表示占位符，使用format填写元素
		print("{} * {} = {}".format(j,i,i * j),end="\t")
	print()

3.continue和break语句

# continue语句，结束本次循环，执行后续循环
n = 10
while n < 100:
    n += 5
    if n == 30:
        continue
    print(n)
# n = 30的时候跳过，执行下一次循环

# break：结束该层循环
while n < 100:
    n += 5
    if n == 30:
        break
    print(n)
"""
15
20
25  # 结束循环
"""
# 因为python是以缩进区分范围的，故语句的缩进位置非常重要，缩进放在不同的位置会有不同的效果，使用不当可能造成函数结果错误或程序bug
# 1.
for i in range(1,10):
    for j in range(1,10):
        print(i * j)
    if i == 5:  # 外层循环i == 5时，结束循环
        break
# 2.
for i in range(1,10):
    for j in range(1,10):
        print(i * j)
    	if i == 5:  # 外层循环i== 5 时，结束内层循环
        	break

二、函数

函数 function：就是从问题到解的映射，通俗的讲，就是通过一些代码能够实现某些功能。
当然，使用关键字来定义的函数针对的是我们自定义的函数，python中也有很多官方早就定义好的函数，可以直接拿过来用。
函数的本质：

变量可以指向函数
函数名就是一个变量名
函数名可以做参数名使用

基本函数

# Python中的函数的定义使用关键字 def来定义，后面写函数名，以冒号结尾，换行一个缩进之后就是函数体语句了

def func():  # 关键字 函数名():
	print("hello world!")  # 函数体

def func1():
	result = sum(range(101))  # sum()求和， python自带函数
	print(result)
	
# 上面的函数是无参函数，下面介绍有参数的函数，参数可以是任意类型的数据，除非你自己限制
def func2(arg):  # arg 参数
	print(arg) 

def Bubble(new_list):
	for i in range(len(new_list)-1):
		for j in range(i,len(new_list)):
			if new_list[i] > new_list[j]:
				new_list[i],new_list[j] = new_list[j],new_list[i]
	return new_list   # return结束函数的关键字 返回值  根据情况看是否需要返回值

list1 = [1,12,15,43,5,45,46,13,789,131,121,20]
Bubble(list1)  # 调用函数
# [1, 5, 12, 13, 15, 20, 43, 45, 46, 121, 131, 789]

# 多个参数
def func3(a,b,c):
	return a + b + c

# 不定长参数：
"""
*args不定长参数：表示传入不确定长度的参数，将参数打包成一个元组给函数使用,说更明白点就是传入不确定长度的元组，*就是解包成一个个元素
"""
def func(*args):
	for i in args:
		print(i)
func(a,b,c,d,e)


"""
**kwargs 不定长参数：表示传入不确定长度的参数，将参数打包成一个字典给函数使用,**表示捷解包的意思，按照字典的key-vlaue形式解包，通俗讲就是把不确定长度的有名参数以关键字传参的形式传给函数，一般就是就是字典
"""
def func(**kwargs):
	print(kwargs)

lambda函数
匿名函数，一个没有函数名的函数，主要以简短的代码来实现一些简单的操作，一般就是一行代码

result = lambda x:x % 2 == 0 # 判断时候是偶数，这样写result就相当于是函数名了。
result(101) # True

高阶函数
一个函数的参数是另外一个函数，返回一个结果，该函数就是一个高阶函数。其实就是python内置的函数套函数，可以实现一些复杂操作

# 下面介绍四种python中的高阶函数
"""
1. map(fn,Iterabel1,Iterabel2...)   映射
	1. fn 函数  Iterable序列，fn是一个需要传参的函数，序列可以传多个，参数的个数与序列个数相同
	2. fn 要设置返回值，否则生成的结果都为None,将函数的结果有存放在一个容器中
	3. 多个序列长度可以不一致，结果以元素最少的为准
"""
list1 = ["fahkDSNKda","daDSJsldjl","tjwaaflFJOg"]
# 需求：将list1 中的所有元素全部转换为大写
list1 = list(map(lambda ch:ch.upper(),list1))  # lambda 匿名函数
print(list1) # ['FAHKDSNKDA', 'DADSJSLDJL', 'TJWAAFLFJOG']

"""
2. reduce(fn,Iterablel),聚合，减少，累积
	1. fn 函数，Iterable序列
	2. fn函数首先将Iterable中的第0个元素和第1个元素进行计算，
	   将得到的结果再与第2个元素进行如上操作，以此类推，
	   直到序列中的全部元素都参与运算
"""
from functools import reduce
# 需求： "123465798" ----> 123456789

result = reduce(lambda x,y:int(x) * 10 + int(y),"123456798")
print(result) #  123456789


"""
3. filter(fn,Iterable) 过滤
	1. 通过一定的条件过滤掉可迭代对象中的数据，
	   fn函数返回一个bool值，根据返回的True/False 决定是否保留元素,最终返回一个容器
"""
# 需求：过滤出分数大于80分的人
list1 = [
	{"name":"张三","age":20,"score":90},
	{"name":"李四","age":21,"score":80},
	{"name":"王五","age":19,"score":70},
	{"name":"小强","age":20,"score":90}
]

def func(new_list):
    if new_list["score"] <= 80:
        return False
    else:
        return True
list1 = list(filter(func,list1))
print(list1) 
# [{'name': '张三', 'age': 20, 'score': 90}, {'name': '小强', 'age': 20, 'score': 90}]

"""
 - sorted(Iterable,key,reverse)  排序
	1. Iterable是序列，key关键字是要排序的指定规则，可以是自定义的函数，reverse=True反序，False正序，默认正序
	2. sorted 和sort功能很像，sort是列表的方法，只能用在列表中，
	   而sorted则可以操作任意的可迭代数据,但二者都可以使用key关键字定义排序规则
"""
list1 = ["ff","6fhufhua","hello","aba"]
list1 = sorted(list1,key=len,reverse=True)
print(list1) # ['6fhufhua', 'hello', 'aba', 'ff']

递归函数
递归函数：一个函数调用自身，该函数就叫做递归函数。递归函数包含了一个隐式循环，它会重复调用自身。
使用递归函数解决问题的思路：
1.找到临界值（让它停下来的条件）
2.找到两次循环之间的关系
3.递归中必须设置返回值

# 返回第n项斐波那契数
def Fibonacci(n):
    # 临界值，使函数停下的条件
    if n == 1 or n == 2:
        return 1  # 返回值
    else:
    	# 调用自身
        return Fibonacci(n - 1) + Fibonacci(n - 2)

待更新！！！

Calm_1024

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
python3常用基础三

逻辑控制语句和循环语句一、条件语句if 语句单分支# python中的 if语句a = 10# if 空格后跟条件，以:结尾，真则执行，假则不执行，python中语句使用缩进区分，4个空格为一个缩进，缩进写错要么执行其他语句，要么报错，要非常注意这一点if a > 10 : # 条件语句 print(1) # 条件为真执行的语句if-else 双分...
复制链接

扫一扫