python3基础二——基本的数据类型三
Posted 温润有方
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python3基础二——基本的数据类型三相关的知识，希望对你有一定的参考价值。
一.字符串str
1.创建字符串，为变量分配一个值
1 word=\'字符串\'
2 sentence="字符串\\n" #python中单引号和双引号使用完全相同
3 paragraph="""这是一个段落
4 可以有多行组成""" #使用三引号(\'\'\'或""")可以指定一个多行字符串
5 print(word,sentence,paragraph)
6 ----------------------------------------------------------------------------
7 字符串 字符串
8 这是一个段落
9 可以有多行组成
2.字符串不能改变，只是创建了一个新的字符串，又重新给变量赋值，原字符串并不会改变
3.没有单独的字符类型，一个字符就是长度为 1 的字符串
4.Python 不支持单字符类型，单字符也在Python也是作为一个字符串使用
5.Python2中普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，Python3所有的字符串都是Unicode字符串。
6.Python 访问子字符串，可以使用方括号来截取字符串
1 # 字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始
2 str=\'Runoob\'
3 print(str) # 输出字符串
4 print(str[0]) # 输出字符串第一个字符R
5 print(str[0:-1]) # 输出第一个到倒数第二个的所有字符,0<=内容<-1
6 print(str[2:5]) # 输出从第三个开始到第五个的字符
7 print(str[2:]) # 输出从第三个开始的后的所有字符
8 print(str[0:]) # 输出所有字符等同于print（str[:])等同于print(str)
9 print(str*2) # 输出字符串两次，用 * 运算符重复
10 print(str+\'你好\') # 连接字符串，用 + 运算符连接在一起
11 print(str[::2]) # 第一个冒号两侧的数字是指截取字符串的范围,第二个冒号后面是指截取的步长。
12
13 ---------------------------------------------------------------------
14 Runoob
15 R
16 Runoo
17 noo
18 noob
19 Runoob
20 RunoobRunoob
21 Runoob你好
22 Rno
7.转义字符以及使用r可以让反斜杠不发生转义
1 str=\'Runoob\\n\' # 反斜杠 \'\\\'可以用来转义，\\n换行
2 str2=r\'Runoob\\n\' # 使用r可以让反斜杠不发生转义
3 print(str) # 输出字符串
4 print(str2)
5 ------------------------------------------------------
6 Runoob
7
8 Runoob\\n
8.字符串运算符
9.字符串格式化：将一个值插入到一个有字符串格式符 %s 的字符串中。还可以用format()进行格式化
1 print("我叫 %s 今年 %d 岁"%(\'小明\',10))
2 ------------------------------------------
3 我叫 小明 今年 10 岁
10.占位符
其他：%-左对齐、%+右对齐，%0用0补齐空格
10.编码解码bytes,bytes（在字符串前加b以区分）与str类型只有编码解码的方法不同
1 name="李璐"
2 for i in name:
3 print(i)#for循环每一个元素是“字符”
4 print(bytes(i,encoding=\'utf-8\'))#把i转换为字节形式，以16进制表示，字符变字节
5 for b in bytes(i,encoding=\'utf-8\'):
6 print(b)#for循环输出每一个元素（字节）是以十进制形式
7 print(bin(b))#bin()把一个字节（十进制的数）用二进制表示
8 #一个汉字三个字节，
9 #bytes可以将字符串准换位字节
10 #字节：用16进制表示的二进制
11 ----------------------------------------------------
12 李
13 b\'\\xe6\\x9d\\x8e\'
14 230
15 0b11100110
16 157
17 0b10011101
18 142
19 0b10001110
20 璐
21 b\'\\xe7\\x92\\x90\'
22 231
23 0b11100111
24 146
25 0b10010010
26 144
27 0b10010000
1 #对于字符串只有encode编码功能，把字符串转换为bytes字节类型，16进制字节
2 var1 = \'你好，世界!\'
3 print(var1)
4 #encode(encoding=\'UTF-8\',errors=\'strict\')以指定的编码格式编码字符串,默认utf-8和strict
5 # errors参数可以指定不同的错误处理方案,默认为 \'strict\',意为编码错误引起一个UnicodeError。
6 # 其他可能得值有 \'ignore\', \'replace\', \'xmlcharrefreplace\',\'backslashreplace\'以及通过codecs.register_error()注册的任何值。
7 print(var1.encode())#返回编码后的字符串，它是一个 bytes 对象
8
9
10
11 #对于bytes字节类型只有解码功能，把bytes类型转换为字符串
12 print(var1.encode().decode())
13 --------------------------------------------------------------------------------
14 你好，世界!
15 b\'\\xe4\\xbd\\xa0\\xe5\\xa5\\xbd\\xef\\xbc\\x8c\\xe4\\xb8\\x96\\xe7\\x95\\x8c!\'
16 你好，世界!
11.函数
1 a1=\'alex\\tis Alph \'
2 print(len(a1)) #获取字符串长度
3 print(a1.capitalize())#首字母变大写
4 print(a1.center(20,"*"))#center(self, width, fillchar=None)内容居中，长度设定，其他填充设定
5 print(a1.count(\'al\',0,9))#count(self, sub, start=None, end=None)计算指定范围内子序列出现的次数
6 print(a1.encode(\'utf-8\'))#encoding 指定的编码格式解码 str
7 print(a1.endswith(\'l\',0,2))#endswith(self, suffix, start=None, end=None)指定范围内是否以XXX结尾
8 print(a1.expandtabs())#将tab转换成空格，默认一个tab转换成8个空格
9 print(a1.find(\'ex\'))#find(self, sub, start=None, end=None)从左往右在指定范围寻找子序列位置，如果没找到，返回 -1
10 print(a1.format())#字符串格式化，动态参数
11 print(a1.index(\'a\'))#在指定范围寻找子序列位置，子序列位置，如果没找到，报错
12 print(a1.isalnum())#是否全是字母和数字
13 print(a1.isalpha())#是否全是字母
14 print(a1.isdigit())#是否全是数字
15 print(a1.islower())#是否小写
16 print(a1.isspace())#是否空格
17 print(a1.istitle())#是否标题，首字母全大写
18 print(a1.isupper())#是否全部大写
19 print(\'-\'.join(a1))#个个单位之间用符号连接
20 print(a1.join(\'333333\'))#字符串之间链接
21 print(a1.ljust(20,\'*\'))#内容左对齐，右侧填充
22 print(a1.lower())#变小写
23 print(a1.strip())#去除两边空格
24 print(a1.partition(\'s\'))#分割，前，中，后三部分
25 print(a1.replace(\'l\',\'kb\',2))#替换,从左往右几个
26 print(a1.split(\'l\',1))#分割，有几个分几部分，可以指定几个分割
27 print(a1.startswith(\'a\'))#startswith(self, prefix, start=None, end=None)是否起始
28 print(a1.splitlines())#根据换行分割
29 print(a1.swapcase())#大写变小写，小写变大写
30 print(a1.title())#标题化
31 print(a1.upper())#全大写
32 --------------------------------------------------------------------------------------
33 13
34 Alex is alph
35 ***alex is Alph ****
36 1
37 b\'alex\\tis Alph \'
38 True
39 alex is Alph
40 2
41 alex is Alph
42 0
43 False
44 False
45 False
46 False
47 False
48 False
49 False
50 a-l-e-x- -i-s- -A-l-p-h-
51 3alex is Alph 3alex is Alph 3alex is Alph 3alex is Alph 3alex is Alph 3
52 alex is Alph *******
53 alex is alph
54 alex is Alph
55 (\'alex\\ti\', \'s\', \' Alph \')
56 akbex is Akbph
57 [\'a\', \'ex\\tis Alph \']
58 True
59 [\'alex\\tis Alph \']
60 ALEX IS aLPH
61 Alex Is Alph
12.str
(1)一般函数：startswith、endwith、count、find...
(2)判断字符串：islower、isupper、isdigit、isalpha...
(3)操作类函数：lower、upper、strip/rstrip/lstrip、swapcase(交换大小写)...
13.字符串函数分类：
(1).查找计算：len、find、rfind、index、rindex、count
(2).转换：replace、capitalize、title、lower、upper、
(3).填充压缩：ljust、rjust、center、lstrip、rstrip
(4).分割拼接：split、partition、rpartition、splitlines、join
(5).判定：isalpha、isdigit、isalnum、isspace、startswith、endswith、
二.序列
1.序列是Python中最基本的数据结构
2.序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。每个索引对应一个元素，最后一个索引是-1
3.Python包含6种内建的序列，包括列表、元组、字符串、Unicode字符串、buffer对象和xrange对象
4.序列通用操作：索引，切片，加，乘，成员检查，计算序列的长度，取序列中的最大、最小值
5.索引：获取单个元素[ ];切片：获取子序列[ : ];加：连接相同序列+；乘：重复序列中所有的元素*；成员检查in;计算长度len（）；取最大最小值max（），min()
6.索引和切片是不同的：比如list[0]返回第0个元素的值，list[0:1]返回一个只含第0个元素的列表
7.序列的遍历
（1）在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来
（2）在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到，以0开始
（3）同时遍历两个或更多的序列，可以使用 zip() 组合
（4）要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数
（5）要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值
1 #zip（）遍历多个序列
2 questions = [\'name\', \'quest\', \'favorite color\']
3 answers = [\'lancelot\', \'the holy grail\', \'blue\']
4 for q, a in zip(questions, answers):
5 print(\'What is your {0}? It is {1}.\'.format(q, a))
6
7 #enumerate() 函数同时得到索引和值
8 for i, v in enumerate([\'tic\', \'tac\', \'toe\']):
9 print(i, v)
10
11 #reversed() 函数反向遍历
12 for i in reversed(range(1, 10, 2)):
13 print(i)
14
15 #sorted() 函数 顺序遍历
16 basket = [\'apple\', \'orange\', \'apple\', \'pear\', \'orange\', \'banana\']
17 for f in sorted(set(basket)):
18 print(f)
19 ------------------------------------------------------------------------------
20 What is your name? It is lancelot.
21 What is your quest? It is the holy grail.
22 What is your favorite color? It is blue.
23 0 tic
24 1 tac
25 2 toe
26 9
27 7
28 5
29 3
30 1
31 apple
32 banana
33 orange
34 pear
8.序列的切片和拼接操作可以实现形式上的序列的更新和删除
三.列表
1.创建列表
1 #列表，方括号内,逗号分隔
2 # 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
3 list1=[\'a\',\'goole\',1995,"2000"]#列表可包含任何数据类型的元素，单个列表中的元素无须全为同一类型
4 print(list1)
5 --------------------------------------------------------------
6 [\'a\', \'goole\', 1995, \'2000\']
2.列表作为一个序列，有序列的通用功能：索引，切片，加，乘，成员检查，计算序列的长度，取序列中的最大、最小值
1 list1=[\'a\',\'goole\',1995,"2000"]#列表可包含任何数据类型的元素，单个列表中的元素无须全为同一类型
2 print(list1)
3 print(list1[0]) #列表索引从0开始
4 print(list1[1:5]) #使用方括号的形式截取字符成一个子列表，冒号使用和字符串中一样
5 list1[2]=2001 #直接赋值对列表的数据项进行修改或更新，
6 print(list1)
7 del list1[2] #del语句删除列表的元素
8 print(list1)
9 print(len(list1)) #len()表示列表的长度
10 print(list1+[1,2,3]) #+组合，拼接列表
11 print(list1*2) #*重复
12 print(\'a\' in list1) #in元素是否存在于列表中
13 for i in list1:
14 print(i,end=\' \') #迭代
15 ------------------------------------------------------------------------------
16 [\'a\', \'goole\', 1995, \'2000\']
17 a
18 [\'goole\', 1995, \'2000\']
19 [\'a\', \'goole\', 2001, \'2000\']
20 [\'a\', \'goole\', \'2000\']
21 3
22 [\'a\', \'goole\', \'2000\', 1, 2, 3]
23 [\'a\', \'goole\', \'2000\', \'a\', \'goole\', \'2000\']
24 True
25 a goole 2000
3.嵌套列表
1 #嵌套
2 a = [\'a\', \'b\', \'c\']
3 n = [1, 2, 3]
4 x = [a, n]
5 print(x)
6 print(x[0])
7 print(x[0][1])
8 ----------------------------------------
9 [[\'a\', \'b\', \'c\'], [1, 2, 3]]
10 [\'a\', \'b\', \'c\']
11 b
4.列表元素可以通过直接赋值对列表的数据项进行修改或更新
5.列表末尾添加元素：append and extend,其中append（一个元素），extend(多个元素)（多个元素以列表显示）
1 #append and extend
2 list1=[\'google\',1995,"Tabo"]
3 list1.append(\'baidu\') #调用append()方法向列表的尾部添加一个新的元素,只能一个元素
python3基础二——基本的数据类型三