一.数据类型
1.1 数字类型
1.1.1 整数 int 例子：age=18 完整写法 age=int(18) #用来表示整数
用途：表示整数相关的比如：年龄，等级，编号
定义方式：age=18，level=10，num=999
n=int('123123123') #整数类型只能对字符串内的数字转换为整数，不能加小数点或者字符串
1.1.2 浮点性 float 例子：age=18.1 完整写法 age=float(18.1) #用来表示小数点
n = float('121111') #浮点性只能对字符串内的数字或者带小数点(最多一个小数点)的数字转换为浮点型
总结：int 与float类型
1.只能存一个值 2.属于不可变类型
1.2 字符串类型 str
1.用来表示描述性的东西等~
2.定义方式：name='sudada' #定义字符串类型需要加引号 (单 ''，双 ""，三 (''' ''' 或 """ """))
name='sudada'
print(type(name))
<class 'str'>
反而言之：name="111111" 引号内"111111"也被定义为字符串类型，或者说加了引号的内容都被认为是字符串
当一段内容里面有单引号和双引号时：
怎么区分：外面用单引号里面就用双引号，反之亦然
name='my name is "szq"'
print(name)
my name is "szq"
1.2.1 字符串str的常用操作和内置方法
1.2.1.1 字符串str优先掌握的操作：
1、按索引取值(正向取+反向取) ：只能取，不能修改索引值
msg='hello'
msg[1]='E'
print(msg)
运行后会报错：提示字符串不能修改
TypeError: 'str' object does not support item assignment
2、切片--顾头不顾尾([0:3]切片时不能取到最后一个索引值)，切片--步长([0:3:2]隔2个步长取一个索引值)
切片与切分的区别：1.切片是按照索引取值，切分(split)是指定分隔符取值
2.切片后得到的值为"字符串类型"，切分(split)后得到的值为"列表类型"，可将字符串类型的数据通过切分(split)转换为列表类型的数据。
msg='hello world'
print(msg[0:9]) #从'hello world'中取值,取从0开始9结束的索引值
运行后得到 hello wor
print(msg[0:9:2]) #从'hello world'这个值的[0-9]索引数据中取值,每隔2个步长取一个值
运行后得到 hlowr
msg='hello world'
print(msg.split()) #默认以空格分隔
运行后得到['hello', 'world']
例子如下：切片([0:9])后得到的值为"字符串类型"，切分(split)后得到的值为"列表类型"
msg='hello world'
print(type(msg[0:9])) 运行后得到 <class 'str'>
print(type(msg.split(' '))) 运行后得到 <class 'list'>
3、长度len #查看字符串的长度(有几个字符串)
msg = 'hello world'
print(len(msg))
运行后得到
11
4、成员运算in和not in #判断某一个值(字符串)是否存在与一个变量中 in 表示存在，not in 表示不存在。
msg='szq is baby'
print('szq' in msg) 运行后得到 True
print('szq' not in msg) 运行后得到 False
5、移除空白strip strip 首先设定一些需要被移除的字符，然后strip从左右两边开始匹配，当左右两边的任意一个值不等于被移除的字符，那么匹配结束。
举例说明：
5.1、name='*** szq* /**'，现在我要保留'szq'这个值
name="****_szq**/*"
res=name.strip('*_/')
print(res)
szq #打印后得到的值为"szq"，而字符"szq"左右两边的其他符号" * /"都被移除了
5.2、name='s / *** szq* /**'，现在我要保留'szq'这个值
name='s / *** szq* /**'
res=name.strip('* /')
print(res)
s / *** szq
这里得到的值为"s / *** szq"，因为strip('* /')(要移除的字符为'* /')，而左边的第一个字符为"s"，那么左边就不满足匹配条件，右边第一个字符为"*"，属于要移除的字符，那么继续往左一直到字符"q"这里时结束，因为字符"q"，不属于移除的字符
5.3、name='s / *** szq* /**'，设置name.strip('* s')，需要移除的字符为"* s"
name='s / *** szq* /**'
res=name.strip('* s')
print(res)
/ *** szq* /
这里得到的值为"/ *** szq* /"，strip('* s')(要移除的字符为'* s')，从左边开始匹配，第一个不满足的是"/"，那么左边的匹配结束，然后从右边开始，第一个不满足的是"/"，那么右边的匹配结束
6、切分-split(Python内置参数) #msg.split() 默认以"空格"为分隔符 msg.split() == msg.split(' ')
msg='root:x:0:0::/root:/bin/bash'
res=msg.split(':') #对变量"msg"的值进行切分,以":(冒号)"为分隔符
print(res)
运行后得到一个新的值：(id，值都会发生改变)
['root', 'x', '0', '0', '', '/root', '/bin/bash'] #这里看出,原值已被修改,:(冒号)已替换为逗号分隔
#split把字符串切分成了一个列表
7、循环
name='szq'
for n in name: #相当于：for n in 'szq'
print(n)
>>：s
>>：z
>>：q
这里可以看出，for循环内，对变量n依次赋值为"szq"(依次赋值为"s" "z" "q")，那么在取变量n的值的时候，就能够依次取出"s" "z" "q"多个值
8、实践用法
while True:
cmd=input('>>:').strip() #把用户输入的"空"值都给移除掉(空格也被包含在内)
#cmd=cmd.strip()
if len(cmd) == 0 :continue #配置len使用,只用输入的值不为"空"时，程序才会做出回应
elif cmd == 'q':break
print('%s is running' %(cmd))
这段代码的意思是：除了输入"q"将退出外，无论输入任何空的值，都将跳过(可以理解为Xshell里面再命令行里面一直敲回车或者空格时，Xshell并不会回应任何类容)
1.2.1.2 字符串str需要掌握的操作：
strip的多种用法：lstrip和rstrip，lstrip:移除左边指定的字符串，rstrip:移除右边指定的字符串
name='**********sudada////'
lres=name.lstrip('*') #移除字符串"**********sudada////",左边所有的字符"*"
rres=name.rstrip('/') #移除字符串"**********sudada////",右边所有的字符"/"
print(lres)
print(rres)
>>：sudada////
>>：**********sudada
lower和upper的用法：lower将大写的字符串改为小写，upper将小写的字符串改为大写
msg='Abc'
print(msg)
print(msg.lower())
print(msg.upper())
>>：Abc #原值不会受到影响
>>：abc #使用lower后，大写的字符串会改为小写
>>：ABC #使用upper后，小写的字符串会改为大写
startswith和endswith的用法：startswith:以~~开头，endswith:以~~结尾
msg='my name is sudada'
print(msg.startswith('my')) #判断当前字符串是否以字符串"my"开头
print(msg.endswith('da')) #判断当前字符串是否以字符串"da"结尾
>>：True
>>：True
format格式化输出的三种玩法：在这里我们使用第3种用法 --可自定义的格式化输出
print('my name is %s my age is %s' %('sudada',18)) #格式化输出%s的用法
>>：my name is sudada my age is 18
print('my name is {} my age is {}'.format('sudada',18)) #{}不指定内容,在传参时会根据.format('sudada',18)的值来依次传参
>>：my name is sudada my age is 18
print('my name is {name} my age is {age}'.format(name='sudada',age=18)) #{}指定了变量名"{name}",在传参时会根据变量名这只的值来传参
>>：my name is sudada my age is 18 #使用这种方式
split与rsplit：split从左往右切分，rsplit从右往左切分 #split把字符串切分成了一个列表
info='root:0:0::/root:/bin/bash'
print(info.split(':',1)) #split设置切分的分隔符为":"(冒号)，从左往右切分1次
>>：['root', '0:0::/root:/bin/bash'] #第一个切分出来的当做一个值，后面剩余所有值当做一个值
print(info.rsplit(':',1)) #rsplit设置切分的分隔符为":"(冒号)，从右往左切分1次
>>：['root:0:0::/root', '/bin/bash']
print(info.split(':',-1)) #split(':')不加切分次数，默认切分所有
>>：['root', '0', '0', '', '/root', '/bin/bash']
join的用法：把列表拼接成字符串(与split相反) # join只能用于值全都为字符串的列表，如果列表中的某一个值为数字或其他，则会报错！
a=['root', '0', '0', '', '/root', '/bin/bash'] #这是一个列表
a_list=':'.join(a) #指定分隔符为":"(冒号)，join(a)：可以理解为"join(['root', '0', '0', '', '/root', '/bin/bash'])"
print(a_list)
# >>：root:0:0::/root:/bin/bash
b_list=':::'.join(a) #指定分隔符为":::"(冒号)，join(a)：可以理解为"join(['root', '0', '0', '', '/root', '/bin/bash'])"
print(b_list)
# >>：root:::0:::0::::::/root:::/bin/bash
例子：join与split功能对比使用
linux="root:/bin/bash:/sbin/:/usr/bin/"
print(linux.split(":"))
# ['root', '/bin/bash', '/sbin/', '/usr/bin/']
linux_list=['root', '/bin/bash', '/sbin/', '/usr/bin/']
data=":".join(linux_list)
print(data)
# root:/bin/bash:/sbin/:/usr/bin/
replace的用法：将一个值替换成另外一个值
msg='wsp say name is wsp'
print(msg.replace('wsp','SB')) #把"wsp"替换成"SB"，默认替换所有的值
>>：SB say name is SB
print(msg.replace('wsp','SB',1)) #只对第一个"wsp"替换成"SB"
>>：SB say name is wsp
isdigit的用法：判断一个值的内容是否全为数字，例子"aaa123123aaa":这个就不满足
while True:
age=input('>>:').strip()
if not age.isdigit():continue #判断输入的值是否为数字，如果不为数字的话，那么就continue，重新输入
age=int(age)
if age > 30:
print('too big')
elif age < 30:
print('too small')
else:
print('success')
1.2.1.3、字符串str总结
1.字符串只能存一个值，因为字符串是一个整体，也可以把字符串当做一个列表，通过索引取值
2.字符串属于有序(能够通过索引取值的都可以称为"有序")
3.字符串属于不可变类型(无论通过lower或upper或split或者strip，它的原值一直没有发生任何改变)
1.3 列表类型 list
作用：存放多个值，存取按照索引来获取值 status[0],status[1]，0代表第一个位置，1代表第二个位置
定义：在[]内，用逗号分开多个值，每个值可以是任意数据类型
打印一个列表的值：print(变量名[索引])
例子1：定义一个列表
status=[1,'sudada',[1,2,'hah']] #定义一个变量status,赋值为 [1,'sudada',[1,2,'hah']]
print(status[0]) #取第1个值 status[0] #类似Shell里面的数组
print(status[1]) #取第2个值 status[1]
print(status[2]) #取第3个值 status[2]
print(status) #取全部的值
print(type(status)) #取类型
1 #取第1个值
sudada #取第2个值
[1, 2, 'hah'] #取第3个值
[1, 'sudada', [1, 2, 'hah']] #取全部的值
<class 'list'> #打印类型
例子2：当列表里面定义列表，并取列表的值
szq_info=['szq',18,['mutong',200,'shanghai']]
print(szq_info[1])
18 #print(szq_info[1]) #得到的值 18
print(szq_info[2])
['mutong', 200, 'shanghai'] #print(szq_info[2]) #得到的值 ['mutong', 200, 'shanghai']
shanghai
print(szq_info[2][2])
#print(szq_info[2][2]) #得到的值shanghai, #这里就相当于取['mutong', 200, 'shanghai']这个列表里面的第3个值
1.3.1 列表得取值多种用法
str = [1, 4, 5, 6, 7, 9, 11, 14, 16]
print(str[-1]) # 截取最后一个元素
print(str[0:3]) # 截取第一位到第三位的字符
print(str) # 截取字符串的全部字符
print(str[6:]) # 截取第七个字符到结尾
print(str[:-3]) # 截取从头开始到倒数第三个字符之前
print(str[2]) # 截取第三个字符
print(str[::-1]) # 创造一个与原字符串顺序相反的字符串
print(str[-3:-1]) # 截取倒数第三位与倒数第一位之前的字符
print(str[-3:]) # 截取倒数第三位到结尾
print(str[:-5:-3]) # 逆序截取后个数，每3个取一个，而且取是逆向取值
print(str[:10:2]) # 前10个数，每两个取一个
Python -- 去除list中的空字符：
方法1：
Python内建filter()函数 - 过滤list
filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素
def not_empty(s):
return s and s.strip()
res = filter(not_empty, ['1', '', '2', None, '3', ' '])
# 结果: ['1', '2', '3']
方法2：
while '' in index:
index.remove('')
1.3.1 列表list的常用操作和内置方法
1.3.1.1 列表list优先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可以取也可以改(属于可变类型)
sudada=['a','b','c','d','e','f']
print(sudada[-1]) #取倒数第一个索引的值
>>：f
print(id(sudada)) #sudada[0]未修改之前的ID
>>：2374574175368
sudada[0]='A'
print(sudada[0])
>>：A
print(id(sudada)) #sudada[0]修改过之后的ID
>>：2374574175368
对列表中的某一个值(sudada[0]='A')做修改之后，虽然值发生了改变，但是值的id不会改变，符合可变类型
注意：列表修改值得时候，只能对已存在的值进行修改，若值或者索引不存在，那么不能修改
sudada=['a','b','c','d','e','f']
sudada[10]='A'
print(sudada[10])
报错：IndexError: list assignment index out of range
2、切片(顾头不顾尾，步长)
sudada=['aaaa','b','c','d','e','f']
print(sudada[0:5]) #取索引0-5的值(正向取值)
>>：['aaaa', 'b', 'c', 'd', 'e']
print(sudada[0:5:2]) #取索引0-5的值，每隔2个步长取一个值
>>：['aaaa', 'c', 'e']
print(sudada[-1::-1])
>>：['f', 'e', 'd', 'c', 'b', 'aaaa'] #把列表反向取值
反向索引--也要记住顾头不顾尾：
sudada=['a','b','c','d','e','f']
print(sudada[5:0:-1]) #可以理解为：取索引5-0的值(也就是反过来取值)
>>：['f', 'e', 'd', 'c', 'b']
print(sudada[5:0:-2]) #取索引5-0的值，每隔2个步长取一个值
>>：['f', 'd', 'b']
3、长度 len
sudada=['aaaa','b','c','d','e','f']
print(len(sudada))
>>：6 #可以理解为索引的个数(或者说是字符串的个数)
4、成员运算in和not in #判断某一个值(字符串)是否存在与一个变量中 in 表示存在，not in 表示不存在。
msg='sudada is baby'
print('sudada' in msg) 运行后得到 True
print('sudada' not in msg) 运行后得到 False
5、追加append 与插入insert
5.1 追加append：name.append('FFF') #从列表末尾开始追加内容
name=['aaa','bbb','ccc','ddd','eee'] #这里5个索引值
name.append('FFF') #使用内置参数name.append('FFF')，往列表末尾追加一个索引内容'FFF'
print(name)
>>：['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'FFF'] #追加一个索引内容后的现实效果
5.2 插入insert：name.insert(2,'AAA') #根据指定的索引值插入，插入到指定的索引值前面
name=['aaa','bbb','ccc','ddd','eee']
name.insert(2,'AAA') #指定插入的内容在哪一个索引前面
print(name)
>>：['aaa', 'bbb', 'AAA', 'ccc', 'ddd', 'eee'] #插入后的效果
6、删除列表中某一个元素 del
方法1：使用del指定列表的索引删除 #这种方法不是列表特有的删除方法
name=['aaa','bbb','ccc','ddd','eee']
del name[0] #可以使用del，然后指定列表的索引删除
print(name)
>>：['bbb', 'ccc', 'ddd', 'eee']
方法2：name.remove('aaa') #指定要删除的元素，remove方法没有返回值
name=['aaa','bbb','ccc','ddd','eee']
name.remove('aaa')
print(name)
>> ：['bbb', 'ccc', 'ddd', 'eee']
name.remove(0) #使用name.remove删除列表的元素是，删除的元素必须是"in list"存在于列表中的，否则报错如下
ValueError: list.remove(x): x not in list
方法3：从列表中取走一个值pop，被取走的值，可以被引用 # name.pop(0)，指定索引删除，原值会改变
name=['aaa','bbb','ccc','ddd','eee']
name.pop(0) #按照索引删除一个元素
print(name)
#>>：['bbb', 'ccc', 'ddd', 'eee'] #已经把列表的索引"0"删除了
print(name.pop(0)) #删除后有返回值(已经删掉的元素)，超出索引则报错
#>>：bbb
7、for 循环
name='szq'
for n in name: #相当于：for n in 'szq',把字符串'szq'的每一个字符单独打印出来
print(n)
>>：s
>>：z
>>：q
这里可以看出，for循环内，对变量n依次赋值为"szq"(依次赋值为"s" "z" "q")，那么在取变量n的值的时候，就能够依次取出"s" "z" "q"多个值
1.3.1.2 列表list需要掌握的操作：
1、反转 reverse #反转(修改列表的值，按照倒序排列，使用reverse后原值也会被修改)
name=['aaa','bbb','ccc','ddd','eee']
name.reverse() #反转，把列表里面的值倒序排列
print(name.reverse())
>>：None
print(name) #reverse修改的是原值，直接把原值从正序改为了倒序
>>：['eee', 'ddd', 'ccc', 'bbb', 'aaa']
2、count 统计元素的个数(当前列表中有几个'aaa')
name=['aaa','bbb','ccc','ddd','eee']
name.count('aaa')
print(name.count('aaa')) #统计元素的个数(当前列表中有几个'aaa')
>>：1
3、clear 清空列表中所有的值
name=['aaa','bbb','ccc','ddd','eee']
name.clear()
print(name.clear()) #清空列表中所有的值
>>：None
print(name)
>>：[]
4、copy 复制
name=['aaa','bbb','ccc','ddd','eee']
l=name.copy() #复制一份内容
print(l)
>>：['aaa', 'bbb', 'ccc', 'ddd', 'eee']
5、index 查看索引值的序列号
name=['aaa','bbb','ccc','ddd','eee']
name.index('aaa')
print(name.index('aaa'))
>>：0 #'aaa'在列表中处于第0个索引
6、sort 排序 #对同类型的元素排序，从小到大排序(数字和字符串不能做比较)
name=[-1,99,22,-3,23]
name.sort() #对同类型的元素排序，从小到大
print(name)
>>：[-3, -1, 22, 23, 99]
name=['aaa','bbb','ccc','ddd','eee']
name.sort() #字符串比较大小，从字符串的第一个元素开始比较谁大谁小
print(name)
['aaa', 'bbb', 'ccc', 'ddd', 'eee']
1.3.1.3、列表list总结
1、列表能存多个值
2、列表属于有序(可以按照索引取值的都为有序)
3、列表属于可变类型
1.4 队列与堆栈
1.4.1 队列-(先进先出)
#入队列：
name=[]
name.append('aaa') #使用append追加，每次追加的内容都在末尾
name.append('bbb')
name.append('ccc')
print(name)
>>：['aaa', 'bbb', 'ccc']
#出队列：
name.pop(0) #使用pop取值，符合先进先出的规则，那么就要取第一个索引的值'aaa'
print(name)
>>：['bbb', 'ccc'] #取出'aaa'，之后剩下['bbb', 'ccc']
name.pop(0)
print(name)
>>：['ccc'] #取出'bbb'，之后剩下['ccc']
name.pop(0)
print(name)
>>：[] #取出'ccc'，之后剩下[]
或者：
#入队列：
name=[]
name.append('aaa')
name.append('bbb')
name.append('ccc')
print(name)
#出队列：
print(name.pop(0))
>>：aaa #第一个取出的值
print(name.pop(0))
>>：bbb #第二个取出的值
print(name.pop(0))
>>：ccc #最后一个取出的值
1.4.2 堆栈-(先进后出，或后进先出)
#入栈
name=[]
name.append('aaa')
name.append('bbb')
name.append('ccc')
print(name)
#出栈
name.pop(-1) #这里是有pop(-1)，取倒数第一个值
print(name)
>>：['aaa', 'bbb'] #取出'ccc'后，还剩下['aaa', 'bbb']
name.pop(-1)
print(name)
>>：['aaa'] #取出'bbb'后，还剩下['aaa']
name.pop(-1)
print(name)
>>：[] #取出'aaa'后，还剩下[]
或者：
#入栈
name=[]
name.append('aaa')
name.append('bbb')
name.append('ccc')
print(name)
>>：['aaa', 'bbb', 'ccc']
#出栈
print(name.pop(-1))
>>：ccc #第一个取出的值
print(name.pop(-1))
>>：bbb #第二个取出的值
print(name.pop(-1))
>>：aaa #最后一个取出的值
1.5 元组 tuple (不可变的列表) #可以理解为一个列表但是值不能被修改
1.5.1 元组的用法和列表是一样的，只不过元组属于不可变类型
1.5.2 元组属于有序，可以存多个值，属于不可变类型
1.6 字典类型 dict
定义：在{}内，以逗号分隔，每个元素是用key : value的形式
强调：key通常是字符串类型(不可变类型)，value可以是任意类型，key和value之间通过冒号":"，来建立对应关系
打印一个字典的值：print(变量名[Key])
例子1：字典的写法
szq_info={'aaa':111, #'aaa'就是一个Key
'bbb':222,
'ccc':333,
'ddd':['11','22','33'] #'ddd'也是一个Key,它的值为['11','22','33']
}
print(szq_info['aaa'])
111 #获取到Key(aaa)对应的value(111)
print(szq_info['ddd'][1])
22 #获取到Key(ddd)对应的value['11','22','33']，取第二个索引
1.6.1 列表List与字典Dict的组合应用
students=[
{'name':'szq','age':18,'hobby':['read','sleep']},
{'name':'wusp','age':28,'hobby':['read','sleep']},
{'name':'zhangold','age':38,'hobby':['read','sleep']}
]
print(students[1]) #取第2个索引的值
{'name': 'wusp', 'age': 28, 'hobby': ['read', 'sleep']}
print(students[1]['name']) #取第2个索引的值，然后取Key 'name'，取Key 'hobby'
wusp
print(students[1]['hobby']) #取第2个索引的值，然后取Key 'hobby'
['read', 'sleep']
print(students[1]['hobby'][1]) #取第2个索引的值,然后取Key 'hobby' 得到['read','sleep']，然后在取第2个索引的值
sleep
1.6.1.1 字典dir优先掌握的操作：
1、按key存取值：可存可取
name={'aaa':1123,'bbb':1223}
name['aaa']=333 #修改key'aaa'对应的value的值为'333'
print(name) #字典属于可变类型
>> ：{'aaa': 333, 'bbb': 1223} #发现key对应的值已经被改变
2、长度len #判断字典中 Key的个数
name={'aaa':1123,'bbb':1223}
name['aaa']=333
print(len(name))
>> ：2
3、成员运算in和not in #for循环中取得变量是key
name={'aaa':1123,'bbb':1223}
name['aaa']=333
for n in name: #for循环中取得变量是key
print(n)
>> ： aaa
>> ： bbb
4、删除 popitem的用法和pop的用法
4.1、popitem的用法：删除字典中里面的最后一个键值对，通过调用name.popitem()获取到被删除的键值对
name={'aaa':111,'bbb':222,"ccc":333}
print(name.popitem()) # popitem表示删除掉一个键值对items()
>> ：('ccc', 333) # 执行name.popitem()，得到一个元组类型数据
4.2、pop的用法：删除字典里面的一个key，通过调用name.pop('aaa')获取到被删除key对应的value
name={'aaa':1123,'bbb':1223}
print(name.pop('aaa')) #pop后面接key，那么得到删除的key对应的值
>> ：1123
print(name) #使用pop删除后，那么这个key对应的键值对就会被删除
>>：{'bbb': 1223}
4.3、如果删除的key不存在，那么使用default默认输出一个值，但是原值不会改变
name={'aaa':1123,'bbb':1223}
print(name.pop('aaaaaa','没有这个key,请重新定义Key')) #如果定义了一个不存在的key，那么给一个默认输出
>>：{没有这个key,请重新定义Key
print(name) #那么原值不会发生任何改变
>>：{{'aaa': 1123, 'bbb': 1223}
5、键keys()，值values()，键值对items()
5.1、keys 取出所有的key
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
print(msg_dic.keys()) #.keys指的是字典的所有key
>>：dict_keys(['apple', 'tesla', 'mac', 'lenovo', 'chicken'])
在使用for循环时，使用.keys可以拿到字典中所有的key(不过for循环本身即可完成)
for n in msg_dic.keys():
print(n)
>>：apple
>>：tesla
>>：mac
>>：lenovo
>>：chicken
5.2 values 取出所有的value
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
print(msg_dic.values()) #.value指的是所有的key对应的value
>>：dict_values([10, 100000, 3000, 30000, 10])
在使用for循环时，使用.values可以拿到字典中所有的key对应的value(相当于取所有的值)
for n in msg_dic.values():
print(n)
>>：10
>>：100000
>>：3000
>>：30000
>>：10
5.3 items 取出所有的键值对
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
print(msg_dic.items())
>>：dict_items([('apple', 10), ('tesla', 100000), ('mac', 3000), ('lenovo', 30000), ('chicken', 10)])
在使用for循环时，使用.items可以拿到字典中所有的键值对 (转换成了元组的形式)
for n in msg_dic.items():
print(n)
>>：('apple', 10)
>>：('tesla', 100000)
>>：('mac', 3000)
>>：('lenovo', 30000)
>>：('chicken', 10)
使用for循环转换，把items拿到的元祖形式装换为普通形式：
for k,v in msg_dic.items(): #items取出的是所有的键值对，那么定义变量k==keys,v==values,就能得到所有的keys和values
print(k,v)
>>：apple 10
>>：tesla 100000
>>：mac 3000
>>：lenovo 30000
>>：chicken 10
6、循环(循环字典)
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
for n in msg_dic: #n定义为字典的中所有的key
print(n) #打印n得到所有的key
>>：apple
>>：tesl
>>：mac
>>：lenovo
>>：chicken
print(msg_dic[n]) #打印字典中所有的key，得到所有的key对应的value
>>：10
>>：100000
>>：3000
>>：30000
>>：10
print(n,msg_dic[n]) #打印字典中所有的key及对应的value
>>：apple 10
>>：tesla 100000
>>：mac 3000
>>：lenovo 30000
>>：chicken 10
1.6.1.2 字典dir需要掌握的操作：
1、msg.get('aaa') # 如key('aaa')不存在字典中，那么返回空值，而不是报错
msg={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
print(msg.get('aaa','值不存在'))
>> ：None #默认返回空值
>> ：值不存在 #可以添加提醒项，若key不存在则返回提示项
2、msg.update({'a':1,'b':2}) # 修改字典的值为设定的值
msg={'aaa':111,'bbb':222}
print(msg)
>> ：{'aaa':111,'bbb':222}
msg.update({'aaa': 'AAA', 'bbb': 'BBB', "ccc":333})
# 把.update({'aaa':'AAA','bbb':'BBB'})里面的键值赋值给msg,有则修改，无则添加。
print(msg)
{'aaa': 'AAA', 'bbb': 'BBB', 'ccc': 333}
3.1、 msg.setdefault('aaa',666) #若key('aaa')存在字典中，那么则不会修改原有的值
msg={'aaa':111,'bbb':222}
msg.setdefault('aaa',666) #若key('aaa')存在字典中，那么则不会修改原有的值
print(msg)
>> ：{'aaa': 111, 'bbb': 222}
3.2、msg.setdefault('sudada',666) #若key('sudada')不存在字典内，那么则在字典中追加一个键值对{'sudada': 666}
msg={'aaa':111,'bbb':222}
msg.setdefault('sudada',666) #若key('sudada')不存在字典内，那么则在字典中追加一个键值对{'sudada': 666}
print(msg)
>> ：{'aaa': 111, 'bbb': 222, 'sudada': 666}
总结setdefault：有则不变，无则增加
setdefault例子：博客里面，统计单词个数
1.6.1.3、字典dir总结
1、字典能存多个值
2、字典属于无序(可以按照索引取值的都为有序)
3、字典属于可变类型
1.6.1.3、python dict与zip的使用
1、zip函数：接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。
# 例子1：
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
注意：Python3.x和Python2.x这里的差别
Python3.x
xyz = list(zip(x, y, z))
Python2.x
xyz = zip(x, y, z)
print(xyz)
输出结果：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
# 例子2：
x = [1, 2, 3]
y = [4, 5, 6, 7]
xy = list(zip(x, y))
print(xy)
输出结果：[(1, 4), (2, 5), (3, 6)]
# 例子3：
x = [1, 2, 3]
x = list(zip(x))
print(x)
输出结果：[(1,), (2,), (3,)]
# 例子4：
x = list(zip())
print(x)
输出结果：[]
# 例子5：
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz = list(zip(x, y, z))
print(xyz )
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
u = list(zip(*xyz))
print(u)
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
一般认为这是一个unzip的过程，它的运行机制是这样的：
在运行zip(*xyz)之前，xyz的值是：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
那么，zip(*xyz) 等价于 zip((1, 4, 7), (2, 5, 8), (3, 6, 9))
所以，运行结果是：[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
注：在函数调用中使用*list/tuple的方式表示将list/tuple分开，作为位置参数传递给对应函数（前提是对应函数支持不定个数的位置参数）
2、zip函数在字典里面的使用
# 例子1：zip函数利用字符串创建字典
key = 'abcde'
value = range(1, 6)
print(dict(zip(key, value)))
输出结果：{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# 例子2：使用items()来遍历字典
d={'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
for key,value in d.items():
print(key,value)
或者：
for n in d:
print(n,d[n])
a 1
b 2
c 3
d 4
e 5
# 例子3：dict(dict1, **dict2)合并两个字典
a={'a':1,'b':2,'c':3}
b={'d':11,'e':22,'f':33}
print(dict(a,**b))
输出结果：{'a': 1, 'b': 2, 'c': 3, 'd': 11, 'e': 22, 'f': 33}
# 例子4：合并多个字典：如果多个字典内有重复的key，那么以"**b"字典为准
a={'a':1,'b':2,'c':3}
b={'d':11,'e':22,'f':33}
c=dict(a,**b)
d={'aa': 1, 'bb': 2, 'c': 3333, 'd': 4, 'e': 5}
print(dict(c,**d))
输出结果：{'a': 1, 'b': 2, 'c': 3333, 'd': 4, 'e': 5, 'f': 33, 'aa': 1, 'bb': 2}
# 例子5：使用fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
seq={'name','age','score'}
d=dict.fromkeys(seq,100)
print(d)
输出结果：{'score': 100, 'name': 100, 'age': 100}
1.7 布尔类型 - 只有2种值， "True"或者"False"
a=3
b=5
print(a>b)
False #3>5不成立则为False
print(a<b)
True #3<5成立则为True
1.7.1 布尔类型补充知识：所有的数据类型都自带布尔值(True或False )
1.这里需要知道：什么样的数据类型自带的布尔值是为False(假)
即：0，None，空(字符串没有定义的值)
if not cmd:continue #if 后面接条件，当条件为真(True)时，执行continue。那么只有在cmd的值为"空"(False)时，cmd为假，那么not cmd即为"真"(True)。 #这里取了个反值
1.8 可变或者不可变类型
1.8.1 可变类型定义：值发生改变，但是id没有发生改变--【可变类型是不可hash的】
1.列表类型(list)
2.字典类型(dict)
l=['a','b','c','d']
print(id(l),l)
3130959555272 ['a', 'b', 'c', 'd'] #第一次打印得到ID和值
l[0]='A'
print(id(l),l)
3130959555272 ['A', 'b', 'c', 'd'] #第二次打印得到ID和值
#运行后可以看出，第二次与第一次相比较，值发生改变，但是id没有发生改变，满足可变数据类型！
1.8.2 不可变类型定义：值发生改变，id也发生改变--【不可变类型是可以hash的】
1.数字类型(int与float)，
2.字符串类型(str)，
3.元组类型(tuple)，
1.9、集合{}类型(set)
2.定义方式
2.1 {}内用逗号分隔开多个元素，每一个元素必须为不可变类型(也就是集合内只能存不可变类型)
2.2 集合内的元素不能重复
2.3 集合无序(不能被索引取值)
s={1,'a',3} #集合内定义值得方式
print(type(s))
>>：<class 'set'>
3、集合优先掌握的操作
1、长度len
s={1,'a',3}
print(len(s))
>>：3
2、成员运算in和not in
s={1,'a',3}
print('a' in s)
>>：True
print('b' not in s)
>>：True
3、|合集
A={111,'aaa',3333,333}
B={111,222,333,'aaa','bbb'}
print(A | B) #并集(A与B所有的值加起来)
>>：{3333, 333, 111, 'bbb', 222, 'aaa'}
4、&交集
A={111,'aaa',3333,333}
B={111,222,333,'aaa','bbb'}
print(A & B) #交集(A与B都存在的值)
>>：{333, 'aaa', 111}
5、-差集
A={111,'aaa',3333,333}
B={111,222,333,'aaa','bbb'}
print(A - B) #差集(A减B:该值在A存在但是在B不存在)
>>：{3333}
>print(B - A) #差集(B减A:该值在B存在但是在A不存在)
>>：{'bbb', 222}
6、^对称差集
A={111,'aaa',3333,333}
B={111,222,333,'aaa','bbb'}
print(A ^ B) #对称差集(取A与B之间不重复的值(A与B去重后得到的值))
>>：{3333, 'bbb', 222}
7、父集(>,>=) 与 子集(<,<=)
# 集合之间做比较：指的是包含于被包含的关系
s1={1,2,3}
s2={1,2}
print(s1 >= s2) #s1包含s2
>>：True
print(s2 <= s1) #s2被s1包含
>>：True
4、集合需要掌握的操作
1、difference与difference_update（差集）
s1={'a','b','c'}
s2={'b','d','f'}
print(s1.difference(s2)) #s1与s2的差集
# >>：{'a', 'c'}
s1.difference_update(s2) #这步操作实际上就是把s1与s2的差集赋值给s1(重新定义了s1)
print(s1)
# >>：{'a', 'c'}
2、add（添加）
s1={'a','b','c'}
s2={'b','d','f'}
s1.add('d') #在集合内添加一个值
print(s1)
# >>：{'c', 'd', 'a', 'b'}
3、删除集合内的元素
s1={'a','b','c'}
s2={'b','d','f'}
s1.remove('a') #把集合内的元素'a'删除(删除后无返回值)
print(s1)
# >>：{'c', 'b'}
s1.discard('a') #把集合内的元素'a'删除(删除后无返回值)
print(s1)
# >>：{'b', 'c'}
s1.pop() #随机删除集合内的元素(有返回值)
print(s1)
# >>：{'a', 'c'}
# >>：{'b', 'c'}
例子1：替换列表里面的某个元素(这里指的某些特殊字符) -- 根据excel获取IP值那个脚本学到的
import re
list_a=['外网IP', '75.126.166.229', '75.126.134.229', '75.126.214.83|10.80.142.94', '75.126.134.226',]
list_d={' ':'\|'} """ key=" " 空 value='\|' """
list_b=",".join(list_a)
for n in list_d.keys():
list_b=re.sub(list_d[n],n,list_b)
"""
参数介绍：
re.sub 正在表达式里面'替换'的用法
list_d[n] == '\|'
n == ' '
list_b == '外网IP,75.126.166.229,75.126.134.229,75.126.214.83 10.80.142.94,75.126.134.226'
意思介绍：
把字符'\|'替换为空' '，针对内容'外网IP,75.126.166.229,75.126.134.229,75.126.214.83 10.80.142.94,75.126.134.226'
"""
print(list_b.split(","))
>>：['外网IP', '75.126.166.229', '75.126.134.229', '75.126.214.83 10.80.142.94', '75.126.134.226']
例子2：替换列表里面的某个元素
import re
a = ["123", "456", "789"]
d = {
"B": "2",
"E": "5",
"H": "8"
}
b = ",".join(a)
print(b)
# 123,456,789
for i in d.keys():
b = re.sub(d[i], i, b)
"""
参数介绍：
d[i] = key对应的值
i = 字典d里面的key
b = '123,456,789'
意思介绍：
把数字"2" "5" "8"替换为"B" "E" "H"，针对内容'123,456,789'
"""
print(b.split(","))
# ['1B3', '4E6', '7H9']
例子：将三个列表内的数据并排显示
total = []
a=['外网IP', '75.126.166.229', '75.126.134.229', '75.126.214.83']
b=['内网IP', '10.84.248.207', '10.86.92.198', '10.81.223.142']
c=['root', 'C6SWlKJ3', 'F3PcL98m', 'Dd59nlVA', 'AqGb6qfh', 'V5']
for q,w,e in zip(a,b,c):
total.append(q+' '+w+' '+e)
for n in total:
print(n)
>>：外网IP 内网IP root
>>：75.126.166.229 10.84.248.207 C6SWlKJ3
>>：75.126.134.229 10.86.92.198 F3PcL98m
>>：75.126.214.83 10.81.223.142 Dd59nlVA
1.10、eval函数 eval函数就是实现list、dict、tuple与str之间的转化
1、字符串转换成列表
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
b = eval(a)
print(b)
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
2、字符串转换成字典
aa = "{1: 'a', 2: 'b'}"
bb = eval(aa)
print(bb)
{1: 'a', 2: 'b'}
3、字符串转换成元组
aaa = "([1,2], [3,4], [5,6], [7,8], (9,0))"
bbb = eval(aaa)
print(bbb)
([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))