列表list
定义符号：[]
创建：[]直接创建    ， list()
可变性：可变
是否有序：有序
元素是否重复：可以重复
切片：支持切片
索引：支持索引
访问：索引访问
删除：
del()    
list.remove(value) 
list.pop()

修改插入：
 list[]=    
 append() 
 insert()
 extend()  
 +   

遍历：for循环遍历
 for   i   in  list:           

+或*:     支持
元组tuple
定义符号：（）
创建：() 直接创建     ，   tuple()
可变性：不可变
是否有序：有序
元素是否重复：可以重复
切片：支持切片
索引：支持索引
访问：索引访问
删除：
del()   

修改插入：不可修改
遍历：for循环遍历
for   i   in  tuple:        

+或*:     支持
字典dict
定义符号:   {key:value}
创建： dict{key:value}       {}直接创建
可变性：可变
是否有序：无序
元素是否重复：键不可以重复
切片：不支持切片
索引：不支持索引
访问：
键访问
get()访问

删除：
del()   

修改插入：
dict[key]=value

遍历：for循环遍历
for   key,value  in  dict.items:           
key_list=list(dict2.keys())    #输出字典中所有的key值
print(key_list)
value_list=list(dict2.values())   #输出字典中所有的value值
print(value_list)
items_list=list(dict2.items())    #输出以元组方式的键对值 

+或*:     不支持
集合set
定义符号：{}
创建：{}直接创建        set()
可变性：可变
是否有序:   无序
元素是否重复：不可以重复
切片：不支持切片
索引：不支持索引
删除：
del()
set.pop()
set.remove()
set.clear()

修改插入：
set.add()

遍历：
for循环遍历    for  i  in  set:

+或*:     不支持
其他：交集&     并集|
set1={1,2,3,4,5}
set2={2,3,4}
ret=set1&set2
print(ret)     #输出{2，3，4}
ret1=set1|set2
print(ret1)      #输出{1，2，3，4，5}

去重：
set1={11,11,22,22,33,44}
ret=set(set1)
print(ret)        #输出结果{22，11，33，44}

5 字符串列表元组字典集合
5.1 字符串的介绍
python中字符串的格式

双引号或者单引号中的数据，就是字符串
如果使用一对引号来定义字符串，当出现符号冲突时可以使用转移字符
在字符串前添加r可以表达字符串的原生内容
使用三个单引号、双引号定义的字符串可以包裹任意文本

字符串的分类：


普通字符


转义字符
# 转义字符 - 在指定符号前加 \ 用来表示一些特殊功能和特殊意义的字符
# 大部分编码字符与C语言类似，此处不再赘述。这里着重介绍下编码字符
# 编码字符：\u4位的十六进制
# 注意：计算字符串长度的时候，一个转义字符的长度是1
# 组织转义： r/R   1）应用于表达字符串的原生内容；2）正则表达式



5.1.1 字符串的输入输出
input获取的数据，都以字符串的方式进行保存。
print中输出字符串，可以使用%s进行占位。
5.1.2 字符串的下标和切片
1.下标/索引
“下标”就是“索引”，就是编号，可以通过下标来找到相应的存储空间。
2.切片

切片是对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始：结束：步长]，也可以简化使用[起始：结束]


选取的区间从“开始”位开始，到“结束”位的前一位结束（不包括结束位本身），步长表示选取间隔。
# 索引是通过下标取某一个元素
# 切片是通过下标去某一段元素

s = 'Hello World!'
print(s)

print(s[4])  # o 字符串里的第4个元素

print(s[3:7])  # lo W 包含下标 3，不含下标 7

print(s[:]) # Hello World! 取出所有元素（没有起始位和结束位之分），默认步长为1

print(s[1:]) # ello World! 从下标为1开始，取出 后面所有的元素（没有结束位）

print(s[:4])  # Hell 从起始位置开始，取到 下标为4的前一个元素（不包括结束位本身）

print(s[:-1]) # Hello World 从起始位置开始，取到 倒数第一个元素（不包括结束位本身）

print(s[-4:-1]) # rld 从倒数第4个元素开始，取到 倒数第1个元素（不包括结束位本身）

print(s[1:5:2]) # el 从下标为1开始，取到下标为5的前一个元素，步长为2（不包括结束位本身）

print(s[7:2:-1]) # ow ol 从下标为7的元素开始(包含下标为7的元素)，倒着取到下标为2的元素(不包括下标为2的元素) 

# python 字符串快速逆置
print(s[::-1])  # !dlroW olleH 从后向前，按步长为1进行取值


# 1)获取列表元素
# a.获取单个元素
'''
语法：列表[下标]

说明：
列表  -  任何结果是列表的表达式；独立的列表数据、保存列表的变量、返回值是列表的函数调用表达式、结果是列表的运算表达式
[]   -  固定写法
下标  -  想要获取元素的对应下标

补充：下标是什么
下标又叫索引，表示有序序列中元素的位置（顺序）
列表中的每个元素都有唯一并且固定的下标，用来表示这个元素在列表中的位置，下标值的范围是从0开始，一次增加，其中0表示第一个元素，以此类推
列表中的每个元素有两种下标值，一种是正的下标值（从0开始），另一种是负的下标值（从-1开始，依次减少，-1表示是最后一个元素）

注意：下标不能越界
'''

# b. 获取部分元素  -  切片
'''
语法：列表[开始下表：结束下标：步长]   -  从开始下表开始，每次下标2值增加步长，取到结束下标前为止

说明：
列表  -  任何结果是列表的表达式；独立的列表数据、保存列表的变量、返回值是列表的函数调用表达式、结果是列表的运算表达式
[]   -  固定写法
开始下标、结束下标 - 下标值，整数
步长  -  整数

如果步长是正，表示获取元素的时候是在开始下标到结束下标的范围内从左往右取；保证开始下标对应的元素要在结束下标对应的元素的前面，否则切片的结果是[];
如果步长是负，表示获取元素的时候是从后往前取；保证开始下标对应的元素要在结束下标对应的元素后面，否则切片的结果是[]。

注意：切片的时候下标可以越界
'''

# c. 切片语法的省略写法
'''
Ⅰ 省略步长
列表[开始下表：结束下表] ----> 列表[开始下标：结束下标：1]
'''

'''
Ⅱ 省略开始下标
列表[:结束下标：步长]  /  列表[：结束下表]

步长为正，表示从第一个元素开始往后取
步长为负，表示从最后一个元素开始往前取
'''

'''
Ⅲ 省略结束下标
列表[开始下标：：步长]  /  列表[开始下标：]

步长为正，表示从第一个元素开始往后取至最后一个元素为止
步长为负，表示从最后一个元素开始往前取至第一个元素为止
'''

'''
Ⅳ 同时省略开始下标和结束下表
列表[：：步长]  /  列表[:]
步长为正，表示从第一个元素开始往后取至最后一个元素为止
步长为负，表示从最后一个元素开始往前取至第一个元素为止
movies[::-1] 可以用于列表倒序
'''



5.1.3 字符串常见操作
字符串的常见操作包括：

获取长度：len
查找内容：find、index、rfind、rindex
判断：startswith、endswith、isalpha、isdigit、isalnum、isspace
计算出现次数：count
替换内容：replace
切割字符串：split、rsplit、splitlines、partition、rpartition
修改大小写：capitalize、title、upper、lower
空格处理：ljust、rjust、center、lstrip、rstrip、strip、zfill
字符串拼接：join

注意：在python中，字符串是不可变的，所有对字符串的操作都不改变原字符串的内容，都是返回一个结果，在这个新的返回值里，保留执行后的结果。
一、len
msg = '今天天气好晴朗，处处好风光呀好风光'
print(len(msg))

二、查找
1.find
查找指定内容在字符串中是否存在，如果存在就返回内容在字符串中第一次出现的开始位置索引值，如果不存在，则返回-1.
msg = '今天天气好晴朗，处处好风光呀好风光'
msg.find('好风光')  #10

2.rfind
类似于find，不过是从右边开始查找。
msg = '今天天气好晴朗，处处好风光呀好风光'
msg.rfind('好风光')  #14

3.index
跟find（）方法一样，只不过，find未找到时，返回-1，而index未找到时，会异常报错。
4.rindex
类似于index（），不过是从右边开始。
三、判断
1.startswith
判断字符串是否以指定内容开始。
msg = '今天天气好晴朗，处处好风光呀好风光'
print(msg.startswith('今天'))   #True
print(msg.startswith('好'))     #False

2.endswith
判断字符串是否以制定内容结束。
msg = '今天天气好晴朗，处处好风光呀好风光'
print(msg.endswith('风光'))   #True
print(msg.endswith('好'))     #False

3.isalpha
判断字符串是否是纯数字。
msg = 'hello'
print(msg.isalpha())  #True
mystr = 'hello world'
print(mystr.isalpha()) # False 因为中间有空格

4.isdigit
判断一个字符串是否是纯数字，只要出现非0~9的数字，结果就是False。
mystr = '1234'
print(mystr.isdigit()) # True
mystr = '123.4'
print(mystr.isdigit()) # False
mystr = '-1234'
print(mystr.isdigit()) # False


5.isalnum
判断是否由数字和字母组成。只要出现了非数字和字母，就返回False。
mystr = 'abcd'
print(mystr.isalnum())  # True
mystr = '1234'
print(mystr.isalnum()) # True
mystr = 'abcd1234'
print(mystr.isalnum()) # True
mystr = 'abcd1234_'
print(mystr.isalnum()) # False


6.isspace
判断字符串是否只包含空格，则返回True，否则返回False。
mystr = ''
print(mystr.isspace()) # False mystr是一个空字符串
mystr = '  '
print(mystr.isspace()) # True 只有空格
mystr = ' d'
print(mystr.isspace()) # False 除了空格外还有其他内容


四、计数
采用count可以在字符串内统计指定内容出现的次数。
mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.count('好'))  # 3. '好'字出现三次


五、替换
替换字符串中指定的内容，如果指定次数count，则替换不超过count次
mystr = '今天天气好晴朗，处处好风光呀好风光'
newstr = mystr.replace('好', '坏')
print(mystr)  # 今天天气好晴朗，处处好风光呀好风光  原字符串未改变！
print(newstr)  # 今天天气坏晴朗，处处坏风光呀坏风光 得到的新字符串里，'好'被修改成了'坏'

newstr = mystr.replace('好','坏',2)  # 指定了替换的次数
print(newstr) # 今天天气坏晴朗，处处坏风光呀好风光 只有两处的'好'被替换成了'坏'


六、内容分隔
1.split
以指定字符串为分隔符切片，如果 maxsplit有指定值，则仅分隔 maxsplit+1 个子字符串。返回的结果是一个列表。
mystr = '今天天气好晴朗，处处好风光呀好风光'
result = mystr.split() # 没有指定分隔符，默认使用空格，换行等空白字符进行分隔
print(result) #['今天天气好晴朗，处处好风光呀好风光'] 没有空白字符，所以，字符串未被分隔

result = mystr.split('好')  # 以 '好' 为分隔符
print(result) # ['今天天气', '晴朗，处处','风光呀,'风光']

result = mystr.split("好",2) # 以 '好' 为分隔符，最多切割成3份
print(result) # ['今天天气', '晴朗，处处', '风光呀好风光']


2.rsplit
用法与split基本一致，只不过是从右往左分隔。
3.splitlines
按照行分隔，返回一个包含各行作为元素的列表。
mystr = 'hello \nworld'
print(mystr.splitlines())


4.partition
把字符串以制定内容分隔成三部分，三部分组成一个元组
mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.partition('好'))  # ('今天天气', '好', '晴朗，处处好风光呀好风光')


5.rpartition
类似于partition（）函数，只不过是从右往左分隔
七、修改大小写
修改大小写的功能只对英文有效，主要包括，首字母大写capitalize,每个单词的首字母大写title,全小写lower,全大写upper.
1.capitalize
第一个单词的首字母大写。
mystr = 'hello world'
print(mystr.capitalize()) # Hello world


2.title
每个单词的首字母大写。
mystr = 'hello world'
print(mystr.title()) # Hello World


3.lower
所有的字母都变成小写。
mystr = 'hElLo WorLD'
print(mystr.lower()) # hello world


4.upper
所有的字母都大写。
mystr = 'hello world'
print(mystr.upper())  #HELLO WORLD


八、空格处理
1.ljust
返回指定长度的字符串，并在右侧使用空白字符串补全（左对齐）。
str = 'hello'
print(str.ljust(10))  # hello     在右边补了五个空格


2.rjust
返回指定长度的字符串，并在左侧使用空白字符补全（右对齐）。
str = 'hello'
print(str.rjust(10))  #      hello在左边补了五个空格


3.center
返回指定长度的字符串，并在两端使用空白字符补全（居中对齐）
str = 'hello'
print(str.center(10))  #  hello   两端加空格，让内容居中


4.lstrip
删除字符串左边的空白字符
mystr = '    he   llo      '
print(str.lstrip())  #he   llo      只去掉了左边的空格，中间和右边的空格被保留


5.rstrip
删除字符串右边的空白字符
mystr = '    he   llo      '
print(str.rstrip())  #    he   llo右边的空格被删除


6.strip
删除两段的空白字符
str = '    he   llo      '
print(str.strip())  #he   llo


7.zfill
# 给任意一个商品的数字编号值，转换成固定格式的商品编码：
# GDxxxx--->GD0001,GD0012,...
num = 34
print('GD' + str(num).zfill(4))  # GD0034

九、字符串拼接
把参数进行遍历，取出参数里的每一项，然后再在后面加上字符串
作用：可以把列表或者元组快速的转变成为字符串，并且以制定的字符串分隔。
mystr = 'a'
print(mystr.join('hxmdq'))  #haxamadaq  把hxmd一个个取出，并在后面添加字符a. 最后的 q 保留，没有加 a
print(mystr.join(['hi','hello','good']))  #hiahelloagood


txt = '_'
print(txt.join(['hi','hello','good'])) #hi_hello_good
print(txt.join(('good','hi','hello'))) #good_hi_hello


十、比较大小
两个字符串比较大小：比较的是第一组不相等的字符的编码值的大小。
十一、字符串内建函数总结




函数名
用途
实例




capitalize()
1.首字符会转换成大写，其余字符会转换成小写；2.首字符如果是非字母，首字母不会转换成大写，会转换成小写。
‘hello’.capitalize()     # Hello


center(width,fillchar)
返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
‘[hello]’.center(9,’/’) #   /[hello]/


count(str,start,end)
返回在字符串指定范围内str出现的次数。
mystr = ‘今天天气好晴朗，处处好风光呀好风光’;print(mystr.count(‘好’,0,6))  # 1


endswith(str,start,end)
返回在字符串指定范围内是否以str结尾。
msg = ‘今天天气好晴朗，处处好风光呀好风光’；print(msg.endswith(‘风光’))   #True；print(msg.endswith(‘好’))     #False


expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
msg = ‘hel\tlo’ print(msg.expandtabs(tabsize=8))  # hel     lo


find(str,start,end)
返回在字符串指定范围内str的下标，如果没有找到返回-1。
msg = ‘今天天气好晴朗，处处好风光呀好风光’;msg.find(‘好风光’)  #10


index(str,start,end)
返回在字符串指定范围内str的下标，如果没有找到会报错。
msg = ‘今天天气好晴朗，处处好风光呀好风光’;msg.index(‘好风光’)  #10


isalnum()
判断是否由数字和字母组成。只要出现了非数字和字母，就返回False。
mystr = ‘abcd’;print(mystr.isalnum())  # True;mystr = ‘1234’;print(mystr.isalnum()) # True;mystr = ‘abcd1234’;print(mystr.isalnum()) # True


isalpha()
判断字符串是否是纯字母。
msg = ‘hello’;print(msg.isalpha())  #True;mystr = ‘hello world’;print(mystr.isalpha()) # False 因为中间有空格


isdigit()
如果字符串只包含数字则返回 True 否则返回 False。
mystr = ‘1234’;print(mystr.isdigit()) # True;mystr = ‘123.4’;print(mystr.isdigit()) # False;mystr = ‘-1234’;print(mystr.isdigit()) # False


islower
判断字符串是否都是小写。
msg = ‘helLo woRld’ ；print(msg.islower())  # False


isnumeric()
如果字符串中只包含数字字符，则返回 True，否则返回 False。
mystr = ‘1234’;print(mystr.isdigit()) # True;mystr = ‘123.4’;print(mystr.isdigit()) # False;mystr = ‘-1234’;print(mystr.isdigit()) # False


isspace()
如果字符串中只包含空白，则返回 True，否则返回 False。
mystr = ‘’;print(mystr.isspace()) # False mystr是一个空字符串;mystr = ’  ‘;print(mystr.isspace()) # True 只有空格;mystr = ’ d’;print(mystr.isspace()) # False 除了空格外还有其他内容


istitle
如果字符串是标题化的(见 title())则返回 True，否则返回 False
msg = ‘hello world’ ;print(msg.istitle())  # False


isupper()
如果字符串都是大写的则返回 True，否则返回 False
msg = ‘hello world’ ;print(msg.isupper())  # False


join(seq)
以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串。
txt = ‘_’;print(txt.join([‘hi’,‘hello’,‘good’])) #hi_hello_good;print(txt.join((‘good’,‘hi’,‘hello’))) #good_hi_hello


len()
返回字符串长度。
msg = ‘hello’;len(msg)   # 5


ljust(width,fillchar)
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
str = ‘hello’;print(str.ljust(10))  # hello     在右边补了五个空格


lower()
转换字符串中所有大写字符为小写。
mystr = ‘hElLo WorLD’;print(mystr.lower()) # hello world


lstrip()
截掉字符串左边的空格或指定字符。
mystr = ’    he   llo      ';print(str.lstrip())  #he   llo      只去掉了左边的空格，中间和右边的空格被保留


maketrans()
创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
intab = “aeiou”; outtab = “12345”; trantab = str.maketrans(intab, outtab)  ;str = “this is string example…wow!!!” ;print (str.translate(trantab))    #  th3s 3s str3ng 2x1mpl2…w4w!!!


max(str)
返回字符串 str 中最大的字母。
msg = ‘hello world’; print(max(msg))  # w


min(str)
返回字符串 str 中最小的字母。
msg = ‘hello world’ ;print(min(msg))


replace(old,new,max)
把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
mystr = ‘今天天气好晴朗，处处好风光呀好风光’;newstr = mystr.replace(‘好’, ‘坏’);newstr = mystr.replace(‘好’,‘坏’,2)  # 指定了替换的次数;print(newstr) # 今天天气坏晴朗，处处坏风光呀好风光 只有两处的’好’被替换成了’坏’


rfind(str,start,end)
类似于find，只不过是从右边开始查找。
-


rindex(str,start,end)
类似于index，只不过是从右边开始查找。
-


rjust(width,fillchar)
返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串。
str = ‘hello’;print(str.rjust(10))  #      hello在左边补了五个空格


rstrip()
删除字符串字符串末尾的空格。
mystr = ’    he   llo      ';print(str.rstrip())  #    he   llo右边的空格被删除


split(str,num)
以str为分隔符截取字符串，如果指定了num，则仅截取num+1个子字符串。返回的结果是一个列表。
mystr = ‘今天天气好晴朗，处处好风光呀好风光’;result = mystr.split(“好”,2) # 以 ‘好’ 为分隔符，最多切割成3份;print(result) # [‘今天天气’, ‘晴朗，处处’, ‘风光呀好风光’]


splitlines(keepends)
按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True(默认），则保留换行符。
mystr = ‘hello \nworld’;print(mystr.splitlines())


startswith(str,start,end)
返回在字符串指定范围内是否以str结尾。
msg = ‘今天天气好晴朗，处处好风光呀好风光’；print(msg.startswith(‘今天’))   #True；print(msg.startswith(‘好’))     #False


strip()
删除字符串两端的空白字符。
str = ’    he   llo      ';print(str.strip())  #he   llo


swapcase()
将字符串中大写转换为小写，小写转换为大写
msg = ‘helLo woRld’ ;print(msg.swapcase())  # HELlO WOrLD


title()
标题化：将所有的单词的首字母大写，其余字母小写。
mystr = ‘hello world’;print(mystr.title()) # Hello World


translate（table，deletechars）
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中。
intab = “aeiou” ;outtab = “12345” ;trantab = str.maketrans(intab, outtab) ;  # 制作翻译表  str = “this is string example…wow!!!”; print (str.translate(trantab))      #  th3s 3s str3ng 2x1mpl2…w4w!!!


upper()
将字符串中的小写字母全转化成大写。
mystr = ‘hello world’;print(mystr.upper())  #HELLO WORLD


zfill(width)
返回长度为 width 的字符串，原字符串右对齐，前面填充0。
num = 34;print(‘GD’ + str(num).zfill(4))  # GD0034


isdecimal()
检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。
msg = ‘45’;print(msg.isdecimal())  # True


partition(str)
把字符串以制定内容分隔成三部分，三部分组成一个元组。
mystr = ‘今天天气好晴朗，处处好风光呀好风光’;print(mystr.partition(‘好’))  # (‘今天天气’, ‘好’, ‘晴朗，处处好风光呀好风光’)


rpartiton(str)
类似于partition（）函数，只不过是从右往左分隔。
-


注意：isalpha、isdigit、isnumerical、isalnum会将中文汉字也纳入其中，所以在实际开发中，有相关需求需要自己写代码实现，不能一概使用以上方法。
5.1.4 字符编码
1.什么是编码
计算在存储数据的时候只能存数字，而且存的是数字的补码。
为了能让计算机存储文本数据，给每个字符关联了一个固定的数字，用来对这个字符关联的那个数字就是这个字符的编码值。
2.编码表
1）ASCII码表
用1个字节来对字符进行编码（编码范围：0~127）
a.数字在字母的前面（字符0~字符9的编码值连续递增）
b.大写字母在小写字母的前面（字母之间是连续递增）  (ord(‘A’) - ord(‘a’) = 32)
c.大写字母和小写字母之间有其他符号（不连续）
2）Unicode编码表
Unicode编码表是对ASCII表的扩展（Unicode编码表中包含了ASCII表中所有符号）
Unicode编码表中包含了世界上所有国家所有民族所有语言的符号，共计65536个
Unicode中的中文编码范围：4e00 ~ 9fa5
3.编码相关函数
1）chr（）函数
chr(编码值)  -  获取指定编码值对应的字符
print(chr(0x0f00))   # ༀ


2）ord（）函数
ord(字符)  -  获取指定字符对应的编码
print(ord('一'))   # 19968

# 练习1：输入一个字符串，统计字符串中中文和字母的个数
msg = 'hello, 你好吗？'
count_alp = 0
count_char = 0
for item in msg:
    if 'a' <= item <= 'z' or 'A' <= item <= 'Z':
        count_alp += 1
    if '\u4e00' <= item <= '\u9fa5':
        count_char += 1
print('中文有个{}，字母有{}个。'.format(count_char, count_alp))

5.1.5 字符串的格式化输出
字符串中某一个或者多个部分不确定就可以使用格式字符串来实现功能

格式占位符

语法：包含格式占位符的字符串 % （数据1，数据2，数据3，…）
说明：
​			a. 数据个数和前面占位符的个数保持一致
​			b. 格式占位符
​				%d   -   整数
​				%Nd/%-Nd     -     整数填充字符串时，宽度是N，不够的用空格在前面或后面占位
​				%s   -   字符串
​				%f   -   小数
​				%.Nf     -     约定小数点后的位数
​			c.一般情况下，格式占位符与后方数据的类型需保持一致，只有%s可以用任何类型的数据填充
print('%s今年%d岁！'%('xiaoming',18))


format

在字符串中通过{}来占位表示字符串中变化的部分
1)变量个数和{}的个数保持一致
name = 'xiaoming'
age = 18
msg = '{}今年{}岁'.format(name,age)
print(msg)

2)列表形式的format:{下标}
name = 'xiaoming'
age = 18
msg = '你好，我是{0}，今年{1}岁。{0}你好！'.format(name, age, score)
print(msg)


3）key形式的format：{key}
msg = '{name}今年{age}岁，得分：{score}。'.format(name = '张三', age = 18, score = 95)

4）key形式的format的变形：f'{变量名}'
a = 10
b = 20
msg = f'a={a}, b={b}'
print(msg)

5）数字格式化
：.Nf  -  限制小数的小数点位数（N位）
print('数字：{:.2f}'.format(3.1415926))  # 数字：3.14
print('数字：{1:.2f}'.format(3.1415926,1.68926))  # 数字：1.69
print('数字：{n2:.2f}'.format(n1 = 3.1415926, n2 = 1.68926))  # 数字：1.69
pi = 3.1415926
print(f'数字：{pi:.2f}')  # 数字：3.14

:x>Nd  -  数字占N位，不够用X填充（填在左边）
x<Nd  -  数字占N位，不够用X填充（填在右边）
print('{:0>5d}'.format(34))   # 00034
print(f'{34:a>5d}')    # aaa34

print(f'{34:a<5d}')   # 34aaa

:,  -  用逗号将数据进行分割（通用于银行数据显示）
num = 3695000000
print(f'{num:,}')   # 3,695,000,000


:.N%  -  以百分比的形式显示数据，数据保留 N 位小数
num = 0.45
print(f'{num:.3%}')  # 45.000%

print(f'{num:%}')  # 45.000000%

5.2 列表的介绍
5.2.1 列表的增删改查
一、添加元素
添加元素有如下的方法：

append在末尾添加元素
insert在指定位置插入元素
extend合并两个列表

#append会把新元素添加到列表末尾
#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']

print("-----添加之前，列表A的数据-----A=%s" % A)

#提示、并添加元素
temp = input('请输入要添加的学生姓名:')
A.append(temp)

print("-----添加之后，列表A的数据-----A=%s" % A)


#insert(index, object) 在指定位置index前插入元素object
strs = ['a','b','m','s']
strs.insert(3,'h')
print(strs)  # ['a', 'b', 'm', 'h', 's']


#通过extend可以将另一个集合中的元素逐一添加到列表中
a = ['a','b','c']
b = ['d','e','f']
a.extend(b)
print(a)  # ['a', 'b', 'c', 'd', 'e', 'f'] 将 b 添加到 a 里
print(b) # ['d','e','f'] b的内容不变


二、修改元素

通过制定下标来访问列表元素，因此修改元素的时候，为指定的列表下标赋值即可。
#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']

print("-----修改之前，列表A的数据-----A=%s" % A)

#修改元素
A[1] = 'xiaoLu'

print("-----修改之后，列表A的数据-----A=%s" % A)


#特殊用法
'''
列表1[开始下标：结束下标] = 列表2  将列表1中开始下标到结束下标选中的所有元素替换成列表2中所有的元素
'''
nums = [10, 20, 30, 40, 50]
nums[1:3] = [100]
print(nums)  #[10, 100, 40, 50]


三、查找元素
列表查找元素的方法有：

in 和 not in

in（存在），如果存在那么结果为True，否则为False
not in（不存在），如果不存在那么结果是True，否则为False


index 和 count

index用来查找元素所在的位置，如果未找到则会报错；
count用来计算某个元素出现的次数。



#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']

#获取用户要查找的名字
findName = input('请输入要查找的姓名:')

#查找是否存在
if findName in nameList:
    print('在列表中找到了相同的名字')
    else:
        print('没有找到')

        
>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0


四、删除元素
列表元素的删除常用方法有：

del：根据下标进行删除（如果用同名变量，也会将其删除）
pop：取出最后一个元素或者取出列表中指定下标的元素，并且返回被取出的元素。
remove：根据元素的值进行删除

#del 列表[下标]  （下标不能越界）
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName)
del movieName[2]
print('------删除之后------movieName=%s' % movieName)


movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName)
movieName.pop()
t = movieName.pop(1)
print('------删除之后------movieName=%s' % movieName)
print(t)


movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------movieName=%s' % movieName)
movieName.remove('指环王')
print('------删除之后------movieName=%s' % movieName)
#如果指定的元素不存在，会报错
#如果指定的元素存在且多个，则只删除第一个指定的元素

Python中删除列表元素的坑
# 练习：已知一个分数列表，[89,45,55,30,78,90,34,87,10,59,100],删除列表中所有低于60分的成绩
scores = [89, 45, 55, 30, 78, 90, 34, 87, 10, 59, 100]
for score in scores:
    if score < 60:
        scores.remove(score)
print(scores)   #[89, 55, 78, 90, 87, 59, 100]

'''
从运行结果上看，这样删除并不能很好的删除不及格的成绩，这是由于如下原因：
1.for in 是对下标进行遍历操作，remove()是对值进行操作；
2.Python中，list 属于线性表，用一块连续的内存空间存储元素，调用 remove()函数 删除指定元素时，会删除内存地址中的元素，删除指定元素后，后面所有元素会自动向前移动一个位置；
3.使用list.pop()函数删除指定元素的时候，也存在上述的坑。
'''

#解决方案有如下：
#1.深拷贝列表
import copy
scores = [89, 45, 55, 30, 78, 90, 34, 87, 10, 59, 100]
scores_copy = copy.score
for score in scores:
    if score < 60:
        scores.remove(score)
print(scores)
'''
scores = [89, 45, 55, 30, 78, 90, 34, 87, 10, 59, 100]
# new_scores = scores[:]
for score in scores[::]:
    if score < 60:
        scores.remove(score)
print(scores) 
'''
#2.while判断
c = [1, 2, 3, 3, 3, 4]
while 3 in c:
    c.remove(3)
print(c)    #[1, 2, 4]
'''
scores = [89, 45, 55, 30, 78, 90, 34, 87, 10, 59, 100]
index = 0
while index < len(scores):
	if scores[index]<60:
		del scores[index]
		countinue
	index += 1
print(scores)
'''
#3.列表推导式
scores = [89, 45, 55, 30, 78, 90, 34, 87, 10, 59, 100]
new_scores = [score for score in scores if score > 60]
print(new_scores)
#4.倒序遍历：巧妙避坑
scores = [89, 45, 55, 30, 78, 90, 34, 87, 10, 59, 100]
for score in scores[::-1]:
    if score < 60:
        scores.remove(score)
print(scores)   
#5.新建列表，原理相当于用列表推导式
scores = [89, 45, 55, 30, 78, 90, 34, 87, 10, 59, 100]
new_scores = []
for score in scores[:]:
    if score > 60:
        new_scores.append(score)
print(new_scores) 

注意：删除列表中指定元素时，建议不要使用for循环。
五、排序
sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
reverse方法是将list逆置。
>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()  # 逆置，不排序
>>> a
[3, 2, 4, 1]
>>> a.sort()  # 默认从小到大排序
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)  # 从大到小排序
>>> a
[4, 3, 2, 1]


六、其他操作方法
# 1. 数学运算
'''
列表1 + 列表2  -  将列表1和列表2中的元素合并产生一个新的列表
列表 * N  -  将列表中的元素重复N次，产生一个新的列表
'''
list1 = [1, 2, 3]
list2 = [20, 30, 40]
print(list1 + list2, list1, list2)
print(list1 * 3)

# 2.比较运算
'''
1） == 和 ！=
补充：is 和 == 的区别
    == 判断值是否相等
    is 判断地址是否相等
    （给不同的变量赋相等的数字或字符串的时候，赋值之前系统会先检查这个数字和字符串内存中是否已经存在，如果存在会直接返回数据的地址给变量，不存在才会开辟新的内存返回新的地址。

2）> , < , >= , <=
列表1 > 列表2 - 列表中的元素逐队比较，比较出一次结果则停止比较
'''
print([300, 2, 4] > [100, 200])  # True
# print(['abc',100,300]>print([100,200])   #TypeErro

# 3. 相关函数
# 1)max,min
'''
max(序列)  -  获取列表中最大的元素
min(序列)  -  获取列表中最小的元素

注意：这儿的列表要求列表中的元素类型必须一致，并且支持比较运算
'''
nums = [23, 89, 90, 128, 56]
print(max(nums))
print(min(nums))

# 2)sorted
'''
sorted(列表)  -  将列表中的元素按从小到大进行排序，产生一个新的列表
sorted(列表，reverse = True)  -  将列表中的元素从大到下进行排序，产生一个新的列表  

注意：这儿的列表要求列表中的元素类型必须一致，并且支持比较运算
'''
nums = [23, 89, 90, 128, 56]
new_nums = sorted(nums)
print(nums)
print(new_nums)

# 3)reversed(了解)
'''
reversed(列表)  -  将列表中的元素倒序产生一个新的迭代器对象
'''
nums = [23, 89, 90, 128, 56]
new_nums = reversed(nums)
print(list(new_nums))

# print(nums[::-1])

# 4)sum
'''
sum(列表)  -  返回列表中所有元素的和

注意：序列中的元素必须全部是数字
'''
nums = [23, 89, 90, 128, 56]
sum1 = sum(nums)
print(sum1)

print(sum(range(1, 101)))

# 5)list
'''
list(数据)  -  将数据转换成列表

a. 所有容器型数据类型的数据都可以转换成列表
b. 将容器中的元素全部转换成列表中的元素
'''
str1 = 'hello'
list1 = list(str1)
print(list1)  # ['h', 'e', 'l', 'l', 'o']

list2 = list(range(1, 5))
print(list2)  # [1, 2, 3, 4]

5.2.2 遍历列表
1.使用while循环
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
length = len(namesList)  # 获取列表长度
i = 0
while i<length:
    print(namesList[i])
    i+=1


2.使用for循环
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
    print(name)


3.使用下标遍历
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for index in range(len(namesList)):
    print(namesList[index])

3.交换两个变量的值
# 使用中间变量
a = 4
b = 5
c = 0

c = a
a = b
b = c

print(a)
print(b)


4.冒泡排序法
nums = [5, 1, 7, 6, 8, 2, 4, 3]

for j in range(0, len(nums) - 1):
   for i in range(0, len(nums) - 1 - j):
       if nums[i] > nums[i + 1]:
           a = nums[i]
           nums[i] = nums[i+1]
           nums[i+1] = a

print(nums)


5.2.3 列表嵌套
类似while循环的嵌套，列表也是支持嵌套的
一个列表中的元素又是一个列表，那么这就是列表的嵌套
>>> schoolNames = [
... [1, 2, 3],
... [11, 22, 33],
... [111, 222, 333]
... ]
>>> schoolNames[1][2]  # 获取数字 33
33
>>> schoolNames[1][2] = 'abc'  # 把 33 修改为 'abc'
>>> schoolNames
[[1, 2, 3], [11, 22, 'abc'], [111, 222, 333]]
>>> schoolNames[1][2][2]  # 获取 'abc' 里的字符c
'c'


练习：一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配
import random

# 定义一个列表用来保存3个办公室
offices = [[],[],[]]

# 定义一个列表用来存储8位老师的名字
names = ['A','B','C','D','E','F','G','H']

i = 0
for name in names:
    index = random.randint(0,2)    
    offices[index].append(name)

i = 1
for tempNames in offices:
    print('办公室%d的人数为:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)


5.3 元组的使用
元组与列表类似，但元组的元素不能修改。元组使用小括号表示，列表使用方括号表示。
# 多元素的元组
tuple1 = (1, 2, 30)
#也可以不加括号，直接多个元素逗号分隔
tuple2 = 1， 2，10

一、访问元组
通过下标访问。(列表的访问方法在元组中也同样可用)
# 也可以用拆包的方式获取元组中的各个元素
# a.变量1, 变量2, 变量3,... = 元组(变量个数与元组元素个数必须保持一致)
x, y, z = (100,200,300)
# b.变量1, 变量2, 变量3,... = 元组(变量个数可以少于元组元素个数，但必须有一个变量带有*，即含有可变变量)
person = ('xiaoming','male',18,20,6)
name,sex,age,*num = person 

# 补充： * 的解包
list1 = [10,20,30]
print(*list1)

二、修改元组
python中不允许修改元组的数据，包括不能删除其中的元素。
三、count、index
列表的相关操作同样适用于元组
>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0


四、定义只有一个数据的元组
定义只有一个元素的元组，需要在唯一的元素后写一个逗号
>>> a = (11)
>>> a
11
>>> type(a)
int
>>> a = (11,)  # 只有一个元素的元组，必须要在元素后写一个逗号
>>> a
(11,)
>>> type(a)
tuple


五、交换两个变量的值
# 第1种方式,使用中间变量
a = 4
b = 5
c = 0

c = a
a = b
b = c
print(a)
print(b)

# 第2种方式，直接交换。
a, b = 4, 5
a, b = b, a

print(a)
print(b)


5.4 字典的介绍
一、列表的缺点
当存储的数据要动态添加、删除的时候，我们一般使用列表，但是列表有时会遇到一些麻烦。
# 定义一个列表保存，姓名、性别、职业
nameList = ['xiaoZhang', '男', '木匠'];

# 当修改职业的时候，需要记忆元素的下标
nameList[2] = '铁匠'  

# 如果列表的顺序发生了变化，添加年龄
nameList = ['xiaoWang', 18, '男',  '铁匠']

# 此时就需要记忆新的下标，才能完成名字的修改
nameList[3] = 'xiaoxiaoWang'


字典，既能存储多个数据，还能在访问元素的时候很方便就能够定位到需要的那个元素
二、字典的使用
定义字典的语法格式：
字典名 = {键1:值1, 键2:值2, 键3:值3, ..., 键n:值n}
# 字典是容器型数据类型
# 字典是可变的（支持增删改操作），字典是无序的（不支持下标操作）

例子：
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国上海'}
info['name']  # 字典使用键来获取对应的值


说明：

字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的；字典中找某个元素时，是根据键（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值
键可以使用数字、布尔值、布尔值、元组，但是一般习惯使用字符串（不可变数据类型）
每个字典里的key都是唯一的，如果出现了多个key,后面的value会覆盖前一个key对应的value.

在习惯上：

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

5.4.1 字典的增删改查
一、查找元素
在字典中，查找元素有以下方法：


使用key值查找，但如果查找的key不存在会发生异常
info = {'name':'班长','age':18}

print(info['age']) # 获取年龄
# print(info['sex']) # 获取不存在的key，会发生异常



使用get来获取数据。并且如果key不存在，会返回空的内容，也可以提供一个默认值来输出，但不会将其添加进字典中。
info = {'name':'班长','age':18}

print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常
print(info.get('sex'， '男'))  # 获取不存在的key, 可以提供一个默认值。
print(info)  # {'name': '班长', 'age': 18}

注意，获取默认值不会修改字典内容。


二、修改元素
字典每个元素中的数据是可以修改的，只要通过key找到，即可修改。
info = {'name':'班长', 'id':100}

print('修改之前的字典为 %s:' % info)  # 修改之前的字典为 {'name': '班长', 'id': 100}

info['id'] = 200  # 为已存在的键赋值就是修改

print('修改之后的字典为 %s:' % info)  # 修改之后的字典为 {'name': '班长', 'id': 200}


三、添加元素
使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素。
info = {'name':'班长'}

print('添加之前的字典为:%s' % info)  #添加之前的字典为:{'name': '班长'}

info['id'] = 100  # 为不存在的键赋值就是添加元素

print('添加之后的字典为:%s' % info)  # 添加之后的字典为:{'name': '班长', 'id': 100}


还可以使用 **字典.setdefault(key,value)**来直接添加键值对，但如果已经存在则不会改变，保留原有的键值对；不存在才会添加。
info = {'name':'班长'}

print('添加之前的字典为:%s' % info)  #添加之前的字典为:{'name': '班长'}

info.setdefault('id', 100)  # 为不存在的键赋值就是添加元素

print('添加之后的字典为:%s' % info)  # 添加之后的字典为:{'name': '班长', 'id': 100}

四、删除元素
对字典进行删除，有如下方式：


del  字典名[键] (key不存在会报错)
#del 删除单个元素
info = {'name':'班长', 'id':100}

print('删除前,%s' % info)  # 删除前,{'name': '班长', 'id': 100}
 
del info['name']  # del 可以通过键删除字典里的指定元素

print('删除后,%s' % info)  # 删除后,{'id': 100}

#del 删除整个字典会报错
info = {'name':'monitor', 'id':100}

print('删除前,%s'%info)

del info  # del 也可以直接删除变量

print('删除后,%s'%info)

'''
删除前,{'name': 'monitor', 'id': 100}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'info' is not defined
'''



clear  清空字典
info = {'name':'monitor', 'id':100}

print('清空前,%s'%info)  # 清空前,{'name': 'monitor', 'id': 100}

info.clear()

print('清空后,%s'%info)  # 清空后,{}




pop  出去字典中指定key对应的值，并且返回被取出的值
info = {'name':'monitor', 'id':100}

print('清空前,%s'%info)  # 清空前,{'name': 'monitor', 'id': 100}

id = info.pop('id')
print(id)

print('清空后,%s'%info)  # 清空后,{}




5.4.2  字典的遍历
1.遍历字典的key（键）
info = {'name':'monitor', 'id':100}
for key in info.keys():
    print(key)

2.遍历字典的value（值）
info = {'name':'monitor', 'id':100}
for value in info.values():
    print(value)

3.遍历字典的项（元素）
info = {'name':'monitor', 'id':100}
for item in info.items():
    print(item)

4.遍历字典的key-value（键值对）
info = {'name':'monitor', 'id':100}
for key,value in info.items():
    print('key=',key,'value=',value)

5.4.3 字典的相关操作和方法
1.字典相关操作
字典不支持加法和乘法运算

比较运算

字典只支持比较相等，不支持比较大小
print({'a':1, 'b':2} == {'b':2, 'a':1})  #True


in 和 not in

数据 in 字典  -  判断字典中是否存在指定的key
数据 not in 字典  -  判断字典中是否不存在指定的key

cat = {'name':'花花','age':2,'color':'白色'}
print('name' in cat)  # True
print('花花' in cat)  # False


相关函数



len(字典)  -  统计键值对的个数


dict(数据)  -  将指定的数据转换成字典
数据的要求：


是容器型数据类型


数据中的元素是有且只有两个元素的容器（小容器）


小容器中的第一个元素是不可变的


x = [(1,2),(3,4),[5,6]]
dict1 = dict(x)
print(dict1)  # {1:2, 3:4, 5:6}



字典转换成其他的数据类型

bool（字典）  -  空字典会转换成 False ，其他都是True
list（字典）  -  将字典所有的key作为列表的元素
tuple（字典）  -  将字典所有的key作为元组的元素



2.字典相关的方法


字典.clear()   -   清空字典


字典.copy()   -   复制字典产生一个新的字典并且返回
cat = {'name':'花花','age':2,'color':'白色'}
cat1 = cat
cat1['name'] = '咪咪'
print(cat)

cat = {'name':'花花','age':2,'color':'白色'}
cat1 = cat.copy()
cat1['name'] = '咪咪'
print(cat)
print(cat1)



dict.fromkeys()


dict.fromkeys(序列)   -    将序列中的元素创建为字典的key（序列元素是不可变的），其对应的value是None。
dict3 = dict.fromkeys('abc')
print(dict3)  # {'a':None, 'b':None, 'c':None}

stu = dict.fromkeys(['name', 'age', 'gender', 'address'])
print(stu)  # {'name': None, 'age': None, 'gender': None, 'address': None}

message = ['张三', '李四', '王五']
for name in message:
    new_stu = stu.copy()
    new_stu['name'] = name
    print(new_stu)
'''
{'name': '张三', 'age': None, 'gender': None, 'address': None}
{'name': '李四', 'age': None, 'gender': None, 'address': None}
{'name': '王五', 'age': None, 'gender': None, 'address': None}
'''



dict.fromkeys(序列，值)   -   将序列中的元素创建为字典的key（序列元素是不可变的），其对应的value是指定的值。


stu = dict.fromkeys(['name', 'age', 'gender', 'address'], 0)
print(stu)  
# {'name': 0, 'age': 0, 'gender': 0, 'address': 0}



items、keys、values

字典.keys()  -  获取字典所以的key，返回一个容器（这个容器不是列表）
字典.values()  -  获取字典所以的值，返回一个容器（这个容器不是列表）
字典.items()  -  获取字典所有的key和值，返回一个容器，容器中的元素是元组，每个元组对应一个键值对（这个容器不是列表）

stu = dict.fromkeys(['name', 'age', 'gender', 'address'])
print(stu)

print(stu.keys())
print(list(stu.keys()))
# dict_keys(['name', 'age', 'gender', 'address'])
# ['name', 'age', 'gender', 'address']

print(stu.values())
# dict_values([None, None, None, None])


print(stu.items())
# dict_items([('name', None), ('age', None), ('gender', None), ('address', None)])




字典.setdefault(键，值)


字典.update(序列)   -    用序列生成的字典去更新原字典（更新方式：不存在就添加，存在就修改）
dict1 = {'a': 10, 'b': 20, 'c': 30}
dict1.update({'a': 100, 'd': 40})
print(dict1)  # {'a': 100, 'b': 20, 'c': 30, 'd': 40}




5.5 集合的使用
集合(set)是一个无序的不重复元素列表，可以使用大括号{ }或者set( ) 函数创建集合。
注意：创建空集合必须用set（）而不是{ }，因为{ }是创建空字典。
列表不能作为集合的元素
创建格式：
parame = {value01,value02,...}
或者
set(value)


一、添加元素

add

语法格式如下：
s.add(x)

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}



update

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，将其中的元素逐个加入到集合中。
语法格式如下：
s.update( x )


x 可以有多个，用逗号分开。
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}


二、移除元素
语法格式如下：
s.remove( x )


将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>


此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
s.discard( x )


>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}


我们也可以设置随机删除集合中的一个元素，语法格式如下：
s.pop()

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)
print(thisset)


三、查找元素
集合没有办法直接获取单个元素，只能遍历查找
四、set常见方法列表




方法
描述




add()
为集合添加元素


clear()
移除集合中的所有元素


copy()
拷贝一个集合


difference()
返回多个集合的差集


difference_update()
移除集合中的元素，该元素在指定的集合也存在。


discard()
删除集合中指定的元素


intersection()
返回集合的交集


intersection_update()
删除集合中的元素，该元素在指定的集合中不存在。


isdisjoint()
判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。


issubset()
判断指定集合是否为该方法参数集合的子集。


issuperset()
判断该方法的参数集合是否为指定集合的子集


pop()
随机移除元素


remove()
移除指定元素


symmetric_difference()
返回两个集合中不重复的元素集合。


symmetric_difference_update()
移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。


union
返回两个集合的并集


update()
给集合添加元素


五、数学集合运算
python中的集合支持数学集合运算： &（求交集）、|（求并集）、-（求差集）、对称差集（^）、>/<（判断是否是真子集）


交集：求两个集合的公共部分


并集：求两个集合都有所有元素


差集：集合1- 集合2  是求集合1中出集合2剩余的部分


对称差集：去除两个集合公共部分，保留剩下的部分


真子集：集合1 > 集合2   判断集合2是否是集合1的真子集
​				集合1 < 集合2   判断集合1是否是集合2的真子集


set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8,9}

#求交集
print(set1 & set2)  # {4,5}

#求并集
print(set2 | set2)  # {1,2,3,4,5,6,7,8,9}

#求差集
print（set1 - set2）  # {1，2，3}

#求对称差集
print(set1 ^ set2)  # {1,2,3,6,7,8,9}

#求真子集
print({100, 200, 300, 400} > {10, 20})  #False
print({1,10,20} > {10,20})  # True
print({10,20} > {10,20})   # False

5.6 总结





列表
元组
字典
集合




容器标志
[]
()
{}
{} or set()


特点
可变、有序
不可变、有序
可变、无序
可变、无序


查
获取单个元素、切片、遍历
与列表一致，拆包的方式
单个、遍历
遍历


增
append、insert、extend、‘ + ’
不可变
字典[key]=value、setdefault、update
add、update


删
del、pop、remove
无
del、pop
remove、discard


改
列表[下标] = 新值、列表1[start:end] = 列表2
无
字典[key]=value
无


元素
没有要求
没有要求
键值对（键不可变且唯一）
不可变且唯一


其他操作
+、*、>、<、>=、<=、==、！=、in、not in
和列表一样
==、！=、in、not in
==、！=、in、not in


相关函数
max/min/sum/reversed/sorted/len/list
和列表一样
len/list
max/min/sum/sorted/len/set（排序生成一个新的列表

Python列表、元组、集合、字典的操作及列表与字典时间复杂度的比较






列表
元组
字典
集合




是否
可变
可变
不可变
可变
可变


是否
有序
有序
有序
可变
可变


元素
是否
重复
可重复
可重复
键不可重复
不可重复


定义
符号
[]
()
{key:value}
{}


创建
1.[]直接创建
2.list()
3.列表解析式
1.()直接创建
2.tuple()
1.{}直接创建
2.dict()
1.set()
(不可以使用{}来创建，
那样是dict而不是set)


删除
1.del删除元素或者列表
2.list.remove(value)
1.del删除元素或元组
1.del删除元素或字典
1.del删除元素或集合
2.set.remove()
3.set.pop()
4.set.clear()


修改
插入
1.append()
2.insert()
3.+
4.extend()
不可修改
1.dict[key]=value
s.add()


访问
遍历
1.索引访问
2.for循环遍历
for i in list
for index，i in enumerate（list）
1.索引访问
2.for循环遍历
1.键访问
2.get()访问
3.for key，value in dict.items()
 for key in dict.keys()
for value in dict.values()
for循环遍历


生成式
[i*i for i in list1]返回列表
(i*i for i in list1)返回生成器对象，
通过for和next()访问
dict={i:j for i,j in zip(list1,list2)}
dict={i*2:2 for i in range(1,10)}
交集&，并集 |
，差集- ,
  ^ 不同时包含于a和b集合的元素


切片
支持切片
支持切片
不支持切片
不支持切片


索引
支持索引
支持索引
不支持索引
不支持索引


+、*
运算
支持
支持
不支持
不支持


其它
不能作为字典的键
可以作为字典的键




概括几点列表、字典、集合某些操作的时间复杂度比较：

1.查找速度快,无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
2.字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。不允许同一个键出现两次。
键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行。
3.关于列表内部实现是数组（具体实现要看解析器, CPython的实现 ），因此就有数组的特点。超过容量会增加更多的容量，set, get 是O(1)，但del, insert, in的性能是O(n)。具体的看下表，'n’是容器中当前的元素数， 'k’需要操作的元素个数；
关于字典需要了解的是hash函数和哈希桶。一个好的hash函数使到哈希桶中的值只有一个，若多个key hash到了同一个哈希桶中，称之为哈希冲突。查找值时，会先定位到哈希桶中，再遍历hash桶。更详细的信息请点这里。在hash基本没有冲突的情况下get, set, delete, in方面都是O(1)。自己的操作不会超过O(n)；
关于set内部实现是dict的。在in操作上是O(1), 这一点比list要强。
也有list不存在的差运算；

list列表：


dict字典:

1.元组
1.1 符号： （）
空元组： （） 类型： <class ‘tuple’>
1.2 特点
只能存放数据，不能进行增删改查，属于不可变数据类型
1.3 唯二两个方法：index count
基本与列表的使用一致
1.4定义一个只有一个元素的元组
a = (9)
print(type(a))    # <class 'int'>
b = (9,)
print(type(b))    # <class 'tuple'>

1.5 赋值操作
1.2.1 装包：系统自动完成
a = 5,6
print(a)    # (5, 6)
print(type(a)) # <class 'tuple'>

一个变量对应多个值

1.2.2 拆包：系统自动完成
a,b = (1,2)
print(a,b)

1.2.3 交换两个变量的值
# 第1种方式,使用中间变量
a = 4
b = 5
c = 0
c = a
a = b
b = c
print(a)   # 5
print(b)   # 4

# 第2种方式，直接交换。
a, b = 4, 5
a, b = b, a
print(a)     # 5
print(b)     # 4

2.字典
列表进行元素的增删改查时，需要知道该元素的索引，而当列表的顺序发生变化的时候，相应的索引也发生变化，此时便无法根据索引来获取元素了。为了克服列表的这种缺点，故引入字典。
2.1字典的格式
字典的格式：{键1:值1, 键2:值2, 键3:值3, …, 键n:值n}

可变类型不能作为字典的key
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国上海'}
info['name']  # 班长 字典使用键来获取对应的值

说明：

字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的；字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值
键可以使用数字、布尔值、布尔值、元组，但是一般习惯使用字符串
每个字典里的key都是唯一的，如果出现了多个key,后面的value会覆盖前一个key对应的value.
在习惯上：列表更适合保存多个商品、多个姓名、多个时间，这样的相似数据；字典更适合保存一个商品的不同信息、一个人的不同信息，这样的不同数据。
2.2 字典的增删改查
2.2.1 查看元素
info = {'name':'班长','age':18}
print(info['age']) # 获取年龄
# print(info['sex']) # 获取不存在的key，会发生异常
print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常
print(info.get('sex'， '男'))  # 获取不存在的key, 可以提供一个默认值。
info = {'zhangsan': 19, 'lisi': 20}
print(info.keys()) # dict_keys(['zhangsan', 'lisi'])，获取字典所有的key
print(info.values()) # dict_values([19, 20]) ，获取字典所有的value
print(info.items()) # dict_items([('zhangsan', 19), ('lisi', 20)])，获取键值对

注意，获取默认值不会修改字典内容。

2.2.2 修改元素
info = {'name':'班长', 'id':100}
print('修改之前的字典为 %s:' % info) # 修改之前的字典为 {'name': '班长', 'id': 100}
info['id'] = 200  # 为已存在的键赋值就是修改
print('修改之后的字典为 %s:' % info) # 修改之后的字典为 {'name': '班长', 'id': 200}

2.2.3 添加元素

如果在使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素
info = {'name':'班长'}
print('添加之前的字典为:%s' % info) # 添加之前的字典为:{'name': '班长'}
info['id'] = 100  # 为不存在的键赋值就是添加元素
print('添加之后的字典为:%s' % info) # 添加之后的字典为:{'name': '班长', 'id': 100}

2.2.4 删除元素
del：

通过key删除指定元素 或者删除整个字典
clear（）：清空字典
pop方法：

info.pop(‘key’) 返回值为被删除的值
popitem()方法：每次删除最后一个键值对

info.popitem()

以元组的形式返回删除的元素，如果删除空字典会报错。
2.3 字典的遍历
2.3.1 字典key的遍历

for key in info.keys():
2.3.2 字典value的遍历

for value in info.values():
2.3.3 字典每个元素的遍历

for item in info.items():
2.3.4 遍历字典的键值对

for key,value in info.items():
2.4 字典推导式
呼唤一个字典的key和value
dict1 = {"a": 100, "b": 200, "c": 300}
dict2 = {v: k for k, v in dict1.items()}
print(dict2)

3.集合
3.1集合的表示
集合是一个无序不重复的序列，用{ }表示或者 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。集合不支持索引和切片操作。
格式：          
       parame = {value01,value02,...}
       或者
       set(value)

3.2 集合的方法
3.2.1 添加元素

add方法：
    格式：
    s.add(x)

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
update方法：

可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
    s.update( x )

x 可以有多个，用逗号分开。
  thisset = set(("Google", "Runoob", "Taobao"))
  thisset.update({1,3})
  print(thisset)       #  {1, 3, 'Google', 'Taobao', 'Runoob'}
  thisset.update([1,4],[5,6])  
  print(thisset)        #{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

3.2.2 删除元素
remove方法：

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
discard方法：

移除集合中的元素，且如果元素不存在，不会发生错误。
pop方法：

随机删除集合中的一个元素，并返回被删除的元素。
clear方法： 清空集合
del关键字：删除整个集合，
3.3.3 其他方法




方法
描述




copy()
拷贝一个集合


difference()或 -
返回多个集合的差集


a.difference_update(b)
从a中删除与b中重复的元素


intersection()或者 &
返回集合的交集


a.intersection_update(b)
从a中删除与b中不同的元素


isdisjoint()
判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False


a.issubset(b)
a是否为b的子集，是返回Ture，不是返回False


a.issuperset(b)
b是否为a的子集，是返回Ture，不是返回False


symmetric_difference()或者
返回两个集合中不重复的元素集合


symmetric_difference_update()
移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中


union（）或者
返回两个集合的并集