Python 基础之运算符和基本数据类型

1. 运算符

1.1 结果是具体值（数字或字符串）的运算符
1.1.1 算数运算

1.1.2 赋值运算

1.2 结果是布尔值的运算符
1.2.1 比较运算

1.2.2 逻辑运算

1.2.3 成员运算

2. 基本数据类型入门
2.1 字符串
2.1.1 字符串介绍
在 python 中，字符串可以用单引号、双引号、三个单引号和三个双引号引起来。

name = "勒布朗"
name = 'iverson'
name = '''sb'''
name = """"tsb"""

2.1.2 字符串的加法

[root@learnpy ~]# vim str.py
n1 = "alex"
n2 = "tsb"
n3 = "zhang"
n4 = n1 + n2 + n3
print(n4)
[root@learnpy ~]# python3 str.py # 字符串的加法会将字符串拼接起来。 
alextsbzhang 

2.1.3 字符串的乘法

[root@learnpy ~]# vim strc.py
n1 = "zhang"
n2 = n1 * 10
print(n2) 
[root@learnpy ~]# python3 strc.py # 字符串的乘法会将字符串重复。
zhangzhangzhangzhangzhangzhangzhangzhangzhangzhang
提示：Python 中字符串只有乘法和加法，没有除法和减法。

2.2 数字

在 python 中没有用引号引起来的阿拉伯数字，例如 age = 15。
2.2.1 数字的加减乘除幂运算

a1 = 10 
a2 = 20 
a3 = a1 + a2
a4 = a2 - a1
a5 = a1 * a2 # 一个 * 表示乘法。
a6 = 10 / 4 # 除法取商（具体即 2.5）。
a6 = 10 //4 # 除法取商（即为 2）。
a7 = 4**4 # 幂运算。
a8 = 58 % 6 # 取模（取出算式的余数）。

2.2.2 有关将数字字符串转化为数字的问题

• 使用 print('字符串') 的方式只能输出字符串；
• 使用 input 等待输入，不输入永远等待，如 inp = input ('>>>') 方式输入的数字也会被认为是字符串；
• 将数字字符串转换为数字：new_inp = int(inp) 可以通过 int 整型转换。

2.3 布尔值
2.3.1 通过举例引出布尔值

name = "布莱恩特"
if "布" in name:
print('OK')
else:
print('Error')
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
OK # 执行结果为 OK。
name = "布莱恩特"
if "布恩" in name:
print('OK')
else:
print('Error')
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
Error # 布恩不是上面字符串的子序列，所以 Error。
name = "布莱恩特"
if "布恩" not in name:
print('OK')
else:
print('Error')
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
OK # 判断是否 not in 执行的结果。
判断某个东西是否在某个东西里包含，即为 in 或者 not in。
此时引出数据类型为布尔值，包含真（True）或假（False）。

2.3.2 布尔值运用示例

name = "布莱恩特"
v = "布恩" not in name
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True # 将判断条件结果赋值给 v，通过 print 得到布尔值。

3. 基本数据类型应用详解
3.1 数字（int）
3.1.1 数字（整型）的介绍
数字，用英文 int 代指，在 Python 3 里，数字无论有多大，都属于数字（int）类型。在 Python 2 里面数字（int）被称为整型，它有一个范围，超过这个指定的范围，就不属于整形（int）类型了，被称为长整型（long）。Python 3 里的所有类型个都是整型（整数类型）。
3.1.2 整型的所有功能都包含在 int 里面
可通过在 Pycharm 中输入 int，点击 Ctrl 键不放，鼠标点击 int 可以看到所有整型对应的功能。
3.1.3 整型的魔法
① int 将数字字符串转换为整型数字：

a = "123" 
print(type(a)) # 输出 a 的数据类型。
b = int(a) # 此步会将字符串“123”转换为整型数字 123。
b = b + 321 # 转换完成还可做数值运算。
print(type(b)) # 输出 b 的数据类型。
print(b)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py # 执行结果。
<class 'str'> # 此处输出了上面 a 字符串的数据类型。
<class 'int'> # 此处输出了上面 b 整型的数据类型。
444 # 此处输出了转换为整型并运算后的数字结果。
上面的数据类型和结果可以同时输出：
a = "123"
print(type(a),a)
b = int(a)
b = b + 321
print(type(b),b)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py 
<class 'str'> 123 # 数据类型和结果同时输出（字符串）。
<class 'int'> 444 # 数据类型和结果同时输出（整型）。

② bit_length() 当前数字的二进制至少用几位二进制位表示：

例如将数字转换为二进制位的位数：
age = 5
r = age.bit_length()
print(r)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
3 # 表示将整型数字 5 转换为二进制后有 3 个二进制位（即 101）。

3.2 字符串（str）

3.2.1 字符串类型介绍
字符串，用英文 str 代指。
3.2.2 字符串类型的所有功能都包含在 str 里面
可通过在 Pycharm 中输入 str，点击 Ctrl 键不放，鼠标点击 str 可以看到所有字符串类型对应的功能。
3.2.3 字符串的魔法
① capitalize() 将英文字符串的首字母改为大写：

test = "alex"
v = test.capitalize()
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
Alex # 可以看到 Alex 的名字首字母变成大写了。

② test.casefold() 和 test.lower() 将英文字符串中的大写转换为小写：

test = "aLex"
v1 = test.casefold() # 优先使用，包含很多未知的对应关系。
print(v1)
v2 = test.lower()
print(v2)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
alex
alex

③ center(self, width, fillchar=None) 设置字符串长度，并将内容居中。

test = "aLex"
v = test.center(20) # 此处的 20 代表总长度。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
aLex # 可以看到两边加了空格凑够 20 个字符。
test = "aLex"
v = test.center(20,"*") 
# 后面加 * 则会用星号填充空白位置（可有可无，不写默认为空格，只能填一个字符）。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
********aLex********
test = "alex"
v = test.ljust(20,"*") # ljust 表示将内容放在左边，用指定字符串填充其他空白位置。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
alex****************
test = "alex"
v = test.rjust(20,"*") # rjust 表示将内容放在最右边，其他位置用指定字符填充。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
****************alex

④ count(self, sub, start=None, end=None) 在指定字符串中寻找包含指定字符或子序列的个数：

test = "aLexalexer"
v = test.count("e")
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
3 # 此处的 3 表示上面字符串中含有指定字符 e 的个数为 3 个。
test = "aLexalexer"
v = test.count("ex")
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
2 # 表示在该字符串中包含指定子序列的个数为 2 个。
test = "aLexalexer"
v = test.count("ex",5)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
1 # 从第五个字符开始找指定子序列的个数为 1个。
test = "aLexalexer"
v = test.count("ex",5,6)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
0 # 在第五个和第六个字符之间找指定子序列的个数为 0。

⑤ endswith(self, suffix, start=None, end=None) 判断字符串以什么字符结尾，正确为 True，错误为 Flase：

startswith(self, suffix, start=None, end=None) 判断字符串以什么字符开头，正确为 True，错误为 Flase：
test = "alex"
v = test.endswith("a")
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
False # 判断字符串是否以 a 结尾，不是所以输出 Flase。
test = "alex"
v = test.endswith("ex")
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True # 判断字符串是否以 ex 结尾，正确所以输出 True。
test = "alex"
v = test.endswith("ex")
print(v)
v1 = test.startswith("al") # 与之对应的还有 startwith，略。
print(v1)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True
True

⑥ find(self, sub, start=None, end=None) 从开始往后找指定子序列，找到第一个获取其位置：

test = "alexalex"
v = test.find('ex')
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
2 # 表示在该字符串中的第二个字符后面找到指定子序列。
test = "alexalex"
v = test.find('ex',5,8)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
6 # 表示在大于等于 5 小于 8 的区间内寻找指定子序列的位置。

⑦ format(self, *args, **kwargs) 格式化，将一个字符串中的占位符替换为指定的值。

test = 'I am {name},my age is {age}'
v = test.format(name='alex',age=20)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
I am alex,my age is 20 
上面的也可以不指定名字将占位符（占位符从 0 开始）替换为指定值：
test = 'I am {0},my age is {1}'
v = test.format('alex',20)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
I am alex,my age is 20 
有关字典的用法：
test = 'I am {name},my age is {age}'
v1 = test.format(name='alex',age=20)
print(v1)
v2 = test.format_map({"name":'alex',"age":'20'}) # 字典，一个 KRY 对应一个值（键值对）。
print(v2)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
I am alex,my age is 20
I am alex,my age is 20

⑧ index(self, sub, start=None, end=None) 寻找字符串中的子序列，找不到就报错：【忽略、用 find】

test = "alexalex"
v = test.index('ex')
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
2 # 此处找到了子序列 ex 的位置，找不到就报错。

⑨ isalnum(self) 判断字符串是否只包含数字和字母（全是字母或数字也行），不是就 False，是就 True：

test = "dag5发5+__"
v = test.isalnum()
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
False # 可以看到上述字符串不是数字和字母的集合。
test = "dag5464" # 可以看到该字符串是数字和字母的集合。
v = test.isalnum()
print(v) 
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True # 判断出该字符串是数字字母的集合，所以输出为 True。

⑩ expandtabs(self, tabsize=8) \t 补全下面指定字符数：

test = "username\temail\tpassword\nalinuxer\[e-mail]\t123\nalinuxer\[e-mail]\t123\nalinuxer\[e-mail]\t123\n"
v = test.expandtabs(20)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
username email password
alinuxer [e-mail] 123
alinuxer [e-mail] 123
alinuxer [e-mail] 123
# 表示当遇到 \t 时不够 20 个字符就用空格补齐 20 个。

⑪ isalpha(self) 判断字符串是否是字母或汉字，是则 True，否则 False。

test = "as2df"
v = test.isalpha()
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
False

⑫ 判断字符串是否为数字：

test = "123"
v1 = test.isdecimal() # 十进制的数字【用的最多】。
v2 = test.isdigit() # 可识别诸如 ② ③ 这样的数字。
v3 = test.isnumeric() # 可识别 “二”、“四” 这样的中文数字。
print(v1,v2,v3)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True True True

⑬ isprintable(self) 判断是否存在不可显示的字符（如：\t、\n）：

test = "oiuasdfkj" # 没有不可显示的字符。
v = test.isprintable()
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True # 所以此处显示为 True。
test = "oiua\tsdfkj" # 此处存在不可显示的 \n 字符。
v = test.isprintable()
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
False # 所以此处显示为 False。

⑭ isspace(self) 判断是否全部是空格。

test = " " # 该字符串内只有两个空格。
v = test.isspace()
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True # 因为全部是空格，所以此处输出为 True。

⑮ istitle() 判断是否是标题：

test = "Return True if all cased characters in S are uppercase and there is"
v1 = test.istitle()
print(v1)
v2 = test.title()
print(v2)
v3 = v2.istitle()
print(v3)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
False # 判断是否为标题（不是每个首字母都是大写，所以 False）。
Return True If All Cased Characters In S Are Uppercase And There Is # 转换为标题。
True # 判断转换为标题的内容是否为标题（因为转换为标题了所以 True）。

⑯ join(self, iterable) 将字符串中的每一个元素按照指定分隔符进行拼接：【非常重要】

test = "你是风儿我是沙"
print(test)
t = ' ' # 此处指定空格为分隔符。
v = t.join(test)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
你是风儿我是沙
你 是 风 儿 我 是 沙
test = "你是风儿我是沙"
print(test)
v = "_".join(test) # 还可以通过此处这种方式指定下划线为分隔符进行拼接。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
你是风儿我是沙
你_是_风_儿_我_是_沙

⑰ 判断是否全部是大小写和转换为大小写

test = "Alex"
v1 = test.islower() # 判断是否全部为小写。
v2 = test.lower() # 转换为小写。
print(v1, v2)
v1 = test.isupper() # 判断是否全部为大写。
v2 = test.upper() # 转换为大写。
print(v1,v2)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
False alex
False ALEX

⑱ 默认可移除字符串两端 \t、\n 或空格字符，还可移除指定字符：

test = " alex " # 字符串两端都有一个空格。
v1 = test.lstrip() # 去除左边的空格。
print(v1)
v2 = test.rstrip() # 去除右边的空格。
print(v2)
v3 = test.strip() # 去除两边的空格。
print(v3)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
alex 
alex
alex
去掉指定字符的操作：（可去掉多个字符）
test = "xalex"
v = test.lstrip('x')
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
alex # 可以看到通过上面指定去除了左边的 ‘x’ 字符。
还可以匹配字符串中的所有内容并去除（优先最多匹配）：
test = "alex"
v = test.lstrip('bdxamklex')
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
# 此处全部被匹配去除。

⑲ maketrans 结合 translate 做对应关系替换：

v = "asidufkasd;fiuadkf;adfkjalsdjf"
m = str.maketrans("aeiou", "12345") # 对应关系为 aeiou 对应 12345。
new_v = v.translate(m) # 将字符串中的数字通过对应关系做替换。
print(new_v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
1s3d5fk1sd;f351dkf;1dfkj1lsdjf

⑳ partition 从左边匹配指定字符分割为三部分（匹配到第一个指定字符就分割）：

test = "testasdsddfg"
v = test.partition('s')
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
('te', 's', 'tasdsddfg') # 指定 ‘s’ 匹配到第一个 s 就分割为 3 部分。
rpartition 从右边匹配指定字符分割为三部分 
test = "testasdsddfg"
v = test.rpartition('s')
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
('testasd', 's', 'ddfg') # 从右边匹配到第一个指定 ‘s’ 字符分割为三份。

㉑ split rsplit 指定分割的字符将字符串分割为指定个数的部分：

test = "testasdsddfg"
v1 = test.split('s',2) # 从左边匹配两个 ‘s’ 分割。
print(v1)
v2 = test.rsplit('s',2) # 从右边匹配两个 ‘s’ 分割。
print(v2)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
['te', 'ta', 'dsddfg']
['testa', 'd', 'ddfg']

㉒ splitlines() 分割，只能根据换行分割，后面可跟 True、False 决定是否保留换行：

test = "asdfadfasdf\nasdfasdf\nadfasdf"
v = test.splitlines(False) # False 表示不保留换行。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
['asdfadfasdf', 'asdfasdf', 'adfasdf'] 
test = "asdfadfasdf\nasdfasdf\nadfasdf"
v = test.splitlines(True) # True 表示保留换行。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
['asdfadfasdf\n', 'asdfasdf\n', 'adfasdf']

㉓ startswith endswith 判断字符串是否以 xx 开头，以 xx 结尾：

test = "backend 1.1.1.1"
v1 = test.startswith('ba') # 判断是否以 ‘ba’ 开头。
print(v1)
v2 = test.endswith('a') # 判断是否以 ‘a’ 结尾。
print(v2)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True
False

㉔ swapcase 大小写转换（大写换小写，小写换大写）：

test = "aLex"
v = test.swapcase()
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
AlEX

 ㉕ 根据索引（或者说下标）获取出字符串中的某一个字符：

test = "alex"
v1 = test[0]
v2 = test[1]
v3 = test[3]
print(v1)
print(v2)
print(v3)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
a
l
x

㉖ 根据索引范围截取指定子序列或某一个字符

test = "alex"
v = test[0:1]
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
a # 可以看到获取到的是大于等于零小于一 的索引位置的字符。
test = "alex"
v = test[0:2]
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
al # 此处就表示获取大于等于零小于二的索引位置的字符。

㉗ lenth 获取当前字符串由多少个字符组成。（还可获取列表中元素的个数）

test = "alex"
v = len(test)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
4 
test = "布莱恩特"
v = len(test)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
4 # 也可获取汉字字符串中字符的个数（Python 2.7 中就不是这样了）。
通过 while 对以上功能的运用：
test = "科比布莱恩特爱打篮球"
index = 0
while index < len(test):
v = test[index]
print(v)
index += 1
print('-------end-------')
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
科
比
布
莱
恩
特
爱
打
篮
球
-------end-------
通过用 for 循环对以上功能的运用：
test = "科比布莱恩特爱打篮球"
for n in test:
print(n)
print('------end------')
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
科
比
布
莱
恩
特
爱
打
篮
球
------end------

㉘ replace 字符串中的替换：

test = "alexalexalex"
v1 = test.replace("ex",'bbb')
print(v1)
v2 = test.replace("ex",'bbb',2) # 后面的数字表示替换的个数（前几个）。
print(v2)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
albbbalbbbalbbb
albbbalbbbalex
补充理论：字符串一旦创建不可修改，一旦修改或者拼接，都会重新生成新的字符串。

㉙ 字母，数字，下划线 ： 标识符 def class

a = "def"
v = a.isidentifier()
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True

㉚ Python range 的用法及练习：获取连续或不连续的数字。
Python2 中直接创建在内容中；
python3 中只有for循环时，才一个一个创建。

v = range(100)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
range(0, 100) # 在 Python 2.7 中会输出 0，1,2,3,4，... 99。
# Python 3 中只有 for 循环或者其他需要时才会打印这些数字（节省内存开销）。.
v = range(100)
for item in v:
print(item)
# 此时会输出 0，1,2,3,4，... 99 这些数字。

帮助创建连续的数字,通过设置步长来指定不连续：

v = range(0, 100, 5)
for item in v:
print(item)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
0
5
10
15
20 # 执行结果是步长为 5 的不连续的数字。

3.2.4 字符串重点回顾：【需要记住并灵活运用】
### 7个基本魔法 ###
# join # '_'.join("asdfasdf")
# split
# find
# strip
# upper
# lower
# replace
### 4个灰魔法 ###
# len("ashflk")
# for 循环
# 索引
# 切片
### 1个深灰魔法 ###
字符串一旦创建不可修改，一旦修改或者拼接，都会重新生成新的字符串。

3.2.5 课后练习：通过 input 将用户输入的文字对应的索引打印出来：
方法一：

test = input(">>>")
print(test)
length = len(test)
print(length)
r = range(0,length)
for item in r:
print(item,test[item])
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
>>>12345 # 用户输入的内容。
12345 # 打印用户输出的内容。
5 # 用户输入的字符串长度。
0 1
1 2
2 3
3 4
4 5

方法二：

test = input(">>>")
for item in range(0,len(test)):
print(item,test[item])
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
>>>abcde
0 a
1 b
2 c
3 d
4 e

3.3 列表（list）

3.3.1 列表的介绍

列表，用中括号括起来，通过逗号分隔每个元素，列表中的元素可以是数字、字符串、列表、布尔值等所有的数据类型。
3.3.2 通过 list 类创建一个对象

li = [1,12,9,"age",["艾弗森",["19",10],"撒哈拉"],"alex"]

3.3.3 列表的常用操作

① 通过索引（下标）取出列表中的指定元素：

li = [1,12,9,"age",["艾弗森",["19",10],"撒哈拉"],"alex"]

print(li[0]) # 取出列表中的第 0 个元素。
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
1
li = [1,12,9,"age",["艾弗森",["19",10],"撒哈拉"],"alex"]
print(li[2]) # 取出列表中第二个元素。
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
9

② 通过切片取值，切片的结果也是列表： 

li = [1,12,9,"age",["艾弗森",["19",10],"撒哈拉"],"alex"]
print(li[3:5]) # 通过切片取值（大于等于三小于五），取出列表中第三和第四个元素。
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
['age', ['艾弗森', ['19', 10], '撒哈拉']]
li = [1,12,9,"age",["艾弗森",["19",10],"撒哈拉"],"alex"]
print(li[2:-1]) 
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[9, 'age', ['艾弗森', ['19', 10], '撒哈拉']]
小提示：如果 Pycharm 中的列表格式下有波浪线，执行 Code ---> Reformat Code 格式化。

③ 通过 for 循环取出列表中的各个元素：

li = [1, 12, 9, "age", ["艾弗森", ["19", 10], "撒哈拉"], "alex"]
for item in li:
print(item)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
1
12
9
age
['艾弗森', ['19', 10], '撒哈拉']
alex

④ 列表中元素的修改：

提示：对于字符串来说，一旦创建就不能修改，一旦字符串发生改变，就需要重新赋值给一个新的变量；对于列表中的元素来说，是可以修改的，因为列表中的每个元素都会标注下一个元素在内存中的位置，发生增删改查时只需要将每个元素指定下一个元素位置的信息修改为新的对应关系即可。

li = [1, 12, 9, "age", ["艾弗森", ["19", 10], "撒哈拉"], "alex"]
li[1] = 120 # 将列表中索引位置为 1 的元素改为 120。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[1, 120, 9, 'age', ['艾弗森', ['19', 10], '撒哈拉'], 'alex']

li = [1, 12, 9, "age", ["艾弗森", ["19", 10], "撒哈拉"], "alex"]
li[1] = [11,22,33,44] # 将列表中索引位置为 1 的元素改为一个列表。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[1, [11, 22, 33, 44], 9, 'age', ['艾弗森', ['19', 10], '撒哈拉'], 'alex']

⑤ 通过切片的方式修改列表中指定元素：

li = [1, 12, 9, "age", ["艾弗森", ["19", 10], "撒哈拉"], "alex"]
li [1:3] = [120,90]
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[1, 120, 90, 'age', ['艾弗森', ['19', 10], '撒哈拉'], 'alex']

⑥ 通过指定列表中的索引位置删除指定的元素：

li = [1, 12, 9, "age", ["艾弗森", ["19", 10], "撒哈拉"], "alex"]
del li[1] # 指定删除列表中索引位置为 1 的元素（即 12）。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[1, 9, 'age', ['艾弗森', ['19', 10], '撒哈拉'], 'alex']

⑦ 通过切片的方式指定列表中的元素进行删除：

li = [1, 12, 9, "age", ["艾弗森", ["19", 10], "撒哈拉"], "alex"]
del li[2:6]
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[1, 12]

⑧ 通过 in 操作判断一个元素是否在列表中：

li = [1, 12, 9, "age", ["艾弗森", ["19", 10], "撒哈拉"], "alex"]
v = 12 in li # 判断 12 是否在 li 中。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True 

li = [1, 12, 9, "age", ["艾弗森", ["19", 10], "撒哈拉"], "alex"]
v = "艾弗森" in li # 判断 “艾弗森” 是不是列表中的一个元素（False）。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
False # 原因分析：列表中的每个元素是以逗号分隔的一个整体。

⑨ 通过索引的方式取出列表中嵌套列表的某个列表中的某个元素：

li = [1, 12, 9, "age", ["艾弗森", ["19", 10], "撒哈拉"], "alex"]
v = li[4][1][0] # 嵌套索引。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
19 # 找到了嵌套列表中的某个元素。

li = [1, 12, 9, "age", ["艾弗森", ["19", 10], "撒哈拉"], "alex"]
v = li[4][1][0][1] # 嵌套索引。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
9 # 嵌套列表中某个元素是字符串，又通过索引方式迭代取出字符串中的某个字符。

⑩ 将字符串转换为列表：

s = "abcdefghijklmn"
new_li = list(s) # 将字符串中的每个字符转换为列表中的每个元素。
print(new_li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n']
补充提示：数字不是可迭代对象（不能 for 循环），所以数字不能直接转换为列表。将字符串转换为列表的本质就是通过 for 循环将字符串的每个字符转换为列表的每个元素。

⑪ 将列表通过 str(li) 的方式转换为字符串，会将整个列表转换为字符串：

li = [11,22,33,"123","alex"]
r = str(li)
print(r)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 22, 33, '123', 'alex'] # 整个列表转换为一个字符串（str() 只是将传的值加引号）。

⑫ 列表中包含数字和字符串，转换为字符串时需 for 循环一个个处理：

li = [11,22,33,"123","alex"]
s = "" # s 为空字符串。
for i in li:
s = s + str(i) # s 和 i 取出并转换成为的字符串进行拼接，成为新的字符串。
print(s)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
112233123alex # 此时列表中的所有元素转换为字符串了。

⑬ 如果列表中只包含字符串，可以通过 join 方式转换为字符串：

li = ["123","alinuxer"] # 列表中只包含字符串，可通过 join 进行转换为字符串。
v = "".join(li)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
123alinuxer

⑭ 如果列表中包含数字，通过 join 方式转换为字符串就会报错：

li = [123,"alinuxer"]
v = "".join(li)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
Traceback (most recent call last):
File "D:/pycharmfiles/first/day2/buer.py", line 250, in <module>
v = "".join(li)
TypeError: sequence item 0: expected str instance, int found
# 列表中包含数字，通过 join 转换就会报错（只能通过 for 循环）。

3.3.4 list 类中内置对象调用的方法

① append 追加，在列表的最后追加一个元素：

li = [11,22,33,44]
v = li.append(5) # 列表中追加一个元素，会直接追加到列表末尾，不能重新赋值给 v 。
print(v)
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
None # None 表示空值，因为赋值已经给了 li ，所以此处为空值。
[11, 22, 33, 44, 5] # 末尾追加新元素后的 li 列表。

li = [11,22,33,44]
li.append(5)
li.append("alex")
li.append([123,456])
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 22, 33, 44, 5, 'alex', [123, 456]] # 可追加字符串、数字、列表等。

② extend 扩展可迭代对象：

li = [11,22,33,22,44]
li.extend([9898,"不得了"]) # 将扩展的内容在内部循环 append 追加到列表的后面。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 22, 33, 22, 44, 9898, '不得了'] # 将扩展内容分别循环 append 到列表末尾。

li = [11,22,33,22,44]
li.append([9898,"不得了"])
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 22, 33, 22, 44, [9898, '不得了']] 
# 注意此处用 append 会将扩展内容视为一个整体列表追加到指定列表的末尾。

li = [11,22,33,22,44]
li.extend("不得了") # 扩展可迭代的字符串，会将字符串迭代成各个字符追加。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 22, 33, 22, 44, '不', '得', '了'] # 将字符串循环追加到列表成为各个元素。

③ clear 清空列表中的元素：

li = [11,22,33,44]
li.clear()
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[] # 可以看到通过 clear 清空后列表中没有元素了。

④ copy 浅拷贝：

li = [11,22,33,44]
v = li.copy() # 需要将拷贝内容重新赋值给一个变量。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 22, 33, 44]

⑤ count 计数，计数列表中指定元素出现的次数。

li = [11,22,33,22,44]
v = li.count(22)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
2

⑥ index 找到列表中指定元素所在的索引位置（默认从左开始，匹配到第一个就停止）：

li = [11,22,33,22,44]
v = li.index(33) 
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
2 # 可以得到指定元素 "33" 所在索引位置为 2。

li = [11,22,33,22,44]
v = li.index(22)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
1 # 得到指定元素所在索引位置为 1（左边优先，找到一个就停止并输出）。

⑦ insert 指定列表中的索引位置插入新的元素：

li = [11,22,33,22,44]
li.insert(0,99) # 在列表中索引位置为 0 处添加一个元素 "99"。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[99, 11, 22, 33, 22, 44]

⑧ pop 指定索引位置删除指定的元素：

li = [11,22,33,22,44]
v = li.pop() # 获取 pop 默认情况下删除的元素（默认删除最后一个元素）。
print(li)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 22, 33, 22] # 删除最后一个元素的列表。
44 # 获取到的被删除的最后一个元素。

li = [11,22,33,22,44]
v = li.pop(1) # 指定删除索引位置为 1 的元素。
print(li)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 33, 22, 44] # 删除索引位置指定的元素后的列表。
22 # 获取到的被索引位置指定删除的元素。

⑨ remove 指定需要删除的元素进行删除：

li = [11,22,33,22,44]
li.remove(33) # 删除该列表中指定的 "33" 元素。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 22, 22, 44] # 删除指定元素后的列表。

li = [11,22,33,22,44] 
li.remove(22) # 指定删除列表中的一个元素。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 33, 22, 44] # 可以发现只是删除了匹配到的左边优先的第一个 "22"。
删除的功能小节：pop、remove、del[0]/del(7:9)、clear(清空)。

⑩ reverse 反转，将当前列表进行倒序反转：

li = [11,22,33,22,44]
li.reverse() # 将列表中的元素倒序反转。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[44, 22, 33, 22, 11]

⑪ sort 排序，可根据后面不同的参数实现不同的排序：

li = [11,44,22,33,22]
li.sort() # 默认会将列表中的数字按照从小到大的顺序排序。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[11, 22, 22, 33, 44]

li = [11,44,22,33,22]
li.sort(reverse=True) # 此时可以通过添加 reverse=True 参数实现从大到小排序。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[44, 33, 22, 22, 11]
提示：此功能还有 cmp、key 两个参数，涉及到函数和 LAN 的表达式，见后文。

3.4 元组（tuple）

3.4.1 元祖的介绍
元组中的一级元素不可被修改，不能被增加或删除，一般写元组的时候，推荐在最后加入一个逗号。元组中可以加数字、字符串，可以嵌套列表、可以嵌套元组等等。
元组示例：tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
3.4.2 元组的常用操作
① 通过指定索引取出元组的元素：

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
v = tu[0]
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
111

② 可以通过切片取出元组的指定元素：

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
v = tu[0:2] # 取出该元组中索引位大于等于 0 小于 2 的对应的元素（前两个）。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
(111, 'alex')

③ 通过 for 循环迭代取出元组中的所有元素：【可迭代对象】

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
for item in tu:
print(item)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
111
alex
(11, 22)
[(33, 44)]
True
33
44

④ 把字符串转换成元组：

s = "asgbfxgaga"
v = tuple(s) 
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
('a', 's', 'g', 'b', 'f', 'x', 'g', 'a', 'g', 'a')

⑤ 把列表转换成元组：

li = [123,"alinuxer"]
v = tuple(li)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
(123, 'alinuxer')

⑥ 将元组转换为列表：

tu = (123,23,"alinuxer",)

v = list(tu)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
[123, 23, 'alinuxer']

⑦ 将元组中的元素转换为字符串（元祖中的元素都是字符串的时候）：

tu = ("zhang","alinuxer",)
v = "".join(tu)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
zhangalinuxer

⑧ 补充：前面列表的 extend 也可以扩展元组：

li = ["zahng","jdjg"]
li.extend((11,22,11,)) # 元组也是可迭代对象。
print(li)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
['zahng', 'jdjg', 11, 22, 11] # 将元组中的元素分别转换为列表中的元素了。

⑨ 通过嵌套索引位取出元组中指定的字符：

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
v = tu[3][0][0]
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
33

⑩ 修改元祖中的非一级元素：

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
tu[3][0] = 567
print(tu)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
(111, 'alex', (11, 22), [567], True, 33, 44)

理论知识补充：元组的一级元素不可被修改、增加、删除，上面的修改是修改了一个一级元素 [(33,44)] 中的一个列表内的一个元素 (33,44) 为 567。但是 (33,44,) 是一个元组，该元组中的 33 和 44 都不能被修改，因为它们是元组 (33,44) 中的一级元素。

3.4.3 tuple 类中内置对象调用的方法

① count 计数一个元祖中指定元素出现的次数：

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
v = tu.count(111)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
1

② index 获取元祖中某一个值对应的索引位置：

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
v = tu.index(44)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
6 # 提示：若元祖中有重复的指定元素，优先从左匹配到第一个后输出。

3.5 字典（dict）

3.5.1 字典的介绍

字典，键值对。字典是无序的。
字典的值（Value）可以是任何数据类型，包括数字、字符串、列表等。
字典的键（Key）可以是数字、字符串、布尔值、和元组，不可以是列表和字典。
（在字典中，key 是不可以重复的，因为 key 重复的情况只能保留一个）。

info = {
　　"k1":True,
　　2:123,
　　True:456,
　　False:789
}
print(info)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
{False: 789, True: 456, 'k1': True, 2: 123}
# True = 1，False = 0，建议字典中的 key 不要同时出现 01 和布尔值，默认只保留一个。 

3.5.2 书写一个字典示例

info = {
　　"k1":18,
　　"k2":True,
　　"k3": [
　　11,
　　22,
　　33,
　　]
}
print(info)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
{'k3': [11, 22, 33], 'k2': True, 'k1': 18}

3.5.3 有关字典的常用操作

① 字典是无序的，所以可通过指定 kye 获取对应的 value：

info = {
　　"k1":18,
　　2:True,
　　"k3": [
　　　　11,
　　　　22,
　　　　33,
　　]
}
v1 = info["k1"]
print(v1)
v2 = info[2]
print(v2)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
18
True

② 在该字典中获取到 "kk3" 对应的 value 中的 "11"：

info = {
　　"k1":18,
　　2:True,
　　"k3":[
　　　　11,
　　　　[],
　　　　(),
　　　　22,
　　　　33,
　　　　{
　　　　　　"kk1":"vv1",
　　　　　　"kk2":"vv2",
　　　　　　"kk3":(11,22),
　　　　}
　　],
　　"k4":(11,22,33,44)
}
v = info["k3"][5]["kk3"][0] # 此行表示获取到该字典 k3 对应的 value （是一个列表）中的索引位置为 5 的字典的 'kk3' 对应的元组中的索引位置为 0 的元素。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
11

③ 删除字典中指定的元素：

info = {
　　"k1":18,
　　2:True,
　　"k3":[
　　　　11,
　　　　[],
　　　　(),
　　　　22,
　　　　33,
　　{
　　　　"kk1":"vv1",
　　　　"kk2":"vv2",
　　　　"kk3":(11,22),
　　}
],
　　"k4":(11,22,33,44)
}
del info["k1"] # 通过 del 指定字典中的键删除指定元素。
print(info)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
{'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22), 'kk1': 'vv1'}], 2: True, 'k4': (11, 22, 33, 44)}

④ 删除指定的 "kk1":

info = {
　　"k1":18,
　　2:True,
　　"k3":[
　　　　11,
　　　　[],
　　　　(),
　　　　22,
　　　　33,
　　　　{
　　　　"kk1":"vv1",
　　　　"kk2":"vv2",
　　　　"kk3":(11,22),
　　　　}
　　],
　　"k4":(11,22,33,44)
}
del info["k3"][5]["kk1"]
print(info)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
{'k4': (11, 22, 33, 44), 2: True, 'k3': [11, [], (), 22, 33, {'kk3': (11, 22), 'kk2': 'vv2'}], 'k1': 18}

⑤ 通过 for 循环字典中的元素：【默认只输出 key】

info = {
　　"k1":18,
　　2:True,
　　"k3":[
　　　　11,
　　　　[],
　　　　(),
　　　　22,
　　　　33,
　　　　{
　　　　"kk1":"vv1",
　　　　"kk2":"vv2",
　　　　"kk3":(11,22),
　　　　}
　　],
　　"k4":(11,22,33,44)
}
for item in info:
print(item)
提示：上面的 for 循环和下面两行（.keys）效果是一样的。
for item in info.keys():
print(item)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
k4
2
k1
k3

⑥ 通过 for 循环输出所有的 values：

info = {
　　"k1":18,
　　2:True,
　　"k3":[
　　　　11,
　　　　[],
　　　　(),
　　　　22,
　　　　33,
　　　　{
　　　　　　"kk1":"vv1",
　　　　　　"kk2":"vv2",
　　　　　　"kk3":(11,22),
　　　　}
　　],
　　"k4":(11,22,33,44)
}
for item in info.values():
print(item)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
18
True
[11, [], (), 22, 33, {'kk1': 'vv1', 'kk3': (11, 22), 'kk2': 'vv2'}]
(11, 22, 33, 44)

⑦ 同时输出字典中所有的 key 和 value：

info = {
　　"k1":18,
　　2:True,
　　"k3":[
　　　　11,
　　　　[],
　　　　(),
　　　　22,
　　　　33,
　　　　{
　　　　"kk1":"vv1",
　　　　"kk2":"vv2",
　　　　"kk3":(11,22),
　　　　}
　　],
　　"k4":(11,22,33,44)
}
for item in info.keys():
print(item,info[item])
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
k3 [11, [], (), 22, 33, {'kk3': (11, 22), 'kk2': 'vv2', 'kk1': 'vv1'}]
k1 18
2 True
k4 (11, 22, 33, 44)

⑧ 通过 items 同时获取字典中的 key 和 value：

info = {
　　"k1":18,
　　2:True,
　　"k3":[
　　　　11,
　　　　[],
　　　　(),
　　　　22,
　　　　33,
　　　　{
　　　　"kk1":"vv1",
　　　　"kk2":"vv2",
　　　　"kk3":(11,22),
　　　　}
　　],
　　"k4":(11,22,33,44)
}
for k,v in info.items():
print(k,v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
2 True
k4 (11, 22, 33, 44)
k1 18
k3 [11, [], (), 22, 33, {'kk2': 'vv2', 'kk1': 'vv1', 'kk3': (11, 22)}]

3.5.4 dict 类中内置对象调用的方法
① clear 清空字典中的所有元素【略】
② copy 浅拷贝【略】
③ fromkeys（静态方法@staticmethod）dict.fromkeys 根据序列创建字典并指定统一值。 

v = dict.fromkeys(["k1",123,"999"])
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
{123: None, '999': None, 'k1': None}
# 传入一个序列，将序列中的每一个元素当做 key，value 为空。
v = dict.fromkeys(["k1",123,"999"],123)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
{123: 123, 'k1': 123, '999': 123}
# 传入一个序列和一个值，前面的序列每个元素作为 key，后面的第二个参数为 key赋值。

 

④ get 获取字典中 key 对应的 value，key 不存在返回 None，还可以指定不存在就赋值：

dic = {
"k1":"v1"
}
v = dic.get("k1")
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
v1 # 获取存在的 key 就得到对应的值。
dic = {
"k1":"v1"
}
v = dic.get("k11111")
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
None # 获取不存在的 key 就得到默认值 None。
dic = {
"k1":"v1"
}
v = dic.get("k11111",123)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
123 # 获取 key 值不存在时可以将后面传参赋值给获取的 key。 

 

⑤ pop 删除指定的 key 及对应 value并获取值。

dic = {
　　"k1":"v1",
　　"k2":"v2"
}
v = dic.pop("k1")
print(v)
print(dic)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
v1
{'k2': 'v2'}
dic = {
　　"k1":"v1",
　　"k2":"v2"
}
v = dic.pop("k1000",123) # 当要删除的 key 不存在，可赋予一个默认值。
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
123
{'k2': 'v2', 'k1': 'v1'}

⑥ popitem 随即删除【略】

⑦ 设置值，如果 key 已存在就不设置，并获取 key 对应已经存在的值。如果 key 不存在就设置值并获取新设置的 key 对应的值。

dic = {
　　"k1":"v1",
　　"k2":"v2"
}
v = dic.setdefault('k123','456')
print(dic)
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
{'k1': 'v1', 'k123': '456', 'k2': 'v2'}
456

⑧ update 更新，存在，需要更新为新的值，不存在就创建新的键值对：

dic = {
　　"k1":"v1",
　　"k2":"v2"
}
dic.update({"k1":'111111',"k5":12345})
print(dic)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
{'k1': '111111', 'k5': 12345, 'k2': 'v2'
update 另一种用法如下：将传参内容遍历为键值对并更新字典。
dic = {
　　"k1":"v1",
　　"k2":"v2"
}
dic.update(k1=123,k3=456,k5="alinuxer") # update 的另一种用法。
print(dic)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
{'k2': 'v2', 'k3': 456, 'k5': 'alinuxer', 'k1': 123}

⑨ 字典的 in 操作：

dic = {
"k1": 'v1'
}
v = "k1" in dic
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True # 判断 "k1" 这个 key 是否在字典 dic 中，存在即为 True。
dic = {
"k1": 'v1'
}
v = "v1" in dic.values()
print(v)
D:\pycharmfiles\first\venv\Scripts\python.exe D:/pycharmfiles/first/day2/buer.py
True # 通过 values() 判断 "v1" 这个 value 是否存在该字典中，存在即为 True。
字典用法小结：最重要的有 keys() 、 values() 、items() 、update() 、get()。

3.6 布尔值（bool）
布尔值有两个，分别为 True（对应 1 ），False（对应 0）；布尔值用法： bool(...) 判断括号内是真或假；需要记住的常见 False 的内容： None "" () [] {} 0 ==> False。

4. 数据类型重点整理 

4.1 数字
# int(..)
4.2 字符串
# replace/find/join/strip/startswith/split/upper/lower/format
4.3 列表
# append、extend、insert
# 索引、切片、循环
4.4 元组
# 忽略
# 索引、切片、循环 以及元素不能被修改
4.5 字典
# get/update/keys/values/items
# for,索引
4.6 布尔值
# True(1) / False(0)
# bool(...)
# None "" () [] {} 0 ==> False