Python3 & 基本数据类型（一）

Posted 2023-04-07

参考技术A

Python提供的基本数据类型：数值(整型、浮点型、复数、布尔型等)、字符串、列表、元组、字典、集合等，将它们简单分类如下：

通常被称为整型，数值为正或者负，不带小数点。
Python 3的整型可以当做Long类型使用，所以Python 3没有
Python 2的Long类型。
Python 初始化的时候会自动建立一个小整数对象池，方便我们调用，避免后期重复生成！这是一个包含 262个指向整数对象的指针数组，范围是 -5 到 256 。

Python的浮点数就是数学中的小数，类似C语言中的double。
浮点数 也就是小数，如 1.23 ， 3.14 ， -9.01 等等。但是对于很大或很小的浮点数，一般用科学计数法表示，把10用e替代， 1.23x10^9 就是 1.23e9 ，或者 12.3e8 ， 0.000012 可以写成1.2e-5 等等。

复数 由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点。

对 与 错 、 0 和 1 、 正 与 反 ，都是传统意义上的布尔类型。
但在Python语言中，布尔类型只有两个值， True 与 False 。请注意，是英文单词的对与错，并且首字母要大写。
在Python中，0、0.0、-0.0、None、空字符串“”、空元组()、空列表[]、空字典都被当作False，还有自定义类型，如果实现了 nonzero ()或 len ()方法且方法返回0或False，则其实例也被当作False，其他对象均为True

布尔值还可以用and、or和not运算。
1)、and 运算是 与 运算，只有所有都为 True ， and 运算的结果才是 True ;
2)、or 运算是 或 运算，只要其中有一个为 True ， or 运算结果就是 True ;
3)、not 运算是 非 运算，它是单目运算符，把 True 变成 False，False 变成 True。
例如：

由以上案例可以看出，在做四则运算的时候，明显把 True 看做 1 ， False 看做 0 。

4）空值
空值不是布尔类型，只不过和布尔关系比较紧密。
空值是Python里一个特殊的值，用 None 表示（首字母大写）。None不能理解为0，因为0是整数类型，而None是一个特殊的值。None也不是布尔类型，而是NoneType。

在某些特定的情况下，需要对数字的类型进行转换。
Python提供了内置的数据类型转换函数：
int(x) 将x转换为一个整数。如果x是一个浮点数，则截取小数部分。
float(x) 将x转换成一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y)： 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。

Python字符串即可以用单引号也可以用双引号括起来，甚至还可以用三引号括起来，字符串是以\'\'或""括起来的任意文本。
例如：\'abc\'，"xyz"等等。请注意，\'\'或""本身只是一种表示方式，不是字符串的一部分，因此，字符串\'abc\'只有a，b，c这3个字符。如果\'本身也是一个字符，那就可以用""括起来，比如"I\'m OK"包含的字符是I，\'，m，空格，O，K这6个字符。
字符串中包括特殊字符，可以用转义字符\\来标识
但是字符串里面如果有很多字符都需要转义，就需要加很多\\，为了简化，Python还允许用r\'\'表示\'\'内部的字符串默认不转义
例如：
print r\'\\\\\\t\\\\\' #输出：\\\\\\t\\\\

字符串的一些常见操作

切⽚是指对操作的对象截取其中⼀部分的操作
语法：序列[开始位置下标:结束位置下标:步⻓]
a. 不包含结束位置下标对应的数据， 正负整数均可；
b. 步⻓是选取间隔，正负整数均可，默认步⻓为1。

find()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1。
index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。
rfind()： 和find()功能相同，但查找⽅向为右侧开始。
rindex()：和index()功能相同，但查找⽅向为右侧开始。
count()：返回某个⼦串在字符串中出现的次数。

replace()：替换
split()：按照指定字符分割字符串。
join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。
capitalize()：将字符串第⼀个字符转换成⼤写。
title()：将字符串每个单词⾸字⺟转换成⼤写。
lower()：将字符串中⼤写转⼩写。
upper()：将字符串中⼩写转⼤写。
lstrip()：删除字符串左侧空⽩字符。
rstrip()：删除字符串右侧空⽩字符。
strip()：删除字符串两侧空⽩字符。
ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串。
rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和
ljust()相同。
center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语
法和ljust()相同。

所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。

startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开
始和结束位置下标，则在指定范围内检查。
endswith()：：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开
始和结束位置下标，则在指定范围内检查。
isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回
False。

python3----模块（序列化（json&pickle）+XML+requests）

一、序列化模块

Python中用于序列化的两个模块：

• json     跨平台跨语言的数据传输格式，用于【字符串】和 【python基本数据类型】 间进行转换
• pickle   python内置的数据传输格式，多用于二进制形式，用于【python特有的类型】 和 【python基本数据类型】间进行转换

Json模块提供了四个功能：dumps、dump、loads、load

pickle模块提供了四个功能：dumps、dump、loads、load

 1 #pickle.dumps将数据通过特殊的形式转换为只有python能识别的字符串
 2 import pickle
 3 data={\'k1\':123,\'k2\':\'hello\'}
 4 p_str=pickle.dumps(data)
 5 print(p_str)      ------->b\'\\x80\\x03}q\\x00(X\\x02\\x00\\x00\\x00k2q\\x01X\\x05\\x00\\x00\\x00helloq\\x02X\\x02\\x00\\x00\\x00k1q\\x03K{u.\'
 6 s = pickle.loads(p_str)
 7 print(s)       -------->{\'k2\': \'hello\', \'k1\': 123}
 8 #pickle.dump将数据通过特殊的形式转换为只有python认识的字符串，并写入文件
 9 with open(\'db\',\'w\') as fp:
10     pickle.dump(data,fp)
11 
12 json实例
13 #json.loads()#将字符串转换成python基本数据类型，注：里面一定要是双引号，外面是单引号
14 import json
15 s=\'{"name":"tina","age":"18"}\'
16 l=\'[1,2,3,4]\'
17 r=json.loads(l)
18 w=json.loads(s)
19 print(r,type(r))
20 print(w,type(w))
21 ############执行结果如下：###########
22 [1, 2, 3, 4] <class \'list\'>
23 {\'age\': \'18\', \'name\': \'tina\'} <class \'dict\'>
24 #json.dumps()将python的基本数据类型转换成字符串
25 a={"name":"tina","age":"18"}
26 b=json.dumps(a)
27 print(b,type(b))
28 #############执行结果如下：##########
29 {"age": "18", "name": "tina"} <class \'str\'>
30 
31 #不带s的是对文件进行操作
32 dic = {\'k1\':123,\'k2\':345}
33 a=json.dump(dic,open(\'db\',\'w\'))
34 print(a,type(a))
35 #读内容
36 #字符串转换成字典
37 r=json.load(open(\'db\',\'r\'))
38 print(r,type(r))
39 #############执行结果如下：##########
40 写入db文件中的内容即为dict
41 {\'k2\': 345, \'k1\': 123} <class \'dict\'>

 

二、XML

JSON跨平台跨语言的数据传输格式

XML实现不同语言或程序之间进行数据交换的协议

返回的都是字符串，只是不同表现形式的字符串

XML文件格式如下：

 1 <data>
 2     <country name="Liechtenstein">
 3         <rank updated="yes">2</rank>
 4         <year>2023</year>
 5         <gdppc>141100</gdppc>
 6         <neighbor direction="E" name="Austria" />
 7         <neighbor direction="W" name="Switzerland" />
 8     </country>
 9     <country name="Singapore">
10         <rank updated="yes">5</rank>
11         <year>2026</year>
12         <gdppc>59900</gdppc>
13         <neighbor direction="N" name="Malaysia" />
14     </country>
15     <country name="Panama">
16         <rank updated="yes">69</rank>
17         <year>2026</year>
18         <gdppc>13600</gdppc>
19         <neighbor direction="W" name="Costa Rica" />
20         <neighbor direction="E" name="Colombia" />
21     </country>
22 </data>

1、解析XML

1 from xml.etree import ElementTree as ET
2 #打开文件，读取文件内容
3 str_xml = open(\'first.xml\',\'r\').read()
4 #将文件内容解析成XML格式，root是文件tree的根节点
5 root=ET.XML(str_xml)
6 print(root.tag)    #打印根节点的标签，结果为data     
7 print(root)         #<Element \'data\' at 0x00000057EDD566D8>

1 方法二：
2 from xml.etree import ElementTree as ET
3 #直接解析XML文件
4 tree = ET.parse(\'first.xml\')
5 #获取XML文件的根节点
6 root=tree.getroot()
7 print(root)        #<Element \'data\' at 0x0000008708517318>
8 print(root.tag)   #data
9 #返回结果是一样的

1 @@@@@@@@@小练习@@@@@@@@
2 from xml.etree import ElementTree as tina
3 TT = tina.parse(\'first.xml\')
4 print(TT.getroot().tag)    #data

2、操作XML

XML格式类型是节点嵌套节点，对于每一个节点均有以下功能，以便对当前节点进行操作：

具体用法举例说明：

（1）遍历XML文档的所有内容

（2） 遍历XML中指定的节点

 1 from xml.etree import ElementTree as ET
 2 
 3 ############ 解析方式一 ############
 4 """
 5 # 打开文件，读取XML内容
 6 str_xml = open(\'xo.xml\', \'r\').read()
 7 
 8 # 将字符串解析成xml特殊对象，root代指xml文件的根节点
 9 root = ET.XML(str_xml)
10 """
11 ############ 解析方式二 ############
12 
13 # 直接解析xml文件
14 tree = ET.parse("xo.xml")
15 
16 # 获取xml文件的根节点
17 root = tree.getroot()
18 
19 
20 ### 操作
21 
22 # 顶层标签
23 print(root.tag)
24 
25 
26 # 遍历XML中所有的year节点
27 for node in root.iter(\'year\'):
28     # 节点的标签名称和内容
29     print(node.tag, node.text)
30 
31 eg1

 1 from xml.etree import ElementTree as tina
 2 TT = tina.parse(\'first.xml\')
 3 # print(TT.getroot().tag)
 4 # for i in TT.getroot():#在跟节点下遍历孩子标签及属性
 5 #     print(i.tag,i.attrib)
 6 #     for j in i:#在孩子节点下遍历孙子标签及属性
 7 #         print(j.tag,j.attrib)
 8 #返回结果也是呈树状的，有点像之前三级联动的小练习
 9 for node in TT.getroot().iter(\'year\'):
10     #遍历XML中所有的year节点，类似于Windows中文件夹中全局搜索
11     print(node.tag,node.text)
12 @@@@@@非注释部分的执行结果如下：@@@@@@@
13 year 2025
14 year 2028
15 year 2028
16 
17 eg2

（3）修改节点内容

由于修改节点时，都是在内存中进行，不会影响文件中的内容，所以，如果想要修改，则需要重新将内存中的内容写入到文件。

解析字符串方式打开，修改，保存

解析文件方式打开，修改，保存

（4）删除节点

解析字符串方式打开，删除，保存

解析文件方式打开，删除，保存

3、创建XML文档

 1 from xml.etree import ElementTree as ET
 2 
 3 
 4 # 创建根节点
 5 root = ET.Element("famliy")
 6 
 7 
 8 # 创建节点大儿子
 9 son1 = ET.Element(\'son\', {\'name\': \'儿1\'})
10 # 创建小儿子
11 son2 = ET.Element(\'son\', {"name": \'儿2\'})
12 
13 # 在大儿子中创建两个孙子
14 grandson1 = ET.Element(\'grandson\', {\'name\': \'儿11\'})
15 grandson2 = ET.Element(\'grandson\', {\'name\': \'儿12\'})
16 son1.append(grandson1)
17 son1.append(grandson2)
18 
19 
20 # 把儿子添加到根节点中
21 root.append(son1)
22 root.append(son1)
23 
24 tree = ET.ElementTree(root)
25 tree.write(\'oooo.xml\',encoding=\'utf-8\', short_empty_elements=False)
26 
27 创建方式（一）
28 
29 创建方式一

由于原生保存的XML时默认无缩进，如果要设置缩进的话，需要修改保存方式：

 1 from xml.etree import ElementTree as ET
 2 from xml.dom import minidom
 3 
 4 
 5 def prettify(elem):
 6     """将节点转换成字符串，并添加缩进。
 7     """
 8     rough_string = ET.tostring(elem, \'utf-8\')
 9     reparsed = minidom.parseString(rough_string)
10     return reparsed.toprettyxml(indent="\\t")
11 
12 # 创建根节点
13 root = ET.Element("famliy")
14 
15 
16 # 创建大儿子
17 # son1 = ET.Element(\'son\', {\'name\': \'儿1\'})
18 son1 = root.makeelement(\'son\', {\'name\': \'儿1\'})
19 # 创建小儿子
20 # son2 = ET.Element(\'son\', {"name": \'儿2\'})
21 son2 = root.makeelement(\'son\', {"name": \'儿2\'})
22 
23 # 在大儿子中创建两个孙子
24 # grandson1 = ET.Element(\'grandson\', {\'name\': \'儿11\'})
25 grandson1 = son1.makeelement(\'grandson\', {\'name\': \'儿11\'})
26 # grandson2 = ET.Element(\'grandson\', {\'name\': \'儿12\'})
27 grandson2 = son1.makeelement(\'grandson\', {\'name\': \'儿12\'})
28 
29 son1.append(grandson1)
30 son1.append(grandson2)
31 
32 
33 # 把儿子添加到根节点中
34 root.append(son1)
35 root.append(son1)
36 
37 
38 raw_str = prettify(root)
39 
40 f = open("xxxoo.xml",\'w\',encoding=\'utf-8\')
41 f.write(raw_str)
42 f.close()
43 
44 定义缩进函数

4、命名空间

详细介绍，猛击这里

 1 from xml.etree import ElementTree as ET
 2 
 3 ET.register_namespace(\'com\',"http://www.company.com") #some name
 4 
 5 # build a tree structure
 6 root = ET.Element("{http://www.company.com}STUFF")
 7 body = ET.SubElement(root, "{http://www.company.com}MORE_STUFF", attrib={"{http://www.company.com}hhh": "123"})
 8 body.text = "STUFF EVERYWHERE!"
 9 
10 # wrap it in an ElementTree instance, and save as XML
11 tree = ET.ElementTree(root)
12 
13 tree.write("page.xml",
14            xml_declaration=True,
15            encoding=\'utf-8\',
16            method="xml")
17 
18 命名空间

 

 三、requests模块

requests是使用Apache2 Licensed许可证的基于python开发的HTTP库，其在python内置模块的基础上进行了高度的封装，从而使pythoner在进行网络请求时，变得更容易，使用requests可以轻而易举的完成浏览器可有的任何操作。requests模块是第三方开发库里的模块，调用前要先下载安装该模块。

1、安装模块

pip3 install requests

2、使用模块

 1 无参数，直接访问网站，拿数据
 2 import requests
 3 response = requests.get("http://www.weather.com.cn/adat/sk/101010500.html")
 4 response.encoding=\'utf-8\'
 5 result = response.text
 6 print(result)
 7 ###################执行结果如下：#####################
 8 {"weatherinfo":
 9 {"city":"怀柔",
10 "cityid":"101010500",
11 "temp":"9",
12 "WD":"南风",
13 "WS":"1级",
14 "SD":"29%",
15 "WSE":"1",
16 "time":"10:25",
17 "isRadar":"1",
18 "Radar":"JC_RADAR_AZ9010_JB",
19 "njd":"暂无实况","qy":"1007"}
20 }

 1 有参数，参数用params=变量名传入，结果中会先将参数打印在头部
 2 import requests
 3 payload={\'k1\':\'value1\',\'k2\':\'value2\'}
 4 ret=requests.get("http://www.weather.com.cn/adat/sk/101010500.html",params=payload)
 5 ret.encoding=\'utf-8\'
 6 print(ret.url)
 7 print(ret.text)
 8 ###############执行结果如下：################
 9 http://www.weather.com.cn/adat/sk/101010500.html?k1=value1&k2=value2
10 {"weatherinfo":
11 {"city":"怀柔",
12 "cityid":"101010500",
13 "temp":"9",
14 "WD":"南风",
15 "WS":"级",
16 "SD":"29%",
17 "WSE":"1",
18 "time":"10:25",
19 "isRadar":"1",
20 "Radar":"JC_RADAR_AZ9010_JB",
21 "njd":"暂无实况",
22 "qy":"1007"}
23 }

 1 # 1、基本POST实例
 2  
 3 import requests
 4  
 5 payload = {\'key1\': \'value1\', \'key2\': \'value2\'}
 6 ret = requests.post("http://httpbin.org/post", data=payload)
 7  
 8 print(ret.text)
 9  
10  
11 # 2、发送请求头和数据实例
12  
13 import requests
14 import json
15  
16 url = \'https://api.github.com/some/endpoint\'
17 payload = {\'some\': \'data\'}
18 headers = {\'content-type\': \'application/json\'}
19  
20 ret = requests.post(url, data=json.dumps(payload), headers=headers)
21  
22 print(ret.text)
23 print(ret.cookies)#cookies验证，比如登录后服务器会发送一串XX码保存在客户端内存中或硬盘中，即为cookies
24 
25 POST请求

更多requests模块相关的文档见：http://cn.python-requests.org/zh_CN/latest/

3、用requests模块发送HTTP请求，请求结束后解析XML的实例

 1 import urllib
 2 import requests
 3 from xml.etree import ElementTree as ET
 4 
 5 # 使用内置模块urllib
以上是关于Python3 & 基本数据类型（一）的主要内容，如果未能解决你的问题，请参考以下文章
 
 python3基础二——基本的数据类型一
 python基本数据类型-集合与运算符-python3笔记
 Python3之基本数据类型，基本运算
 python3----模块（序列化（json&pickle）+XML+requests）
 python3:基本数据类型（int，bool，str）
 python3基础二——基本的数据类型二