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

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

python的数据类型(6种):

  1. Number(数字)表示数据组成为数字
  2. String(字符串)表示数据组成是字符
  3. List(列表):用来表示一组有序元素,后期数据可以修改
  4. Tuple(元组):用来表示一组有序元素,后期数据不可修改
  5. Sets(集合):一组数据无序不重复元素
  6. Dictionary(字典):用键值对的形式保存一组元素

变量赋值

X=Z=200

变量命名注意:

  1. 变量首字母必须字母或下划线“—”
  2. 注意区分大小写
  3. 不得存在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(整型)使用方法

  1. 直接赋值

     num1=100
    
  2. 转换型

     var1='200'
     num2=int(var1)
    

float(浮点型)使用方法

  1. 直接赋值

     num3=15.0
    
  2. 使用float函数强置转换

     num4=float(15)
    

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

  1. 整型相除

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

bool(布尔型)使用方法

bool(布尔型)指True(1)和False(0)

  1. 直接使用

     t=True
     f=False
     print(t,f)
     bool(布尔型)区分大小写注意
    
  2. 使用bool函数

    F=bool(0)

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

bool 是 int 的子类。

  1. 表达式运算结果

    print(1>2)

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

complex(复数型)使用方法

  1. 必须满足复数组合要求
  2. 数据类型必须是浮点型
  3. 虚数必须有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

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

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

  2. 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

列表常用运算符

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

元组类型(tuple)与列表类型对比:

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

  2. 快速生成元组:

     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)
    
  3. stu3=()#无实意

  4. 官方帮助

     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 
    14 
    15 
    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

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

  1. 列表(list)转元组(tuple)涉及tuple函数

     tuple=tuple(list)
    
  2. 元组(tuple)转列表(list)涉及list函数

     list=list(tuple)
    

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

  1. 键(key)组成:数字,字符串,元组;不可修改
  2. 注意:字典定义时,出现键(key)重复情况,默认最后一次键(key)中的值(value)将覆盖之前键(key)中的值(value)。
  3. 访问值(value)的前提是对于键(key)的指定
  4. 键(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 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)

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

快速访问集合(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 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结构类型总结

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

学习python结构类型目的

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

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

你可能感兴趣的:(python,3.6.0版本,基于python,3.6.0的基础知识)