30天Python基础（六、字符串，元组，字节）

⼀、元组
元组和列表相似，但元组属于不可变序列，所以元组：

• 不能修改元素的值
• 元组⽤（）表示

1.1 创建元组

t1 = () #创建⼀个空元组
#或者
t1 = tuple() #空元组
t2 = (1,) #创建带有⼀个元素的元组，后⾯的逗号是必须的，否则⽆法区分是（）表
达式还是元组
或者：t2 = 1,
t3 = (1,4,True,'hello')
t4 = 10,20,30 #t4 = (10,20,30)
t5 = tuple('abc')

1.2 成员访问

t1 = (10,7,12,23)
print(t1[0])
#print(t1[4]) 下标越界 IndexError
t2 = (1,2,[4,5])
t2[2][0] = 10 #元组的元素⽆法修改，但元素如果是可变列表，则列表元素是可以
修改的

1.3 通⽤操作

#1.连接
t1 = (1,2,3)
t2 = (4,5,6)
1.4 元组其它操作
元组和列表的转换
查找
遍历
t3 = t1 + t2
print(t3) #(1,2,3,4,5,6)
#2.重复
print(t1 * 2) #(1,2,3,1,2,3)
#3.切⽚
print(t3[0:3]) #(1,2,3)
print(t3[3:]) #(4,5,6)
print(t3[-1::-1]) (6,5,4,3,2,1)
#4.成员运算符
print(3 in t3) #True
print(2 not in t3) #False
#5.元素个数
print(len(t3))
#6.最值
print(max(t3)) #6
print(min(t3)) #1

1.4 元组其它操作

• 元组和列表的转换

t1 = (10,20,30)
l1 = [1,2,3]
#列表转元组
print(tuple(l1))
#元组转列表
print(list(t1))

• 查找

t1 = (10,20,30,10)
print(t1.index(20)) #查找值等于20的第⼀个元素
print(t1.count(10)) #返回元组中10的个数

• 遍历

t1 = (10,20,30,10)
for value in t1:
 print(value)
 
#同时获取下标和值
for index,value in enumerate(t1):
 print(index, value)
#通过下标遍历
for i in range(len(t1)):
 print(t1[i])

1.5 ⼆维元组

t1 = ((1,2,3),(4,5,6))
#遍历
for elem in t1:
 for value in elem:
 print(value, end = ' ')
 print('')

1.6 序列的解包

#元组解包
#变量个数和元素个数⼀致
t1 = (11,20)
a, b = t1
print(a,b) #11 20
a, b = 2, 3 
a,b,c = (1,2,3)
#变量个数和元素个数不同
#a=10,c=50,_获取（20,30）
a, *_, c = 10,20,30,50
print(a,c,_) #10 50 [20, 30]
#a=10，b=20,c获得剩余的元素
a, b, *c = 10,20,30,50
print(a,b,c) #10 20 [30, 50]
⼆、字符串
字符串就是由若⼲个不同的unicode字符组成的不可变序列
1 .字符串创建
2.获取字符
#*解包
print(*(1,2,3)) # 1 2 3
#range解包
a, b, c = range(3) #a=0,b=1,c=2
#列表解包
a,*_b,c = [1,2,3,4,5]
print(a,_b,c) # 1 [2, 3, 4] 5
#字符串解包
a,b,c = '123'
print(a,b,c) # a='1',b='2',c='3'

⼆、字符串
字符串就是由若⼲个不同的unicode字符组成的不可变序列
1 .字符串创建

#单引号字符串
str1 = '天要下⾬，娘要嫁⼈，由他去吧'
str2 = str() #空串
str3 = str([10,20,30])
#双引号字符串
str2 = "天要下⾬，娘要嫁⼈，由他去吧" #三引号字符串 多⾏字符串
str3 = '''
好⾬知时节
当春乃发⽣
'''
str4 = """
随⻛潜⼊夜
润物细⽆声
""

2.获取字符
因为是不可变序列，所以不能修改单个字符；凡是修改字符串的操作都产⽣新串

str1 = '天要下⾬，娘要嫁⼈，由他去吧'
print(str1[0],str1[-1]) #天 吧

3.字符串转义
之前有过介绍，在内置符号前加 \ 表示本身含义
原⽣字符：如果在字符串中不把\当做转移字符，可以使⽤

str1 = r'c:\wh1803\course\1'
print(str1) #c:\wh1803\course\1

4.字符串支持序列的通用操作
拼接，重复，成员操作，切片
5.字符串常用函数
5.1 字符串查找和替换

str1 = 'a fox jumped over the fence'

str.count(sub,start=0,end=len(string))
查找⼦串sub出现的次数；start从指定下标开始查，end结束下标 str1.count(‘f’)
str.find(str, beg=0, end=len(string))
从左向右检测字符串中是否包含⼦字符串 str,如果包含返回下标，否则返回-1。beg和end是可选参数，指定查找范围 str1.find(‘fox’)
str.rfind(sub[, start[, end]])
从右向左检测字符串中是否包含sub⼦串，包含返回⼦串的下标，否则返回-1 str1.rfind(‘fox’)
str.index(sub[, start[, end]])
作⽤类似find，但⼦串sub不存在会报ValueError str.index(‘fox’)
str.rindex(sub[, start[, end]])
从右向左检测，类似rfind，会报ValueError str1.rindex(‘fox’)
str.replace(old, new[, count])
返回⼀个新字符串，原串中的old被替换为new，可选参数count指定替换次
数。str1.replace(‘a’,‘many’)
5.2 字符串分隔和组合
str.split([sep[,num=count(sep)]])
将字符串拆分为以sep为分隔符的列表，如果指定num,则最多拆分num次
str.rsplit([sep[,num=count(sep)]])
从右向左拆分
str.partition(seq)
将字符串拆分为⼀个有三个元素的元组（seq前的字符串，seq，seq后的字符串）。
str.rpartion(seq)
同上
str.splitlines([keepends])
拆分⼀个包含多⾏的字符串，以每⾏为⼀个元素返回⼀个列表。
keepends是⼀个True字符或⾮零整数，表示保留⾏尾标志（即换⾏符）
str.join(seq)
以指定字符串str作为分隔符，将seq对象中所有的元素(字符串表示)合并为⼀个新的字符串;seq可以是字符串、列表等
5.3字符串判断
str.isalpha()
判断字符串是否由字⺟构成并且只包含字⺟，是返回True，否返回
False str1.isalpha()
str.isalnum()
检测字符串是否由字⺟和数字组成，如果都是数字或字⺟返回True，否则返回False
str.isdigit()
检测字符串是否由数字构成，可检测byte类型
str.isdecimal()
检测字符串是否由数字构成
str.isnumeric()
检测字符串是否由数字构成, 可以检测汉字数字：⼗
str.isspace()
检测字符串是否只有空格或tab构 成
str.islower()
检测字符串中的字⺟字符是否全部由⼩写字⺟组成
str.isupper()
检测字符串中的字⺟字符是否全部由⼤写写字⺟组成
str.startswith(suffix[,start[, end]])
⽤于判断字符串是否以指定⼦字符串开头，如果是则返回True，否则返回False。
str.endswith(suffix[,start[, end]])
⽤于判断字符串是否以指定⼦字符串 结尾，如果是则返回True，否则返回False。
5.4字符串转换（产⽣新的字符串）
str.lower() 字符串转
str.upper() 字符串转⼤写
str.swapcase()把字符串中的⼤⼩写字⺟互换，⼤写转换成⼩写，⼩写转换成⼤
写。不去管⾮字⺟类字符
str.capitalize() 将字符串的第⼀个字符转换为⼤写， 其余转换为⼩写
str.title() 字符串中每个单词的⾸字⺟⼤写，其余⼩写。
str.strip([chars]) 去除字符串两边边指定的字符，默认是去除空格
5.5其他方法

#1. 将其他类型转换为字符串
print(str(90)) #'90'
print(str([20,30])) #'[20,30]'
#2 ord(x) 返回⼀个字符所对应的码值
 - 字符串格式化
⽤%格式化
⽤format格式化
print(ord('a')) #97
print(ord('中')) #20013
#3 chr(x) 输⼊⼀个unicode码，返回⼀个对应的字符。
print(chr(20013)) #中
#eval，将字符串当做代码执⾏
age = 1
print(eval('age + 3')) # 4
print(eval('+123')) #123
print(eval('3 + 2')) #5
#有安全问题
eval("__import__('os').system('dir')") #显示当前⽬录的⽂件列表
#4 repr(x) 返回⼀个对象的String格式，适合机器执⾏
a = [20,30]
s1 = repr(a)
list1 = eval(s1)
list2 = str(a)
print(a == list1)
print(a == list2)

6.字符串的格式化

• ⽤%格式化

%[flags][width][.precision]typecode
flags:对其⽅式，-左对⻬ +右对⻬(默认),0表示⽤0填充(只针对数值型)，默认
是⽤空格填充
width：所占宽度，单位是列
.precision: 精度，如果带⼩数点，可以指定带⼏位⼩数，指定后会四舍五⼊
typecode: d 将数值转换为整型显示；f 将数值转换为浮点数显示 s将数值转换
为字符串显示
#⼤家好，我叫 王尼玛，我今年35岁了,我有5000000.69
print("⼤家好，我叫%+6s，我今年%d岁了,我有%10.2f" % ('王尼
玛',35,5000000.687))

• ⽤format格式化

 tp1 = "I am {}, age {}, {}".format("seven", 18, 'alex')
tp2 = "I am {name}, age {age}, really
{name}".format(name="seven", age=18)
tp3 = "I am {:s}, age {:d}, money {:.0f}".format("seven", 18,
88888.1)
print(tp1) #I am seven, age 18, alex
print(tp2) #I am seven, age 18, really seven
print(tp3) #I am seven, age 18, money 8888

三、字节

在python3中最重要的特性是对⽂本和⼆进制数据做了更加清晰的区分，⽂本总是
Unicode，由字符类型表示，⽽⼆进制数据则由byte类型表示，python3不会以任
意隐式⽅式混⽤字节型和字符型，也因此在python3中不能拼接字符串和字节包
（python2中可以，会⾃动进⾏转换），也不能在字节包中搜索字符串，也不能将
字符串传⼊参数为字节包的函数。
Bytes 对象是由单个字节作为基本元素（8位，取值范围 0-255）组成的序列，为
不可变对象。 bytes对象只负责以⼆进制字节序列的形式记录所需记录的对象，⾄
于该对象到底表示什么（⽐如到底是什么字符）则由相应的编码格式解码所决定。
Python3中，bytes通常⽤于⽹络数据传输、⼆进制图⽚和⽂件的保存等等。可以
通过调⽤bytes()⽣成bytes实例，其值形式为 b’xxxxx’，其中 ‘xxxxx’ 为⼀⾄多个转
义的⼗六进制字符串（单个 x 的形式为：\x12，其中\x为⼩写的⼗六进制转义字
符，12为⼆位⼗六进制数）组成的序列，每个⼗六进制数代表⼀个字节（⼋位⼆进
制数，取值范围0-255），对于同⼀个字符串如果采⽤不同的编码⽅式⽣成bytes对
象，就会形成不同的值.
1 创建字节

#创建字节
b1 = b'hello'
b2 = b"ello"
b3 = b'''hello'''
b4 = bytes('中⽂','utf-8')

2 设置python⽂件编码格式

# -*- coding: utf-8 -*-
import sys
sys.setdefaultencoding('utf-8') #修改系统默认编码格式

3 字符串和字节的转换

#字符串转字节
s1 = "中⽂"
s2 = s1.encode('utf-8') #str.encode()
print(type(s2)) #
print(s2) #b'\xe4\xb8\xad\xe6\x96\x87'
#字节转字符串
s3 = s2.decode('utf-8') #bytes.decode()
print(type(s3)) #
print(s3)#中⽂