精华内容
下载资源
问答
  • 二进制数据是0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”。当前的计算机系统使用的基本上是二进制系统,数据在计算机中主要是以补码的形式存储的。计算机中的二进制则...

    一、字符编码

    二进制定义

    二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”。当前的计算机系统使用的基本上是二进制系统,数据在计算机中主要是以补码的形式存储的。计算机中的二进制则是一个非常微小的开关,用“开”来表示1,“关”来表示0。

    1、ASCII码

    ASCII(American Standard Code for Information Interchange,美国信息交换标准代码)是基于拉丁字母的一套电脑编码系统,主要用于显示现代英语和其他西欧语言。它是现今最通用的单字节编码系统,并等同于国际标准ISO/IEC 646。

    由于这些字符串长的长,短的短,写在一起让我们难以分清每一个字符的起止位置,所以聪明的人类就想出了一个解决办法,既然一共就这255个字符,那最长的也不过是11111111八位,不如我们就把所有的二进制都转换成8位的,不足的用0来替换。

    在这里,每一位0或者1所占的空间单位为bit(比特),这是计算机中最小的表示单位

    每8个bit组成一个字节,这是计算机中最小的存储单位(毕竟你是没有办法存储半个字符

    2、GBK和GB2312

    GB2312是中国国家标准简体中文字符集,由中国国家标准总局发布,1981 年 5 月 1 日实施。GB 2312 编码通行于中国大陆;新加坡等地也采用此编码。中国大陆几乎所有的中文系统和国际化的软件都支持 GB 2312。

    GB 2312 标准共收录 6763 个汉字,其中一级汉字 3755 个,二级汉字 3008 个;同时收录了包括拉丁字母、希腊字母、日文平假名及片假名字母、俄语西里尔字母在内的 682 个字符。

    GB 2312 的出现,基本满足了汉字的计算机处理需要,它所收录的汉字已经覆盖中国大陆99.75% 的使用频率。

    对于人名、古汉语等方面出现的罕用字,GB 2312 不能处理,这导致了后来 GBK 及 GB 18030 汉字字符集的出现。

    2 GBK

    GBK即汉字内码扩展规范,英文全称 Chinese Internal Code Specification。

    GBK 共收入 21886 个汉字和图形符号,包括:

    GB 2312 中的全部汉字、非汉字符号。

    BIG5 中的全部汉字。

    与 ISO 10646 相应的国家标准 GB 13000 中的其它 CJK 汉字,以上合计 20902 个汉字。

    其它汉字、部首、符号,共计 984 个。

    GBK 向下与 GB 2312 完全兼容,向上支持 ISO 10646 国际标准,在前者向后者过渡过程中起到的承上启下的作用。

    GBK 采用双字节表示,总体编码范围为 8140-FEFE 之间,首字节在 81-FE 之间,尾字节在 40-FE 之间,剔除 XX7F 一条线。GBK 编码区分三部分:

    汉字区 包括

    GBK/2:OXBOA1-F7FE, 收录 GB 2312 汉字 6763 个,按原序排列;

    GBK/3:OX8140-AOFE,收录 CJK 汉字 6080 个;

    GBK/4:OXAA40-FEAO,收录 CJK 汉字和增补的汉字 8160 个。

    图形符号区 包括

    GBK/1:OXA1A1-A9FE,除 GB 2312 的符号外,还增补了其它符号

    GBK/5:OXA840-A9AO,扩除非汉字区。

    用户自定义区

    GBK 区域中的空白区,用户可以自己定义字符。

    3 GB18030

    GB 18030,全称:国家标准 GB 18030-2005《信息技术中文编码字符集》,是中华人民共和国现时最新的内码字集,是 GB 18030-2000《信息技术信息交换用汉字编码字符集基本集的扩充》的修订版。

    GB 18030与 GB 2312-1980 和 GBK 兼容,共收录汉字70244个。

    与 UTF-8 相同,采用多字节编码,每个字可以由 1 个、2 个或 4 个字节组成。

    编码空间庞大,最多可定义 161 万个字符。

    支持中国国内少数民族的文字,不需要动用造字区。

    汉字收录范围包含繁体汉字以及日韩汉字

    GB 18030 编码是一二四字节变长编码。

    单字节,其值从 0 到 0x7F,与 ASCII 编码兼容。

    双字节,第一个字节的值从 0x81 到 0xFE,第二个字节的值从 0x40 到 0xFE(不包括0x7F),与 GBK 标准兼容。

    四字节,第一个字节的值从 0x81 到 0xFE,第二个字节的值从 0x30 到 0x39,第三个字节从0x81 到 0xFE,第四个字节从 0x30 到 0x3

    3、

    Unicode

    Unicode把所有语言都统一到一套编码里,这样就不会再有乱码问题了。

    Unicode标准也在不断发展,但最常用的是用两个字节表示一个字符(如果要用到非常偏僻的字符,就需要4个字节)。现代操作系统和大多数编程语言都直接支持Unicode。

    ---新的问题又出现了:如果统一成Unicode编码,乱码问题从此消失了。但是,如果你写的文本基本上全部是英文的话,用Unicode编码比ASCII编码需要多一倍的存储空间,在存储和传输上就十分不划算。

    4、

    UTF-8

    出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符,用UTF-8编码就能节省空间:

    5、总结一下现在计算机系统通用的字符编码工作方式:

    在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。

    用记事本编辑的时候,从文件读取的UTF-8字符被转换为Unicode字符到内存里,编辑完成后,保存的时候再把Unicode转换为UTF-8保存到文件。

    文件存取编码转换图

    常用编码介绍一览表

    编码制定时间作用所占字节数

    ASCII

    1967年

    表示英语及西欧语言

    8bit/1bytes

    GB2312

    1980年

    国家简体中文字符集,兼容ASCII

    2bytes

    Unicode

    1991年

    国际标准组织统一标准字符集

    2bytes

    GBK

    1995年

    GB2312的扩展字符集,支持繁体字,兼容GB2312

    2bytes

    UTF-8

    1992年

    不定长编码

    1-3bytes

    6、

    python2中默认是ASCII,python3中为utf-8

    二、数据类型

    1、python3保留int,没有long, 布尔类型是True 和False

    2、进制转换

    bin():十进制转换为二进制使用bin方法

    oct():十进制转换为八进制

    hex():十进制转换为十六进制

    3、算术运算(+ - * / // divmod **)

    >>> 2+3

    5

    >>> 2-3

    -1

    >>> 2*3

    6

    >>> 3/2

    1.5

    >>> 3//2

    1

    >>> divmod(16,3)

    (5, 1)

    >>> 2**3

    8

    python divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。

    4、float  浮点型

    float是有限小数或无限循环小数

    展开全文
  • 一 数据类型 1、什么是数据?... 数据是用来表示状态的,不同的状态就应该不同的类型的数据去表示 3、数据类型 数字 (整形、长整形、浮点型、复数) 字符串 字节串 列表 元祖 字典...

    一 数据类型

    1、什么是数据?

          x=1u,1u 是我们要存储的数据

    2、为什么数据要分不同的类型

         数据是用来表示状态的,不同的状态就应该用不同的类型的数据去表示

    3、数据类型

           数字        (整形、长整形、浮点型、复数)

          字符串

          字节串      

          列表

          元祖

          字典

          集合

    二  数字类型

    1、整形 int

    用途:表示年龄,等级,qq号等

    定义方式:

    age=18     # age=int(18)

    整形总结

    只能存一个值,属于不可变类型,可hash

    2、浮点型 float

    用途:身高,体重,体质参数等

    定义方式

    salary=3.1    # salary=float(3.1)

    浮点型总结:

    只能存一个值,属于不可变类型,可hash

    3、复数(了解) complex

    定义方式

    x=1+2j

    1代表实数        查看方法:  print(x.real)

    2代表虚数        查看方法:   print(x.imag)

    三  字符串类型

    用途: 姓名,性别。。。。

    定义方式

    ‘’,“”,‘’‘ ’‘’内定义的一串字符

    msg=‘hello  world’

    1、按照索引取值(正向取+反向取):只能取

    2、切片

    3、长度

    4、成员运算

    5、移除空白 strip

    6、 切分split

    7、 循环

    8、字符串总结

    只能存一个值,有序(能按照索引取值的),不可变类型,可hash

    注:以上讲解是必须要掌握的,以下是需要掌握和了解的

    9、strip   lstrip    rstrip

    10、字符串大小写  lower upper

    11、判断以什么开头和结尾 startswith,   endswith

    12、format的三种用法

     13、 split 和join的用法演示

    join 列表中的数据全是字符串,才能用join拼接

    14、 replace  替换

    15、 判断字符串是否是纯数字   isdigit

    注: 以下为了解的内容

    16、查找索引位置    find 和 index 

    17、 统计 count  

    18、样式  center  ljust  rjust  zfile

    19、 capitalize    title   swapcase

    20、is 判断数字系列

    21  is 其他

    四  列表类型

    作用:存放多个装备,多个爱好等

    定义:[ ]内可以有多个任意类型的值,逗号分隔

    小技巧:(能用for循环遍历的都能用这种方法)

    1、 安索引取值(正向和方向) # 和字符串一样

    2、 切片(顾头不顾尾,步长) # 和字符串一样

    3、 长度                                    #和字符串一样

    4、成员运算 in 和not in             # 和字符串一样

    5、追加 和 删除

    6 循环

    for + break or continue

    for  + else

    若程序没有被break打断,则执行else, 若被break 打断,贼忽略else

    注: 以上为必会部分,以下为掌握部分

    7、insert  安索引位插入值

    8、clear  清空列表中的所有内容

    9、copy

    10、count

    11、 extend 插入多个值

    12、index

    13、reverse 反转列表

    14 、 sort

    纯字符串也是能比较大小的(具体怎么比较是看字母表,比价字符串的首字母,以此比较)

    15、列表类型总结:

    可以存多个值,值可以是任何类型,有序,可变,不可hash

    16 、列表的小练习

    1)用列表模拟队列  (先进先出)

    2)用列表模拟堆栈(先进的后出,后进的先出)

     

    转载于:https://www.cnblogs.com/yuguangwei/p/8021851.html

    展开全文
  • 需要将一系列值组合成数据结构并通过编号来访问各个值时,列表很有用。本章介绍一种可通过名称来访问其各个值的数据结构。这种数据结构称为映射(mapping)。字典是Python中唯一的内置映射类型,其中的值不按顺序排列...

    需要将一系列值组合成数据结构并通过编号来访问各个值时,列表很有用。本章介绍一种可通过名称来访问其各个值的数据结构。这种数据结构称为映射(mapping)。字典是Python中唯一的内置映射类型,其中的值不按顺序排列,而是存储在键下。键可能是数、字符串或元组。

    字典的用途(推荐学习:Python视频教程)

    字典的名称指出了这种数据结构的用途。普通图书适合按从头到尾的顺序阅读,如果你愿意,可快速翻到任何一页,这有点像Python中的列表。字典(日常生活中的字典和Python字典)旨在让你能够轻松地找到特定的单词(键),以获悉其定义(值)。

    在很多情况下,使用字典都比使用列表更合适。下面是Python字典的一些用途:

    表示棋盘的状态,其中每个键都是由坐标组成的元组;

    存储文件修改时间,其中的键为文件名;

    数字电话/地址簿。

    假设有如下名单:>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']

    如果要创建一个小型数据库,在其中存储这些人的电话号码,该如何办呢?一种办法是再创建一个列表。假设只存储四位的分机号,这个列表将类似于:>>> numbers = ['2341', '9102', '3158', '0142', '5551']

    创建这些列表后,就可像下面这样查找Cecil的电话号码:>>> numbers[names.index('Cecil')]

    '3158'

    这可行,但不太实用。实际上,你希望能够像下面这样做:>>> phonebook['Cecil']

    '3158'

    如何达成这个目标呢?只要phonebook是个字典就行了。

    更多Python相关技术文章,请访问Python教程栏目进行学习!

    展开全文
  • 序言:集合中各元素间是无序的,相同元素在集合中唯一存在。...集合的类型:可变集合 —— set不可变集合 ——frozenset注:本文重点讨论的是可变集合set————————————————python中可变集合set和...

    序言:

    集合中各元素间是无序的,相同元素在集合中唯一存在。即 集合是无序组合,它没有索引和位置的概念,但可变集合中的元素是可以动态增加或删除的。

    集合应用场景:

    去重:如列表  去重。

    关系测试:判断数据是否存在 交集,并集,差集  等关系。

    集合的类型:

    可变集合 —— set

    不可变集合 —— frozenset

    注:本文重点讨论的是可变集合set

    ————————————————

    python中可变集合set和不可变集合frozenset的区别链接

    1.0 set()函数

    描述:可以将其它的组合数据类型转化为可变集合类型(或将不可变的集合类型frozenset转变为可变的集合类型set),返回一个无重复元素且排序任意的可变集合。

    语法: set() -> new empty set object  返回一个空集合(该集合可变)

    set(iterable) -> new set object  返回一个新集合(该集合可变)

    iterable —— 要转换的组合数据类型。

    注:s = {} 生成的是字典类型,而不是集合类型。

    程序示例①:

    s1 = set() #创建一个空集合。

    l = [1.23,"a"] #列表类型

    d = {1:"a",2:"b"} #字典类型

    a = (1,2,"b") #元组类型

    s = "厉害了,我的国" #字符串

    #将列表,字典,元组,字符串转化为集合

    s2 =set(s)

    s3=set(l)

    s4=set(d)

    s5=set(a)print(s1)print(s2)print(s3)print(s4)print(s5)

    程序运行结果:

    set()

    {'了', '的', '厉', '害', '国', ',', '我'}

    {'a', 1.23}

    {1, 2}

    {1, 2, 'b'}

    程序示例②:

    d = {} #创建的是字典类型,空字典

    s = set() #创建可变空集合

    a = {1,2,3,"a"} #默认为可变集合

    b = set("1,2,3") #与a语句等效

    c1 = frozenset() #创建空的不可变集合,该集合不能添加任何元素。

    c2 = frozenset("1,2,3") #不可变集合,集合中元素不能增加或删除。

    print(type(d),type(s),type(a),type(b),type(c1),type(c2))

    f= frozenset(a) #将可变集合a转换为不可变集合f

    print(f,type(f))

    s1= set(c2) #将不可变集合c2转换为可变集合s1

    print(s1,type(s1))

    程序运行结果:

    frozenset({'a', 1, 2, 3}) {'2', '3', ',', '1'}

    2.0 add()函数

    描述:如果集合s中不存在元素x,则将元素x添加到集合s中。

    语法:s.add(x)

    x —— 要添加的元素。集合s已经存在元素x,也不会报错。

    程序示例:

    s = {1,2,"a"}

    s.add("ab") #将字符串"ab"添加到集合s中

    s.add(1) #集合s已存在元素 1 ,但不会报错

    s.add("z") #将单字符"z"添加到集合s中

    print(s)

    程序运行结果:

    {'a', 1, 2, 'z', 'ab'}

    3.0 clear()函数

    描述:删除集合s中的所有元素。

    语法:s.clear()

    程序示例:

    s = {1,2,3,"a","bn"}

    s.clear() #删除集合s所有元素

    print(s)

    程序运行结果:

    set()

    4.0 copy()函数

    描述:复制生成一个新的集合。

    语法 s.copy()

    程序示例:

    s = {1,2,3,"a","bc"}

    s1 = s.copy() #复制集合s

    s.add(789) #向原集合添加元素 789

    s1.add("opq") #向复制集合s1添加元素 “opq”

    #结果都互不干扰

    print(s)

    print(s1)

    程序运行结果:

    {1, 2, 3, 'a', 789, 'bc'}

    {1, 2, 3, 'a', 'opq', 'bc'}

    5.0 discard()函数

    描述:移除集合s中的value元素。若value元素存在,则移除,不存在也不报错。

    语法:s.discard(value)

    value —— 要删除的元素

    程序示例:

    s = {1,2,3,4,5,"a","ab","h"}

    s.discard(1) #移除元素 1

    s.discard("ab") #移除元素 "ab"

    s.discard("hj") #移除元素 "hj",但集合s中不存在元素"hj"

    print(s)

    程序运行结果:

    {2, 3, 4, 5, 'a', 'h'}

    6.0 remove()函数

    描述:移除集合s中的value元素。若value元素存在,则移除,不存在则报错(产生KeyError异常)。

    语法:s.remove(value)

    value —— 要删除的元素

    程序示例:

    s = {1,2,3,4,5,"a","ab","h"}

    s.remove(1) #移除元素 1

    s.remove("ab") #移除元素 "ab"

    print(s)

    s.remove("hj") #移除元素 "hj",但集合s中不存在元素"hj" 程序会报错

    print(s)

    程序运行结果:

    {2, 3, 4, 5, 'a', 'h'}

    ---------------------------------------------------------------------------

    KeyError Traceback (most recent call last)

    in ()

    3 s.remove("ab") #移除元素 "ab"

    4 print(s)

    ----> 5 s.remove("hj") #移除元素 "hj",但集合s中不存在元素"hj"

    6 print(s)

    KeyError: 'hj'

    7.0 pop()函数

    描述:随机移除集合s中的一个元素并返回该元素。若集合为空则报错(产生KeyError异常)

    语法:s.pop()

    程序示例:

    s1 = {1,2,3,4,5,"a","b"}

    print(s1.pop()) # 随机删除一个元素并返回

    print(s1)

    s2 = set() #创建一个空集合

    print(s2.pop()) #s2为空集合,程序会报错。

    程序运行结果:

    1

    {2, 3, 4, 5, 'b', 'a'}

    ---------------------------------------------------------------------------

    KeyError Traceback (most recent call last)

    in ()

    4

    5 s2 = set() #创建一个空集合

    ----> 6 print(s2.pop()) #s2为空集合,程序会报错。

    KeyError: 'pop from an empty set'

    8.0 difference()函数

    描述:生成集合的差集。

    差集概念:一般地,记A,B是两个集合,则所有属于A且不属于B的元素构成的集合,叫做集合A减集合B(或集合A与集合B之差),类似地,对于集合A、B,我们把集合 x|x∈A,且x∉B 叫做A与B的差集

    差集

    语法:a.difference(b,c,d...)  返回一个差集  等效于 a - b - d -...

    a —— 集合a

    b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

    程序示例①:

    a = {1,2,3,"a","b","c"}

    b = {1,2,"a","h","78","b"}

    x1 = a.difference(b) #集合a 减 集合b

    x2 = b.difference(a) #集合b 减 集合a

    print(x1)

    print(x2)

    print(a,b) #集合a和集合b的元素不改变。

    程序运行结果:

    {3, 'c'}

    {'78', 'h'}

    {1, 2, 3, 'b', 'a', 'c'} {1, 2, 'b', 'a', 'h', '78'}

    程序示例②:

    a = {1,2,3,"a","b","c","k"}

    b = {1,2,"a","h","78","b"}

    c = {1,2,0,"c","l"}

    x = a.difference(b,c)

    print(x)

    程序运行结果:

    {3, 'k'}

    9.0 difference_update()函数

    描述:把集合a更新为集合a与集合b的差集。集合a元素被更新改变,但集合b元素不改变。

    或 从集合s中删除同时也在x中出现的所有元素。x可以是 集合,列表,元组,字典等或者支持迭代的所有对象。

    语法:a.difference_update(b,c,d...)  无返回值

    s.difference_update(x) 无返回值

    a —— 集合a

    b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

    x—— 可以是 集合,序列或可以迭代的对象(括号中可以有多个对象)。

    程序示例①:

    a = {1,2,3,"a","b","c"}

    b = {1,2,"a","h","78","b"}

    a.difference_update(b) #把集合a 更新 为集合a与集合b的差集

    print(a.difference_update(b)) #返回值为空。

    print(a) #集合a元素被更新改变。

    print(b) #集合b元素不改变

    程序运行结果:

    None

    {3, 'c'}

    {1, 2, 'b', 'a', 'h', '78'}

    程序示例②:

    a = {1,2,3,4,5,6,7,8,9,"a","b"}

    b = {1,2,3,"a","k"}

    c = {7,8,"h","o"}

    a.difference_update(b,c)

    print(a) #集合a元素被更新为 集合a与集合b,集合c 的差集。

    print(b,c) #集合b,c元素不改变

    程序运行结果:

    {4, 5, 6, 9, 'b'}

    {'a', 1, 2, 3, 'k'} {8, 'o', 'h', 7}

    程序示例③:

    a = {1,2,3,4,5,6,"a","b","c"}

    b = {1,2,"h"} #集合

    l = [4,"a"] #列表

    t = ("c","88") #元组

    d = {"k":11,5:"666"} #字典

    #从集合a中删除在 集合b 列表l 元组t 字典d 中出现过的元素。

    a.difference_update(b,l,t,d)

    print(a)

    程序运行结果:

    {'b', 3, 6}

    注意difference()函数和difference_update()函数的区别:

    difference()函数不改变集合的元素。

    difference_update()函数改变集合a元素。

    10.0 union()函数

    描述:生成集合的并集。即将集合a和集合b取并集,并将并集作为一个新的集合返回, 但是不改变原集合a和集合b

    并集的概念:给定两个集合A,B,把他们所有的元素合并在一起组成的集合,叫做集合A与集合B的并集,记作A∪B,读作A并B。

    语法:a.union(b,c,d...)  等效于 a | b | c | d...

    a —— 集合a

    b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

    程序示例:

    a = {1,2,"a","b"}

    c = {3,5,"a"}

    d = {"b",7,8,9}

    print(a.union(c,d)) #返回集合a,集合b,集合c 的并集

    print(a.union(c)) #返回集合a,集合c的并集

    程序运行结果:

    {1, 2, 'b', 3, 5, 7, 8, 'a', 9}

    {1, 2, 'b', 3, 5, 'a'}

    11.0 update()函数

    描述:将集合a和集合b取并集,并将结果保存在集合a中(即更新集合a),集合b不改变,但是没有返回值。

    或  将x中的所有项添加到集合a中。x可以是 集合,列表,元组,字典等或者支持迭代的所有对象。

    语法:a.update(b,c,d...)  返回值为空

    a.update(x)  返回值为空

    a —— 集合a

    b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

    x—— 可以是 集合,序列或可以迭代的对象(括号中可以有多个对象)。

    注:集合中union()函数和update()函数都是将多个可迭代的集合 合并,但是返回的结果和对原集合的影响却不一样

    程序示例①:

    a = {1,2,3,"a","b"}

    b = {7,2,9,"j"}

    a.update(b)

    print(a.update(b)) #返回值为空

    print(a) #集合a被更新。

    print(b) #集合b不改变。

    程序运行结果:

    None

    {1, 2, 3, 7, 'b', 9, 'a', 'j'}

    {9, 2, 'j', 7}

    程序示例②:

    a = {1,2,3,"a","b"}

    b = {7,2,9,"j"}

    c = {5,6,"o"}

    a.update(b,c)

    print(a) #集合a被更新。

    print(b,c) #集合b,集合c 不改变。

    程序运行结果:

    {1, 2, 3, 5, 6, 7, 'o', 'b', 9, 'a', 'j'}

    {9, 2, 'j', 7} {5, 6, 'o'}

    程序示例③:

    a = {1,2,3}

    b = {7,8,9}

    l = ["a","b",55] #列表

    t = ("c","88") #元组

    d = {"k":11,"l":"666"} #字典

    #分别将 集合b 列表l 元组t 字典d 添加到集合a中

    a.update(b,l,t,d)

    print(a)

    注:字典类型作用的是key值

    程序运行结果:

    {1, 2, 3, 'a', 7, 8, 9, 'k', 'l', '88', 'c', 55, 'b'}

    12.0 symmetric_difference()函数

    描述:返回对称差集(反向交集),即返回两个集合中不重复的元素集合,即移除两个集合中都存在的元素。

    对称差集的概念:集合A与集合B中所有不属于A∩B的元素的集合,记为A△B,也就是A△B=(A/B)∪(B/A).

    ​​​​​对称差集

    语法:a.symmetric_difference(b)  等效于 a ^ b

    a —— 集合a

    b —— 集合b

    程序示例:

    a = {1,2,3,"a","b"}

    b = {5,6,1,"b","c"}

    x1 = a.symmetric_difference(b)

    print(x1)

    print(a,b)

    程序运行结果:

    {2, 3, 5, 6, 'c', 'a'}

    {1, 2, 3, 'b', 'a'} {'c', 1, 'b', 5, 6}

    13.0  symmetric_difference_update()函数

    函数:把集合a更新为:集合a与集合b的对称差集。集合a元素被更新改变,但集合b元素不改变。

    或 计算集合s与x的对称差集,并将结果保存在集合s中。x可以是 集合,列表,元组,字典等或者支持迭代的所有对象。

    对称差集的概念:集合A与集合B中所有不属于A∩B的元素的集合,记为A△B,也就是A△B=(A/B)∪(B/A).

    ​​​​​对称差集

    语法:a.symmetric_difference_update(b)   返回值为空

    s.symmetric_difference_update(x)    返回值为空

    a —— 集合a

    b —— 集合b

    x—— 可以是 集合,序列或可以迭代的对象(括号中只有一个对象)。

    程序示例①:

    a = {1,2,3,"a","b"}

    b = {1,5,6,"a",}

    a.symmetric_difference_update(b) #取集合a和集合b的对称差集,更新集合a并保存在集合a中

    print(a.symmetric_difference_update(b)) #返回值为空

    print(a) #集合a被更新.

    print(b) #集合b元素不变。

    程序运行结果:

    None

    {1, 2, 3, 'b', 'a'}

    {1, 'a', 5, 6}

    程序示例②:

    a1 = {1,2,3,4,5,6,"a","b","c"}

    a2 = {1,2,3,4,5,6,"a","b","c"}

    a3 = {1,2,3,4,5,6,"a","b","c"}

    l = [1,2,"a"] #列表

    t = (3,5,"b") #元组

    d = {"a":11,5:"666"} #字典

    a1.symmetric_difference_update(l) #计算集合a1与 列表l 的对称差集,并将结果保存在集合a1中

    a2.symmetric_difference_update(t) #计算集合a2与 元组t 的对称差集,并将结果保存在集合a1中

    a3.symmetric_difference_update(d) #计算集合a3与 字典d 的对称差集,并将结果保存在集合a1中

    print(a1)

    print(a2)

    print(a3)

    注:字典类型作用的是key值

    程序运行结果:

    {'b', 3, 4, 5, 6, 'c'}

    {1, 2, 4, 6, 'a', 'c'}

    {'b', 1, 2, 3, 4, 6, 'c'}

    14.0 intersection()函数

    描述:生成集合的交集。

    交集的概念:设A,B是两个集合,由所有属于集合A且属于集合B的元素所组成的集合,叫做集合A与集合B的交集(intersection),记作A∩B。

    交集

    语法:a.intersection(b,c,d...)  等效于 a & b & c & d...

    a —— 集合a

    b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

    程序示例:

    a = {1,2,3,"a","b"}

    c = {2,8,"b","a","c"}

    b = {1,2,5,8,"a","k"}

    x1 = a.intersection(b) #返回集合a 和集合b 的交集

    x2 = a.intersection(b,c) #返回集合a,集合b,集合c的交集

    print(x1)

    print(x2)

    print(a,b,c) #集合a,集合b,集合c 元素不改变

    程序运行结果:

    {1, 2, 'a'}

    {2, 'a'}

    {1, 2, 3, 'b', 'a'} {1, 2, 'k', 5, 8, 'a'} {8, 'b', 2, 'a', 'c'}

    15.0 intersection_update()函数

    描述:把集合a更新为:集合a与集合b(或多个集合)的交集。集合a元素被更新,但集合b(其它集合)的元素不改变。

    或 计算集合s与x的交集,并将结果保存在集合s中。x可以是 集合,列表,元组,字典等或者支持迭代的所有对象。

    交集的概念:设A,B是两个集合,由所有属于集合A且属于集合B的元素所组成的集合,叫做集合A与集合B的交集(intersection),记作A∩B。

    交集

    语法:a.intersection_update(b,c,d...) 返回值为空

    s.intersection_update(x)  返回值为空

    a —— 集合a

    b,c,d... —— 括号中可以有多个集合(但至少要有一个)。

    x—— 可以是 集合,序列或可以迭代的对象(括号中可以有多个对象)。

    程序示例①:

    a = {1,2,3,"a","b"}

    c = {2,8,"b","a","c"}

    a.intersection_update(b) #取集合a和集合b的交集,更新集合a并把结果保存在集合a中

    print(a.intersection_update(b)) #返回值为空

    print(a) #集合a中的元素被更新

    print(b) #集合b中的元素不改变

    程序运行结果:

    None

    {1, 2, 'a'}

    {1, 2, 'k', 5, 8, 'a'}

    程序示例②:

    a = {1,2,3,"a","b"}

    c = {2,8,"b","a","c"}

    b = {1,2,5,8,"a","k"}

    a.intersection_update(b,c) #去集合a,集合b,集合c的交集,更新集合a并把结果保存在集合a中

    print(a)

    print(b,c)

    程序运行结果:

    {2, 'a'}

    {1, 2, 'k', 5, 8, 'a'} {8, 'b', 2, 'a', 'c'}

    程序示例③:

    s = {1,2,3,5,"a","b"}

    l = [1,2,"a"] #列表

    t = (1,2,3,8,"a","b") #元组

    d = {1:2,2:6,"a":5,"k":11,5:"666"} #字典

    s.intersection_update(l,t,d) #计算集合s与 列表l 元组t 字典d 的交集,并将结果保存在集合s中。

    print(s)

    注:字典类型作用的是key值

    程序运行结果:

    {1, 2, 'a'}

    16.0 isdisjoint()函数

    描述:判断两个集合是否包含相同的元素,若没有相同元素则返回 True,否则返回 False。

    语法:s.isdisjoint(b)   返回bool类型(True False)

    a —— 集合a

    b —— 集合b

    程序示例:

    a = {1,2,3,"a"}

    b = {"b","c","55","66"}

    c = {1,2,5,"a"}

    print(a.isdisjoint(b)) #集合a与集合b无相同的元素 返回True

    print(a.isdisjoint(c)) #集合a与集合c有相同的元素,返回False

    程序运行结果:

    True

    False

    17.0 issubset()函数

    描述:判断两个集合是否是子集关系(A⊆B)。即判断集合a中的所有元素是否都包含在集合b中,若都包含在集合b中则返回True,否则返回False

    子集

    语法:a.issubset(b) 返回bool类型(True False)

    a —— 集合a

    b —— 集合b

    程序示例:

    a = {1,2,3,"a"}

    b = {1,2,3,"a","b","c"}

    c = {1,2,3,"b","h"}

    print(a.issubset(b)) #集合a是集合b的子集

    print(a.issubset(c)) #集合a不是集合b的子集

    程序运行结果:

    True

    False

    18.0 issuperset()函数

    描述:判断两个集合是否是超集(父集)。即判断集合b中的所有元素是否都包含在集合a中,若都包含在集合a中则返回True,否则返回False

    超集概念:如果一个集合S2中的每一个元素都在集合S1中,且集合S1中可能包含S2中没有的元素,则集合S1就是S2的一个超集,反过来,S2是S1的子集。 S1是S2的超集,若S1中一定有S2中没有的元素,则S1是S2的真超集,反过来S2是S1的真子集。

    超集

    语法:a.issuperset(b)  返回bool类型(True False)

    a —— 集合a

    b —— 集合b

    程序示例:

    a = {1,2,3,"a","b","c"}

    b = {1,3,"a"}

    c = {1,2,3,"b","h"}

    print(a.issuperset(b)) #集合a是集合b的超集.

    print(a.issuperset(c)) #集合a不是集合b的超集。

    程序运行结果:

    True

    False

    注:issubset()函数和issuperset()函数的用法相似,注意两者区别。

    展开全文
  • Python有五个标准的数据类型:Numbers(数字)String(字符串)List(列表)Tuple(元组)Dictionary(字典)其中属于集合类型的数据类型列表、元组及字典。0x00. 数字(Numbers)数字数据类型用于存储数值。他们...
  • 因为数据是用来表示状态的,不同的状态就要不同类型的数据去表示。3:Python中常见的数据类型有哪些?数字、字符串、列表、元组、字典、集合、字节串4:如何开展数据类型的学习?基本使用(用途;定义方式;常用...
  • 列表是python的基本数据类型之一,[]来表示,可以存放各种数据类型(什么都能装,能装对象的对象)列表相比于字符串,不仅可以存放不同类型的数据,而且可以存放大量的数据.2.列表的索引和切片(列表和字符串一样,也拥有...
  • 因为数据是用来表示状态的,不同的状态就要不同类型的数据去表示。 3:Python中常见的数据类型有哪些? 数字、字符串、列表、元组、字典、集合、字节串 4:如何开展数据类型的学习? 基本使用(用途;定义方式...
  • 基本数据类型列表

    2019-04-18 18:19:00
    但是,现在我想表示全班同学的名字,应该用什么呢? 用我们现在学习的知识能解决问题么? 也许有的同学说,可以使用一个长字符串,把所有同学的名字都写进去,可是问题来了。 比如当某一个同学学的太差被学校开除...
  • 因为数据是用来表示状态的,不同的状态就要不同类型的数据去表示。3:Python中常见的数据类型有哪些?数字、字符串、列表、元组、字典、集合、字节串4:如何开展数据类型的学习?基本使用(用途;定义方式;常用...
  • 列表是python的基本数据类型之一,[]来表示,可以存放各种数据类型(什么都能装,能装对象的对象) 列表相比于字符串,不仅可以存放不同类型的数据,而且可以存放大量的数据. 2.列表的索引和切片(列表和字符串一样,也...
  • 文章来源:可乐的数据分析之路作者:虾壳可乐Code写在...列表(list),是方括号[]括起来的一种数据结构,元素和元素之间逗号分隔,列表中的元素是可以进行增删查改等一系列操作的,列表通常这样表示列表名 =...
  • 列表是由一系列元素按照一定顺序排列组成,[ ]来表示逗号来分隔其中的元素。举个栗子:cars = ["bmw", "ford", "benz]列表数据结构的应用场景用来存储多个同一类型的事物,方便进行统一操作和管理访问列表列表...
  • 列表由 [ ] 来表示,每一项元素逗号隔开,列表中可以放入任何基本数据类型 二、列表索引和切片 列表的索引和切片与字符串相似,并且切片之后是列表 [start : end : step ] 三、列表的增删改查 1、增加 ...
  • 一、列表(list1 = [1,2,3,"蓝色海洋",“abcd”])1)列表的定义:列表使用[]来表示列表中的元素可以是任意数据类型列表中的元素使用逗号隔开2)列表的基本操作:a.下标取值,例如:print(list1[1])b.切片:切出来...
  • 列表是Python中的基本数据类型之一[]来表示,每一项元素由逗号隔开,列表什么都能装,(能装对象的对象)  2.可以用来存放大量数据  3.是一个可以改变的数据类型 二、列表的索引与切片  1.列表和字符串一样也有...
  • 方括号[]来表示列表,并用逗号来分隔其中的元素。可通过从0开始的索引来访问列表元素,-1代码最后一个元素,-2代表倒数第二个元素>>> ls=[1,0.4,"ab",[2,23]] >>&...
  • 比如我计算今天一天的开销花了多少钱我可以用数字来表示,如果是整形用 int ,如果是小数用 float ,如果你想记录某件东西花了多少钱,应该使用 str 字符串型,如果你想记录表示所有开销的物品名称,你应该用什么表示呢...
  • 除了列表中括号表示而元组是小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列的数据,事实真是如此吗?a = [1, 3, 5, 7, 'a']b = (1, 3, 5, 7, 'b')# 现在改变b中的值b[2] = 4TypeError...
  • 1、 列表什么 列表由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9或字母与数字...在Python中,方括号([])来表示列表,并用逗号来分隔其中的元素。 2、创建列表 创...
  • 为何数据要分不同的类型数据是用来表示状态的,不同的状态就应该不同的类型的数据去表示3.数据类型数字字符串列表元组字典集合二. 基础数据类型2.1 数字 (int)数字主要是用于计算的,使用方法并不是很多,就...
  • 除了列表中括号表示而元组是小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列的数据,事实真是如此吗? a = [1, 3, 5, 7, 'a'] b = (1, 3, 5, 7, 'b') # 现在...
  • 2.3数字 减加乘除,**表示乘方, 数字转字符串的方式 str() ...什么列表列表由特定顺序的元素组成,[]括起来,中间可以放任何元素。 cars=['audi','bmw','toyota'] 3.1.1访问列表。 print(...
  • 列表什么 列表由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9 或所有家庭成员...在Python中,方括号([ ])来表示列表,并用都好来分隔期中的元素。下面是一个简单的列表示例,这...
  • 1.概述列表是python的基本数据类型之一,是一个可变的数据类型[]方括号表示,每一项元素使用逗号隔开,可以装大量的数据#先来看看list列表的源码写了什么,方法:按ctrl+鼠标左键点listclass list(object):""...
  • 1,数据类型 ... 变量值是用来保存现实世界中的状态的,那么针对不同的状态就应该不同类型的数据去表示 1.3如何,即数据类型的分类? 整形int类型, 作用:表示人的年龄,各种号码,等级 ...
  • 在Python中,[]来表示列表,并用逗号来分隔其中的元素。我们可以创建包含字母,数字或者任何东西的列表。其中列表中的元素之间可以没有任何的关系。由于列表通常包含多个元素,再给创建的列表命名时,一般使用复数...
  • 在Python语言中,列表用 方括号 [ ] 来表示,并用逗号来分隔其中的元素。 示例: fruits = ['banana', 'apple', 'cherry', 'pear', 'fig'] print(fruits) 示例输出: ['banana', 'apple', 'cherry', 'pear',
  • 要编程完成某个任务,最基本的就是要知道如何利用编程语言...数据类型Python中的数据类型包容:数值型:包括整数(int),浮点数(float),布尔型(真或假,True, False表示),复数(complex).字符串(str):一段文字,...
  • 列表

    2020-12-05 16:50:56
    列表是由一组任意类型的值组合而成的序列,组成列表的值称为元素,每个元素之间逗号隔开,具体示例如下: 在这里插入图片描述 上述示例中,创建了4个列表,其中list4中嵌套一个列表,正是由于列表中元素可以是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 748
精华内容 299
关键字:

列表类型用什么表示