从零开始学习人工智能Day2-python基础数据类型(续)-CSDN博客

本文链接：https://blog.csdn.net/m0_63581095/article/details/147422592

六、python基本数据类型(续)

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

1.Python3 数字(Number)

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

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

1.1 Python 数字类型转换

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

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

num1 = 10
num2 = 20.5
print(complex(num1))      #输出： (10+0j)
print(complex(num1, num2))  #输出： (10+20.5j)

1.2 Python 数字运算

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

print(10//3)  #输出： 3
print(10.0//3)   #输出： 3.0

1.3 数学函数

import math!!!

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	以浮点数形式返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x)	返回数字x的平方根。

#数学函数
import math

#绝对值
print(abs(-10))   #输出： 10
#浮点数的绝对值
print(math.fabs(-10))   #输出： 10.0

#向上取整
print(math.ceil(3.7))   #输出： 4

#e的x次幂
print(math.exp(1))  #输出： 2.718281828459045

#向下取整
print(math.floor(3.7))   #输出： 3

#默认底数为e，求对数
print(math.log(math.e))   #输出： 1.0
print(math.log(100,10))   #输出： 2.0
print(math.log10(100))   #输出： 2.0

#求最大值
print(max(10, 20))   #输出： 20
print(max(list(range(10))))   #输出： 9(列表中最大值0-9)

#求最小值
print(min(10, 20))   #输出： 10

#求整数部分
print(math.modf(3.7))   #输出： (0.7, 3.0)

#求平方
print(math.pow(2,3))   #输出： 8.0

#求四舍五入
print(round(3.765,2))   #输出： 3.77

#求平方根
print(math.sqrt(16))   #输出： 4.0

1.4 随机数函数

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

import random

#choice()函数：从序列中随机选取一个元素
print(random.choice([1,2,3,4,5]))   #输出： 4

#randrange()函数：从指定范围内随机选取一个整数
print(random.randrange(1,10))   #输出： 7

#random()函数：生成一个随机浮点数 (0.0 <= x < 1.0)
print(random.random())   #输出： 0.17970987693706186

#shuffle()函数：将序列随机打乱
list1 = [1,2,3,4,5]
random.shuffle(list1)
print(list1)   #输出： [3, 2, 5, 1, 4]

#uniform(X,Y)函数：生成一个指定范围内的随机浮点数 (X <= x <= Y)
print(random.uniform(1,10))   #输出： 7.347833923738241

seed():

预先使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个。

import random
#seed()函数：设置随机数种子
print(random.random())   #输出： 0.10817837257088536
print(random.random())   #输出 0.44292243955793875


#使用相同种子后，两次生成的随机数相同
random.seed(10)
print(random.random())   #输出：0.5714025946899135
random.seed(10)
print(random.random())   #输出： 0.5714025946899135

1.5 三角函数

函数	描述
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ，返回90.0
radians(x)	将角度转换为弧度

#三角函数
import math

#计算sin值
print(math.sin(math.pi/2))   #输出： 1.0

#计算cos值
print(math.cos(math.pi/2))   #输出： 6.123233995736766e-17
# 根本原因是计算机时二进制，十进制浮点数变二进制时会有除不尽的情况，然后变回来必然出现舍位
# 所以需要确认精度，使用round()函数
print(round(math.cos(math.pi/2),15))     #输出： 0.0

#计算tan值
print(math.tan(math.pi/4))   #输出： 0.9999999999999999
# 同理，计算机的浮点数运算也会出现精度问题，所以需要确认精度
print(round(math.tan(math.pi/4),15))     #输出： 1.0


#degrees()将弧度转换为角度
print(math.degrees(math.pi/2))   #输出： 90.0



#反三角函数

#计算asin值
print(math.asin(1.0))   #输出： 1.5707963267948966 = (pi/2)
print(math.degrees(math.asin(1.0)))   #输出： 90.0

#计算acos值
print(math.acos(0.0))   #输出： 1.5707963267948966 = (pi/2)
print(math.degrees(math.acos(0.0)))   #输出： 90.0

#计算atan值
print(math.atan(1.0))   #输出： 0.7853981633974483 = (pi/4)
print(math.degrees(math.atan(1.0)))   #输出： 45.0

#atan2(x,y)函数：给定的 X 及 Y 坐标值的反正切值
print(math.atan2(1.0,1.0))   #输出： 0.7853981633974483 = (pi/4)
print(math.degrees(math.atan2(1.0,1.0)))   #输出： 45.0



#hypot()函数：计算斜边的长度(欧几里德范数)
print(math.hypot(3,4))   #输出： 5.0

#radians(）函数：将角度转换为弧度
print(math.radians(90))   #输出： 1.5707963267948966 = (pi/2)

1.6数学常量

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

#pi值
print(math.pi)   #输出： 3.141592653589793

#e值
print(math.e)   #输出： 2.718281828459045

2.Python3 字符串

不可修改

我们可以使用引号( ' 或 " )来创建字符串。

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

2.1Python 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

2.2Python 字符串更新

截取字符串的一部分并与其他字段拼接

str1 = "Hello World"
str2 = "Python is awesome"
str3 = str1[0:6]+str2[0:7]
print(str3)     # 输出: Hello Python

2.3 Python 转义字符

转义字符	描述	实例
\\	反斜杠符号	>>> print("\\") \
\'	单引号	>>> print('\'') '
\"	双引号	>>> print("\"") "
\b	退格(Backspace)	>>> print("Hello \b World!") Hello World!
\000	空	>>> print("\000") >>>
\n	换行	>>> print("\n") >>>
\v	纵向制表符	>>> print("Hello \v World!") Hello World! >>>
\t	横向制表符	>>> print("Hello \t World!") Hello World! >>>
\r	回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。	>>> print("Hello\rWorld!") World! >>> print('google runoob taobao\r123456') 123456 runoob taobao
\f	换页	>>> print("Hello \f World!") Hello World! >>>
\yyy	八进制数，y 代表 0~7 的字符，例如：\012 代表换行。	>>> print("\110\145\154\154\157\40\127\157\162\154\144\41") Hello World!
\xyy	十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行	>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21") Hello World!
\other	其它的字符以普通格式输出

print("\\")    # 输出: \
print('\'')    # 输出: '
print("\"")     # 输出: "

#\b 退格符
print("Hello\bWorld")    # 输出: HellWorld

#\000 空字符
print("\000")    # 输出: 空

#\n 换行符
print("Hello\nWorld")   # 输出: Hello
                        #      world

#\t 制表符
print("Hello\tWorld")   # 输出: Hello    World

#\r 回车符
print("Hello\rWorld")       # 输出: World
print("google runoob taobao\r123456")   # 输出:123456

#\yyyy 八进制转义字符
#八进制数，y 代表 0~7 的字符，例如：\012 代表换行。
print("\110\145\154\154\157")   # 输出: Hello

#\uxxxx 十六进制转义字符
#十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行
print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")   # 输出: Hello World!

2.4Python 字符串运算符

变量 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' )
%	格式字符串	请看下一节内容。

print(ord('A'))  # 输出: 65
print(hex(ord('A')))     # 输出: 0x41
print("\x41")    # 输出: A    十六进制ASCII码
print(r"\x41")   # 输出: \x41

2.5Python 字符串格式化

基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。（C 中 printf 函数类似的语法）

print("我叫%s, 今年%d岁!" % ("小明", 18))   # 输出: 我叫小明, 今年18岁!

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

格式化操作符辅助指令:

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

2.6 Python三引号

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

str="""可以包括换行
的字符串
TAB ( \t )。
也可以使用换行符 [ \n ]。"""
print(str)  

#输出:
# 可以包括换行
# 的字符串
# TAB ( 	 )。
# 也可以使用换行符 [ 
#  ]。

2.7 f-string

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

之前我们习惯用百分号 (%):

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

name = "小明"
print(f"我叫{name}")  # 输出: 我叫小明

print(f"{1+2}")  # 输出: 3

dict1={"name": "小明", "age": 18}
print(f"我叫{dict1['name']}")

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

x=1
print(f"{x+1}")     # 输出: 2
print(f"{x+1=}")     # 输出: x+1=2

2.8 Unicode 字符串

Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。

使用的语法是在字符串前面加上前缀 u。

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

2.9 Python 的字符串内建函数

2.9.1 capitalize() :

方法用于将字符串的第一个字符转换为大写，其他字符转换为小写。

str="abcDEF"
print(str.capitalize())  # 输出: Abcdef

2.9.2 center(width, fillchar):

方法用于指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

str="hello world"
print(str.center(20))  # 输出:       hello world      
print(str.center(20, "*"))  # 输出:****hello world*****

2.9.3 count(str, beg=0, end=len(string))

方法用于统计字符串中 str 出现的次数，如果 beg 和 end 指定范围，则统计范围内 str 出现的次数。

str="hello world"
print(str.count("l"))  # 输出: 3

2.9.4endswith(suffix, start, end)

方法用于检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。

str="hello world"
print(str.endswith("ld"))  # 输出: True

2.9.5 find(str, beg=0, end=len(string))

方法用于检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，发现则返回第一次出现的子串的索引位置，否则返回-1

str="hello world"
print(str.find("l"))  # 输出: 2
print(str.find('a'))    # 输出: -1

2.9.6 index(str, beg=0, end=len(string))

跟find()方法一样，只不过如果str不在字符串中会报一个异常。

str="hello world" 
print(str.index("l")) # 输出: 2 
print(str.index('a')) # 输出: ValueError: substring not found

2.9.7 isalnum()

如果字符串至少有一个字符，并且所有字符都是字母或数字，则返回 True；否则返回 False。

str="hello123"
print(str.isalnum())  # 输出: True

str="hello world"
print(str.isalnum())  # 输出: False

2.9.8 isalpha()

如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False

str="hello world"
print(str.isalpha())  # 输出: False(有空格)

str="hello哈哈哈"
print(str.isalpha())  # 输出: True

2.9.9 isdigit()

方法用于检查字符串是否只由数字组成

str="123456"
print(str.isdigit())  # 输出: True

2.9.10 join(seq)

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

s1='-'
s2='*'
seq=['a', 'b', 'c']
print(s1.join(seq))  # 输出: a-b-c
print(s2.join(seq))  # 输出: a*b*c

2.9.11 len(str)

返回字符串长度

str="hello world"
print(len(str))  # 输出: 11

2.9.12 lower()

转换字符串中所有大写字符为小写

str="HELLO WORLD"
print(str.lower())  # 输出: hello world

2.9.13 upper()

方法用于将字符串中的所有小写字母转换为大写。

str="hello world"
print(str.upper())  # 输出: HELLO WORLD

2.9.14 replace(old,new,max)

把将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。

str="hello world"
print(str.replace("l", "L",2))  # 输出: heLLo world

2.9.15 split(str="", num=string.count(str))

方法用于分割字符串，如果 num 有指定值，则分割 num +1个子字符串，如果 num 为负数，则分割所有子字符串。

str="hello world python is awesome"
print(str.split())  # 输出: ['hello', 'world', 'python', 'is', 'awesome']
print(str.split(" ",2))  # 输出: ['hello', 'world', 'python is awesome']
print(str.split(" ",-1))  # 输出: ['hello', 'world', 'python', 'is', 'awesome']

2.9.16 swapcase()

方法用于交换字符串中的大小写。

str="HeLLo WoRLD"
print(str.swapcase())  # 输出: hEllO wOrld

3.Python3 列表

Python 有 6 个序列的内置类型6 个序列的内置类型(列表、元组、字符串、Unicode字符串、buffer对象和 xrange 对象)，但最常见的是列表和元组。

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

3.1访问列表中的值

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

通过索引列表可以进行截取、组合等操作。

索引也可从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推(负号=倒数x第位)。

使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符，如下所示：

3.2更新列表

可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项

#列表的更新
list1 = [1, 2, 3, 4, 5]
list1[0]=0
print(list1)    # Output: [0, 2, 3, 4, 5]

#列表的添加
list1.append(6)
print(list1)     # Output: [0, 2, 3, 4, 5, 6]

3.3 删除列表元素

可以使用 del 语句来删除列表中的元素

#列表的删除
list1=[0, 2, 3, 4, 5, 6]
del list1[1]
print(list1)     # Output: [0, 3, 4, 5, 6]

3.4 Python列表脚本操作符

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

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	迭代

3.5 Python 列表截取与拼接

L=['Google', 'Runoob', 'Taobao']

ython 表达式	结果	描述
L[2]	'Taobao'	读取第三个元素
L[-2]	'Runoob'	从右侧开始读取倒数第二个元素: count from the right
L[1:]	['Runoob', 'Taobao']	输出从第二个元素开始后的所有元素

3.6嵌套列表

使用嵌套列表即在列表里创建其它列表(类似于二维数组)

a = [1, 2, 3]
b = [4, 5, 6]
c = [a, b]
print(c)    # Output: [[1, 2, 3], [4, 5, 6]]
print(c[0][1])    # Output: 2

3.7 列表比较

列表比较需要引入 operator 模块的 eq 方法

import operator
list1 = [1, 2, 3, 4, 5]
list2 = [1, 2, 3, 4, 5]
list3 = [1, 2, 3, 4, 6]
print(operator.eq(list1, list2))    # Output: True
print(operator.eq(list1, list3))    # Output: False

3.8 Python列表函数&方法

Python包含以下函数:

序号	函数
1	len(list) 列表元素个数
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表

list1 = [1, 2, 3, 4, 5]
print(len(list1))    # Output: 5
print(max(list1))    # Output: 5
print(min(list1))    # Output: 1
print(sum(list1))    # Output: 15
tuple1=(1,)
print(list(tuple1))    # Output: [1]

Python包含以下方法:

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort( key=None, reverse=False) 对原列表进行排序
10	list.clear() 清空列表
11	list.copy()

list1 = [1, 2, 3, 4, 5]

# 在列表末尾添加新的对象
list1.append(6)
print(list1)     # Output: [1, 2, 3, 4, 5, 6]

# 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.extend(list1, [7, 8, 9])
print(list1)         # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 将对象插入列表
list1.insert(2, 0)
print(list1)     # Output: [1, 2, 0, 3, 4, 5, 6, 7, 8, 9]

# 从列表中移除元素（默认最后一个元素），并且返回该元素的值
print(list1.pop())    # Output: 9
print(list1)         # Output: [1, 2, 0, 3, 4, 5, 6, 7, 8]

# 从列表中根据值移除元素（只移除第一次出现的值）
list1.remove(0)
print(list1)         # Output: [1, 2, 3, 4, 5, 6, 7, 8]

# 反转列表元素的顺序
list1.reverse()
print(list1)         # Output: [8, 7, 6, 5, 4, 3, 2, 1]

# 对原列表进行排序（默认升序）
list1.sort()
print(list1)         # Output: [1, 2, 3, 4, 5, 6, 7, 8]

# 对原列表进行排序（指定排序方式）
list1.sort(reverse=True)
print(list1)         # Output: [8, 7, 6, 5, 4, 3, 2, 1]

#从列表中找出某个值第一个匹配项的索引位置（如果没有匹配项，则引发ValueError）
list1.index(3)    # Output: 2
# list1.index(0)    # Output: ValueError: 0 is not in list

# 统计某个元素在列表中出现的次数
print(list1.count(3))    # Output: 1

# 复制列表（浅拷贝）
list2=list1.copy()
print(list2)    # Output: [8, 7, 6, 5, 4, 3, 2, 1]
print(list1 is list2)    # Output: False

#清空列表
list1.clear()
print(list1)    # Output: []

4.Python3 元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

4.1访问元组

tuple1 = (1, 2, 3, 4, 5)
print(tuple1) # Output: (1, 2, 3, 4, 5) 
print(tuple1[0])     # Output: 1 
print(tuple1[1:3])   # Output: (2, 3)

4.2 修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tuple1 = (1, 2, 3, 4, 5)
# tuple1[0] = 10
# print(tuple1) # Output: TypeError: 'tuple' object does not support item assignment
tuple2 = tuple1 + (6, 7, 8)
print(tuple2) # Output: (1, 2, 3, 4, 5, 6, 7, 8)

4.3 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tuple1 = (1, 2, 3, 4, 5)
del tuple1
#print(tuple1) # Output: NameError: name 'tuple1' is not defined

4.4元组运算符

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

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> c = a+b >>> c (1, 2, 3, 4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接，c 就是一个新的元组，它包含了 a 和 b 中的所有元素。
>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> a += b >>> a (1, 2, 3, 4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接，a 就变成了一个新的元组，它包含了 a 和 b 中的所有元素。
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x, end=" ")	1 2 3	迭代

4.5 元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素

tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')

表达式	结果	描述
tup[1]	'Runoob'	读取第二个元素
tup[-2]	'Weibo'	反向读取，读取倒数第二个元素
tup[1:]	('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')	截取元素，从第二个开始后的所有元素。
tup[1:4]	('Runoob', 'Taobao', 'Wiki')	截取元素，从第二个开始到第四个元素（索引为 3）。

4.6 元组内置函数

Python元组包含了以下内置函数(类似于列表)

序号	方法及描述	实例
1	len(tuple) 计算元组元素个数。	>>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>>
2	max(tuple) 返回元组中元素最大值。	>>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>>
3	min(tuple) 返回元组中元素最小值。	>>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>>
4	tuple(iterable) 将可迭代系列转换为元组。	>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu')

5.Python3 字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中

注意：

dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
键必须是唯一的，但值则不必
值可以取任何数据类型，但键必须是不可变的（元组，字符串，数字）

dict1 = {'name': 'John', 3: 30, 'city': 'New York'}
print(dict1) # Output: {'name': 'John', 3: 30, 'city': 'New York'}

5.1 创建空字典

使用大括号 { }或dict() 创建空字典

dict2={}
print(dict2) # Output: {}

dict3=dict()
print(dict3) # Output: {}

5.2访问字典里的值

dict1 = {'name': 'John', 3: 30, 'city': 'New York'}
print(dict1['name'])    # Output: John
print(dict1[3])         # Output: 30

5.3删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显式删除一个字典用del命令，如下实例：

dict1 = {'name': 'John', 3: 30, 'city': 'New York'}
del dict1['name']
print(dict1) # Output: {3: 30, 'city': 'New York'}

dict1.clear()
print(dict1) # Output: {}

del dict1    #执行 del 操作后字典不再存在
#print(dict1) # Output: NameError: name 'dict1' is not defined

字典键的特性:

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，

dict1={['name']: 'John', 3: 30, 'city': 'New York'}
print(dict1) # Output: TypeError: unhashable type: 'list'

5.4 字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述	实例
1	len(dict) 计算字典元素个数，即键的总数。	>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(tinydict) 3
2	str(dict) 输出字典，可以打印的字符串表示。	>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(tinydict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
3	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。	>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(tinydict) <class 'dict'>

序号

函数及描述

实例

len(dict)
计算字典元素个数，即键的总数。

>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> len(tinydict)
3

str(dict)
输出字典，可以打印的字符串表示。

>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(tinydict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"

type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。

>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> type(tinydict)
<class 'dict'>

dict1 = {'name': 'John', 3: 30, 'city': 'New York'}

print(len(dict1))   # Output: 3

print(str(dict1))           # Output: "{'name': 'John', 3: 30, 'city': 'New York'}"
print(type(str(dict1)))     # Output: <class 'str'>
print(type(dict1))          # Output: <class 'dict'>

Python字典包含了以下内置方法：

序号	函数及描述
1	dict.clear() 删除字典内所有元素
2	dict.copy() 返回一个字典的浅复制
3	dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	dict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict 如果键在字典dict里返回true，否则返回false
6	dict.items() 以列表返回一个视图对象
7	dict.keys() 返回一个视图对象
8	dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2) 把字典dict2的键/值对更新到dict里
10	dict.values() 返回一个视图对象
11	dict.pop(key[,default]) 删除字典 key（键）所对应的值，返回被删除的值。
12	dict.popitem() 返回并删除字典中的最后一对键和值。

dict1 = {'name': 'John', 3: 30, 'city': 'New York'}

#查看所有键
print(dict1.keys())    # Output: dict_keys(['name', 3, 'city'])

#查看所有值
print(dict1.values())  # Output: dict_values(['John', 30, 'New York'])

#查看所有键值对
print(dict1.items())   # Output: dict_items([('name', 'John'), (3, 30), ('city', 'New York')])

#修改字典元素
dict1.update({'age': 25})
print(dict1)           # Output: {'name': 'John', 3: 30, 'city': 'New York', 'age': 25}

#返回指定键的值，如果键不在字典中返回 default 设置的默认值
print(dict1.get('name'))   # Output: John
print(dict1.get('a',100))    # Output: 100

#判断键是否存在
print('name' in dict1)   # Output: True

#删除指定键的值，并返回该值
print(dict1.pop('name'))   # Output: John

#删除最后一对键值对，并返回该键值对
print(dict1.popitem())   # Output: ('age', 25)

#复制字典
dict2=dict1.copy()
print(dict2)   # Output: {3: 30, 'city': 'New York'}

#清空字典
dict1.clear()
print(dict1)   # Output: {}


#创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
seq=['name', 'age', 'city']
dict3=dict.fromkeys(seq, 10)
print(dict3)     # Output: {'name': 10, 'age': 10, 'city': 10}

dict3=dict.fromkeys(seq)
print(dict3)     # Output: {'name': None, 'age': None, 'city': None}

6.Python3 集合

集合（set）是一个无序的不重复元素序列。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔，或者也可以使用 set() 函数创建集合。

s = set()
print(s) #输出：set()

set1 = {1,2,3,4,5}
print(set1) #输出：{1, 2, 3, 4, 5}

set1=set([1,2,3,4,5])
print(set1) #输出：{1, 2, 3, 4, 5}

set2=set("hello")
print(set2) #输出：{'h', 'e', 'l', 'o'}

set3=set((1,2,3,4,5))
print(set3) #输出：{1, 2, 3, 4, 5}

set4=set({1,2,3,4,5})
print(set4) #输出：{1, 2, 3, 4, 5}

注意：

创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
set(seq),seq为列表，字符串，元组，集合，字典

6.1集合的基本操作

6.1.1、添加元素

set1={1,2,3,4,5}

# s.add( x ) 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
set1.add(6)
print(set1) #输出：{1, 2, 3, 4, 5, 6}

# s.update( x ) 且参数可以是列表，元组，字典等，
set1.update([7,8,9],[0])
print(set1) #输出：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

6.1.2、移除元素

set1={1,2,3,4,5}

# s.remove( x ) 从集合 s 中删除元素 x，如果元素不存在，则会引发 KeyError 异常。
set1.remove(3)
print(set1) #输出：{1, 2, 4, 5}

#s.discard( x ) 与 remove() 类似，但如果元素不存在，则不进行任何操作。
set1.discard(3)
print(set1) #输出：{1, 2, 4, 5}

#s.pop() 随机删除集合中的一个元素，并返回该元素。如果集合为空，则会引发 KeyError 异常。
print(set1.pop()) #输出：1
print(set1) #输出：{2, 4, 5}

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

6.1.3计算集合元素个数

set1={1,2,3,4,5}

# len( s ) 返回集合 s 的长度。
print(len(set1)) #输出：5

6.1.4、清空集合

set1={1,2,3,4,5}

# s.clear() 清空集合 s，删除所有元素。
set1.clear()
print(set1) #输出：set()

6.1.5、判断元素是否在集合中存在

set1={1,2,3,4,5}

# x in s 返回 True，如果集合 s 中存在元素 x，否则返回 False。
print(3 in set1) #输出：True

6.1.6集合内置方法完整列表

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

#两个集合的操作
set1={1,2,3,4,5}
set2={4,5,6,7,8}

# s1.intersection( s2 ) 返回两个集合的交集，即包含 s1 和 s2 中都存在的元素的集合。
print(set1.intersection(set2)) #输出：{4, 5}

# s1.union( s2 ) 返回两个集合的并集，即包含 s1 和 s2 中所有元素的集合。
print(set1.union(set2)) #输出：{1, 2, 3, 4, 5, 6, 7, 8}


# s1.difference( s2 ) 返回 s1 中存在而 s2 中不存在的元素的集合。
print(set1.difference(set2)) #输出：{1, 2, 3}

# s1.symmetric_difference( s2 ) 返回 s1 和 s2 中都存在，但不同时属于 s1 和 s2 的元素的集合。
print(set1.symmetric_difference(set2)) #输出：{1, 2, 3, 6, 7, 8}

# s1.issubset( s2 ) 返回 True，如果 s1 是 s2 的子集，否则返回 False。
print(set1.issubset(set2)) #输出：False

# s1.issuperset( s2 ) 返回 True，如果 s1 是 s2 的超集，否则返回 False。
print(set1.issuperset(set2)) #输出：False