第一章 python入门
阅读目录：
1.变量
2.用户与程序交互
3.基本数据类型
4.格式化输出
5.基本运算符
6.流程控制之if....else
7.流程控制之while循环
8.流程控制之for循环
9.开发工具ide
10.扩展阅读
11：作业
1.变量
#编码
中文编码有万国码（unicode）、utf8、gbk
其中utf8中文占三个字节，gbk中文占两个字节，一个字节等于八位
其中utf8可以跟unicode相互转化
gbk可以转变成unicode unicode做中文处理的时候可以与gbk转化
1.变量必须由字母数字下划线组成 2.数字不能作为开头 3.不能是python中的关键字，最好不要跟python中内置的东西重复
定义变量会有 id type value
注意：1.=比较的是vlaue
2.is 比较的是id
强调：1.id相同，意味着type跟value必定相同
2.value相同type不也相同，id可能不相同：
x='juxianwen'
y='juxianwen'
id(x)
4376607152
id(y)
4376607408
x==y
true
x is y
false
#1.在交互模式下
python实现int的时候由小数池。为了避免因为创建相同的值而重复申请内存空间所带来的效率问题，python解释器会再启动时创建出小数池，
范围是[-5,256]，在该范围内的整数对象是全局解释器范围内被重复使用，永远不会被回收。（也就是说创建出来这个范围内相同的数字的id
相同）
#在pycharm中
在pycharm中会过大这个范围
常量
常量是指不变的量，程序员约定俗成的用变量名全大写表示常量
#ps 在c语言中有专门的常量定义语法，const、int、count，一旦定义为常量，更改便会报错
2.用户与程序交互
#在python3中 input：用户输入的任何值，都存成字符串类型 #在python2中 input：用户输入什么类型，就存什么类型 raw_input:等于python3的input
完成一个用户程序交互：1.提醒用户输入用户名跟密码
2.获取用户名跟密码，如果用户名是：root 密码是：root 提示正确登录，否则登录失败
1 name=input('请输入用户名：')
2 pass_world=input('请输入用户密码：')
3 if name=='root' and pass_world=='root':
4 print('登录成功')
5 else:
6 print('登录失败')
代码注释原则：
#1 不用全部都加注释，只是把自己觉得难理解的地方加上注释
2. 注释可以用中文也可以用英文但是不要用拼音
3.单行注释用# 多行注释用三对双引号""" """
三 基本数据类型
数字
#int 整型
定义：age=10 #age=int(10)
功能：用于标识 工资 身高 体重
#int整形了解部分
在32位机器上，整型的位数为32位，取值范围为 -2**32~2**32-1
在64位系统上，整型的位数为64位，取值范围为-2**63~2**63-1
#long长整型
跟c语言不同，python的长整型没有指定位宽，即：python没有限制长整型的数值大小，但由于机器内存有限制所有我们使用的长整型不能
无限大。
注意在python2.2以后，如果整型发生溢出，那么python自动将整数数据转化为长整数，所以现在长整数数据后面不加字母l也不会产生严重
后果。
注意自python3以后不再有长整型，全部是int
整型的功能
1.如何将其他形式转化为整型：
若a='123'
b=int(a) 这样子b=123 b就变成了一个整型
num='0011'
int（num，base=2）base=2是指以二进制的形式输出0011，base=16，是以16进制的形式进行输出，所以这个程序就是将0011以二进制的 形式进行转化为十进制，所以输出以后为3.
2.__.bit_length()的功能
这个的功能是这个数字用二进制表示至少需要几位
例如：age=10
r=age.bit_length()
print(r)
字符串
#在python中，加了引号的字符就是字符串类型，python并没有字符类型。
定义：name='jxw' 相当于name=str(jxw)
用于标识：描述性内容，如姓名、性别等
len,join,for,索引切片 在别的数据结构中也能用
#那么单引号、双引号、多引号有什么区别呢？
单双引号没有什么区别，只有在下面这种情况你需要考虑单双号的配合。
msg=" i'am a"
多引号用于进行多行注释。
#字符串的加减
name='jxw'
age='18'
name+age 输出的是 jxw18 类型是字符串
name*5 输出的是 jxwjxwjxwjxwjxw 类型是字符串
注意1：字符串相加的效率不高
字符串1+字符串2，并不会在字符串1的基础上加上字符串2，而是申请一个全新的内存空间，存放字符串1和字符串2，所以占用了内存。
注意2：只能字符串加字符串，不能字符串加其他类型
#字符串的功能
1.字符串首字母大写
text='alex'
v=test.capitalize()
print(v) 输出的是alex
2.大写变成小写
test.casefold() 这条命令是不管什么国家的语言都可以变成小写
test.lower() 这个是只能英文字符大写转化为小写
3.填补功能
test='alex'
v=test.ceter(20)
print(v)
输出的是 alex 空格加alex总共为20位
v=test.cete(20,'*')
print(v)
输出的是********alex********
4.计算字符串中某个字符的个数
test='alexalex'
v=test.count('e')
计算e在alexalex中出现多少次
v=test.count('ex',1,6)从第二个位置到第七个位置ex出现了多少次，但是不包括第二个位置跟第七个位置
5.判断以什么结尾，以什么开头
test='alex'
test.endwith('a',1,3) 看alex 在它的第二个位置到第四个位置是不是以a结尾的（包括第四个位置）
test.startwith('a') 看alex是否以a开头
6.寻找目标所在位：
test='alexalex'
v=test.find('ex',1,4) 在第二个位置跟第五个位置寻找ex在哪个位置（不包括第五个位置），寻找到第一个ex就不往后找了
7.将字符串中的占位符替换成指定的值
test='i am {name},age{a}'
test.format(name='alex',a=19) 输出i am alex，age19
相当于test='i am {name},age{name}'.format(**{name:'alex',age:19})字典形式得加**
test='i am {0},age{1}'test.format('alex',19) 输出i am alex，age19 按照顺序来的先0后1
test='i am {name}'.format('name'='xa')
test.format_map({'name':'alex'})输出的是 i am alex
test='{0},{0}'.format(1,2,3)输出的是11
test='i am {0[1]}'.format([1,2,3],[123])输出的[1,2,3]中的第二个元素 即 i am 2
test='{:s} {:d} {:f}'.format('sex',1,1.2) :s接受字符串 :d接受数字 :f接受浮点数 输出的是 sex 1 1.2
test='{:s} {:d}'.format(*['sex',12]) *['sex',12]是指的是输入整个列表 输出的是 sex 12
test='{:b}(输入二进制) {:o}(输入八进制) {:d}(输入整型) {:x}（16进制 输入小写abcd） {：x}（输入16进制 输入大写abcd）
{.%}(显示百分比默认显示小数点6位)'.format(15,1,15,15,15,15,8,2)
8.寻找字节在哪个位置
text=’alexalex’
v=text.index(‘a’,4,5)
寻找a在哪个位置，如果没有4，5则默认从第零位开始，否则从第四位查找（包括第四位）到第五位结束（不包括第五位），
遇到一个a直接输出a的位置，这个a以后的则不查找，也就是说查找第一个a所在的位置。
9.判断字符串是否只包含字母与数字
test.isalnum 是的话是true不是的话flase
10.断句换行功能
expandtabs（a）在a个字符之内遇到\t直接用空格填充到6
比如：s='uba\tk'
a=s.expandtabs(6)输出的是uba k总共位
断句，先将前6个拿出来无tab忽略再找6个，找到\t后补充到6个
11.判断是否全为字母跟汉字
text.isalpha（） 全是输出true 反之输出flase
12.判断是否全为数字
test.isdecimal() 这个甚至可以判断特殊的数字比如① 二
test.isdigit()只能判断普通的数字
12.判断是否为标识符
标识符=有字母数字下划线组成（字母不开头）
test.isidentifier()是的话true反之flase
13.islower（）判断是否为小写
14.判断是否可以打印
什么叫做可打印：如果存在\t,\n这些不可现实的字符就是不可打印
test.isprintable() 可打印true反之false
15.判断是否全为空格
test.isspace（）判断是否全为空格
16.判断是否为标题
什么是标题：所有单词的首字母大写就是标题
test.istitle()
17.将字符串中的每个元素按照指定分隔符进行拼接
join(self,iterable)
test='你是风儿，我是沙'
t=' '
v=t.join(test) 输出 你 是 风 儿 ， 我 是 沙
18.填充字符
右填充 ljust
v='alex'
a=v.ljust(5,'*') 输出的是*alex
左填充
v='alex'
a=v.rjust(5,'*')输出的是alex*
左填充0（只能填充0）
v='alex'
a=v.zfill(5)输出的是0alex
19.判断字符串是否全为大写
test.isupper()
20.消除指定字符串
消除空格
test.strip()消除两边空格
test.lstrip()消除左边空格
test.rstrip()消除右边空格
\n \t 也可以消除
test='\nalex'
v=test.lstrip()这样输出的也是alex
消除指定的元素
test='xalex'
v=text.lstrip('x') 输出的是alex
21.转变字符串的特定内容
test='你是风儿我是沙'
text1='去你妈的风和沙'
v='你是风儿我是沙，缠缠绵绵去你家'
将v中test内容换成test1中的内容
m=v.maketrans('你是风儿我是沙'，'去你妈的风和沙')
new_v=tanslate（m）
22.分割
test='testastsd'
test.partition('s') 输出的是 'te','s','tastsd' 只分割第一个s
test.rpartition('s')从右起第一个s作为分割 'testast','s','d'
test.split('s') 'te','ta','t','d'
可以指定分割次数test.split('s',1)输出的是'te','tastsd'
从右开始分割 test.rsplit('s')
22.根据换行符进行分割
test='a\na\n'
v=test.splitlines()输出的['a','a']
v=test.splitlines(true)输出的是['a\n','a\n']
v=test.splitline(flase)输出的是['a','a']
23.大小写转换
test='alex'
v=test.swapcase() 输出的是alex
24.字符串的索引，切片，长度功能
test='alex'
索引 test[0] 输出的是a
切片 test[0:1] 输出范围 0=<x<1
test[0:-1]输出的范围是第一位到最后一位
长度 test='你是猪'
len(test)在python3中输出的是三，在python2中输出的是9 因为utf8中一个汉字占三位
li=['2','1','0']
len(li)输出的是三
for zjw in test:
print(zjw)
相当于：
index=0
while index <len(test):
v=test[index]
print(v)
index=index+1
25.替换
test='alexalexalex'
test.replace('ex','bbb')输出的是albbbalexalex
test.replace('ex','bbb',2)输出的是albbbalbbbalex
26.创建连续的数字
v=range(100)
print(v) 输出的是range(100)
for i in v:
print(i) 输出的是0到99
也可以设置步长
v=range(0,100,5)
for i in v:
print(i)输出的是0 5 10 。。。。
#习题 将 文件索引打印出来
test=input('')#需要打印索引的内容
l=len(test)
r=range(0,l)
for k in r:
print(k,test[k])
列表
#在[]内用逗号分隔，可以存放n个任意类型的值
定义：students=['1','2','3']
#students=list(['1','2','3'])
用于标识：存储多个值得情况，比如一个人的多个爱好
#存放多个学生的信息：姓名，年龄，爱好
student_info=[['egon',18,['play']],['alex',18,['play','sleep']]]
student_info[0][2],[0] 输出的是play
列表可以有索引、切片
列表可以进行for，while 自然也支持break contiune
链表：因为列表存储不是连续存的，就是在第一个位置里存放着第二个位置的坐标。正因为列表存储不连续，所以列表可以修改
比如：列表第一个位置为20
li[0]=120 第一个位置就由20变成120
1.删除，修改功能
del li[1] 将li的第二个位置删除掉
del li[2:6]删除li的 3,4,5,6位置的元素
li[1:3]=[120,90]第二位换成120，第三位换成90
2.列表中是否有这个元素
v=12 in li
print(v)如果12在li中输出的true 如果不在输出flase
3.取列表的特定的值
li=[1,12,9,8,['1',['19',10]],'alex',true]
li[4][1][0] 输出的是19
4.字符串转化为列表的原理
s='1234'
list(s)
这个原理是
list=[]
for i in s:
list=list.append(i)
li=[1,2,3]
str(li）输出的是'[1,2,3]'
5.末端插入
li=[1,2,3]
li.append(5)
print(li)输出的是[1,2,3,5]
5.清空列表
li.clear()
6.浅拷贝
li.copy
7.计算列表中元素出现了多少次
v=li.count(22)看列表li中22出现了多少次
8.扩展列表，参数为可迭代对象
li=[11,22,33,44,55]
li=extend([98,12])
print(li) 输出的是[11,22,33,44,55,98,12]
9.从左往右找值，找到第一个就不继续找下去了
li=[11,22,33,44,55]
v=li.index(22) #index(x,start,end)
10.在指定位置插入一个值
li=[11,22,33]
li.insert(0,99)
print(li)输出的是[99,11,22,33]
11.删除指定位置元素，并且可以获取到这个元素
li=[1,2,3]
v=li.pop()
print(v)输出的是3
v=li.pop(1)删除第二个位置的元素,并获取这个值赋值给v
12.删除指定元素
li.remove(22)删除从左到右第一个22
13.将列表进行翻转
li=[1,2,3]
li.reverse()
print(li)输出的是[3,2,1]
14.进行排列
li=[11,44,22,33,22]
li.sort
print(li) 输出的是[11,22,22,33,44]
li.sort(reverse=true)
print(li)输出的是[44,33,22,22,11]
#练习题
1.l=[1,2,3,4,5,6]
正向步长：l[0:3:1] 输出的是[1,2,3]
反向步长：l[2：：-1]输出的是[3,2,1]
列表翻转：l[::-1]输出的是[6,5,4,3,2,1]
2.用列表data=['alex',49,[1900,3,18]],分别取出列表中名字，年龄，出生的年，月，日赋值给不同的变量
data[0]输出的是 alex
data[1]输出的是 49
data[2]输出的是 [1900,3,18]
元组
列表：有序、[]、可以增删
元组：li=（1,2）小括号，可以查看li[0]（这里就已经证明元组是有序的）,li[0:6]，但是不可以修改跟删除,可迭代 for i in li：
因为可以迭代所以 元组列表
字符串可以相互转化。注意：元组的一级元素不可修改、删除、增加，但是二级元素确不一定不可以修改。
元组的join可以用
tu=（'asdf','asdf'）
v='_'join(tu)输出的是asdf_asdf
count计数
index获取指定元素在元组中的索引
字典
字典的作用：可以存放多个任意类型的值，并且可以硬性规定值得映射关系。
#在{}内用逗号分隔，可以存放多个key，value的值，其中value可以是任意值，key只能是数字、字符串、布尔值，每一个值都有唯一一个
key对应，可以更为高效方便的取值。
注意：key重复时只能保留一个
布尔值作为key时，true相当1，所以数字1跟true同时存在的时候只保留一个。false相当于数字0.
info={
'name':'se',
'hobbies':['play','sleep'],
'company_info':{
'name':'oldboy',
'type':'edu'
'emp_num':40
}
}
print(info['company_info']['name']} 输出的是 oldboy
del infor('name') name:se 这个键值对就被删除了
注意：字典不可以被while循环，但是可以进行for循环。
for i in infor: 相当于 for i in infor.keys(): 默认输出的是key
for i in infor.values(): 这个是只循环初values
for i,v in infor.items(): 这个是将key value 都循环出来。
v='v1' in dic.values() 判断v1在没在value中出现
字典的功能：
1.clear清空功能
2.copy复制功能
3.fromkeys（直接写类名）根据序列创建字典，并指定统一值。
v=dict.fromkeys(['k1',123,'99'])
print（v)输出的是{123:none,'k1':none,'999':none}
4.字典的取值功能
v=dic.get('k1')取到k1这个键对应的值，如果没有输出none
v=dic.get('k11',111)输出k11键对应的那个值，如果没有输出111
5.字典的删除功能
v=dic.pop('k1')删除k1对应的那对键值对
print(k1)输出k1那个键对应的那个值
v=dic.pop('k1',111)
print(v)如果字典中本来没有k1 这样就输出111
6.设置默认值
v=dic.setdefault('k1','123')如果k1存在则k1不设置成123，print(k1)将输出字典中的k1
如果k1不存在，那么将k1作为键123作为值放入字典中，print（dic['k1']）输出的是123
7.更新
dic.update({'k1':'1111','k2'=123}) 相当于 dic.(k1='1111',k2=123)
如果dic中k1已经存在，那么久覆盖掉，如果不存在更新上。
布尔值
#布尔值 一个true 一个false
bool（a）将a转化为布尔值
#所有类型都自带布尔值
1.none，0，空 都为false
2.其余值都为true
重点
#可变类型：在id不变的情况下，value可变，则称为可变类型，如列表、字典。
#不可变类型：value一旦改变，id也得变，则成为不可变类型（id变，意味着创立新的内存空间）
集合
#作用：去重、关系运算
#集合的定义：
1.集合可以包括多个元素，用逗号分割开
2.每个元素必须是不可变类型（可hash，可作为字典key）
3.没有重复元素
4.无序
例：s=set('hello')
print(s)输出的是{'h','e','l','o'}
s=set(['alex','alex','sb'])
print(s)输出的是{'alex','sb'}
#集合的功能
1.添加元素
s={1,2,3}
s.add('s')
print(s)输出的是{1,2,3，s}
2.清空功能
s.clear()
print(s) 输出的是set（）
3.复制功能
s1=s.copy()
这个我相当于s1==s
4.删除功能
v=s.pop()这个是随机删除
v=s.remove(1)指定删除元素1，如果没有1，则会报错
v=s.discard（1）指定删除元素1，如果没有1也不会报错
5.交集
python_1=['lv','gh','gg']
linux_1=['lv','cnm','nmb']
python_and_linux=[]
for i in python_1:
if i in linux_1:
python_and_linux.append(i)
python_and_linux=set(python_and_linux)
这段程序相当于 p_s=set(python_1)
l_s=set(linus_1)
print(p_s.intersection(l_s)) 相当于 print(p_s&l_s)
6.并集
print(p_s.union(l_s)) 相当于 print(p_s|l_s)
7.差集：p_s中减去p_s与l_s的交集
print(p_s.different(l_s))相当于print(p_s-l_s)
进行差集以后，p_s与l_s并没有改变
p_s=p_s-l_s 相当于 p_s.different.updata(l_s) p_s就更新为 p_s-l_s
8.交叉补集：p_s并上l_s在减去p_s交上l_s
print(p_s.symmetric_difference(l_s)) 相当于 print(p_s^l_s)
9.判断s1，s2集合是否为空
print(s1.isdisjoint(s2))若是为空则输出true
10.子集，复集 若s1为s2的子集，那么s2为s1的复集
子集：print(s1.issubset(s2))如果是子集输出true
复集 ：print(s2.issuperset(s1))如果 s2>=s1那么输出true
11.不可变集合：
s=forzenset('hello')
通过这个命令形成的集合不可增加也不可删除
有如下列表
l=[
{'name':'alex','age' :18,'sex'='male'}
{'name':'egon','age' :73,'sex'='male'}
{'name':'alex','age' :20,'sex'='female'}
{'name':'alex','age' :18,'sex'='male'}
{'name':'alex','age' :18,'sex'='male'}
],去重，得到新列表并且保留原来顺序。
a=[{'name': 'egon', 'age': 18, 'sex': 'male'},
{'name': 'alex', 'age': 73, 'sex': 'male'},
{'name': 'egon', 'age': 18, 'sex': 'female'},
{'name': 'egon', 'age': 18, 'sex': 'male'},
{'name': 'egon', 'age': 18, 'sex': 'male'},
]
b=[]
num=len(a)
while num>0:
num=num-1
v=a.pop()
for i in a:
if i['name']==v['name'] and i['age']==v['age'] and i['sex']==v['sex']:
a.remove(i)#当a发生改变时直接跳出for 循环
a.append(v)
print(a)
数据类型总结
按存储空间的占用分（从低到高）
数字 字符串 集合：无序，即无序存索引相关信息 元组：有序，需要存索引相关信息，不可变 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改 字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
四 格式化输出
程序中经常会有这样场景：要求用户输入信息，然后打印成固定的格式
比如要求用户输入用户名和年龄，然后打印如下格式：
my name is xxx，my age is xxx.
很明显，用逗号进行字符串拼接，只能把用户输入的名字和年龄放到末尾，无法放到指定的xxx位置，而且数字也必须经过str(数字)的转换才能与字符串进行拼接。
这就用到了占位符，如：%s、%d
#%s字符串占位符：可以接收字符串，也可接收数字
print('my name is %s,my age is %s' %('egon',18))
#%d数字占位符：只能接收数字
print('my name is %s,my age is %d' %('egon',18))
print('my name is %s,my age is %d' %('egon','18')) #报错
#接收用户输入，打印成指定格式
name=input('your name: ')
age=input('your age: ') #用户输入18,会存成字符串18,无法传给%d
print('my name is %s,my age is %s' %(name,age))
#注意：
#print('my name is %s,my age is %d' %(name,age)) #age为字符串类型,无法传给%d,所以会报错
浮点数（小数）的格式化：
tp1='percent %f'%99.975 这个%f 默认保留6位 所以输出的是percent99.975000
tp1='percent%..2f'%99.9765 这个保留两位小数 输出的是 percent99.97
tp1='percent%..2f%%'%99.222 这个%%是指输出% 输出的是percent99.22%
字典的形式格式化：
tp1='i am %(name)s age %(age)d '%{'name':'alex','age':19}输出的是 i am alex age 19
print中的sep分割：
print（'root','x','0','0',sep=':'）这个值得是以：分割 输出的是 root：x：0:0:
五 基本运算符
计算机可以进行的运算有很多种，可不只加减乘除这么简单，运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算，今天我们暂只学习算数运算、比较运算、逻辑运算、赋值运算
算数运算
以下假设变量：a=10，b=20
比较运算
以下假设变量：a=10，b=20
赋值运算
以下假设变量：a=10，b=20
逻辑运算
#三者的优先级从高到低分别是：not，or，and >>> 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3 false #最好使用括号来区别优先级，其实意义与上面的一样 >>> (3>4 and 4>3) or ((1==3 and 'x' == 'x') or 3 >3) false
身份运算
#is比较的是id #而==比较的是值
六控制流程之 if....else语句
既然我们编程的目的是为了控制计算机能够像人脑一样工作，那么人脑能做什么，就需要程序中有相应的机制去模拟。人脑无非是数学运算和逻辑运算，对于数学运算在上一节我们已经说过了。对于逻辑运算，即人根据外部条件的变化而做出不同的反映，比如
# 如果:今天是monday,那么:上班
# 如果:今天是tuesday,那么:上班
# 如果:今天是wednesday,那么:上班
# 如果:今天是thursday,那么:上班
# 如果:今天是friday,那么:上班
# 如果:今天是saturday,那么:出去浪
# 如果:今天是sunday,那么:出去浪
#方式一：
today=input('>>: ')
if today == 'monday':
print('上班')
elif today == 'tuesday':
print('上班')
elif today == 'wednesday':
print('上班')
elif today == 'thursday':
print('上班')
elif today == 'friday':
print('上班')
elif today == 'saturday':
print('出去浪')
elif today == 'sunday':
print('出去浪')
else:
print('''必须输入其中一种:
monday
tuesday
wednesday
thursday
friday
saturday
sunday
''')
#方式二：
today=input('>>: ')
if today == 'saturday' or today == 'sunday':
print('出去浪')
elif today == 'monday' or today == 'tuesday' or today == 'wednesday' \
or today == 'thursday' or today == 'friday':
print('上班')
else:
print('''必须输入其中一种:
monday
tuesday
wednesday
thursday
friday
saturday
sunday
''')
#方式三：
today=input('>>: ')
if today in ['saturday','sunday']:
print('出去浪')
elif today in ['monday','tuesday','wednesday','thursday','friday']:
print('上班')
else:
print('''必须输入其中一种:
monday
tuesday
wednesday
thursday
friday
saturday
sunday
''')
七 流程控制之while循环
条件循环：while，语法如下
while 条件:
# 循环体
# 如果条件为真，那么循环体则执行，执行完毕后再次循环，重新判断条件。。。
# 如果条件为假，那么循环体不执行,循环终止
#打印0-10
count=0
while count <= 10:
print('loop',count)
count+=1
#打印0-10之间的偶数
count=0
while count <= 10:
if count%2 == 0:
print('loop',count)
count+=1
#打印0-10之间的奇数
count=0
while count <= 10:
if count%2 == 1:
print('loop',count)
count+=1
死循环
import time
num=0
while true:
print('count',num)
time.sleep(1)
num+=1
循环嵌套与tag
tag=true while tag: ...... while tag: ........ while tag: tag=false
#练习，要求如下：
1 循环验证用户输入的用户名与密码
2 认证通过后，运行用户重复执行命令
3 当用户输入命令为quit时，则退出整个程序
#实现一：
name='egon'
password='123'
while true:
inp_name=input('用户名: ')
inp_pwd=input('密码: ')
if inp_name == name and inp_pwd == password:
while true:
cmd=input('>>: ')
if not cmd:continue
if cmd == 'quit':
break
print('run <%s>' %cmd)
else:
print('用户名或密码错误')
continue
break
#实现二：使用tag
name='egon'
password='123'
tag=true
while tag:
inp_name=input('用户名: ')
inp_pwd=input('密码: ')
if inp_name == name and inp_pwd == password:
while tag:
cmd=input('>>: ')
if not cmd:continue
if cmd == 'quit':
tag=false
continue
print('run <%s>' %cmd)
else:
print('用户名或密码错误')
continue break
break 是直接结束所有循环 continue结束当前循环在会到本层循环重新开始循环
while 1==1：（break直接回到这里并且结束这里）
while 1==1：(while 是结束循环回到这里并且继续执行循环)
a=input（'请输入'）
if a=='a':
contiune
else:
break
while+else
#与其它语言else 一般只与if 搭配不同，在python 中还有个while ...else 语句，while 后面的else 作用是指，当while
循环正常执行完，中间没有被break 中止的话，就会执行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 循环正常执行完啦 -----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 ------
while循环练习题
#1. 使用while循环输出1 2 3 4 5 6 8 9 10
#2. 求1-100的所有数的和
#3. 输出 1-100 内的所有奇数
#4. 输出 1-100 内的所有偶数
#5. 求1-2+3-4+5 ... 99的所有数的和
#6. 用户登陆（三次机会重试）
#7：猜年龄游戏
要求：
允许用户最多尝试3次，3次都没猜对的话，就直接退出，如果猜对了，打印恭喜信息并退出
#8：猜年龄游戏升级版
要求：
允许用户最多尝试3次
每尝试3次后，如果还没猜对，就问用户是否还想继续玩，如果回答y或y, 就继续让其猜3次，以此往复，如果回答n或n，就退出程序
如何猜对了，就直接退出
#题一
count=1
while count <= 10:
if count == 7:
count+=1
continue
print(count)
count+=1
count=1
while count <= 10:
if count != 7:
print(count)
count+=1
#题目二
res=0
count=1
while count <= 100:
res+=count
count+=1
print(res)
#题目三
count=1
while count <= 100:
if count%2 != 0:
print(count)
count+=1
#题目四
count=1
while count <= 100:
if count%2 == 0:
print(count)
count+=1
#题目五
res=0
count=1
while count <= 5:
if count%2 == 0:
res-=count
else:
res+=count
count+=1
print(res)
#题目六
count=0
while count < 3:
name=input('请输入用户名：')
password=input('请输入密码：')
if name == 'egon' and password == '123':
print('login success')
break
else:
print('用户名或者密码错误')
count+=1
#题目七
age_of_oldboy=73
count=0
while count < 3:
guess=int(input('>>: '))
if guess == age_of_oldboy:
print('you got it')
break
count+=1
#题目八
age_of_oldboy=73
count=0
while true:
if count == 3:
choice=input('继续(y/n?)>>: ')
if choice == 'y' or choice == 'y':
count=0
else:
break
guess=int(input('>>: '))
if guess == age_of_oldboy:
print('you got it')
break
count+=1
for循环
for i in range（1,9）：
for t in range(1,i):
print(i)
break
输出的是 2,3,4,5,6,7,8为什么从2开始输出，因为开始i是1所以变成for t in range（1,1）这个自动结束重新进行 for i in range（1,9）就从2开始
上一篇： 原生Ajax详解