基本数据类型--目录
基本数据类型
python基本数据类型包括：
数字类型( int float complex )、布尔值( bool )、字符串( str )、列表( list )、元组( tuple )、字典( dict )、集合( set )。
一、查看数据类型的方法
1 type(…)： 查看数据类型
temp = 'hello'
t = type(temp)
print(t) # <class 'str'>
2 help(type(…))： 查看该数据类型下的所有方法
temp = 'hello'
help(type(temp))
# Help on class str in module builtins:
3 dir(…)：查看类下面所有方法的名字
temp = 'hello'
d = dir(temp)
print(d)
# ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
4 查看某一类下的特定方法：Ctrl + 鼠标左键点击该方法名
二、数字类型
1 int 整型
整型有四种进制表示：二进制、八进制、十进制、十六进制。（默认为十进制，其他需要使用引导符号） 
# 1.整型int
a = 88 # 十进制
print('a的数据类型是：', type(a)) # a的数据类型是： <class 'int'>
b = 0b1110 # 二进制
print('b的数据类型是：', type(b))
c = 0o57 # 八进制
print('c的数据类型是：', type(c))
d = 0xa5c # 十六进制
print('d的数据类型是：', type(d))
# 整数类型，理论取值范围[-无穷，+无穷], 实际取值范围受限于运行的计算机的内存大小。
# 32位机器：-2**31~2**31-1；64位：-2**63~2**63-1
2 float 浮点型
浮点型：数值带有小数部分。
两种表示方式：
十进制：1.20 32.159
科学记数法：1.2e3 0.5E6
浮点型参与计算时结果不精确。
# 浮点数float
a = 0.0
print('a的类型是：', type(a))
b = 75.
print('b的类型是：', type(b))
c = -3.1415926
print('c的类型是：', type(c))
d = 9.8e-2
print('d的类型是：', type(d))
s = 0.1 + 0.2
print(s) # 0.30000000000000004 不精确
print('s的类型是：', type(s))
3 complex 复数
注意复数分为实数部分和虚数部分
# 复数complex
a = 12.3 + 4j
print('a的数据类型是：', type(a)) # a的数据类型是： <class 'complex'>
print(a.real) # 12.3
print(a.imag) # 4.0
4 数字类型之间的转换–内置数字类型转换函数
三、布尔值 bool
只分为True和False
非零、非空 的布尔值皆为True
同理，零 和 空 即为False
# 布尔值bool：True和False
# 变量初始化
a = 2
b = 3.14
c = '5'
d = 0
e = ""
print("a的布尔值是：", bool(False))
print("b的布尔值是：", bool(None))
print("c的布尔值是：", bool(""))
print("d的布尔值是：", bool([]))
print("e的布尔值是：", bool(()))
四、字符串 str
1 查看和使用方法
Ctrl + 鼠标左键 点击方法名 查看方法用途和使用方法
先查看数据类型(type)，然后查看类下的方法名(div)，再查看方法如何使用(Ctrl + 左键)
# S.count(sub[, start[, end]]) -> int
b = "hello,world"
print(b.count("l")) # 3
print(b.count('l', 3)) # 2
print(b.count('l', 3, 8)) # 1
2 常用方法
2.1 索引取值
# 索引取值
s = 'hello,TZ'
print(s[0])
# 长度len()
print(len(s))
2.2 切片
# 切片
# 切片：变量[头下标：尾下标]，不包含尾下标（包头不包尾）
s = 'hello.TZ'
print(s[2:5])
print(s[-6:-3]) # 从头往后切
print(s[5:2]) # 不能交叉取值
print(s[0])
print(s[-8])
print(s[0:5:1]) # 步长为1
print(s[0:5:2])
print(s[::-1]) # 步长为负时 从后往前切 下标也应该从后往前写
print(s[::-2])
2.3 移除空白 strip( )
# 移除空白strip() left right
# S.strip([chars]) -> str
s1 = " hello,TZ "
s = 'hello.TZ'
print(s)
print(s1)
print(s1.strip()) # 移除两端空格
print(s1.lstrip()) # 移除左端空格
print(s1.rstrip()) # 移除右端空格
print(s.strip("Z")) # 移除两端指定的字符
2.4 分割 split()
# 分割split
# S.split(sep=None, maxsplit=-1) -> list of strings
s = 'hello,TZ'
print(s.split(',')) # ['hello', 'TZ']
print(s.split()) # ['hello,TZ']
print(s.split("l", 1)) # ['he', 'lo,TZ']
print(s.split("l", 2)) # ['he', '', 'o,TZ']
3 取消转义
print('after\\noon') #转义字符前面添加 \
print(r'after\noon') #在字符串外面加 r
print('\n')
4 字符串拼接
# 通过使用 + 实现字符串拼接
s1 = "a"
s2 = "b"
s3 = s1 + s2
print(s3) # ab
print("1:" + s3) # 1:ab
print("1:", s3) # 1: ab
五、 列表 list
1 变量的初始化
# 变量的初始化
a = [] # 空列表
b = [1, True, 'abc', []]
print('a的类型是：', type(a)) # a的类型是： <class 'list'>
print('b的类型是：', type(b)) # a的类型是： <class 'list'>
2 索引
# 索引
L = ['a', 'b', 'c']
print(L[0])
print(L[-3])
3 列表是有序可变的元素集合
# 列表是有序的可变的元素集合 。
L[0] = 'w'
print(L[0])
print(L)
4 长度 len( )
# 长度len()
print(len(L))
5 切片
# 切片
L = ['a', 'b', 'c']
print(L[:2])
print(L[-3:-1])
6 排序 sort()
# 排序sort
# L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
L = ['a', 'c', 'b']
L.sort() # 返回值为None 此操作是对原列表的修改
print("正序1：", L)
L.sort(reverse=True) # 逆序
print("2:", L)
L.reverse()
print("3:", L)
7 增删改查
7.1 增
# 增
L = ['a', 'b', 'c']
# 追加：append、
# 批量追加：extend
# 插入：insert
L.append('d')
print(L)
L2 = [1, 2, 3]
L.extend(L2)
print(L)
L.insert(1, 'w')
print(L)
7.2 删除
# 删除
# 删一个尾巴,并且该尾巴可以赋值给另一个变量：pop
# 移除左边起第一个指定的元素：remove
# 删除指定索引元素：del
# 清空：clear
a = L.pop()
print(a)
print(L)
L.append('w')
print(L)
L.remove('w')
print(L)
del(L[1])
print(L)
L.clear()
print(L)
7.3 改
通过索引赋值可以直接修改
L[0] = 'w'
7.4 查（包含 in ）
判断元素是否在列表中
# 包含in
L = ['a', 'b', 'c']
a = 'c'
b = 'd'
print(a in L) # True
print(b in L) # False
六、元组 tuple
tuple元组是有序的不可变的元素集合
1 变量的初始化
元素可以是任何类型的数据
a = () # 空元组
b = (1, False, 'ab', [], ())
print('a的类型是：', type(a)) # a的类型是： <class 'tuple'>
print('b的类型是：', type(b)) # a的类型是： <class 'tuple'>
# 注意：单元素元组要注意，带上‘，’
f = ('hello')
g = ('hell0',)
print('f的类型是：', type(f)) # f的类型是： <class 'str'>
print('g的类型是：', type(g)) # g的类型是： <class 'tuple'>
2 索引
T = ('a', 'b', 'c')
print(T[1]) # 通过索引去取值
# T.index(value, [start, [stop]]) -> integer
print(T.index('b')) # 通过值去获取索引
# T.count(value) -> integer
print(T.count('b'))
3 长度 len()
print(len(T))
4 切片
print(T[1:])
print(T[-2:])
5 包含
T = ('a', 'b', 'c')
a = 'c'
b = 'w'
print(a in T)
print(b in T)
七 字典 dict
dict 字典是由键值对构成(key、value)的可变的无序集合
key值唯一互不相同
# dict字典是由键值对构成（key、value）的无序集合
# （不像字符串、列表和元祖那样有固定的位置）。
# 1，"a", ['ab', 2, 'c'], ('ab', 2, 'c')
# 姓名：xf， 密码：123456，。。。。。。。。。。。。。。
# {key: value}
1 变量初始化
# 字典key一般使用数字或者字符串，也可以使用元组， value可以使用任何类型的数据类型
a = {} # 空字典
print('a的数据类型是：', type(a)) # a的数据类型是： <class 'dict'>
b = {
1: 2, # key:数字，value：数字
'k1': 'v1', # key:字符串， value：字符串
False: True,
'k2': [1, 2, 3], # value:列表
(1, 2, 3): (1, 2, 3), # key: 元组， value：元组
'k3': { # value: 字典
'k2': 'v2',
'k4': 'v9',
'k5': {}
},
}
print('b的数据类型是：', type(b))
2 常用功能
D = {
'k1': 'v1',
'k2': 'v2',
'k3': 'v3',
}
D1 = {}
L = [1, 2, 3]
print(D1.fromkeys(L))
print(D1.fromkeys(L, 'v'))
2.1 长度 len()
# 长度len()
print(len(D))
2.2 键、值、键值对
# 键、值、键值对
print(D.items()) # dict_items([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
print(D.keys()) # dict_keys(['k1', 'k2', 'k3'])
print(D.values()) # dict_values(['v1', 'v2', 'v3'])
2.3 获取值
2.3.1 第一种方法：通过key值去取value值 D(key)
print(D['k1'])
D = {
'k1': 'v1',
'k2': 'v2',
'k3': 'v3',
}
2.3.2 第二种方法：D.get()
# D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
# 通过给定的key查找对应的value值，如果给定的key在字典中，返回对应的value，如果不在，则默认返回None（如果设置了d，则返回d）
print("="*20)
print(D.get('k3'))
print(D.get('k4'))
print(D)
print(D.get('k4', 'false'))
2.3.3 第三种方法：D.setdefault()
# 第三种D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
# 通过给定的key查找对应的value值，如果给定的key在字典中，返回对应的value，如果不在,返回默认值，同时，在字典中增加了key：默认值的键值对（默认为None，如果设置了d，则使用d）
print("="*20)
print(D.setdefault("k3"))
print(D.setdefault("k4"))
print(D)
print(D.setdefault("k5", "v5"))
print(D)
# 第三种D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
# 通过给定的key查找对应的value值，如果给定的key在字典中，返回对应的value，如果不在,返回默认值，同时，在字典中增加了key：默认值的键值对（默认为None，如果设置了d，则使用d）
print("="*20)
print(D.setdefault("k3"))
print(D.setdefault("k4"))
print(D)
print(D.setdefault("k5", "v5"))
print(D)
3 增删
3.1 增
3.1.1 第一种方法：通过key，key有则改，无则增
D = {
'k1': 'v1',
'k2': 'v2',
'k3': 'v3',
}
print("="*20)
print(D['k1'])
D['k1'] = 'w'
print(D['k1'])
D['k4'] = 'v4'
print(D)
3.1.2 第二种方法：D.setdefault()
# key有获取，无则新增
print(D.setdefault("k3"))
print(D.setdefault("k5", "v5"))
print(D)
3.2 删
D = {
'k1': 'v1',
'k2': 'v2',
'k3': 'v3',
}
3.2.1 第一种方法：D.pop()
# pop:(获取并删除指定key值项)
# D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
# If key is not found, d is returned if given, otherwise KeyError is raised
a = D.pop('k2')
print(a)
print(D)
3.2.2 第二种方法：D.popitem()
# popitem:获取并在字典中移除最后一项
b = D.popitem()
print(b)
print(D)
3.2.3 第三种方法：D.clear()
# clear(清空)
D.clear()
print(D) # {}
八、集合
集合： 一个包含唯一元素的可变和无序的集合数据类型
1 变量初始化
# 变量初始化,同列表类似，元素可以是任何数据类型(排除列表)
a = set()
print("a的数据类型是：", type(a)) # a的数据类型是： <class 'set'>
# 注 a = {} 是空字典
b = {1, 'a', ()}
print("b的数据类型是：", type(b))
2 添加（add , update）
# 添加（add、update）
SE = {1, 2, 3, 4, 5, 7, 8}
SE.add('hello')
print(SE)
# update:把要传入的元素拆分，作为个体传入到集合中
SE.update('hello')
print(SE)
3 删(remove/pop/discard)
# remove:如果有，直接删除,如果无，报错
# pop:随机删除一个集合中的元素,如果集合没有元素报错
# discard：如果有，直接删除,如果无，不做任何操作
se = {1, 2, 3, 4, 5, 7, 8}
se.remove(4)
# se.remove(6)
print(se)
# pop
se.pop()
print(se)
# s1 = set()
# s1.pop()
# print(s1)
# discard
se = {1, 2, 3, 4, 5, 7, 8}
se.discard(4)
print(se)
se.discard(9)
print(se)
4 集合间的运算：交集( & )，并集( | )，差集( - )，相对差集( ^ )
# 交集（&）
S1 = {1, 2, 5, 8, 10}
S2 = {2, 5, 10, 11, 15}
S3 = S1 & S2
print(S3) # {2, 10, 5}
# 并集 |
S1 = {1, 2, 5, 8, 10}
S2 = {2, 5, 10, 11, 15}
# S3 = {1, 2, 5, 8, 10, 11, 15}
S4 = S1 | S2
print(S4) # {1, 2, 5, 8, 10, 11, 15}
# 差集 -
S1 = {1, 2, 5, 8, 10}
S2 = {2, 5, 10, 11, 15}
S5 = S1 - S2 # {1, 8}
print(S5)
# 相对差集^
S1 = {1, 2, 5, 8, 10}
S2 = {2, 5, 10, 11, 15}
S6 = S1 ^ S2
print(S6) # {1, 8, 11, 15}
5 去重（利用集合内元素唯一的特性）
# 去重
L = [1, 2, 3, 4, 5, 5, 4, 6, 3, 8, 9, 7]
T = (1, 2, 3, 4, 5, 5, 4, 6, 3, 8, 9, 7)
S1 = set(L)
print(S1)
L = list(S1)
print(L)
S2 = set(T)
print(tuple(S2))
九、运算符
# 算术运算符：+，-，*，/，%，**，//
# 比较运算符：==，!=，>，<，>=，<=
# 赋值运算符：=，+=，-=，*=，/=，%=， **=，//=
# 逻辑运算符：and，or，not
# 成员运算符：in，not in
a = 10
b = 20
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a % b) # 取余（返回除法的余数）
print(a ** b) # 幂
print(a // b) # 取整除（返回商的整数部分）
# 5 / 3 = 1...2
# 比较运算符：==，!=，>，<，>=，<=
a = 10
b = 20
print(a == b) # 等于，False
print(a != b) # 不等于，True
print(a > b) # 大于
print(a < b) # 小于
print(a >= b) # 大于等于
print(a <= b) # 小于等于
# 赋值运算符：=，+=，-=，*=，/=，%=， **=，//=
c = a + b # 赋值
print(c)
c += a # ====》c = c + a 先c和a相加，然后赋值给c
print(c)
c -= a # ===>c = c - a
print(c)
c *= a # 乘等于
c /= a # 除等于
c %= a # 取余等于
c **= a # 幂等于
c //= a # 取整除等于
# 逻辑运算符：and，or，not
print(a and b) # 20
print(a or b) # 10
print(not a) # False
# 成员运算符：in，not in
L = [1, 2, 3]
a = 3
print(a in L) # True
print(a not in L) # False
十、字符串编码
1 简介
计算机其实是只认识0和1的，我们编写的代码，要让计算机认识，中间涉及到字符转换为数字0和1的过程，这个过程实际就是一个字符如何对应一个特定的数字的标准，这个标准就称之为字符编码
0/1 = 1bit
1byte = 8bit # 计算机的最小存储单位 0-255的数值
字符编码的发展史00000000
第一个阶段：
考虑英文ASCII（英文字符/键盘上的所有字符）
ASCII码用一个字节代表一个字符
第二个阶段：
各个国家纷纷定制了自己的字符编码
GBK使用两个字节（2bytes）代表一个字符 2**16-1 65535
第三个阶段：
unicode兼容万国语言 使用两个字节（2bytes）代表一个字符
第四个阶段：
utf-8：对英文字符1byte表示，中文3bytes
总结：
1.为了处理英文字符，产生了ASCII码
2.为了处理中文字符，产生了GBK
3.为了处理各国字符，产生了Unicode
4.为了提高存储和传输性能，产生了utf-8
重点：python3下字符编码使用情况
unicode：简单粗暴，所有字符都是2bytes，优点字符–》数字的转换速度快，缺点占用空间大
utf-8：精准，对不同的字符用不同的长度表示，优点：节省空间，缺点：字符–》数字的转换速度慢
python3中字符编码实际类型使用
1.内存中使用的就是unicode，用空间换时间
2.硬盘中或者网络传输用utf-8，尽可能节省带宽，保证数据传输的稳定性
２ 编码（encode）和解码（decode）
编码（encode）：将unicode转换为其他指定的编码
解码（decode）：将原编码转换为unicode编码
s = '中' # 当程序执行时，字符会以unicode形式保存到内存空间中
# 编码
s1 = s.encode('utf-8')
s2 = s.encode('GBK')
print(s)
print(s1)
print(s2)
print(type(s)) # <class 'str'>
print(type(s1)) # <class 'bytes'>
print(type(s2)) # <class 'bytes'>
# 巩固
a = '你好潭州'
# unicode--》gbk
unicode_gbk = a.encode('gbk')
print(unicode_gbk)
# unicode--》utf-8
unicode_utf8 = a.encode('utf-8')
print(unicode_utf8)
# gbk--->utf-8
gbk_utf8 = unicode_gbk.decode('GBK').encode('utf-8')
print(gbk_utf8)
# 总结：
"""
1.各个编码的相互转换都要先转换为unicode，通过unicode再转其他编码
2.GBK不止这一个
"""
unicode_gbk = a.encode('gb18030')
print(unicode_gbk)
十一、赋值深浅复制
1 字符串（数字）
在内存中是一次性创建的，不能直接修改，如需修改，需要重新创建
2 列表等可修改的数据类型
在内存中创建时是以链表的形式创建
3 字符串、数字
赋值、深浅拷贝都没有意义，因为其永远指向同一个内存地址
4 列表、元组、字典
# 赋值:只是创建一个变量，该变量指向原来的内存地址
n1 = {"k1": 'fei', "k2": 123, "k3": ["fly", 18]}
# 赋值
n2 = n1
# n1["k1"] = "李波奇"
# print(n1)
# print(n2)
# n1["k3"][0] = "溪日流水"
# print(n1)
# print(n2)
# 浅复制:在内存中只额外的创建第一层数据
import copy
n3 = copy.copy(n1)
# n1["k1"] = "二月兰"
# print(n1)
# print(n3)
#
# n1["k3"][0] = "托马斯"
# print(n1)
# print(n3)
# 深拷贝
n4 = copy.deepcopy(n1)
n1["k1"] = "勿忘我"
print(n1)
print(n4)
n1["k3"][0] = "李贤滂"
print(n1)
print(n4)
十二、bytes和bytearray（字符串，列表）
print(type("ffff"))
print(type(b"ffff"))
# bytes是byte的序列，字符串是字符的序列
# str---》bytes
s1 = "中"
b1 = s1.encode('utf-8')
print(b1)
# bytes--->str
s2 = b1.decode("utf-8")
print(s2)
# 拓展
# str---》bytes
s = '托马斯'
b1 = bytes(s, encoding='utf-8')
b2 = bytes(s, encoding='GBK')
print(b1)
print(b2)
# bytes--->str
s1 = str(b1, encoding='utf-8')
s2 = str(b2, encoding='gbk')
print(s1)
print(s2)
# bytearray
s1 = "你好，朦胧"
b1 = bytearray(s1.encode('utf-8'))
print(b1)
print(type(b1))
print(b1.decode('utf-8'))
b1[:6] = bytearray("美丽", encoding="utf-8")
print(b1)
print(b1.decode('utf-8'))
十三、字符串格式化
%是传统方法，format是python特有
1 第一种方法：%
year = 2019
month = 6
day = 18
# 格式化日期
print('%04d-%02d-%02d' % (year, month, day)) # %02d:输出2位整数，不足位用0补足
f = 3.141
print("%06.2f" % f) # %06.2f保留宽度为6，小数2位的浮点数，不足位用0补足
print('%o' % 10)
print('%02x' % 10)
2 第二种方法：format
# format
test = "name:%s,age:%d,nick_name:%s" % ("狐狸", 18, "星翼")
print(test)
test = "name:{},age:{},nick_name:{}".format("狐狸", 18, "星翼")
print(test)
test = "name:{0},age:{1},nick_name:{0}".format(*["狐狸", 18])
print(test)
test = "name:{name},age:{age},nick_name:{name}".format(**{"name": '勿忘我', "age": 18, "height": 168})
print(test)
test = "numbers: {:b}, {:o}.{:d},{:x},{:X},{:%}".format(10, 10, 10, 10, 10, 10, 10)
print(test)
test = "numbers: {num:b}, {num:o}.{num:d},{num:x},{num:X},{num:%}".format(num=10)
test = "numbers: {0:b}, {0:o}.{0:d},{0:02x},{0:X},{0:%}".format(10)
print(test)
print('{:.2f}'.format(3.1415926))
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
