Python基础数据类型

Posted on

分类

数字、字符串、列表、元组、字典、集合

数字

  • python整数不分类型，或者说它只有一种类型的整数。Python 整数的取值范围是无限的，不管多大或者多小的数字，Python 都能轻松处理。
    当所用数值超过计算机自身的计算能力时，Python 会自动转用高精度计算（大数计算）。
  • python 只有一种小数类型，就是 float。
  • 复数（Complex）是python的内置类型，直接书写即可。换句话说，Python 语言本身就支持复数，而不依赖于标准库或者第三方库。复数由实部（real）和虚部（imag）构成，在Python中，复数的虚部以j或者j作为后缀。
  • 布尔值型bool 　真 1 True,假 0 False

字符串

字符串是由独立字符组成的一个序列，通常包含在单引号（’’）双引号（””）或者三引号之中（’’’ ‘’’或””” “””，两者一样）
avatar

  • 常用操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
# capitalize / swapcase / title
name = 'sunShine'
msg = 'hello world'
print(name.capitalize()) # 首字母大写,其它小写 Sunshine
print(name.swapcase())  #大小写反转 SUNHINE
print(msg.title()) # 每个单词首字母大写 Hello World

#内同居中，总长度，空白处填充
res1 = name.center(20,'*')
print(res1) # ******sunhine*******

# 字符串中的元素出现的个数
res2 = name.count("n",0,7)  # 在0到7个字符间出现n的次数
print(res2) # 2

a2 = "hqw\t"
res3 = a2.expandtabs() # 默认将一个tab键编程8个空格，如果tab前面的字符长度不足8位，则补全8个，
# 如果超过8个但是不足16个，则补全至16位，以此类推。
print(len(res3))  # 8

# startswith / endswith
print(name.startswith('S')) # 判断name是否以S为开头,返回布尔值 #False
print(name.endswith('e')) # 判断name是否以e为结尾,返回布尔值 # True
print(name,name.endswith('hi',4,6))
print(name,name.startswith('Sh',3,6))

# find / index
res4 = name.find('un',1,6) # 在索引1，6之间匹配，不写默认是全部匹配
print(res4) # 匹配结果则为1， 不匹配结果为 -1
res5 = name.index('i',3,7)
print(res5)  # 返回找到的元素的索引，找不到则报错。ValueError: substring not found # 5

# split / rsplit 以某个内容分隔，最终形成一个列表，此列表中不含有这个分割的元素
res6 = 'title,Title,test'
print(res6.split('t')) #以t为分割,['', 'i', 'le,Ti', 'le,', 'es', '']
print(res6.rsplit('t',1)) # 按由右向左的顺序，只将第一个匹配到的分割['title,Title,tes', '']

# format 格式化输出
print('{} {} {}'.format('sunshine',28,'male'))  #sunshine 28 male
print('{1} {0} {1}'.format('sunshine',28)) #28 sunshine 28
print('{name} {age} {sex}'.format(name='sunshine',age=28,sex='male')) #sunshine 28 male

# strip 一般用来去空
name='*sunshine**'
print(name.strip('*')) #sunshine   去除所有的*
print(name.lstrip('*')) #sunshine** 去除左边的*
print(name.rstrip('*')) #*sunshine  去除右边的*

# replace  将匹配的元素替换为新的元素
name = 'sunshine say :i am a good boy!'
print(name.replace('sunshine','SS'))

# is
name = 'sunshine123'
print(name.isalnum()) # 判断字符串是否由字母或者数字组成，返回布尔值 True
print(name.isalpha()) # 判断字符串是否由纯字母组成，返回布尔值  False
print(name.isdigit()) # 判断字符串是否由纯数字组成，返回布尔值  False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# string.capitalize()                                  #把字符串的第一个字符大写
# string.center(width)                                 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
# string.count(str, beg=0, end=len(string))            返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
# string.decode(encoding='UTF-8', errors='strict')     以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'
# string.encode(encoding='UTF-8', errors='strict')     以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
# string.endswith(obj, beg=0, end=len(string))         检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
# string.expandtabs(tabsize=8)                         把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
# string.find(str, beg=0, end=len(string))             检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
# string.index(str, beg=0, end=len(string))            跟find()方法一样，只不过如果str不在 string中会报一个异常.
# string.isalnum()                                     如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
# string.isalpha()                                     如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
# string.isdecimal()                                   如果 string 只包含十进制数字则返回 True 否则返回 False.
# string.isdigit()                                     如果 string 只包含数字则返回 True 否则返回 False.
# string.islower()                                     如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
# string.isnumeric()                                   如果 string 中只包含数字字符，则返回 True，否则返回 False
# string.isspace()                                     如果 string 中只包含空格，则返回 True，否则返回 False.
# string.istitle()                                     如果 string 是标题化的(见 title())则返回 True，否则返回 False
# string.isupper()                                     如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
# string.join(seq)                                     以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
# string.ljust(width)                                  返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
# string.lower()                                       转换 string 中所有大写字符为小写.
# string.lstrip()                                      截掉 string 左边的空格
# string.maketrans(intab, outtab])                     maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
# max(str)                                             返回字符串 str 中最大的字母。
# min(str)                                             返回字符串 str 中最小的字母。
# string.partition(str)                                有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
# string.replace(str1, str2,  num=string.count(str1))  把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
# string.rfind(str, beg=0,end=len(string) )            类似于 find()函数，不过是从右边开始查找.
# string.rindex( str, beg=0,end=len(string))           类似于 index()，不过是从右边开始.
# string.rjust(width)                                  返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
# string.rpartition(str)                               类似于 partition()函数,不过是从右边开始查找.
# string.rstrip()                                      删除 string 字符串末尾的空格.
# string.split(str="", num=string.count(str))          以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
# string.splitlines(num=string.count('\n'))            按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
# string.startswith(obj, beg=0,end=len(string))        检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
# string.strip([obj])                                  在 string 上执行 lstrip()和 rstrip()
# string.swapcase()                                    翻转 string 中的大小写
# string.title()                                       返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
# string.translate(str, del="")                        根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
# string.upper()                                       转换 string 中的小写字母为大写

元组 & 列表

  • 元组也称为只读列表，数据只可以被查询，不能被修改。字符串的切片操作同样适用于列表。列表用（）标示，黎明的元素用逗号隔开。如（1，2，3)
  • 列表是python的基础数据类型之一，是用[]括起来，每个元素以逗号隔开，里面可以存放各种数据类型。如：li = [‘sunshine’,18,{‘hobby’:’eat’},[1,2,3]]。列表还可以储存大量数据，32位python的限制是536870912个元素，64位python的限制是1152921504606846975 个元素。列表是有序的，有索引值，可以切片，方便取值。
  • 列表和元组的存储方式的差异
    1 由于列表是动态的，所以它需要存储指针，来指向对应的元素（上述例子中，对于int 型，8 字节）。另外，由于列表可变，所以需要额外存储已经分配的长度大小（8 字节），这样才可以实时追踪列表空间的使用情况，当空间不足时，及时分配额外空间。，Python 每次分配空间时都会额外多分配一些，这样的机制（over-allocating）保证了其操作的高效性：增加 / 删除的时间复杂度均为 O(1)。
    2 元组长度大小固定，元素不可变，所以存储空间固定。
  • 列表和元组的区别
    1 列表是动态的，长度可变，可以随意的增加、删减或改变元素。列表的存储空间略大于元组，性能略逊于元组。
    2 元组是静态的，长度大小固定，不可以对元素进行增加、删减或者改变操作。元组相对于列表更加轻量级，性能稍优。
  • 列表和元组的使用场景
    1 如果存储的数据和数量不变，比如你有一个函数，需要返回的是一个地点的经纬度，然后直接传给前端渲染，那么肯定选用元组更合适。
    2 如果存储的数据或数量是可变的，比如社交平台上的一个日志功能，是统计一个用户在一周之内看了哪些用户的帖子，那么则用列表更合适。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# insert / append / extend
li = [1,'a','b',2,3,'a']
li.insert(0,55) # 按索引增加个55的值 #[55, 1, 'a', 'b', 2, 3, 'a']
li.append('c')# 增加到最后 [55, 1, 'a', 'b', 2, 3, 'a', 'c']
li.append([1,2,3])#[55, 1, 'a', 'b', 2, 3, 'a', 'c', [1, 2, 3]]
li.extend(['a,b,c']) # 迭代的去增加元素 [55, 1, 'a', 'b', 2, 3, 'a', 'c', [1, 2, 3], 'a,b,c']
li.extend(['a,b','ccc']) # [55, 1, 'a', 'b', 2, 3, 'a', 'c', [1, 2, 3], 'a,b,c', 'a,b', 'ccc']
li.extend('aaa') #[55, 1, 'a', 'b', 2, 3, 'a', 'c', [1, 2, 3], 'a,b,c', 'a,b', 'ccc', 'a', 'a', 'a']
li.extend('b,b')#[55, 1, 'a', 'b', 2, 3, 'a', 'c', [1, 2, 3], 'a,b,c', 'a,b', 'ccc', 'a', 'a', 'a', 'b', ',', 'b']
print(li)

#pop_del_remove_clear
li = [1,'a','b',2,3,'a']
li.pop(1) # 按索引位置去删除
print(li) #[1, 'b', 2, 3, 'a']
del li[1:3] # 按照位置去删除
print(li) #[1, 3, 'a']
li.remove('a') # 按照元素去删除
print(li) # [1, 3]
li.clear() #清空列表
print(li) # []

li = [1,'a','b',2,3,'a']
li[1]='ccc'
print(li) #[1, 'ccc', 'b', 2, 3, 'a']
li[4:6] = [5,7]
print(li) #[1, 'ccc', 'b', 2, 5, 7]

#count (数) 统计某个元素在列表中出现的次数。
a = ['s','u','n','s','h','i','n','e']
print(a.count('s'))  # 出现了2次

#index 方法 用于从列表中找出某个值第一个匹配项的索引位置
a = ['s','u','n','s','h','i','n','e']
print(a.index('n')) # 第一个出现n的索引位置为 2

#sort 在原位置对列表进行排序
a = ['s','u','n','s','h','i','n','e']
print(a.sort()) # 输出为 None
a.sort() # 没有返回值
print(a) # ['e', 'h', 'i', 'n', 'n', 's', 's', 'u']

#reverse 将列表中的元素反向存放
a = ['s','u','n','s','h','i','n','e']
# print(a.reverse()) # 输出为 None
a.reverse() # 没有返回值
print(a) # ['e', 'n', 'i', 'h', 's', 'n', 'u', 's']

字典

字典是Python中唯一的映射类型，采用键值对（key–>value）的形式存储数据。Python对key进行哈希函数运算，根据运算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示kye必须是不可变类型，如：数组、字符串、元组。字典是除列表之外最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象结合。两者的区别在于：字典是通过key来取值的，而不是通过偏移存取。

1
2
3
4
5
6
7
8
9
10
dic = {'name':'sunshine','age':28,'sex':'male'}
dic['li'] = ['a','b']  
print(dic) # {'name': 'sunshine', 'age': 28, 'sex': 'male', 'li': ['a', 'b']}
# setdefault在字典中增加键值对，如果只有键那对应的值就是none,但是如果原字典中存在设置的键值对，则不会发生变更
#{'name': 'sunshine', 'age': 28, 'sex': 'male', 'li': ['a', 'b'], 'hobby': ['study', 'listen', 'eat']}
dic.setdefault('hobby',['study','sleep','eat'])  # 未发生变化
#{'name': 'sunshine', 'age': 28, 'sex': 'male', 'li': ['a', 'b'], 'hobby': ['study', 'listen', 'eat']}
print(dic)

setdefaut