Python-8.3-内置类型
内置类型
- str
- list
- tuple
- set
- dict
一：str
- str字符串
- 转义字符
- 格式化
- 内建函数
1、str字符串
- 表示文字信息
- 用单引号，双引号，三引号括起来
2、转义字符
- 用一个特色的方法表示一系列不方便写出的内容，比如回车键，换行符，退格键
- 借助反斜杠字符，一旦字符串出现反斜杠，则反斜杠后面一个或者几个字符表示已经不是原来的意思了，进行了转义
- 在字符串中，一旦出现反斜杠就要加倍小心，可能由转义字符出现
- 不同系统对换行操作有不同的表示
- Windows: \n
- Linux: \r\n
#转义字符的案例
#向表达Let's Go
#使用转义字符
s = 'let\'s Go.'
print(s)
print()
# 使用单双引号嵌套
s = "Let's Go"
print(s)
print()
# 表示斜杆
# 比如表示c:\User\Augsnano
s = "c:\\User\\Augsnano"
print(s)
print()
# 回车换行
# 想表达的效果
# I
# like
# Apple
# Windows下也可以使用\r\n，效果相同
s = "I \nlike\nApple"
print(s)
let’s Go.
Let’s Go
c:\User\Augsnano
I
like
Apple
- 单个斜杆的用法
- 在Python里，单个反斜杠表示此行未结束，出于美观，需要下一行继续
# 单个斜杠的用法
def name_fruit(name,\
fruit):
favorite_fruit = name.title() + \
" favorite fruit is " + \
fruit + \
"."
return favorite_fruit
nf = name_fruit('jack', 'apple')
print(nf)
Jack favorite fruit is apple.
3、格式化
- 把字符串按照一定格式进行打印或者填充
- 格式化的分类
- 传统格式化
- format
（1）字符串的传统格式化方法
- 使用%进行格式化
- %（百分号）也叫占位符
- %s:字符串
- %r:字符串，但是是使用repr而不是str
- %c:整数转换为单个字符
- %d:十进制整数
- %u:无符号整数
- %o:表示八进制
- %x:十六进制，字母为小写（x为小写）
- %X:十六进制，字母为大写（X为大写）
- %e:浮点数（e为小写），例如2.87e+12
- %E:浮点数（E为大写）。例如2.87E+12
- %f,%F:浮点数十进制形式
- %g,%G:十进制形式浮点或者指数浮点自动转换
- 格式字符前出现整数表示此占位符所占位置的宽度
# %s 表示简单的字符串
a = "I like %s."
# 占位符可以单独使用
print(a)
print(a%'apple')
print(a%"banana")
# 占位符一般只能被同类型替换，或者替换类型能被转换成占位符的类型
# Python中的特例：
print("I like %s."%"pear")
print("I like %s."%100)
I like %s.
I like apple.
I like banana.
I like pear.
I like 100.
# %d 表示十进制整数
# 占位符一般只能被同类型替换
a = "The year is the %dst century"
print(a%21)
#以下打印会出错
print(a%"21")
The year is the 21st century
a = "I am %fKG weight, %fm Height."
print(a)
# 如果需要格式化信息多余一个，则用括号括起来就可以
# 以下打印使用了默认格式，多余打出了好多个0
print(a%(61, 172))
print()
# 实际需要进行格式化的信息的数量必须与百分号给出的数据数量匹配，否则报错
# 如下例子，实际需要格式化的为4处，但是给出数据为三个，则报错
a = "I am %.2fKG weight, %fm Height."
print(a%(61, 172))
I am %fKG weight, %fm Height.
I am 61.000000KG weight, 172.000000m Height.
I am 61.00KG weight, 172.000000m Height.
（2）format格式化
- 使用函数形式进行格式化，代替以前的百分号
- 不用指定位置，按顺序读取
- 设置指定位置
- 使用命名参数
- 通过字典设置参数，需要解包
# format格式化案例
# 不用指定位置，按顺序读取
# version1.0
a = "{},Welcome to {}."
print(a)
print(a.format('Jack', 'Python'))
print()
# version2.0
a = "{},Welcome to {}".format('Tony', 'Java')
print(a)
{},Welcome to {}.
Jack,Welcome to Python.
Tony,Welcome to Java
# format设置指定位置
# version1.0
a = "{0},Welcome to {1}.".format('Kevin', 'C++')
print(a)
print()
# version2.0
a = "Kevin like {0} and Jake like {0} too.".format('Python')
print(a)
Kevin,Welcome to C++.
Kevin like Python and Jake like Python too.
# format使用命名参数
a = "{name} favorite fruit is {fruit}."
a = a.format(name='Jack', fruit='apple')
print(a)
Jack favorite fruit is apple.
# 通过字典设置参数，需要解包
a = "{name} favorite fruit is {fruit}."
a_dict = {
'name':'Jack',\
'fruit':'apple'}
# ** 是解包操作
a = a.format(**a_dict)
print(a)
Jack favorite fruit is apple.
- 对数字的格式化需要用到
^ < > 分别是居中、左对齐、右对齐，后面带宽度
(:)冒号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充
(+)加号表示正数前显示 + ，(-)减号表示负数前显示 - ，（ ）空格表示正数前加空格
b d o x 分别是二进制、十进制、八进制、十六进制
此处我们可以使用大括号{}来转义大括号
# 对数字的格式化需要用到
a = "I am {:.2f}KG weight, {:+}m Height."
a = a.format(62, 172)
print(a)
I am 62.00KG weight, +172m Height.
4、str内置函数
- 很多语言字符串使用string表示，但是Python中使用str
# str内置函数
help(str)
Help on class str in module builtins:
class str(object)
| str(object=’’) -> str
| str(bytes_or_buffer[, encoding[, errors]]) -> str
|
| Create a new string object from the given object. If encoding or
| errors is specified, then the object must expose a data buffer
| that will be decoded using the given encoding and error handler.
| Otherwise, returns the result of object.str() (if defined)
（1）字符串查找类，find, index
- find：查找字符串中是否包含一个子串
- rfind lfind 从左开始查找和从右开始查找
- index:与find唯一的区别是：查找不到子串包含在字符串中，index会报错或者引发异常
# find案例
a = "I like red apple and green apple"
a1 = "apple"
# 返回第一次发现这个字符串的位置
a.find(a1)
# 返回-1表示没有找到
a2 = 'banana'
a.find(a2)
11
# 使用的时候可以使用区间
a = "I like red apple and green apple."
a1 = 'apple'
a.index(a1, 18)
print(a.index(a1, 18))
27
（2）判断函数
- 此类函数的特点是一般都用is开头，比如islower
- 此类函数不建议使用，在后期爬虫中，判断是否是数字建议采用正则表达式的方法
- isalpha:判断是否是字母，需要注意的是两点
- 此函数默认前提是字符串至少包含一个字符，如果没有，同样返回False
- 汉字被认为是alpha，所以，此函数不能作为区分英语字母还是汉字的标识，区分中英文请使用unicode码
- isdigit, isnumeric, isdecimai三个判断数字的函数总结：
- digit:
- True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
- False：汉字数字
- Error:无
- isnumeric()
- True:Unicode数字，全角数字（双字节），罗马数字，汉字数字
- False:无
- Error:byte数字（单字节）
- isdecimal()
- True:Unicode数字，全角数字（双字节）
- False:罗马数字，汉字数字
- Error:byte数字（单字节）
# isalpha
# 汉字被认为是alpha
a = "strudent"
b = "学生"
c = "I am a student"
d = "NO"
e = "NO.1"
print(a.isalpha())
print(b.isalpha())
print(c.isalpha())
print(d.isalpha())
print(e.isalpha())
True
True
False
True
False
# 判断数字案例
a = "1.5"
print(a.isdigit())
print(a.isnumeric())
print(a.isdecimal())
False
True
False
（3）内容判断类
- startswith/endswith:是否以xxx开头或者结尾
- 检测某个字符串是否以某个子串开头，常用三个参数
- suffix:被检查的字符串，必须有
- start:检查范围的开始范围
- end:检查范围的结束范围
- 检测某个字符串是否以某个子串开头，常用三个参数
- islower/isupper判断字符串是否为大小写
# startswith/endswith案例
a = 'Jack'
b = 'Python.'
c = "Jack like Python."
print(c.startswith(a))
print(c.endswith(b))
True
True
# islower/isupper
a = "asd"
b = "Asd"
c = "ASD"
print(a.islower())
print(b.islower())
print(b.isupper())
print(c.isupper())
True
False
False
True
（4）操作类函数
- format:格式化用的
- strip:这个函数主要作用是删除字符串两边的空格，其实这个函数允许你去定义删除字符串两边的哪个字符，只不过如果不指定的话默认是空格
- lstrip和rstrip，此处l和r分别表示左边右边，即删除字符串左边或者右边制定字符，默认空格
- 需要注意的是，此处删除不是删除一个，是指从头开始符合条件的连续字符
- strip相似的函数还包含lstrip, rstrip
- join:这个函数主要对字符串进行拼接。它需要一个可以迭代的内容作为参数（迭代的概念后面介绍，此处暂时理解成一个列表），功能是可把迭代的字符串拼接在一起，中间使用调用字符串作为分隔符
# strip()删除字符串两边的空格
a = "AAAAI like apple. "
print(a, a, end='')
print()
# 检测是否成功删除两边空格
print(a.strip(), a, end='')
print()
# 删除定义的字符
print(a.strip('A'), a)
AAAAI like apple. AAAAI like apple.
AAAAI like apple. AAAAI like apple.
I like apple. AAAAI like apple.
# join()案例
# 使用s1, s2, s3作为分隔符，把ss内的内容拼接在一起
s1 = " "
s2 = "-"
ss = "I", "like", "apple."
print(s1.join(ss))
print(s2.join(ss))
I like apple.
I-like-apple.
二：list列表
- 一组由有序数据做成的序列
- 数据就有先后顺序
- 数据可以不是一类数据
- list的创建
- 直接创建，用中括号创建，内容直接用英文逗号隔开
- 调用函数list()创建
1、list的创建
- 直接创建，用中括号创建，内容直接用英文逗号隔开
- 调用函数list()创建
# list直接创建
L1 = [1, 2, 3, 4]
# list内的数据可以不是一个类型
L2 = [1, 2, 3, 'apple', 'jack']
print(L1)
print(L2)
[1, 2, 3, 4]
[1, 2, 3, ‘apple’, ‘jack’]
# 调用函数list()创建列表
a = list()
print(a)
# 查看变量a的类型
print(type(a))
[]
<class ‘list’>
- 内置函数的概念
- help:帮助函数
- type:显示变量的类型
- id:显示变量的id
- print:打印
2、列表的常见操作
(1)访问
- 使用下标操作，也叫索引
- 列表的元素是从0开始的
# 使用下标访问
L1 = ['apple', 'banana', 'pear']
# 超标会引起IndexError引发的原因
print(L1[0])
apple
(2)切片操作
- 对列表进行任意一段截取
# 切片操作需要注意取值范围，左包括右不包括
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 对比打印结果跟下标的值
print(a[1:5])
[1, 2, 3, 4]
- 截取之后，创建一个新的列表
- 通过内置函数id可以判断出切片是否生成了全新的列表
- id的作用是用来判断两个变量是否是一个变量
# 调用id()函数案例
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b = a[0:5]
# 通过id判断切片后是否生成新的列表
print(id(a))
print(id(b))
1808205067912
1808203153800
- 切片下标可为空
# 切片下标为空
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[:5])
print(a[1:])
print(a[:])
[0, 1, 2, 3, 4]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- 分片可以控制增长幅度，默认增长幅度为1
# 控制增长幅度
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[:])
# 上下两个相同
print(a[::1])
# 选取02468，设置增长幅度为2
print(a[::2])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8]
- 下标可以超出范围，超出后不在考虑多余下标内容
# 下标可超出范围
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[:999])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- 下标值，增长幅度可以为负数
- 表明顺序是从右往左
- 规定：数组最后一个数字的下标是-1
# 增长幅度可为负数
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 下面例子为空，因为默认是从左向右移动
print(a[-2:-5])
# 利用负数下标打印9，8，7
print(a[-2:-5:-1])
# 利用负数下标打印7, 8, 9
print(a[-4:-1:1])
[]
[9, 8, 7]
[7, 8, 9]
三：tuple(元组)
- 可以理解成一个不要允许更改的列表
1、元组的创建
- 直接用小括号创建
# 直接用小括号创建元组
a = ()
print(type(a))
# 当用小括号创建一个元素的tuple的时候
b= (100)
print(type(b))
# 特例，需在后面加逗号
c = (100,)
print(type(c))
<class ‘tuple’>
<class ‘int’>
<class ‘tuple’>
- 直接用逗号创建元组
# 用逗号创建元组
a = 100,
print(type(a))
print(a)
<class ‘tuple’>
(100,)
- 使用tuple定义创建元组
# 用tuple()函数创建元组
a = tuple()
print(type(a))
<class ‘tuple’>
- 使用列表创建元组
- 要求tuple参数可迭代
# 使用列表创建元组
a = [num for num in range(11)]
b = tuple(a) # 要求tuple参数必须可迭代
print(a)
print(b)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
2、tuple其余特征跟list基本一致
- 有序
- 可以访问不可以修改
- 元素可以是任意类型
# tuple索引操作
t = (0, 1, 2, 3, 4, 5)
print(t[2])
2
# tuple分片操作
t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(t[-1])
print(t[0:6])
print(t[:6])
print(t[2::2])
print(t[-1])
print(t[-1:])
print(t[-1::-1])
10
(0, 1, 2, 3, 4, 5)
(0, 1, 2, 3, 4, 5)
(2, 4, 6, 8, 10)
10
(10,)
(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
- 元组的相加
- 元组的乘法
# 元组的相加
a = 100, 200, 300
b = ('apple', 'banana')
c = a + b
print(c)
# 元组的乘法
d = c * 2
print(d)
(100, 200, 300, ‘apple’, ‘banana’)
(100, 200, 300, ‘apple’, ‘banana’, 100, 200, 300, ‘apple’, ‘banana’)
- tuple成员检测
- 返回的一定是布尔值，可用if语句
# 成员检测
a = 100, 200, 300, 400
b = 100
if b in a:
print(str(b) + " in it.")
100 in it.
- 元组的遍历
# 元组遍历
ts = 100, 200, 300, 400, 500, 600
for t in ts:
print(t)
100
200
300
400
500
600
- 元组的嵌套
- 嵌套元组的访问
- 双层循环访问
- 单层循环访问
- 上面访问规定，i,j,k要跟元组个数对应
# 元组嵌套的双层访问循环
tss = ((100, 200, 300, 400), \
('apple', 'banana', 'pear'))
for ts in tss:
print(ts)
for t in ts:
print(t)
(100, 200, 300, 400)
100
200
300
400
(‘apple’, ‘banana’, ‘pear’)
apple
banana
pear
# 元组嵌套的单层访问循环
tss = ((100, 200, 300), \
('apple', 'banana', 'pear'), \
(1, 2, 3))
# for里面的变量与单个元组内的个数有关
for i, j, k in tss:
print(i,j,k)
100 200 300
apple banana pear
1 2 3
3、常用元组函数
- len:长度
- max:最大值
- min:最小值
- count:对某一元素计数
- index:某一元素所在位置
# 元组的常用函数
a = 100, 200, 600, 100,700, 800, 100
# 长度
print(len(a))
# 最大值
print(max(a))
# 最小值
print(min(a))
# 对某一元素计数
print(a.count(100))
# 某一元素所在位置
print(a.index(100))
7
800
100
3
0
- tuple的特殊用法
- 要求对a, b值进行互换
- 此种用法是python的独门秘籍
# a, b 两值互换
a = 100
b = 'apple'
print(a, b)
# 对a, b值进行互换
a, b = b, a
print(a, b)
100 apple
apple 100
四：集合
- 跟数学中集合的概念一致
- 内容无序 + 内容不重复
1、集合的定义
- 通过set关键字
- 使用大括号
# 1、通过set创建集合
l = [1, 22, 25, 18, 1, 22]
s1 = set(l)
print(s)
print()
# 2、使用大括号创建集合
s2 = {1, 5, 1, 5, 8, 7, 5, 3, 4, 6}
print(s2)
{1, 18, 22, 25}
{1, 3, 4, 5, 6, 7, 8}
2、集合的操作
- 检测元素
- 遍历元素
# 集合的操作
s1 = {1, 5, 1, 5, 8, 7, 5, 3, 4, 6}
a = 8
b = 88
# 1、检测元素
if a in s1:
print(str(a) + " in it.")
if b not in s1:
print(str(b) + " not in it.")
print()
# 2、遍历元素
print("集合元素：")
for s in s1:
print("\t", s)
8 in it.
88 not in it.
集合元素：
1
3
4
5
6
7
8
# 3、集合的另一种遍历
s = {(4, 5, 6), ('apple', 'banan', 'pear'), (7, 8, 9)}
for i, j, k in s:
print(i, j, k)
apple banan pear
4 5 6
7 8 9
3、集合的生成式
- 利用集合生成新的集合
- 打印出偶数
# 利用集合生成新的集合s2
s1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
s2 = {i for i in s1}
print(s2)
# 打印出偶数
s3 = {i for i in s1 if i % 2 == 0}
print(s3)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
{0, 2, 4, 6, 8, 10}
- 双重for循环
- 把s中的每一个元素的平方生成一个新的集合
- 1、用一个for
- 2、使用两个for
- 把s中的每一个元素的平方生成一个新的集合
# 1、使用一个for
s = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
s1 = {i**2 for i in s}
print(s1)
# 2、使用两个for
s2 = { m*n for m in s for n in s}
print(s2)
{64, 1, 4, 36, 100, 9, 16, 49, 81, 25}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27, 28, 30, 32, 35, 36, 40, 42, 45, 48, 49, 50, 54, 56, 60, 63, 64, 70, 72, 80, 81, 90, 100}
4、集合的内置函数
- len:长度
- max:最大值
- min:最小值
- add:向集合添加元素
- clear:清空
# 向集合添加元素
s = {4, 5, 1, 2, 5, 8, 7, 9, 6}
s.add(555)
print(s)
# 清空操作
s.clear()
print(s)
{1, 2, 4, 5, 6, 7, 8, 9, 555}
set()
- 删除操作
- remove 和 discard 的区别：
- remove删除的值如果不在集合中,报错
- discard
s = {4, 5, 1, 2, 5, 8, 7, 9, 6}
print(s)
# 使用remove删除
s.remove(5)
print(s)
# 使用discard删除
s.discard(5)
print(s)
{1, 2, 4, 5, 6, 7, 8, 9}
{1, 2, 4, 6, 7, 8, 9}
{1, 2, 4, 6, 7, 8, 9}
- pop弹出集合的一个内容
- 删除的内容是随机的
- 删除的内容没规律，随机的
# 使用pop随机删除元素
s = {4, 5, 1, 2, 5, 8, 7, 9, 6}
print(s)
s.pop()
print(s)
{1, 2, 4, 5, 6, 7, 8, 9}
{2, 4, 5, 6, 7, 8, 9}
5、集合的数学操作
- intersection:交集
- difference:差集
- union:并集
# 集合的数学操作
s1 = {1, 2, 3, 4, 5, 6}
s2 = {4, 5, 6, 7, 8, 9}
# 1、s1 和 s2 的交集
print("interection:")
print(s1.intersection(s2))
print()
# 2、s1 和 s2 的差集
print("difference:")
print(s1.difference(s2))
# another,直接 s1 - s2
print(s1 - s2)
print()
# 3、s1 和 s2 的并集
print("union:")
print(s1.union(s2))
interection:
{4, 5, 6}
difference:
{1, 2, 3}
{1, 2, 3}
union:
{1, 2, 3, 4, 5, 6, 7, 8, 9}
6、frozenset 冰冻集合
- 不允许修改的集合
# frozenset 冰冻集合
s1 = {1, 2, 3, 4, 5, 6, 7, 8}
print(s1)
s2 = frozenset(s1)
print(s2)
{1, 2, 3, 4, 5, 6, 7, 8}
frozenset({1, 2, 3, 4, 5, 6, 7, 8})
扫一扫
1908
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
