Python编程基础二：数据类型

1. 数字

整数和浮点数（小数）在数学中被称为实数，与之对应的是复数；布尔类型是整数类型的子类
整数类型<class ‘int’>
浮点类型<class ‘float’> 储存小数数值
复数类型<class ‘complex’>：在数学中表现为a+bi，可用来表示向量
布尔类型<class ‘bool’> 只有True和False两个值

<class 'int'> 	#整数类型
<class 'float'>	#浮点类型
	float(3.1415e-2)	#得到0.031415，小数点左移2位
    float(3.1415e2)		#得到314.15，小数点右移2位
<class 'complex'> #复数类型
<class 'bool'>	#布尔类型

布尔类型

True：非零整数，小数，非空字符串
False：整数0，空字符串，空列表，空字典

bool	int()	float()	complex()
True	1	1.0	1+0j
False	0	0.0	0j

2. 序列sequence

是一种可迭代的，元素有序的容器类型的数据。
包括：列表（list)、字符串(str)、元祖(tuple)和字节序列(bytes)等

2.1 序列索引

正值索引：第一个元素的索引是0
负值索引：最后一个元素的索引是-1


以字符串举例，字符串 a="hello"是由五个字符有序组成的数据。
>>>a[0]
h
按照正值索引，其对应符号分别是：[0]h [1]e [2]l [3]l [4]o
按照负值索引，其对应符号分别是：[-5]h [-4]e [-3]l [-2]l [-1]o


max() 获取最后一个元素
min() 获取第一个元素
len() 用于获取序列的长度

2.2 序列运算操作

序列加法**+：将两个序列连接起来
序列乘法***：将序列重复多次
乘赋值运算符***=：a * = 2 相当于 a = a * 2
加赋值运算符+=**：a += ‘World’ 相当于 a = a + ‘World’

2.3 序列切片操作：切片运算符

序列的切片（Slicing）就是从序列中切分出小的子序列
切片运算符：[start: end: step]

start：开始索引，切下来的切片包括start元素
end：结束索引，切下来的切片不包括end部分（要包括end部分留空，如[-5::1]）
step：步长（切片时获取的元素的间隔，可以是正整数，也可以是负整数，-1表示取反）

2.4 测试符

in ： 用来测试某段代码是否包含某一元素
not in ： 用来测试是否不包含某一元素

3. 字符串"" str

字符串就是用引号括起来的一系列字符

3.1 修改字符串

不同的方式打印name里面的信息：
title() 首字母大写
upper() 全字母大写：
lower() 全字母小写
\t 增加空格
\n 换行
rstrip() 删除空白

3.2 字符串的表达方式

3.2.1 普通字符串

用单引号(’)或双引号(")括起来的字符串

常用的转义符

字符表示	说明
\t	水平制表符，换行增加空格
\n	换行
\r	回车
"	双引号
’	单引号
\	反斜线

3.2.2 原始字符串

原始字符串（raw string）需要在普通字符串前加r，原始字符串中的特殊字符不需要被转义

r"Hello\n World"

(原始字符串中的\n表示\和n两个字符)

3.2.3 长字符串

表示包含换行，缩进等排版的字符

使用三个单引号(’’’)或三个双引号(""")括起来

s = '''XXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXX''' 
# 三个括号里面是长字符串

3.3 字符串与数字的相互转换

将字符串转换成数字： int(), float()

如果成功则返回数字，否则引发异常。

如int(‘80’), float(‘80.0’)

将数字转换为字符串：str()

3.4 格式化字符串

字符串的format()方法：可实现字符串的拼接，还可以格式化字符串

3.4.1 使用占位符

要将表达式的计算结果插入到字符串中，则需要使用字符串{}

i = 32
s =  ' i * i = ' + str(‘i * i')  # 用str转换为字符串，拼接字符串
s =  ' i * i = {}'.format(i*i)   
# 字符串占位符被format()方法中的参数替换
s = '{0} * {0} = {1}'.format(i,i*i)
# 参数序号占位符，从0开始，序号0被format()方法中第一个参数取代，序号1被format()方法中第二个参数取代，以此类推
s = '{p1} * {p1} = {p2}'.format(p1=i,p2=i*i)
# 参数名占位符，可以用参数名替换占位符

3.4.2 格式化控制符

格式化控制符位于占位符索引或占位符位置的后面，之间用冒号分隔。

语法：{参数序号/参数名: 格式控制符}

参数序号与:之间不能有空格！

格式控制符	说明
s	string字符串（非数值向）
d	deci-十进制整数
f、F	float十进制浮点数
g、G	十进制整数或浮点数
e、E	科学计算法表示浮点数
o	八进制整数，小写字母o
x、X	十六进制整数，x是小写表示，X是大写表示

money = 4001.39
name = 'Mike'
s = '{0:s}年龄{1:d}，他的月薪是{2:f}元。'.format(name, 20, money)
print(s)
# print结果：Mike年龄20，他的月薪是4001.390000元。

3.5操作字符串

3.5.1 字符串查找.find()

语法: str.find(sub[, start[, end]])

表示：在索引start到end之间查找字符串sub，如果找到，则返回最左端位置的索引；如果没找到，则返回-1

注意：在Python文档中[]表示可以省略部分内容，find()方法的参数[, start[, end]]表示start和end都可以省略

s1 = "Hello World"
s1.find('e')    # 省略[,start[和end]]
# 生成结果为1，表示找到第一个参数为1
s1.find('l',4)
# 生成结果为9，表示所索引s1[9]为l
s1.find（'l',4,6）
# 生成结果为-1，表示没有找到

3.5.2 字符串替换.replace()

语法：str.replace(old, new[, count])

表示：用new字符串代替old字符串，count参数制定了替换old字符串的个数。如果count被省略，则替换所有old字符串

text = '13579 24680 13579 24680'
text.replace(' ', '|', 2)
# 生成 '13579|24680|13579 24680'
text.replace(' ', '|')
# 生成 '13579|24680|13579|24680'

3.5.3 字符串分割.split()

语法：str.split(sep=None, maxsplit=-1)

表示：使用sep子字符串分割字符串str，maxsplit是最大分割次数，如果maxsplit被省略，则不限制分割次数。

text = '1 2 3 4 5 6 7'
text.split(' ')
# 生成['1','2','3','4','5','6','7']
text.split(' ', maxsplit=0)
['1 2 3 4 5 6 7']
text.split(' ', maxsplit=2)
['1','2','3 4 5 6 7']

4. 列表[] list

可变序列类型，可以追加、插入、删除和替换列表中的元素。

4.1 创建列表

1. list(iterable)函数：函数iterable是可迭代对象（字符串、列表、元祖、集合和字典）
   1. list(‘Hello’) = [‘H’, ‘e’, ‘l’, ‘l’, ‘o’]
2. [元素1, 元素2, 元素3, …]： 指定具体的列表元素，元素之间以逗号分隔
   1. [20, 10, 50, 30]

4.2 列表追加元素

append(单个元素)
extend/+(多个元素）


example:

list = [1,2,3]
list.append(4)	#append（）函数增加一个元素
list = [1,2,3,4]
t= [5,6]
list.extend(t)	#extend（）函数增加多个元素
list = [1,2,3,4,5,6]
list += [7,8]	#加赋值运算符增加多个元素
list = [1,2,3,4,5,6,7,8]

4.3 列表插入元素

insert(i, x) i指定索引位置，x是要插入的元素，索引位置原来的元素会后移一位
PS：这个似乎只能插入数字，插入文字的尝试没有成功。


example:

list = [1, 2, 3]
list. insert(1, 9) #在索引[1]的位置（原来元素是2）插入9
list = [1, 9, 2, 3]

4.4 列表替换元素

用赋值符号（=）替换索引元素的符号


example：

list=[1, 2, 3]
list[1]=20
list[1, 20, 3]

4.5 列表删除元素

remove(元素)移除第一个匹配到的元素


example:

list=[1, 2, 3]
list.remove(2)
list= [1, 3]

5. 元组 () tuple

不可变的序列类型。

5.1 创建元组/元组打包

1. tuple(iterable)函数：可迭代对象（字符串、列表、元组、集合和字典等）
   1. tuple([1,2,3,4])
2. 制定的元祖元素
   1. a = 1, 3, 4 形成元组(1, 3, 4)
   2. a = 1, 形成元组 (1,) 单元素元组时，逗号绝不可省略
3. 可创建空元组()

5.2 元组拆包

将元组中的元素取出，分别赋值给不同的变量。


Example:

s_id, s_name = (102, "Mike")
s_id = 102
s_name = "Mike"	

6. 集合 {} set

序列中的集合是有序的，可重复的；集合是无序的，不可重复的
集合（set）是一种可迭代的、无序的、不能包含重复元素的容器数据的类型。

6.1 创建集合

set(iterable)函数
{元素1, 元素2, 元素3, …}


Example

set("Hello") 
{'o', 'H', 'e', 'l'}
{1, 2, 3, 3}

6.2 修改集合

类似修改列表
add(elem): add an element that not yet exist
remove(elem): remove an existed element otherwise it will make bug
clear(): 清除集合

s_set = {'one', 'two', 'three'}
s_set.add('four')	#此时set为{'one','two','three','four'}
s_set.remove('two')	#此时set为{'one','three','four'}
s_set.clear()
# 此时s_set = set ()，集合内的符号串均已消除

7. 字典{} dict

Python字典能将相关信息关联起来，可以自由的储存、访问和修改。理解字典之后，就能够更准确地为各种真实物体建模。
字典（dict）是可迭代的，通过键（key）来访问元素的可变的容器类型的数据。
由两部分视图构成：
键视图key：不能包含重复的元素，key和value是成对出现的
值视图value：能包含重复的存在

7.1 创建字典

1. dict（）函数
2. {key1:value1, key2:value2, key3:value3, …, key_n:value_n}

dict和集合的区别：key和value之间的：

# 四种生成同样字典的方式
# 1.直接输入{key:value的}数据
dict({1:'one',2:'two',3:'three'})	
# 2. 用函数（）输入元组（key，value）的数据
dict(((1,'one'),(2,'two'),(3，'three')))	
# 3. 用列表[]输入元组（key,value)的数据
dict（[(1,'one'),(2,'two'),(3,'three')]）
# 4. 用zip()函数将两个可迭代对象打包成两个元组，并一一对应。
dict(zip([1,2,3],['one','two','three']))
#最终都生成dict字典
{1:'one', 2:'two', 3:'three'}

7.2 访问字典

items() 返回字典的所有键值对视图
keys() 返回字典键视图
values() 返回字典值视图

dict1 = {1:'one',2:'two',3:'three'}
dict1.items()
dict_items([(1,'one'),(2,'two'),(3,'three')])	#这行为运行结果
dict1.keys()
dict_keys([1,2,3])	#这行为运行结果
dict1.values()
dict_values(['one','two','three'])
list(dict_items())
[(1,'one'),(2,'two'),(3,'three')]	#此行为运行结果，用list()函数返回键值对照表
#访问相关键的值
print(dict1[1]) #将会打印 one
number = dict1[1]
print(f"you are the only {number} person in the room") #将字典相应键位的值赋予变量number，再打印出来

7.3 遍历字典

所谓遍历(Traversal)，是指沿着某条搜索路线，依次对树（或图）中每个节点均做一次访问。访问结点所做的操作依赖于具体的应用问题， 具体的访问操作可能是检查节点的值、更新节点的值等。不同的遍历方式，其访问节点的顺序是不一样的。遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。

# 待完善，使用print for，以及keys(),values()函数

7.4 添加、修改键值对

直接用赋值号=

dict1 [4] = "four"
dict1 [5] = "five"
print (dict1)
{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'} #print输出
dict1 [1] = "Una" #修改键值对的值

7.5 删除键值对

使用del语句指明字典名和要删除的键<br / >删除的键对会永远消失

del dict1[1]
print(dict1)
{2: 'two', 3: 'three', 4: 'four', 5: 'five'} #print输出

7.6 用get()访问值

get()的第一个参数用于指定键，是必不可少的；第二个参数为指定键不存在时要返回的值，是可选的：
如果没有指定第二参数，Python将返回值None，表示所需值不存在。
如果指定的键有可能不存在，应考虑使用方法get()，而不要使用方括号表示法。

alien_0 = {'color':'green', 'speed':'slow'}
point_value = aliend_0.get('points', 'No point value assigned.')
print(point_value)
No point value assigned #print output

8. 参考资料

《看漫画学Python》第3章、第6章、第7章
《Python教程：从入门到实践》第2章、第3章、第6章