一 介绍
1. 基础数据类型
1.1 数字int---整型
数字主要是用于计算，使用方法较少，记住一种：
#bit_bit_length() i = 3 print(i.bit_length()) #转化成二进制后，占用多少位
1.2 布尔值bool
布尔值只有两种True与False，判断真假
bool """ 字符串的转化 int ---> str: str(int) str ---> int: int(str) str必须全是数字组成 int ---> bool: 0 False 非零 True bool ---> int int(True) --> 1 int(False) --> 0 str ---> bool： ''：False 非空字符串：True print(bool("")) False #空字符串 print(bool(" ")) True #非空字符串 """
1.3 字符串str
1.3.1 字符串的索引
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
s = 'python自动化运维21期' #字符串是有索引的 ，索引是角标 s1 = s[0] print(s1) # p print(s[2]) # t print(s[-1]) # 期
1.3.2 字符串的切片
切片就是通过字符串的索引（索引:索引:步长）截取字符串的一段，形成新的字符串
原则：顾头不顾尾
s = 'python自动化运维21期' # s[起始索引:结束索引+1:步长] print(s[0:6]) # python #顾头不顾腚，首位0可省略不写 print(s[:6]) # python print(s[0:5:2]) # pto print(s[:5:2]) # pto print(s[:]) #python自动化运维21期 print(s[:-1]) #python自动化运维21 #倒着取 print(s[-1:-5]) ## 空，倒着取的话必须加反向步长 print(s[-1:-5:-1]) ## 期12维
1.3.3 字符串的增删改查、常用方法
s = 'olDBoy' * 首字母大写，其他字母小写 s1 = s.capitalize() print(s1) #Oldboy # *** 全部变成大写upper() 验证码 s2 = s.upper() print(s2) #OLDBOY # *** 全部变成小写 lower() 验证码 s3 = s2.lower() print(s3) #oldboy # * 大小写反转 s4 = s.swapcase() print(s4) #OLdbOY # * 非字母隔开的每个单词首字母大写 st = 'alex wusir*oldboy3taibai' s5 = st.title() print(s5) #Alex Wusir*Oldboy3Taibai s.center() #居中, 长度自己设定，默认填充空格 #使用方法： def center(self, width, fillchar=None): # real signature unknown; restored from __doc__ """ S.center(width[, fillchar]) -> str Return S centered in a string of length width. Padding is done using the specified fill character (default is a space) """ return "" s6 = s.center(30) print(s6) #( olDBoy ) s6 = s.center(30,"*") print(s6) #(************olDBoy************)
# startwith endwith 判断是否以。。。开头或者结尾，返回布尔值 s = 'olDBoy' s7 = s.startswith('o') print(s7) #True s7 = s.startswith('ol') print(s7) #True s7 = s.startswith('Boy',3,) print(s7) ## 源码中看到 start=None, end=None 代表有切片功能 def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__ """ S.startswith(prefix[, start[, end]]) -> bool Return True if S starts with the specified prefix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. prefix can also be a tuple of strings to try. """ return False
# *** strip 去除首位的空格、制表符 、换行符 。不仅仅是去除空格 s = ' olD Boy ' s8 = s.strip() print(s8) username = input('>>>').strip() ##在用户输入的时候，务必使用strip方法，防止用户输入前后多输入空格 if username == 'oldboy': print("验证成功") # lstrip 只去除左边的 rstrip 只去除右边的 # split 将字符串变为列表(默认空格，可以以任何形式隔开 分割 split可设置切割次数 s = 'oldboy wusir alex' l = s.split('o') print(l) s = 'sbcde sbcde sfes dsrda' print(s.split('e'))
# # join 将列表转化为字符串 s = 'oldBoy' s9 = '+'.join(s) s91 = '-'.join(s) print(s9,s91) #o+l+d+B+o+y o-l-d-B-o-y l1 = ['eldboy','wusir','alex'] ## join可对列表进行操作 s91 = '='.join(l1) print(s91) #eldboy=wusir=alex s = '大铁锤fsdb铁锤妹妹' #将铁翠替换成钢蛋 # replace s10 = s.replace('铁锤','钢蛋') # print(s10) #大钢蛋fsdb钢蛋妹妹 #find index 几乎一样的方法 通过元素找索引 #通过字符串的位置，找到对应的方法 s = 'oldBoy' ind = s.find('d') #找不到时返回-1 int = s.index('d') ##找不到，会报错 print(ind) print(int)
公共方法
s = 'sfasfasfasf' print(len(s)) ##计算字符串s的长度 s = 'addfadggadfdsa' print(s.count('d')) ##统计d的个数
格式化输出 format
res = '我叫{}，今年{}，爱好{}'.format('wph',28,'male') print(res) res = '我叫{0}，我的年纪{1}，我的名字是{2}'.format('wph',28,'ball') print(res) res = '{sex} {name} {age}'.format(sex='man',name='wph',age=18) print(res)
is 系列
name = 'jinxing123' print(name.isalnum()) ##p判断字符串由字母或者数据组成 print(name.isalpha()) ##判断字符串只由字母组成 print(name.isdigit()) ##判断字符串由数字组成
1.4列表list
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
1.4.1 列表的增删改查
l = ['老男孩','alex','wusir','ritian'] # 增 #append 追加 # l.append('葫芦') print(l) print(l.append('葫芦')) ##none 打印的是增加的动作 #insert 插入 l.insert(1,'景女神') print(l) ## 迭代着增加 l.extend('alex') print(l) l.extend(['111',222,333]) print(l)
#pop 有返回值 按照索引去删 print(l.pop(0)) print(l) #remove 按元素删除 l.remove('alex') print(l) # #clear 清空列表 # l.clear() # print(l) ## del 内存级别删除列表、 # del l # print(l) #按索引去删 print(l) del l[1] print(l)
l = ['老男孩','alex','wusir','ritian'] # 按索引改 print(l[2]) l[2] = '武藤兰' print(l) print(l[2]) # #按切片改 # l[:2] = 'abcv' #将切片先替换，后添加 # print(l) l[1:3] = [111,333,222] print(l)
# 查 l = ['老男孩','alex','wusir','ritian'] # 按照索引去查询 # 按照切片去查询 # 循环查 for i in l: print(i)
1.4.2 列表的其他方法
l1 = [1,2,1,2,1,1,3,4] # count计数 print(l1.count(1)) #列表中出现的次数 #len 测量长度 print(len(l1)) #测量列表的长度 # 通过元素找索引 print(l1.index(4)) #查找4的索引，只找到第一个就返回 l2 = [3,2,4,6,9,8,7,1] #列表排序 sort l2.sort() print(l2) #从小到大排序 l2.sort(reverse=True) ##加参数 从大到小排列 print(l2) #倒叙排列 l2.reverse() print(l2)
1.4.3 列表的嵌套
l1 = [1,2,'alex','wusir',['oldboy','ritian',99],'taibai'] #1 将'alex'全部变成大写，放回原处，两种方法去做 l1[2] = 'ALEX' l1[2] = l1[2].upper() #2 给 ['oldboy','ritian',99] 追加一个元素 print(l1[-2]) l1[-2].append('景nvsheng') print(l1) #3 将'ritian'首字母大写，放回原处 print(l1[-2][1]) l1[-2][1] = l1[-2][1].capitalize() print(l1) #将99通过数字相加，或者字符串相加等等，变成字符串'100' l1[-2][-2] = str(l1[-2][-2] + 1) print(l1) # 字符串相加 将10通过数字相加，或者字符串相加等等，变成字符串'100' l1 = [1,2,'alex','wusir',['oldboy','ritian',10],'taibai'] l1[-2][-1] = str(l1[-2][-1]) + '0' print(l1)
1.5 字典dict
1.5.1 字典介绍
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典的查询速度非常快 符合二分查找
字典的key是唯一的 key必须是不可变的数据类型
key: 不可变的数据类型(可哈希)： str，bool，tuple，int
value: 任意数据类型。
数据类型分类
不可变的数据类型(可哈希)： str，bool，tuple，int
可变的数据类型：dict，list，set。
容器类的数据类型： list，tuple，dict，set.
字典：存储数据多，关系型数据，查询速度快（二分查找）
3.5及之前版本 字典是无序的，3.6及以后的版本，字典是有序的
1.5.2 字典的增删改查
dic = {'name':'taibai','age':'28','hobby':'girl'}
1.5.2.1 增
dict['high'] = 180 ##有则覆盖 ，无则添加 字典的改 print(dict) dic.setdefault('high') ##键为high，值为空none print(dict) dic.setdefault('high',180) ## setdefault 有则不变，无则添加 print(dic)
1.5.2.2 删
dic.pop('name') # 根据键值对的键 来操作删除】 print(dic.pop('name')) #返回值 返回删除的对应键的值 dic.clear() #清空字典 del dic #内存级别删除字典 print(dic) del dic['age'] #按键值删除 print(dic) print(dic) dic.popitem() #随机删除 但是3.6是有序的了，就是从后往前删除 print(dic) print(dic.popitem()) #打印返回值 返回的是一个元组 删除的键值对放在元组里 #pop可以删除不存在的键值对，但是不报错，返回指定结果 print(dic.pop('name1','没有此键')) print(dic)
1.5.2.3 改
dic['name'] = 'oldboy' #2 update dic = {"name":"wph","age":"18"} dic2 = {"name":"lq","sex":"women"} dic2.update(dic) #将dic的键值对覆盖增加到dic2 print(dic) print(dic2)
1.5.2.4 查
print(dic['name']) #查键对应的值，但是没有会报错。 print(dic.get('name1','NO Have')) ##不报错 #循环查找 # 1.2.3 个方法 # keys() values() items() print(dic.keys()) # 把所有的放在一个容器里。可以转化成list 更好利用 print(list(dic.keys())) for i in dic.keys(): print(i) dic.values() print(dic.values()) #把所有的值放到一个容器里，可以转化成list 更好利用 for i in dic.values(): print(i) print(dic.items()) #把键值对放到元组里，可以转化成列表 print(list(dic.items())) for i in dic.items(): print(i)
1.5.3 分别赋值
a = 1 a,b = 1,2 print(a,b) a,b,c = ["alex","wusir","ritian"] print(a,b,c) # 一行代码将a b 互换 a = 1 b = 2 a,b = b,a print(a,b) for k,v in dic.items(): print(k,v)
1.5.4 公共方法
#len 键值对个数 print(len(dic))
1.5.5 fromkeys
# fromkeys 创建一个字典 dic1 = dict.fromkeys('abc','zhangshan') dic2 = dict.fromkeys([1,2,3],'lisi') print(dic1,dic2) ### 注意大坑！！！ dic3 = dict.fromkeys('abc',[]) print(dic3) dic3['a'].append('王鹏鸿') print(dic3) ###会将‘王鹏鸿’加到每一个键值对中！坑
1.5.6 字典的嵌套
dic = { 'name_list':['b哥', '张帝', '人帅', 'kitty'], '老男孩':{ 'name':'老男孩', 'age': 46, 'sex': 'ladyboy', }, } print(dic) #1 给['b哥', '张帝', '人帅', 'kitty'] 追加一个元素'骑兵' dic['name_list'].append('骑兵') print(dic['name_list']) print(dic) #2 将kitty全部大写 dic['name_list'][-1] = dic['name_list'][-1].upper() print(dic['name_list']) print(dic) #3 将 '老男孩'改成'oldboy' dic['老男孩']['name'] = 'oldboy' print(dic) #4 将ladyboy首字母大写 dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize() print(dic)
1.6 元组
一句话介绍： 可查不可改 元组不可改，但是儿子不可改孙子可改！
tu = (11,2,True,[2,3,4,],'alex') #查 for i in tu: print(i) print(tu[1]) #2 print(tu[:3:2]) #(11,True) print(tu.index(True)) print(tu.count(2)) #计算数量 print(len(tu)) #计算元素数量 # 儿子不可改孙子可改 tu[-2].append(666) print(tu)
1.7 集合
1.7.1 集合的作用
集合专门用于处理数据，用处较少
''' 集合： 无序不重复的数据类型 里面的元素必须是可哈希的（不可变的） 但是集合本身是可变的 1. 关系测试 交并集 子集 差集 2. 去重 （列表的去重） 很不重要！！！ '''
1.7.2 列表的常用方法-增、删、去重
set1 = {1,'alex',False,(1,2,3)}
l1 = [1,1,2,2,3,3,4,5,6,6]
set2 = list(set(l1)) #列表的去重
print(set2)
#增
set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('666')
print(set1)
#update #迭代增加
set1.update('abc')
print(set1)
#删
set1.remove('alex') #按照元素去删
print(set1)
set1.pop() #随机删除一个元素
print(set1)
set1.clear() #清空集合
del set1 # 删除集合
print(set1)
1.7.3 集合的关系测试
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
#交集
print(set1 & set2) #生成一个新的交集
print(set1.intersection(set2))
#并集
print(set1 | set2) #{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2))
#差集
print(set1 - set2) #{1, 2, 3} set1 独有的
print(set1.difference(set2))
#反交集
print(set1 ^ set2) #{1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))
#子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
#子集
print(set1 < set2) #True
print(set1.issubset(set2)) #True
#超集
print(set2 > set1) #True
print(set2.issuperset(set1)) #True
###
# frozenset 冻 冻集合 集合变成不可变的数据类型
s = frozenset('barry')
print(s,type(s)) #frozenset({'y', 'a', 'b', 'r'}) <class 'frozenset'>
s1 = frozenset({4,5,6,7,8})
print(s1,type(s1)) #frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>
二 其他数据类型补充
2.1 数据类型补充
2.1.1 删除列表的奇数位元素
l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩'] #删除列表的奇数位元素 #1 del l1[1::2] print(l1) #2 for i in l1: if l1.index(i) % 2 == 1: #3 #在循环一个列表的时候，不要对列表进行删除的动作（改变列表元素的动作） for i in range(len(l1)-1,-1,-1): #5个元素 len(l1)-1 if i % 2 == 1: # print(i) del l1[i] print(l1)
2.1.2 range 可定制的数字列表
for i in range(10): print(i) for i in range(1,10,2): print(i) for i in range(10,1,-1): print(i) print(range(10))
2.1.3 删除字典中元素的方法
# ##将含有k元素对应的键值对删除 # # # dict 在循环字典时，不要改编字典的大小 for i in dic: if 'k' in i: del dic[i] ##改变大小会报错 ##可以先将字典改变为其他类型 l1 = [] for i in dic: if 'k' in i: l1.append(i) # print(l1) for i in l1: del dic[i] print(dic)
2.1.4 不是元组的元组
#tu 如果元组里面只有一个元素，并且没有逗号隔开，那么它的数据类型与该元素一致。就不是元组了。 tu1 = (1) print(tu1,type(tu1)) #1 <class 'int'> tu2 = ('alex') print(tu2,type(tu2)) #alex <class 'str'> tu3 = (['alex',1,2]) print(tu3,type(tu3)) #['alex', 1, 2] <class 'list'>
2.2 小数据池
# id = = is a = 'alex' print(a) b = 'alex' print (a==b) #数值 print (a is b) #内存地址 #id 测内存地址 print(id(a),id(b)) #一定要在内存地址去试，pycharm会做优化 ab内存地址一样吗？？？ #小数据池的概念？ #int -5~256 的相同的数全部指向一个内存地址 节省空间 #str: s = 'a' *21 #单个字符 * 21 缺少具体范围。。。了解即可 # >>> a = 'A'*20 # >>> b = 'A'*20 # >>> print(a is b) # True # >>> a = 'A'*21 # >>> b = 'A'*21 # >>> print(a is b) # False # >>> a = 'alex' # >>> b = 'alex' # >>> print(a is b) # True # >>> a = 'alex#' #含有非字母 # >>> b = 'alex#' # >>> print(a is b) # False