Python基础知识
Python历史
一、历史
Python之父，荷兰人Guido van Rossum（吉多·范罗苏姆）。他于1982年从阿姆斯特丹大学取得了数学和计算机硕士学位。1991年，Python的第一个解释器诞生了。之所以选中Python（大蟒蛇的意思）作为程序的名字，是因为他是一个叫Monty Python的喜剧团体的爱好者。
二、应用领域
Python 语言除了在自动化测试领域有出色的表现外，在系统编程，网络编程，web 开发，GUI开发，科学计算，游戏开发、网络应用、网站后台、 爬虫服务、系统工具、大数据、人工智能、自动化测试等多个领域应用非常广泛，而且具有非常良好的社区支持。也就是说学习和掌握python 编程，其实是为你打开了一道更广阔的大门。
三、优点
1.易于维护和学习，语法简单；
2.提供了广泛的库，既可以开发小工具也可以开发企业级应用，功能强大；
3.面向对象，免费开源。
四、缺点
1.解释性语言（先翻译成中间代码，再由解释器对中间代码进行解释运行），执行速度慢
2.代码无法加密，直接运行代码，不是运行程序
五、选择Python的理由
1.测试人员的编程能力普遍不是很强，而Python作为一种脚本语言，不仅功能强大，而且语法优美，支持多种自动化测试工具，而且学习上手比较容易。
2.Python的社区发展比较好，有着非常多的文档和支持库，另外Python也可以在Web开发、数据处理、科学计算等纵多领域有着非常好的应用前景。
3.对于有一定编程基础的人员，使用Python作为自动化测试的语言可以非常顺畅的转换，几乎没有学习成本。
第一行代码
一、创建一个项目
路径最好不要有中文
项目名称最好不能有空格
项目名称最好不能数字开头
二、创建python文件
文件名称最好不能有空格
文件名称最好不能数字开头
头文件设置
三、打印输出
name = "hello word"
age = 18
1.# 换行输出
print(name)
print(age)
print('---------')
2.# 不换行输出
print(name, end=" " )
print(age, end=" " )
3.#格式化输出
print(“我的名字叫{}”.format('小明')）
4.#打印输出换行
print('\n')
5.#打印输出空格
print('\t)
6."+"号
注：+号两边的数值类型必须一致
name = "小明"
print("我的名字是：" + name)
7.”,”号
name = "码上开始"
print("我的名字是：" , name)
8.运算
a=10
b=20
print(a*b)
四、输入
input(“请输入你的名字：“）
输入值类型为字符串
五、注释
1.单行注释
# 第一个注释
print ("Hello, 码上开始!") # 第二个注释
2.多行注释
多行注释可以用多个 # 号，还有 ''' 和 """：
# 第一个注释
# 第二个注释
'''
第三注释
第四注释
'''
"""
第五注释
第六注释
"""
六、变量与常量
常量就是普通字符串
变量就是定义之后还能发生改变，可以重新赋值的量；
是与常量相对而言，python里 a = 1 就算是声明一个变量 a, 然后重新赋值a = 10，a的值就变成了10了
七、变量的类型
1.数值类型：整数、浮点数、布尔数、复数
2.非数值类型：字符串，字符串的表现是单双引号
3.对象类型：列表、元组、字典
八、运算符：
1.算数运算符
a=10，b=20，c=4
（1）加+
print(a+b)
结果：30
（2）减-
print(b-a)
结果：10
（3）乘 *
print(a*b)
结果：200
（4） 除/
print(b/a)
结果：2
（5）取余%
print(a%c)
结果：2
（6） 返回商的整数//
print(a//c)
结果：2
（7）幂 **
print(a**c)
结果：10000
2.比较运算符
（1）等于==
（2）不等于！=
（3）小于<
（4）大于>
（5）大于等于>=
（6）小于等于<=
3.赋值运算符
（1）赋值=
a=10
（2）加法赋值
a+=b 相当于a=a+b
（3）乘法赋值
a*=b 相当于a=a*b
（4）减法、除法、幂等以此类推
4.逻辑运算符
（1）且、与and
x and y x和y都为真才为真，才返回True，否则返回False
print(10>2 and 20<5)
返回False
（2）或or
x or y x和y只要有一个为真
print(10>2 or 20<5)
返回True
（3）不not
print(not(10>2 and 20<5))
返回True
5.成员运算符
（1）in
如果在指定的序列中找到值返回 True，否则返回False。
（2）not in
如果在指定的序列中没有找到值返回 True，否则返回 False。
6.身份运算符
（1）is 是判断两个标识符是不是引用自一个对象
（2）is not 是判断两个标识符是不是引用自不同对象
7.运算符优先级
九、标识符
1.定义：Python 对各种 变量、方法、函数等命名时使用的字符序列称为标识符。
2.命名规则
（1）由 26 个英文字母大小写，0-9 ，_ 组成。
（2）不能以数字开头。
（3）严格区分大小写。
（4）不能包含空格、@、% 以及 $ 等特殊字符。
（5）不能以系统保留关键字作为标识符。
十、关键字
1.定义：关键字是预先保留的标识符，每个关键字都有特殊的含义。（在编译器中显示为深蓝色的特殊字符）
2.包含：
and、or、class、def、if、else、elif、for、while、True、False、try、expect、raise、Finally、as、break、continue、from、global、import、in、is、not、pass、return、with、assert、None、del、lambda、nonlocal、yield
3.判断方法：
keyword.iskeyword('and')
如果是关键字，返回 True；否则，返回 False。
十二、传统的格式化输出%
a.输出整数 %d
举例：将45.123输出为整数
print('%d'%45.123)
结果：45
b.输出浮点数 %f
举例：将45输出为浮点数
print('%f'%45)
结果：45.000000
c.指定输出小数点位数：%.2f
举例：将45.123输出为保留俩位数的浮点数
print('%.2f'%45.123)
结果：45.12
d.输出字符串%s
举例：将45.123输出为字符串
print(type('%s'%45.123))
结果：<class 'str'>
e.字符串截取%.2s保留2个长度的字符串
举例：将字符串'dsfgd'保留2个长度的字符串
print('%.2s'%'dsfgd')
结果：ds
f.百分数
举例：将45转化为百分数输出
print('%.f%%'%45)
结果：45%
十三、习题
1.手动输入自己的名字，使用三种方式输出我的名字叫什么
name=input("请输入自己的名字：")
print("我的名字叫：",name)
print("我的名字叫："+name)
print("我的名字叫：{}".format(name))
2.请用知道的方法，注释掉以下语句
print("hello Spon")
print("我的名字叫小邦")
3.请写出变量的三种类型，并且写出各自包含的内容
①数值类型：浮点数、整数、复数、布尔数
②非数值类型：字符串
③对象类型：列表、字符串、字典
4. 请判断以下可以作为标识符的变量有哪些
①input_name ②886 ③for ④insert ⑤num2 ⑥True ⑦print ⑧CHeck ⑨xiaoming@ ⑩ hello world ⑪return ⑫music%s ⑬_root ⑭FileName ⑮add. ⑯-replace ⑰print^name ⑱i1s ⑲index ⑳format
① ④ ⑤ ⑦ ⑧ ⑬ ⑭ ⑱ ⑲ ⑳
5.请写出下列输出语句
a=15.15645 b='fgxfdbg'
（1）请将a保留3位小数输出
print('%.2f'%a)
（2）请将a输出为整数
print('%d'%a)
（3）请将b保留3位字符输出
print('%.3s'%b)
（4）请将a保留2位小数并且输出为百分数
print('%.2f%%'%a)
6.请写出变量的命名规则
（1）由26个字母，0-9数字，下划线组成
（2）不能以数字开头
（3）不能包含特殊字符%￥#@.&*
（4）不能直接引用关键字
7.a=4，b=10，c=30，请写出a、b、c的和，c除以a的余数及其商的整数，b的a次方幂
print(a+b+c)
print(c%a)
print(c//a)
print(b**a)
序列类型
一、列表list
列表是python最基本的数据结构，它的下标是从0开始,列表值是放在方括号内
列表定义
list = ["码上开始", 1, 'hello']
1.访问列表的值
（1）下标索引取值：列表内部的元素是有顺序的，从0开始，可以通过下标获取对应的值
print(list[0])
结果："码上开始"
print(list[-1])
结果： 'hello'
（2）index：查找位置
print(list.index('hello'))
结果：2
（3）count：查找列表值出现的次数
print(list.count('hello'))
结果：1
（4）sort：字母或者数字默认按升序排列
list1 = ['dsvd','zgbd','hjs']
list2= [12,52,1]
list1.sort()
list2.sort()
print(list1)
print(list2)
结果：['dsvd','hjs','zgbd']
结果：[1,12,52]
2.更新列表的值
修改元素的值：列表是可变类型数据，可以通过下标修改制定位置的元素
list[1] = 3
结果：["码上开始", 3, 'hello']
3.增加列表数值
（1）list.append(3)#值
结果：["码上开始", 1, 'hello'，3]
（2）list.insert(1,123)#位置，值
结果：["码上开始", 123，1, 'hello']
（3）extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list1 = [123, 'xyz', 'zara', 'abc', 123]
list2 = [2009, 'manni']
list1.extend(list2)
print(list1)
结果： [123, 'xyz', 'zara', 'abc', 123，2009, 'manni']
4.删除列表数值
list.pop(2)#位置
结果：["码上开始", 1]
list.remove(1)#值
结果：["码上开始", 'hello']
list.clear()#删除全部
结果：[]
二、元组tuple
1.元组定义：
（1）Python 的元组与列表类似，不同之处在于元组的元素不能修改。
（2）元组使用小括号，列表使用方括号。
（3）元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
（4）定义元组：
tuple = (1, "码上开始"，“hello”)
tuple=（1，）只有一个数据的时候需要注意加逗号
（5）访问元组，下标索引取值：列表内部的元素是有顺序的，从0开始，可以通过下标获取对应的值
print(tuple(0))
（6）修改元组（重点：元组是不能修改值）
三、字典dict
1.定义：字典的每个键值对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所
示：
dict = {key1 : value1, key2 : value2 }
2.创建字典
dict = {"name": "python", "num": 1}
3.访问字典的值
print(dict["name"])
结果：python
4.访问字典的键
print(dict.keys())
结果：dict_keys(['name', 'num'])
5.访问字典的值
print(dict.values())
结果：dict_values(['python', 1])
6.修改字典
dict["name"] = "码上开始"
结果：{"name": "码上开始", "num": 1}
7.添加新的值
dict['age'] = 28
结果：{"name": "码上开始", "num": 1,'age':28}
8.删除
dict.pop("name")
结果：{'num': 1}
四、字符串str
1.字符串定义：单引号、双引号、三引号、str()
s='hello word'
s=”hello word”
s='''hello word'''
s=str(123456)
空字符串定义：s=“
2.字符串常见操作：
(1)字符串拼接：+
print('我的名字叫'+'小明')
结果：我的名字叫小明
(2)字符串的输出：print（），输出多个不同的数据用逗号隔开
name = "小明"
print("我的名字叫：" , name)
结果：我的名字叫小明
(3)字符串转义： \n换行， r“ ” 防止转义
①转义字符：ASCII 编码为每个字符都分配了唯一的编号，称为编码值。在 Python 中，一个 ASCII 字符除了可以用它的实体（也就是真正的字符）表示，还可以用它的编码值表示。这种使用编码值来间接地表示字符的方式称为转义字符（Escape Character）。在python中转义字符，就是那些以反斜杠\开头的字符。
②转义字符：\n \r \t \a \b \\ \' \” \，简单来说就是这几个字符在python里面有特殊意义，要想让它变成字符的形式就要不让它转义
③举例：
print('\n')
结果：输出换行
print(r'\n')
结果：\n
(4)下标取值：[]
s='hello word'
print(s[3])
结果：l
(5)字符串常见的方法：
①join：连接字符串数组。将字符串、元组、列表中的元素（元素为字符串）以指定的字符(分隔符)连接生成一个新的字符串
语法格式：separator.join(str/tuple/list)
separator：分隔符
举例：
a=['sdf','hiuhk','fefgsdf']
res=':'.join(a)
print(res)
结果：sdf:hiuhk:fefgsdf
②find：查找字符串元素的位置
举例：
s='我的名字叫：小明'
print(s.find("字"))
取第二个字符的位置
a='fdsdddssssbb'
s=a.find('s',a.find('s')+1)
结果：6
③count：查找元素的个数
举例：
a='fdsdddssssbb'
print(a.count('s'))
结果：5
④replace：替换
举例：
a='dfgffghdfgf'
print(a.replace('f','1'))
结果：d1g11ghd1g1
⑤split：分割
语法格式：str.split(str="",num=string.count(str))
参数说明：
str:表示为分隔符，默认为空格，但是不能为空('')。若字符串中没有分隔符，则把整个字符串作为列表的一个元素
num:表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串
举例1：
txt = "hello word"
print(txt.split())
结果：['hello', 'word']
举例2：
txt='dsvfvfdvfdsv'
print(txt.split('f',2))
结果：['dsv', 'v', 'dvfdsv']
⑥大小写转换
upper:转变为大写
lower:转变为小写
举例：
s='GUukygGYF'
print(s.lower())
print(s.upper())
结果：guukyggyf
GUUKYGGYF
⑦格式化输出
name='小明'
print('我的名字叫：{}'.format(name))
结果：我的名字叫：小明
⑧切片
语法格式：str[首:尾:步长] 取头不取尾，默认为1
举例1：
s='asdfghjdthh'
print(s[1:3])
结果：sd
举例2：
print(s[2:5:2])
结果：dg
举例3：
print(s[2:10:3])
结果：dht
五、对象类型转化
1.列表转元组、字符串、字典
lis=[12,45,45] lis1=[56,12,88]
tup=tuple(lis) strs=str(lis) dic=dict(zip(lis,lis1))#zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
2.元组转列表、字符串、字典
tup=(12,45,55) tup1=(52,55,85)
lis=list(tup) strs=str(tup) dic=dict(zip(list(tup),list(tup1)))
3.字符串转列表、元组、字典
strs='hkukh' strs1='awslkj'
lis=list(strs) tup=tuple(strs) dic=dict(zip(list(strs),list(strs1)))
4.字典转列表、元组、字符串
dic={'dc':12,'dc':45,'dc':4,'dc':21}
list(dic.items()) tuple(dic.items()) strs=str(dic)
六、习题
1.请写出列表、字典、字符串增删改查和元组查的方法
2.请写出下列语句
a=18
list=[10,12,17,15,14,13,16,11]
list1=[786,45,78]
（1）请将list按照升序进行排序
list.sort()
（2）请用俩种方式将a添加进list列表里面
list.append(a) list.insert(8,a)
（3）请用俩种方式删除list里面的元素17
list.remove(17) list.pop(2)
（4）请将列表list1添加进list列表里面
list.extend(list1)
3.请写出元组和列表的区别
1.定义不同，一个是圆括号一个是方括号 2.元组只能查，不能修改，列表可以增删改查
4.请写出下列语句
（1）小明在麓谷小学读三年级，请将小明的姓名、学校、年级信息添加到字典里面
data={}
data['姓名']='小明'
data['学校']='麓谷中学'
data['年级']='三年级'
print(data)
（2）俩年以后小明转到尖山湖小学读五年级，请在第一问的基础上对字典信息进行修改
data['姓名']='小明'
data['学校']='尖山湖中学'
data['年级']='五年级'
print(data)
5.请写出下列语句
strs='sdfggkrfgdmfg'
（1）请查找出第3个’g‘的位置
index=strs.find('g',strs.find('g',strs.find('g')+1)+1)
print(index)
（2）请查找出字母’g'出现的次数
time=strs.count('g')
print(time)
（3）请将字母g用’a‘替换
new_strs=strs.replace('g','a')
print(new_strs)
（4）请将字符串strs转换成大写
new_strs=strs.upper()
print(new_strs)
（5）请将字符串按‘f'分割符进行分割
new_strs=strs.split('f')
print(new_strs)
（6）请用切片输出字符’kfdf‘
new_strs=strs[5:12:2]
print(new_strs)
6.请写出下列语句
list=['a','b','c','d'] list1=[12,13,14,15]
(1)请将list转化为字符串、元组，将list和list1转化为字典
strs=str(list)
tup=tuple(list)
dic=dict(zip(list,list1))
函数
一、定义：
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。例如：input、print
二、作用：
函数能提高应用的模块性，和代码的重复利用率。
三、函数分类：
函数分为内置函数与自定义函数
四、常用内置函数：
1.type()
（1）作用：返回数的数据类型
（2）举例：
a=[13,46,352]
b={"use":"admin"}
c='sfdvfd'
d=(12,45)
①print(type(a))#<class 'list'>
②print(type(b))#<class 'dict'>
③print(type(c))#<class 'str'>
④print(type(d))#<class 'tuple'>
2.eval()
（1）作用：eval() 函数用来执行一个字符串表达式，并返回表达式的值。
（2）举例：
①print(eval('12*13'))
结果：156
②print(eval('{"use":"admin"}'))
结果：{"use":"admin"}
③print(type(eval('{"use":"admin"}')))
结果：<class 'dict'>
3.数据类型强制装换
（1）dict()
①作用：将一对数据强制装换为字典，必须是有一对值
②a=[('gjhj','klm'),('bgfb',2)]
print(dict(a))
结果：{'gjhj': 'klm', 'bgfb': 2}
③a=(['gjhj','klm'],['bgfb',2])
print(dict(a))
结果：{'gjhj': 'klm', 'bgfb': 2}
（2）list()
①作用：将数据装换为列表
②举例：
a='fdgfg'#字符串
b={'hk':'1435','gyjg':'hb'}
c=(12,453)
②print(list(a))
结果：['f', 'd', 'g', 'f', 'g']
③print(list(c))
结果：[12, 453]
④print(list(b))
结果：['hk', 'gyjg']
（3）tuple()
①作用：将数据装换为元组
②举例
a='fdgfg'
b={'hk':'1435','gyjg':'hb'}
c=[12,453]
③print(tuple(a))
结果：('f', 'd', 'g', 'f', 'g')
④print(tuple(c))
结果：b={'hk':'1435','gyjg':'hb'}
⑤print(tuple(b))
结果：('hk', 'gyjg')
（4）str()
①作用：将数据装换为字符串
②举例：
a=(12,463)
b={'hk':'1435','gyjg':'hb'}
c=[12,453]
print(type(str(a)))
结果：<class 'str'>
print(type(str(b)))
结果：<class 'str'>
print(type(str(c)))
结果：<class 'str'>
4.set()
（1）作用：set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
（2）举例：a=[12,45,123,4,15,864,5,45,5,123,46,4]
b=set('sdccvdfvckl')
c=set('fdvdscddcshy')
①print(set(a))#去重复
结果：{864, 4, 5, 12, 45, 46, 15, 123}#返回的是一个集合
②print(list(set(a)))#强制装换为列表，实现去重复
结果：[864, 4, 5, 12, 45, 46, 15, 123]
③print(eval('c&b'))#交集
结果：{'c', 'd', 'f', 's', 'v'}
④print(eval('c|b'))#并集
结果：{'y', 'c', 'd', 'k', 'l', 'f', 'h', 's', 'v'}
⑤print(eval('c-b'))#差集
结果：{'k', 'l'}
⑥print(eval('c^b'))#补集
结果：{'k', 'h', 'y', 'l'}
5.sorted()
（1）作用：排序
（2）举例：
①升序：
a=[15,13,54,1,53,22,5]
print(sorted(a))
print(sorted(a, reverse=False))
结果：[1, 5, 13, 15, 22, 53, 54]
②降序：
print(sorted(a, reverse=True))
结果：[54, 53, 22, 15, 13, 5, 1]
③元组或列表：
a=[('b',2),('a',1),('c',3),('d',4)]
b=[['b',2],['a',1],['c',3],['d',4]]
升序：
print(sorted(a, key=lambda x:x[1]))
结果：[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
降序：
print(sorted(b, key=lambda x:x[1], reverse=True))
结果：[['d', 4], ['c', 3], ['b', 2], ['a', 1]]
6.字符转换
（1）int()
①作用：用于将一个字符串或数字转换为整型。
②语法格式：class int(x, base=10)
x -- 字符串或数字。
base -- 进制数，默认十进制。
③举例：
a='12'
b=12.2
#将字符串转化为整型
print(type(int(a)))
结果：<class 'int'>
#将浮点数转化为整型
print(type(int(b)))
结果：<class 'int'>
（2）float()
#将字符串转化为整型
print(type(float(a)))
结果：<class 'int'>
#将浮点数转化为整型
print(type(float(b)))
结果：<class 'int'>
7.sum()
（1）作用：sum() 方法对序列进行求和计算。
（2）语法格式：sum(iterable[, start])
参数：
iterable -- 可迭代对象，如：列表、元组、集合。
start -- 指定相加的参数，如果没有设置这个值，默认为0。
（3）举例：
print(sum([0,1,2]))
结果：3
print(sum((2, 3, 4), 1)) # 元组计算总和后再加 1
结果：10
print(sum([0,1,2,3,4], 2)) # 列表计算总和后再加 2
结果：12
8.len()
(1)作用：返回对象（字符、列表、元组等）长度
a = "jhukhk"
print(len(a)) # 字符串长度
结果：6
b = [1, 2, 3, 4, 5]
print(len(b)) # 列表元素个数
结果：5
9.random()
（1）作用：返回随机生成的一个实数
（2）举例：
import random
① 随机整数：
print(random.randint(1,50))
② 随机选取0到100间能被2整除的数：
print(random.randrange(0, 101, 2))
③ 随机浮点数：
print(random.uniform(1, 10))
④ 随机选取字符串：
print(random.choice(['剪刀', '石头', '布']))
⑤打乱排序
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
random.shuffle(items)
print(items)
10.round()
（1）作用：保留小数点后多少位数，返回浮点数x的四舍五入值
（2）举例：
print(round(80.23556, 2))
结果：80.24
11.strip
（1）作用： 字符串去掉字符串开头和结尾的指定字符，默认为空格或换行符
（2）举例：
a='dddjlkn\n'
strs = a.strip('\n')
print(strs)
#输出：dddjlkn
五、习题
1.请写出下列代码语句
lists=[45,23,84,11,25,46,86,45,23,45,11]
（1）请将列表lists按照降序排列
list_sort=sorted(lists,reverse=True)
print(list_sort)
（2）请去除lists重复的元素，返回一个列表
list_set=list(set(lists))
print(list_set)
（3）请求出列表lists所有元素的和
print(sum(lists))
（4）请求出列表lists的长度
print(len(lists))
2.利用随机函数，写出一个随机出一个剪刀、石头或布的代码语句
play=random.choice(['剪刀','布','石头'])
print(play)
3.请将a变成一个只保留3位数的浮点数b
a=56.333333333
b=round(a,3)
控制流程语句
一、条件判断语句
1.if
（1）判断条件为单个：
if 判断条件：
执行语句……
else：
执行语句……
（2）运行流程：其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句。
（3）举例：
a=10
b=15
if a<b:
print('a小于b')
else:
print('a大于b')
结果：a小于b
（4）当判断条件为多个值时，可以使用以下形式：
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
（5）运行流程：
由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断
时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。
（6）举例：
import random
a=random.randint(1,999)
if len(str(a))==1:
print('{}是一位数'.format(a))
elif 3>len(str(a))>=2:
print('{}是两位数'.format(a))
else 4>len(str(a))>=3:
print('{}是三位数'.format(a))
year=int(input('请输入年份：'))
if year%400==0 or (year%4==0 and year%100!=0):
print('{}年是闰年'.format(year))
else :
print('{}年是平年'.format(year))
二、循环语句
1.while
（1）基本格式：
while 判断条件：
执行语句……
else:
执行语句……
（2）运行流程：
执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。当判断条件假false时，循环结束。
（3）举例：
count = 0
while count < 5:
print(count, " is less than 5")
count = count + 1
else:
print(count, " is not less than 5")
无限循环
a=100
while True:
print(a)
a=a-1
if a<=0:
break
#当运行碰到break时，循环结束，否则一直运行。
2.for
（1）作用：for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
（2）语法格式：
for i in range(num):
#执行语句
#系统会自动将num的数从第一个到最后一个给i，num如果不指定区间数，将以默认为0开头，取头位数，不取尾数位。
for i in list:
#list为列表，系统会自动将list的数从第一个到最后一个给i，知道list数给完。
（3）举例：
①求一个数列：1/2+1/4+1/6+1/8....,求前20项的和
sum=0
for i in range(1,41):
if i%2==0:
sum=1/float(i)+float(sum)
print(round(sum,2))
②冒泡排序
xuhaos=[15,165,12,663,654,2,232,17,52]
for x in range(0, len(xuhaos) - 1):
for i in range(0, len(xuhaos) - 1):
if xuhaos[i + 1] > xuhaos[i]:
b = xuhaos[i]
xuhaos[i] = xuhaos[i + 1]
xuhaos[i + 1] = b
print(xuhaos)
#输出:[663, 654, 232, 165, 52, 17, 15, 12, 2]
③99乘法表
for y in range(1,10):
for x in range(1,y+1):
print('{}*{}={}'.format(x,y,x*y),end=' ')
print('\n')
三、习题
1.输入年份，判断是为闰年（能被400整除，或者能被4整除但是不能被100整除）还是平年
year=int(input('请输入年份：'))
if year%400==0 or (year%4==0 and year%100!=0):
print('{}年是闰年'.format(year))
else :
print('{}年是平年'.format(year))
2.随机生成一个数1000以内的数判断是几位数
import random
a=random.randint(1,999)
if len(str(a))==1:
print('{}是一位数'.format(a))
elif 3>len(str(a))>=2:
print('{}是两位数'.format(a))
else 4>len(str(a))>=3:
print('{}是三位数'.format(a))
3.求一个数列：1/2+1/4+1/6+1/8....,求前20项的和
sum=0
for i in range(1,41):
if i%2==0:
sum=1/float(i)+float(sum)
print(round(sum,2))
4.冒泡排序
a=[14,56,111,42,12,32,95,22,61]
for x in range(len(a)-1):
for y in range(len(a)-1):
if a[y]>a[y+1]:
b=a[y]
a[y]=a[y+1]
a[y+1]=b
print(a)
5.99乘法表
for x in range(1,10):#行
for y in range(1,x+1):#列
print('{}*{}={}'.format(x,y,x*y),end=' ')
print('\n')
异常处理
一、定义：
异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
二、语法格式：
1.第一种：
try：
#执行语句
expect Expection：
#执行语句
2.第二种：
try:
#执行语句
expect Expection as e
raise e
finally:
#执行语句
（1）Expection属于万能异常，更多异常类请看博客
（2）as e 捕捉到异常程序报错，但是程序不会停止运行,e是异常信息
（3）raise e 主动触发异常，程序控制台报错，程序停止运行
（4）finally不论运行完try或者expect都会运行一次finally
（5）traceback.print_exc() 可以用来查看异常的传播轨迹，追踪异常触发的源头。
三、举例：
try:
#语句
print('dc'+1)
except Exception as e:#Exception万能异常
print('***程序出现错误***')
print(e)#打印异常信息，不打印行号，程序继续运行
traceback.print_exc()#查看程序异常信息，打印行和异常信息，程序继续运行
raise e#主动触发异常，打印行号和异常信息，程序停止运行
finally:#无论执行try还是except都会执行，主动触发异常程序停止运行时继续运行
print('66666')
print('888888')
四、应用场景
1.代码出现问题时程序不会立马崩溃，写出日志
2.提供俩个选项，作出选择
五、出错点
1.长度函数用整数 2.input输入浮点数 3.字符跟整数拼接 4.文件读取无此文件
文件读写
一、打开文件
open() 方法
Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该
文件无法被打开，会抛出 OSError。
注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
二、语法格式：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True)
参数说明:
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式 'r' 'w' 'a' ,'w'会清空文字
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
一般只用到file，mode和encoding
三、文件写入：
写入单行 write
file=open("text.txt","a")
file.write("今天天气好"
写入多行 writelines
file.writelines([1,2,3])
保存文件 flush
file.flush()
四、读取文件：
读取单行 read
res=f.read()
读取多行 readlines
file.writelines()
五、文件定位
tell() 方法告诉你文件内的当前位置
seek（offset，from）方法改变当前文件指针的位置
offset：变量表示要移动的字节数 正和负数
from：变量指定开始移动字节的参考位置，默认为1
0：参考位置为文件开头
1：参考位置设为当前所在位置
2：参考位置设为文件结尾
file=open('test.txt','r'）
file.tell()
file.readline()
file.seek(0)
六、with open
我们写入文件内容时，系统并不会立刻就把所有数据写入到磁盘，它是先放到内存中缓存，等到空闲的时候再慢慢写入到磁盘。当调用close()方法时，系统才能保证把剩余没有写入的数据全部写入到磁盘。假如我们忘记调用了close()方法，那很可能导致我们的数据遗失。为了保证万无一失，最好是使用with open()进行内容的读写。
七、写入
.write:写入的是一个字符串
.writelines:注意写入的必须是字符串，可以是列表
.read() 每次读取整个文件，它通常将读取到底文件内容放到一个字符串变量中，也就是说 .read() 生成文件内容是一个字符串类型。
.readline()每只读取文件的一行，通常也是读取到的一行内容放到一个字符串变量中，返回str类型。
.readlines()每次按行读取整个文件内容，将读取到的内容放到一个列表中，返回list类型。
