Python3 基本数据类型

发表于 | 分类于 ， | 阅读次数: |
字数统计: 14.5k | 阅读时长 61 分钟

前言:
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建;
在 Python 中，变量就是变量，它没有类型，我们所说的”类型”是变量所指的内存中对象的类型

Python 变量类型

(1)变量存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间
(2)基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中
(3)因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符

变量赋值

(1)Python 中的变量赋值不需要类型声明
(2)每个变量在内存中创建，都包括变量的标识，名称和数据这些信息
(3)每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建
(4)等号=用来给变量赋值
(5)等号=运算符左边是一个变量名,等号=运算符右边是存储在变量中的值

1
2
3
4
5
6
counter = 100 	# 赋值整型变量
miles = 1000.0 	# 浮点型
name = "John" 	# 字符串
print("整数："+str(counter))
print("浮点数："+str(miles))
print("字符串："+str(name))

输出结果：

1
2
3
整数：100
浮点数：1000.0
字符串：John

多个变量赋值

(1)Python允许你同时为多个变量赋值，例如：创建一个整型对象，值为1，三个变量被分配到相同的内存空间上

1
2
3
>>> a = b = c = 1
>>> print(a+b+c)
3

(2)多个对象指定多个变量，例如：两个整型对象1和2分别分配给变量a和b，字符串对象john分配给变量c

1
2
3
>>> a, b, c = 1, 2, "john"
>>> print(str(a)+str(b)+c)
12john

标准数据类型

(1)Python3定义了*六个标准数据类型，用于存储各种类型的数据：

  • Numbers（数字）
  • String（字符串）
  • List（列表）
  • Tuple（元组）
  • Set（集合） # Python3以下版本无此数据类型
  • Dictionary（字典）

(2)

  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
  • 有序：列表list、字典dict(python3.6之后)、Tuple（元组）、Number（数字）、String（字符串）
  • 无序：字典dict(python3.6之前)、集合set

Number（数字）

(1)Python3支持int、float、bool、complex（复数）
(2)在Python3里，只有一种整数类型int，表示为长整型，没有python2中的Long
(3)像大多数语言一样，数值类型的赋值和计算都是很直观的
(4)内置的type()函数可以用来查询变量所指的对象类型 

1
2
3
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

(5)此外还可以用isinstance来判断类型

1
2
3
>>> a,b = 111,'111'
>>> print('a是不是整型：',isinstance(a, int),'b是不是整型：',isinstance(b, int))
a是不是整型： True b是不是整型： False

(6)isinstance和type的区别在于：

  • type()不会认为子类是一种父类类型。
  • isinstance()会认为子类是一种父类类型
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    >>> class A:
    ...     pass
    ... 
    >>> class B(A):
    ...     pass
    ... 
    >>> isinstance(A(), A)
    True
    >>> type(A()) == A 
    True
    >>> isinstance(B(), A)
    True
    >>> type(B()) == A
    False

注意：在Python2中是没有布尔型的，它用数字0表示False，用1表示True。到Python3中，把True和False定义成关键字了，但它们的值还是1和0，它们可以和数字相加
(7)使用del语句删除一些对象引用，del语句的语法是：

1
2
3
del var1[,var2[,var3[....,varN]]]   # del语语法
del var                             # del语句删除单个对象
del var_a, var_b                    # del语句删除多个对象

数值运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 17 // 3# 除法，得到一个整数
5
>>> 17 % 3 # 取余 
2
>>> 2 ** 5 # 乘方
32
  • Python可以同时为多个变量赋值，如a, b = 1, 2
  • 一个变量可以通过赋值指向不同类型的对象
  • 数值的除法包含两个运算符/返回一个浮点数，//返回一个整数
  • 在混合计算时，Python会把整型转换成为浮点数

数值类型实例

int float complex
10 0.0 3.14j
100 15.20 45.j
-786 -21.9 9.322e-36j
080 32.3e+18 .876j
-0490 -90. -.6545+0J
-0x260 -32.54e100 3e+26J
0x69 70.2E-12 4.53e-7j

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型

数学函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import math
import random

x,y = 10,20
list1=[9,4,7,3,8,5,1,6]

# 数学函数
print('abs(-10):',abs(-10))	# 返回数字的绝对值，如abs(-10) 返回 10
print('math.fabs(-10):',math.fabs(-10))	# 返回数字的绝对值，如math.fabs(-10) 返回10.0
print('max(list1):',max(list1))	# 返回给定参数的最大值，参数可以为序列(列表等)
print('min(list1):',min(list1))	# 返回给定参数的最小值，参数可以为序列(列表等)
print('(x>y)-(x<y):',(x>y)-(x<y))	# 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换
print('math.exp(1):',math.exp(1))	# 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
print('math.ceil(4.1):',math.ceil(4.1))	# 返回数字的上入整数，如math.ceil(4.1) 返回 5
print('math.floor(4.9):',math.floor(4.9))	# 返回数字的下舍整数，如math.floor(4.9)返回 4
print ("math.pow(2, 4):", math.pow(2, 4))	# x**y 运算后的值，math.pow(2, 4)返回16.0
print ("round(70.23456):", round(70.23456,4))	# 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数，其实准确的说是保留值将保留到离上一位更近的一端
print ("math.sqrt(100): ", math.sqrt(100))	# 返回数字x的平方根，math.sqrt(100)返回10.0
print ("math.modf(100.12): ", math.modf(100.12))	# 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示
print('math.log(32,2):',math.log(32,2))	# log() 方法返回x的自然对数，如math.log(math.e)返回1.0,math.log(32,2)返回5.0
print('math.log10(10000):',math.log10(10000))	# 返回以10为基数的x的对数，如math.log10(10000)返回 4.0


# 随机数函数(随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性)
# random.choice(seq)函数：从序列(可以是一个列表，元组或字符串)的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数
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'))
# random.randrange ([start,] stop [,step])：从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2))	# 从 1-100 中选取一个奇数
print ("randrange(100) : ", random.randrange(100))	# 从 0-99 选取一个随机数
# random.random()：随机生成下一个实数，它在[0,1)范围内
print ("random() : ", random.random())	# 随机生成一个[0,1)的实数
print ("random() : ", (random.random()*10+1))	# 随机生成一个[0,10]的实数
# random.seed ( [x] ): 方法改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数.
# 预先使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个
random.seed(10)
print ("使用整数 10 种子生成随机数：", random.random())		# 产生一个随机数
random.seed(10)
print ("使用整数 10 种子生成随机数：", random.random()) 	# 和上一个随机数一致
# random.shuffle (lst)：将序列的所有元素随机排序，lst为列表，函数返回 None
random.shuffle(list1);	# 随机排序列表
print ("随机排序列表1 : ", list1)
random.shuffle(list1)	# 随机排序列表
print ("随机排序列表3 : ", list1)
# random.uniform(x, y)：随机生成下一个实数，它在[x,y]范围内，返回一个浮点数 N，取值范围为如果 x<y 则 x <= N <= y，如果 y<x 则y <= N <= x
print ("uniform(5, 10) 的随机浮点数 : ",  random.uniform(5, 10))
print ("生成两位小数的浮点数 : ",  round(random.uniform(5, 10), 2))


# 三角函数
print ("cos(0) : ",  math.cos(0))	# 返回x的弧度的余弦值	返回x的弧度的余弦值,-1 到 1 之间
print ("acos(1) : ",  math.acos(1))	# 返回x的反余弦弧度值	x为-1到1之间的数值。如果x是大于1，会产生一个错误
print ("sin(math.pi/2) : ",  math.sin(math.pi/2))	# 返回的x弧度的正弦值	返回的x弧度的正弦值，数值在 -1 到 1 之间
print ("asin(0) : ",  math.asin(0))	# 返回x的反正弦弧度值	x为-1到1之间的数值。如果x是大于1，会产生一个错误
print ("tan(0) : ",  math.tan(0))	# 返回x弧度的正切值	返回的x弧度的正弦值，数值在 -1 到 1 之间
print ("atan(0.64) : ",  math.atan(0.64))	# 返回x的反正切弧度值
print ("atan2(5,5) : ",  math.atan2(5,5))	# 返回给定的 X 及 Y 坐标值的反正切值
print ("hypot(0, 2) : ",  math.hypot(0, 2))	# 返回欧几里德范数 sqrt(x*x + y*y)
print ("degrees(math.pi/2) : ",  math.degrees(math.pi/2))	# 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
print ("radians(math.pi/2) : ",  math.radians(math.pi/2))	# 将角度转换为弧度


# 数学常量
print('pi：',math.pi)	# 数学常量 pi（圆周率，一般以π来表示）
print('e：',math.e)	# 数学常量 e，e即自然常数（自然常数）

String（字符串）

(1)Python中的字符串用单引号'或双引号"括起来，同时使用反斜杠\转义特殊字符
(2)索引值以0为开始值，-1为从末尾的开始位置
Python 字符串索引
(3)加号+是字符串的连接符，星号*表示复制当前字符串，与之结合的数字为复制的次数
(4)Python使用反斜杠\转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个r，表示原始字符串 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
>>>str = 'Runoob'
>>>print (str)          # 输出字符串
Runoob
>>>print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
Runoo
>>>print (str[0])       # 输出字符串第一个字符
R
>>>print (str[2:5])     # 输出从第三个开始到第五个的字符
noo
>>>print (str[2:])      # 输出从第三个开始的后的所有字符
noob
>>>print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str) 
RunoobRunoob
>>>print (str + "TEST") # 连接字符串
RunoobTEST
>>>print ('Ru\noob')	 # 反斜杠 \ 转义特殊字符
Ru
oob
>>>print (r'Ru\noob')	 # 字符串前面添加一个 r，表示原始字符串，不让反斜杠发生转义
Ru \n oob
>>>inputStr = '123 456 789'
>>>inputStr=inputStr[-1::-1]	# 字符串逆置
>>>print(inputStr)
987 654 321

(5)Python没有单独的字符类型，一个字符就是长度为1的字符串
(6)Python字符串不能被改变，向一个索引位置赋值，比如word[0]='m'会导致错误

1
2
3
4
5
>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P

Python字符串格式化

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

1
2
>>>print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
我叫 小明 今年 10 岁!

(2)Python字符串格式化符号

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

f-string

(1)f-string是python3.6之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法,之前我们习惯用百分号(%)
(2)f-string格式化字符串以f开头，后面跟着字符串，字符串中的表达式用大括号{}包起来，它会将变量或表达式计算后的值替换进去，实例如下

1
2
3
>>> name = 'Runoob'
>>> 'Hello %s' % name
'Hello Runoob'

(3)用了f-string方式显得更简单，不用再去判断使用%s，还是%d
(4)在Python 3.8的版本中可以使用 = 符号来拼接运算表达式与结果

1
2
3
4
5
6
>>> x = 1
>>> print(f'{x+1}')   # Python 3.6
2
>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8
'x+1=2'

字符串内建函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
# Python 的字符串内建函数，Python 的字符串常用内建函数如下：

string = 'Hello World'

# capitalize()：该方法返回一个首字母大写的字符串
# (1)首字符会转换成大写，其余字符会转换成小写
# (2)首字符如果是非字母，首字母不会转换成大写，会转换成小写
print ("str.capitalize() : ", 'lu XIONG'.capitalize())	# 输出：str.capitalize() :  Lu xiong
print ("str.capitalize() : ", '123 Lu XIONG'.capitalize())	# 输出：str.capitalize() :  123 lu xiong

# center(width[, fillchar])：返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格.如果 width 小于字符串宽度直接返回字符串
print ("str.center(40, '*') : ", '[runoob]'.center(40, '*'))		# 输出：str.center(40, '*') :  ****************[runoob]****************
# ljust(width[, fillchar])：返回一个原字符串左对齐,并使用空格(fillchar填充字符，默认为空格)填充至指定长度(width)的新字符串，如果指定的长度小于原字符串的长度则返回原字符串
print ('大帅哥'.ljust(40, '*')) # 输出：大帅哥*************************************
# rjust(width[, fillchar])：返回一个原字符串右对齐,并使用空格(fillchar填充字符，默认为空格)填充至指定长度(width)的新字符串，如果指定的长度小于原字符串的长度则返回原字符串
print ('大帅哥'.rjust(40, '*')) # 输出：*************************************大帅哥

# zfill(width)：返回指定长度的字符串，原字符串右对齐，前面填充0(作用同 rjust(width,"0"))
print ('大帅哥'.zfill(40)) # 输出：0000000000000000000000000000000000000大帅哥

# count(sub, start= 0,end=len(string))：返回回子字符串(sub)在字符串中出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
print ("str.count('o') : ", 'www.runoob.com'.count('o',0,10)) # 输出：str.count('o') :  2
 
# find(str, beg=0, end=len(string))：检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
print("Runoob example....wow!!!".find("exam"))      # 输出：7
print("Runoob example....wow!!!".find("exam", 5))   # 输出：7
print("Runoob example....wow!!!".find("exam", 10))  # 输出：-1
# rfind(str, beg=0 end=len(string))：类似于 find()函数，不过是从右边开始查找.返回字符串str最后一次出现的位置，如果没有匹配项则返回-1(beg-开始查找的位置，默认为0  end-结束查找位置，默认为字符串的长度)
print ('abcdefghijklmnopqrstubvwxyz 中 b 最后一次出现在：','abcdefghijklmnopqrstubvwxyz'.rfind('b',0,20)) # 输出：aa bb aa bb aa bb aa bb中 bb 最后一次出现在： 9
print ('abcdefghijklmnopqrstubvwxyz 中 b 最后一次出现在：','abcdefghijklmnopqrstubvwxyz'.find('b',0,20)) # 输出：aa bb aa bb aa bb aa bb中 bb 最后一次出现在： 3


# # index(str, beg=0, end=len(string))：跟find()方法一样，只不过如果str不在字符串中会报一个异常
# print("Runoob example....wow!!!".index("exam"))      # 输出：7
# print("Runoob example....wow!!!".index("exam", 5))   # 输出：7
# print("Runoob example....wow!!!".index("exam", 10))  # 输出：ValueError: substring not found
# # rindex(str, beg=0, end=len(string))：类似于 find()函数，不过是从右边开始查找.跟find()方法一样，只不过如果str不在字符串中会报一个异常
# print("Runoob example....wow!!!".rindex("exam"))      # 输出：7
# print("Runoob example....wow!!!".rindex("exam", 5))   # 输出：7
# print("Runoob example....wow!!!".rindex("exam", 10))  # 输出：ValueError: substring not found

# isalnum()：检测字符串是否由字母和数字组成，如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
print('runoob2016 是不是都是字母或者数字：',"runoob2016".isalnum())             # 输出：runoob2016 是不是都是字母或者数字： True
print('www.runoob.com 是不是都是字母或者数字：',"www.runoob.com".isalnum())     # 输出：www.runoob.com 是不是都是字母或者数字： False
# isalpha()：检测字符串是否只由字母或文字组成，如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
print('runoob菜鸟教程 是不是都是字母或者文字组成：', "runoob菜鸟教程".isalnum())  # 输出：runoob2016 是不是都是字母或者数字： True
print('Runoob example....wow!!! 是不是都是字母或者数字：', "Runoob example....wow!!!".isalnum())  # 输出：www.runoob.com 是不是都是字母或者数字： False
# isdigit()：检测字符串是否只由数字组成，如果字符串只包含数字则返回 True 否则返回 False
print('12985 是不是都是数字：', '12985'.isdigit())  # 输出：12985 是不是都是数字： True
print('runoo 是不是都是数字：', "runoo".isdigit())  # 输出：12985 是不是都是数字： False
# isdecimal()：检测字符串是否只包含十进制字符。这种方法只存在于unicode对象。注：定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可
print('12985 是不是都是十进制字符：', '12985'.isdecimal())  # 输出：12985 是不是都是十进制字符： True
print('129ww 是不是都是十进制字符：', '129ww'.isdecimal())  # 输出：129ww 是不是都是十进制字符： False

# islower()：检测字符串是否由小写字母组成，如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
print('12uno1 的字母是不是都是小写字母：', '12uno1'.islower())   # 输出：12uno1 的字母是不是小写字母： True
print('ruNoo 的字母是不是都是小写字母：', "ruNoo".islower())     # 输出：runoo 的字母是不是都是小写字母： False
# isupper()：检测字符串中所有的字母是否都为大写，如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
print('12ABC 的字母是不是都是大写字母：', '12ABC'.isupper())  # 输出：12ABC 的字母是不是小写字母： True
print('abCDE 的字母是不是都是大写字母：', "abCDE".isupper())  # 输出：abCDE 的字母是不是都是小写字母： False

# lower()：转换字符串中所有大写字符为小写，返回将字符串中所有大写字符转换为小写后生成的字符串
print( "Runoob EXAMPLE....WOW!!!".lower()) # 输出：runoob example....wow!!!
# upper()：转换字符串中所有大写字符为大写，返回将字符串中所有小写字符转换为大写后生成的字符串
print( "this is string".upper()) # 输出：THIS IS STRING

# swapcase()：用于对字符串的大小写字母进行转换，返回大小写字母转换后生成的新字符串
print ('This Is String'.swapcase())	# 输出：tHIS iS sTRING

# isnumeric()：测字符串是否只由数字组成，数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。指数类似 ² 与分数类似 ½ 也属于数字.如果字符串中只包含数字字符，则返回 True，否则返回 False
print('222666 是不是只包含数字字符：', '222666'.isnumeric())  # 输出：222666 是不是只包含数字字符： True
print('222abc 是不是只包含数字字符：', "222abc".isnumeric())  # 输出：222abc 是不是只包含数字字符： False

# isspace()：检测字符串是否只由空白字符组成，如果字符串中只包含空格，则返回 True，否则返回 False
print('        '.isspace()) # 输出：True
print('   a    '.isspace()) # 输出：False

# istitle()：检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写，如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False
print('Hello World'.istitle())  # 输出：True
print('Hello world'.istitle())  # 输出：False

# title()：返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写
print('this is string'.title()) # 输出：This Is String

# join()：用于将序列中的元素以指定的字符连接生成一个新的字符串，返回通过指定字符连接序列中元素后生成的新字符串
print('-'.join(list('World'))) # 输出：W-o-r-l-d
print(' '.join(list('World'))) # 输出：W o r l d

# len()：返回对象（字符、列表、元组等）长度或项目个数
print('Hello World 的长度为：'+str(len('Hello World'))) # 输出：Hello World 的长度为：11

# lstrip([chars])：用于截掉字符串左边的空格或指定字符(chars)，返回截掉字符串左边的空格或指定字符后生成的新字符串
print('     this is string'.lstrip()) # 输出：this is string
print('889999988this is string999'.lstrip('89')) # 输出：this is string999
# rstrip([chars])：用于截掉字符串右边的空格或指定字符(chars)，返回截掉字符串右边的空格或指定字符后生成的新字符串
print('this is string     '.rstrip()) # 输出：this is string
print('889999988this is string889999988'.rstrip('89')) # 输出：889999988this is string
# strip([chars])：用于移除字符串头尾指定的字符（默认为空格）或字符序列。该方法只能删除开头或是结尾的字符，不能删除中间部分的字符(相当于执行 lstrip()和 rstrip())
print('     this is string     '.strip()) # 输出：this is string
print('889999988this is string889999988'.strip('89')) # 输出：this is string

# str.maketrans(intab, outtab)：用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标
# 两个字符串的长度必须相同，为一一对应的关系
# Python3.4 已经没有 string.maketrans() 了，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans()
print ('在字符串 just do it 中，将abcdefs对应的字符转化为1234567的结果是： ','just do it'.translate(str.maketrans('abcdefs','1234567'))) # 输出：在字符串 just do it 中，将abcdefs对应的字符转化为1234567的结果是：  ju7t 4o it
# translate(table[, delete])：根据参数table(table:翻译表是通过 maketrans() 方法转换而来)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中
print ('在字符串 just do it 中，将abcdefs对应的字符转化为1234567的结果是： ','just do it'.translate(str.maketrans('abcdefs','1234567'))) # 输出：在字符串 just do it 中，将abcdefs对应的字符转化为1234567的结果是：  ju7t 4o it
bytes_tabtrans = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')	# 制作翻译表
print ('转换为大写，并删除字母o： ',b'just do it'.translate(bytes_tabtrans, b'o')) # 输出：转换为大写，并删除字母o：  b'JUST D IT'

# max(str)：返回字符串中最大的字母
print ("最大字符: " + max('runoob')) # 输出：最大字符: u
# min(str)：返回字符串中最小的字母
print ("最小字符: " + min('runoob')) # 输出：最小字符: b

# replace(old, new[, max])：把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次
print ('将 aa 替换为 cc ，替换次数不超过3次：','aa bb aa bb aa bb aa bb'.replace("aa", "cc", 3)) # 输出：将 aa 替换为 cc ，替换次数不超过3次： cc bb cc bb cc bb aa bb

# split(str="", num=string.count(str))：通过指定分隔符(str)对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串，返回分割后的字符串列表
print ('Google#Runoob#Taobao#Facebook 用#分割俩次结果为：',"Google#Runoob#Taobao#Facebook".split('#',2)) # 输出：Google#Runoob#Taobao#Facebook 用#分割俩次结果为： ['Google', 'Runoob', 'Taobao#Facebook']

# splitlines([keepends])：按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符
print ('保留换行符：','ab c\n\nde fg\rkl\r\n'.splitlines(True)) # 输出：保留换行符：['ab c\n', '\n', 'de fg\r', 'kl\r\n']
print ('保留换行符：','ab c\n\nde fg\rkl\r\n'.splitlines()) # 输出：保留换行符：['ab c', '', 'de fg', 'kl']

# startswith(substr, beg=0,end=len(string))：检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查
print('aaa bbb ccc索引为 1~6 的子字符串否以 aa 开头：','aaa bbb ccc'.startswith('aa',1,6))    # aaa bbb ccc索引为 1~6 的子字符串否以 aa 开头： True
print('aaa bbb ccc是否以 bb 开头：','aaa bbb ccc'.startswith('bb'))    # 输出：aaa bbb ccc是否以 bb 开头： False
# endswith(suffix[, start[, end]])：判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 "start" 与 "end" 为检索字符串的开始与结束位置
print('aaa bbb ccc索引为 1~6 的子字符串否以 bb 结尾：','aaa bbb ccc'.endswith('bb',1,6))    # aaa bbb ccc索引为 1~6 的子字符串否以 bb 结尾 True
print('aaa bbb ccc是否以 cc 结尾：','aaa bbb ccc'.endswith('cc'))    # 输出：aaa bbb ccc是否以 cc 结尾： True

# expandtabs(tabsize=8)：把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8 ，tabsize指定转换字符串中的 tab 符号('\t')转为空格的字符数
print("原始字符串: " + "this is\tstring example....wow!!!")      # 输出：原始字符串: this is	string example....wow!!!
print("替换 \\t 符号: " + "this is\tstring example....wow!!!".expandtabs())     # 输出：替换 \t 符号: this is string example....wow!!!
print("使用16个空格替换 \\t 符号: " + "this is\tstring example....wow!!!".expandtabs(16))    # 输出：使用16个空格替换 \t 符号: this is         string example....wow!!!

# # decode(encoding="utf-8", errors="strict")：以指定的编码格式解码 bytes 对象，errors参数可以指定不同的错误处理方案，默认编码为 'utf-8'，该方法返回解码后的字符串
# print("UTF-8 编码：", '雄雄雄'.encode('UTF-8')) # 输出：UTF-8 编码： b'\xe5\x8d\xa2\xe9\x9b\x84'
# print("GBK 编码：", '雄雄雄'.encode('GBK')) # 输出：GBK 编码： b'\xc2\xac\xd0\xdb'
# print("UTF-8 解码：", '雄雄雄'.encode('UTF-8').decode('UTF-8','strict')) # 输出：UTF-8 解码： 雄雄雄
# print("GBK 解码：", '雄雄雄'.encode('GBK').decode('GBK','strict')) # 输出：GBK 解码： 雄雄雄

# # encode(encoding='UTF-8',errors='strict')：以指定的编码格式编码字符串了，errors参数可以指定不同的错误处理方案，该方法返回编码后的字符串，它是一个 bytes 对象
# print("UTF-8 编码：", '雄雄雄'.encode('UTF-8'))  # 输出：UTF-8 编码： b'\xe5\x8d\xa2\xe9\x9b\x84'
# print("GBK 编码：", '雄雄雄'.encode('GBK'))  # 输出：GBK 编码： b'\xc2\xac\xd0\xdb'
# print("UTF-8 解码：", '雄雄雄'.encode('UTF-8').decode('UTF-8', 'strict'))  # 输出：UTF-8 解码： 雄雄雄
# print("GBK 解码：", '雄雄雄'.encode('GBK').decode('GBK', 'strict'))  # 输出：GBK 解码： 雄雄雄

List（列表）

(1)List（列表）是Python中使用最频繁的数据类型，列表可以完成大多数集合类的数据结构实现
(2)列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）
(3)列表是写在方括号[]之间、用逗号分隔开的元素列表
(4)和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表
Python列表截取
(5)加号+是列表连接运算符，星号*是重复操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>>list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
>>>tinylist = [123, 'runoob']

>>>print (list)            # 输出完整列表
['abcd', 786, 2.23, 'runoob', 70.2]
>>>print (list[0])         # 输出列表第一个元素
abcd
>>>print (list[1:3])       # 从第二个开始输出到第三个元素
[786, 2.23]
>>>print (list[2:])        # 输出从第三个元素开始的所有元素
[2.23, 'runoob', 70.2]
>>>print (tinylist * 2)    # 输出两次列表
[123, 'runoob', 123, 'runoob']
>>>print (list + tinylist) # 连接列表
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

(6)与Python字符串不一样的是，列表中的元素是可以改变的

1
2
3
4
5
6
7
8
>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 将对应的元素值设置为 [] 
>>> a
[9, 2, 6]

(7)List内置了有很多方法，例如append()、pop()等等，这在后面会讲到

  • List写在方括号之间，元素用逗号隔开
  • 和字符串一样，list可以被索引和切片
  • List可以使用+操作符进行拼接
  • List中的元素是可以改变的

(8)Python列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引1到索引4的位置并设置为步长为`2（间隔一个位置）来截取字符串
Python列表截取
(9)如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def reverseWords(input): 
      
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ")
    print(inputWords)	# 输出：['I', 'like', 'runoob']
    # 翻转字符串
    # 假设列表 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]	# 列表逆置
    print(inputWords)
    # 重新组合字符串
    output = ' '.join(inputWords)	# 每个元素直接加个空格
      
    return output 
  
if __name__ == "__main__": 
    input = 'I like runoob'
    rw = reverseWords(input) 
    print(rw)

输出结果为：

1
2
3
['I', 'like', 'runoob']
['runoob', 'like', 'I']
runoob like I

Python列表函数&方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
# Python 列表

testlist1 = ['Google', 'Runoob', 1997, 2000, 'Runoob']
testlist2 = list('987123645')
testlist3 = ['我最', '爱学习', 'python']

# Python有6个序列的内置类型，但最常见的是列表和元组
# 序列都可以进行的操作包括索引，切片，加，乘，检查成员
print('testlist1：', testlist1)  # testlist1： ['Google', 'Runoob', 1997, 2000]
print('testlist2：', testlist2)  # testlist2： ['1', '2', '3', '4', '5', '6', '7', '8', '9']

testlist1[2] = 2001  # 更新testlist1第三个元素
print('testlist1更新后的第三个元素为 :', testlist1[2])  # testlist1更新后的第三个元素为 : 2001
del testlist1[2]  # 删除testlist1第三个元素
print('testlist1删除第三个元素后为 :', testlist1)  # testlist1删除第三个元素后为 : ['Google', 'Runoob', 2000]

# Python列表脚本操作符：列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表
print('testlist2 长度为：', len(testlist2))  # testlist2 长度为： 9
print('testlist1 和 testlist2 组合后为：',
      testlist1 + testlist2)  # testlist1 和 testlist2 组合后为： ['Google', 'Runoob', 2000, '1', '2', '3', '4', '5', '6', '7', '8', '9']
print('testlist1 重复输出3次：',
      testlist1 * 3)  # testlist1 重复输出3次： ['Google', 'Runoob', 2000, 'Google', 'Runoob', 2000, 'Google', 'Runoob', 2000]
print('3 是否在 testlist2中？', 3 in testlist2)  # 3 是否在 testlist2中？ False
# for x in testlist2:
# 	print ('testlist2迭代：',x) # testlist2迭代： 1.....

# Python列表函数&方法
# 函数
# len(list)：返回列表元素个数
print('range(5) 列表长度为：', len(range(5)))  # range(5) 列表长度为： 5
print('testlist2 列表长度为：', len(testlist2))  # testlist2 列表长度为： 9
# max(list)：返回列表元素中的最大值
# list元素全部为字符串类型(string)时，则比较的是比较的是每个字符串元素的第一个字符的 ASCII 的大小
# list元素全部为数字类型时，直接根据值的大小比较
# list元素为列表或者元组中的元素为数字类型和字符串类型混杂时，则无法比较
print('testlist2 列表最大值为：', max(testlist2))  # testlist2 列表最大值为： 9
print('testlist3 列表最大值为：', max(testlist3))  # testlist3 列表最大值为： 爱学习
# min(list)：返回列表元素中的最小值
print('testlist2 列表最大值为：', min(testlist2))  # testlist2 列表最大值为： 1
print('testlist3 列表最大值为：', min(testlist3))  # testlist3 列表最大值为： python
# list(seq)：将元组或字符串转换为列表
print('该元组列表元素为：', list((123, 'Google', 'Runoob', 'Taobao')))  # 该元组列表元素为： [123, 'Google', 'Runoob', 'Taobao']
print('range(5) 列表元素为：', list(range(5)))  # range(5) 列表元素为： [0, 1, 2, 3, 4]

# 方法
# list.append(obj)：在列表末尾添加新的对象，该方法无返回值，但是会修改原来的列表
testlist3.append('aaa')
print('testlist3 更新后为：', testlist3)  # testlist3 更新后为： ['我最', '爱学习', 'python', 'aaa']
# list.count(obj)：用于统计某个元素在列表中出现的次数
print('testlist1 中Runoob出现次数为：', testlist1.count('Runoob'))  #
# list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）,seq-元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾
# 该方法没有返回值，但会在已存在的列表中添加新的列表内容
testlist1.extend(testlist2)
print('testlist1 和 testlist2 组合后为：',
      testlist1)  # testlist1 和 testlist2 组合后为： ['Google', 'Runoob', 2000, 'Runoob', '1', '2', '3', '4', '5', '6', '7', '8', '9']
# list.index(x[, start[, end]])：从列表中找出某个值第一个匹配项的索引位置，
print('Taobao 索引值为：', ['Google', 'Runoob', 'Taobao'].index('Taobao'))  # Taobao 索引值为 2
# list.insert(index, obj)：用于将指定对象插入列表的指定位置
# 该方法没有返回值，但会在列表指定位置插入对象
testlist1.insert(1, 'Baidu')
print('testlist1 插入元素后为：',
      testlist1)  # testlist1 插入元素后为： ['Google', 'Baidu', 'Runoob', 2000, 'Runoob', '1', '2', '3', '4', '5', '6', '7', '8', '9']
# ：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值，索引值不能超过列表总长度，默认为 index=-1，删除最后一个列表值
print('testlist1 移除的元素为：', testlist1.pop(1))  # testlist1 移除的元素为： Baidu
# list.remove(obj)：移除列表中某个值的第一个匹配项
# 该方法没有返回值但是会移除列表中的某个值的第一个匹配项
testlist1.remove(2000)
print('testlist1 更新后为：',
      testlist1)  # testlist1 更新后为： ['Google', 'Runoob', 'Runoob', '1', '2', '3', '4', '5', '6', '7', '8', '9']
# list.reverse()：用于反向列表中元
# 该方法没有返回值，但是会对列表的元素进行反向排序
testlist1.reverse()
print('testlist1 反转后为：', testlist1)  #
# list.sort( key=None, reverse=False)：对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序     reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）
# 该方法没有返回值，但是会对列表的对象进行排序
testlist2.sort(reverse=True)
print('testlist2 降序排列：', testlist2)  # testlist2 降序排列： ['9', '8', '7', '6', '5', '4', '3', '2', '1']
testlist2.sort()
print('testlist2 升序排列：', testlist2)  # testlist2 升序排列： ['1', '2', '3', '4', '5', '6', '7', '8', '9']


def takeSecond(elem):  # 获取列表的第二个元素
    return elem[1]

random = [(2, 2), (3, 4), (4, 1), (1, 3)]  # 列表
random.sort(key=takeSecond)  # 指定第二个元素排序
print('排序列表：', random)  # 排序列表： [(4, 1), (2, 2), (1, 3), (3, 4)]

# list.clear()：清空列表，类似于 del a[:]
# 该方法没有返回值
testlist1.clear()
print('testlist1 列表清空后为：', testlist1)  # testlist1 列表清空后为： []
# list.copy()：用于复制列表，类似于 a[:]，返回复制后的新列表
testlist4 = testlist2.copy()
print('testlist2 后为：', testlist2)  # testlist2 后为： ['1', '2', '3', '4', '5', '6', '7', '8', '9']
print('testlist4 后为：', testlist4)  # testlist4 后为： ['1', '2', '3', '4', '5', '6', '7', '8', '9']

Tuple（元组）

(1)元组（tuple）与列表类似，不同之处在于元组的元素不能修改
(2)元组写在小括号()里，元素之间用逗号隔开
(3)元组中的元素类型也可以不相同
(4)元组与字符串类似，可以被索引且下标索引从0开始，-1为从末尾开始的位置，也可以进行截取(字符串可以看作一种特殊的元组)

1
2
3
4
5
6
7
8
9
>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11  # 修改元组元素的操作是非法的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

(5)tuple的元素不可改变，但它可以包含可变的对象，比如list列表
(6)构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则

1
2
tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

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

  • 与字符串一样，元组的元素不能修改
  • 元组也可以被索引和切片，方法一样
  • 注意构造包含 0 或 1 个元素的元组的特殊语法规则
  • 元组也可以使用+操作符进行拼接

元组运算符与内置函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# 元组与列表类似，不同之处在于元组的元素不能修改
# 元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

tup1 = ('Google', 'Runoob', 1997, 2000, 'Runoob')
print('tup1：', tup1)  # tup1： ('Google', 'Runoob', 1997, 2000, 'Runoob')
tup2 = tuple('987123645')
print('tup2：', tup2)  # tup2： ('9', '8', '7', '1', '2', '3', '6', '4', '5')
tup3 = "a", "b", "c", "d", "g", "f", "e", "h"  # 不需要括号也可以
print('tup3：', tup3)  # tup3： ('a', 'b', 'c', 'd', 'g', 'f', 'e', 'h')
tup4 = ()  # 创建空元组
print('tup4：', tup4)  # tup4： ()
tup5 = 50,  # 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
print('tup5：', tup5)  # tup5： (50,)

# 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
print('tup1 + tup2：',
      tup1 + tup2)  # tup1 + tup2： ('Google', 'Runoob', 1997, 2000, 'Runoob', '9', '8', '7', '1', '2', '3', '6', '4', '5')

# 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
print('tup3[2] is：', tup3[2])  # tup3[2] is： c
# del tup3    # 删除元组
# print(tup3) # NameError: name 'tup' is not defined

# 元组运算符：元组对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表
print('tup2 长度为：', len(tup2))  # tup2 长度为： 9
print('tup1 和 tup2 组合后为：',
      tup1 + tup2)  # tup1 和 tup2 组合后为： ('Google', 'Runoob', 1997, 2000, 'Runoob', '9', '8', '7', '1', '2', '3', '6', '4', '5')
print('tup1 重复输出3次：',
      tup1 * 3)  # tup1 重复输出3次： ('Google', 'Runoob', 1997, 2000, 'Runoob', 'Google', 'Runoob', 1997, 2000, 'Runoob', 'Google', 'Runoob', 1997, 2000, 'Runoob')
print('3 是否在 tup2中？', '3' in tup2)  # 3 是否在 tup2中？ True
for x in tup2:
    print('tup2迭代：', x)  # tup2迭代： 9.....

# 元组内置函数
# len(tuple)：计算元组元素个数
print('tup1 元素个数为：', len(tup1))  # tup1 元素个数为： 5
# max(tuple)：返回元组中元素最大值
# tuple元素全部为字符串类型(string)时，则比较的是比较的是每个字符串元素的第一个字符的 ASCII 的大小
# tuple元素全部为数字类型时，直接根据值的大小比较
# tuple元素为列表或者元组中的元素为数字类型和字符串类型混杂时，则无法比较
print('tup2 最大值为：', max(tup2))  # tup2 最大值为： 9
# min(tuple)：返回元组中元素最小值
print('tup3 最小值为：', min(tup3))  # tup3 最小值为： a
# tuple(iterable)：将可迭代系列转换为元组
print('tup2 ：', tup2)  # tup2 ： ('9', '8', '7', '1', '2', '3', '6', '4', '5')

# 关于元组是不可变的：元组的不可变指的是元组所指向的内存中的内容不可变
tup = ('r', 'u', 'n', 'o', 'o', 'b')
print('tup：',tup)	#
# tup[0] = 'g'     # 不支持修改元素，会报错：TypeError: 'tuple' object does not support item assignment
print('查看内存地址：',id(tup))	     # 查看内存地址： 2464144715208
tup = (1,2,3)   # 内存地址发生了改变
print('查看内存地址：',id(tup))	     # 查看内存地址： 2464146173240

Set（集合）

(1)集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员
(2)基本功能是进行成员关系测试和删除重复元素
(3)可以使用大括号{ }或者set()函数创建集合，注意：创建一个空集合必须用set()而不是{ }，因为{ }是用来创建一个空字典 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu', 'Google'}
print(sites)   # 输出集合，重复的元素被自动去掉

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

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print('集合a为：',a,'  集合b为：',b)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

输出结果为：

1
2
3
4
5
6
7
{'Taobao', 'Google', 'Facebook', 'Runoob', 'Zhihu', 'Baidu'}
Runoob 在集合中
集合a为： {'b', 'a', 'd', 'r', 'c'}   集合b为： {'c', 'a', 'm', 'l', 'z'}
{'b', 'r', 'd'}
{'b', 'r', 'm', 'l', 'z', 'c', 'd', 'a'}
{'c', 'a'}
{'m', 'b', 'r', 'l', 'z', 'd'}

集合的基本操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 集合（set）是一个无序的不重复元素序列


# 创建集合
set1 = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}  # 集合去重功能，去除重复的 apple ;快速判断元素是否在集合内
print('set1：', set1)  # set1： {'pear', 'apple', 'banana', 'orange'}
print('orange 在 set1 内吗？：', 'orange' in set1)  # orange 在 set1 内吗？： True
set2 = set()  # 创建空集合
print('set2：', set2)  # set2： set()

# 集合的基本操作：添加元素add()、移除元素remove()、计算集合元素个数len()、清空集合clear()、判断元素是否在集合中存在 in 
# s.add( x )：将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作，该函数没有任何返回值
set1.add(123)
print('set1：', set1)  # set1： {'orange', 123, 'banana', 'pear', 'apple'}
# s.update( x )：添加元素，且参数可以是列表，元组，字典等，该函数没有任何返回值
set1.update(['a','b','c'])
print('set1：', set1)  # set1： {'orange', 'b', 'c', 'a', 'banana', 'pear', 'apple', 123}

# s.remove( x )：将元素 x 从集合 s 中移除，如果元素不存在，则会发生KeyError错误，该函数没有任何返回值
set1.remove(123)
print('set1：', set1)  # set1： {'pear', 'orange', 'c', 'banana', 'a', 'apple', 'b'}
# s.discard( x )：移除集合中的元素，且如果元素不存在，不会发生错误，该函数没有任何返回值
set1.discard(246)
print('set1：', set1)  # set1： {'pear', 'orange', 'c', 'banana', 'a', 'apple', 'b'}
# s.pop()：对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除并返回被删除的元素
print('set1 移除的元素为：', set1.pop())  # set1 移除的元素为： banana

# len(s)：计算集合 s 元素个数
print('set1 的元素个数为：', len(set1))  # set1 的元素个数为： 6

# s.clear()：清空集合 s，该函数没有任何返回值
set1.clear()
print('set1：', set1)  # set1： set()

集合的内置方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
# 创建集合
set1 = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}  # 集合去重功能，去除重复的 apple ;快速判断元素是否在集合内
print('set1：', set1)  # set1： {'pear', 'apple', 'banana', 'orange'}
print('orange 在 set1 内吗？：', 'orange' in set1)  # orange 在 set1 内吗？： True
set2 = set()  # 创建空集合
print('set2：', set2)  # set2： set()


# 集合内置方法
# s.add( x )：将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作，该函数没有任何返回值
set1.add(123)
print('set1：', set1)  # set1： {'orange', 123, 'banana', 'pear', 'apple'}
# s.update( x )：添加元素，且参数可以是列表，元组，字典等，该函数没有任何返回值
set1.update(['a','b','c'])
print('set1：', set1)  # set1： {'orange', 'b', 'c', 'a', 'banana', 'pear', 'apple', 123}
# set.copy()：copy() 方法用于拷贝一个集合，该函数没有任何返回值
set2=set1.copy()
print('set2 拷贝 set1 为：', set2)  # 

# x.difference(y)：difference() 方法用于返回集合的差集，即返回的集合元素包含在 x 中，但不包含在 y(方法的参数)中
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
print('集合x和集合y的差集为：', x.difference(y))  # 集合x和集合y的差集为： {'banana', 'cherry'}
print('集合x和集合y的差集为：', x - y)  # 集合x和集合y的差集为： {'banana', 'cherry'}
# x.difference_update(y)：在集合x中移除两个集合中都存在的元素，该函数没有任何返回值
x.difference_update(y)
print('集合 x 为：', x)  # 集合 x 为： {'banana', 'cherry'}

# set.union(set1, set2...)：返回两个或多个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次
x = set('abracadabra')
y = set('alacazam')
print('x 和 y 的并集为：', x.union(y))  # x 和 y 的并集为： {'l', 'z', 'r', 'b', 'a', 'c', 'm', 'd'}

# set.intersection(set1, set2 ... etc)：返回两个或更多集合中都包含的元素，即交集
print('集合x和集合y的交集为：', x.intersection(y))  # 集合x和集合y的交集为： {'c', 'a'}
print('集合x和集合y的交集为：', x & y)  # 集合x和集合y的交集为： {'c', 'a'}
# set.intersection_update(set1, set2 ... etc)：在集合x中保留所有集合的交集，该函数没有任何返回值
x.intersection_update(y)
print('集合 x 为：', x)  # 集合 x 为： {'a', 'c'}

# x.symmetric_difference(y)：返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素
x = set('abracadabra')
y = set('alacazam')
print('集合x集合y中不同时存在的元素为：', x.symmetric_difference(y))  # 集合x集合y中不同时存在的元素为： {'r', 'd', 'l', 'b', 'm', 'z'}
print('集合x集合y中不同时存在的元素为：', x ^ y)  # 集合x集合y中不同时存在的元素为： {'r', 'd', 'l', 'b', 'm', 'z'}
# x.symmetric_difference_update(y)：x集合中存放不重复的元素集合，该函数没有任何返回值
x.symmetric_difference_update(y)
print('集合 x 为：', x)  # 集合 x 为： {'l', 'r', 'd', 'b', 'm', 'z'}

# x.isdisjoint(y)：用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
x = set('abracadabra')
y = set('alacazam')
print('集合x和集合y没有包含相同的元素？：', x.isdisjoint(y))  # 集合x和集合y没有包含相同的元素？： False
# x.issubset(y)：判断集合x的所有元素是否都包含在指定集合y中(集合x是否是集合y的子集)，如果是则返回 True，否则返回 False
print('集合x是否是集合y的子集？：', x.issubset(y))  # 集合x是否是集合y的子集？： False
# x.issuperset(y)：判断集合y的所有元素是否都包含在集合x中(集合y是否是集合x的子集)，如果是则返回 True，否则返回 False
print('集合x和集合y是否包含相同的元素？：', x.issuperset(y))  # 集合x和集合y是否包含相同的元素？： False

# s.remove( x )：将元素 x 从集合 s 中移除，如果元素不存在，则会发生KeyError错误，该函数没有任何返回值
set1.remove(123)
print('set1：', set1)  # set1： {'pear', 'orange', 'c', 'banana', 'a', 'apple', 'b'}
# s.discard( x )：移除集合中的元素，且如果元素不存在，不会发生错误，该函数没有任何返回值
set1.discard(246)
print('set1：', set1)  # set1： {'pear', 'orange', 'c', 'banana', 'a', 'apple', 'b'}
# s.pop()：对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除并返回被删除的元素
print('set1 移除的元素为：', set1.pop())  # set1 移除的元素为： banana
# s.clear()：清空集合 s，该函数没有任何返回值
set1.clear()
print('set1：', set1)  # set1： set()

Dictionary（字典）

(1)字典（dictionary）是Python中另一个非常有用的内置数据类型
(2)列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取
(3)字典是一种映射类型，字典用{ }标识，它是一个无序的键(key):值(value)的集合
(4)键(key)必须使用不可变类型，在同一个字典中，键(key)必须是唯一的 

1
2
3
4
5
6
7
8
9
10
11
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

输出结果为：

1
2
3
4
5
1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

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

1
2
3
4
5
6
>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

(6)字典类型也有一些内置的函数，例如clear()、keys()、values()等

  • 字典是一种映射类型，它的元素是键值对
  • 字典的关键字必须为不可变类型，且不能重复
  • 创建空字典使用{ }

字典运算符与内置函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
# 字典是另一种可变容器模型，且可存储任意类型对象
# 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
# 键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或字典

# 创建字典
dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}  # 键值对创建字典
print('dict1：', dict1)  # dict1： {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print("dict1['Name']: ", dict1['Name'], "\tdict1['Class']: ",
      dict1['Class'])  # dict1['Name']:  Runoob  dict1['Class']:  First
dict2 = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])  # 构造函数 dict() 创建字典
print('dict2：', dict2)  # dict2： {'Runoob': 1, 'Google': 2, 'Taobao': 3}
dict3 = dict(Runoob=1, Google=2, Taobao=3)  # 构造函数 dict() 创建字典
print('dict3：', dict3)  # dict2： {'Runoob': 1, 'Google': 2, 'Taobao': 3}
dict4 = {x: x ** 2 for x in (2, 4, 6)}  #
print('dict4：', dict4)  # dict4： {2: 4, 4: 16, 6: 36}
dict5 = {}  # 创建空字典
print('dict5：', dict5)  # dict4： {}

# 字典中的元素值是允许修改的，添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
dict1['Age'] = 8  # 更新 Age
dict1['School'] = "清华大学"  # 添加信息
print('dict1：', dict1)  # dict1： {'School': '清华大学', 'Name': 'Runoob', 'Age': 8, 'Class': 'First'}
# 删除字典元素
del dict1['Name']  # 删除键 'Name'
print('dict1：', dict1)  # dict1： {'School': '清华大学', 'Age': 8, 'Class': 'First'}
dict1.clear()  # 清空字典
print('dict1：', dict1)  # dict1： {}
# del dict1         # 删除字典
# print('dict1：', dict1)  		# 产生报错：NameError: name 'dict1' is not defined


# 字典内置函数&方法
# 内置函数
# len(dict)：计算字典元素个数，即键的总数
print('dict2 长度为：', len(dict2))  # dict2 长度为： 3
# str(dict)：输出字典，以可打印的字符串表示
print('dict2 为：', str(dict2))  # dict2 为： {'Taobao': 3, 'Runoob': 1, 'Google': 2}
# type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型
print('dict2 类型为：', type(dict2))  # dict2 类型为： <class 'dict'>

# 内置方法
# dict.clear()：clear() 函数用于删除字典内所有元素，该函数没有任何返回值
dict3.clear()
print('dict3 为：', str(dict3))  # dict3 为： {}
# dict.copy()：copy() 函数返回一个字典的浅复制
dict3 = dict2.copy()
print('dict3 copy dict2 后为：', dict3)  #
# 直接赋值、浅拷贝和深度拷贝解析
dic1 = {'user': 'runoob', 'num': [1, 2, 3]}
dic2 = dic1  # 浅拷贝: 引用对象
dic3 = dic1.copy()  # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
dic1['user'] = 'root'  # 修改 dic1 数据
dic1['num'].remove(1)  # 修改 dic1 数据
# dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改
print('dic1 为：', dic1)  # dic1 为： {'num': [2, 3], 'user': 'root'}
print('dic2 为：', dic2)  # dic2 为： {'num': [2, 3], 'user': 'root'}
print('dic3 为：', dic3)  # dic3 为： {'num': [2, 3], 'user': 'runoob'}

# dict.fromkeys(seq[, value])： fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值(默认为None)，该方法返回一个新字典
print('dict 为：', dict.fromkeys(('k1', 'k2', 'k3'), 'a'))  # dict 为： {'k3': 'a', 'k2': 'a', 'k1': 'a'}
# dict.get(key, default=None)：get() 函数返回指定键的值，如果值不在字典中返回默认值(默认为None)
print('dict2 的 Google 为：', dict2.get('Google'))  # dict2 的 Google 为： 2
# print('dict2 的 abc 为：', dict2['abc'])	# abc对应的值不存在，返回错误：KeyError: 'abc'
# key in dict：in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false，not in 操作符刚好相反
print('Google 在 dict2 中：', 'Google' in dict2)  # Google 在 dict2 中： True
# dict.items()：items() 方法以列表返回可遍历的(键, 值) 元组数组
print('dict2 为：', dict2.items())  #
# dict.keys()：keys() 方法返回一个可迭代对象，可以使用 list() 来转换为列表
print('dict2 的keys为：', dict2.keys())  # dict2 的keys为： dict_keys(['Runoob', 'Google', 'Taobao'])
print('dict2 的keys为：', list(dict2.keys()))  # dict2 的keys为： ['Runoob', 'Google', 'Taobao']
# dict.values()：values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值
print('dict2 的values为：', dict2.values())  # dict2 的values为： dict_values([2, 3, 1])
print('dict2 的values为：', list(dict2.values()))  # dict2 的values为： [2, 3, 1]
# dict.setdefault(key, default=None)： setdefault() 方法和 get()方法 类似, 如果键(key)不已经存在于字典中，将会添加键并将值设为默认值(default),如果 key 在 字典中，返回对应的值
print('dict2 的 Google 为：', dict2.setdefault('Google', 888))  # dict2 的 Google 为： 2
print('dict2 的 abc 为：', dict2.setdefault('abc', 666))  # dict2 的 abc 为： 666
# dict.pop(key[,default])：  pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值，如key不存在且无default只，会报错KeyError: 3
print('dict2 被删除的值为：', dict2.pop('Google', 888))  # dict2 被删除的值为： 2
print('dict2 被删除的值为：', dict2.pop('abc', 666))  # dict2 被删除的值为： 666
# dict.popitem()：popitem() 方法随机返回并删除字典中的最后一对键和值。返回一个键值对(key,value)形式，如果字典已经为空，却调用了此方法，就报出KeyError异常
print('dict4 为：', dict4)  # dict4 为： {2: 4, 4: 16, 6: 36}
print('dict4 popitem 后为：', dict4.popitem())  # dict4 popitem 后为： (2, 4)
print('dict4 为：', dict4)  # dict4 为： {4: 16, 6: 36}
# dict.update(dict2)： update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里，该方法没有任何返回值
dict1 = {'Name': 'Runoob', 'Age': 7}
dict2 = {'Age': '88', 'School': '清华大学'}
dict1.update(dict2)
print('dict1 更新后为：', dict1)  # dict1 更新后为： {'Name': 'Runoob', 'School': '清华大学', 'Age': '88'}

直接赋值、浅拷贝和深度拷贝解析

直接赋值、浅拷贝和深度拷贝解析

Python数据类型转换

(1)
(2)

函数            |     描述
--              |   :--:

int(x [,base]) | 将 x 转换为一个整数(x为字符串或数字，base为进制数，默认十进制)
float(x) | 将 x 转换到一个浮点数(x为整数或字符串)
complex(real [,imag]) | 创建一个复数(real为int, long, float或字符串，imag为int, long, float)
str(x) | 将对象 x 转换为字符串(x为object对象)
repr(x) | 将对象 x 转换为表达式字符串(x为object对象)
eval(str) | 用来计算在字符串中的有效Python字符串表达式,并返回一个对象
tuple(s) | 将序列 s 转换为一个元组(s为要转换为元组的可迭代序列)
list(s) | 将序列 s 转换为一个列表(s为要转换为列表的元组或字符串)
set(s) | 转换为可变集合(s为要转换为元组的可迭代序列)
dict(d) | 创建一个字典，d 必须是一个(key, value)元组序列
frozenset(s) | 转换为不可变集合(s为可迭代序列，比如列表、字典、元组等等)
chr(x) | 将一个整数转换为一个字符(x可以是10进制也可以是16进制的形式的整数，范围在0～255之内)
ord(x) | 将一个字符转换为它的整数值(x为字符，返回对应的ASCII数值，或者Unicode数值)
hex(x) | 将一个整数转换为一个十六进制字符串(x为10进制整数)
oct(x) | 将一个整数转换为一个八进制字符串(x为整数)
函数具体用法可参考：Python 内置函数

Python运算符优先级

(1)
(2)
运算符 | 描述
– | :–:
** | 指数 (最高优先级)
~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

  • / % // | 乘，除，求余数和取整除
    • | 加法减法

      << | 右移，左移运算符
      & | 位 ‘AND’
      ^ | | 位运算符
      <= < > >= | 比较运算符
      == != | 等于运算符
      = %= /= //= -= += = *= | 赋值运算符
      is is not | 身份运算符
      in not in | 成员运算符
      not and or | 逻辑运算符

—— 感谢您的阅读 ( ﾟ∀ﾟ) 有什么疑问可以在下方留言哦 ——
坚持原创技术分享，您的支持将鼓励我继续创作！