Python的基本语法(上篇)的章节内容如下五部分
一、基本数据类型
二、程序与用户交互
三、格式化输出
四、基本运算符
五、流程控制
文章目录
一、基本数据类型
引入
生活中常见的数据类型
视频文件 音频文件 表格 图像 图片 文本…
在程序中也有千变万化的数据格式
整型 浮点型 字符串 列表 元组 集合 字段…
展示如下
salary = 3.1 # 用浮点型去记录薪资
age = 18 # 用整型去记录年龄
name = 'lili' # 用字符串类型去记录人名
1、数据类型的八种类型
eg:整型,浮点型,字符串,列表,字典,布尔,元组,集合
其中我们通常把(整型)和(浮点型)统称为数字类型
2、数字类型
数字类型作用:
1、数学运算
>>> a = 1
>>> b = 3
>>> c = a + b
>>> print(c) #输出结果是4
2、比较大小
>>> x = 10
>>> y = 11
>>> print(x > y) #输出结果是False
3、数据类型
1、整型(int)
1.1、整型的作用
用来记录人的年龄,出生年份,学生人数等整数相关的状态
用大白话说就是:整数
1.2、整型的定义
age=18
birthday=1990
student_count=48
2、浮点型(float)
2.1、浮点型的作用
用来记录人的身高,体重,薪资等小数相关的状态
用大白话说就是:小数
2.2、浮点型的定义
height=172.3
weight=103.5
salary=15000.89
3、字符串(str)
3.1、字符串的作用:
用来记录人的名字,家庭住址,性别等描述性质的状态
3.2、定义:
方式1:
name = ‘kevin’
方式2:
name = “kevin”
方式3:
name = ‘’‘kevin’‘’ # (当左边有赋值符号和遍历名的时候,它就是字符串)
方式4:
name = “”“kevin”“” # (当左边有赋值符号和遍历名的时候,它就是字符串)
ps:用引号引起来的部分
3.3、用单引号、双引号、多引号,都可以定义字符串,本质上是没有区别的,但是需要注意两点:
3.3.1、需要考虑引号嵌套的配对问题
msg = "My name is Tony , I'm 18 years old!"
#**内层有单引号,外层就需要用双引号。内层有双引号,外层就需要用单引号。**
3.3.2、多引号可以写多行字符串
msg = '''
天下只有两种人。比如一串葡萄到手,一种人挑最好的先吃,另一种人把最好的留到最后吃。
照例第一种人应该乐观,因为他每吃一颗都是吃剩的葡萄里最好的;
第二种人应该悲观,因为他每吃一颗都是吃剩的葡萄里最坏的。
不过事实却适得其反,缘故是第二种人还有希望,第一种人只有回忆。
3.4、字符串的使用
数字可以进行加减乘除等运算,字符串呢?也可以,但只能进行"相加"和"相乘"运算。
>>> name = 'tony'
>>> age = '18'
>>> name + age #相加其实就是简单的字符串拼接
'tony18'
>>> name * 5 #相乘就相当于将字符串相加了5次
'tonytonytonytonytony'
总结:
1、字符串的相加其实就是简单的字符串拼接
2、字符串的相乘就相当于将字符串相连续打印了N次
4、列表(list)
4.1、列表的作用
果我们需要用一个变量记录多个学生的姓名,用数字类型是无法实现,字符串类型确实可以记录下来,比如 stu_names=’张三 李四 王五’,但存的目的是为了取,此时若想取出第二个学生的姓名实现起来相当麻烦,而列表类型就是专门用来记录多个同种属性的值(比如同一个班级多个学生的姓名、同一个人的多个爱好等),并且存取都十分方便
4.2、列表的定义
中括号 [ ] 括起来,内部可以存放多个元素,元素与元素之间使用逗号隔开,可以是任意的数据类型和嵌套。如下图
stu_names=['张三','李四','王五']
4.3、列表的使用
4.3.1、列表类型是用索引来对应值,索引代表的是数据的位置,从0开始计数
>>> stu_names=['张三','李四','王五']
>>> stu_names[0]
'张三'
>>> stu_names[1]
'李四'
>>> stu_names[2]
'王五'
4.3.2、列表可以嵌套,嵌套取值如下
>>> students_info=[['tony',18,['jack',]],['jason',18,['play','sleep']]]
>>> students_info[0][2][0] #取出第一个学生的第一个爱好
'play'
5、 字典(dict)
5.1、字典的作用
如果我们需要用一个变量记录多个值,但多个值是不同属性的,比如人的姓名、年龄、身高,用列表可以存,但列表是用索引对应值的,而索引不能明确地表示值的含义,这就用到字典类型,字典类型是用key:value形式来存储数据,其中key可以对value有描述性的功能
5.2、字典的定义
大括号括起来,内部可以存放多个元素,元素与元素之间使用逗号隔开,是以K:V键值对的形式存储
K:是对V的描述性信息(一般情况是字符串)
V:真正的数据,其实相当于变量值,也是任意的数据类型
d = {'username': 'kevin', 'age': 18, 'hobby': 'music'}
5.3、字典的使用
5.3.1、字典类型是用key来对应值,key可以对值有描述性的功能,通常为字符串类型 。
person_info = {'name': 'tony', 'age': 18, 'height': 185.3}
print(person_info['name'])
# 'tony'
print(person_info['age'])
# 18
print(person_info['height'])
# 185.3
5.3.2、字典可以嵌套,嵌套取值如下 :
students=[
{'name':'tony','age':38,'hobbies':['play','sleep']},
{'name':'jack','age':18,'hobbies':['read','sleep']},
{'name':'rose','age':58,'hobbies':['music','read','sleep']},
]
print(students[1]['hobbies'][1])
#取第二个学生的第二个爱好 'sleep'
6、布尔(bool)
6.1、布尔的作用
用来记录真假这两种状态 True/False
6.2、布尔的定义
# 布尔值的变量命名规范:以is开头
>>> is_ok = True
>>> is_ok = False
6.3、布尔的使用
6.3.1、通常用来当作判断的条件,我们将在if判断中用到它
6.3.2、结果可能是布尔值的情况,我们都采用is开头命名
6.3.3、在python中,所有的数据类型都可以转为布尔值
6.3.4、在python中 0, None, ‘’, [], {}…都是是假的(False),其他都是真(True)
7、元组(tuple)
7.1、元组的作用
元组与列表类似,也是可以存多个任意类型的元素,不同之处在于元组的元素不能修改,即元组相当于不可变的列表,用于记录多个固定不允许修改的值,单纯用于取
7.2、元组的定义
在()内用逗号分隔开多个任意类型的值,小括号括起来,内部存放多个元素,元素之间逗号隔开,数据不支持修改
# 在()内用逗号分隔开多个任意类型的值
countries = ("中国", "美国", "英国") # 本质:countries = tuple("中国","美国","英国")
countriess = ("中国",) # 本质:countries = tuple("中国")
# 强调:如果元组内只有一个值,则必须加一个逗号,否则()就只是包含的意思而非定义元组
couut = () #表示空元组
couutt = (1) #表示是整数1
couuttt = (1,) #表示元组类型
print(type(couut)) # <class 'tuple'>
print(type(couutt)) # <class 'int'>
print(type(couuttt)) # <class 'tuple'>
7.3、元组的使用
1、按索引取值,只能取,不能改否则报错!
tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
# 1、按索引取值:只能取,不能改否则报错!
print(tuple1[0]) #输出为 1
print(tuple1[3]) #输出为 11
8、集合(set)
8.1、集合的作用
集合、list、tuple、dict一样都可以存放多个值,但是集合主要用于:去重、关系运算。总结就是(特点:无序 去重 集合运算)
8.2、集合的定义
大括号括起来,内部可以存放多个元素,元素与元素之间逗号隔开,但是不是K:V键值对的形式,集合中得元素不能直接取出。
"""
定义:在{}内用逗号分隔开多个元素,集合具备以下三个特点:
1:每个元素必须是不可变类型
2:集合内没有重复的元素
3:集合内元素无序
s = {1,2,3,4} # 本质 s = set({1,2,3,4})
# 注意1:列表类型是索引对应值,字典是key对应值,均可以取得单个指定的值,而集合类型既没有索引也没有key与值对应,所以无法取得单个的值,而且对于集合来说,主要用于去重与关系元素,根本没有取出单个指定值这种需求。
# 注意2:{}既可以用于定义dict,也可以用于定义集合,但是字典内的元素必须是key:value的格式,现在我们想定义一个空字典和空集合,该如何准确去定义两者?
d = {} # 默认是空字典
s = set() # 这才是定义空集合
"""
二、程序与用户交互
1、什么是与用户交互
用户交互就是人往计算机中input/输入数据,计算机print/输出结果
2、为什么要与用户交互?
为了让计算机能够像人一样与用户沟通交流
比如,过去我们去银行取钱,用户需要把帐号密码告诉柜员,而现在,柜员被ATM机取代,ATM机就是一台计算机,所以用户同样需要将帐号密码告诉计算机,于是我们的程序中必须有相应的机制来控制计算机接收用户输入的内容,并且输出结果
3、如何与用户交互
交互的本质就是输入、输出
3.1 输入 input()
在python3中input功能会等待用户的输入,用户输入任何内容,都存成字符串类型,然后赋值给等号左边的变量名
# 在python3中input功能会等待用户的输入,用户输入任何内容,都存成字符串类型,然后赋值给等号左边的变量名
username = input('请输入您的用户名:')
# 请输入您的用户名:jack # username = "jack"
password = input('请输入您的密码:')
# 请输入您的密码:123 # password = "123"
# 了解知识:
# 1、在python2中存在一个raw_input功能与python3中的input功能一模一样
# 2、在python2中还存在一个input功能,需要用户输入一个明确的数据类型,输入什么类型就存成什么类型
l = input('输入什么类型就存成什么类型: ')
# 输入什么类型就存成什么类型: [1,2,3]
type(l)
# <type 'list'>
3.2 输出 print()
print('hello world') # 只输出一个值 hello world
print('first', 'second', 'third') # 一次性输出多个值,值用逗号隔开 first second third
# 默认print功能有一个end参数,该参数的默认值为"\n"(代表换行),可以将end参数的值改成任意其它字符
print("aaaa", end='')
print("bbbb", end='&')
print("cccc", end='@')
# 整体输出结果为:aaaabbbb&cccc@
三、格式化输出
1、什么是格式化输出?
把一段字符串里面的某些内容替换掉之后再输出,就是格式化输出。
2、为什么要格式化输出?
我们经常会输出具有某种固定格式的内容,比如:'亲爱的xxx你好!你xxx月的话费是xxx,余额是xxx‘,我们需要做的就是将xxx替换为具体的内容。
3、如何格式化输出?
这就用到了占位符,如:%s、%d
占位符:%s %d
%s:可以给任意的数据类型占位
%d:只能给数字类型占位
当有多个替换数据的时候,%后面的数据一定是有顺序要求的,一一对应’‘’
# %s占位符:可以接收任意类型的值
# %d占位符:只能接收数字
print('亲爱的%s你好!你%s月的话费是%d,余额是%d' % ('tony', 12, 103, 11))
#亲爱的tony你好!你12月的话费是103,余额是11
# 练习1:接收用户输入,打印成指定格式
name = input('your name: ')
age = input('your age: ') # 用户输入18,会存成字符串18,无法传给%d
print('My name is %s,my age is %s' % (name, age))
# 练习2:用户输入姓名、年龄、工作、爱好 ,然后打印成以下格式
'''
------------ info of Tony - ----------
Name: Tony
Age: 22
Sex: male
Job: Teacher
------------- end - ----------------
'''
#答案:
res = '''
------------ info of Tony - ----------
Name: %s
Age: %d
Sex: %s
Job: %s
------------- end - ----------------
'''
print(res % ("lili", 22, "男", "Teacher"))
四、基本运算符
1、算术运算符
python支持的算数运算符与数学上计算的符号使用是一致的,我们以x=9,y=2为例来依次介绍它们,如下图
2、比较运算符
比较运算用来对两个值进行比较,返回的是布尔值True或False,我们以x=9,y=2为例来依次介绍它们
3、赋值运算符
python语法中除了有=号这种简单的赋值运算外,还支持增量赋值、链式赋值、交叉赋值、解压赋值,这些赋值运算符存在的意义都是为了让我们的代码看起来更加精简。我们以x=9,y=2为例先来介绍一下增量赋值
3.1、增量赋值
3.2、链式赋值
如果我们想把同一个值同时赋值给多个变量名,可以这么做
z = 10
y = z
x = y
print(x, y, z) #(10, 10, 10)
链式赋值指的是可以用一行代码搞定这件事
x = y = z = 10
print(x, y, z) # (10, 10, 10)
3.3、交叉赋值
我们定义两个变量m与n,如果我们想将m与n的值交换过来,可以这么做
m = 10
n = 20
temp = m
m = n
n = temp
print(m, n) # (20, 10)
交叉赋值指的是一行代码可以搞定这件事
m = 10
n = 20
m, n = n, m # 交叉赋值
print(m, n) # (20, 10)
1、注意,上述解压赋值,等号左边的变量名个数必须与右面包含值的个数相同,否则会报错
2、但如果我们只想取头尾的几个值,可以用*_匹配
nums = [11, 22, 33, 44, 55]
a, b, *_ = nums
print(a, b) # (11, 22)
print(*_) # (33 44 55)
ps:字符串、字典、元组、集合类型都支持解压赋值
3.4、解压赋值
如果我们想把列表中的多个值取出来依次赋值给多个变量名,可以这么做
nums = [11, 22, 33, 44, 55]
a = nums[0]
b = nums[1]
c = nums[2]
d = nums[3]
e = nums[4]
print(a, b, c, d, e) # (11, 22, 33, 44, 55)
>解压赋值指的是一行代码可以搞定这件事
```python
nums = [11, 22, 33, 44, 55]
a,b,c,d,e = nums # nums包含多个值,就好比一个压缩包,解压赋值因此得名
print(a, b, c, d, e) # (11, 22, 33, 44, 55)
4、逻辑运算符
逻辑运算符用于连接多个条件,进行关联判断,会返回布尔值True或False
4.1、连续多个 and
可以用and连接多个条件,会按照从左到右的顺序依次判断,一旦某一个条件为False,则无需再往右判断,可以立即判定最终结果就为False,只有在所有条件的结果都为True的情况下,最终结果才为True。
列:( 2 > 1 and 1 != 1 and True and 3 > 2 )
判断完第二个条件,就立即结束,得的最终结果为False
False
4.2、连续多个 or
可以用or连接多个条件,会按照从左到右的顺序依次判断,一旦某一个条件为True,则无需再往右判断,可以立即判定最终结果就为True,只有在所有条件的结果都为False的情况下,最终结果才为False
列:( 2 > 1 or 1 != 1 or True or 3 > 2 )
判断完第一个条件,就立即结束,得的最终结果为True
True
4.3、优先级 not > and > or
4.3.1、三者的优先级关系:not>and>or,同一优先级默认从左往右计算。
列:( 3>4 and 4>3 or 1==3 and ‘x’ == ‘x’ or 3 >3 )
0结是False
4.3.2、最好使用括号来区别优先级,其实意义与上面的一样
原理为:
(1) not的优先级最高,就是把紧跟其后的那个条件结果取反,所以not与紧跟其后的条件不可分割
(2) 如果语句中全部是用and连接,或者全部用or连接,那么按照从左到右的顺序依次计算即可
(3) 如果语句中既有and也有or,那么先用括号把and的左右两个条件给括起来,然后再进行运算列: (3>4 and 4>3) or (1==3 and ‘x’ == ‘x’) or 3 >3
结果是:False
4.3.3、短路运算
# 3、短路运算:逻辑运算的结果一旦可以确定,那么就以当前处计算到的值作为最终结果返回
print(10 and 0 or '' and 0 or 'abc' or 'egon' == 'dsb' and 333 or 10 > 4)
# 我们用括号来明确一下优先级
print((10 and 0) or ('' and 0) or 'abc' or ('egon' == 'dsb' and 333) or 10 > 4)
# 短路: 0 '' 'abc'
# 假 假 真
# 返回: abc
短路运算面试题:
>>> 1 or 3
1
>>> 1 and 3
3
>>> 0 and 2 and 1
0
>>> 0 and 2 or 1
1
>>> 0 and 2 or 1 or 4
1
>>> 0 or False and 1
False
5、成员运算符
注意:虽然下述两种判断可以达到相同的效果,但我们推荐使用第二种格式,因为not in语义更加明确
print('lili' in ['jack', 'tom', 'robin'])
# False
print('lili' not in ['jack', 'tom', 'robin'])
# True
6、身份运算符
需要强调的是:==双等号比较的是value(值)是否相等,而is比较的是id(内存地址)是否相等
#案列1:
# 1. id相同,内存地址必定相同,意味着type和value必定相同
# 2. value相同type肯定相同,但id可能不同,如下
x = 'Info Tony:18'
y = 'Info Tony:18'
print(id(x), id(y)) # x与y的id相同,但是二者的值相同(1489832544432 1489832544432)
print(x == y) # 等号比较的是value(值) True
print(type(x), type(y)) # 值相同type肯定相同 (<class 'str'>, <class 'str'>)
print(x is y) # is比较的是id,x与y的值相等但id可以不同 True
#案列2:
# 判断两个值是否相等
# 符号:is(比较的是内存地址) ==(比较的是值)
s1 = ['a', 'b', 'c']
s2 = ['a', 'b', 'c']
print(s1 == s2) # True
print(id(s1)) # 2795136239944
print(id(s2)) # 2795136239880
print(s1 is s2) # False
'''
值相等的内存地址不一定相等
内存地址相等的值一定相等
'''
基本运算符更详细的内容建议去 ~ 菜鸟教程:https://www.runoob.com/python/python-operators.html
五、流程控制
一 引子:
流程控制即控制流程,具体指控制程序的执行流程,而程序的执行流程分为三种结构:顺序结构(之前我们写的代码都是顺序结构)、分支结构(用到if判断)、循环结构(用到while与for)
1、顺序结构
就是自上而下的执行
2、分支结构
2.1 、什么是分支结构
分支结构就是根据条件判断的真假去执行不同分支对应的子代码
2.2、为什么要用分支结构
人类某些时候需要根据条件来决定做什么事情,比如:如果今天下雨,就带伞。所以程序中必须有相应的机制来控制计算机具备人的这种判断能力
2.3、分支结构有哪些以及注意事项
注意事项:
1. 根据条件的成立与否,决定是否执行if代码块
2. 我们通过缩进代码块,来表示代码之间的从属关系
3. 不是所有的代码都拥有子代码块
4. 我们推荐使用缩进4格
5. 同属于一个代码块的子代码块缩进量
2.3.1、单分支结构(单 if 判断)
"""
#1、单if判断
#关键字:if
#语法格式:
# if 判断条件1: # 如果条件1的结果为True,就依次执行:代码1、代码2,......
# 代码1
# 代码2
# ......
#2、双分支结构
#关键字:if
#语法格式:
# if 判断条件1: # 如果条件1的结果为True,就依次执行:代码1、代码2,......
# 代码1
# 代码2
# else:
# 条件1不成立执行的子代码块
#3、多分支结构
#关键字:if
#语法格式:
# if 条件1:
# 条件1成立执行的子代码块
# elif 条件2:
# 条件1不成立条件2成立执行的子代码块
# elif 条件3:
# 条件1、2不成立条件3成立执行的子代码块
# elif 条件4:
# 条件1、2、3不成立条件4成立执行的子代码块
# else:
# 以上条件都不成立的时候执行的代码块
# else语句是可有可无的
# 注意:
# 1、python用相同缩进(4个空格表示一个缩进)来标识一组代码块,同一组代码会自上而下依次运行
# 2、条件可以是任意表达式,但执行结果必须为布尔类型
# 在if判断中所有的数据类型也都会自动转换成布尔类型
# 2.1、None,0,空(空字符串,空列表,空字典等)三种情况下转换成的布尔值为False
# 2.2、其余均为True
"""
2.3.2、双分支结构
"""
#2、双分支结构
#关键字:if
#语法格式:
# if 判断条件1: # 如果条件1的结果为True,就依次执行:代码1、代码2,......
# 代码1
# 代码2
# else:
# 条件1不成立执行的子代码块
# 注意:
# 1、python用相同缩进(4个空格表示一个缩进)来标识一组代码块,同一组代码会自上而下依次运行
# 2、条件可以是任意表达式,但执行结果必须为布尔类型
# 在if判断中所有的数据类型也都会自动转换成布尔类型
# 2.1、None,0,空(空字符串,空列表,空字典等)三种情况下转换成的布尔值为False
# 2.2、其余均为True
"""
# 案例1:
# 如果:女人的年龄>30岁,那么:叫阿姨
age_of_girl = 31
if age_of_girl > 30:
print('阿姨好')
# 案例2:
# 如果:女人的年龄>30岁,那么:叫阿姨,否则:叫小姐
age_of_girl = 18
if age_of_girl > 30:
print('阿姨好')
else:
print('小姐好')
2.3.3、多分支结构
多 if 判断的语法
"""
#3、多分支结构
#关键字:if
#语法格式:
# if 条件1:
# 条件1成立执行的子代码块
# elif 条件2:
# 条件1不成立条件2成立执行的子代码块
# elif 条件3:
# 条件1、2不成立条件3成立执行的子代码块
# elif 条件4:
# 条件1、2、3不成立条件4成立执行的子代码块
# else:
# 以上条件都不成立的时候执行的代码块
# else语句是可有可无的
# 注意:
# 1、python用相同缩进(4个空格表示一个缩进)来标识一组代码块,同一组代码会自上而下依次运行
# 2、条件可以是任意表达式,但执行结果必须为布尔类型
# 在if判断中所有的数据类型也都会自动转换成布尔类型
# 2.1、None,0,空(空字符串,空列表,空字典等)三种情况下转换成的布尔值为False
# 2.2、其余均为True
"""
# 案例3:
# 如果:女人的年龄>=18并且<22岁并且身高>170并且体重<100并且是漂亮的,那么:表白,否则:叫阿姨**
age_of_girl = 18
height = 171
weight = 99
is_pretty = True
if age_of_girl >= 18 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:
print('表白...')
else:
print('阿姨好')
2.3.4、if 判断之嵌套
案例5:if嵌套
# 在表白的基础上继续:
# 如果表白成功,那么:在一起
# 否则:打印。。。
age_of_girl=18
height=171
weight=99
is_pretty=True
success=False
if age_of_girl >= 18 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:
if success:
print('表白成功,在一起')
else:
print('什么爱情不爱情的,爱nmlgb的爱情,爱nmlg啊...')
else:
print('阿姨好')
3、循环结构
循环结构就是重复执行某段代码块
3.1、while 循环结构
python中有while与for两种循环机制,其中while循环称之为条件循环,语法如下:
"""
while 条件:
代码1
代码2
代码3
......
while的运行步骤:
步骤1:如果条件为真,那么依次执行:代码1、代码2、代码3、......
步骤2:执行完毕后再次判断条件,如果条件为True则再次执行:代码1、代码2、代码3、......,如果条件为False,则循环终止
"""
案列如下:
#用户认证程序的基本逻辑就是接收用户输入的用户名密码然后与程序中存放的用户名密码进行判断,判断成功则登陆成功,判断失败则输出账号或密码错误
username = "jason"
password = "123"
inp_name = input("请输入用户名:")
inp_pwd = input("请输入密码:")
if inp_name == username and inp_pwd == password:
print("登陆成功")
else:
print("输入的用户名或密码错误!")
#通常认证失败的情况下,会要求用户重新输入用户名和密码进行验证,如果我们想给用户三次试错机会,本质就是将上述代码重复运行三遍,你总不会想着把代码复制3次吧。。。。
username = "jason"
password = "123"
# 第一次验证
inp_name = input("请输入用户名:")
inp_pwd = input("请输入密码:")
if inp_name == username and inp_pwd == password:
print("登陆成功")
else:
print("输入的用户名或密码错误!")
# 第二次验证
inp_name = input("请输入用户名:")
inp_pwd = input("请输入密码:")
if inp_name == username and inp_pwd == password:
print("登陆成功")
else:
print("输入的用户名或密码错误!")
# 第三次验证
inp_name = input("请输入用户名:")
inp_pwd = input("请输入密码:")
if inp_name == username and inp_pwd == password:
print("登陆成功")
else:
print("输入的用户名或密码错误!")
#即使是小白的你,也觉得的太low了是不是,以后要修改功能还得修改3次,因此记住,写重复的代码是程序员最不耻的行为。
#那么如何做到不用写重复代码又能让程序重复一段代码多次呢? 循环语句就派上用场啦(使用while循环实现)
username = "jason"
password = "123"
# 记录错误验证的次数
count = 0
while count < 3:
inp_name = input("请输入用户名:")
inp_pwd = input("请输入密码:")
if inp_name == username and inp_pwd == password:
print("登陆成功")
else:
print("输入的用户名或密码错误!")
count += 1
3.2、while + break 的使用
使用了while循环后,代码确实精简多了,但问题是用户输入正确的用户名密码以后无法结束循环,那如何结束掉一个循环呢?这就需要用到break了!
username = "jason"
password = "123"
# 记录错误验证的次数
count = 0
while count < 3:
inp_name = input("请输入用户名:")
inp_pwd = input("请输入密码:")
if inp_name == username and inp_pwd == password:
print("登陆成功")
break # 用于结束本层循环
else:
print("输入的用户名或密码错误!")
count += 1
3.3、break本层含义
break代表结束本层循环
3.4、标志位的使用
针对嵌套多层的while循环,如果我们的目的很明确就是要在某一层直接退出所有层的循环,其实有一个窍门,就让所有while循环的条件都用同一个变量,该变量的初始值为True,一旦在某一层将该变量的值改成False,则所有层的循环都结束
#案列1:
flag = True
while flag:
username=input('username:>>>')
password=input('password:>>>') #
if username == 'kevin' and password == '123':
print('欢迎光临')
while flag:
cmd=input('请输入你的指令:>>>')
if cmd == 'q':
# 结束程序
flag = False
print('正在执行你的指令:%s' % cmd)
else:
print('登录失败')
3.5、while + continue的使用
break代表结束本层循环,而continue则用于结束本次循环,直接进入下一次循环
# 打印1到10之间,除7以外的所有数字
number=11
while number>1:
number -= 1
if number==7:
continue # 结束掉本次循环,即本次循环continue之后的代码都不会运行了,而是直接进入下一次循环
print(number)
3.6、while+else的使用
在while循环的后面,我们可以跟else语句,当while 循环正常执行完并且中间没有被break 中止的话,就会执行else后面的语句,所以我们可以用else来验证,循环是否正常结束
count = 0
while count <= 5 :
count += 1
print("Loop",count)
else:
print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
循环正常执行完啦 #没有被break打断,所以执行了该行代码
-----out of while loop ------
如果执行过程中被break,就不会执行else的语句
count = 0
while count <= 5 :
count += 1
if count == 3:
break
print("Loop",count)
else:
print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
-----out of while loop ------ #由于循环被break打断了,所以不执行else后的输出语句
3.7、while循环嵌套 + break
如果while循环嵌套了很多层,要想退出每一层循环则需要在每一层循环都有一个break
username = "jason"
password = "123"
count = 0
while count < 3: # 第一层循环
inp_name = input("请输入用户名:")
inp_pwd = input("请输入密码:")
if inp_name == username and inp_pwd == password:
print("登陆成功")
while True: # 第二层循环
cmd = input('>>: ')
if cmd == 'quit':
break # 用于结束本层循环,即第二层循环
print('run <%s>' % cmd)
break # 用于结束本层循环,即第一层循环
else:
print("输入的用户名或密码错误!")
count += 1
3.8、死循环
'''在程序中,可千万不能出现死循环'''
while True:
print(100)
'''能用for循环实现的,都不要使用while循环'''
3.9、for 循环结构
循环结构的第二种实现方式是for循环,for循环可以做的事情while循环都可以实现,之所以用for循环是因为在循环取值(即遍历值)时for循环比while循环的使用更为简洁,
"""
语法格式:
for 变量名 in 可迭代对象: # 此时只需知道可迭代对象可以是 (字符串、列表、字典、元组) ,我们之后会专门讲解可迭代对象
代码一
代码二
...
# 例1
for item in ['a', 'b', 'c']:
print(item)
# 运行结果
# a
# b
# c
# 参照例1来介绍for循环的运行步骤
# 步骤1:从列表['a','b','c']中读出第一个值赋值给item(item=‘a’),然后执行循环体代码
# 步骤2:从列表['a','b','c']中读出第二个值赋值给item(item=‘b’),然后执行循环体代码
# 步骤3: 重复以上过程直到列表中的值读尽
PS:for后面的变量名命名的时候,如果没有特殊的含义,我们一般使用i,j,k,v,item等等
"""
# 简单版:for循环的实现方式
for count in range(6): # range(6)会产生从0-5这6个数
print(count)
# 复杂版:while循环的实现方式
count = 0
while count < 6:
print(count)
count += 1
重点 ~ for循环遍历字典
# 简单版:for循环的实现方式
for k in {'name':'jason','age':18,'gender':'male'}:
# for 循环默认取的是字典的key,并赋值给变量名k
print(k) # 结果是:(name,age,gender)
# 复杂版:while循环确实可以遍历字典,后续将会迭代器部分详细介绍
3.10、for循环 ~ range关键字
# 配合for循环使用
第一种玩法:
for i in range(10) # 一个参数, 打印数字列表,从0开始
print(i)
第二种玩法:
for i in range(4, 18): # 顾头不顾尾
print(i)
第三种玩法:
for i in range(2, 20, 3):# 步长 # 顾头不顾尾
print(i)
总结:
1、一个参数, 打印数字列表,从0开始
2、顾头不顾尾(左开右闭)
3、range(2, 20, 3): # 3表示步长 # 顾头不顾尾打印结果是(2 5 8 11 14 17)
# 拓展知识:
"""
推断:https://movie.douban.com/top250?start=0&filter= 第一页
https://movie.douban.com/top250?start=25&filter= 第二页
https://movie.douban.com/top250?start=50&filter= 第三页
https://movie.douban.com/top250?start=75&filter= 第四页
https://movie.douban.com/top250?start=100&filter= 第五页
...
https://movie.douban.com/top250?start=225&filter= 第十页
"""
url = 'https://movie.douban.com/top250?start=%s&filter='
for i in range(0,250,25):
print(url % i)
'''小补充:range在不同解释器版本中是有区别的。'''
3.11、for 循环嵌套
#请用for循环嵌套的方式打印如下图形:
*****
*****
*****
for i in range(3):
for j in range(5):
print("*",end='')
print() # print()表示换行
打印九九乘法表
for i in range(1,10):
for j in range(1,i+1):
print('%s*%s=%s' %(i,j,i*j),end=' ')
print()
3.12、for + break 的使用
for i in range(10):
if i == 3:
break #break代表结束本层循环
print(i) #输出为(0,1,2)
3.13、for + continue 的使用
for i in range(10):
if i == 3:
continue #continue则表示结束本次循环,直接进入下一次循环
print(i) #输出结果是:(0,1,2,4,5,6,7,8,9)
3.14、for + else 的使用
for i in range(10):
if i == 3:
break
print(i)
else:
print('哈哈哈哈') #循环正常执行完啦 #被break打断,所以不执行该行代码
for i in range(10):
if i == 3:
continue
print(i)
else:
print('哈哈哈哈') #循环正常执行完啦 #没有被break打断,所以执行了该行代码
总结
以上就是今天要讲的内容,本文仅仅简单介绍了语法知识。下篇讲解数据类型的内置方法。