python 数据类型

一,数字

Python 数字数据类型用于存储数值。

数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1
var2 = 10

您也可以使用del语句删除一些数字对象的引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]

您可以通过使用del语句删除单个或多个对象的引用，例如：

del var
del var_a, var_b

Python 支持三种不同的数值类型：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

我们可以使用十六进制和八进制来代表整数：

>>> number = 0xA0F # 十六进制
>>> number
2575

>>> number=0o37 # 八进制
>>> number
31

• Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

---

数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

• int(x) 将x转换为一个整数。
• float(x) 将x转换到一个浮点数。
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

以下实例将浮点数变量 a 转换为整数：

>>> a = 1.0
>>> int(a)
1

---

数字运算

Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。

表达式的语法很直白： +, -, ***** 和 /, 和其它语言（如Pascal或C）里一样。例如：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # 总是返回一个浮点数
1.6

注意：在不同的机器上浮点运算的结果可能会不一样。

在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ：

>>> 17 / 3  # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3  # 整数除法返回向下取整后的结果
5
>>> 17 % 3  # ％操作符返回除法的余数
2
>>> 5 * 3 + 2 
17

注意：//得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。

>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>> 

Python 可以使用 ** 操作来进行幂运算：

>>> 5 ** 2  # 5 的平方
25
>>> 2 ** 7  # 2的7次方
128

不同类型的数混合运算时会将整数转换为浮点数：

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

python是强类型动态语言,即字符串格式的1和数字格式的1不能做数学运算

---

数学常量

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）。

二,字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!' var2 = "Runoob"

---

转义字符

在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：

转义字符	描述
(在行尾时)	续行符
\	反斜杠符号
'	单引号
"	双引号
\a	响铃
\b	退格(Backspace)
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

---

字符串运算符

下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：

操作符	描述	实例
+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果：HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。	a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	'H' in a 输出结果 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	'M' not in a 输出结果 True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print( r'\n' ) print( R'\n' )
%	格式字符串	请看下一节内容。

---

字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
我叫 小明 今年 10 岁!

python字符串格式化符号:

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

格式化操作符辅助指令:

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
	在正数前面显示空格
#	在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0	显示的数字前面填充'0'而不是默认的空格
%	'%%'输出一个单一的'%'
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

---

三引号

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下

#!/usr/bin/python3 para_str = """这是一个多行字符串的实例 多行字符串可以使用制表符 TAB ( \t )。 也可以使用换行符 [ \n ]。 """ print (para_str)

以上实例执行结果为：

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (    )。
也可以使用换行符 [ 
 ]。

---

f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

name = 'Runoob'
f'Hello {name}' # 替换变量

f'{1+2}'     # 使用表达式
'3'

w = {'name': 'Runoob', 'url': 'www.runoob.com'}
f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。

在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

x = 1
print(f'{x+1}')  # Python 3.6
2

x = 1
print(f'{x+1=}')  # Python 3.8
'x+1=2'

---

Unicode 字符串

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在Python3中，所有的字符串都是Unicode字符串。

---

字符串内建方法

Python 的字符串常用内建函数如下：

常用方法

1,按索引取值(正向取+反向取)

res='1234567'

print(res[0])

print(res[-1])

2,切片:索引的拓展应用，从一个大字符串中拷贝出一个子字符串

msg='hello world'
# 顾头不顾尾
res=msg[0:5] #x
print(res)
print(msg)

#步长
res=msg[0:5:2] # 0 2 4
print(res) # hlo

#反向步长
res=msg[5:0:-1]
print(res) #" olle"

#不填写时的默认值
msg='hello world'
res=msg[:] # res=msg[0:11]
print(res)
res=msg[::-1] # 把字符串倒过来
print(res)

3 长度 len

msg='hello world'
print(len(msg))

4 成员运算in和not in

判断一个子字符串是否存在于一个大字符串中

print("alex" in "alex is sb")
print("alex" not in "alex is sb")
print(not "alex" in "alex is sb") # 不推荐使用

5 移除字符串左右两侧的符号strip

默认去掉的空格

msg='      egon      '
res=msg.strip()
print(msg) # 不会改变原值
print(res) # 是产生了新值

括号内传什么参数就去掉什么,直到遇到第一个不能删除的字符

msg='****egon****'
print(msg.strip('*'))

注意删除多个字符时：只要头尾有对应其中的某个字符即删除，不考虑顺序，直到遇到第一个不包含在其中的字符为止。

str = '123132231213321312==321312213231123132'
print(str.strip('123'))

以上代码输出结果为：==

msg='****e*****gon****'
print(msg.strip('*'))

msg='**/*=-**egon**-=()**'
print(msg.strip('*/-=()'))

还有左删除和右删除 lstrip()和 rstrip()

6 切分split：把一个字符串按照某种分隔符进行切分，得到一个列表

默认分隔符是空格

info='egon 18 male'
res=info.split()
print(res)

指定分隔符

info='egon:18:male'
res=info.split(':')
print(res)

指定分隔次数

info='egon:18:male'
res=info.split(':',1)
print(res)

**把列表拼接成字符串 join **

l=['egon', '18', 'male']
res=l[0]+":"+l[1]+":"+l[2]
res=":".join(l) # 按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串
print(res)

l=[1,"2",'aaa'] # 不能拼接有非字符串的列表,会报错!
":".join(l)

7 用于for循环

info='egon:18:male'
for x in info:
    print(x)

8 大小写转换 lower,upper

全大写全小写

msg='AbbbCCCC'
print(msg.lower())
print(msg.upper())

9 判断开头结尾 startswith,endswith

返回布尔值

print("alex is sb".startswith("alex"))
print("alex is sb".endswith('sb'))

10 格式化字符 format

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。还可以用字典传值

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

11 maketrans 和translate 群替换字符串

maketrans创建映射关系,translate负责替换

intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)

str = "this is string example....wow!!!"
print (str.translate(trantab))

th3s 3s str3ng 2x1mpl2....w4w!!!

参数详解:

一个参数，该参数必须为字典

>>> d = {'a':'1','b':'2','c':'3','d':'4','e':'5','s':'6'}
>>> trantab = str.maketrans(d)
>>> st='just do it'
>>> print(st.translate(trantab))
ju6t 4o it

两个参数 x 和 y，x、y 必须是长度相等的字符串，并且 x 中每个字符映射到 y 中相同位置的字符

>>> x = 'abcdefs'
>>> y = '1234567'
>>> st='just do it'
>>> trantab = str.maketrans(x,y)
>>> print(st.translate(trantab))
ju7t 4o it

三个参数 x、y、z，第三个参数 z 必须是字符串，其字符将被映射为 None，即删除该字符；如果 z 中字符与 x 中字符重复，该重复的字符在最终结果中还是会被删除。也就是无论是否重复，只要有第三个参数 z，z 中的字符都会被删除。

>>> x = 'abcdefs'
>>> y='1234567'
>>> z='ot'
>>> st='just do it'
>>> trantab = str.maketrans(x,y,z)
>>> print(st.translate(trantab))
ju7 4 i

>>>x = 'abst'
>>>y = '1234'
>>>z = 's'
>>>st = 'just do it'
>>>trantab = str.maketrans(x,y,z)
>>>print(st.translate(trantab))
ju4 do i4

replace 单次替换

msg="you can you up no can no bb"
print(msg.replace("you","YOU",))
print(msg.replace("you","YOU",1))

12 isdigit

判断字符串是否由纯数字组成

print('123'.isdigit())
print('12.3'.isdigit())

其他方法

1 查找,计数

find,rfind,index,rindex,count

msg='hello egon hahaha' 找到返回起始索引

msg='hello egon hahaha'
print(msg.find('e')) # 返回要查找的字符串在大字符串中的起始索引
print(msg.find('egon'))
print(msg.index('e'))
print(msg.index('egon'))

找不到时两种方法的不同情况

msg='hello egon hahaha'
print(msg.find('xxx')) # 返回-1，代表找不到
print(msg.index('xxx')) # 抛出异常

msg='hello egon hahaha egon、 egon'
print(msg.count('egon'))

2 设置填充

center,ljust,rjust,zfill

居中,左对齐,右对齐,zero fill用零填充

print('egon'.center(50,'*'))
print('egon'.ljust(50,'*'))
print('egon'.rjust(50,'*'))
print('egon'.zfill(10))

3 设置制表符的空格数 expandtabs

msg='hello\tworld'
print(msg.expandtabs(2)) # 设置制表符代表的空格数为2

4 样式调整 capitalize,swapcase,title

整个字符串的第一个单词首字母大写,大小写翻转,每个单词的首字母大写

print("hello world egon".capitalize())
print("Hello WorLd EGon".swapcase())
print("hello world egon".title())

5 is数字系列

num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

isdigit只能识别：num1、num2

print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False

isnumberic可以识别：num2、num3、num4

print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True

isdecimal只能识别：num2

print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False

is其他

print('abc'.islower())  # 是否全小写
print('ABC'.isupper())  # 是否全大写
print('Hello World'.istitle())  # 是否所有单词首字母大写
print('123123aadsf'.isalnum()) # 字符串由字母或数字组成结果为True
print('ad'.isalpha()) # 字符串由由字母组成结果为True
print('     '.isspace()) # 字符串由空格组成结果为True
print('print'.isidentifier())   # 是否合法标识符，True
print('age_of_egon'.isidentifier())     #True
print('1age_of_egon'.isidentifier())    # False

三,列表

作用：列表一般用于按位置存放多个值

定义:列表是一个由多个数据组成的数据结构

l=[1,1.2,'a'] 
# 相当于l=list([1,1.2,'a'])
print(type(l))
# <class 'list'>

类型转换: 能够被for循环遍历的类型都可以使用list()转成列表

res=list('hello')
print(res)
s = "hello"
l = []
for i in s:
    l.append(i)
print(l)

---

列表运算

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

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, end=" ")	1 2 3	迭代

列表内建方法

常用方法

1、按索引存取值(正向存取+反向存取)：即可以取也可以改

l=[111,'egon','hello']
# 正向取值
print(l[0])
# 反向取值
print(l[-1])
# 可以取也可以改：索引存在则修改对应的值
l[0]=222
print(l)
# 无论是取值操作还是赋值操作：索引不存在则报错
l[3]=333

2、切片(顾头不顾尾，步长)

l = [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
print(l[0:3])
# [111, 'egon', 'hello']
print(l[0:5:2]) # 取索引为0 2 4的值
# [111, 'hello', 'b']

print(l[0:len(l)])
# [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
print(l[:])
# [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
new_l=l[:] # 切片等同于拷贝行为，而且相当于浅copy
print(id(l))
# 2277356332168
print(id(new_l))
# 2277356332936

l[-1][0]=1111111		# 修改原列表,验证切片与浅拷贝类似
print(l)
# [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1111111, 2, 3]]
print(new_l)
# [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1111111, 2, 3]]
print(l[::-1])
# [[1111111, 2, 3], 'd', 'c', 'b', 'a', 'hello', 'egon', 111]

3、长度

print(len([1, 2, 3]))
# 3

4、成员运算in和not in

print('aaa' in ['aaa', 1, 2])
# True
print(1 in ['aaa', 1, 2])
# True

5、往列表中添加值

追加 append

在列表尾部添加单个数据

l=[111,'egon','hello']
l.append(3333)
l.append(4444)
print(l)
# l=[111,'egon','hello',3333,4444]

插入 insert

按照填入的索引,在对应的位置插入数据

l=[111,'egon','hello']
l.insert(0,'alex')
print(l)
# ['alex', 111, 'egon', 'hello']

**解压添加值 extend **

extend可以将新列表内的数据解压添加到原列表

如果我们想将一个新的列表内的数据添加到原列表,使用append无法实现,我们可以使用extend方法

new_l = [1, 2, 3]
l = [111, 'egon', 'hello']
for item in new_l:
    l.append(item)
print(l)
# [111, 'egon', 'hello', 1, 2, 3]
# 实现了功能
l.extend('abc')
print(l)
# [111, 'egon', 'hello', 1, 2, 3, 'a', 'b', 'c']

6 删除

方式一：根据索引删除，只是单纯的删除、没有返回值

l = [111, 'egon', 'hello']
del l[1]
print(l)
x = del l[1] # 查看返回值,抛出异常，不支持赋值语法

方式二：list.pop()根据索引删除，会返回删除的值(经常使用)

不输入索引时默认删除最后一个数据

l = [111, 'egon', 'hello', 55]
l.pop()  # 不指定索引默认删除最后一个
l.pop()
print(l)
# [111, 'egon']
res = l.pop(1)
print(l)
# [111]
print(res)
# egon

方式三：l.remove()根据元素删除，返回None

l = [111, 'egon', [1,2,3],'hello']
l.remove([1,2,3])
print(l)
# [111, 'egon', 'hello']
res=l.remove('egon')		# 返回值为None
print(res) 
# None

7、循环与列表

不要在循环中对列表进行删除操作,会导致索引错乱,

l=[1,'aaa','bbb']
for x in l:
    l.pop(1)
    print(x)

其他方法

1、l.count()

输入内容在列表中出现的次数

print(l.count('aaa'))

2、l.index()

查找方法,查找输入内容第一次出现的位置的索引

print(l.index('aaa'))
print(l.index('aaaaaaaaa')) # 找不到报错

3、l.clear()

清空列表

l.clear()

4、l.reverse():

注意: reverse不是排序后翻转，是将列表的索引翻转

l = [1, 'egon','alex','lxx']
l.reverse()
print(l)

5、l.sort(): 列表内元素必须是同种类型才可以排序

l=[11,-3,9,2,3.1]
l.sort() # 默认从小到大排，称之为升序
l.sort(reverse=True) # 从大到小排，设置为降序
print(l)

l=[11,'a',12]  # 不同类型报错!
l.sort()

l=['c','e','a']		# 按ascii码排序,A<a
l.sort()
print(l)

字符串可以比大小，按照对应的位置的字符依次pk
字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的

print('a'>'b')
# False

print('abz'>'abcdefg')
# True

列表也可以比大小,原理同字符串一样,但是对应位置的元素必须是同种类型

l1=[1,'abc','zaa']
l2=[1,'abc','zb']

print(l1 < l2)
# True

max(list)返回列表元素最大值

min(list) 返回列表元素最小值

四,元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组就是"一个不可变的列表"

1、作用：按照索引/位置存放多个值，只用于读不用于改

2、定义:（）内用逗号分隔开多个任意类型的元素

t=(1,1.3,'aa') 
# 相当于t=tuple((1,1.3,'aa'))
print(t,type(t))
# (1, 1.3, 'aa') <class 'tuple'>

x=(10) # 单独一个括号代表包含的意思为整数数据类型!!
print(x,type(x))
# 10 <class 'int'>

t=(10,) # 如果元组中只有一个元素，必须加逗号
print(t,type(t))
# (10,) <class 'tuple'>

元组是不可变数据类型:不可变体现在它第一层的数据指向的内存地址不能更改.

t=(1,1.3,'aa') # t=(0->值1的内存地址,1->值1.3的内存地址,2->值'aaa'的内存地址，)
t[0]=11111
# TypeError: 'tuple' object does not support item assignment

t=(1,[11,22]) # t=(0->值1的内存地址,1->值[1,2]的内存地址，)
print(id(t[0]),id(t[1]))
# 1358874288 2579862236488

t[0]=111111111 # 不能改第一层的内存地址
# TypeError: 'tuple' object does not support item assignment

t[1]=222222222 # 不能改第一层的内存地址
# TypeError: 'tuple' object does not support item assignment

t[1][0]=11111111111111111	# 修改第二层的内存地址
print(t)
# (1, [11111111111111111, 22])

print(id(t[0]),id(t[1]))
# 1358874288 2579862236488
# 修改第二层的内存地址后第一层内存地址不变

3、类型转换: 所有能被for循环遍历的数据都能转换成元组,与列表的转换条件相同

print(tuple('hello'))
# ('h', 'e', 'l', 'l', 'o')

print(tuple([1,2,3]))
# (1, 2, 3)

print(tuple({'a1':111,'a2':333}))
# ('a1', 'a2')

print(tuple(range(10)))
# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

元组运算

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

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、按索引取值(正向取+反向取)：只能取,不能修改,否则会报错

t=('aa','bbb','cc')
print(t[0])
# aa
print(t[-1])
# cc

2、切片(顾头不顾尾，步长):切片为索引附带的功能,本质为浅拷贝,并不在原数据上进行修改

t=('aa','bbb','cc','dd','eee')
print(t[0:3])
# ('aa', 'bbb', 'cc')

print(t[::-1])
# ('eee', 'dd', 'cc', 'bbb', 'aa')

3、长度: 元组内元素个数

t=('aa','bbb','cc','dd','eee')
print(len(t))
# 5

4、成员运算in和not in

t=('aa','bbb','cc','dd','eee')
print('aa' in t)
# True

5、循环: 遍历读取

for x in t:
    print(x)

6、查找:index和count

t=(2,3,111,111,111,111)
print(t.index(111))
# 2

print(t.index(1111111111))    # index查找数据不存在时会报错
# ValueError: tuple.index(x): x not in tuple

print(t.count(111))			# 111出现的次数
# 4

五,字典

1、作用

字典可以用来存储含有描述性信息的数据,可读性比其他类型高,比如{"name":"wu","age":24}

它是以键值对的形式存储数据

2、定义：{}内用逗号分隔开多个key：value，其中value可以使任意类型，但是key必须是不可变类型,且不能重复

造字典的方式一 手写：

d={'k1':111,(1,2,3):222} # d=dict(...)
print(d['k1'])
# 111
print(d[(1,2,3)])
# 222
print(type(d))
# <class 'dict'>

d={} # 默认定义出来的是空字典
print(d,type(d))
# {} <class 'dict'>

造字典的方式二 dict()函数：

>>>dict()                        # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>>

造字典的方式三:初始化一个字典

seq = ('name', 'age', 'sex')
 
dict = dict.fromkeys(seq)
print ("新的字典为 : %s" %  str(dict))

dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %  str(dict))

新的字典为 : {'age': None, 'name': None, 'sex': None}
新的字典为 : {'age': 10, 'name': 10, 'sex': 10}

字典不能运算

字典内置方法

基础方法

1、按key存取值：可存可取

d={'k1':111}

# 针对赋值操作：如果key存在，则修改
d['k1']=222

# 针对赋值操作：如果key不存在，则创建新值
d['k2']=3333

print(d)
# {'k1': 222, 'k2': 3333}

2、长度len

d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
print(len(d))
# 4

3、成员运算in和not in:根据key

d={'k1':111,'k2':2222}
print('k1' in d)
# True
print(111 in d)       	# 只检测key
# False

4、删除

通用删除方法

d={'k1':111,'k2':2222}
del d['k1']
print(d)

pop删除：根据key删除元素，返回删除key对应的那个value值,如果要删除的 key 不存在，则需要添加默认值，否则会报错：

d={'k1':111,'k2':2222}
res=d.pop('k2')
print(d)
print(res)


dict1 = {1: "a", 2: [1, 2]}
print(dict1.pop(3,"nokey"),dict1) # 设置默认值，必须添加，否则报错
nokey {2: [1, 2]}

popitem删除：python2随机删除，python3删除最后一个,返回元组(删除的key,删除的value)

d={'k1':111,'k2':2222}
res=d.popitem()
print(d)
# {'k1': 111}

print(res)
# ('k2', 2222)

5 键值对items() ,键keys()，值values()

在python2中
d={'k1':111,'k2':2222}

d.keys()
['k2', 'k1']
d.values()
[2222, 111]
d.items()
[('k2', 2222), ('k1', 111)]
dict(d.items())
{'k2': 2222, 'k1': 111}

6、for循环使用

d={'k1':111,'k2':2222}
for k in d.keys():
    print(k)
# k1
# k2

for k in d:
    print(k)
# k1
# k2

for v in d.values():
    print(v)
# 111
# 2222

for k,v in d.items():
    print(k,v)
# k1 111
# k2 2222

print(list(d.keys()))
# ['k1', 'k2']
print(list(d.values()))
# [111, 2222]
print(list(d.items()))
# [('k1', 111), ('k2', 2222)]

常用方法

1、d.clear() 清空字典

d = {'k1': 111}
d.clear()
print(d)
# {}

2、d.update()

把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。

d={'k1':111}
d.update({'k2':222,'k3':333,'k1':111111111111111})
print(d)
# {'k1': 111111111111111, 'k2': 222, 'k3': 333}

3、d.get() ：根据key取值，容错性好

d={'k1':111}
print(d['k2'])  # key不存在则报错
# KeyError: 'k2'

print(d.get('k1')) 
# 111

print(d.get('k2')) 
# key不存在不报错，返回None

4、d.setdefault()

如果key有则不添加,返回字典的值

info = {"name": "wu"}
print(info.setdefault("name", "???"))
# wu

print(info)
# {'name': 'wu'}

如果key没有则添加，返回添加的值

info = {}
print(info.setdefault("name", "???"))
# ???

print(info)
# {'name': '???'}

5 values() 方法

values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。

dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
 
print ("字典所有值为 : ",  list(dict.values()))

字典所有值为 :  ['female', 7, 'Zara']

6 copy()方法

copy() 函数返回一个字典的浅复制。

dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
dict2 = dict1.copy()
print ("新复制的字典为 : ",dict2)

新复制的字典为 :  {'Age': 7, 'Name': 'Runoob', 'Class': 'First'}

六,集合

作用:集合可以进行独特的关系运算，对某些数据能做出去重的操作

1,集合的定义:

集合的形式是在{}内用逗号分隔开多个元素，并且这多个元素有以下三个特点

集合内元素必须为不可变类型

集合内元素无序

集合内元素不重复

s={} # 直接使用{}默认创建空字典
print(type(s))
# <class 'dict'>

# 定义空集合的方法
s=set()
print(s,type(s))
# set() <class 'set'>

s={1,2} # s=set({1,2})，集合的定义
s={1} # s=set({1})，集合的定义


# 集合内元素的3个特征

s={1,[1,2]} # 集合内元素必须为不可变类型
# TypeError: unhashable type: 'list'

s={1,'a','z','b',4,7} # 集合内元素无序
# 输出结果不同

s={1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
print(s)
# {1, 'a', 'b'}

2,类型转换(集合的创建)

所有能被for循环遍历的数据类型都能被转换成集合，但是有一个前提条件：这个数据内的元素必须都为不可变数据类型

res=set('hellolllll')
print(res)
# {'e', 'l', 'o', 'h'}

s = set(range(5))
print(s)
# {0, 1, 2, 3, 4}

print(set([1,1,1,1,1,1]))
# {1}

print(set([1,1,1,1,1,1,[11,222]]) # 报错
# TypeError: unhashable type: 'list'
      
print(set({'k1':1,'k2':2}))
# {'k2', 'k1'}

集合关系运算

取交集：等价于intersection() 方法

两者共同的好友
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
res=friends1 & friends2
print(res)
# {'egon', 'jason'}

print(friends1.intersection(friends2))
# {'egon', 'jason'}

取并集：等价于union() 方法

两者所有的好友
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 | friends2)
# {'Jy', 'ricky', 'jason', 'kevin', 'egon', 'zero'}

print(friends1.union(friends2))
# {'Jy', 'ricky', 'jason', 'kevin', 'egon', 'zero'}

取差集：等价于difference() 方法

取friends1独有的好友
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 - friends2)
# {'zero', 'kevin'}

print(friends1.difference(friends2))
# {'zero', 'kevin'}

---

取friends2独有的好友
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends2 - friends1)
# {'Jy', 'ricky'}

print(friends2.difference(friends1))
# {'Jy', 'ricky'}

**对称差集: **

求两个用户独有的好友们（即去掉共有的好友）

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 ^ friends2)
# {'ricky', 'Jy', 'zero', 'kevin'}

print(friends1.symmetric_difference(friends2))
# {'ricky', 'Jy', 'zero', 'kevin'}

父子集：包含的关系

issuperset()与issubset()

s1={1,2,3}
s2={1,2,4}
# 不存在包含关系，下面比较均为False
print(s1 > s2)
print(s1 < s2)

s1={1,2,3}
s2={1,2}
print(s1 > s2) # 当s1大于或等于s2时，才能说是S2是s1的子集
print(s1.issuperset(s2)) # s1是父集
# True

print(s2.issubset(s1)) # s2是子集，s2 < s1  =>True
# True

s1={1,2,3}
s2={1,2,3}
print(s1 == s2) # s1与s2互为子集
# True

print(s1.issuperset(s2))
# True

print(s2.issuperset(s1))
# True

集合去重

使用集合去重有两个注意点：

1,只能针对不可变类型去重

因为集合内不能存放不可哈希的数据类型，即集合内不能有可变数据类型的数据，所以集合的去重只能针对不可变类型去重。

print(set([1,1,1,1,2]))
# {1, 2}

print({1, 1, 1, [1, 1, 2]})
# TypeError: unhashable type: 'list'

2,无法保证原来的顺序

集合是一种无序的数据类型，所以去重后无法保证顺序相同

l=[1,'a','b','z',1,1,1,2]
l=list(set(l))
print(l)
# [1, 2, 'b', 'z', 'a']

其他方法

长度 len

s1 = {1, 2, 3}
print(len(s1))
# 3

成员运算 in

s1 = {1, 2, 3}
print(1 in s1)
# True

循环遍历

s1 = {1, 2, 3}
for i in s1:
    print(i)

删除元素 discard,remove,pop,clear

s1 = {1, 2, 3}
s1.discard(4)
# 不会报错

s1 = {1, 2, 3}
s1.remove(4)
# KeyError: 4

pop有返回值：删除的元素
s1 = {1, 2, 3}
res = s1.pop()
print(res)
# 1

print(s1)
# {2, 3}

clear() 方法用于移除集合中的所有元素。
fruits = {"apple", "banana", "cherry"}
fruits.clear()

添加元素：add

s1 = {1, 2, 3}
s1.add(4)
print(s1)
# {1, 2, 3, 4}

更新:update

s1 = {1, 2, 3}
s1.update({1, 3, 5})
print(s1)
# {1, 2, 3, 5}

不常用方法

是否独立：isdisjoint

s1 = {1, 2, 3}
res = s1.isdisjoint({3, 4, 5, 6})
# 两个集合有交集，则返回False
print(res)
res = s1.isdisjoint({4, 5, 6})
# 两个集合完全独立、没有共同部分，则返回True
print(res)

update

这个系列相当于在之前的功能上添加一个赋值操作

s = {1, 2, 3}
s.difference_update({3,4,5}) # s=s.difference({3,4,5})
print(s)
# {1, 2}

copy() 方法用于拷贝一个集合。

fruits = {"apple", "banana", "cherry"}
x = fruits.copy()