您的位置: 首页 > IT文章 > Python 基本数据类型

Python 基本数据类型

分类: IT文章 • 2025-01-13 12:40:19

不可变数据(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-8
errors -- 设置不同错误的处理方案.
默认为 '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 符号('	')转为空格，tab 符号('	')默认的空格数是 8

#语法:
str.expandtabs(tabsize=8)

#参数:
tabsize -- 指定转换字符串中的 tab 符号('	')转为空格的字符数

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

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 -- 分隔符，默认为所有的空字符，包括空格、换行(
)、制表符(	)等
num -- 分割次数

#返回值:
返回分割后的字符串列表

split()

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

#语法:
str.splitlines([keepends])

#参数:
keepends -- 在输出结果里是否去掉换行符('
', '
', 
')，默认为 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)
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']

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() 函数用于清空列表，类似于 del a[:]

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

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 索引值为 1
Taobao 索引值为 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: 通过指定列表中的元素排序来输出列表

# 获取列表的第二个元素
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)]

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

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 in dict

#参数:
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 in s:
    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()