Python常见的数据类型有以下几种：Number（int, float, complex），String（字符串），List（列表），Tuple（元组），Dictionary（字典），Set（集合），此外还有 布尔值 和 空值 等。这份笔记主要记录python相关数据类型的常用操作，以及不同数据类型间的相互转换。
一、Number
1.1 运算符 之 ‘/’，‘//’，‘%’，‘**’
x = 2e2 ; y = 3 # 科学计数法，表示2* 10^2 = 200
print(x / y) # 除法，66.66666666666667
print(x // y) # 整除，66
print(x % y) # 取余，2
print(x ** y) # 乘方，80000001.2 复数类型 complex
a = complex(2, 4) # 复数定义1
b = 3 - 5j # 复数定义2
print(a, b) # (2+4j) (3-5j)
print(a.real, a.imag, a.conjugate()) # 2.0 4.0 (2-4j)
print(a + b, a * b) # (5-1j) (26+2j)
二、String
2.1 字符串连接 【增】
运算符 +，*
s1 = 'hello ' , s2 = 'python!'
print(s1 + s2) # hello python!
print(s1 * 2) # hello hellos. join(list)
s = '-'
alist = ['a', 'b', 'c', 'd']
print(s.join(alist)) # 'a-b-c-d'2.2 删除字符串中的元素 【删】
删除下标为i的元素
s = '0123456789'
i = 5
s_temp = s[0:i] + s[i + 1:]
print(s_temp) # 012346789s.replace(src_char, dst_char)
s = '21122332'
print(s.replace('2', '')) # 1133s.strip()
# strip函数不指定参数，默认删除头尾的'\r', '\t', '\n'和'空格'
s = '\n\t 161 \n'
print(s.strip()) # '161'
print(s.lstrip()) # '161 \n'
print(s.rstrip()) # '\n\t 161'
# strip函数指定参数
s = '112211'
print(s.strip('1')) # 22
print(s.lstrip('1')) # 2211
print(s.rstrip('1')) # 11222.3 修改字符串的值 【改】
s.upper() , s.lower() , s.swapcase() , s.capitalize()
s = 'hello python'
print(s.upper()) # HELLO PYTHON，转换成大写
print(s.lower()) # hello python，转换成小写
print(s.swapcase()) # HELLO PYTHON，大小写互换
print(s.capitalize()) # Hello python，首字母大写2.4 查找字符串元素和相关属性 【查】
s[start : stop : step] , s[ : : -1]
s = '0123456789'
# 1. 从左到右索引默认为0开始
print(s[1:5]) # 1234
print(s[1:]) # 123456789
print(s[:5]) # 01234
print(s[5:2]) # 输出为空
print(s[0:20]) # 0123456789, 超出索引则输出最大长度
print(s[::2]) # 02468
print(s[::-1]) # 9876543210, 相当于翻转字符串
# 2. 从右到左索引默认从-1开始，当成 len(s)-i考虑即可
print(s[-1]) # 9
print(s[:-1]) # 012345678
print(s[1:-1]) # 12345678
len(s), s.isalpha(), s.isspace(), s.isalnum(), s.isdigit(), s.isnumeric(), s.istitle()
# 查询字符串属性
print(len(s)) # 输出字符串长度
print(s.isalpha()) # 是否只由[字母]组成
print(s.isspace()) # 是否只由[空格]组成
print(s.isalnum()) # 是否只由[字母+数字]组成
print(s.isdigit()) # 是否只由[数字]组成
print(s.isnumeric()) # 是否只由[数字]组成,这种方法是只针对unicode对象
print(s.istitle()) # 所有的单词拼写首字母是否为大写，且其他字母为小写s.find(sub_str, begin, end )
# find() 方法检测字符串str中是否包含子字符串sub_str
# 如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，
# 如果包含子字符串则返回开始的索引值，否则返回-1。
str.find(sub_str, beg=0, end=len(string))2.5 字符串其他函数
s.split(char)
# split()函数，把字符串分解成列表
s = "I Love You"
print(s.split(' ')) # ['I', 'Love', 'You']格式化字符串 % 和format()
1） 用 ‘%’ 方式实现。
- ‘ % ’ 运算符可以用来格式化字符串。
- 在字符串内部，'%s' 表示用字符串替换，'%d' 表示用整数替换，'%f' 表示用浮点数替换，'%x' 表示用十六进制整数替换.
- 有几个 '%?' 占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
s = "hello, %s，I'm %d years old and %.2f cm." % ('bacon', 25, 172.456)
print(s) # hello, bacon，I'm 25 years old and 172.46 cm.2） 用format()函数实现
index = "{:0>3}".format('6')
print(index) # 006使用 r"xxx" 表示字符串不转意, b"xxx"表示字节编码（一般用utf-8）
s1=r"\t666"
s2="\t666"
print(s1) # \t666
print(s2) # 666字符串内置方法
三、List
列表采用 [ ] 标识，类似于其他语言的数组，但功能更加强大。
3.1 列表定义
# 1. 直接定义
l1 = ['hello', 15, True]
l2 = [1,2,"ab","1",True,["a","b","c"]]# 2. 通过range函数定义
nums = range(1,100)# 3. 列表生成式定义
nums = [i ** 2 for i in range(10) if i < 5]
print(nums) # [0, 1, 4, 9, 16]# 4. 嵌套链表定义
re = []
for i in range(2):
re.append([])
for j in range(3):
re[i].append(str(i) + "_" + str(j))
print(re) # [['0_0', '0_1', '0_2'], ['1_0', '1_1', '1_2']]3.2 增加元素 【增】
+ ， *
# 1. 运算符 +，*
nums1 = [1, 2, 3]
nums2 = [4, 5, 6]
print(nums1 + nums2) # [1, 2, 3, 4, 5, 6]
print(nums1 * 2) # [1, 2, 3, 1, 2, 3]arr.append()
# 2. nums.append(obj),在列表末尾添加新的对象
nums1 = [1, 2, 3]
nums1.append(4) # [1, 2, 3, 4]
nums1.append([4, 5]) # [1, 2, 3, [4, 5]]arr.insert()
# 3. nums.insert(index, obj),在下标为index的位置插入新对象
nums1 = [1, 2, 3]
nums1.insert(2, 100) # [1, 2, 100, 3]
nums1.insert(2, [55, 66]) # [1, 2, [55, 66], 3]arr.extend()
# 4. nums.extend(list),将list中的元素插入到nums中
nums1 = [1, 2, 3]
nums1.extend([4, 5, 6]) # [1, 2, 3, 4, 5, 6]3.3 删除元素
arr.pop(index)
# 1. nums.pop(index)函数
nums = [1, 2, 3, 4]
nums.pop() # [1, 2, 3]
nums.pop(1) # [1, 3, 4]arr.remove(obj)
# 2. remove(obj)函数
nums = [1, 1, 2, 3, 4]
nums.remove(1) # [1, 2, 3, 4], 只会删除最左边一个
nums.remove(9) # 元素不存在会报错3.4 修改元素
nums = [1, 2, 3]
nums[1] = 555
print(nums) # [1, 555, 3]3.5 查询元素
nums = [1, 2, 2, 3, 4, 4, 4, 5]
# 1. 元素读取采用切片方式
print(nums[1:5]) # [2, 2, 3, 4]
# 2. len(list) 查看列表长度
print(len(nums)) # 8
# 3. nums.count(obj)查看某个元素在列表中出现的个数
print(nums.count(4)) # 3
# 4. 查看最值
print(max(nums)) # 5
print(min(nums)) # 13.6 列表其他函数
3.6.1 翻转列表
arr.reverse()
# 1. 翻转列表
nums = [1, 2, 3, 4, 5]
nums.reverse()
print(nums) # [5, 4, 3, 2, 1]3.6.2 列表排序
arr.sort() ： inplace, 所以不能 tuple.sort(), 只能sorted(tuple).
# 2. 列表排序
nums = [1, 3, 2, 4, 5]
nums.sort()
print(nums) # [1, 2, 3, 4, 5]sorted(arr)
# 列表排序
arr=[1, 3, -2 ,-7, 9]
arr_sort_abs = sorted(arr, key = lambda x:abs(x))
print(arr) # [1, 3, -2, -7, 9]
print(arr_sort_abs) # [1, -2, 3, -7, 9]3.6.3 模拟栈和队列操作
# 模拟栈操作：append(obj), pop()
nums = [1,2,3]
nums.append(4)
print(nums) # [1, 2, 3, 4]
nums.pop()
print(nums) # [1, 2, 3]# 模拟队列操作： insert(0, obj), pop()
nums = [1,2,3]
nums.insert(0, 4)
print(nums) # [4, 1, 2, 3]
nums.pop()
print(nums) # [4, 1, 2]四、Tuple
- 元组用“（）”标识，类似于只读列表，不能二次赋值。
- 元组中含有列表等可变对象时，列表元素是可以更改的。
简单用法如下所示：
t = (1, 'hello', 'Python', 1)
print(t[0:2]) # (1, 'hello')
print(t.index('Python')) # 2
print(t.count(1)) # 2元组中只有一个元素的情况
# 括号()既可以表示tuple，又可以表示数学公式中的小括号。
# Python规定，这种情况下，按小括号进行计算。
# 所以，只有1个元素的tuple定义时必须加一个逗号','，来消除歧义。
t = (1) # t表示一个数1
t = (1,) # t表示元组(1)
五、Dictionary
字典用“{ }”标识，由索引（key）和对应的值（value）组成，可存储任意类型的对象。注意列表是有序的对象集合，而字典是无序的对象集合。
dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较，dict有以下几个特点：1. 查找和插入的速度极快，不会随着key的增加而变慢；2. 需要占用大量的内存，内存浪费多。所以，dict是用空间来换取时间的一种方法。
需要牢记的第一条就是dict的key必须是不可变对象。
5.1 字典定义
dict = {1: "one", 2: "two"}
print(dict) # {1: 'one', 2: 'two'}
# 错误示例
dict = {[1]: "one"}
print(dict) # 程序崩溃，key必须是不可变对象aDict = {'Wangdachui': 3000, 'Niuyun':2000, 'Linling':4500, 'Tianqi':8000}
bDict = dict( [('Wangdachui',3000), ('Niuyun',2000), ('Linling',4500), ('Tianqi',8000)])
cDict = dict([['Wangdachui',3000], ['Niuyun',2000], ['Linling',4500], ['Tianqi',8000]])
dDict = dict(Wangdachui=3000, Niuyun=2000, Linling=4500, Tianqi=8000)
eDict = {}.fromkeys(('Wangdachui', 'Niuyun', 'Linling', 'Tianqi'),3000)
# {'Tianqi': 3000, 'Wangdachui': 3000, 'Niuyun': 3000, 'Linling': 3000}
names = ['Wangdachui','Niuyun','Linling','Tianqi']
salaries = [3000, 2000, 4500, 8000]
fDict = dict(zip(names,salaries))5.2 字典增加和修改元素
dict = {1: "one", 2: "two"}
dict[3] = "three" # 索引不存在，则增加该键值对
dict[1] = "change" # 索引存在，则修改对应值
print(dict) # {1: 'change', 2: 'two', 3: 'three'}5.3 删除元素
dict.clear()
dict = {1: "one", 2: "two"}
# 1. dict.clear()清除字典中的所有键值对
dict.clear()
print(dict) # {}del dict
aInfo = {'Wangdachui': 3000, 'Niuyun':2000, 'Linling':4500, 'Tianqi':8000}
del aInfo # 删除字典dict.pop(key)
dict = {1: "one", 2: "two"}
# 2. 使用dict.pop(index， default)删除索引为index的键值对，不存在时则返回default
print(dict.pop(1, -1)) # one
print(dict) # {2: 'two'}
print(dict.pop(3, -1)) # -1
print(dict) # {2: 'two'}dict.popitem()
dict = {1: "one", 2: "two"}
# 3. 使用dict.popitem()随机删除字典内容
dict.popitem()5.4 查询词典元素和属性
5.4.1 获取元素
# 1. 通过下标的方式获取元素，key不存在时崩溃
dict = {1: "one", 2: "two"}
print(dict[1]) # one
print(dict[3]) # 报错dict.get(key)
# 2. 通过dict.get(key)方式获取
dict = {1: "one", 2: "two"}
print(dict.get(2)) # two
print(dict.get(3)) # None
print(type(dict.get(3))) # <class 'NoneType'>5.4.2 查询属性
# 1. 使用len(dict)查询键值对个数
dict = {1: "one", 2: "two"}
print(len(dict)) # 2key in dict
# 2. 查询key是否在字典中
dict = {1: "one", 2: "two"}
print(1 in dict) # True
print(3 in dict) # Falsedict.keys()
# 3. 通过dict.keys()获取所有索引
dict = {1: "one", 2: "two"}
print(dict.keys()) # dict_keys([1, 2])
print(type(dict.keys())) # <class 'dict_keys'>
dkeys = list(dict.keys())
print(dkeys[0]) # 1dict.values()
# 4. 通过dict.values()获取所有的值
dict = {1: "one", 2: "two"}
print(dict.values()) # dict_values(['one', 'two'])
print(type(dict.values())) # <class 'dict_values'>
dvalues = list(dict.values())
print(dvalues[0]) # one5.5 字典其他函数用法
5.5.1 dict.items()
dict = {1: "one", 2: "two"}
# 1. 使用dict.items()返回可遍历的(key, value)元组列表
print(dict.items()) # dict_items([(1, 'one'), (2, 'two')])
# 2
for k, v in d.items():
pass5.5.2 按key值或value值排序输出
dict = {3:"a", 1:"c", 2:"b"}
print(dict) # {3: 'a', 1: 'c', 2: 'b'}
# 按key值排序输出
print(sorted(dict.items(),key=lambda x:x[0])) # [(1, 'c'), (2, 'b'), (3, 'a')]
# 按value值排序输出
print(sorted(dict.items(),key=lambda x:x[1])) # [(3, 'a'), (2, 'b'), (1, 'c')]六、Set
- set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
- set和dict的唯一区别仅在于没有存储对应的value。但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。
# 1. 基本操作
s = set([1, 1, 2, 2, 3, 3])
print(type(s)) # <class 'set'>
print(s) # {1, 2, 3}
s.add(4)
print(s) # {1, 2, 3, 4}
s.remove(2)
print(s) # {1, 3, 4}# 2. 集合操作
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print(s1 & s2) # {2, 3}
print(s1 | s2) # {1, 2, 3, 4}aSet = set('sunrise')
bSet = set('sunset')
aSet & bSet # set(['u', 's', 'e', 'n'])
aSet | bSet # set(['e', 'i', 'n', 's', 'r', 'u', 't'])
aSet - bSet # set(['i', 'r'])
aSet ^ bSet # set(['i', 'r', 't'])
aSet -= set('sun') # set(['e', 'i', 'r'])
七、 其他数据类型
7.1 布尔值
布尔值只有
True、False两种值，要么是True，要么是False。在Python中，可以直接用True、False表示布尔值（注意大小写），也可以通过布尔运算计算出来。布尔值可以用
and、or和not运算。
7.2 空值
空值是Python里一个特殊的值，用
None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
八、数据类型转换
repr() 和 eval()函数
dict = {1: "one", 2: "two"}
l = [1, 2, 3]
t = (1, 2, 3)
# 1. repr(obj)函数将对象转换成可以被eval(str)函数解析的字符串
repr_dict = repr(dict)
repr_l = repr(l)
repr_t = repr(t)
print(type(repr_dict), repr_dict) # <class 'str'> {1: 'one', 2: 'two'}
print(type(repr_l), repr_l) # <class 'str'> [1, 2, 3]
print(type(repr_t), repr_t) # <class 'str'> (1, 2, 3)
# 2. eval(str) 将字符串按格式解析成相关数据类型
eval_dict = eval(repr_dict)
eval_l = eval(repr_l)
eval_t = eval(repr_t)
print(type(eval_dict), eval_dict) # <class 'dict'> {1: 'one', 2: 'two'}
print(type(eval_l), eval_l) # <class 'list'> [1, 2, 3]
print(type(eval_t), eval_t) # <class 'tuple'> (1, 2, 3)
扫一扫
7029
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
