这篇博客涵盖了Python的基础知识，包括分支与循环、字符串、列表、元组、字典、集合的练习题，以及函数、模块、文件操作等内容。通过一系列的实践题目，帮助读者巩固Python编程基础，提升编程能力。
文章目录
----------------------------Python代码
分支与循环部分练习题:
1、从键盘输入三个同学的成绩，然后找出最高分。
a = int(input("请输入第一个同学的成绩"))
b = int(input("请输入第二个同学的成绩"))
c = int(input("请输入第三个同学的成绩"))
d = max(a,b,c)
print(d)
2、输入三个同学的成绩，然后由大到小排序。
L=[]
a = int(input("请输入第一个同学的成绩"))
b = int(input("请输入第二个同学的成绩"))
c = int(input("请输入第三个同学的成绩"))
L.append(a)
L.append(b)
L.append(c)
L.sort()
print(L)
3、求出1000以内的所有完全数，如6=1+2+3除了它自身以外的因子之和等于它本身叫完全数。
for x in range(1,1000): //x从1到1000遍历
sum = 0
for y in range(1,x): //y从1到x遍历
if(x % y ==0): //如果x取余y ==0 说明y是x的因子
sum += y //将这个数的所有因子之和加起来
if(x==sum): //如果除它本身之外的因子之和 等于它本身 就输出
print(sum)
4、用循环语句求出1+22+333+4444+55555+…+nnnnn
a = int(input("输出n的数")) //使用终端输入
sum=0
k=1
for x in range(1,a+1): //从1遍历到a
sum+=k*x //sum=1+11*2+111*3+1111*4+11111*5
k=k+(10**x) //k=11 111 1111 11111
print(sum) //求出sum的和
5、求出2000-2100的所有闰年，条件是四年一闰；百年不闰，四百年再闰。
for i in range(2000,2101):
if i % 4 ==0 and i % 100 != 0 or i % 400 ==0:# and优先级高于or
print(i)
6、输入两个正整数，并求出它们的最大公约数和最小公倍数。
j = int(input("输入第一个数"))
l = int(input("输入第二个数"))
if(j<l):
o,k=j,l
else:
o,k=l,j
gck = 1
for x in range(2,o+1):
if o % x == 0 and k % x ==0:
gck = x
print("最大公约数=",gck)
gld = k
while (gld % o !=0 or gld % k !=0):
gld += 1
print("最小公倍数=",gld)
7、输出100以内的所有质数。
L=[]
for x in range(2,100):
for y in range(2,x):
if(x % y == 0):
break
else:
L.append(x)
print(L)
8、求100以内最大的10个质数的和。
L=[]
for x in range(2,100):
for y in range(2,x):
if(x % y == 0):
break
else:
L.append(x)
print("100以内最大10个质数之和",L[-1]+L[-2]+L[-3]+L[-4]+L[-5]+L[-6]+L[-7]+L[-8]+L[-9]+L[-10])
print(sum(L[-1:-11:-1]))
9、求1到10所有偶数的和。
sum = 0
for x in range(0,11,2):
sum+=x
print(sum)
10、将10-20不能被2或3整数的数输出。
for x in range(10,21):
if(x % 2 != 0):
if(x % 3 !=0):
print(x)
字符串部分练习题：
1、计算用户输入的内容中有几个十进制数字？几个字
母？
如统计"China123 321china987CHINESE789 2"字符串字母和数字出现的个数。
# 方法一
a = "China123 321china987CHINESE789 2"
n = 0
m = 0
for x in a:
if(x.isalpha()):
n += 1
if(x.isdigit()):
m +=1
print("字母是:",n,"个")
print("数字是:",m,"个")
print(len(a))
# 字母是: 17 个
# 数字是: 13 个
# 33
# 方法二
a = "China123 321china987CHINESE789 2"
i=0
k=0
j=0
for x in a:
if (x>='A')&(x<='Z'):
i+=1
elif (x>='a')&(x<='z'):
k+=1
elif (x>='0')&(x<='9'):
j+=1
print("字符串中字母个数为",i+k,"个")
print("字符串中大写字母个数为",i,"个")
print("字符串中小写字母个数为",k,"个")
print("字符串中数字个数为",j,"个")
# 字符串中字母个数为 17 个
# 字符串中大写字母个数为 8 个
# 字符串中小写字母个数为 9 个
# 字符串中数字个数为 13 个
2、开发敏感词语过滤程序，提示用户输入内容，
如果用户输入的内容中包含特殊的字符：如’二柱子’改成’佐助’
str = '二柱子和鸣人是好兄弟'
if '二柱子' in str:
print(str.replace('二柱子','佐助'))
3、制作随机验证码，不区分大小写
流程：
- 用户执行程序
- 给用户显示需要输入验证码
- 用户输入的值
用户输入的值和显示的值相同时显示正确的信息:
否则继续生成验证码等待用户输入
import random
a = random.randint(1,10)
b = 0
while True:
if a == b:
print("输入正确", a)
break
elif(a<b):
b = int(input("输入大了,请输入验证码"))
else:
b = int(input("输入小了,请输入验证码"))
列表练习题:
1、设计一个程序，可以输入用户名，将所有输入的用户加入列表，当输入的是0的时候，结束输入操作并将所有列表用户输出
修改：在增加用户名的程序基础上，完成指定用户名称的修改操作
2、在增加用户名的程序基础上，完成指定用户名称的
修改操作。
查询
3、在已经有数据的列表中查询用户输入的用户名，
如果有则提示用户找到
如果么有则提示用户不存在
删除
4、在以上的代码基础上输入一个要删除的用户名，首
先判断是否
在列表中，如果在就删除，如果不在就提醒。
其他：
反转 大小 排序
L = []
while True:
a = input("请输入用户名")
if (a == '0'):
print(L)
break
L.append(a)
str = input("请输入要修改的")
if str in L:
L[L.index("狐妖")] = "漩涡鸣人"
print("狐妖已修改成漩涡鸣人")
else:
print("没找到")
print(L)
str2 = input("请输入要删除的值")
if str2 in L:
L.remove(str2)
print(L)
else:
print("二柱子不存在")
元组练习题：
tup=(“nihao”,“wohao”,“dajiahao”)
a.计算元组长度并输出
b.获取元组第2个元素并输出
c.获取元素第2-3个元素并输出
d.使用for循环遍历输出元组
e.使用for，len，range输出元组的索引
f.将元组中元素第一个与最后一个交换后整体输出
tup=("nihao","wohao","dajiahao")
print("a:",len(tup))
print("b",tup[1])
print("c",tup[1:3:1])
for x in tup:
print("d:",x)
for y in range(0,len(tup)):
print("e:",y)
a = tup[0]
b = tup[1]
c = tup[2]
newTup = (b,b,a)
print("f:",newTup)
字典练习题:
按照要求实现每一个功能
dict = {“k1”:“v1”,“k2”:“v2”,“k3”:“v3”}
1、请循环遍历出所有的key
2、请循环遍历出所有的value
3、请循环遍历出所有的key和value
4、请在字典中增加一个键值对,“k4”:“v4”，输出添加后
的字典
5、请删除字典中键值对"k1":“v1”,并输出删除后的结果
6、请删除字典中键"k5"对应的键值对，如果字典中不
存在键"k5",则不报错，返回None
7、请获取字典中"k2"对应的值
8、请获取字典中"k6"对应的值,如果不存在，则不报
错，并且让其返回None。
9、现有dict2 = {“k1”:“v11”,“a”:“b”},通过一行操作使
dict2 = {“k1”:“v1”,“k2”:“v2”,“k3”:“v3”,“a”:“b”}
dict={"k1":"v1","k2":"v2","k3":"v3"}
for k,v in dict.items():
print("1:",k)
for k,v in dict.items():
print("2:",v)
print("3:",dict)
dict04 = {"k4":"v4"}
dict.update(dict04)
print("4:",dict)
del dict["k1"]
print("5:",dict)
print("6:",dict.get("k5"))
print("7:",dict["k2"])
print("8:",dict.get("k6"))
dict = {"k1":"v1","k2":"v2","k3":"v3"}
dict2 = {"k1":"v11","a":"b"}
del dict2["k1"]
dict2.update(dict)
reversed(dict2)
print(dict2)
集合练习题：
1、生成了N个1~100之间的随机整数（N<=1000），
N是用户输入的； 对于期指其中重复的数字，
只保留一个，把其余相同的数字去掉；
import random
N = int(input("输入1~1000随机一个数"))
s = {""}
for x in range(1,N+1):
ra = int(random.randint(1,100))
s.add(ra)
print(x,":",ra)
s.remove("")
print(s)
2、怎么使用集合完成列表的去重操作，并将最终的列
表由大到小排序输出。
L = [1,2,3,4,4,2,5,9,1] #创建一个列表
s={0} #创建一个集合，创建空set的话用不了add方法，在第六行删了0
print(s) #打印一下新集合
for x in L:
s.add(x) #遍历列表每一个元素，将每一个元素加到 set里
s.remove(0) #第二行已解释过
print(s)
newList=[] #创建一个新空的列表
for y in s:
newList.append(y) #遍历 set ，将每个元素加到新空列表
newList.reverse() #反转
print("新列表是：",newList) #输出新列表
大作业：
使用组合数据类型(列表，元组，字典，集合)中任意
一种存储方式，完成一个简单的学生管理系统，可以
多次录入学生信息到系统并完成基本的 增加 删除
修改，查询操作。
学生信息： 学号，姓名，性别，年龄，专业；
def showInfo():
print("**************")
print(" 学生管理系统")
print(" 1.添加学生的信息")
print(" 2.删除学生的信息")
print(" 3.修改学生的信息")
print(" 4.查询学生的信息")
print(" 5.遍历所有学生的信息")
print(" 6.退出系统")
print("**************")
students = []
while True:
#showInfo()
print("**************")
print(" 学生管理系统")
print(" 1.添加学生的信息")
print(" 2.删除学生的信息")
print(" 3.修改学生的信息")
print(" 4.查询学生的信息")
print(" 5.遍历所有学生的信息")
print(" 6.退出系统")
print("**************")
# 提示用户选择功能
# 获取用户选择的功能
key = int(input("请选择功能（序号）"))
if key == 1:
print("您选择了添加学生信息功能")
name = input("请输入学生姓名")
stuId = input("请输入学生学号(学号不可重复)")
age = input("请输入学生年龄:")
##验证学号是否唯一
leap = 0
for temp in students:
if temp['id'] == stuId:
leap = 1
break
if leap == 1:
print("输入学生学号重复，添加失败！")
break
else:
# 定义一个字典，存放单个学生信息
stuInfo = {}
stuInfo['name'] = name
stuInfo['id'] = stuId
stuInfo['age'] = age
# 单个学生信息放入列表
students.append(stuInfo)
print("添加成功！")
elif key == 2:
print("您选择了删除学生功能")
delId = input("请输入要删除的学生学号:")
# i记录要删除的下标，leap为标志位，如果找到leap=1，否则为0
i = 0
leap = 0
for temp in students:
if temp['id'] == delId:
leap = 1
break
else:
i = i + 1
if leap == 0:
print("没有此学生学号，删除失败！")
else:
del students[i]
print("删除成功！")
elif key == 3:
print("您选择了修改学生信息功能")
alterId = input("请输入你要修改学生的学号:")
# 检测是否有此学号，然后进行修改信息
i = 0
leap = 0
for temp in students:
if temp['id'] == alterId:
leap = 1
break
else:
i = i + 1
if leap == 1:
while True:
alterNum = int(input(" 1.修改学号\n 2.修改姓名 \n 3.修改年龄 \n 4.退出修改\n"))
if alterNum == 1:
newId = input("输入更改后的学号:")
# 修改后的学号要验证是否唯一
i = 0
leap1 = 0
for temp1 in students:
if temp1['id'] == newId:
leap1 = 1
break
else:
i = i + 1
if leap1 == 1:
print("输入学号不可重复，修改失败！")
else:
temp['id'] = newId
print("学号修改成功")
elif alterNum == 2:
newName = input("输入更改后的姓名:")
temp['name'] = newName
print("姓名修改成功")
elif alterNum == 3:
newAge = input("输入更改后的年龄:")
temp['age'] = newAge
print("年龄修改成功")
elif alterNum == 4:
break
else:
print("输入错误请重新输入")
else:
print("没有此学号，修改失败！")
elif key == 4:
print("您选择了查询学生信息功能")
searchID = input("请输入你要查询学生的学号:")
# 验证是否有此学号
leap = 0
for temp in students:
if temp['id'] == searchID:
leap = 1
break
if leap == 0:
print("没有此学生学号，查询失败！")
else:
print("找到此学生，信息如下：")
print("学号：%s\n姓名：%s\n年龄：%s\n" % (temp['id'], temp['name'], temp['age']))
elif key == 5:
# 遍历并输出所有学生的信息
print('*' * 20)
print("接下来进行遍历所有的学生信息...")
print("id 姓名 年龄")
for temp in students:
print("%s %s %s" % (temp['id'], temp['name'], temp['age']))
print("*" * 20)
elif key == 6:
# 退出功能，尽量往不退出的方向引
quitconfirm = input("亲，真的要退出么 （yes或者no）")
if quitconfirm == 'yes':
print("谢谢使用本系统!")
break;
else:
print("您输入有误，请重新输入")
函数练习题
1、编写自定义函数，可以输出自己的名字即可。
def print_name(s):
return s
print(print_name(input("请输入你的名字")))
2、编写自定义函数，完成一个简单的减法运算函数。
def subtraction(a,b):
return a-b
print(subtraction(5,2))
3、写函数，接受5个数字，求这些参数数字的和
def num_sum(a,b,c,d,e):
return a+b+c+d+e
print(num_sum(4,2,5,6,7))
4、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表。
List=[1,2,3,4,5]
def func01(list):
newList = list[0::2]
return newList
print(func01(List))
tuple = (1,2,3,4,5)
def func01(tuple):
newTuple =tuple[0::2]
print(newTuple)
pass
func01(tuple)
5、写函数，统计字符串中有几个字母，几个数字，几个空格，几个其他字符，并返回结果。
str01="china 12345 CHINA ##"
def count(s):
a,b,c,d = 0,0,0,0 # a字母 b数字 c空格 d其他
for x in s:
if x.isalpha():
a += 1
elif x.isdigit():
b += 1
elif x.isspace():
c += 1
else:
d += 1
return a,b,c,d
print(count(str01))
6、写函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空。
def num_isempty(obj):
if len(obj)==0:
return "空"
else:
return "不为空"
print(num_isempty(" 2"))
7、写函数，检查传入字典的每一个value长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
dict = {"k1":"80103","k2":[1,2,3,4,5]}
def fun01(s):
for k,v in s.items():
if len(v)>2:
s[k] = v[0:2]
else:
print("长度小于2")
return s
print(fun01(dict))
8、写函数，接受两个数字参数，返回比较大的数字。
def num_max(m,n):
return (m if m>n else n)
print(num_max(66,55))
9、写函数，利用递归获取斐波那契数列中的第10个数，并将该值返回给调用者。
def fib(a,a1,a2):
if a == 10:
return a1
a3 = a1 + a2
return fib(a+1,a2,a3)
print(fib(1,1,1))
模块练习题
1、定义一个test模块，模块中有三个变量长（long）宽（wide）高（high），数值自定义，有一个返回值为周长的perimeter方法，一个返回值为表面积的area方法。
# 第1题
# test.py
long = 3
wide = 4
high = 5
def perimeter():
return (long + wide + high) * 3
print("周长=",perimeter())
def are():
return long * high * wide
print("面积=",are())
2、定义一个用户文件stu1.py,在该文件中打印test的长宽高，并获得周长和表面积，打印出来。
# stu1.py
import test
print("长=",test.long,"宽=",test.wide,"高=",test.high)
print("周长=",test.perimeter())
print("面积=",test.area())
3、在stu2.py文件中导入test模块时为模块起简单别名，利用别名完成第二题中完成的操作。
# stu2.py
import test as demo
print("长=",demo.long,"宽=",demo.wide,"高=",demo.high)
print("周长=",demo.perimeter())
print("面积=",demo.area())
4、结合第1、2、3题完成from…import…案例，完成同样的功能。
# stu3.py
from test import perimeter,area
print("周长=",perimeter())
print("面积=",area())
文件练习题
1、编写一个程序，提示用户输入其名字，密码；用户做出响应后，将其这些信息写以空格间隔方式写入到文件test.txt中。
while True:
name = input("请输入用户名")
pasd = input("请输入密码")
if name == 'n':
break;
with open("test.txt","a+") as file:
file.write(name)
file.write(" ")
file.write(pasd)
file.write("\n")
2、编写一个程序，可以将指定文件中的字符串修改，比如 将文件中所有的"java"修改为"python"。
def alter(file,old_str,new_str):
with open(file,"r")as f1,open("%s.bak"%file,"w")as f2:
for line in f1:
if old_str in line:
line = line.replace(old_str,new_str)
f2.write(line)
alter("test.txt","python","java")
3、利用b模式，编写一个拷贝工具，既可以拷贝文本又可以拷贝视频，图片等文件。
home = "./"
img = input(">>")
fr = open(img,'rb')
filename = img + "[复件]"
fw = open(filename,'wb')
while True:
data = fr.read()
if not data: # if data ==":
break
fw.write(data)
fr.close()
fw.close()
4、批量重命名指定目录下的所有文件。
import os
#0. 提示并获取一个要重命名的文件夹
needRenameFile = input("请输入要批量重命名的文件夹： ")
#1. 获取制定路径下 的所有文件名
allFileName = os.listdir("./"+needRenameFile)
print(allFileName)
#2. 循环的方式 依次进行重命名
for name in allFileName:
os.rename("./"+needRenameFile+"/"+name,"./"+needRenameFile+"/"+"[大哥出品]-"+name)
#if "[大哥出品]" in name:
# os.rename(name,name[7:])
----------------------------Python笔记
##基础
类型与变量：
char = =>short = =>int = =>long
1 2 4 4/8
整数：
Python可以处理任意大小的整数，当然包括负整数，
在程序中的表示方法和数学上的写法一模一样。
例如：1，100，-8080，0，等等。
注意：Python的整数没有大小限制。
浮点数：
浮点数可以用数学写法，如1.23，3.14，-9.01，等等
对于很大或很小的浮点数，就必须用科学计数法表示，
把10用e替代，1.23x10 ^9就是1.23e9，或者
12.3e8， 0.000012可以写成1.2e-5，等等
Python的浮点数也没有大小限制，但是超出一定范围
就直接表示为inf（无限大）。
字符串：
''' zifuchuan 3'''
"zifcuan2"
'zifuchuan1'
字符串是以单引号'或双引号"括起来的任意文本，
比如'abc'，"xyz"等等
如果字符串内部既包含' 又包含" 可以用转义字符\
来标识
比如：'I\'m \"OK\"!' = =》I'm "OK"!
Python还允许用r''表示''内部的字符串默认不转义
print(r'\\\t\\') = =》\\\t\\
格式化的字符串，采用的格式化方式和C语言是一致
的，用%实现。
>>>'Hi, %s, you have $%d.' %
('Michael', 1000000)
>>>'Hi, Michael, you have $1000000.'
%运算符就是用来格式化字符串的。在字符串内部，
%s表示用字符串替换，%d表示用整数替换，
有几个%?占位符，后面就跟几个变量或者值，顺序
要对应好。如果只有一个%?，括号可以省略
常见的占位符有：
符号 描述
%d 浮点数
%f 浮点数
%s 字符串
%x 十六进制整数
布尔值：
布尔值和布尔代数的表示完全一致，一个布尔值只有
True、False两种值。
空值：
空值是Python里一个特殊的值，用None表示。None
不能理解为0，因为0是有意义的，而None是一个特殊
的空值。
变量：
变量在程序中就是用一个变量名表示，变量名必须是
大小写英文、数字和_的组成，
且不能用数字开头,不能和内置关键字冲突，
变量不需要声明。每个变量在使用前都必须赋值。
<= =不需要类型定义
在Python中，等号=是赋值语句，可以把任意数据类
型赋值给变量。
赋值语句先计算右侧的表达式值，得到结果，再赋给
左侧变量，注意区别数学=的差异。同一个变量可以反
复赋值，而且可以是不同类型的变量。= =》动态语言
常量：
所谓常量就是不能变的量，在Python中，通常用全部
大写的变量名表示常量：
比如：PI = 3.14159265359
但事实上PI仍然是一个变量，Python根本没有任何
机制保证PI不会被改变，
所以，用全部大写的变量名表示常量只是一个习惯上
的用法，
如果你一定要改变变量PI的值，也没人能拦住
你！！！
运算符：
算术运算： + - * / // %
关系运算： == != > < <= >=
逻辑运算： and or not
成员运算： in not in
身份运算： is is not
位运算： & | ^ ~ >> <<
a = 2; =⇒ 0010
b = 4; = =>0100
c = a & b; = =>0000
注意：
Python 可以使用**操作来进行幂运算：
>>> 5 ** 2 # 5 的平方
25
>>> 2 ** 7 # 2的7次方
128
在Python中，有两种除法，一种除法是/
>>> 10 / 3
3.3333333333333335
/除法计算结果是浮点数，即使是两个整数恰好整
除，结果也是浮点数：
>>> 9 / 3
3.0
还有一种除法是//，称为地板除，两个整数的除法
仍然是整数：
>>> 10 // 3
3
你没有看错，整数的地板除//永远是整数，即使除
不尽。要做精确的除法，使用/就可以
================= = =成员运算符和身份运算
符举例========== =
# -*- coding: UTF-8 -*-
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print "1 - 变量 a 在给定的列表中 list 中"
else:
print "1 - 变量 a 不在给定的列表中 list 中"
if a and b :
print "1 - 变量 a 和 b 都为 true"
else:
print "1 - 变量 a 和 b 有一个不为 true"
if not( a and b ):
print "5 - 变量 a 和 b 都为 false，或其中一个变量为
false"
else:
print "5 - 变量 a 和 b 都为 true"
if ( a is b ):
print "1 - a 和 b 有相同的标识"
else:
print "1 - a 和 b 没有相同的标识"
if ( a is not b ):
print "4 - a 和 b 没有相同的标识"
else:
print "4 - a 和 b 有相同的标识"
==================================
基本I0:
终端输入很简单，使用input()函数即可。
print('--------------终端输入--------------') #o操作，屏
幕会出现打印的内容
input_string = input('Please input some words:') #o操
作，Please input some words:
#i操作，input()调用，回自动获取键盘输入
print(input_string) #o操作，屏幕打印变量的值
若需要数字型数据，可以使用 int( ) 或 float( ) 函数转
换。
height = input("输入长方形的高度：")
width = input("输入长方形的宽度：")
print("长方形的面积是：",float(height) * float(width))
注：在Python 3.x版本中取消了 raw_input() 函数
========================》input()
终端输出用的是我们到目前为止非常熟悉的一个函数
print()。 类似与c语言的printf()
格式化输出：
1 - 顺序填坑 可以有元素多，不能有元素少
如：print( '名字是{},年龄是{}'.format(name,
age) )
2 - 下标填坑
如：print('名字是{1},年龄是{0}'.format(age,name))
3 - 变量填坑
如：print('名字是{name},年龄是{age}'.format(name
= 'tom', age = 23))
分隔类型输出
float类型精度控制：同C语言
pi=3.1415926 m.n ⇒ %f 输出的时候，m是域
宽， .n是精度
print("%2.5f" %(pi))#字段宽度为2，精度为5，左对齐
print("%10.5f" %(pi))#字段宽度为10，精度为5，左对
齐，对象宽度不够，采用空白填充
print("%*.*f" %(10,3,pi))#用*从后面的元组中读取字
段宽度的精度
print("%010.5f" %(pi))#字段宽度为10，精度为5，左
对齐，对象宽度不够，采用0填充
print("%-10.5f" %(pi))#字段宽度为10，精度为5，左
对齐，对象宽度不够，默认左对齐，显示负
print("%+f" %(pi))#显示正负号，右对齐，对象宽度不
够，空白填充
print("%+10.5f" %(pi))
"""输出结果：
3.14159
3.14159
3.142
0003.14159
3.14159
+3.141593
+3.14159
"""
其他也可以指定长度输出： > 右对齐 < 左对齐 中
间对齐 用^ 异或
如：print('名字是：{:>9},年龄是：
{:>9}'.format(name,age))
总长度都是9 右对齐，不足左边补空格
print('名字是：{:<9},年龄是：
{:<9}'.format(name,age))
总长度都是9 左对齐，不足右边补空格
print('名字是：{:0>9},年龄是：{:
0>9}'.format(name,age))
总长度都是9 右对齐，不足左边补0
print('名字是：{:^9},年龄是：
{:^9}'.format(name,age))
总长度都是9 中间对齐 不足两边补空格
print('--------------终端输出--------------')
print('这是一段输出', '下一段输出', sep=',', end=' ')
注：sep是多个输出之间的分隔符，默认是一个空格。
而end是输出的结尾，默认是换行。
output
流程控制：
条件判断：只有if else 判断，没有switch case判断
if语句的完整形式
简写版：
if 判断 :
执行1
else:
执行2
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>
11/40
比如：
age = 20
if age <= 6:
print('teenager')
elif age >= 18:
print('adult')
else:
print('kid')
if判断条件还可以简写，比如：
if x: //x是非零数值、非空字符串、非空list等，
就判断为True，否则为False
print('True')
循环语句：
Python的循环有两种，
第一种是for...in循环
第二种循环是while循环，只要条件满足，就不断循
环，条件不满足时退出循环
for..in语法规则：
for 临时变量 in 循环范围 ：
循环执行语句
while 语法规则：
while 逻辑表达式 ：
循环执行语句
比如：
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)
依次把list或tuple中的每个元素迭代出来， 所以for
x in ...循环就是
把每个元素代入变量x，然后执行缩进块的语句。
再比如：其中range是python提供的内置函数，表示
边界范围。
sum = 0
for x in range(101): #遍历 0 - 100 的所有整
数
sum = sum + x
print(sum)
函数语法
range（strat，stop，step）
参数说明
strat：计数从start开始。默认是range（5）等价于range（0，5）；
stop：计数从stop结束，但不包括stop。例如:range（0，5）是[0,1,2,3,4,5]没有5
step：步长，默认是1.例如：range（0，5）等价于range（0，5，1）
将以上代码转换成while循环则如下所示：
sum = 0
n = 100
while n > 0:
sum = sum + n
n = n - 1
print(sum)
for 循环使用 else 语句
在 python 中，for … else 表示这样的意思，for 中的语
句和普通的没有区别，else 中的语句会在循环正常执行
完（即 for 不是通过 break 跳出而中断的）的情况下执
行，while … else 也是一样。
for num in range(10,20): # 迭代 10 到 20 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0: # 确定第一个因子
j=num/i # 计算第二个因子
print '%d 等于 %d * %d' % (num,i,j)
break # 跳出当前循环
else: # 循环的 else 部分
print num, '是一个质数'
str字符串
1、字符串求长度：len(str1);
2、字符串拼接： + 'Jack'*3 重复创建相应的字符串
3、字符串遍历： for a in str1
4、字符串包含判断：if('a' in sample_str7) = =>true /
false
5、字符串索引：
正向索引： str1[0] str1[1] str[2]
反向索引： str1[-1] str1[-2] str1[-3]
注意：虽然索引可以获得该顺序上的字符，但是不能够通过该索引去修改对应的字符
6、字符串切片：str1[start:end:step] = =》str1[0:4]
获取索引为0-4之间的字符串，从索引0开始到3为止
str1 = "nihao wohao dajiahao"
print(str1[6:11]) #直接指定下标切片获取数 6是起始
下标 11是终止下标
print(str1[0:11:2]) #其中2是移动的步长，默认是1
print(str1[:5]) #下标5之前的所有数据
print(str1[5:]) #下标5以后的所有数据
常见字符串内置函数：
str.strip([chars]) ==》
print(sample_fun1.strip()) #默认去掉
首尾空格
print(sample_fun1.strip('#')) #指定首尾
需要删除的字符
str.count('chars',start,end)
统计chars字符串或者字符在str中出现的次数，
从start顺序开始查找一直到end顺序范围结束，默
认是从顺序0开始
str. capitalize() 将字符串的首字母大写
str.upper() 将字符串中的字母全部转换成大写字母
str.isupper() 判断字符串是否全是大写
str.low() 将字符串中的字母全部转换成小写字母
str.islower() 判断字符串是否全是小写
str.find('str',start,end)
查找并返回子字符'str'在start到end范围内的顺序，
默认范围是从字符串的头开始到尾结束
str.index('str',start,end) 同上，单没有字符会报错
str.replace(oldstr, newstr,count)
用旧的子字符串替换新的子字符串，若不指定
count默认全部替换
str.split(sep,maxsplit)
将字符串按照指定的sep字符进行分割，
maxsplit是指定需要分割的次数，若不指定
sep默认是分割空格。
str.isalnum() 字符串是由字母或数字组成则返回true否
则返回false
str.isalpha() 字符串是否全是由字母组成的
str.isdigit() 字符串是否全是由数字组成，是则返回
true，否则返回false
list列表
1、 使用 [ ] 直接创建列表
listname = [element1 , element2 ,
element3 , ... , elementn]
其中，listname 表示变量名，element1 ~ elementn 表
示列表元素
2、使用 list() 函数创建列表
提供了一个内置的函数 list()，使用它可以将其它数据类
型转换为列表类型。
#将字符串转换成列表
list1 = list("hello")
print(list1)
#将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)
#将字典转换成列表，最终列表中只有键没有值
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)
#将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)
Python中List中的元素用中括号[]来表示，可以这样定义
一个List:
L = [12, 'China', 19.998] #不要求元素的类型都
是一样的
也可以定义一个空的List: L = []
List是有序的，所以要访问List的话显然要通过序号来访
问，
就像是数组的下标一样，一样是下标从0开始,不要越
界，否则会报错.
print (L[0])
12
也可以倒序访问
print L[-1]
19.998
1、增加
内置的append()方法来添加到尾部，通过insert()方法添
加到指定位置（下标从0开始）
>>> L = [12, 'China', 19.998]
>>> L.append('Jack')
>>> print L
[12, 'China', 19.998, 'Jack']
>>> L.insert(1, 3.14)
>>> print L
[12, 3.14, 'China', 19.998, 'Jack']
>>>
2、删除
通过pop()删除最后尾部元素，也可以指定一参数删除
指定位置：
>>> L.pop()
'Jack'
>>> print L
[12, 3.14, 'China', 19.998]
>>> L.pop(0)
12
>>> print L
[3.14, 'China', 19.998]
3、修改
也可以通过下标进行复制替换
>>> L[1] = 'America'
>>> print L
[3.14, 'America', 19.998]
4、查找
if x in L:
xxx
else:
yyy
tuple元组
tuplename = (element1, element2, ...,elementn) 其中，tuplename 表示变量名，element1 ~ elementn 表示元组的元素。 注意的一点是，当创建的元组中只有一个字 符串类型的元素时， 该元素后面必须要加一个逗号,， 否则 Python 解释器会将它视为字符串。 其他创建方式： 使用tuple()函数创建元组 tp1= tuple(data) #其中，data 表示可以转化为元组 的数据， 包括字符串、元组、range 对象等 Tuple可以看做是一种“不变”的List，访问也是通过下 标，用小括号（）表示： >>> t = (3.14, 'China', 'Jason') >>> print t (3.14, 'China', 'Jason') 但是不能重新赋值替换： >>> t[1] = 'America' Traceback (most recent call last): File "
dict字典
dict的使用：
Dict是Python中非常重要的数据类型，就像它的字面意思一样，它是个字典，其实就是Key-Value键值对。
字典类型是 Python 中唯一的映射类型。“映射”是数学中的术语，
简单理解，它指的是元素之间相互对应的关系，即通过一个元素，可以唯一找到另一个元素。
字典创建：
1、使用 { } 创建字典
dictname = {'key':'value1', 'key2':'value2', ...,
'keyn':valuen}
其中 dictname 表示字典变量名，keyn : valuen 表示各
个元素的键值对。
需要注意的是，同一字典中的各个键必须唯一，不能重
复。
#使用字符串作为key
scores = {'数学': 95, '英语': 92, '语文': 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)
#创建空元组
dict2 = {}
print(dict2)
2、通过 fromkeys() 方法创建字典
dictname = dict.fromkeys(list，value=None)
其中，list 参数表示字典中所有键的列表（list）；
value 参数表示默认值，如果不写，则为空值 None。
knowledge = ['语文', '数学', '英语']
scores = dict.fromkeys(knowledge, 60)
print(scores)
===》{'语文': 60, '英语': 60, '数学': 60}
3、通过 dict() 映射函数创建字典
#创建空的字典
d = dict()
print(d)
字典的常见操作：
d1={'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}
增加：直接通过键值对方式添加dict中的元素。
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95,
'Bart': 59}
>>> d['Jone'] = 99
>>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95,
'Jone': 99, 'Bart': 59}
删除字典元素：
能删单一的元素也能清空字典，清空只需一项操作。
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典，执行 del 操作后字典不再存在
查找：Dict用Key来访问：
>>> print d['Adam']
95
如果Key不存在，会报错：
>>> print d['Jack']
Traceback (most recent call last):
File "< pyshell#40>", line 1, in
print d['Jack']
KeyError: 'Jack'
所以访问之前最好先查询下key是否存在：
>>> if 'Adam' in d : print 'exist key'
exist key
或者直接用保险的get方法：
>>> print d.get('Adam')
95
>>> print d.get('Jason')
None
遍历字典的一般方式：
>>> for key in d : print key, ':',
d.get(key)
Lisa : 85
Paul : 75
Adam : 95
Bart : 59
字典的合并：
d3 = dict(d1)
d3.update(d2)
print (d3)
{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}
或者
d3={}
for k,v in d1.items():
d3[k] =v
for k,v in d2.items():
d3[k] =v
print(d3)
字典的特性：
1）不允许同一个键出现两次。创建时如果同一个键被
赋值两次，后一个值会被记住。
2）键必须不可变，所以可以用数字，字符串或元组充
当，而用列表就不行。
字典的内置方法：
len(dict) 计算字典元素个数，即键的总数。
str(dict) 输出字典，以可打印的字符串表示。
type(variable) 返回输入的变量类型，如果变量是字典
就返回字典类型。
set集合
set的使用：
set就像是把Dict中的key抽出来了一样，类似于一个
List，但是内容又不能重复，
简言之：无序的不重复元素序列。
从形式上看，和字典类似，Python 集合会将所有元素
放在一对大括号 {} 中，
相邻元素之间用“,”分隔。
{element1,element2,...,elementn}
其中，elementn 表示集合中的元素，个数没有限制。
从内容上看，同一集合中，只能存储不可变的数据类
型，
包括整形、浮点型、字符串、元组，
无法存储列表、字典、集合这些可变的数据类型，
否则 Python 解释器会抛出 TypeError 错误
创建集合set
1、使用 {} 创建
setname = {element1,element2,...,elementn}
a = {1,'c',1,(1,2,3),'c'}
print(a)
2、set函数创建
set() 函数为 Python 的内置函数，其功能是将字符串、
列表、元组、range 对象
等可迭代对象转换成集合。该函数的语法格式如下：
setname = set(iteration)
其中，iteration 就表示字符串、列表、元组、range 对
象等数据。
注意：创建一个空集合必须用 set() 而不是 { }，因为
{ } 是用来创建一个空字典
set1 = set("baidu.com")
set2 = set([1,2,3,4,5])
set3 = set((1,2,3,4,5))
print("set1:",set1)
print("set2:",set2)
print("set3:",set3)
结果可能如下：
set1: {'d', 'o', 'b', 'a', 'c', '.', 'm', 'i', 'u'}
set2: {1, 2, 3, 4, 5}
set3: {1, 2, 3, 4, 5}
s = set(['A', 'B', 'C']) #set也是无序的，也不能包含重
复的元素
访问一个set的意义就仅仅在于查看某个元素是否在这个集合里面：
>>> print 'A' in s
True
>>> print 'D' in s
False
也通过for来遍历：
s = set([('Adam', 95), ('Lisa', 85),
('Bart', 59)])
#tuple
for x in s:
print (x[0],':',x[1])
>>>
Lisa : 85
Adam : 95
Bart : 59
通过add和remove来添加、删除元素（保持不重复），
添加元素时，用set的add()方法：
>>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4])
如果添加的元素已经存在于set中，add()不会报错，但
是不会加进去了：
>>> s = set([1, 2, 3])
>>> s.add(3)
>>> print s
set([1, 2, 3])
删除set中的元素时，用set的remove()方法：
>>> s = set([1, 2, 3, 4])
>>> s.remove(4)
>>> print s
set([1, 2, 3])
如果删除的元素不存在set中，remove()会报错：
>>> s = set([1, 2, 3])
>>> s.remove(4)
Traceback (most recent call last):
File "", line 1, in
KeyError: 4
所以如果我们要判断一个元素是否在一些不同的条件内
符合，用set是最好的选择，下面例子：
months =
set(['Jan','Feb','Mar','Apr','May','Jun',
x1 = 'Feb'
x2 = 'Sun'
if x1 in months:
print 'x1: ok'
else:
print 'x1: error'
if x2 in months:
print 'x2: ok'
else:
print 'x2: error'
>>>
x1: ok
x2: error
总结：1、list、tuple是有序列表；dict、set是无序列
表
2、list元素可变、tuple元素不可变
3、dict和set的key值不可变，唯一性
4、set只有key没有value
5、set的用途：去重、并集、交集等
6、list、tuple：+、*、索引、切片、检查成员等
7、dict查询效率高，但是消耗内存多；list、
tuple查询效率低、但是消耗内存少
函数
函数
1、概念：
在数学领域，函数是一种关系，这种关系使一个集合里的每一个元素对应到另一个集合里的唯一元素。 y= f(x)
计算机的函数，是一个固定的一个程序段，或称其为一个子程序
2、作用：
函数是组织好的，可重复使用的，用来实现单一或相关联功能的代码段。
3、分类：
内置函数，标准库函数，用户自定义函数
3.1 内置函数 ： str()/list()/len()/max()/min()，可以拿来直接使用
3.2 标准库函数：所有的库函数都可以先 import 库名 然后通过 dir(库名) 查看该模块下的所有内置方法。
import os
os.getcwd() # 返回当前的工作目录
os.system('mkdir today') # 执行系统命令 mkdir DOS
import sys
print(sys.argv) # python demo.py
one two three #主调用传参数
['demo.py', 'one', 'two', 'three']
import math
math.fabs(-0.03) #返回x的绝对值
xxx@qq.com
import re #正则表达式的库 * 任意长度字符 ？ 一个字符长度
re.findall(r'\bf[a-z]*', 'which foot or
hand fell fastest')
3.3 用户自定义函数： 三要素：定义，调用，返
回值
3.3.1 函数的定义
语法：
def 函数名（形参数列表）: <缩进>函数体
eg：
def show()：
print("hello show1!!")
print("hello show2!!")
print("hello show3!!")
注意：函数名称必须符合命名规范，
1、不要和关键字冲突
2、不能用数字开头
3、只能是数字，字母，下划线组成
3.3.2 函数的调用
调用函数之前，必须先定义函数内置函数对象会自动创建。例如：str,python启动后都创建好了
标准库和第三方库函数，通过import导入模块时，会执行模块中的def语句
自定义函数可以在定义位置以下任意位置调用，单独调用要顶格书写
show()
3.4 函数参数与返回值：
#函数定义
def print_welcome ( name ): #一个形式参数
print("Welcome", name)
def area( width, height ): #两个参数
return width * height
#函数调用
print_welcome("caoqb") #实际参数
w = 4
h = 5
r = area(w, h)
print("width =", w, " height =", h, " area =", r)
注意：
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
1、python 传不可变对象实例
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print( b ) # 结果是 2
2、传可变对象实例
#可写函数说明
def changeme( mylist ): #修改传入的列表
mylist.append([1,2,3,4])
print ("函数内取值: ", mylist)
return
#调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
3、默认参数
调用函数时，如果没有传递参数，则会使用默认参数。
以下实例中如果没有传入 age 参数，则使用默认值：
def printinfo( name, age = 30 ): #打印任何传入的字
符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=20, name="caoqb" )
print ("------------------------")
printinfo( name="caoqb" )
4、不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
def printinfo( arg1, *vartuple ): #打印任何传入的参数 ，
print ("输出: ")
print (arg1)
print (vartuple)
#调用printinfo 函数
printinfo( 70, 60, 50 )
输出:
70
(60, 50)
还有一种就是参数带两个星号 * *基本语法如下：
加了两个星号 ** 的参数会以字典的形式导入
def printinfo( arg1, **vardict ):
print ("输出: ")
print (arg1)
print (vardict)
#调用printinfo 函数
printinfo(1, a=2,b=3)
输出:
1
{'a': 2, 'b': 3}
4、函数的返回值
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。
如果函数体中包含return语句，则结束函数执行并返回值
如果函数体中不包含return语句，则返None值
要返回多个返回值，使用列表、元组、字典、集合将多个值“存起来”即可
注意：函数一次返回多个结果时，是以元组的形式返回
的。
def my_avg(a,b):
return (a+b)/2 #return作用 1）返回值
2）结束函数的运行
c = my_avg(10,12)
print(c)
def my_add(a,b):
print("计算两个数的值：{0}，{1},{2}".format(a,b,(a+b)))
return #没有写返回值，默认返回None。
print(my_add(11,16))
def test03():
msg='我要返回多个值'
print(msg)
return msg,"hello xiaozhu",[1,2,3,4,5],
{'name':'zhou','age':18}
t3=test03()
print('test03的结果：'+'\n'+'\t'+str(t3))
模块
python 模块概念
1、Python 模块(Module)，是一个 Python 文
件，以 .py 结尾，包含了 Python 对象定义和Python语句。
2、模块能定义函数，类和变量，模块里也能
包含可执行的代码。
3、每个模块都是一个独立的名称空间
模块分为三种：
1、内置模块(又称标准库)执行
help('modules')查看所有Python自带模块列表
2、第三方开源模块，可通过pip install 模块
名 联网安装
3、自定义模块
模块使用流程：
1、import
module[,module1,module2 ...] # 引入模 如果有多个用","隔开
通常情况下，Python 会按照以下顺序查找指定的模块文件：
在当前目录，即当前执行的程序文件所在目录下查找；
到 PYTHONPATH（环境变量）下的每个目录中查找；
到 Python 默认的安装目录下查找。
注意：
第二种导入方式： from 模块名 import函数名
from modname import name1[,name2[, ... nameN]]
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中
这个声明不会把整个模块导入到当前的命名空间中
它只会将 fib 里的 name1 单个引入到执行这个声明的模块的全局符号表
第三种导入方式： import 模块名 as 新名字
相当于给导入的模块名称重新起一个别名，便于记忆，方便地在程序中调用。
python 的模块常见多文件编程使用
1、在同一文件夹下模块函数调用：
A.py文件：
def add(x,y):
print('和为：%d'%(x+y))
B.py文件调用：
import A
A.add(1,2)
或
from A import add
add(1,2)
2、在同一文件夹下模块类调用：
A.py文件:
class A:
def __init__(self,xx,yy):
self.x=xx
self.y=yy
def add(self):
print("x和y的和为：%d"%
(self.x+self.y))
B.py文件调用：
from A import A
a=A(2,3)
a.add()
或
import A
a=A.A(2,3)
a.add()
3、在不同文件夹下模块调用
A.py文件的文件路径：E:
\PythonProject\caoqb
B.py文件：
import sys
sys.path.append(r'E:\PythonProject\caoqb')
'''python import模块时， 是在sys.path里按顺
序查找的。
sys.path是一个列表，里面以字符串的形式存储了许多路径。
使用A.py文件中的函数需要先将他的文件路径放到sys.path中'''
import A
a=A.A(2,3)
a.add()
2、模块名.函数名
() # 在当前代码中调用模块函数
举例：
在mod_add.py 中定义函数如下
def add(a,b):
return a+b
在mod_test.py 中引入模块并调用
import mod_add
x = mod_add.add(3, 4)
print("x = ", x)
或者
import module1 as jsq
x = jsq.add(3, 4)
print("x = ", x)
输出结果为
x = 7
注意特殊情况：
if __name__ == '__main__' 相当于 Python模拟的程序入口。Python 本身并没有规定这
么写，这只是一种编码习惯。由于模块之间
相互引用，不同模块可能都有这样的定义，
而入口程序只能有一个。到底哪个入口程序
被选中，这取决于 name 的值。
__name__是内置变量，用于表示当前模块的名字。
所以，
if __name__ == '__main__'
我们简单的理解就是：如果本模块是被直接
运行的，则代码块被运行，如果本模块是被
导入到其它模块中去，则处于 name 中的代
码不被运行。
模块的升级版：包
包的概念：把许多个模块按照功能放到不同
的目录中来组织模块，
这些组织存放模块文件的目录，我们
称之为包。
包只是模块的一种形式而已，包的本
质也是一种模块。
一个包含__init__.py文件的目
录，
创建包的目的不是为了运行，而
是被导入使用
包的使用：
第一种方法：
1、新建一个包文件，会自动生成一个__init__.py文件
2、可以在__init__.py中编写代码和变量
3、在包同一级别的位置新建一个测试模块
test.py
4、在测试模块中引入包 import mypackage
5、在测试模块中使用包中函数和变量
第二种方法：(推荐)
1、新建一个包文件
2、在该包文件下新建多个模块文件 test1.py
test2.py
3、在包下的模块文件中分别编写函数或者类
4、在包同一级别的位置新建一个测试模块
test.py
5、在测试模块中引入包 from 包 import 模 块 或者 from 包.包 import 模块
5、在测试模块中使用包中函数和变量
第三方模块的安装：
1、命令提示符安装：
开始 --》运行 ---》cmd --》python 进
入环境
pip -–version 查看是否有pip工具
如果没有需要 python get-pip.py 该文件在共享目录
https://pan.baidu.com/s/
1drSW3InNKj8gczbPNA1a7A 提取码: 7nhv
或者 https://bootstrap.pypa.io/getpip.py
pip使用命令：在cmd中执行不用进到python
> pip install <包名>
#安装最新版
> pip install -v <包名>== #安装指定版本
> python -m pip install <包名> #安装最新版
> pip uninstall <包名
> #卸载Python包
> pip search <包名
> #搜索包
> pip install --upgrade <包名
> #升级包到最新版本
> pip list #列出已经安装的Python包
> pip show <包名
> #查看某个包的信息
> pip show --files <包名
> #查看某个包下的文件
pip install matplotlib
Collecting matplotlib
Downloading matplotlib-3.3.0-cp38-cp38-
win_amd64.whl (8.8 MB)
|▌ | 163 kB 23 kB/
s eta 0:06:06
pip缓存位置： C:
\Users\Administrator\AppData\Local\pip\cache
pip安装位置： c:
\users\administrator\appdata\local\programs\python\python38\lib\site
packages (4.9.1)
2、pycharm 安装模块
file--》setting --》project untitled --
>project InterPreter
右侧有一个加号 单击进入 在最上面的搜索
栏输入要安装的包名
左下角 install Package
如果安装过程失败或者速度很慢，可以考虑
修改数据来源地址
左下角 Manage Repositories
清华：https://pypi.tuna.tsinghua.edu.cn/
simple
阿里：http://mirrors.aliyun.com/pypi/simple/
豆瓣：http://pypi.douban.com/simple/
华中理工大学：http://pypi.hustunique.com/
山东理工大学：http://pypi.sdutlinux.org/
中国科学技术大学http://pypi.mirrors.ustc.edu.cn/
官方： https://pypi.python.org/-simple
lxml BeautifulSoup4 urllib3
模块使用实例：
1、datetime是Python处理日期和时间的标准
模块
from datetime import datetime
now = datetime.now() # 获取当前datetime
print(now)
dt = datetime(2018, 6, 19, 13,15) # 用指定日期时间创建datetime
print(dt)
#str转换为datetime
datee_test =datetime.strptime('2018-06-19 13:15:00','%Y-%m-%d %H:%M:%S')
print(datee_test)
#datetime转换为str
now = datetime.now()
print(now.strftime('%a, %b %d%H:%M'))
• %a 本地简化星期名称
• %b 本地简化的月份名称
• %H 24小时制小时数（0-23）
• %M 分钟数（00-59）
2、随机数:random模块，random模块是
python自带模块，功能是：生成随机数。
import random
print(dir(random)) #查看random
模块可用的方法
生成随机整数：randint()
random.randint(10,2390) #生成
一个指定范围内的整数，其中下限必须小于
上限
输出：1233
随机浮点数：random
random.random() #不带参数
输出：0.47203863107027433
random.uniform(35, 100) #带上限，下限参数
输出：78.02991602825188
random.uniform(350, 100) #随机浮点数时，下限可以大于上限
输出：232.2659504153889
随机字符：choice
random.choice('98&@!~gho^')
#98&@!~gho^是随便给的一个字符序列
输出：'g'
洗牌：shuffle()
list = [20, 16, 10, 5] #要随机出现的列表源
random.shuffle(list)
print "随机排序列表 : ", list
3、python的休眠函数sleep
import time
print "Start : %s" % time.ctime()
time.sleep( 5 ) #休眠5秒钟
print "End : %s" % time.ctime()
4、python 的暂停动作
import os
os.system("pause");
# 文件
python 文件操作：
不论那种语言，对于文件的操作都有如下基
本流程：
打开文件 ==》读写(定位)文件 ==》关闭文件
python也不例外：
1、打开文件
打开文件时，需要指定文件路径和以何等方式打开文件，
打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。
Python使用内置的open()函数打开一个文件，并且返回一个文件对象，也叫句柄(handle)。
f = open("./test.txt") #在本文件夹下面的一个文件
f = open("C:/Python33/README.txt") # 全
路径
注意有时候，打开文件时，我们需要指定文件打开的模式。
f = open("test.txt", 'r') #只读 必
须存在
f = open("test.txt", 'w') #只写 创 建 清空功能慎重使用
f = open("test.txt", 'a') #追加 创 建
其实所有的模式如下：常用模式
| r | 文本模式，读取 默认模式 ，r 这种应该
在后面注明编码格式 如encode=‘UTF-8’|
| rb | 二进制模式，读取，不能指定编码格式
|
2/15
| w | 文本模式，写入 |
| wb | 二进制模式，写入 |
| a | 文本模式，追加 |
| ab | 二进制模式，追加 |
| + | 可读可写 |
r+ rb+ w+ wb+ a+ ab+
所有能打开的文件类型主要有两种：
1、ASCII文件 = =》用文本编辑器可以直接
3/15
打开并阅读
2、二进制文件 = =》不能用文本编辑器打开
读写
但是注意：
f =
open("test.txt",mode="r",encoding="UTF-8")
对 文本文件才有可能需要编码
f =
open("text.bin",mode="rb",encoding="UTF-8")
错 二进制文件不需要指定编码
否则会报出异常：binary mode doesn't take
an encoding argument
读取非UTF-8编码的文本文件，需要open()
函数传入encoding参数，
例如，读取GBK编码的文件：
f = open('/Users/gbk.txt', 'r', encoding='gbk')
f.read()
= =》'测试'
遇到有些编码不规范的文件，你可能会遇到
UnicodeDecodeError，因为在文本文件中
可能夹杂了一些非法编码的字符。遇到这种
情况，open()函数还接收一个errors参数，
表示如果遇到编码错误后如何处理。最简单
的方式是直接忽略：
f = open('/Users/gbk.txt', 'r',encoding='gbk', errors='ignore')
2、文件关闭： f.close()
官方建议：
with open('test.txt', 'r') as f:
do_something()
使用这种用法，我们不必调用close()方法，系统自动垃圾回收
在with语句程序内部就会执行，无论内部是否出现异常。
3、文件操作
以文本方式写入的文件, 无需指定编码
以二进制方式写入文件，写入的内容要
求为bytes,所以通过str.encode('utf-8')来返回bytes
3.1 文件写操作：write()方法
f.write("hello world") #向目标文本文件写入一行字符串
f.write("hello world".encode("utf-8")) #向目标二进制文件写入一行字符串
3.2 文件写操作： writelines()方法写入文件的字符串序列。
seq = ["hello world 1\n", "nihaowohao 2"]
f.writelines( seq )
3.3 文件读操作：read()方法从文件读取指定的字节数，如果未给定或为负则读取所有。
ret = f.read() #默认全部读出
ret = f.read(5) #读出指定长度字符
3.4 文件读操作： readline()方法可以读出一行数据
ret = f.readline() #读取一行
注意：有个很像的 readlines()方法
ret = f.readlines() #返回的是一个列表，但是当数据较大时，这样的用法会很用内存
3.5 文件定位操作：
tell() 方法用于获取文件当前指
针距离文件开头位置
seek() 方法用于移动文件读取指针到指定位置。
f.seek(offset[, whence])
其中：
offset -- 开始的偏移量，也就是代
表需要移动偏移的字节数
offset >0 向文件末尾偏移
offset <0 向文件开头偏移
whence：可选，默认值为 0。给offset参数一个定义，表示要从哪个位置开始偏移；
0代表从文件开头开始算起，
1代表从当前位置开始算起，
2代表从文件末尾算起。
f.seek(14,0) #从文件开头偏移
14个字节读出5个字符
ret = f.read(5)
f.seek(10, 2) #从文件末尾偏移
10字节写入“666”字符串
ret =
f.write("666".encode("utf-8"))
seek()函数报错：can't do nonzero endrelative seeks
在文本文件中，没有使用b模式选项打开的文件，只允许从文件头开始计算相对位置，从文件尾计算时就会引发异常。
4、默认都是读取文本文件，并且是UTF-8编
码的文本文件。要读取二进制文件， 比如图片、视频等等，用'rb'模式打开文件即可：
5、文件的重命名、删除 、创建等相关操作import os #os 模块中的 rename()可以完成对文件的重命名操作
os.rename("毕业论文.txt", "毕业论文-最终
版.txt")
import os
os.remove("毕业论文.txt") #os 模块中的
remove()可以完成对文件的删除操作。
import os
os.mkdir("张三") #创建文件夹
import os
os.mkdir("张三") #获取当前目录
import os
os.chdir("../") #改变默认工作目录
import os
os.listdir("./") #获取目录列表
import os
os.rmdir("张三") #删除文件夹
一些注意事项：
编码过程： x = “hello ”
b = bytes(x,encoding='utf-8')
= =>b 就是可以写操作的二进制数据
解码过程： b = ？？？
x = b.decode('utf-8')
==>x 就是可以是被的字符串
b = b"example" # bytes object
s = "example" # str object
sb = bytes(s, encoding = "utf8") # str to
bytes
或者：sb = str.encode(s) # str to
bytes
bs = str(b, encoding = "utf8") # bytes
to str
或者：bs = bytes.decode(b) # bytes
to str
扫一扫
7907
到【灌水乐园】发言
