标签：strs 结果 Python list 列表 字符串 print 基础知识
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类型。
标签：strs,结果,Python,list,列表,字符串,print,基础知识 来源： https://www.cnblogs.com/1527275083gj/p/15760296.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。