数据类型操作方法
字符串的操作
加法
# 字符串连接操作
str1 = "十一假期"
str2 = "快乐"
str3 = str1 + str2
print(str3)
乘法
str1 = "Python"
str2 = str1 * 5
print(str2)
切片操作
'''
[] 字符串索引操作，通过索引访问指定位置的字符，索引从0开始
[::] 字符串取片操作
完整格式：[开始索引:结束索引:步长]
[:结束索引] 从开头截取到结束索引之前
[开始索引:] 从开始索引截取到字符串的最后
[开始索引：结束索引] 从开始索引截取到结束索引之前
[:] 截取所有字符串
[开始索引:结束索引:步长] 从开始索引截取到结束索引之前按照指定步长取字符（每几取第一个）
'''
str1 = "大金链子小手表，一天三顿小烧烤，青春献给小酒桌，怎么澎湃怎么喝！"
print(str1[:7])
print(str1[12:15])
print(str1[-8:])
print(str1[36:])
print(str1[::3])
print(str1[::-2])
# 截取"烤烧小"
print(str1[-18:-21:-1])
print(str1[14:11:-1])
# 截取 桌小献
print(str1[-10:-15:-2])
print(str1[22:17:-2])
# 超出切片不报错,超出索引报错
# print(str1[100]) 报错
print(str[70:100]) # 输出空
dir()查看一个变量的内置方法
print(dir(str))
len() 计算字符串的长度
# 查看变量长度
val = len(str1)
print(val)
capitalize()将一个字符串首字母大写
# 功能：将一个字符串首字母大写
# 格式：字符串.capitalize()
str1 = "constant dropping wears the stone."
str2 = str1.capitalize()
print(str2)
startswith() 判断是否以某个字符为开头
# startswith()方法语法：
# str.startswith(str,beg=0,end=len(string))
# str -- 检测的字符串。
# beg -- 可选参数用于设置字符串检测的起始位置。
# end -- 可选参数用于设置字符串检测的结束位置。
str1 = "Whatever is worth doing is worth doing well."
str2 = str1.startswith("t",4)
print(str2)
endswith() 判断是否以某个字符结尾
# endswith()方法语法：
# str.endswith(suffix[, start[, end]])
# suffix -- 该参数可以是一个字符串或者是一个元素。
# start -- 字符串中的开始位置。
# end -- 字符中结束位置。
str1 = "Whatever is worth doing is worth doing well."
str2 = str1.endswith(".")
print(str2)
count() 统计字符串中某个元素的数量
# 查看某个字符额数量
# count()方法语法：
# str.count(sub, start= 0,end=len(string))
# sub -- 搜索的子字符串
# start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
# end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
str1 = "Whatever is worth doing is worth doing well."
val = str1.count("s")
print(val)
find() 查找某个字符串第一次出现的索引位置
# find()方法语法：
# str.find(str, beg=0, end=len(string))
# str -- 指定检索的字符串
# beg -- 开始索引，默认为0。
# end -- 结束索引，默认为字符串的长度。
str1 = "Whatever is worth doing is worth doing well."
str2 = str1.find("t",2,10)
print(str2)
index()检测字符串中子字符串索引
#index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
#index()方法语法：
#str.index(str, beg=0, end=len(string))
#str -- 指定检索的字符串
#beg -- 开始索引，默认为0。
#end -- 结束索引，默认为字符串的长度。
#返回值:如果包含子字符串返回开始的索引值，否则抛出异常
str1 = "mihongguang example....wow!!!"
str2 = "exam"
print(str1.index(str2))
print(str1.index(str2, 5)
# print(str1.index(str2, 10)) #报错
title()把每个单词首字母大写
# str.title()
str1 = "Whatever is worth doing is worth doing well."
str3 = str1.title()
print(str3)
upper()将所有小写字母变成大写
#str.upper()
str1 = "Whatever is worth doing is worth doing well."
str2 = str1.upper()
print(str2)
lower()将所有大写字母小写
#str.lower()
str1 = "Whatever is worth doing is worth doing well."
str3 = str1.lower()
print(str3)
swapcase()大小写互换
#str.swapcase()
str1 = "Whatever is worth doing is worth doing well."
str2 = str1.swapcase()
print(str2)
isupper() 判断字符串是否都是大写字母
str3 = "THIS Is A"
str2 = str3.isupper()
print(str2)
islower() 判断字符串是否都是小写字母
str3 = "this is "
str2 = str3.islower()
print(str2)
istitle() 判断字符串是否每个单词都首字母大写
str3 = "This Is a Test"
str2 = str3.istitle()
print(str2)
isalnum() 判断字符串是否是由数字或者字母或者汉字组成
str3 = "thisisa12中"
str2 = str3.isalnum()
print(str2)
isalpha() 判断字符串是否由字母或者汉字组成
str3 = "thisis中"
str2 = str3.isalpha()
print(str2)
join() 字符串拼接
#str1.join(str2)
str1 = "@"
str2 = "this"
str3 = str1.join(str2)
print(str3) # 加在两个字符中间(每个空都加)
zfill() 填充字符串
# zfill()方法语法：
# str.zfill(width)
# width -- 指定字符串的长度。原字符串右对齐，前面填充0。
str1 = "this"
str2 = str1.zfill(10)
print(str2)
center() 填充字符串 然后字符串居中
# center()方法语法：
# str.center(width, fillchar)
# width -- 字符串的总宽度。
# fillchar -- 填充字符。
str1 = "this"
str2 = str1.center(10,"#")
print(str2)
ljust() 字符串居左填充
# ljust()方法语法:
# str.ljust(width, fillchar)
# width -- 指定字符串长度。
# fillchar -- 填充字符，默认为空格。
str1 = "this"
str2 = str1.ljust(10,"$")
print(str2)
rjust() 字符串居右填充
# rjust()方法语法：
# str.rjust(width, fillchar)
# width -- 指定填充指定字符后中字符串的总长度.
# fillchar -- 填充的字符，默认为空格。
str1 = "this"
str2 = str1.rjust(10,"%")
print(str2)
replace()把字符串中的旧字符串替换成新字符串
# replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
# replace()方法语法：
# str.replace(old, new[, max])
# old -- 将被替换的子字符串。
# new -- 新字符串，用于替换old子字符串。
# max -- 可选字符串, 替换不超过 max 次
#返回值:
#返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
str = "www.baidu.com"
print ("百度地址：", str)
print ("百度地址：", str.replace("www.baidu.com", "baidu.com"))
str = "this is string example....wow!!!"
print (str.replace("is", "was", 3))
strip() 去掉指定的字符串 默认去掉换行
#str.strip(str1)
# 默去掉两头的换行
str1 = "\nthis is a \npython test\n"
print(str1)
str2 = str1.strip()
print(str2)
# 去两头,两头的都删完
str1 = "thist"
print(str1)
str2 = str1.strip("t")
print(str2)
rstrip() 从右边去掉某个字符
str1 = "this"
print(str1)
str2 = str1.rstrip("s")
print(str2)
lstrip() 从左边去掉某个字符
str1 = "this"
print(str1)
str2 = str1.lstrip("t")
print(str2)
split() 按照指定的字符进行切分，默认按照空格
#str.split(str1)
str1 = "Whatever is worth doing is worth doing well."
str2 = str1.split()
print(str2)
str3 = str1.split("t")
print(str3)
splitlines() 按照换行来进行切分
str3 = "this is \n a \n test"
str2 = str3.splitlines()
print(str2)
isdigit() 判断是否是由十进制数字组成的
#str.isdigit()
str2 = "15"
str3 = str2.isdigit()
print(str3)
# isdigit()的应用
L = ["A","1","bc","26","89"]
sum1 = 0
for val in L:
if val.isdigit():
val1 = int(val)
sum1 += val1
print(sum1)
isnumeric() 判断是否是数字组成的字符串
str2 = "123"
str3 = str2.isnumeric()
print(str3)
isdecimal() 判断是否是数值组成的字符串
str2 = "123"
str3 = str2.isdecimal()
print(str3)
isspace() 判断字符串是否由空白符组成
str3 = "\r\n"
str2 = str3.isspace()
print(str2)
maketrans() 和 translate()
"""
maketrans()
功能：制作用于字符串替换的映射表
格式: str.maketrans('查找字符','替换字符') 两个字符必须长度相等
返回值：字典
translate()
功能：进行字符串替换操作
格式：str.translate(映射表)
返回值：替换之后的字符串
"""
str1 = "this is a test"
str2 = str1.maketrans("t","Y")
print(str2)
str3 = str1.translate(str2)
print(str3)
format 格式化字符串
#语法：它通过{}和:来代替%。
#注意：字符串的format函数可以接受无限个参数，位置可以不按顺序，可以不用或者用多次
顺序传参
str1 = "{} say hello to {}"
str2 = str1.format("jack","jerry")
print(str2)
按照索引值进行传参 注意：大括号中传递得是Index值，不要超出索引范围
# {}中的数字代表着传递的参数的索引
str1 = "{1} say hello to {0}"
str2 = str1.format("jack","jerry")
print(str2)
按照索引来进行传参
# {}中的数字代表着传递的参数的索引
# 不支持切片取值
# 注意：format括号中的元素数量
str1 = "{0[1]} say hello to {0[0]}"
str2 =str1.format(["jack","jerry"])
print(str2)
关键字来进行传参
str1 = "{name} is {age} years old!"
str2 = str1.format(name = "tom",age = "100")
print(str2)
填充
"""
居中 ^
左对齐 <
右对齐 >
"""
# 第一个是冒号,第二个是要填充的字符(只能是一个字符),第三个是填充方向,第四个是填充的宽度
# 填充格式写在前面
str1 = "this"
str2 = "{:$^10}".format(str1)
print(str2)
str1 = "this"
str2 = "{:$<10}".format(str1)
print(str2)
str1 = "this"
str2 = "{:$>10}".format(str1)
print(str2)
调整精度(四舍五入)
str1 = 1.234563
str2 = "{:.2f}".format(str1)
print(str2)
str3 = "保留两位小数：%.2f"%(str1)
print(str3)
进制转换
# 十进制转
# 二进制
str1 = "{:b}".format(17)
print(str1)
# 八进制
str1 = "{:o}".format(17)
print(str1)
# 十进制
str1 = "{:d}".format(17)
print(str1)
# 十六进制
str1 = "{:x}".format(17)
print(str1)
逗号,还能用来做金额的千位分隔符：
# 三位一组
str1 = "{:,}".format(123456789)
print(str1)
内建函数
类型相关
int()
#创建或者将其他数据转化为整型
float()
#创建或者将其他数据转化为浮点型
bool()
#创建或者将其他数据转化为布尔型
complex()
#创建或者将其他数据转化为复数
str()
#创建或者将其他数据转化为字符串
list()
#创建或者将其他数据转化为列表
tuple()
#创建或者将其他数据转化为元组
set()
#创建或者将其他数据转化为集合
dict()
#创建或者将其他数据转化为字典
变量相关
id()
#获取变量的id标志
type()
#获取变量的类型字符串
print()
#打印变量的值
locals()
# 打印当前环境中所有的变量
# locals() 函数会以字典类型返回当前位置的全部局部变量。
user = "小明"
def func():
name = "小红"
age = 99
sex = "girl"
result = locals()
print(result)
func()
print(locals())
数学相关：
abs()
#获取一个数值的绝对值
var = -20
print(abs(var))
sum()
#计算一个序列的数值和
L = [1,2,3,4,5]
sum1 = sum(L)
print(sum1)
#
L1 = range(1,101)
sum2 = sum(L1)
print(sum2)
max()
'''
获取最大值
格式1：max(序列)
返回值：序列中的最大值
格式2：max(参数1,参数2...)
返回值：多个参数中的最大值
'''
L = [2,44,12,423,572,32]
print(max(L))
L1 = sorted(L) # sorted() 函数对所有可迭代的对象进行排序操作。
L2 = L1[-1]
print(L2)
list1 = [22,45,31,101,25,46,87,91]
val = 0
print(max(list1))
for var in list1:
if var > val:
val = var
print(val)
min()
'''
获取最小值
格式1：min(序列)
返回值：序列中的最小值
格式2：min(参数1,参数2...)
返回值：多个参数中的最小值
'''
L = [2,44,12,423,572,32,0,-65]
print(min(L))
list1 = [22,41,35,64,87,56,69]
# print(min(list1))
val = 0
# 先获取容器中的最大值
for var in list1:
# 如果var大于val
if var > val:
# 那么就给val重新赋值
val = var
# 通过对最大值的比较 再获取最小值
for var in list1:
if var < val:
val = var
print(val)
pow()
#获取一个数值的N次方
#前两个数先进行运算 然后再取第三个数的余数
print(pow(2,3,3))
round()
#对一个数值进行四舍五入操作
# 第二个参数是保留的几位小数
num = round(3.1255,2)
print(num)
range()
'''
产生连续数据的序列
# range(start, stop, step)
# start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
# stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
# step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
'''
num = range(1,11,2)
for val in num:
print(val)
进制相关：
hex()
#将十进制转化为16进制
print(hex(22))
oct()
#将十进制转化为8进制
print(oct(22))
bin()
#将十进制转化为2进制字符串:
print(bin(22))
chr()
#将ascii编码转化为字符
print(chr(65))
ord()
#将字符转化为ascii编码
print(ord("A"))
repr()
#获取任意数据的原始格式字符串
eval()
#将一个字符串当作python代码执行，字符串需要符合代码规范和repr配合
num = 10
str1 = "num + 1"
print(eval(str1))
num = int(input(">>>"))
print(num,type(num))
列表的操作
加法
L = [1,2,3]
L1 = [4,5,6]
print(L+L1)
乘法
L = [1,2,3]
print(L*2)
切片操作
'''
格式：变量 = 列表[:]
获取整个列表
格式：变量 = 列表[:结束索引]
获取列表开头到结束索引之前的数据组成的列表
格式：变量 = 列表[开始索引:]
获取列表开始索引到列表末尾的数据组成的列表
格式：变量 = 列表[开始索引:结束索引]
获取开始索引和结束索引之间的数据组成的列表（包含开始索引，不包含结束索引）
格式：变量 = 列表[开始索引:结束索引:步长]
获取开始索引和结束索引之间的数据（按照步长来获取）组成的列表（包含开始索引，不包含结束索引）
'''
L = [1,2,3,4,5,6,7,8,9,10]
L1 = L[6:3:-1]
print(L1)
成员检测
#检测一个数据是否在列表中
# 格式：值 in 列表
# 结果：布尔值
#检测一个数据是否不在列表中
#格式：值 not in 列表
#结果：布尔值
遍历操作
for...in...
L = [1,2,3,4,5]
for val in L:
print(val)
while
L = [1,2,3,4,5,6,7]
i = 0
while i遍历同等长度的二级列表
#列表 = [[值1,值2],[值1,值2],....]
#for 变量1,变量2 in 列表:
# 使用变量1和变量2
#注意：变量1取二级列表中的第一个值，变量2取第二个值
L = [[1,2],[3,4],[5,6]]
for val,var in L:
print(val,var)
遍历非同等长度的二级列表
#列表 = [[值1，值2]，[值1，值2,值3],[值]...]
#for 变量1 in 列表:
# for 变量2 in 变量1:
# 使用变量2(变量2是二级列表中的每个值)
L = [[1,2],[3,4],[5,6,7]]
for val in L:
print(val,type(val))
for var in val:
print(var,type(var))
append()追加
#功能：向列表的末尾添加新的元素
#格式：列表.append(值)
#返回值：None
#注意：新添加的值在列表的末尾，该函数直接操作原有列表
L = [1,2,3,4,5,6,7]
L.append(8)
L.append(7)
print(L)
insert()指定位置加入
#功能：在指定位置之前插入元素
#格式：列表.insert(索引,值)
#返回值:None
#注意：直接改变原有列表
L = [1,2,3,4,5,6,7]
L.insert(0,1)
print(L)
extend()继承
#功能：将一个列表继承另一个列表,把列表内容从后面添加
#格式：列表.extend(序列)
#返回值：None
#注意：直接改变原有列表
L = [1,2,3,4,5,6,7]
L1 = [8,9,10,11,12]
L.append(L1)
print(L)
L.extend(L1)
print(L)
pop()删除
#功能：在列表中移除一个元素
#格式：列表.pop([索引])
#返回值：返回删除的那个元素
#注意：没有指定索引，默认移除最后一个元素
L = [1,2,3,4,5,6,7]
L.pop()
L.pop(0) #可以传递索引值 来删除指定的元素
print(L)
remove()移除
#功能：移除指定的值
#格式：列表.remove(值)
#返回值：无
#注意：如果有索引的情况下推荐使用POP移除，效率比remove高
L = [1,2,3,4,5,6,7,8,9,10,11]
L.remove([7,8,9])
L.remove(8) #如果有多个相同的元素 默认删除第一个
print(L)
index()获取索引
#功能：获取某个值在列表中的索引
#格式：列表.index(值,[start,[stop]])
#返回值：整数
#注意：值不存在于列表时抛出异常错误！
L = [1,2,3,4,5,6,7,8,9,10,11]
print(L.index(8))
print(L.index(7,5))
L = [2,1,5,4,2,4,6,4,2,1,5]
print(L.pop(L.index(5,L.index(5)+1))) # L.index(5)+1查询第一个5的下一位开始查
print(L)
count()统计数量
#功能：计算某个元素出现的次数
#格式：列表.count(值)
#返回值：整数
L = [2,1,5,4,2,4,6,4,2,1,5]
print(L.count(2))
print(L.count(5))
print(L.count(6))
sort()排序
'''
功能：列表排序
格式：列表.sort() 按照从小到大排序（数字）
格式：列表.sort(reverse=True) 按照从大到小排序（数字）
格式：列表.sort(key=函数) 对值进行指定的函数处理之后在从小到大排序
格式：列表.sort(key=函数，reverse=True) 对值进行指定的函数处理之后在从大到小排序
返回值：None
注意：直接改变原有列表
'''
L = [2,1,4,3,7,6]
L.sort()
print(L)
L = [2,1,4,3,7,6]
L1 = L.sort()
L1 = sorted(L)
print(L)
print(L1)
L = [
{"name":"jack","age":18},
{"name":"rose","age":22},
{"name":"tom","age":102},
{"name":"jerry","age":19}
]
L.sort(key=lambda x:x["name"])
print(L)
reverse()反转
#功能：反转整个列表
#格式：列表.reverse()
#返回值：None
L = [2,1,4,3,7,6]
L.reverse()
print(L)
clear() 清空列表
list1 = [2,1,4,3,7,6]
list1.clear()
print(list1)
copy() 复制列表
list1 = [1,2,3,4,5,[6,7,8,9,[10,11,12,13]]]
list2 = list1.copy()
list1.append(100)
list1[5][4].append(14)
print(list1)
print(list2)
# copy()只拷贝了外部列表，有新的地址。内层还是原来的地址,内层变就跟着变
enumerate()枚举
#函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
#以下是 enumerate() 方法的语法:enumerate(sequence, [start=0])
#参数
#sequence -- 一个序列、迭代器或其他支持迭代对象。
#start -- 下标起始位置。
#返回值
#返回 enumerate(枚举) 对象。
shop_list = [["iphone",5000],["bike",800],["ipad",6000],["computer",8000]]
for num,shop in enumerate(shop_list):
print(num,shop)
列表推导式
例1：已知L = [1,2,3,4,5,6,7,8,9],求变量L内所有元素的平方组成的列表
for循环写法：
L = [1,2,3,4,5,6,7,8,9]
L1 = []
for val in L:
L1.append(val**2)
print(L1)
列表推导式
L = [1,2,3,4,5,6,7,8,9]
L1 = [var**2 for var in L]
print(L1)
例2：求L中所有偶数的平方
for循环写法
L = [1,2,3,4,5,6,7,8,9]
L1 = []
for val in L:
if val % 2 == 0:
L1.append(val**2)
print(L1)
列表推导式
L = [1,2,3,4,5,6,7,8,9]
L1 = [val**2 for val in L if val%2==0]
print(L1)
例3：L = ["jack","ada","tom","WE","file","continue","break"]求列表中所有元素的长度组成的列表
L = ["jack","ada","tom","WE","file","continue","break"]
L1 = [len(i) for i in L]
print(L1)
例4：已知str1="abc" str2="ABC" 求两个字符串中的元素的所有组合
str1="abc"
str2="ABC"
L1 = [x+y for x in str1 for y in str2 ]
print(L1)
例5：求x,y组成的元组 x是1~5之间的偶数 y是1~6之间的奇数
# L1 = [x for x in range(1,5) if x % 2==0]
# print(tuple(L1))
# L2 = [y for y in range(1,6) if y % 2==1]
# print(tuple(L2))
#
# list1 = [(x,y) for x in range(2,6,2) for y in range(1,7,2)]
# print(list1)
L = [(x,y) for x in range(1,6) if x%2==0 for y in range(1,6) if y%2==1]
print(L)
例6：已知 L = [[1,2,3],[4,5,6],[7,8,9]]求[3,6,9]组成的列表
L = [[1,2,3],[4,5,6],[7,8,9]]
L1 = [i[2] for i in L]
print(L1)
例7：求上面列表中[1,5,9]组成的列表
L1 = [L[i][i] for i in range(len(L))]
print(L1)
# i = 0,1,2
# 当i = 0 L[i] = [1,2,3] L[i][i] = 1
# 当i = 1 L[i] = [4,5,6] L[i][i] = 5
# 当i = 2 L[i] = [7,8,9] L[i][i] = 9
深浅拷贝
赋值操作 赋值后的列表跟随元列表进行改变
浅拷贝 只拷贝外层列表 内层列表跟随原列表进行改变
深拷贝 深拷贝拷贝整个列表 不跟随原列表进行改变
copy 深浅拷贝
# 容器类
# 引入copy模块
import copy
a = [1,2,3,4,[5,6,7]]
# 赋值 使用同一内存地址 所以会跟随原始数据改变
b = a
# 浅拷贝 只拷贝最外层地址 所以原始数据的内层发生变化时 会跟随改变
c = copy.copy(a)
# 深拷贝 拷贝所有的地址 所以无论原始数据如何改变 都不会变
d = copy.deepcopy(a)
a.append(8)
a[4].append(9)
print(a)
print(b)
print(c)
print(d)
元组的操作
加法
tuple1 = (1,2,3,4,5)
tuple2 = (8,9,10)
print(tuple1 + tuple2)
乘法
c = (1,2,3)
print(c*2)
元组的遍历
for ... in
t = (1,2,3,4)
for val in t:
print(val)
while
t = (1,2,3,4)
i = 0
while i < len(t):
print(t[i])
i += 1
遍历长度相同的多级元组
#元组 = ((值1,值2...),(值1,值2...)...)
#for 变量1，变量2.. in 元组:
# 使用变量1和变量2
t = ((1,2),(3,4),(5,6))
for val,var in t:
print(val,var)
遍历长度不同的多级元组
#元组 = ((值1,值2...),(值1,值2...)...)
#for 变量1 in 元组:
# for 变量2 in 变量1：
# 使用变量2获取每个值
t = ((1,2),(3,4,5),(6,7))
for val in t:
for var in val:
print(val,var)
index()获取指定值在元组中的索引值
#获取指定值在元组中的索引值
#格式：元组.index(值)
#返回值：整数
t = (1,2,3,4)
print(t.index(2))
count()计算某个值在元组中出现的次数
#计算某个值在元组中出现的次数
#格式：元组.count(元素值,star,stop)
#返回值：整数
t = (1,2,3,4,4,5)
print(t.count(4)）
元组推导式
基本格式：
#格式： 变量 = (i for i in 元组)
#结果：不是元组而是一个生成器(generator)
var = (1,2,3,4,5,6)
res = (i**2 for i in var)
print(res)
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
for i in res:
print(i)
print(next(res))
带条件格式：
#格式： 变量 = (i for i in 元组 if 条件表达式)
#结果：不是元组而是一个生成器(generator)
多循环推导式：
#格式： 变量 = (x+y for x in 元组1 for y in 元组2)
#结果：不是元组而是一个生成器(generator) x+y可以是其他操作
带条件的多循环推导式：
#格式： 变量 = (x+y for x in 元组1 for y in 元组2 if 条件表达式)
#结果：不是元组而是一个生成器(generator) x+y可以是其他操作
字典的操作
创建多个元素的字典
#方式1：
# 变量 = {键:值,键:值....}
dict1 = {"a":1,"b":2,"c":3}
print(dict1)
#方式2：
# 变量 = dict({键:值,键:值....})
dict2=dict({"a":1,"b":2,"c":3})
print(dict2)
#方式3：
# 变量 = dict(键=值,键=值...)
# 注意：该方式键作为形参名使用，不可以添加引号，必须符合变量规则
dict3 = dict(a=1,b=2,c=3)
print(dict3)
#方式4：
# 变量 = dict([(键,值),(键,值)...])
# 变量 = dict([[键,值],[键,值]...])
# 变量 = dict(((键,值),(键,值)...))
dict1 = dict[["a",1],["b",2],["c",3]]
print(dict1)
#方式5：
# 变量 = dict(zip((键，键...),(值,值...)))
# 选最少的为数量准则
list1 = ["a","b","c"]
list2 = [1,2,3]
dict4 = dict(zip(list1,list2))
print(dict4)
dict5 = dict(zip(("a","b","c"),(1,2,3,4,5)))
print(dict5)
list1 = ["a","b","c","d","e","f"]
list2 = [1,2,3]
dict4 =dict(zip(list1,range(1,10)))
print(dict4)
字典的遍历
遍历键
#for 变量i in 字典:
#使用i(默认)遍历所有的键，有键就可以通过变量访问其值
for key in dict1:
print(key)
遍历值
#for 变量i，变量j in 字典.values():
#使用变量i遍历所有键，通过变量j遍历所有值
for value in dict1.values():
print(value)
遍历键和值
#for 变量i，变量j in 字典.items():
#使用变量i遍历所有键，通过变量j遍历所有值
for key,value in dict1.items():
print(key,value)
clear()
#功能：清空字典
#格式：字典.clear()
#返回值：None
#注意：直接改变原有字典
dict1 = {"a":1,"b":2,"c":3}
dict1.clear()
print(dict1)
copy()
#功能：复制字典,浅拷贝
#格式：字典.copy()
#返回值：新的字典
dict1 = {"a":1,"b":2,"c":3}
dict2 = dict1.copy()
print(dict1)
print(dict2)
dict1 = {"a":1,"b":2,"c":3}
dict2 = dict1.copy()
dict1["e"] = 5
print(dict1)
print(dict2)
# 浅拷贝
dict1 = {"a":1,"b":2,"c":3,"d":{"e":4,"f":6}}
dict2 = dict1.copy()
dict1["d"]["f"] = 5
print(dict1)
print(dict2)
fromkeys()
#功能：使用指定的序列作为键创建字典
#格式：字典.fromkeys(键,值)
#返回值：字典
dict1 = {}
lsd = ["d","e","f"]
lsd1 = [1,2,3]
dict2 = dict1.fromkeys(lsd,lsd1)
print(dict2)
# 键唯一
var1 = "PHP"
var2 = ["a","b","c"]
dict2 = dict1.fromkeys(var1,var2)
# 整个var2都作为值的部分
print(dict2)
get()
#功能：根据键获取指定的值
#格式：字典.get(键，[默认值])
#返回值:值
#注意:如果键不存在，则使用默认值,如果没有默认值则返回None
dict1 = {"a":1,"b":2,"c":3,"d":{"e":4,"f":6}}
print(dict1["d"])
print(dict1.get("d"))
items()
#功能：将字典的键值转化成类似元组的形式方便遍历
#格式：字典.items()
#返回值：类似元组的类型
dict1 = {"a":1,"b":2,"c":3,"d":{"e":4,"f":6}}
print(dict1.items())
keys()
#功能：将字典的所有键组成一个序列
#格式：字典.keys()
#返回值:序列
dict1 = {"a":1,"b":2,"c":3,"d":{"e":4,"f":6}}
print(dict1.keys())
values()
#功能：将字典的所有值组成一个序列
#格式：字典.values()
#返回值：序列
dict1 = {"a":1,"b":2,"c":3,"d":{"e":4,"f":6}}
print(dict1.values())
pop()
#功能：移除字典中指定的元素
#格式：字典.pop(键,[默认值])
#返回值：被移除的键对应的值
#注意：如果键不存在，则报错，如果键不存在，默认值设置，则返回默认值
dict1 = {"a":1,"b":2,"c":3,"d":{"e":4,"f":6}}
dict2 = dict1.pop("a")
print(dict2)
print(dict1)
# 修改键
dict2 = {"a":1}
dict2["b"] = dict2.pop("a")
print(dict2)
popitem()
#功能：移除字典中的键值对
#格式：字典.popitem()
#返回值：键值对组成的元组
#注意：弹一个原字典就少一个，字典为空就不可以弹出，会报错
dict1 = {"a":1,"b":2,"c":3,"d":{"e":4,"f":6}}
dict1.popitem()
print(dict1)
dict1.popitem()
print(dict1)
dict1.popitem()
print(dict1)
dict1.popitem()
print(dict1)
setdefault()
#功能：添加一个元素
#格式：字典.setdefault(键,值)
#返回值:None
#注意：添加是键存在则不进行任何操作，键不存在则添加，添加时不写值，默认None为值
dict1 = {"a":1,"b":2,"c":3,"d":{"e":4,"f":6}}
dict1.setdefault("d",4)
print(dict1)
dict1.setdefault("g",8)
print(dict1)
dict1.setdefault("h")
print(dict1)
update()
#功能：修改字典中的值
#方式1：
# 格式： 字典.update(键=值)
# 返回值：None
# 注意:此处的键作为关键字参数使用，不可以添加''
#方式2：
# 格式: 字典.update({键:值})
# 返回值：None
dict1 = {"a":1,"b":2,"c":3,"d":{"e":4,"f":6}}
dict1.update(d=5)
print(dict1)
dict1.update({"e":6})
print(dict1)
# 如果添加的key在原始字典中没有 那么就添加新的键值对,如果有那么就更新原字典的键所对应的值
dict2 = {"f":7,"g":8,"a":0}
dict1.update(dict2)
print(dict1)
集合的操作
确定的无序的一组数据就是集合。
- 集合中的值不会重复(唯一)
- 集合中的元素没有任何顺序
- 集合中可以使用整数，浮点数，布尔值，复数，字符串，元组，冰冻集合
add()
#向集合中添加一个元素，添加位置随机
#格式:集合.add(值)
#返回值：None
#注意：直接改变原有集合
s = {1,2,3,4,5,6}
s.add(7)
print(s)
pop()
#随机删除集合中的一个元素
#格式：集合.pop()
#返回值：删除的那个元素
#注意：直接改变原有集合
s = {1,2,3,4,5,6}
s.pop()
print(s)
remove()
#删除集合中的某个元素
#格式：集合.remove(值)
#返回值：None
#注意：直接改变原有集合
#remove移除非成员值会报错
s = {1,2,3,4,5,6,7}
s.remove(7)
print(s)
discard()
#删除集合中的某个元素
#格式：集合.dicard(值)
#返回值：None
#注意：直接改变原有集合
remove移除非成员值会报错，discard移除非成员值，不报错！
s = {1,2,3,4,5,6,7}
s.discard(9)
print(s)
clear()
#清空集合
#格式：集合.clear()
#返回值：None
#注意：直接改变原有集合
s = {1,2,3,4,5,6,7}
s.clear()
print(s)
copy()
#复制集合，浅拷贝
#格式：集合.copy()
#返回值：复制的一份集合
s = {1,2,3,4,5,6,7}
s2 = s.copy()
print(s2)
difference()
#差集
#格式:集合1.difference(集合2)
#返回值：集合
#操作：获取存在于集合1但是不存在与集合2中的数据的集合
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
result = x.difference(y)
#x有y没有
result1 = y.difference(x)
#y有x没有
print(result)
print(result1)
difference_update()
#差集 更新
#格式:集合1.difference(集合2)
#返回值：None 直接将结果赋值给集合1
#操作：获取存在于集合1但是不存在与集合2中的数据的集合
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
x.difference_update(y)
#把x中的元素删除，将差集直接赋值给x
print(x)
intersection()
#交集
#格式：集合1.intersection(集合2)
#返回值：集合
#操作：获取即存在于集合1又存在于集合2中的数据组成的集合
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
result = x.intersection(y)
print(result)
result = y.intersection(x)
print(result)
intersection_update()
#交集更新
#格式：集合1.intersection_update(集合2)
#返回值：None 直接将结果赋值给集合1
#操作：获取即存在于集合1又存在于集合2中的数据组成的集合
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
x.intersection_update(y)
print(x)
y.intersection_update(x)
print(y)
union()
#并集
#格式：集合1.union(集合2)
#返回值：集合
#操作：将集合1和集合2中所有数据新建一个集合（去重）
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
result = x.union(y)
print(result)
result1 = y.union(x)
print(result1)
update()
#并集更新
#格式：集合1.update(集合2)
#返回值：无 直接将结果赋值给集合1
#操作：将集合1和集合2中所有数据新建一个集合(去重)
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
x.update(y)
print(x)
issuperset()
#检测一个集合是不是另外一个集合的超集
#格式:集合1.issuperset(集合2)
#返回值:布尔值
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
z = {4,5,6}
result = y.issuperset(z)
print(result)
issubset()
#检测一个集合是不是另外一个集合的子集
#格式：集合1.issubset(集合2)
#返回值：布尔值
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
z = {4,5,6}
result = z.issubset(y)
print(result)
isdisjoint()
#检测2个集合是否不相交
#格式：集合1.isdisjoint(集合2)
#返回值：布尔值
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
result = x.isdisjoint(y)
print(result)
symmetric_difference()
#对称差集操作
#格式：集合1.symmetric_difference（集合2）
#返回值：集合
#操作：将集合1和集合2不相交的部分取出组成的新的集合
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
result = x.symmetric_difference(y)
result1 = y.symmetric_difference(x)
print(result)
print(result1)
symmetric_difference_update()
#对称差集更新操作
#格式：集合1.symmetric_difference_update（集合2）
#返回值：None 直接将结果赋值给集合1
#操作：将集合1和集合2不相交的部分取出组成的新的集合
x = {1,2,3,4,5,6}
y = {4,5,6,7,8,9}
x.symmetric_difference_update(y)
print(x)
冰冻集合
创建空的冰冻集合
#变量 = frozenset()
创建多个元素的集合
#变量 = frozenset(容器类数据)
s = frozenset()
print(s,type(s))
s1 = frozenset([1,2,3,6,54])
print(s1)