python数据类型、字符串类型及操作学习笔记

最新推荐文章于 2023-05-08 21:32:29 发布

craftsman2018ship

最新推荐文章于 2023-05-08 21:32:29 发布

阅读量724

点赞数

分类专栏： python学习笔记文章标签： python

本文链接：https://blog.csdn.net/craftsman2018ship/article/details/116101542

版权

python学习笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

python数据类型、字符串类型及操作学习笔记

一、整数类型

1.可正可负，没有取值范围限制；

例如：常用函数pow(x,y)可以计算x^y，想算多大就可以算多大。

2.具有四种进制表示形式：

十六进制：以0x或者0X开头，例如：0x5a,-0X6a;
十进制：例如：21，37，199;
八进制：以0o或者0O开头，例如：0o235,0O453;
二进制：以0b或者0B开头，例如：0b011,-0B001;

二、浮点数类型

1.与数学中实数相一致，带有小数点以及小数的数字。

1.1 浮点数取值范围和小数精度都存在限制，常规计算可忽略；

1.2 取值范围数量级约（-10)³⁰⁸至10³⁰⁸，精度数量级为10^-16。

2.不确定的尾数存在于浮点数的运算中。（该情况存在于其它编程语言中）

2.1 python语言采用53位二进制数表示一个浮点数类型的小数部分（约10^-16），不确定尾数一般发生在10^-16左右；

2.2 原因：计算机中二进制与十进制数不存在严格的对等关系，十进制小数用二进制表示时可以看作一个无限的小数，计算机只能截取其中的无限接近该小数的53位，但是其并不是真正的等于该小数。因此转换该二进制数为十进制数时会有一段尾数，也就是说二进制数表示的小数可以无限接近十进制数，但不完全相同。

2.3 可以使用round函数解决上述问题：round（x,y）：对x进行四舍五入，d是小数截取位数。在浮点数间运算和比较的时候，可以用round函数进行辅助。

2.4 浮点数可以用科学计数法进行表示：使用字母E或者e作为幂的符号,10为基数，例如：<a>e<b>表示a*10^b

2.5 由于取值范围很大，精度很小，可以看作无限制。

三、复数类型

与数学中复数概念相一致，在常规计算机编程中很少使用。

四、操作符

1.操作符是完成运算的一种符号体系。

1.1 主要可以有：加（x+y）、减（x-y)、乘(x*y)、整数除（x//y）——得到整数商、除（x/y）——python中产生的是浮点数结果，其它编程语言中两个整数相除并不是浮点数结果。

1.2 +X表示X本身；-X表示X的负值；X%Y表示余数——模运算；
X**Y表示：1.幂运算，X的Y次幂,X^Y。2.当Y是小数时，进行开方运算；

2.二元操作符有对应的增强赋值操作符。

二元操作符：x op= y,其中op为二元操作符。
主要有七种形式：例如X+=Y;X-=Y;X*=Y;X/=Y;X**=Y;X//=Y;X%=Y;
值得注意的是：X**=6与X=X**6等价。

五、数字类型的关系

1. 类型间可以进行混合运算，生成结果为“最宽”类型。

1.1 三种类型存在一种逐渐“扩展”或“变宽”的关系，即最终的数据计算一般由最宽的数据决定（依次变宽——整数<浮点数<复数）。

2. 数值运算函数。

2.1. 类型间可以进行混合运算，生成结果为“最宽”类型。
举例：
1.绝对值函数：abs(x)；
2.商余函数：divmod(x,y)=(x//y,x%y),同时输出商和余数。
3.幂余函数：pow(x,y[,z])=(x**y)%z，[…]表示参数z可以省略。
4.四舍五入函数：round(x[,d]),d是保留小数的位数，默认为0。
5.判断最大值函数：max(x1,x2,x3,...,Xn),返回最大值，n无限制。
6.判断最小值函数：min(x1,x2,x3,...,Xn),返回最小值，n无限制。

2.2.数值转换函数。
举例：
1.将X变成整数，省去小数部分:int(x),如果x是数字字符串，也有同样的效果，即int(''134'')=134。
2.将X变成浮点数，增加小数部分:float(x),如:float(5)=5.0；如果x是数字字符串，也有同样的效果,即float(''5.12'')=5.12。
3.将X变成复数，增加虚数部分:complex(x),如：complex(1)=1+0j。

六、字符串类型及操作

1.字符串介绍

1.1 字符串的定义:由多个或零个字符组成的有序字符数列（其中的字符可以被索引，首字符是第0个字符）。
1.2 字符串的表示:可以用双引号或者单引号表示。

2.字符串类型

2.1 字符串的四种表示:可以用双引号或者单引号表示（单行字符串）；一对三单引号（可以当作注释）或三双引号（多行字符串）。

3.字符串序号

3.1 正向递增序号：从0开始（从左至右）
3.2 反向递减序号：从-1开始（从右至左）

4.字符串的使用

4.1 索引：返回字符串中的单个字符，例如：<字符串>[L]，L表示字符串的序号，其中使用[ ]来获取字符串中的一个或多个字符。
4.2 切片：返回字符串中的多个字符，例如：<字符串>[L：M]，L和M表示字符串的序号。 L和M可以缺失，L缺失表示至开头，M缺失表示至结尾。例如"HELLOWORLD"[:3],可得结果为"HEL"
4.3 切片进阶用法：使用[L：M：N]根据步长N对字符串切片。例如："HELLOWORLD"[1:8:2]，可得结果为"ELWR"。
4.4 字符串逆序：[::-1],表示字符串从最开始到最结尾，L和M默认缺失，而步长为-1，表示从后向前逐一地取出从开始到结尾的所有字符串，相当于字符串逆序。

5.字符串的特殊字符

5.1 转义符\：
1.表达特定字符的本意（比如特殊的字符，单引号和双引号）。如果字符串中出现了\，则\后面的字符将会被当作字符的本意来理解，比如"LG(\")"，输出后会变成正真的",即得到LG(")。
2.转义符形成一些组合，可表达不可打印的含义
例如：
"\b"表示回退，使得当前的光标向前回退一个位置。
"\n"表示换行，使得当前的光标移动到下行的行首。
"\r"表示回车，使得当前的光标移动到本行的行首。
刷新：用后打印的字符覆盖之前的字符，不能换行，需要用到回退\r

6.字符串的操作符

6.1 连接两个字符串x和y，得到新的字符串:x+y
6.2 复制n次x字符串，得到新的字符串:n*x或者x*n
6.3 如果x是s的字串，返回True，否则返回False:x in s,in是保留字，判断和它的所在关系是否存在一致性。

7.字符串的处理函数

7.1 以函数形式提供字符串的处理功能
例如：
1.返回字符串x的长度：len(x),len("123")=3
2.将任何类型的x变成字符串形式：str(x)，即str(LG)的结果为"LG"。
3.将字符串两侧的引号去掉：eval()函数。
4.整数x的十六进制或者八进制小写形式字符串：hex(x)或oct(x)函数。
5.u为Unicode编码，返回其对应的字符：chr(u)
6.x为字符，返回其对应的Unicode编码：ord(x)
注：在python3中所有的字符串、代码的编码形式都为Unicode编码，其出现是基于统一字符编码，以此覆盖所有字符的编码方式。从0到1114111（0x10FFFF）空间，每个编码对应一个字符，对应世界上的字符，Unicode编码使得python能够涵盖多种语言（中文、日文、韩文等）

8.字符串的处理方法

8.1 "方法"在编程中是一个面向对象的专有名词:指的是<a>.<b>()风格中的<b>(),本身也是函数，与<a>有关，<a>.<b>()风格使用，字符串变量也是<a>，存在一些方法。
8.2 一些以方法形式提供的字符串处理功能：
1.str.lower()和str.upper():
返回字符的副本，全部字符大写或者小写，例如："ABCdEFg".lower()结果为"abcdefg"。
2.str.split(sep=None):
返回一个列表，由str根据sep被分隔的部分组成，例如："A,B,D".split(",")结果为['A','B','D']，获得三个独立字符串的列表形式。
3.str.join(iter):
在iter变量除最后元素外每个元素后增加一个str,例如：",".join("lgisadog")结果为:"l,g,i,s,a,d,o,g",主要用于字符串的分隔。
4.str.strip(chars):
从str中去掉其左侧和右侧chars中列出的字符。"= python= ".strip(" =np")，结果为"ytho"。
5.str.count(sub):
返回字串sub在str中出现的次数。例如："lg is a dog".count("g")结果为2。
6.str.replace(old,new):
返回字符串str副本，所有的old被替换成new。例如："lgisadog".replace("dog","pig")结果为"lgisapig"。
7.str.center(width[,fillchar]):
字符串str根据宽度居中，可以把字符串放在一个居中的位置上，居中存在一个参数宽度，剩余的两侧需要字符来进行填充，fillchar可设置填充的字符。例如："lgisadog".center(16,"00")结果为‘0000lgisadog0000'

注意：在python中，所有出现的标点符号要采用英文的半角形式。

9.字符串的格式化

9.1 格式化是对字符进行格式表达的方式，主要使用.format()方法： <模板字符串>.format(<逗号分隔的参数>)
9.2 占位信息符：槽——使用一对大括号“{}”来表达，只在字符串中有用。每一个槽中所添加的内容与.format方法中对应的参数一致，默认顺序相一致，其中槽可以设定顺序，默认顺序是从左至右以0开始。
举例如下："{1}:LG {0} a{2}".format("xiao","is","dog")。
9.2 槽内部对格式化的配置方式:{<参数序号>:<格式控制标志>},可以通过一个引号：来控制某一个变量在槽位置的输出格式。
9.3 python一共有六种格式控制标记：
1. <填充>：用于填充的单个字符。
2. <宽度>：槽设定的输出宽度。
3. <对齐>：<左对齐，>右对齐，^居中对齐。

>>>"{0：=^20}".format（”lgisadog“） 输出：‘======lgisadog======’
>>>"{0：*>20}".format（”lgisadog“） 输出：‘************lgisadog’
0表示放入槽中的format方法中的第0个参数。
>>>"{：6}".format（"lg"） 输出：‘lg    ’(默认填充空格，变量左对齐)

4. <.精度>：浮点数、小数精度或者字符串最大输出长度。
5. <类型>：整数类型b（二进制）、c(字符形式，Unicode编码形式)、d（十进制）、o（八进制）、x（十六进制）、X（大写十六进制），浮点类型e、E、f、%。
6. <,>：数字的千位分隔符。

>>>"{0:,.2f}".format(6666.66) 输出：‘6,666.66’
>>>"{0:b},{0:d},{0:o},{0:x},{0:X}".format(425) 
输出：‘110101001,425,651,1a9,1A9’
>>>"{0:e},{0:E},{0:f},{0:x},{0:%}".format(3.23)
输出：‘3.230000e+00,3.230000E+00,3.230000,314.000000%’

七、组合数据类型

组合数据类型分为：集合类型、序列类型（元组类型和列表类型）、字典类型

1.集合类型及操作

1.1 集合类型定义：
集合是多个元素的无序组合，不存在相同元素，所有元素独一无二，python要求集合中的元素是不可变数据类型，不能被修改，这是因为集合要求元素独一无二。

非可变数据类型：整数、浮点数、复数、字符串类型、元组类型等

1.2 集合类型表示：
python中集合用{}表示，元素间用逗号，分隔，集合元素没有顺利，同时不包含相同元素。

1.3 集合类型的建立：
建立集合用{}或者set()，建立空集合，必须用set()

1.4 案例：

>>>A={"pythonLG","pythonLG",235,("pythonLG",235)}   #使用{}建立集合，其中()表示的数据类型叫元组类型
{"pythonLG",235,("pythonLG",235)}      #相同元素"pythonLG"只保留一个
>>>B=set("pythpyLG")      #使用set()建立集合,使得字符串每个字符单独拆分变成集合中的元素，相同的元素会被删除只保留一个，同时元素的顺序会呈现无序。
{'L','G','p','y','t','h'}

2.集合操作符（六个）-增强操作符（四个）和处理方法

2.1 集合操作符应用及说明：并、差、交、补集

1.S | T——返回一个新集合，包括集合S、T在内的所有元素。
2.S - T——返回一个新集合，包括集合S但不在T内的所有元素。
3.S & T——返回一个新集合，包括同时在集合S、T在内的所有元素。
4.S ^ T——返回一个新集合，包括集合S、T在内的非相同元素。
5.S <= T或S < T——返回true/false，判断S、T的子集关系。
6.S >= T或S > T——返回true/false，判断S、T的包含关系。

2.2 增强操作符：

1.S |= T——更新集合S，包括集合S、T在内的所有元素。
2.S -= T——更新集合S，包括在集合S但不在T内的所有元素。
3.S &= T——更新集合S，包括同时在集合S、T在内的所有元素。
4.S ^= T——更新集合S，包括集合S、T在内的非相同元素。

注意：如果不使用增强操作符，两个集合的运算会产生一个新的集合，可以赋值给一个新的集合。如果使用增强操作符，则修改原有的集合。

举例：

>>>A={"L","G",478}       #案例1
>>>B=set("LGLG478")
>>>A-B      #在A出现，B中不出现，B只有字符串 一
{478}
>>>B-A      #在B出现，A中不出现，B只有字符串 二  #案例2
{'4','7','8'}
>>>A$B      #在A、B同时出现  三    #案例三
{'L','G'}
>>>A^B      #在A、B内不同时出现  四     #案例四
{478，'4'，'7'，'8'}

2.3 集合处理方法：（操作函数和方法）增加、删除、取出、拷贝、判断等

1.S.add(x)——如果x不在集合S中，将x增加到S。
2.S.discard(x)——移除S中的元素x，如果x不在集合S中，不报错。
3.S.remove(x)——移除S中的元素x，如果x不在集合S中，产生KeyError异常。可以采用try、except捕捉异常。
4.S.clear——移除S中的所有元素。
5.S.pop()——随机返回S中的一个元素，更新集合S，S为空产生KeyError异常。
6.S.copy()——随机集合S中的一个副本。
7.len(S)——返回S中的元素个数。
8.x in S——判断集合S中元素x，x在集合S中，返回True,否则返回False。
9.x not in S——判断集合S中元素x，x不在集合S中，返回True,否则返回False。
9.set(x)——将其它类型的变量转化为集合类型。

举例：

>>>A={"L","G",478}    #案例1
>>>for item in A：
       print(item,end=" ")    #由于集合元素没有顺序，所以使用for in的形式返回获得的元素也是不确定的，可能与定义的顺序不同。
L478G
>>>try:               #案例2            捕捉异常，程序退出
       while True: 
           print(A.pop(), end="")
   except:
      pass
L478G            #最后A变成一个空集合

2.4 集合类型应用场景：

1.包含关系的比较：判断一个数据、一组数据是否在已知的一组数据中。

>>>"L" in {"L","G",123}
True
>>> {"L","G"} >= {"L","G",123}
False

2.数据去重：集合中所有数据无重复，利用集合类型中所有数据不重复的特点。

>>>1s = ["L","L","G","G",123]     # 给定一个列表类型
>>>s = set(1s)       #利用集合无法重复元素的特点，变成一个集合s
{"L","G",123}
>>>1t = list(s)      #将集合转换为列表类型
["L","G",123]        #最终将一个有重复元素的列表转换为没有重复元素的列表，达到数据去重的效果。

3.序列类型及操作`（较为重要）`

3.1 序列类型定义：序列是一个基类类型（基本数据类型），不会直接使用序列类型，而是使用其衍生类型。——包括字符串类型、元组类型、列表类型，序列类型的所有操作在其中都是适用的。

——序列是具有先后关系的一组元素，序列是一维元素的向量。
——元素之间可以相同，元素类型可以不同，类似数学中的序列。
——元素间由序号引导，通过下标访问序列的特定元素。

3.2 列表类型定义：列表是一种序列类型，创建后可以被修改，可以向其中随意的增加元素或减少元素，十分有用。

3.3 列表类型特点：
——列表使用方括号[]或list()创建，元素间用逗号，分隔。
——列表各元素类型不同，列表也无长度限制。

>>>ls = ["cat","dog","LG",478]  #定义一个列表类型
>>>1s
['cat','dog','LG',478]          #输出生成一个列表变量
>>>lt = ls
>>>lt                           #方括号[]真正创建一个列表，赋值仅传递引用，并未生成一个新的列表，而是将同一个列表赋值赋予另一个名字
['cat','dog','LG',478]          #输出生成一个列表变量

3.4 列表类型的操作、函数和方法：

1.ls[i]=x——替换列表ls第i元素为x。
2.ls[i:j:k] = lt——用列表lt替换ls切片后所对应元素的子列表。
3.del ls[i]——删除列表ls中第i个元素。
4.del ls[i:j:k]——删除列表ls中第i到第j以k为步长的元素。
5.ls += lt——更新列表ls，将列表lt元素增加到列表ls中。
6.ls *= n——更新列表ls，其元素重复n次

>>>ls = ["cat","dog","LG",478]  #定义一个列表类型
>>>ls[1:2] = [1,2,3,4]          #[1:2]的切片为"dog"
['cat',1,2,3,4,'LG',478] 
>>>del ls[::3]                 #以三为步长的删除
[1,2,4,'LG']

1.ls.append(x)——在列表ls最后增加一个元素x。
2.ls.clear()——删除列表ls中所有元素。
3.ls.copy()——生成一个新列表ls，赋值ls中的所有元素
4.ls.insert(i,x)——在列表ls的第i位置增加元素x。
5.ls.pop(i)——将列表ls中的第i位置元素取出，并删除该元素。
6.ls.remove(x)——将列表ls中出现的第一个元素x删除。
7.ls.reverse(x)——将列表ls中的元素反转。

3.5 元组类型的定义：

——元组一旦创建就不能被修改，使用()或tuple()创建，元素间用逗号，分隔，可以使用小括号，也可以不使用小括号。
——元组类型继承了序列类型的全部通用操作。

def func():
  return1,2
>>>creature= "cat","dog","LG",478          #定义一个元组类型
>>>creature
('cat','dog','LG',478)
>>>color = (0x001100, "blue",creature)
>>>color
(4352, "blue", ('cat','dog','LG',478) )
>>>creature[::-1]
(478,'LG','dog','cat')
>>>color = (0x001100, "blue",creature)
>>>color[-1][2]
'LG'

4.字典类型及操作

4.1 字典类型定义：映射是一种键和值的索引。

——键值对：键是数据索引的扩展。
——字典是键值对之间的集合，键值对之间无序。
——采用大括号{}和dict()创建，键值对用：表示，空字典用{}来完成。

{<键1>:<值1>,<键2>:<值2>,<键3>:<值3>}

在字典中，通过键获得值：

<字典变量> = {<键1>:<值1>,<键2>:<值2>,<键3>:<值3>}
<值> = <字典变量>[<键>]       <字典变量>[<键>] = <值> 
[]用来向字典变量中索引或增加元素
>>>d = {"广西”:"南宁", "甘肃":"兰州","云南":"昆明"}
>>>d
{'广西':'南宁', '甘肃':'兰州','云南':'昆明'}
>>>d["广西"]
'南宁'
>>>de = {};type（de）    #type(x)返回变量x的类型
<class 'dict'>

4.2 字典类型操作函数及方法：

1.del d[k]——删除字典d中键k对应的数据值。
2.k in d——判断键k是否在字典d中，如果返回True,否则返回False。
3.d.keys()——返回字典中所有的键信息
4.d.values()——返回字典中所有值的信息。
5.d.items()——返回字典中所有键值对的信息。

>>>d = {"广西”:"南宁", "甘肃":"兰州","云南":"昆明"}
>>>"广西" in d        #判断索引是否在字典中
True
>>>d.keys()
dict_keys(['广西', '甘肃','云南'])
>>>d.values()
dict_values(['南宁','兰州','昆明'])

方法
1.d.get(k.<default>)——键k存在，则返回相应值，不存在则返回default值，非常重要
2.d.pop(k.<default>)——键k存在，则取出相应值，不存在则返回default值。
3.d.popitem()——随机从字典d中取出一个键值对，以元组形式返回。
4.d.clear——删除所有的键值对。
5.len(d)——返回字典中元素的个数。

>>>d = {"广西”:"南宁", "甘肃":"兰州","云南":"昆明"}
>>>d.get("广西","伊斯坦布尔")
'南宁'
>>>d.get("巴基斯坦","伊斯坦布尔")   #由于巴基斯坦不是d中的键
'伊斯坦布尔'
>>>d.popitem()              #随机获取键值对，以元组形式返回
('广西'，'南宁')

d={}                 #定义一个空字典
d["a"] = 1; d["b"] = 2  #向d新增两个键值对元素
d["b"] = 3          #修改第二个元素
"c" in d     #判断字符c是否是d的键
len(d)    #计算d的长度
d.clear        #清空d