标签：测试 lsa diff lower 反向 lex 迭代 enc ali
python基础-数据类型
python 数据类型包括 数字类型、字符串、列表、元组、字典、集合。
1、 int 整数型
eg：1,2,3 .... 用于计算，运算。
#.bit_length() 将十进制转换为二进制的最小有效位数 i = 3 i = 4 print(i.bit_length()) """ 二进制 十进制 0000 0001 1 0000 0010 2 0000 0011 3 0000 0100 4 """
2、str 字符串
eg： ‘老男孩’，‘alex‘.... 可以 少量的数据的存储
2,1 索引（下标）
#字符串是有索引的。什么是索引？ 索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。 s = ‘python自动化运维21期‘ #第一个元素 s1 = s[0] #第二个元素 print(s1) s2 = s[2] print(s2) #最后一个元素 s3 = s[-1] print(s3) #倒数第二个元素 s4 = s[-2] print(s4)
2.2 切片
#切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。 #s[起始索引:结束索引+1:步长] #想要取到第5位 s1 = s[0:6] #顾头不顾腚 #开头0可以忽略 s1 = s[:6] print(s1) #取6位到8位 s2 = s[6:9] print(s2) #开头取到第四位，间隔为一，步长就是2 s3 = s[:5:2] print(s3) #从头取值到结尾 s4 = s[:] print(s4) #倒着取到第四个，步长必须写 s5 = s[-1:-5:-1] #倒着取值，必须加反向步长 print(s5)
2.3 操作方法
#对字符串进行操作，形成新的字符串
#常用：
#全部大写upper()
#全部小写lower()
s2 = s.upper()
s3 = s.lower()
print(s2,s3)
## 验证密码不区别大小写
code = ‘QeAr‘.upper()
your_code = input(‘请输入验证码:‘).upper()
if your_code == code:
print(‘验证成功‘)
# center 居中，俩侧进行填充。长度可自己设定，默认填充物None
s6 = s.center(30)
s6 = s.center(30,"*")
print(s6)
#startswith 判断以什么为开头
#endswith 判断以什么为结尾
#也是顾头不顾尾
s = ‘oldBoy‘
*** startswith endswith
s7 = s.startswith(‘o‘)
s7 = s.startswith(‘ol‘)
s7 = s.startswith(‘oldBoy‘)
s7 = s.startswith(‘Bo‘,3,5)
print(s7)
#后期可以根据开头判断走什么业务逻辑
#strip 默认去除首尾的空格，还可以制表符\t,换行符，还可以迭代去除元素
#lstrip() 只去除左边的
#rstrip() 只去除右边的
s = ‘ oyldBoy ‘
print(s)
#默认去除首尾的空格
s8 = s.strip()
print(s8)
#去除元素
s81 = s.strip(‘t‘)
print(s81)
#迭代去除元素
s81 = s.strip(‘tey‘)
print(s81)
name = input(‘>>>‘).strip()
if name == ‘oldboy‘:
print(‘验证成功‘)
#split (str ---> list)以什么分割，最终形成一个列表此列表不含有这个分割的元素
#以空格 或者以逗号分隔
s1 = ‘oldboy wusir alex‘
s1 = ‘oldboy,wusir,alex‘
l = s.split()
print(l)
l = s1.split(‘,‘)
print(l)
#以o分割 ，最终列表将没有o元素
s = ‘oldboywusiroalex‘
l2 = s.split(‘o‘) # [‘‘, ‘ldb‘, ‘ywusir‘, ‘alex‘]
print(l2)
# 还可以添加修改的次数
l2 = s.split(‘o‘,1) # [‘‘, ‘ldboywusiroalex‘]
print(l2)
#join 将list --->str。里面的元素通过连接符形成新的字符串
#缺点：里面有非字符串元素，就会报错
# s9 = ‘+‘.join(s)
# s9 = ‘_‘.join(s)
# print(s9)
# l1 = [‘oldboy‘,‘wusir‘,‘alex‘]
# s91 = ‘_‘.join(l1)
# print(s91)
#replace 替换，可以限制次数
s = ‘大铁锤fdsalj铁锤妹妹范德萨‘
s10 = s.replace(‘铁锤‘,‘钢蛋‘)
print(s10)
#find 通过元素找索引 找不到返回-1
#index 通过元素找索引 找不到报错
ind = s.find(‘d‘)
print(ind)
ind = s.find(‘o‘)
print(ind)
ind = s.find(‘A‘)
print(ind)
ind = s.index(‘A‘)
print(ind)
#公共方法：元组、列表、字符串都可以用的方法
#len 统计有多少个元素
# count 统计元素出现几次
s = ‘fdsafsdagsdafjdskahdhjlsadhfkj‘
print(len(s))
s = ‘fdsadd‘
print(s.count(‘d‘))
#格式化输出format
res=‘我叫{}今年{}岁，爱好{}‘.format(‘egon‘,18,‘male‘)
print(res)
#可以根据索引进行替换
res=‘我叫{0}今年{1}岁，爱好{2},我依然叫{0}‘.format(‘egon‘,18,‘male‘)
print(res)
#无需注意顺序，可以根据key找到值
res=‘{name} {age} {sex}‘.format(sex=‘male‘, name=‘egon‘, age=18)
print(res)
#is系列
name = ‘jinxin123‘
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成
i = ‘123a‘
if i.isdigit():
i = int(i)
else:
print("输入有误...")
#不常用：
# capitalize 首字母大写，其他字母小写
s = ‘oldBoy‘
#capitalize 首字母大写，其他字母小写
s1 = s.capitalize()
print(s1)
#*大小写反转 swapcase()
s4 = s.swapcase()
print(s4)
#非字母的元素隔开的每个单词首字母大写 title()
s = ‘alex wusir*oldboy3taibia‘
s5 = s.title() # Alex Wusir*Oldboy3Taibia
print(s5)
3、bool 布尔值 （True、False）
#数值 字符串 布尔之间转换
#int可以任意转换为str
int ---> str :str(int)
#str转换为int必须全部是数字组成。
str ---> int :int(str)
#int 转换bool
int --- > bool 0 False 非零 True
#bool转换为int
bool ---> int int(True) 1 int(False) 0
#str转换为bool
str ---> bool ""为False 非空字符串为True
# print(int(True))
# print(bool("")) # False
4、list 列表
eg：[True,1,‘alex‘,{‘name‘:‘oldboy‘},[1,2,3],(2,3,4),{‘wusir‘}]
4.1 列表是有序的，有索引值，可切片，方便取值
li = [111,‘alex‘,222,‘wusir‘] print(li[1]) # alex print(li[-1]) # wusir print(li[:2]) # [111, ‘alex‘] print(li[:3:2])
4.2 增
l = [‘老男孩‘, ‘alex‘, ‘wusir‘, ‘taibai‘, ‘ritian‘] #append 在最后追加 l.append(‘葫芦‘) #无返回值，不能打印添加动作 l.append([1,2,3]) print(l) #insert 插入，任意位置 l.insert(1,‘景nvshen‘) print(l) #迭代着添加，必须可迭代，按添加最小元素一一添加进去。 l.extend(‘alex‘) l.extend([‘111‘,222,333]) print(l)
4.3 删
#pop 四种操作唯一有返回值 按照索引删除 print(l.pop(0)) print(l) #remove 按照元素取删除 l.remove(‘alex‘) print(l) #clear 清空列表，还在内存中占着位置 l.clear() print(l) #del 内存级别删除列表 del l print(l) #按索引删除 del l[1] print(l) #切片删除 del l[:3] print(l)
4.4 改
#按照索引改 print(l[2]) l[2] = ‘武藤兰‘ print(l) #按照切片去改 l[:2] = ‘abc‘ #切面区域都删除，添加按最小元素添加，可以不对等 print(l) l[1:3] = [111,222,333,444] print(l)
4.5 查
#按照索引去查询，按照切片去查询
for i in l:
print(i)
l1 = [1,2,1,2,1,1,3,4]
#其他方法：
#count 计数 计算元素个数
print(l1.count(1))
#len 计算多少元素
print(len(l1))
#通过元素找索引，找到第一个就返回
print(l1.index(2))
l2 = [3,2,4,6,9,8,7,1]
#排序
#sort 正序
l2.sort() 从小到大
print(l2)
l2.sort(reverse=True) #从大到小排序，加参数
print(l2)
#reverse 倒序排列
l2.reverse()
print(l2)
4.6 列表的嵌套
#列表的嵌套 l1 = [1, 2, ‘alfdsafex‘, ‘wusir‘,[‘oldboy‘, ‘ritian‘, 10], ‘taibai‘] #1,将‘alex‘全部变成大写，放回原处。 l1[2] = ‘ALEX‘ #将单独元素赋值 print(l1[2].upper()) l1[2] = l1[2].upper() print(l1) #2.给[‘oldboy‘, ‘ritian‘, 99] 追加一个元素‘女神’。 一个方法 l1[-2].append(‘女财神‘) print(l1) #3，将‘ritian‘首字母大写，放回原处。 l1[-2][1] = l1[-2][1].capitalize() print(l1) #4，将10通过数字相加，或者字符串相加或者等等，变成‘100‘ l1[-2][-1] = str(l1[-2][-1] + 90) print(l1) #字符串的拼接 l1[-2][-1] = str(l1[-2][-1]) + ‘0‘ print(l1)
5、 tuple 元组 只读列表
eg：(True,1,‘alex‘,{‘name‘:‘oldboy‘},[1,2,3],(2,3,4),{‘wusir‘}) 只读列表
存放多个值，元组不可变，更多的是用来做查询
元组本身是不可变的，但是内部的元素可以是可变类型
tu = (11,2,True,[2,3,4],‘alex‘)
#循环去查
for i in tu:
print(i)
#索引
print(tu[1])
#切片
print(tu[:3:2])
#通过元素找索引
print(tu.index(True))
#元素统计
print(tu.count(2))
print(len(tu))
#内部的元素可以是可变类型
tu[-2].append(666)
print(tu)
6、dict 字典 key：value 成对组成的
eg ：{‘name‘:‘oldboy‘,‘age‘:45,‘name_list‘:[‘张三‘....]}
字典的key是唯一的。key 必须是不可变的数据类型。
key:不可变的数据类型(可哈希)：str，bool，tuple，int。
value：任意数据类型。
数据类型分类：
不可变的数据类型(可哈希)：str，bool，tuple，int
可变的数据类型：dict，list，set。
容器类数据类型：list，tuple，dict，set.
字典：存储数据多，关系型数据，查询速度快（二分查找）。
3.6版本之前，字典是无序的，3.6之后字典是有序的。
6.1增
#dic[‘high‘] 有则覆盖，无则添加 dic[‘high‘] = 180 dic[‘name‘] = ‘ritian‘ print(dic) #dic.setdefault() 有则不变，无则添加 dic.setdefault(‘high‘) dic.setdefault(‘high‘,180) dic.setdefault(‘name‘,‘日天‘) print(dic)
6.2 删
#字典中的key就相当于索引 print(dic.pop(‘name‘)) # 返回值 对应的值 print(dic.pop(‘name1‘,‘没有此key sb‘))#没有name1，删除不报错 print(dic) print(dic) dic.clear() # 清空 print(dic) print(dic.popitem()) #随机删除，返回值 print(dic) del dic print(dic) del dic[‘age‘] print(dic)
6.3 改
dic[‘name‘] = ‘老男孩‘
print(dic)
dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic) # 将dic的键值对覆盖添加到dic2中，dic不变。
print(dic)
print(dic2)
6.4 查
#get查询，没有key不报错
print(dic[‘name2‘])
print(dic.get(‘name‘))
print(dic.get(‘name1‘))
print(dic.get(‘name1‘,‘没有此key，sb‘))
#keys() values() items() 字典的转换
#将key转换为列表
print(list(dic.keys()))
for i in dic.keys():
print(i)
#将value转换为列表
print(dic.values())
for i in dic.values():
print(i)
#将键值对放到一个元组，元组在构成一个列表
print(list(dic.items()))
for i in dic.items():
print(i)
#分别赋值
a,b = 1,2
a,b,c = [‘alex‘, ‘wusir‘, ‘ritain‘]
print(a,b,c)
a = 1
b = 5
a,b = b,a
print(a,b)
for i in dic.items():
print(i)
for k,v in dic.items():
print(k,v)
#len 统计键值对个数
print(len(dic))
#fromkeys
dic1 = dict.fromkeys(‘abc‘,‘张三‘)
dic2= dict.fromkeys([1,2,3],‘李四‘)
print(dic2)
#多个都公用一个列表，改一个其他也改
dic3 = dict.fromkeys(‘abc‘,[])
# print(dic3)
dic3[‘a‘].append(‘老男孩‘)
print(dic3)
6.5 字典的嵌套
dic = {
‘name_list‘:[‘b哥‘, ‘张帝‘, ‘人帅‘, ‘kitty‘],
‘老男孩‘:{
‘name‘:‘老男孩‘,
‘age‘: 46,
‘sex‘: ‘ladyboy‘,
},
}
#1,[‘b哥‘, ‘张帝‘, ‘人帅‘, ‘kitty‘]追加一个元素，‘骑兵‘
dic[‘name_list‘].append(‘骑兵‘)
print(dic)
#2，将kitty全部变成大写。
l1 = dic[‘name_list‘]
print(l1[-1].upper())
l1[-1] = l1[-1].upper()
print(dic)
dic[‘name_list‘][-1] = dic[‘name_list‘][-1].upper()
print(dic)
#3，将老男孩 改成oldboy。
dic[‘老男孩‘][‘name‘] = ‘oldboy‘
print(dic)
，将ladyboy首字母大写。
dic[‘老男孩‘][‘sex‘] = dic[‘老男孩‘][‘sex‘].capitalize()
print(dic)
7 set：集合
关系型数据的交集，并集，差集，子集.... 列表的去重。
集合：
无序，不重复的数据类型。它里面的元素必须是可哈希的。但是集合本身是不可哈希的。
1：关系测试。交集并集，子集，差集....
2,去重。（列表的去重）
set1 = {1,‘alex‘,False,(1,2,3)}
l1 = [1,1,2,2,3,3,4,5,6,6]
l2 = list(set(l1))
print(l2)
set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
#增
set1.add(‘666‘)
print(set1)
update
set1.update(‘abc‘)
print(set1)
#删
set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.remove(‘alex‘) # 删除一个元素
print(set1)
set1.pop() # 随机删除一个元素
print(set1)
set1.clear() # 清空集合
print(set1)
del set1 # 删除集合
print(set1)
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
#交集 & intersectio
print(set1 & set2)
print(set1.intersection(set2))
#并集 | union
print(set1 | set2)
print(set1.union(set2))
#差集 - difference
print(set1 - set2)
print(set1.difference(set2))
#反交集 ^ symmetric_difference
print(set1 ^ set2)
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
#子集与超集
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1))
#不可变几个，让集合变为不可变
s = frozenset(‘barry‘)
s1 = frozenset({4,5,6,7,8})
print(s,type(s))
print(s1,type(s1))
8、数据类型的补充
l1 = [‘alex‘, ‘wusir‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
#删除奇数为元素，切片
del l1[1::2]
print(l1)
#再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错
for i in range(len(l1)):
print(l1) # [‘alex‘, ‘wusir‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
# [‘alex‘, ‘wusir‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
# [‘alex‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
# [‘alex‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
print(i) # 0 1 2 3
if i % 2 == 1:
del l1[i]
print(l1) # [‘alex‘, ‘wusir‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
# [‘alex‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
# [‘alex‘, ‘taibai‘, ‘barry‘]
print(i) # 0 1
#range可定制的数字列表，顾头不顾尾
range 可定制的数字列表
for i in range(10):
print(i)
for i in range(1,10):
print(i)
#设置步长
for i in range(1,10,2):
print(i)
#倒序
for i in range(10,1,-1):
print(i)
print(range(10))
for i in range(len(l1)-1,-1,-1):
if i % 2 == 1:
del l1[i]
print(l1)
dict 再循环字典时，不要改变字典的大小。
dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v3‘,‘r‘:666}
l1 = []
for i in dic:
if ‘k‘ in i:
l1.append(i)
# print(l1)
for i in l1:
del dic[i]
print(dic)
tu 如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。
tu1 = (1)
print(tu1,type(tu1))
tu2 = (‘alex‘)
print(tu2,type(tu2))
tu3 = ([‘alex‘,1,2])
print(tu3,type(tu3))
9、 作业（购物车）
标签：测试 lsa diff lower 反向 lex 迭代 enc ali
原文地址：https://www.cnblogs.com/dacheng-tony/p/8824712.html
