Python3基础知识（基础语法、基本数据类型、数据类型转换）

最新推荐文章于 2023-09-13 20:13:13 发布

Selcouther

最新推荐文章于 2023-09-13 20:13:13 发布

阅读量378

点赞数 3

分类专栏： Python 文章标签： python python3

本文链接：https://blog.csdn.net/m0_50609545/article/details/118444915

版权

Python 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

本篇文章内容篇幅较长，关于本篇文章中单独知识点可详见以下文章：
1、基础语法
 2.1、 Number(数字)
2.2、 Sstring(字符串)
2.3、 List(列表)、Tuple(元组)
2.4、Set(集合)、Dictionary(字典)
3、数据类型转换

写在前面：

解释器

Python的解释器是Python.exe，用来解释运行编写的Python代码

我们下载的Python（无论是2版本，还是3版本）自带解释器和编译器，可以直接在命令行敲入代码，或者写一个文本然后调用Python的解释器来执行也可以

常见的有CPython、IPython、PyPy、Jython、IronPython等

Python编程模式

Python 的编程模式分为两种：交互式、脚本式

交互式编程：打开 cmd 窗口（命令提示符窗口），在窗口中键入python进入了交互式编程，此时直接输入 python 语句就可以得到运行的结果

脚本式编程：先把 python 语句写好并保存在后缀为 .py 的文件里，从外部调用这个文件，也可以使用 cmd 窗口进行调用

交互式编程

在命令提示符中输入"Python"命令来启动Python解释器
在这里插入图片描述

脚本式编程

cmd窗口调用.py文件
安装IDE（以PyCharm为例）
PyCharm是一个IDE，使编写程序更加方便，但是PyCharm不带Python解释器，所以在安装PyCharm之前，要安装好Python

Pycharm配置好解释器之后如下所示：
-

File→Setting→Python Interpreter查看

一、基础语法

1.1 编码

默认情况下为 UTF-8 编码，所有字符串都是 unicode 字符串

1.2 import

在 python 用 import 或者 from…import 来导入相应的模块

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的导入全部函数，格式为：from somemodule import *

1.3 标识符

第一个字符必须是字母表中字母或下划线 _
标识符的其他的部分由字母、数字和下划线组成
区分大小写
不可以使用关键字
在 Python 3 中，可以用中文作为变量名

1.4 关键字（保留字）

Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字
在这里插入图片描述

1.5 注释

单行注释

以 # 开头

# 注释以#开头
print("Hello World!"); #输出Hello World！

多行注释

①多个 # 号

# 第一行注释
# 第二行注释

② ‘’’

'''
第一行注释
第二行注释
'''

③ “”"（建议使用）

"""
第一行注释
第二行注释
"""

1.6 语句

单行语句

Python一般为单行语句
如果语句很长，可以使用反斜杠 \ 来实现多行语句
tips：在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \

# 使用 反斜杠 \  来实现多行语句
fruit = apple + \ 
        banana + \
        peach
#在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \
fruit = ['apple', 'banana', 
        'peach']

同一行显示多条语句

同一行显示多条语句时，语句之间使用分号 ; 分割

1.7 代码块（多个语句构成的代码组）

代码块的表示

区别于C、Java等语言，Python代码块不使用大括号 {}
用缩进（or空格）来表示代码块，因此同一个代码块的语句必须包含相同的缩进空格数
tips：缩进是Python语法的一部分

代码块的应用

缩进相同的一组语句构成一个代码块，成为代码组
if、while、def和class这样的复合语句，首行以关键字开始，以冒号: 结束，该行之后的一行或多行代码构成代码组【首行及后面的代码组称为一个子句(clause)】
例：

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

1.8 空行

空行也是程序代码的一部分

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。
类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

作用：分隔两段不同功能或含义的代码

tips：
与代码缩进不同，空行并不是Python语法的一部分（不写也不会出错），但是是程序代码的一部分

1.9 等待用户输入

"\n\n"在结果输出前会输出两个新的空行，按下 enter 键时，程序将退出：

input("\n\n按下 enter 键后退出。")

1.10 print 输出

print 默认输出换行，如果要实现不换行需要在变量末尾加上 end=""

x="a"
y="b"
# 换行输出
print( x )
print( y )
"""
a
b
"""
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()
"""
a 
b 

"""

1.11 变量

没有类型，不需要声明！

类型是变量所指的内存中对象的类型

每个变量在使用前都必须赋值，赋值后才会被创建

1.12 赋值

赋值：变量名 = 变量值

多个变量同时赋同一值

a = b = c = 1  #从后向前依次赋值
"""
a=1
b=1
c=1
"""

多个变量同时赋不同值

a, b, c = 1, 2, "runoob"
"""
a=1
b=2
c="runoob"
"""

1.13 查询类型

type

内置的 type() 函数可以用来查询变量所指的对象类型

a,b,c = 1,2,"hello"
print(type(a), type(b), type(c))



"""
输出结果
<class 'int'> <class 'int'> <class 'str'>
"""

isinstance

isinstance 来判断数据类型

a,b,c = 1,2,"hello"
print(isinstance(a,int),isinstance(x,int))



"""
输出结果：
True False
"""

区别

type()不认为子类是一种父类类型。
isinstance()认为子类是一种父类类型

class A:pass
class B(A): pass

print(isinstance(A(), A),type(A()) == A ,isinstance(B(), A),type(B()) == A)



"""
输出结果：
True True True False
"""

1.14 运算符

算数运算符

符号	意义
+	加
-	减
*	乘
\	除，得到浮点数
\ \	除，向下取整
%	取余
**	乘方

代码示例：

print(5 + 2)   #5、2为操作数，+为运算符
print(5 - 2)
print(5 * 2)
print(5 / 2)
print(5 // 2)
print(5 % 2)
print(5 ** 2)



"""
输出结果：
7
3
10
2.5
2
1
25
"""

比较运算符

所有比较运算符返回1表示真，返回0表示假，分别与特殊的变量True和False等价

运算符	描述	实例(a = 10,b = 20)
==	等于，比较对象是否相等	(a == b) 返回 False
!=	不等于，比较两个对象是否不相等	(a != b) 返回 True
>	大于，返回x是否大于y	(a > b) 返回 False
<	小于，返回x是否小于y	(a < b) 返回 True
>=	大于等于，返回x是否大于等于y	(a >= b) 返回 False
<=	小于等于，返回x是否小于等于y	(a <= b) 返回 True

代码示例：

a = 21
b = 10
print('a =',a)
print('b =',b)

if (a == b):
    print("a == b")
else:
    print("a != b")

if (a != b):
    print("a != b")
else:
    print("a == b")

if (a < b):
    print("a < b")
else:
    print("a >= b")

if (a > b):
    print("a > b")
else:
    print("a <= b")


'''
输出结果：
a = 21
b = 10
a != b
a != b
a >= b
a > b

'''

赋值运算符

运算符	描述	实例(a=10,b=20)
=	简单的赋值运算符	c = a + b, 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
//=	向下取整除赋值运算符	c //= a 等效于 c = c // a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a(c的a次幂)
:=	海象运算符，在表达式内部为变量赋值，Python3.8 版本新增	例：if (n := len(a)) > 10

代码示例：

a = 2
b = 10
c = 5
print('a =',a,' b = ',b,' c = ',c)
a + b
print("a + b的值为：", a + b)
c += a
print("c += a的值为：", c)
c *= a
print("c *= a的值为：", c)
c /= a
print("c /= a的值为：", c)
c //= a
print("c //= a的值为：", c)
c %= a
print("c %= a的值为：", c)
c **= a
print("c **= a的值为：", c)



'''
输出结果：
a = 2  b =  10  c =  5
a + b的值为： 12
c += a的值为： 7
c *= a的值为： 14
c /= a的值为： 7.0
c //= a的值为： 3.0
c %= a的值为： 1.0
c **= a的值为： 1.0
'''

位运算符

按位运算中，把数字看作二进制来进行计算

运算符	描述
&	按位与运算符：对应位都为1→结果为1
\|	按位或运算符：对应位有一个为1时→结果位为1
^	按位异或运算符：对应位不同→结果为1
~	按位取反运算符：对数据的每个二进制位取反,1→0,0→1
<< n	左移动运算符：运算数的各二进位全部左移n位，高位丢弃，低位补0
>> n	右移动运算符：运算数的各二进位全部右移n位

代码示例：

a = 60  # 60 = 0011 1100
b = 13  # 13 = 0000 1101
c = 0

c = a & b  # 12 = 0000 1100
print("c = a & b值为：", c)

c = a | b  # 61 = 0011 1101
print("c = a | b值为：", c)

c = a ^ b  # 49 = 0011 0001
print("c = a ^ b值为：", c)

c = ~a  # -61 = 1100 0011
print("c = ~a值为：", c)

c = a << 2  # 240 = 1111 0000
print("c = a << 2值为：", c)

c = a >> 2  # 15 = 0000 1111
print("c = a >> 2 值为：", c)



'''
输出结果：
c = a & b值为： 12
c = a | b值为： 61
c = a ^ b值为： 49
c = ~a值为： -61
c = a << 2值为： 240
c = a >> 2 值为： 15
'''

逻辑运算符

运算符	逻辑表达式	描述(a=10,b=20)
and	x and y	“与” ，如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值
or	x or y	“或” ，如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值
not	not x	“非”，如果 x 为 True，返回 False 。如果 x 为 False，它返回 True

代码示例：

a = 10
b = 20
print('a and b:',a and b)
if (a and b):
    print("变量 a 和 b 都为 true")
else:
    print("变量 a 和 b 有一个不为 true")
print()

print('a or b:',a or b)
if (a or b):
    print("变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("变量 a 和 b 都不为 true")
print()

# 修改变量 a 的值
a = 0
print('a and b:',a and b)
if (a and b):
    print("变量 a 和 b 都为 true")
else:
    print(" 变量 a 和 b 有一个不为 true")
print()

print('a or b:',a or b)
if (a or b):
    print("变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("变量 a 和 b 都不为 true")
print()

print('not a and b:',not (a and b))
if not (a and b):
    print("变量 a 和 b 都为 false，或其中一个变量为 false")
else:
    print("5变量 a 和 b 都为 true")



'''
输出结果：
a and b: 20
变量 a 和 b 都为 true

a or b: 10
变量 a 和 b 都为 true，或其中一个变量为 true

a and b: 0
 变量 a 和 b 有一个不为 true

a or b: 20
变量 a 和 b 都为 true，或其中一个变量为 true

not a and b: True
变量 a 和 b 都为 false，或其中一个变量为 false
'''

成员运算符

运算符	描述	实例
in	在指定的序列中找到值返回 True，否则返回 False	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	在指定的序列中没有找到值返回 True，否则返回 False	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

代码示例：

a = 10
b = 20
list = [1, 2, 3, 4, 5]
print('list:',list)
print('a =',a,' b =',b)
if (a in list):
    print("变量 a 在给定的列表中 list 中")
else:
    print("变量 a 不在给定的列表中 list 中")

if (b not in list):
    print("变量 b 不在给定的列表中 list 中")
else:
    print("变量 b 在给定的列表中 list 中")

# 修改变量 a 的值
a = 2
print('a =',a)
if (a in list):
    print("变量 a 在给定的列表中 list 中")
else:
    print("变量 a 不在给定的列表中 list 中")


'''
输出结果：
list: [1, 2, 3, 4, 5]
a = 10  b = 20
变量 a 不在给定的列表中 list 中
变量 b 不在给定的列表中 list 中
a = 2
变量 a 在给定的列表中 list 中
'''

身份运算符

用于比较两个对象的存储单元

tips： id() 函数用于获取对象内存地址

运算符	描述	实例
is	判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y)，如果引用的是同一个对象则返回 True，否则返回 False
is not	判断两个标识符是不是引用自不同对象	x is not y ，类似 id(a) != id(b)，如果引用的不是同一个对象则返回结果 True，否则返回 False

代码示例：

a = 20
b = 20
print('a = ',a,' b =',b)
if (a is b):
    print("a 和 b 有相同的标识")
else:
    print("a 和 b 没有相同的标识")

if (id(a) == id(b)):		#判断引用变量的值是否相等
    print("a 和 b 有相同的标识")
else:
    print("a 和 b 没有相同的标识")


b = 30						# 修改变量 b 的值
print('a = ',a,' b =',b)
if (a is b):
    print("a 和 b 有相同的标识")
else:
    print("a 和 b 没有相同的标识")

if (a is not b):
    print("a 和 b 没有相同的标识")
else:
    print("a 和 b 有相同的标识")



'''
输出结果：
a =  20  b = 20
a 和 b 有相同的标识
a 和 b 有相同的标识
a =  20  b = 30
a 和 b 没有相同的标识
a 和 b 没有相同的标识
'''

tips:
is 用于判断两个变量** 引用对象是否为同一个**
== 用于判断引用变量的值是否相等
↓

代码示例：

a = [1, 2, 3]
b = a          #a,b指向同一个对象
print('a:',a)
print('b:',b)
print('b is a:',b is a )   			  #is判断两个变量引用对象是否为同一个
print('b == a:',b == a)               #==判断引用变量的值是否相等

b = a[:]        #创建一个新的与a完全相同的对象，但是与a并不指向同一对象
print('a:',a)
print('b:',b)
print('b is a:',b is a)      		 #is判断两个变量引用对象是否为同一个
print('b == a:',b == a)    			 #==判断引用变量的值是否相等



'''
输出结果：
a: [1, 2, 3]
b: [1, 2, 3]
b is a: True
b == a: True
a: [1, 2, 3]
b: [1, 2, 3]
b is a: False
b == a: True

'''

tips：

b=a与b=a[:]的区别：
b=a→a,b指向同一个对象
b=a[:]→创建一个新的与a完全相同的对象，但是与a并不指向同一对象
在计算机中，不同的对象即不同的内存地址

运算符优先级

运算符	描述
**	指数 (最高优先级)
~, + ,-	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
*, / ,%, //	乘，除，求余数和向下取整除
+, -	加法减法
>>, <<	右移，左移运算符
&	位 ‘AND’
^ \|	位运算符
<=, <, >, >= ,	比较运算符
==, !=	等于运算符
=, %=, /=, //=, -=, +=, =, *=	赋值运算符
is ,is not	身份运算符
in ,not in	成员运算符
not, and, or	逻辑运算符

tips:
逻辑运算符中，and拥有更高运算级

代码示例：

x = True
y = False
z = False

if x or y and z:
    print("yes")
else:
    print("no")



'''
运算结果：
yes
'''

二、六大基本数据类型

数据类型
不可变数据
Number（数字）	int,float,bool,complex
String（字符串）	单引号 ’ 或双引号 " 括起来表示字符串（单引号和双引号使用完全相同）
Tuple（元组）	写在小括号 () 里，元素之间用逗号隔开，元素类型可以不相同
可变数据
List（列表）	写在方括号 [] 内、用逗号分隔开的元素列表，元素类型可以不相同
Set（集合）	使用大括号 { } 或者 set() 函数，不输出重复元素
Dictionary（字典）	用 { } 标识，它是一个无序的键(key) : 值(value) 的集合，key值唯一

1、 Number(数字)

数据类型不允许改变，如果改变数字数据类型的值，将重新分配内存空间

四种基本类型

类型
int (整数)	整数类型只有一种 int，不带小数点，没有大小限制，也可以用8进制（0o）或16进制（0x）表示
bool (布尔)	是 int 的子类，True 和 False 可以和数字相加，True = 1，False = 0
float (浮点数)	如 1.23、3E-2
complex (复数)	由实部和虚部构成，可以用a + bj,或者complex(a,b)表示，实部a和虚部b都是浮点型，如 1 + 2j、 1.1 + 2.2j

代码示例：

a1,a2,a3,a4 = 1,-1,0o37,-0x080      #0o代表8进制，0x代表16进制
b1,b2,b3,b4 = 0.0,90.,12.0E-2,1.2e+2
c1,c2,c3,c4 = 3.14j,1.2e+2j,-.1+0J,1.2e-2j
d1,d2 = True,False
print(a1,a2,a3,a4)
print(b1,b2,b3,b4)
print(c1,c2,c3,c4)
print(d1,d2)



"""
输出结果：
1 -1 31 -128
0.0 90.0 0.12 120.0
3.14j 120j (-0.1+0j) 0.012j
True False
"""

数值运算

运算符号：

符号	意义
+	加
-	减
*	乘
\	除，得到浮点数
\ \	除，向下取整，但是得到的并不一定是整数类型，它与分母分子的数据类型有关系
%	取余
**	乘方

代码示例：

print(5 + 2)
print(5 - 2)
print(5 * 2)
print(5 / 2)
print(5 // 2)
print(5 // 2.0)
print(5 % 2)
print(5 ** 2)		#5的平方



"""
输出结果：
7
3
10
2.5
2
2.0
1
25
"""

tips：

变量在使用前必须先"定义"（即赋予变量一个值）
混合计算时，会把整型转换成为浮点数

在交互模式中，最后被输出的表达式结果被赋值给变量 _
此处， _ 变量应被用户视为只读变量

代码示例：

tax = 12.5 / 100
price = 100.50
print(price * tax)
print(price + _)
print(round(_, 2))



'''
输出结果：
12.5625
113.0625
113.06
'''

删除操作

使用del语句

删除一些数字对象的引用

del a[,b[,c[…,z]]]

单个或多个对象的引用

del a,b

代码示例：

a = 10
b = 20
c = 30
del b,c		#删除b、c
print(a)
print(b,c)

输出结果：

在输出10（a的值）后会报错：NameError: name ‘b’ is not defined

由上述代码可知，b、c已经被删除

数字类型转换

数据类型的转换，将目标数据类型作为函数名即可

函数名	作用
int(x)	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(x)	将x转换到一个复数，实数部分为 x，虚数部分为 0
complex(x, y)	将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式

int(x [,base])

int() 函数用于将一个字符串或数字转换为整型

class int(x, base=10)

参数：
x：字符串或数字
base = n：n为进制数，默认n=10，即十进制
返回值：
整型数据

代码示例：

a1 = int()               # 不传入参数时，得到结果0
a2 = int(2)
a3 = int(3.9)           #向下取整
a4 = int('12',16)        # 带参数base,x以字符串的形式进行输入,12为16进制
a5 = int('0xa',16)        # 带参数base,x以字符串的形式进行输入,16为16进制
a6 = int('10',8)        # 带参数base,x以字符串的形式进行输入,10为8进制
print(a1,a2,a3,a4,a5,a6)



'''
输出结果：
0 2 3 18 10 8
'''

float(x)

用于将整数和字符串转换成浮点数

class float([x])

参数：
x：整数或字符串
返回值：
返回浮点数

代码示例：

a0 = float()
a1 = float(1)
a2 = float(2)
a3 = float(-3.3)
a4 = float('444')     # 字符串
print(a0,a1,a2,a3,a4)



'''
输出结果：
0.0 1.0 2.0 -3.3 444.0
'''

complex(real [,imag])

用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数
如果第一个参数为字符串，则不需要指定第二个参数

class complex([real[, imag]])

参数：
real：int, long, float 或字符串
imag ： int, long, float
返回值：
返回一个复数

代码示例：

a0 = complex()
a1 = complex(1,2)
a2 = complex(1.1)  # 数字
a3 = complex("1")  # 当做字符串处理
a4 = complex("12")
a5 = complex("1+2j")# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
print(a0)
print(a1)
print(a2)
print(a3)
print(a4)
print(a5)



'''
输出结果：
0j
(1+2j)
(1.1+0j)
(1+0j)
(12+0j)
(1+2j)
'''

数学常量

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）

代码示例：

from math import pi			#导入
from math import e

print(pi)
print(e)

'''
输出结果：
3.141592653589793
2.718281828459045
'''

数学函数

不能直接访问的函数需要导入 math 模块：import math
除了abs()、round()，都需要导入math模块
pow(x, y) 可根据所需类型选择是否导入math模块（内置把参数作为整型，math将参数作为浮点型）

函数	作用（返回值）
abs(x)	返回数字的绝对值
fabs(x)	返回 x 的绝对值
ceil(x)	返回一个≥ x的的整数，向上取整
floor(x)	返回一个≤x的整数，向下取整
round(x [,n])	四舍五入
~~cmp(x, y)~~	~~x < y返回 -1, x == y 返回 0, x > y 返回 1~~ （ Python 3 已废弃）用 (x>y)-(x<y) 替换
exp(x)	返回x的指数e^x
log(x)	返回x的自然对数，x > 0
log10(x)	返回以10为基数的x的对数
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列
modf(x)	返回 x 的小数部分与整数部分，两部分的数值符号与 x 相同，整数部分以浮点型表示
pow(x, y)	返回 x^y 的值
sqrt(x)	返回数字x的平方根

abs()
返回数字的绝对值

abs( x )

参数
x ：数值表达式（整数、浮点数、复数）
返回值
函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小

代码示例：

print("abs(1-2) : ", abs(1-2))
print ("abs(-40) : ", abs(-40))
print ("abs(100.10) : ", abs(100.10))
print("abs(1+2j) : ", abs(1+2j))



'''
输出结果：
abs(1-2) :  1
abs(-40) :  40
abs(100.10) :  100.1
abs(1+2j) :  2.23606797749979
'''

fabs(x)

类似于 abs() 函数，fabs(x) 方法也是返回 x 的绝对值

区别：

abs()	fabs()
内置函数	在 math 模块中定义
适用于整数、浮点数、复数	只适用于整数、浮点数

注意：fabs()不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.fabs( x )

参数
x ：数值表达式（整数、浮点数、复数）
返回值
函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小

代码示例：

import math   # 导入 math 模块

print ("math.fabs(1-2) : ", math.fabs(1-2))
print ("math.fabs(-40) : ", math.fabs(-40))
print ("math.fabs(100.10) : ", math.fabs(100.10))
# print ("math.fabs(1+2j) : ", math.fabs(1+2j))   #区别于abs(),fabs()不支持复数


'''
输出结果：
math.fabs(1-2) :  1.0
math.fabs(-40) :  40.0
math.fabs(100.10) :  100.1
'''

ceil(x)

返回一个≥ x的的最小整数，向上取整

注意：ceil()不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.ceil( x )

参数
x ：数值表达式（整数、浮点数、复数）
返回值
返回一个≥ x 的的最小整数

代码示例：

import math   # 导入 math 模块

print ("math.ceil(-3.4) : ", math.ceil(-3.4))
print ("math.ceil(6.1) : ", math.ceil(6.1))
print ("math.ceil(6.6) : ", math.ceil(6.6))
print ("math.ceil(math.pi) : ", math.ceil(math.pi))



'''
输出结果：
math.ceil(-3.4) :  -3
math.ceil(6.1) :  7
math.ceil(6.6) :  7
math.ceil(math.pi) :  4
'''

floor(x)

返回≤x的整数，向下取整

注意：floor(x) 不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.floor( x )

参数
x ：数值表达式（整数、浮点数）
返回值
返回≤x的整数，向下取整

代码示例：

import math   # 导入 math 模块

print ("math.floor(-1.1) : ", math.floor(-1.1))
print ("math.floor(3.1) : ", math.floor(3.1))
print ("math.floor(3.9) : ", math.floor(3.9))



'''
输出结果：
math.floor(-1.1) :  -2
math.floor(3.1) :  3
math.floor(3.9) :  3
'''

round(x [,n])

四舍五入

机器中浮点数不一定能精确表达，换算成一串 1 和 0 后可能是无限位数的，机器已经做出了截断处理，因此准确度不高

round( x [, n] )

参数
x ：数字表达式。
n ：四舍五入的小数点位数，默认值为 0
返回值
四舍五入后的值

代码示例：

print ("round(1.1) : ", round(1.1))
print ("round(1.9) : ", round(1.9))
print ("round(1.12345678,3) : ", round(1.12345678,3))
print ("round(1.12345678,5) : ", round(1.12345678,5))



'''
输出结果：
round(1.1) :  1
round(1.9) :  2
round(1.12345678,3) :  1.123
round(1.12345678,5) :  1.12346
'''

exp(x)

返回x的指数e^x

注意：exp()不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.exp( x )

参数
x ：数值表达式（整数、浮点数、复数）
返回值
返回x的指数e^x

代码示例：

import math   # 导入 math 模块

print ("math.exp(-1) : ", math.exp(-1))
print ("math.exp(1) : ", math.exp(1))
print ("math.exp(1.1) : ", math.exp(1.1))
print ("math.exp(100) : ", math.exp(100))
print ("math.exp(math.pi) : ", math.exp(math.pi))



'''
输出结果：
math.exp(-1) :  0.36787944117144233
math.exp(1) :  2.718281828459045
math.exp(1.1) :  3.0041660239464334
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267
'''

log(x)

返回x的自然对数，x > 0

注意：log(x)不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.log( x )

参数
x ：数值表达式
返回值
返回x的自然对数，x>0

代码示例：

import math   # 导入 math 模块

print ("math.log(math.exp(5)) : ", math.log(math.exp(5)))
print ("math.log(100.72) : ", math.log(100.72))
print ("math.log(100) : ", math.log(10))



'''
输出结果：
math.log(math.exp(5)) :  5.0
math.log(100.72) :  4.612344389736092
math.log(100) :  2.302585092994046
'''

log10(x)

返回以10为基数的x的对数

注意：log10(x)不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.log10( x )

参数
x ：数值表达式
返回值
返回以10为基数的x的对数，x>0

代码示例：

import math   # 导入 math 模块

print ("math.log10(1000) : ", math.log10(10000))
print ("math.log10(8) : ", math.log10(8))
print ("math.log10(100.2) : ", math.log10(1000.2))



'''
输出结果：
math.log10(1000) :  4.0
math.log10(8) :  0.9030899869919435
math.log10(100.2) :  3.000086850211649
'''

max(x1, x2,…)

返回给定参数的最大值，参数可以为序列

max( x, y, z, … )

参数
x ：数值表达式
y ：数值表达式
z ：数值表达式
返回值
返回给定参数的最大值

代码示例：

print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))



'''
输出结果：
max(80, 100, 1000) :  1000
max(-20, 100, 400) :  400
'''

min(x1, x2,…)

返回给定参数的最小值，参数可以为序列

min( x, y, z, … )

参数
x ：数值表达式
y ：数值表达式
z ：数值表达式
返回值
返回给定参数的最小值

代码示例：

print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))



'''
输出结果：
min(80, 100, 1000) :  80
min(-20, 100, 400) :  -20
'''

modf(x)

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

注意：modf(x) 不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.modf( x )

参数
x ：数值表达式
返回值
返回x的小数部分与整数部分

代码示例：

import math

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



'''
输出结果：
math.modf(100.12) :  (0.09999999999999432, 100.0)
math.modf(100.72) :  (0.5999999999999996, 6.0)
math.modf(119) :  (0.0, 1.0)
math.modf(math.pi) :  (0.14159265358979312, 3.0)

'''

pow(x, y)

返回 x^y 的值

注意：

pow() 通过内置的方法直接调用，内置方法把参数作为整型
math 模块把参数转换为 float

内置的 pow() 方法
pow(x, y[, z])
先计算 x^y，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
import math
math.pow( x, y )

参数
x ：数值表达式
y ：数值表达式
z ：数值表达式
返回值
返回 x^y 的值

代码示例：

import math   # 导入 math 模块

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

print ("math.pow(100, -2) : ", math.pow(10, -2))
print ("math.pow(2, 4) : ", math.pow(2, 4))
print ("math.pow(3, 0) : ", math.pow(3, 0))



'''
输出结果：
pow(100, 2) :  10000
math.pow(100, 2) :  10000.0
math.pow(100, -2) :  0.01
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0
'''

sqrt(x)

返回数字x的平方根

注意：sqrt()不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.sqrt( x )

参数
x ：数值表达式
返回值
返回数字x的平方根

代码示例：

import math  # 导入 math 模块

print("math.sqrt(100) : ", math.sqrt(100))
print("math.sqrt(7) : ", math.sqrt(4))



'''
输出结果：
math.sqrt(100) :  10.0
math.sqrt(7) :  2.0
'''

随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

choice(seq)

从序列seq的元素中随机挑选一个元素

注意：choice()不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.choice( seq )

参数
seq ：可以是一个列表，元组或字符串
返回值
从序列seq的元素中随机挑选一个元素

代码示例：

import random

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



'''
输出结果：
#第一次运行
从 range(100) 返回一个随机数 :  19
从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 :  3
从字符串中 'Hello World' 返回一个随机字符 :  l

#第二次运行
从 range(100) 返回一个随机数 :  2
从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 :  3
从字符串中 'Hello World' 返回一个随机字符 :  r
'''

randrange ([start,] stop [,step])

从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1

注意：randrange()不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.randrange ([start,] stop [,step])
[]参数可以省略

参数
范围：[start,stop)
start ：指定范围内的开始值，包含在范围内
stop ：指定范围内的结束值，不包含在范围内
step ：指定递增基数
返回值
返回指定递增基数集合中的一个随机数

代码示例：

import random

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

# 从 0-100 中选取一个5的倍数
print("从 0-100 中选取一个5的倍数 - randrange(0,100, 5) : ", random.randrange(0, 100, 5))

# 从 0-100 中选取一个10的倍数
print("从 0-100 中选取一个10的倍数 - randrange(0,100, 10) : ", random.randrange(0, 100, 10))

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



'''
输出结果：
#第一次运行
从 1-100 中选取一个奇数 - randrange(1,100, 2) :  95
从 1-100 中选取一个偶数 - randrange(0,100, 2) :  64
从 0-100 中选取一个5的倍数 - randrange(0,100, 5) :  75
从 0-100 中选取一个10的倍数 - randrange(0,100, 10) :  70
从 0-99 选取一个随机数 - randrange(100) :  59

#第二次运行
从 1-100 中选取一个奇数 - randrange(1,100, 2) :  69
从 1-100 中选取一个偶数 - randrange(0,100, 2) :  86
从 0-100 中选取一个5的倍数 - randrange(0,100, 5) :  15
从 0-100 中选取一个10的倍数 - randrange(0,100, 10) :  30
从 0-99 选取一个随机数 - randrange(100) :  9
'''

random()

在[0,1)范围内随机生成一个实数

注意：random()不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.random()

参数
无参数
返回值
返回[0,1)范围内随机生成的一个实数

代码示例：

import random

# 第一个随机数
print ("[0,1)范围内的随机数 - random() : ", random.random())


# 第二个随机数
print ("[0,100)范围内的随机数 - 100 * random() : ", random.random() * 100)
print ("[0,100)范围内的随机整数 - 100 * random() : ", int(random.random() * 100))
print ("[10,100)范围内的随机整数 - (100 * random() + 10) : ", int(random.random() * 100 + 10 ))



'''
输出结果：
#第一次运行
[0,1)范围内的随机数 - random() :  0.45891700127033763
[0,100)范围内的随机数 - 100 * random() :  43.66635324114735
[0,100)范围内的随机整数 - 100 * random() :  26
[10,100)范围内的随机整数 - (100 * random() + 10) :  52

#第二次运行
[0,1)范围内的随机数 - random() :  0.695584731761969
[0,100)范围内的随机数 - 100 * random() :  12.36738508897739
[0,100)范围内的随机整数 - 100 * random() :  64
[10,100)范围内的随机整数 - (100 * random() + 10) :  35
'''

seed([x])

改变随机数生成器的种子seed，可以在调用其他随机模块函数之前调用此函数
（如果不了解其原理，不必特别去设定seed，Python会帮忙选择seed）

我们调用 random.random() 生成随机数时，每一次生成的数都是随机的。但是，当我们预先使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个。

注意：seed()不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.seed ( [x] )

调用 random.random() 生成随机数时，每一次生成的数都是随机的。但是，当预先使用 random.seed(x) 设定好种子之后（x 可以是任意数字），如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个

参数
x ：改变随机数生成器random() 的种子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.8726260274738153
使用默认种子生成随机数： 0.6264429425808272
使用整数 10 种子生成随机数： 0.5714025946899135
使用整数 10 种子生成随机数： 0.5714025946899135
使用字符串种子生成随机数： 0.3537754404730722

#第二次运行
使用默认种子生成随机数： 0.529689373355667
使用默认种子生成随机数： 0.5102080210309986
使用整数 10 种子生成随机数： 0.5714025946899135
使用整数 10 种子生成随机数： 0.5714025946899135
使用字符串种子生成随机数： 0.3537754404730722
'''

shuffle(lst)

将序列的所有元素随机排序

注意：shuffle() 不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.shuffle (lst )

参数
lst ：列表
返回值
没有返回值

代码示例：

import random

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



'''
输出结果：
#第一次运行
第一次随机排序列表 :  [20, 16, 10, 5]
第二次随机排序列表 :  [10, 5, 16, 20]

#第二次运行
第一次随机排序列表 :  [5, 16, 10, 20]
第二次随机排序列表 :  [20, 5, 10, 16]
'''

uniform(x, y)

在[x,y]范围内随机生成下一个实数

注意：uniform()不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.uniform(x, y)

参数
范围[x,y]
x ：随机数的最小值，包含该值
y ：随机数的最大值，包含该值
返回值
返回一个[x,y]范围内的浮点数 N

代码示例：

import random

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

print("uniform(1, 3) 的随机浮点数 : ", random.uniform(1, 3))



'''
输出结果：
#第一次运行
uniform(5, 10) 的随机浮点数 :  7.706819723161358
uniform(1, 3) 的随机浮点数 :  2.65807090127158

#第二次运行
uniform(5, 10) 的随机浮点数 :  5.586430560664185
uniform(1, 3) 的随机浮点数 :  2.9197159129977774
'''

三角函数

函数	描述
sin(x)	返回的x弧度的正弦值
cos(x)	返回x的弧度的余弦值
tan(x)	返回x弧度的正切值
asin(x)	返回x的反正弦弧度值
acos(x)	返回x的反余弦弧度值
atan(x)	返回x的反正切弧度值
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ，返回90.0
radians(x)	将角度转换为弧度

2、 String字符串

string、list 和 tuple 都属于 sequence（序列）

Unicode 字符串

Python3中，所有的字符串都是Unicode字符串（Python2中，普通字符串是以8位ASCII码进行存储）

Unicode字符串存储16位unicode字符串，使用时在字符串前面加上前缀 u即可

创建字符串

使用 单引号 ’ 或 双引号 " 来创建字符串，为变量分配一个值

tips : 单字符在 Python 中作为字符串使用

s1 = '字符串1'	#单引号创建
s2 = "字符串2"	#双引号创建
s2 = "s"		#单字符在py中作为字符串使用

字符串表示

没有单独的字符类型，一个字符就是长度为 1 的字符串（不区分单字符与多字符）
单引号 ’ 或双引号 " 括起来表示字符串（单引号和双引号使用完全相同）
使用三引号(’’’ 或 “”")可以指定一个多行字符串，反斜杠\也可以作为续行符
字符串不能改变，比如向一个索引位置赋值，word[0] = ‘m’ 会导致错误

word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""

字符串操作

字符串截取：

变量[头下标:尾下标]
变量[头下标:尾下标:步长]

两种索引方式：
从左往右，以0开始
从右往左，以-1开始

字符串连接：+

字符串复制：* n（n代表复制的次数）

级联字符串：如"this " "is " "string"会被自动转换为this is string

代码示例：

str = '123456789'

print(str)  # 输出字符串
print(str[:])  # 输出所有字符
print(str[0:-1])  # 输出第一个到倒数第二个的所有字符
print(str[0])  # 输出字符串第一个字符
print(str[-6:-2])  #输出字符串倒数第六个到倒数第三个的所有字符[-6,-2)
print(str[2:5])  # 输出从第三个开始到第五个的字符[2,5)
print(str[2:])  # 输出从第三个开始后的所有字符
print(str[1:5:2])  # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2)  # 输出字符串两次
print(str + '你好')  # 连接字符串

'''
输出结果：
123456789
123456789
12345678
1
4567
345
3456789
24
123456789123456789
123456789你好
'''

转义字符

反斜杠 \ 转义特殊字符

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\’	单引号
\"	双引号
\a	响铃（执行后电脑有响声）
\b	退格(Backspace)
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成
\f	换页
\yyy	八进制数，y 代表 0~7 的字符，例如：\012 代表换行
\xyy	十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行
\other	其它的字符以普通格式输出

代码示例：

print("换行符\:","line1 \
 line2 \
 line3")
print("空\\000:","\000")
print("纵向制表符\\v:","Hello \v World!")
print("横向制表符\\t:","Hello \t World!")
print("后面内容替换前面内容\\r:",'google runoob taobao\r123456')
print("换页","Hello \f World!")
print("八进制数:","\110\145\154\154\157\40\127\157\162\154\144\41")
print("十六进制数:","\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")



'''
输出结果：
换行符\: line1  line2  line3
空\000:  
纵向制表符\v: Hello  World!
横向制表符\t: Hello 	 World!
123456
换页 Hello  World!
八进制数: Hello World!
十六进制数: Hello World!
'''

使用r或者R可以让反斜杠不发生转义

代码示例：

print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
print('\n')       # 输出空行
print(r'\n')      # 输出 \n


'''
输出结果：
hello
runoob
hello\nrunoob
\n
'''

字符串运算符

操作符	描述
+	字符串连接
*	重复输出字符串
[]	通过索引获取字符串中字符
[ : ]	截取字符串中的一部分，左闭右开
in	成员运算符，如果字符串中包含给定的字符返回 True
not in	成员运算符，如果字符串中不包含给定的字符返回 True
r/R	原始字符串，即所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符（原始字符串除在字符串的第一个引号前加上字母 r 或 R 以外，与普通字符串有着几乎完全相同的语法）
%	格式字符串

代码示例：

a = "Hello"
b = " World!"

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\" in a : True(H 在变量 a 中)")
else:
    print("\"H\" in a : False(H 不在变量 a 中)")

if ("M" not in a):
    print("\"M\" not in a : True(M 不在变量 a 中)")
else:
    print("\"M\" not in a : False(M 在变量 a 中)")

print("r'\\n'不发生转义: ",r'\n')
print("R'\\n'不发生转义: ",R'\n')



'''
输出结果：
a + b ： Hello World!
a * 2 ： HelloHello
a[1] ： e
a[1:4] ： ell
"H" in a : True(H 在变量 a 中)
"M" not in a : True(M 不在变量 a 中)
r'\n'不发生转义:  \n
R'\n'不发生转义:  \n

'''

字符串格式化

格式字符串：%

字符串输出格式化：将一个值插入到一个有字符串格式符 %s 的字符串中

字符串格式化符号

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

代码示例：

print ("这里是 %s ,码龄 %d 年了!" % ('入错行的北北', 1))



'''
输出结果：
这里是 入错行的北北 ,码龄 1 年了!
'''

格式化操作符辅助指令

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

字面量格式化字符串

python3.6 之后版本添加，新的格式化字符串的语法

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

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

代码示例：

name = 'World'
print('Hello %s' % name)
print(f'Hello {name}')      # 替换变量
print(f'{1+2}')         # 使用表达式

w = {'昵称': '入错行的北北', '码龄': '1年'}
print(f'{w["昵称"]}: {w["码龄"]}')

x = 1
print(f'{x+1}')    # python 3.6
print(f'{x+1=}')   # Python 3.8

'''
输出结果：
Hello World
Hello World
3
入错行的北北: 1年
2
x+1=2
'''

字符串内置函数

方法	描述
capitalize()	将字符串的第一个字符转换为大写
center(width, fillchar)	返回一个指定宽度并居中的字符串，fillchar 为填充的字符，默认为空格
ljust(width[, fillchar])	返回一个原字符串左对齐，fillchar 为填充的字符，默认为空格
rjust(width,[, fillchar])	返回一个原字符串右对齐，fillchar 为填充的字符，默认为空格
zfill (width)	返回长度为 width 的字符串，原字符串右对齐
count(str, beg= 0,end=len(string))	用于统计字符串里某个字符出现的次数，可选参数为在字符串搜索的开始与结束位置
bytes.decode(encoding=“utf-8”, errors=“strict”)	以指定的编码格式解码 bytes 对象，默认编码为 ‘utf-8’
encode(encoding=‘UTF-8’,errors=‘strict’)	以指定的编码格式编码字符串，errors参数可以指定不同的错误处理方案
endswith(suffix, beg=0, end=len(string))	判断字符串是否以指定后缀结尾
startswith(substr, beg=0,end=len(string))	检查字符串是否是以指定子字符串开头
expandtabs(tabsize=8)	把字符串中的 tab 符号 \t (默认8个空格)转为空格
find(str, beg=0, end=len(string))	检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内
rfind(str, beg=0,end=len(string))	类似于find()函数，不过从右边开始查找
index(str, beg=0, end=len(string))	与find()方法大致一样，但是如果str不在字符串中会报异常
rindex( str, beg=0, end=len(string))	类似于 index()，不过从右边开始
isalnum()	检测字符串是否由字母和数字组成
isalpha()	检测字符串是否只由字母或文字组成
isdigit()	检测字符串是否只由数字（纯数字）组成
isnumeric()	检测字符串是否只由数字组成
islower()	检测字符串中的字母是否都是小写字母
isupper()	检测字符串中的字母是否都是大写字母
isspace()	检测字符串是否只由空白字符组成
title()	返回"标题化"的字符串，所有单词都是首字母大写、其余字母为小写
istitle()	检测字符串中所有的单词拼写是否为首字母大写、其余字母为小写
join(seq)	用于将序列中的元素以指定的字符连接生成一个新的字符串
len(string)	返回对象（字符、列表、元组等）长度或项目个数
lower()	字符串中所有大写字符转换为小写
upper()	字符串中的小写字母转换为大写
swapcase()	将字符串中大写转换为小写，小写转换为大写
lstrip()	删除字符串左边的空格或指定字符
rstrip()	删除字符串末尾的空格或指定字符
strip([chars])	在字符串上执行 lstrip()和 rstrip()
maketrans()	创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标
translate(table, deletechars="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
max(str)	返回字符串 str 中最大的字母
min(str)	返回字符串 str 中最小的字母
replace(old, new [, max])	把将字符串中的 old 替换成 new，替换不超过 max 次
split(str="", num=string.count(str))	以 str 为分隔符分割字符串，如果 num 有指定值，则仅分割 num+1 个子字符串
splitlines([keepends])	按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符
isdecimal()	检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false

capitalize()

将字符串的第一个字符转换为大写，其它字母小写

str.capitalize()

参数
无
返回值
返回一个首字母大写的字符串

代码示例：

str = "hello WORLD！"
print ("str.capitalize() : ", str.capitalize())

'''
输出结果：
str.capitalize() :  Hello world！

'''

center(width, fillchar)

返回一个指定宽度 并居中的字符串，fillchar 为填充的字符，默认为空格

str.center(width[, fillchar])

参数
width ：字符串的宽度
fillchar ：填充字符（默认为空格）
返回值
返回一个指定宽度 并居中的字符串
width小于字符串宽度直接返回字符串，否则fillchar填充

代码示例：

str = "[hello]"

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

'''
输出结果：
str.center(4      ) :  [hello]
str.center(40     ) :                  [hello]                 
str.center(40, '*') :  ****************[hello]*****************

'''

ljust(width[, fillchar])

返回一个原字符串左对齐，fillchar 为填充的字符，默认为空格

str.ljust(width[, fillchar])

参数
width ：指定字符串长度
fillchar ：填充字符，默认为空格
返回值
返回一个指定宽度 并左对齐的字符串
width小于字符串宽度直接返回字符串，否则fillchar填充

代码示例：

str = "[hello]"

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


'''
输出结果：
str.center(4      ) :  [hello]
str.center(40     ) :  [hello]                                 
str.center(40, '*') :  [hello]*********************************
'''

rjust(width,[, fillchar])

返回一个原字符串右对齐，fillchar 为填充的字符，默认为空格

str.rjust(width[, fillchar])

参数
width ：指定字符串长度
fillchar ：填充字符，默认为空格
返回值
返回一个指定宽度 并右对齐的字符串
width小于字符串宽度直接返回字符串，否则fillchar填充

代码示例：

str = "[hello]"

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



'''
输出结果：
str.center(4      ) :  [hello]
str.center(40     ) :                                   [hello]
str.center(40, '*') :  *********************************[hello]
'''

zfill (width)

返回长度为 width 的字符串，原字符串右对齐

width小于字符串宽度直接返回字符串，否则前面填充0

str.zfill(width)

参数
width ：指定字符串的长度。原字符串右对齐，前面填充0
返回值
返回一个指定宽度 并右对齐的字符串
width小于字符串宽度直接返回字符串，否则前面填充0

代码示例：

str = "hello world!"
print ("str.zfill : ",str.zfill(2))
print ("str.zfill : ",str.zfill(20))

'''
输出结果：
str.zfill :  hello world!
str.zfill :  00000000hello world!
'''

count(str, beg= 0,end=len(string))

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

str.count(sub, start= 0,end=len(string))

参数
sub ：搜索的子字符串
start ：搜索的起始位置，默认索引值为0
end：搜索的结束位置，默认为字符串的最后一个位置
返回值
返回子字符串在字符串中出现的次数

代码示例：

str="Hello world！"
sub='o'
print ("str.count('o') : ", str.count(sub))
print ("str.count('o', 3, 5) : ", str.count(sub,3,5))

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



'''
输出结果：
str.count('o') :  2
str.count('o', 3, 5) :  1
str.count('run') :  0

'''

bytes.decode(encoding=“utf-8”, errors=“strict”)

以指定的编码格式解码 bytes 对象，默认编码为 ‘utf-8’

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\x85\xa5\xe9\x94\x99\xe8\xa1\x8c\xe7\x9a\x84\xe5\x8c\x97\xe5\x8c\x97'
GBK 编码： b'\xc8\xeb\xb4\xed\xd0\xd0\xb5\xc4\xb1\xb1\xb1\xb1'
UTF-8 解码： 入错行的北北
GBK 解码： 入错行的北北

'''

encode(encoding=‘UTF-8’,errors=‘strict’)

以指定的编码格式编码字符串，errors参数可以指定不同的错误处理方案

str.encode(encoding=‘UTF-8’,errors=‘strict’)

参数
encoding ：要使用的编码，如: UTF-8
errors ：设置不同错误的处理方案（默认为 ‘strict’，意为编码错误引起一个UnicodeError，其他可能得值有 ‘ignore’， ‘replace’，‘xmlcharrefreplace’，‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值）
返回值
返回编码后的字符串，是一个 bytes 对象

代码示例：

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\x85\xa5\xe9\x94\x99\xe8\xa1\x8c\xe7\x9a\x84\xe5\x8c\x97\xe5\x8c\x97'
GBK 编码： b'\xc8\xeb\xb4\xed\xd0\xd0\xb5\xc4\xb1\xb1\xb1\xb1'
UTF-8 解码： 入错行的北北
GBK 解码： 入错行的北北

'''

endswith(suffix, beg=0, end=len(string))

判断字符串是否以指定后缀结尾

str.endswith(suffix[, start[, end]])

参数
suffix ：一个字符串或者是一个元素
start ：字符串str中的开始位置
end ：字符串str中结束位置
返回值
如果字符串含有指定的后缀返回 True，否则返回 False

代码示例：

Str='Hello!! world!!'
suffix='!!'
print (Str.endswith(suffix))
print (Str.endswith(suffix,5,7))
suffix='beibei'
print (Str.endswith(suffix))
print (Str.endswith(suffix, 0, 19))


'''
输出结果：
True
True
False
False

'''

startswith(substr, beg=0,end=len(string))

检查字符串是否是以指定子字符串开头

str.startswith(substr, beg=0,end=len(string));

参数
str ：检测的字符串
substr：一个字符串或者是一个元素
beg：字符串str中的开始位置
end ：字符串str中结束位置
返回值
如果检测到字符串则返回True，否则返回False

代码示例：

Str='!!Hello!! world!!'
suffix='!!'
print (Str.startswith(suffix))
print (Str.startswith(suffix,7))
suffix='beibei'
print (Str.startswith(suffix))
print (Str.startswith(suffix, 0, 19))

'''
输出结果：
True
True
False
False

'''

expandtabs(tabsize=8)

把字符串中的 tab 符号 \t (默认8个空格)转为空格

在第 0、8、16…等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替

str.expandtabs(tabsize=8)

参数
tabsize ：指定转换字符串中的 tab 符号 \t 转为空格的字符数
返回值
返回字符串中的 tab 符号 \t 转为空格后生成的新字符串

代码示例：

str = "Hello\tworld\t！！"
print('原始字符串:', str)

# 默认 8 个空格
print('替换 \\t 符号:', str.expandtabs())

# 2 个空格
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))


'''
输出结果：
原始字符串: Hello	world	！！
替换 \t 符号: Hello   world   ！！
使用 2 个空格替换 \t 符号: Hello world ！！
使用 3 个空格: Hello world ！！
使用 4 个空格: Hello   world   ！！
使用 5 个空格: Hello     world     ！！
使用 6 个空格: Hello world ！！

'''

find(str, beg=0, end=len(string))

检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内

str.find(str, beg=0, end=len(string))

参数
str ：指定检索的字符串
beg ：开始索引，默认为0
end ：结束索引，默认为字符串的长度
返回值
如果包含子字符串返回开始出现的位置，否则返回-1

代码示例：

str1 = "Hello world!!!"
str2 = "world";

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


'''
输出结果：
6
6
-1

'''

rfind(str, beg=0,end=len(string))

类似于find()函数，不过从右边开始查找

str.rfind(str, beg=0 end=len(string))

参数
str ：指定检索的字符串
beg ：开始索引，默认为0
end ：结束索引，默认为字符串的长度
返回值
返回字符串最后一次出现的位置，如果没有匹配项则返回-1

代码示例：

str1 = "~~ hello hello world!"
str2 = "hello"

print (str1.find(str2))     #从左开始找第一个
print (str1.rfind(str2))    #从右开始找第一个

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

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



'''
输出结果：
3
9
3
3
-1
-1
'''

index(str, beg=0, end=len(string))

与find()方法大致一样，但是如果str不在字符串中会报异常

str.index(str, beg=0, end=len(string))

参数
str ：指定检索的字符串
beg ：开始索引，默认为0
end ：结束索引，默认为字符串的长度
返回值
如果包含子字符串返回开始出现的位置，否则抛出异常

代码示例：

str1 = "Hello world!!!"
str2 = "world";

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


'''
输出结果：
Traceback (most recent call last):
  File "D:\PythonProject\HelloWorld\HelloWorld.py", line 6, in <module>
    print(str1.index(str2, 10))
ValueError: substring not found
6
6

'''

rindex( str, beg=0, end=len(string))

类似于 index()，不过从右边开始

str.rindex(str, beg=0, end=len(string))

参数
str ：指定检索的字符串
beg ：开始索引，默认为0
end ：结束索引，默认为字符串的长度
返回值
返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常

代码示例：

str1 = "hello hello world!!!"
str2 = "hello";

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



'''
输出结果：
6
6
'''

isalnum()

检测字符串是否由字母和数字组成

str.isalnum()

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

代码示例：

str = "HelloWorld"  # 字符串没有空格
print(str.isalnum())

str = "Hello World"
print(str.isalnum())


'''
输出结果：
True
False

'''

isalpha()

检测字符串是否只由字母或文字组成

str.isalpha()

参数
无
返回值
如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False

代码示例：

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

str = "入错行的北北"
print (str.isalpha())

str = "HelloWorld!"
print (str.isalpha())

str = "入错行的北北666"
print (str.isalpha())

'''
输出结果：
True
True
False
False

'''

isdigit()

检测字符串是否只由**数字（单纯的数字）**组成

str.isdigit()

参数
无
返回值
如果字符串只包含数字则返回 True 否则返回 False

代码示例：

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

str = "HelloWorld"
print (str.isdigit())

'''
输出结果：
True
False


'''

isnumeric()

检测字符串是否只由数字组成

数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字

str.isnumeric()

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

代码示例：

str = "Hello World2021"
print (str.isnumeric())

str = "20 21"
print (str.isnumeric())

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

'''
输出结果：
False
False
True

'''

islower()

检测字符串中的字母是否都是小写字母

str.islower()

参数
无
返回值
如果字符串中的字母部分全是小写字母，则返回 True，否则返回 False

代码示例：

str = "Hello World！"
print (str.islower())

str = "hello world!"
print (str.islower())

str = "hello world!嘿嘿！"
print (str.islower())

'''
输出结果：
False
True
True


'''

isupper()

检测字符串中的字母是否都是大写字母

str.isupper()

参数
无
返回值
如果字符串中的字母部分全是大写字母，则返回 True，否则返回 False

代码示例：

str = "HELLO WORLD！"
print (str.isupper())

str = "HELLO WORLD！嘿嘿！"
print (str.isupper())

str = "hello world!"
print (str.isupper())



'''
输出结果：
True
True
False

'''

isspace()

检测字符串是否只由空白字符组成

str.isspace()

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

代码示例：

str = "       "
print(str.isspace())

str = "Hello World!"
print(str.isspace())
'''
输出结果：
True
False

'''

title()

返回"标题化"的字符串，所有单词都是首字母大写、其余字母为小写

非字母后的第一个字母将转换为大写字母

str.title();

参数
无
返回值
返回"标题化"的字符串，所有单词都是首字母大写、其余字母为小写
非字母后的第一个字母将转换为大写字母

代码示例：

str = "hello world!!"
print (str.title())

str = "bye 4g hello 5g"
print (str.title())

'''
输出结果：
Hello World!!
Bye 4G Hello 5G
'''

istitle()

检测字符串中所有的单词拼写是否为首字母大写、其余字母为小写

str.istitle()

参数
无
返回值
如果字符串中所有的单词拼写首字母为大写、字母为小写则返回 True，否则返回 False

代码示例：

str = "Hello World!"
print(str.istitle())

str = "Hello world!"
print(str.istitle())
'''
输出结果：
True
False

'''

join(seq)

用于将序列中的元素以指定的字符连接生成一个新的字符串

str.join(sequence)

参数
sequence ：要连接的元素序列
返回值
返回通过指定字符连接序列中元素后生成的新字符串

代码示例：

s1 = "-"
s2 = ""
seq = ("h", "e", "l", "l", "o") # 字符串序列
print (s1.join( seq ))
print (s2.join( seq ))



'''
输出结果：
h-e-l-l-o
hello
'''

len(s)

返回对象（字符、列表、元组等）长度或项目个数

len( s )

参数
s ：对象
返回值
返回对象长度

代码示例：

l = [1,2,3,4,5]
print(len(l))

s = "Hello World！"
print(len(s))


'''
输出结果：
5
12
'''

lower()

字符串中所有大写字符转换为小写

str.lower()

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

代码示例：

str = "HELLO WORLD!"
print( str.lower() )

'''
输出结果：
hello world!
'''

upper()

字符串中的小写字母转换为大写

str.upper()

参数
无
返回值
返回小写字母转为大写字母的字符串

代码示例：

str = "hello world!!!";

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

'''
输出结果：
str.upper() :  HELLO WORLD!!!
'''

swapcase()

将字符串中大写转换为小写，小写转换为大写

str.swapcase();

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

代码示例：

str = "Hello World!!"
print (str.swapcase())


'''
输出结果：
hELLO wORLD!!
'''

lstrip()

删除字符串左边的空格或指定字符

str.lstrip([chars])

参数
chars : 指定字符
返回值
返回删除字符串左边的空格或指定字符后生成的新字符串

代码示例：

str = "     Hello World!!!     ";
print(str.lstrip());
str = "88888888Hello World!!!8888888";
print( str.lstrip('8') );

'''
输出结果：
Hello World!!!     
Hello World!!!8888888
'''

rstrip()

删除字符串末尾的空格或指定字符

str.rstrip([chars])

参数
chars ：指定删除的字符（默认为空格）
返回值
返回删除 string 字符串末尾的指定字符后生成的新字符串

代码示例：

str = "     Hello World!!!     ";
print(str.rstrip());
str = "88888888Hello World!!!8888888";
print( str.rstrip('8') );

'''
输出结果：
     Hello World!!!
88888888Hello World!!!

'''

strip([chars])

在字符串上执行 lstrip()和 rstrip()

该方法只能删除开头或是结尾的字符，不能删除中间部分的字符

str.strip([chars]);

参数
chars ：移除字符串头尾指定的字符序列
返回值
返回移除字符串头尾指定的字符序列生成的新字符串

代码示例：

str = "     Hello World!!!     ";
print(str.strip());
str = "88888888Hello World!!!8888888";
print( str.strip('8') );
str = "12345678Hello World!!!87654321";
print( str.strip('1234567') );

'''
输出结果：
Hello World!!!
Hello World!!!
8Hello World!!!8
'''

maketrans()

创建字符映射的转换表

对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标

两个字符串的长度必须相同，为一一对应的关系

tips：注：Python3.4 已经没有 string.maketrans() ，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans() 。

str.maketrans(intab, outtab)

参数
intab ：字符串中要替代的字符组成的字符串
outtab ：相应的映射字符的字符串
返回值
返回字符串转换后生成的新字符串

代码示例：

intab = "elord"
outtab = "12345"
trantab = str.maketrans(intab, outtab)

str = "Hello World!!!"
print (str.translate(trantab))

'''
输出结果：
H1223 W3425!!!
'''

translate(table, deletechars="")

根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

str.translate(table)
bytes.translate(table[, delete])
bytearray.translate(table[, delete])

参数
table ：翻译表，通过 maketrans() 方法转换而来
deletechars ：字符串中要过滤的字符列表
返回值
返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射

代码示例：

intab = "helow"
outtab = "12345"
trantab = str.maketrans(intab, outtab)  # 制作翻译表

str = "hello world!!!"
print(str.translate(trantab))

'''
输出结果：
12334 54r3d!!!
'''

max(str)

返回字符串 str 中最大的字母

max(str)

参数
str : 字符串
返回值
返回字符串中最大的字母

代码示例：

str = "Hello World!!!"
print ("最大字符: " + max(str))

'''
输出结果：
最大字符: r
'''

min(str)

返回字符串 str 中最小的字母

min(str)

参数
str : 字符串
返回值
返回字符串 str 中最小的字母

代码示例：

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

'''
输出结果：
最小字符: a
'''

replace(old, new [, max])

把将字符串中的 old 替换成 new

如果 max 指定，则替换不超过 max 次

str.replace(old, new[, max])

参数
old ：将被替换的子字符串
new ：新字符串，用于替换old子字符串
max ：替换不超过 max 次
返回值
返回字符串中的 old（旧字符串）替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次

代码示例：

str = "1年了"
print("错误码龄：", str)
print("正确码龄：", str.replace("1年", "2年"))

str = "hello hello world!"
print(str.replace("hello", "bye", 2))

str = "hello hello world!"
print(str.replace("hello", "bye", 1))

str = "hello hello world!"
print(str.replace("hello", "bye", 0))
'''
输出结果：
错误码龄： 1年了
正确码龄： 2年了
bye bye world!
bye hello world!
hello hello world!
'''

split(str="", num=string.count(str))

以 str 为分隔符分割字符串，如果 num 有指定值，则仅分割 num+1 个子字符串

str.split(str="", num=string.count(str))

参数
str ：分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等
num ：分割次数（默认为 -1, 即分隔所有）
返回值
返回分割后的字符串列表

代码示例：

str = "hello hello world!"
print (str.split( ))       # 以空格为分隔符
print (str.split(' ',1))   # 以 " " 为分隔符
print (str.split(' ',0))   # 以 " " 为分隔符
print (str.split('w'))     # 以 w 为分隔符

'''
输出结果：
['hello', 'hello', 'world!']
['hello', 'hello world!']
['hello hello world!']
['hello hello ', 'orld!']

'''

splitlines([keepends])

按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表

如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符

str.splitlines([keepends])

参数
keepends ：在输出结果里是否去掉换行符(’\r’, ‘\r\n’, \n’)，默认为 False，不包含换行符，如果为 True，则保留换行符
返回值
返回一个包含各行作为元素的列表

代码示例：

str = 'ab c\n\nde fg\rkl\r\n'
print (str.splitlines())       # 输出结果里去掉换行符('\r', '\r\n', \n')
print (str.splitlines(True))    # 输出结果里包含换行符('\r', '\r\n', \n')

'''
输出结果：
['ab c', '', 'de fg', 'kl']
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

'''

isdecimal()

检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false

注意:定义一个十进制字符串，只需要在字符串前添加 ‘u’ 前缀即可

str.isdecimal()

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

代码示例：

str = "hello 2021"
print (str.isdecimal())

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

str = "20212021"
print (str.isdecimal())
'''
输出结果：
False
False
True
'''

3、 List列表

string、list 和 tuple 都属于 sequence（序列）

序列：Python 中最基本的数据结构，序列中的每个值都有对应的位置值，称之为索引

列表是写在方括号 [] 内、用逗号分隔开的元素列表，是Python 中使用最频繁的数据类型，可以完成大多数集合类的数据结构实现

列表中元素的类型可以不相同，可以嵌套列表

和字符串一样，列表可以被索引和截取

创建列表

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

代码示例：

list1 = ['a', 2 , 3.3, 'd']
list2 = ['e', '888']
print(list1)            # 输出完整列表
print(list2)            # 输出完整列表



'''
输出结果：
['a', 2, 3.3, 'd']
['e', '888']
'''

嵌套列表

嵌套列表，即在列表里创建其它列表

代码示例：

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print(x)

print(x[0])
print(x[0][1])


'''
输出结果：
[['a', 'b', 'c'], [1, 2, 3]]
['a', 'b', 'c']
b
'''

列表操作

列表脚本操作符

tips：+ 号用于组合列表，* 号用于重复列表

表达式	结果	描述
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	迭代

列表截取与拼接

表达式	描述
L[i]	读取索引为i元素
L[-i]	从右侧开始读取倒数第i个元素
L[i:]	输出从索引为i开始的所有元素

列表截取：

格式：
变量[头下标:尾下标]
变量[头下标:尾下标:步长]

两种索引方式：
从左往右，以0开始
从右往左，以-1开始

列表连接：+

列表复制：* n（n代表复制的次数）

代码示例：

list1 = ['a', 2 , 3.3, 'd']
list2 = ['e', '888']

print(list1)            # 输出完整列表
print(list1[0])         # 输出列表第一个元素
print(list1[1:3])       # 从第二个开始输出到第三个元素[1,3)
print(list1[2:])        # 输出从第三个元素开始的所有元素
print(list1[-3:-1])      #输出倒数第三个到倒数第二个元素[-3,-1)
print(list1 * 2)       # 输出两次列表
print(list1 + list2)   # 连接列表
print(list1[0:3:2])     #输出[1,4)中的元素，其中步长为2，即输出0,2元素



'''
输出结果：
['a', 2, 3.3, 'd']
a
[2, 3.3]
[3.3, 'd']
[2, 3.3]
['a', 2, 3.3, 'd', 'a', 2, 3.3, 'd']
['a', 2, 3.3, 'd', 'e', '888']
['a', 3.3]
'''

tips: 列表中的元素可以改变

代码示例：

list = ['a', 2 , 3.3, 'd','e','888']
print(list)            # 输出完整列表
list[1] = 1
print(list)
list[2:4] = [3,'x']
print(list)
list[2:5] = []   #[2,5)的元素置为空
print(list)



'''
输出结果：
['a', 2, 3.3, 'd', 'e', '888']
['a', 1, 3.3, 'd', 'e', '888']
['a', 1, 3, 'x', 'e', '888']
['a', 1, '888']
'''

如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串：

	def reverseWords(input):
     
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ")
 
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords=inputWords[-1::-1]
 
    # 重新组合字符串
    output = ' '.join(inputWords)
     
    return output
 
if __name__ == "__main__":
    input = 'I like runoob'
    rw = reverseWords(input)
    print(rw)



'''
输出结果：
runoob like I
'''

更新列表

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

代码示例：

list = ['hello', 'world', 2021]

print("第三个元素为 : ", list[2])
list[1] = 'World!'
print("更新后的第二个元素为 : ", list[2])


list.append('2022')
print("更新后的列表 : ", list)
'''
输出结果：
第三个元素为 :  2021
更新后的第二个元素为 :  2021
更新后的列表 :  ['hello', 'World!', 2021, '2022']
'''

删除列表元素

使用del()

代码示例：

list = ['hello', 'world', 2021]

print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素后 : ", list)


'''
输出结果：
原始列表 :  ['hello', 'world', 2021]
删除第三个元素后 :  ['hello', 'world']
'''

列表的函数

函数	描述
len(list)	返回列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表

len(list)

返回列表元素个数

len(list)

参数
list ：要计算元素个数的列表
返回值
返回列表元素个数

代码示例：

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


'''
输出结果：
3
5
'''

max(list)

返回列表元素最大值

max(list)

参数
list ：要返回最大值的列表
返回值
返回列表元素中的最大值

代码示例：

list1, list2 = ['hello', 'world', '2021'], [111, 222, 333]

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


'''
输出结果：
list1 最大元素值 :  world
list2 最大元素值 :  333
'''

min(list)

返回列表元素最小值

min(list)

参数
list ：要返回最小值的列表
返回值
返回列表元素中的最小值

代码示例：

list1, list2 = ['hello', 'world', '2021','10211'], [111, 222, 333]

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


'''
输出结果：
list1 最大元素值 :  10211
list2 最大元素值 :  111
'''

list(seq)

将元组转换为列表

元组tuple	列表list
值不能修改	值可以修改
存放于()	存放于[]

list( seq )

参数
seq ：要转换为列表的元组或字符串
返回值
返回列表

代码示例：

tuple = (666, 'hello', 'world', '!!!')
list1 = list(tuple)
print ("列表元素 : ", list1)

str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)


'''
输出结果：
列表元素 :  [666, 'hello', 'world', '!!!']
列表元素 :  ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
'''

列表的方法

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

list.append(obj)

在列表末尾添加新的对象

list.append(obj)

参数
obj ：添加到列表末尾的对象
返回值
无返回值，但是会修改原来的列表

代码示例：

list = ['hello', 'world']
print("原列表 ：",list)
list.append('!!!!')
print ("更新后的列表 : ", list)


'''
输出结果：
原列表 ： ['hello', 'world']
更新后的列表 :  ['hello', 'world', '!!!!']
'''

list.count(obj)

统计某个元素在列表中出现的次数

list.count(obj)

参数
obj ：列表中统计的对象
返回值
返回元素在列表中出现的次数

代码示例：

list = ['hello','hello', 'world']
print("原列表中hello的个数 ：",list.count("hello"))
print("原列表中world的个数 ：",list.count("world"))


'''
输出结果：
原列表中hello的个数 ： 2
原列表中world的个数 ： 1
'''

list.extend(seq)

在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list.extend(seq)

参数
seq ：元素列表，可以是列表、元组、集合、字典，若为字典，则仅会将键(key)作为元素依次添加至原列表的末尾
返回值
没有返回值，但会在已存在的列表中添加新的列表内容

代码示例：

list1 = ['hello','hello', 'world']
list2=list(range(5)) # 创建 0-4 的列表
list1.extend(list2)  # 扩展列表
print(list1)


'''
输出结果：
['hello', 'hello', 'world', 0, 1, 2, 3, 4]
'''

list.index(obj)

从列表中找出某个值第一个匹配项的索引位置

list.index(x[, start[, end]])

参数
x ：查找的对象
start ：可选，查找的起始位置
end ：可选，查找的结束位置
返回值
返回查找对象的索引位置，如果没有找到对象则抛出异常

代码示例：

list1 = ['hello','hello', 'world']
print(list1)
print(list1.index('hello'))
print(list1.index('world'))

'''
输出结果：
['hello', 'hello', 'world']
0
2
'''

list.insert(index, obj)

用于将指定对象插入列表的指定位置

list.insert(index, obj)

参数
index ：对象obj需要插入的索引位置。
obj ：要插入列表中的对象
返回值
没有返回值，但会在列表指定位置插入对象

代码示例：

list1 = ['hello','hello', 'world']
print(list1)
list1.insert(0,"666")
list1.insert(2,"2021")
print(list1)

'''
输出结果：
['hello', 'hello', 'world']
['666', 'hello', '2021', 'hello', 'world']
'''

list.pop([index=-1])

移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list.pop([index=-1])

参数
index ：可选参数，要移除列表元素的索引值，不能超过列表总长度（默认为 index=-1，删除最后一个列表值）
返回值
返回从列表中移除的元素对象

代码示例：

list1 = ['hello','hello', 'world',"!!!"]
print(list1)
print("list1.pop():",list1.pop())
print(list1)
print("list1.pop(1):",list1.pop())
print(list1)

'''
输出结果：
['hello', 'hello', 'world', '!!!']
list1.pop(): !!!
['hello', 'hello', 'world']
list1.pop(1): world
['hello', 'hello']

'''

list.remove(obj)

移除列表中某个值的第一个匹配项

list.remove(obj)

参数
obj ：列表中要移除的对象
返回值
没有返回值但是会移除列表中的某个值的第一个匹配项

代码示例：

list1 = ['hello','~','hello', 'world',"!!!"]
print(list1)
list1.remove('hello')
print("list1.remove('hello')后:",list1)
list1.remove('!!!')
print("list1.remove('!!!')后:",list1)


'''
输出结果：
['hello', '~', 'hello', 'world', '!!!']
list1.remove('hello')后: ['~', 'hello', 'world', '!!!']
list1.remove('!!!')后: ['~', 'hello', 'world']

'''

list.reverse()

反向排序列表中元素

list.reverse()

参数
无
返回值
没有返回值，但是会对列表的元素进行反向排序

代码示例：

list1 = ['hello','~','hello', 'world',"!!!"]
print(list1)
list1.reverse()
print("反向排序后：",list1)



'''
输出结果：
['hello', '~', 'hello', 'world', '!!!']
反向排序后： ['!!!', 'world', 'hello', '~', 'hello']

'''

list.sort( key=None, reverse=False)

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

list.sort( key=None, reverse=False)

参数
key ：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序
reverse ：排序规则，reverse = True 降序， reverse = False 升序（默认）
返回值
没有返回值，但是会对列表的对象进行排序

代码示例：

list1 = ['666','333','555', '111',"999","888"]
print(list1)
list1.sort()
print("升序排序后：",list1)
list1.sort(reverse = True)
print("降序排序后：",list1)


'''
输出结果：
['666', '333', '555', '111', '999', '888']
升序排序后： ['111', '333', '555', '666', '888', '999']
降序排序后： ['999', '888', '666', '555', '333', '111']

'''

list.clear()

清空列表

list.clear()

参数
无
返回值
没有返回值，清空列表

代码示例：

list1 = ['666','333','555', '111',"999","888"]
print(list1)
list1.clear()
print("清空列表后后：",list1)



'''
输出结果：
['666', '333', '555', '111', '999', '888']
清空列表后后： []

'''

list.copy()

复制列表

list.copy()

参数
无
返回值
返回复制后的新列表

代码示例：

list1 = ['666','333','555', '111',"999","888"]
print("list1:",list1)
list2 = list1.copy()
print("copy list1 的list2：",list2)



'''
输出结果：
list1: ['666', '333', '555', '111', '999', '888']
copy list1 的list2： ['666', '333', '555', '111', '999', '888']

'''

4、 Tuple元组

string、list 和 tuple 都属于 sequence（序列）

元组写在小括号 () 里，元素之间用逗号隔开

元组中的元素类型可以不相同

元组的元素不能被修改，但可以包含可变的对象，如list列表

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

创建元组

在括号中添加元素，并使用逗号隔开即可

t1 = ()    # 构造0个元素的元组，空元组
t2 = (20,) # 构造1个元素的元组，需要在元素后添加逗号,否则括号会被当作运算符使用
t22 = (20)  #括号被当作运算符使用，此时t22不是元组，而是整数
t3 = (1,2,3,4,5)
t4 = "a", "b", "c", "d"
print(t1)
print(t2)
print(t3)
print(t4)

print(type(t2))
print(type(t22))


'''
输出结果：
()
(20,)
(1, 2, 3, 4, 5)
('a', 'b', 'c', 'd')
<class 'tuple'>
<class 'int'>

'''

元组操作

元组截取：

格式：
变量[头下标:尾下标]
变量[头下标:尾下标:步长]

两种索引方式：
从左往右，以0开始
从右往左，以-1开始

元组连接：+

元组复制：* n（n代表复制的次数）

代码示例：

tuple1 = ('a', 2, 3.3, 'd', 5)
tuple2 = (6, '77')

print (tuple1)             # 输出完整元组
print (tuple1[0])          # 输出元组的第一个元素
print (tuple1[1:3])        # 输出从第二个元素开始到第三个元素[1,3)
print (tuple1[2:])         # 输出从第三个元素开始的所有元素
print (tuple2 * 2)          # 输出两次元组
print (tuple1 + tuple2)     # 连接元组



'''
输出结果：
('a', 2, 3.3, 'd', 5)
a
(2, 3.3)
(3.3, 'd', 5)
(6, '77', 6, '77')
('a', 2, 3.3, 'd', 5, 6, '77')
'''

修改元组

元组中的元素值不允许修改，但可以对元组进行连接组合

元组连接：+

代码示例：

t1 = ('a', 2, 3.3, 'd', 5)
t2 = (6, '77')
t3 = t1 + t2
# 以下修改元组元素操作是非法的
# t1[0] = 100

print (t3)     # 连接元组


'''
输出结果：
('a', 2, 3.3, 'd', 5, 6, '77')

'''

删除元组

元组中的元素值不允许删除，但可以使用del语句来删除整个元组

代码示例：

t1 = ('a', 2, 3.3, 'd', 5)

print(t1)
del t1
print("删除后的元组 t1 : ")
print(t1)	#会抛出异常

'''
输出结果：
('a', 2, 3.3, 'd', 5)
删除后的元组 t1 : 
Traceback (most recent call last):           #抛出异常
  File "D:\PythonProject\HelloWorld\HelloWorld.py", line 7, in <module>
    print(t1)
NameError: name 't1' is not defined

'''

运算符

符号	描述	代码示例	结果
len()	计算元素个数	len((1, 2, 3))	3
+	连接	(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)
*n	复制n次	(‘Hi!’,) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)
in	元素是否存在	3 in (1, 2, 3)	True
for	迭代	for x in (1, 2, 3): print (x,)	1 2 3

内置函数

元组 t = (‘5’, ‘4’, ‘8’);
列表 list = [‘Hello’, ‘World’, ‘!!!’]

方法	描述	代码示例	结果
len(tuple)	计算元组元素个数	len(t);	3
max(tuple)	返回元组中元素最大值	max(t);	‘8’
min(tuple)	返回元组中元素最小值	min(t);	‘4’
tuple(iterable)	将可迭代系列转换为元组	t = tuple(list);print(t);	(‘Hello’, ‘World’, ‘!!!’)
id(tuple)	查看内存地址	id(t)	2660994964288

5、 Set集合

无序、不重复

由一个或数个形态各异的大小整体组成，构成集合的事物或对象称作元素或是成员

基本功能：进行成员关系测试和删除重复元素

集合创建

使用大括号 { } 或者 set() 函数

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

代码示例：

# 创建集合
a = {'1', 2, 2,'R','A','B'}
b = set('12343335')

#输出集合，不输出重复的元素，元素是无序的
print(a)  
print(b)

# 成员测试
if '1' in a :
    print('1 在集合中')
else :
    print('1 不在集合中')



'''
输出结果：
{2, 'B', 'A', 'R', '1'}
{'3', '1', '2', '4', '5'}
1 在集合中
'''

集合运算符

符号	运算
差集	-
并集	\|
交集	&
异或(不同时存在的元素)	^

代码示例：

# 集合运算
a = set('1234567')
b = {'1','3','5','6','7','8'}
print(a)
print(b)
print('1' in a)	# 元素1是否在a中
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素



'''
输出结果：
{'1', '5', '3', '7', '4', '2', '6'}
{'1', '3', '7', '8', '6', '5'}
True
{'4', '2'}
{'1', '5', '3', '7', '4', '2', '8', '6'}
{'1', '5', '3', '7', '6'}
{'4', '2', '8'}
'''

集合操作

方法	描述
s.add(x)	将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作
s.update( x )	添加元素，参数可以是列表，元组，字典等
s.remove( x )	将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误
s.discard( x )	移除元素，如果元素不存在，不会发生错误
s.pop()	随机删除集合中的一个元素
s.copy()	复制集合
s.clear()	清空集合
len(s)	计算集合 s 元素个数
x in s	判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False

代码示例：

s = set('13557')
print(s)

s.add('4')
print('s.add(\'4\'): ',s)

s.update(('4','5','6'))  #元组
print('s.update((\'4\',\'5\',\'6\')): ',s)

s.remove('6')
s.discard('5')
print('s.remove(\'6\')、s.discard(\'5\'): ',s)

s.pop()
print('s.pop()：',s)

s.pop()
print('s.pop()：',s)

s1 = s.copy()
print('s1 = s.copy():',s1)
print('len(s):',len(s))

print('\'1\' in s:','1' in s)


s.clear()
print('s.clear():',s)



'''
输出结果：
{'7', '1', '3', '5'}
s.add('4'):  {'5', '4', '7', '1', '3'}
s.update(('4','5','6')):  {'5', '6', '4', '7', '1', '3'}
s.remove('6')、s.discard('5'):  {'4', '7', '1', '3'}
s.pop()： {'7', '1', '3'}
s.pop()： {'1', '3'}
s1 = s.copy(): {'1', '3'}
len(s): 2
'1' in s: True
s.clear(): set()

'''

方法	描述
s.isdisjoint(s1)	判断两个集合是否包含相同的元素，没有相同元素返回 True，否则返回 False
s.issubset(s1)	判断集合s的所有元素是否都包含在s1中，如果是则返回 True，否则返回 False
s.issuperset(s1)	判断s1的所有元素是否都包含在s中，如果是则返回 True，否则返回 False

s = {'0','1','2'}
s1 = set("34")
print(s)
print(s1)
print('s.isdisjoint(s1):',s.isdisjoint(s1))     #没有相同元素返回true

print('---------------------')
s = {'0','1','2'}
s1 = set("01234")
print(s)
print(s1)
print('s.issubset(s1):',s.issubset(s1))     #判断集合s的所有元素是否都包含在s1中

print('---------------------')
s = {'0','1','2'}
s1 = set("01234")
s2 = set('01')
print(s)
print(s1)
print(s2)
print('s.issuperset(s1):',s.issuperset(s1))    #判断s1的所有元素是否都包含在s中
print('s.issuperset(s2):',s.issuperset(s2))    #判断s2的所有元素是否都包含在s中



'''
输出结果：
{'1', '0', '2'}
{'3', '4'}
s.isdisjoint(s1): True
---------------------
{'1', '0', '2'}
{'0', '4', '2', '1', '3'}
s.issubset(s1): True
---------------------
{'1', '0', '2'}
{'0', '4', '2', '1', '3'}
{'1', '0'}
s.issuperset(s1): False
s.issuperset(s2): True

'''

方法	描述
s.union(s1, s2…)	并集，返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次
s.difference(s1)	差，s-s1，不改变集合
s.difference_update(s1)	差，移除两个集合中都存在的元素,s-s1，改变集合s
s.intersection(s1, s2 … )	交集，即相同元素，不改变集合
s.intersection_update(s1, s2 … )	交集，即相同元素，改变集合s
s.symmetric_difference(s1)	异或，返回两个集合中不重复的元素的集合
s.symmetric_difference_update(s1)	异或，移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中

print('---------并集（s1 ∪ s2）----------')
s1 = {'0','1','2'}
s2 = set("0234")
print('s1:',s1)
print('s2:',s2)
print('s1.union(s2):',s1.union(s2))
print("执行后：(不改变s1,s2)")
print('s1:',s1)
print('s2:',s2)



'''
输出结果：
---------并集（s1 ∪ s2）----------
s1: {'1', '2', '0'}
s2: {'4', '0', '2', '3'}
s1.union(s2): {'1', '2', '0', '4', '3'}
执行后：(不改变s1,s2)
s1: {'1', '2', '0'}
s2: {'4', '0', '2', '3'}

'''

print("-------------差集（s1-s2）-----------------")
s1 = {'0','1','2','3','4'}
s2 = set("23456")
print('s1:',s1)
print('s2:',s2)
print('s1.difference(s2):',s1.difference(s2))
print("执行后：(不改变s1,s2)")
print('s1.difference(s2),s1:',s1)
print('s1.difference(s2),s2:',s2)

print()
s1.difference_update(s2)
print("执行后：(改变s1)")
print('s1.difference_update(s2),s1:',s1)
print('s1.difference_update(s2),s2:',s2)



'''
输出结果：
-------------差集（s-s1）-----------------
s1: {'4', '2', '0', '1', '3'}
s2: {'4', '2', '5', '3', '6'}
s1.difference(s2): {'1', '0'}
执行后：(不改变s1,s2)
s1.difference(s2),s1: {'4', '2', '0', '1', '3'}
s1.difference(s2),s2: {'4', '2', '5', '3', '6'}

执行后：(改变s1,s2)
s1.difference_update(s2),s1: {'0', '1'}
s1.difference_update(s2),s2: {'4', '2', '5', '3', '6'}

'''

print('------------交集------------')
s = {'0','1','2'}
s1 = set("0234")
s2 = set('12456')
print('s:',s)
print('s1:',s1)
print('s2:',s2)
print('s.intersection(s1):',s.intersection(s1))
print("执行后：(不改变s,s1)")
print('s.intersection(s1),s:',s)
print('s.intersection(s1),s1:',s1)
print()
print('s.intersection(s1,s2):',s.intersection(s1,s2))
print("执行后：(不改变s,s1)")
print('s.intersection(s1),s:',s)
print('s.intersection(s1),s1:',s1)

print()
s.intersection_update(s1)
print("执行后：(改变s)")
print('s.intersection_update(s1),s:',s)
print('s.intersection_update(s1),s1:',s1)
s.intersection_update(s1,s2)
print('s.intersection_update(s1,s2),s:',s)



'''
输出结果：
------------交集------------
s: {'0', '2', '1'}
s1: {'3', '0', '4', '2'}
s2: {'2', '5', '4', '6', '1'}
s.intersection(s1): {'0', '2'}
执行后：(不改变s,s1)
s.intersection(s1),s: {'0', '2', '1'}
s.intersection(s1),s1: {'3', '0', '4', '2'}

s.intersection(s1,s2): {'2'}
执行后：(不改变s,s1)
s.intersection(s1),s: {'0', '2', '1'}
s.intersection(s1),s1: {'3', '0', '4', '2'}
'''

print('------------异或（保留不相同元素）------------')
s = {'0','1','2'}
s1 = set("0234")
s2 = set('12456')
print('s:',s)
print('s1:',s1)
s.symmetric_difference(s1)
print('s.symmetric_difference(s1):',s.symmetric_difference(s1))
print("执行后：(不改变s)")
print('s.symmetric_difference(s1),s:',s)
print('s.symmetric_difference(s1),s1:',s1)

print()
s.symmetric_difference_update(s1)
print("执行后：(改变s)")
print('s.symmetric_difference_update(s1),s:',s)#移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中
print('s.symmetric_difference_update(s1),s1:',s1)



'''
输出结果：
------------异或（保留不相同元素）------------
s: {'1', '0', '2'}
s1: {'3', '0', '2', '4'}
s.symmetric_difference(s1): {'3', '1', '4'}
执行后：(不改变s)
s.symmetric_difference(s1),s: {'1', '0', '2'}
s.symmetric_difference(s1),s1: {'3', '0', '2', '4'}

执行后：(改变s)
s.symmetric_difference_update(s1),s: {'3', '1', '4'}
s.symmetric_difference_update(s1),s1: {'3', '0', '2', '4'}
'''

6、 Dictionary字典

Python中另一个非常有用的内置数据类型

字典是无序的对象集合（列表是有序的对象集合）

字典是一种映射类型，用 { } 标识，key和value用":“隔开，键值对之间用”,"分隔，是一个无序的 键值(key-value) 集合

元素通过键key来存取，在同一个字典中，键(key)唯一

键(key)必须使用不可变类型（Number、String、Tuple），值可以取任何数据类型

创建字典

① 用{}标识

代码示例：

# create dictionary
d1= {}
d1['哈哈'] = 'haha'
d1['嘿嘿']= 'heihei'
d2 = {'昵称': '入错行的北北','码龄': '1年','博客':'北北的博客'}
# print dictionary
print (d1["哈哈"])       # 输出键为"哈哈"的值
print (d1["嘿嘿"])       # 输出键为"嘿嘿"的值
print(d1)
print (d1.keys())   # 输出所有键
print (d1.values()) # 输出所有值
print()
print (d2)          # 输出完整的字典
print (d2.keys())   # 输出所有键
print (d2.values()) # 输出所有值

d = { }				#创建空字典
print(d)




'''
输出结果：
haha
heihei
{'哈哈': 'haha', '嘿嘿': 'heihei'}
dict_keys(['哈哈', '嘿嘿'])
dict_values(['haha', 'heihei'])

{'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
dict_keys(['昵称', '码龄', '博客'])
dict_values(['入错行的北北', '1年', '北北的博客'])
{}
'''

② 构造函数dict

构造函数 dict() 可以直接从键值对序列中构建字典

代码示例：

# create dictionary
d = dict([('昵称','入错行的北北'), ('码龄','1年'), ('博客','北北的博客')])
print (d)          # 输出完整的字典
print(d['昵称'])
print(d['码龄'])
print(d['博客'])
print (d.keys())   # 输出所有键
print (d.values()) # 输出所有值



'''
输出结果：
{'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
入错行的北北
1年
北北的博客
dict_keys(['昵称', '码龄', '博客'])
dict_values(['入错行的北北', '1年', '北北的博客'])
'''

③ 其它方法

代码示例1：

d = {x: x ** 2 for x in (2, 4, 6)} #**2,平方; **n,n次方
print(d)



'''
输出结果：
{2: 4, 4: 16, 6: 36}
'''

代码示例2：

d = dict(aa=1, bb=2, cc=3)
print(d)



'''
输出结果：
{'aa': 1, 'bb': 2, 'cc': 3}
'''

基本操作

修改字典

d = dict([('昵称','北北'), ('码龄','1年'), ('博客','北北的博客')])
print (d)          # 输出完整的字典
d['昵称'] = '入错行的北北'  #修改
print(d)



'''
输出结果：
{'昵称': '北北', '码龄': '1年', '博客': '北北的博客'}
{'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
'''

删除字典元素
删除单一元素
清空字典

d = dict([('昵称','北北'), ('码龄','1年'), ('博客','北北的博客')])
print ('原始字典：',d)          # 输出完整的字典
del d['码龄'] # 删除键 '码龄'
print('del d[\'码龄\']:',d)
d.clear()     # 清空字典
print('d.clear():',d)




'''
输出结果：
原始字典： {'昵称': '北北', '码龄': '1年', '博客': '北北的博客'}
del d['码龄']: {'昵称': '北北', '博客': '北北的博客'}
d.clear(): {}

'''

删除字典

del d        # 删除字典
print(d)


'''
输出结果：(报错)
NameError: name 'd' is not defined
'''

内置函数

函数名	作用
len()	求长度
type()	查询类型
str()	字典以可打印的字符串表示

代码示例：

d = dict([('昵称','入错行的北北'), ('码龄','1年'), ('博客','北北的博客')])

print ("d字典长度len(d): ", len(d))
print ("d的类型type(d): ", type(d))
print()
print('输出字典d :' , d)            #输出字典
print ( '输出字典str(d) :' , str(d))     #输出字典，以可打印的字符串表示





'''
代码示例：
d字典长度len(d):  3
d的类型type(d):  <class 'dict'>

输出字典d : {'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
输出字典str(d) : {'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}


'''

内置方法

方法名	描述
copy()	返回一个字典的浅复制
clear()	删除字典内所有元素
get()	返回指定键的值，如果值不在字典中返回default值
key in dict	判断键是否存在于字典中，是则为true
key not in	与in相反
dict.items()	返回视图对象

d = dict([('昵称','入错行的北北'), ('码龄','1年'), ('博客','北北的博客')])

d1 = d.copy()
print('d.items():',d.items())
print('d1 = d.copy(): ' , d1)
d.clear()           #删除字典内所有元素
print('d.clear(): ',d)
print()
print('d1.get(\'昵称\') :' ,d1.get('昵称'))
print('昵称' in d)
print('name' not in d)

'''
输出结果：
d.items():dict_items([('昵称', '入错行的北北'), ('码龄', '1年'), ('博客', '北北的博客')])
d1 = d.copy():  {'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
d.clear():  {}

d1.get('昵称') : 入错行的北北
True
True
'''

方法名	描述
keys()	返回一个迭代器，可以使用 list() 来转换为列表
values()	返回一个迭代器，可以使用 list() 来转换为列表
setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

d = dict([('昵称','入错行的北北'), ('码龄', '1年')])
print('d.keys():',d.keys())
print('d.values():',d.values())

print()
print("昵称 键的值为 : %s" % dict.setdefault('昵称', None))
print("博客 键的值为 : %s" % dict.setdefault('博客', '北北的博客'))
print("新字典为：", dict)


'''
输出结果：
d.keys(): dict_keys(['昵称',  '博客'])
d.values(): dict_values(['入错行的北北', '北北的博客'])

昵称 键的值为 : 入错行的北北
博客 键的值为 : 北北的博客
新字典为： {'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
'''

方法名	描述
dict.fromkeys(seq[, value])	创建一个新字典，seq中元素为键，value为键对应的初始值
update(dict2)	把字典dict2的键/值对更新到dict里
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值
popitem()	随机返回并删除字典中的一对键和值(一般删除末尾对）

seq = ('昵称', '码龄', '博客')
dict = dict.fromkeys(seq)
print("新的字典为 :" ,str(dict))

value = ('你猜')
dict = dict.fromkeys(seq, value)
print("新的字典为 : %s" % str(dict))

print()
d1 = dict([('昵称','入错行的北北'), ('码龄', '1年')])
d2 = {'博客':'北北的博客'}
d1.update(d2)
print(d1)

print('d1.pop(\'码龄\'):',d1.pop('码龄'))
print('d1:',d1)

print()
print('d1.popitem():',d1.popitem())	#默认删除末尾
print('d1:',d1)
'''
输出结果：
新的字典为 : {'昵称': None, '码龄': None, '博客': None}
新的字典为 : {'昵称': '你猜', '码龄': '你猜', '博客': '你猜'}

{'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
d1.pop('码龄'): 1年
d1: {'昵称': '入错行的北北', '博客': '北北的博客'}

d1.popitem(): ('博客', '北北的博客')
d1: {'昵称': '入错行的北北'}

'''

三、数据类型转换

函数	描述
int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典，d 必须是一个 (key, value)元组序列。
frozenset(s)	转换为不可变集合
chr(x)	整数(8、10、16)→字符
ord(x)	字符→10进制整数
hex(x)	整数(8、10)→十六进制字符串
oct(x)	整数(10、16)→八进制字符串

int(x [,base])

int() 函数用于将一个字符串或数字转换为整型

class int(x, base=10)

参数：
x：字符串或数字
base = n：n为进制数，默认n=10，即十进制
返回值：
整型数据

代码示例：

a1 = int()               # 不传入参数时，得到结果0
a2 = int(2)
a3 = int(3.9)           #向下取整
a4 = int('12',16)        # 带参数base,x以字符串的形式进行输入,12为16进制
a5 = int('0xa',16)        # 带参数base,x以字符串的形式进行输入,16为16进制
a6 = int('10',8)        # 带参数base,x以字符串的形式进行输入,10为8进制
print(a1,a2,a3,a4,a5,a6)



'''
输出结果：
0 2 3 18 10 8
'''

float(x)

用于将整数和字符串转换成浮点数

class float([x])

参数：
x：整数或字符串
返回值：
返回浮点数

代码示例：

a0 = float()
a1 = float(1)
a2 = float(2)
a3 = float(-3.3)
a4 = float('444')     # 字符串
print(a0,a1,a2,a3,a4)



'''
输出结果：
0.0 1.0 2.0 -3.3 444.0
'''

complex(real [,imag])

用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数
如果第一个参数为字符串，则不需要指定第二个参数

class complex([real[, imag]])

参数：
real：int, long, float 或字符串
imag ： int, long, float
返回值：
返回一个复数

代码示例：

a0 = complex()
a1 = complex(1,2)
a2 = complex(1.1)  # 数字
a3 = complex("1")  # 当做字符串处理
a4 = complex("12")
a5 = complex("1+2j")# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
print(a0)
print(a1)
print(a2)
print(a3)
print(a4)
print(a5)



'''
输出结果：
0j
(1+2j)
(1.1+0j)
(1+0j)
(12+0j)
(1+2j)
'''

str(x)

将对象 x 转换为字符串

class str(object=’’)

参数：
object ：对象
返回值：
返回对象的string格式

代码示例：

s = 'helloWorld'
dict = {'昵称': '入错行的北北', '码龄': '1年'}
print(str(s))
print(dict)




'''
输出结果：
helloWorld
{'昵称': '入错行的北北', '码龄': '1年'}
'''

repr(x)

将对象 x 转换为表达式字符串（供解释器读取的形式）

repr(object)

参数：
object ：对象
返回值：
返回对象的 string 格式

代码示例：

s = 'helloWorld'
dict = {'昵称': '入错行的北北', '码龄': '1年'}
print(repr(s))
print(repr(dict))



'''
输出结果：
'helloWorld'
{'昵称': '入错行的北北', '码龄': '1年'}
'''

eval(str)

用来执行字符串表达式，并返回表达式的值

eval(expression[, globals[, locals]])

参数：
expression ：表达式
globals ：变量作用域，全局命名空间（如果被提供，则必须是字典对象）
locals : 变量作用域，局部命名空间（如果被提供，可以是任何映射对象）
返回值：
返回表达式计算结果

代码示例：

x = 7
a1 = eval( '3 * x' )
a2 = eval('pow(2,10)')      #2^10
a3 = eval('2 + 2')
n=81
a4 = eval("n + 4")
print(a1)
print(a2)
print(a3)
print(a4)



'''
输出结果：
21
1024
4
85
'''

tuple(s)

将可迭代系列（如列表）转换为元组

tuple( iterable )

参数：
iterable ：要转换为元组的可迭代序列
返回值：
返回元组

代码示例：

list = ['AAA', 222, 'CCC', 'DDD']
tuple = tuple(list)

print('list:',list)
print('tuple:',tuple)



'''
输出结果：
list: ['AAA', 222, 'CCC', 'DDD']
tuple: ('AAA', 222, 'CCC', 'DDD')
'''

list(s)

用于将元组或字符串转换为列表

list( seq )

参数：
seq ：要转换为列表的元组或字符串
返回值：
返回列表

代码示例：

t = (111, 'BBB', '333', 'DDD')
list1 = list(t)
print ("列表元素 : ", list1)
str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)



'''
输出结果：
列表元素 :  [111, 'BBB', '333', 'DDD']
列表元素 :  ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
'''

set(s)

转换为可变集合（无序、不重复）

class set([iterable])

参数：
iterable ：可迭代对象
返回值：
返回集合对象

代码示例：

x = set('hello')
y = set('world')
print(x)
print(y)
print(x & y)      # 交集
print(x | y )         # 并集
print(x - y)         # 差集



'''
输出结果：
{'o', 'h', 'e', 'l'}
{'o', 'd', 'w', 'r', 'l'}
{'o', 'l'}
{'o', 'e', 'd', 'h', 'w', 'r', 'l'}
{'h', 'e'}
'''

dict(d)

创建一个字典
d 必须是一个 (key, value)元组序列

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

参数：
**kwargs ：关键字
mapping ：元素的容器
iterable ：可迭代对象
返回值：
返回一个字典

代码示例：

a1 = dict()                        # 创建空字典
a2 = dict(a='a', b='b', c='c')     # 传入关键字
a3 = dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
a4 = dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
print(a1)
print(a2)
print(a3)
print(a4)



'''
输出结果：
{}
{'a': 'a', 'b': 'b', 'c': 'c'}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
'''

frozenset(s)

返回一个冻结的集合(不可变集合)，冻结后集合不能再添加或删除任何元素

class frozenset([iterable])

参数：
iterable ：可迭代的对象，比如列表、字典、元组等等
返回值：
返回集合，如果不提供任何参数，默认生成空集合

代码示例：

a1 = frozenset(range(10))     # 生成一个新的不可变集合
b1 = frozenset('hello world')  # 创建不可变集合

a2 = set(range(10))
b2 = set('hello world') 

print(a1)
print('set:',a2)
print(b1)
print('set:',b2)



'''
输出结果：
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
set: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
frozenset({'o', 'l', 'h', ' ', 'w', 'd', 'e', 'r'})
set: {'o', 'l', 'h', ' ', 'w', 'd', 'e', 'r'}
'''

chr(x)

将一个整数（0～255）转换为一个字符

chr(i)

参数：
i ： 8进制 or 10进制 or 16进制的形式的数字
返回值：
返回当前整数对应的 ASCII 字符

代码示例：

print('8进制转换为字符：',chr(0o60), chr(0o101), chr(0o141))         #8进制转换为字符
print('10进制转换为字符：',chr(48), chr(65), chr(97))                #10进制转换为字符
print('16进制转换为字符：',chr(0x30), chr(0x41), chr(0x61))          #16进制转换为字符



'''
输出结果：
8进制转换为字符： 0 A a
10进制转换为字符： 0 A a
16进制转换为字符： 0 A a
'''

ord(x)

将一个字符转换为对应的10进制整数值

ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常

ord©

参数：
c ：字符
返回值：
返回字符c对应的十进制整数

代码示例：

print(chr(48), chr(65), chr(97))            # 十进制
print('字符转换为10进制：',ord('0'),ord('A'),ord('a'))               #字符转换为10进制



'''
输出结果：
0 A a
字符转换为10进制： 48 65 97
'''

hex(x)

用于将整数转换成16进制字符串

hex(x)

参数：
x：8进制 or 10进制整数
返回值：
返回整数x对应的16进制字符串

代码示例：

print('8进制转换为字符：',chr(0o60), chr(0o101), chr(0o141))         #8进制转换为字符
print('10进制转换为字符：',chr(48), chr(65), chr(97))                #10进制转换为字符
print('16进制转换为字符：',chr(0x30), chr(0x41), chr(0x61))          #16进制转换为字符
print('8进制整数转换为16进制：',hex(0o60),hex(0o101),hex(0o141))             #8进制整数转换为16进制
print('10进制整数转换为16进制：',hex(48),hex(65),hex(97))                  #10进制整数转换为16进制



'''
输出结果：
8进制转换为字符： 0 A a
10进制转换为字符： 0 A a
16进制转换为字符： 0 A a
8进制整数转换为16进制： 0x30 0x41 0x61
10进制整数转换为16进制： 0x30 0x41 0x61
'''

oct(x)

将**整数转换为八进制字符串**

Python3.x 版本的 8 进制以 0o 作为前缀

oct(x)

参数：
x：10进制 or 16进制整数
返回值：
返回 8 进制字符串

代码示例：

print('10进制整数转换为8进制：',oct(48),oct(65),oct(97))                  #10进制整数转换为8进制
print('16进制整数转换为8进制：',oct(0x30),oct(0x41),oct(0x61))            #16进制整数转换为8进制



'''
输出结果：
10进制整数转换为8进制： 0o60 0o101 0o141
16进制整数转换为8进制： 0o60 0o101 0o141
'''