基本数据类型 浮点型、字符串、列表、字典、元组、集合 字符编码,编码转换 进制
数据类型
float:浮点型
浮点数是属于有理数中某特定子集的数的数字表示,在计算机中用以近似表示任意某个实数。具体的说,这个实数由一个整数或定点数(即尾数)乘以某个基数的整数次幂得到,这种表示方法类似于基数为10的科学计数法。
整数和浮点数在计算机内部的存储方式是不同的,整数永远精确而浮点数运算可能有误差
Python默认17位精度,也就是小数点后16位,但是精度越往后越不准
str:字符串
用以存储和表示基本的文本信息,所有引号引起来的都是字符串
特性:
有序--有索引
不可变--所有对字符串的操作都是形成一个新的字符串
索引和切片
1 s = "abCde123asD5"
2
3 s1 = s[0] # 字符串有索引,从0开始
4 # a
5 s2 = s[-1] # 倒着取
6 # 5
7 s3 = s[0:3] # 取索引为0-3,不包括3,顾头不顾尾
8 # abC
9 s4 = s[0:-1] # 从头取到位,取不到最后一个
10 # abCde123asD
11 s5 = s[0:] # 从头取到尾,取所有
12 # abCde123asD5
13 s6 = s[:] # 取所有
14 # abCde123asD5
15 s7 = s[1:6:2] # 取2-6,步长为2
16 # bd1
17 s8 = s[-1:0:-1] # 倒着取,取不到索引为0的,顾头不顾尾
18 # 5Dsa321edCb
19 s9 = s[::-1] # 倒着取,取所有
20 # 5Dsa321edCba
21 s10 = s[-1:3:-2] # 倒着取,步长为2
22 # 5s31
字符串的操作
1 # 字符串的操作
2 s = "abCde123asD5"
3
4 s1 = s.capitalize() # 首字母大写
5 # Abcde123asd5 # 如果第一个字符不是字母,后面所有字母都变小写
6 s11 = s.title() # 每个被非字母字符隔开的单词首字母大写
7 # Abcde123Asd5
8 s12 = s.upper() # 全大写
9 # ABCDE123ASD5
10 s13 = s.lower() # 全小写
11 # abcde123asd5
12 s14 = s.swapcase() #大小写反转
13 # ABcDE123ASd5
14
15 s2 = s.isalnum() # 判断字符串是否由字母和数字组成,返回bool
16 # True
17 s21 = s.isalpha() # 判断字符串是否是纯字母
18 # False
19 s22 = s.isdigit() # 是否是纯数字
20 # False
21 s23 = s.istitle() # 是否每个隔开的单词首字母都是大写
22 # False
23 s24 = s12.isupper() # 是否全大写
24 # True
25
26 s3 = s.center(20) # 总长度20,字符串居中,两侧空格填充
27 # abCde123asD5
28 s31 = s.center(20,'*') # 填充字符可以设置
29 # ****abCde123asD5****
30
31 s4 = s.find('s') # 通过元素找索引,第一个匹配的索引
32 # 9
33 s41 = s.find('k') # 找不到,返回-1
34 # -1
35 s42 = s.index('s') # 通过元素找索引,第一个匹配的索引
36 # 9
37 # s43 = s.index('k') # 找不到,报错
38 # print(s43)
39
40 s5 = s.startswith('a') # 判断字符串是否以a开头,返回bool
41 # True
42 s51 = s.startswith('b',3,6) # 可切片
43 # False
44 s52 = s.startswith('abc')
45 # False
46 s53 = s.endswith('5') # 判断是否以某元素结尾
47 # True
48
49 s6 = s.replace('a','9') # 替换
50 # 9bCde1239sD5
51 s7 = s.count('a') # 统计元素在字符串中出现的次数
52 # 2
53 s8 = len(s) # 字符串长度
54 # 12
55
56
57 s = " as1*fr 23d\tdb** "
58
59 s1 = s.expandtabs() # \t前面的补全 默认将一个tab键变成8个空格,若tab前不足8个,则补全8个,超过则补全为8的倍数
60 # as1*fr 23d db **
61 s2 = s.strip() # 去除字符串两侧的空格
62 # as1*fr 23d db**
63 s21 = s.strip(' *') # 可以设置要去除的元素
64 # as1*fr 23d db
65
66 s3 = s.split() # 字符串以空格分割,形成列表
67 # ['as1*fr', '23d', 'db**']
68 s31 = s.split('*') # 可以设置以某元素分割
69 # [' as1', 'fr 23d\tdb', '', ' ']
70
71
72 li = ['abc','qw23','alex']
73 s1 = ''.join(li) # 列表转换字符串
74 # abcqw23alex
75 s2 = '_'.join(li) # 可以设置以某元素连接
76 # abc_qw23_alex
格式化输出 format()
1 name = input("名字:")
2 age = input("年龄:")
3 hob = input("爱好:")
4 s = "我叫{},今年{}岁,喜欢{},是的,我是{}".format(name,age,hob,name)
5 print(s)
6 s = "我叫{0},今年{1}岁,喜欢{2},是的,我是{0}".format(name,age,hob)
7 print(s)
8
9 s = "我叫{name},今年{age}岁,喜欢{hob},是的,我是{name}".format(hob='girl',name='alex',age='22')
10 print(s)
list:列表
列表是一个数据的集合,集合内可以放任何数据类型,可对集合进行方便的增删改查操作
创建
1 l1 = [] # 定义空列表
2 l2 = ['a','b','c','d'] # 创建列表,索引0,1,2,3
3 l3 = ['abc',['alex',1,2]] # 嵌套列表
4
5 l4 = list() # 创建空列表
6 print(l4)
7 []
查询
1 li = ['a','b','c',2,3,4,'d','a','e']
2
3 l1 = li[0] # 通过索引取值
4 # a
5 l2 = li[-1] # 通过索引从右边开始找
6 # e
7 l3 = li[-2]
8 # a
9 l4 = li.index('a') # 返回指定元素的索引值,从左往右找,找到第一个匹配值 则返回
10 # 0
11 l5 = li.count('a') # 统计指定元素的个数
12 # 2
切片
1 li = ['a','b','c',2,3,4,'d','a','e']
2
3 l1 = li[0:3] # 返回索引0-3的元素,不包括3,顾头不顾尾
4 # ['a', 'b', 'c']
5 l2 = li[0:-1] # 返回索引从0至最后的元素,不包括最后一个
6 # ['a', 'b', 'c', 2, 3, 4, 'd', 'a']
7 l3 = li[3:6]
8 # [2, 3, 4]
9 l4 = li[3:] # 返回索引0至最后所有元素
10 # [2, 3, 4, 'd', 'a', 'e']
11 l5 = li[:3] # 返回索引0至3的元素,不包括3
12 # ['a', 'b', 'c']
13 l6 = li[1:6:2] # 返回索引1-6的元素,步长为2(隔一个,取一个值)
14 # ['b', 2, 4]
15 l7 = li[:] # 返回所有
16 # ['a', 'b', 'c', 2, 3, 4, 'd', 'a', 'e']
17 l8 = li[::2] # 按步长为2返回所有
18 # ['a', 'c', 3, 'd', 'e']
增加、修改
1 li = ['a','b',1,4,'e']
2
3 li.append('A') # 列表尾部追加A
4 # ['a', 'b', 1, 4, 'e', 'A']
5 li.insert(3,'E') # 在列表索引为3的位置 插入一个值 E
6 # ['a', 'b', 1, 'E', 4, 'e', 'A']
7 li[3] = 'alex' # 把索引为3的元素改为alex
8 # ['a', 'b', 1, 'alex', 4, 'e', 'A']
9 li[3:5] = 'alex' # 把索引3-5的元素改为alex,不够的元素自己增加
10 # ['a', 'b', 1, 'a', 'l', 'e', 'x', 'e', 'A']
删除
1 li = ['a', 'b', 1, 'a', 'l', 'e', 'x', 'e', 'A']
2
3 li.pop() # 删除最后一个元素
4 # ['a', 'b', 1, 'a', 'l', 'e', 'x', 'e']
5 li.remove('a') # 删除从左到右找到的第一个指定元素
6 # ['b', 1, 'a', 'l', 'e', 'x', 'e']
7 del li[4] # 删除索引为4的元素
8 # ['b', 1, 'a', 'l', 'x', 'e']
9 del li[3:5] # 删除多个元素
10 # ['b', 1, 'a', 'e']
循环
1 li = ['b', 1, 'a', 'l', 'x', 'e']
2 for i in li:
3 print(i)
排序
1 li = ['b', 1, 'a', 'l', 'X', 'e']
2 li.sort() # 不能对包含str和int的列表排序
3 # TypeError: unorderable types: int() < str()
4
5 li = ['b', '*', 'a', '$','l', 'X', 'e']
6 li.sort() # 按ASCII排序
7 # ['$', '*', 'X', 'a', 'b', 'e', 'l']
8 li.reverse() # 反转
9 # ['l', 'e', 'b', 'a', 'X', '*', '$']
其他用法
1 li = ['l', 'e', 'b', 'a', 'X', '*', '$']
2
3 li.extend([1,2,3,4]) # 把一个列表扩展到li列表
4 # ['l', 'e', 'b', 'a', 'X', '*', '$', 1, 2, 3, 4]
5
6 li[2] = ['alex','rain','jack']
7 # ['l', 'e', ['alex', 'rain', 'jack'], 'a', 'X', '*', '$', 1, 2, 3, 4]
8 l1 = li[2][1] # 嵌套列表取值
9 # rain
10
11 li.clear() # 清空列表
12 # []
tuple:元祖
又叫只读列表,一旦创建,就不能再修改
特性:
不可变
元组本身不可变,如果元组中还包含其他可变元素,这些可变元素可以改变
使用场景:
显示的告诉别人,此处数据不可修改
数据库连接配置信息等
1 tu = ('l', 'e', ['alex', 'rain', 'jack'], 'a', 'X', 3, 4)
2
3 # tu[0] = '123' # 报错,不可更改
4 tu[2][1] = '123' # 可以改
5 # ('l', 'e', ['alex', '123', 'jack'], 'a', 'X', 3, 4)
6
7 tu.index('a')
8 # 3
9 tu.count('a')
10 # 1
11 # 切片 #同列表一样
dict:字典
key-value结构
key必须可哈希、且必须为不可变数据类型、必须唯一
value可存放任意多个值、可修改、可以不唯一
无序
查找速度快
增删改查
1 info = {
2 "alex":[26,"技术部","工程师",12345],
3 "shanshan":[25,"公关部","夜魔",13579],
4 "龙庭":[22,"设计部","UI",23234]
5 }
6
7 info["jack"] = [23,"销售部","经理",45678] # 增加
8 print(info)
9 info["alex"][0] = 18 # 修改
10 # {'alex': [18, '技术部', '工程师', 12345], 'shanshan': [25, '公关部', '夜魔', 13579], 'jack': [23, '销售部', '经理', 45678], '龙庭': [22, '设计部', 'UI', 23234]}
11
12 print("alex" in info) # 查找 判断在不在字典里
13 # True
14 print(info.get("alex")) # 获取
15 # [18, '技术部', '工程师', 12345]
16 print(info["alex"]) # 获取
17 # [18, '技术部', '工程师', 12345]
18 # print(info["rain"]) # key不存在,会报错
19 print(info.get("rain")) # key不存在,返回None
20 # None
21
22 print(info.pop("alex")) # 删除,返回删除key所对应的value
23 # [18, '技术部', '工程师', 12345]
24 print(info.popitem()) # 随机删,返回元组
25 # ('jack', [23, '销售部', '经理', 45678])
26 del info["alex"] # 删除,无返回值
嵌套
1 info = {
2 "alex": {
3 "age": 26,
4 "post": "工程师",
5 "Tel": 12345
6 },
7 "shanshan": {
8 "age": 25,
9 "post": "夜魔",
10 "Tel": 13579
11 },
12 }
13
14 info["alex"]["age"] = 18
15 print(info)
其他方法
1 info = {
2 "alex": [26, "工程师"],
3 "shanshan": [25, "夜魔"],
4 }
5
6 print(info.values())
7 # dict_values([[26, '工程师'], [25, '夜魔']])
8 print(info.keys())
9 # dict_keys(['alex', 'shanshan'])
10 print(info.items())
11 # dict_items([('alex', [26, '工程师']), ('shanshan', [25, '夜魔'])])
12
13 info.setdefault("jack",22) # 显示”jack“的内容,字典没有,设置为22
14 # 22
15 print(info.setdefault("alex",22)) # 显示”alex“的内容,字典有,显示原值
16 # [26, '工程师']
17
18 dic1 = {1:2,2:3,"alex":22}
19 info.update(dic1) # 更新,key不存在的添加,key存在的值覆盖
20 print(info)
21
22 info = info.fromkeys([1,2,3],"alex") # 通过一个列表生成默认字典
23 print(info)
循环
1 info = {
2 "alex": [26, "工程师"],
3 "shanshan": [25, "夜魔"],
4 }
5 # 循环
6 for k in info: # 只打印key
7 print(k)
8
9 for k in info:
10 print(k,info[k])
11
12 for k,v in info.items(): # 低效
13 print(k,v)
set():集合
无序的,不重复的数据组合
作用:去重
关系测试 测试两组数据间交、差、并等关系
特性:
确定性 元素必须可哈希
互异性 去重
无序性
1 s = {}
2 print(type(s)) # 字典
3 s = {1}
4 print(type(s)) # 集合
5 s.pop()
6 print(s)
7 set() #空集合
增删改
1 s = {1,2,3,4,2,3,4}
2
3 # {1, 2, 3, 4} # 元素不重复
4 s.add(2)
5 # {1, 2, 3, 4} # 元素重复,添加不进去
6 s.add(22) # 增
7 # {1, 2, 3, 4, 22}
8 # s.add([5,6]) # 报错,只能添加不可变数据
9
10 s.update([4,5,6,7]) # 把多个值加入到集合
11 # {1, 2, 3, 4, 5, 6, 7, 22}
12 s.update({4,5,8,9})
13 # {1, 2, 3, 4, 5, 6, 7, 8, 9, 22}
14
15 s.pop() # 随机删除元素,集合为空的话会报错
16 # {2, 3, 4, 5, 6, 7, 8, 9, 22}
17 s.discard(2) # 删除元素,没有也不报错
18 # {3, 4, 5, 6, 7, 8, 9, 22}
19 s.clear() # 清空集合
20 set()
21 s.remove(6) # 删除元素,不存在会报错
集合关系测试
1 s1 = {1,2,3,4}
2 s2 = {3,4,5,6}
3
4 s = s1.intersection(s2)
5 s = s1 & s2 # 交集
6 # {3, 4}
7
8 s = s1.difference(s2)
9 s = s1 - s2 # 差集
10 # {1, 2}
11 s = s2.difference(s1)
12 s = s2 - s1
13 # {5, 6}
14
15 s = s1.union(s2)
16 s = s1 | s2 # 并集
17 # {1, 2, 3, 4, 5, 6}
18
19 s = s1.symmetric_difference(s2)
20 s = s1 ^ s2 # 对称差集
21 s = (s1 | s2) - (s1 & s2)
22 # {1, 2, 5, 6}
23
24 s1.difference_update(s2)
25 print(s1)
26 # {1, 2} # 把s1中 也在s2中的元素 去掉
两个集合之间一般有三种关系,相交、包含、不相交
1 s1 = {1,2,3,4,5,6}
2 s2 = {1,2,3,4}
3
4 s1.issuperset(s2)
5 s1 >= s2
6 # True # s1是s2的超集 s1包含s2
7 s2.issubset(s1)
8 s2 <= s1
9 # True # s2是s1的子集
10
11 s1.isdisjoint(s2)
12 # False # 判断两个集合是不是不相交
基础数据类型总结
按储存空间的占用分(从低到高)
数字
字符串
集合:无序,无需存索引相关信息
元组:有序,需要存索引相关信息
不可变
列表:有序,需要存索引相关信息
可变,需要处理数据的增删改
字典:无序,需要存key与value映射的相关信息
可变,需要处理数据的增删改
按存值个数区分
标量/原子类型 数字,字符串
容器类型 列表,元组,字典
按可变不可变区分
可变 列表,字典
不可变 数字,字符串,元组,bool
按访问顺序区分
直接访问 数字
顺序访问(序列类型) 字符串,列表,元组
key值访问(映射类型) 字典
字符编码
电脑的传输,还有储存的实际上都是高低电平,对应01001001
# ASCII:美国标准信息交换代码, 只规定了英文字母数字和一些特殊字符
用8位二进制表示(一个字节)一个字符
最初只用了后7位,将拉丁文编码后占用了最高位
# Unicode:万国码 ,为解决传统的字符编码方案的局限而产生的,为每种语言的每个设定了统一并且唯一的二进制编码
最开始16位 之后32位 中文32位,4个字节
# utf-8:可变长 unicode transformation format 对unicode编码的压缩和优化
ascii 1个字节
欧洲 2个字节
亚洲 3个字节
# GBK:国内使用
英文 1个字节
中文 2个字节
windows系统默认编码GBK
Mac OS\Linux系统默认编码Utf-8
1、各个编码之间的二进制,是不能互相识别的,会产生乱码
2、文件的储存、传输,不能是unicode(只能是utf-8 utf-16 gbk gb2312 ascii等)
# 内存中统一采用unicode,浪费空间来换取可以转换成任意编码(不乱码),硬盘可以采用各种编码,如utf-8,保证存放于硬盘或者基于网络传输的数据量很小,提高传输效率与稳定性。
无论以什么编码在内存里显示字符,存到硬盘上都是二进制
存到硬盘上时是以何种编码存的,再从硬盘上读出来时,就必须以何种编码,要不然就乱了
python3的执行过程:
1、解释器找到代码文件,把代码字符串按文件头定义的编码加载到内存,转成unicode
2、把代码字符串按照语法规则进行解释
3、所有的变量字符都会以unicode编码声明
编码转换过程:
utf-8 --(decode解码)--> unicode --(encode编码)--> gbk
python的bytes类型:
python2中的字符串更应该称为字节串。
python2中有str类型,bytes类型,unicode类型
str == bytes
str 解码后就会变成unicode类型
python3:默认编码utf-8,字符串是unicode类型
str 就是unicode格式的字符
bytes 就是单纯的二进制
(想在py3里看字符,必须是unicode编码,其他编码一律按bytes格式显示)
py2:以utf-8 or gbk.. 编码的代码,加载到内存中,并不会被转成unicode,编码依然是utf-8 or gbk
py3:以utf-8 or gbk.. 编码的代码,加载到内存中,会被自动转成unicode
python出现编码问题的原因:
python解释器的默认编码
python源文件文件编码
终端使用的编码
操作系统的语言设置
进制:
二进制:01
八进制:01234567
十进制:0123456789
十六进制:0123456789abcdef
1 a = 31
2
3 b = oct(a)
4 # 0o37 # 八进制
5 c = hex(a)
6 # 0x1f # 十六进制
7 d = bin(a)
8 # 0b11111 # 二进制