(1)基础数据类型
是否可变：
不可变数据类型：数字，字符串，元祖
可变类型：列表，字典,集合
有无序：
有序类型：列表，字符串，元祖，集合，
无序类型：字典，数字
可哈希：指的是同一元素中不能有相同的元素（set,dict）
int(整数类型)
int将字符串类型转换成整数型
a = '123' print(type(a),a) #<class 'str'> 123 a = int(a) #将字符串‘123’转换成整数型123 print(type(a),a) #<class 'int'> 123
float转成int
a = 1.011 print(type(a),a)#<class 'float'> 1.011 a =int(a)#float转换成int print(type(a),a)#<class 'int'> 1
暂时这些.........
str(字符串类型)
增
join使用字符进行拼接
t = 'yang' k = 'qqqq' t = k.join(t)#使用赋值后的变量进行拼接 print(t) t = '*'.join(t)#以字符的方式进行拼接 print(t) <yqqqqaqqqqnqqqqg> <y*a*n*g>
ljust从左边字符后面添加
test="yang" v=test.ljust(10,"!") print(v) <yang!!!!!!>
rjust从右边字符后面添加
test="yang" v=test.rjust(10,"!") print(v) <!!!!!!yang>
删
改
capitalize首字母大写
t = 'yangxiang' k = t.capitalize()#首字母大写 print(k) <Yangxiang>
casefold所有字母小写
t = 'YANGXIANG' k = t.casefold()#首字母大写 print(k) <yangxiang>
center居中
test = "ALex" v = test.center(20) # 20：是居中的位置,"&":默认是没有的 print(v) $$$$$$$$ALex$$$$$$$$
title转换成标题
t = 'YANGXIANG' print(t.title())#只能改变字母，将首字母改成大写 <Yangxiang>
istitle判断是否是标题
t = 'YANGXIANG' print(t.istitle())#判断是否是标题 t = 'Yangxiang' print(t.istitle())#判断是否是标题 <False> <True>
lower字母变小写
t = 'YANG' print(t.lower())#字母变小写。用途：可以做一些文本输入时用做判断大小写用 <yang>
islower()判断字母是否为小写
test="Yang" v=test.islower() #判定字母是否为小写 print(v) <False>
upper字母变大写
test="Yang" v1=test.upper() #将字母转换成大写 print(v1) <YANG>
isupwer判断字母是否为大写
test="Yang" v=test.isupper() #判定是否为大写 print(v) <True>
strip去除特殊\t \n 空格。还可以去除定义的字符
t = 'yang dfs'
print(t.strip())#去除空格
print(t.strip('y'))#去除定义字符
print(t.lstrip())#去除左边的空格
print(t.lstrip('y'))#去除左边定义字符
print(t.rstrip())#去除空格右边的空格
print(t.rstrip('s'))#去除空格右边定义字符
<yang dfs>
<ang dfs>
<yang dfs>
<ang dfs>
<yang dfs>
<yang df>
replace替换字符，可以替换空字符，算数里面的-- ++
st = "yangxiang"
v = st.replace('a', 'bbbbb',1) #‘a’：old.'bbbb':new.1:替换的次数
print(v)
<ybbbbbngxiang>
split分割方法，指定的字符进行分割
s="hello world".split("l",1)#指定的字符进行分割，还可以指定分割的次数
s1="hello world"
print(s1.split()) #默认是以空格进行的分割
print(s1.split('l',2)) #进行分割，指定分割次数
print(s)
<['hello', 'world']>
<['he', '', 'o world']>
<['he', 'lo world']>
查
index获取元素的下标
t = 'qwe'
print(t.index('q'))#获取元素的下标
<0>
len(字符的长度)
t = 'yang' print(len(t)) #获取的是字符长度
<4>
字符串切片/索引（取左不取右）
t = 'yangxiang' print(t[3]) #下标是3的元素 print(t[:]) #全部读取 print(t[1:])#因为是下标，从0开始的所以从第二个开始读取的 print(t[0:])#全部读取 print(t[:-1])#读取最后一个往前所有的 print(t[1:-1])#不读取0和-1（取左不取右） print(t[1:3])#读取下标1-2 print(t[2:8:2]) #读取2-8的下标元素，以2个元素分割读取 print(t[:6])#读取0-5的元素 print(t[-5:-1])#读取下标-5- -2的元素
count查找：查找元素出现的次数
t = 'yangxiang'
k = t.count('n')#查找元素出现的次数
print(k)
<2>
endswith以什么结束
t = 'yangxiang'
k = t.endswith('y')#以什么结束。返回的是一个bool值
print(k)
<false>
startswith以什么开始
t = 'yangxiang'
k = t.startswith('y')#以什么开始。返回的是一个bool值
print(k)
<True>
find查看元素的下标
t = 'yangxiang'
k = t.find('n',4)#查找元素的下标，可以设置起始位置，默认是从0开始
print(k)
<7>
format将字符中的占位符替换为置顶的值{}
t = 'I am {name},age {age}'.format(name = 'yang',age = 23)#占位符，使用{}，将{}里面的内容替换成需要的内容 print(t) t = 'I am {name},age {age}' res = t.format(name = 'yang',age = 23)#通过关键字赋值的方式传参 print(res) t = 'I am {0},age {1}'.format('yang',23)#通过位置传参 print(t) <I am yang,age 23> <I am yang,age 23> <I am yang,age 23>
format_map格式化传入值
test = " I am {name},age {age}."
v = test.format_map({"name": "yang", "age": 20})
print(v)
<I am yangxiang, age 20。>
isalnum字符串中是否包含字母和数字and汉字
t = 'yangxiang000包' print(t.isalnum()) t = 'yangxiang000‘；。' print(t.isalnum()) <True> <False>
isalpha是否有字母或者汉字
t = 'yang含' print(t.isalpha())#同时包含字母和汉字返回bool值 t = 'yang含000' print(t.isalpha()) t = 'yang;' print(t.isalpha()) <True> <False> <False>
expandtabs 添加空格 断句 制表格
t = '使用字符串大法就是好，我很喜欢\t789456123' v = t.expandtabs(7) #代表在\t后添加7个空格 print(v) test = "username\tage\tpassword\nyangxiang\t20\t456\nyangxiang\t20\t456\nyangxiang\t20\t456\nyangxiang\t20\t456" k = test.expandtabs(20) #expandtabs只以\n\t做处理。进行断句，制表格 print(k) <使用字符串大法就是好，我很喜欢 789456123> < username age password yangxiang 20 456 yangxiang 20 456 yangxiang 20 456 yangxiang 20 456 >
判断是否是数字的三种方法
print("一".isdecimal()) #查看是否是数字
print("一".isdigit()) #查看是否是数字
print("壹".isnumeric()) #查看是否是数字（只要是数字都可以）
<False>
<False>
<True>
list(列表类型)
列表的创建，可以嵌套任何类型
li = [1,12,5,['yang'],'li',('zhang',),{'yang':111},{222,3344,55}]
print(li)
<[1, 12, 5, ['yang'], 'li', ('zhang',), {'yang': 111}, {3344, 222, 55}]>
增
append：在原来的值后面追加
li = [1,2,3,4]
li.append('yang')#只能添加到最后面，不能追加到指定的位置
print(li)
<[1, 2, 3, 4, 'yang']>
___________________________________________________
#可以使用append进行循环添加
li = [1,2,3,4]
for i in ['yang','lol',99,77]:
li.append(i)
print(li)
<[1, 2, 3, 4, 'yang', 'lol', 99, 77]>
extend循环添加
li = [1,2,3,4,5,6] li.extend([99,88,77,66,55,44])#好处就是一次性可以添加多个属性 print(li) <[1, 2, 3, 4, 5, 6, 99, 88, 77, 66, 55, 44]>
insert根据索引插入元素
li = [1,2,3,4,5,6] li.insert(0,'yang')#输入所需要插入的位置 print(li) <['yang', 1, 2, 3, 4, 5, 6]>
删
del删除列表元素
a = [1,2,3,4,5,6] print(a)#删除之前 del a[3] print(a)#删除之后 <[1, 2, 3, 4, 5, 6]> <[1, 2, 3, 5, 6]>
clear:清空列表。没什么用不推荐
a = [1,2,3,4,5,6] print(a)#清除之前 a.clear() print(a)#清除之后,虽然是清楚了，但还是会保留一个空的列表 <[1,2,3,4,5,6]> <[]>
pop:删除某个值
a = [1,2,3,4,5,6] a.pop()#默认删除最后一个元素 print(a) a.pop(2)#删除指定的下标元素 print(a) <[1, 2, 3, 4, 5]> <[1, 2, 4, 5,6]>
remove:删除指定的值
a = [1,2,3,4,5,6,9,[1,54445],(1,5,4,),{'a','b',}]
a.remove(9)#删除指定的元素，写的是你的元素
print(a)
a.remove([1,54445])#删除指定的元素，写的是你的元素,删除的内容可以是：数字，字符串，列表,元祖，集合，字典
print(a)
a.remove((1,5,4,))
print(a)
a.remove({'a','b',})
print(a)
'''
[1, 2, 3, 4, 5, 6, [1, 54445], (1, 5, 4), {'b', 'a'}]
[1, 2, 3, 4, 5, 6, (1, 5, 4), {'b', 'a'}]
[1, 2, 3, 4, 5, 6, {'b', 'a'}]
[1, 2, 3, 4, 5, 6]
'''
改
索引修改列表元素
a = [1,2,3] a[1] = 8 #通过索引改变元素 print(a) <[1,8,3]>
通过index去改变元素
a = [1,2,3] a[a.index(2)] = 9 #通过先获取元素索引，找到元素对应的index值进行替换 print(a) <[1, 9, 3]>
通过切片去修改元素
a = [1,2,3,4] a[0:2] = [9,8,4,5] #更改索引0-2的元素，如果替换的元素超出了替换的元素，那么会往后顶替 print(a) <[9, 8, 4, 5, 3, 4]>
查
使用索引获取列表中的元素
print(li[0][1])
使用切片获取列表
li = [1,2,3,4,[6,7,8],9,99,88,77,44]#取左不取右 print(li[2])#获取下标为2的元素 print(li[4][1])#获取下标为4的元素中的[2]元素 print(li[0:])#获取从0后面的所有 print(li[:])#获取所有元素 print(li[1:-1])#获取下标1到-1的元素 print(li[0:4])#获取从0-4之间的元素 print(li[0:7:2])#获取0-7的下标元素，间隔为2 print(li[:-1])#获取最后一个往前所有的 print(li[-5:-1])#获取最后一个到倒数第五个元素 print(li[:5])#获取下标5之前的所有元素 ''' 结果： 3 7 [1, 2, 3, 4, [6, 7, 8], 9, 99, 88, 77, 44] [1, 2, 3, 4, [6, 7, 8], 9, 99, 88, 77, 44] [2, 3, 4, [6, 7, 8], 9, 99, 88, 77] [1, 2, 3, 4] [1, 3, [6, 7, 8], 99] [1, 2, 3, 4, [6, 7, 8], 9, 99, 88, 77] [9, 99, 88, 77] [1, 2, 3, 4, [6, 7, 8]] '''
count：计算元素出现的次数
li = [1,2,3,4,5,1,1] print(li.count(7)) #获取元素累计的次数。写入没有的元素，也不会报错，默认'0' print(li.count(1)) #获取元素累计的次数。写入没有的元素，也不会报错，默认'0' <0> <3>
index:根据当前的元素获取元素的下标
li = [1,2,3,4,5,1,1] print(li.index(1))#从起始位置开始查找 print(li.index(1,3))#设置指定的起始位置查找元素的下标 <0> <5>
其他
copy拷贝（浅拷贝）
li = [12, 45, 78] v = li.copy() #对列表进行复制 print(li) print(v) <[12, 45, 78]> <[12, 45, 78]>
深浅拷贝
'''
拷贝的列表是开辟的新的一块内存空间，但是列表里面的元素都是指向同一个内存地址。
浅拷贝：在一级元素上进行更改，copy的列表是不会跟着改变的，内存地址是改变的，（没有发生改变的元素，内存地址也是一样的）
深拷贝：在二级元素上进行更改，copy的列表会跟着改变，当然内存地址也是跟着改变的
'''
a = [[1,2],3,4,9]
b= a[:]
a[2] = 5
a[0][1] = 6
print('-----------------------------------------------')
print(a,b)
print(id(a),id(b)) #改变
print('*************')
print('a[0]:',id(a[0]),'b[0]:',id(b[0]))#不改变
print('a[0][0]:',id(a[0][0]),'b[0][0]:',id(b[0][0]))#不改变
print('a[0][1]:',id(a[0][1]),'b[0][1]:',id(b[0][1]))#不改变
print('a[1]:',id(a[1]),'b[1]:',id(b[1]))#不改变
print('a[2]:',id(a[2]),'b[2]:',id(b[2]))#改变
print('a[3]:',id(a[3]),'b[3]:',id(b[3]))#改变
'''
-----------------------------------------------
[[1, 6], 3, 4, 9] [[1, 6], 3, 4, 9]
18276232 18306888
*************
a[0]: 18307208 b[0]: 18307208
a[0][0]: 1505960656 b[0][0]: 1505960656
a[0][1]: 1505960816 b[0][1]: 1505960816
a[1]: 1505960720 b[1]: 1505960720
a[2]: 1505960752 b[2]: 1505960752
a[3]: 1505960912 b[3]: 1505960912
'''
reverse:将当前列表翻转
li = [1,2,3,8,5,4,9] li.reverse()#没有返回值，也不能直接放入print中打印 v= li.reverse() print(li) print(v) print(li.reverse()) <[9, 4, 5, 8, 3, 2, 1]> <None> <None>
sort:从大到小排序
li = [1,2,3,8,5,4,9] li.sort()#将列表进行从小到大排序 print(li) li.sort(reverse=True)#将列表从小到大排序，且进行翻转 print(li) <[1, 2, 3, 4, 5, 8, 9]> <[9, 8, 5, 4, 3, 2, 1]>
元素和下标一起打印，三种方式
l = [11,22,33]
count = 0
for i in l:
print('%s----->%s'%(i,count))
count +=1
for i in l:
print(l.index(i),i)
for i,v in enumerate(l):
print(i,v)
列表补充：
a,*c = [1,2,3,4,5,6] print(a,c)#将列表分为两个部分 <1 [2, 3, 4, 5, 6]>
tuple(元祖类型)
元祖是不可被修改的，只能通过转换才能进行修改
元祖是不能被修改的，不能增加或者删除
tu = (20, "yang", (10, 20), [(50, 40)], True, 30,20,) li=[20, "yang", (10,20), [(50, 40)], True, 30] v=tuple(li) print(v) print(tu[3][0][0])
查
索引查找
tu = (20, "yang", (10, 20), [(50, 40)], True, 30,20,) print(tu[3][0][0]) <50>
切片
tu = (20, "yang", True, 30,20,4,5,48)
print(tu[2])#获取下标为2的元素
print(tu[0:])#获取从0后面的所有
print(tu[:])#获取所有元素
print(tu[1:-1])#获取下标1到'-1的元素
print(tu[0:4])#获取从0-4之间的元素
print(tu[0:7:2])#获取0-7的下标元素，间隔为2
print(tu[:-1])#获取最后一个往前所有的
print(tu[-5:-1])#获取最后一个到倒数第五个元素
print(tu[:5])#获取下标5之前的所有元素
'''
结果：
True
20
(20, 'yang', True, 30, 20, 4, 5, 48)
(20, 'yang', True, 30, 20, 4, 5, 48)
('yang', True, 30, 20, 4, 5)
(20, 'yang', True, 30)
(20, True, 20, 5)
(20, 'yang', True, 30, 20, 4, 5)
(30, 20, 4, 5)
(20, 'yang', True, 30, 20)
'''
count:计算出现的次数
v = tu.count(20) print(v)
index:根据值，显示出元素的下标
tu = (1,2,(10,20),) v1 = tu.index((10, 20)) print(v1) <2>
dict(字典类型)
字典的key不能相同，
字典是无序的
dict的书写
info={
'k1':'v1', #键对值
'k2':'v2',
'k3':'v3',
}
字典的value可以是任何值
dic = {
'k1':1,
'k2':True,
'k3':[
1,
2,
{
'kk1': '1',
'kk2':2,
'kk3':3,
}
],
'k4':{
'kk1': '1',
'kk2':2,
'kk3':3,
}
}
print(dic)
通过索引的方式找到字典
info={
'k1': 18,
'k2': 14,
'k3':[
11,
12,
123,
{
'kk1': 'yang',
'kk2': 'yg',
'kk3': (11,22),
}
]
}
v=info['k3'][3]['kk3'][0]
print(v)
<11>
增
fromkeys:根据序列，创建字典，并制定统一的值
dic = {
'k1':1,
'k2':True,
}
v = dic.fromkeys(['k1','k2',],321)#更换value值
print(v)
<{'k1': 321, 'k2': 321}>
setdefault：设置值
dic = {
'k1':1,
'k2':True,
}
v = dic.setdefault('k2','yang')#key已存在，所以设置的无效
v1 = dic.setdefault('k3','yang')#key不存在的，就可以设置
print(v)
print(v1)
print(dic)
'''
结果：
True
yang
{'k3': 'yang', 'k1': 1, 'k2': True}
'''
update：更新、添加键值对
dic = {
'k1':1,
'k2':True,
}
dic.update({'k3':1,'k4':2})#设置新的k:v，并且保留原来的
print(dic)
dic.update(k3=2,k4=5)#设置新的k:v，并且保留原来的
print(dic)
'''
{'k3': 1, 'k1': 1, 'k2': True, 'k4': 2}
{'k2': True, 'k3': 2, 'k1': 1, 'k4': 5}
'''
增加新的k:v
dic[age]=16
删
del删除元素
dic = {
'k1':1,
'k2':True,
}
del dic['k1']
print(dic)
<{ 'k2':True,}>
pop：删除并获取value值
dic = {
'k1':1,
'k2':True,
}
v = dic.pop('k1')
print(dic,v) #读取删除之后的字典和删除掉的value，只能获取删除的value值
<{'k2': True} 1>
popitem：删除并获取k,v值
dic = {
'k1':1,
'k2':True,
}
v,k = dic.popitem()#随机删除k:v值，不能设置指定的元素
print(dic,v,k)
<{'k1': 1} k2 True>
改
通过key去修改val值
dic = {
'k1':1,
'k2':True,
}
dic['k1'] = 2222
print(dic)
<{'k2': True, 'k1': 2222}>
查
for循环，输出的是key值
dic = {
'k1':1,
'k2':True,
}
for i in dic:
print(i,dic[i])#获取的只有key值，dic[i]可以获取对应的value值
'''
k2 True
k1 1
'''
循环获取字典中的value值
for item in info.values():
print(item)
循环获取字典的key值
for item in info.keys():
print(item)
循环获取键值对
for k,v in info.items():
print(k,v)
get:根据key获取值，key不存在时，也不会报错，指定默认值（None）
dic = {
'k1':1,
'k2':True,
}
v=dic['k1']
print(v)
# v = dic['k6']#报错
# print(v)
v1 = dic.get('k2')
print(v1)
v1 = dic.get('k3')
print(v1)
'''
1
True
None
'''
set(集合类型)
set:可变的数据类型
应用功能：去重，关系测试
set写法：
s = {1,2,3,4,5,6}
去重，先将list转成set去重，再转成list
name = ['yang','li','yang'] print(name) name = list(set(name)) print(name) ''' ['yang', 'li', 'yang'] ['li', 'yang'] '''
增
clear删除
s = {1,2,3,4,5,6}
print(s)
s.clear()#清除之后，得到的是一个set()
print(s)
'''
{1, 2, 3, 4, 5, 6}
set()
'''
pop：随机删除
s = {1,2,3,4,5,6}
s.pop()#随机删除，不能指定元素
print(s)
<{2, 3, 4, 5, 6}>
remove:指定删除，不在集合内的，就报错
s = {1,2,3,4,5,6}
s.remove(3)
print(s)
s.remove(9)#不存在的报错
print(s)
<{1, 2, 4, 5, 6}>
discard：指定删除，不在集合内的不会报错
s = {1,2,3,4,5,6}
s.discard(3)
print(s)
s.discard(9)
print(s)
''
{1, 2, 4, 5, 6}
{1, 2, 4, 5, 6}
'''
改
frozenset遍历写入的元素，以set的方式遍历出来
s = frozenset('hello')
print(s)
<frozenset({'h', 'o', 'l', 'e'})>
去重的用法
p = {"a",'b','c','g','f'}
s = {"a",'b','d','g','h'}
# 求交集（&）：两边不同的去掉
print(p.intersection(s))
print(p&s)
# 求并集（|）：两边相同的去掉，且留一个相同的
print(p.union(s))
print(p|s)
# 求差集（-）:两边相同的除掉，谁在前留谁的元素
print(p.difference(s))
print(p-s)
# 求交叉集(^)：两边相同的除掉,不相同的显示出来
print(s.symmetric_difference(p))
print(s^p)
'''
结果：
{'g', 'a', 'b'}
{'g', 'a', 'b'}
{'d', 'f', 'a', 'h', 'c', 'g', 'b'}
{'d', 'f', 'a', 'h', 'c', 'g', 'b'}
{'f', 'c'}
{'f', 'c'}
{'d', 'f', 'h', 'c'}
{'d', 'f', 'h', 'c'}
'''
差集difference_update：不能直接放入print中输出
p = ['a','b','c','d']
s = ['s','b','c','f']
p1 = set(p)
s1 = set(s)
p1.difference_update(s1)
print(p1)
<{'a', 'd'}>
isdisjoint:如果没有交集返回True,否则Flase
s1 = {1,2}
s2 = {1,2,5}
print(s1.isdisjoint(s2))
<false>
issubset:是否是子序列 s1>s2
s1 = {1,2}
s2 = {1,2,5}
print(s1.issubset(s2))#s1是s2的子集True
print(s2.issubset(s1))#Flase
<True>
<false>
issuperset:是否是父级
s1 = {1,2}
s2 = {1,2,5}
print(s2.issuperset(s1)) #s1<s2
print(s1.issuperset(s2)) #s1<s2
<True>
<False>
updata:可添加{},[],'',添加字符串，会将字符串遍历添加
s1 = {1,2}
s1.update((1,5,4,855))#更新多个值
print(s1)
s1.update('qweqdfgsvcbn')#遍历添加
print(s1)
s1.add(11) #更新一个值
print(s1)
'''
{1, 2, 4, 5, 855}
{1, 2, 'q', 4, 5, 'd', 's', 'c', 'b', 'n', 'f', 'e', 'v', 855, 'g', 'w'}
{1, 2, 'q', 4, 5, 'd', 's', 'c', 'b', 'n', 11, 'f', 'e', 'v', 855, 'g', 'w'}
'''
浙公网安备 33010602011771号