Python变量——字符串、列表、元组、字典、set
1.字符串
单行字符串：由一对单引号或一对双引号表示，也可以在字符串中包含单引号和双引号；多行字符串：由一对三单引号/双引号表示；
stra = 'abcd'
strb = "I'm your teacher," \
"Are your ok?" \
"Hello!"
strc = '''I'm your teacher,
Are you ok?
Hello!'''
print(stra)
print(strb)
print(strc)结果：
序号：正向递增序号（0,1,.....）;反向递减序号（...,-2,-1）
•方法 和函数类似，同样是封装了独立的功能，方法是python对数据执行的操作。
•方法 需要通过 对象（本处指字符串） 来调用，表示针对这个 对象 要做的操作。
1.1常用操作
x+y
x+y ： 字符串变量 之间使用 + 拼接字符串
str1 = 'i'
str2 = 'love'
str3 = 'apple'
#result:I love apple!
print(str1.title() + " " + str2 + " " + str3 + "!")n*x或x*n
n*x或x*n ： 字符串变量 可以和 整数 使用， 重复拼接相同的字符串
str2 = 'love'
#result:lovelovelove
print(str2 * 3)x in s
x in s ： 如果x是s的子串，返回True，否则返回False
str1 = 'abcdhurifhkjfmklam'
str2 = 'hur'
str3 = 'gqx'
#True
print(str2 in str1)
#False
print(str3 in str1)
#1
if str2 in str1:
print(1)
else:
print(0)
#0
if str3 in str1:
print(1)
else:
print(0)len(x)
len(x)：返回字符串x的长度
str1 = 'abcdhurifhkjfmklam'
# 18
print(len(str1))str(x)
str(x)：任何类型的x所对应的字符串格式
a = 12345
# 12345ok
print(str(a) + "ok")int()
int()函数可以实现将数字或字符转为整数，如果是实数，则只取整数部分
print(int(125.1)) #125
print(int(-22.1234))#-22
print(int("1111")) #1111
print(int(1/7)) #0hex(x)或oct(x)
hen(x)或otd(x)：整数x的十六进制或八进制小写形式字符串
a = 100
#0x64 十六进制
print(hex(a))
# 0o144 八进制
print(oct(a))chr(x)
chr(x)：Unicode—>单字符
Unicode（统一字符编码）是python字符串的编码形式，从0-1114111(OX10FFFF)空间，每个编码对应一个字符。例如 chr(9801)对应小金牛的图案，ord(“青”)对应的Unicode编码是 38738
#♉
print(chr(9801))ord(x)
ord(x)：单字符—>Unicode
#97
print(ord("a"))string.title()
把字符串的每个单词首字母大写
str1 = 'a little prince'
#result:A Little Prince
print(str1.title())1.2大小写转换
string.upper()
所有字母大写
string.lower()
所有字母小写
name = 'Ada Lovelace'
#ADA LOVELACE
print(name.upper())
#ada lovelace
print(name.lower())string.capitalize()
把字符串的第一个字符大写
name = 'a little cat is lovely'
#A little cat is lovely
print(name.capitalize())string.swapcase()
翻转 string 中的大小写
name = 'aBCdeFGh'
#AbcDEfgH
print(name.swapcase())1.3去除空白字符
空白字符：使用制表符或换行符可以添加空白
print("Python")
print("\tPython")
print("Languages:\nPython\nC\nJavaScript")
print("Languages:\n\tPython\n\tC\n\tJavaScript")结果：
rstrip():删除字符串末尾的空白 right
lstrip():删除字符串开头的空白 left
strip():删除字符串两端的空白
str1 = "Python "
str2 = " Java"
str3 = " momo "
##Python
print(str1.rstrip())
#Java
print(str2.lstrip())
#momo
print(str3.strip())1.4字符串的索引、切片
切片方法适用于字符串、列表、元组。
◦切片 使用 索引值 来限定范围，从一个大的 字符串 中 切出 小的 字符串
◦列表 和 元组 都是 有序 的集合，都能够 通过索引值 获取到对应的数据
注意：指定的区间属于 左闭右开 型，从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)，索引从0开始，如果倒着数，最后一位是-1。
使用 [ ] 选取字符串中一个或多个字符：
索引：<字符串>[M] 返回字符串中单个字符
<字符串>[M:N] 返回字符串中遗传字符；若M缺失表示至开头，N缺失表示至结尾
切片：<字符串>[M:N:K] 表示根据步长K对字符串切片
<字符串>[::-1] 逆序表示字符串
切片不会导致越界，但通过下标访问会越界（会抛出异常）
message = "我叫齐天大圣"
print(message) #打印字符串 "我叫齐天大圣"
print(message[2]) #打印正数第三个字 齐
print(message[-1]) #打印最后一个字 圣
print(message[0:2]) #打印第一个到第二个字 我叫
print(message[-2:]) #打印最后两个字 大圣
#[M:N:K] 表示根据步长K对字符串切片
print(message[-2:-5:-1]) #取“大天齐”，取倒序则需要用到步长，步长默认为1，则为正序一个一个取，倒序一个一个取则步长为-1
print(message[-2:-5]) #如果不用步长为-1则会无法显示 输出为空
print(message[::-1]) #圣大天齐叫我
print(message[::2]) #我齐大
print(message[10:]) # 输出空
print(message[10]) #ndexError: string index out of range1.5判断类型
isspace
string.isspace() 如果 string 中只包含空格，则返回 True
strs = "I love apple"
strt = " "
#False
print(strs.isspace())
#True
print(strt.isspace())isnumeric
alphanumeric：字母数字的
string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
str1 = "I love apple"
str2 = "Iloveapple"
str3 = "A56Ghbmn"
#False
print(str1.isalnum())
#True
print(str2.isalnum())
#True
print(str3.isalnum())isalpha
alphabet：字母表，基本要素
string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True
str1 = "I love apple"
str2 = "Iloveapple"
str3 = "A56Ghbmn"
#False
print(str1.isalpha())
#True
print(str2.isalpha())
#False
print(str3.isalpha())isdecimal、isdigit、isnumeric
这三个方法均可用来检测字符串是否只由数字组成，注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。
| isdecimal | isdigit | isnumeric | |
| 半角数字 | True | True | True |
| 全角数字 | True | True | True |
| 小数 | False | False | False |
| 负数 | False | False | False |
| 罗马数字(大小写) | False | False | True |
| 中文数字（简繁体） | False | False | True |
| byte数字（单字节） | Error | True | Error |
str1 = "A56Ghbmn" #数字字母
print(str1.isdecimal()) #False
print(str1.isdigit()) #False
print(str1.isnumeric()) #False
str2 = "123" #半角数字
print(str2.isdecimal()) #True
print(str2.isdigit()) #True
print(str2.isnumeric()) #True
str3 = "１２３" #全角数字
print(str3.isdecimal()) #True
print(str3.isdigit()) #True
print(str3.isnumeric()) #True
str4 = "123.45" #小数
print(str4.isdecimal()) #False
print(str4.isdigit()) #False
print(str4.isnumeric()) #False
str5 = "-50" #负数
print(str5.isdecimal()) #False
print(str5.isdigit()) #False
print(str5.isnumeric()) #False
str6 = u"23443434" #十进制数字
print(str6.isdecimal()) #True
print(str6.isdigit()) #True
print(str6.isnumeric()) #True
str7 = "ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹ" #大小写罗马数字
print(str7.isdecimal()) #False
print(str7.isdigit()) #False
print(str7.isnumeric()) #True
str8 = "一二三肆伍" #汉字简繁体
print(str8.isdecimal()) #False
print(str8.isdigit()) #False
print(str8.isnumeric()) #True
str9 = b"1"
print(str9.isdecimal()) #Error AttributeError: 'bytes' object has no attribute 'isdecimal'
print(str9.isdigit()) #True
print(str9.isnumeric()) #Error AttributeError: 'bytes' object has no attribute 'isnumeric'istitle
string.istitle() 如果 string 是标题化的(每个单词的首字母大写)则返回 True
strs = "A Bcd Efgh"
strt = "A bcd Efg"
print(strs.istitle()) #True
print(strt.istitle()) #Falseislower
string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
isupper
string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True
str1 = "ab67shkBH98"
print(str1.islower()) # False
print(str1.isupper()) # False
str2 = "abc680opl"
print(str2.islower()) # True
print(str2.isupper()) # False
str3 = "GLORIA123"
print(str3.islower()) # False
print(str3.isupper()) # True1.6查找和替换
startswith
string.startswith(str) 检查字符串是否是以 str 开头，是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
startswith()方法语法：
str.startswith(str, beg=0,end=len(string));
参数
- str -- 检测的字符串。
- strbeg -- 可选参数用于设置字符串检测的起始位置。
- strend -- 可选参数用于设置字符串检测的结束位置。
str = "this is string example....wow!!!"
print(str.startswith( 'this' )) #True
print(str.startswith( 'is', 2, 4 )) #True
print(str.startswith( 'this', 2, 4 )) #Falseendswith
string.endswith(str) 检查字符串是否是以 str 结束，是则返回 True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
endswith()方法语法：
str.endswith(suffix[, start[, end]])
参数
- suffix -- 该参数可以是一个字符串或者是一个元素。
- start -- 字符串中的开始位置。
- end -- 字符中结束位置。
str = "this is string example....wow!!!"
suffix = "wow!!!"
print(str.endswith(suffix)) #True
print(str.endswith(suffix, 20)) #True
suffix = "is"
print(str.endswith(suffix, 2, 4)) #True
print(str.endswith(suffix, 2, 6)) #Falsefind
string.find(str, start=0, end=len(string)) 检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果包含则返回开始的索引值，否则返回 -1。
- str -- 指定检索的字符串
- beg -- 开始索引，默认为0
- end -- 结束索引，默认为字符串的长度
str1 = "this is string example....wow!!!"
str2 = "exam"
print(str1.find(str2)) #15
print(str1.find(str2, 10)) #15
print(str1.find(str2, 40)) #-1rfind
string.rfind(str, start=0, end=len(string)) 类似于 find()，不过是从右边开始查找，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
- str -- 查找的字符串
- beg -- 开始查找的位置，默认为 0
- end -- 结束查找位置，默认为字符串的长度。
str = "this is really a string example....wow!!!"
substr = "is"
print (str.rfind(substr)) #5
print (str.rfind(substr, 0, 10)) #5
print (str.rfind(substr, 10, 0)) #-1
print (str.find(substr)) #2
print (str.find(substr, 0, 10)) #2
print (str.find(substr, 10, 0)) #-1index
string.index(str, start=0, end=len(string)) 跟 find() 方法类似，不过如果 str 不在 string 会报异常。
- str -- 指定检索的字符串
- beg -- 开始索引，默认为0。
- end -- 结束索引，默认为字符串的长度。
str1 = "this is string example....wow!!!"
str2 = "exam"
print(str1.index(str2)) #15
print(str1.index(str2, 10)) #15
print(str1.index(str2, 40)) #Traceback (most recent call last): ValueError: substring not foundlist.index(x[, start[, end]])，index() 函数用于从列表中找出某个值第一个匹配项的索引位置。如果没有找到对象则抛出异常。
- x-- 查找的对象。
- start-- 可选，查找的起始位置。
- end-- 可选，查找的结束位置。
aList = [123, 'xyz', 'runoob', 'abc']
print("xyz 索引位置：",aList.index("xyz")) # xyz 索引位置： 1
print ("runoob 索引位置 : ", aList.index( 'runoob', 1, 3 )) # runoob 索引位置 : 2rindex
string.rindex(str, start=0, end=len(string)) 类似于 index()，不过是从右边开始。返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常。
注意：'list' object has no attribute 'rindex'
- str -- 查找的字符串
- beg -- 开始查找的位置，默认为0
- end -- 结束查找位置，默认为字符串的长度。
str1 = "this is string example....wow!!!"
str2 = "exam"
print(str1.rindex(str2)) #15
print(str1.rindex(str2, 10)) #15
print(str1.rindex(str2, 40)) #Traceback (most recent call last): ValueError: substring not foundreplace
replace() 方法用另一个指定的短语替换一个指定的短语。
注释：如果未指定其他内容，则将替换所有出现的指定短语。
string.replace(old_str, new_str, num=string.count(old))
| oldvalue | 必需。要检索的字符串。 |
| newvalue | 必需。替换旧值的字符串。 |
| count | 可选。数字，指定要替换的旧值出现次数。默认为所有的出现。 |
txt = "I like bananas"
x = txt.replace("bananas", "apples")
print(x) # I like apples
#默认替换所有出现的单词
txt = "one one was a race horse, two two was one too."
x = txt.replace("one", "three")
print(x) #three three was a race horse, two two was three too.
#定要替换的旧值出现次数
txt = "one one was a race horse, two two was one too."
x = txt.replace("one", "three", 2)
print(x)适用于列表、字典。
li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
for a in range(len(li)):
li[a] = li[a].replace("alec" , "Lily")
print(li) #['Lily', ' aric', 'Alex', 'Tony', 'rain']
#遍历元组需要先转换成列表，通过list()来实现，最后输出前需要转换回元组，通过tuple()来实现。因为'tuple' object does not support item assignment
tu = list(tu)
for b in range(len(tu)):
tu[b] = tu[b].replace("alec" , "Lily")
tu = tuple(tu)
print(tu) #('Lily', ' aric', 'Alex', 'Tony', 'rain')
for c in dic:
dic[c] = dic[c].replace("alex" , "Lily")
print(dic) #{'k3': 'Alex', 'k1': 'Lily', 'k2': ' aric', 'k4': 'Tony'}1.7文本对齐
ljust
string.ljust(width) 返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串
str.ljust(width, fillchar)
- width -- 指定字符串长度。
- fillchar -- 填充字符，可选，默认为空格。
str = "this is string example....wow!!!"
print(str.ljust(50, '0')) #this is string example....wow!!!000000000000000000rjust
string.rjust(width) 返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串
str.rjust(width, fillchar)
- width -- 指定字符串长度。
- fillchar -- 填充字符，可选，默认为空格。
str = "this is string example....wow!!!"
print(str.rjust(50, '0')) #000000000000000000this is string example....wow!!!center
Python center() 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。
str.center(width, fillchar)
- width -- 字符串的总宽度。
- fillchar -- 填充字符，选，默认为空格。
strs = 'abcd'
#result: abcd
print(strs.center(10))
#result:***abcd***
print(strs.center(10,'*'))1.8拆分和连接
partition
partition 分割
partition() 方法用来根据指定的分隔符将字符串进行分割。
如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
str.partition(str)
str : 指定的分隔符
str = "this is string example....wow!!!"
print(str.partition(" ")) #('this', ' ', 'is string example....wow!!!')
str = "www.runoob.com"
print(str.partition(".")) #('www', '.', 'runoob.com')rpartition
string.rpartition(str) 类似于 partition() 方法，不过是从右边开始查找
str = "this is string example....wow!!!"
print(str.rpartition(" ")) #('this is string', ' ', 'example....wow!!!')
str = "www.runoob.com"
print(str.rpartition(".")) #('www.runoob', '.', 'com')split
string.split(str="", num) 以 str 为分隔符拆分 string，str 默认包含 '\r', '\t', '\n' 和空格
分割次数num默认为 -1, 即分隔所有。如果 num 有指定值，则仅分隔 num + 1 个子字符串
str = "Line1-abcdef \nLine2-abc \nLine4-abcd"
print(str.split( )) # 以空格为分隔符，包含 \n ['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
print(str.split(' ')) # 以空格为分隔符 ['Line1-abcdef', '\nLine2-abc', '\nLine4-abcd']
print(str.split(' ', 1 )) # 以空格为分隔符，分隔成两个 ['Line1-abcdef', '\nLine2-abc \nLine4-abcd']splitlines
string.splitlines([keepends]) 按照行('\r', '\n', '\r\n')分隔，返回一个包含各行作为元素的列表
- keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，输出结果不包含换行符，如果为 True，输出结果则保留换行符。
能被识别的行界符：
| 行界符 | 描述 |
|---|---|
\n |
Line Feed 换行 |
\r |
Carriage Return 回车 |
\r\n |
Carriage Return + Line Feed 回车+换行 |
\v or \x0b |
Line Tabulation |
\f or \x0c |
Form Feed 换页 |
\x1c |
File Separator 文件分隔符 |
\x1d |
Group Separator 组分隔符 |
\x1e |
Record Separator 记录分隔符号 |
\x85 |
Next Line (C1 Control Code) |
\u2028 |
Line Separator 行分隔符 |
\u2029 |
Paragraph Separator 段落分隔符号 |
strs = 'ab c\n\nde fg\rkl\r\n'
print(strs.splitlines()) # ['ab c', '', 'de fg', 'kl']
print(strs.splitlines(False)) # ['ab c', '', 'de fg', 'kl']
print(strs.splitlines(True)) #['ab c\n', '\n', 'de fg\r', 'kl\r\n']join
string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串,返回通过指定字符连接序列中元素后生成的新字符串。
str.join(sequence)
- sequence -- 要连接的元素序列。
str = "-"
seq = ("a", "b", "c") # 字符串序列
print(str.join( seq )) #a-b-c列表
列表由一系列按特定顺序排列的元素组成，用[]来表示列表，并用逗号分隔其中的元素。比如：bicycles = ['trek','cannondale','redline','specialized']
列表：•List（列表） 是Python中使用最频繁的数据类型，在其他语言中通常叫做数组
•专门用于存储一串信息
•列表用[ ]定义，数据 间使用,分隔
•列表的索引从0开始
使用列表中的各个值：
bicycles = ['trek','cannondale','redline','specialized']
message = "My first bicycle was a " + bicycles[0].title() + "."
print(message)#My first bicycle was a Trek.应用场景：
•尽管 Python 的 列表 中可以 存储不同类型的数据，但是在开发中，更多的应用场景是
1.列表 存储相同类型的数据
2.通过 迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作
创建列表
定义普通列表
创建列表： list_name = []
motorcycles = ['honda','yamaha','suzuki']创建数字列表
可以使用range()
range()函数还可以指定步长，例如 range(2,11,2),从2开始数，然后不断加2，直到达到或超过终值(11)，结果为2,4,6,8,10
numbers1 = list(range(1,6))
print(numbers1) #[1, 2, 3, 4, 5]
numbers2 = list(range(2,11,2))
print(numbers2) #[2, 4, 6, 8, 10]增加
insert
列表.insert(索引, 数据)：在指定位置插入数据
motorcycles = ['honda','yamaha','suzuki']
print(motorcycles) #['honda', 'yamaha', 'suzuki']
motorcycles.insert(0,'ducati')
print(motorcycles) #['ducati', 'honda', 'yamaha', 'suzuki']
motorcycles.insert(2,'dayang')
print(motorcycles) #['ducati', 'honda', 'dayang', 'yamaha', 'suzuki']append
列表.append(数据)：在末尾追加数据
motorcycles = ['honda','yamaha','suzuki']
print(motorcycles) #['honda', 'yamaha', 'suzuki']
motorcycles.append('ducati')
print(motorcycles) #['honda', 'yamaha', 'suzuki', 'ducati']extend
列表1.extend(列表2)：将列表2 的数据追加到列表
motorcycles = ['honda','yamaha','suzuki']
print(motorcycles) #['honda', 'yamaha', 'suzuki']
bicycles = ['trek','cannondale','redline','specialized']
motorcycles.extend(bicycles)
print(motorcycles) #['honda', 'yamaha', 'suzuki', 'trek', 'cannondale', 'redline', 'specialized']修改
列表[索引] = 数据：修改指定索引的数据
motorcycles = ['honda','yamaha','suzuki']
print(motorcycles) #['honda', 'yamaha', 'suzuki']
motorcycles[0] = 'ducati'
print(motorcycles) #['ducati', 'yamaha', 'suzuki']删除
del
del 列表[索引] ：删除指定索引的数据
motorcycles = ['honda','yamaha','suzuki']
print(motorcycles) #['honda', 'yamaha', 'suzuki']
del motorcycles[0]
print(motorcycles) #['yamaha', 'suzuki']remove
列表.remove(数据) ：删除第一个出现的指定数据（根据值删除元素）
motorcycles = ['honda','yamaha','suzuki']
print(motorcycles) #['honda', 'yamaha', 'suzuki']
motorcycles.remove('yamaha')
print(motorcycles) #['honda', 'suzuki']pop
列表.pop ：删除末尾数据
motorcycles = ['honda','yamaha','suzuki']
print(motorcycles) #['honda', 'yamaha', 'suzuki']
motorcycles.pop()
print(motorcycles) #['honda', 'yamaha']列表.pop(索引) ：删除指定索引数据
motorcycles = ['honda','yamaha','suzuki']
print(motorcycles) #['honda', 'yamaha', 'suzuki']
motorcycles.pop(1)
print(motorcycles) #['honda', 'suzuki']clear
列表.clear ：清空列表
motorcycles = ['honda','yamaha','suzuki']
print(motorcycles) #['honda', 'yamaha', 'suzuki']
motorcycles.clear()
print(motorcycles) #[]统计
len
len(列表) ：列表长度
count
列表.count(数据) ：数据在列表中出现的次数
motorcycles = ['honda','yamaha','suzuki']
print(len(motorcycles)) #3
print(motorcycles.count('honda')) #1min(列表)，max(列表)，sum(列表)
对数字列表也可以执行简单的统计计算：
list = [10,5,9,4,20,14,6,7]
print(min(list)) #4
print(max(list)) #20
print(sum(list)) #75排序
sort
列表.sort() ：升序排序 （永久改变，无法回到从前的顺序），该方法没有返回值。
使用 list.sort() 方法，它会直接修改原列表（并返回 None 以避免混淆），通常来说它不如 sorted() 方便 ——— 但如果你不需要原列表，它会更有效率。
a = [5, 2, 3, 1, 4]
print(a.sort())结果：None
a = [5, 2, 3, 1, 4]
a.sort()
print(a)结果：[1, 2, 3, 4, 5]
参考文档：排序指南 — Python 3.8.17 文档
Python列表有一个内置的 list.sort() 方法可以直接修改列表。还有一个 sorted() 内置函数，它会从一个可迭代对象构建一个新的排序列表。list.sort() 方法只是为列表定义的，而 sorted() 函数可以接受任何可迭代对象。
list.sort( key=None, reverse=False)
- key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
- reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
cars = ['bmw','audi','toyota','subaru']
cars.sort()
print(cars) #['audi', 'bmw', 'subaru', 'toyota'] 按字母升序排列
cars.sort(reverse=True)
print("Cars: ",cars) #Cars: ['toyota', 'subaru', 'bmw', 'audi']关于key,通过指定列表中的元素排序来输出列表
#获取列表的第二个元素
def takeSecond(elem):
return elem[1]
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
random.sort(key=takeSecond)
print(random) #[(4, 1), (2, 2), (1, 3), (3, 4)]sorted
sorted(列表)：对列表进行临时排序（不影响它们在列表中的原始排列顺序）
sorted(iterable, key=None, reverse=False)
- iterable -- 可迭代对象。
- key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
- reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
cars = ['bmw','audi','toyota','subaru']
sorted(cars)
print("cars:",cars) #cars: ['bmw', 'audi', 'toyota', 'subaru']
print("cars:",sorted(cars)) #cars: ['audi', 'bmw', 'subaru', 'toyota']
print(sorted(cars,reverse=True))#['toyota', 'subaru', 'bmw', 'audi']列表或字典：
>>> sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]或者：
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]关键函数
list.sort() 和 sorted() 都有一个 key 形参来指定在进行比较之前要在每个列表元素上进行调用的函数。
例如，下面是一个不区分大小写的字符串比较：
>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']一种常见的模式是使用对象的一些索引作为键对复杂对象进行排序。例如：
列表里面是元组时：
student_tuples = [
('john', 'A', 15),
('jane', 'B', 12),
('dave', 'B', 10),
]
# sort by age
print(sorted(student_tuples, key=lambda student: student[2]))结果：[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
列表里面是字典时：
student_tuples = [
{'name': 'sumcet', 'age': 18},
{'name': 'bbu', 'age': 11}
]
a = sorted(student_tuples, key=lambda x: x['age'])
print(a)结果：[{'name': 'bbu', 'age': 11}, {'name': 'sumcet', 'age': 18}]
同样的技术也适用于具有命名属性的对象。例如：
key=lambda 元素: 元素[字段索引]
比如 print(sorted(C, key=lambda x: x[2]))
x:x[]字母可以随意修改，排序方式按照中括号[]里面的维度进行排序，[0]按照第一维排序，[2]按照第三维排序
class Student:
def __init__(self, name, grade, age):
self.name = name
self.grade = grade
self.age = age
# __repr__()方法：显示属性
def __repr__(self):
return repr((self.name, self.grade, self.age))
student_objects = [
Student('john', 'A', 15),
Student('jane', 'B', 12),
Student('dave', 'B', 10),
]
a = sorted(student_objects, key=lambda student: student.age)
print(a)结果：[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
Operator 模块函数： itemgetter() 、 attrgetter() 和 methodcaller() 函数
itemgetter()
from operator import itemgetter
student_tuples = [
('john', 'A', 15),
('jane', 'B', 12),
('dave', 'B', 10),
]
a = sorted(student_tuples, key=itemgetter(2))
print(a)attrgetter()
from operator import attrgetter
class Student:
def __init__(self, name, grade, age):
self.name = name
self.grade = grade
self.age = age
def __repr__(self):
return repr((self.name, self.grade, self.age))
student_objects = [
Student('john', 'A', 15),
Student('jane', 'B', 12),
Student('dave', 'B', 10),
]
a = sorted(student_objects, key=attrgetter('age'))
print(a)Operator 模块功能允许多级排序。 例如，按 grade 排序，然后按 age 排序：
from operator import attrgetter
class Student:
def __init__(self, name, grade, age):
self.name = name
self.grade = grade
self.age = age
def __repr__(self):
return repr((self.name, self.grade, self.age))
student_objects = [
Student('john', 'A', 15),
Student('jane', 'B', 12),
Student('dave', 'B', 10),
]
a = sorted(student_objects, key=attrgetter('grade', 'age'))
print(a)结果：[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
升序和降序
list.sort() 和 sorted() 接受布尔值的 reverse 参数（True或False）。这用于标记降序排序。
from operator import itemgetter
student_tuples = [
('john', 'A', 15),
('jane', 'B', 12),
('dave', 'B', 10),
]
a = sorted(student_tuples, key=itemgetter(2), reverse=True)
print(a)结果：[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
from operator import attrgetter
class Student:
def __init__(self, name, grade, age):
self.name = name
self.grade = grade
self.age = age
def __repr__(self):
return repr((self.name, self.grade, self.age))
student_objects = [
Student('john', 'A', 15),
Student('jane', 'B', 12),
Student('dave', 'B', 10),
]
a = sorted(student_objects, key=attrgetter('age'), reverse=True)
print(a)结果：[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
reverse
列表.reverse() ：逆序、反转，此方法不返回任何值，但从列表中反转给定对象。永久排序。
cars = ['bmw','audi','toyota','subaru']
cars.reverse()
print(cars) #['subaru', 'toyota', 'audi', 'bmw']遍历
循环遍历：遍历就是从头到尾依次从列表中获取数据
◦在循环体内部针对每一个元素，执行相同的操作
在Python中为了提高列表的遍历效率，专门提供的迭代iteration遍历
使用for就能够实现迭代遍历
# for 循环内部使用的 变量 in 列表，从列表cars中取出一个，并将其存在变量car(任意命名)中
cars = ['bmw','audi','toyota','subaru']
for car in cars:
print(car)切片、复制列表
切片
切片方法适用于字符串、列表、元组。
◦切片 使用 索引值 来限定范围，从一个大的 字符串 中 切出 小的 字符串
◦列表 和 元组 都是 有序 的集合，都能够 通过索引值 获取到对应的数据
注意：指定的区间属于 左闭右开 型，从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)，索引从0开始，如果倒着数，最后一位是-1。
使用 [ ] 选取字符串中一个或多个字符：
索引：<字符串>[M] 返回字符串中单个字符
<字符串>[M:N] 返回字符串中遗传字符；若M缺失表示至开头，N缺失表示至结尾
切片：<字符串>[M:N:K] 表示根据步长K对字符串切片
<字符串>[::-1] 逆序表示字符串
切片不会导致越界，但通过下标访问会越界（会抛出异常）
players = ['charles','martina','michael','florence','eli']
print(players[0:3]) #['charles', 'martina', 'michael']
print(players[1:4]) #['martina', 'michael', 'florence']
print(players[:4]) #['charles', 'martina', 'michael', 'florence']
print(players[2:]) #['michael', 'florence', 'eli']
print(players[-3:]) #['michael', 'florence', 'eli']
print(players[::-1])#['eli', 'florence', 'michael', 'martina', 'charles']
print(players[0:4:2]) #['charles', 'michael']
print(players[6]) #IndexError: list index out of range遍历切片
players = ['charles','martina','michael','florence','eli']
for player in players[:3]:
print(player.title())
'''结果如下：
Charles
Martina
Michael'''复制
列表[:]
my_foods = ['pizza','apple','milk','carrot cake']
friends_foods = my_foods[:]
print(friends_foods) #['pizza', 'apple', 'milk', 'carrot cake']列表解析
将for循环和创建新元素的代码合并成一行，并自动附加新元素。
squares = [value**2 for value in range(1,11)]
print(squares) #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]元组
元组本身是不可变数据类型，没有增删改查；可以存储任意类型的数据。
•Tuple（元组）与列表类似，不同之处在于元组不可改变
•元组 表示多个元素组成的序列
•元组 在 Python 开发中，有特定的应用场景
•用于存储 一串 信息，数据 之间使用 , 分隔
•元组用 ( ) 定义
•元组的 索引 从 0 开始
而且，任意无符号的对象，以逗号隔开，默认为元组
a=1,2,3,'hello'
print(a) #输出：(1,2,3,'hello')
创建元组
创建元组：info_tuple = ("zhangsan", 18, 1.75)
创建空元组：info_tuple = ()
元组中 只包含一个元素 时，需要 在元素后面添加逗号以避免歧义：info_tuple = (50, )
常用操作
删除
元组中的元素是不允许删除的，但可以使用del语句来删除整个元组
连接和复制
元组中的元素值使不允许修改的，但可以使用+和*，即允许元组进行组合连接和重复复制，运算后会生成一个新的元组
tup1=(1,2,3)
tup2=(3,4,5)
tup3=tup1+tup2 #输出：tup3=(1,2,3,3,4,5)
tup4=tup1*3 #输出： tup4=(1,2,3,1,2,3,1,2,3)
切片
◦切片 使用 索引值 来限定范围，从一个大的 字符串 中 切出 小的 字符串
◦列表 和 元组 都是 有序 的集合，都能够 通过索引值 获取到对应的数据
注意：指定的区间属于 左闭右开 型，从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)
使用 [ ] 选取字符串中一个或多个字符：索引：<字符串>[M] 返回字符串中单个字符
<字符串>[M:N] 返回字符串中遗传字符；若M缺失表示至开头，N缺失表示至结尾
切片：<字符串>[M:N:K] 表示根据步长K对字符串切片
<字符串>[::-1] 逆序表示字符串
对元组进行操作的内建函数
cmp(tup1,tup2): 比较两个元组元素
len(tup): 返回元组中元素的个数
max(tup): 返回元组中元素最大的值
min(tup): 返回元组中元素最小的值
元组没有列表中的增、删、改的操作，只有查的操作
tuple.index(obj)：从元组中找出某个值第一个匹配项的索引值
tuple.count(obj)： 统计某个元素在元组中出现的次数
循环遍历
•取值 就是从 元组 中获取存储在指定位置的数据
•遍历 就是 从头到尾 依次 从 元组 中获取数据
# for 循环内部使用的变量 in 元组
for item in info:
循环内部针对元组元素进行操作
print(item)
•在 Python 中，可以使用 for 循环遍历所有非数字型类型的变量：列表、元组、字典 以及 字符串
应用场景
在开发中，更多的应用场景是：
①◦函数的 参数 和 返回值，一个函数可以接收 任意多个参数，或者 一次返回多个数据
◦格式字符串，格式化字符串后面的 ( ) 本质上就是一个元组
◦让列表不可以被修改，以保护数据安全
②元组和列表之间的转换
•使用 list 函数可以把元组转换成列表：list(元组)
•使用 tuple 函数可以把列表转换成元组：tuple(列表)
列表和元组的区别
| 列表 | 元组 |
| 使用方括号[]创建列表 | 使用括号()创建元组 |
| 列表是动态数组，它们可变且可以重设长度 | 元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变 |
| 列表是相同类型的数据队列 | 元组通常由不同的数据组成 |
| 列表不能当作字典的key | 元组可以当作字典的key |
| 列表可以复制 | 元组无法复制 |
| 对列表分配小内存块 | Python将低开销的较大的块分配给元组，因为它们是不可变的。与列表相比，元组的内存更小。 当你拥有大量元素时，元组比列表快。 |
字典
字典：字典可以用来存储多个数据 ，通常用于存储描述一个物体的相关信息，字典用 { } 定义
和列表的区别：列表 是 有序 的对象集合，字典 是 无序 的对象集合
字典使用“键值对”存储数据，键值对之间使用“,”分隔 ，我们可以使用键来访问与之相关联的值：
◦键（key）是索引
◦值（value）是数据
◦键 和 值 之间使用 : 分隔
◦键必须是唯一的
◦值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组
例如：
xiaoming = {"name": "小明","age": 18,"gender": True,"height": 1.75}
print(xiaoming["name"])
print(xiaoming["gender"])结果是：
新建字典
card_dict={ }
先创建一个空字典，再分别添加各个键值对，例如：
alien = {}
alien["color"] = "green"
alien["points"] = 5
print(alien)结果为：{'color': 'green', 'points': 5}
循环遍历
遍历 就是 依次 从 字典 中获取所有键值对
在实际开发中，由于字典中每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求并不是很多
应用场景
◦使用 多个键值对，存储 描述一个 物体 的相关信息 —— 描述更复杂的数据信息
◦将 多个字典 放在 一个列表 中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理
card_list = [{"name": "张三",
"qq": "12345",
"phone": "110"},
{"name": "李四",
"qq": "54321",
"phone": "10086"}]
字典和json：
字典和json非常像，字典是对象，json是字典的字符串格式。两者可以相互转换。
set集合
定义
set是一个无序且不重复的元素集合。
集合对象是一组无序排列的可哈希的值，集合成员可以做字典中的键。集合支持用in和not in操作符检查成员，由len()内建函数得到集合的大小，用 for 循环迭代集合的成员。但是因为集合本身是无序的，不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值。
set和dict一样，只是没有value，相当于dict的key集合，由于dict的key是不重复的，且key是不可变对象因此set也有这两个特性：不重复，且元素为不可变对象
创建
使用：set() 函数创建一个无序不重复元素集
class set([iterable])
参数说明：
- iterable -- 可迭代对象对象；
x = set('google')
y = set('Cindy')
print(x) #{'l', 'e', 'o', 'g'}
print(y) #{'C', 'n', 'd', 'i', 'y'}创建空集合：s = set()
s = {11,22,33,44} #再赋值
a=set('boy')
b=set(['y', 'b', 'o','o'])
b2 = {['y', 'b', 'o','o']}
c=set({"k1":'v1','k2':'v2'})
d={'k1','k2','k2'}
e= {('k1', 'k2','k2')}
e2 = set(('k1', 'k2','k2'))
print(a,type(a)) #{'y', 'b', 'o'}
print(b,type(b)) #{'y', 'b', 'o'}
print(b2,type(b2)) #TypeError: unhashable type: 'list'
print(c,type(c)) #{'k1', 'k2'}
print(d,type(d)) #{'k1', 'k2'}
print(e,type(e))#{('k1', 'k2', 'k2')}
print(e2,type(e2)) #{'k1', 'k2'} 基本操作
比较
se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be) #找到se中存在，be中不存在的集合，返回新值
print(temp1) #{33, 11}
print(se) #{33, 11, 22}
temp2 = se.difference_update(be) #找到se中存在，be中不存在的集合，覆盖掉se
print(temp2) #None
print(se) #{33, 11}删除
discard()、remove()、pop()
se = {11, 22, 33}
se.discard(11)
se.discard(44) # 移除不存的元素不会报错
print(se)
se = {11, 22, 33}
se.remove(11)
se.remove(44) # KeyError: 44 移除不存的元素会报错
print(se)
se = {11, 22, 33} # 移除末尾元素并把移除的元素赋给新值
temp = se.pop()
print(temp) # 33
print(se) # {11, 22}取交集
se = {11, 22, 33}
be = {22, 55}
temp1 = se.intersection(be) #取交集，赋给新值
print(temp1) # 22
print(se) # {11, 22, 33}
temp2 = se.intersection_update(be) #取交集并更新自己
print(temp2) # None
print(se) # 22判断
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的父集合合并
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}取并集
se = {11, 22, 33}
be = {22,44,55}
temp=se.union(be) #取并集，并赋新值
print(se) #{33, 11, 22}
print(temp) #{33, 22, 55, 11, 44}更新
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}
集合的转换
se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(se)) #[0, 1, 2, 3]
print(li,type(li)) #[0, 1, 2, 3]
print(tu,type(tu)) #(0, 1, 2, 3)
print(st,type(st)) #{0, 1, 2, 3} 交集、并集、差集也可以这样写
x = set('runoob')
y = set('google')
print(x) #{'o', 'n', 'b', 'u', 'r'}
print(y) #{'e', 'g', 'l', 'o'}
print(x&y) #{'o'}
print(x|y) #{'g', 'l', 'e', 'r', 'n', 'b', 'o', 'u'}
print(x-y) #{'n', 'r', 'u', 'b'}参考：https://www.cnblogs.com/whatisfantasy/p/5956775.html