首页 > 其他分享 >六大类型常用函数及详解

六大类型常用函数及详解

时间：2023-11-24 12:34:32浏览次数：25  
标签：输出 六大 函数 Runoob 字符串 详解 str print math

一、数字类型

（一）含义概念

Python 数字数据类型用于存储数值。

数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1
var2 = 10

Python 支持三种不同的数值类型：

  • 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
  • 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
  • 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

（二）数字类型常用的函数

1、数学函数

abs(x)	#	返回数字的绝对值，如abs(-10) 返回 10
print ("abs(-40) : ", abs(-40))
print ("abs(100.10) : ", abs(100.10))

#输出结果为
abs(-40) :  40
abs(100.10) :  100.1

round(x [,n]) #	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。

print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))

#	输出结果为
round(70.23456) :  70
round(56.659,1) :  56.7
round(80.264, 2) :  80.26
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0

max(x1, x2,...)	#	返回给定参数的最大值，参数可以为序列。

print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))
#	输出结果为
max(80, 100, 1000) :  1000
max(-20, 100, 400) :  400
max(-80, -20, -10) :  -10
max(0, 100, -400) :  100

    
    
min(x1, x2,...)	#	返回给定参数的最小值，参数可以为序列。

print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))
print ("min(-80, -20, -10) : ", min(-80, -20, -10))
print ("min(0, 100, -400) : ", min(0, 100, -400))
#	输出结果为
min(80, 100, 1000) :  80
min(-20, 100, 400) :  -20
min(-80, -20, -10) :  -80
min(0, 100, -400) :  -400

下列函数需要导入math模块后方可使用

ceil(x)	#	返回数字的上入整数，如math.ceil(4.1) 返回 5


import math   # 导入 math 模块

print ("math.ceil(-45.17) : ", math.ceil(-45.17))
print ("math.ceil(100.12) : ", math.ceil(100.12))
print ("math.ceil(100.72) : ", math.ceil(100.72))
print ("math.ceil(math.pi) : ", math.ceil(math.pi))

#	输出结果为
math.ceil(-45.17) :  -45
math.ceil(100.12) :  101
math.ceil(100.72) :  101
math.ceil(math.pi) :  4

exp(x)	#	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045


import math   # 导入 math 模块

print ("math.exp(-45.17) : ", math.exp(-45.17))
print ("math.exp(100.12) : ", math.exp(100.12))
print ("math.exp(100.72) : ", math.exp(100.72))
print ("math.exp(math.pi) : ", math.exp(math.pi))

#	输出结果为
math.exp(-45.17) :  2.4150062132629406e-20
math.exp(100.12) :  3.0308436140742566e+43
math.exp(100.72) :  5.522557130248187e+43
math.exp(math.pi) :  23.140692632779267

fabs(x)	#	以浮点数形式返回数字的绝对值，如math.fabs(-10) 返回10.0

import math

x = -1.5
y = math.fabs(x)
print(y) # 输出 1.5

x = 10
y = math.fabs(x)
print(y) # 输出 10.0

"""
以上实例中，fabs(-1.5) 返回了 -1.5 的绝对值 1.5， fabs(10) 返回了 10 的绝对值 10.0。注意，返回值总是一个浮点数，即使传入的参数是整数。
"""


import math   # 导入 math 模块

print ("math.fabs(-45.17) : ", math.fabs(-45.17))
print ("math.fabs(100.12) : ", math.fabs(100.12))
print ("math.fabs(100.72) : ", math.fabs(100.72))
print ("math.fabs(math.pi) : ", math.fabs(math.pi))

#	输出结果为
math.fabs(-45.17) :  45.17
math.fabs(100.12) :  100.12
math.fabs(100.72) :  100.72
math.fabs(math.pi) :  3.141592653589793

floor(x)#	返回数字的下舍整数，如math.floor(4.9)返回 4

import math   # 导入 math 模块

print ("math.floor(-45.17) : ", math.floor(-45.17))
print ("math.floor(100.12) : ", math.floor(100.12))
print ("math.floor(100.72) : ", math.floor(100.72))
print ("math.floor(math.pi) : ", math.floor(math.pi))


#	输出结果为
math.floor(-45.17) :  -46
math.floor(100.12) :  100
math.floor(100.72) :  100
math.floor(math.pi) :  3

log(x)	#	如math.log(math.e)返回1.0,math.log(100,10)返回2.0

import math   # 导入 math 模块

print ("math.log(100.12) : ", math.log(100.12))
print ("math.log(100.72) : ", math.log(100.72))
print ("math.log(math.pi) : ", math.log(math.pi))


#	输出结果为
math.log(100.12) :  4.6063694665635735
math.log(100.72) :  4.612344389736092
math.log(math.pi) :  1.1447298858494002

log10(x)#	返回以10为基数的x的对数，如math.log10(100)返回 2.0

import math   # 导入 math 模块

print ("math.log10(100.12) : ", math.log10(100.12))
print ("math.log10(100.72) : ", math.log10(100.72))
print ("math.log10(119) : ", math.log10(119))
print ("math.log10(math.pi) : ", math.log10(math.pi))

#	输出结果为
math.log10(100.12) :  2.0005208409361854
math.log10(100.72) :  2.003115717099806
math.log10(119) :  2.075546961392531
math.log10(math.pi) :  0.4971498726941338

modf(x)	#	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

import math   # 导入 math 模块

print ("math.modf(100.12) : ", math.modf(100.12))
print ("math.modf(100.72) : ", math.modf(100.72))
print ("math.modf(119) : ", math.modf(119))
print ("math.modf(math.pi) : ", math.modf(math.pi))

#	输出结果为
math.modf(100.12) :  (0.12000000000000455, 100.0)
math.modf(100.72) :  (0.7199999999999989, 100.0)
math.modf(119) :  (0.0, 119.0)
math.modf(math.pi) :  (0.14159265358979312, 3.0)

pow(x, y)	#	x**y 运算后的值。

import math   # 导入 math 模块

print ("math.pow(100, 2) : ", math.pow(100, 2))
# 使用内置，查看输出结果区别
print ("pow(100, 2) : ", pow(100, 2))
print ("math.pow(100, -2) : ", math.pow(100, -2))
print ("math.pow(2, 4) : ", math.pow(2, 4))
print ("math.pow(3, 0) : ", math.pow(3, 0))

#	输出结果为
math.pow(100, 2) :  10000.0
pow(100, 2) :  10000
math.pow(100, -2) :  0.0001
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0

sqrt(x)	#	返回数字x的平方根。

2、随机数函数

需要导入random模块才能使用

choice(seq)	#	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。

import random

print ("从 range(100) 返回一个随机数 : ",random.choice(range(100)))
print ("从列表中 [1, 2, 3, 5, 9] 返回一个随机元素 : ", random.choice([1, 2, 3, 5, 9]))
print ("从字符串中 'Runoob' 返回一个随机字符 : ", random.choice('Runoob'))

#	输出结果为
从 range(100) 返回一个随机数 :  68
从列表中 [1, 2, 3, 5, 9] 返回一个随机元素 :  2
从字符串中 'Runoob' 返回一个随机字符 :  u

    
"""
生成密码小方法：

def generate_password(length):
    # 定义密码可用字符集合（ascii_letters为大小写字母，digits为数字，punctuation为特殊符号）
    chars = string.ascii_letters + string.digits + string.punctuation

    # 随机选择字符生成密码，将循环循环length次，每次在chars中取一个值，将六个值组装成一个字符串赋值给password变量
    password = ''.join(random.choice(chars) for _ in range(length))

    return password


random_pwd = generate_password(6)  # 输出长度为 6
print(random_pwd)

"""

randrange ([start]，stop ,[step])	#	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1


import random
 
# 从 1-100 中选取一个奇数
print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2))
 
# 从 0-99 选取一个随机数
print ("randrange(100) : ", random.randrange(100))

#	输出结果为
randrange(1,100, 2) :  97
randrange(100) :  42

random()	#	随机生成下一个实数，它在[0,1)范围内。


import random

# 第一个随机数
print ("random() : ", random.random())

# 第二个随机数
print ("random() : ", random.random())

#	输出结果为
random() :  0.09690599908884856
random() :  0.8732120512570916

seed([x])	#	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。


import random

random.seed()
print ("使用默认种子生成随机数：", random.random())
print ("使用默认种子生成随机数：", random.random())

random.seed(10)
print ("使用整数 10 种子生成随机数：", random.random())
random.seed(10)
print ("使用整数 10 种子生成随机数：", random.random())

random.seed("hello",2)
print ("使用字符串种子生成随机数：", random.random())

#	输出结果为
使用默认种子生成随机数： 0.7908102856355441
使用默认种子生成随机数： 0.81038961519195
使用整数 10 种子生成随机数： 0.5714025946899135
使用整数 10 种子生成随机数： 0.5714025946899135
使用字符串种子生成随机数： 0.3537754404730722

shuffle(lst)	#	将序列的所有元素随机排序

import random
 
list = [20, 16, 10, 5];
random.shuffle(list)
print ("随机排序列表 : ",  list)
 
random.shuffle(list)
print ("随机排序列表 : ",  list)

#	输出结果为
随机排序列表 :  [20, 5, 16, 10]
随机排序列表 :  [5, 20, 10, 16]

uniform(x, y)	#	随机生成下一个实数，它在[x,y]范围内。


import random
 
print ("uniform(5, 10) 的随机浮点数 : ",  random.uniform(5, 10))
 
print ("uniform(7, 14) 的随机浮点数 : ",  random.uniform(7, 14))

#	输出结果为
uniform(5, 10) 的随机浮点数 :  7.054602800254241
uniform(7, 14) 的随机浮点数 :  12.552229882744296

二、字符串

（一）含义概念

字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号 [] 来截取字符串

（二）字符串转义

在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表

(在行尾时) 续行符 >>> print("line1 <br/>... line2 <br/>... line3")
line1 line2 line3
>>>
\ 反斜杠符号 >>> print("\")
\
' 单引号 >>> print(''')
'
" 双引号 >>> print(""")
"
\a 响铃 >>> print("\a")
执行后电脑有响声
\b 退格(Backspace) >>> print("Hello \b World!")
Hello World!
\000 空 >>> print("\000")

>>>
\n 换行 >>> print("\n")


>>>
\v 纵向制表符 >>> print("Hello \v World!")
Hello
World!
>>>
\t 横向制表符 >>> print("Hello \t World!")
Hello World!
>>>
\r 回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。 >>> print("Hello\rWorld!")
World!
>>> print('google runoob taobao\r123456')
123456 runoob taobao
\f 换页 >>> print("Hello \f World!")
Hello
World!
>>>

使用 \r 实现百分比精度：

import time

for i in range(101):
    print("\r{:3}%".format(i),end=' ')
    time.sleep(0.05)

演示示例：

print('\'Hello, world!\'')  # 输出：'Hello, world!'

print("Hello, world!\nHow are you?")  # 输出：Hello, world!
                                        #       How are you?

print("Hello, world!\tHow are you?")  # 输出：Hello, world!    How are you?

print("Hello,\b world!")  # 输出：Hello world!

print("Hello,\f world!")  # 输出：
                           # Hello,
                           #  world!

（三）字符串运算

下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：

+ 字符串连接 a + b 输出结果： HelloPython
* 重复输出字符串 a*2 输出结果：HelloHello
[] 通过索引获取字符串中字符 a[1] 输出结果 e
[ : ] 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 a[1:4] 输出结果 ell
in 成员运算符 - 如果字符串中包含给定的字符返回 True 'H' in a 输出结果 True
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True 'M' not in a 输出结果 True
r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 print( r'\n' )
print( R'\n' )
% 格式字符串 请看下一节内容。

演示示例：

 
a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
 
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
 
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")
 
print (r'\n')
print (R'\n')

#	输出结果为
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

（四）字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

#!/usr/bin/python3
 
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

#	输出结果为

我叫 小明 今年 10 岁!
符 号 描述
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写

格式化字符串辅助指令：

符号 功能
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
在正数前面显示空格
# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0 显示的数字前面填充'0'而不是默认的空格
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

format详解：

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'



 
print("网站名：{name}, 地址 {url}".format(name="淘宝", url="https://www.taobao.com"))
 
# 通过字典设置参数
site = {"name": "淘宝", "url": "https://www.taobao.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['淘宝', 'https://www.taobao.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的


#	输出结果为
网站名：淘宝, 地址 https://www.taobao.com
网站名：淘宝, 地址 https://www.taobao.com
网站名：淘宝, 地址 https://www.taobao.com

也可以向 str.format() 传入可迭代对象：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的


#	输出结果为
value 为: 6

下表展示了 str.format() 格式化数字的多种方法：

>>> print("{:.2f}".format(3.1415926))
3.14
数字 格式 输出 描述
3.1415926 3.14 保留小数点后两位
3.1415926 +3.14 带符号保留小数点后两位
-1 -1.00 带符号保留小数点后两位
2.71828 3 不带小数
5 05 数字补零 (填充左边, 宽度为2)
5 5xxx 数字补x (填充右边, 宽度为4)
10 10xx 数字补x (填充右边, 宽度为4)
1000000 1,000,000 以逗号分隔的数字格式
0.25 25.00% 百分比格式
1000000000 1.00e+09 指数记法
13 13 右对齐 (默认, 宽度为10)
13 13 左对齐 (宽度为10)
13 13 中间对齐 (宽度为10)

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

print ("{} 对应的位置是 {{0}}".format("runoob"))

#	输出结果为
runoob 对应的位置是 {0}

f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

之前我们习惯用百分号 (%):

>>> name = 'Runoob'
>>> 'Hello %s' % name
'Hello Runoob'

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。

在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

>>> x = 1
>>> print(f'{x+1}')   # Python 3.6
2

>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8
x+1=2

（五）字符串常用函数

序号 方法及描述
1 capitalize() 将字符串的第一个字符转换为大写
2 center(width, fillchar)返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3 count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4 bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5 encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
6 endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。
7 expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8 find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9 index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常。
10 isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
11 isalpha() 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
12 isdigit() 如果字符串只包含数字则返回 True 否则返回 False..
13 islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14 isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
15 isspace() 如果字符串中只包含空白，则返回 True，否则返回 False.
16 istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False
17 isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18 join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19 len(string) 返回字符串长度
20 [ljust(width, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21 lower() 转换字符串中所有大写字符为小写.
22 lstrip() 截掉字符串左边的空格或指定字符。
23 maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24 max(str) 返回字符串 str 中最大的字母。
25 min(str) 返回字符串 str 中最小的字母。
26 [replace(old, new , max]) 把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
27 rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找.
28 rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始.
29 [rjust(width,, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30 rstrip() 删除字符串末尾的空格或指定字符。
31 split(str="", num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
32 [splitlines(keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33 startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34 [strip(chars]) 在字符串上执行 lstrip()和 rstrip()
35 swapcase() 将字符串中大写转换为小写，小写转换为大写
36 title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37 translate(table, deletechars="") 根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38 upper() 转换字符串中的小写字母为大写
39 zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0
40 isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 
Python capitalize() 将字符串的第一个字母变成大写，其他字母变小写。
capitalize() 方法语法：
str.capitalize()


str = "this is string Example From Runoob....wow!!!"

print ("str.capitalize() : ", str.capitalize())

#	输出结果
str.capitalize() :  This is string example from runoob....wow!!!

center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

center()方法语法：

str.center(width[, fillchar])
width -- 字符串的总宽度。
fillchar -- 填充字符。



str = "[runoob]"

print ("str.center(40, '*') : ", str.center(40, '*'))

#	输出结果
str.center(40, '*') :  ****************[runoob]****************

count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

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

sub='run'
print ("str.count('run', 0, 10) : ", str.count(sub,0,10))

#	输出结果
str.count('o') :  3
str.count('run', 0, 10) :  1

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

decode()方法语法：

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

 
str = "忽而嘿哟";
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")
 
print(str)
 
print("UTF-8 编码：", str_utf8)
print("GBK 编码：", str_gbk)
 
print("UTF-8 解码：", str_utf8.decode('UTF-8','strict'))
print("GBK 解码：", str_gbk.decode('GBK','strict'))

#	输出结果
忽而嘿哟
UTF-8 编码： b'\xe5\xbf\xbd\xe8\x80\x8c\xe5\x98\xbf\xe5\x93\x9f'
GBK 编码： b'\xba\xf6\xb6\xf8\xba\xd9\xd3\xb4'
UTF-8 解码： 忽而嘿哟
GBK 解码： 忽而嘿哟

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

endswith()方法语法：

str.endswith(suffix, [start], [end])
suffix -- 该参数可以是一个字符串或者是一个元素。
start -- 字符串中的开始位置。
end -- 字符中结束位置。


 
Str='Runoob example....wow!!!'
suffix='!!'
print (Str.endswith(suffix))
print (Str.endswith(suffix,20))
suffix='run'
print (Str.endswith(suffix))
print (Str.endswith(suffix, 0, 19))

#	输出结果
True
True
False
False


expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16...等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。

expandtabs() 方法语法：

str.expandtabs(tabsize=8)
tabsize -- 指定转换字符串中的 tab 符号 \t 转为空格的字符数。

 
 
str = "runoob\t12345\tabc"  
print('原始字符串:', str)
 
# 默认 8 个空格
# runnob 有 6 个字符，后面的 \t 填充 2 个空格
# 12345 有 5 个字符，后面的 \t 填充 3 个空格
print('替换 \\t 符号:', str.expandtabs())
 
# 2 个空格
# runnob 有 6 个字符，刚好是 2 的 3 倍，后面的 \t 填充 2 个空格
# 12345 有 5 个字符，不是 2 的倍数，后面的 \t 填充 1 个空格
print('使用 2 个空格替换 \\t 符号:', str.expandtabs(2))
 
# 3 个空格
print('使用 3 个空格:', str.expandtabs(3))
 
# 4 个空格
print('使用 4 个空格:', str.expandtabs(4))
 
# 5 个空格
print('使用 5 个空格:', str.expandtabs(5))
 
# 6 个空格
print('使用 6 个空格:', str.expandtabs(6))

#	输出结果
原始字符串: runoob      12345   abc
替换 \t 符号: runoob  12345   abc
使用 2 个空格替换 \t 符号: runoob  12345 abc
使用 3 个空格: runoob   12345 abc
使用 4 个空格: runoob  12345   abc
使用 5 个空格: runoob    12345     abc
使用 6 个空格: runoob      12345 abc

find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。



find()方法语法：

str.find(str, beg=0, end=len(string))
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。


 
str1 = "Runoob example....wow!!!"
str2 = "exam";
 
print (str1.find(str2))
print (str1.find(str2, 5))
print (str1.find(str2, 10))

#	输出结果
7
7
-1

"""
示例2
>>>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中会报一个异常。

index()方法语法：
str.index(str, beg=0, end=len(string))
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。



str1 = "Runoob example....wow!!!"
str2 = "exam";

print (str1.index(str2))
print (str1.index(str2, 5))
print (str1.index(str2, 10))

#	输出结果
7
7
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (str1.index(str2, 10))
ValueError: substring not found


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

isalnum()方法语法：

str.isalnum()

 
str = "runoob2016"  # 字符串没有空格
print (str.isalnum())
 
str = "www.runoob.com"
print (str.isalnum())

#	输出结果为
True
False

Python isalpha() 方法检测字符串是否只由字母或文字组成。

isalpha()方法语法：

str.isalpha()


str = "runoob"
print (str.isalpha())

# 字母和中文文字
str = "runoob菜鸟教程"
print (str.isalpha())

str = "Runoob example....wow!!!"
print (str.isalpha())

#	输出结果
True
True
False

Python isdigit() 方法检测字符串是否只由数字组成。

isdigit()方法语法：

str.isdigit()

str = "123456"; 
print (str.isdigit())

str = "Runoob example....wow!!!"
print (str.isdigit())

#	输出结果
True
False



#	isdigit() 方法只对正整数有效，负数及小数均返回不正确。

#	可以使用以下函数来解决：
# 	判断是否为数字
def is_number(s):    
    try:    # 如果能运⾏ float(s) 语句，返回 True（字符串 s 是浮点数）        
        float(s)        
        return True    
    except ValueError:  # ValueError 为 Python 的⼀种标准异常，表⽰"传⼊⽆效的参数"        
        pass  # 如果引发了 ValueError 这种异常，不做任何事情（pass：不做任何事情，⼀般⽤做占位语句）    
    try:        
        import unicodedata  # 处理 ASCII 码的包        
        unicodedata.numeric(s)  # 把⼀个表⽰数字的字符串转换为浮点数返回的函数        
        return True    
    except (TypeError, ValueError):        
        pass    
        return False
 
print(is_number(1))
print(is_number(1.0))
print(is_number(0))
print(is_number(-2))
print(is_number(-2.0))
print(is_number("abc"))

#	输出结果为
True
True
True
True
True
False

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

islower()方法语法：

str.islower()

str = "RUNOOB example....wow!!!"
print (str.islower())

str = "runoob example....wow!!!"
print (str.islower())

#	输出结果为
False
True

isnumeric() 方法检测字符串是否只由数字组成，数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。指数类似 ² 与分数类似 ½ 也属于数字。
# s = '½'
s = '\u00BD'

isnumeric()方法语法：

str.isnumeric()


str = "runoob2016"  
print (str.isnumeric())

str = "23443434"
print (str.isnumeric())

#	输出结果为
False
True

Python isspace() 方法检测字符串是否只由空白字符组成。

isspace() 方法语法：

str.isspace()
 
str = "       " 
print (str.isspace())
 
str = "Runoob example....wow!!!"
print (str.isspace())

#	输出结果为
True
False

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

istitle()方法语法：

str.istitle()
 
str = "This Is String Example...Wow!!!"
print (str.istitle())
 
str = "This is string example....wow!!!"
print (str.istitle())

#	输出结果为
True
False

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

isupper()方法语法：

str.isupper()


str = "THIS IS STRING EXAMPLE....WOW!!!"
print (str.isupper())

str = "THIS is string example....wow!!!"
print (str.isupper())

#	输出结果为
True
False

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

join()方法语法：

str.join(sequence)


s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print (s1.join( seq ))
print (s2.join( seq ))

#	输出结果为
r-u-n-o-o-b
runoob


Python len() 方法返回给定序列的元素数量，无论这个序列是字符串、列表、元组、集合还是其他可迭代对象。

len()方法语法：

len( s )
s -- 对象。

text = "Hello, World!"
length = len(text)
print(length)  # 输出：13
#	以上实例中，len(text) 返回字符串 text 的字符数，包括空格和标点符号，输出结果为:13

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length)  # 输出：5
#	以上实例中，len(my_list) 返回列表 my_list 中的元素数量，输出结果为:5

my_tuple = (10, 20, 30)
length = len(my_tuple)
print(length)  # 输出：3
#	以上实例中，len(my_tuple) 返回元组 my_tuple 中的元素数量，输出结果为:3

my_set = {5, 10, 15, 20}
length = len(my_set)
print(length)  # 输出：4
#	以上实例中，len(my_set) 返回集合 my_set 中的唯一元素数量，输出结果为:4

my_dict = {"apple": 3, "banana": 2, "cherry": 4}
length = len(my_dict)
print(length)  # 输出：3
#	以上实例中，len(my_dict) 返回字典 my_dict 中键-值对的数量，输出结果为:3


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

ljust()方法语法：

str.ljust(width[, fillchar])
width -- 指定字符串长度。
fillchar -- 填充字符，默认为空格。


str = "Runoob example....wow!!!"

print (str.ljust(50, '*'))

#	输出结果为
Runoob example....wow!!!**************************

Python lower() 方法转换字符串中所有大写字符为小写。

lower()方法语法：

str.lower()


str = "Runoob EXAMPLE....WOW!!!"

print( str.lower() )

#	输出结果
runoob example....wow!!!

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

lstrip()方法语法：

str.lstrip([chars])
chars --指定截取的字符。


str = "     this is string example....wow!!!     ";
print( str.lstrip() );
str = "88888888this is string example....wow!!!8888888";
print( str.lstrip('8') );

#	输出结果为
this is string example....wow!!!     
this is string example....wow!!!8888888

max() 方法返回字符串中最大的字符。

max()方法语法：

max(str)
str -- 字符串。


str = "runoob"
print ("最大字符: " + max(str))


#	输出结果为
最大字符: u

Python min() 方法返回字符串中最小的字符。

min()方法语法：

min(str)
str -- 字符串。


str = "runoob";
print ("最小字符: " + min(str));

#	输出结果为
最小字符: b

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

replace()方法语法：

str.replace(old, new,[max])
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次

 
str = "www.baidu.com"
print("百度旧地址：", str)
print("百度新地址：", str.replace("baidu.com", "baidu.cn"))

str = "this is string example....wow!!!"
print(str.replace("is", "was", 3))


#	输出结果为
百度旧地址： www.baidu.com
百度新地址： www.baidu.cn
thwas was string example....wow!!!

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

rfind() 方法语法：

str.rfind(str, beg=0, end=len(string))
str -- 查找的字符串
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。


str1 = "this is really a string example....wow!!!"
str2 = "is"

print (str1.rfind(str2))

print (str1.rfind(str2, 0, 10))
print (str1.rfind(str2, 10, 0))

print (str1.find(str2))
print (str1.find(str2, 0, 10))
print (str1.find(str2, 10, 0))

#	输出结果为
5
5
-1
2
2
-1


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

rindex()方法语法：

str.rindex(str, beg=0 end=len(string))
str -- 查找的字符串
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。

str1 = "this is really a string example....wow!!!"
str2 = "is"

print (str1.rindex(str2))
print (str1.rindex(str2,10))


#	输出结果为
5
Traceback (most recent call last):
  File "test.py", line 6, in <module>
    print (str1.rindex(str2,10))
ValueError: substring not found


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

rjust()方法语法：

str.rjust(width,[fillchar])
width -- 指定填充指定字符后中字符串的总长度.
fillchar -- 填充的字符，默认为空格。


str = "this is string example....wow!!!"
print (str.rjust(50, '*'))

#	输出结果为
******************this is string example....wow!!!

rstrip() 删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。

rstrip()方法语法：

str.rstrip([chars])
chars -- 指定删除的字符（默认为空白符）

random_string = 'this is good    '

# 字符串末尾的空格会被删除
print(random_string.rstrip())

# 'si oo' 不是尾随字符，因此不会删除任何内容
print(random_string.rstrip('si oo'))

# 在 'sid oo' 中 'd oo' 是尾随字符，'ood' 从字符串中删除
print(random_string.rstrip('sid oo')) 

# 'm/' 是尾随字符，没有找到 '.' 号的尾随字符, 'm/' 从字符串中删除
website = 'www.runoob.com/' 
print(website.rstrip('m/.'))


# 移除逗号(,)、点号(.)、字母 s、q 或 w，这几个都是尾随字符
txt = "banana,,,,,ssqqqww....."
x = txt.rstrip(",.qsw")
print(x)
# 删除尾随字符 *
str = "*****this is string example....wow!!!*****"
print (str.rstrip('*'))

#	输出结果为
this is good
this is good
this is g
www.runoob.co
banana
*****this is string example....wow!!!

split() 方法通过指定分隔符对字符串进行切片，该方法将字符串分割成子字符串并返回一个由这些子字符串组成的列表。
如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
split()方法特别适用于根据特定的分隔符将字符串拆分成多个部分。

split() 方法语法：

str.split(str="", num=string.count(str))
str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数，如果设置了这个参数，则最多分割成 maxsplit+1 个子字符串。默认为 -1, 即分隔所有。


str = "this is string example....wow!!!"
print (str.split())        # 默认以空格为分隔符
print (str.split('i',1))   # 以 i 为分隔符
print (str.split('w'))     # 以 w 为分隔符

#	输出结果为
['this', 'is', 'string', 'example....wow!!!']
['th', 's is string example....wow!!!']
['this is string example....', 'o', '!!!']




#	示例2【以下实例以 # 号为分隔符，指定第二个参数为 1，返回两个参数列表。】
 
txt = "Google#Runoob#Taobao#Facebook"
 
# 第二个参数为 1，返回两个参数列表
x = txt.split("#", 1)
 
print(x)

#	输出结果为
['Google', 'Runoob#Taobao#Facebook']

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

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

                          
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']
>>> 


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

startswith()方法语法：

str.startswith(substr, beg=0,end=len(string));
str -- 检测的字符串。
substr -- 指定的子字符串。
strbeg -- 可选参数用于设置字符串检测的起始位置。
strend -- 可选参数用于设置字符串检测的结束位置。

 
str = "this is string example....wow!!!"
print (str.startswith( 'this' ))   # 字符串是否以 this 开头
print (str.startswith( 'string', 8 ))  # 从第九个字符开始的字符串是否以 string 开头
print (str.startswith( 'this', 2, 4 )) # 从第2个字符开始到第四个字符结束的字符串是否以 this 开头

#	输出结果为
True
True
False

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

strip()方法语法：

str.strip([chars]);
chars -- 移除字符串头尾指定的字符序列。


 
str = "*****this is **string** example....wow!!!*****"
print (str.strip( '*' ))  # 指定字符串 *

#	输出结果为
this is **string** example....wow!!!
#	从结果上看，可以注意到中间部分的字符并未删除。




#	以上下例演示了只要头尾包含有指定字符序列中的字符就删除：
 
str = "123abcrunoob321"
print (str.strip( '12' ))  # 字符序列为 12

#	输出结果为
3abcrunoob3

Python swapcase() 方法用于对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母。

swapcase() 方法语法：

str.swapcase();


str = "RUNOOB!!!";
print ( str.swapcase() );
 
str = "runoob!!!";
print ( str.swapcase() );
 
str = "abCDE--RuNOob!!!";
print ( str.swapcase() );

#	输出结果为
runoob!!!
RUNOOB!!!
ABcde--rUnoOB!!!

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

title()方法语法：

str.title();
 
str = "this is string example from runoob....wow!!!"
print (str.title())

#	输出结果为
This Is String Example From Runoob....Wow!!!



请注意，非字母后的第一个字母将转换为大写字母：
 
txt = "hello b2b2b2 and 3g3g3g"
x = txt.title()
print(x)

#	输出结果为
Hello B2B2B2 And 3G3G3G

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

translate()方法语法：

str.translate(table)
bytes.translate(table, [delete])    
bytearray.translate(table, [delete]) 
table -- 翻译表，翻译表是通过 maketrans() 方法转换而来。
deletechars -- 字符串中要过滤的字符列表。


 
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)   # 制作翻译表
 
str = "this is string example....wow!!!"
print (str.translate(trantab))

#	输出结果为
th3s 3s str3ng 2x1mpl2....w4w!!!




#	示例二【以下实例演示如何过滤掉的字符 o：】
 
# 制作翻译表
bytes_tabtrans = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
# 转换为大写，并删除字母o
print(b'runoob'.translate(bytes_tabtrans, b'o'))

#	输出结果为
b'RUNB'

Python upper() 方法将字符串中的小写字母转为大写字母。

upper()方法语法：

str.upper()

str = "this is string example from runoob....wow!!!";

print ("str.upper() : ", str.upper())

#	输出结果为
str.upper() :  THIS IS STRING EXAMPLE FROM RUNOOB....WOW!!!

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

zfill()方法语法：

str.zfill(width)
width -- 指定字符串的长度。原字符串右对齐，前面填充0。


str = "this is string example from runoob....wow!!!"
print ("str.zfill : ",str.zfill(40))
print ("str.zfill : ",str.zfill(50))


#	输出结果为
str.zfill :  this is string example from runoob....wow!!!
str.zfill :  000000this is string example from runoob....wow!!!

isdecimal() 方法检查字符串是否只包含十进制字符。

isdecimal() 方法语法：

str.isdecimal()

str = "runoob2016"
print (str.isdecimal())

str = "23443434"
print (str.isdecimal())

#	输出结果为
False
True

三、列表

（一）含义和概念

序列是 Python 中最基本的数据结构。

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

Python 有 6 个序列的内置类型，但最常见的是列表和元组。

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

（二）列表截取、更新、删除

通过索引列表可以进行截取、组合等操作。

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

img

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

img

使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符，如下所示：

img

集中示例：

#	正访问
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )
#	输出结果为
red
green
blue


#	反访问
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )
#	输出结果为
black
white
yellow


#	方括号截取
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
#	输出结果为
[10, 20, 30, 40]



#	使用负数索引值截取
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
 
# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])
#	输出结果为
list[1]:  Runoob
list[1:-2]:  ['Runoob', 'Zhihu']

Python 的列表截取与字符串操作类似，如下所示：

Python 表达式 结果 描述
L[2] 'Taobao' 读取第三个元素
L[-2] 'Runoob' 从右侧开始读取倒数第二个元素: count from the right
L[1:] ['Runoob', 'Taobao'] 输出从第二个元素开始后的所有元素 
>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>


>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 表达式 结果 描述
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, end=" ") 1 2 3 迭代

你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：

 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
 
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

#	输出结果为
第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

可以使用 del 语句来删除列表的的元素，如下实例：

 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

#	输出结果为
原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

使用嵌套列表即在列表里创建其它列表，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

列表比较需要引入 operator 模块的 eq 方法（详见：Python operator 模块）：

# 导入 operator 模块
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))

#	输出结果为
operator.eq(a,b):  False
operator.eq(c,b):  True

（三）列表的函数和方法

Python包含以下函数:

序号 函数
1 len(list) 列表元素个数
2 max(list) 返回列表元素最大值
3 min(list) 返回列表元素最小值
4 list(seq) 将元组转换为列表

Python包含以下方法:

序号 方法
1 list.append(obj) 在列表末尾添加新的对象
2 list.count(obj) 统计某个元素在列表中出现的次数
3 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4 list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj) 将对象插入列表
6 [list.pop(index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7 list.remove(obj) 移除列表中某个值的第一个匹配项
8 list.reverse() 反向列表中元素
9 list.sort( key=None, reverse=False) 对原列表进行排序
10 list.clear() 清空列表
11 list.copy() 复制列表 
len() 方法返回列表元素个数。

len()方法语法：

len(list)
list -- 要计算元素个数的列表。


list1 = ['Google', 'Runoob', 'Taobao']
print (len(list1))
list2=list(range(5)) # 创建一个 0-4 的列表
print (len(list2))

#	输出结果为
3
5

max() 方法返回列表元素中的最大值。

max()方法语法：

max(list)
list -- 要返回最大值的列表。


list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200]

print ("list1 最大元素值 : ", max(list1))
print ("list2 最大元素值 : ", max(list2))

#	输出结果为
list1 最大元素值 :  Taobao
list2 最大元素值 :  700

min() 方法返回列表元素中的最小值。

min()方法语法：

min(list)
list -- 要返回最小值的列表。


list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200]

print ("list1 最小元素值 : ", min(list1))
print ("list2 最小元素值 : ", min(list2))


#	输出结果为
list1 最小元素值 :  Google
list2 最小元素值 :  200

append() 方法用于在列表末尾添加新的对象。

append()方法语法：

list.append(obj)
obj -- 添加到列表末尾的对象。



list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

#	更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']


"""
队列是一种先进先出（FIFO）的数据结构，我们可以使用列表来实现队列的基本功能。

append() 方法向队列的末尾添加一个元素。
pop() 方法从队列的开头删除一个元素并返回它。

queue = []

# 添加元素到队列的末尾
queue.append('A')
queue.append('B')
queue.append('C')

# 从队列的开头删除元素并返回
print(queue.pop(0))  # A
print(queue.pop(0))  # B
print(queue.pop(0))  # C

我们创建了一个空的列表作为队列，然后使用 append() 方法向队列的末尾添加了三个元素。接下来，我们使用 pop() 方法从队列的开头删除元素并返回它们。由于队列是一个先进先出的数据结构，所以我们得到的输出结果是 'A'、'B' 和 'C'。
"""

count() 方法用于统计某个元素在列表中出现的次数。

count()方法语法：

list.count(obj)
obj -- 列表中统计的对象。


aList = [123, 'Google', 'Runoob', 'Taobao', 123];

print ("123 元素个数 : ", aList.count(123))
print ("Runoob 元素个数 : ", aList.count('Runoob'))

#	输出结果为
123 元素个数 :  2
Runoob 元素个数 :  1

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

extend()方法语法：

list.extend(seq)
seq -- 元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。

 
list1 = ['Google', 'Runoob', 'Taobao']
list2=list(range(5)) # 创建 0-4 的列表
list1.extend(list2)  # 扩展列表
print ("扩展后的列表：", list1)

#	输出结果为	
扩展后的列表： ['Google', 'Runoob', 'Taobao', 0, 1, 2, 3, 4]




#	不同数据类型
 
# 语言列表
language = ['French', 'English', 'German']
 
# 元组
language_tuple = ('Spanish', 'Portuguese')
 
# 集合
language_set = {'Chinese', 'Japanese'}
 
# 添加元组元素到列表末尾
language.extend(language_tuple)
 
print('新列表: ', language)
 
# 添加集合元素到列表末尾
language.extend(language_set)
 
print('新列表: ', language)

#	输出结果为
新列表:  ['French', 'English', 'German', 'Spanish', 'Portuguese']
新列表:  ['French', 'English', 'German', 'Spanish', 'Portuguese', 'Chinese', 'Japanese']

index() 函数用于从列表中找出某个值第一个匹配项的索引位置。

index()方法语法：

list.index(x, [start, [end]])
x-- 查找的对象。
start-- 可选，查找的起始位置。
end-- 可选，查找的结束位置。


list1 = ['Google', 'Runoob', 'Taobao']
print ('Runoob 索引值为', list1.index('Runoob'))
print ('Taobao 索引值为', list1.index('Taobao'))

#	输出结果为
Runoob 索引值为 1
Taobao 索引值为 2




list1 = ['Google', 'Runoob', 'Taobao', 'Facebook', 'QQ']
# 从指定位置开始搜索
print ('Runoob 索引值为', list1.index('Runoob',1))

#	输出结果为
Runoob 索引值为 1

insert() 函数用于将指定对象插入列表的指定位置。

insert()方法语法：

list.insert(index, obj)
index -- 对象obj需要插入的索引位置。
obj -- 要插入列表中的对象。


list1 = ['Google', 'Runoob', 'Taobao']
list1.insert(1, 'Baidu')
print ('列表插入元素后为 : ', list1)

#	输出结果为
列表插入元素后为 :  ['Google', 'Baidu', 'Runoob', 'Taobao']

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

pop()方法语法：

list.pop([index=-1])
index -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。


list1 = ['Google', 'Runoob', 'Taobao']
list1.pop()
print ("列表现在为 : ", list1)
list1.pop(1)
print ("列表现在为 : ", list1)

#	输出结果为
列表现在为 :  ['Google', 'Runoob']
列表现在为 :  ['Google']
    
    
"""
队列是一种先进先出（FIFO）的数据结构，我们可以使用列表来实现队列的基本功能。

append() 方法向队列的末尾添加一个元素。
pop() 方法从队列的开头删除一个元素并返回它。

queue = []

# 添加元素到队列的末尾
queue.append('A')
queue.append('B')
queue.append('C')

# 从队列的开头删除元素并返回
print(queue.pop(0))  # A
print(queue.pop(0))  # B
print(queue.pop(0))  # C

我们创建了一个空的列表作为队列，然后使用 append() 方法向队列的末尾添加了三个元素。接下来，我们使用 pop() 方法从队列的开头删除元素并返回它们。由于队列是一个先进先出的数据结构，所以我们得到的输出结果是 'A'、'B' 和 'C'。
"""

remove() 函数用于移除列表中某个值的第一个匹配项。

remove()方法语法：

list.remove(obj)
obj -- 列表中要移除的对象。


list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.remove('Taobao')
print ("列表现在为 : ", list1)
list1.remove('Baidu')
print ("列表现在为 : ", list1)

#	输出结果为
列表现在为 :  ['Google', 'Runoob', 'Baidu']
列表现在为 :  ['Google', 'Runoob']

reverse() 函数用于反向列表中元素。

reverse()方法语法：

list.reverse()


list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.reverse()
print ("列表反转后: ", list1)

#	输出结果为
列表反转后:  ['Baidu', 'Taobao', 'Runoob', 'Google']

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

sort()方法语法：

list.sort( key=None, reverse=False)
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

 
aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
 
aList.sort()
print ( "List : ", aList)

#	输出结果为
List :  ['Facebook', 'Google', 'Runoob', 'Taobao']

    
    
以下实例降序输出列表：
# -*- coding: UTF-8 -*-
 
# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
 
# 降序
vowels.sort(reverse=True)
 
# 输出结果
print ( '降序输出:', vowels )
#	输出结果为
降序输出: ['u', 'o', 'i', 'e', 'a']

    

    
    
以下实例演示了通过指定列表中的元素排序来输出列表：
# 获取列表的第二个元素
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)]

clear() 函数用于清空列表，类似于 del a[:]。

clear()方法语法：

list.clear()



list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.clear()
print ("列表清空后 : ", list1)

#	输出结果为
列表清空后 :  []

copy() 函数用于复制列表

copy()方法语法：

list.copy()


list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list2 = list1.copy()
print ("list2 列表: ", list2)

#	输出结果为
list2 列表:  ['Google', 'Runoob', 'Taobao', 'Baidu']

四、元组

（一）元组的概念及基本使用

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

img

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

创建空元组

tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

img

访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

 
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)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

#	输出结果为
(12, 34.56, 'abc', 'xyz')

或者将元组中嵌套列表，在列表中修改元素是可以的。

tup1 = (12, 34.56, [13, 14])

tup1[2][0] = 15
print(tup1)

#	输出结果为
(12, 34.56, [15, 14])

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，但删除后相对应的变量也不复存在，再次调用会报错，如下实例:

 
tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

#	输出结果为
以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined

元组运算符

与字符串一样，元组之间可以使用 +、+=和 ***** 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式 结果 描述
len((1, 2, 3)) 3 计算元素个数
>>> a = (1, 2, 3)
>>> b = (4, 5, 6)
>>> c = a+b
>>> c
(1, 2, 3, 4, 5, 6)		 (1, 2, 3, 4, 5, 6) 连接，c 就是一个新的元组，它包含了 a 和 b 中的所有元素。
>>> a = (1, 2, 3)
>>> b = (4, 5, 6)
>>> a += b
>>> a
(1, 2, 3, 4, 5, 6)		 (1, 2, 3, 4, 5, 6) 连接，a 就变成了一个新的元组，它包含了 a 和 b 中的所有元素。
('Hi!',) * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') 复制
3 in (1, 2, 3) True 元素是否存在
for x in (1, 2, 3):
print (x, end=" ")		 1 2 3 迭代

元组索引、截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')

img

Python 表达式 结果 描述
tup[1] 'Runoob' 读取第二个元素
tup[-2] 'Weibo' 反向读取，读取倒数第二个元素
tup[1:] ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin') 截取元素，从第二个开始后的所有元素。
tup[1:4] ('Runoob', 'Taobao', 'Wiki') 截取元素，从第二个开始到第四个元素（索引为 3）。 
>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', 'Taobao', 'Wiki')
>>>

（二）元组内置函数

Python元组包含了以下内置函数

序号 方法及描述 实例
1 len(tuple) 计算元组元素个数。 >>> tuple1 = ('Google', 'Runoob', 'Taobao')
>>> len(tuple1)
3
>>>
2 max(tuple) 返回元组中元素最大值。 >>> tuple2 = ('5', '4', '8')
>>> max(tuple2)
'8'
>>>
3 min(tuple) 返回元组中元素最小值。 >>> tuple2 = ('5', '4', '8')
>>> min(tuple2)
'4'
>>>
4 tuple(iterable) 将可迭代系列转换为元组。 >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')

关于元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

五、字典

（一）字典的概念和基本使用

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

注意：****dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。

img

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

一个简单的字典实例：

tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}

tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }

# 使用大括号 {} 来创建空字典
emptyDict = {}
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:", len(emptyDict))
 
# 查看类型
print(type(emptyDict))

#	输出结果为
{}
Length: 0
<class 'dict'>

img

使用内建函数 dict() 创建字典：

emptyDict = dict()
 
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:",len(emptyDict))
 
# 查看类型
print(type(emptyDict))

#	输出结果为
{}
Length: 0
<class 'dict'>

访问字典里的值

把相应的键放入到方括号中，如下实例:

 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])

#	输出结果为
tinydict['Name']:  Runoob
tinydict['Age']:  7

如果用字典里没有的键访问数据，会输出错误如下：

 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Alice']: ", tinydict['Alice'])

#	输出结果为
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "小学"  # 添加信息
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

#	输出结果为
tinydict['Age']:  8
tinydict['School']:  小学

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显式删除一个字典用del命令，如下实例：

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])


但这会引发一个异常，因为用执行 del 操作后字典不再存在：
#	输出结果为
Traceback (most recent call last):
  File "/runoob-test/test.py", line 9, in <module>
    print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined

注：del() 方法后面也会讲解。

字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸡'}
 
print ("tinydict['Name']: ", tinydict['Name'])

#	输出结果为
tinydict['Name']:  小菜鸡

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

 
tinydict = {['Name']: 'Runoob', 'Age': 7}
 
print ("tinydict['Name']: ", tinydict['Name'])

#	输出结果为
Traceback (most recent call last):
  File "test.py", line 3, in <module>
    tinydict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

（二）字典内置函数和方法

字典内置函数&方法

Python字典包含了以下内置函数：

序号 函数及描述 实例
1 len(dict) 计算字典元素个数，即键的总数。 >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> len(tinydict)
3
2 str(dict) 输出字典，可以打印的字符串表示。 >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(tinydict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
3 type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(tinydict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"

Python字典包含了以下内置方法：

序号 函数及描述
1 dict.clear() 删除字典内所有元素
2 dict.copy() 返回一个字典的浅复制
3 dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4 dict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
5 key in dict 如果键在字典dict里返回true，否则返回false
6 dict.items() 以列表返回一个视图对象
7 dict.keys() 返回一个视图对象
8 dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 dict.update(dict2) 把字典dict2的键/值对更新到dict里
10 dict.values() 返回一个视图对象
11 [pop(key,default]) 删除字典 key（键）所对应的值，返回被删除的值。
12 popitem() 返回并删除字典中的最后一对键和值。 
Python 字典 clear() 函数用于删除字典内所有元素。

clear()方法语法：

dict.clear()


tinydict = {'Name': 'Zara', 'Age': 7}

print ("字典长度 : %d" %  len(tinydict))
tinydict.clear()
print ("字典删除后长度 : %d" %  len(tinydict))

#	输出结果为
字典长度 : 2
字典删除后长度 : 0

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

copy()方法语法：

dict.copy()
 
dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
dict2 = dict1.copy()
print ("新复制的字典为 : ",dict2)

#	输出结果为
新复制的字典为 :  {'Age': 7, 'Name': 'Runoob', 'Class': 'First'}

    
直接赋值和 copy 的区别
dict1 =  {'user':'runoob','num':[1,2,3]}
 
dict2 = dict1          # 浅拷贝: 引用对象
dict3 = dict1.copy()   # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，子对象是引用
 
# 修改 data 数据
dict1['user']='root'
dict1['num'].remove(1)
 
# 输出结果
print(dict1)
print(dict2)
print(dict3)

实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。

#	输出结果为
{'user': 'root', 'num': [2, 3]}
{'user': 'root', 'num': [2, 3]}
{'user': 'runoob', 'num': [2, 3]}

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

fromkeys() 方法语法：

dict.fromkeys(seq, [value])
seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。

#	输出结果为
 
seq = ('name', 'age', 'sex')
 
tinydict = dict.fromkeys(seq)
print ("新的字典为 : %s" %  str(tinydict))
 
tinydict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %  str(tinydict))




不指定值：
 
x = ('key1', 'key2', 'key3')
 
thisdict = dict.fromkeys(x)
 
print(thisdict)

#	输出结果为
{'key1': None, 'key2': None, 'key3': None}

Python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。
而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。

in 操作符语法：

key in dict
key -- 要在字典中查找的键。


 
thisdict = {'Name': 'Runoob', 'Age': 7}
 
# 检测键 Age 是否存在
if  'Age' in thisdict:
    print("键 Age 存在")
else :
    print("键 Age 不存在")
 
# 检测键 Sex 是否存在
if  'Sex' in thisdict:
    print("键 Sex 存在")
else :
    print("键 Sex 不存在")
 
 
# not in
 
# 检测键 Age 是否存在
if  'Age' not in thisdict:
    print("键 Age 不存在")
else :
    print("键 Age 存在")
    
#	输出结果为
键 Age 存在
键 Sex 不存在
键 Age 存在

Python 字典 items() 方法以列表返回视图对象，是一个可遍历的key/value 对。
dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。

items()方法语法：

dict.items()
 
tinydict = {'Name': 'Runoob', 'Age': 7}
 
print ("Value : %s" %  tinydict.items())

#	输出结果为
Value : dict_items([('Age', 7), ('Name', 'Runoob')])

Python3 字典 keys() 方法返回一个视图对象。
dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。
注意：Python2.x 是直接返回列表

keys()方法语法：

dict.keys()


>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # 迭代
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys 和 values 以相同顺序（插入顺序）进行迭代
>>> list(keys)     # 使用 list() 转换为列表
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # 视图对象是动态的，受字典变化的影响，以下删除了字典的 key，视图对象转为列表后也跟着变化
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

Python 字典 setdefault() 方法和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

setdefault()方法语法：

dict.setdefault(key, default=None)
key -- 查找的键值。
default -- 键不存在时，设置的默认键值。

 
tinydict = {'Name': 'Runoob', 'Age': 7}
 
print ("Age 键的值为 : %s" %  tinydict.setdefault('Age', None))
print ("Sex 键的值为 : %s" %  tinydict.setdefault('Sex', None))
print ("新字典为：", tinydict)

#	输出结果为
Age 键的值为 : 7
Sex 键的值为 : None
新字典为： {'Age': 7, 'Name': 'Runoob', 'Sex': None}

Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。

update() 方法语法：

dict.update(dict2)
dict2 -- 添加到指定字典dict里的字典。

 
tinydict = {'Name': 'Runoob', 'Age': 7}
tinydict2 = {'Sex': 'female' }
 
tinydict.update(tinydict2)
print ("更新字典 tinydict : ", tinydict)

#	输出结果为
更新字典 tinydict :  {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}

Python3 字典 values() 方法返回一个视图对象。
dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。

values()方法语法：

dict.values()


>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # 迭代
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys 和 values 以相同顺序（插入顺序）进行迭代
>>> list(keys)     # 使用 list() 转换为列表
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # 视图对象是动态的，受字典变化的影响，以下删除了字典的 key，视图对象转为列表后也跟着变化
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(values)
[1, 500]
>>> #相同两个 dict.values() 比较返回都是 False
>>> d = {'a': 1}
>>> d.values() == d.values()
False

Python 字典 get() 函数返回指定键的值。
get()方法语法：

dict.get(key, [value]) 
key -- 字典中要查找的键。
value -- 可选，如果指定键的值不存在时，返回该默认值。


tinydict = {'Name': 'Runoob', 'Age': 27}

print ("Age : ", tinydict.get('Age'))

# 没有设置 Sex，也没有设置默认的值，输出 None
print ("Sex : ", tinydict.get('Sex'))  

# 没有设置 Salary，输出默认的值  0.0
print ('Salary: ', tinydict.get('Salary', 0.0))

#	输出结果为
Age : 27
Sex : None
Salary: 0.0

    
    
    
    
get() 方法 Vs dict[key] 访问元素区别
get(key) 方法在 key（键）不在字典中时，可以返回默认值 None 或者设置的默认值。

dict[key] 在 key（键）不在字典中时，会触发 KeyError 异常。
>>> runoob = {}
>>> print('URL: ', runoob.get('url'))     # 返回 None
URL:  None

>>> print(runoob['url'])     # 触发 KeyError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'url'
>>>




嵌套字典使用
get() 方法对嵌套字典的使用方法如下：
tinydict = {'RUNOOB' : {'url' : 'www.runoob.com'}}

res = tinydict.get('RUNOOB', {}).get('url')
# 输出结果
print("RUNOOB url 为 : ", str(res))

#	输出结果为
RUNOOB url 为 :  www.runoob.com

Python 字典 pop() 方法删除字典 key（键）所对应的值，返回被删除的值。
如果 key 存在 - 删除字典中对应的元素
如果 key 不存在 - 返回设置指定的默认值 default
如果 key 不存在且默认值 default 没有指定 - 触发 KeyError 异常

pop()方法语法：

pop(key,[default])
key - 要删除的键
default - 当键 key 不存在时返回的值


site= {'name': '玛卡巴卡', 'alexa': 10000, 'url': 'www.baidu.com'}

element = site.pop('name')

print('删除的元素为:', element)
print('字典为:', site)

#	输出结果为
删除的元素为: 玛卡巴卡
字典为: {'alexa': 10000, 'url': 'www.baidu.com'}
    
    
    
    
    
如果删除的键不存在会触发异常：
site= {'name': '玛卡巴卡', 'alexa': 10000, 'url': 'www.baidu.com'}

element = site.pop('nickname')

print('删除的元素为:', element)
print('字典为:', site)

#	输出结果为
File "/Users/RUNOOB/runoob-test/test.py", line 5, in <module>
    element = site.pop('nickname')
KeyError: 'nickname'
    
    
    
    
可以设置默认值来避免异常：
site= {'name': '玛卡巴卡', 'alexa': 10000, 'url': 'www.baidu.com'}

element = site.pop('nickname', '不存在的 key')

print('删除的元素为:', element)
print('字典为:', site)

#	输出结果为
删除的元素为: 不存在的 key
字典为: {'name': '玛卡巴卡', 'alexa': 10000, 'url': 'www.baidu.com'}

Python 字典 popitem() 方法随机返回并删除字典中的最后一对键和值。
如果字典已经为空，却调用了此方法，就报出 KeyError 异常。

popitem()方法语法：

popitem()

site= {'name': '玛卡巴卡', 'alexa': 10000, 'url': 'www.百度.com'}

# ('url': 'www.百度.com') 最后插入会被删除
result = site.popitem()

print('返回值 = ', result)
print('site = ', site)

# 插入新元素
site['nickname'] = 'Runoob'
print('site = ', site)

# 现在 ('nickname', 'Runoob') 是最后插入的元素
result = site.popitem()

print('返回值 = ', result)
print('site = ', site)

#	输出结果为
返回值 =  ('url', 'www.百度.com')
site =  {'name': '玛卡巴卡', 'alexa': 10000}
site =  {'name': '玛卡巴卡', 'alexa': 10000, 'nickname': 'Runoob'}
返回值 =  ('nickname', 'Runoob')
site =  {'name': '玛卡巴卡', 'alexa': 10000}

六、集合

（一）集合的概念和基本使用

集合（set）是一个无序的不重复元素序列。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。

创建格式：

parame = {value01,value02,...}
或者
set(value)

以下是一个简单实例：

set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

更多实例演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

类似列表推导式，同样集合支持集合推导式(Set comprehension):

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

集合的基本操作

1、添加元素

语法格式如下：

s.add( x )

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )

x 可以有多个，用逗号分开。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>

2、移除元素

语法格式如下：

s.remove( x )

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop() 

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)

输出结果：

Runoob

多次执行测试结果都不一样。

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

3、计算集合元素个数

语法格式如下：

len(s)

计算集合 s 元素个数。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3

4、清空集合

语法格式如下：

s.clear()

清空集合 s。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

5、判断元素是否在集合中存在

语法格式如下：

x in s

判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
>>>

（二）集合的内置方法

方法 描述
add() 为集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
difference() 返回多个集合的差集
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
discard() 删除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 返回集合的交集。
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset() 判断指定集合是否为该方法参数集合的子集。
issuperset() 判断该方法的参数集合是否为指定集合的子集
pop() 随机移除元素
remove() 移除指定元素
symmetric_difference() 返回两个集合中不重复的元素集合。
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union() 返回两个集合的并集
update() 给集合添加元素
len() 计算集合元素个数 
add() 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

add()方法语法：

set.add(elmnt)
elmnt -- 必需，要添加的元素。


fruits = {"apple", "banana", "cherry"}
fruits.add("orange") 
print(fruits)
#	输出结果为
{'apple', 'banana', 'orange', 'cherry'}




已存在的元素，则不执行添加操作：
fruits = {"apple", "banana", "cherry"}
fruits.add("apple")
print(fruits)
#	输出结果为
{'apple', 'banana', 'cherry'}

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

clear()方法语法：

set.clear()

fruits = {"apple", "banana", "cherry"}
fruits.clear()
print(fruits)
#	输出结果为
set()

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

copy() 方法语法：

set.copy()

sites = {"Google", "Runoob", "Taobao"}
x = sites.copy()
print(x)
#	输出结果为
set(['Google', 'Taobao', 'Runoob'])

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

difference() 方法语法：

set.difference(set)
set -- 必需，用于计算差集的集合

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
 
z = x.difference(y) 
 
print(z)
#	输出结果为
{'cherry', 'banana'}

difference_update() 方法用于移除两个集合中都存在的元素。
difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。

difference_update() 方法语法：

set.difference_update(set)
set -- 必需，用于计算差集的集合

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
 
x.difference_update(y) 
 
print(x)
#	输出结果为
{'cherry', 'banana'}


discard() 方法用于移除指定的集合元素。
该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

discard() 方法语法：

set.discard(value)
value -- 必需，要移除的元素

fruits = {"apple", "banana", "cherry"}
 
fruits.discard("banana") 
 
print(fruits)
#	输出结果为
{'cherry', 'apple'}


intersection() 方法用于返回两个或更多集合中都包含的元素，即交集。

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_update() 方法用于获取两个或更多集合中都重叠的元素，即计算交集。
intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。


intersection_update() 方法语法：

set.intersection_update(set1, set2 ... etc)
set1 -- 必需，要查找相同元素的集合
set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开

移除 x 集合中不存在于 y 集合中的元素：
x = {"apple", "banana", "cherry"}  # y 集合不包含 banana 和 cherry，被移除 
y = {"google", "runoob", "apple"}
 
x.intersection_update(y) 
 
print(x)
#	输出结果为
{'apple'}




计算多个集合的并集：

x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
 
x.intersection_update(y, z)
 
print(x)
#	输出结果为
{'c'}


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

isdisjoint() 方法语法：

set.isdisjoint(set)
set -- 必需，要比较的集合

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "facebook"}
 
z = x.isdisjoint(y) 
 
print(z)
#	输出结果为
True




如果包含返回 False：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
z = x.isdisjoint(y) 
 
print(z)
#	输出结果为
False


issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。

issubset() 方法语法：

set.issubset(set)
set -- 必需，要比查找的集合

判断集合 x 的所有元素是否都包含在集合 y 中：
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
 
z = x.issubset(y) 
 
print(z)
#	输出结果为
True




如果没有全部包含返回 False：
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b"}
 
z = x.issubset(y) 
 
print(z)
False


issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。

issuperset() 方法语法：

set.issuperset(set)
set -- 必需，要比查找的集合


判断集合 y 的所有元素是否都包含在集合 x 中：
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


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

pop() 方法语法：

set.pop()

fruits = {"apple", "banana", "cherry"}
 
fruits.pop() 
 
print(fruits)
#	输出结果为
{'apple', 'banana'}



输出返回值：
fruits = {"apple", "banana", "cherry"}
 
x = fruits.pop() 
 
print(x)
#	输出结果为
banana

remove() 方法用于移除集合中的指定元素。
该方法不同于 discard() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。

remove() 方法语法：

set.remove(item)
item -- 要移除的元素

fruits = {"apple", "banana", "cherry"}
 
fruits.remove("banana") 
 
print(fruits)
#	输出结果为
{'cherry', 'apple'}


symmetric_difference() 方法返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素。

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() 方法移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

symmetric_difference_update() 方法语法：

set -- 要检测的集合

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
x.symmetric_difference_update(y) 
 
print(x)
#	输出结果为
{'google', 'cherry', 'banana', 'runoob'}


union() 方法返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。

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


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

update() 方法语法：

set.update(set)
set -- 必需，可以是元素或集合

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
x.update(y) 
 
print(x)
#	输出结果为
{'banana', 'apple', 'google', 'runoob', 'cherry'}


Python len() 方法返回给定序列的元素数量，无论这个序列是字符串、列表、元组、集合还是其他可迭代对象。

len()方法语法：

len( s )
s -- 对象。


text = "Hello, World!"
length = len(text)
print(length)  # 输出：13

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length)  # 输出：5

my_tuple = (10, 20, 30)
length = len(my_tuple)
print(length)  # 输出：3

my_set = {5, 10, 15, 20}
length = len(my_set)
print(length)  # 输出：4

my_dict = {"apple": 3, "banana": 2, "cherry": 4}
length = len(my_dict)
print(length)  # 输出：3

注：章节内容及函数基础均来自菜鸟教程的归纳与整理

标签：输出,六大,函数,Runoob,字符串,详解,str,print,math
From： https://www.cnblogs.com/Aniiwuyan/p/17853480.html

相关文章

  • 无涯教程-Tcl - continue语句函数
    Tcl语言中的continue语句的工作原理与break语句类似。但是，continue不是强制终止，而是强制循环的下一次迭代发生，从而跳过两者之间的任何代码。continuestatement-语法Tcl中continue语句的语法如下-continue;continuestatement-流程图continuestatement-示例......
  • GPT实现的企业信用代码校验函数
    functionValidateEnterpriseCode(EnterpriseCode:string):Boolean;vari,sum,code,weight:Integer;beginResult:=False;//企业信用代码长度校验ifLength(EnterpriseCode)<>18thenExit;//企业信用代码权重因子constfactor:array......
  • 函数计算的新征程：使用 Laf 构建 AI 知识库
    Laf已成功上架Sealos模板市场，可通过Laf应用模板来一键部署！这意味着Laf在私有化部署上的扩展性得到了极大的提升。Sealos作为一个功能强大的云操作系统，能够秒级创建多种高可用数据库，如MySQL、PostgreSQL、MongoDB和Redis等，也可以一键运行各种消息队列和微服务，甚至G......
  • Service 服务详解 及自定义服务模板
    文章目录1、服务简介2、服务的生命周期1）Service的启动停止2)、服务的生命周期的方法3、使用startService启动后服务的生命周期1）、文件结构2）activity_main.xml文件3）、myService自定义服务文件4）、MainActivity文件5）、AndroidManifest.xml文件6）、打印的相关log5、使用bindS......
  • Android典型技术模块开发详解 pdf 资料
    文章目录1、介绍2、章节介绍1、介绍Android典型技术模块开发详解适合刚步入Android开发的工作者，对于Android各个模块能够很好、很全面的讲解。2、章节介绍Android典型技术模块开发详解pdfAndroid典型技术模块开发详解代码文献参考：《Android典型技术模块开发详解》......
  • 【JAVA】native2ascii命令详解
    参考：<https://blog.csdn.net/sinat_27933301/article/details/60358760><https://blog.csdn.net/zhuiqiuzhuoyue583/article/details/127223542>1、native2ascii简介：native2ascii是sunjavasdk提供的一个工具。用来将别的文本类文件（比如.txt,.ini,.properties,.java等等）编码......
  • UEC++头文件添加与函数查找方法
    1.官方函数查找与应用技巧在蓝图中插入函数（中文也可以），右键能看到库名；官网也能查找函数名和使用方法；C++中使用可以将蓝图转化2.UEC++头文件添加VS编译时缺失头文件会报错，ctrl单击调用的函数，进入.h文件中查看的地址，将地址classes后面的目录用#clucde放入如下图如果报错......
  • std::function 与 std::bind解决类成员函数作为回调函数的问题
    1、std::functionstd::function是一个模板类，其可对C++可调用的对象进行封装，比如，成员函数、静态函数等；它的基本作用是简化调用的复杂程度，归一化调用方式。std::function<int(int,int)>int_function:声明方式为<返回值类型(参数类型1，参数类型2，...)>，其可封装任何可调用的......
  • 工作常用的EXCEL公式 | vlookup和match函数的应用
    数据源：返回多列结果： ......
  • 详解vue大文件视频切片上传的处理方法
    前端上传大文件、视频的时候会出现超时、过大、很慢等情况,为了解决这一问题,跟后端配合做了一个切片的功能,接下来就详细的给大家介绍一下vue大文件视频切片上传的处理方法,需要的朋友可以参考下 前端上传大文件、视频的时候会出现超时、过大、很慢等情况，为了解决这一问题，跟后端......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99