Python成长之路 基础篇2

基础篇2

一、模块

二、pyc文件

三、数据类型

四、列表

五、元组

六、字符串

七、字典

八、字符的转换

1、模块和pyc文件

咱们脚本上是用 python 解释器来编程，若是你从 Python 解释器退出再进入，那么你定义的全部的方法和变量就都消失了。

为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。

模块是一个包含全部你定义的函数和变量的文件，其后缀名是.py。模块能够被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

在Python中，一个.py文件就构成一个模块。一个模块中的定义能够导入（import）到另外一个模块或主模块。

好比你能够经过内置模块platform来查看你当前的操做平台信息：

1 import platform
2 s = platform.platform()
3 print(s)
4 #输出为Windows-10-10.0.15063-SP0

platform

 当你要导入某个模块时，会在Python加载路径中查找相应的模块文件，好比可使用sys模块中的sys,path属性查看查找模块文件的路径：

1 import sys
2 print(sys.path)
3 
4 #['F:\\python\\day1', 'F:\\python', 'C:\\Program Files\\Python35\\python35.zip', 'C:\\Program Files\\Python35\\DLLs', 'C:\\Program Files\\Python35\\lib', 'C:\\Program Files\\Python35', 'C:\\Program Files\\Python35\\lib\\site-packages']

View Code

python中使用import语句导入模块时，python经过三个步骤来完成这个行为。 
1：在python模块加载路径中查找相应的模块文件 
2：将模块文件编译成中间代码 
3：执行模块文件中的代码

这里面的第二步就是编译成.pyc的文件。

pyc是一种二进制文件，是由py文件通过编译后，生成的文件，是一种byte code，py文件变成pyc文件后，加载的速度有所提升，并且pyc是一种跨平台的字节码，是由python的虚拟机来执行的，这个是相似于JAVA或者.NET的虚拟机的概念。pyc的内容，是跟python的版本相关的，不一样版本编译后的pyc文件是不一样的，2.5编译的pyc文件，2.4版本的 python是没法执行的。

为何要.pyc的文件。

网上查了不少资料发现有的人说.pyc文件主要是为了避免把源代码暴露出来，同时也有人说第一次执行脚本时，会寻找是否拥有该脚本的.pyc文件。若是有了那就就直接运行，这样就会增长运行速度，若是没有就会预编译成.pyc的文件这样在下次能用到的时候他就会直接执行使之可以节约时间，那么问题就来了若是咱们修改了源文件里的内容使之改变那是否也是直接使用，不会这样的由于在你想到这个问题是别人也想到了这样，它会有一个机制验证是否被修改过，是经过检验源文件和.pyc文件的最新更新时间，若是源文件的最新更新时间在.pyc后面那么编译器就会从新编译一下。这些我只是在网上了解的有可能不对或者不是很深刻，

2、数据类型

Python 中的变量不须要声明。每一个变量在使用前都必须赋值，变量赋值之后该变量才会被建立。

在 Python 中，变量就是变量，它没有类型，咱们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

python3中有六个标准的数据类型

一、Number（数字）

二、String（字符串）

三、List（列表）

四、Tuple（元组）

五、Dictionary（字典）

六、Sets（集合）

其中Number（数字）中有int、float、bool、complex。

在Python3中只有一种整数类型int，表示长整型，Python2中长整型表示为Lang。

在Python2中当赋值的int（整数）超过了它的最大值时，会自动转换成长整型。这里我就不演示了，如今主要学python3。想知道能够去百度一下。

 

 

3、列表

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字，咱们叫作索引，一般索引的是从0开始的，索引对应位置是序列从左到右一一对应的。

序列通用的操做有索引，切片，加，乘，检查成员。

序列还内置了肯定序列的长度以及肯定最大和最小的元素的方法。

列表就是序列中的一种，拥有序列的一切操做。

列表中的元素都'[]'里面，且每一个元素之间使用英文的逗号分隔开了。

列表的一些建立：

1 list = []
2 list1 = ['name', 'age', 'salary']
3 list2 = ['name', 'teacher',]
4 print(list, list1, list2)
5 
6 #[] ['name', 'age', 'salary'] ['name', 'teacher']

View Code

上面列子能够知道咱们可以建立一个空的列表，也能够在最后一个元素后面加上逗号或不加逗号都不影响。

列表中建立列表或者元组、字典。也能够在列表中的在列表嵌套列表，理论上能够无限嵌套，可是通常只嵌套3-5个，太多会致使列表复杂化。

1 list1 = [('name', 'Tom'), 'age', {'salary':5236}, ['num', 123]]
2 print(list1)
3 
4 #[('name', 'Tom'), 'age', {'salary': 5236}, ['num', 123]]

View Code

 记住列表中的元素能够是字符串，能够是变量，bool值等。

列表利用下标索引取相应的元素

1 name = ['Tom', 'Bob', 'Jack', 'Ana']
2 print(name[1])      #经过索引取第二个元素
3 print(name[-1])     #经过索引取最后一个个元素
4   
5 #下面是上面运行的结果  
6 #Bob    
7 #Ana

View Code

上面利用下标索引取相应的元素时，记得下标索引是从0开始的因此第一元素的下标索引为0，第二个为1，以此类推。

若是下标索引为负数，取值-1对应的是列表最右边的一个元素，也就是说负数是从右边开始与元素一一对应的，也是从-1开始取值。

 

列表的切片

利用切片能够取到想要的列表中某个范围内的元素。

 1 number = [1, 2, 3, 4, 5, 6, 7, 8, 9]
 2 
 3 print(number[:])        #取全部的元素
 4 print(number[:4])       #取前面四个元素
 5 print(number[:-2])      #取第一个到倒数第三个数元素
 6 print(number[2:4])      #从第三个元素到第四个元素
 7 print(number[::2])      #设步长为2，就是从第一个元素开始，每一个一个元素取一个元素。
 8 print(number[::-1])     #改变取元素的方向，从右开始向左开始取元素，步长为1也就是
 9 print(number[3:2])
10 print(number[3:2:-1])
11 print(number[2:3:-1])
12 
13 #下面的和上面的print语句一一对应
14 #[1, 2, 3, 4, 5, 6, 7, 8, 9]
15 #[1, 2, 3, 4]
16 #[1, 2, 3, 4, 5, 6, 7]
17 #[3, 4]
18 #[1, 3, 5, 7, 9]
19 #[9, 8, 7, 6, 5, 4, 3, 2, 1]
20 #[]
21 #[4]
22 #[]

View Code

 从上面的代码能够知道咱们在切片的时候能够取三个值，以":"分隔开来最后一个值能够不取，默认为1，也就是步长值为1表示从左向右截取元素。

下面咱们对照上面的代码看看每一个值意义。如[x:y:z]

x:表明的时取得第一元素的下标位置

y:表明的是结束时的下标的位置

切片咱们能够看看下面的图示：

上图的红色数字就是切片时的下标，这样咱们就能够看出来number[1:3]返回的值就是红色数字1和3之间元素，也就是[2, 3]。

在切片时x不写是表明的是0，y不写时表明的是取值到最后。因此上面的代码中咱们能够知道

number[:]=number[0:9]

number[:4] = number[0:4]

number[1:] = number[1:9]

如今咱们说一下list[x:y:z]中的 z，这个表示步长和取值的方向。

当Z>0时，咱们是从列表的左边向右取值，也就是默认的方向。当z=2是就是隔一个元素取一个元素。以此类推

同时上面的x<y，不然取出的将是一个空的列表上面的代码中咱们也能够看到

当z<0时，咱们在列表中是从右往左取值，步长和上面同样，这个时候x>y，不然将获得的是一个空的列表。

 

列表的拼接

1 name = ['Tom', 'Bob', 'Jack', 'Ana']
2 name2 = ['Lilei', 'Hanmeimei']
3 print(name+name2)
4 
5 #下面是代码执行的结果
6 #['Tom', 'Bob', 'Jack', 'Ana', 'Lilei', 'Hanmeimei']

View Code

从上面咱们能够看出列表的拼接就是把2个列表合二为一。

 

Python列表的函数和方法

函数

一、len(list) 　　 #列表中元素的个数

二、max(list)　　#返回列表中元素的最大值

三、min(list)　　#返回列表元素中的最小值

四、list(seq)　　#把元组转换成列表，返回的是一个列表，元组seq自己没变。

 1 name = ['Tom', 'Bob', 'Jack', 'Ana']
 2 name2 = ['Lilei', 'Hanmeimei','Jack']
 3 name3 = ['Jilei', 'Lanmeimei','Hack']
 4 name4 = (1, 2, 3, 4, 5, 6)
 5 name5 = [11, 34, 55, 6]
 6 
 7 print(len(name))
 8 print(max(name2))
 9 print(min(name2))
10 print(max(name3))
11 print(min(name3))
12 print(list(name4))
13 print(name4)
14 print(max(name5))
15 print(min(name5))
16 
17 #执行的结果
18 #4
19 #Lilei
20 #Hanmeimei
21 #Lanmeimei
22 #Hack
23 #[1, 2, 3, 4, 5, 6]
24 #(1, 2, 3, 4, 5, 6)
25 #55
26 #6

View Code

上面代码能够看出这些函数的效果，在上面的代码中咱们发现去一群字符串中取最大的元素是受字母在字母表的位置界定的。通常咱们使用这个函数都是去数字的最大值。关于全字母的字符串个人代码验证中是首字母在 字母表中的位置界定的。若果错了欢迎指出或把你的看法告诉我。

 

list的一些方法

list.append(obj)　　　　#在列表的末尾添加新的对象，没有返回值，改变原来的列表。

list.count(obj)　　　　　#统计列表中某个元素出现的次数，返回列表中该元素的个数

list.extend(seq)　　　　#在列表的末端一次性追加另外一个序列中的多个值（用序列表扩展原来的列表）

上面的这个咱们后面说道使用序列来扩展原来的列表，也就是说咱们的seq能够是字符串，元组。且他没有返回值，列表list的自身改变。不像字符串拼接字符串自己都没有改变，只是拼接有返回值。

list.index(obj)　　　　#从列表中找出某个元素第一个匹配项的索引位置，匹配的顺序是从左向右，返回的是匹配的对象的索引位置，若是没有找到则抛出异常。这个在查找的后面能够添加从什么位置开始查找对象。

list.insert(index, obj)　　#在某个位置插入对象这个位置能够参考上面切片的位置理解添加到相应的位置，无返回值

list.pop(obj = list[-1])　　#移除列表中的某个元素，并返回该移除的元素。默认是最后一个元素。

list.remove(obj)　　　　#删除列表中某个值的第一个匹配项，没有返回值

list.reverse()　　　　　　#把列表中的元素反过来显示，没有返回值

list.sort([func])　　　　　#把列表进行排序,若是有func那就会按这个函数的方法排序，没有返回值

list.clear()　　　　　　　#清空列表，没有返回值，原列表变为一个空列表

list.copy()　　　　　　　#返回复制后的新列表，这个复制属于浅copy也就是他只复制第一层，当它复制列表中嵌套的列表是它只会把嵌套的列表的内存地址复制给新的列表，当修改原列表中嵌套的列表的值时，新的列表中嵌套的列表值也会改变，由于嵌套的列表的内存地址是同样的。这个copy和list[:]效果同样

 

 

4、字符串

字符串是Python中常见的数据类型。咱们使用引号（"或'）括起来建立字符串。

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

字符串也支持切片和索引取值。可是字符串是不可变的。

序列支持的操做字符串也能操做，方法与上面的同样。

在须要在字符中使用特殊字符时，python用反斜杠(\)转义字符。以下表：

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy表明的字符，例如：\o12表明换行
\xyy	十六进制数，yy表明的字符，例如：\x0a表明换行
\other	其它的字符以普通格式输出

 

Python字符串运算符

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

操做符	描述	实例
+	字符串链接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果：HelloHello
[]	经过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分	a[1:4] 输出结果 ell
in	成员运算符 - 若是字符串中包含给定的字符返回 True	H in a 输出结果 True
not in	成员运算符 - 若是字符串中不包含给定的字符返回 True	M not in a 输出结果 True
r/R	原始字符串 - 原始字符串：全部的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（能够大小写）之外，与普通字符串有着几乎彻底相同的语法。	print r'\n' prints \n 和 print R'\n'prints \n
%	格式字符串

字符串的一些方name = "my name is Alex"

print(name.capitalize()                 #首字母大写
print(name.count('a'))                  #统计'a'有多少个
print(name.center(50,'-'))              #一共打印50个字符，不够用'-'补全，name位于中间
print(name.endswith('ex'))              #查看以'ex'结尾，是则返回True，不然返回Falsh
name = "my \tname is Alex"
print(name.expandtabs(tabsize = 30))    #把name中的tab键转换成30个空格
print(name.find('name'))                #从下标0开始，查找在字符串里第一个出现的子串的下标并返回
print(name.find('name'， 1))            #从下标1开始，查找在字符串里第一个出现的子串的下标并返回
print(name.find('Name'))                #查找不到返回 -1
print(name.index('name'))               #和find同样,只是找不到会报异常
print(name.isalnum())                   #若是字符串至少有一个字符而且全部字符都是字母或数字则返 回 True,不然返回 False
print(name.isalpha())                   #若是字符串至少有一个字符而且全部字符都是字母则返回 True, 不然返回 False
print(name.isdigit())                   #若是字符串只包含数字则返回 True 不然返回 False.
print(name.islower())                   #检查字符串中的字母是否全为小写，是则返回True，不然返回False
print(name.isnumric())                  #这个和isdigit()差很少都是检验它的组成是否全为数字，这种方法是只针对unicode对象
print(name.isspace())                   #若是字符串中只包含空白，则返回 True，不然返回 False.
print(name.istitle())                   #若是字符串的每个单词的首字母都是大写则返回 True，不然返回 False，这里的单词划分是相连的字母为一个单词，若是'qweq1dad'这个就是2个单词
print(name.isupper())                   #检查字符串中的字母是否全为大写，是则返回True，不然返回False
print(name.isdecimal())                 #判断十进制的数字
print(name.isidentifier())              #判断是否是合法的变量名
print("-".join('abcdew'))               #将序列中的元素以指定的字符链接生成一个新的字符串指定的字符串是join前面的双引号能够为空或者空格
p = str.maketrans("abcdefg", "1234567") #"abcdefg"和"1234567"前面和后面的字符是一一对应的下面的字符串会把有前面的字母替换成和它对应的这个只是一个映射关系。和下面的一块儿使用
print("my name is Tom".translate(p))    #输出为my n1m5 is Tom
print(name.ljust(width[,fillchar]))     #返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。若是指定的长度小于原字符串的长度则返回原字符串，fillchar默认为空格。fillchar='-'也能够，可是这个里面只能有一个字符如fillchar='--'这个就会报错
print(name.lower())                     #转换字符穿中全部大写字符为小写
print(name.upper())                     #转换字符穿中全部小写字符为大写
print(name.lstrip())                    #截掉字符串左边的空格或指定字符
print(name.rstrip())                    #截掉字符串右边的空格或指定字符
print(name.strip())                     #截掉字符串左边和右边的空格或指定字符
print(name.replace(str1,str2[,max]))    #将字符串中的 str1 替换成 str2,若是 max 指定，则替换不超过 max 次。
print(name.rfind())                     #相似于 find()函数，不过是从右边开始查找
print(name.rindex())                    #相似于 index()，不过是从右边开始.
print(name.rjust())                     #相似于ljust，只是右对齐
print(name.split(str="", num=string.count(str)))#经过指定分隔符对字符串进行切片，若是参数num 有指定值，则仅分割num个字符串，返回的是一个字符列表
print(name.splitlines([keepends]))      #按照行('\r', '\r\n', \n')分隔，返回一个包含各行做为元素的列表，若是参数keepends为Falsh，不包含换行符。若是为True则保留换行字符
print(name.startswith(str, beg=0,end=len(string)))#检查字符串是不是以指定子字符串开头，若是是则返回 True，不然返回False，若是参数beg和end制定值，则在指定的范围内检查
print(name.swapcase())                  #将字符串中大写转换为小写，小写转换为大写
print(name.title())                     #返回"标题化"的字符串,就是说全部单词都是以大写开始，其他字母均为小写，这个界限的标准就是相连的字母第一个字母改为大写，其他的改为小写
print(name.zfill())                     #返回指定长度的字符串，原字符串右对齐，前面填充0。

 5、元组

Python中的元组和列表类似，至关于不可变的列表。

元组使用小括号，列表使用方括号。

元组的建立和列表差很少。

元组的建立要不就是空的元组，要不建立一个元素的元组时后面必须加上都好(,)，不然建立出来的为字符串

1 tuple1 = ()
2 tuple2 = ('name',)
3 tuple3 = ('name')
4 print(tuple1, tuple2, tuple3)
5 
6 
7 
8 #下面显示的就是上面运行的结果
9 #() ('name',) name

View Code

 元组也属于序列中的一种因此序列支持的操做元组也支持。方法和上面序列所操做的同样。

由于元组不支持修改，可是能够删除，元组相加咱们能够赋值给新的元组

同时元组也支持嵌套。由于元组的不可变，序列的一些操做都在这里面适用。

 

6、字典

字典是另外一种可变的容器模型，且可存储任意类型对象。字典中的键值对是无序的。

字典的每一个键值（key => value）对用冒号(:)分隔，每一对键值对之间用逗号(,)分隔。整个字典都在花括号中({})，格式如：

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

在这里面键(key)必须是惟一的，可是值（value）能够重复，由于下面的操做有的是根据键来取相应的值。

这里面的值(value)能够是任意数据类型，可是键（key）必须是不可变的，如：字符串，数字，元组。

举个列子：

d = {"name":"Tom"} .这个能够可是当咱们建立 d = {{1:2}:"Tom"}这样咱们建立它就会报错。一样咱们的key不可以为列表

若是咱们的key为列表时，咱们的字典中key是可变的。能够经过相应的操做改变其数据，这样就不符合键（key）惟一和不可变。

咱们值(value)是能够为任何的数据如字典，列表什么的。

咱们日常听到的字典嵌套字典，其实就是字典中的值(value)为字典。

 

访问字典中的值(value)：

dict = {'name':'Tom', 'age':20, 'salary':5000}

print(dict['name'])
print(dict['Name'])

#下面的是上面运行的结果与上面一一对应
#Tom
#Traceback (most recent call last):
     File "F:/python/day1/text.py", line 4, in <module>
        print(dict['Name'])
   KeyError: 'Name'

View Code

上面的代码咱们能够看到，当键(key)存在于字典时他会返回对应的值(value)，若是不存在的话他就会报错。

 

修改字典中键(key)对应的值：

1 dict = {'name':'Tom', 'age':20, 'salary':5000}
2 dict['name'] = 'Helen'
3 print(dict)
4 dict['class'] = 3
5 print(dict)
6 
7 #下面是对应上面运行结果
8 #{'salary': 5000, 'name': 'Helen', 'age': 20}
9 #{'class': 3, 'salary': 5000, 'name': 'Helen', 'age': 20}

View Code

咱们从上面的列子能够看到。当咱们修改对应键(key)的值时，若是输入的键(key)存在，那就修改对应的值。若是间不存在，那就向字典中添加这个键值对。

 

删除字典中的键值对：

 1 #!/usr/bin/env python
 2 # -*-coding:utf-8-*-
 3 d1 = {'name':'Tom', 'age':20, 'salary':5000}
 4 del d1['name']
 5 print(d1)
 6 d2= {'name':'Tom', 'age':20, 'salary':5000}
 7 d2.clear()
 8 print(d2)
 9 d3 = {'name':'Tom', 'age':20, 'salary':5000}
10 del d3
11 print(d3)
12 
13 #运行结果
14 {'age': 20, 'salary': 5000}
15 {}
16 Traceback (most recent call last):
17   File "F:/python/s1.py", line 11, in <module>
18     print(d3)
19 NameError: name 'd3' is not defined
20 
21 Process finished with exit code 1

View Code

上面我列出了删除字典中的键值。删除字典中全部的键值。和最后删除整个字典。还有一些删除的方法好比dict.pop()和dict.popitem()。dict.pop(key) 是删除该键值对而且返回删除的值。dict.popitem()是随机删除键值对以元组的方式显示。

 

下面咱们说下字典中的键(key),在字典中键是惟一的，因此通常只能用数字、字符串、元组。

若是咱们在建立字典的时候，里面同时出现2个同样的键（key），那么会之后面的为准。以下代码

1 d1 = {'name':'Tom', 'age':20, 'salary':5000 ,'name':'Helen'}
2 print(d1)
3 
4 #运行的结果
5 {'age': 20, 'name': 'Helen', 'salary': 5000}

View Code

 

字典的一些方法使用

字典的copy

 1 d1 = {'name':'Tom', 'age':20, 'salary':5000 ,'home':{'populace':3}}
 2 d2 = d1.copy()
 3 print(d1)
 4 print(d2)
 5 d1['name'] = 'Helen'
 6 d1['home']['populace'] = 5
 7 print(d1)
 8 print(d2)
 9 
10 #运行的对应的结果
11 {'salary': 5000, 'age': 20, 'name': 'Tom', 'home': {'populace': 3}}
12 {'salary': 5000, 'age': 20, 'name': 'Tom', 'home': {'populace': 3}}
13 {'salary': 5000, 'age': 20, 'name': 'Helen', 'home': {'populace': 5}}
14 {'salary': 5000, 'age': 20, 'name': 'Tom', 'home': {'populace': 5}}

View Code

与上面的结果能够看出这个copy属于浅copy，我之前也说过关于浅copy。也就是它只会复制第一层的数据，若是字典中嵌套字典那么咱们copy过来的嵌套的字典和被copy字典中的嵌套字典内存中的地址是同样的。因此改变其中一个嵌套的字典值，其余的也会改变，上面举得例子咱们嵌套的是字典，嵌套其它可变数据类型都是相同的结果。

 

fromkey()函数

 1 seq = ('name', 'age', 'sex')
 2 
 3 dict = dict.fromkeys(seq)
 4 print ("新的字典为 : {}".format(dict))
 5 
 6 dict = dict.fromkeys(seq, 10)
 7 print ("新的字典为 : {}".format(dict))
 8 
 9 
10 #运行的结果
11 新的字典为 : {'sex': None, 'name': None, 'age': None}
12 新的字典为 : {'sex': 10, 'name': 10, 'age': 10}

View Code

dict.fromkey(seq[,value])函数咱们能够看到是用来建立一个新的字典，seq做为字典的键(key)来作，value做为字典初始化的值，它无关紧要,当没有的时候会默认为空

 

dict.get(key, default=None)

 1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 }
 2 >>> d1.get('name')
 3 'Tom'
 4 >>> d1.get('home')
 5 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 }
 6 >>> print(d1.get('name'))
 7 Tom
 8 >>> print(d1.get('home'))
 9 None
10 >>> print(d1.get('home', 'aaa'))
11 aaa

View Code

从上面的代码中咱们能够知道，使用dict.get()方法查找想要键(key)对应的值比咱们上面的方法好点。

由于当咱们查找的键(key)存在时，会返回相应的值，可是当咱们查找的键(key)不存在时使用dict.get()方法，不会报错，若是设置了不存在时有相应返回的值那就会返回你设置的那个值，若是没有设置会默认为None。然而咱们前面所说到的方法会报错。因此之后使用dict.get()方法来查找相应的值。

 

key in dict

1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 }
2 >>> print('name' in d1)
3 True

View Code

这个是为了查询某个键是否在这个字典中若是存在那就返回True，不然返回Flash

dict.items()

1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 }
2 >>> print(d1.items())
3 dict_items([('age', 20), ('name', 'Tom'), ('salary', 5000)])

View Code

这个是以列表的返回可遍历的（key，value）元组数组

dict.keys()

1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 }
2 >>> print(d1.keys())
3 dict_keys(['age', 'name', 'salary'])

View Code

这个是以列表的方式返回字典中全部的键

 

dict.setdefault(key, default = None)

1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 }
2 >>> d1.setdefault('home')
3 >>> print(d1)
4 {'home': None, 'age': 20, 'name': 'Tom', 'salary': 5000}
5 >>> d1.setdefault('sex',2400)
6 2400
7 >>> print(d1)
8 {'home': None, 'sex': 2400, 'age': 20, 'name': 'Tom', 'salary': 5000}

View Code

这个函数和上面的dict.get()差很少，不过当查询的键(key)不存在时，它会自动把这个键添加到字典中，默认的值为None，能够本身给它一个值。

 

dict.update(dict2)

1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 }
2 >>> d2 = {'mom':'Kate' ,'father':'Bob'}
3 >>> d2 = {'mom':'Kate' ,'father':'Bob', 'name':'Jack'}
4 >>> print(d1.update(d2))
5 None
6 >>> print(d1)
7 {'mom': 'Kate', 'age': 20, 'name': 'Jack', 'salary': 5000, 'father': 'Bob'}

View Code

上面的代码中咱们能够知道，这个就至关于把dict2中的键值对更新到dict中，若是dict2和dict有相同的键，那么更新后的字典中相同的键会以dict2的键值为主，至关于实时更新。

dict.values()

1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 }
2 >>> print(d1.values())
3 dict_values([20, 'Tom', 5000])

View Code

这个和上面的dict.keys()同样不过他返回的列表是以字典中的值做为元素的。

 

dict.pop(key[,default])

1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 }
2 >>> print(d1.pop('name'))
3 Tom

View Code

这个 就是删除字典中的键值对，返回的是删除的键的对应的值

dict.popitem()

1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 }
2 >>> d1.popitem()
3 ('age', 20)
4 >>> print(d1)
5 {'name': 'Tom', 'salary': 5000}

View Code

在上面的实验能够看出，这个函数是随机在字典中删除键值对。并返回删除的键值对。

 

7、字符的转换

Python3中的一大新的概念就是文本和二进制的区分，不会出现两者混用的概念。想要详细理解两者之间的关系能够自行上网搜下Python3的bytes/str之别。上面有详细的介绍与解释。下面的代码就是关于两者之间的转换。

1 >>> f = '欢迎光临'
2 >>> type(f)
3 <class 'str'>
4 >>> f1 = f.encode('utf-8')
5 >>> print(type(f1),f1)
6 <class 'bytes'> b'\xe6\xac\xa2\xe8\xbf\x8e\xe5\x85\x89\xe4\xb8\xb4'
7 >>> f2 = f1.decode('utf-8')
8 >>> print(type(f2),f2)
9 <class 'str'> 欢迎光临

View Code

上面在转换时，你要告诉你如今的编码格式是什么上面的实验室以'utf-8'的格式来相互转换的。

 

说完了字符和二进制的转换，如今咱们学一个小知识。

三元运算符

三元运算符就是在赋值变量的时候能够加以判断，在直接赋值。

 1 >>> a = 5
 2 >>> b = 6
 3 >>> c = a if a>b else b 
 4 >>> print(c)
 5 6
 6 >>> if a > b :
 7 ...     c = a
 8 ... else:
 9 ...     c = b
10 ...     
11 >>> print(c)
12 6

View Code

上面的代码前面使用的三元运算符来赋值，下面的是使用的if-else判断语句

三元运算符还有一些其余的的应用如今简单介绍下赋值一方面的，同时还能够运用在列表、字典、集合上等。

这期的学习就分享到这里，若是文中有什么错误的或不完善的，但愿发现的您能够指出来让我这个小白学习学习。