遵义北京网站建设,wordpress 超过2m,网站做百度推广的要求,网络营销顾问是什么数据类型是编程语言中的一个重要概念#xff0c;它定义了数据的类型和提供了特定的操作和方法。在 python 中#xff0c;数据类型的作用是将不同类型的数据进行分类和定义#xff0c;例如数字、字符串、列表、元组、集合、字典等。这些数据类型不仅定义了数据的类型#xf…数据类型是编程语言中的一个重要概念它定义了数据的类型和提供了特定的操作和方法。在 python 中数据类型的作用是将不同类型的数据进行分类和定义例如数字、字符串、列表、元组、集合、字典等。这些数据类型不仅定义了数据的类型还为数据提供了一些特定的操作和方法例如字符串支持连接和分割列表支持排序和添加元素字典支持查找和更新等。因此选择合适的数据类型是 python 编程的重要组成部分。
2.1 算数类型
算数运算符在编程语言中是一种非常重要的工具它用于执行数学运算。在 python 中算数运算符大致可以分为 7 种类型算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符和身份运算符。
除了运算符外python 还支持多种数值类型如int、float、bool和 complex复数等。这些数值类型的赋值和计算都是直观易懂的因此它们对于初学者来说是非常友好的。
数值间的数据互换可以参考如下列表:
函数名描述int(x)将 x 转换为一个整数long(x)将 x 转换为一个长整数float(x)将 x 转换为一个浮点数complex()创建一个复数str(x)将对象 x 转换为字符串repr(x)将对象 x 转换为表达式字符串eval(str)计算字符串中的有效 python 表达式tuple(x)将序列 x 转换为一个元组list(x)将序列 x 转换为一个列表chr(x)将一个整数转换为一个字符unichr(x)将一个整数转换为 Unicode 字符ord(x)将一个字符转换为它的整数值hex(x)将一个整数转换为一个十六进制字符串oct(x)将一个整数转换为一个八进制字符串
基本算术运算: 算数运算是任何一门编程语言中都存在的使用算术运算可以实现对特定变量的加减乘除比较等基本功能在Python中实现算数运算很容易。 import math,osnumberA 10numberB 20numberC 10numberA numberB
30numberA ! numberB
TruenumberA 10位运算符号: 在程序中位运算就是直接对整数在内存中的二进制位进行操作。 a60 # 60 0011 1100 b13 # 13 0000 1101c a b # 12 0000 1100print(a与b: ,c)
a与b: 12c a | b # 61 0011 1101 print(a或b: ,c)
a或b: 61ca^b # 49 0011 0001print(a异或b:,c)
a异或b: 49ca 2 # 240 1111 0000print(a左移2,c)
a左移2 240其他运算符: 其他运算符包括常用的,逻辑运算,成员运算,身份运算等. num1 10num2 20num3 0list [10,20,30,40,50]num1 and num3
0num1 in list # 判断num1是否在list里面
Truenum1 not in list
Falsenum1 is num3 # 判断两个标识符是不是引用自一个对象
Truenum1 is num2
Falsenum1 is not num2
True整数转其他数值: 使用转换命令将一个整数转换为其他任意数值. number 100float(number)
100.0complex(number)
(1000j)str(number)
100chr(number)
dord(chr(number))
100实现数值之间进制转换: 使用转换命令实现进制转换,bin二进制,oct八进制,hex十六进制,format也支持转换输出. import mathnumber 1024bin(number)
0b10000000000oct(number)
0o2000hex(number)
0x400format(number,b)
10000000000format(number,x)
400int(-4d2,16)
-1234实现浮点数/负数之间运算: 复数的函数操作正弦、余弦和平方根可以使用cmath模块 import cmath,mathnumberA complex(2,4)numberB 3-5jnumberA,numberB # 复数相加
((24j), (3-5j))numberA.real # 取实属部分
2.0numberA.imag # 取虚数部分
4.0math.ceil(3.14) # 四舍五入
4round(3.14) # 四舍五入
3cmath.sin(numberA)
(24.83130584894638-11.356612711218174j)cmath.cos(numberA)
(-11.36423470640106-24.814651485634187j)cmath.exp(numberA)
(-4.829809383269385-5.5920560936409816j)数值格式化输出: 针对数值做格式化,并对齐进行输出显示. number 1234.56789format(number,0.2f)
1234.57 # 格式化时精确2位小数value {:20.3f}.format(number) # 输出右侧对齐
value 1234.568value {:20.3f}.format(number) # 输出左侧对齐
value 1234.568 value {:^20.3f}.format(number) # 输出居中对齐
value 1234.568 数值类型格式化输出: 实例化数字类型,或将其他类型转换为数字类型,或各种进制转换为十进制. temp int(21) # 实例化数字类型print(type(temp),temp) # 打印类型,和参数值
class int 21print(int(110101,base2)) # 将二进制转为十进制
53print(int(156,base8)) # 将八进制转为十进制
110print(int(1A2C31,base16)) # 将十六进制转为十进制
17152492.2 字符类型
字符串是字符的集合是一种常见的数据类型。python 提供了强大的字符串处理功能以支持各种字符串操作。例如您可以使用字符串运算符进行字符串拼接、比较和替换您还可以使用字符串内置函数对字符串进行搜索、切片、大小写转换等操作。
总的来说字符串是 python 编程中不可或缺的一部分它们在处理文本数据、输入输出、网络通信等方面都发挥了重要作用。因此学习和掌握 python 中的字符串操作是非常必要的。
接下来我们将找出几个比较常用的字符串函数来进行演示.
方法描述str.capitalize()将字符串的首字母变为大写str.title()将字符串中的每个单词的首字母大写str.upper()将字符串转换为大写str.lower()将字符串转换为小写str.index()返回字符串中指定子字符串的索引str.find()返回字符串中指定子字符串的索引str.count()返回字符串中指定元素出现的次数str.format()格式化字符串str.center()用指定字符填充字符串使其居中str.join()以指定字符串连接字符串str.split()使用指定字符作为分隔符来分割字符串str.strip()去除字符串左右两边的空格str.replace()查找并替换字符串中的元素str.isupper()判断字符串是否为大写str.islower()判断字符串是否为小写str.isalnum()判断字符串是否为字母或数字str.isalpha()判断字符串是否为字母或下划线str.isdigit()判断字符串是否为数字str.isspace()判断字符串是否为空格str.startswith()返回以指定元素开头的字符串str.endswith()返回以指定元素结尾的字符串
首字母大写: 使用capitalize()函数,将一个指定字符串首字母变成大写. strhello lysharkstr.capitalize()
Hello lyshark全部首字母大写: 使用title()函数,将字符串中的每一个单词的首字母大写. strhello lysharkstr.title()
Hello Lyshark查找字符串位置: 使用index()查找字符串所在位置(不能存在则报错),使用find()查找字符串位置(不存在返回-1). str hello lysharkstr.index(hello)
0str.index(lyshark)
6str.find(hello)
0统计字符串出现次数: 使用count()函数,统计指定字符串的出现次数. strhello lysharkstr.count(h)
2str.count(l)
3str.count(hello)
1str.count(mk)
0字符串文本对齐: 字符串对齐函数实现对字符串的对齐与填充,字符串方法包括ljust()、rjust()和center() str hello lysharkstr.ljust(30)
hello lyshark str.rjust(30)hello lysharkstr.center(30)hello lyshark str.center(50,-)
------------------hello lyshark-------------------字符串连接: 使用join()函数,将序列中以指定的字符连接生成一个新字符串 str-seq(hello,lyshark,welcome)print(str.join(seq))
hello-lyshark-welcomelist [1,2,3,4,5]print(.join(list))
12345kill %s % .join([1024,2234])
kill 1024 2234切割字符串: 使用split()函数,指定分割一个字符串,并保存成列表. strhello-lyshark-welcomestr.split(-)
[hello, lyshark, welcome]去除字符串两边空格: 使用strip()函数去除两边的空格,而lstrip/rstrip则是分别去掉两边空格. str hello lyshark str.strip() # 去掉两边空格
hello lysharkstr.rstrip() # 去掉右边空格hello lysharkstr.lstrip()
hello lyshark 去除字符串中注释行: 将一个文件中的以警号开头的行注释掉. import oswith open(test.log,r) as fp:
... for each in fp:
... if each[0] #:
... continue
... else:
... print(each,end)字符串查找并替换: 通过使用replace()函数或者是re.sub()函数,查找并替换指定字符串. string hello lyshark ! ?string.replace(lyshark,world)
hello world ! ?string.replace(!,).replace(?,)
hello lyshark string brhello lyshark/br !re.sub([br | /br | ],,string)
hellolyshak!判断是否为大写: 使用isupper()函数,判断指定字符串是否为大写. strLYSHARKstr1lysharkstr.isupper()
Truestr1.isupper()
False实现字符串拆分: 通过split拆分分解元素,将一个字符串拆解成多个部分. string python# 拆分上面的字符串,忽略某个值使用下划线代替x,_,_,y,_,_ stringx
ppasswd root:x:0:0:root:/root:/bin/bashusername,*_,homedir,sh passwd.split(:)username
root查找开头结尾: 使用startswith函数,找出指定字母开头的字符元素,endswith找出字母结尾的元素. from fnmatch import fnmatch,fnmatchcaseurl https://www.baidu.comurl.endswith(.com)
Trueurl.startswith(http://)
Falseurl.startswith(https://) and url.endswith(.com)
Truefnmatch(url,*.com)
Truefilename [a.py,b.zip,c.zip,d.doc,e.py,f.jpg,g.gz,h.tar.gz][ item for item in filename if item.endswith((.py,.jpg)) ] # 多个结果匹配时使用元组集合
[a.py, e.py, f.jpg]any(item.endswith(.py) for item in filename) # 判断目录中是否有.py结尾的文件
Truenames [dat01.csv,dat99.csv,config.ini,foo.py][i for i in names if fnmatch(i,dat[0-9]*.csv)] # 支持正则匹配查询
[dat01.csv, dat99.csv]addr [
... 5412 N CLARK ST,
... 1060 W ADDISON ST,
... 1039 W GRANVILLE AVE,
... 2122 N CLARK ST,
... 4802 N BROADWAY ][ i for i in addr if fnmatch(i,*ST) ]
[5412 N CLARK ST, 1060 W ADDISON ST, 2122 N CLARK ST][ i for i in addr if fnmatch(i,*CLARK*) ]
[5412 N CLARK ST, 2122 N CLARK ST]2.3 列表类型
列表List是最常用的数据结构之一它是一个有序的、可变的、元素可以重复的集合。列表中的每个元素都可以根据它们在列表中的位置或索引进行访问第一个元素的索引为0第二个为1以此类推。列表可以容纳任意类型的对象包括整数、浮点数、字符串、函数等。
列表操作函数来进行演示.
方法名描述list.insert()在列表中指定索引位置前插入元素list.append()在列表尾部插入list.remove()删除指定的元素list.pop()没有指定索引则弹出最后一个元素返回的结果是弹出的索引对应的元素list.copy()浅复制只复制第一层如果有嵌套序列则不会复制需要复制要导入copy模块list.extend()把另外一个列表合并并不是追加list.index()列表中元素出现的索引位置list.count()统计列表中元素的次数list.reverse()进行逆序list.sort()进行排序无法把数字和字符串一起排序list1 list2合并两个列表返回一个新的列表不会修改原列表list * N把list重复N次返回一个新列表
正向/反向输出列表: 简单的实现正向输出列表元素,与反向输出列表元素. list
[1, 2, 3, 4, 5, 6, 7, python]for each in list:
... print(正向输出: ,each)for each in reversed(list):
... print(反向输出: ,each)向列表追加数据: 使用append()函数,追加写入几个数据到指定的列表里. list [1,2,3,4,5]list.append(6)list.append(7)list.append(python)list
[1, 2, 3, 4, 5, 6, 7, python]向列表插入数据: 使用insert()函数,向指定的列表插入几个数据到指定的位置. list [admin,lyshark]list
[admin, lyshark]list.insert(1,python)list
[admin, python, lyshark]list.insert(2,ruby)list.insert(2,ruby)list
[admin, python, ruby, ruby, lyshark]修改指定数据: 使用names[]变量赋值的方式,修改指定元素的字段值. list
[admin, python, ruby, ruby, lyshark]list[0]mkdirslist
[mkdirs, python, ruby, ruby, lyshark]list[3]piplist
[mkdirs, python, ruby, pip, lyshark]删除指定数据: 使用remove()函数,删除指定数据,或使用del()函数来删除. list
[mkdirs, python, ruby, pip, lyshark]del list[2] #通过下标删除元素list
[mkdirs, python, pip, lyshark]list.remove(python) #删除指定的元素list
[mkdirs, pip, lyshark]list.pop() #删除列表的最后一个元素
lysharklist.pop()
piplist
[mkdirs]扩展一个列表: 使用extend()函数,将一个列表追加到另一个列表的后面. list1 [admin,guest,lyshark]list2 [1,2,3]list1.extend(list2)list1
[admin, guest, lyshark, 1, 2, 3]浅COPY列表: 使用copy()函数,实现列表的浅Copy. list1
[admin, guest, lyshark, 1, 2, 3]list1_copy list1.copy()list1_copy
[admin, guest, lyshark, 1, 2, 3]统计元素次数: 使用count()函数,统计列表中元素出现的次数. list [admin,admin,lyshark,mkdirs]list.count(admin)
2list.count(mkdirs)
1列表正反向排序: 使用sort()函数实现正向排序,使用reverse()函数则实现反向排序. list [admin,python,ruby,1,3,6,9]list
[admin, python, ruby, 1, 3, 6, 9]list.sort() #正向排序,必须元素类型一致list
[1, 3, 6, 9, admin, python, ruby]list
[1, 3, 6, 9, admin, python, ruby]list.reverse() #反向排序,必须元素类型一致list
[ruby, python, admin, 9, 6, 3, 1]获取列表元素下标: 使用index()函数,我们可以获取到指定元素的下标值. list
[ruby, python, admin, 9, 6, 3, 1]list.index(admin)
2list.index(1)
6实现列表的切片: 使用[]特殊符号既可以定义列表,也可以实现列表的各种切片操作. list[1,2,3,4,5,6,7,8,9,0]list[1:4] #取出下标1-4的元素,不包括4
[2, 3, 4]list[1:-1] #取出下标1至-1,不包括-1
[2, 3, 4, 5, 6, 7, 8, 9]list[1:] #取出下标从1到最后的数据
[2, 3, 4, 5, 6, 7, 8, 9, 0]list[:] #取出所有元素
[1, 2, 3, 4, 5, 6, 7, 8, 9]list[0::2] #取元素时每次格2格
[1, 3, 5, 7, 9]通过分片删除数据: 通过使用分片来清除指定列表中的数据. list
[123, 111, 111, 111, 8, 7, 6, 5, 4, 3, 2, 1]list[0:3]
[123, 111, 111]list[0:3][] #将下标0-3替换成空,不包括3print(list)
[111, 8, 7, 6, 5, 4, 3, 2, 1]嵌套列表的实现: 一次性声明两个列表,并于数据名称相关联. list1,list2 [[1,a,b],[2,a,b]]print(list1)
[1, a, b]print(list2)
[2, a, b]从列表中随机弹出元素: 在一个列表中随机弹出一个元素. import randomfrom random import randrangelist [admin,python,ruby,1,3,6,9]random.choice(list)
pythonrandom.choice(list)
9random_index randrange(0,len(list))list[random_index]
9列表元素查找并修改: 查找列表中的指定元素,并将列表中所有的元素1修改为88888. number [1,2,3,4,5,1,5,6,1]def FindNumber(num_list,number,modify):
... for item in range(num_list.count(number)):
... ele_index num_list.index(number)
... num_list[ele_index] modify
...number
[1, 2, 3, 4, 5, 1, 5, 6, 1]FindNumber(number,1,88888)number
[88888, 2, 3, 4, 5, 88888, 5, 6, 88888]列表生成式筛选元素: 通过使用列表生成式,我们可以灵活地筛选出列表中的元素. from itertools import compressmylist [1,2,-5,10,-8,3,-1]list(item for item in mylist if item 0) # 筛选出列表中大于0的数值
[1, 2, 10, 3]list(item for item in mylist if item 0) # 筛选出列表中小于0的数值
[-5, -8, -1]list(item if item0 else 0 for item in mylist) # 大于0的数值直接输出,小于0的直接填0
[1, 2, 0, 10, 0, 3, 0]more [item 3 for item in mylist] # 列表中大于3的返回真假more
[False, False, False, True, False, False, False]统计列表中元素出现频率: 统计出number列表中所有元素的出现频率,并组合成字典. number [12:10,12:20,12:10,12:20,12:20,12:10,12:10]def GetFrequency(item):
... dict {}
... for x in item:
... dict[x] dict.get(x,0) 1
... return dict
...dict GetFrequency(number)dict
{12:10: 4, 12:20: 3}from collections import Counterdata [1,1,1,1,2,3,4,4,5,6,5,3,3,4,5,6,7,8,9,6,5,4,5]Counter(data) # 统计列表元素出现次数,以字典方式展现
Counter({5: 5, 1: 4, 4: 4, 3: 3, 6: 3, 2: 1, 7: 1, 8: 1, 9: 1})Counter(data).most_common() # 统计列表元素出现次数,以元组方式展现
[(5, 5), (1, 4), (4, 4), (3, 3), (6, 3), (2, 1), (7, 1), (8, 1), (9, 1)]Counter(data).most_common(2) # 统计列表元素出现次数,并取出前两个元素
[(5, 5), (1, 4)]定义固定长度的列表: 使用collections.deque保存有限的列表数据,deque用来创建一个固定长度的队列. from collections import dequequeue deque(maxlen4) # 定义最大可存储4个元素queue.append(1)queue.append(2)queue.append(3)queue.append(4)queue
deque([1, 2, 3, 4], maxlen4)queue.append(5)queue # 超出部分会被从左侧排除出去
deque([2, 3, 4, 5], maxlen4)queue.appendleft(6) # 从左边加入数据到队列,超出部分从右侧排除queue
deque([6, 2, 3, 4], maxlen4)queue.pop() # 从末尾取出一个数据
4queue.popleft() # 从左侧取出一个数据
6列表中取出最大/最小值: 在heapq模块中有两个函数nlargest()从最大的值开始取,nsmallest()从最小的值开始取. import heapqdata [1,3,4,9,11,34,55,232,445,9812,321,45,67,434,555]heapq.heappush(data,1000) # 追加写入一个元素data
[1, 3, 4, 9, 11, 34, 55, 232, 445, 9812, 321, 45, 67, 434, 555, 1000]heapq.heappop(data) # 取出第一个元素data
[3, 9, 4, 232, 11, 34, 55, 1000, 445, 9812, 321, 45, 67, 434, 555]heapq.nlargest(3,data) # 取出最大的三个数
[9999, 9812, 1000]heapq.nsmallest(3,data) # 取出最小的三个数
[4, 9, 11]将二维列表横竖颠倒: 将一个横向排列的二维数组,以竖向排列,每一排代表一条记录. val \[[/etc/system/winsss, /proc/, /sys, /abc/lyshark],[1024GG, 2048GB, 111GB, 1111GB],[1024GG, 2048GB, 111GB, 22GB],[10%, 50%, 20%, 33%]] ref_xor list ( map(list,zip(*val)) )for num in ref_xor:
... print(num)
...
[/etc/system/winsss, 1024GG, 1024GG, 10%]
[/proc/, 2048GB, 2048GB, 50%]
[/sys, 111GB, 111GB, 20%]
[/abc/lyshark, 1111GB, 22GB, 33%]多个列表的同步输出: 通过使用enumerate()/zip()函数,可以实现多个列表同时遍历输出. data [C,Java,python,Shell,Ruby,Go,perl]# enumerate() 函数可用输出元素序列for key,value in enumerate(data,1):
... print(key,value)
...
1 C
2 Java
3 python
4 Shell
5 Ruby# 迭代打印一个嵌套列表结构data [(1,2),(3,4),(5,6)]for num,(key,value) in enumerate(data,1):
... print(ID: {} Value: {} {}.format(num,key,value))
...
ID: 1 Value: 1 2
ID: 2 Value: 3 4
ID: 3 Value: 5 6# 同时迭代多个序列可使用zip()函数,它将迭代对象产生出一个元组,整个迭代的长度取其中最短的序列list1 [1,2,3,4,5]list2 [a,b,c,d]list3 [jar,py,sh]for x,y,z in zip(list1,list2,list3):
... print(x,y,z)
...
1 a jar
2 b py
3 c shfrom itertools import zip_longestfor each in zip_longest(list1,list2,list3):
... print(each)
...
(1, a, jar)
(2, b, py)
(3, c, sh)
(4, d, None)
(5, None, None)遍历列表的所有组合: itertools 模块中提供了3个函数来解决枚举所有列表元素的组合排列的可能情况. from itertools import permutations# 第一个itertools.permutations()item [1,2,3]for each in permutations(item):
... print(each)
...
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)# 如果要限定排序的长度可用指定长度参数for each in permutations(item,2):
... print(each)
...
(1, 2)
(1, 3)
(2, 1)
(2, 3)
(3, 1)
(3, 2)追加列表保持元素数: 保持列表中最多只有Size个元素,如果超出则自动shift左移或自动unshift右移,保证只有Size个元素. def shift(Array, Size, Push):
... if len(Array) Size and len(Array) 0:
... Array.pop(0)
... Array.append(Push)
... return True
... return False
...def unshift(Array, Size, Push):
... if len(Array) Size and len(Array) 0:
... Array.pop(Size-1)
... Array.insert(0,Push)Array [1,1,1,1,1,1,1,1,1,1]shift(Array,10,0)shift(Array,10,0)print(Array)
[1, 1, 1, 1, 1, 1, 1, 1, 0, 0]unshift(Array,10,0)unshift(Array,10,0)print(Array)
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1]2.4 字典类型
字典Dictionary是一种内置数据结构它是一种可变的容器模型可以存储任意类型的对象不仅如此字典的一个重要特性是它可以通过任意不可变对象通常是字符串或数字来作为键key来存储和检索值value。字典是基于哈希表实现的可以快速地根据键找到对应的值。
字典的定义使用大括号{}包含键值对每个键值对使用冒号:连接键和值键值对之间使用逗号, 分割。例如
d {name: Alice, age: 20, gender: female}在上面的例子中d 是一个字典包含三个键值对‘name’、‘age’ 和 ‘gender’ 分别是键而它们对应的值分别是 ‘Alice’、20 和 ‘female’。可以使用键来访问对应的值例如
print(d[name]) # 输出 Alice需要注意的是字典中的数据是无序存储的这意味着字典中的键值对的顺序不固定不能通过下标来访问只能通过键来访问对应的值。
另一个字典的特性是字典中的键必须是唯一的如果多个键对应的值相同后面的键值对会覆盖前面的键值对。这是因为字典是基于哈希表实现的每个键的哈希值是唯一的如果多个键的哈希值相同就会发生哈希冲突这个冲突会被解决为一个链表。所以字典中的键天生就是去重的。
如下是字典的几种格式声明:
person {name: lyshark, age: 22}
person dict({name: lyshark, age: 22})info {stu1: administrator,stu2: lyshark,stu3: redhat,
}字典需要使用字典专有的操作函数,字典的常用函数有以下这几种,后面我会使用不同的例子进行说明.
函数描述dict.get(key)取得某个key的valuedict.has_key(key)判断字典是否有这个keypython3中已废除使用indict.keys()返回所有的key为一个列表dict.values()返回所有的value为一个列表dict.items()将字典的键值拆成元组全部元组组成一个列表dict.pop(key)弹出某个key-valuedict.popitem()随机弹出key-valuedict.clear()清除字典中所有元素dict.copy()字典复制d2d1.copy()是浅复制深复制需要copy模块dict.fromkeys(s)生成一个新字典dict.update(key)将一个字典合并到当前字典中dict.iteritems()生成key-value迭代器可以用next()取下个key-valuedict.iterkeys()生成key迭代器dict.itervalues()生成values迭代器
增加字典: 在info字典的基础上,增加一个字段info[stu4] root. info
{stu1: administrator, stu2: lyshark, stu3: redhat}info[stu4] rootinfo
{stu1: administrator, stu2: lyshark, stu3: redhat, stu4: root}修改字典: 在info字典的基础上,修改将stu1:administrator修改为stu1:centos. info
{stu1: administrator, stu2: lyshark, stu3: redhat, stu4: root}info[stu1] centosinfo
{stu1: centos, stu2: lyshark, stu3: redhat, stu4: root}删除字典: 在info字典的基础上,删除几个字典,以下提供多种删除方法. info
{stu1: centos, stu2: lyshark, stu3: redhat, stu4: root}info.pop(stu1) #通过pop函数删除
centosinfo
{stu2: lyshark, stu3: redhat, stu4: root}del info[stu4] #通过del命令删除info
{stu2: lyshark, stu3: redhat}info.popitem() #随机删除元素
(stu3, redhat)查找字典: 在info字典基础上,完成几个查询任务,这里提供几种方法. info
{stu1: administrator, stu2: lyshark, stu3: redhat}stu1 in info #标准的查询方式
Trueinfo.get(stu1) #使用get函数查询
administratorinfo[stu2]
lyshark更新字典: 在info字典的基础上,更新字典内容,将temp字典与info字典合并. info
{stu1: administrator, stu2: lyshark, stu3: redhat}temp {1:2,stu4:root}info.update(temp)info
{stu1: administrator, stu2: lyshark, stu3: redhat, 1: 2, stu4: root}遍历字典: 这里提供两种字典遍历方法,建议使用第二种,因为其遍历速度最快. info {stu1: administrator, stu2: lyshark, stu3: redhat}for keys,values in info.items():
... print(keys,values)
...
stu1 administrator
stu2 lyshark
stu3 redhat for keys in info:
... print(keys,info[keys])
...
stu1 administrator
stu2 lyshark
stu3 redhat索引字典: 字典也支持索引的方式获取字典中的元素,只不过必须以key作为索引. info {stu1: administrator, stu2: lyshark, stu3: redhat}info[stu2]
lysharklen(info)
3dict {姓名:administrator,得分:[98,99,87]}dict[姓名]
administratordict[得分]
[98, 99, 87]dict[得分][2:]
[87]字典嵌套: 字典内部可继续存放列表或新的字典,遍历时只需要逐级输出即可. info {name: lyshark, gender: male, age: 22, company: [oldboy, beijing, 50]}info[name]
lysharkinfo[company][1]
beijinginfo {name: lyshark, gender: male, age: 22, company: {c_name: oldboy, c_addr: shandong}}info[company][c_addr]
shandong将字典解包: 将字典分解为独立的元组并将元组赋值给其他变量. dict {姓名:administrator,得分:[98,99,87]}t1,t2 dict.items()print(t1)
(姓名, administrator)print(t2)
(得分, [98, 99, 87])k1,k2 {x:100,y:200}print(k1)
x根据字典的值找键: 通常情况下是根据key找值,但是有时需要反过来,根据值找key. Dict { admin:001 , guest:002 , lyshark:003 }Dict.get(admin,0) # 一般用法
001list(Dict.keys())[list(Dict.values()).index(001)] # 单值返回
admindef get_keys(d, value): # 多值返回列表
... return [k for k,v in d.items() if v value]
...get_keys(Dict,002)
[guest]列表合并为字典: 将两个列表合成一个字典,其中list1是key,list2是values. dict {}list [100,200,300,400,500]head [MemTotal,MemFree,Cached,SwapTotal,SwapFree]for (keys,values) in zip(head,list):
... dict[keys] values
...dict
{MemTotal: 100, MemFree: 200, Cached: 300, SwapTotal: 400, SwapFree: 500}dict(map(lambda x,y:[x,y],head,list))
{MemTotal: 100, MemFree: 200, Cached: 300, SwapTotal: 400, SwapFree: 500}dict(zip(head,list))
{MemTotal: 100, MemFree: 200, Cached: 300, SwapTotal: 400, SwapFree: 500}字典键值对调: 将字典中的键与字典中的值进行位置的对调,第一个是列表对调,第二个是字典对调. list [100,200,300,400,500]head [MemTotal,MemFree,Cached,SwapTotal,SwapFree]{key:value for key,value in zip(head,list)}
{MemTotal: 100, MemFree: 200, Cached: 300, SwapTotal: 400, SwapFree: 500}{value:key for key,value in zip(head,list)}
{100: MemTotal, 200: MemFree, 300: Cached, 400: SwapTotal, 500: SwapFree} dict {MemTotal: 100, MemFree: 200, Cached: 300, SwapTotal: 400, SwapFree: 500}{key:value for key,value in dict.items()}
{MemTotal: 100, MemFree: 200, Cached: 300, SwapTotal: 400, SwapFree: 500}{value:key for key,value in dict.items()}
{100: MemTotal, 200: MemFree, 300: Cached, 400: SwapTotal, 500: SwapFree}字典拆分为列表: 将一个完整的字典拆分为两个列表. dict {stu1: administrator, stu2: lyshark, stu3: redhat}keys dict.keys()values dict.values()print(keys:{}.format(keys))
keys:dict_keys([stu1, stu2, stu3])dict {stu1: administrator, stu2: lyshark, stu3: redhat}keys,values zip(*dict.items())print(Keys:,str(keys))
Keys: (stu1, stu2, stu3) dict {stu1: administrator, stu2: lyshark, stu3: redhat}keys []values []items dict.items()for x in items:
... keys.append(x[0]),values.append(x[1])
...print(str(keys))
[stu1, stu2, stu3]字典合并与拷贝: 合并字典,但是在有相同的key时会覆盖原有的key的值. dict1 {x:1,y:2}dict2 {a:3,b:4}dict3 {}dict3 {**dict1,**dict2}print(dict3)
{x: 1, y: 2, a: 3, b: 4}dict3.update(dict1)dict3.update(dict2)print(dict3)
{x: 1, y: 2, a: 3, b: 4}import copyn1 {k1: wu, k2: 123, k3: [lyshark, 456]}n2 {}n2 copy.deepcopy(n1)print(n2)
{k1: wu, k2: 123, k3: [lyshark, 456]}复杂字典数据存储: 首先定义三个字典用于存储用户信息,然后将其放入一个列表中,并对列表中的元素进行取值. dict1 {name:admin,age:19,salary:3000,address:beijing}dict2 {name:guest,age:20,salary:4000,address:shanghai}dict3 {name:lyshark,age:21,salary:5000,address:shenzhen}table [dict1,dict2,dict3]# 用于获取指定人的指定字段数据print(table[1].get(name))
guestprint(table[2].get(address))
shenzhen# 打印表格中所有人的名字for i in range(len(table)):
... print(table[i].get(name))
...
admin
guest
lyshark统计字典中的重复记录数: 就是统计两个字典中key的出现频率,并输出. dictA {a: 3,c: 2, b: 1, d: 2, e: 1, r: 1, w: 2}dictB {a: 3, b: 2, d: 1, c: 1, r: 2, e: 1, s: 1, w: 1}def GetDict(A,B):
... for key,value in B.items():
... A[key] A.get(key,0) value
... return A
...item GetDict(dictA,dictB)item
{a: 6, c: 3, b: 3, d: 3, e: 2, r: 3, w: 3, s: 1}让字典保持有序存储: 字典默认是无序排列的,使用内置模块,当对字典做迭代时,它会严格按照元素初始添加的顺序进行迭代. from collections import OrderedDictdict OrderedDict()dict[one] 1dict[two] 2dict[three] 3for key,value in dict.items():
... print(key,value)
...
one 1
two 2
three 3字典中实现的列表推导: 通过使用列表推导式,对字典进行迭代操作,筛选字典元素. prices {
... ACME:45.23,
... AAPL:612.78,
... IBM:205.55,
... HPQ:37.20,
... FB:10.75,
... }P1 { key:value for key,value in prices.items() if value 30 }print(P1)
{ACME: 45.23, AAPL: 612.78, IBM: 205.55, HPQ: 37.2}tech {ACME,IBM,HPQ,FB}P2 { key:value for key,value in prices.items() if key in tech }print(P2)
{ACME: 45.23, IBM: 205.55, HPQ: 37.2, FB: 10.75}P3 dict((key,value) for key,value in prices.items() if value 100)P3
{AAPL: 612.78, IBM: 205.55}numbers [ {name:GOOG,shares:50},{name:YHOO,shares:75} ]sumnmber sum(item[shares] for item in numbers)sumnmber
125字典中元素的排序: 使用zip()将字典中的值映射为元组的迭代器,并求最大值、最小值和排序. prices {
... ACME:45.23,
... AAPL:612.78,
... IBM:205.55,
... HPQ:10.75,
... FB:10.75
... }max(zip(prices.values(),prices.keys()))
(612.78, AAPL)min(zip(prices.values(),prices.keys()))
(10.75, FB)sorted(zip(prices.values(),prices.keys()))
[(10.75, FB), (10.75, HPQ), (45.23, ACME), (205.55, IBM), (612.78, AAPL)]字典间差异对比与元素排除: 比较两个字典之间存在的差异,和排除字典中指定的key并生成新字典. dictA {x: 1 , y: 2 , z: 3}dictB {a: 10 , y: 11 , z: 12}dictA.keys() dictB.keys() # dictA和dictB中同时都有的Key
{y, z}dictA.keys() - dictB.keys() # dictA中的键不在dictB中出现的Key
{x}dictA.items() - dictB.items() # dictA和dictB中键值都相同的元素
{(y, 2), (x, 1), (z, 3)}dictOld { admin:123 , guest:456, lyshark:123123, zhangsan: 123456 }dictNew { key:dictOld[key] for key in dictOld.keys() - {guest,zhangsan} }dictNew
{lyshark: 123123, admin: 123}高级字典列表的排序: operator模块中的itemgetter函数可以对嵌套数据结构的排序会非常简单且运行很快 from operator import itemgetterdata [
... {fname:Brian,lname:Jones,uid:1003},
... {fname:David,lname:Beazley,uid:1002},
... {fname:John,lname:Cleese,uid:1001},
... {fname:Big,lname:Jones,uid:1004},
... ]sorted(data,keyitemgetter(uid)) # 以UID字段作为排序条件,从小到大的排列sorted(data,keyitemgetter(uid),reverseTrue) # 以UID字段作为排序条件,从大到小的排列sorted(data,keyitemgetter(uid,fname)) # 通过多个公共键排序max(data,keyitemgetter(uid)) # 找出UID字段最大的一条字典高级字典取出最大/最小值: 在heapq模块中有两个函数nlargest()从最大的值开始取,nsmallest()从最小的值开始取. import heapqdata [
... {name:dhcp,port:67},
... {name:mysql,port:3306},
... {name:memcached,port:11211},
... {name:nginx,port:80},
... {name:ssh,port:22}]heapq.nlargest(2,data,keylambda x:x[port]) # 取出port字段最大的两个字典
[{name: memcached, port: 11211}, {name: mysql, port: 3306}]heapq.nsmallest(3,data,keylambda x:x[port]) # 取出port字段最小的三个字典
[{name: ssh, port: 22}, {name: dhcp, port: 67}, {name: nginx, port: 80}]高级字典记录的分组: itertools模块中的函数groupby()可以通过扫描序列,并将相同元素进行分组排序. from operator import itemgetterfrom itertools import groupbyrows [
... { name:c,date: 2012/12/11 },
... { name:python,date: 2016/01/12 },
... { name:ruby,date: 2012/12/11 },
... { name:perl,date: 2020/11/12 },
... { name:c#,date: 2020/11/12 }
... ]rows.sort(keyitemgetter(date)) # 通过date字段对字典进行排序for date,items in groupby(rows,keyitemgetter(date)):
... print(时间归档: {}.format(date))
... for value in items:
... print(-- {}.format(value))
...
时间归档: 2012/12/11
-- {name: c, date: 2012/12/11}
-- {name: ruby, date: 2012/12/11}
时间归档: 2016/01/12
-- {name: python, date: 2016/01/12}# 根据数据分组来构建一个一键多值的字典 {2012/12/11: [{name: c, date: 2012/12/11}]from collections import defaultdictrows_data defaultdict(type(list))for row in rows:
... rows_data[row[date]].append(row)print(rows_data)2.5 元组类型
元组是一种不可变的有序数据结构由多个元素组成每个元素可以是不同的数据类型包括数字、字符串、元组等。元组的创建很简单只需要使用小括号将元素括起来并使用逗号隔开即可。元组一旦创建后不能对其中的元素进行修改所以也被称为只读列表。元组通常用于存储一些固定不变的数据如一行记录或一组配置参数等。元组可以作为函数的参数和返回值也可以与列表等数据类型进行相互转换。与列表不同元组中的元素是不可变的这使得元组在某些场景下比列表更加安全和高效。
函数名描述tuple.count(x)返回元组中x出现的次数tuple.index(x)返回元组中第一个出现x的位置tuple1 tuple2合并两个元组len(tuple)返回元组的长度max(tuple)返回元组中最大值min(tuple)返回元组中最小值tuple(seq)将列表转换为元组
创建元组: 同个几个实例看一下元组是如何被创建的. tup1 (google,baidu,1997,1998)tup2 (1,2,3,4,5,6,7)tup3 a,b,c,dtup1
(google, baidu, 1997, 1998)tup2
(1, 2, 3, 4, 5, 6, 7)tup3
(a, b, c, d)type(tup1)
class tuple访问元组: 元组可以使用下标索引来访问元组中的值. tup1
(google, baidu, 1997, 1998)print(tup1[0:],tup1[0])
tup1[0:] googleprint(tup1[1:2],tup1[1:2])
tup1[1:2] (baidu,)连接元组: 元组中的元素值是不允许修改的,但我们可以对元组进行连接组合. tup1 (1,2,3,4)tup2 (abc,xyz)tup3 tup1tup2print(tup3)
(1, 2, 3, 4, abc, xyz)删除元组: 元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组. tup (admin,lyshark, 1997, 2000)print(tup)
(admin, lyshark, 1997, 2000)del tup;print(tup)列表转元组: 将一个列表,强制转换成元祖. list [admin,lyshark,guest]tuple tuple(list)tuple
(admin, lyshark, guest)数据统计: 通过使用count(),index()函数统计元组中的其他数据. tuple
(admin, lyshark, guest)tuple.count(lyshark) #统计lyshark出现次数
1tuple.index(lyshark) #统计lyshark索引位置
1元素修改: 在没有嵌套的情况,元组是不可变对象,但是元组内的列表是可变的. tup(lyshark,[1,2,3,4,5])tup
(lyshark, [1, 2, 3, 4, 5])tup[1].pop()
5tup
(lyshark, [1, 2, 3, 4])元组解包: 将两个元组,查分开,分别存储在两个变量中. tup1,tup2((1,2,3),(a,b,c))print(tup1)
(1, 2, 3)print(tup2)
(a, b, c)创建可命名元组: 根据namedtuple可以创建一个包含tuple所有功能以及其他功能的类型. from collections import namedtupletup namedtuple(tup1,[x,y,z])obj tup(1,2,3)obj.x
1obj.y
2任意长度对象分解元素: 从某个可迭代对象中分解出N个元素,可以使用python的*表达式. grades (68,98,85,78,84,79,88)first,*middle,last gradessum(middle) / len(middle)
84.8records [
... (foo,1,2,3),
... (bar,11,22,33),
... (foo,4,5,6),
... (bar,44,55,66),
... ]for tag,*args in records:
... if tag foo:
... print(*args)
1 2 3
4 5 62.6 集合类型
集合是一种无序的、不重复的数据结构。集合中的元素必须是可哈希的因此支持数字、字符串、元组等不可变类型不支持列表、字典等可变类型。可以通过工厂函数set()或使用花括号{}来创建集合。将列表传入set()中可以快速实现去重而添加重复元素则会被忽略。
集合可以进行并集、交集、差集等基本运算也支持添加、删除、清空等操作。由于集合是无序的因此不支持索引、切片等操作只能通过迭代遍历来访问集合中的元素。
值得注意的是集合支持使用推导式set comprehension来创建集合形如{expression for item in iterable}这在创建大型集合时比使用循环和add()方法更为高效。另外python中还提供了frozenset()函数创建一个不可变集合它可以作为字典的键值而普通集合不能作为键值。
方法说明set.add(item)将item添加到set中,如果item已经在set中,则无任何效果set.remove(item)从set中删除item,如果item不是set的成员,则引发KeyError异常set.discard(item)从set中删除item.如果item不是set的成员,则无任何效果set.pop()随机删除一个集合元素,并从set删除,有变量接收则会接收删除到的元素set.clear()删除set中的所有元素set.copy()浅复制set.update(t)将t中的所有元素添加到set中,t可以是另一个集合、一个序列set.union(t)求并集,返回所有在set和t中的元素set.intersection(t)求交集,返回所有同时在set和t中的都有的元素set.intersection_update(t)计算set与t的交集,并将结果放入setset.difference(t)求差集,返回所有在set中,但不在t中的元素set.difference_update(t)从set中删除同时也在t中的所有元素set.symmetric_difference(t)求对称差集,返回所有set中没有t中的元素和t中没有set中的元素组成的集合set.sysmmetric_difference_update(t)计算set与t的对称差集,并将结果放入setset.isdisjoint(t)如果set和t没有相同项,则返回Trueset.issubset(t)如果s是t的一个子集,则返回Trueset.issuperset(t)如果s是t的一个超集,则返回True
set(): 实例化可变集合类型,或其他类型转换成集合类型.
(1) 实例化集合类型s set({fedora,geentoo,debian,centos})print(type(s),s)
class set {fedora, centos, debian, geentoo}(2) 将其他类型转换成集合set类型l [centos,centos,redhat,ubuntu,suse,ubuntu]s set(l)print(type(s),s)
class set {ubuntu, centos, redhat, suse} d {kernel:Linux,os:ubuntu,version:15.10}s set(d.keys())print(type(s),s)
class set {kernel, version, os}frozenset(): 实例化不可变集合,或类型转换成不可变集合类型.
(1) 实例化不可变集合fs frozenset({redhat,centos,fedora,debian,ubuntu})print(type(fs),fs)
class frozenset frozenset({fedora, ubuntu, centos, debian, redhat})(2) 类型转换成不可变集合l [1,2,3,4,4,5,5]fs1 frozenset(l)print(type(fs1),fs1)
class frozenset frozenset({1, 2, 3, 4, 5})创建集合: 使用两种方式分别创建一个集合元素. s {tom,cat,name,lyshark}s set({tom,cat,name,lyshark})s
{tom, cat, name, lyshark}type(s)
class set定义可变集合: 定义一个可变集合,集合中的元素不可重复,都是不同的. set_test set(hello)set_test
{o, e, l, h}定义不可变集合: 定义一个不可变集合,集合中的元素不可重复,都是不同的. set_test set(hello)set_test
{o, e, l, h}no_set_test frozenset(set_test)no_set_test
frozenset({o, e, l, h})求子集: 子集为某个集合中一部分的集合,故亦称部分集合. A set(abcd)B set(cdef)C set(ab)CA #C是A的子集
TrueC.issubset(A) #C是A的子集
TrueCB #C不是B的子集
False求并集: 一组集合的并集是这些集合的所有元素构成的集合,而不包含其他元素. A
{d, a, c, b}B
{f, d, e, c}A | B
{f, b, c, a, e, d}A.union(B)
{f, b, c, a, e, d}求交集: 两个集合A和B的交集是含有所有既属于A又属于B的元素,而没有其他元素的集合. A
{d, a, c, b}B
{f, d, e, c}A B
{c, d}A.intersection(B)
{c, d}求差集: A与B的差集是,所有属于A且不属于B的元素构成的集合. A
{d, a, c, b}B
{f, d, e, c}A - B
{a, b}A.difference(B)
{a, b}对称差: 两个集合的对称差是只属于其中一个集合,而不属于另一个集合的元素组成的集合. A
{d, a, c, b}B
{f, d, e, c}A ^ B
{f, b, a, e}A.symmetric_difference(B)
{f, b, a, e}添加元素: 使用add()函数,向一个现有的集合添加一个元素. s {1,2,3,4,5,6}s
{1, 2, 3, 4, 5, 6}s.add(s)s.add(e)s.add(t)s
{1, 2, 3, 4, 5, 6, t, s, e}清空集合: 使用clear()函数,清空一个集合中的所有元素. s
{1, 2, 3, 4, 5, 6, t, s, e}s.clear()s
set()删除指定元素: 使用remove,discard函数,删除集合中的指定元素. s {1,2,3,4,5}s
{1, 2, 3, 4, 5}s.remove(3)s
{1, 2, 4, 5}批量更新元素: 使用update()函数,用自己和另一个的并集来更新这个集合. s {p,y}s
{p, y}s.update([H,e],{1,2,3})s
{H, 1, y, p, 2, e, 3}2.7 序列类型
序列类型是指由索引为非负整数的有序对象集合组成的数据类型包括字符串、列表和元组。其中字符串是由字符组成的不可变序列列表和元组都是由任意python对象组成的序列。列表支持插入、删除和替换元素等操作而元组是不可变序列对元素的操作是不支持的但是可以嵌套包含列表和字典等可变对象进行操作。所有序列类型都支持迭代操作可以通过for循环遍历序列中的每一个元素。此外还可以使用切片操作对序列进行分片以获取子序列或进行元素复制。
以下是几个常用的序列操作函数:
方法描述s r连接字符串、数据s * n重复 s 的 n 次复制v1, v2, ..., vn s变量解包 (unpack)s[i]索引s[i:j]切片s[i:j:stride]扩展切片x in s, x not in s成员关系for x in s:迭代all(s)如果 s 中的所有项都为 True则返回 Trueany(s)如果 s 中的任意项为 True则返回 Truelen(s)长度元素个数min(s)s 中的最小项max(s)s 中的最大项sum(s[, initial])具有可选初始值的项的和按照上面的处理
all判断: 如果temp中的所有项都为True,则返回True. temp [1,1,1,1,1,1]temp1 [1,1,1,1,0,1]all(temp)
Trueall(temp1)
Falseany判断: 如果temp中的任意项为True,则返回True. temp [1,1,1,1,1,1]temp1 [1,1,1,1,0,1]any(temp)
Trueany(temp1)
Truelen计算元素个数: 计算列表或字典等相关的元素个数. temp [1,1,1,1,1,1]len(temp)
6min返回最小: 返回列表中最小的数值. temp [1,2,3,4,5,6,7,8,9]min(temp)
1max返回最大: 返回列表中最大的数值. temp [1,2,3,4,5,6,7,8,9]max(temp)
9本文作者 王瑞 本文链接 https://www.lyshark.com/post/5c5c4a4e.html 版权声明 本博客所有文章除特别声明外均采用 BY-NC-SA 许可协议。转载请注明出处
