1.怎么查看电脑是 32位还是64位？
右击此电脑，找到属性，点击即可
2.python解释器和编译器
python解释器：解释代码的，把python计算机语言翻译给计算机认识
编辑器：编写代码的，有自动补全以及自动提示的功能
3、#注释(不运行)
Python 支持两种类型的注释，分别是单行注释和多行注释。
(1)单行注释
从井号#开始，直到这行结束为止的所有内容都是注释。Python 解释器遇到#时，会忽略它后面的整行内容。
Python 使用井号#作为单行注释的符号，语法格式为：
# 注释内容
说明多行代码的功能时一般将注释放在代码的上一行，例如：
#使用print输出字符串
print("Hello World!")
print("C语言中文网")
print("http://c.biancheng.net/python/")
#使用 print输出数字
print(100)
print( 3 + 100 * 2)
print( (3 + 100) * 2 )
说明单行代码的功能时一般将注释放在代码的右侧，例如：
print("http://c.biancheng.net/python/") #输出Python教程的地址
print( 36.7 * 14.5 ) #输出乘积
print( 100 % 7 ) #输出余数
(2)多行注释
多行注释指的是一次性注释程序中多行的内容（包含一行）。
Python 使用三个连续的单引号'''或者三个连续的双引号"""注释多行内容，具体格式如下：
'''
使用 3 个单引号分别作为注释的开头和结尾
可以一次性注释多行内容
这里面的内容全部是注释内容
'''
或者
"""
使用 3 个双引号分别作为注释的开头和结尾
可以一次性注释多行内容
这里面的内容全部是注释内容
"""
多行注释通常用来为 Python 文件、模块、类或者函数等添加版权或者功能描述信息。
注意：（1）Python 多行注释不支持嵌套，所以下面的写法是错误的：
'''
外层注释
'''
内层注释
'''
'''
(2)不管是多行注释还是单行注释，当注释符作为字符串的一部分出现时，就不能再将它们视为注释标记，而应该看做正常代码的一部分，例如：
print('''Hello,World!''')
print("""http://c.biancheng.net/cplus/""")
print("#是单行注释的开始")
运行结果：
Hello,World!
http://c.biancheng.net/cplus/
#是单行注释的开始
对于前两行代码，Python 没有将这里的三个引号看作是多行注释，而是将它们看作字符串的开始和结束标志。
对于第 3 行代码，Python 也没有将井号看作单行注释，而是将它看作字符串的一部分。
4.\的用法
（1）\n:换行
（2）\t:制表符 #代表4个空格
（3）\r:覆盖 覆盖前面所有
（4）\b:删除 #往回删掉一个
（5）\:两个反斜线表示一个\
（6）原字符：使转义字符不起作用，写在前面，用r或R
（7）转义符
print("我的名字叫\"柚子\"")
运行结果：
我的名字叫"柚子"
就是把引号转译成字符
5.变量名限制
（1）变量名第一个字符不能是数字
（2）变量名字区分大小写，大小写字母被认为是两个不同的字符
（3）特殊关键字不能命名为变量名
6.六个标准数据类型
不可变数据（3个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3个）：List（列表）、Dictionary（字典）、Set（集合）。
1.Number（数字）
（1）支持int、float、bool
整数（int）：通常被称为是整数或整型，是正或者负数，不带小数点
浮点数（float）:浮点型由整数部分与小数部分组成
布尔型（bool）:True #真 False #假
Ture代表1，False代表0
（2）数值运算
加、减、乘、除 + - * /
除数取整// #向下取整
除数取余数 %
求m的n次幂 m**n （式中m和n均为数字）
等于 == 不等于！= 大于> 小于< 大于等于>= 小于等于<=
（3）逻辑运算符
and（且 两边都要正确）
or（一个对就是对）
not（反面）
PS：数字和符号之间通常会有一个空格
（4）空值None
None 什么都没有 单独存在的数据类型
内置函数的返回值 None
函数运行之后是可以有返回值的（在于我们自己的设置）
2.String（字符串）
一、切片
（1）字符串索引下标由0开始（从前往后）
s = '学习Python'
print(s[1])
运行结果：习
（2）从后往前直接就是“-1”
s = "学习Python"
print(s[-1])
运行结果：n
(3)切片[开始:结尾]取左不取右
[ : ]切片的是整个字符串
[ :3]取值范围的下标是[0,3)
[3:]取值范围的下标是[3:结尾]
name = "小仙女长相甜美并且温柔"
print(name[0:3])
print(name[:])
print(name[:3])
print(name[3:])
运行结果：
小仙女
小仙女长相甜美并且温柔
小仙女
长相甜美并且温柔
（4）如果从后往前取值要注意顺序,如[-3,-1],而不能反着写
取值范围是[倒数第3个：倒数第1个)
name = "小仙女长相甜美并且温柔"
print(name[-3:-1])
运行结果：且温
（5）切片[开始:结尾:步长] 取左不取右
如：[0:6:2] 从0开始，步长为2，下一步就是0+2=2，下一步是2+2=4
name = "小仙女长相甜美并且温柔"
print(name[0:6:1])
print(name[0:6:2])
print(name[0:6:3])
运行结果：
小仙女长相甜
小女相
小长
如：[-6:-1,2]从倒数第6个到倒数第1个，步长为2
print(name[-6:-1:1])
print(name[-6:-1:2])
运行结果：
甜美并且温
甜并温
（6）[::-1]反转字符串
print(name[::-1])
运行结果：
柔温且并美甜相长女仙小
二、字符串
（1）字符串拼接 “+”
a = '100'+'50'
print(a)
b = "我的名字叫做柚柚"
c = "我的工作是python技术教学"
d = "我很高兴来到这里给你们教学"
f = ",".join((b, c, d))
print(f)
运行结果：
10050
我的名字叫做柚柚,我的工作是python技术教学,我很高兴来到这里给你们教学
（2）字符串格式化format()函数
s2 = "大家好，我的名字叫{}，今年{}岁，性别{}".format("逍遥", 18,"男")
print(s2)
运行结果：
大家好，我的名字叫逍遥，今年18岁，性别男
s3 = "大家好，我的名字叫{}，今年{}岁，性别{}"
print(s3.format("柚柚", 18, "女"))
运行结果：
大家好，我的名字叫柚柚，今年18岁，性别女
s3 = "大家好，我的名字叫{1}，今年{0}岁，性别{2}"
print(s3.format("柚柚", 18, "女"))
运行结果：
大家好，我的名字叫18，今年柚柚岁，性别女
(3)字符串的常用方法
<1>find()函数：查找元素位置
如果查找的字符串存在多个，查找结果是第一个出现的字符串的下标，找不到返回-1。
s1 = "pythonyouyou"
print(s1.find("o"))
运行结果：4
在6到11中寻找
s1 = "pythonyouyou"
print(s1.find("o", 6, 11))
运行结果：7
<2>count()函数 ：统计字符串片段，在字符串中出现的次数，找不到返回0。
s1 = "pythonyouyou"
print(s1.count("o"))
运行结果：3
<3>replace:替换指定的字符串片段
参数1：要替换的字符串片段
参数2：替换之后的字符串片段
参数3：替换的次数，从前往后替换（默认替换所有的）
s1 = "python to youyou"
res = s1.replace('o', 'TT')
print(res)
运行结果：pythTTn tTT yTTuyTTu
s1 = "python to youyou"
res = s1.replace('o', 'TT', 2)
print(res)
运行结果：pythTTn tTT youyou
<4>upper:将小写字母转换为大写
lower：将大写字母转换为小写
s1 = "python to youyou"
res2 = s1.upper()
print(res2)
运行结果：
PYTHON TO YOUYOU
res2 = PYTHON TO YOUYOU
res3 = res2.lower()
print(res3)
运行结果：
python to youyou
<5>split:指定分割点对字符串进行分割
参数1：分割点
参数2：分割的次数（默认找到所有的分割点进行分割）
s1 = "111ab222ab333ab4444"
#将字符串，用规定的字符"a"进行分割，得到一个列表
print(s1.split('a'))
运行结果：
['111', 'b222', 'b333', 'b4444']
s1 = "111ab222ab333ab4444"
#将字符串，用规定的字符"a"进行分割2次，得到一个列表
print(s1.split('a', 2))
运行结果：
['111', 'b222', 'b333ab4444']
<6>strip:去掉字符串首尾的空格
s2 = ' python：666'
print(s2.strip()) #去除字符串的首尾空格
运行结果：
python：666
s3 = '666666python66666'
print(s3.strip('6'))
运行结果：
python
s4 = ' python:6666 youyou :77777 '
print(s4.strip())
运行结果：
python:6666 youyou :77777
（只是去除首尾的空格，中间不会去除）
如果想要去除中间的空格，可以用replace
s4 = ' python:6666 youyou :77777 '
print(s4.replace(' ', ''))
运行结果：
python:6666youyou:77777
<7>传统的格式化输出&F表达式
传统的格式化输出方法：%
%s:为字符占位，任意类型都行
%d:为字符占位，任意类型都可以
%f:为浮点数占位
s1 = '我%s你'%('爱')
print(s1)
运行结果：我爱你
s2 = '我的成绩是%d'%(99.99)
print(s2)
运行结果：我的成绩是99
s3 = '我的零花钱是%f'%(99.99)
print(s3)
运行结果：我的零花钱是99.990000
<8>F表达式（F、f都一样，python3.6以上支持）
name = '柚子'
age = 18
s3 = F"我的名字{name},年龄{age}"
print(s3)
运行结果：我的名字柚子,年龄18
<9>len()
len():字符串的长度
s = 'python'
print(len(s))
s1 = 'pyth on'
print(len(s1))
运行结果：
6
8
<10>format：格式化输出（进阶）
1、格式化小数长度（会四舍五入） :.2f
s = 3.6567
print("今天的橘子{:.2f}一斤".format(s))
运行结果：今天的橘子3.66一斤
s = 3.6567
x = 5.6567
print("今天的橘子{:.2f}一斤".format(s, x))
print("今天的橘子{1:.2f}一斤".format(s, x))
运行结果:
今天的橘子3.66一斤
今天的橘子5.66一斤
2、将小数按百分比的形式显示 :.2%
print("百分比为{:.2%}".format(0.23455))
运行结果：百分比为23.46%
3.list(列表)
（1）定义列表
（2）列表的下标（从0开始）
（3）列表的取值
list = [1, 2, 3, 4, "我爱你", [10, 20, 30]]
print(list[4])
print(list[5][0])
运行结果：
我爱你
10
（4）列表的长度和更新列表
list_1 = [10, 20, 30, 40, 50]
print(len(list_1))
运行结果：5
list_1 = [10, 20, 30, 40, 50]
list_1[2] = 99
print(list_1)
运行结果：
[10, 20, 99, 40, 50]
（5）列表的加法和乘法操作
list_1 = [10, 20, 30]
list_2 = [5, 6, 7]
print(list_1 + list_2)
print(list_1 * 3)
print("我爱你" * 5)
运行结果：
[10, 20, 30, 5, 6, 7]
[10, 20, 30, 10, 20, 30, 10, 20, 30]
我爱你我爱你我爱你我爱你我爱你
（6）列表的切片取值
(同字符串)
<1>从0开始，取左不取右
list_1 = [10, 20, 30, 40, 50, 60, 70, 80]
print(list_1[0:3])
运行结果：
[10, 20, 30]
<2>从后往前取
list_1 = [10, 20, 30, 40, 50, 60, 70, 80]
print(list_1[-3:-1])
print(list_1[-3:])
运行结果：
[60, 70]
[60, 70, 80]
<3>步长
list_1 = [10, 20, 30, 40, 50, 60, 70, 80]
print(list_1[1:6])
print(list_1[1:6:2])
运行结果：
[20, 30, 40, 50, 60]
[20, 40, 60]
list_1 = [10, 20, 30, 40, 50, 60, 70, 80]
print(list_1[-6:-1])
print(list_1[-6:-1:3])
运行结果：
[30, 40, 50, 60, 70]
[30, 60]
<4>反向
list_1 = [10, 20, 30, 40, 50, 60, 70, 80]
print(list_1[::-1])
运行结果：
[80, 70, 60, 50, 40, 30, 20, 10]
（7）列表的操作方法
<1>del关键字 删除
a = [1, 2, 3]
del a #在计算机（内存）当中，a变量定义列表删除
print(a)
运行结果：
NameError: name 'a' is not defined
a = [1, 2, 3]
del a[0] #删除列表中指定的值
print(a)
运行结果：
[2, 3]
<2>append方法 append函数用于向列表末尾添加元素
a = [1, 2, 3]
a.append(4) #不能直接print（a.append(4)）
print(a)
运行结果：[1, 2, 3, 4]
<3>insert方法
insert函数用于向列表中插入元素
insert函数的第一个参数是插入的位置，第二个参数是要插入的对象
list_1 = [20, 30, 40, 50]
list_1.insert(2, [1, 2, 3])
print(list_1)
运行结果：[20, 30, [1, 2, 3], 40, 50]
<4>clear函数用于将列表清空
list_1 = [20, 30, 40, 50]
list_1.clear()
print(list_1)
print(len(list_1))
运行结果：
[]
0
<5>remove函数
remove函数用于从列表移除元素
注意：（执行结果如下，可以看到，若列表中有重复元素，remove函数只会移除匹配到的第一个）
a = ["hello", "world", "python", "hello"]
a.remove("hello")
print(a)
运行结果：
['world', 'python', 'hello']
<6>pop函数
pop函数用于移除列表中指定位置的元素，并返回要移除的元素，在默认的情况下，移除列表中最后一个元素
a = ["hello", "world", "python", "hello"]
a.pop(3)
print(a)
运行结果：['hello', 'world', 'python']
a = ["hello", "world", "python", "hello"]
print("要移除的数据：",a.pop(3))
print("已经更改后的列表：",a)
运行结果：
要移除的数据： hello
已经更改后的列表： ['hello', 'world', 'python']
<7>index函数
index函数用于返回所匹配的元素的索引。该函数的第一个参数是待查找的对象，第二个参数是查找的起始范围，第三个参数是查找的结束范围
a = ["hello", "world", "python", "hello"]
r = a.index('hello')
print(r)
r2 = a.index('hello', 1)
print(r2)
运行结果：
0
3
<8>reverse函数
reverse函数用于数列表反向排列
a = ["hello", "world", "hello", "python"]
a.reverse()
print(a)
运行结果：
['python', 'hello', 'world', 'hello']
方法二：
print(a[::-1])
<9>extend方法
extend函数用于在列表的末尾添加另一个列表
与append函数相比，extend函数可以一次性添加多个元素
注意：（使用extend函数与列表加法的结果是一样的，但extend函数会将另一个列表并入当前列表，而列表加法是返回新列表，为节约内存空间。更推荐使用extend函数来实现大列表的连接操作）
a = [10, 20, 30]
a.extend([1, 2,3])
print(a)
运行结果：[10, 20, 30, 1, 2, 3]
与append的区别：
a.append([1, 2, 3])
print(a)
运行结果：[10, 20, 30, [1, 2, 3]]
a = [10, 20, 30]
b = [1, 2, 3]
c = a + b
print(c)
运行结果：[10, 20, 30, 1, 2, 3]
<10>copy函数
copy函数用于创建列表的副本
a = ["hello", "world", "hello", "python"]
b = a.copy()
del a[0]
print('删除a[0]元素之后，输出b列表：',b)
运行结果：
删除a[0]元素之后，输出b列表： ['hello', 'world', 'hello', 'python']
用copy函数与赋值的区别：
a = ["hello", "world", "hello", "python"]
b = a
del a[0]
print('删除a[0]元素之后，输出b列表：',b)
运行结果：删除a[0]元素之后，输出b列表： ['world', 'hello', 'python']
<11>sort()函数
sort函数用于将列表进行排序
ASCII码科普
常见ASCII码的大小规则：09<AZ<a~z
a = ["hello", "world", "hello", "python"]
a.sort()
print(a)
运行结果：['hello', 'hello', 'python', 'world']
a = ["hello", "我", "world", "hw", "python"]
a.sort()
print(a)
运行结果：['hello', 'hw', 'python', 'world', '我']
a.同类型才能排序
b = [1,2,3,5,2,4,1,"我"]
b.sort()
print(b)
运行结果：TypeError: '<' not supported between instances of 'str' and 'int'
b.正常默认是升序，降序.sort(reverse= =True)
b = [1,2,3,5,2,4,1]
b.sort(reverse=True)
print(b)
运行结果:[5, 4, 3, 2, 2, 1, 1]
<12>count函数
count函数用于统计某个元素在列表中出现的次数
a = ["hello", "我", "world", "hello", "python"]
r = a.count("hello")
print(r)
r1 = a.count("ta")
print(r1)
运行结果：
2
0
4.Tuple（元组）
（1）元组也是一种数据容器，使用小括号“（）”表示，其使用场景与列表相类似，这意味着能使用列表的地方，基本上都能使用元组，包括元组推导式、切片等操作。元组与列表的唯一区别是元组不可变的。
（2）元组的元素类型可以不统一
t = ("hello", 66, -20, 3.36, [10, 20, 30])
print(t)
print(t[1])
print(t[1:4])
print(t[1:4:2])
运行结果：
('hello', 66, -20, 3.36, [10, 20, 30])
66
(66, -20, 3.36)
(66, 3.36)
（3）元组的加法以及元组中列表的数据更新
t1 = ("hello", "world", "python")
t2 = ([1,2], [3, 4], [5, 6, 7, 8])
t3 = t1 + t2
t3[3][0] = "加油"
print(t3)
运行结果：
('hello', 'world', 'python', ['加油', 2], [3, 4], [5, 6, 7, 8])
（4）关于元组/列表/字符串的一些共同操作
len()
max()
min()
元组：
a = (1, 2, 3, 4)
print(len(a))
print(max(a))
print(min(a))
运行结果：
4
4
1
列表：
b = [10, 20, 30, 40]
print(len(b))
print(max(b))
print(min(b))
运行结果：
4
40
10
字符串：
c = "123456我abcABC"
print(len(c))
print(max(c))
print(min(c))
运行结果：
13
我
1
（5）元组的注意事项以及乘号的使用
不写（）定义元组也是ok的
元组里面只有一条数据，后面必须写上“，”，才代表是元组
a = (1, 2, 3, 4)
b = 10,20,30 #不写（）定义元组也是ok的
c = (10,) #元组里面只有一条数据，后面必须写上“，”，才代表是元组
d = （10）
print(a)
print(b)
print(c)
print(d)
运行结果：
(1, 2, 3, 4)
(10, 20, 30)
(10,)
10
d = (20,)
print(d*10)
运行结果：
(20, 20, 20, 20, 20, 20, 20, 20, 20, 20)
5.set(集合)
集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中元素去重，集合中默认去重
(1)创建集合
<1>变量名=set(元素) 字符串/列表/元组/字典
<2>变量名 = {元素，元素，，，} 元组/字符串/数字
<3> 元素是唯一的，用于列表的去重
#字符串
a = set("1234")
print(a)
运行结果：{'4', '3', '1', '2'}
#列表
b = set([10, 20, 30])
print(b)
运行结果：{10, 20, 30}
#元组
c = set((1,2,3,4))
print(c)
运行结果：
{1, 2, 3, 4}
#字典
d={
"年龄":18,
"名字":"柚子"
}
f = set(d)
print(f)
运行结果：{'年龄', '名字'}
#用大括号创建集合
aa = {1, 2, 3, (1, 2, 3),"123"} #字典/列表 用大括号的时候是不可行的
print(aa)
运行结果：{1, 2, 3, (1, 2, 3), '123'}
#列表的去重
a = set([1,2,1,3,2,4,5])
print(a)
运行结果：{1, 2, 3, 4, 5}
#元组的去重
b = set((1,1,2,3,2))
print(b)
运行结果：{1, 2, 3}
#字典的去重
cc = {
"名字":"柚子","名字":"柚子"
}
print(cc)
dd = {
"名字":"柚子","名字":"花花"
}
print(dd)
运行结果：
{'名字': '柚子'}
{'名字': '花花'}
#字符串的去重
zz = set("123123123")
print(zz)
运行结果:{'2', '3', '1'}
（2）集合添加元素的方法
add() 往集合中添加元素 数字/字符串/元组
a = {1,2,3}
a.add(6)
print(a)
a.add("柚子")
print(a)
运行结果：
{1, 2, 3, 6}
{1, 2, 3, '柚子', 6}
（3）合并集合
update可以将集合合并
a = {1,2,3}
b = {'w','b'}
a.update(b)
print(a)
运行结果：{1, 2, 3, 'w', 'b'}
注意：集合排序，随机排列
（4）集合删除元素
<1>remove
使用remove删除集合中的元素
如果有直接删除
a = {"python", "学", "柚子"}
a.remove("python")
print(a)
运行结果：{'柚子', '学'}
如果没有程序报错
a = {"python", "学", "柚子"}
a.remove("123")
print(a)
运行结果：KeyError: '123'
<2>pop
使用pop 删除是随机删除集合中的元素 如果集合没有元素程序报错
a = {"python", "学", "柚子"}
a.pop()
print(a)
运行结果：{'python', '学'}
<3>discard
使用discard删除
如果元素存在直接删除
a = {"python", "学", "柚子"}
a.discard("学")
print(a)
运行结果：{'python', '柚子'}
如果元素不存在不做任何操作
a = {"python", "学", "柚子"}
a.discard("123")
print(a)
运行结果：{'柚子', '学', 'python'}
（5）集合的交集和并集
<1>交集：使用"&"符号连接多个集合，得到相同的元素
<2>并集：使用"|"符号连接多个集合，得到集合中的全部数据
s1 = {1, 2, 3, 4}
s2 = {1, 2, 6, 7}
s3 = s1 & s2
s4 = s1|s2
print(s3)
print(s4)
运行结果：
{1, 2, 3, 4, 6, 7}
6.字典
字典是一种映射类型，它的元素是键值对，字典的键必须为不可变类型，且不能重复（键重复会保留后面的那个），键可以是任意不可变类型（元组/字符串/数字）
（1）字典的创建方式
<1>直接使用“{}”
a = {
"姓名":"柚子",
1:18,
(1,2,3):"123"
}
print(a)
运行结果：{'姓名': '柚子', 1: 18, (1, 2, 3): '123'}
<2>使用dict()
b = dict((["年龄",18],["名字","柚子"]))
print(b)
运行结果：{'年龄': 18, '名字': '柚子'}
（2）空字典
直接写{}，表达的是字典
c={}
表达空集合，用set()
d=set()
(3)字典的增删改查
<1>增加
d = {"名字":"慕洲", "年龄":18}
d["技能"] = "python技能" #字典 增加操作
print(d)
运行结果：{'名字': '慕洲', '年龄': 18, '技能': 'python技能'}
<2>删除
d = {"名字":"慕洲", "年龄":18}
d["技能"] = "python技能" #字典 增加操作
del d["技能"] # 字典的删除操作 del关键字
print(d)
运行结果：{'名字': '慕洲', '年龄': 18}
<3>修改
d = {"名字":"慕洲", "年龄":18}
d["技能"] = "python技能" #字典 增加操作
del d["技能"] # 字典的删除操作 del关键字
d["名字"] ='小明' #字典的修改操作
print(d)
运行结果：{'名字': '小明', '年龄': 18}
<4>查找
d = {"名字":"慕洲", "年龄":18}
d["技能"] = "python技能" #字典 增加操作
del d["技能"] # 字典的删除操作 del关键字
d["名字"] ='小明' #字典的修改操作
print(d["年龄"]) #查找
运行结果：18
（4）字典的操作方法
<1>get函数
get函数用于从字典获取指定键的值。在get函数中可以设置默认值，当get函数没有获取到对应键时，get函数会将默认值返回
d = {"名字":"柚子", "年龄":18}
r = d.get("名字")
print(r)
运行结果:柚子
d = {"名字":"柚子", "年龄":18}
r = d.get("技能")
print(r)
运行结果：None
d = {"名字":"柚子", "年龄":18}
r = d.get("技能","python技能") #如果没有返回默认值
print(r)
print(d) #原来的字典并不会改变
运行结果：
python技能
{'名字': '柚子', '年龄': 18}
<2>keys函数
keys函数将以列表的形式返回字典中的所有键
d = {
"名字":"柚子",
"年龄":18,
"技能":{
"技能1":"python",
"技能2":"java"
}
}
print(d.keys())
运行结果：
dict_keys(['名字', '年龄', '技能'])
<3>items函数
items函数将以列表的形式返回字典中的所有键值对
d = {
"名字":"柚子",
"年龄":18,
"技能": {
"技能1": "python",
"技能2": "java"
}
}
r = d.items()
print(r)
运行结果：
dict_items([('名字', '柚子'), ('年龄', 18), ('技能', {'技能1': 'python', '技能2': 'java'})])
<4>values
values函数将以列表的形式返回字典中的所有值
d = {
"名字":"柚子",
"年龄":18,
"技能": {
"技能1": "python",
"技能2": "java"
}
}
r1 = d.values()
print(r1)
运行结果：
dict_values(['柚子', 18, {'技能1': 'python', '技能2': 'java'}])
<5>clear函数
clear函数用于将字典清空
d = {
"名字":"柚子",
"年龄":18,
"技能": {
"技能1": "python",
"技能2": "java"
}
}
d.clear()
print(len(d))
运行结果：0
<6>copy函数
copy函数用于创建字典的副本，修改原字典对象，不会影响其副本
d = {
"名字":"柚子",
"年龄":18,
"技能": {
"技能1": "python",
"技能2": "java"
}
}
d1 = d.copy()
del d["名字"]
print(d)
print(d1)
运行结果：
{'年龄': 18, '技能': {'技能1': 'python', '技能2': 'java'}}
{'名字': '柚子', '年龄': 18, '技能': {'技能1': 'python', '技能2': 'java'}}
<7>fromkeys函数
fromkeys函数用于创建一个新的字典
第一个参数是一个序列（列表/元组/集合），用于作为字典的键
第二个参数可以是任何数据类型，作为每个键的值
d = {}
d1 = d.fromkeys(("名字","年龄"),(1,2))
print(d1)
运行结果：{'名字': (1, 2), '年龄': (1, 2)}
<8>pop函数
pop函数用于从字典中移除指定键，并返回改键所对应的值
d = {
"名字":"柚子",
"年龄":18
}
r = d.pop("名字")
print(d)
print(r)
运行结果：
{'年龄': 18}
柚子
<9>popitem函数
popitem函数用于从字典中删除最后一项，并以元组形式返回该项所对应的键和值
d = {
"名字":"柚子",
"年龄":18
}
r = d.popitem()
print(r)
print(d)
运行结果：
('年龄', 18)
{'名字': '柚子'}
<10>setdefault函数
setdefault函数用于设置键的默认值
若在字典中该键已经存在，则忽略设置；若不存在，则添加该键和值
d.setdefault(键,值)
d = {
"名字":"柚子",
"年龄":18
}
d.setdefault("技能","python技能")
print(d)
运行结果：{'名字': '柚子', '年龄': 18, '技能': 'python技能'}
d = {
"名字":"柚子",
"年龄":18
}
d.setdefault("名字","小明")
print(d)
运行结果：
{'名字': '柚子', '年龄': 18}
<11>update函数
update函数用于将字典2的值更新到字典1
若字典2的键在字典1已经存在，则对字典1进行修改
d1 = {
"名字":"柚子"
}
d2 = {
"名字":"刘亦菲"
}
d1.update(d2)
print(d1)
运行结果：{'名字': '刘亦菲'}
若不存在，则对字典1进行添加
d1 = {
"名字":"柚子"
}
d2 = {
"年龄":"18"
}
d1.update(d2)
print(d1)
运行结果：{'名字': '柚子', '年龄': '18'}
网友评论