Python 学习笔记 Day5

最新推荐文章于 2024-07-27 12:20:46 发布

Leonardo_bits

最新推荐文章于 2024-07-27 12:20:46 发布

阅读量423

点赞数

文章标签： python

本文链接：https://blog.csdn.net/Leonardo_bits/article/details/106375084

版权

程序的循环结构

Python语言的循环结构包括两种：遍历循环和无限循环
遍历循环使用了保留字for依次提取遍历结构个元素进行处理
无限循环使用保留字while根据判断条件施行程序

遍历循环：for

for循环常用于可迭代对象的遍历，for循环的语法格式如下：

for 变量 in 可迭代对象:
    语句块1
else: #else 是可选的，在正常执行for语句后，程序会继续执行else语句的内容
    语句块2

遍历结构的流程图如下：
在这里插入图片描述
⭐注：可迭代对象（遍历结构）包括：
1.序列：字符串、列表、元组
2.字典
3.迭代器对象
4.生成器函数

>>>for x in (20,30,40):
    print(x*3)
    
60
90
120

>>>for x in 'abcde':
    print(x)
a
b
c
d
e
>>>

for x in {'name':'Leo','age':18}:
    print(x)
for x in {'name':'Leo','age':18}.keys():
    print(x)
for x in {'name':'Leo','age':18}.values():
    print(x)
for x in {'name':'Leo','age':18}.items():
    print(x)

name
age
name
age
Leo
18
('name', 'Leo')
('age', 18)

range对象

range对象是一个迭代器对象，用来产生指定范围的数字序列，格式为：

range(start,end [,step])

生成的数值序列从start开始到end结束（不含end），start默认从0开始
step是可选的步长默认为1

for i in range(11):
    print(i,end=' ')
0 1 2 3 4 5 6 7 8 9 10 

for i in range(5,11,2):
    print(i,end=' ')
5 7 9

#求0-100所有的偶数和与奇数和
sum_odd=0
sum_even=0
for i in range(101):
    if i%2==0:
        sum_even+=i
    else:
        sum_odd+=i
print('0-100所有的偶数和为：'+str(sum_even))
print('0-100所有的奇数和为：'+str(sum_odd))

0-100所有的偶数和为：2550
0-100所有的奇数和为：2500

for循环嵌套

练习1
在这里插入图片描述

for i in range(5):
    for j in range(5):
        print(i,end=' ')
    print()

练习2

#打印九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(str(j)+'×'+str(i)+'='+str(i*j),end='\t')
    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

练习3
在这里插入图片描述

employee1=['高小一',18,30000,'北京']
employee2=['高小二',19,20000,'上海']
employee3=['高小三',20,10000,'深圳']
tb={'姓名':[employee1[0],employee2[0],employee3[0]],\
    '年龄':[employee1[1],employee2[1],employee3[1]],\
    '薪资':[employee1[2],employee2[2],employee3[2]],\
    '城市':[employee1[3],employee2[3],employee3[3]],\
    }
print('工资高于15000的人有：')
for i in range(3):
    if int(tb['薪资'][i])>15000:
        print(str(tb['姓名'][i]),end='\t')

print('\n他们的详细信息为:')
for i in range(3):
    if int(tb['薪资'][i])>15000:
        print(tb['姓名'][i],tb['年龄'][i],tb['薪资'][i],tb['姓名'][i])

工资高于15000的人有：
高小一	高小二	
他们的详细信息为:
高小一 18 30000 高小一
高小二 19 20000 高小二

employee1=dict(name='高小一',age=18,salary=30000,city='beijing')
employee2=dict(name='高小二',age=19,salary=20000,city='shanghai')
employee3=dict(name='高小三',age=20,salary=10000,city='shenzhen')
tb=[employee1,employee2,employee3]
for x in tb:
    if x.get('salary')>15000:
        print(x)
        
{'name': '高小一', 'age': 18, 'salary': 30000, 'city': 'beijing'}
{'name': '高小二', 'age': 19, 'salary': 20000, 'city': 'shanghai'}

无限循环：while

在这里插入图片描述

循环控制

语句	说明
break	跳出循环)
continue	结束本次循环，继续下一次
pass	什么都不做
else	在循环语句下，正常施行完就执行else语句

break语句可用于while和for循环，用来结束整个循环，当在嵌套循环中，break语句只能跳出最内部的一层循环

while True:
    a=input('请输入你的名字（输入Q结束）：')
    if a.upper()=='Q':
        print('循环结束，end')
        break
    else:
        print(a)

continue语句
continue语句用于结束本次循环，继续下一次，多层循环时，continue也是只用于最内的一层

'''
练习
要求输入员工的薪资，若薪资小于0则重新输入
最后打印出录入员工的：
1.数量
2.薪资明细
3.平均薪资
'''
empnum=0
salarySum=0
salary=[]
while True:
    s=input('请输入员工薪资(按Q结束):')
    if s.upper()=='Q':
        print('录入结束END')
        break
    if float(s)<0:
        continue
    empnum+=1
    salarySum+=float(s)
    salary.append(float(s))
print('员工数{0}'.format(empnum))
print('录入薪资：',salary)
print('平均薪资{0}'.format(salarySum/empnum))

请输入员工薪资(按Q结束):2131321
请输入员工薪资(按Q结束):54654
请输入员工薪资(按Q结束):1125
请输入员工薪资(按Q结束):54966
请输入员工薪资(按Q结束):2156453
请输入员工薪资(按Q结束):513516
请输入员工薪资(按Q结束):251632
请输入员工薪资(按Q结束):Q
录入结束END
员工数7
录入薪资： [2131321.0, 54654.0, 1125.0, 54966.0, 2156453.0, 513516.0, 251632.0]
平均薪资737666.7142857143

循环代码优化

虽然计算机越来越强大，但我们仍然要在性能问题上“斤斤计较”
在编写Python代码的时候，遵循下面三个原则可以大大地提高运行效率：

1.尽量减少循环内部不必要的计算
2.嵌套循环中，尽量减少内层循环的计算
3.局部变量查询较快，尽量使用局部变量
4.连接多个字符串，尽量用join()而不是+
5.列表进行插入和删除，尽量在尾部操作

import time

s=time.time()
for i in range(1000):
    result=[]
    for j in range(10000):
        result.append(i*10000+j*100)
e= time.time()
print('耗时:{0}'.format(e-s))

s2=time.time()
for i in range(1000):
    result=[]
    c=i*10000
    for j in range(10000):
        result.append(c+j*100)
e2= time.time()
print('耗时:{0}'.format(e2-s2))

耗时:1.9578063488006592
耗时:1.4919688701629639

使用ZIP并行迭代

ZIP函数可以在最短序列用完时就停止

names=('Lisa','JoJo','Lucy','kim')
ages=(1,2,3,4)
jobs=('T','S','G','Q')

for name,age,job in zip(names,ages,jobs):
    print('{}-{}-{}'.format(name,age,job))

Lisa-1-T
JoJo-2-S
Lucy-3-G
kim-4-Q

练习

#综合练习_绘制不同颜色的多个同心圆
import turtle
colors = ('Blue','MediumBlue','MidnightBlue','DarkBlue','Navy',\
          'RoyalBlue','CornflowerBlue','LightSteelBlue'\
          ,'LightSlateGray','SlateGray',\
          'AliceBlue','SteelBlue','LightSkyBlue','SkyBlue',\
          'DeepSkyBlue')
t= turtle.Pen()
t.width(4)
t.speed(0) #加速
for i in range(100000):
    t.pu()
    t.goto(0,-i*10)
    t.pd()
    t.color(colors[i%(len(colors))])
    t.circle(15+i*10)
turtle.done()

在这里插入图片描述

#综合练习_绘制棋盘
import turtle
width=30
num=18
t= turtle.Pen()
x1=[(-400,400),(-400+width*num,400)]
y1=[(-400,400),(-400,400-width*num)]
t.speed(0)

for i in range(0,19):
    t.pu()
    t.goto(x1[0][0],x1[0][1]-30*i)
    t.pd()
    t.goto(x1[1][0],x1[1][1]-30*i)

for i in range(0,19):
    t.pu()
    t.goto(y1[0][0]+30*i,y1[0][1])
    t.pd()
    t.goto(y1[1][0]+30*i,y1[1][1])

turtle.done()

在这里插入图片描述

推导式

推导式是从一个或多个迭代器快速创建序列的一种方法，它可以将循环和条件判断结合起来，从而避免冗长的代码

列表推导式

列表推导式生成列表对象，语法如下：

     [表达式 for item in 可迭代对象]
or   {表达式 for item in 可迭代对象 if 条件}
#可以增加多个for判断

a1=[x for x in range(1,5)]
a2=[x*2 for x in range(1,5)]
a3=[x*2 for x in range(1,20) if x%5==0]
a4=[a for a in 'abcdef']
print(a1)
print(a2)
print(a3)
print(a4)

[1, 2, 3, 4]
[2, 4, 6, 8]
[10, 20, 30]
['a', 'b', 'c', 'd', 'e', 'f']

cells = [(row,col) for row in range(1,10) \
                   for col in range(1,10)]
print(cells)
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9)]

字典推导式

字典推导式生成字典对象，格式如下：

{key_expression : value_expression for 表达式 in 可迭代对象 if 条件}
#可以增加多个for判断

#统计文本中字符出现的次数
my_text='''
Give me the strength lightly to bear my joys and sorrows.
Give me the strength to make my love fruitful in service.
Give me the strength never to disown the poor or bend my knees before insolent might.
Give me the strength to raise my mind high above daily trifles.
And give me the strength to surrender my strength to thy will with love.
'''
char_count={c : my_text.count(c) for c in my_text}
print(char_count)

{'\n': 6, 'G': 4, 'i': 19, 'v': 10, 'e': 41, ' ': 59, 'm': 13, 't': 31, 'h': 18, 's': 16, 'r': 20, 'n': 17, 'g': 10, 'l': 10, 'y': 9, 'o': 18, 'b': 4, 'a': 6, 'j': 1, 'd': 7, 'w': 4, '.': 5, 'k': 2, 'f': 4, 'u': 3, 'c': 1, 'p': 1, 'A': 1}

#等价于
my_text='''
Give me the strength lightly to bear my joys and sorrows.
Give me the strength to make my love fruitful in service.
Give me the strength never to disown the poor or bend my knees before insolent might.
Give me the strength to raise my mind high above daily trifles.
And give me the strength to surrender my strength to thy will with love.
'''
char_count={}
for c in my_text:
    char_count[c]=my_text.count(c)
print(char_count)

集合推导式

集合推导式生成集合，语法格式如下：

{表达式 for item in 可迭代对象 if 条件} 
#if 可选

a={x for x in range(1,100) if x%9==0}
print(a)

{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}

生成器推导式

一个生成器只能用一次，语法格式如下：
⭐注：生成器是一个可迭代的对象

(表达式  for  item  in  可迭代对象  if 条件)

a = (x*2 for x in range(6))
print(a)
print(list(a))

<generator object <genexpr> at 0x0000027998970A98>
[0, 2, 4, 6, 8, 10]

a = (x*2 for x in range(6))
for x in a:
    print(x)

0
2
4
6
8
10

函数

函数介绍

![在这里插入图片描述](https://img-blog.csdnimg.cn/20200527222825843.png?
在Python中，函数是可复用的程序代码块，函数不仅可以实现复用，还可以实现代码的一致性：只要修改函数的代码，则所有调用该函数的地方都能得到体现

函数分类

Python中函数分为如下几类：

内置函数 我们前面使用的str()、list()、len()等这些都是内置函数，我们可以拿来直接使用。
标准库函数 我们可以通过 import 语句导入库，然后使用其中定义的函数
第三方库函数 Python社区也提供了很多高质量的库。下载安装这些库后，也是通过 import 语句导入，然后可以使用这些第三方库的函数
用户自定义函数 用户自己定义的函数，显然也是开发中适应用户自身需求定义的函数。

函数的定义

函数是一段具有特定功能的、可复用的语句组，我们可以通过函数名和其参数来使用它
使用函数有两个目的：降低编程难度和增加代码复用
Python通过保留字def定义函数，语法形式如下:

def <函数名>(<非可选参数列表>,<可选参数>=<默认值>):
    <函数体>
    return<返回值列表>

def test1():
    print('*'*11)
test1()

***********

⭐注：

我们使用def 来定义函数，然后就是一个空格和函数名称，Python执行 def时，会创建一个函数对象，并绑定到函数名变量上
参数列表
(1) 圆括号内是形式参数列表，有多个参数则使用逗号隔开
(2) 形式参数不需要声明类型，也不需要指定函数返回值类型
(3) 无参数，也必须保留空的圆括号
(4) 实参列表必须与形参列表一一对应
return返回值
(1) 如果函数体中包含 return语句，则结束函数执行并返回值
(2) 如果函数体中不包含return 语句，则返回None值
调用函数之前，必须要先定义函数，即先调用def 创建函数对象
(1) 内置函数对象会自动创建
(2) 标准库和第三方库函数，通过import导入模块时，会执行模块中的def 语句

函数的使用

函数的使用具体分为4个步骤：
①函数定义：用def保留字把一段代码定义为函数，需要确定函数名、参数名、参数的个数，使用参数名称作为形式参数（占位符）编写函数内部的功能代码
②函数调用：通过函数名调用函数功能，对函数的各个参数赋予实际值，实际值可以是实际数据，也可以是在调用函数前定义过的变量
③函数执行：函数被调用过后，使用实际参数参与函数内部代码的执行，如果有结果则输出
④函数返回：函数执行结束后，根据return保留字的指示决定是否返回结果，如果返回结果，则结果将被放到函数被调用的位置，函数使用完毕，程序继续进行
Python语言最小函数可以不表达任何功能：

def f():
    pass

函数的参数传递

形式参数：在定义函数的时候使用的参数
实际参数：实际使用的时候，把实际传递到函数里面的参数

#求n的阶乘
def fact(n): #形式参数n
    s=1
    for i in range (1,1+n):
        s *= i
    return s
print(fact(5)) #实际参数5
'''
(1) 圆括号内是形式参数列表，有多个参数则使用逗号隔开
(2) 形式参数不需要声明类型，也不需要指定函数返回值类型
(3) 无参数，也必须保留空的圆括号
(4) 实参列表必须与形参列表一一对应
'''
#我们可以通过help(函数名字.__doc__) 查看该函数的注释

函数的返回值

return语句用来结束函数并将程序被调用的位置继续执行
return语句可以出现在函数的任何位置，同时可以将0个、1个或多个函数运算的结果返回给函数被调用处的变量
⭐注：

如果函数体中包含return 语句，则结束函数执行并返回值
如果函数体中不包含return语句，则返回None值
要返回多个返回值，使用列表、元组、字典、集合将多个值“存起来”即可

#打印n个星号
def print_star(n):
    print('*'*n)
print(print_star(11))

***********
None             #不包含return语句，返回None值

#求两个数字的平均数
def avg(a,b):
    return (a+b)/2
print(avg(9,7))

8.0

def test3(a,b,c):
    return [a*10,b*10,c*10]
print(test3(1,2,3))

[10, 20, 30]

Leonardo_bits

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python 学习笔记 Day5

@TOC程序的循环结构Python语言的循环结构包括两种：遍历循环和无限循环遍历循环使用了保留字for依次提取遍历结构个元素进行处理无限循环使用保留字while根据判断条件施行程序遍历循环：forfor循环常用于可迭代对象的遍历可迭代对象：1.序列：字符串、列表、元组2.字典3.迭代器对象4.生成器函数for循环的语法格式如下：for 变量 in 可迭代对象: 循环体语句无限循环：while循环控制语句说明break跳出循环(必须和if连用)
复制链接

扫一扫