Python数据类型总结
'''
1.整型
即int类型，无论整型数字多大多小都属于int。
代码：
x = 10
print(type(x)) # <class 'int'>
1.1整型数字之间进制关系
# 十六进制
print(0x11)
print(0x111)
# 二进制
print(0b101)
print(0B101)
# 八进制
print(0o12)
print(0o23)
# 十进制转换为二进制
print(bin(3))
# 十进制转换为十六进制
print(hex(19))
# 十进制转换为八进制
print(oct(10))
==============================
2.浮点型
在python中小数都属于浮点型(float）,有两种表现形式
2.1小数点形式
f = 3.14
print(f) # 3.14
print(type(f)) # <class 'float'>
f3 = 3.1415926123456789876543217789
print(f3) # 双精度(double float,保留17为有效数字)
print(type(f3))
2.2指数形式： aEn 或 aen
3.2E5 = 3.2×105，其中 3.2 是尾数，5 是指数。
2.7E-3 = 2.7×10-2，其中 2.7 是尾数，-3 是指数。
0.2E8 = 0.2×107，其中 0.2 是尾数，8 是指数。
f1 = 3.2E5
print(f1) # 320000.0
print(type(f1)) # <class 'float'>
f2 = 3.2E-5
print(f2) # 3.2e-05
print(type(f2)) # <class 'float'>
==============================
3.布尔类型
布尔型（Boolean）是一种数据的类型，这种类型只有两种值，即"真"与"假"。在python中用 bool表示布尔类型，“真"用关键字true表示，“假"用false表示。
print(4 == 2) # False
name = "xi"
print(name == "alvin") # False
print(1 == "1") # False
3.1零值
不光表达式的结果是布尔值，任意值都有自己的布尔值，这就涉及到布尔的零值。
# 任意数据类型都一个具体值的布尔值为False,我们称为零值。该类型的其他值的布尔值皆为True。
print(bool("")) # 字符串的零值 “”
print(bool(0)) # 整型的零值 0
print(bool(False)) # 布尔类型的零值 False
==============================
4.字符串
字符串是由零个或多个字符组成的有限序列。字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有字符。
在python中字符串是通过单引号''或者双引号""标识的，Python 字符串中的双引号和单引号没有任何区别！。
s1 = "hi xi"
print(s1)
s2 = ""
print(s2)
s3 = 'xi是最帅!'
print(s3)
4.1字符串的转义符
转义字符 说明
\n 换行符，将光标位置移到下一行开头。
\r 回车符，将光标位置移到本行开头。
\t 水平制表符，也即 Tab 键，一般相当于四个空格。
\a 蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b 退格（Backspace），将光标位置移到前一列。
\ 反斜线
' 单引号
" 双引号
\ 在字符串行尾的续行符，即一行未完，转到下一行继续写。
4.2长字符串
s = """
s = "hi xi\\nhi，alvin"
I'm xi
这是一个python解释器路径："D:\\nythonProject\\nenv\Scripts\python.exe"
长字符串中放置单引号或者双引号不会导致解析错误
"""
print(s)
4.3格式化输出
之前讲到过 print() 函数的用法，这只是最简单最初级的形式，print() 还有很多高级的玩法，比如格式化输出。
name = "xi"
age = 23
print("My name is %s; My age is %d"%(name,age))
在 print() 函数中，由引号包围的是格式化字符串，它相当于一个字符串模板，可以放置一些转换说明符（占位符）。本例的格式化字符串中包含一个%s和%d说明符，它最终会被后面的name和age 变量的值所替代。中间的%是一个分隔符，它前面是格式化字符串，后面是要输出的表达式。
print() 函数使用以%开头的转换说明符对各种类型的数据进行格式化输出，具体请看下表。
转换说明符 解释
%d、%i 转换为带符号的十进制整数
%o 转换为带符号的八进制整数
%x、%X 转换为带符号的十六进制整数
%e 转化为科学计数法表示的浮点数（e 小写）
%E 转化为科学计数法表示的浮点数（E 大写）
%f、%F 转化为十进制浮点数
%g 智能选择使用 %f 或 %e 格式
%G 智能选择使用 %F 或 %E 格式
%c 格式化字符及其 ASCII 码
%r 使用 repr() 函数将表达式转换为字符串
%s 使用 str() 函数将表达式转换为字符串
4.4归属序列类型
字符串属于序列类型，所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。
s= "hello yuan"
image-20210413141108883
Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，如图 所示。
序列类型支持的操作：
# （1）索引取值
s = "hello yuan"
print(s[6])
print(s[-10])
# （2）切片取值：序列类型对象[start : end : step]
s = "hello yuan"
print(s[1:4]) # ell ：取索引1到索引3（左闭又开）
print(s[:4]) # hell ：start缺省，默认从0取
print(s[1:]) # ello yuan ： end缺省，默认取到最后
print(s[1:-1]) # ello yua
print(s[6:9]) # yua
print(s[-4:-1]) # yua
print(s[-1:-4]) # 空
print(s[-1:-4:-1]) #nau step为1：从左向右一个一个取。为-1 ，从右向左一个取
# （3）判断存在：Python 中，可以使用 in 关键字检查某元素是否为序列的成员。
s = "hello yuan"
print("yuan" in s) # True
# （4）支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
# 使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果
s = "hello"+" yuan"
print(s) # hello yuan
s= "*"*10
print(s) # **********
（5）内置方法（重点）
方法 作用 示例 输出
upper 全部大写 "hello".upper() "HELLO"
lower 全部小写 "Hello".lower() "hello"
startswith() 是否以a开头 "Yuan".startswith("Yu") True
endswith() 是否以a结尾 "Yuan".endswith("a") False
isdigit() 是否全数字 '123'.isdigit() True
isalpha() 是否全字母 'yuan123'.isalpha() False
isalnum() 是否全为字母或数字 'yuan123'.isalnum() True
strip() 去两边空格 " hi yuan \n".strip() "hi yuan"
join() 将多个字符串连接在一起 "-".join(["yuan","alvin","eric"]) "yuan-alvin-eric"
split() 按某字符分割字符串，默认按空格分隔 "yuan-alvin-eric".split("-") ['yuan', 'alvin', 'eric']
find() 搜索指定字符串，没有返回-1 "hello world".index("w") 6
index() 同上，但是找不到会报错 "hello world".index("w") 6
count() 统计指定的字符串出现的次数 "hello world".count("l") 3
replace() 替换old为new 'hello world'.replace(‘world',‘python') "hello python"
format() 格式化方法
# 任意数据对象.方法()实现对数据的某种操作
# 不同数据类型对象支持不同方法
# 字符串类型对象支持哪些方法
s1 = "yuan"
s2 = "RAIN"
# (1) upper方法和lower方法
s3 = s1.upper()
s4 = s2.lower()
print(s3) # "YUAN"
print(s4) # "rain"
s5 = "hello yuan"
s6 = "hi world"
# (2) startswith和endswith：判断字符串是否以什么开头和结尾
print(s5.startswith("hello")) # True
print(s6.startswith("hello")) # False
print(s6.startswith("hi wor")) # True
print(s6.endswith("hi wor")) # False
# (3) isdigit(): 判断字符串是否是一个数字字符串
s7 = "123"
s8 = "123A"
print(s7.isdigit()) # True
print(s8.isdigit()) # False
s9 = "123SAA%#"
print(s9.isalnum()) # False 不能包含特殊符号
# (4) strip(): 去除两端空格和换行符号
s10 = " I am yuan "
print(s10)
print(s10.strip())
name = input("请输入姓名>>").strip()
print(name)
# (5) split分割方法: 将一个字符串分割成一个列表
s11 = "rain-yuan-alvin-eric"
print(s11.split("-")) # ['rain', 'yuan', 'alvin', 'eric']
# (6) join方法: 将一个列表中的字符串拼接成一个字符串
names_list = ['rain', 'yuan', 'alvin', 'eric']
s12 = "-".join(names_list) # 用什么分隔符拼接names_list列表
print(s12,type(s12)) # "rain-yuan-alvin-eric"
==============================
5.列表
列表声明
在实际开发中，经常需要将一组（不只一个）数据存储起来，以便后边的代码使用。列表就是这样的一个数据结构。
列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，如下所示：
[element1, element2, element3, ..., elementn]
不同于C，java等语言的数组，python的列表可以存放不同的，任意的数据类型对象。
l = [123,"xi",True]
print(l,type(l))
# 注意
a,b = [1,2]
print(a,b)
5.1索引求值
l = [10,11,12,13,14]
print(l[2]) # 12
print(l[-1]) # 14
5.2切片操作
l = [10,11,12,13,14]
print(l[2:5])
print(l[-3:-1])
print(l[:3])
print(l[1:])
print(l[:])
print(l[2:4])
print(l[-3:-1])
print(l[-1:-3])
print(l[-1:-3:-1])
print(l[::2])
1、取出的元素数量为：结束位置 - 开始位置；
2、取出元素不包含结束位置对应的索引，列表最后一个元素使用 list[len(slice)] 获取；
3、当缺省开始位置时，表示从连续区域开头到结束位置；
4、当缺省结束位置时，表示从开始位置到整个连续区域末尾；
5、两者同时缺省时，与列表本身等效；
6、step为正，从左向右切，为负从右向左切。
5.3判断成员是否存在
in 关键字检查某元素是否为序列的成员
l = [10,11,12,13,14]
print(20 in l) # False
print(12 in l) # True
5.4相加
l1 = [1,2,3]
l2 = [4,5,6]
print(l1+l2) # [1, 2, 3, 4, 5, 6]
5.5循环列表
for name in ["张三",'李四',"王五"]:
print(name)
for i in range(10): # range函数： range(start,end,step)
print(i)
# 基于for循环从100打印到1
for i in range(100,0,-1):
print(i)
==============================
6.列表
在实际开发中，经常需要将一组（不只一个）数据存储起来，以便后边的代码使用。列表就是这样的一个数据结构，python的列表可以存放不同的，任意的数据类型对象。
列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，如下所示：
[element1, element2, element3, ..., elementn]
l = [123,"yuan",True]
print(l,type(l))
# 注意
a,b = [1,2]
print(a,b)
#序列操作
列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。
[1,2,3,4,5]
0 1 2 3 4
-5 -4 -3 -2 -1
6.1索引求值
l = [10,11,12,13,14]
print(l[2]) # 12
print(l[-1]) # 14
6.2切片操作
l = [10,11,12,13,14]
print(l[2:5])
print(l[-3:-1])
print(l[:3])
print(l[1:])
print(l[:])
print(l[2:4])
print(l[-3:-1])
print(l[-1:-3])
print(l[-1:-3:-1])
print(l[::2])
1、取出的元素数量为：结束位置 - 开始位置；
2、取出元素不包含结束位置对应的索引，列表最后一个元素使用 list[len(slice)] 获取；
3、当缺省开始位置时，表示从连续区域开头到结束位置；
4、当缺省结束位置时，表示从开始位置到整个连续区域末尾；
5、两者同时缺省时，与列表本身等效；
6、step为正，从左向右切，为负从右向左切。
6.3判断成员是否存在
in 关键字检查某元素是否为序列的成员
l = [10,11,12,13,14]
print(20 in l) # False
print(12 in l) # True
6.4相加
l1 = [1,2,3]
l2 = [4,5,6]
print(l1+l2) # [1, 2, 3, 4, 5, 6]
6.5循环列表
for name in ["张三",'李四',"王五"]:
print(name)
for i in range(10): # range函数： range(start,end,step)
print(i)
# 基于for循环从100打印到1
for i in range(100,0,-1):
print(i)
6.6列表内置方法
l = [1,2,3]
方法 作用 示例 结果
append() 向列表追加元素 l.append(4) l：[1, 2, 3, 4]
insert() 向列表任意位置添加元素 l.insert(0,100) l：[100, 1, 2, 3]
extend(） 向列表合并一个列表 l.extend([4,5,6]) l：[1, 2, 3, 4, 5, 6]
pop() 根据索引删除列表元素（为空删除最后一个元素） l.pop(1) l：[1, 3]
remove() 根据元素值删除列表元素 l.remove(1) l：[2, 3]
clear() 清空列表元素 l.clear() l：[]
sort() 排序（升序） l.sort() l：[1,2,3]
reverse() 翻转列表 l.reverse() l：[3,2,1]
count() 元素重复的次数 l.count(2) 返回值：1
index() 查找元素对应索引 l.index(2) 返回值：1
# 增删改查: [].方法()
# (1) ******************************** 增(append，insert，extend) ****************
l1 = [1, 2, 3]
# append方法：追加一个元素
l1.append(4)
print(l1) # [1, 2, 3, 4]
# insert(): 插入，即在任意位置添加元素
l1.insert(1, 100) # 在索引1的位置添加元素100
print(l1) # [1, 100, 2, 3, 4]
# 扩展一个列表：extend方法
l2 = [20, 21, 22, 23]
# l1.append(l2)
l1.extend(l2)
print(l1) # [1, 100, 2, 50, 3, 4,[20,21,22,23]]
# 打印列表元素个数python内置方法：
print(len(l1))
# (2) ******************************** 删（pop，remove，clear） **********************
l4 = [10, 20, 30, 40, 50]
# 按索引删除:pop,返回删除的元素
# ret = l4.pop(2)
# print(ret)
# print(l4) # [10, 20, 40, 50]
# 按着元素值删除
l4.remove(30)
print(l4) # [10, 20, 40, 50]
# 清空列表
l4.clear()
print(l4) # []
# (3) ******************************** 修改(没有内置方法实现修改，只能基于索引赋值) ********
l5 = [10, 20, 30, 40, 50]
# 将索引为1的值改为200
l5[1] = 200
print(l5) # [10, 200, 30, 40, 50]
# 将l5中的40改为400 ,step1：查询40的索引 step2：将索引为i的值改为400
i = l5.index(40) # 3
l5[i] = 400
print(l5) # [10, 20, 30, 400, 50]
# (4) ******************************** 查（index，sort） *******************************
l6 = [10, 50, 30, 20,40 ]
l6.reverse() # 只是翻转 [40, 20, 30, 50, 10]
print(l6) # []
# # 查询某个元素的索引，比如30的索引
# print(l6.index(30)) # 2
# 排序
# l6.sort(reverse=True)
# print(l6) # [50, 40, 30, 20, 10]
==============================
7.元组
Python的元组与列表类似，不同之处在于元组的元素只能读，不能修改。通常情况下，元组用于保存无需修改的内容。
元组使用小括号表示，声明一个元组：
(element1, element2, element3, ..., elementn)
需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串。
l = (1,2,3)
print(l,type(l)) # (1, 2, 3) <class 'tuple'>
序列操作
7.1索引和切片
l = (1,2,3,4,5)
print(l[2]) # 3
print(l[2:4]) # (3, 4)
print(l[:4]) # (1, 2, 3, 4)
print(2 in l)
7.2内置方法
l = (1,2,3,4,5,3,3)
print(l.count(3)) #统计3的个数
print(l.index(5)) #查找首次5索引位置
==============================
8.字典
字典是Python提供的唯一内建的映射(Mapping Type)数据类型。
python使用 { } 创建字典，由于字典中每个元素都包含键（key）和值（value）两部分，因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。
使用{ }创建字典的语法格式如下：
1、同一字典中的各个键必须唯一，不能重复。
2、字典是键值对是无序的，但在3.6版本后，字典默认做成有序的了，这是新的版本特征。
dictname = {'key':'value1', 'key2':'value2', ...}
#字典的基本操作
8.1查键值
print(book["title"]) # 返回字符串 西游记
print(book["authors"]) # 返回列表 ['rain', 'yuan']
8.2添加或修改键值对
注意：如果键存在，则是修改，否则是添加
book["price"] = 299 # 修改键的值
book["publish"] = "北京出版社" # 添加键值对
8.3删除键值对 del 删除命令
print(book)
del book["publish"]
print(book)
del book
print(book)
8.4判断键是否存在某字典中
print("price" in book)
8.5循环
for key in book:
print(key,book[key])
8.6字典的内置方法
方法 作用 示例 结果
get() 查询字典某键的值，取不到返回默认值 d.get("name",None) "yuan"
setdefault() 查询字典某键的值，取不到给字典设置键值，同时返回设置的值 d.setdefault("age",20) 18
keys() 查询字典中所有的键 d.keys() ['name','age']
values() 查询字典中所有的值 d.values() ['yuan', 18]
items() 查询字典中所有的键和值 d.items() [('name','yuan'), ('age', 18)]
pop() 删除字典指定的键值对 d.pop(“age”) {'name':'yuan'}
popitem() 删除字典最后的键值对 d.popitem() {'name':'yuan'}
clear() 清空字典 d.clear() {}
update() 更新字典 t={"gender":"male","age":20}d.update(t) {'name':'yuan','age': 20, 'gender': 'male'}
dic = {"name": "yuan", "age": 22, "sex": "male"}
# （1）查字典的键的值
print(dic["names"]) # 会报错
name = dic.get("names")
sex = dic.get("sexs", "female")
print(sex)
print(dic.keys()) # 返回值：['name', 'age', 'sex']
print(dic.values()) # 返回值：['yuan', 22, 'male']
print(dic.items()) # [('name', 'yuan'), ('age', 22), ('sex', 'male')]
# setdefault取某键的值，如果能取到，则返回该键的值，如果没有改键，则会设置键值对
print(dic.setdefault("name")) # get()不会添加键值对 ，setdefault会添加
print(dic.setdefault("height", "180cm"))
print(dic)
# （2）删除键值对 pop popitem
sex = dic.pop("sex") # male
print(sex) # male
print(dic) # {'name': 'yuan', 'age': 22}
dic.popitem() # 删除最后一个键值对
print(dic) # {'name': 'yuan'}
dic.clear() # 删除键值对
# (3) 添加或修改 update
add_dic = {"height": "180cm", "weight": "60kg"}
dic.update(add_dic)
print(dic) # {'name': 'yuan', 'age': 22, 'sex': 'male', 'height': '180cm', 'weight': '60kg'}
update_dic = {"age": 33, "height": "180cm", "weight": "60kg"}
dic.update(update_dic)
print(dic) # {'name': 'yuan', 'age': 33, 'sex': 'male', 'height': '180cm', 'weight': '60kg'}
# (4) 字典的循环
dic = {"name": "yuan", "age": 22, "sex": "male"}
# 遍历键值对方式1
# for key in dic: # 将每个键分别赋值给key
# print(key, dic.get(key))
# 遍历键值对方式2
# for i in dic.items(): # [('name', 'yuan'), ('age', 22), ('sex', 'male')]
# print(i[0],i[1])
# 关于变量补充
# x = (10, 20)
# print(x, type(x)) # (10, 20) <class 'tuple'>
# x, y = (10, 20)
# print(x, y)
for key, value in dic.items():
print(key, value)
==============================
9.集合
Python 中的集合，和数学中的集合概念一样。由不同可hash的不重复的元素组成的集合。
#声明集合
Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示：
{element1,element2,...}
其中，elementn 表示集合中的元素，个数没有限制。
从内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。
由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来。
s = {"zhangsan",18,"male"}
for item in s:
print(item)、
s = {1,2,3,9}
print(s,type(s))
9.1去重功能
l = [1,2,3,4,5,1]
s = set(l)
print(s)
new_l =list(s)
print(new_l)
9.2访问元素
for i in s
print(i)
9.3内置方法
方法 作用 示例 结果
add() 向集合添加元素 a.add(4) {1, 2, 3, 4}
update() 向集合更新一个集合 a.update({3,4,5}) | {1, 2, 3, 4, 5}` |
remove() 删除集合中的元素 a.remove(2) {1, 3}
discard() 删除集合中的元素 a.discard(2) {1, 3}
pop() 随机删除集合一个元素 a.pop() {2,3}
clear() 清空集合 a.clear() {}
intersection() 返回两个集合的交集 a.intersection(b) {3}
difference() 返回两个集合的差集 a.difference(b)b.difference(a) {1,2}{4,5}
symmetric_difference() 返回两个集合的对称差集 a.symmetric_difference(b) {1, 2, 4, 5}
union() 返回两个集合的并集 a.union(b) {1, 2, 3, 4, 5}
a = {1,2,3}
b = {3,4,5}
(1).添加元素
a.add(5)
print(a)
(2).更新元素
a.update({3,4,5})
print(a) #{1,2,3,4,5}
(3).删除元素
a.remove(6) #删除元素不存在报Key错误。
print(a)
a.discard(6) #删除元素不存在不报错。
a.pop
print(a) #随机删除一个元素
(4).交集
ret = a.intersection(b)
print(ret)
ret = b.intersection(a)
print(ret)
(5).并集
#a.update(b)
#print(a)
ret2 = a.union(b)
print(ret2)
ret2 = b.union(a)
print(ret2)
(6).差集
ret3 = a.difference(b)
print(ret3)
ret3 = b.difference(a)
print(ret3)
(7).对称差集
print(a.symmetric_difference(b))
print(b.symmetric_difference(a))
==============================
999.类型转换
i = int("3")
print(i,type(i)) # 3 <class 'int'>
s = str(3.14)
print(s,type(s)) # 3.14 <class 'str'>
'''
