python数据类型

python六大标准数据类型

1. Number（数字）
2. String（字符串）
3. List（列表）
4. Tuple（元组）
5. Set（集合）
6. Dictionary（字典）

注意点：

1. Number（数字）、String（字符串）、Tuple（元组）属于不可变数据类型
2. List（列表）、Dictionary（字典）、Set（集合）属于可变数据类型
3. 内置的 type() 函数可以用来查询变量所指的对象类型。isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型。isinstance()会认为子类是一种父类类型。

 

一、Number（数字）

1. int（有符号整型）
2. float（浮点型）
3. bool（布尔型）
4. complex（复数）

用法：

1. +，-，*，/，%
2. // 除法，得到一个整数，即地板除
3. ** 乘方
4. 浮点型也可以用科学计数法表示，2.5e2= 2.5 x 102 = 250
5. 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

注意点：

1. 在python2.x中，当你的数值小于int范围的时候，就是int变量，当大于int范围的时候，就是long类型了。当变量大于int范围的时候，python会自动帮你把数据类型转为long类型的。在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647,在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
2. 在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。Python3 整型是没有限制大小的
3. 整数除法返回浮点型，不同类型的数混合运算时会将整数转换为浮点数
4. 在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

数学函数：

1. abs(x)，返回数字的绝对值，如abs(-10) 返回 10
2. ceil(x)，返回数字的上入整数，如math.ceil(4.1) 返回 5
3. cmp(x, y)，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃 。使用 使用 (x>y)-(x<y) 替换
4. exp(x)，返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
5. fabs(x)，返回数字的绝对值，如math.fabs(-10) 返回10.0
6. floor(x)，返回数字的下舍整数，如math.floor(4.9)返回 4
7. log(x)，如math.log(math.e)返回1.0,math.log(100,10)返回2.0
8. log10(x)，返回以10为基数的x的对数，如math.log10(100)返回 2.0
9. max(x1, x2,...)，返回给定参数的最大值，参数可以为序列。
10. min(x1, x2,...)，返回给定参数的最小值，参数可以为序列。
11. modf(x)，返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
12. pow(x, y)，x**y 运算后的值。
13. round(x [,n])，返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
14. sqrt(x)，返回数字x的平方根

用法案例：

# Python3 整型是没有限制大小的
a = 922337203685477580811
print(type(a))
# // 得到的并不一定是整数类型的数
print(7 / 2)  # 3.5
print(7 // 2)  # 3
print(7.0 / 2)  # 3.5
print(7.0 // 2)  # 3.0
"""数学函数"""
# abs,ceil,cmp,exp,fabs,floor,log,log10,max,min,modf,pow,round,sqrt
# 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
print(math.modf(10.3))
"""随机数"""
# choice,randrange,random,seed,shuffle,uniform,randint
for i in range(20):
    # 从序列的元素中随机挑选一个元素
    print(random.choice(range(10)), end='')
print()  # 33430436396496623185
for i in range(20):
    # 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
    print(random.randrange(2, 10, 2), end='')
print()  # 28626622688248468282
# 随机生成下一个实数,它在[0,1)范围内。
print(random.random())  # 0.6905597758450086
# 使用相同的随机数种子，相同的次序生成的随机数是相同的
random.seed(1)
print(random.random())
# 将序列的所有元素随机排序
a = [1, 2, 3, 4, 5]
random.shuffle(a)
print(a)  # [5, 2, 3, 4, 1]
# 随机生成下一个实数，它在[x, y]范围内。
for i in range(4):
    print(random.uniform(1, 9), end=' ')
print()  # 7.643509634313039 1.817455568060705 8.719267117297669 6.719165339718973
# 随机生成[x, y]的整数
for i in range(20):
    print(random.randint(0, 3), end='')
print()  # 30330321020000313013
"""三角函数"""
# acos,asin,atan,atan2,cos,hypot,sin,tan,degress,radians
# 返回欧几里德范数 sqrt(x*x + y*y)。
print(math.hypot(3, 4))  # 5.0
# 将弧度转换为角度
print(math.degrees(math.pi / 2))  # 90.0
# 将角度转换为弧度
print(math.radians(180))  # 3.141592653589793
"""数学常量"""
print(math.pi)  # 3.141592653589793
print(math.e)  # 2.718281828459045

 

二、String（字符串）

用法：

1. 字符串可以使用+和*操作
2. 字符串可以进行切片操作
3. in操作 可以判断一个字符串在不在另一个字符串中 'a' in 'abbc'
4. 字符串拼接方式
   1. 'a' + 'b'
   2. '%sxxx%sx' % ('a', 'b') 字符串格式化
   3. ''.join(['a', 'b']
   4. 字符串用+拼接会多开辟内存空间， 最好使用%格式化字符串，或者.format
   5. join方式在大量数据拼接时快于+方式， 参考该文章http://www.sohu.com/a/162334410_776230，结论是如果连接的字符串很少，只有几个或者十几个，完全可以通过「+」来连接，毕竟这种方式更直白，而超过一定个数之后，则应该采用「join」方法，只有在操作大数据的时候，两者的对比才明显。

注意点：

1. 字符串前面加r是代表这个string是raw string，让反斜杠不发生转义
2. 字符串不能被改变
3. 反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

用法案例：

# 反斜杠(\)可以作为续行符，表示下一行是上一行的延续。
# 也可以使用 """...""" 或者 '''...''' 跨越多行。
a = '111' \
    '222'
b = '''33\
444\
555'''
print(a)  # 111222
print(b)  # 33444555
print(a[3])  # 2
print(a[0:3])  # 111
"""字符串内建函数"""
st = 'hello world'
print(st.count('l'))  # 统计元素个数        3
print(st.capitalize())  # 首字母大写         Hello world
print(st.center(50, '-'))  # 居中                -------------------hello world--------------------
print(st.encode('utf-8'))
print(st.endswith('ld'))  # 是否以某个字符串结尾
print(st.startswith('he'))  # 是否以某个字符串开头
print('he\tllo world'.expandtabs(20))  # tab替换成n个空格       he                  llo world
print(st.find('e'))  # 查找到第一个匹配的元素，并返回索引值        1
print('hello {1} world {0} {name}'.format('and', 'hi', name='xxx'))  # 格式化字符串       hello hi world and xxx
print('hello {{world}} {name}'.format_map({'name': 'xxx'}))  # 格式化字符串       hello {world} xxx
print(st.index('l'))  # 找不到会报错，find找不到返回-1        2
print('abc123'.isalnum())  # 只包含数字字母
print('11'.isdecimal())  # 是否为十进制数
print('222'.isdigit())  # 是否为数字
print('222'.isnumeric())  #
print('b222'.isidentifier())  # 是否合法变量名
print('asdad'.islower())  # 字符串里的字母是否全部小写
print('ADSD'.isupper())  # 字符串里的字母是否全部大写
print(' \t\r\n'.isspace())  # 是否为空白符(空格，制表，回车)
print('Adsadsd Bs'.istitle())  # 每个单词首字母大些
print('AvdsVSDF'.lower())  # avdsvsdf
print('AvdsVSDF'.upper())  # AVDSVSDF
print('AvdsVSDF'.swapcase())  # aVDSvsdf
print(st.ljust(50, '-'))  # 靠左        hello world---------------------------------------
print(st.rjust(50, '-'))  # 靠右        ---------------------------------------hello world
print('\t 1 354z\n'.strip())  # 去掉两边的空白符号(空格，制表，回车)
print('\t 1 354z\n'.lstrip())  # 去左
print('\t 1 354z\n'.rstrip())  # 去右
print('123a11sd'.replace('1', 'aa', 1))  # 替换一次      aa23a11sd
print('123a11sd'.rfind("1"))  # 同find 从右往左找   5
print('123,213,321'.split(','))  # 分割成列表，list.join的逆过程 ['123', '213', '321']
print('123,213,321'.rsplit(',', 1))  # 从右往左 分割一次 ['123,213', '321']
print('s\na\n'.splitlines())  # 根据换行符分割
print('123 asd aqsz'.title())  # 单词首字母变成大写
print('qq ww ee'.translate(str.maketrans('qwe', '123')))  # 11 22 33
print(max('abc'))  # c
print(min('abc'))  # a
print('1'.zfill(2))  # 前面补0  01

 

三、List（列表）

用法：

1. 查：
   1. 索引(下标)，是从0开始的
   2. 切片操作
   3. .count()查某个元素的出现次数
   4. .index()根据内容找其所在的位置
   5. 'xx' in a 根据内容查看是否在列表中
2. 增：
   1. .append('xx')追加
   2. .insert(index, "xx") 在index位置前插入元素
   3. .extend() 扩展
   4. + × 两个列表相加，乘一个整数
3. 改：
   1. a[index] = "xx"
   2. a[start: end] = ['aa', 'bb']
4. 删除：
   1. a.remove('xx')
   2. a.pop(index) 不指定index删除最后一个
   3. del a, del a[1]
   4. a.clear() 清空列表
5. 排序
   1. a.sort()
   2. a.reverse()
6. 身份判断
   1. type(a) is list 用==结果相同

enumerate用法：

1. 一个列表既要遍历索引又要遍历元素时用enumerate，如for index, item in enumerate(list1)
2. enumerate还可以接收第二个参数，用于指定索引起始值,默认为0
3. enumerate()返回的对象其实是由一个个元组组成的，可以赋给一个变量，也可以赋给两个变量
4. python可以直接交换两个变量的位置，其他语言基本不可以

用法案例：

"""list的增删改查和其他常用方法"""
# 查
a = ['aa', 'bb', 'cc', 'dd', 'ee']
print(a[1:])  # ['bb', 'cc', 'dd', 'ee']
print(a[1:-1])  # ['bb', 'cc', 'dd']
print(a[1::2])  # ['bb', 'dd']
print(a[3::-2])  # ['dd', 'bb']
print(a[3::-1])  # ['dd', 'cc', 'bb', 'aa']
print(a.count('aa'))  # 1
print(a.index('aa'))  # 0
print('aa' in a)  # True
# 查找第二个aa的位置
b = ['aa', 'bb', 'aa', 'cc', 'dd', 'ee']
print(b.index('aa', b.index('aa') + 1))  # 2
# 增
a.append('ff')
a.insert(1, 'ss')
print(a)  # ['aa', 'ss', 'bb', 'cc', 'dd', 'ee', 'ff']
print(a + ['gg'])  # ['aa', 'ss', 'bb', 'cc', 'dd', 'ee', 'ff', 'gg']
print(a * 2)  # ['aa', 'ss', 'bb', 'cc', 'dd', 'ee', 'ff', 'aa', 'ss', 'bb', 'cc', 'dd', 'ee', 'ff']
# b的元素加到a列表中
b = ['hh', 'jj']
a.extend(b)
print(a)  # ['aa', 'ss', 'bb', 'cc', 'dd', 'ee', 'ff', 'hh', 'jj']
print(b)  # ['hh', 'jj']
# 改
a[1] = 'hh'
print(a)  # ['aa', 'hh', 'bb', 'cc', 'dd', 'ee', 'ff', 'hh', 'jj']
a[1:3] = ['q', 'w']
print(a)  # ['aa', 'q', 'w', 'cc', 'dd', 'ee', 'ff', 'hh', 'jj']
# 删
a.remove('q')
print(a)  # ['aa', 'w', 'cc', 'dd', 'ee', 'ff', 'hh', 'jj']
print(a.pop(1))  # w
print(a)  # ['aa', 'cc', 'dd', 'ee', 'ff', 'hh', 'jj']
del a[1:3]
print(a)  # ['aa', 'ee', 'ff', 'hh', 'jj']
del a
# print(a) # name 'a' is not defined
a = ['aa', 'ee', 'ff', 'hh', 'jj']
a.clear()
print(a)
# 反转列表
a = ['aa', 'ee', 'ff', 'hh', 'jj']
a.reverse()
print(a)  # ['jj', 'hh', 'ff', 'ee', 'aa']
# 按升序排序, 字符串会按照ascii大小
x = [4, 6, 2, 1, 7, 9]
x.sort()
print(x)  # [1, 2, 4, 6, 7, 9]
# 按降序排序
x.sort(reverse=True)
print(x)  # [9, 7, 6, 4, 2, 1]
# 身份判断
print(type(x) is list)  # True

 

四、Tuple（元组）

用法：

1. 查操作，+ ×操作，身份判断都和列表用法相同

注意点：

1. 不可变对象，tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
2. 构造包含 0 个或 1 个元素的元组比较特殊，有一些额外的语法规则：
   1. tup1 = () # 空元组
   2. tup2 = (20,) # 一个元素，需要在元素后添加逗号
3. 可以把字符串看作一种特殊的元组。

用法案例：

"""元组 查,+*,身份判断"""
# 查
a = ('aa', 'bb', 'cc', 'dd', 'ee')
print(a[1:2])  # ('bb',)
print(a.count('aa'))  # 1
print(a.index('aa'))  # 0
print('aa' in a)  # True
# +*操作
print(a + ('ff',))  # ('aa', 'bb', 'cc', 'dd', 'ee', 'ff')
print(a * 2)  # ('aa', 'bb', 'cc', 'dd', 'ee', 'aa', 'bb', 'cc', 'dd', 'ee')
# 身份判断
print(type(a) is tuple)  # True
# 创建方式，创建1个与元素的元组
a = ('aa',)
print(a)  # ('aa',)

 

五、Set（集合）

注意点：

1. 集合（set）是一个无序不重复元素的序列。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
2. frozenset是不可变的集合，创建后不可更改

用法：

1. 创建方式：
   1. a= {'a', 'b', 'r', 'a', 'c', 'a'}
   2. a = set('abracadabra')
2. 增：
   1. a.add('q')
   2. a.update([5, 'c']) # 添加多个元素
   3. a.update('1234') # 添加4个元素
3. 删：
   1. a.remove(2) # 删除2这个元素
   2. a.pop() # 不确定删除哪个
   3. a.clear()
4. 运算：
   1. ==，判断是否相等
   2. <和>，a<b判断a是否为b的真子集
   3. 并集：
      1. a | b
      2. a.union(b)
   4. 交集：
      1. a & b
      2. a.intersection(b)
   5. 差集：
      1. a - b
      2. a.difference(b)
   6. 对称差集（不同时存在的元素）：
      1. a ^ b
      2. a.symmetric_difference(b)
   7. 父集：
      1. a.issuperset(b)
   8. 子集：
      1. a.issubset(b)

用法案例：

"""set增删，运算"""
# 创建方式
a = {1, 2, 3}
print(a)  # {1, 2, 3}
print(type(a))  # <class 'set'>
f = frozenset({1, 2})
print(f)  # frozenset({1, 2})
print(type(f))  # <class 'frozenset'>
# 增
a.add('q')
print(a)  # {1, 2, 3, 'q'}
a.update([5, 'c'])  # 添加多个元素
print(a)  # {1, 2, 3, 5, 'c', 'q'}
a.update('1234')
print(a)  # {1, 2, 3, '4', 5, '1', '2', 'c', 'q', '3'}
# 删
a.remove(2)
print(a)  # {1, 3, '4', 5, '1', '2', 'c', 'q', '3'}
a.pop()  # 不确定删除哪个
print(a)  # {3, '4', 5, '1', '2', 'c', 'q', '3'}
a.clear()
print(a)  # set()
# 运算
print(set('aa1') == set('a111'))  # True
print(set('aa1') < set('a1112'))  # True 前者是后者的真子集
print(set('aa1') | set('bb21'))  # 并集
print(set('aa1').union(set('bb21')))  # {'1', '2', 'a', 'b'}
print(set('aa21') & set('bb21'))  # 交集
print(set('aa21').intersection(set('bb21')))  # {'1', '2'}
print(set('aa1') - set('a2'))  # 差集
print(set('aa1').difference(set('a2')))  # {'1'}
print(set('aa1') ^ set('a2'))  # 对称差集
print(set('aa1').symmetric_difference(set('a2')))  # {'1', '2'}
print(set('aa1').issuperset(set('a')))  # True 父集
print(set('a').issubset(set('a1')))  # True 子集

六、Dictionary（字典）

注意点：

1. key只能用不可变类型
2. key是唯一的
3. 键值对是无序存储的

用法：

1. 创建方式：
   1. d = dict.fromkeys(['q', 'w', 'e'], 'test')
   2. a = {"name": "xx"}
2. 查：
   1. d['xx']
   2. d.get('xxx')
   3. d.setfault('xx', 10)
   4. list(a.keys()),list(a.values()),list(a.items()
3. 增：
   1. d["xxx"] = 21
   2. d.update(d2) 把d2字典的内容加到d字典中去
4. 改：
   1. d["xxx"] = 21
5. 删除：
   1. del d['xx']
   2. del d
   3. d.clear()
   4. a.pop('hobby')
   5. a.popitem() 删除内容不可预测
6. 排序
   1. sorted(a)，sorted(a.keys())，sorted(a.values())
7. 遍历
   1. for k, v in d.items()，for k in d

用法案例：

"""dict增删改查，排序，遍历"""
# 创建方式
a = dict.fromkeys(['q', 'w', 'e'], 'test')
print(a)  # {'q': 'test', 'w': 'test', 'e': 'test'}
a = {'name': 'xx', 'age': 21}
print(a)  # {'name': 'xx', 'age': 21}
# 查
print(a['name'])  # xx
print(a.get('name'))  # xx
# setdefault()若键存在返回相应的值，不存在则添加键值对并返回值
print(a.setdefault('age', 34))  # 21
print(a.setdefault('hobby', 'game'))  # game
print(a)  # {'name': 'xx', 'age': 21, 'hobby': 'game'}
# 取所有键，所有值，所有键值对
print(list(a.keys()))  # ['hobby', 'age', 'name']
print(list(a.values()))  # ['game', 21, 'xx']
print(list(a.items()))  # [('hobby', 'game'), ('age', 21), ('name', 'xx')]
# 增
# 添加键值对 或 修改值
a['age'] = 30
print(a)  # {'name': 'xx', 'age': 30, 'hobby': 'game'}
# update 将a字典的元素逐个放到b里，键相同的则覆盖
b = {'name': 'aa', 'qq': 1}
b.update(a)
print(b)  # {'name': 'xx', 'qq': 1, 'age': 30, 'hobby': 'game'}
# 删除
del a['name']
print(a)  # {'age': 30, 'hobby': 'game'}
# del a
# print(a)  # name 'a' is not defined
a.clear()
print(a)  # {}
a = {'age': 21, 'hobby': 'game', 'name': 'xx'}
print(a.pop('hobby'))  # game
print(a)  # {'age': 21, 'name': 'xx'}
print(a.popitem())  # ('name', 'xx') 删除内容不可预测
# 其他操作
a = {'age': '21', 'hobby': 'game', 'name': 'xx'}
print(sorted(a))  # ['age', 'hobby', 'name']
print(sorted(a.keys()))  # ['age', 'hobby', 'name']
print(sorted(a.values()))  # ['21', 'game', 'xx']
# 遍历
for k in a:
    print(k, a[k], sep=':', end=',')  # age:21,name:xx,hobby:game,
print()
for k, v in a.items():
    print(k, v, sep=':', end=',')  # age:21,name:xx,hobby:game, 效率比上面那种低

七、数据类型的转换

1. int(x [,base])，将x转换为一个整数
2. float(x)，将x转换到一个浮点数
3. complex(real [,imag])，创建一个复数
4. str(x)，将对象 x 转换为字符串
5. repr(x)，将对象 x 转换为表达式字符串
6. eval(str)，用来计算在字符串中的有效Python表达式,并返回一个对象
7. tuple(s)，将序列 s 转换为一个元组
8. list(s)，将序列 s 转换为一个列表
9. set(s)，转换为可变集合
10. dict(d)，创建一个字典。d 必须是一个序列 (key,value)元组。
11. frozenset(s)，转换为不可变集合
12. chr(x)，将一个整数转换为一个字符
13. ord(x)，将一个字符转换为它的整数值
14. hex(x)，将一个整数转换为一个十六进制字符串
15. oct(x)，将一个整数转换为一个八进制字符串