Python初级语法-Plus

人机交互

input用法

s = input()#输入一个字符串
s = input("请输入数据：")#提示信息后输入
s = eval(input())#根据字符串自动返回匹配类型的值。输入12，返回int；输入3.2，返回float；输入[1, 2]，返回list
s = float(input())
s = int(input())

进制转换

	2进制	8进制	10进制	16进制
2进制		bin(int(n,8))	bin(int(n,10))	bin(int(n,16))
8进制	oct(int(n,2))		oct(int(n,10))	oct(int(n,16))
10进制	int(n,2)	int(n,8)		int(n,16)
16进制	hex(int(n,2))	hex(int(n,8))	hex(int(n,10))

基本方法

len(A)#求A长度，A必须实现了__len__方法
type(A)#获取A的类型
round(B,2)#对数字B四舍五入，保留两位小数

Print用法

print(1,2,3,4,5)             # 输出：1 2 3 4 5，默认用空格分隔多个输出对象
print(1,2,3,4,5,sep = ',')   # 输出：1,2,3,4,5，各输出对象间用指定的逗号分隔
print(2019,11,18,sep = '/')  # 输出：2019/11/18
print(23,59,36,sep = ':')    # 输出：23:59:36
print([1,2,3,4,5])           # 输出：[1, 2, 3, 4, 5]，这是一个列表对象
print(*[1,2,3,4,5])          # 输出：1 2 3 4 5，输出时对列表对象（序列类型）进行解包
print('12345')               # 输出：12345，这是一个对象
print(*'12345')              # 输出：1 2 3 4 5，输出时对字符串对象（序列类型）进行解包
for i in range(5):           # 产生整数序列：0,1,2,3,4，依次赋值给i
	print(i)                 # 输出后换行，竖向输出0 1 2 3 4
# 加参数end = ','，输出后不换行，每个输出后跟一个逗号0,1,2,3,4,
for i in range(5):
	print(i,end = ',')       
# 加参数end = ' '，输出后不换行，每个输出后跟一个逗号0 1 2 3 4 （注意4后面有空格）
for i in range(5):
	print(i,end = ' ')

在已经创建了文件对象的前提下，可通过 file 参数将输出打印到其他文件对象中，如 file=f (f 是已经创建好的文件对象)

#输出到文件
f = open('test.txt','w',encoding = 'utf-8')       
# 以写模式打开当前路径下的文件test.txt（文件不存在时创建文件），创建文件对象，命名为： f

print('这是要写入的测试数据')                        
# file参数缺省时，默认输出到控制台，即显示器

print('这是要写入的测试数据',file=f)                 
# 将输出的内容 '这是要写入的测试数据' 写入到文件对象 f 中，即写入文件test.txt中

f.close()                                          
# 文件对象的 close()方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。

#格式控制
name = input()
city = input()
hobby = input()

#第一种
print(f"我的名字是{name}，来自{city}，我的爱好是{hobby}!")
#第二种
print("我的名字是{}，来自{}，我的爱好是{}".format(name, city, hobby))#{}可以替代int float str

#浮点数精度控制
num = 1.344
print("{:.3f}".format(num))

Python format 格式化函数 | 菜鸟教程 (runoob.com)

#分行书写末尾加\或()括起来多行
#用反斜杠链接多行代码，示例输出:55
a = 22 + \
33
print a

#用小括号括起来，示例输出:55
a = (22+
33)
print 

#针对较长字符串分成多行书写的还有一种简单的方法：用三个单引号，但是该方法只针对字符串有用。
a = '''32 +
45'''
print a

循环

#sum代替循环求和0+1+2+...+99
sum(range(100))#sum参数为可迭代的对象如list

#生成公差为1的等差数列
list(range(1, n + 1))

#for...else...语句
#else写循环结束后（包括循环次数为0的情况）应执行的代码
for i in range(10):
	if A:
		print("直接退出for...else...语句（else里面语句不执行）")
		break
else:
	print("没执行过break，则for停止后执行else里的语句")

字符串

字符串属性

操作符	描述
s+t	拼接两个序列 s 和 t‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
s * n 或n * s‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	将序列s重复n次生成新序列‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
s[i]‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	索引，返回序列s的第i项‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
s[start:end[:step]]‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	切片，返回序列 s 从start到end （不包括end ）的步长为step的字符生成新的序列，step缺省时，步长为1，返回序号从start到end的子序列。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
len(s)‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	返回序列s的长度（包含元素的个数）‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
min(s,*[,key, default])‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	返回序列 s的最小值，key关键字缺省时按元素值比较‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
max(s,*[,key, default])‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	返回序列 s的最大值，key关键字缺省时按元素值比较‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
s.count(x)‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	序列s中x的个数‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
s.index(x[, i[, j]])‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	序列中第一个x的索引值，i值表示从索引i处开始查找x，j表示x查找范围在i和j之间。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
x in s‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	如果序列x与序列s中的任一子序列相等，返回True，否则返回False；当x与s的元素相等时返回True，否则返回False。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
x not in s‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	如果序列x与序列s中的任何子序列都不相等，返回True，否则返回False

#字符串属性操作示例
id = input()    # 输入学号
name = input()  # 输入姓名
print(id + name) # 输出学号姓名，中间无空格
print(name * 5)   # 重复输出姓名5遍，中间无空格

s = '人都可以走路，也就是有一个走路方法'  # 这是一个字符串
n = eval(input()) # 接收一个整数输入n
print(s[n])       # 输出字符串s中序号为n的字符
print(s[::2])    # 输出字符串s中序号为偶数的字符
print(s[::-1])   # 将字符串逆序输出
s = s[k:] + s[:k-1]#删除第k个元素
print(len(s))     # 输出字符串s的长度
print(len(s[n:])) # 输出字符串s中从序号n到字符串结尾包含的字符个数（包括序号为n的字符）
print(s.count('走路'))  # 输出字符串s中子字符串‘走路’的个数
print(s.index('走'))   # 输出字符串s中字符‘走’第一次出现的位置序号
test = input()          # 输入一个字符串
print(test in s)       # 测试test是否在s中存在，输出测试的结果
#print(s.index('走路方法论'))   # ValueError: substring not found

#字符映射处理
intab = "aeiou"
outtab = "12345"
deltab = "thw"
  
trantab1 = str.maketrans(intab,outtab) # 创建字符映射转换表
trantab2 = str.maketrans(intab,outtab,deltab) #创建字符映射转换表，并删除指定字符
  
test = "this is string example....wow!!!"
  
print(test.translate(trantab1))#th3s 3s str3ng 2x1mpl2....w4w!!!
print(test.translate(trantab2))#3s 3s sr3ng 2x1mpl2....4!!!

字符串方法

方法名	描述	备注
str.upper()‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	转换字符串str中所有字母为大写‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
str.lower()‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	转换字符串str中所有字母为小写‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
str.strip()‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	用于移除字符串头尾指定的字符（缺省时去掉空字符，包括\t、\n、\r、\x0b、\x0c等）	‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬另有str.lstrip()与str.rstrip()
str.split()‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	通过指定分隔符对字符串进行切片，将一个字符串分裂成多个字符串列表，缺省时根据空格切分，可指定逗号或制表符等。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
str.join(seq)‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	以字符串str作为分隔符，将序列 seq 中所有的元素合并为一个新的字符串‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
str.find()‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	搜索指定字符串‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
str.replace(old, new[, count])‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	把字符串str中的 old 替换成 new，如果 count 指定，则替换不超过 count 次，否则有多个old子串时全部替换为new。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬
for in ‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬	字符串迭代，如果var在string中存在，则进行循环

字符串方法操作示例

s = input()       # 输入一个英文字符串
print(s.upper())  # 将字符串中所有英文字符转为大写输出
print(s.lower())  # 将字符串中所有英文字符转为小写输出
t = s.split()     # 将输入的字符串根据空格切分为列表，命名为t,每个单词为一个元素
print(t)         # 输出切分的列表
print(' '.join(t)) # 将列表t中的元素用空格连接后输出
print('-'.join(t)) # 将列表t中的元素用连字符“-”连接后输出
print('/'.join(t)) # 将列表t中的元素用'/'连接后输出
print(s.find('the')) # 搜索字符串s中是否存在字符串'the'，如存在返回其位置序号
r = s.replace('the', 'a') # 将字符串s中所有的'the'替换为'a'，替换后的字符串重新命名为r
print(r)             # 输出替换后的字符串r
r = s.replace('the', 'a', 1)# 将字符串s中的第一个'the'替换为'a'，替换后的字符串重新命名为r
print(r)            # 输出替换后的字符串r

列表

s = input()       # 输入一个英文字符串
print(s.upper())  # 将字符串中所有英文字符转为大写输出
print(s.lower())  # 将字符串中所有英文字符转为小写输出
t = s.split()     # 将输入的字符串根据空格切分为列表，命名为t,每个单词为一个元素
print(t)         # 输出切分的列表
print(' '.join(t)) # 将列表t中的元素用空格连接后输出
print('-'.join(t)) # 将列表t中的元素用连字符“-”连接后输出
print('/'.join(t)) # 将列表t中的元素用'/'连接后输出
print(s.find('the')) # 搜索字符串s中是否存在字符串'the'，如存在返回其位置序号
r = s.replace('the', 'a') # 将字符串s中所有的'the'替换为'a'，替换后的字符串重新命名为r
print(r)             # 输出替换后的字符串r
r = s.replace('the', 'a', 1)# 将字符串s中的第一个'the'替换为'a'，替换后的字符串重新命名为r
print(r)            # 输出替换后的字符串r

Python sorted() 函数 | 菜鸟教程 (runoob.com)

列表的方法（属性和字符串的一样）

方法	解释
ls.insert(i, e)	在序号i的位置插入元素e
ls.remove(e)	删除第一个出现的e
ls.append(e)	在列表最后追加e
ls.pop()	弹出列表最后一个元素
ls.reverse()	逆置列表
ls.sort()	排序
ls1 + ls2	ls2的元素追加到ls1中
ls1.extend(ls2)	效果同上
ls * n	n个ls拼接

Python3 List sort()方法 | 菜鸟教程 (runoob.com)

• sort函数使用实例

  动物重量排序

  描述

  输入一系列动物名和其重量，重量单位可能是kg，也可能是t，动物名、与重量间空格分隔，重量数值与单位间无分隔。按重量由小到大排序以二维列表形式输出。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

  输入

  每次输入一个动物名，以及其重量和单位，动物名与重量间用空格分隔，直接输入回车时结束输入。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

  输出

  以二维列表形式输出，按重量由小到大升序排序。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

  输入输出示例

  输入：

  海豚 228kg 北极熊 0.75t 企鹅 35kg 海豹 0.35t 白鲸 1.35t

  输出：

  [['企鹅', '35kg'], ['海豚', '228kg'], ['海豹', '0.35t'], ['北极熊', '0.75t'], ['白鲸', '1.35t']]

  ans = []
  
  while True:
      s = input()
      if s == '':
          break
      ls = s.split()
      ans.append(ls)
  
  print(sorted(ans, key = lambda x: float(x[1][:-1]) * 1000 if x[1][-1] == 't' else float(x[1][:-2])))#sorted无cmp函数，使用key = lambda x: x的表达式
  

列表推导式

列表推导式是一种创建新列表的便捷的方式，通常用于根据一个列表中的每个元素通过某种运算或筛选得到另外一系列新数据，创建一个新列表。列表推导式由1个表达式跟一个或多个for 从句、0个或多个if从句构成。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

# 列表推导式由1个表达式跟一个或多个for 从句、0个或多个if从句构成。
# 列表推导式置于一对方括号之中
[x**2 for x in range(10)]  #计算range(10)中每个数的平方，推导出新列表# 得到新列表[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

for前面是一个表达式，in 后面是一个列表或能生成列表的对象。将in后面列表中的每一个数据作为for前面表达式的参数，再将计算得到的序列转成列表。if是一个条件从句，可以根据条件返回新列表。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

for前面也可以是一个内置函数或自定义函数：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

# 自定义函数f(x)
def fun(x):
    return x + x ** 2 + x ** 3     # 返回 x + x ** 2 + x ** 3

y = [fun(i) for i in range(10)]    # 列表推导式，按函数fun(x)，推导出新列表print(y)                           # 输出列表[0, 3, 14, 39, 84, 155, 258, 399, 584, 819]

#用条件语句（if从句）对数据进行过滤
ls = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
print(ls)      # 输出[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

#多个for从句对多个变量进行计算
ls = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
print(ls)      # 输出[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

#列表推导式的[]改成()得到生成器
print([x ** 3 for x in range(10)])
# 输出列表 [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]

print((x ** 3 for x in range(10)))
# 输出生成器对象 <generator object <genexpr> at 0x000001FBC47185C8>print(list(x ** 3 for x in range(10)))
# 生成器可遍历或转列表# [0, 1, 8, 27, 64, 125, 216, 343, 512, 729]

#字典推导式
dic = {'李明': '20191202001', '张凡':'20191202002'} # 姓名：学号
dic_update = {v: k for k, v in dic.items()}
print(dic_update)
# 输出交换了键和值的字典 {'20191202001': '李明', '20191202002': '张凡'}

#集合推导式
dic = {'李明': '20191202001', '张凡':'20191202002'} # 姓名：学号
dic_update = {v: k for k, v in dic.items()}
print(dic_update)
# 输出交换了键和值的字典 {'20191202001': '李明', '20191202002': '张凡'}

函数

局部变量与全局变量

局部变量：函数内部定义的变量，函数执行完后被释放

全局变量：函数外部定义的变量

############1
x = 1#全局变量
def f():
	print(x)#输出1

############2
x = 1
def f():
	x = 2
	print(x)#输出2
print(x)#输出1

############3
x = 1
def f():
	global x#声明使用全局变量x
	x = 2

print(x)#输出2

参数传递

#猜猜下面代码运行结果是什么
def func(x = [],y = [6,7]):
  x.append(8)
  y.append(8)
  return(x+y)

a,b = [1,2],[3,4]
t=func(x=a)
t=func(y=b)
print(func(),end=";")

#结果是[8, 8, 6, 7, 8, 8]
#Note：你会发现形参的改变是会被保留的！注意x，y值的变化！

lambda函数

#用于代替一个有若干参数和一个返回语句的函数
def f(x, y):
	return x + y

f = lambda x, y: x + y
#上面两句作用完全相等，lambda函数更简洁

常用内置函数

map和filter均返回iterable

#map(function, iterable)

def square(x):
	return x ** 2#每个元素平方
map(square, [1, 2, 3])#返回[1, 4, 9]
map(int, ['3', '4'])#返回34

#filter
#filter(function, iterable)

def even(x):
	return x % 2 == 0#筛选偶数

filter(even, [1, 2, 3, 4])#返回[2, 4]
filter(str.digit, 'p2p')#返回'2'

#reduce
from functools import reduce

def add(x, y) :            # 两数相加
    return x + y
sum1 = reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
sum2 = reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数

集合

集合是无序的，无重复元素的数据类型，在转化为序列时，其各元素位置随机

方法	解释	示例
st.add(e)	向集合st添加元素e
st.remove(e)	从st中移除e，若无e则报错
st.discard(e)	移除e，无报错
st.pop()	随机删除一个元素，有报错
st.update(any)	any可为集合、列表、元组、字典等，将any中元素加入st中	>>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.update({1,3}) >>> print(thisset) {1, 3, 'Google', 'Taobao', 'Runoob'} >>> thisset.update([1,4],[5,6]) >>> print(thisset)
st.clear()	清空
st1 | st2	st1并st2
st1 & st2	st1交st2
st1 - st2	st1去除st2
st1 ^ st2	不同时在st1和st2中的元素
set()	生成一个空集合{}，不能用st={}声明，这样会判定为字典

print(set())   # 产生空集合 set()
print(set('Hello Python')) # 字符串转集合，去掉重复字符 {'e', 'H', 'c', 'a', 'R', 'r', 'k', 'n'}

print(set((1,2,3,4,5,5))) # 元组转集合，去掉重复元素  {1, 2, 3, 4, 5}

print(set(set(['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n'])))
#  列表转集合，去掉重复元素  {'e', 'a', 'r', 'k', 'H', 'n', 'c'}
print(set([1,2,1,2,3,4,5,6,0,9,12,22,3])) #
# 列表转集合，去掉重复元素  {0, 1, 2, 3, 4, 5, 6, 9, 12, 22}
print(set({'University' : 'WHUTI', 'Rank' : 40 }))
# 字典转集合，返回字典的键（字典的键唯一），不确定顺序 {'Rank', 'University'}

print(set(enumerate(['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n'])))
# {(9, 'k'), (4, 'e'), (0, 'H'), (7, 'a'), (3, 'k'), (8, 'n'), (1, 'a'), (5, 'r'), (2, 'c'), (6, 'r')}

类

class Bing():
    def __init__(self,age,name):
        self.age=age;
        self.name=name;
    
    def speak(self):
        print("My name is "+self.name)
    
lover=Bing(30,'wang')
lover.speak()

class Wangbingbing(Bing):
    def __init__(self,age,name):
        super().__init__(age,name)#调用父类方法
        

firstlover=Wangbingbing(22,'wangbingbing')
firstlover.speak()

文件

open()函数有两个参数：文件名和打开模式。打开模式用于控制使用何种方式打开文件，open()函数提供7种基本的打开模式，如下：

r：只读模式，如果文件不存在，返回异常FileNotFoundError，默认值

w：覆盖写模式，文件不存在则创建，存在则完全覆盖原文件

x：创建写模式，文件不存在则创建，存在则返回异常FileExistsError

a：追加写模式，文件不存在则创建，存在则在原文件最后追加内容

b：二进制文件模式

t：文本文件模式，默认值

+：与r/w/x/a一同使用，在原功能基础上增加读写功能

其中'r'、'w'、'x'、'a'可以和'b'、't'、'+'组合使用。

with open('test.txt') as file:#打开文件
    content=file.readlines()#按行读，content为一个列表
#[line.strip() for line in file]可以读入时对所有行进行操作，并组成列表
    for line in content:
        if '123' in line:
            print('Here am I')
            
filename='output.txt'#若该文件不存在则先创建一个

#w 写 r 读 a 追加 w+ 读和写
#write不会在写入的文本末尾添加空行。写入文件不存在时，创建文件。写入文件若已存在，写入前会清空原内容。
with open(filename,'w') as file:#以写模式打开文件，r读
    while True:
        name=input("What's your name?")
        if name == 'gui':
            break
        file.write(name+' entered the system!\n')#向文件写入内容，写入的必须是字符串
        print("Welcome to the system! "+name)

异常

如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。

如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印默认的出错信息）。

如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

try:
    print(5/0)
except ZeroDivisionError:#除0异常
    print("Can't divide by zero")
    
try:
    with open('fakefile') as file:
        content=file.read()
        print(content)
except FileNotFoundError:#文件存在异常
    pass#什么也不做
else:#不存在异常
		pass

模块

#第一种
import math#引入math模块
math.sqrt(10)#math.fun()调用math中的函数

#第二种
from math import sqrt#直接引入math中的sqrt函数
sqrt(10)

#第三种
from math import *#引入math中的全部函数

常用模块

collections

counter

Counter是字典的一个子类，字典的方法都可以使用，用于统计可迭代序列中每个元素出现的次数。

from collections import Counter

c = Counter('I just wanna run')
print(c)

#输出
Counter({' ': 3, 'n': 3, 'u': 2, 'a': 2, 'I': 1, 'j': 1, 's': 1, 't': 1, 'w': 1, 'r': 1})

(1条消息) Python计数器collections.Counter用法详解_THEAQING的博客-CSDN博客_collections.count