python基础学习之数据类型

数据类型（一）

一、基本类型：数值

（一）整数类型：int

1. 特点：不限制大小，无论多复杂的算式都可以直接得到结果

2. 常见运算
   

3. 连续比较大小
   注意：只会输出 True or False

7 > 3 >= 3
True
12 < 23 < 22
False

4. 数的进制

注意：同一个数可以用不同的进制来体现，在python语言中可以直接用二进制＼八进制＼十六进制，来表示整数，只要加一个前缀用以标识几进制即可

（二）浮点数类型

1. 操作与整数类似
2. 浮点数受到17位有效数字的限制，通常用科学计数法来呈现
3. 进制转换会导致误差，大小比较或者相等判断时，只要误差小于一个数，就可以说它们是相等的

4.2 + 2.1 == 6.3
False
4.2 + 2.1
6.300000000000001

（三）复数类型

1. 复数支持所有常见计算，在python中避免与1混淆，用j来代替i（eg. 1+3j)
2. 复数之间只能比较是否相等,不能比大小

（四）更多数学函数：math模块&cmath模块

math模块中的数学函数只能用于计算整数和浮点数，cmath模块专门面向复数计算

二、基本类型：逻辑值

（一）判断与真值

1. 逻辑（bool) 类型
   逻辑值仅包括真（True) /假 (False) 两个
   用来配合if / while 等语句做条件判断

（二）逻辑运算: "与"and、"或"or、"非"not

1. and 连接的两个真值需要同时为真，计算结果才为真，相当于“乘法”
2. or 连接的两个真值只要有一个为真，计算结果就为真，相当于“加法”
3. not 连接的一个真值，非真为假，非假为真，属单目运算符，相当于“负号”
4. 优先级为：not 最高，and 次之，or 最低

（三） 各种类型对应的真值

1. 整数、浮点数、复数类型：
   0 是 “假” ，所有 非 0 得数值都是 “真”
2. 字符串类型：
   空串（“”）是 假 ，所有非空串都是 “真”
3. 所有序列类型（包括字符串）：
   空序列是 “假” ，所有非空序列都是 “真”
4. 空值 None ：
   表示“无意义”、“不知道”，也是 “假”

三、基本类型：字符串

（一） 文本的表示

1. 字符串就是把一个个文字的字符“串”起来的数据
   文字字符包含有：拉丁文字母、数字、标点符号、特殊字符及各种语言文字字符等

2. 表示字符串数值：
   成对的单引号（’ '）或双引号（" "）
   多行字符串用三个连续的单引号表示

3. 特殊字符用转义符号” \ “表示
   

4. 字符的编号：
   由 0 开始依次表示，也可从倒数开始第一个字符 -1 开始编号
   用这种整数编号可以从字符串中抽取出任何一个字符

（二）字符串和名字的区别

1. 字符串是数据本身
2. 名字是数据的标签
3. 名字和字符串是”名“ 和 ”值“ 之间的关系：
   一个字符串数值可以关联多个名字，但是一个名字在同一时刻只能关联一个字符串数值
   字符串数值只能是字符串类型，名字可以关联任意类型的数值

（三）常见的字符串操作

1. 获取字符串的长度： len（）函数
2. 切片（slice）操作： s[start : end : step] (左开右闭）
   注意： 在python中，list, tuple以及字符串等可以遍历访问的类型都可以应用slice访问

3. 加法 + ：拼接两个字符串，得到新字符串；
   乘法*：将字符串重复若干次，得到新字符串
4. 判断字符串内容是否相同： ==
   判断字符串中是否包含某个字符串： in
5. 删除空格：
   str.strip 去掉字符串前后所有空格，内部空格不受影响
   str.lstrip 去掉字符串前部（左部）的所有空格
   str.rstrip 去掉字符串前部（左部）的所有空格
6. 判断字母数字
   str.isalpha：判断字符串是否全部由字母构成
   str.isdigit： 判断字符串是否全部由数字构成
   str,isalnum： 判断字符串是否仅包含字母和数字，而不包含特殊字符

（四）字符串的高级操作

1. split：分割；join：合并
2. upper/lower/swapcase：大小写相关
3. ljust/center/rjust：排版左中右对齐
4. replace：替换子串

'you are my sunshine.'.split(' ')
['you', 'are', 'my', 'sunshine.']
'-'.join(["one", "for", "two"])
'one-for-two'
'abc'.upper()
'ABC'
'aBC'.lower()
'abc'
'Abc'.swapcase()
'aBC'
'hello world'.center(20)
'    hello world     '
'Tom smiled,Tom cried,Tom shouted'.replace('Tom', 'Jane')
'Jane smiled,Jane cried,Jane shouted'

（五）字符串是一种序列

1. 序列：能够按照整数顺序排列的数据
2. 序列的内部结构：
   ① 可以通过从 0 开始的连续整数来索引单个对象；
   ② 可以执行切片操作，获取序列的一部分；
   ③ 可以通过 len 函数来获取序列中包含多少元素；
   ④ 可以用 “ + ” 来进行连接，得到更长的序列；
   ⑤ 可以用 “ * ”来从复多次，得到更长的序列；
   ⑥ 可以用 “ in ”来判断某个袁术是否在序列中存在。

数据类型（二）

一、容器类型：列表和元组

（一）数据收纳盒

1. 用来收纳数据对象的数据类型
2. 以一种规则的下标索引方式（收纳盒名字+数字序号）访问到每个数据
3. 这种收纳盒是一种序列(从0开始排序的序列）
4. 列表可以删除、添加、替换、重排序列中的元素（可变类型）
5. 元组是不能再更新（不可变） 序列
   元组在保留列表大多数功能的同时，去掉了一些灵活性以换取更高的处理性能

（二）列表和元组的创建

1. 创建列表
   方括号法[ ]，指明类型法list( )
2. 创建元组
   圆括号法( )，指明类型法tuple( )
3. 列表或元组中保存的各个数据称作元素(element)，类型没有限制

（三） 列表和元组的操作

列表的操作：增长/缩减

1. 增长列表
   append操作/insert操作/extend操作
2. 缩减列表
   pop操作/remove操作/clear操作
3. 列表是一种可变容器，可以随意增减
4. 但并不是所有的数据容器都能像列表这样可以继续添加新元素

列表的操作：重新组织

1. reverse/sort操作
   reverse：把列表中的数据元素头尾反转重新排列
   sort：把列表中的数据元素按照大小顺序重新排列
2. reversed/sorted操作
   得到重新排列的列表，而不影响原来的列表

num = [1,2,7,4,3,9,0]
num.reverse()
num
[0, 9, 3, 4, 7, 2, 1]
num.sort()
num
[0, 1, 2, 3, 4, 7, 9]
num.sort(reverse = True)
num
[9, 7, 4, 3, 2, 1, 0]

列表和元组的操作

1. 合并
   加法运算+：连接两个列表／元组
   乘法运算*：复制n次，生成新列表／元组
2. 列表/元组大小
   len( )：列表／元组中元素的个数
3. 索引
   列表：alist [n]或 元组 atuple [n]
   可以用赋值语句给列表中的任何一个位置重新赋值
   但元组属于不可变类型，索引只能获取对应位置中的数据值，不可重新赋值
4. 切片
   alist [start : end : step]
   atuple [start : end : step]
5. 查找
   in操作：判断某个元素是否存在于列表/元组中
   index操作：指定的数据在列表/元组的哪个位置
   count操作：指定的数据在列表/元组中出现过几次
6. 计算
   sum函数：将列表中所有的数据元素累加
   min/max函数：返回列表中最小/最大的数据元素

二、容器类型：字典

（一）贴标签的数据

1. “标签收纳盒” ：给数据贴上标签，就可以通过具有特定含义的名字或者别的记号来获取数据
2. 现实生活中的字典：通过标签（或者关键字）来索引数据，区别于列表或元组通过连续的整数来索引
3. 标签（key）和数据值（value）
   字典容器中保存着一系列的key-value对通过键值key来索引元素value

（二）创建一个字典

1. 花括号法和指明类型法：
   student = { } 和 student = dict（）
2. 数据向、项（item）
   字典中保存的各个标签-数据值（key - value）
   标签和数据值之间用冒号 ： 连接，组成一个数据项
3. 批量添加数据项： student = dict.fromkeys((‘name’, ‘age’))
4. 字典是可变类型，可以添加、删除、替换元素
5. 字典中的元素value没有顺序，可以是任意类型，甚至也可以是字典
6. 字典的键值key可以是任意不可变类型（数值／字符串／元组）
   例如:用元组来作为坐标，索引元素

bands={'CK':['Moe','Curly'],'KK':[True,'moon']}
bands['KK'][1]   # 检索kk中的第一个元素
'moon'
poi={(100,100):'zhongguancun',(123,123):'pizza'}
poi[(100,100)]
'zhongguancun'

（三）更新一个字典

1. 合并字典：update 方法
2. 增长字典：“关联”操作
   update操作：以key=value的形式批量添加数据项
3. 缩减字典：
   del操作：删除指定标签的数据项
   pop操作：删除指定标签的数据项并返回数据值
   popitem操作：删除并返回任意一个数据项
   clear操作：清空字典
4. 字典大小：len函数

（四）访问字典的数据项

1. 标签索引：dict [key] (也可以用 get())
   获取字典中指定标签的数据值
   更新指定标签的数据项
2. 获取字典的标签、数据值和数据项
   keys函数：返回字典中的所有标签；
   values函数：返回字典中的所有数据值；
   items函数：将每个数据项表示为二元元组，返回所有的数据项

（五）在字典中查找

1. in操作
   判断字典中是否存在某个标签
2. in操作和values函数的组合
   判断字典中是否存在某个数据值

三、容器类型：集合

（一）标签的容器

1. “标签袋” 通过改造字典类型，去掉关联数据值，只留下标签的新容器类型
2. 集合是不重复元素的无序组合

（二）创建一个集合

1. 创建集合：{ } 或者 set()
   用set()创建空集
   可用set()从其它序列转换生成集合
2. 集合会自动忽略重复的数据
3. 集合中不能加入可变类型数据
4. 增长集合
   add：添加一个数据
   update：批量添加数据
5. 缩减集合
   remove/discard：删除
6. 指定数据
   pop：删除任意数据并返回值
   clear：清空集合
7. 集合大小
   len函数

（三）访问集合中的元素

1. in：判断元素是否属于集合
2. pop：
   删除数据元素的同时，返回它的值
   取遍所有数据元素之后，集合成为一个空集
   可以用copy操作先给集合制作一个“替身”
3. 迭代循环
   for a in aset:

（四）集合的运算

1. 生成新集合的运算
   
   (注意：对称差就是把a-b和b-a合并在一起）
2. 关系判定
   <=,=,>：子集/真子集/超集（>=)/真超集(>)
3. 交集
   isdisjoint()：两集合交集是否为空

（五）什么时候用集合

1. 快速去除重复的数据项
   154, 233, 432, 154, 236, 213, 342,
   432, 236, 332, 321, 243, 319, 326,
   324, 321, 163, 183, 235,…
2. 判断元素是否在一组数据中，如果这 些数据的次序不重要，使用集合可以
   获得比列表更好的性能
   如，325是否在上述的一组数据中？

四、可变类型和不可变类型

（一）数据收纳的灵活性

1. 列表：可长，可短的积木式收纳盒（有序、可变）
2. 元组：固定长度的收纳盒（有序、不可变）

（二）数据类型

1. 不可变类型：一旦创建就无法修改数据值得数据类型：
   ① 基本数据类型：整数int、浮点数float、复数complex、字符串str、逻辑值bool；
   ② 容器数据类型：元组tuple
2. 可变类型：可以随时改变的数据类型：
   列表list、字典dict、集合set
   灵活性强会花费一些计算或者存储的代价去维持这些强大的功能

（三）可变类型的变量引用

可变类型的引用特性：可变类型的变量操作需要注意，多个变量通过赋值引用同一个可变类型对象时，通过其中任何一个变量改变了可变类型对象，其他变量也随之改变

>>> a = [1,2,3,4]
>>> a
[1, 2, 3, 4]
>>> b = a
>>> b
[1, 2, 3, 4]
>>> id(a)     # 获取 变量 a 的内存地址
6232360
>>> id(b)     # 获取 变量 b 的内存地址，均指向同一个地址
6232360
>>> a[0] = 'Hello'
>>> a
['Hello', 2, 3, 4]
>>> b
['Hello', 2, 3, 4]             
# 通过a 改变列表第一个元素，b 变量也随之改变

五、建立复杂的数据结构

（一）比较几种数据结构

1. 使用方括号[]创建列表
2. 使用圆括号()创建元组
3. 使用花括号{}创建字典
4. 每种类型中，都可以通过方括号[ ]对单个元素进行访问
   对于列表和元组，方括号里是整型的偏移量，即索引
   对于字典，方括号里的是键**（key)**
   都返回元素的值

（二）建立大型数据结构

1. 将这些内置的数据结构自由地组合成更大、更复杂的结构
2. 创建自定义数据结构的过程中，唯一的限制来自于这些内置数据类型本身

建立3个不同的列表
alist = [1,2,3]
blist = ['Hello', 'python']
clist = [True, False]

嵌套列表 / 元组
list_of_list = [[1,2,3], ['Hello', 'python'], [True, False]]  # 列表嵌套列表
tuple_of_list = ([1,2,3], ['Hello', 'python'], [True, False])  # 元组嵌套列表

列表嵌套，元素可以进行复制修改
>>> list_of_list[1][1]
'python'
>>> list_of_list[1][1] = 'world'
>>> list_of_list[1][1]
'world'

元组嵌套，可以对其中的列表进行修改，不能对元组本身进行修改
>>> tuple_of_list = ([1,2,3], ['Hello', 'python'], [True, False])
>>> tuple_of_list[1][1]
'python'
① 对列表元素的子元素进行修改
>>> tuple_of_list[1][1] = 'world'
>>> tuple_of_list[1][1]
'world'
② 尝试对元组本身元素进行修改，出现异常！    
>>> tuple_of_list[1]
['Hello', 'world']
>>> tuple_of_list[1] = 'abc'
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    tuple_of_list[1] = 'abc'
TypeError: 'tuple' object does not support item assignment

嵌套字典
>>> dict_of_lists = {'num':[1, 2, 3], 'word':['hello', 'python'], 'bool':[True, False]}
>>> dict_of_lists['word']
['hello', 'python']
>>> dict_of_lists['word'][1]
'python'
>>> dict_of_lists['word'][1] = 'world'
>>> dict_of_lists['word']
['hello', 'world']

3. 字典的元素（值value）可以是任意类型，甚至也可以是字典
4. 字典的键 （key）可以是任意不可变类型
   例如用元组来作为坐标，索引元素

六、输入和输出（input/print)

（一）来料加工：input函数

1. input(prompt)
   显示提示信息prompt，由用户输入内容
2. input()返回值是字符串
   通过int()函数将字符串类型强制转换为整数类型

x = input('x:')
x:5
y = input('y:')
y:6
x + y
'56'

x = input('x:')
x:5
y = input('y:')
y:6
int(x) + int(y)   # 整数相加
11

（二）产品展示：print函数

1. 打印各变量的值输出
   print ([object,…] [,sep=‘ ‘] [,end=‘\n’] [,file=sys.stdout])
   sep：表示变量之间用什么字符串隔开，缺省是空格
   end：表示以这个字符串结尾，缺省为换行
   file：指定了文本将要发送到的文件、标准流或其它类似的
   文件的对象；默认是sys.stdout

（三）格式化字符串

1. print函数默认把对象打印到stdout流，并 且添加了一些自动的格式化(可以自定义分隔符和行末符）
2. 格式化字符串
   ‘%d %s’ % (v1, v2)

yname = input('please input your name')
please input your nameTom Hanks
yname
'Tom Hanks'
print (1,23,'hello')
1 23 hello
print (1,23,'hello', end='')
1 23 hello
print (1,23,'hello', sep=',')
1,23,hello
'%d %s' % (23,'hello')  # 就是把后面的元素代入到d 和 s
'23 hello'
'%d' % (23,)
'23'
'(%4d):K:%s' % (12,'hello')  # 4表示前面的括号内要占据4个字符，不够的话就空格
'(  12):K:hello'
'(%04d):K:%10s' % (12, 'hello') 
# 04表示前面的括号内要占据4个字符，不够的话就用0代替
'(0012):K:     hello'
# 10表示后面要占据10个字符，不够的话用空格代替