python 数据类型
Python中的数据结构的说明
在Python中，不需要提前声明，当给一个变量赋值的时候就会创建这个值所对应的数据类型。并且变量出现在表达式中的时候就会用其值替换。所以在使用变量的值之前必须对其赋值
类型通用法则：可作用于多种类型的通用型操作都是以内置函数或表达式的形式出现的[例如 len(X) X[0]]，类型特定的操作是以方法调用的形式出现的[例如 a.upper()]
Python的类型特点
Python是一种动态类型的语言，在程序执行过程中，变量名称会被绑定到不同的值，这些值可以属于不同的类型。例如：a = 10 赋值运算符的作用仅仅是在名称和值之间创建的一种关联。尽管每个值都有一个相关类型，如integer或string，但变量名称是无类型的，在执行过程中可以引用任意类型的数据。
整数
整型
长整型 long
在py3中已经不区分整型与长整型，统一都叫做整型，也就是说自py2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数。所以在长整数数据后面不加字母L也不会导致数据溢出的后果了，甚至Python的int可以存储任意大小的整数，甚至超过64位
浮点型 float
浮点数用来处理实数，带有小数的数字，类似于C语言中的double类型，占8个字节(64位)，其中52位表示底，11位表示指数，剩下的一位表示符号
复数Complex
复数由实数部分和虚数部分组成，一般的想形式为x+yj,x为复数的实数部分，y是复数的虚数部分，x和y都是实数
布尔类型
计算机中最基本的数据类型
布尔只有两种类型 真（True 注意 Python中的真是大写字母开头） 值 或者 假 （False） Python中的布尔是以大写字母开头
在Python中True可以用1表示，Flase用0表示
字符串
在计算机中，一切皆对象
- 字符串是任意字符的集合
- 字符串在Python中是作为序列，序列中的元素包含了一个从左到右的顺序，序列中的元素根据它们的相对位置进行存储和读取
- 字符串是单个字符的序列
- 字符串属于不可变序列这一类型
字符串操作
基本操作
-
使用str() repr() format()函数可以将非字符串值转换为字符串表示形式
* str()生成的输出与使用print语句得到的输出相同
* repr() 创建的字符串可表示程序中某个对象的精确值
`````` 使用\对一些字符进行转义
使用+进行拼接
使用*复制
使用[]提取字符
在字符串名后面添加[],并在括号里指定偏移量可以提取该位置的单个字符。第一个的字符的偏移量是0，下一个是1
>>> str = 'abcdefg'
>>> str[0]
'a'
>>> str[1]
'b'
-
序列操作
- 字符串支持对其中各个元素包含位置顺序的操作
str_file = 'span' print(len(str_file)) print(str_file[0])在Python中，索引是按照从最前面的偏移量进行编码的，也就是从0开始，第一项的索引为0,依次类推
反向索引：反向索引就是从右边开始计算，一般来说，负的索引号会简单的与字符串的长度相加。
s[-1] # 等效于 s[len(s)+(-1)] -
分片
- 所谓的分片就是一种一步就能够提取整个分片的方法就是从一个字符串中抽取子字符串的方法。
- X[I:J] 表示取出在X中从偏移量为I直到但不包括偏移量为J的内容
- 在一个分片中，左边界默认为0,又边界默认为分片序列的长度。
'''字符串分片操作''' print(str_file[1:3]) print(str_file[1:]) print(str_file[0:len(str_file)]) print(str_file[:1])- 作为一个序列字符串也支持使用加号进行合并，或者重。合并使用 ‘+’ 。重复使用 ‘*’
- [:] 提取从开头到结尾的整个字符串
- [start:] 从start提取到结尾
- [:end] 从开头提取到end-1
- [start:end] 从start提取到end-1
- [start:end:step]从start提取到end-1每step个字符提取一个
此处注意，区间不包含尾部，包头不包尾，所以为end-1
使用len()获取长度
我们可以使用字符串的len()函数获取字符串的字符数
字符串不可变性
字符串在Python中具有不可变性——在创建后不能被就地改变。在Python中 数字、字符串、元组这些数据类型是不可边的。-
字符串find
find方法是一个基本的子字符串查找的操作，它将返回一个传入子字符串的偏移量，或者没有找到的情况下返回-1- 格式：
- find(self,start,end)
- self 要查找的子字符串
- 开始的索引位置
- 结束的位置
'''字符串查找find操作'''
print(str_file.find('123', 0, 1))
- 查找最后 rfind
rfind会返回指定查找的字符串最后出现的偏移量
>>> a_z.rfind('x')
23
count返回指定字符串出现的次数
使用字符串的count方法可以返回要查找的字符的数量-
replace 全局替换
replace可以将字符串中的目标子字符串替换为新的字符串并返回替换后的全局字符串- 格式
- replace(old: str, new: str,count)
- old str 要被替换的子字符串
- new str 替换的字符串
- count 替换几次
print(str_file.replace("span", "naps"))
- splite 分割字符串
- 格式
- splite(str) 返回分割后的列表 str:分割符
- str 分割标识
'''分割字符串''' print(str_file.split('12')) - join()合并字符串
使用join()需要首先指定粘合用的字符串，然后再指定需要合并的列表
>>> crypto_list = ['a','b','c','d','e']
>>> copy_str = '.'.join(crypto_list)
>>> print(copy_str)
a.b.c.d.e
-
rsplite
- 按照指定的分隔符，并指定最大分割数
- 并且以从右边分割为准
-
大小写转换
- upper() 转换为大写
- lower() 转换为小写
- capitalize() 把第一个字母转换为大写，其余小写
- title() 把每个单词的第一个字母转换为大写，其余的小写
- swapcase()将所有字母的大小写转换,小写变大写
a_z.swapcase() 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' str_change = "hello i am hero" # 转换为大写 print(str_change.upper()) # 转换为小写 print(str_change.lower()) # 首字母大写 print(str_change.capitalize()) # 按照标题转换 所有单词首字母大写其余小写 print(str_change.title()) -
排版操作
- 居中 center() 返回一个使用指定字符填充至指定长度的的新字符串
>>> test_a = 'abc'
test_a.center(10,'x')
'xxxabcxxxx'
* 左对齐 ljust(width,fillchar) 返回一个使用指定字符串填充至指定长度的左对齐的新字符串
test_a.ljust(20,'v')
'abcvvvvvvvvvvvvvvvvv'
* 右对齐 rjust(width,fillchar)返回一个使用指定字符串填充至指定长度的右对齐的新字符串
test_a.rjust(20,'c')
'cccccccccccccccccabc'
* 占位符操作
'''占位符'''
print('%s , is ,%s,a ,str' % ('a', 'b'))
* 字符串包含在单引号或者是双引号中代表相同的东西，字符串包含在三引号中是，所有的行都合并在一起，并在每一行的末尾增加换行符
* 去掉反斜线raw
python支持原始字符串常量，即去掉反斜线转义机制
* 模式匹配
* 字符串模式匹配使用正则表达式需要导入一个re的模块。
import re
match = re.match(格式);
mathc.group(1)
* 判断子字符串是否存在
if '123' in '123abc':
print('yes')
* join拼接
str.join(str1)
* join的参数是一个iterable 可以使用列表 元组
* 将str拼接到str1的每一项后面
a = 'a'
b = a.join("1234567")
print(b)
输出结果
1a2a3a4a5a6a7
* 填充字符
center 以指定的字符填充到字符数
a = 'abcde'
print(a.center(20, '*'))
结果
*******abcde********
* 判断是否以某个内容结尾
endwith(str)
print(a.endswith('e'))
* 判断是否以某个内容开头
* startWith(str)
print(a.startswith('a'))
* 格式化输出 format
a = 'my name is {name}'
print(a.format(name='kkk'))
输出结果
my name is kkk
* 字典形式 format_map
a = 'my name is {name}{age}'
print(a.format_map({'name': 'wx', 'age': 22}))
* isalnum() 判断字符串是否是字母或者数字的字符串
* isdecimal() 判断是否是10进制的数
* isdigit() 判断是否是一个数
* islower() 判断是否全部小写
* isupper() 判断是否全部大写
* isspace() 是否全部是空格
* lower() 大写变小写
* upper() 小写变大写
* swipecase() 大写变小写 小写变大写 反转
* strip() 去掉两端的空格和换行符
* rfind(str) 找到从右开始的第一个str的真实索引值
*
#### 列表
* 列表是一个任意类型的对象的位置相关的有序集合。是序列的一种
* 没有固定大小
* 支持字符串序列的所有操作，返回的结果往往还是列表，支持索引，切片等操作
* Python的列表没有固定类型的约束，一个列表中可以存在多种数据类型的元素
* 由于列表没有固定大小，所以Python会对列表进行边界的检查
* 列表可以修改
L = [1, 2, 3, 4, 5]
print(L[0])
print(L[:-1])
print(L + [6, 7, 8])
print(L + ['aaa', 'bbb'])
##### 列表类型特定的操作
> 列表的特定操作都会就地改变列表对象，而不是创建一个新的列表
* append 在列表的末尾增加一个数据项
append扩充列表的大小并在列表的尾部插入一项元素
L.append('abc')
print(L)
* extend 在列表末尾增加一个数据集合
list = ['a', 'b', 'c']
list.extend(['d', 'e', 'f'])
print(list)
* pop
pop移除给定偏移量的一项，从而减小列表大小,不指定索引将会删除最后一个数据:pop(0)将返回列表元素的头部，pop()或pop(-1)则会返回列表的尾部元素
L.pop(2)
print(L)
* insert
在列表指定偏移量出插入元素
L.insert(1, True)
print(L)
* index() 查询具有特定值得元素位置
list = ['aaa','bbb','ccc','ddd']
list.index('aaa')
0
* 使用in判断值是否存在
可以使用in来判断是否存在在指定的列表中
'bbb' in list
True
* remove
按照指定值删除元素
L.remove("abc")
print(L)
* count 记录特定值出现的次数
list.count('aaa')
2
* sort
按照升序对列表进行排序，返回一个新的列表，会对原列表进行排序，会改变原列表的内容
L.sort()
降序
ks.sort(reverse=False) # 默认false
* sorted会返回排好序的列表副本，原列表内容不变
list_sorted = sorted(list)
list_sorted
['aaa', 'aaa', 'bbb', 'ccc', 'ddd']
* 改变排序行为
我们可以指定sort的排序行为，我们可以使用name=value
* reverse 允许排序按照降序而不是升序进行
```
L = ['abc','abC','ABC']
L.sort(key=str.lower)
```
> 在Python3中，不再支持这种排序，所以建议使用内置的sorted方法
list = ['abc', 'Abc', 'ABC']
print(sorted(list, key=str.upper, reverse=False))
* reverse
对列表进行翻转
L.reverse()
* clear()
清除列表所有数据，但并不删除列表
* del 列表[index] 删除列表(直接删除内存地址的指向)
##### 列表的嵌套
由于列表支持任意的嵌套，能够以任意的组合对其进行嵌套，并可以多个层次进行嵌套。可以实现多维数组等复杂数据类型
##### 列表的解析
* 先来一个2*2的矩阵
LL = [[1, 2], [3, 4]]
* 运用列表解析表达式 取出第一行数据
col = [row[1] for row in LL]
> 列表表达式是一种通过对序列中的每一项运行一个表达式来创建一个新列表的方法，每次一个从左到右。
> 列表解析是卸载方括号中的，并且由使用了同一个变量名的表达式和循环结构组成
#### 字典
* Python中的字典是一种映射。映射是一个其他对象的集合。通过键来进行存储
* 字典是Python核心对象集合中唯一的一种映射类型。也具有可变性
* 格式
* directory = {"key",value,"key2","value2"}
* 保存在字典中的项没有特定的顺序，Python字典采用最优化的散列算法来寻找键，因此搜索是很快速的。
##### 映射操作
* 作为常量编写时，字典编写在大括号中，并且包含一系列的“键：值”对
D = {'name': 'wx', 'age': 12, 'phone': 1366666666}
我们可以通过索引来操作字典，通过索引操作使用的是和序列相同的语法，在方括号中填写的是元素的键，而不是相对位置索引
print(D['name'])
##### 字典的创建方式
1
D = {}
D['name'] = 'hello'
D['age'] = 20
D['phone'] = 123456
print(D)
2 函数
dic2 = dict((('key','value'),))
3. 创建时初始化值
dic_test = dic.fromkeys(存放所有的键，对应键的值)
dic_test = dic.fromkeys(['a','b','c'],0)
输出结果
{'a': 0, 'b': 0, 'c': 0}
##### 添加内容方式
setDefault 在key不存在的情况下会添加key-value的默认值，如果key存在则不会修改，并且会返回已有的值
如果key不存在的情况，在字典里增加键值对并返回相应的值
setdefault('key','value'
* 使用[key]添加或修改元素
向字典中添加元素只需指定该元素的键并赋予相应的值即可。如果该元素的键已经存在于字典中，那么该键对应的旧值会被新值取代。如果该元素的键并未在字典中出现，则会被加入到字典中
pyhons
{'cleese': 'john', 'chapman': 'graham', 'idle': 'eric'}
pyhons['wx']='niubi'
pyhons
{'cleese': 'john', 'chapman': 'graham', 'idle': 'eric', 'wx': 'niubi'}
pyhons
{'cleese': 'john', 'chapman': 'graham', 'idle': 'eric', 'wx': 'niubi'}
pyhons['chapman']='ahahaha'
pyhons
{'cleese': 'john', 'chapman': 'ahahaha', 'idle': 'eric', 'wx': 'niubi'}
* 字典的键必须不相同，如果创建字典时同一个键出现了两次，后面出现的值会取代之前的值
##### 查
1. 通过键去查找 keys() 获取的字典的key也是无序的
dict_a = dict((('a', 'b'), ('c', 'd')))
print(dict_a['a'])
2. 查找所有对应的值 value(),会返回字典所有的值
pyhons.values()
dict_values(['john', 'ahahaha', 'eric', 'niubi'])
3. 查找所有的元素 items(),可以获取字典中所有的键值对
dict_a = dict((('a', 'b'), ('c', 'd')))
print(dict_a.items())
> 以上3中查找元素的方法在Python3.0中已经被修改为返回一个可迭代的对象，而不是列表，所以在Python3.0中使用的时候需要将可迭代对象转换为列表
dict_a = {'a': 'b', 'c': 'd', 'e': 'f', 'h': 'g'}
print(list(dict_a.keys()))
print(list(dict_a.values()))
print(list(dict_a.items()))
4.通过get()方法避免misskey错误
在字典中可以通过get(key,default)来获取指定Key对应的value值，如果key不存在则返回默认值default
dic = {'a':'b','c':'d'}
print(dic.get('a','default'))
4. 查看列表的长度 len()
len()是内置方法，同样适用于字典，len()会返回字典的元素数目或者是keys集合的长度
##### 改
* 通过键修改
dict_a = dict((('a', 'b'), ('c', 'd')))
dict_a['a'] = 22
print(dict_a)
* update可以将一个字典的键值对复制到另一个字典中去方法指定具体的键值，如果键值不存在则增加这个键值对，如果键存在则修改更新这个值
* 格式
```
a.update(b) 将b字典合并到a字典中
```
c_pro = {'type':'language','hard':1}
pyhons.update(c_pro)
pyhons
{'cleese': 'john', 'chapman': 'ahahaha', 'idle': 'eric', 'wx': 'niubi', 'type': 'language', 'hard': 1}
* setdefault(k,v) 如果找到字典中的k键对应的值则返回，否则返回v 并将字典中k键对应的值设置为v
print(dic.setdefault('aa', 0))
print(dic)
{'a': '1', 'b': 'abcdef', 'c': 1234, 'aa': 0}
##### 删
1. clear() 删除字典所有元素
> 使用clear()可以将字典中所有元素删除
dirc_a.clear()
2. 删除字典某一个键对应的值 del
del dic4[键名]
3.删除指定键值对并返回该键值对的值，如果不指定会删除最后一个，并返回删除的这个值
dict_a.pop(key)
4.随机删除一个
dict_a.popitem()
5. 删除整个字典
del dict_a
#### 查
##### 字典重访嵌套
human_info = {'name': {'last': 'wx', 'first': 'xw'}, 'age': 18, 'age': 40.5,
unit: {'abc': 123, '1': '234', True: False}}
print(human_info[unit])
print(human_info[unit]['1'])
##### 字典的遍历
> 字典不是序列，并不包含任何可靠的从左到右的顺序，但是如果希望字典的键是顺序的
可以通过字典的keys方法收集一个键的数据，有点像但并不是列表，然后使用sort进行排序
dir_keytest = {'a': 1, 'e': 2, 'c': 3, 'd': 4}
ks = list(dir_keytest.keys())
ks.sort()
print(ks)
* 在新版的Python中，可以使用最新的sorted调用返回结果并对各种对象类型进行排序
key_list = sorted(dir_keytest)
for i in key_list:
print(i)
##### 查询字典中的键是否存在
* 查询字典中的一个键是否存在
* 格式
* 键值 in 字典
> 在3.0中已经取消了2.x中的判断一个键在字典中是否存在的has_key方法，而在3.0中使用in来判断键是否在字典中存在
if 'f' in D:
print('键值存在')
else:
print('键值不存在')
* python 2.x has_key
在python2.x中存在has_key方法用于判断字典中的指定的键是否存在，但这个方法在python3中不可用
##### 使用[key]获取元素
可以指定字典名称和键名即可获得对应的值
* 格式
dict[key]
##### 使用get()获取键
可以使用get(键)获取键在字典中的值，#如果指定了可选值，那么get()函数将返回这个可选值，否则会返回None
pyhons.get('wx')
'niubi'
pythons.get('cleesea','123')
'123'
##### 使用keys()获取所有的键
使用keys()可以获得字典中的所有键,keys()会返回一个列表。python3中会返回dict_key(),是键的迭代形式，这种形式不需要时间和空间来创建返回的列表,在python2中会返回一个列表
pythons.keys()
dict_keys(['cleese', 'chapman', 'idle', 'wx', 'type', 'hard'])
##### 使用items() 返回由(key,values)对组成的一个序列
#### 元组
* 元组是任意对象的有序集合
* **不可改变的列表，也就意味着长度不能增长或者缩短**
* 元组是序列，具有不可变性
* 编写在圆括号中，支持任意类型任意嵌套以及常见的序列操作
* 格式
* tupple = (item1,item2)
* 创建包含一个或多个元素的元组时，每一个元素后面都需要跟一个逗号，即使只包含一个元素也不能省略
one_marx = 'abcde',
type(one_marx)
<class 'tuple'>
one_marx
('abcde',)
##### 特定类型方法
* 在Python3中，元组有特定的方法
* index(i) 获取指定元素的索引
* count(i) 获取指定元素在元组中的个数
##### 创建
* 直接创建
tumple_test = (1,2,3,4,5)
* 通过可迭代对象创建
tuple_Test = tuple('1234')
print(tuple_Test)
* 如果圆括号内的单一对象是元组对象而不是简单的表达式需要对Python进行说明，需要在这个元素后，关闭括号之前加入一个，（逗号）
x = (40)
out
40 # int type
x = (40,)
out
(40,) #tuple type
##### 元组解包
我们可以一口气将元组赋值给多个变量，这样的操作我们称为元组解包,这个解包中接收的变量要和元组的元素相等
list_sorted
['aaa', 'aaa', 'bbb', 'ccc', 'ddd']
a,b,c,d,e = list_sorted
a
'aaa'
b
'aaa'
c
'bbb'
d
'ccc'
e
'ddd'
###### 增
* 通过序列操作扩充元组
(1,2)+(3,4)
out
(1,2,3,4)
> 由于元组不可变，所以通过序列的操作会返回一个新的元组
> 元组不支持字符串和列表的方法，如果需要使用使用需要将元组转换为列表
* 对元组排序
tuple_sort = (3, 5, 6, 4, 2, 1, 5, 6)
list = list(tuple_sort)
print(sorted(list))
### 文件类型
* 文件对象是Python对外部文件的主要接口
* 没有特定的常量语法创建文件
* 需要调用内置的open函数以字符串的形式传递给它一个外部的文件名以及一个处理模式的字符串
* 在当前文件夹下创建文件，并向它写入文本
* ‘w’ 写文件 ‘r’ 读文件 默认读取
f = open('data.txt', 'w')
f.write("hello\n")
f.write("hi\n")
f.write("how are you\n")
f.close()
* 读取文件
f = open('data.txt', 'r')
text = f.read()
print(text)
### 集合
* 集合是唯一的不可变的对象的无序集合。集合是无序的，也无法通过数字进行索引。集合中的元素不能重复
* 集合不提供索引或切片操作，也不存在相关的键值
* 集合通过调用内置set函数创建
* 可变集合set是非哈希的，不能用作字典的键
* 集合的元素都是不同的，相同的元素会只保留一个
* 集合分为两种集合：set是可变集合，frozenset不可变集合，不可以添加删除
#### 创建方式：
x = set('ABCabc')
Y = {'a', 'b', 'c'}
print(x, Y)
* 将字典作为参数传入set()函数时只有键会被使用
#### 向集合中添加新项
使用add()或update()可以在集合中添加新项
s = set([3, 5, 9, 1, 2, 7])
使用add向集合添加新项
s.add(20)
print(s)
使用update向集合中添加新项
s.update([22])
print(s)
* add向集合中添加一项
* update(iterable) 向集合中添加多项，这里添加的是可迭代的对象
#### 使用in测试值是否在集合中存在
* 交集 intersection **&** 返回两个集合相同的部分
s = set([1,2,3,4,5,6])
s1 = set([5,6,7,8,9,0])
s.intersection(s1)
s&s1
* 并集 union **|**
s = set([1,2,3,4,5,6])
s1 = set([5,6,7,8,9,0])
s.union(s1)
s | s1
* 差集 **-**
s = set([1,2,3,4,5,6])
s1 = set([5,6,7,8,9,0])
s.difference(s1)
s-s1
* 对称差集 (项在t或者s中，但不会同时出现在二者中) **^**
s1=set([1,2,3,4,5])
s2=set([2,3,4,5,6])
print(s1.symmetric_difference(s2))
s1^s2
* 父集 超集 **a>=b**
print(a.issuperset(b))
a>=b
* 子集 **a<=b**
a.issubset(b)
a <= b
### 数字
python中的数字分为
* 整数和浮点数
* 复数
* 固定精度的十进制数
* 有理分数
* 集合
* 布尔类型
* 无穷的整数精度
* 各种数字内置函数和模块
### Python中的进制表示
* Python一般以10位基数也就是10进制的记数法来记录数字
* 各种进制的格式
* 十六进制 0xff
* 八进制 0o 或者0O 0o1
* 二进制 0b
* python提供了转换为其它进制字符串的内置函数
* oct 将十进制转换为八进制
* hex 将十进制转换为十六进制
* bin 将十进制转换为二进制
* int 将一个数字的字符串变换为一个整数，并且可以通过第二个参数来确定变换后的进制
```
int('64',16) 将表示64的字符串表示为2进制的整数
```
## 可变与不可变对象分类
