数据类型
目录
整形
定义
使用int()方法定义整形变量
age = 18等同于age = int(18)
常用方法
# 算数运算
+ - * / // % **
# 将浮点型强制转换为整形
print(int(18.9))
'''
18
'''
# 布尔值判断，0为False，其他为True
print(bool(0),bool(2),bool(-1))
'''
False True True
'''
浮点型
定义
使用float()方法定义浮点型变量
weight = 180.5等同于age = float(18.5)
常用方法
# 算数运算
+ - * / // % **
# 将整形强制转换为浮点形
print(int(18))
'''
18.0
'''
# 布尔值判断，0为False，其他为True
print(bool(0.0),bool(1.6),bool(-1.5))
'''
False True True
'''
字符串
定义
用str()方法定义字符串变量，用单引号''或双引号""或三单引号''''''或三双引号""""""定义变量值
name = 'alex'等同于name = str('alex')
注意点：在字符串变量值的前面（即定义变量值用的引号前面）
常用
1、写r代表原生字符串，即定义的字符串变量值里的特殊符号不再有特殊意义，如换行符等等
不常用
2、写b代表二进制编码的字符串，如b'101'
3、写u代表使用unicode编码的字符串
字符串是不可变类型，因此调用字符串的方法会返回一个新的变量值，会存放在新的内存空间，原值不会被修改
常用方法
s = 'I am a python learner !'
print(s + '\n') # +拼接字符串
print(s * 4) # *赋值拼接字符串，只能跟整形
print(s[0],s[3],s[-1]) # 按索引取值，负号索引表示从末尾向开头索引，从-1开始
print(len(s)) # 求长度，即包含字符总个数，包括空格字符
print(s[0:1],s[2:4],[-1:10:-1]) # 按索引切片取值，注意索引取头不取尾,有步长的概念，负号步长表示反向
print(s[0:],s[:-1]) # 索引切片取值时，省略起始索引或者结束索引，代表取到开头或结尾
print('am' in s,'nick' not in s) # 成员运算，判断是否包含某个字符串，结果为布尔值
print(s.strip(),s.strip('! I')) # 移除两端指定字符，参数没有顺序，无参时，移除空格和换行符
print(s.split(' ')) # 按指定字符，分割字符串，存储到列表中（不包含指定字符）
for i in s # 不按索引循环遍历s中每个字符
for i in range(len(s)) # 按索引遍历s中每个元素s[i]
内置方法
s = 'I am a python learner !'
s.lstrip()/s.rstrip() # 清除左边/右边的指定字符换串
s.lower()/s.upper() # 小写/大写字符串
s.startswith()/s.endswith() # 判断是否以指定字符串开始/结束
s.rsplit() # 从右往左，按照指定字符切分字符串
''.join(list) # 按照指定字符串将只含有字符串数据的列表/元组等可迭代对象拼接成字符串
s.replace(old_str,new_str,count_int) # 替换字符串中的指定个数的某个字符串,不写个数则替换全部
s.isdigit() # 无参，判断s是否是一个纯数字,结果为布尔值
s.find()/s.rfind()/s.index()/s.rindex() # 返回指定字符串在s中的索引,若没有，find不会报错,index会报错
s.count() # 统计s中指定字符串的个数
s.center(int,str)/s.ljust()/s.rjust()/s.zifill() #总长度为int，按str填充，格式s的对齐方式
不可变/可哈希
字符串是不可变类型，因此调用字符串的方法得到的值，会存放在新的内存空间，原值不会被修改
s = 'I am a python learner !'
print(s,id(s))
print(s.replace('a','b'),id(s),id(s.replace('a','b')))
'''
I am a python learner ! 2889133608592
I bm b python lebrner ! 2889133608592 2889133608672
'''
字典
定义
按key:value的格式，在{}内以逗号隔开，存放多个元素
key ：不可变数据类型
value ：任意数据类型
dic = dict() # 定义空字典
dic = {} # 定义空字典
dic = {'name':'alex','age':18,'hobby_list':['music','dapao']} # 定义字典
常用方法
dic[key] # 按key获取value值，若无该key，程序报错
dic[key] = value # 字典中有这个key，修改对应的value值，若字典中没有这个key，则添加这个键值对
len(dic) # 求字典长度（包含键值对个数）
del dic[key] # 按key删除删除键值对
print(x in dic) # 成员运算
for key in dic # 遍历字典的key
for key in dic.keys() # 遍历字典中的key
for value in dic.values() # 遍历字典的value
for item in dic.items() # 遍历字典的键值对，item取值后以元组存储
for key,value indic.items() # 等于对上一个item的解压缩
内置方法
dic.keys() #
dic.values() #
dic.items() #
dic.pop(key) # 按key弹出一个键值对元素，返回值是对应的vlaue
dic.popitem() # 随机弹出一个键值对，以元组返回(key,value)
dic[key] # 按key获取value值，若无该key，程序报错
dic.get(key) # 按key获取value值，若无该key,程序不会报错
dic[key] = value # 字典中有这个key，修改对应的value值，若字典中没有这个key，则添加这个键值对
dic.update(**kwargs) # 字典中有关键字实参名的key，就更新对应的vlaue，没有就添加键值对
dic.copy() # 复制后的dic，值的修改不会影响原来的dic
dic.setdefault(key,value) # 字典中有这个key，就不修改，字典中没有这个key就添加这个键值对
dic.fromkeys([key1,key2,key3,...],value) # 新建字典，默认值都为value，key用列表，元组，等可迭代对象传入
dic.clear() # 清空字典
可变/不可哈希
dic = {'name':'nick'}
print(dic,id(dic))
dic['age'] = 18
print(dic,id(dic))
'''
{'name': 'nick'} 2366442570200
{'name': 'nick', 'age': 18} 2366442570200
'''
列表
定义
使用list()方法定义，用[]存放变量值
存放多个任意数据类型的值
lt = [1,2]等同于lt = list([1,2])
常用方法
lt = [1,2,[3,4]]
print(lt[1],lt[-1],lt[-1][1]) # 按索引取值
lt[2] = 9;print(lt) # 按索引修改值
print(lt[0:2]) # (同字符串)按索引切片取值，取头不取尾，得到新值，不会修改原值
print(len(lt)) # 长度
print(2 in lt) # 成员运算，返回布尔值
lt.append(8);print(lt) # 列表末尾追加值，返回None，直接修改原值
def lt[0] # 按索引删除值
for 循环
内置方法
lt = [1,2,[3,4]]
可变类型，内置方法直接修改原值，基本上不会有返回值
lt.insert(i,values) # 按索引插入值
lt.pop(i) # 按索引弹出值，返回该值，并且修改原值，无参时默认弹出最后一个元素
lt.remove(values) # 按照值删除指定列表元素，返回None，修改原址，没有这个values时，会报错
lt.count(values) # 统计列表中指定元素的个数
lt.index(values) # 返回列表中某个元素的索引，没有时会报错
lt.sort()/lt.reverse() # 正向排序/反向排序
lt.extend(list) # 扩展列表
可变/不可哈希
lt = [1,2,3]
print(lt,id(lt))
lt.append([2,3,4,5])
print(lt,id(lt))
'''
[1, 2, 3] 2219877421640
[1, 2, 3, [2, 3, 4, 5]] 2219877421640
'''
元组
定义
在()内以逗号隔开，存储多个元素，当为一个元素时，需加上逗号，与运算优先级()进行区分
tup =1,2,3等同于tup = (1,2,3)
除了不可变，与列表相同
tup = tuple() # 定义空元组
tup = () # 定义空元组
tup = ('a','b',2,5,[1,2,3]) # 可以存储可变元素，但是tup本身不可变
常用方法
tup =1,2,3
print(tup[2]) # 索引取值
print(tup[2:3]) # 按索引切片取值
print(len(tup)) # 计算长度
print(3 in tup) # 成员运算
for 循环
内置方法
只有两种内置方法
tup.count(value) # 计数
tup.index(value,start,end) # 指定索引返回内寻找值并返回它的索引，默认从左到右查找第一个目标元素
不可变/可哈希
tup = (1,2)
print(tup,id(tup))
tup = (1,2,4)
print(tup,id(tup))
'''
(1, 2) 1841682939080
(1, 2, 4) 1841685233560
'''
集合
定义
在{}内以逗号分隔，存储多个不可变元素
重复的值，只取第一个
无序
s = set() # 定义空集合，只能使用这个方式定义空集合
s = {'a','b',1,3,2}
print(s)
常用方法
| # 并集
& # 交集
- # 差集
^ # 交叉补集
内置方法
s.remove(element) # 删除不可变元素,当删除的元素不存在，程序报错，返回值为None
s.discard(element) # 删除不可变元素，当删除的元素不存在，程序不报错，不管存不存在，都返回None
s.add(element) # 添加不可变元素
s.pop()
s.clear()
s.copy()
s.update(s)
可变/不可哈希
s = {'a','b',1,3,2,4}
print(s,id(s))
s.add(5)
print(s,id(s))
'''
{1, 2, 3, 4, 'b', 'a'} 1845526130248
{1, 2, 3, 4, 5, 'b', 'a'} 1845526130248
'''
布尔类型
定义
只有两个值
True：一般用作条件判断，条件成立为真
False：一般用作条件判断，条件不成立为假
常用方法
任何数据类型都自带布尔值
None\0\0.0\空布尔值为False
其他的值都为True
print(bool(0),bool(''),bool([]),bool({}))
print(bool(1),bool('name'))
'''
False False False False
True True
'''
解压缩
从可迭代对象中一次性取出多个值
lt = [1,2,3,5,6]
# 接收解压数据的变量个数应与迭代对象包含的元素个数相同
a,b,c,d,e = lt
print(a,b,c,d,e)
'''
1 2 3 5 6
'''
# 解压的数据中，不需要用的可以用'_'代替，约定俗成不会调用'_'，当连续不需要的变量数量较多，使用'*_'代替
a,_,c,*_ == lt
print(a,c)
'''
1 3
'''
深浅拷贝
针对可变数据类型而言
当变量为可变数据类型，变量值的改变，不会改变内存地址
拷贝
只添加对变量的引用
当通过变量的任意一个引用改变变量值，该值的所有引用的值同样会改变，因为内存地址没变
lt = [1,2]
lt1 = lt
print(lt,lt1,id(lt),id(lt1))
lt.append(3)
print(lt,lt1,id(lt),id(lt1))
'''
[1, 2] [1, 2] 2909969404488 2909969404488
[1, 2, 3] [1, 2, 3] 2909969404488 2909969404488
'''
浅拷贝
复制拷贝对象中的不可变元素，存储到新的内存空间，同时对拷贝对象中的可变元素添加引用
当拷贝对象或者拷贝得到的对象中的不可变元素发生变化，不会对另一个产生影响，当拷贝对象或者被拷贝对象中的可变元素发生变化，另一个的可变元素也会发生同步变化
import copy
lt = [1,3,[2,4]]
print(lt,id(lt),id(lt[2]))
lt1 = copy.copy(lt)
print(lt1,id(lt1),id(lt1[2]))
lt.append(5)
print(lt,id(lt),id(lt[2]))
print(lt1,id(lt1),id(lt1[2]))
lt1[2].append(6)
print(lt,id(lt),id(lt[2]))
print(lt1,id(lt1),id(lt1[2]))
'''
[1, 3, [2, 4]] 2696187565128 2696187564616
[1, 3, [2, 4]] 2696337515208 2696187564616
[1, 3, [2, 4], 5] 2696187565128 2696187564616
[1, 3, [2, 4]] 2696337515208 2696187564616
[1, 3, [2, 4, 6], 5] 2696187565128 2696187564616
[1, 3, [2, 4, 6]] 2696337515208 2696187564616'''
深拷贝
复制拷贝对象中元素，存储到新的内存空间
当拷贝对象或者拷贝得到的对象中的元素发生变化，另一个不会发生变化
import copy
lt = [1,3,[2,4]]
print(lt,id(lt),id(lt[2]))
lt1 = copy.deepcopy(lt)
print(lt1,id(lt1),id(lt1[2]))
lt.append(5)
print(lt,id(lt),id(lt[2]))
print(lt1,id(lt1),id(lt1[2]))
lt1[2].append(6)
print(lt,id(lt),id(lt[2]))
print(lt1,id(lt1),id(lt1[2]))
'''
[1, 3, [2, 4]] 2239576364040 2239576363528
[1, 3, [2, 4]] 2239697964488 2239577634248
[1, 3, [2, 4], 5] 2239576364040 2239576363528
[1, 3, [2, 4]] 2239697964488 2239577634248
[1, 3, [2, 4], 5] 2239576364040 2239576363528
[1, 3, [2, 4, 6]] 2239697964488 2239577634248
'''
