列举python中常用的数据类型_Python 基本数据类型

不可变数据(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]************

center()

#描述: capitalize()将字符串的第一个字母变成大写,其他字母变小写

#语法: str.capitalize()

#参数: 无

#返回值: 该方法返回一个首字母大写的字符串

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

count()

#描述:

decode() 方法以指定的编码格式解码 bytes 对象. 默认编码为 'utf-8'.#语法:

bytes.decode(encoding="utf-8", errors="strict")#参数:

encoding -- 要使用的编码，如"UTF-8"errors-- 设置不同错误的处理方案. 默认为 'strict', 意为编码错误引起一个UnicodeError. 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace'以及通过 codecs.register_error() 注册的任何值#返回值:

该方法返回解码后的字符串

decode()

#描述:

encode() 方法以指定的编码格式编码字符串. errors参数可以指定不同的错误处理方案#语法:

str.encode(encoding='UTF-8',errors='strict')#参数:

encoding -- 要使用的编码，如: UTF-8errors--设置不同错误的处理方案.

默认为'strict',意为编码错误引起一个UnicodeError.

其他可能得值有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace'以及通过 codecs.register_error() 注册的任何值#返回值:

该方法返回编码后的字符串, 它是一个 bytes 对象

encode()

#描述:

endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True, 否则返回False. 可选参数"start"与"end"为检索字符串的开始与结束位置#语法:

str.endswith(suffix[, start[, end]])#参数:

suffix --该参数可以是一个字符串或者是一个元素

start--字符串中的开始位置

end--字符中结束位置#返回值:

如果字符串含有指定的后缀返回True,否则返回False

endswith()

#描述:

expandtabs() 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8

#语法:

str.expandtabs(tabsize=8)#参数:

tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数#返回值:

该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串

expandtabs()

#描述:

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

find()

#描述:

index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg(开始) 和 end(结束) 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常#语法:

str.index(str, beg=0, end=len(string))#参数:

str --指定检索的字符串

beg--开始索引，默认为0

end--结束索引，默认为字符串的长度#返回值:

如果包含子字符串返回开始的索引值，否则抛出异常

index()

#描述:

isalnum() 方法检测字符串是否由字母和数字组成#语法:

str.isalnum()#参数:

无#返回值:

如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

isalnum()

#描述:

isalpha() 方法检测字符串是否只由字母组成#语法:

str.isalpha()#参数:

无#返回值:

如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False

isalpha()

#描述:

isdigit() 方法检测字符串是否只由数字组成#语法:

str.isdigit()#参数:

无#返回值:

如果字符串只包含数字则返回 True, 否则返回 False

isdigit()

#描述:

islower() 方法检测字符串是否由小写字母组成#语法:

str.islower()#参数:

无#返回值:

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

islower()

#描述:

isupper() 方法检测字符串中所有的字母是否都为大写#语法:

str.isupper()#参数:

无#返回值:

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

isupper()

#描述:

isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象

[注意]: 定义一个字符串为Unicode，只需要在字符串前添加'u'前缀即可#语法:

str.isnumeric()#参数:

无#返回值:

如果字符串中只包含数字字符，则返回 True，否则返回 False

isnumeric()

#描述:

isspace() 方法检测字符串是否只由空白字符组成#语法:

str.isspace()#参数:

无#返回值:

如果字符串中只包含空格，则返回 True，否则返回 False

isspace()

#描述:

istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写#语法:

str.istitle()#参数:

无#返回值:

如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False

istitle()

#描述:

isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象

[注意]: 定义一个十进制字符串，只需要在字符串前添加'u'前缀即可#语法:

str.isdecimal()#参数:

无#返回值:

如果字符串是否只包含十进制字符返回True，否则返回False

isdecimal()

#描述:

join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串#语法:

str.join(sequence)#参数:

sequence --要连接的元素序列#返回值:

返回通过指定字符连接序列中元素后生成的新字符串

join()

#描述:

len() 方法返回对象(字符、列表、元组等)长度或项目个数#语法:

len( s )#参数:

s --对象#返回值:

返回对象长度

len()

#描述:

lower() 方法转换字符串中所有大写字符为小写#语法:

str.lower()#参数:

无#返回值:

返回将字符串中所有大写字符转换为小写后生成的字符串

lower()

#描述:

ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串#语法:

str.ljust(width[, fillchar])#参数:

width --指定字符串长度

fillchar--填充字符，默认为空格#返回值:

返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串#实例:

str = "Hello, Word!"

print (str.ljust(20, '*'))#输出结果:

Hello, Word!********

ljust()

#描述:

lstrip() 方法用于截掉字符串左边的空格或指定字符#语法:

str.lstrip([chars])#参数:

chars --指定截取的字符#返回值:

返回截掉字符串左边的空格或指定字符后生成的新字符串

lstrip()

#描述:

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

maketrans()

#描述:

max() 方法返回字符串中最大的字母#语法:

max(str)#参数:

str --字符串#返回值:

返回字符串中最大的字母

max()

#描述:

min() 方法返回字符串中最小的字母#语法:

min(str)#参数:

str --字符串#返回值:

返回字符串中最小的字母

min()

#描述:

rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回-1

#语法:

str.rfind(str, beg=0 end=len(string))#参数:

str --查找的字符串

beg--开始查找的位置，默认为0

end--结束查找位置，默认为字符串的长度#返回值:

返回字符串最后一次出现的位置，如果没有匹配项则返回-1

rfind()

#描述:

rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间#语法:

str.rindex(str, beg=0 end=len(string))#参数:

str --查找的字符串

beg--开始查找的位置，默认为0

end--结束查找位置，默认为字符串的长度#返回值:

返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常

rindex()

#描述:

rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串#语法:

str.rjust(width[, fillchar])#参数:

width --指定填充指定字符后中字符串的总长度

fillchar--填充的字符，默认为空格#返回值:

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串

rjust()

#描述:

rstrip() 删除 string 字符串末尾的指定字符(默认为空格)#语法:

str.rstrip([chars])#参数:

chars --指定删除的字符(默认为空格)#返回值:

返回删除 string 字符串末尾的指定字符后生成的新字符串

rstrip()

#描述:

replace() 方法把字符串中的 old(旧字符串) 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次#语法:

str.replace(old, new[, max])#参数:

old --将被替换的子字符串。

new--新字符串，用于替换old子字符串

max--可选字符串, 替换不超过 max 次#返回值:

返回字符串中的 old(旧字符串) 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次

replace()

#描述:

split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串#语法:

str.split(str="", num=string.count(str))#参数:

str --分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等

num--分割次数#返回值:

返回分割后的字符串列表

split()

#描述:

splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符

#语法:

str.splitlines([keepends])#参数:

keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符

#返回值:

返回一个包含各行作为元素的列表

splitlines()

#描述:

startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查#语法:

str.startswith(str, beg=0,end=len(string))#参数:

str --检测的字符串

strbeg--可选参数用于设置字符串检测的起始位置

strend--可选参数用于设置字符串检测的结束位置#返回值:

如果检测到字符串则返回True，否则返回False

startswith()

#描述:

strip() 方法用于移除字符串头尾指定的字符(默认为空格)或字符序列。

[注意]: 该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。#语法:

str.strip([chars])#参数:

chars --移除字符串头尾指定的字符序列#返回值:

返回移除字符串头尾指定的字符序列生成的新字符串

strip()

#描述:

swapcase() 方法用于对字符串的大小写字母进行转换#语法:

str.swapcase()#参数:

无#返回值:

返回大小写字母转换后生成的新字符串

swapcase()

#描述:

title() 方法返回"标题化"的字符串, 就是说所有单词的首个字母转化为大写，其余字母均为小写#语法:

str.title()#参数:

无#返回值:

返回"标题化"的字符串,就是说所有单词的首字母都转化为大写

title()

#描述:

translate() 方法根据参数table给出的表(包含 256个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中#语法:

str.translate(table)

bytes.translate(table[, delete])

bytearray.translate(table[, delete])#参数:

table --翻译表，翻译表是通过 maketrans() 方法转换而来

deletechars--字符串中要过滤的字符列表#返回值:

返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射

translate()

#描述:

upper() 方法将字符串中的小写字母转为大写字母#语法:

str.upper()#参数:

无#返回值:

返回小写字母转为大写字母的字符串

upper()

#描述:

zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0#语法:

str.zfill(width)#参数:

width --指定字符串的长度。原字符串右对齐，前面填充0#返回值:

返回指定长度的字符串

zfill()

三. 元组(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)deltup;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']

list.append(obj)

#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]

list.extend(seq)

#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']

list.insert(index, obj)

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

list.pop()

#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']

list.remove()

#1. 描述:

clear() 函数用于清空列表，类似于 dela[:]#2. 语法:

list.clear()#3. 参数:

无#4. 返回值:

无#5. 实例:

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']

list1.clear()print ("列表清空后 :", list1)#输出结果:

列表清空后 : []

list.clear()

#del lst[index] -- 指定索引进行删除

#del lst[beg:end:step] -- 切片删除

del 语句

3. 修改

#索引修改 -- lst[index] = 目标对象

#切片修改 -- lst[start:end:step] = 目标对象

4. 查询

for循环遍历列表:

#只能拿到元素

for el inlist:print(el)#即拿索引又拿元素

for i inrange(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 元素个数 : 2Runoob 元素个数 :1

list.count(obj)

#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 索引值为 1Taobao 索引值为2

list.index(obj)

#1. 描述:

reverse() 函数用于反向列表中元素。#2. 语法:

list.reverse()#3. 参数:

无#4. 返回值:

该方法没有返回值，但是会对列表的元素进行反向排序。#5. 实例:

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']

list1.reverse()print(list1)#输出结果:

['Baidu', 'Taobao', 'Runoob', 'Google']

list.reverse()

#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: 通过指定列表中的元素排序来输出列表

#获取列表的第二个元素

deftakeSecond(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)]

list.sort()

#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']

list.copy()

函数:

#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

len(list)

#1. 描述:

max() 方法返回列表元素中的最大值#2. 语法:

max(list)#3. 参数:

list --要返回最大值的列表#4. 返回值:

返回列表元素中的最大值

max(list)

#1. 描述

min() 方法返回列表元素中的最小值#2. 语法:

min(list)#3. 参数:

list --要返回最小值的列表#4. 返回值:

返回列表元素中的最小值

min(list)

#1. 描述:

list() 方法用于将元组转换为列表。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。#2. 语法:

list( seq )#3. 参数:

list --要转换为列表的元组。#4. 返回值:

返回列表。

list(seq)

二. 字典(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

dict[key] = value

#描述:

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}

dict.setdefault(key, default=None)

2. 删除

dic = {"name":"王乃卉", "age":19","hobby":"摄影"}

ret= dic.pop("age") #pop()有返回值,返回被删除的value

print(ret) #结果为: 19

dict.pop[key]

dic = {"name":"王乃卉", "age":19","hobby":"摄影"}

del dic["age"]print(dic) #结果为: {"name":"王乃卉", "hobby":"摄影"}

del dict[key]

dic = {"name":"王乃卉", "age":19","hobby":"摄影"}

ret= dic.popitem() #随机删除,返回一个元组(删除的key,删除的value), 可以结构: k, v = dic.popitem()

print(ret) #结果为: ("hobby":"摄影")

dict.popitem()

#dict.clear()用于 清空字典

dict.clear()

3. 修改

dict[key] = value给字典增加一个键值对

dict[key] = value

dic = {"name":"王乃卉", "age":19","hobby":"摄影"}

dic1 = {"name":"王力宏", "age":37","hobby":"音乐"}

dic.update(dic1)#把dic1中的内容更新到dic中.如果key重名,则修改替换.如果不存在key,则新增.

dict.update()

4. 查询

dic = {"name":"王乃卉", "age":19","hobby":"摄影"}

print(dic["name"]) #结果: "王乃卉"

print(dic["gender"]) #如果key不存在则报错

dict[key]

dic = {"name":"王乃卉", "age":19","hobby":"摄影"}

print(dic.get("name")) #结果为: "王乃卉"

print(dic.get("gender")) #key不存在返回None

print(dic.get("gender", "女")) #key不存在时,第二个参数可以指定返回内容,原dict的内容不变,此打印结果为: 女

dict.get(key)

dic = {"name":"王乃卉", "age":19","hobby":"摄影"}

print(dic.setdefault("gender")) #key不存在时会为dict新增一个键值对 "gender":None ,此时打印结果为: None

dict.setdefault(key)

dic = {"name": "王乃卉", "age": 19, "hobby": "摄影"}#获取到所有key

for k indic:print(k)#获取到所有key

for k indic.keys():print(k)#获取到所有values

for v indic.values():print(v)#获取到所有key和values

for k, v indic.items():print(k, v)

for循环遍历字典

5. 其他常用操作

描述:

copy() 函数返回一个字典的浅复制

语法:

dict.copy()

参数:

无

返回值:

返回一个字典的浅复制

dict.copy()

#描述:

fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值#语法:

dict.fromkeys(seq[, value])#参数:

seq --字典键值列表

value--可选参数, 设置键序列(seq)的值#返回值:

该方法返回列表

dict.fromkeys(seq[, value])

#描述:

in操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。

而not in操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。#语法:

key indict#参数:

key --要在字典中查找的键。#返回值:

如果键在字典里返回true，否则返回false。

key in dict

#字典的嵌套

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 --必需，要添加的元素。#返回值:

无

add()

#描述:

update() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。#语法:

set.update(set)#参数:

set --必需，可以是元素或集合#返回值:

无#举例说明:

x = {"apple", "banana", "cherry"}

y= {"google", "runoob", "apple"}

x.update(y)print(x)#执行结果:#{'banana', 'apple', 'google', 'runoob', 'cherry'}

update(迭代更新)

2. 删除

#描述:

pop() 方法用于随机移除一个元素。#语法:

set.pop()#参数:

无#返回值:

返回移除的元素。#举例说明:

fruits = {"apple", "banana", "cherry"}

fruits.pop()print(fruits)#执行结果:#{'apple', 'banana'}

pop()

#描述:

remove() 方法用于移除集合中的指定元素。

该方法不同于 discard() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。#语法:

set.remove(item)#参数:

item --要移除的元素#返回值:

返回移除的元素。#举例说明:

fruits = {"apple", "banana", "cherry"}

fruits.remove("banana")print(fruits)#执行结果:#{'cherry', 'apple'}

remove()

#描述:

clear() 方法用于移除集合中的所有元素。#语法:

set.clear()#参数:

无#返回值:

无

clear()

3. 修改

集合中的数据没有索引. 也没有办法去定位一个元素. 所以没有办法进行直接修改，我们可以采用先删除后添加的方式来完成修改操作，具体如下示例:

s = {"刘嘉玲", '关之琳', "王祖贤","张曼玉", "李若彤"}#把刘嘉玲改成赵本山

s.remove("刘嘉玲")

s.add("赵本山")print(s)

4. 查询

set是一个可迭代对象. 所以可以进行for循环遍历查询:

for el ins:print(el)

5. 其他操作

#copy() 方法用于拷贝一个集合.

#举例说明:

fruits = {"apple", "banana", "cherry"}

x=fruits.copy()print(x)#执行结果:#{'cherry', 'banana', 'apple'}

copy()

#描述:

difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。#语法:

set.difference(set)#参数:

set --必需，用于计算差集的集合#返回值:

返回一个新的集合。#举例说明:

x = {"apple", "banana", "cherry"}

y= {"google", "microsoft", "apple"}

z=x.difference(y)print(z)#执行结果:#{'cherry', 'banana'}

difference()

#描述:

discard() 方法用于移除指定的集合元素。

该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。#语法:

set.discard(value)#参数:

value --必需，要移除的元素#返回值:

无#举例说明:

fruits = {"apple", "banana", "cherry"}

fruits.discard("banana")print(fruits)#执行结果:#{'cherry', 'apple'}

discard()

#描述:

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'}

intersection()

#描述:

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

set.isdisjoint(set)#参数:

set --必需，要比较的集合#返回值:

返回布尔值，如果不包含返回 True，否则返回 False。#举例说明:

x = {"apple", "banana", "cherry"}

y= {"google", "runoob", "facebook"}

z=x.isdisjoint(y)print(z)#执行结果:#True

set.isdisjoint()

#描述:

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

issubset()

#描述:

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

issuperset()

#描述:

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

#描述:

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'}

symmetric_difference_update()

#描述:

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'}

union()