Python笔记

小问题

创建.py文件报错：Error parsing Velocity template: Encountered " " at [line 4, column 28] Was expecting one of:

#@Time: ${DATE} ${time}
#@Author:xfzhang0602
#@File:${NAME}.py
#@Software: ${PRODUCT_NAME}

解决方法
和后面的说明之间，要有空格，改为：

# @Time: ${DATE} ${time}
# @Author:xfzhang0602
# @File:${NAME}.py
# @Software: ${PRODUCT_NAME}

即可解决

概念

显示中文

#coding=utf-8
# -*- coding:utf-8 -*-

变量及类型

a = b = c = 100 #一次性多个变量赋值，相同数值
a,b,c = 1,100,"hello" #多个变量赋值，不同数值（及类型）
print(a,b,c)

标识符和关键字

python一些具有特殊功能的标示符，这就是所谓的关键字
关键字，是python已经使用的了，所以不允许开发者自己定义和关键字相同的名字的标示符
Python 3.8.5 目前有关键字35个:

False None True and as assert async
await break class continue def del elif
else except finally for from global if
import in is lambda nonlocal not or
pass raise return try while with yield

输出

格式化输出

什么是格式化

% 操作符 （最原始）
format()函数 (Python 2.6之后)
fStrings (Python 3.6 之后）【推荐】
看如下代码:

age = 10
print("我今年%d岁"%age)
age += 1
print("我今年%d岁"%age)
age += 1
print("我今年%d岁"%age)
...

在程序中，看到了 % 这样的操作符，这就是Python中最原始的格式化输出。

age = 18
age = 20 #变量被修改
country = "中国"
print("我的年龄是%d岁"%age)
print("我的国籍是%s"%country)
print("我的年龄是%d岁,我的国籍是%s"%(age,country)) #一次性输出两个变量

常用的格式符号

format 格式化函数

python2.6之后，可以使用format函数。

#1.顺序填充
str = "我的名字是{},我的年纪是{},我的国籍是{}".format("张三",18,"中国")
print(str)
#2.索引填充
str = "{0},{1},{0}!".format("你好","世界")
print(str)
#3.关键字填充
str = "姓名:{name},年龄:{age}".format(age=18,name="张三")
print(str)
#4.通过字典设置参数, ** 展开map集合
info = {"name":"张三","age":18}
str = "姓名:{name},年龄:{age}".format(**info)
print(str)
#5.利用列表的索引设置参数
list = ["IT私塾","www.itsishu.cn"]
str = "网站名称：{0[0]}，网址：{0[1]}，时间：{1}".format(list,2020)
print(str)

数字格式化

print("圆周率：{:+.2f}".format(3.1415926)) #输出：圆周率：+3.14
print("{:,}".format(10000000)) #输出：10,000,000
print("{:.2e}".format(1000000)) #输出：1.00e+06
print("{:.1%}".format(0.25)) #输出：25.0%

字符串格式化：对齐

str = "IT私塾"
print("{:*>10}".format(str)) #输出：******IT私塾
print("{:*<10}".format(str)) #输出：IT私塾******
print("{:#^10}".format(str)) #输出：###IT私塾

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
更多内容，可以参考：https://www.runoob.com/python/att-string-format.html

f-string 格式化

python3.6之后，可以使用f-string。

name = "咯咯"
age = 3
print(f"你好, {name}今年{age}岁了.") #输出：你好，咯咯今年3岁了.
str = "IT私塾"
print(f"{str:*>10}") #输出：******IT私塾
print(f"{str:*<10}") #输出：IT私塾******
print(f"{str:#^10}") #输出：###IT私塾###
#补充
#任意表达式
print(f"{2*100}") #输出：200
print(f"{'abc'.upper()}") #输出: ABC
#多行f-string
teacher = "张老师"
days = 3
message = (f"{'请假条':_^15}\n" #输出：______请假条______
f"{teacher}您好:\n" #输出：张老师您好:
f"我想请假{days}天,可以吗？" #输出：我想请假3天，可以吗？
)
print(message)
#显示大括号
print(f"{{86}}") #输出：{86}

换行输出

在输出的时候，如果有 \n 那么，此时 \n 后的内容会在另外一行显示

print("1234567890-------") # 会在一行显示
print("1234567890\n-------") # 一行显示1234567890，另外一行显示-------

print("aaa","bbb","ccc",200) #输出：aaa bbb ccc 200
print("www","itsishu","cn",sep=".") #输出：www.itsishu.cn
print("hello",end="")
print("world",end="\t")
print("python",end="\n") #输出：helloworld python
print("end") #输出：end

输入

password = input("请输入密码:")
print('您刚刚输入的密码是:', password)

input()的小括号中放入的是，提示信息，用来在获取数据之前给用户的一个简单提示
input()在从键盘获取了数据以后，会存放到等号左边的变量中
input()函数接受的输入必须是表达式

a = input("输入：")
print(type(a))
#input函数默认接受到的是字符串类型。
print("输入了一个数字：%s" %a)
a = int("123")
print(type(a))
b = a + 100
print(b)
c = int(input("输入c："))
print("输入了一个数字：%d" %c)
result = input(3+2)
print(result)

基本数据类型

Python的数据类型

1.基本数据类型
整形 （int）
浮点型 （float）
布尔型 （bool）
复数类型 （complex）
2.字符串类型 （string）
3.列表类型 （list）
4.元组类型 （tuple）
5.集合类型 （set）
6.字典类型 （dict）

基本数据类型

1.整型（int）

type() 查看数值类型

a10 = 100 #数字100，十进制表示
print(type(a10))
a2 = 0b01100100 #数字100，二进制表示
print(a2,type(a2))
a8 = 0o144 #数字100，八进制表示
print(a8,type(a8))
a16 = 0x64 #数字100，十流进制表示
print(a16,type(a16))

补充：二进制、八进制和十六进制的表示法
二进制 0 1 （只包含2个数字，不足以表达数量时，+1进位）
八进制 0 1 2 3 4 5 6 7 （只包含8个数字，不足以表达数量时，+1进
位）
十进制 0 1 2 3 4 5 6 7 8 9 （只包含10个数字，不足以表达数量时，+1进
位）
十六进制 0 1 2 3 4 5 6 7 8 9 a b c d e （只包含16个数字，不足以表达数量时，+1进
位）

#十进制转为二进制
print(bin(100)) #binary
#十进制转为八进制
print(oct(100)) #octonary
#十进制转为十六进制
print(hex(100)) #hexadecimal
#二进制：01100100 0 * 2**7 + 1 * 2**6 + 1 * 2**5 + 0 * 2**4 + 0 * 2**3
# + 1 * 2**2 + 0 * 2**1 + 0 * 2**0
#十进制：100 1 * 10**2 + 0 * 10**1 + 0 * 10**0
#八进制：144 1 * 8**2 + 4 * 8**1 + 4 * 8**0
#十六进制：64 6 * 16**1 + 4 * 16**0

2.浮点型（float）

a = 3.1415926
print(a,type(a))
a = 2.1e-2 #浮点型表示方法一
b = 5.67e3 #浮点型表示方法二，科学计数法
print(a,type(a))
print(b,type(b))

3.布尔型（bool类型）

state = True #True ,表示“真”，也表示“成立”："正确"，”对的“
state = False #False，表示“假”，也表示“不成立”：”不正确“，”错误的“
print(state,type(state))

4.复数类型（complex）

复数 = 实数 + 虚数
j：如果一个数的平方是-1，那么这个数就是j

c = 3 + 4j
print(c,type(c))
c = complex(3,4)
print(c,type(c))

5.自动类型转换

不同数据类型进行运算时，结果默认为更高精度类型
精度从第低到高： bool -> int -> float -> complex

#(a) bool + int
state = False #False在底层存储，本质是数字0
print("bool + int：",state + 3) #True在底层存储，本质是数字1
#(b) bool + float
print("bool + float: ",True + 3.2) #结果默认为浮点型
#(c) bool + complex
print("bool + complex: " , False + 2+3j)
#(d) int + float
print("int + float: " , 10 + 20.0)
#(e) int + complex
print("int + complex: " , 10 + 5+6j)
#(f) float + complex
print("float + complex: " , 3.14 + 5+6j)

6.强制类型转换

示例：

num1 = 10
num2 = 22.99
num3 = True
num4 = 4+5j
num5 = "567"
num6 = "a78"
#int()
res = int(num2) #22
print(res)
res = int(num3) #True为1,False为0
res = int(num5) #567
print(res,type(num5))
#res = int(num6) #:报错
print(res)
#float()
res = float(num1) #10.0
res = float(num3) #1.0
res = float(num5) #567.0
print(res)
#complex
res = complex(num1) #10+0j
res = complex(num2) #22.22+0j
res = complex(num3) #1+0j
res = complex(num5) #567+0j
print(res)
#bool
res = bool(num4) #3+4j
print(res)
res = bool(num6) #a78
print(res)

7.什么时候bool类型时false？（共10种）

表达“空”的概念的时候

a = 0
print(a,bool(a))
# a = 0.0 #浮点0
# a = 0j #复数0
# a = False #布尔False
# a = '' #空字符串
# a = () #空元组
# a = [] #空列表
# a = set() #空集合
# a = dict() #空字典
a = None #空对象
print(a,bool(a))

运算符和表达式

运算符包括：
算数运算符 （必会）
比较运算符 （必会）
赋值运算符 （会用）
位运算符 （计算机专业了解）
逻辑运算符 （必会）
成员运算符 （必会，学完全部数据类型后）
身份运算符 （必会，学完面向对象后）

算数运算符

#(1)整数 + - * /
print("7 + 2 = ",7 + 2)
print("7 - 2 = ",7 - 2)
print("7 * 2 = ",7 * 2)
print("7 / 2 = ",7 / 2)

#(2)浮点数 + - * /
#对大多数实数，计算机都无法精确存储。这造成误差。
#在用计算机解决实际问题时，要考虑上述误差的积累。
print("0.1 + 0.1 = ", 0.1 + 0.1)
print("0.1 - 0.1 = ", 0.1 - 0.1)
print("0.1 * 0.1 = ", 0.1 * 0.1) #计算机无法精确存储0.01，存储了它的近似值。
print("0.1 / 0.1 = ", 0.1 / 0.1)
print("0.3 == 3 * 0.1\t", 0.3 == 3 * 0.1)
a = 0.2
b = 0.1
print("a + b = ", a + b) #计算机无法精确存储0.3，存储了它的近似值。

#(3) 幂运算 **
c = 2 ** 10 #2的10次方（幂）
print("2 ** 10 = ",2 ** 10)

#(4) 整数除法 //
a = 4/2 #除法，默认是小数
print(a,type(4/2))
# a = 7/0 #除零错误
a = 7//2 #取整,向下取最接近的整数
print("7 // 2 = ",7 // 2)
print("-7 // 2 = ",-7 // 2)

#(5) 模运算 %
b = 7 % 2 #取余数
# print(b,type(b))
print("7 % 2 = ",7 % 2)

#(6) divmod() 同时获得商和余数
d,e = divmod(7,2)
print(d) #商
print(e) #余数

比较运算符

a = 3
b = 4
print(a == b) #表示a和b的值是否相等，用两个等号
print(a != b)
print(a > b)
print(a < b)
print(a >= b)
print(a <= b)

赋值运算符

a = 3
b = 4
#a = a + b
a += b #注意：+= 是一个符号，中间没有空格。
print(a)

位运算符

a = 60
b = 13
print(bin(a))
print(bin(b))

补充：

按位与

a 00111100
b 00001101
RESULT 00001100

a = 0b00111100
b = 0b00001101
print("a & b",a & b) #12, 1100

按位或

a 00111100
b 00001101
RESULT 00111101

a = 0b00111100
b = 0b00001101
print("a | b",a | b) #61, 00111101

按位异或

a 00111100
b 00001101
RESULT 00110001

a = 0b00111100
b = 0b00001101
print("a ^ b",a ^ b) #49, 00110001

按位非 ~n 结果为：-(n + 1)

a 00111100
RESULT 11000011

a = 0b00111100
b = 0b00001101
print("~a",~a) #-61, 11000011

向左移位 n<<m ,表示 n乘以2的m次幂

a 00111100
RESULT 11110000

a = 0b00111100
b = 0b00001101
print("a << 2",a << 2) #240, 11110000

向右移位 n>>m ,表示 n除以2的m次幂

a 00111100
RESULT 00001111

a = 0b00111100
b = 0b00001101
print("a >> 2",a >> 2) #15, 00001111

逻辑运算符

and ，与，表示“并且”

第一个条件 and 第二个条件 结果
1 and 1 1
1 and 0 0
0 and 1 0
0 and 0 0
结论：都为1才可以

or ， 或，表示“或者”

第一个条件 or 第二个条件 结果
1 or 1 1
1 or 0 1
0 or 1 1
0 or 0 0
结论：只要有1就可以

not， 非，表示“不是”

not 条件 结果
not 1 0
not 0 1
结论：总是相反的

#and，所有条件都成立才可以
age = 20
vision = 5.0
if age>= 20 and vision>=5.0:
	print("可以开公交车")
else:
	print("不可以开公交车")

#or，满足一个条件就成立
month = 5
if month ==3 or month == 4 or month ==5:
	print("春季")
else:
	print("不是春季")

#not
drink = 1
if not drink:
	print("可以开车")
else:
	print("不可以开车")

短路原则

and，如果前面为False，后面不计算。只要有一个不成立，全都不成立。
or ，如果前面为True，后面不计算。只要有一个成立，全都成立。

# print(bool(10 and 20))
print(10 and 20)
print(0 and 20)
print("----------")
print(10 or 20)
print(0 or 20)

优先级

not 高于 and 高于 or

print(1>2 or 4>3 and not 6<5)
# False or True and not False
# False or True
# True
print((1>2) or (4>3 and (not 6<5)))

成员运算符

str = "IT私塾"
print("IT" in str) #输出：True
print("it" in str) #输出：False

list = [1,2,3] #列表
print(5 in list)

tuple = (7,8,9) #元组
print(7 in tuple)

dict = {"name1":"张三","name2":"李四"}
print("name3" not in dict) #判断的是键是否存在在字典中

身份运算符

id() 函数返回对象的唯一标识符，标识符是一个整数。
CPython 中 id() 函数用于获取对象的内存地址。

a = "IT私塾"
print(id(a))

is 两个标识符是否为同一个对象
is not 两个标识符不是同一个对象

a = 10000
b = 10000
print(a == b)
print(a is b)

print(a,id(a))
print(b,id(b))

Python的整数缓存 （了解）
1.交互模式下 [-5,256]
2.pycharm或者文件中 [-∞, ∞]

运算符优先级

一元运算符：只操作一个数字运算的，例如： ~ -
二元运算符：同时操作两个数字运算的，例如：+ - * /
一元运算符 > 二元运算符 （**除外）
算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
赋值语句在运算结束后，最后执行

建议：当表达式比较复杂，不容易确定优先级顺序时，使用小括号来界定运算符的范围。

判断语句和循环语句

流程控制：
1.顺序结构：代码自上而下，逐行执行
2.分支结构：根据条件，分情况执行
3.循环结构：根据条件，不断重复执行

条件判断语句

age = 30
print "------if判断开始------"
if age>=18:
print "我已经成年了"
print "------if判断结束------"

if-else

if True:
	print ("Answer")
	print ("True")
else:
	print ("Answer")
	print ("False") # 缩进不一致，会导致运行错误

elif

score = 65
if 90<= score and score <= 100:
	print("本次考试，等级为A")
if score >= 80 and score < 90:
	print("本次考试，等级为B")
if (score >= 70) and (score < 80):
	print("本次考试，等级为C")
if (score >= 60 and score < 70) :
	print("本次考试，等级为D")
if score >= 0 and score < 60:
	print("本次考试，等级为E")

score = 77
if 90 <= score <= 100:
	print("本次考试，等级为A")
elif 80 <= score < 90:
	print("本次考试，等级为B")
elif 70 <= score < 80:
	print("本次考试，等级为C")
elif 60 <= score < 70:
	print("本次考试，等级为D")
# elif 0 <= score <= 60: #elif可以和else一起使用
# 	print("本次考试，等级为E")
else:
	print("本次考试，成绩不合格")

score = 95
grade = "不合格"
if 90 <= score <= 100:
	grade = "A"
elif 80 <= score < 90:
	grade = "B"
elif 70 <= score < 80:
	grade = "C"
elif 60 <= score < 70:
	grade = "D"
print(f"本次考试分数为{score}，等级为:{grade}")

if嵌套

light = "红灯"
pedestrian = 1 #行人
turn_round = 0 #调头
if light == "绿灯":
	# 《道路交通安全法》第47条中的规定
	if pedestrian == 1:
		print("礼让，等待。。。。")
	else:
		print("绿灯行")
else :
	# 《道路交通安全法》第49条中的规定
	if turn_round == 1:
		print("可以调头。。。。")
	else:
		print("停止,等待。。。")

import 与 from…import

在 python 用 import 或者 from…import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc,thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *

循环控制语句

for循环

for i in range(5): #相当于range(0,5),打印范围是 [0,5),左闭右开区间
	print(i)
print("end")
for i in range(0,13,3):
	print(i)
for i in range(-10,-101,-30):
	print(i)

其他可迭代对象：

#字符串
city = "chengdu"
for i in city:
	print(i,end="\t")
#元组
a = (10,20,30)
for i in a:
	print(i)
#列表
n = ["aa","bb","cc"]
for i in n:
	print(i)
n = ["aa","bb","cc","dd"]
print(len(n))
for _ in range(len(n)):
	print(f"{_}位置，元素{n[_]}")

while循环

计算1-100自然数相加的和

total = 0 #保存求和结果
n = 1 #当前循环的数字
while n <= 100:
	total += n #total = total + n
	n += 1
print("1到100的和为：",total)

执行过程说明:
n = 1 total = 0 开始循环
第一次循环： n = 1 (n<=100:True) total = 1 n = 2
第二次循环： n = 2 (n<=100:True) total = 3 n = 3
…
第100次循环： n = 99 (n<=100:True) total = 4950 n = 100
第101次循环： n = 100 (n<=100:True) total = 5050 n = 101
第102次循环： n = 101 (n<=100:False) 循环结束

break和continue

带有break的循环示例如下:

i = 0
while i<10:
	i = i+1
	print('----')
	if i==5:
		break
	print(i)

带有continue的循环示例如下:

i = 0
while i<10:
	i = i+1
	print('----')
	if i==5:
		continue
	print(i)

打印输入出四个星期的每一天。格式如下：
第1周：
星期一、星期二、星期三、星期四、星期五、星期六、星期日、
第2周：
星期一、星期二、星期三、星期四、星期五、星期六、星期日、
第3周：
星期一、星期二、星期三、星期四、星期五、星期六、星期日、
第4周：
星期一、星期二、星期三、星期四、星期五、星期六、星期日、

a = ["星期一","星期二","星期三","星期四","星期五","星期六","星期日"]
for j in a:
	print(j,end="、")
print()
for i in range(4):
	print(f"第{i+1}周:")
	for j in a:
		print(j,end="、")
	print(i)

字符串

字符串截取

str1 = "itsishu"
#正向索引：
# 0123456
#反向索引：
# -7...-3,-2 ,-1
print(len(str1)) # 内置函数 len() 获取字符串长度
print(str1) # 打印字符串
print(f"{str1}[2]:",str1[2]) # 获取字符串中的第二个字符
print(f"{str1}[0:2]:",str1[0:2]) # 截取字符串索引值为0~1的字符，不包括索引值
为2的字符 [0,2) 左闭右开区间。
print(f"{str1}[2:5]:",str1[2:5]) # 截取字符串索引值为2~4的字符，不包括索引值
为5的字符 [2,5) 左闭右开区间。
print(f"{str1}[2:-1]:",str1[2:-1]) # 截取字符串重索引值为2开始直到字符串结尾
的前一个，-1的索引值表示最后一个
print(f"{str1}[2:len(str1)]:",str1[2:len(str1)]) # 截取字符串索引值2~8，最后一个字
符的索引值为7，所以刚刚好能截取到字符串末尾
# 截取在列表中索引值为0-4的数据，冒号前面不设置参数，默认从0开始
print(f"{str1}[:4]:",str1[:4])
# 截取在列表中索引值为2-末尾的数据，冒号后面不设置参数，默认截取到最后一位数据
print(f"{str1}[2:]:",str1[2:])
print(f"{str1}[0:7:2]:",str1[0:7:2]) # [起始位置：结束位置：间隔值]
print(f"{str1}[-1:-6:-1]:",str1[-1:-6:-1]) #反向索引，倒序打印

字符串拼接

str1 = "IT私塾。"
str1 += "学以致用"
print(str1 + "高效学习")
print('-' * 30)
str2 = "这是一个很长的字符串，以至于一行都写不完" \
"那就第二行接着写" \
"可以一直写下去，都算一个字符串"
print(str2)

字母转换

# capitalize 字符串首字母大写
str1 = "itsishu"
res = str1.capitalize()
print(res) #输出:Itsishu
# title 每个单词的首字母大写 (非字母隔开的单词)
str1 = "It si shu"
res = str1.title()
print(res) #输出:It Si Shu
res = str1.istitle() #判断每个单词的首字母是否大写
print(res) #输出:False
#upper 将所有字母变成大写
str1 = "It Si Shu"
res = str1.upper()
print(res) #输出:IT SI SHU
# lower 将所有字母变成小写
res = str1.lower()
print(res) #输出:it si shu
# swapcase 大小写互换
res = str1.swapcase()
print(res) #输出:iI sI sHU

统计与查找

#count 统计字符串中某个元素的数量
str1 = "it si shu"
res = str1.count("s") #s为2；it为1；IT为0
print(res)
#find 查找某个字符串第一次出现的索引位置
#find('字符串',开始位置,结束位置) 结束位置取不到,取到之前的一个值
str1 = "IT私塾：高效学习，学以致用"
res = str1.find("学") # 7，标点符号也算字符
res = str1.find("学",8) # 10
res = str1.find("学",1,8) #-1表示没有匹配到 [1,7) 左闭右开区间
res = str1.find("学习") # 7
print(res)
#index 与 find 功能相同 find找不到返回-1,index找不到数据直接报错
res = str1.index("it") # 推荐使用find
print(res)

判断开头、结尾

# startswith 判断是否以某个字符或字符串为开头
# startswith('字符串',开始位置,结束位置) 返回True或False
str1 = "IT私塾：高效学习，学以致用"
res= str1.startswith("IT") #True
res = str1.startswith("学",10) #True
res = str1.startswith("学以",10,12) #True
print(res)
# endswith 判断是否以某个字符或字符串结尾
# endswith('字符串',开始位置,结束位置) 返回True或False
res = str1.endswith("用") #True
res = str1.endswith("学习",-9,-5) #True
print(str1[-9:-5]) #高效学习
print(res)

分隔与拼接

str1 = "IT私塾 高效学习 学以致用"
res = str1.split()
print(res) #['IT私塾', '高效学习', '学以致用']
str1 = "IT_私塾_高效_学习_学以_致用"
res = str1.split("_",2) # 第二个参数是分割几次 (从左向右)
print(res) #输出：['IT', '私塾', '高效_学习_学以_致用']
#rsplit 从右向左分割
res = str1.rsplit("_",1) # (从右向左)
print(res) # 返回列表，输出：['IT_私塾_高效_学习_学以',
'致用']
#join 按某字符将列表拼接成字符串(容器类型都可)
listvar = ['IT私塾',"高效学习","学以致用"]
res = "*".join(listvar)
print(res) # 输出：IT私塾*高效学习*学以致用

去掉与替换

# replace 替换字符串(第三个参数选择替换的次数)
str1 = "IT私塾 高效学习 学以致用"
res = str1.replace(" ","/")
print(res) #输出：IT私塾/高效学习/学以致用
# 第三个参数为替换的次数
res = str1.replace("学","练",1)
print(res) #输出：IT私塾 高效练习 学以致用
# strip 默认去掉首尾两边的空白符
str1 = "\r IT私塾 \t \n"
print(str1) #输出： IT私塾
res = str1.strip()
print(res)
print("end") #输出：IT私塾
# end
#lstrip(),只去掉左侧的空白符
res = str1.lstrip() #输出：IT私塾
print(res)
print("end") # end
# rstrip(),只去掉右侧的空白符
res = str1.rstrip()
print(res) #输出： IT私塾
print("end") # end

判断类型

#isspace() 字符串中只包含空白，则返回 True，否则返回 False
res = " " #True
res = "\t \r\n" #True
print(res.isspace())
# isalpha 字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
res = "abc" #True
# res = "123" #False
# res = "123.0" #False
res = "$123" #False
print(res.isalpha())
# isalnum,字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
res = "abc" #True
res = "abc123" #True
res = "123.0" #False
res = "$123" #False
print(res.isalnum())
# isdecimal 检测字符串是否以数字组成 必须是纯数字
# isdigit() 字符串只包含数字则返回 True 否则返回 False
# isnumeric() 字符串中只包含数字字符，则返回 True，否则返回 False
res = "1234" #True
# res = "1234.0" #False
# res = "$1234" #False
print(res.isdecimal())
num = "1" #unicode
print(f"{num} isdigit:",num.isdigit()) # True
print(f"{num} isdecimal:",num.isdecimal()) # True
print(f"{num} isnumeric:",num.isnumeric()) # True
#切换全角：win10 在输入法的”设置“中，”按键“，选择”全/半角切换”中的“Shift+空格
num = "１" # 全角
print(f"{num} isdigit:",num.isdigit()) # True
print(f"{num} isdecimal:",num.isdecimal()) # True
print(f"{num} isnumeric:",num.isnumeric()) # True
num = b"1" # byte
print(f"{num} isdigit:",num.isdigit()) # True
#print(f"{num} isdecimal:",num.isdecimal()) # AttributeError 'bytes' object has
no attribute 'isdecimal'
#print(f"{num} isnumeric:",num.isnumeric()) # AttributeError 'bytes' object has
no attribute 'isnumeric'
num = "Ⅳ" # 罗马数字4
print(f"{num} isdigit:",num.isdigit()) # False
print(f"{num} isdecimal:",num.isdecimal()) # False
print(f"{num} isnumeric:",num.isnumeric()) # True
num = "四" # 汉字4
print(f"{num} isdigit:",num.isdigit()) # False
print(f"{num} isdecimal:",num.isdecimal()) # False
print(f"{num} isnumeric:",num.isnumeric()) # True

长度、填充

# len 计算容器类型长度
res = len("IT私塾")
print(res) #输出：4
# center 填充字符串,原字符居中 (默认填充空格)
str1 = "IT私塾"
res = str1.center(10,"*") #center(填充的个数,填充的字符)
print(res) #输出：***IT私塾***

编码和解码

# max 返回字符串中编码最大的字母
# min 返回字符串中编码最小的字母
str1 = "IT私塾"
print(max(str1)) #输出：私
print(min(str1)) #输出：I
# ord,内置函数，返回汉字或字母的Unicode编码
print("'I'的编码",ord("I")) #输出：'I'的编码 73
print("'T'的编码",ord("T")) #输出：'T'的编码 84
print("'私'的编码",ord("私")) #输出：'私'的编码 31169
print("'塾'的编码",ord("塾")) #输出：'塾'的编码 22654
#python3 默认是unicode，16位的编码
print(chr(22654)) #编码为65的字符 #输出：塾
str = "IT私塾"
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")
#b表示字节 2字符 = 2字节 1字节 = 8bit 比特位 比特 0或1
print(str)
print("UTF-8 编码：", str_utf8,type(str_utf8))
#输出：UTF-8 编码： b'IT\xe7\xa7\x81\xe5\xa1\xbe' <class
'bytes'>
print("GBK 编码：", str_gbk,type(str_gbk))
#输出：GBK 编码： b'IT\xcb\xbd\xdb\xd3' <class 'bytes'>
print("UTF-8 解码：", str_utf8.decode('UTF-8','strict')) #输出：UTF-8 解码： IT私
塾
print("GBK 解码：", str_gbk.decode('GBK','strict')) #输出：GBK 解码： IT私塾

列表