8.1 Number数字

• 之前我们已经介绍了Nember类型的基本操作，下面介绍他们的操作函数（了解）

数学函数

随机数函数

三角函数

数学常量

8.2 String字符串

Python转义字符

　Python字符串运算符

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

#!/usr/bin/python3

a = "Hello"
b = "Python"

print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])

if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")

if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")

print (r'\n')
print (R'\n')

• 以上实例输出结果为：

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

Python字符串格式化:

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

#!/usr/bin/python3

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

# 以上实例输出结果：
# 我叫 小明 今年 10 岁!

*python字符串格式化符号:

• 格式化操作符辅助指令:

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

Python 的字符串内建函数:

8.3 List列表

• 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

• 列表操作实例：

#!/usr/bin/python3

# 定义 
list0 = [] # 创建一个空列表 或者  变量 = list()
list1 = ['Google', 'Python', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];

#输出
print ("list1[0]: ", list1[0])  # Google
print ("list2[1:5]: ", list2[1:5]) # [2, 3, 4, 5]

#更新其中的值
print ("第三个元素为 : ", list[2])    # 2000
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])  # 2001

#删除其中一个元素
del list[2]
print ("删除第三个元素 : ", list)  #  ['Google', 'Python', 2000]

列表的遍历操作:

1.使用for...in 遍历列表

    for 变量 in 列表：
        使用变量

2.使用while循环遍历列表

    i = 0
    while i<len(列表):
        使用列表中的元素(列表[i])
        i += 1

3.同等长度二级列表的遍历

    列表 = [[值1,值2],[值1,值2],....]

    for 变量1,变量2 in 列表:
        使用变量1和变量2

    注意：变量1取二级列表中的第一个值，变量2取第二个值
4.非同等长度的二级列表的遍历

    列表 = [[值1，值2]，[值1，值2,值3],[值]...]

    for 变量1 in 列表：
        for 变量2 in 变量1：
            使用变量2(变量2是二级列表中的每个值)

Python列表脚本操作符：

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

　Python列表截取与拼接：

• Python的列表截取与字符串操作类型，如下所示：L=['Google', 'Python', 'Taobao']

• 使用嵌套列表即在列表里创建其它列表，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

Python列表函数&方法:

• Python包含以下函数:

• Python包含以下方法:

8.4 Tuple元组

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

# 定义元组的方式：
tup0 = ()  #定义一个空元组 或者 变量 = tuple()
tup1 = ('Google', 'Python', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

# 输出元组：
print ("tup1[0]: ", tup1[0])       # tup1[0]:  Google
print ("tup2[1:5]: ", tup2[1:5])   # tup2[1:5]:  (2, 3, 4, 5)

# 注意下面这种定义不加逗号，类型为整型
tup4 = (50)
print(type(tup4))  # <class 'int'>

# 正确定义方式加上逗号，类型为元组
tup5 = (50,)
print(type(tup5))  # <class 'tuple'>

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

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

元组运算符：

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

　元组索引，截取：

• 因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素
• 如下所示：L=('Google', 'Python', 'Taobao')

元组内置函数:

• Python元组包含了以下内置函数:

list1= ['Google', 'Taobao', 'Runoob', 'Baidu']

tuple1=tuple(list1)

print(tuple1)

#('Google', 'Taobao', 'Runoob', 'Baidu')

8.5 set集合

• 集合（set）是一个无序不重复元素的序列。
• 基本功能是进行成员关系测试和删除重复元素。
• 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

# 集合的定义
set1 = set()  #定义一个空的集合
set2 = {1,2,3}

# 增加一个元素
set1.add(5)  

#增加多个：
set1.update([5,6,7,8])

#删除某个值
set1.remove(1)

#查：无法通过下标索引

#改：不可变类型无法修改元素

a={10,20,30}
b={20,50}
print(a - b)     # a和b的差集 

print(a | b)     # a和b的并集

print(a & b)     # a和b的交集

print(a ^ b)     # a和b中不同时存在的元素

集合的遍历:

1.普通序列的遍历

    for 变量 in 集合：
        使用变量

2.多级集合

    集合 = {（值,值..）,（值，值..）。。。}

    for 变量1，变量2 in 集合：

        使用变量1和变量2

集合的序列函数：

• len() 计算集合的长度

• max() 获取集合中的最大值

• min() 获取集合中的最小值

• set() 创建空集合或者将其他数据转换为集合

集合中的方法：

• add -- 增加集合元素

name = {'d', 's'}
name.add('d')
name
返回结果：{'d', 's'}
name.add('sd')
name
返回结果：{'sd', 'd', 's'}

• update--更新已有集合

name = {'sd', 'd', 's'}
name.update('df')
name
返回结果：{'sd', 'd', 'f', 's'}

• remove--移除指定集合元素

name = {'sd','d','s'}
name.remove('s')
返回结果：name
{'sd', 'd'}

• discard--移除元素

name = {'sd', 'd', 's'}
name.discard('s')
返回结果：name 
        {'sd', 'd'}

# remove移除非成员值会报错，discard移除非成员值，啥也不错！

• clear--清空集合元素

name = {'d', 's'}
name.clear()
name
返回结果：{}

• copy--浅拷贝

name = {'sd', 'd', 's'}
li = name.copy()
返回结果：li
        {'sd', 'd', 's'}

• difference -- 求差集

name.difference(li)
set()
>>> name.difference()
{'sd', 'd', 's'}

• union--并集，创建新的对象

name = {'sd', 'd', 's'}
li = {'s', 'd','h'}
name.union(li)
返回结果：{'h', 's', 'd', 'sd'}

• difference_update---删除当前set中的所有包含在 new set 里的元素

li = ('s', 'd')
name = {'sd', 'd', 's'}
name.difference_update(li)
name
返回结果：{'sd'}

• intersection--取交集,建立新的set集合

li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection(li)
返回结果：{'d', 's'}

• intersection_update--取交集,更新原来的set集合

li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection_update(li)
返回结果：{'d', 's'}

• isdisjoint--判断没有交集，返回True,否则,返回False

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.isdisjoint(li)

• issubset--判断是否是子集

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issubset(li)  #判断name是不是li的子集
返回结果：False
li.issubset(name)  #判断li是不是name的子集
返回结果：True

• issuperset--判断是否是父集

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issuperset(li)  #判断name是不是li的父集
返回结果：True
li.issuperset(name)  #判断li是不是name的父集
返回结果：False

• pop--移除集合元素

name = {'sd', 'd', 's'}
name.pop()
返回结果：'sd' #同一个集合，删除集合元素的顺序固定
se1 = {'a','s','sb'}
se1.pop()
返回结果：'sb'

• symmetric_difference--去两个集合的差集，建立新的set集合对象

name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference(li)
返回结果：{'sd'}

• symmetric_difference_update--去两个集合的差集，更新原来的集合对象

name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference_update(li)
返回结果：{'sd'}

8.6 Dictionary字典

• 字典是另一种可变容器模型，且可存储任意类型对象。
• 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

• 键必须是唯一的，但值则不必。

创建字典:

1.创建空字典
    变量 = {} 或者 变量 = dict()

2.创建多个元素的字典：
    方法1：
        变量 = {键:值,键:值....}

    方法2：
        变量 = dict({键:值,键:值....})

    方法3：
        变量 = dict(键=值,键=值...)
        注意：该方式键作为形参名使用不可以添加引号，必须符合变量规则

    方法4：
        变量 = dict([(键,值),(键,值)...])
        变量 = dict([[键,值],[键,值]...])
        变量 = dict(((键,值),(键,值)...))

    方法5：
        变量 = dict(zip((键，键...),(值,值...)))

字典的基本操作:

访问字典的元素：
    变量[键]

添加字典的元素
    变量[新键] = 值

修改字典元素
    变量[键] = 新值

删除字典元素
    del 变量[键]

• 案例：

#!/usr/bin/python3

# 定义一个字典
dict = {'Name': 'Python', 'Age': 17, 'Class': 'First'}

# 输出子典中的信息
print ("dict['Name']: ", dict['Name']) #Python
print ("dict['Age']: ", dict['Age'])   #17

# 输出错误信息：KeyError: 'Alice'
#print ("dict['Alice']: ", dict['Alice'])


# 修改和添加内容
dict['Age'] = 18;              # 更新 Age
dict['School'] = "云课堂"      # 添加信息

# 删除信息
del dict['Name'] # 删除键 'Name'一个元素值
dict.clear()     # 清空字典
del dict         # 删除字典

字典的遍历:

1.键的遍历
    for 变量i in 字典：
        使用i遍历所有的键，有键就可以通过变量访问其值

2.键值遍历
    for 变量i，变量j in 字典.items()：
        使用变量i遍历所有键，通过变量j遍历所有值

字典内涵/字典推导式:

1.普通的字典内涵
    变量= {key:value for key,value in 字典.items()}

2.带有判断条件的字典内涵
    变量= {key:value for key,value in 字典.items() if 条件表达式}

3，多个循环的字典内涵
    变量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items()}

4.带有判断条件的多个循环的字典内涵
    变量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items() if 条件表达式}

　字典内置函数&方法：

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

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