数据类型是编程语言中的一个重要概念，它定义了数据的类型和提供了特定的操作和方法。在 python 中，数据类型的作用是将不同类型的数据进行分类和定义，例如数字、字符串、列表、元组、集合、字典等。这些数据类型不仅定义了数据的类型，还为数据提供了一些特定的操作和方法，例如字符串支持连接和分割，列表支持排序和添加元素，字典支持查找和更新等。因此，选择合适的数据类型是 python 编程的重要组成部分。
算数运算符在编程语言中是一种非常重要的工具，它用于执行数学运算。在 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,os
>>>
>>> numberA = 10
>>> numberB = 20
>>> numberC = 10
>>>
>>> numberA + numberB
30
>>> numberA != numberB
True
>>> numberA += 10
位运算符号: 在程序中，位运算就是直接对整数在内存中的二进制位进行操作。
>>> a=60 # 60 = 0011 1100
>>> b=13 # 13 = 0000 1101
>>>
>>> c= a & b # 12 = 0000 1100
>>> print("a与b: ",c)
a与b: 12
>>>
>>> c= a | b # 61 = 0011 1101
>>> print("a或b: ",c)
a或b: 61
>>>
>>> c=a^b # 49 = 0011 0001
>>> print("a异或b:",c)
a异或b: 49
>>>
>>> c=a << 2 # 240 = 1111 0000
>>> print("a左移2",c)
a左移2 240
其他运算符: 其他运算符包括常用的,逻辑运算,成员运算,身份运算等.
>>> num1 = 10
>>> num2 = 20
>>> num3 = 0
>>> list = [10,20,30,40,50]
>>>
>>> num1 and num3
0
>>> num1 in list # 判断num1是否在list里面
True
>>> num1 not in list
False
>>>
>>> num1 is num3 # 判断两个标识符是不是引用自一个对象
True
>>> num1 is num2
False
>>> num1 is not num2
True
整数转其他数值: 使用转换命令将一个整数转换为其他任意数值.
>>> number = 100
>>>
>>> float(number)
100.0
>>> complex(number)
(100+0j)
>>> str(number)
'100'
>>> chr(number)
'd'
>>> ord(chr(number))
100
实现数值之间进制转换: 使用转换命令实现进制转换,bin二进制,oct八进制,hex十六进制,format也支持转换输出.
>>> import math
>>>
>>> number = 1024
>>> bin(number)
'0b10000000000'
>>> oct(number)
'0o2000'
>>> hex(number)
'0x400'
>>>
>>> format(number,"b")
'10000000000'
>>> format(number,"x")
'400'
>>>
>>> int("-4d2",16)
-1234
实现浮点数/负数之间运算: 复数的函数操作正弦、余弦和平方根，可以使用cmath模块
>>> import cmath,math
>>> numberA = complex(2,4)
>>> numberB = 3-5j
>>> numberA,numberB # 复数相加
((2+4j), (3-5j))
>>>
>>> numberA.real # 取实属部分
2.0
>>> numberA.imag # 取虚数部分
4.0
>>> math.ceil(3.14) # 四舍五入
4
>>> round(3.14) # 四舍五入
3
>>> cmath.sin(numberA)
(24.83130584894638-11.356612711218174j)
>>> cmath.cos(numberA)
(-11.36423470640106-24.814651485634187j)
>>> cmath.exp(numberA)
(-4.829809383269385-5.5920560936409816j)
数值格式化输出: 针对数值做格式化,并对齐进行输出显示.
>>> number = 1234.56789
>>>
>>> format(number,"0.2f")
'1234.57' # 格式化时精确2位小数
>>>
>>> "value = > {:>20.3f}".format(number) # 输出右侧对齐
'value = > 1234.568'
>>> "value = > {:<20.3f}".format(number) # 输出左侧对齐
'value = > 1234.568 '
>>> "value = > {:^20.3f}".format(number) # 输出居中对齐
'value = > 1234.568 '
数值类型格式化输出: 实例化数字类型,或将其他类型转换为数字类型,或各种进制转换为十进制.
>>> temp = int(21) # 实例化数字类型
>>> print(type(temp),temp) # 打印类型,和参数值
<class 'int'> 21
>>> print(int("110101",base=2)) # 将二进制转为十进制
53
>>> print(int("156",base=8)) # 将八进制转为十进制
110
>>> print(int("1A2C31",base=16)) # 将十六进制转为十进制
1715249
字符串是字符的集合，是一种常见的数据类型。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()函数,将一个指定字符串首字母变成大写.
>>> str="hello lyshark"
>>>
>>> str.capitalize()
'Hello lyshark'
全部首字母大写: 使用title()函数,将字符串中的每一个单词的首字母大写.
>>> str="hello lyshark"
>>>
>>> str.title()
'Hello Lyshark'
查找字符串位置: 使用index()查找字符串所在位置(不能存在则报错),使用find()查找字符串位置(不存在返回-1).
>>> str = "hello lyshark"
>>>
>>> str.index("hello")
0
>>> str.index("lyshark")
6
>>> str.find("hello")
0
统计字符串出现次数: 使用count()函数,统计指定字符串的出现次数.
>>> str="hello lyshark"
>>>
>>> str.count("h")
2
>>> str.count("l")
3
>>> str.count("hello")
1
>>> str.count("mk")
0
字符串文本对齐: 字符串对齐函数实现对字符串的对齐与填充,字符串方法包括ljust()、rjust()和center()
>>> str = "hello lyshark"
>>>
>>> str.ljust(30)
'hello lyshark '
>>> str.rjust(30)
' hello lyshark'
>>>
>>> str.center(30)
' hello lyshark '
>>>
>>> str.center(50,"-")
'------------------hello lyshark-------------------'
字符串连接: 使用join()函数,将序列中以指定的字符连接生成一个新字符串
>>> str="-"
>>> seq=("hello","lyshark","welcome")
>>>
>>> print(str.join(seq))
hello-lyshark-welcome
>>>
>>> list =['1','2','3','4','5']
>>> print(''.join(list))
12345
>>>
>>> 'kill %s' % ' '.join(['1024','2234'])
'kill 1024 2234'
切割字符串: 使用split()函数,指定分割一个字符串,并保存成列表.
>>> str="hello-lyshark-welcome"
>>>
>>> str.split("-")
['hello', 'lyshark', 'welcome']
去除字符串两边空格: 使用strip()函数去除两边的空格,而lstrip/rstrip则是分别去掉两边空格.
>>> str=" hello lyshark "
>>>
>>> str.strip() # 去掉两边空格
'hello lyshark'
>>> str.rstrip() # 去掉右边空格
' hello lyshark'
>>>
>>> str.lstrip()
'hello lyshark '
去除字符串中注释行: 将一个文件中的以警号开头的行注释掉.
>>> import os
>>>
>>> with 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 = " <br>hello lyshark</br> !"
>>>
>>> re.sub('[<br> | </br> | ]',"",string)
'hellolyshak!'
判断是否为大写: 使用isupper()函数,判断指定字符串是否为大写.
>>> str="LYSHARK"
>>> str1="lyshark"
>>>
>>> str.isupper()
True
>>> str1.isupper()
False
实现字符串拆分: 通过split拆分分解元素,将一个字符串拆解成多个部分.
>>> string = "python"
>>> # 拆分上面的字符串,忽略某个值使用下划线代替
>>> x,_,_,y,_,_ = string
>>> x
'p'
>>>
>>> passwd = 'root:x:0:0:root:/root:/bin/bash'
>>> username,*_,homedir,sh = passwd.split(":")
>>> username
'root'
查找开头结尾: 使用startswith函数,找出指定字母开头的字符元素,endswith找出字母结尾的元素.
>>> from fnmatch import fnmatch,fnmatchcase
>>> url = "https://www.baidu.com"
>>>
>>> url.endswith(".com")
True
>>> url.startswith("http://")
False
>>> url.startswith("https://") and url.endswith(".com")
True
>>> fnmatch(url,"*.com")
True
>>> filename = ["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结尾的文件
True
>>> names = ['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']
列表（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]="mkdirs"
>>> list
['mkdirs', 'python', 'ruby', 'ruby', 'lyshark']
>>>
>>> list[3]="pip"
>>> list
['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() #删除列表的最后一个元素
'lyshark'
>>> list.pop()
'pip'
>>> list
['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")
2
>>> list.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")
2
>>> list.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替换成空,不包括3
>>> print(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 random
>>> from random import randrange
>>>
>>> list = ["admin","python","ruby","1","3","6","9"]
>>>
>>> random.choice(list)
'python'
>>> random.choice(list)
'9'
>>>
>>> random_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 compress
>>>
>>> mylist = [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 item>0 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 Counter
>>>
>>> data = [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 deque
>>>
>>> queue = deque(maxlen=4) # 定义最大可存储4个元素
>>> queue.append(1)
>>> queue.append(2)
>>> queue.append(3)
>>> queue.append(4)
>>> queue
deque([1, 2, 3, 4], maxlen=4)
>>> queue.append(5)
>>> queue # 超出部分会被从左侧排除出去
deque([2, 3, 4, 5], maxlen=4)
>>>
>>> queue.appendleft(6) # 从左边加入数据到队列,超出部分从右侧排除
>>> queue
deque([6, 2, 3, 4], maxlen=4)
>>> queue.pop() # 从末尾取出一个数据
4
>>> queue.popleft() # 从左侧取出一个数据
6
列表中取出最大/最小值: 在heapq模块中有两个函数nlargest()从最大的值开始取,nsmallest()从最小的值开始取.
>>> import heapq
>>>
>>> data = [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 sh
>>> from itertools import zip_longest
>>>
>>> for 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]
字典（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的value |
| dict.has_key(key) | 判断字典是否有这个key（python3中已废除，使用in） |
| dict.keys() | 返回所有的key为一个列表 |
| dict.values() | 返回所有的value为一个列表 |
| dict.items() | 将字典的键值拆成元组，全部元组组成一个列表 |
| dict.pop(key) | 弹出某个key-value |
| dict.popitem() | 随机弹出key-value |
| dict.clear() | 清除字典中所有元素 |
| dict.copy() | 字典复制，d2=d1.copy()是浅复制，深复制需要copy模块 |
| dict.fromkeys(s) | 生成一个新字典 |
| dict.update(key) | 将一个字典合并到当前字典中 |
| dict.iteritems() | 生成key-value迭代器，可以用next()取下个key-value |
| dict.iterkeys() | 生成key迭代器 |
| dict.itervalues() | 生成values迭代器 |
增加字典: 在info字典的基础上,增加一个字段info["stu4"] = "root".
>>> info
{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}
>>> info["stu4"] = "root"
>>>
>>> info
{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}
修改字典: 在info字典的基础上,修改将stu1:administrator修改为stu1:centos.
>>> info
{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}
>>>
>>> info["stu1"] = "centos"
>>> info
{'stu1': 'centos', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}
删除字典: 在info字典的基础上,删除几个字典,以下提供多种删除方法.
>>> info
{'stu1': 'centos', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}
>>>
>>> info.pop("stu1") #通过pop函数删除
'centos'
>>> info
{'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 #标准的查询方式
True
>>>
>>> info.get("stu1") #使用get函数查询
'administrator'
>>>
>>> info["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']
'lyshark'
>>>
>>> len(info)
3
>>>
>>> dict = {"姓名":"administrator","得分":[98,99,87]}
>>>
>>> dict["姓名"]
'administrator'
>>> dict["得分"]
[98, 99, 87]
>>> dict["得分"][2:]
[87]
字典嵌套: 字典内部可继续存放列表或新的字典,遍历时只需要逐级输出即可.
>>> info = {'name': 'lyshark', 'gender': 'male', 'age': 22, 'company': ['oldboy', 'beijing', 50]}
>>>
>>> info["name"]
'lyshark'
>>> info["company"][1]
'beijing'
>>>
>>> info = {'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) # 一般用法
'001'
>>> list(Dict.keys())[list(Dict.values()).index("001")] # 单值返回
'admin'
>>>
>>> def 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 copy
>>> n1 = {"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"))
guest
>>> print(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 OrderedDict
>>>
>>> dict = OrderedDict()
>>>
>>> dict["one"] = 1
>>> dict["two"] = 2
>>> dict["three"] = 3
>>>
>>> for 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 itemgetter
>>> data = [
... {'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,key=itemgetter("uid")) # 以UID字段作为排序条件,从小到大的排列
>>> sorted(data,key=itemgetter("uid"),reverse=True) # 以UID字段作为排序条件,从大到小的排列
>>> sorted(data,key=itemgetter("uid","fname")) # 通过多个公共键排序
>>> max(data,key=itemgetter("uid")) # 找出UID字段最大的一条字典
高级字典取出最大/最小值: 在heapq模块中有两个函数nlargest()从最大的值开始取,nsmallest()从最小的值开始取.
>>> import heapq
>>>
>>> data = [
... {'name':'dhcp','port':67},
... {'name':'mysql','port':3306},
... {'name':'memcached','port':11211},
... {'name':'nginx','port':80},
... {'name':'ssh','port':22}]
>>>
>>> heapq.nlargest(2,data,key=lambda x:x["port"]) # 取出port字段最大的两个字典
[{'name': 'memcached', 'port': 11211}, {'name': 'mysql', 'port': 3306}]
>>>
>>> heapq.nsmallest(3,data,key=lambda x:x["port"]) # 取出port字段最小的三个字典
[{'name': 'ssh', 'port': 22}, {'name': 'dhcp', 'port': 67}, {'name': 'nginx', 'port': 80}]
高级字典记录的分组: itertools模块中的函数groupby()可以通过扫描序列,并将相同元素进行分组排序.
>>> from operator import itemgetter
>>> from itertools import groupby
>>>
>>> rows = [
... { "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(key=itemgetter("date")) # 通过date字段对字典进行排序
>>> for date,items in groupby(rows,key=itemgetter("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 defaultdict
>>> rows_data = defaultdict(type(list))
>>> for row in rows:
... rows_data[row["date"]].append(row)
>>> print(rows_data)
元组是一种不可变的有序数据结构，由多个元素组成，每个元素可以是不同的数据类型，包括数字、字符串、元组等。元组的创建很简单，只需要使用小括号将元素括起来，并使用逗号隔开即可。元组一旦创建后，不能对其中的元素进行修改，所以也被称为只读列表。元组通常用于存储一些固定不变的数据，如一行记录或一组配置参数等。元组可以作为函数的参数和返回值，也可以与列表等数据类型进行相互转换。与列表不同，元组中的元素是不可变的，这使得元组在某些场景下比列表更加安全和高效。
| 函数名 | 描述 |
|---|---|
| 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","d"
>>>
>>> tup1
('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:] google
>>> print("tup1[1:2]",tup1[1:2])
tup1[1:2] ('baidu',)
连接元组: 元组中的元素值是不允许修改的,但我们可以对元组进行连接组合.
>>> tup1 = (1,2,3,4)
>>> tup2 = ("abc","xyz")
>>>
>>> tup3 = tup1+tup2
>>> print(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出现次数
1
>>> tuple.index("lyshark") #统计lyshark索引位置
1
元素修改: 在没有嵌套的情况,元组是不可变对象,但是元组内的列表是可变的.
>>> tup=("lyshark",[1,2,3,4,5])
>>> tup
('lyshark', [1, 2, 3, 4, 5])
>>>
>>> tup[1].pop()
5
>>> tup
('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 namedtuple
>>>
>>> tup = namedtuple("tup1",["x","y","z"])
>>> obj = tup(1,2,3)
>>>
>>> obj.x
1
>>> obj.y
2
任意长度对象分解元素: 从某个可迭代对象中分解出N个元素,可以使用python的*表达式.
>>> grades = (68,98,85,78,84,79,88)
>>> first,*middle,last = grades
>>> sum(middle) / len(middle)
84.8
>>>
>>> records = [
... ('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 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的交集,并将结果放入set |
| set.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的对称差集,并将结果放入set |
| set.isdisjoint(t) | 如果set和t没有相同项,则返回True |
| set.issubset(t) | 如果s是t的一个子集,则返回True |
| set.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")
>>>
>>> C<A #C是A的子集
True
>>> C.issubset(A) #C是A的子集
True
>>> C<B #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'}
序列类型是指由索引为非负整数的有序对象集合组成的数据类型，包括字符串、列表和元组。其中字符串是由字符组成的不可变序列，列表和元组都是由任意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，则返回 True |
any(s) |
如果 s 中的任意项为 True，则返回 True |
len(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)
True
>>> all(temp1)
False
any判断: 如果temp中的任意项为True,则返回True.
>>> temp = [1,1,1,1,1,1]
>>> temp1 = [1,1,1,1,0,1]
>>>
>>> any(temp)
True
>>> any(temp1)
True
len计算元素个数: 计算列表或字典等相关的元素个数.
>>> temp = [1,1,1,1,1,1]
>>> len(temp)
6
min返回最小: 返回列表中最小的数值.
>>> temp = [1,2,3,4,5,6,7,8,9]
>>>
>>> min(temp)
1
max返回最大: 返回列表中最大的数值.
>>> temp = [1,2,3,4,5,6,7,8,9]
>>>
>>> max(temp)
9
本文作者： 王瑞
本文链接： https://www.lyshark.com/post/5c5c4a4e.html
版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
本文主要介绍了在使用Python面向对象编程时，如何实现组合关系，同时对比了组合关系和继承关系的优缺点，并讲解了如何通过csv模块来保存Python接收/生成的数据。