码迷,mamicode.com
首页 > 其他好文 > 详细

基础数据类型

时间:2020-06-19 23:24:10      阅读:114      评论:0      收藏:0      [点我收藏+]

标签:··   ring   测试结果   stdin   lower   开头   super   ndt   and   

基础数据类型

出现原因

? 让机器做出一些精准的区分,数字、汉字、英文...。

类型:

  • 整数类型(int) : 1、2,3,4,5...;用来计算(+-*/...)。
  • 字符串类型(str) : 单引号/双引号引起来的数据称之为字符串。
  • 布尔值类型(bool) : 条件判断中使用:判断真假;True / False。
  • 列表类型(list) : [1,”Hello”,[1,”2”,3]] 存储大量的数据。
  • 元组类型(tuple) : (1,”Hello”,[1,”2”,3]) 存储大量的数据,里面的元素不可变。
  • 字典类型(dict) : {“name”:’张三’} 存储大量关联型数据,查询速度非常快。
  • 集合类型(set) : 交集,并集,差集。

使用type()查看数据类型。

整数型

int使用

主要用于计算(+-*/等)。
不同的进制之间的转换(十进制、二进制、八进制、十六进制)。

进制转换

  1. 进制表示

    二进制用0b加相应数字来表示,8进制用0o加相应数字来表示,16进制用0x加相应数字来表示。即:

  • 二进制 :>>> 0b10 # 代表十进制:2
  • 八进制 :>>> 0o10 # 代表十进制:8
  • 十六进制 :>>> 0x10 # 代表十进制:10
  • 十进制 :>>> 10
  1. 进制转换

其它进制转换二进制:bin()
bin(2)  #十进制转换二进制 #   ‘0b10‘
bin(0o10) #八进制转换二进制   # ‘0b1000‘
bin(0xf) #十六进制转换二进制   # ‘0b1111‘
其它进制转换为八进制:oct()
oct(0b101)   # ‘0o5‘
oct(0xf)   # ‘0o17‘
oct(0o123)   # ‘0o123‘
其它进制转换为十六进制:hex()
hex(0o10)   # ‘0x8‘
hex(3)   # ‘0x3‘
hex(0b111)   # ‘0x7‘

其它进制转换为十进制:int()

int(0o10)   # 8
int(0xf)   # 15
int(0b10)   # 2

int.bit_lenth(): 显示数字的有效二进制位数

a = 4
print(a.bit_lenth()) # 3

字符串类型

字符串或串(String)是由数字、字母、下划线组成的一串字符。一般记为 :
s="a1a2···an"(n>=0) 它是编程语言中表示文本的数据类型。

字符串操作

  • 加号(+)是字符串连接运算符(字符串拼接)。
  • 星号(*)是重复操作(乘法)。

公共方法

  • max(str):返回字符串 str 中最大的字母。
  • min(str):返回字符串 str 中最小的字母。
  • len(string):返回字符串长度。
  • count(str, beg= 0,end=len(string)):返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

切片

python的字串列表有2种取值顺序:

  • 从左到右索引默认0开始的,最大范围是字符串长度少1
  • 从右到左索引默认-1开始的,最大范围是字符串开头

下标是从 0 开始算起,可以是正数或负数

  • str [头下标:尾下标] :从字符串中截取一段子字符串,下标可以为空表示取到头或尾。
  • str[头下标:尾下标] :获取的子字符串包含头下标,但不包含尾下标的字符。比如:
s = ‘abcdef‘
s[1:5]   # ‘bcde‘
  • str[头下标:尾下标:步长] :截取可以接收第三个参数,参数作用是截取的步长,以下实例在索引 1 到索引 4 的位置,设置步长为 2(间隔一个位置)来截取字符串:
字符串内建函数

序号 方法及描述

  • upper():转换字符串中的小写字母为大写

  • isupper():如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False

  • lower():转换字符串中所有大写字符为小写.

  • islower():如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False

  • startswith(substr, beg=0,end=len(string)):检查字符串是否是以指定子字符串 substr 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。

  • endswith(suffix, beg=0, end=len(string)):检查字符串是否以 obj 结束,如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束,如果是,返回 True,否则返回 False.

  • replace(old, new [, max]):把 将字符串中的 str1 替换成 str2,如果 max 指定,则替换不超过 max 次。

  • lstrip():截掉字符串左边的空格或指定字符。

  • rstrip():删除字符串字符串末尾的空格.

  • strip([chars]):在字符串上执行 lstrip()和 rstrip()

  • split(str="", num=string.count(str)):num=string.count(str)) 以 str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num+1 个子字符串

  • splitlines([keepends]):按照行(‘\r‘, ‘\r\n‘, \n‘)分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。

  • join(seq):以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

  • capitalize():将字符串的第一个字符(如果是小写字母)转换为大

  • title():返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写istitle():如果字符串是标题化的(见 title())则返回 True,否则返回 False

  • find(str, beg=0 end=len(string)):检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1
    rfind(str, beg=0,end=len(string)):类似于 find()函数,不过是从右边开始查找.

  • index(str, beg=0, end=len(string)):跟find()方法一样,只不过如果str不在字符串中会报一个异常.
    rindex( str, beg=0, end=len(string)):类似于 index(),不过是从右边开始.

  • isalpha():如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False

  • isalnum():如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False

  • isdecimal():检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false。

  • isdigit():如果字符串只包含数字则返回 True 否则返回 False..

  • isnumeric():如果字符串中只包含数字字符,则返回 True,否则返回 False

  • isspace():如果字符串中只包含空白,则返回 True,否则返回 False.

  • encode(encoding=‘UTF-8‘,errors=‘strict‘):以 encoding 指定的编码格式编码字符串,如果出错默认报一个ValueError 的异常,除非 errors 指定的是‘ignore‘或者‘replace‘

  • bytes.decode(encoding="utf-8", errors="strict"):Python3 中没有 decode 方法,但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,这个 bytes 对象可以由 str.encode() 来编码返回。

  • center(width, fillchar):返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。

  • ljust(width[, fillchar]):返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。

  • rjust(width,[, fillchar]):返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串

  • swapcase():将字符串中大写转换为小写,小写转换为大写

  • expandtabs(tabsize=8):把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8 。

  • maketrans():创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。

  • translate(table, deletechars=""):根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

  • zfill (width):返回长度为 width 的字符串,原字符串右对齐,前面填充0

列表类型

  • List(列表):列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(即嵌套)。

  • 列表用 [ ] 标识,列表是可变容器模型,且可存储任意类型对象。

  • 列表中值的切割也可以用 [头下标:尾下标] ,就可以截取相应的列表,从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标可以为空表示取到头或尾。

列表的增删改查:

a = [‘q‘,‘w‘,‘e‘,‘r‘,‘t‘,‘y‘,‘u‘,‘i‘]         #以下每一个输出,都以此列表为准
查询
print(a[3:6]) #从左往右,取下标为3至5的内容      [‘r‘,‘t‘,‘y‘]
print(a[0:])  #从左往右,取到列表最后        [‘q‘,‘w‘,‘e‘,‘r‘,‘t‘,‘y‘,‘u‘,‘i‘]
print(a[0:-1])  #从左往右,取到列表倒数第二个   [‘q‘,‘w‘,‘e‘,‘r‘,‘t‘,‘y‘,‘u‘]
print(a[0::2])  #从左往右,跳着取,步长为2    [‘q‘, ‘e‘, ‘t‘, ‘u‘]
print(a[4::-2])   #从右往左,下标为4开始取,取到边界,步长为2    [‘t‘, ‘e‘, ‘q‘]
print(a[-2::-1]) #从右往左,倒数第二个开始,取到边界,步长为1   [‘u‘, ‘y‘, ‘t‘, ‘r‘, ‘e‘, ‘w‘, ‘q‘]
增加
  • append #默认添加到列表最后的位置
  • insert #将是数据输入到列表任意一个位置
  • extend #将列表合并到一起,一次添加多个
修改
a[2] = ‘lalala‘   #[‘q‘, ‘w‘, ‘lalala‘, ‘r‘, ‘t‘, ‘y‘, ‘u‘, ‘i‘]
a[1:2] = [‘11‘,‘12‘]   #[‘q‘, ‘11‘, ‘22‘, ‘e‘, ‘r‘, ‘t‘, ‘y‘, ‘u‘, ‘i‘
删除
  • remove 内置方法、直接删除、只能删除一个值
    a.remove(‘q‘) #[‘w‘, ‘e‘, ‘r‘, ‘t‘, ‘y‘, ‘u‘, ‘i‘]
  • pop 根据索引删除、可以提取出来被删掉的值;括号里为空,默认删除列表最后一项
    b = a.pop(1) # [‘q‘, ‘e‘, ‘r‘, ‘t‘, ‘y‘, ‘u‘, ‘i‘]
    print(b) # w
  • del 可以按照索引删除,也可以直接删除列表
    del a[0] # [‘w‘, ‘e‘, ‘r‘, ‘t‘, ‘y‘, ‘u‘, ‘i‘]
    del a # 报错 NameError: name ‘a‘ is not defined
内置函数
  • list.count(i) 统计字符i出现的次数
  • list.append() 表示向列表中添加一个元素,会添加到列表的末尾
  • list.insert() 插入,想列表的某个位置插入一个元素, 前面的元素不变,后面的元素后移
  • list.pop() 表示删除一个元素,默认删除最后一个,如果有参数,根据参数删除
  • list.remove(m) 移除列表中第一个匹配的m元素,没有会报错
  • list.clear() 清空列表中的数据, 变为空列表
  • del list[0] 删除列表
  • list.Index() 查找该值在列表中的第一次出现的位置,没找到会报错
  • list.sort()方法是将list按特定顺序重新排列,默认为由小到大,参数reverse=True可改为倒序,由大到小。 reverse方法是将list逆置。
  • list.extend() 表示向列表中添加一个列表,会将列表的数据添加在原数据的末尾
sort(list) 和sorted

用List的成员函数sort进行排序,在本地进行排序,不返回副本;用built-in函数sorted进行排序,返回副本,原始输入不变
sort(...)
L.sort(key=None, reverse=False)
sorted(...)
sorted(iterable,key=None, reverse=False)
iterable:是可迭代类型;
key:用列表元素的某个属性或函数进行作为关键字,有默认值,迭代集合中的一项;
reverse:排序规则. reverse = True 降序 或者 reverse = False 升序有默认值。
返回值:是一个经过排序的可迭代类型,与iterable一样。

元组

? 与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

tup1 = (‘Google‘, 2, 1997, 2000);
tup2 = "a", "b", "c", "d";   #  不需要括号也可以
type(tup2)  # <class ‘tuple‘>

创建空元组

tup1 = ();
元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用:

tup1 = (50)   # type(tup1)   <class ‘int‘>  # 不加逗号,类型为整型
tup1 = (50,)   # type(tup1)  <class ‘tuple‘>  # 加上逗号,类型为元组

元组与字符串类似,下标索引从0开始,可以进行截取,组合等。

访问元组(切片)

元组可以使用下标索引来访问元组中的值,如下实例:
tup1 = (‘Google‘, ‘Runoob‘, 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0]) # tup1[0]: Google
print ("tup2[1:5]: ", tup2[1:5]) # tup2[1:5]: (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例:
tup1 = (12, 34.56);
tup2 = (‘abc‘, ‘xyz‘)

tup1[0] = 100 # 修改元组元素操作是非法的。

可以将元组拼接 创建一个新的元组
tup3 = tup1 + tup2;
print(tup3) # (12, 34.56, ‘abc‘, ‘xyz‘)

删除元组

元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例:
tup = (‘Google‘, ‘Runoob‘, 1997, 2000)
del tup;
print ("删除后的元组 tup : ",tup)
以上实例元组被删除后,输出变量会有异常信息,输出如下所示:
删除后的元组 tup :
Traceback (most recent call last):
File "test.py", line 8, in
print (tup)
NameError: name ‘tup‘ is not defined

元组运算符

与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。
Python 表达式 结果 描述

  • len((1, 2, 3)) 3 计算元素个数
  • (1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
  • (‘Hi!‘,) * 4 (‘Hi!‘, ‘Hi!‘, ‘Hi!‘, ‘Hi!‘) 复制
  • 3 in (1, 2, 3) True 元素是否存在
  • for x in (1, 2, 3): print (x,) 1 2 3 迭代
元组内置函数

序号 方法 描述 实例
1 len(tuple) 计算元组元素个数。 >>> len(tuple1)
2 max(tuple) 返回元组中元素最大值。 >>> max(tuple2)
3 min(tuple) 返回元组中元素最小值。 >>> min(tuple2)
4 tuple(seq) 将列表转换为元组。 >>> tuple1=tuple(list1)

元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的地址不可变。

tup = (‘r‘, ‘u‘, ‘n‘, ‘o‘, ‘o‘, ‘b‘)
tup[0] = ‘g‘     # 不支持修改元素
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: ‘tuple‘ object does not support item assignment
id(tup)     # 查看内存地址
4440687904
tup = (1,2,3)
id(tup)
4441088800    # 内存地址不一样了

从以上实例可以看出,重新赋值的元组 tup,绑定到新的对象了,不是修改了原来的对象。

字典

  • 优点:查询速度快,数据的关联性强
  • 字典是一种可变容器模型,且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,格式如下所示:
    d = {key1 : value1, key2 : value2 }
  • 键(key)必须是唯一的,但值则不必。值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。一个简单的字典实例:
    dict = {‘Alice‘: ‘2341‘, ‘Beth‘: ‘9102‘, ‘Cecil‘: ‘3258‘}

字典的创建方式

  • 方法一 :dict1 = dict(((’k1’, ’v1’),(’k2’, ’v2’),(’k3’, ’v3’)))
  • 方法二 :dict2 = dict(k1=v1, k2=v2, k3=v3)
  • 方法三 :dict3 = {’k1’:’v1’,’k2’, ’v2’,’k3’, ’v3’}

访问字典里的值

把相应的键放入到方括号中,如下实例:

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
print ("dict[‘Name‘]: ", dict[‘Name‘]) # dict[‘Name‘]:  Runoob
print ("dict[‘Age‘]: ", dict[‘Age‘]) # dict[‘Age‘]:  7

如果用字典里没有的键访问数据,会输出错误如下:

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
print ("dict[‘Alice‘]: ", dict[‘Alice‘])
以上实例输出结果:
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("dict[‘Alice‘]: ", dict[‘Alice‘])
KeyError: ‘Alice‘

修改字典

向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对如下实例:

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
dict[‘Age‘] = 8               # 更新 Age
dict[‘School‘] = "教程"  # 添加信息
print ("dict[‘Age‘]: ", dict[‘Age‘])  # dict[‘Age‘]:  8
print ("dict[‘School‘]: ", dict[‘School‘]) # dict[‘School‘]:  教程
删除字典元素

能删单一的元素也能清空字典,清空只需一项操作。显示删除一个字典用del命令,如下实例:

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
del dict[‘Name‘] # 删除键 ‘Name‘
dict.clear()     # 清空字典
del dict         # 删除字典
print ("dict[‘Age‘]: ", dict[‘Age‘])
print ("dict[‘School‘]: ", dict[‘School‘])
但这会引发一个异常,因为用执行 del 操作后字典不再存在:
Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print ("dict[‘Age‘]: ", dict[‘Age‘])
TypeError: ‘type‘ object is not subscriptable

字典键的特性

字典值可以是任何的 python 对象,既可以是标准的对象,也可以是用户定义的,但键不行。两个重要的点需要记住:

  • 1)不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住,如下实例:
    dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Name‘: ‘小菜鸟‘}
    print ("dict[‘Name‘]: ", dict[‘Name‘]) # dict[‘Name‘]: 小菜鸟
  • 2)键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行,如下实例:
    dict = {[‘Name‘]: ‘Runoob‘, ‘Age‘: 7}
    print ("dict[‘Name‘]: ", dict[‘Name‘])
    以上实例输出结果:
    Traceback (most recent call last):
    File "test.py", line 3, in
    dict = {[‘Name‘]: ‘Runoob‘, ‘Age‘: 7}
    TypeError: unhashable type: ‘list‘

字典内置函数&方法

Python字典包含了以下内置函数:
序号 函数及描述 实例

  • 1 len(dict) 计算字典元素个数,即键的总数。 >>> len(dict)
  • 2 str(dict) 输出字典,以可打印的字符串表示。 >>> str(dict)
  • 3 type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型。 >>>type(dict)

字典内置方法:

  • dict.keys() :keys将字典中的键以列表形式返回。
  • dict.values() :values以列表的形式返回字典中的值。
  • dict.items() :将所有的字典项以列表方式返回,列表中项来自(键,值)。
  • dict.get() :get函数可以访问字典中不存在的键,当该键不存在是返回None
  • dict.pop() :删除字典中对应的键
  • dict.setdefault() :类似于get方法,获取与给定键相关联的值,也可以在字典中不包含给定键的情况下设定相应的键值
  • dict.clear() :清除字典中的所有项
  • dict.update() :用一个字典更新另外一个字典(有则覆盖,无则添加)
  • dict.copy() :返回一个具有相同键值的新字典
  • dict.popitem() :移出字典中的项
  • dict.fromkeys() :使用给定的键建立新的字典,键默认对应的值为None

集合

  • 集合(set)是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

  • 创建格式:
    parame = {value01,value02,...}
    或者
    set(value)

  • 用途:
    去重
    关系测试:交集、并集、差集.....

集合的数学运算

a = set(‘abracadabra‘)
b = set(‘alacazam‘)
a     # {‘a‘, ‘r‘, ‘b‘, ‘c‘, ‘d‘}
a - b : 差集 相当于a.difference(b)  # 集合a中包含而集合b中不包含的元素
{‘r‘, ‘d‘, ‘b‘}
a | b : 并集  相当于a.intersection(b)  # 集合a或b中包含的所有元素
{‘a‘, ‘c‘, ‘r‘, ‘d‘, ‘b‘, ‘m‘, ‘z‘, ‘l‘}
a & b : 交集 相当于a.union(b)  # 集合a和b中都包含了的元素
{‘a‘, ‘c‘}
a ^ b      相当于a.symmetric_difference(b)  # 不同时包含于a和b的元素
{‘r‘, ‘d‘, ‘b‘, ‘m‘, ‘z‘, ‘l‘}
集合推导式(Set comprehension):
a = {x for x in ‘abracadabra‘ if x not in ‘abc‘}
print(a)  # {‘r‘, ‘d‘}

集合的基本操作

1、添加元素
  • s.add(x),将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
print(thisset)  # {‘Taobao‘, ‘Facebook‘, ‘Google‘, ‘Runoob‘}
  • s.update(x)也可以添加元素.且参数可以是列表,元组,字典等,x 可以有多个.用逗号分开。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.update({1,3})
print(thisset) # {1, 3, ‘Google‘, ‘Taobao‘, ‘Runoob‘}

thisset.update([1,4],[5,6])  
print(thisset) # {1, 3, 4, 5, 6, ‘Google‘, ‘Taobao‘, ‘Runoob‘}
2、移除元素
  • s.remove( x ),将元素x从集合s中移除,如果元素不存在,则会发生错误。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.remove("Taobao")
print(thisset) # {‘Google‘, ‘Runoob‘}

thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: ‘Facebook‘
s.discard( x )也是移除集合中的元素,且如果元素不存在,不会发生错误.
thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Facebook")  # 不存在不会发生错误
print(thisset) # {‘Taobao‘, ‘Google‘, ‘Runoob‘}
  • s.pop() : 可以设置随机删除集合中的一个元素,语法格式如下:

    thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
    x = thisset.pop()
    print(x)  #  Runoob
    

    多次执行测试结果都不一样。set 集合的 pop 方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除。

3、计算集合元素个数
  • len(s),计算集合 s 元素个数。
thisset = set(("Google", "Runoob", "Taobao"))
len(thisset) # 3
4、清空集合
  • s.clear(),清空集合 s。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.clear()
print(thisset) # set()
5、判断元素是否在集合中存在
  • x in s,判断元素x是否在集合s中,存在返回True,不存在返回 False。
thisset = set(("Google", "Runoob", "Taobao"))
"Runoob" in thisset    # True
"Facebook" in thisset    # False

集合内置方法完整列表

方法 描述

  • add() 为集合添加元素
  • clear() 移除集合中的所有元素
  • copy() 拷贝一个集合
  • difference() 返回多个集合的差集
  • difference_update() 移除集合中的元素,该元素在指定的集合也存在。
  • discard() 删除集合中指定的元素
  • intersection() 返回集合的交集
  • intersection_update() 返回集合的交集。
  • pop() 随机移除元素
  • remove() 移除指定元素
  • symmetric_difference() 返回两个集合中不重复的元素集合。
  • symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。
  • union() 返回两个集合的并集
  • update() 给集合添加元素
  • isdisjoint() 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。
  • issubset() 判断指定集合是否为该方法参数集合的子集。
  • issuperset() 判断该方法的参数集合是否为指定集合的子集

8、数据类型转换

数据类型的转换,将数据类型作为函数名即可。以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。
函数 描述

  • int(x [,base]) 将x转换为一个整数
  • long(x [,base] ) 将x转换为一个长整数
  • float(x) 将x转换到一个浮点数
  • complex(real [,imag]) 创建一个复数
  • repr(x) 将对象 x 转换为表达式(带引号的)字符串(原形毕露)
  • tuple(s) 将序列 s 转换为一个元组
  • list(s) 将序列 s 转换为一个列表
  • set(s) 转换为可变集合
  • dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
  • frozenset(s) 转换为不可变集合
  • chr(x) 将一个整数转换为一个字符
  • unichr(x) 将一个整数转换为Unicode字符
  • ord(x) 将一个字符转换为它的整数值

补充

  • ’’,0,(),{},[],set(),None 转换成布尔值时都为False

基础数据类型

标签:··   ring   测试结果   stdin   lower   开头   super   ndt   and   

原文地址:https://www.cnblogs.com/q121211z/p/13166653.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!