【半月社 1 】Python的六个内置标准数据类型
Python3 内置了共六个标准数据类型，分别为Numbers，String，List，Tuple，Dict，Set用以存储不同类型的数据
对于Python3来说，创建变量不需要类型声明，变量在初次赋值后才会基于赋值的数据类型被创建，
解释器会分配指定内存，并决定什么数据可以被存储在内存中
变量赋值
在Python3中，使用等号 “=”来给变量赋值，左边为变量名，右边为储存在变量中的值，变量的命名规则基本与C中是一致的。
下面是Python3中的部分变量赋值的示例，与C中不同，变量赋值不需要先声明类型，但是每个变量在使用前都必须赋值。
#!/usr/bin/env python
# coding: utf-8
# 第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释
# 第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "Hao" # 字符串
print(counter) # 100
print(miles) # 1000.0
print(name) # Hao
# Python 也允许你同时为多个变量赋值
a = b = c = 10
a, b, c = 0, 2.5, "Hao"在Python中，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：
a = 123 # a是整数
print(a)
a = 'ABC' # a变为字符串
print(a)
这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型
如果赋值的时候类型不匹配，就会报错。例如Java、C/C++。
当我们写 a = 'ABC' 时，Python解释器干了两件事情：
-
在内存中创建了一个
'ABC'的字符串； -
在内存中创建了一个名为
a的变量，并把它指向'ABC'。
也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据。
a = 'ABC'
b = a
a = 'XYZ'
print(b)
可变和不可变类型
初学python的时候，一定要记住“一切皆为对象，一切皆为对象的引用”这句话
什么是可变类型和不可变类型？
存储空间保存的数据不允许被修改，这种数据就是不可变类型
Numbers，String，Tuple，不可变集合（可通过frozenset产生）
存储空间保存的数据允许被修改，这种数据就是可变类型
List，Dict，Set
基于内存地址来讲：
当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，就称不可变数据类型。
当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，就称可变数据类型。
（1）不可变数据类型分析
>>> x = 1
>>> id(x)
31106520
>>> y = 1
>>> id(y)
31106520
>>> x = 2
>>> id(x)
31106508
>>> y = 2
>>> id(y)
31106508
>>> z = y
>>> id(z)
31106508
>>> x += 2
>>> id(x)
31106484 
从上面的过程可以看出，不可变数据类型在内存中不管有多少个引用，相同的对象只占用了一块内存，
但是当需要对改变变量引用的对象的值时，由于是不可变的数据类型，所以必须创建新的对象，
这样就会使得一次次的改变创建了一个个新的对象，不再使用的内存会被垃圾回收器回收。
（2）可变数据类型分析
>>> a = [1, 2, 3]
>>> id(a)
41568816
>>> a = [1, 2, 3]
>>> id(a)
41575088
>>> b = a
>>> id(b)
41575088
>>> a.append(4)
>>> id(a)
41575088
>>> a += [2]
>>> id(a)
41575088
>>> a
[1, 2, 3, 4, 2]
Numbers 数字数据类型（不可变类型）
数字数据类型用于存储数值，Python3中支持三种不同的数字类型
· int（有符号整型）
· float（浮点型）
· complex（复数）
1）int 整数类型
Python中的整数类型与数学中的整数概念一致
可正可负，可任意大小（只是理论上的无限，实际上机器内存有限，不可能无限大）
Dec1 = 10 # 十进制正整数
Dec2 = -785 # 十进制负整数
Binay1 = 0b101 # 二进制正整数 大小写b都可
Binay2 = -0B0100 # 二进制负整数
Oct1 = 0o145 # 八进制正整数 大小写o都可
Oct2 = -0O334 # 八进制负整数
Hex1 = 0x8b # 十六进制正整数 大小写x都可
Hex2 = -0Xaaa # 十六进制负整数布尔型
布尔型其实是整型的一种，一个布尔值只有True、False两种值，要么是True，要么是False
在Python中，可以直接用True、False表示布尔值（请注意大小写）
# 布尔值
print(True)
print(False)
print(True and True)
print((5 > 31) or (0 > 22))
print(not a < b)2）float 浮点数类型
Python中的浮点数也与数学中一致，指带有小数点及小数的数字。浮
点数的取值范围从数量级上讲约是-10^308~10^308，精度数量级约是10^-16，即两个小数间的差值最小是10^-16数量级
samp1 = 1.230
samp2 = -10.2553
samp3 = 1.23e9
samp4 = 6.244e-4
samp5 = 70.2E+12需要注意的是，浮点数有一个特性：浮点数见运算会存在不确定尾数，具体的例子如下
print(0.1+0.2)
print(0.1+0.3)
# 以下是输出
0.30000000000000004
0.4
这个不确定尾数并不止Python中存在，许多编程语言中都存在，它涉及到了计算机对数字运算的内部实现原理
首先，我们需要了解以下浮点数表示法：
即用一个有效数字。一个基数（Base）、一个指数（Exponent）以及一个表示正负的符号来表达实数
比如：666.66 可以表达为 0.66666×103、6.6666×102 或者 66.666×101 三种方式，
因为这种表达的多样性，因此有必要对其加以规范化以达到统一表达的目标。规范的浮点数表达方式具有如下形式：
其中，d.dd…d 为有效数字，β 为基数，e 为指数。有效数字中数字的个数称为精度，我们可以用 p 来表示，
即可称为 p 位有效数字精度。每个数字 d 介于 0 和基数 β 之间，包括 0。更精确地说，±d0.d1d2…dp-1×βe 表示以下数：
其中，对十进制的浮点数，即基数 β 等于 10 的浮点数而言，上面的表达式非常容易理解。
如 12.34，我们可以根据上面的表达式表达为：1×10^1+2×10^0+3×10^-1+4×10^-2，其规范浮点数表达为1.234×101。
但对二进制来说，上面的表达式同样可以简单地表达。唯一不同之处在于：
二进制的 β 等于 2，而每个数字 d 只能在 0 和 1 之间取值。如二进制数 1001.101，
我们可以根据上面的表达式表达为：1×2^3+0×2^2+0×2^1+1×2^0+1×2^-1+0×2^-2+1×2^-3，其规范浮点数表达为 1.001101×23。
现在，我们就可以这样简单地把二进制转换为十进制，如二进制数 1001.101 转换成十进制为：
由上面的等式，我们可以得出：
向左移动二进制小数点一位相当于这个数除以 2，而向右移动二进制小数点一位相当于这个数乘以 2。
如 101.11=5+3/4，而 10.111=2+7/8。
除此之外，我们还可以得到这样一个基本规律：
一个十进制小数要能用浮点数精确地表示，最后一位必须是 5（当然这是必要条件，并非充分条件）。规律推演如下面的示例所示：
上面阐述了二进制数转换十进制数，如果你要将十进制数转换成二进制数
则需要把整数部分和小数部分分别转换。其中，整数部分除以 2，取余数；小数部分乘以 2，取整数位。
如将 13.125 转换成二进制数如下：
1、首先转换整数部分（13），除以 2，取余数=1101
13/2=6...1
6/2=3...0
3/2=1...1
1/2=0...12、其次转换小数部分（0.125），乘以 2，取整数位。转换过程如下：
0.125×2=0.25 取整数位0
0.25×2=0.5 取整数位0
0.5×2=1 取整数位13、小数部分所得结果为 001，即 13.125=1101.001，用规范浮点数表达为 1.101001×23。
OK，当我们了解了十进制与二进制雄鼠转换的原来后，我们来看上面的0.1+0.2的问题
Python使用的IEEE 754标准（52M/11E/1S），该标准采用8字节的64位二进制存储空间，
分配了52位来存储浮点数的有效数字，11位存储指数，1位存储正负号
（也是Python常说的53位二进制表示小数部分，52+1，2^53-2=9007199254740990，约为10^16）
即这是一种二进制版的科学计数法格式。
原十进制小数为0.1
0.1*2=0.2——取整数部分填充当前二进制小数位——0——剩余非零部分用于继续运算——0.2
0.2*2=0.4——取整数部分填充当前二进制小数位——0——剩余非零部分用于继续运算——0.4
0.4*2=0.8——取整数部分填充当前二进制小数位——0——剩余非零部分用于继续运算——0.8
0.8*2=1.6——取整数部分填充当前二进制小数位——1——剩余非零部分用于继续运算——0.6
0.6*2=1.2——取整数部分填充当前二进制小数位——1——剩余非零部分用于继续运算——0.2
......之后进入无限循环但是到了Python中并不能无限循环，从第53位开始进行舍入，
舍入规则为0舍1入，那么0.1转换为二进制小数实际为
0.00011001100110011001100110011001100110011001100110011010，然后将起二进制小数转为十进制
原二进制小数为0.00011001100110011001100110011001100110011001100110011010
0*2^-1+
0*2^-2+
0*2^-3+
1*2^-4+
1*2^-5+
0*2^-6+
......
1*2^-53+
0*2^-54+
1*2^-55+
0*2^-56=
0.10000000000000000055511151231257827021181583404541015625可以看到经过两次转行后出现了非常长的尾数，只是在浮点数输出时只输出了前16位小数。
所以我们可以得出一个结论，二进制表示小数，可以无限接近，但不完全相同。
这也是不确定尾数产生的原因，在运算时会先将十进制转换为二进制，再进行运算，运算完成后再由二进制转换为十进制。
随之也带来了另一个问题，运算后的数值比较：
由于不确定尾数的存在，不能直接进行比较，必须使用round(x,d)函数，对数值x进行四舍五入，d为小数精确位数。
>>> 0.1+0.2==0.3
False
>>> round(0.1+0.2,1)==0.3
True3）复数类型
在众多的编程语言中，只有Python提供了复数类型，复数类型与数学中的复数概念一致。
定义j2=-1，即j=√(-1)，以此为基础构建的数学体系。a+bj被成称为复数，其中a为实部，bj整个是虚数部分，b为虚部
例如：z=1.23e-4+5.6e+89j，那么z就是一个复数类型，可以使用z.real获取实部1.23e-4，z.imag获取虚部5.6e+89
在Python 中可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
Python 序列（Sequence）
序列类型是Python组合数据类型中非常重要的一种类型结构，在编程中会经常使用。
序列是具有先后关系的一组元素，可以理解为序列是一维元素的向量。
正是因为序列存在先后关系，所以元素之间可以相同，元素的类型可以不同。
Python序列类型类似于数学元素序列，也是由序号来引导的，可以通过类似下标的整数序列编号方式来进行访问。
我们一般只会使用序列类型衍生出来的几种数据类型，比如：字符串类型、元组类型和列表类型等
但是序列类型的所有操作，在衍生类型中都是适用的
序列类型有一个关于序号的定义，也就是说序列中的元素存在正向递增的序号索引关系和反向递减的序号索引关系。
1）序列操作符
| 操作符及应用 | 描述 |
| x in s | 如果序列s包含元素x，则返回True，否则返回False |
| x not in s | 与x in s相反 |
| s + t | 连接两个序列s和t |
| s * n或n * s | 将序列s复制n次 |
| s[i] | 索引，返回序列s中的第i个元素，i是序列的序号，序号有正向递增和反向递减两种 |
| s[i:j]或s[i:j:k] | 切片，返回序列s中[i,j)（大于等于i，小于j），以k为步长的元素子序列。 特殊用法：i=j=0,k=-1表示倒序 |
2）序列函数
| 函数和方法 | 描述 |
| len(s) | 返回序列s的长度 |
| min(s) | 返回序列s的最小元素，需要序列s中的元素可比较，如果在序列中元素是不同类型、不能比较，那么将报错 |
| max(s) | 返回序列s的最大元素，需要序列s中的元素可比较，如果在序列中元素是不同类型、不能比较，那么将报错 |
| s.index(x)或 s.index(x,i,j) | 返回序列s中[i,j)（大于等于i，小于j）第一次出现元素x的位置 |
| s.count(x) | 返回序列s中出现x的总次数 |
String 字符串类型
1）Python字符串表示方法
字符串或串(String)是由数字、字母、下划线组成的一串字符，它是编程语言中表示文本的数据类型。
python提供了单行字符串和多行字符串的表示方法
1、单行字符串：由一对单引号或双引号表示
2、多行字符串：由一对三单引号或三双引号
# 单行字符串的两种表示方法
str1 = "To see a world in a grain of sand"
str2 = 'And have a heaven in a wild flower'
# 多行字符串的两种表示方法
poem1 = """
I'm located on the cloud
floating on the top of the mountains of plateau
sometimes come down to pick wild fruit
observe giant blue whale across the sky under the dark nights
have a titmouse friend
and possess a cute little bowl made by soma flowers
"""
poem2 ='''
But when I walked on the ground
I become a beggar dressed in rags
begging meaningless love in vain
'''
转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\
print('I\'m ok.')
# I'm ok.
print('I\'m learning\nPython.')
# I'm learning
# Python.
print('\\\n\\')
# \
# \如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用...表示多行内容
print('''line1
... line2
... line3''')字符串支持Python序列的一系列操作，但需要注意字符串是不可变类型。
Python中提供了一些以函数形式来实现的字符串处理功能，称之为字符串处理函数。Python提供了6个有用的内置函数，如下：
| 函数及使用 | 描述 |
| len(x) | 返回字符串x的长度，例如：len("一二三456")结果为6。 注意：在Python中，无论是数字、标点符号、英文字母或汉字都是一个字符，长度是相同的 |
| str(x) | 将任意类型的x转换为对应的字符串形式，例如：str(1.23)结果为"1.23"，str([1,2])结果为"[1,2]" |
| hex(x)或oct(x) | 将整数x转换为小写十六进制或八进制的字符串，例如：hex(425)结果为"0x1a9"，oct(425)结果为"0o651" |
| chr(u) | u位Unicode编码，返回其对应的单字符 |
| ord(x) | x为单字符，返回其对应的Unicode编码 |
符串处理方法
| 方法及使用 | 描述 |
| str.lower()或str.upper() | 使用这两个函数可以将字符串中的所有字符全小写或大写， 例如："AaBbCcDd".lower()结果为"aabbccdd" "AaBbCcdD".upper()结果为"AABBCCDD" |
| str.split(sep=None) | 返回一个列表，这个列表由字符串str根据字符串sep被分割的部分组成， 例如："A,B,C".split(",")结果为['A','B','C'] |
| str.count(sub) | 返回子字符串sub在字符串str中出现的次数，例如： "an apple a day".count("a")结果为4 |
| str.replace(old,new[,max]) | 将字符串str中old子串替换为new子串，如果存在整数max，表示替换次数上限， 例如："python".replace("n",'n123')结果为"python123" |
| str.center(width[,fillchar]) | 返回width宽度str居中的字符串，如果存在fillchar，那么空余部分使用fillchar填充， 例如："python".centor(10)结果为" python "， "python".center(10,"=")结果为"==python==" |
| str.strip(chars) | 对照字符串chars中列出的字符，将字符串str左侧和右侧存在的相同字符去除，例如： "helloworld".strip("helod")结果为"wor"。strip()也可以认为是同时执行了lstrip()和rstrip() |
| str.join(iter) | 以指定字符串str作为分隔符，将iter所有字符分隔，重新组成一个新的字符串，例如： ",".join("python")结果为"p,y,t,h,o,n" |
PS:由于Python中字符串是不可变类型，所以向一个索引位置赋值时，会产生错误：Poem[2] = 'o'。
List 列表类型
列表是Python中内置的异常常用数据类型，List是一种有序集合，是可变数据类型，可以随时添加、删除或更改其中的元素。
列表可以完成大多数集合类的数据结构实现，支持字符、数字、字符串、列表、元组、集合、字典，甚至可以支持他们的混合
列表用 '[ ]'表示，中间用逗号 ' , ' 分隔，也可以使用 list()函数来创建列表，列表中各元素类型可以不同，列表也没有长度限制，例如
list1 = [1, 'a', 'we123', [1, 2, 3], (4, 5, 6), {"key": 1111}, {7, 8, 9}]
print(list1)
PS：使用[]或list()函数是真正创建一个列表，如果仅使用等号（=）将一个列表变量赋值给另一个列表变量，
那么此时并没有在系统中真正的创建一个列表，而是将同一个列表赋给不同的名字，当其中一个变量被修改时
另一个变量也会被修改，类似于Windows的快捷方式。
>>> ls=["cat","dog","tiger",1024]
>>> ls
['cat', 'dog', 'tiger', 1024]
>>> lt=ls
>>> lt
['cat', 'dog', 'tiger', 1024]
>>> ls[1]="human"
>>> ls
['cat', 'human', 'tiger', 1024]
>>> lt
['cat', 'human', 'tiger', 1024]List可以使用序列的所有操作，还有一些自己额外的函数，如：
| 函数或方法 | 描述 |
| ls.appedn(x) | 在列表ls最后增加一个元素x |
| ls.clear() | 删除列表ls中所有元素 |
| ls.copy() | 生成一个新列表，包含ls中所有元素 |
| ls.insert(i,x) | 在列表ls的第i位增加元素x |
| ls.pop(i) | 将列表ls中第i位元素取出，并删除列表中该元素 |
| ls.remove(x) | 将列表ls中第一次出现的元素x删除 |
| ls.reverse() | 将列表中的元素反转 |
| sorted(ls) | 对列表ls进行排序 |
| ls.sort(cmp=None, key=None, reverse=False) | 对列表ls进行排序 cmp：可选参数, 如果指定了该参数会使用该参数的方法进行排序。 key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 reverse：排序规则，reverse = True 降序， reverse = False 升序（默认）。 |
实例：
>>> ls=["cat","dog","tiger",1024]
>>> ls[1:2]=[1,2,3,4]
>>> ls
['cat', 1, 2, 3, 4, 'tiger', 1024]
>>> del ls[::3]
>>> ls
[1, 2, 4, 'tiger']
>>> ls*2
[1, 2, 4, 'tiger', 1, 2, 4, 'tiger']
>>> ls.append(1234)
>>> ls
[1, 2, 4, 'tiger', 1234]
>>> ls.insert(3,"human")
>>> ls
[1, 2, 4, 'human', 'tiger', 1234]
>>> ls.reverse()
>>> ls
[1234, 'tiger', 'human', 4, 2, 1]Tuple 元组类型
元组类型也是一种序列类型扩展，但元组属于不可变对象，元组一旦被创建旧不能被修改。
元组使用()表示，元素之间用逗号（,）分隔。创建一个元组需要使用()或tuple()函数,在使用时也可以不使用()
当不使用（）时，Python内部会认为返回了一个值，这个值的类型默认是元组类型
creature="cat","dog","tiger","human"
color=(0x001100,"blue",creature)
fruit=tuple("banana","apple","doge")
# 如果要定义只有一个元素的tuple，必须加1个逗号，来消除小括号的歧义
t = (1,)
元组类型就是将元素进行有序排列，用()形式来组织，元组类型的每个元素一旦被定义，那么它的元素值是不能改变的
元组可使用序列的所有操作和函数，且由于元组的不可变性质，元组没有针对自身的特殊操作。
字典类型
了解字典首先要了解映射，映射是一种索引和数据的对应关系，也是一种键和值的对应关系，可以认为索引叫键，数据叫值。
映射更多的是表达了某一个属性跟它对应的值，这种映射本身就是一种索引或一种属性与数据之间的对应关系。
映射关系无处不在，例如：“姓名”与具体的姓名数据，“年龄”与具体的年龄数据。
字典是一种映射类型（mapping type），它是一个无序的 键 : 值 对集合。
关键字必须使用不可变类型，也就是说list和包含可变类型的tuple不能做关键字。
在同一个字典中，关键字还必须互不相同。
在Python中字典用{}表示，键值对之间用冒号（:）表示，元素之间用逗号分隔，创建一个字典需要使用{}或dict()函数
>>> dic={"中国":"北京","美国":"华盛顿"}
>>> dic["中国"]
'北京'
>>> dic["日本"]="东京" #增加键值对
>>> dic
{'中国': '北京', '美国': '华盛顿', '日本': '东京'}
>>> dic["日本"]="无" #修改键值对
>>> dic
{'中国': '北京', '美国': '华盛顿', '日本': '无'}
>>> d={}
>>> d
{}
>>> type(d)
<class 'dict'>字典的处理函数及方法
| 函数或方法 | 描述 |
| del d[k] | 删除字典d中键为k所对应的数据值 |
| k in d | 判断键值k是否在字典d中，如果在返回True，如果不在返回False |
| d.keys() | 返回字典d中所有的键信息 |
| d.values() | 返回字典d中所有的值信息 |
| d.items() | 返回字典d中所有的键值对信息 |
| d.get(k,<default>) | 在字典d中，如果键k存在，则返回对应的值，如果不存在，则返回<default> |
| d.pop(k,<default>) | 在字典d中，如果键k存在，则返回对应的值，如果不存在，则返回<default>。最后删除字典中相应的键值对 |
| d.popitem() | 随机从字典d中取出一个键值对，以元组形式返回，取出的键值对会从字典d中删除 |
| d.clear() | 删除字典d中的所有键值对 |
| len(d) | 返回字典d中元素的个数 |
集合
集合类型是组合数据类型非常重要的一种表达方式，是多个元素的无序组合。
集合元素之间无序，在集合中不存在相同元素，即每一个元素都是独一无二的
在Python的集合类型中，它要求放入集合中的元素是不可变数据类型，例如：整数、浮点数、复数、字符串、元组等。
在Python中集合用{}表示，元素之间用逗号（,）分隔。创建一个集合需要使用{}或set()函数
如果创建一个空集合必须采用set()，因为{ }是用来创建空字典的。
>>> A={"python",123,("python",123)} #使用{}创建集合
>>> print(A)
{'python', ('python', 123), 123}
>>> B=set("pypy123") #使用set()创建集合，将字符串中的每一个字符单独拆分变成集合的一个元素。
>>> print(B) #由于给定的字符串中存在相同的字符，生成集合后相同的字符只保留一个，并且无序存在。
{'1', '3', '2', 'p', 'y'}
>>> C={"python",123,"python",123} #使用{}创建的集合一样会将相同的元素去除，只保留一个
>>> print(C)
{'python', 123}1）集合操作符
| 操作符与应用 | 描述 |
| S | T | 返回一个新集合，包含集合S和T中所有元素，实现了集合之间的并 |
| S - T | 返回一个新集合，包含集合S中的元素但不包括T中的元素，实现了集合之间的差 |
| S & T | 返回一个新集合，包括同时在集合S和T中的元素，实现了集合之间的交 |
| S ^ T | 返回一个新集合，包括集合S和T中的非相同元素，实现了集合间的补 |
| =、>、>=、<、<= | 返回True或False，判断集合间的子集（包含）关系 |
Python还提供了增强操作符，通过四种基础操作符和赋值符号的组合来实现对集合S的更新，如下：
| 操作符及应用 | 描述 |
| S |= T | 更新集合S，包含集合S和T中所有元素 |
| S -= T | 更新集合S，包含集合S中的元素但不包含T中的元素 |
| S &= T | 更新集合S，包含同时在集合S和T中的元素 |
| S ^= T | 更新集合S，包含集合S和T中的非相同元素 |
>>> A={"p","y",123}
>>> B=set("pypy123")
>>> A-B
{123}
>>> B-A
{'3', '2', '1'}
>>> A&B
{'y', 'p'}
>>> A|B
{'y', '3', '1', 123, '2', 'p'}
>>> A^B
{'3', 123, '2', '1'}2）集合处理方法
| 操作函数或方法 | 描述 |
| S.add(x) | 如果元素x不在集合S中，将x添加到S中 |
| S.discard(x) | 移除集合S中的元素x，如果S中没有x也不报错 |
| S.remove(x) | 移除集合S中的元素x，如果S中没有x则产生KeyErroe异常 |
| S.clear() | 移除集合S中的所有元素 |
| S.pop() | 提取集合S中的第一个元素，并在集合中删除该元素，如果S为空则产生KeyError异常 |
| S.copy() | 返回一个与集合S一样的副本 |
| len(S) | 返回集合S中的元素个数 |
| set(x) | 将其他类型变量x转换为集合类型 |
| x in S | 判断元素x是否在集合S中，如果存在则返回True，如果不存在则返回False |
| x not in S | 与x in S相反 |
PS：集合并不是完全无序，只是自己本身有着特殊的排序方式，并不一定会按照创建时给出元素顺序
>>> A={1,2,3,4,5}
>>> A
{1, 2, 3, 4, 5}
>>> A={1,"A",23,"BC"}
>>> A
{1, 'BC', 'A', 23}
>>> A.pop()
1
>>> A
{'BC', 'A', 23}
>>> A.add(1)
>>> A
{1, 'BC', 'A', 23}Python数据类型转换
| 函数 | 描述 |
|---|---|
| 将x转换为一个整数 | |
| 将x转换为一个长整数 | |
| 将x转换到一个浮点数 | |
| 创建一个复数 | |
| 将对象 x 转换为字符串 | |
| 将对象 x 转换为表达式字符串 | |
| 用来计算在字符串中的有效Python表达式,并返回一个对象 | |
| 将序列 s 转换为一个元组 | |
| 将序列 s 转换为一个列表 | |
| 转换为可变集合 | |
| 创建一个字典。d 必须是一个序列 (key,value)元组。 | |
| 转换为不可变集合 | |
| 将一个整数转换为一个字符 | |
| 将一个整数转换为Unicode字符 | |
| 将一个字符转换为它的整数值 | |
| 将一个整数转换为一个十六进制字符串 | |
| 将一个整数转换为一个八进制字符串 |
None类型
Python None 类型
是Python的特殊类型，Null对象或者是None Type，它只有一个值None.
它不支持任何运算也没有任何内建方法.
None和任何其他的数据类型比较永远返回False。
None有自己的数据类型NoneType。
你可以将None复制给任何变量，但是你不能创建其他NoneType对象。
813
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
