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)) #0

hex(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 range

1.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()) #False

islower 

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()) # True

1.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 )) #False

endswith

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)) #False

find

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)) #-1

rfind

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)) #-1

index

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 found

list.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 索引位置 :  2

rindex

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 found

replace

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!!!000000000000000000

rjust

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')) #1

min(列表)，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'} <class 'set'>
print(b,type(b)) #{'y', 'b', 'o'} <class 'set'>
print(b2,type(b2)) #TypeError: unhashable type: 'list'
print(c,type(c)) #{'k1', 'k2'} <class 'set'>
print(d,type(d)) #{'k1', 'k2'} <class 'set'>
print(e,type(e))#{('k1', 'k2', 'k2')} <class 'set'>
print(e2,type(e2)) #{'k1', 'k2'} <class 'set'>

基本操作

比较

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] <class 'set'>
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'>

交集、并集、差集也可以这样写

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