python的数据类型

• 二进制
• 字符编码
• 浮点型
• 列表
• 字典
• 字符串
• 字符编码总结
• hash函数
• 集合

二进制

每个0或者1所占的空间单位为bit(比特)， 这就是计算机最小的表示单位

8bit = 1bytes
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
1EB = 1024PB
1ZB = 1024EB
1YB = 1024ZB
1BB = 1024YB

字符编码

ASCII码

ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是现今最通用的单字节编码系统，并等同于国际标准ISO/IEC 646。

GB2312

GB2312又称国标码，由国家标准总局发布，1981年5月1日实施，通行于大陆，新加坡等地也使用此编码。共7445个字符，其中汉字占6763个。

GBK1.0

1995年发布GBK1.0,gbk编码能够用来同时表示繁体字和简体字，该编码标准兼容GB2312,共收录汉字21003个，同时包含不中日韩文字里所有的汉字

GB18030

2000年发布GB18030，是对GBK编码的扩充，覆盖中文、日文、朝鲜语和中国少数民族文字，其中收录27484个汉字。兼容GBK和GB2312字符集

BIG5

BIG5编码：台湾地区繁体中文边准字符集，采用双子节编码，共收录13053个中文字，1984年实施。

Unicode

Unicode编码:国际标准字符集，它将世界各种语言的每个字符定义一个唯一的编码，以满足跨语言、跨平台的文本信息转换。Unicode(统一码、万国码)规定所有的字符和符号最少由16位来表示（2个字节）， 即:2 ** 16 = 65536

UTF-8

UTF_8是对UNIcode编码的压缩和优化，他不再使用2个字节，而是将所有的字符用2个字节保存，东亚的字符用3个字节保存。。。

备注
windows系统中文默认编码是GBK

Mac Os \ Linux系统默认编码是UTF-8

python2.x默认编码是ASSCII

python3.x默认编码是UTF-8

浮点型

• 整数和浮点数在计算机内部存储的方式是不同的，整数永远是精确的而浮点数运算则是可能会有四舍五入的误差。

• python默认的是17位精度，也就是小数点后16位。

列表

创建列表

names1 = []  # 创建空列表
names2 = list()  # 创建空列表
names3 = ["a", "b", ["c", "d"]]  # 列表嵌套
print("names1:%s names2:%s names3:%s" % (names1, names2, names3))

查询

names = ["a", "b", "a", ["c", "d"]]

print(names[1])  # 打印b
print(names[2])  # ["c", "d"]
print(names[-1])  # ["c", "d"]
print(names[-1][-1])  # d
print(names.index("b"))  # 1, 取索引值
print(names.index("a"))  # 0, 取到第一个就返回
print(names.count("a"))  # 2, 查询个数

切片

names = ["a", "b", "a", ["c", "d"], 1, 2, 3, 4]

print(names[0: 3])  # 顾头不顾尾
# ['a', 'b', 'a']
print(names[-5:])
# [['c', 'd'], 1, 2, 3, 4]
print(names[-5: -1])  # 顾头不顾尾
# [['c', 'd'], 1, 2, 3]
print(names[:5])
# ['a', 'b', 'a', ['c', 'd'], 1]
print(names[:5:2])  # 步长，跳着取
# ['a', 'a', 1]
print(names[::2])
# ['a', 'a', 1, 3]

修改及插入

n = ["a", "b", "c", "d"]
n.append("alex")
print(n)
# ['a', 'b', 'c', 'd', 'alex']
n.insert(2, "abc")
print(n)
# ['a', 'b', 'abc', 'c', 'd', 'alex']
n[2] = 'cba'
print(n) # 修改
# ['a', 'b', 'cba', 'c', 'd', 'alex']

删除

L = ["a", "b", "c", "d", 1, 2, 3, 4, 5]
L.pop()  # 删除最后一个元素
print(L)
#  ['a', 'b', 'c', 'd', 1, 2, 3, 4]
L.remove("c")  # 从左到右第一个元素
print(L)
#  ['a', 'b', 'd', 1, 2, 3, 4]
del L[2]  # 删除指定元素
print(L)
#  ['a', 'b', 1, 2, 3, 4]
del L[2:5]  # 删除多个元素
print(L)
# ['a', 'b', 4]

• 循环

L = ["a", "b", "c", "d", 1, 2, 3, 4, 5]
for i in L:
    print(i)

排序

字符串和数字混合不能排序

L = ["a", "b", "c", "d", 1, 2, 3, 4, 5]
L.sort()
# TypeError: '<' not supported between instances of 'int' and 'str'

排序和反转

L = ['a', 'b', 'e', 'z', 'P', "A", "*", "#"]
L.sort()  #按ASCII排序
print(L)
# ['#', '*', 'A', 'P', 'a', 'b', 'e', 'z']
L.reverse()
print(L)
# ['z', 'e', 'b', 'a', 'P', 'A', '*', '#']

扩展

a = [1, 2, 3, 4]
b = ['a', 'b', 'c']
a.extend(b)
print(a)
# [1, 2, 3, 4, 'a', 'b', 'c']

清除

a = ['a', 'b', 'c']
a.clear()
print(a)  # []

浅copy

names = ["a", "b", "c", ["alex", "jack"], "j"]
names2 = names.copy()  # 浅copy, 只copy内存地址
print(names, names2)
# ['a', 'b', 'c', ['alex', 'jack'], 'j'] ['a', 'b', 'c', ['alex', 'jack'], 'j']
names2[3][0] = "ALEX"
print(names, names2)
# ['a', 'b', 'c', ['ALEX', 'jack'], 'j'] ['a', 'b', 'c', ['ALEX', 'jack'], 'j']

深copy

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# __author__:JasonLIN
import copy
names = ["a", "b", "c", ["alex", "jack"], "j"]
# names2 = copy.copy(names) # 浅copy
# names2 = names[:]  # 浅copy
# names2 = list(names)  # 浅copy
names2 = copy.deepcopy(names)
print(names, names2)
# ['a', 'b', 'c', ['alex', 'jack'], 'j'] ['a', 'b', 'c', ['alex', 'jack'], 'j']
names2[3][0] = "ALEX"
print(names, names2)
# ['a', 'b', 'c', ['alex', 'jack'], 'j'] ['a', 'b', 'c', ['ALEX', 'jack'], 'j']'

字符串

name = "my \tname is {name} and i am {year} years old"
print(name.capitalize())  # 首字母大写
print(name.count("a"))   # 统计
print(name.center(50, "-"))  # 打印50个字符，不够用“-”补齐，name放中间
print(name.endswith("ex"))  # 判断字符串以什么结尾
print(name.expandtabs(tabsize=30))  # 加空格，没什么卵用
print (name[name.find("name"):])  # 切片
print(name.format(name='alex', year=23))
print(name.format_map({'name': 'alex', 'year': 23}))
print('abc123'.isalnum())  # 是不是阿拉伯数字和字母
print('Aassafsdf'.isalpha())  # 是不是纯英文字母
print('10'.isdigit())  # 是不是整数
print('1f'.isdecimal())  # 是不是十进制
print('f-f'.isidentifier())  # 判断是不是一个合法的标识符
print('22'.isnumeric())  # 是不是只有数字
print('qqQ'.isupper())  # 是不是全是大写
print('+'.join(['1', '2', '3', '4']))
print(name.ljust(50, '*'))  # 放左边，不够用*补齐
print(name.rjust(50, '*'))  # 放右边，不够用*补齐
print('ALEX'.lower())  # 变小写
print('alex'.upper())  # 变大写
print('\nalex'.lstrip())  # 去左边的空格回车
print('alex\n'.rstrip())  # 去右边的空格回车
print('           alex\n'.strip())  # 去两边空格回车
p = str.maketrans("abcdeflix", "123456789")  # 加密
print("alex li".translate(p))             # 加密
print('alex li'.replace('l', 'L', 1))
print('alex li'.rfind('l'))  # 找到最右边的值的下标
print('1+2+3+4'.split('+'))
print('1+2\n3+4'.splitlines())
print('Alex Li'.swapcase())  # 大小写转换
print('alex li'.title())
print('alex li'.zfill(50))  # 不够用0补上

元组

元组其实跟列表差不多，也是存一组数，只不过它一旦创建，便不能再修改，所有又叫只读列表

names = ('alex', 'jack', 'eric')

hash函数

Hash, 一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是将一种任意长度的消息压缩到某一固定长度的消息摘要的函数。

print(hash("abc"))
# 4986596475539039790

字典

info = {"std1": "LongZeLuoLa",
        "std2": "WuTengLan",
        "std3": "Boduoye"}

info["std4"] = "苍井空"  # 增加
info["std2"] = "武藤兰"  # 修改
action = "std1" in info  # 查
print(action)  # True
print(info.get("std2"))  # 获取
# 武藤兰
print(info.get("std0"))  # 获取
# None
print(info["std2"])  # 获取， key不存在会报错
# 武藤兰

** 其他方法**

#values
>>> info.values()
dict_values(['LongZe Luola', 'XiaoZe Maliya'])

#keys
>>> info.keys()
dict_keys(['stu1102', 'stu1103'])

#setdefault
>>> info.setdefault("stu1106","Alex")
'Alex'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> info.setdefault("stu1102","龙泽萝拉")
'LongZe Luola'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

#update
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
>>> info.update(b)
>>> info
{'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}

#items
info.items()
dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])


#通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
>>> dict.fromkeys([1,2,3],'testd')
{1: 'testd', 2: 'testd', 3: 'testd'}

循环

# 方法1
for key in info:
    print(key,info[key])
# 方法2
for k,v in info.items:
    print(k, v)

集合

list_1 = {1, 4, 5, 7, 3, 6, 7, 9}
list_1 = set(list_1)  # 把集合变成列表 去重复
print(list_1, type(list_1))  # <class "set">
list_2 = set([2, 6, 0, 66, 22, 8, 4])
print(list_1.intersection(list_2))  # 交集
print(list_1.union(list_2))         # 并集
print(list_1.difference(list_2))    # 差集
# 子集
list_3 = set([1, 3, 7])
print(list_3.issubset(list_1))      #  list_3 <= list_1  list_3包含于list_1
# True
print(list_1.issuperset(list_3))    # list_1 >= list_3  list_1包含list_3
# True
# 对称差集
print(list_1.symmetric_difference(list_2))  # 并集然后去掉相同部分
# {0, 1, 2, 66, 3, 5, 8, 7, 9, 22}
list_4 = set([5, 7, 8])
print(list_3.isdisjoint(list_4))  # False 有交集返回False没交集返回True

# 交集
print(list_1 & list_2)
# 并集
print(list_1 | list_2)
# 差集
print(list_1 - list_2)  # in list_1 but not in list_2
# 对称差集
print(list_1 ^ list_2)

集合的的基本操作

list_1 = {1}
list_1.add(999)        # 添加一项
list_1.update([888, 777])  # 添加多项
print(list_1)
list_1.remove(777)  # 删除
list_1.discard(888)    # 删除, 删除集合里面没有的元素不会报错
print(list_1)  # {1, 999}
print(len(list_1))
print(list_1.pop())  # 随机删除然后返回删除的那个数

字符编码总结

日本编码 -解码(decode)-> unicode -- 编码(encode)

• python2

内存中字符默认编码是ASCII，默认文件编码是ASCII

当声明了文件头的编码后， 字符串的编码就按文件编码来

python2中的unicode是一个单独的类型， 用u"路飞"来表示

python2 str == bytes, bytes直接是按字符编码存成的2进制格式在内存里

• python3

字符串都是unicode

文件编码默认是utf-8, 读到内存会被py解释器自动转成unicode

bytes与str做了明确区分

所有的unicode字符编码后都会变成bytes格式

GBK需要转换为UTF-8格式编程：

1、首先通过编码[decode]转换为Unicode编码

2、然后通过解码[encode]转换为UTF-8的编码