Python中常见的数据类型

数据类型

---

变量

什么是变量？在面向对象编程语言中，变量是一个可以随意赋值的对象。用于存储指定的数据类型。
变量的定义规则同标识符。
Python中的变量不需要事先声明，也就是不需要提前指定它的数据类型，它会根据赋予的值的数据类型自动转换。
变量是通过“=”进行定义和赋值。如：
a = 12
print(type(a))

输出结果为：
<class 'int'>

多变量赋值

顾名思义，就是同时给多个变量进行赋值。
1. a=b=c=1   # 在多个变量值相等的情况下同时赋值
2. a,b,c = 1,2,3	# 各变量值不等的情况下同时赋值

数字（Number）

python支持三种不同的数值类型：
int（整型）：整数，不带小数点的数。如1，-19等
float（浮点型）：又称为小数，带小数点的数。如1.0、3.1415926
complex（复数）：a+bj，由实部和虚部组成的数值，a和b都是实数，以浮点数的形式出现。

数字类型转换

不同的数字类型之间可以相互转换，如整型转换成浮点数，浮点数取整，如
print(float(12))
print(int(5.26))

输出结果为：
12.0
5

随机数

从多个数字元素（数字的集合）中随机抽取一个数值。
随机数多用于游戏、数学、安全等领域的应用。
通过导入随机库random来进行调用，如
import radom
print(random.randrange(1,4))

输出结果为1-3之间的一个数值。

随机数函数

random.choice(seq)：随机从一个有序列的集合中抽取一个元素
randrange ([start,] stop [,step])：随机从一个指定的数值区间抽取一个元素，start是开始的数值，stop是结束的数值，step是间隔、步长
random()：随机生成一个0-1之间的浮点数
shuffle(lst)：将一个列表中的元素随机进行排序。

常用数学函数

abs()：求绝对值。如print(abs(-3)) 输出 3
fabs()：求绝对值的浮现数形式，如fabs(-5) 返回的数字为 5.0
floor()：返回数字的下舍整数，如floor(5.2)返回的数字为 5
ceil()：返回数字的上入整数，如ceil(4.2)返回的数字为 5
max()：从多个数值中选出最大值，括号内可以是序列（数字的集合）
min()：从多个数值中选出最小值，括号内可以是序列（数字的集合）
pow(x,y)：返回x的y次幂
round(float)：圆整，四舍五入
sqrt(x)：求x的平方根

数学常量

e：自然常数
pi：指math.pi，即圆周率

字符串（String）

字符串是任何编程语言中最常见的数据类型。

访问字符串中的字符

字符串在python中也有序列关系，即一个字符串的每个字符都有自己的序列号（顺序编号，从0开始）。

举例

str = "Python"
# str这个变量的值是“Python”这个字符串，从序列号分配给python，如图：
P y t h o n
↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5

访问字符串中的字符，是通过方括号[]中添加序列号进行访问（读取），如：
print(str[0])

输出结果为：
P

字符串切片

切片：截取字符串的一部分，是通过冒号“：”进行截取。如：
str = "congratulation"
print(str[1:5]) # 去掉1个str的1个字符，持续截取到第5个字符
print(str[5:]) # 去掉前5个字符，持续查完剩余字符
print(str[::-1]) # 倒序输出所有字符
print(str[::-3]) # 倒序输出从最末一个，间隔为3-1的字符	
print(str[:5]) # 输出前5个字符
结果为:
'ongr'  
'atulation'  
'noitalutargnoc'  
'nturo'  
'congr'  

字符串拼接

字符换可以使用“+”和“，”实现拼接。如：
print("Tom"+"was"+"21 years old.")
print("Tom","was","21 years old.")
输出结果为：
Tomwas21 years old.
Tom was 21 years old.

“+”拼接的字符串没有空格
“,”拼接的字符串会产生一个空格

# 在print()函数中，字符串和数字不能混合拼接打印，必须将数字转化为string类型，如：
print("Tom"+"was"+21+"years old.")
输出会报错：
Traceback (most recent call last):
File "<pyshell#20>", line 1, in <module>
	print("Tom"+"was"+21+"years old.")
TypeError: Can't convert 'int' object to str implicitly

正确的做法应为：
print("Tom"+"was"+str(21)+"years old.")
结果为：
Tomwas21 years old.

# 使用“,”拼接时，不需要转换数据类型
print("Tom","was",21,"years old.")
结果为：
print("Tom","was",21,"years old.")

转义字符

\(在行尾时)	 #续行符
\\			#反斜杠符号
\'			#单引号
\"			#双引号
\a			#响铃
\b			#退格(Backspace)
\e			#转义
\000		#空/空格
\n			#换行
\v			#纵向制表符
\t			#横向制表符
\r			#回车
\f			#换页
\other		#其它的字符以普通格式输出

字符串常用运算符

*	 		#重复输出（翻倍），如 print("Tom"*3) 结果为：TomTomTom
in			#查看某个字符或字符串是否在指定字符串中，if 'o' in "Python"
not in		#与in相反
r/R			#输出原始字符串，也就是不管字符串中有没有转义或含有其他意义的字符，都按照原本的形式输出，如:print(r"abc\n defg")中有一个换行符，但在打印时加了一个“r”，这个换行符无效。输出结果为：abc\n defg

字符串格式化

使用格式化字符来代替一部分名可以变更的字符串，可以理解为格式化就是将指定的可变字符串设置成一个变量。
格式：print("abc %s defg %d" %("%s"的值,"%d的值"))
举例：
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
输出结果为：
我叫 小明 今年 10 岁!

常用格式化符号

%s	 # 格式化字符串
%d	 # 格式化整数
%u	 # 格式化无符号整型	
%f	 # 格式化浮点数字，可指定小数点后的精度

三引号字符串

在print()函数中想输出多行数据，可以使用三个单引号或三个双引号
举例：
print("""I love python,
because it's easy to learn,
and easy to use.""")
输出结果为：
I love python,
because it's easy to learn,
and easy to use.

内建函数

什么是内建函数？
当前对象本身可以使用的python自带函数
内建函数的使用方法
如字符串a = 'jack'需要转化为'Jack'时，可以使用a.capitalize()的方式实现首字母转换为大写的方法

常用字符串内建函数

capitalize()：将字符串的第一个字符转换为大写，空格不需要写东西
upper()：转换字符串中的小写字母为大写
swapcase()：将字符串中大写转换为小写，小写转换为大写（互相转换）
lower()：转换字符串中所有大写字符为小写
lstrip()：截掉字符串左边的空格或指定字符
rstrip()：删除字符串字符串末尾的空格
strip()：截掉字符串两端的空格
len(string)：返回字符串的长度，以整型数值显示
max(str)：返回字符串 str 中最大的字母。
min(str)：返回字符串 str 中最小的字母。

##数组

含有多个元素的数据集合。
表现形式主要有：列表（list）、元组（tuple）、字典（dict）、集合（set）

##列表（List）

列表（list）是一个有序的数据的集合，在python中通过[ ]标记。
举例：
lst = [1,2,3,"Mary"]
print(lst)
输出结果为：
[1,2,3,"Mary"]

# 这是一个列表，列表中可以存储多个数据（列表元素），列表中的每个元素都是有序号的，顺序编号是从0开始，如图：
[ 1, 2, 3, "Mary"]
  ↑  ↑  ↑     ↑
  0  1  2     3
# 列表中等元素类似于字符串的每个字符，在截取列表元素的方式（切片）也是类似的。
举例：
print(lst[2])
结果为：
3

###操作列表

访问列表

同访问字符串（类似于字符串切片）。

更新列表元素

相当于替换列表元素。访问列表中的元素，然后重新赋值即可。
举例：
lst = [1,2,3,"Mary"]
lst[2] = 5
print(lst)
结果为：
[1,2,5,"Mary"]

删除列表元素

类似于更新列表元素，使用del关键字执行删除操作。
举例：
lst = [1,2,3,"Mary"]
del lst[2]
print(lst)

# 也可以使用del删除整个列表，格式：del 列表名。

python列表常用操作符

len(lst)：统计列表中元素的个数
+ ：拼接列表，类似于字符串拼接
* ：重复输出列表数据（翻倍）
in：判断某个字符（元素）是否在列表中

# for i in (lst) 列表是一个有序的集合，它是可以迭代（逐个输出一遍列表的元素）

lst_a = [1,2,3]
lst_b = ["a","b","c"]

print(len(lst_a))
print(lst_a+lst_b)
print(lst_a*3)
print("a" in lst_b)

输出结果为：
3
[1,2,3,'a','b','c']
[1, 2, 3, 1, 2, 3, 1, 2, 3]
True

嵌套列表

通常在其他编程语言中，这种说法成为二维数组或多维数组，即列表中的元素也可以是列表或其他集合。如：
lst_a = [1,2,[3,4,5],[6,[7],8]]
print(lst_a)
结果为：
[1,2,[3,4,5],[6,[7],8]]

常用列表函数

列表函数都属于内建函数。
使用方法参考字符串的内建函数的用法。

list.append(obj)：在列表末尾添加新的元素
list.count(obj)：统计列表中指定元素的个数（出现的次数）
list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)：将对象插入列表
list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)：移除列表中某个值的第一个匹配项
list.reverse()：反向输出列表中元素
list.clear()：清空列表
list.copy()：复制列表

举例：
lst = [1,2,3]
print(lst.append(1,5,1,7,2,4))
print(lst.count(1))
print(lst.extend(["a","b","c"])
print(lst.index(3))
print(lst.insert(2,['o']))
print(lst.pop())
print(lst.remove(2))
print(lst.clear())

lst_b = lst.copy
print(lst_b)

输出结果为：
[1,2,3,(1,5,1,7,2,4)] # 在新生成的列表中，这个列表里的tuple中的元素不能单独被lst统计
1
[1,2,3,["a","b","c"]]
2
[1,2,3,o]
[1,2]
[1,3]
[]
[1,2,3]

##练习1

1.有一个字符串“Congratulation!You win the game!”
要求使用字符串切片的方式输出下列数据：
You win the game!
You
将字符串倒序输出

2.小明的各科成绩列表为[75,82,86,93]
将第二科成绩修改为85
追加一科成绩62
小红的成绩为[69,72,81,95]与小明的成绩拼接在一起

##元组（Tuple）

元组与列表类似，不同之处在于，元组的元素不可变（嵌套在元组中的列表除外）。
元组用圆括号（）表示

创建空元组
tup = ()

# 有时候创建元组不需要圆括号也可以，如下
tup1 = 2,3,4,5,6
tup2 = [1,2],3,4,5

元组的操作符
+ 、* 、in 、len()等等，与列表操作符类似

删除元组
del tup[index] # 删除元组中指定编号的元素
del tup1 # 从内存中删除元组

# 元组的索引、截取与列表类似。

元组内置函数

len(tup)：统计元组的元素个数
max(tup)：返回元组中元素最大值
min(tup)：返回元组中元素最小值
tuple(list)：将列表转化为元组
list(tuple)：将元组转化为列表

##字典（Dict）

字典（dictionary）是一个可变的容器，它的数据都是以 键：值 成对出现。
字典是用花括号{}标志。
字典中的 键（Key）是唯一的，若出现重名的键值，以最后出现的为准。
info = {"name":"杨家路","address":"杨家路"，"age":23}

访问字典

访问字典中的信息（通常指的是值（value）），需要通过键名进行读取。字典不是一个序列。
从上述的例子中读取该字段info的信息，应当这么写：
print(info["name"])
打印的结果为：
杨家路

修改字典

info["age"] = 25 #修改字典中的信息（修改value）

#通常需要修改字典中的键名时，应该先del（删除）对应的键，再添加一个新的键:值

字典的特性

1.字典中若出现重名的键，则以最后出现的为准，如：
dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
print("dict['Name']: ", dict['Name'])
结果为：
小菜鸟

2.字典的键名，可以使用数字、字符串甚至是元组来命名，但绝不能用列表。如：
dict = {['Name']: 'Runoob', 'Age': 7}
print ("dict['Name']: ", dict['Name'])
输出结果：
Traceback (most recent call last):
	File "test.py", line 3, in <module>
		dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

##集合（Set）

集合是一个无序的数组，主要就是将序列中的数据进行去重。可以看作是一个函数，将序列（如列表）转化成集合，列表中的元素会自动去重。
将数组转化成集合后，集合是用花括号{}标志。
举例：
lst = [1,2,1,5,7,2,9]
newlst = set(lst)
print(newlst)

集合的关系

# 交集：两个集合中共有的值
set_1.intersection(set_2)  # set_1和set_2表示两个不同的列表

a = set_1 | set_2
print(a)

# 并集：两个集合合并后去重
set_1.union(set_2)

b = set_1 & set_2
print(b)

# 差集：左边的集合（list_1）有，右边的集合（list_2）没有
set_1.difference(set_2)

c = set_1 - set_2
print(c)

# 对称差集：去掉两个集合的交集后剩余的所有元素
set_1.symmetric_difference(set_2)

d = set_1 ^ set_2
print(d)


# 子集：判断一个集合是否包含的另一个集合的所有元素
set_2.issubset(set_1) # 判断set_1是否包含了set_2中的所有元素

# 父集：判断集合是为另一个集合的父集
set_1.issuperset(set_2) # 判断set_1是set_2的父集