不可变数据(3个):
数字(number)
字符串(string)
元组(tuple)
可变数据(3个):
列表(list)
字典(dict)
集合(set)
不可变数据
一. 数字(number)
1. int(整数)
#描述: int() 函数用于将一个字符串或数字转换为整型 #语法: class int(x, base=10) #参数: x -- 字符串或数字 base -- 进制数, 默认十进制 #返回值: 返回整型数据
2. float(浮点数)
#描述: float() 函数用于将整数和字符串转换成浮点数 #语法: class float([x]) #参数: x -- 整数或字符串 #返回值: 返回浮点数
3. bool(布尔值)
#描述: bool() 函数用于将给定参数转换为布尔类型, 如果没有参数, 返回 False. bool 是 int 的子类. #语法: class bool([x]) #参数: x -- 要进行转换的参数 #返回值: 返回 Ture 或 False
4. complex(复数)
#描述: complex() 函数用于创建一个值为real + imag * j 的复数或者转化一个字符串或数为复数. 如果第一个参数为字符串, 则不需要指定第二个参数 #语法: class complex([real[, imag]]) #参数: real -- int, long, float或字符串 imag -- int, long, float #返回值: 返回一个复数 #实例: >>> complex(1, 2) (1 + 2j) >>> complex(1) # 数字 (1 + 0j) >>> complex("1") # 当做字符串处理 (1 + 0j) # 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错 >>> complex("1+2j") (1 + 2j)
二. 字符串(string)
字符串是 Python 中最常用的数据类型. 我们可以使用单引号或双引号来创建字符串.
字符串内建函数(40个):(以首字母a~z进行排序)
#描述: center() 方法返回一个指定的宽度 width 居中的字符串, fillchar 为填充的字符, 默认为空格 #语法: str.center(width[, fillchar]) #参数: width -- 字符串的总宽度 fillchar -- 填充字符 #返回值: 返回一个指定的宽度 width 居中的字符串, 如果 width 小于字符串宽度直接返回字符串, 否则使用 fillchar 去填充 #实例: str = "[www.runoob.com]" print (str.center(40, '*')) # 输出结果: ************[www.runoob.com]************
#描述: capitalize()将字符串的第一个字母变成大写,其他字母变小写 #语法: str.capitalize() #参数: 无 #返回值: 该方法返回一个首字母大写的字符串
#描述: count() 方法用于统计字符串里某个字符出现的次数. 可选参数为在字符串搜索的开始与结束位置. #语法: str.count(sub, start= 0,end=len(string)) #参数: sub -- 搜索的子字符串 start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0 end -- 字符串中结束搜索的位置. 字符中第一个字符的索引为 0. 默认为字符串的最后一个位置. #返回值: 该方法返回子字符串在字符串中出现的次数 #实例: str="www.runoob.com" sub='o' print ("str.count('o') : ", str.count(sub)) # 输出结果: str.count('o') : 3
#描述: decode() 方法以指定的编码格式解码 bytes 对象. 默认编码为 'utf-8'. #语法: bytes.decode(encoding="utf-8", errors="strict") #参数: encoding -- 要使用的编码,如"UTF-8" errors -- 设置不同错误的处理方案. 默认为 'strict', 意为编码错误引起一个UnicodeError. 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值 #返回值: 该方法返回解码后的字符串
#描述: encode() 方法以指定的编码格式编码字符串. errors参数可以指定不同的错误处理方案 #语法: str.encode(encoding='UTF-8',errors='strict') #参数: encoding -- 要使用的编码,如: UTF-8 errors -- 设置不同错误的处理方案. 默认为 'strict',意为编码错误引起一个UnicodeError. 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值 #返回值: 该方法返回编码后的字符串, 它是一个 bytes 对象
#描述: endswith() 方法用于判断字符串是否以指定后缀结尾,如果以指定后缀结尾返回True, 否则返回False. 可选参数"start"与"end"为检索字符串的开始与结束位置 #语法: str.endswith(suffix[, start[, end]]) #参数: suffix -- 该参数可以是一个字符串或者是一个元素 start -- 字符串中的开始位置 end -- 字符中结束位置 #返回值: 如果字符串含有指定的后缀返回True,否则返回False
#描述: expandtabs() 方法把字符串中的 tab 符号('\t')转为空格,tab 符号('\t')默认的空格数是 8 #语法: str.expandtabs(tabsize=8) #参数: tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数 #返回值: 该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串
#描述: find() 方法检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果指定范围内如果包含指定索引值,返回的是索引值在字符串中的起始位置。如果不包含索引值,返回-1。 #语法: str.find(str, beg=0, end=len(string)) #参数: str -- 指定检索的字符串 beg -- 开始索引,默认为0 end -- 结束索引,默认为字符串的长度 #返回值: 如果包含子字符串返回开始的索引值,否则返回-1 #实例: >>>info = 'abca' >>> print(info.find('a')) # 从下标0开始,查找在字符串里第一个出现的子串,返回结果:0 0 >>> print(info.find('a', 1)) # 从下标1开始,查找在字符串里第一个出现的子串:返回结果3 3 >>> print(info.find('3')) # 查找不到返回-1 -1
#描述: index() 方法检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,该方法与 python find()方法一样,只不过如果str不在 string中会报一个异常 #语法: str.index(str, beg=0, end=len(string)) #参数: str -- 指定检索的字符串 beg -- 开始索引,默认为0 end -- 结束索引,默认为字符串的长度 #返回值: 如果包含子字符串返回开始的索引值,否则抛出异常
#描述: isalnum() 方法检测字符串是否由字母和数字组成 #语法: str.isalnum() #参数: 无 #返回值: 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
#描述: isalpha() 方法检测字符串是否只由字母组成 #语法: str.isalpha() #参数: 无 #返回值: 如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
#描述: isdigit() 方法检测字符串是否只由数字组成 #语法: str.isdigit() #参数: 无 #返回值: 如果字符串只包含数字则返回 True, 否则返回 False
#描述: islower() 方法检测字符串是否由小写字母组成 #语法: str.islower() #参数: 无 #返回值: 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False
#描述: isupper() 方法检测字符串中所有的字母是否都为大写 #语法: str.isupper() #参数: 无 #返回值: 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False
#描述: isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象 [注意]: 定义一个字符串为Unicode,只需要在字符串前添加 'u' 前缀即可 #语法: str.isnumeric() #参数: 无 #返回值: 如果字符串中只包含数字字符,则返回 True,否则返回 False
#描述: isspace() 方法检测字符串是否只由空白字符组成 #语法: str.isspace() #参数: 无 #返回值: 如果字符串中只包含空格,则返回 True,否则返回 False
#描述: istitle() 方法检测字符串中所有的单词拼写首字母是否为大写,且其他字母为小写 #语法: str.istitle() #参数: 无 #返回值: 如果字符串中所有的单词拼写首字母是否为大写,且其他字母为小写则返回 True,否则返回 False
#描述: isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象 [注意]: 定义一个十进制字符串,只需要在字符串前添加 'u' 前缀即可 #语法: str.isdecimal() #参数: 无 #返回值: 如果字符串是否只包含十进制字符返回True,否则返回False
#描述: join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串 #语法: str.join(sequence) #参数: sequence -- 要连接的元素序列 #返回值: 返回通过指定字符连接序列中元素后生成的新字符串
#描述: len() 方法返回对象(字符、列表、元组等)长度或项目个数 #语法: len( s ) #参数: s -- 对象 #返回值: 返回对象长度
#描述: lower() 方法转换字符串中所有大写字符为小写 #语法: str.lower() #参数: 无 #返回值: 返回将字符串中所有大写字符转换为小写后生成的字符串
#描述: ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串 #语法: str.ljust(width[, fillchar]) #参数: width -- 指定字符串长度 fillchar -- 填充字符,默认为空格 #返回值: 返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串 #实例: str = "Hello, Word!" print (str.ljust(20, '*')) # 输出结果: Hello, Word!********
#描述: lstrip() 方法用于截掉字符串左边的空格或指定字符 #语法: str.lstrip([chars]) #参数: chars --指定截取的字符 #返回值: 返回截掉字符串左边的空格或指定字符后生成的新字符串
#描述: maketrans() 方法用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。 两个字符串的长度必须相同,为一一对应的关系。 #语法: str.maketrans(intab, outtab) #参数: intab -- 字符串中要替代的字符组成的字符串 outtab -- 相应的映射字符的字符串 #返回值: 返回字符串转换后生成的新字符串 #实例: 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() 方法返回字符串中最大的字母 #语法: max(str) #参数: str -- 字符串 #返回值: 返回字符串中最大的字母
#描述: min() 方法返回字符串中最小的字母 #语法: min(str) #参数: str -- 字符串 #返回值: 返回字符串中最小的字母
#描述: rfind() 返回字符串最后一次出现的位置,如果没有匹配项则返回-1 #语法: str.rfind(str, beg=0 end=len(string)) #参数: str -- 查找的字符串 beg -- 开始查找的位置,默认为0 end -- 结束查找位置,默认为字符串的长度 #返回值: 返回字符串最后一次出现的位置,如果没有匹配项则返回-1
#描述: rindex() 返回子字符串 str 在字符串中最后出现的位置,如果没有匹配的字符串会报异常,你可以指定可选参数[beg:end]设置查找的区间 #语法: str.rindex(str, beg=0 end=len(string)) #参数: str -- 查找的字符串 beg -- 开始查找的位置,默认为0 end -- 结束查找位置,默认为字符串的长度 #返回值: 返回子字符串 str 在字符串中最后出现的位置,如果没有匹配的字符串会报异常
#描述: rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串 #语法: str.rjust(width[, fillchar]) #参数: width -- 指定填充指定字符后中字符串的总长度 fillchar -- 填充的字符,默认为空格 #返回值: 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
#描述: rstrip() 删除 string 字符串末尾的指定字符(默认为空格) #语法: str.rstrip([chars]) #参数: chars -- 指定删除的字符(默认为空格) #返回值: 返回删除 string 字符串末尾的指定字符后生成的新字符串
#描述: replace() 方法把字符串中的 old(旧字符串) 替换成 new(新字符串),如果指定第三个参数max,则替换不超过 max 次 #语法: str.replace(old, new[, max]) #参数: old -- 将被替换的子字符串。 new -- 新字符串,用于替换old子字符串 max -- 可选字符串, 替换不超过 max 次 #返回值: 返回字符串中的 old(旧字符串) 替换成 new(新字符串)后生成的新字符串,如果指定第三个参数max,则替换不超过 max 次
#描述: split()通过指定分隔符对字符串进行切片,如果参数num 有指定值,则仅分隔 num 个子字符串 #语法: str.split(str="", num=string.count(str)) #参数: str -- 分隔符,默认为所有的空字符,包括空格、换行(\n)、制表符(\t)等 num -- 分割次数 #返回值: 返回分割后的字符串列表
#描述: splitlines() 按照行('\r', '\r\n', \n')分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符 #语法: str.splitlines([keepends]) #参数: keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n'),默认为 False,不包含换行符,如果为 True,则保留换行符 #返回值: 返回一个包含各行作为元素的列表
#描述: startswith() 方法用于检查字符串是否是以指定子字符串开头,如果是则返回 True,否则返回 False。如果参数 beg 和 end 指定值,则在指定范围内检查 #语法: str.startswith(str, beg=0,end=len(string)) #参数: str -- 检测的字符串 strbeg -- 可选参数用于设置字符串检测的起始位置 strend -- 可选参数用于设置字符串检测的结束位置 #返回值: 如果检测到字符串则返回True,否则返回False
#描述: strip() 方法用于移除字符串头尾指定的字符(默认为空格)或字符序列。 [注意]: 该方法只能删除开头或是结尾的字符,不能删除中间部分的字符。 #语法: str.strip([chars]) #参数: chars -- 移除字符串头尾指定的字符序列 #返回值: 返回移除字符串头尾指定的字符序列生成的新字符串
#描述: swapcase() 方法用于对字符串的大小写字母进行转换 #语法: str.swapcase() #参数: 无 #返回值: 返回大小写字母转换后生成的新字符串
#描述: title() 方法返回"标题化"的字符串, 就是说所有单词的首个字母转化为大写,其余字母均为小写 #语法: str.title() #参数: 无 #返回值: 返回"标题化"的字符串,就是说所有单词的首字母都转化为大写
#描述: translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中 #语法: str.translate(table) bytes.translate(table[, delete]) bytearray.translate(table[, delete]) #参数: table -- 翻译表,翻译表是通过 maketrans() 方法转换而来 deletechars -- 字符串中要过滤的字符列表 #返回值: 返回翻译后的字符串,若给出了 delete 参数,则将原来的bytes中的属于delete的字符删除,剩下的字符要按照table中给出的映射来进行映射
#描述: upper() 方法将字符串中的小写字母转为大写字母 #语法: str.upper() #参数: 无 #返回值: 返回小写字母转为大写字母的字符串
#描述: zfill() 方法返回指定长度的字符串,原字符串右对齐,前面填充0 #语法: str.zfill(width) #参数: width -- 指定字符串的长度。原字符串右对齐,前面填充0 #返回值: 返回指定长度的字符串
三. 元组(tuple)
#元组介绍: #(1)Python 的元组与列表类似,不同之处在于元组的元素不能修改, 即元组是只读列表。另外, 元素的不可变指的是元组的第一层不可变。 #(2)元组使用小括号,列表使用方括号。 #(3)元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。 #(4)创建空元组: tup1 = () tup2 = tuple() #(5)元组和列表可以互相嵌套。 #(6)注意: 元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用。
1. 修改元组
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例:
tup1 = (12, 34.56); tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2; print (tup3) # 输出结果: (12, 34.56, 'abc', 'xyz')
2. 删除元组
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例:
tup = ('Google', 'Runoob', 1997, 2000) print (tup) del tup; print ("删除后的元组 tup : ") print (tup) #以上实例元组被删除后,输出变量会有异常信息,输出如下所示: #删除后的元组 tup : #NameError: name 'tup' is not defined
3. 访问元组
元组可以使用下标索引来访问元组中的值,如下实例:
tup1 = ('Google', 'Runoob', 1997, 2000) tup2 = (1, 2, 3, 4, 5, 6, 7 ) print ("tup1[0]: ", tup1[0]) print ("tup2[1:5]: ", tup2[1:5]) # 输出结果: tup1[0]: Google tup2[1:5]: (2, 3, 4, 5)
4. 元组运算符
与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。
#计算元素个数: len((1, 2, 3)) --> 3 #连接: (1, 2, 3) + (4, 5, 6) --> (1, 2, 3, 4, 5, 6) #复制(重复): ('Hi!',) * 4 --> ('Hi!', 'Hi!', 'Hi!', 'Hi!') #元素是否存在: 3 in (1, 2, 3) --> True #迭代: for x in (1, 2, 3) print (x,) #输出结果: 1 2 3
5. 元组索引,截取
元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素.
如下实例:
L = ('Google', 'Taobao', 'Runoob') print(L[2]) # 'Runoob' print(L[-2]) # 'Taobao' print(L[1:]) # ('Taobao', 'Runoob')
6. 元组内置函数
# len(tuple) -- 计算元组元素个数 # max(tuple) -- 返回元组中元素最大值 # min(tuple) -- 返回元组中元素最小值 # tuple(seq) -- 将列表转换为元组
可变数据
一. 列表(list)
#1. 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。 #2. Python有6个序列的内置类型,但最常见的是列表和元组。 #3. 序列都可以进行的操作包括索引,切片,加,乘,检查成员。 #4. 列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现。 #5. 列表的数据项不需要具有相同的类型。 #6. 创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。 #7. 与字符串的索引一样,列表索引从0开始。列表可以进行截取、组合等。
1. 增加
#1. 描述: append() 方法用于在列表末尾添加新的对象。 #2. 语法: list.append(obj) #3. 参数: obj -- 添加到列表末尾的对象。 #4. 返回值: 该方法无返回值,但是会修改原来的列表。 #5. 实例: list1 = ['Google', 'Runoob', 'Taobao'] list1.append('Baidu') print (list1) # 输出结果: ['Google', 'Runoob', 'Taobao', 'Baidu']
#1. 描述: extend() 函数用于在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)。 #2. 语法: list.extend(seq) #3. 参数: seq -- 元素列表。 #4. 返回值: 该方法没有返回值,但会在已存在的列表中添加新的列表内容。 #5. 实例: list1 = ['Google', 'Runoob', 'Taobao'] list2=list(range(5)) # 创建 0-4 的列表 list1.extend(list2) # 扩展列表 print (list1) # 输出结果: ['Google', 'Runoob', 'Taobao', 0, 1, 2, 3, 4]
#1. 描述: insert() 函数用于将指定对象插入列表的指定位置。 #2. 语法: list.insert(index, obj) #3. 参数: index -- 对象obj需要插入的索引位置。 obj -- 要插入列表中的对象。 #4. 返回值: 该方法没有返回值,但会在列表指定位置插入对象。 #5. 实例: list1 = ['Google', 'Runoob', 'Taobao'] list1.insert(1, 'Baidu') print (list1) # 输出结果: ['Google', 'Baidu', 'Runoob', 'Taobao']
2. 删除
#1. 描述: pop() 函数用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值。 #2. 语法: list.pop([index=-1]) #3. 参数: index -- 可选参数,要移除列表元素的索引值,不能超过列表总长度,默认为 index=-1,删除最后一个列表值。 #4. 返回值: 该方法返回从列表中移除的元素对象。 #5. 实例: list1 = ['Google', 'Runoob', 'Taobao'] list1.pop() print ("列表现在为 : ", list1) list1.pop(1) print ("列表现在为 : ", list1) # 输出结果: 列表现在为 : ['Google', 'Runoob'] 列表现在为 : ['Google']
#1. 描述: remove() 函数用于移除列表中某个值的第一个匹配项 #2. 语法: list.remove(obj) #3. 参数: obj -- 列表中要移除的对象 #4. 返回值: 无 #5. 实例: list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list1.remove('Taobao') print ("列表现在为 : ", list1) list1.remove('Baidu') print ("列表现在为 : ", list1) # 输出结果: 列表现在为 : ['Google', 'Runoob', 'Baidu'] 列表现在为 : ['Google', 'Runoob']
#1. 描述: clear() 函数用于清空列表,类似于 del a[:] #2. 语法: list.clear() #3. 参数: 无 #4. 返回值: 无 #5. 实例: list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list1.clear() print ("列表清空后 : ", list1) # 输出结果: 列表清空后 : []
# del lst[index] -- 指定索引进行删除 # del lst[beg:end:step] -- 切片删除
3. 修改
# 索引修改 -- lst[index] = 目标对象 # 切片修改 -- lst[start:end:step] = 目标对象
4. 查询
for循环遍历列表:
# 只能拿到元素 for el in list: print(el) # 即拿索引又拿元素 for i in range(len(list)): print(list[i])
5. 其他常用操作
方法:
#1. 描述: count() 方法用于统计某个元素在列表中出现的次数。 #2. 语法: list.count(obj) #3. 参数: obj -- 列表中统计的对象。 #4. 返回值: 返回元素在列表中出现的次数。 #5. 实例: aList = [123, 'Google', 'Runoob', 'Taobao', 123]; print ("123 元素个数 : ", aList.count(123)) print ("Runoob 元素个数 : ", aList.count('Runoob')) # 输出结果如下: 123 元素个数 : 2 Runoob 元素个数 : 1
#1. 描述: index() 函数用于从列表中找出某个值第一个匹配项的索引位置。 #2. 语法: list.index(obj) #3. 参数: obj -- 查找的对象。 #4. 返回值: 该方法返回查找对象的索引位置,如果没有找到对象则抛出异常。 #5. 实例: list1 = ['Google', 'Runoob', 'Taobao'] print ('Runoob 索引值为', list1.index('Runoob')) print ('Taobao 索引值为', list1.index('Taobao')) # 输出结果如下: Runoob 索引值为 1 Taobao 索引值为 2
#1. 描述: reverse() 函数用于反向列表中元素。 #2. 语法: list.reverse() #3. 参数: 无 #4. 返回值: 该方法没有返回值,但是会对列表的元素进行反向排序。 #5. 实例: list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list1.reverse() print (list1) # 输出结果: ['Baidu', 'Taobao', 'Runoob', 'Google']
#1. 描述: sort() 函数用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数。 #2. 语法: list.sort(cmp=None, key=None, reverse=False) #3. 参数: cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。 key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。 reverse -- 排序规则,reverse = True 降序, reverse = False 升序(默认)。 #4. 返回值: 该方法没有返回值,但是会对列表的对象进行排序。 #5. 实例1: # 列表 vowels = ['e', 'a', 'u', 'o', 'i'] # 降序 vowels.sort(reverse=True) # 输出结果 print ( '降序输出:', vowels ) 实例1输出结果如下: 降序输出: ['u', 'o', 'i', 'e', 'a'] #实例2: 通过指定列表中的元素排序来输出列表 # 获取列表的第二个元素 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)]
#1. 描述: copy() 函数用于复制列表,类似于 a[:] 注意: 这里的属于浅拷贝 #2. 语法: list.copy() #3. 参数: 无 #4. 返回值: 返回复制后的新列表。 #5. 实例: list1 = ['Google', 'Runoob', 'Taobao', 'Baidu'] list2 = list1.copy() print ("list2 列表: ", list2) # 以上实例输出结果如下: # list2 列表: ['Google', 'Runoob', 'Taobao', 'Baidu']
函数:
#1. 描述: len() 方法返回列表元素个数 #2. 语法: len(list) #3. 参数: list -- 要计算元素个数的列表 #4. 返回值: 返回列表元素个数 #5. 实例: list1 = ['Google', 'Runoob', 'Taobao'] print (len(list1)) list2=list(range(5)) # 创建一个 0-4 的列表 print (len(list2)) # 输出结果: # 3 # 5
#1. 描述: max() 方法返回列表元素中的最大值 #2. 语法: max(list) #3. 参数: list -- 要返回最大值的列表 #4. 返回值: 返回列表元素中的最大值
#1. 描述 min() 方法返回列表元素中的最小值 #2. 语法: min(list) #3. 参数: list -- 要返回最小值的列表 #4. 返回值: 返回列表元素中的最小值
#1. 描述: list() 方法用于将元组转换为列表。 注:元组与列表是非常类似的,区别在于元组的元素值不能修改,元组是放在括号中,列表是放于方括号中。 #2. 语法: list( seq ) #3. 参数: list -- 要转换为列表的元组。 #4. 返回值: 返回列表。
二. 字典(dict)
#1. 字典的介绍: 字典(dict)是python中唯一的一个映射类型,它是以{}括起来的键值对组成,在dict中key是唯一的,在保存的时候,根据key来计算出一个内存地址,然后将key-value保存在这个地址中,这种算法被称为hash算法,所以,切记,在dict中存储的key-value中的key必须是可hash的,如果你搞不懂什么是可哈希,暂时可以这样记:可以改变的都是不可哈希的,那么可哈希就意味着不可变。这个是为了能准确的计算内存地址而规定的。 已知的可哈希(不可变)的数据类型: int, str, bool, tuple 不可哈希(可变)的数据类型: list, dict, set #2. 语法: {key:value1, key2:value2, ...} 注意: key必须是不可变(可哈希)的, value则没有要求,可以保存任意类型的数据. #3. 举例说明: # 合法 dic = { 123: 456, True: 999, "id": 1, "name": "sylar", "age": 18, "stu": ["帅哥", "美女"], (1, 2, 3): "麻花藤" } print(dic[123]) print(dic[True]) print(dic["id"]) print(dic["stu"]) print(dic[(1, 2, 3)]) # 不合法 dic1 = {[1, 2, 3,]:"周杰伦"} # list是可变的,不能作为key dic2 = {{1:2}:"娃哈哈"} # dict是可变的,不能作为key dic3 = {{1, 2, 3}:"爽歪歪"} # set是可变的,不能作为key # dict保存的数据不是按照我们添加进去的顺序保存的,是按照hash表的顺序,而hash表不是连续的,所以dicct不能进行切片工作,它只能通过key来获取dict中的数据.
1. 增加
#dict[key] = value给字典添加一个键值对 #举例说明: dic = {} dic["name"] = "王力宏" # 如果dict中没有出现这个key,就会新增一个key-value组合 dic["age"] = 18
#描述: setdefault() 方法和get()方法类似, 如果键不已经存在于字典中,将会添加键并将值设为默认值。 #语法: dict.setdefault(key, default=None) #参数: key -- 要查找的键 default -- 若key不存在,则把key:default新增进字典中 #返回值: 如果key在字典中,返回对应的值.如果不在字典中,则插入key及设置的默认值default,并返回default,default默认值为None. #举例说明: dic = {"周杰伦":"亚洲音乐天王"} dic,setdefault("王力宏") # 给字典dic设置一个键值对 "王力宏":None ,返回值是None print(dic) # 结果为: {"周杰伦":"亚洲音乐天王", "王力宏":None} dic.setdefault("周杰伦", "跳舞") # 如果dic中已经存在这个key了,那么setdefault不会起作用,返回值是这个key对应的dict中的value值 print(dic) # 结果为 {"周杰伦":"亚洲音乐天王", "王力宏":None} dic.setdefault("刘德华", 18) # 在dict中新增键值对 "刘德华":18 ,返回值是18 print(dic) # 结果为{"周杰伦":"亚洲音乐天王", "王力宏":None, "刘德华":18}
2. 删除
dic = {"name":"王乃卉", "age":19", "hobby":"摄影"} ret = dic.pop("age") # pop()有返回值,返回被删除的value print(ret) # 结果为: 19
dic = {"name":"王乃卉", "age":19", "hobby":"摄影"} del dic["age"] print(dic) # 结果为: {"name":"王乃卉", "hobby":"摄影"}
dic = {"name":"王乃卉", "age":19", "hobby":"摄影"} ret = dic.popitem() # 随机删除,返回一个元组(删除的key,删除的value), 可以结构: k, v = dic.popitem() print(ret) # 结果为: ("hobby":"摄影")
# dict.clear()用于 清空字典
3. 修改
dict[key] = value给字典增加一个键值对
dic = {"name":"王乃卉", "age":19", "hobby":"摄影"} dic1 = {"name":"王力宏", "age":37", "hobby":"音乐"} dic.update(dic1) # 把dic1中的内容更新到dic中.如果key重名,则修改替换.如果不存在key,则新增.
4. 查询
dic = {"name":"王乃卉", "age":19", "hobby":"摄影"} print(dic["name"]) # 结果: "王乃卉" print(dic["gender"]) # 如果key不存在则报错
dic = {"name":"王乃卉", "age":19", "hobby":"摄影"} print(dic.get("name")) # 结果为: "王乃卉" print(dic.get("gender")) # key不存在返回None print(dic.get("gender", "女")) # key不存在时,第二个参数可以指定返回内容,原dict的内容不变,此打印结果为: 女
dic = {"name":"王乃卉", "age":19", "hobby":"摄影"} print(dic.setdefault("gender")) # key不存在时会为dict新增一个键值对 "gender":None ,此时打印结果为: None
dic = {"name": "王乃卉", "age": 19, "hobby": "摄影"} # 获取到所有key for k in dic: print(k) # 获取到所有key for k in dic.keys(): print(k) # 获取到所有values for v in dic.values(): print(v) # 获取到所有key和values for k, v in dic.items(): print(k, v)
5. 其他常用操作
描述:
copy() 函数返回一个字典的浅复制
语法:
dict.copy()
参数:
无
返回值:
返回一个字典的浅复制
#描述: fromkeys() 函数用于创建一个新字典,以序列seq中元素做字典的键,value为字典所有键对应的初始值 #语法: dict.fromkeys(seq[, value]) #参数: seq -- 字典键值列表 value -- 可选参数, 设置键序列(seq)的值 #返回值: 该方法返回列表
#描述: in 操作符用于判断键是否存在于字典中,如果键在字典 dict 里返回 true,否则返回 false。 而 not in 操作符刚好相反,如果键在字典 dict 里返回 false,否则返回 true。 #语法: key in dict #参数: key -- 要在字典中查找的键。 #返回值: 如果键在字典里返回true,否则返回false。
# 字典的嵌套 dic1 = { "name": "汪峰", "age": 43, "wife": { "name": '章子怡', "age": 39 }, "children": ['第一个孩子', '第二个孩子'], "desc": '峰哥不会告我吧,没关系的' } print(dic1.get("wife").get("name")) print(dic1.get("children")) print(dic1.get("children")[1]
三. 集合(set)
#set(集合)是python的一个基本数据类型,一般不是很常用,set中的元素是不重复的,无序的,里面的元素必须是可hash的(int,tuple,bool),我们可以这样来记,set就是dict类型的数据但是不保存value,只保存key,set也用{}表示。 #注意:set集合中的元素必须是可hash的,但是set本身是不可hash,set是可变的。 #创建一个空字典和一个空集合: d = {} # 创建一个空字典 s = set() # 创建一个空集合
1. 增加
#描述: add() 方法用于给集合添加元素,如果添加的元素在集合中已存在,则不执行任何操作。 #语法: set.add(elmnt) #参数: elmnt -- 必需,要添加的元素。 #返回值: 无
#描述: update() 方法用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略。 #语法: set.update(set) #参数: set -- 必需,可以是元素或集合 #返回值: 无 #举例说明: x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} x.update(y) print(x) # 执行结果: # {'banana', 'apple', 'google', 'runoob', 'cherry'}
2. 删除
#描述: pop() 方法用于随机移除一个元素。 #语法: set.pop() #参数: 无 #返回值: 返回移除的元素。 #举例说明: fruits = {"apple", "banana", "cherry"} fruits.pop() print(fruits) # 执行结果: # {'apple', 'banana'}
#描述: remove() 方法用于移除集合中的指定元素。 该方法不同于 discard() 方法,因为 remove() 方法在移除一个不存在的元素时会发生错误,而 discard() 方法不会。 #语法: set.remove(item) #参数: item -- 要移除的元素 #返回值: 返回移除的元素。 #举例说明: fruits = {"apple", "banana", "cherry"} fruits.remove("banana") print(fruits) # 执行结果: # {'cherry', 'apple'}
#描述: clear() 方法用于移除集合中的所有元素。 #语法: set.clear() #参数: 无 #返回值: 无
3. 修改
集合中的数据没有索引. 也没有办法去定位一个元素. 所以没有办法进行直接修改,我们可以采用先删除后添加的方式来完成修改操作,具体如下示例:
s = {"刘嘉玲", '关之琳', "王祖贤","张曼玉", "李若彤"} # 把刘嘉玲改成赵本山 s.remove("刘嘉玲") s.add("赵本山") print(s)
4. 查询
set是一个可迭代对象. 所以可以进行for循环遍历查询:
for el in s: print(el)
5. 其他操作
#copy() 方法用于拷贝一个集合. #举例说明: fruits = {"apple", "banana", "cherry"} x = fruits.copy() print(x) # 执行结果: # {'cherry', 'banana', 'apple'}
#描述: difference() 方法用于返回集合的差集,即返回的集合元素包含在第一个集合中,但不包含在第二个集合(方法的参数)中。 #语法: set.difference(set) #参数: set -- 必需,用于计算差集的集合 #返回值: 返回一个新的集合。 #举例说明: x = {"apple", "banana", "cherry"} y = {"google", "microsoft", "apple"} z = x.difference(y) print(z) # 执行结果: # {'cherry', 'banana'}
#描述: discard() 方法用于移除指定的集合元素。 该方法不同于 remove() 方法,因为 remove() 方法在移除一个不存在的元素时会发生错误,而 discard() 方法不会。 #语法: set.discard(value) #参数: value -- 必需,要移除的元素 #返回值: 无 #举例说明: fruits = {"apple", "banana", "cherry"} fruits.discard("banana") print(fruits) # 执行结果: # {'cherry', 'apple'}
#描述: intersection() 方法用于返回两个或更多集合中都包含的元素,即交集。 #语法: set.intersection(set1, set2 ... etc) #参数: set1 -- 必需,要查找相同元素的集合 set2 -- 可选,其他要查找相同元素的集合,可以多个,多个使用逗号 , 隔开 #返回值: 返回一个新的集合 #举例说明: x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.intersection(y) print(z) # 执行结果: # {'apple'} #计算多个集合的交集: x = {"a", "b", "c"} y = {"c", "d", "e"} z = {"f", "g", "c"} result = x.intersection(y, z) print(result) # 执行结果: # {'c'}
#描述: isdisjoint() 方法用于判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 #语法: set.isdisjoint(set) #参数: set -- 必需,要比较的集合 #返回值: 返回布尔值,如果不包含返回 True,否则返回 False。 #举例说明: x = {"apple", "banana", "cherry"} y = {"google", "runoob", "facebook"} z = x.isdisjoint(y) print(z) # 执行结果: # True
#描述: issubset() 方法用于判断集合的所有元素是否都包含在指定集合中,如果是则返回 True,否则返回 False。 #语法: set.issubset(set) #参数: set -- 必需,要比查找的集合 #返回值: 返回布尔值,如果都包含返回 True,否则返回 False。 #举例说明: x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b", "a"} z = x.issubset(y) print(z) # 执行结果: # True
#描述: issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中,如果是则返回 True,否则返回 False。 #语法: set.issuperset(set) #参数: set -- 必需,要比查找的集合 #返回值: 返回布尔值,如果都包含返回 True,否则返回 False。 #举例说明: x = {"f", "e", "d", "c", "b", "a"} y = {"a", "b", "c"} z = x.issuperset(y) print(z) # 执行结果: # True #如果没有全部包含返回 False: x = {"f", "e", "d", "c", "b"} y = {"a", "b", "c"} z = x.issuperset(y) print(z) # 执行结果: # False
#描述: symmetric_difference() 方法返回两个集合中不重复的元素集合,即会移除两个集合中都存在的元素。 #语法: set.symmetric_difference(set) #参数: set -- 集合 #返回值: 返回一个新的集合。 #举例说明: x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.symmetric_difference(y) print(z) # 执行结果: # {'google', 'cherry', 'banana', 'runoob'}
#描述: symmetric_difference_update() 方法移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 #语法: set.symmetric_difference_update(set) #参数: set -- 要检测的集合 #返回值: 无 #举例说明: x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} x.symmetric_difference_update(y) print(x) # 执行结果: {'google', 'cherry', 'banana', 'runoob'}
#描述: union() 方法返回两个集合的并集,即包含了所有集合的元素,重复的元素只会出现一次。 #语法: set.union(set1, set2...) #参数: set1 -- 必需,合并的目标集合 set2 -- 可选,其他要合并的集合,可以多个,多个使用逗号 , 隔开。 #返回值: 返回一个新集合。 #举例说明: x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} z = x.union(y) print(z) # 执行结果: # {'cherry', 'runoob', 'google', 'banana', 'apple'} #合并多个集合: x = {"a", "b", "c"} y = {"f", "d", "a"} z = {"c", "d", "e"} result = x.union(y, z) print(result) # 执行结果: # {'c', 'd', 'f', 'e', 'b', 'a'}