1.1Python的数据类型

• 字符串类型，简单少量的储存数据，并进行相应的操作。
• 数字类型，包括整数，浮点数，复数，数字主要用于运算。
• 布尔类型，布尔类型一共有两个值，一个是True，一个是False。
• 列表类型（list），大量有序数据。
• 元组类型（tuple），只读，不能更改。
• 字典类型（dict），大量数据，且是关联性比较强的数据。
• 集合类型（set）。

 　　使用type函数可以查看对象数据类型。

a = 12
# 使用type内置函数可以查看一个变量对应的数据类型
print(type(a))  # type(a).之后pycharm会自动给我们补全,<class 'int'>整数型

# 在python里，变量是没有数据类型的，我们所说变量的数据类型，其实是变量对应的值的数据类型
x = 12
print(type(x))  # <class 'int'>
x = 'hello'
print(type(x))  # <class 'str'>

1.2字符串

　　字符串是一种序列，可以使用索引，切片，加法，乘法等进行操作。但是字符串是不可变的，不能对它进行赋值操作。

　　可以使用一对单引号、上引号或者一对三个双引号、一对三个单引号来表示字符串，如果字符串里还有双引号，外面就可以使用单引号。

　　（1）使用单引号来表示字符串，如下：

strName='I am bo xiao yuan'
print(strName)

　　（2）使用双引号来表示字符串，如下：

strName="I am bo xiao yuan"
print(strName)

　　（3）使用三引号来表示字符串，此种方法可以在多行内显示字符串，三引号中可以使用单引号和双引号，如下：

strName = '''Hello,
I am bo
xiao
yuan.
what's your "name".
'''
print(strName)

　　说明：

• 在Python中，字符串之间可以使用+拼接成新的字符串。
• 字符串变量可以和整数使用*重复拼接相同的字符串。
• 数字和字符串之间不能进行其他运算，否则会报错。

first_name = "zhang"
last_name = "san"
num = "13"
print(first_name + last_name)
print(first_name * 20)
print(num + 1)  # 报错

　　字符串里的转义字符 \

# '  ==> 显示一个普通的单引号
# "  ==> 显示一个普通的双引号
# \n  ==> 显示一个换行
# \t  ==> 显示一个制表符
# \  ==> 显示一个普通的反斜线
x = 'I\' xiaoming'  # \表示的是转义字符，作用是对\后面的字符进行转义

在字符串的前面添加r，在Python里表示的是原生字符串。

x = r'hello \teacher'
print(x)  # hello \teacher

1.2.1字符串的下标

　　下标又称为索引，表示第几个数据。

• 可迭代对象：str，list，tuple，dict，set，range都可以遍历。
• str，list，tuple都可以通过下标来获取或者操作数据。
• 在计算机里，下标都是从0开始的。
• 字符串是不可变的数据类型，对于字符串的任何操作，都不会改变原有的字符串。

1.2.2字符串的切片

切片方法适用于字符串，列表，元组。

• 切片使用索引值来限定范围，从一个大的字符串中切除小的字符串。
• 列表和元组都是有序的集合，都能够通过索引值获取对应的数据。

字符串[开始索引：结束索引：步长]

• 指定的区间属于左闭右开型，从起始位开始，到结束为的前一位结束。
• 开始索引数字可以省略，冒号不能省略，到结尾结束，结束索引数字可以省略，冒号不能省略。
• 步长默认为1，如果连续切片，数字和冒号都可以省略。

a = "0123456789"
print(a[:])  # 0123456789
print(a[3:])  # 3456789
print(a[:3])  # 012
print(a[3:5])  # 34
print(a[0:6:2])  # 024
print(a[2::-1])  # 210
print(a[::-1])  # 9876543210  逆序

1.2.3字符串常见方法

　　字符串的常用操作方法，不会对原字符串进行任何操作，都是产生一个新的字符串。

1.2.3.1find

　　mystr.find(str, start=0, end=len(mystr))，检查str是否包含在mystr中，如果是则返回开始的索引值，否则返回-1。

mystr = "hello world boxiaoyuan and bodayuan"
print(mystr.find("boxiaoyuan"))  # 12
print(mystr.find("boxiaoyuan", 0, 10))  # -1

1.2.3.2index

　　mystr.index(str, start=0, end=len(mystr))，跟find()方法一样，只不过如果str不在mystr中会报异常。

mystr = "hello world boxiaoyuan and bodayuan"
print(mystr.index("boxiaoyuan"))  # 12
print(mystr.index("boxiaoyuan", 0, 10))  # -1

12
Traceback (most recent call last):
  File "E:/Python/01_Python基础/demo05.py", line 5, in <module>
    print(mystr.index("boxiaoyuan", 0, 10))  # -1
ValueError: substring not found

1.2.3.3count

　　mystr.count(str, start=0, end=len(mystr))，返回str在start和end之间在mystr里面出现的次数。

mystr = "hello world boxiaoyuan and bodayuan"
print(mystr.count("yuan"))  # 2
print(mystr.count("yuan", 0, 10))  # 0

1.2.3.4replace

　　mystr.replace(str1, str2,  mystr.count(str1))，把mystr 中的str1 替换成str2,如果count 指定，则替换不超过count 次。

mystr = "hello world boxiaoyuan and bodayuan"
replaced_str = mystr.replace("bo", "zhang")
print(replaced_str)  # hello world zhangxiaoyuan and zhangdayuan
replaced_str = mystr.replace("bo", "zhang", 1)
print(replaced_str)  # hello world zhangxiaoyuan and bodayuan

1.2.3.5split

　　mystr.split(str=" ", maxsplit)，以str为分隔符切片mystr，如果maxsplit有指定值，则仅分隔maxsplit个子字符串。

mystr = "hello world boxiaoyuan and bodayuan"
split_str = mystr.split(" ", 2)
print(split_str)  # ['hello', 'world', 'boxiaoyuan and bodayuan']

1.2.3.6capitalize

　　mystr.capitalize()，把字符串的第一个字符大写。

my_str = "hello world boxiaoyuan and bodayuan"
cap_str = my_str.capitalize()
print(cap_str)  # Hello world boxiaoyuan and bodayuan

1.2.3.7title

　　my_str.title()，把字符串的每个单词首字母大写。

my_str = "hello world boxiaoyuan and bodayuan"
title_str = my_str.title()
print(title_str)  # Hello World Boxiaoyuan And Bodayuan

1.2.3.8startswith

　　mystr.startswith(prefix, start=None, end=None),检查字符串是否是以prefix开头, 是则返回True，否则返回False。

my_str = "hello world boxiaoyuan and bodayuan"
print(my_str.startswith("hello"))  # True
print(my_str.startswith("world", 6,20))  # True

1.2.3.9endswith

　　mystr.endswith(suffix, start=None, end=None)，检查字符串是否是以prefix结尾, 是则返回True，否则返回False

my_str = "hello world boxiaoyuan and bodayuan"
print(my_str.endswith("bodayuan"))  # True
print(my_str.endswith("world", 0, 11))  # True

1.2.3.10lower

　　mystr.lower()，转换mystr 中的字母为小写。

my_str = "hello world boxiaoyuan and bodayuan"
title_str = my_str.title()
print(title_str)  # Hello World Boxiaoyuan And Bodayuan
lower_str = title_str.lower()
print(lower_str)  # hello world boxiaoyuan and bodayuan

1.2.3.11upper

　　mystr.upper()，转换mystr 中的字母为大写。

my_str = "hello world boxiaoyuan and bodayuan"
upper_str = my_str.upper()
print(upper_str)  # HELLO WORLD BOXIAOYUAN AND BODAYUAN

1.2.3.12ljust

　　mystr.ljust(width)，返回一个原字符串左对齐,并使用空格填充至长度width的新字符串。

my_str = "hello"
ljust_str = my_str.ljust(10)
print(ljust_str)  # "hello     "

1.2.3.13rjust

　　mystr.rjust(width)，返回一个原字符串右对齐,并使用空格填充至长度width的新字符串。

my_str = "hello"
rjust_str = my_str.rjust(10)
print(rjust_str)  # "     hello"

1.2.3.14center

　　mystr.center(width)，返回一个原字符串居中,并使用空格填充至长度width的新字符串。

my_str = "hello"
center_str = my_str.center(10)
print(center_str)  # "  hello   "
my_str = "hello"
center_str = my_str.center(10, "*")
print(center_str)  # "  hello   "# **hello***

1.2.3.15lstrip

　　mystr.lstrip()，删除mystr 左边的空白字符。

my_str = "   hello"
lstrip_str = my_str.lstrip()
print(lstrip_str)  # "hello"

1.2.3.16rstrip

　　mystr.rstrip()，删除mystr 右边的空白字符。

my_str = "hello   "
rstrip_str = my_str.rstrip()
print(rstrip_str)  # "hello"

1.2.3.17strip

　　mystr.strip()，删除mystr 两边的空白字符。

my_str = "   hello   "
strip_str = my_str.strip()
print(strip_str)  # "hello"

　　也可以去除指定的字符。

s4 = 'rre博r小w园qsd'
s5 = s4.strip('qrswed')
print(s5)  # 博r小w园

1.2.3.18rfind

　　mystr.rfind(str, start=0,end=len(mystr))，类似于find()函数，不过是从右边开始查找。

my_str = "hello world boxiaoyuan and bodayuan"
print(my_str.rfind("boda"))  # 27

1.2.3.19rindex

　　mystr.rindex( str, start=0,end=len(mystr))，类似于index()，不过是从右边开始。

my_str = "hello world boxiaoyuan and bodayuan"
print(my_str.rindex("boda"))  # 27
print(my_str.rindex("ceshi"))  #  报异常

1.2.3.20partition

　　mystr.partition(str)，把mystr以str分割成三部分,str前，str和str后。

my_str = "hello world boxiaoyuan and bodayuan"
par_str = my_str.partition("bo")
print(par_str)  # ('hello world ', 'bo', 'xiaoyuan and bodayuan')

1.2.3.21rpartition

　　mystr.rpartition(str)，类似于partition()函数,不过是从右边开始。

my_str = "hello world boxiaoyuan and bodayuan"
par_str = my_str.rpartition("bo")
print(par_str)  # ('hello world boxiaoyuan and ', 'bo', 'dayuan')

1.2.3.22splitlines

　　mystr.splitlines()，按照行分隔，返回一个包含各行作为元素的列表。

my_str = """hello world
boxiaoyuan
and 
bodayuan
"""
print(my_str.splitlines())  # ['hello world', 'boxiaoyuan', 'and ', 'bodayuan']

1.2.3.23isalpha

　　mystr.isalpha()，如果mystr所有字符都是字母则返回True,否则返回False。

my_str = "abcd"
print(my_str.isalpha())  # True
my_str = "1234"
print(my_str.isalpha())  # False

1.2.3.24isdecimal

　　mystr.isdecimal()，如果mystr只由十进制组成，则返回True，否则返回False。

S = "runoob2016"
print(S.isdecimal())  # False

S = "23443434"
print(S.isdecimal())  # True

1.2.3.25isalnum

　　mystr.isalnum()，如果mystr所有字符都是字母或数字，则返回True，否则返回False。

my_str = "abcd"
print(my_str.isalnum())  # True
my_str = "1234"
print(my_str.isalnum())  # True
my_str = "abcd1234"
print(my_str.isalnum())  # True

1.2.3.26isspace

　　mystr.isspace()，如果mystr 中只包含空格，则返回True，否则返回False。

my_str = "abcd"
print(my_str.isspace())  # False
my_str = "   "
print(my_str.isspace())  # True

1.2.3.27join

　　mystr.join(str)，str中每个字符后面插入mystr,构造出一个新的字符串。

name = ["my", "english", "name", "is", "zhangsan"]
my_str = " "
new_name = my_str.join(name)
print(new_name)  # my english name is zhangsan

1.2.3.28swapcase

　　对字符串的大小写字母进行转换。

S = "This Is String Example....WOW!!!"
print (S.swapcase())  # tHIS iS sTRING eXAMPLE....wow!!!

1.2.4格式化打印字符串

1.2.4.1百分号格式化

 print ('我叫%s, 身高%scm'  % (name,height))   ** 传入的值为元组，依次填充

• %s ：占位符 str()  
• %d-：十进制 整数
• %x ： 十六进制
• %f  ：浮点型

指定长度：

• %5d     右对齐，不足左边补空格
• %-5d    - 代表左对齐，不足右边默认补空格
• %05d    右对齐，不足左边补0

浮点数：

• %f   默认是输出6位有效数据， 会进行四舍五入
• 指定小数点位数的输出 %.2f---保留小数点后2位
• %4.8f'    4代表整个浮点数的长度，包括小数，不足4位空格补足，可以用%04.8使用0补足空格

1.2.4.2format

　　format( *args, **kwargs)，格式化字符串。

• 1、通过字符串中的花括号{}来识别替换字段，从而完成字符串的格式化。
• 2、替换的内容包括：字段名、格式说明符三部分，形式一般为：{字段名：格式说明符}。

1.省略不写：花括号内省略不写，代表传递位置参数

• 替换字段形式{}
• 注意事项：花括号个数少于等于后面的位置参数的个数，多了会报错

# 用{}代表占位符，直接位置传参
 
print('我是{}，喜欢{}！'.format('张三','编程'))
# 我是张三，喜欢编程！
 
# {}数量必须少于后面位置参数数量，不然报错
print('我是{}，喜欢{}，不喜欢{}。'.format('张三','编程','美女','男人'))
 
print('我是{}，喜欢{}，不喜欢{}。'.format('张三','编程'))
# 报错误：IndexError: tuple index out of range

2.数字形式传参：通过位置索引值传递位置参数

• 索引从整数0开始
• 索引可以重复引用，输出
• 索引可以不按照传输顺序
• 索引数值就是后面位置参数放入一个元组来取值的过程，所以索引数值不能大于元组里面位置参数的最大索引值，否则报错

print('我身高{0}，年龄正好{1}，{2}长。'.format('180cm',18,'15cm'))
# 我身高180cm，年龄正好18，15cm长。
 
print('我身高{0}，{0}不多不少，年龄正好{1}。'.format('180cm',18))
# 我身高180cm，180cm不多不少，年龄正好18。
 
print('我身高{1}，{1}不多不少，年龄正好{0}。'.format('180cm',18))
# 我身高18，18不多不少，年龄正好180cm。
 
print('我身高{0}，年龄正好{1}，{2}长。'.format('180cm',18))
# IndexError: tuple index out of range
# 索引值大于format()内的最大位置数

3.变量名{关键字} 传递输出参数

• 特别注意，关键字的变量名在参数那里无需加引号，同时{}里面引用直接填变量名。

print('我的名字叫{name}，我其实是一名{career}！'.format(name='张三',career='程序员'))
# 我的名字叫张三，我其实是一名程序员！
 
print('我叫{name2}，又名{name1}，我弟弟叫{name3}！'.format(name1='张小三',name2='张三',name3='李四'))
# 我叫张三，又名张小三，我弟弟叫李四！

4.{}、{0}、{name}混合使用

• 位置参数在前，关键字参数在后
• 但注意！！{}不能与数字形式{0}同时使用，但可以和关键字参数同时使用

print('吹个{0}，吹个{2}，吹大了{1}，玩{ball}!'.format('球','气球','大气球',ball='球球'))
# 吹个球，吹个大气球，吹大了气球，玩球球!
 
print('吹个{}，吹大了{}，玩{ball}!'.format('球','气球','大气球',ball='球球'))
# 吹个球，吹大了气球，玩球球!
 
print('吹个{0}，吹大了{1}，玩{ball}!'.format('球','气球','大气球',ball='球球'))
# 吹个球，吹大了气球，玩球球!
 
print('吹个{0}，吹大了{}，玩{ball}!'.format('球','气球','大气球',ball='球球'))
#报错 ValueError: cannot switch from manual field specification to automatic field numbering

5.使用元组和字典传参：

• str.format()方法可以使用*元组和**字典的形式传参，可以混用。
• 方法相当于*args和**kwargs打散传参，元组按位置或索引传参，字典按关键字传参（键）。
• 位置参数、关键字参数、元组、*字典也可以同时使用，但要注意位置参数在关键字参数前，元组要在*字典前。
• 使用元组或者字典格式化输出的形式就是相当于将元组和字典打散，变成位置参数和关键字参数，然后按照前面的方法传参就行。

print('我喜欢{}，喜欢{}，同时也喜欢{}！'.format(*('篮球','足球','观球')))
# 我喜欢篮球，喜欢足球，同时也喜欢观球！
print('我喜欢{0}，喜欢{1}，同时也喜欢{2}！'.format(*('篮球','足球','观球')))
# 我喜欢篮球，喜欢足球，同时也喜欢观球！
 
# 字典
print('{name}的女朋友是{gf}，我也喜欢{gf}!'.format(**{'name':'钢铁侠','gf':'小辣椒'}))
# 钢铁侠的女朋友是小辣椒，我也喜欢小辣椒!
 
# 元组+字典
print('我是{beauty}的{1}，我们都喜欢{0}，请大家{2}！'\
      .format(*('球类','球迷','文明观球'),**{'beauty':'斯嘉丽约翰逊',}))
# 我是斯嘉丽约翰逊的球迷，我们都喜欢球类，请大家文明观球！
 
# 位置参数、关键字参数、元组、字典混合使用：
print('我是{name}，好像{age}了 ^_^，在{0}，等你哦！\n喜欢{1}、{2}和{3}。\n我的唯一 >>>:{only_one}\n我的小可爱 >>>: {love}!'\
      .format('武汉',name='苏光体',age=18,*('读书','健身','折腾数码'),**{'only_one':'杨林','love':'苏弘睿'}))
# 我是苏光体，好像18了 ^_^，在武汉，等你哦！
# 喜欢读书、健身和折腾数码。
# 我的唯一 >>>:杨林
# 我的小可爱 >>>: 苏弘睿!

6.对象参数格式化输出传值

• format还可以使用对象属性传参，这个对象可以是实例化的对象，也可以是列表、字典

# 对象属性传参
# 实例化对象：
class Dog:
    def __init__(self,name,speak):
        self.name=name
        self.speak=speak
 
dog1=Dog('小黄','汪汪汪')
print('我的{0.name}会{0.speak}。'.format(dog1))
# 我的小黄会汪汪汪。
 
# 文件对象
with open('text.txt','wb') as f:
    print('打开的文件名为：{0.name}'.format(f))
# 打开的文件名为：text.txt
 
# 列表、字典对象
print('I have a {0[0]} , I have a {0[1]} .'.format(['Apple','Pen']))
print('我叫{0[name]},{0[id]}就是我！'.format({'name':'阿星','id':'9527'}))
print('{1[name]}变成了{0[0]},藏进了{1[role]}的裤裆里，为什么不变{0[1]}而是{0[0]}呢？'.format(['葡萄','苹果'],{'name':'菩提老祖','role':'至尊宝'}))
# I have a Apple , I have a Pen .
# 我叫阿星,9527就是我！
# 菩提老祖变成了葡萄,藏进了至尊宝的裤裆里，为什么不变苹果而是葡萄呢？

7.格式说明符：规定传入参数字符的格式

# 格式限定符
# 它有着丰富的的“格式限定符”（语法是{}中带:号），比如：
# 填充与对齐
# 填充常跟对齐一起使用
# ^、<、>分别是居中、左对齐、右对齐，后面带宽度
# :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
print('{:>8}'.format('zhang'))  #     zhang 前面三个空格
print('{:0>8}'.format('zhang'))  # 000zhang
print('{:a<8}'.format('zhang'))  # zhangaaa
print('{:p^10}'.format('zhang'))  # ppzhangppp
# 精度与类型f
# 精度常跟类型f一起使用
print('{:.2f}'.format(31.31412))  # 31.31
# 其他类型
# 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制
print('{:b}'.format(15))  # 1111
print('{:d}'.format(15))  # 15
print('{:o}'.format(15))  # 17
print('{:x}'.format(15))  # f
# 用逗号还能用来做金额的千位分隔符
print('{:,}'.format(123456789))  # 123,456,789

1.2.4.3格式化 f''

 python3.6 后的版本支持：

f'名字是：{name}，年龄是：{age}'  

1.3数字

1.3.1 整数

a = 15
print(a)  # 15
b = a / 3
print(b)  # 5.0
c = a // 4
print(c)  # 3

　　注：由以上输出结果可以看出，整数除法的结果为浮点数（即使除得尽），如果只想要获取浮点数的整数部分可以使用地板除(//)，整数的地板除为整数（即使除得尽） 。因为数字主要是用于计算，所以针对于数字可以使用的方法除了那些运算之外，没有什么经常会用的方法，python给咱们提供了一种方法：bit_length()就是帮助快速的计算整数在内存中占用的二进制码的长度。

num = 10
print(num.bit_length())  # 当十进制用二进制表示时，最少使用的位数
# 运行结果: 4

1.3.2浮点数

a = 15
print(a)  # 15
b = a / 3.0
print(b)  # 5.0
c = a // 4.0
print(c)  # 3.0

　　注：由以上输出结果可以看出，浮点数除法的结果为浮点数，地板除的结果依然是浮点数。

1.3.3复数

com = 1 + 2j
print(com)  # (1+2j)
print(type(com))  # <class 'complex'>

1.3.4类型转换

1.3.4.1int(x)将x转换为整数

　　全部由数字组成的字符串才可以转化成数字

print('int()方法默认情况下：', int())  # int()方法默认情况下： 0
print('字符类型转换为int：', int('111'))  # 字符类型转换为int：111
print('浮点类型转换为int：', int(112.23))  # 浮点类型转换为int： 112

x = '1a2c'
y = int(x, 16)  # 把字符串1a2c当做十六进制转换为整数
print(y)  # 6700 打印一个数字，默认使用十进制输出

1.3.4.2float(x)将x转换为浮点数

print('float()方法默认情况下：', float())  # 0.0
print('str类型转换为float：', float('111'))  # 111.0
print('int类型型转换为float：', float(112))  # 112.0

1.3.4.3complex(x,y)创建复数

print('创建一个复数：',complex(12, 13))  # 创建一个复数： (12+13j)
print('创建一个复数：',complex(13))  # 创建一个复数： (13+0j)

1.3.4.4str(x)将x转换为字符串

print('str()方法默认情况下：', str())  #
print('int类型转换为str：', str(12))  # 12
print('float类型型转换为str：', str(112.3))  # 112.3

1.3.4.5bool(x)将x转换为布尔值

使用bool内置类可以将其他数据类型转换为布尔值

print(bool(12))  # True
print(bool(-1))  # True

　　在python中，只有空字符串'',""，数字0，空字典{}，空列表[]，空元祖()，空集合set()和空数据None会被转换称为False，其他的都会被转换成为True。

　　在计算机里，True和False其实就是使用1和0来保存的。

print(True + 1)  # 2
print(False + 1)  # 1

1.3.4.6tuple(x)将可迭代对象 (字符串，列表，字典) 转换为元组

lists = ['11', '22', '33', '44']
print(tuple(lists))  # ('11', '22', '33', '44')

1.3.4.7list(x)将可迭代对象(字符串，元组，字典)转换为列表

lists = ['11', '22', '33', '44']
tuples = ('11', '22', '33', '44')
strs = 'bo xiao yuan'
dicts = {'11', '22', '33', '44'}
print(list(lists))  # ['11', '22', '33', '44']
print(list(tuples))  # ['11', '22', '33', '44']
print(list(strs))  # ['b', 'o', ' ', 'x', 'i', 'a', 'o', ' ', 'y', 'u', 'a', 'n']
print(list(dicts))  # ['44', '11', '22', '33']

　　注：列表和元组很相似，列表使用方括号，元组使用括号，元组的值不能修改。

1.3.5进制转换

1.3.5.1hex(x)将一个整数转换为它的十六进制

s=12
print(hex(s))  # 0xc

1.3.5.2oct(x)将一个整数转换为他的八进制

s=12
print(oct(s))  # 0o14

1.3.5.3bin()将一个整数转换为它的二进制

s = 12
print(bin(s))  # 0b1100

1.3.6数学运算

import math
import operator
print(abs(-12))  # 12，返回数字的绝对值
print(math.ceil(12.6))  # 13，返回数字的上入整数
# 比较两个值
print(operator.le(2, 2))  # True，2小于等于2
print(math.exp(2))  # 7.38905609893065，返回e的2次方
print(math.fabs(-12))  # 12.0，返回-12的绝对值
print(math.floor(3.9))  # 3，返回数字的下舍整数
print(math.log(100, 10))  # 返回2.0
print(math.sqrt(2))  # 1.4142135623730951，返回数字的平方根
print(max(2, 4))  # 4
print(math.pow(2, 3))  # 8.0，返回2的3次幂
print(round(2.36, 1))  # 2.4，返回四舍五入值

1.4列表 list

1.4.1列表概述

• 列表中的数据按顺序排列。
• 列表有正序和倒叙两种索引。
• 列表可存储任意类型数据，且允许重复。

1.4.2初始列表

#变量名=[元素1,元素2,....]
list = ['a' , 'b' , 'c' , 'd' , 1 , 2 , 3 , 4]
print(list)
list1 = []
print(list1)

1.4.3列表的取值

list = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']
print(list)
# 取值的语法: 变量 = 列表变量[索引值]
zhaoliu = list[3]
print(zhaoliu)
zhaoliu = list[-3]
print(zhaoliu)

# 范围取值: 列表变量 = 原列表变量[起始索引:结束索引]
# 在Python中列表范围取值是"左闭右开"
list1 = list[1: 4]
print(list1)
print(list1[-1])

# 列表的index函数用于获取指定元素的索引值
zhaoliu_index = list.index('赵六')
print(zhaoliu_index)

1.4.4列表的遍历

1.4.4.1使用for循环

name_list = ["zhangsan", "lisi", "wangwu"]
for name in name_list:
    print(name)

1.4.4.2使用while循环

name_list = ["zhangsan", "lisi", "wangwu"]
i = 0
name_len = len(name_list)
while i < name_len:
    print(name_list[i])
    i += 1

1.4.5列表的排序与排序

#列表的反转与排序
persons = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']
persons.reverse() #reverse方法用于反转列表
print(persons)

numbers = [28,32,14,12,53,42]
numbers.sort(reverse=True) #sort()用于排序,reverse=True代表降序排列
print(numbers)

　　内置函数sorted，不会改变原有的列表数据，会生成一个新的有序数据

num = [6, 5, 3, 1, 2]
x = sorted(num)
print(x)  # [1, 2, 3, 5, 6]

1.4.6列表的新增

persons = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']
# 列表的追加
persons.append("杨九")
print(persons)
# 列表的插入
persons.insert(2 , '刘二')
print(persons)
persons.insert(len(persons) , '候大')
print(persons)

1.4.7列表的修改

# 列表的更新
persons[2] = '宋二'
print(persons)
# 列表范围取值是"左闭右开"
persons[3:5] = ['王五','李四']
print(persons)

1.4.8列表的删除

# 列表的删除操作
# 按元素内容删除，如果数据不在列表中，会报错
persons.remove('宋二')
print(persons)
# 按索引值删除元素，并且返回这个数据
persons.pop(4)
print(persons)
# 范围删除
persons[4:7] = []
print(persons)

1.4.9列表的查询

tanks = ['程咬金', '盾山', '程咬金']
print(tanks.index('盾山'))  # 1，如果元素不存在，会报错
print(tanks.count('程咬金'))  # 2

1.4.10列表的其他常用方法

1.4.10.1统计出现次数

# 其他常用方法
persons = ['张三', '赵六', '李四', '王五', '赵六', '钱七', '孙八']

#统计出现次数
cnt = persons.count('赵六')
print(cnt)

1.4.10.2追加操作

# 追加操作
# append将整个列表追加到末尾,extend则是将列表中的元素追加到原始列表末尾
persons = ['张三', '赵六']
persons.append(['杨九', '吴十'])  # ['张三', '赵六', ['杨九', '吴十']]
print(persons)
persons.extend(['杨九', '吴十'])  # ['张三', '赵六', ['杨九', '吴十'], '杨九', '吴十']
print(persons)

1.4.10.3in操作符

　　in(成员运算符) 运算符用于判断数据是否在列表中存在,存在返回True,不存在返回False。

persons.remove('张三')
b = '张三' in persons
print(b)

1.4.10.4复制列表

　　copy 函数用于复制列表，这个新列表和原有的里列表内容一样，但是指向不同的内存空间。

persons1 = persons.copy()
persons2 = persons
print(persons1)
#is 身份运算符用于判断两个变量是否指向同一块内存
print(persons1 is persons)
print(persons2 is persons)

1.4.10.5清空列表

#clear 用于清空列表
persons.clear()
print(persons)

1.4.11列表推导式

multiples = [i for i in range(30) if i % 3 is 0]
print(multiples)  # [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

　　列表推导式在有些情况下超赞，特别是当你需要使用for循环来生成一个新列表。例如：

squared = []
for x in range(10):
    squared.append(x**2)

　　你可以使用列表推导式来简化它，就像这样：

squared = [x**2 for x in range(10)]

1.4.12补充：交换两个变量的值

a = 12
b = 15
a, b = b, a
print(a, b)  # 15 12

1.4.13项目中列表的使用场景

# 多维列表(嵌套列表)
# [[姓名,年龄,工资],[姓名,年龄,工资],[姓名,年龄,工资],[姓名,年龄,工资]]
# 字符串:"姓名,年龄,工资"例如: "张三,30,2000"
# str = "张三,30,2000"
# l = str.split(",")
# print(l)
emp_list = []
while True:
    info = input("请输入员工信息:")
    if info == "":
        print("程序结束")
        break
    info_list = info.split(",")
    if len(info_list) != 3:
        print("输入格式不正确,请重新输入")
        continue
    emp_list.append(info_list)
    # print(emp_list)

    for emp in emp_list:
        print("{n},年龄:{a},工资:{s}".format(n=emp[0],a=emp[1],s=emp[2]))

　　列表的应用场景：在实际开发中，列表存储相同类型的数据，通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作。

1.5元组 tuple

　　对于容器型数据类型list，无论谁都可以对其增删改查，那么有一些重要的数据放在list中是不安全的，所以需要一种容器类的数据类型存放重要的数据，创建之初只能查看而不能增删改，这种数据类型就是元组。元组和列表相似，元组使用括号，元组的值一旦初始化便不能进行修改。

1.5.1初始元组

t = ('a', 'b', 'c', 1, 2, 3)
print(t)
print(type(t))

　　注：定义只含有一个元素的元组时，需要在元素后面添加一个逗号，tuples=(1,)，以免产生歧义。

1.5.2获取数据

　　获取数据,在获取数据时与列表完全相同

tuples = ('zhangsan', 'lisi', 'bo xiao yuan', 'zhaolaowu', 'wanglaoliu', 'yanlaoqi')
print(tuples[0])  # zhangsan，打印第0位置的值
print(tuples[-1])  # yanlaoqi，打印最后一个元素的值
print(tuples[-2:])  # ('wanglaoliu', 'yanlaoqi')，打印最后两个元素的值
print(tuples[:-2])  # ('zhangsan', 'lisi', 'bo xiao yuan', 'zhaolaowu')，打印第0索引位置的值到倒数第2个元素的值（不包括倒数第2个元素的值）
print(tuples[:])  # ('zhangsan', 'lisi', 'bo xiao yuan', 'zhaolaowu', 'wanglaoliu', 'yanlaoqi')，打印所有的值

1.5.3修改元组

# 元组在创建后内容不可变
# t[0] = 2
# 写入数据的函数同样不被支持
# t.insert('f')

　　元组中的元组的值虽然不允许修改，但是可以把元组进行连接组合：

tu1 = ('huashan','songshan')
tu2 = ('taishan',)
tu3 = tu1 + tu2
print(tu3)  # ('huashan', 'songshan', 'taishan')

　　注：如果元组内持有列表,那么列表的内容是允许被修改的。

tuples = (1, 2, 3, [4, 5, 6])
tuples[3][1] = 11
print(tuples)  # (1, 2, 3, [4, 11, 6])

1.5.4删除元组

　　元组中的元素虽然不可以进行修改，但是可以把整个元组删除掉：

tuples = ('zhangsan', 'lisi', 'bo xiao yuan', 'zhaolaowu', 'wanglaoliu', 'yanlaoqi')
del tuples
print(tuples)  # NameError: name 'tuples' is not defined

1.5.5循环遍历

　　在Python中，可以使用for循环遍历所有非数字类型的变量：列表、元组、字典以及字符串。但是在实际开发中，除非能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多。

names = ('zhangsan', 'lisi', 'bo xiao yuan', 'zhaolaowu', 'wanglaoliu', 'yanlaoqi')
for name in names:
    print(name)

1.5.6元组的应用场景

　　在实际开发中，元组的应用场景为：

1. 函数的参数和返回值，一个函数可以接收任意多个参数，或者一次返回多个数据。
2. 格式字符串，格式化字符串后面的()本质上就是一个元组。
3. 重要数据，用户名，密码，个人信息，不想让别人改动的一些数据，存在元组中。
4. 元组的拆包。分别赋值。

a, b = (1, 2) # 多一个少一个都不行
print(a,b)
c = (1,2)
a,b = c
print(a,b)

info_tuple = (18, 175, 75.50)
# 格式化字符串后面的'()'本质上就是元组
print("小明的年龄%s,身高%s,体重%.2f" % info_tuple)  # 小明的年龄18,身高175,体重75.50

1.5.7元组和列表之间的转换

　　使用list函数可以把元组转换成列表。

• list(元组)

　　使用tuple函数可以把列表转换成元组。

• tuple(列表)

1.5.8列表与元组的区别与应用场景

1.5.9元组常用方法

tuples = ('zhangsan', 'lisi', 'bo xiao yuan', 'zhaolaowu', 'wanglaoliu', 'yanlaoqi', 'lisi')
print(tuples.index('wanglaoliu'))  #,4，返回指定值的索引
print(tuples.count('lisi'))  # 2，返回指定值出现的次数
print(max(tuples))  # zhaolaowu，返回元组的最大值
print(min(tuples))  # bo xiao yuan，返回元组的最小值
print(len(tuples))  # 7，返回元组的长度

1.6字典

　　咱们目前已经学习到的容器型数据类型只有list，那么list够用？他有什么缺点呢？

• 1. 列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢。
• 2. 列表只能按照顺序存储，数据与数据之间关联性不强。
• 3.列表在表达结构化数据时语义不明确，结构化数据是指有明确属性，明确表示规则的数据。

　　所以针对于上的缺点，所以需要引入另一种容器型的数据类型，解决上面的问题，就是dict字典。

• 不可变（可哈希）的数据类型：int，str，bool，tuple。

• 可变（不可哈希）的数据类型：list，dict，set。

• 在Python3.5版本（包括此版本）之前，字典是无序的。

• 在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。

当然，字典也有缺点：他的缺点就是内存消耗巨大。

在习惯上：

• 列表更适合保存多个商品、多个姓名、多个时间，这样的相似数据；
• 字典更适合保存一个商品的不同信息、一个人的不同信息，这样的不同数据。

1.6.1创建字典

1.6.1.1使用{}

dict1 = {}  # 空的字典
print(type(dict1))
dict2 = {'name': '王峰', 'sex': "男",
         'hiredate': '1997-10-20', 'grade': 'A',
         'job': '销售', 'salary': 1000,
         'welfare': 100
         }
print(dict2)

1.6.1.2利用dict函数创建字典

dict3 = dict(name='王峰', sex='男', hiredate='1997-10-20')
print(dict3)  # {'name': '王峰', 'sex': '男', 'hiredate': '1997-10-20'}
dict4 = dict.fromkeys(['name', 'sex', 'hiredate', 'grade'], 'N/A')
print(dict4)  # {'name': 'N/A', 'sex': 'N/A', 'hiredate': 'N/A', 'grade': 'N/A'}

　　注：字典由多个键及对应的值组成，键和值使用冒号分割，字典中键的值必须唯一，而值不需要，另外，字典中的键必须是不可变的，如：字符串，元组和数字。

1.6.2字典取值

employee = {'name': '王峰', 'sex': "男",
            'hiredate': '1997-10-20', 'grade': 'A',
            'job': '销售', 'salary': 1000,
            'welfare': 100
            }

# 字典的取值
name =  employee['name']  # 如果查找的key不存在，会直接报错
print(name)
salary = employee['salary']
print(salary)

print(employee.get('job'))  # 使用字典的get方法，如果key不存在，会默认返回None，而不报错
print(employee.get('dept' , '其他部门'))  # 如果根据key获取不到value，使用给定的默认值

1.6.3in 成员运算符

employee = {'name': '王峰', 'sex': "男",
            'hiredate': '1997-10-20', 'grade': 'A',
            'job': '销售', 'salary': 1000,
            'welfare': 100
            }

print('name'in employee)  # in运算符，如果直接用在字典上，是用来判断key是否存在，而不是value
print('dept' not in employee)

1.6.4遍历字典

# 第一种遍历方式：直接for...in循环字典
for key in employee:
    v = employee[key]
    print(v)
# 第二种方式
for k,v in employee.items():
    print(k,v)

1.6.5字典的更新和新增

employee = {'name': '王峰', 
　　　　　　  'sex': "男",
            'hiredate': '1997-10-20', 
　　　　　　　'grade': 'A',
            'job': '销售', 
　　　　　　  'salary': 1000,
            'welfare': 100
            }
print(employee)
#单个kv进行更新
employee['grade'] = 'B'
print(employee)
#对多个kv进行更新
employee.update(salary = 1200, welfare=150)
print(employee)

# 字典的新增操作与更新操作完全相同,秉承有则更新,无则新增的原则
employee['dept'] = '研发部'
print(employee)
employee['dept'] = '市场部'
print(employee)
employee.update(weight=80,dept='财务部')  # 合并两个字典，字典不支持+
print(employee)

1.6.6删除字典

　　删除字典可以删除对应的键值对，也可以删除整个字典。

employee = {'name': '王峰', 'sex': "男",
            'hiredate': '1997-10-20', 'grade': 'A',
            'job': '销售', 'salary': 1000,
            'welfare': 100
            }

# 1. pop 删除指定的kv，执行结果是被删除的value
employee.pop('weight')
print(employee)

# 2.popitem 删除最后一个kv，结果是被删除的这个元素组成的键值对
kv = employee.popitem()
kv = employee.popitem()

print(kv)
print(employee)

# 3. clear 清空字典
employee.clear()
print(employee)

1.6.7为字典设置默认值

emp1 = {'name':'Jacky' , 'grade' : 'B'}
emp2 = {'name':'Lily' , 'grade' : 'A'}
# 1. setdefault为字典设置默认值,如果某个key已存在则忽略,如果不存在则设置
emp1.setdefault('grade' , 'C')
emp2.setdefault('grade' , 'C')

#if 'grade' not in emp2:
#    emp2['grade'] = 'C'
print(emp2)

1.6.8字典的视图

emp1 = {'name':'Jacky' , 'grade' : 'B'}
emp2 = {'name':'Lily' , 'grade' : 'A'}
ks = emp1.keys()
print(ks)
print(type(ks))
# (2) values 代表获取所有的值
vs = emp1.values()
print(vs)
print(type(vs))
# (3) items 代表获取所有的键值对
its = emp1.items()
print(its)
print(type(its))

emp1['hiredate'] = '1984-05-30'
print(ks)
print(vs)
print(its)

1.6.9利用字典格式化字符串

# 老版本的字符串格式化
emp_str = "姓名:%(name)s,评级:%(grade)s,入职时间:%(hiredate)s" %emp1
print(emp_str)

# 新版本的字符串格式化
emp_str1 = "姓名:{name},评级:{grade},入职时间:{hiredate}".format_map(emp1)
print(emp_str1)

1.6.10字典推导式

dict1 = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
dict2 = {}
for k, v in dict1.items():
    dict2[v] = k

# dict1 = dict2
# print(dict1)

dict1 = {v: k for k, v in dict1.items()}
print(dict1)  # {'a': 10, 'b': 34, 'A': 7, 'Z': 3}

1.6.11散列值（Hash）

字典也称为“哈希（Hash）”，对应“散列值”，是从任何一种数据中创建数字“指纹”，Python中提供了hash()生成散列值。

# 散列值 hash()
h1 = hash("abc")
print(h1)
h2 = hash("bcd")
print(h2)
h3 = hash(8838183)
print(h3)
h4 = hash("abc")
h5 = hash("def")
print(h4)
print(h5)

1.6.12字典在项目中的应用

# 处理员工数据
source = "7782,CLARK,MANAGER,SALES,5000$7934,MILLER,SALESMAN,SALES,3000$7369,SMITH,ANALYST,RESEARCH,2000"
employee_list = source.split("$")
print(employee_list)

# 保存所有解析后的员工信息,key是员工编号,value则是包含完整员工信息的字典
all_emp = {}

for i in range(0,len(employee_list)):
    #print(i)
    e = employee_list[i].split(",")
    print(e)

    # 创建员工字典
    employee = {"no" : e[0],'name':e[1],'job':e[2],'department':e[3],'salary':e[4]}
    print(employee)
    all_emp[employee['no']] = employee
print(all_emp)

empno = input("请输入员工编号:")
emp = all_emp.get(empno)
if empno in all_emp:
    print("工号:{no},姓名:{name},岗位:{job},部门:{department},工资:{salary}".format_map(emp))
else:
    print("员工信息不存在")

1.6.13字典的其他说明

a)字典和列表的区别

• 字典的特点：查找和插入的速度非常快，但是需要占用大量内存，内存浪费较多。
• 列表的特点：查找和插入的速度随着元素的增加而减慢，占用空间小。

1.7序列

  序列是指“有序”的队列，序列中的元素顺序按添加顺序排序，序列中的数据通过“索引”进行获取。

 

  序列包含常用的数据结构：字符串（Str），列表（List），元组（Tuple），数字序列（Range）。

range：指定范围，生成指定数字。

for i in range(1,10):  # 左闭右开
    print(i)

for i in range(1,10,2):  # 步长
    print(i)

for i in range(10,1,-2): # 反向步长
    print(i)

利用len和range打印列表的索引

l1 = ['zhangsan', 'lisi', '王五', '女神', 12, 666]
for i in range(len(l1)):
    print(i)

1.8集合

1.8.1定义

　　set是一个无序且不重复的元素集合。

　　集合对象是一组无序排列可哈希的值，集合成员可以做字典中的键。集合用in和not in操作符检查成员，以len()內建函数得到集合的基数（大小），用for循环迭代集合的成员。但是因为集合本身是无序的，不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值。

　　set和dict一样，只是没有value，相当于dict的key集合，由于dict的key是不重复的，且key是不可变对象因此set也有如下特性：

1. 不重复
2. 元素为不可变对象

1.8.2创建

• 方式一

　　先初始化再赋值

s = set()
s = {11,22,33,44}  # 注意在创建空集合的时候只能使用s=set()，因为s={}创建的是空字典

• 方式二

　　直接创建

a=set('boy')
d={'k1','k2','k2'}

• 方式三

　　利用set创建

b=set(['y', 'b', 'o','o'])

• 方式四

　　利用dict创建，将会使用dict中的key值作为set的值

c=set({"k1":'v1','k2':'v2'})  # {'k1', 'k2'}

• 方式五

　　使用tuple创建

e={('k1', 'k2','k2')}

1.8.3更新（增加）

graphicDesigner = {'InDesign', 'Photoshop', 'Acrobat', 'Premiere', 'Bridge'}
graphicDesigner.add('Illustrator')
print(graphicDesigner)  # {'Acrobat', 'Illustrator', 'InDesign', 'Premiere', 'Photoshop', 'Bridge'}

　　需要注意的是，你只能将不可变的值（例如一个字符串或一个元组）加入到集合中。如果将一个列表（list）添加到集合中，系统会返回类型错误「TyprError」。

se = {11, 22, 33}
be = {22, 44, 55}

se.update(be)  # 把se和be合并，得出的值覆盖se
print(se)  # {33, 22, 55, 11, 44}
se.update([66, 77])  # 可增加迭代项
print(se)  # {33, 66, 22, 55, 11, 44, 77}

1.8.4删除

1.8.4.1使用「remove」方法从集合中删除一个值

graphicDesigner = {'InDesign', 'Photoshop', 'Acrobat', 'Premiere', 'Bridge'}
graphicDesigner.remove('Photoshop')
print(graphicDesigner)  # {'Bridge', 'InDesign', 'Acrobat', 'Premiere'}

　　这种方法的一个缺点是，如果想要删除一个集合中不存在的值，系统会返回一个键值错误「KeyError」。

1.8.4.2使用「discard」方法从集合中删除一个值

graphicDesigner = {'InDesign', 'Photoshop', 'Acrobat', 'Premiere', 'Bridge'}
graphicDesigner.discard('Photoshop')
print(graphicDesigner)  # {'Acrobat', 'Bridge', 'Premiere', 'InDesign'}

　　这种方法相对于「remove」方法的好处是，如果试图删除一个集合中不存在的值，系统不会返回「KeyError」。如果熟悉字典（dict）数据结构，可能会发现这种方法与字典的「get」方法的工作模式相似。

1.8.4.3使用「pop」方法从集合中删除并且返回一个任意的值

graphicDesigner = {'InDesign', 'Photoshop', 'Acrobat', 'Premiere', 'Bridge'}
print(graphicDesigner.pop())  # Premiere
print(graphicDesigner)  # {'Acrobat', 'Bridge', 'Photoshop', 'InDesign'}

　　需要注意的是，如果集合是空的，该方法会返回一个「KeyError」。

1.8.4.4删除集合中所有的值

graphicDesigner = {'InDesign', 'Photoshop', 'Acrobat', 'Premiere', 'Bridge'}
graphicDesigner.clear()
print(graphicDesigner)  # set()

1.8.5在集合上进行迭代

dataScientist = {'Python', 'R', 'SQL', 'Git', 'Tableau', 'SAS'}
for skill in dataScientist:
    print(skill)

　　如果仔细观察「dataScientist」集合中打印出来的每一个值，会发现集合中的值被打印出来的顺序与它们被添加的顺序是不同的。

1.8.6将集合中的值变为有序

　　首先强调的是集合是无序的。如果需要以有序的形式从集合中取出值，可以使用「sorted」函数，它会输出一个有序的列表。

dataScientist = {'Python', 'R', 'SQL', 'Git', 'Tableau', 'SAS'}
print(type(sorted(dataScientist)))  # <class 'list'>

1.8.7删除列表中的重复项

　　集合是从列表（list）中删除重复值的最快的方法。

print(list(set([1, 2, 3, 1, 7])))  # [1, 2, 3, 7]

1.8.8集合操作

1.8.8.1交集

　　intersection, intersection_update，也可以使用a&b。

se = {11, 22, 33}
be = {22, 44, 55}

temp1 = se.intersection(be)  # 取交集，赋给新值
print(temp1)  # 22
print(se)  # {11, 22, 33}
temp2 = se.intersection_update(be)  # 取交集并更新自己
print(temp2)  # None
print(se)  # {22}
print(se & be)  # {22}

1.8.8.2并集

　　union，也可以使用a|b。

se = {11, 22, 33}
be = {22, 44, 55}

temp = se.union(be)   # 取并集，并赋新值
print(se)  # {33, 11, 22}
print(temp)  # {33, 22, 55, 11, 44}
print(se | be)  # {33, 22, 55, 11, 44}

1.8.8.3差集

　　difference, difference_update，也可以使用a-b。

se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be)  # 找到se中存在，be中不存在的集合，返回新值
print(temp1)  # {33, 11}
print(se-be)  # {33, 11}
print(se)  # {33, 11, 22}

se = {11, 22, 33}
be = {22, 55}
temp2 = se.difference_update(be)  # 找到se中存在，be中不存在的集合，覆盖掉se
print(temp2)  # None
print(se)  # {33, 11}

1.8.8.4合并

　　symmetric_difference, symmetric_difference_update

se = {11, 22, 33}
be = {22}

temp1 = se.symmetric_difference(be)  # 合并不同项，并赋新值
print(temp1)    #{33, 11}
print(se)       #{33, 11, 22}

temp2 = se.symmetric_difference_update(be)  # 合并不同项，并更新自己
print(temp2)    #None
print(se)             #{33, 11}

1.8.9包含关系

　　两个集合之间一般有三种关系，相交、包含、不相交。在Python中分别用下面的方法判断：

• set.isdisjoint(s)：判断两个集合是不是不相交
• set.issuperset(s)：判断集合是不是包含其他集合，等同于a>=b
• set.issubset(s)：判断集合是不是被其他集合包含，等同于a<=b

se = {11, 22, 33}
be = {22}

print(se.isdisjoint(be))        #False，判断是否不存在交集（有交集False，无交集True）
print(se.issubset(be))          #False，判断se是否是be的子集合
print(se.issuperset(be))        #True，判断se是否是be的父集合

1.8.10集合的转换

集合可以转换为list，tuple以及str

se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>
print(st, type(st))  # {0, 1, 2, 3} <class 'str'>

1.8.11不变集合

　　Python提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫frozenset，使用方法如下

a = frozenset("hello")
print(a)  # frozenset({'l', 'h', 'o', 'e'})

　　需要注意的是frozenset仍然可以进行集合操作，只是不能用带有update的方法。如果要一个有frozenset中的所有元素的普通集合，只需把它当作参数传入集合的构造函数中即可：

a = frozenset("hello")
a = set(a)
a.add(12)
print(a)  # {'h', 12, 'o', 'l', 'e'}