python数据(6种)与结构(4种)类型

最新推荐文章于 2023-05-22 14:41:23 发布

初上花样年华

最新推荐文章于 2023-05-22 14:41:23 发布

阅读量9.9k

点赞数 14

分类专栏：基于python 3.6.0的基础知识文章标签： python数据(6种)与结构(4种)类型字符串运算符 python结构类型总结学习python结构类型目的帮助文档

本文链接：https://blog.csdn.net/qq_33897358/article/details/84901424

版权

基于python 3.6.0的基础知识专栏收录该内容

18 篇文章 2 订阅

订阅专栏

本篇是综合python数据类型+python列表(list)类型+python集合(set)类型+python字典(dict)类型+python元组（tuple）类型。进行python数据与结构相关函数进行总结。具体请看分页介绍

python的数据类型（6种）:

Number（数字）表示数据组成为数字
String（字符串）表示数据组成是字符
List（列表）:用来表示一组有序元素，后期数据可以修改
Tuple（元组）：用来表示一组有序元素，后期数据不可修改
Sets（集合）：一组数据无序不重复元素
Dictionary（字典）：用键值对的形式保存一组元素

变量赋值

X=Z=200

变量命名注意：

变量首字母必须字母或下划线“—”
注意区分大小写
不得存在python的保留字

查询保留字方法

import keyword
keyword.kwlist

保留字：‘False’,
‘None’,
‘True’,
‘and’,
‘as’,
‘assert’,
‘break’,
‘class’,
‘continue’,
‘def’,
‘del’,
‘elif’,
‘else’,
‘except’,
‘finally’,
‘for’,
‘from’,
‘global’,
‘if’,
‘import’,
‘in’,
‘is’,
‘lambda’,
‘nonlocal’,
‘not’,
‘or’,
‘pass’,
‘raise’,
‘return’,
‘try’,
‘while’,
‘with’,
‘yield’

关于数据类型number（数字）

包含：int（整型），float（浮点型），bool（布尔型），complex（复数型）

int（整型）使用方法

直接赋值
```
 num1=100
```
转换型
```
 var1='200'
 num2=int(var1)
```

float（浮点型）使用方法

直接赋值
```
 num3=15.0
```
使用float函数强置转换
```
 num4=float（15）
```

float() 函数用于将整数和字符串转换成浮点数

整型相除

  num4=15/3
  只要" / " 两边有一个数是浮点数，那么结果就是浮点数
  " // "表示整数除法

bool（布尔型）使用方法

bool（布尔型）指True（1）和False（0）

直接使用

 t=True
 f=False
 print(t,f)
 bool（布尔型）区分大小写注意

使用bool函数

F=bool（0）

bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。

bool 是 int 的子类。

表达式运算结果

print（1>2）

bool（布尔型）的运算符and（结果判定规定：只要有False 结果为False）,or(结果判定规定：只要有True 结果为True),not（原值取反）

complex（复数型）使用方法

必须满足复数组合要求
数据类型必须是浮点型
虚数必须有j或J

直接赋值
```
  coml=15.0j
  print(type(com1))
```

complex函数

  coml=15.j
  complex(1)#(1+0j)
  complex('3+5j')#(3+5j)
  complex(3,2)#(3+2j)
  complex()#0j
  complex(coml)#15j

关于数据类型String（字符串）

字符串操作连接，拆分，获取
###获取数据###
str[X]:表示截取第X个字符（从0号开始）
str[-X:Y]:表示截取倒数第X个字符（倒数从1号开始计数）
str[:X]:表示截取第X个字符（从1号开始）

    举例：
    str1="h ello"
    str2='hello'
    print("1.",str1[:3])#h e
    print("2.",str2[:3])#hel

###获取连接###
3种:+符合，join函数，格式化连接
####+符合####
举例：
str1=“h ello”
str2=‘hello’
strjoin1=str1+""+str2
print(“1.”,strjoin1)# h ellohello
缺点：效率低，不适合多字符串
####join函数####
公式：str.join(sequence)

sequence:字符串序列，str：使用字符

    sequence=('hello','a')
    str=""
    str3=str.join(sequence)
    print("1.",str3)#1. helloa

###格式化###

    str4="hello"
    str5="n"
    strjoin2='%s %s'%(str4,str5)
    print("1.",strjoin2)#1. hello n

####字符串运算符####

in-字符串包含给定字符返回True

not-字符串不包含给定字符返回True

 str5='hllo'  
 print('h'not in str5)#True

%s-格式字符串
3. \n-换行
4. \v-纵向制表符
5. \t-横向制表符
6. \r-回车
7. \f-换页
8. \b-退格
9. \nn-八进制nn代表
10. \xnn-十六进制nn代表
11. %c-格式化ASCII码
12. %s-格式化字符串
13. %d-格式化整数
14. %u-格式化无符号整型
15. %o-格式化无符号八进制
16. %x-格式化无符号十六进制
17. %X-格式化无符号十六进制
18. %f-格式化浮点小数
19. %e-格式化浮点小数
20. %E-格式化浮点小数
21. %p-格式化十六进制格式变量的地址
22. %%-字符%
23. {：.2f}-保留后2位小数（不保留符号）
24. {:+.f2}-保留后2位小数（保留符号）
25. {:.0f}-保留整数，不带小数位
26. {:0>3d}-指定长度2，不满足时左补充0
27. {:0<3d}-指定长度2，不满足时右补充0
28. abs(a) : 求取绝对值。abs(-1)
29. max(list) : 求取list最大值。max([1,2,3])
30. min(list) : 求取list最小值。min([1,2,3])
31. sum(list) : 求取list元素的和。
32. sorted(list) : 排序，返回排序后的list。
33. len(list) : list长度,len([1,2,3])
34. divmod(a,b): 获取商和余数。
35. pow(a,b) : 获取乘方数。
36. round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。
37. range(a[,b]) : 生成一个a到b的数组,左闭右开。
38. int(str) : 转换为int型。
39. float(int/str) : 将int型或字符型转换为浮点型。
40. str(int) : 转换为字符型。
41. bool(int) : 转换为布尔类型。
42. bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。
43. list(iterable) : 转换为list。
44. iter(iterable)：返回一个可迭代的对象。
45. dict(iterable) : 转换为dict。 d
46. enumerate(iterable) : 返回一个枚举对象。
47. tuple(iterable) : 转换为tuple。
48. set(iterable) : 转换为set。
49. hex(int) : 转换为16进制。hex(1024)
50. oct(int) : 转换为8进制。 oct(1024)
51. bin(int) : 转换为2进制。 bin(1024)
52. chr(int) : 转换数字为相应ASCI码字符。
53. ord(str) : 转换ASCI字符为相应的数字。
54. eval() : 执行一个表达式，或字符串作为运算。
55. exec() : 执行python语句。
56. filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。
57. map(func, *iterable) : 将func用于每个iterable对象。
58. zip(*iterable) : 将iterable分组合并。返回一个zip对象。
59. type()：返回一个对象的类型。
60. id()：返回一个对象的唯一标识值。
61. hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。
62. help()：调用系统内置的帮助系统。
63. isinstance()：判断一个对象是否为该类的一个实例。
64. issubclass()：判断一个类是否为另一个类的子类。
65. globals() : 返回当前全局变量的字典。
66. next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了 default，则当迭代器中的元素遍历后，输出default内容。
67. reversed(sequence) ：生成一个反转序列的迭代器。
68. python range() 函数可创建一个整数列表，一般用在 for 循环中。

列表数据跟维度具有密切联系。之前笔者已经涉及到相关知识点（请参考numpy库篇）

快速生成列表（list）

stu1=[0]*width
#0指元素 width-定义n组含元素的列表
#举例stu99=[0,1,2]*4
     print(stu99)
     #输出[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
stu1=['A','B','C']

访问列表

使用[start:end]

stu2=['A','B','C','D']
print('字母：',stu2[1:3])
#访问第2到4个元素之前的数据（打印第2，3位数据） 输出：B,C

涉及修改列表数据的相关函数—程序说明

stu3=['A','B','C','D']
print('字母：'，stu3)
#输出 字母：['A','B','C','D']


#利用追加.append()
stu3.append('E')
print('1.字母：'，stu3)
#输出 1.字母：['A','B','C','D'，‘E’]
#.append()指数据插入数据维度保持不变


#利用列表函数追加另一组列表.extend()
stu4=['	F','G','H','E']
stu3.extend(stu4)
print('2.字母：'，stu3)
#输出 2.字母：['A','B','C','D'，‘E’,'\tF','G','H','E']
#.extend()指数据插入数据维度发生变化


#利用列表函数计算参数出现次数.count()
print('3.'，stu3.count('E'))
#输出 3. 2


#利用列表函数获取参数在列表位置.index()
print('4.'，stu3.index('A'))
#输出 4.0


#利用列表函数在x位插入y数据.insert(x,y)
stu3.insert(0,'字母：')
print('5.',stu3)
#输出 5. ['字母：', 'A', 'B', 'C', 'D', 'E', '\tF', 'G', 'H', 'E']
stu3.insert(2,'字母：')
print('6.',stu3)
#输出 6. ['字母：', 'A', '字母：', 'B', 'C', 'D', 'E', '\tF', 'G', 'H', 'E']


#利用列表函数在x位删除指定数据.pop(x)
stu3.pop(0)
print('7.',stu3)
#输出 7. ['A', '字母：', 'B', 'C', 'D', 'E', '\tF', 'G', 'H', 'E']
stu3.pop(2)
print('8.',stu3)
#输出 8. ['A', '字母：', 'C', 'D', 'E', '\tF', 'G', 'H', 'E']
#.pop()指删除列表最后一个数据
#.pop(x)-x<0时，指列表从倒数第x个数据删除


#利用列表函数删除指定数据.remove()
stu3.remove('D')
print('9.',stu3)
#输出 9. ['A', '字母：', 'C', 'E', '\tF', 'G', 'H', 'E']


#利用列表函数清空列表数据.clear()
stu4.clear()
print('12.',stu4)
#输出 12. []


#利用列表函数清空指定列表数据.del()
del stu5[0]
del stu5[-1]
print('12.',stu5)
#输出 12. [ 'A', 'C', 'E', 'E', 'G', 'H'] 删除第0位和倒数第一位数据
#del stu[]===stu.clear() 清空列表数据


#利用列表函数反转数据.reverse()
stu3.reverse()
print('10.',stu3)
#输出 10. ['E', 'H', 'G', '\tF', 'E', 'C', '字母：', 'A']


#利用列表函数进行数据排序.sort()
stu3.sort()
stu4=stu3
stu5=stu3
print('11.',stu4)
#输出 11. ['\tF', 'A', 'C', 'E', 'E', 'G', 'H', '字母：']
#.sort()-升序
#.sort(reverse=True)-降序
#,sort(key=comp)--comp对应列表中数据类型进行比较，进行数据类型相关排序


#利用列表函数反馈列表元素个数.len()
print('12.',len(stu3))
#输出 12. 8

利用列表函数反馈列表元素中最大值.max()/最小值.min()

str199=[10,11,9]
print('19.',max(str199))
#输出max=11 min=9

列表常用运算符

+指运算符两侧的列表组合一起
*指根据右侧数字重复运算符左侧的列表
in指判定运算符左侧列表内的元素是否属于右侧列表内的元素

元组类型（tuple）与列表类型对比：

元组类型元素定义之后不可修改

快速生成元组：

 stu1=('A','B','C','1')
 print('1.',stu1)
 #输出 1. ('A', 'B', 'C', '1')
 stu2='A','B','C',1
 print('2.',stu5)
 #输出 2. ('A', 'B', 'C', 1)

stu3=()#无实意
官方帮助
```
 print(help(tuple))
 print(help(type))
```

快速访问元组

    stu3=(1,'年华','男')
    stu4=('1','年华','男')
    stu5=('01','年华','男')
    print('3.学号: %s,名字: %s'%(stu3[0],stu3[1]))
    print('4.性别',stu3[0],stu3[-1])
    print('5.性别',stu4[0],stu3[-1])
    print('6.性别',stu5[0],stu3[-1])
    #输出 3.学号: 1,名字: 年华
          4.性别 1 男
          5.性别 1 男
          6.性别 01 男

涉及修改元组数据的相关函数—程序说明

    stu6='A','99',99,'01',1,'A','1',99,35
    stu7=stu6
    del stu7
    stu8=('AA','56','72')
    print('13',type('01'))
    print('14',type(1))
    print('15',type(stu6))
    print('7.',stu6.count('A'))
    print('8.',stu6.count('99'))
    print('9.',stu6.count(99))
    print('10.',stu6.count('01'))
    print('11.',stu6.count('1'))
    print('12.',stu6.count(1))
    print('16.',stu6.index('99'))
    print('17.',stu6.index(99))
    print('18.',stu6.index(99,3,8))
    print('19.',stu7)
    print('20.',stu6+stu8)
    print('21.',stu8*2)
    print('22.','56' in stu8)
    #输出：13 <class 'str'>
    14 <class 'int'>
    15 <class 'tuple'>
    7. 2
    8. 1
    9. 2
    10. 1
    11. 1
    12. 1
    16. 1
    17. 2
    18. 7
    19. 未定义stu7，因为del
    20. ('A', '99', 99, '01', 1, 'A', '1', 99, 35, 'AA', '56', '72')
    21. ('AA', '56', '72', 'AA', '56', '72')
    22. True
    #.count查找指定元素在元组中的出现次数
    #.index查找指定元素在元组中第一次出现位置
    #.index查找指定x元素在元组中(范围:a<x<b)第一次出现位置  .index(x,a,b))
    #del清空元组的元素，反馈未定义
    #+指运算符两侧的列表组合一起
    #*指根据右侧数字重复运算符左侧的列表
    #in指判定运算符左侧列表内的元素是否属于右侧列表内的元素

元组（tuple）与列表(list)转换

列表(list)转元组（tuple）涉及tuple函数
```
 tuple=tuple(list)
```
元组（tuple）转列表(list)涉及list函数
```
 list=list(tuple)
```

字典(dict)=键(key)+值(value)

键(key)组成：数字，字符串，元组；不可修改
注意：字典定义时，出现键(key)重复情况，默认最后一次键(key)中的值(value)将覆盖之前键(key)中的值(value)。
访问值(value)的前提是对于键(key)的指定
键(key)与值(value)用冒号“：”分开

快速访问字典

    stu1={'A':7,'B':1,'C':9}
    print('1.',stu1)
    print('2.',stu1['C'])
    #输出 1. {'A': 7, 'B': 1, 'C': 9}
         2.9`

快速修改字典数据

    stu2={'A':7,'B':1,'C':9}
    stu2['B']=7
    print('3.',stu2)
    #输出 3. {'A': 7, 'B': 7, 'C': 9}

涉及修改字典数据的相关函数—程序说明

stu3={'A':7,'B':3,'C':9}
print('4.',stu3.keys())
#输出4. dict_keys(['A', 'B', 'C'])
#.keys()以列表形式返回stu中所有键(key)


print('5.',stu3.values())
#输出5. dict_values([7, 3, 9])
#.values()以列表形式返回stu中所有值（value）


print('6.',stu3.items())
#输出6. dict_items([('A', 7), ('B', 3), ('C', 9)])
#.items()以列表形式返回stu中所有键-值


stu4=stu3
stu5=stu3.copy()
print('7.',id(stu3),id(stu4),id(stu5))
print('8.',stu3.items(),stu4.items(),stu5.items())
#输出7. 2073389484216 2073389484216 2073389500816
8. dict_items([('A', 7), ('B', 3), ('C', 9)]) dict_items([('A', 7), ('B', 3), ('C', 9)]) dict_items([('A', 7), ('B', 3), ('C', 9)])
#.copy()当前stu字典(键-值)数据拷贝(浅与深的id区别)


stu6=(1,2,'A','B')
stu9=(1,2,'A,B')
stu10=dict.fromkeys(stu9)
stu7=dict.fromkeys(stu6)
stu8=dict.fromkeys(stu6,'AB')
#stu10=dict.fromkeys(seq1,'AB'，1)
#错误提示TypeError: fromkeys expected at most 2 arguments, got 3------所以stu10不合理
print('9.',stu7)
print('10.',stu8)
print('11.',stu9)
#输出9. {1: None, 2: None, 'A': None, 'B': None}
10. {1: 'AB', 2: 'AB', 'A': 'AB', 'B': 'AB'}
11. (1, 2, 'A,B')
#.fromkeys(seq[,value]) 创建一个字典，以stu中的值作当前字典的键；vale指定值作当前字典的值，当未指定时默认用None
stu3={'A':7,'B':3,'C':9}
stu6={'A':7,'B':3,'C':9}
stu7={'A':7,'B':3,'C':9}
stu9={'A':7,'B':3,'C':9}
stu11={'A':7,'B':3,'C':9}
stu13={'A':7,'B':3,'C':9}
stu14={'A':7,'B':3,'C':9}
stu16={'A':7,'B':3,'C':9}
stu18={'A':7,'B':3,'C':9}
stu19={'A':7,'B':3,'C':9}
stu20={'A':7,'B':3,'C':9}
stu21={'A':7,'B':3,'C':9}

stu4=stu3
stu4.setdefault('C',9)
stu5=stu6
stu5.setdefault('D',9)

stu10={'99'}
stu9.update(stu10)
print('17.',stu9)

stu12={'9'}
stu11.update(stu12)
print('18.',stu11)
#ValueError: dictionary update sequence element #0 has length 1; 2 is required------所以stu11不合理

stu13.clear()
print('19.',stu13)

stu15=stu14.pop('B')
print('20.',stu15)
print('21.',stu14)

stu17=stu16.popitem()
print('22.',stu17)
print('23.',stu16)

del stu18['B']
print('24.',stu18)

del stu19
print('25.',stu19)
#.del stu 情况字典的键-值，再次访问会报错

if 'A' in stu20:
 print('25.',stu20['A'])

if 'M' not in stu21:
 stu21.setdefault('M')
 print('26.',stu21)


stu8={'D':'99'}
stu7.update(stu8)
print('16.',stu7)

print('12.',stu4)
print('13.',stu3)
print('14.',id(stu3),id(stu4),id(stu5),id(stu6))
print('15.',stu5)
#输出12. {'A': 7, 'B': 3, 'C': 9}
 13. {'A': 7, 'B': 3, 'C': 9}
 14. 1668581946568 1668581946568 1668581946208 1668581946208
 15. {'A': 7, 'B': 3, 'C': 9, 'D': 9}
 16. {'A': 7, 'B': 3, 'C': 9, 'D': '99'}
 17. {'A': 7, 'B': 3, 'C': 9, '9': '9'}
 19. {}
 20. 3
 21. {'A': 7, 'C': 9}
 22. ('C', 9)
 23. {'A': 7, 'B': 3}
 24. {'A': 7, 'C': 9}
 25. 7
 26. {'A': 7, 'B': 3, 'C': 9, 'M': None}
#.setdefault(key,default=None) 创建键不住当前字典中，就添加键并将值设置default
#.update(dict2)把指定的键/值添加进原来的字典stu中
#.clear() 情况字典的键-值，再次访问不会报错，但无数据
#.pop(key) 删除指定键的值，有返回值为被删除的指定键中的值（stu15）
#.popitem() 删除当前字典最后一项键-值，有返回值为被删除的指定键和值（stu17）
#.del stu['key'] 根据指定的键(key)，删除包含指定键(key)以及相对应的值(value)
#in指运算符  判定指定键是否在当前字典中
#not in运算符与 .setdefault组合 没有相关键(key),实现自行添加（未指定对应值用None）

.setdefault与.get区别—程序说明

stu3= {'A':7,'B':3,'C':9}
stu3.get('D')
print(stu3)
#输出：{'A': 7, 'B': 3, 'C': 9}


stu4= {'A':7,'B':3,'C':9}
stu4.get('D',99)
print(stu4)
#输出：{'A': 7, 'B': 3, 'C': 9}
#.get(key,default=None) 创建键不住当前字典中，就返回默认值default


stu5= {'A':7,'B':3,'C':9}
stu5.setdefault('D',99)
print(stu5)
#输出：{'A': 7, 'B': 3, 'C': 9, 'D': 99}


stu6= {'A':7,'B':3,'C':9}
stu6.setdefault('D')
print(stu6)
#输出：{'A': 7, 'B': 3, 'C': 9, 'D': None}

字典(dict)帮助文档

print(help(dict))
Help on class dict in module builtins:
class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |  (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |  d = {}
 |  for k, v in iterable:
 |  d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |  in the keyword argument list.  For example:  dict(one=1, two=2)
 |  
 |  Methods defined here:
 |  
 |  __contains__(self, key, /)
 |  True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |  Delete self[key].
 |  
 |  __eq__(self, value, /)
 |  Return self==value.
 |  
 |  __ge__(self, value, /)
 |  Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |  Return getattr(self, name).
 |  
 |  __getitem__(...)
 |  x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |  Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |  Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |  Implement iter(self).
 |  
 |  __le__(self, value, /)
 |  Return self<=value.
 |  
 |  __len__(self, /)
 |  Return len(self).
 |  
 |  __lt__(self, value, /)
 |  Return self<value.
 |  
 |  __ne__(self, value, /)
 |  Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |  Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |  Return repr(self).
 |  
 |  __setitem__(self, key, value, /)
 |  Set self[key] to value.
 |  
 |  __sizeof__(...)
 |  D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |  D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |  D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |  Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |  D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |  D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |  D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |  D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |  If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |  D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |  2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |  D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |  D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |  If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |  If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |  In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |  D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

集合(set)

python的数据结构的另一种表现形式。
作用：自动清除集合类型中的元素重复数据(set),以及元素排序。
集合类型的元素排序是无序不重复。

快速访问集合(set)

set1=set([1,2,3,4])
set2=set(['A','B','D','C'])
set3=set(['A','C', 'B', 'D'])
set4=set(['A','B','D','C','B'])
set5=set('E')
#set6=set('E','A')
#错误提示TypeError: set expected at most 1 arguments, got 2------所以set6不合理
set7=set('hello')
set8=set(['A','B','D','C','B'])

print('1.',set1)
print('2.',set2)
print('3.',set3)
print('4.',set4)
print('5.',set5)
print('6.',set7)
print('7.',set8)

print('8.',id(set1))
print('9.',id(set2))
print('10.',id(set3))
print('11.',id(set4))
print('12.',id(set5))
print('13.',id(set7))
print('14.',id(set8))
#输出1. {1, 2, 3, 4}
2. {'A', 'C', 'B', 'D'}
3. {'A', 'C', 'B', 'D'}
4. {'A', 'C', 'B', 'D'}
5. {'E'}
6. {'h', 'e', 'l', 'o'}
7. {'A', 'C', 'B', 'D'}
8. 1462456352552
9. 1462470585032
10. 1462470585704
11. 1462456352328
12. 1462470586152
13. 1462470585928
14. 1462470585480

涉及修改集合数据的相关函数以及运算符—程序说明

set9=set([1,2,3,4,5,6,7])
set20=set([1,2,3,5,8,4,7])
set11=set9
set12=set9
#set13=set9
set14=set9
set15=set9
set16=set9
#set17=set9
set18=set9
set19=set9
#set22=set9


print('18.',set9)
print('19.',set20)
#输出 18. {1, 2, 3, 4, 5, 6, 7}
      19. {1, 2, 3, 4, 5, 7, 8}

set9.add(8)
print('1.',set9)
#输出 1. {1, 2, 3, 4, 5, 6, 7, 8}
#.add 集合类型添加元素

set21=set20.copy()
print('13.',id(set20))
print('14.',id(set21))
print('15.',set21)
print('16.',set20)
#输出 13. 1462470584360
      14. 1462472086472
      15. {1, 2, 3, 4, 5, 7, 8}
      16. {1, 2, 3, 4, 5, 7, 8}
#.copy 集合类型元素复制

set9.discard(2)
set11.discard(99)
print('3.',set9)
print('4.',set11)
#输出 3. {1, 3, 4, 5, 6, 7, 8}
      4. {1, 3, 4, 5, 6, 7, 8}
#.discard 删除集合类型中指定元素，如果指定元素不存在不会报错

set12.pop()
#set13.pop(1)
#错误提示STypeError: pop() takes no arguments (1 given)------所以set13不合理
print('5.',set12)
#print('6.',set13)
#输出 5. {3, 4, 5, 6, 7, 8}
#.pop 随机删除集合类型中元素

set14.remove(7)
set15.remove(99)
#输出 KeyError: 99(出现报错） 
print('7.',set14)
print('8.',set15)
#输出 7. {3, 4, 5, 6, 8}
#.remove 删除集合类型中指定元素，如果指定元素不存在会报错,并终止程序

set16.update([88,99])
#set17.update([88,99，77])
#错误提示SyntaxError: invalid character in identifier------所以set17不合理
set18.update([88])
print('9.',set16)
#print('10.',set17)
print('11.',set18)
#输出 9. {3, 4, 5, 6, 99, 8, 88}
     11. {3, 4, 5, 6, 99, 8, 88}
#.update 更新集合类型的元素

set19.clear()
#del set22()
#错误提示SyntaxError: can't delete function call------所以set22不合理
print('12.',set19)
#print('17.',set22)
#输出 12. set()
#.claer 清空集合类型的元素
 .del set() 清空集合

print('20.',set9.issubset(set20))
print('21.',set9<=set20)
#输出 21. False
#输出 20. False
#setA.issubset(setB) 运算符： setA<=setB 检测setA中的每一个元素是否都在setB中，子集(setB是否是setA的子集)

print('22.',set9.issuperset(set20))
#输出 22. False
#setA.issuperset(setB) 运算符： setA>=setB 检测setB中的每一个元素是否都在setA中，父集(setB是否是setA的父集)

print('23.',set9.union(set20))
#输出 23. {1, 2, 3, 4, 5, 6, 7, 8}
#setA.union(setB) 运算符： setA\setB 创造一个新的集合，元素包含setB和setA所有元素，并集(所有元素：setB+setA)

print('24.',set9.intersection(set20))
#输出 24. {1, 2, 3, 4, 5, 7}
#setA.intersection(setB) 运算符： setA&setB 检创造一个新的集合，元素包含setB和setA共同元素，交集(共同元素：setB+setA)

print('25.',set20.difference(set9))
#输出 25. {8}
#setB.difference(setA) 运算符： setB-setA 检创造一个新的集合，元素包含setB和setA集合元素中，只setB所拥有的元素，差集(差异元素：setB-setA)

print('26.',set9.symmetric_difference(set20))
#输出 26. {6, 8}
#setA.symmetric_difference(setB) 运算符： setA^setB 检创造一个新的集合，元素包含setB和setA集合元素中，不重复的元素，对称差集(差异元素：setA^setB)

集合(set)帮助文档

print(help(set))
Help on class set in module builtins:
class set(object)
 |  set() -> new empty set object
 |  set(iterable) -> new set object
 |  
 |  Build an unordered collection of unique elements.
 |  
 |  Methods defined here:
 |  
 |  __and__(self, value, /)
 |  Return self&value.
 |  
 |  __contains__(...)
 |  x.__contains__(y) <==> y in x.
 |  
 |  __eq__(self, value, /)
 |  Return self==value.
 |  
 |  __ge__(self, value, /)
 |  Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |  Return getattr(self, name).
 |  
 |  __gt__(self, value, /)
 |  Return self>value.
 |  
 |  __iand__(self, value, /)
 |  Return self&=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |  Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __ior__(self, value, /)
 |  Return self|=value.
 |  
 |  __isub__(self, value, /)
 |  Return self-=value.
 |  
 |  __iter__(self, /)
 |  Implement iter(self).
 |  
 |  __ixor__(self, value, /)
 |  Return self^=value.
 |  
 |  __le__(self, value, /)
 |  Return self<=value.
 |  
 |  __len__(self, /)
 |  Return len(self).
 |  
 |  __lt__(self, value, /)
 |  Return self<value.
 |  
 |  __ne__(self, value, /)
 |  Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |  Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |  Return self|value.
 |  
 |  __rand__(self, value, /)
 |  Return value&self.
 |  
 |  __reduce__(...)
 |  Return state information for pickling.
 |  
 |  __repr__(self, /)
 |  Return repr(self).
 |  
 |  __ror__(self, value, /)
 |  Return value|self.
 |  
 |  __rsub__(self, value, /)
 |  Return value-self.
 |  
 |  __rxor__(self, value, /)
 |  Return value^self.
 |  
 |  __sizeof__(...)
 |  S.__sizeof__() -> size of S in memory, in bytes
 |  
 |  __sub__(self, value, /)
 |  Return self-value.
 |  
 |  __xor__(self, value, /)
 |  Return self^value.
 |  
 |  add(...)
 |  Add an element to a set.
 |  
 |  This has no effect if the element is already present.
 |  
 |  clear(...)
 |  Remove all elements from this set.
 |  
 |  copy(...)
 |  Return a shallow copy of a set.
 |  
 |  difference(...)
 |  Return the difference of two or more sets as a new set.
 |  
 |  (i.e. all elements that are in this set but not the others.)
 |  
 |  difference_update(...)
 |  Remove all elements of another set from this set.
 |  
 |  discard(...)
 |  Remove an element from a set if it is a member.
 |  
 |  If the element is not a member, do nothing.
 |  
 |  intersection(...)
 |  Return the intersection of two sets as a new set.
 |  
 |  (i.e. all elements that are in both sets.)
 |  
 |  intersection_update(...)
 |  Update a set with the intersection of itself and another.
 |  
 |  isdisjoint(...)
 |  Return True if two sets have a null intersection.
 |  
 |  issubset(...)
 |  Report whether another set contains this set.
 |  
 |  issuperset(...)
 |  Report whether this set contains another set.
 |  
 |  pop(...)
 |  Remove and return an arbitrary set element.
 |  Raises KeyError if the set is empty.
 |  
 |  remove(...)
 |  Remove an element from a set; it must be a member.
 |  
 |  If the element is not a member, raise a KeyError.
 |  
 |  symmetric_difference(...)
 |  Return the symmetric difference of two sets as a new set.
 |  
 |  (i.e. all elements that are in exactly one of the sets.)
 |  
 |  symmetric_difference_update(...)
 |  Update a set with the symmetric difference of itself and another.
 |  
 |  union(...)
 |  Return the union of sets as a new set.
 |  
 |  (i.e. all elements that are in either set.)
 |  
 |  update(...)
 |  Update a set with the union of itself and others.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

python结构类型总结

列表常用list-[]
元组中元素不可更改stu-()
字典(dict)=键(key)+值(value)，键(key)不可更改dict-{}
访问python结构类型中的元素列表，元组，字典都使用[]
集合类型的元素排序是无序不重复 set-([])

学习python结构类型目的

大数据处理下，灵活应用python数据类型（6种）和python结构类型（4种），实现对样本分析
组合公式：[A for B in C if D]
A:表达式；B：自变量；C：自变量要满足表达式时，表达式结果的范围；D:自变量要满足表达式时，自变量的范围
[]：取决于表达式结果的结构类型定义
灵活应用数据与结构相关函数

未完待续(2018-12-9 1:48:44 )

初上花样年华

关注

14
点赞
踩
69

收藏

觉得还不错? 一键收藏
打赏
0
评论
python数据(6种)与结构(4种)类型

python的数据类型（6种）字符串运算符数据类型元组类型字典数据集合数据python结构类型总结学习python结构类型目的python数据(6种)与结构(4种)类型帮助文档
复制链接

扫一扫