python学习第二天

一、模块初始

• 定义：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。简单点说：一个py文件就是一个模块。
• 分类：
• 内置模块：python解释器自带的。
• 自定义模块：自己写的模块
• 拓展模块：别人写的，安装后可以使用的
• 导入条件：
  1. 模块名必须符合变量名规范；
  2. 模块所在的位置必须在sys.path模块搜索路径里。　　
• 导入步骤：
  • 导入一个模块的时候，首先创建一个属于自己的内存空间。
  • 加载模块中的所有代码；
  • 将模块中的所有变量和方法存入命名空间里。
• 模块导入顺序
  • 先内置模块，其次扩展模块，最后自定义模块。
• 模块导入的命名空间
  • 1. 导入的名字属于全局空间，但是依然指向模块的名字所在的内存空间。
    2. 导入的名字如果是函数或者方法，引用了全局变量。
    3. 导入的名字跟全局变量中的名字不冲突。类似于重新赋值
    4. 尽管导入的名字属于全局变量，但是引用变量取值时仍然从模块中取值。　　
    5. import* 默认会把所有模块中所有的名字都导入到去全局。可以在模块中用__all__ = [ "a","b"]控制导入项　　　　　　　　　　
• From......import......
• 对比import my_module，会将源文件的名称空间'my_module'带到当前名称空间中，使用时必须是my_module.名字的方式.
• 而from 语句相当于import，也会创建新的名称空间，但是将my_module中的名字直接导入到当前的全局名称空间中，在当前名称空间中，直接使用名字就可以了。
• import导入的变量或者方法虽然都属于导入文件的全局命名空间，但是函数方法需要变量时还是从原模块调用。

二、pyc 是什么

1. Python是一门解释型语言？

Python是一门解释性语言，我就这样一直相信下去，直到发现了*.pyc文件的存在。

如果是解释型语言，那么生成的*.pyc文件是什么呢？c应该是compiled的缩写才对啊！

为了防止其他学习Python的人也被这句话误解，那么我们就在文中来澄清下这个问题，并且把一些基础概念给理清。

  

2. 解释型语言和编译型语言 

计算机是不能够识别高级语言的，所以当我们运行一个高级语言程序的时候，就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两类，第一种是编译，第二种是解释。

编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。

解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby。

通过以上的例子，我们可以来总结一下解释型语言和编译型语言的优缺点，因为编译型语言在程序运行之前就已经对程序做出了“翻译”，所以在运行时就少掉了“翻译”的过程，所以效率比较高。但是我们也不能一概而论，一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化，从而在效率上接近编译型语言，而不能超过编译型语言。

此外，随着Java等基于虚拟机的语言的兴起，我们又不能把语言纯粹地分成解释型和编译型这两种。

用Java来举例，Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。

3. Python到底是什么 

其实Python和Java/C#一样，也是一门基于虚拟机的语言，我们先来从表面上简单地了解一下Python程序的运行过程吧。

当我们在命令行中输入python hello.py时，其实是激活了Python的“解释器”，告诉“解释器”：你要开始工作了。可是在“解释”之前，其实执行的第一项工作和Java一样，是编译。

熟悉Java的同学可以想一下我们在命令行中如何执行一个Java的程序：

javac hello.java

java hello

只是我们在用Eclipse之类的IDE时，将这两部给融合成了一部而已。其实Python也一样，当我们执行python hello.py时，他也一样执行了这么一个过程，所以我们应该这样来描述Python，Python是一门先编译后解释的语言。

4. 简述Python的运行过程

在说这个问题之前，我们先来说两个概念，PyCodeObject和pyc文件。

我们在硬盘上看到的pyc自然不必多说，而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了，继续向下看。

当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。

当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，先对.pyc文件和.py文件的最近一次的修改时间进行判断，如果.pyc文件的修改时间晚于.py文件，说明.py文件中的源代码未修改过，则直接载入，否则就重复上面的过程。

所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。

Python的主要数据类型有：Number（数字），String（字符串类型），布尔值，List（列表），Tuple（元组）和Dictionary（字典）。

三、数据类型

1.数字（Number）

数字包括整数和浮点数

1.1 数字类型的创建

a = 5
b = a
b = 10

print(a)
print(b)

结果是：

a = 5
b = 10

1.2 Number 类型转换

var1 = 1.23
var2 = 4
var3 = int(var1)
var4 = int(var2)
print(var3,var4)

结果：

1 4

 

2.字符串类型（string）

字符串是用单引号‘’或者双引号“”括起来的任意文本，比如'qwer'，"135"等。引号是字符串的表示方式，并不是字符串的一部分，在Python中单引号和双引号没有区别，只有在当字符串中出现类似Let's go等形式时，用双引号括起来"Let's go"，注意空格也是字符串的一部分。

2.1 创建字符串

1 str1 = 'Hello World!'
2 str2 = 'Good Night!'

字符串操作：

1 #1  * 重复输出字符串
2 print('abc'*2)
3 执行结果：abcabc

1 #2  [:]通过索引获取字符串
2 print('goodnight'[2:])
3 执行结果：
4 odnight

1 #3  in 成员运算符，如果字符串中包含给定的字符返回 True
2 print('ood' in 'goodnight')
3 执行结果：
4 True

1 #4  % 格式化输出字符串
2 print('Tom is a good boy')
3 print('%s is a good boy'%'Tom')
4 执行结果：
5 Tom is a good boy
6 Tom is a good boy

 1 #5  + 字符串拼接
 2 a = 'abc'
 3 b = '123'
 4 c1 = a + b
 5 print(c1)
 6 执行结果：
 7 abc123
 8 该方法效率低，用join方法效率高：
 9 c2 = ''.join([a,b])
10 print(c2)
11 执行结果：
12 abc123

Python的内置方法：

 

3.布尔值

布尔值只有两种状态，True或False，要么是True，要么是False。（注意大小写）

print(4>2)
print(4<2)
执行结果：
True
False

布尔值经常用在条件判断中：

1 num = 5
2 if num > 3:
3     print('bigger')
4 else:
5     print('smaller')
6 执行结果：
7 bigger

4.列表（List）

    列表是Python中最常用的数据类型之一，用中括号[]来解析列表。通过列表可以对数据方便的存储、修改等操作。

定义列表

1 lis = ['Tom',1,'jack','abc']

通过下标访问列表中的元素，下标从0开始计数

1 >>> lis = ['Tom',1,'jack','abc']
2 >>> lis[0]
3 'Tom'
4 >>> lis[1]
5 1
6 >>> lis[2]
7 'jack'
8 >>> lis[3]
9 'abc'

一些操作：

1.查（[]）

 

2.增（append.insert）

append方法用于将对象追加到列表结尾，insert可以指定插入位置。

 1 lis = ['Tom',1,'jack','abc','cat','Dota']
 2 lis.append('lol')
 3 print(lis)
 4 执行结果：
 5 ['Tom', 1, 'jack', 'abc', 'cat', 'Dota', 'lol']
 6 
 7 lis = ['Tom',1,'jack','abc','cat','Dota']
 8 lis.insert(1,'lol')  #1是指定插入位置的下标
 9 print(lis)
10 执行结果：
11 ['Tom', 'lol', 1, 'jack', 'abc', 'cat', 'Dota'] 

3.改（重新赋值）

 1 lis = ['Tom',1,'jack','abc','cat','Dota']
 2 lis[3] = 'kong'
 3 print(lis)
 4 执行结果：
 5 ['Tom', 1, 'jack', 'kong', 'cat', 'Dota']
 6 
 7 lis = ['Tom',1,'jack','abc','cat','Dota']
 8 lis[0:2] = ['liu','mu']
 9 print(lis)
10 执行结果：
11 ['liu', 'mu', 'jack', 'abc', 'cat', 'Dota']

4.删（remove,del,pop）

 remove指定元素删除

1 lis = ['Tom',1,'jack','abc','cat','Dota']
2 lis.remove('Tom')
3 print(lis)
4 执行结果：
5 [1, 'jack', 'abc', 'cat', 'Dota']

pop指定下标删除，并返回被删除的内容，默认删除最后一个元素

1 lis = ['Tom',1,'jack','abc','cat','Dota']
2 b = lis.pop(0)
3 print(lis)
4 print(b)
5 执行结果：
6 [1, 'jack', 'abc', 'cat', 'Dota']
7 Tom

del指定下标删除，可以指定范围删除

1 lis = ['Tom',1,'jack','abc','cat','Dota']
2 del lis[0:3]
3 print(lis)
4 执行结果：
5 ['abc', 'cat', 'Dota']

5.其他操作

5.1 count 统计

1 lis = ['Tom','jack','abc','Tom','cat','Dota']
2 print(lis.count('Tom'))
3 执行结果：
4 2

5.2 extend 扩展，在列表末尾一次性加入另一个列表的所有元素

lis = ['Tom','jack','abc','Tom','cat','Dota']
a = ['lol','word']
lis.extend(a)
print(lis)
执行结果：
['Tom', 'jack', 'abc', 'Tom', 'cat', 'Dota', 'lol', 'word']

5.3 index列出某个元素第一次出现的下标

1 lis = ['Tom','jack','abc','Tom','cat','Dota']
2 print(lis.index('Tom'))
3 print(lis.index('jack'))
4 执行结果：
5 0
6 1

5.4 reverse将列表中元素倒置排列

lis = ['Tom','jack','abc','Tom','cat','Dota']
lis.reverse()
print(lis)
执行结果：
['Dota', 'cat', 'Tom', 'abc', 'jack', 'Tom']

5.5 sort由大到小排序，字符串以首字母在ASCII码表中位置排序

1 lis = [5,8,2,3,1,9]
2 lis.sort()
3 print(lis)
4 执行结果：
5 [1, 2, 3, 5, 8, 9]

5.6 copy拷贝

浅拷贝

1 names_class1=['张三','李四','王五','赵六',[1,2,3]]
2 names_class1_copy=names_class1.copy()
3 print(names_class1)
4 print(names_class1_copy)
5 执行结果：
6 ['张三', '李四', '王五', '赵六', [1, 2, 3]]
7 ['张三', '李四', '王五', '赵六', [1, 2, 3]]

5.元组（tuple）

    元组和列表差不多，同样用于存一组数，不同的是，元组一旦创建就不可修改，又叫只读列表。

虽然元组中的元素不可修改，但当列表作为元组的元素时，此列表中的元素可改。

语法

1 names = ('xiaofang','laoliu','cuihua')

当元组中只有一个元素时，元素后加逗号（,）

name = ('xiaofang',)

他只有2个方法，count和index用法和上边的列表一样。

6.字典（Dictionary）

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过下标存取。

创建字典

1 dic1={'name':'xiaoliu','age':27,'sex':'male'}
2 dic2=dict((('name','xiaoliu'),))
3 print(dic1)
4 print(dic2)
5 执行结果：
6 {'age': 27, 'name': 'xiaoliu', 'sex': 'male'}
7 {'name': 'xiaoliu'}

操作：

1.查

 1 dic={'name':'xiaoliu','age':27,'sex':'male'}
 2 print(dic['name'])
 3 print(dic['names'])  #没有键报错
 4 执行结果：
 5 xiaoliu
 6 KeyError: 'names'
 7 
 8 dic={'name':'xiaoliu','age':27,'sex':'male'}
 9 print(dic.get('age'))
10 print(dic.get('ages'))  #没有键返回None
11 执行结果：
12 27
13 None
14 
15 dic={'name':'xiaoliu','age':27,'sex':'male'}
16 print(dic.items())
17 print(dic.keys())
18 print(dic.values())
19 print(list(dic.keys()))
20 执行结果：
21 dict_items([('age', 27), ('name', 'xiaoliu'), ('sex', 'male')])
22 dict_keys(['age', 'name', 'sex'])
23 dict_values([27, 'xiaoliu', 'male'])
24 ['name', 'sex', 'age']
25 
26 print('name' in dic)
27 执行结果：
28 True

2.增

 1 dic3 = {}
 2 dic3['name'] = 'xiaoliu'
 3 dic3['age'] = 18
 4 print(dic3)
 5 执行结果：
 6 {'name': 'xiaoliu', 'age': 18}
 7 
 8 a = dic3.setdefault('name','yuan')
 9 b = dic3.setdefault('age',22)
10 print(a,b)
11 print(dic3)
12 执行结果：
13 xiaoliu 18
14 {'name': 'xiaoliu', 'age': 18}

3.删

 1 dic={'name':'xiaoliu','age':27,'sex':'male'}
 2 dic.clear()  #清空字典
 3 
 4 del dic['name']
 5 print(dic)
 6 执行结果：
 7 {'sex': 'male', 'age': 27}
 8 
 9 del dic  #删除字典
10 
11 a = dic.pop('name')  #删除选中的键和值，并返回值
12 print(a,dic)
13 执行结果：
14 xiaoliu {'sex': 'male', 'age': 27}
15 
16 a = dic.popitem()  #任意删除一组键值，并返回键值
17 print(a,dic)
18 执行结果：
19 ('name', 'xiaoliu') {'age': 27, 'sex': 'male'}

4.改

 1 dic={'name':'xiaoliu','age':27,'sex':'male'}
 2 dic['name'] = 'liyang'
 3 print(dic)
 4 执行结果：
 5 {'name': 'liyang', 'sex': 'male', 'age': 27}
 6 
 7 dic={'name':'xiaoliu','age':27,'sex':'male'}
 8 dic1 = {'hobby':'girl','age':23}  #dic中没有的添加，有相同键的更新
 9 dic.update(dic1)
10 print(dic)
11 执行结果：
12 {'name': 'xiaoliu', 'age': 23, 'hobby': 'girl', 'sex': 'male'}

5.其他操作和方法

5.1 dict.fromkeys()

1 d1 = dict.fromkeys(['name1','name2','name3'],'Tom')
2 d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])
3 print(d1)
4 print(d2)
5 执行结果：
6 {'name2': 'Tom', 'name3': 'Tom', 'name1': 'Tom'}
7 {'host3': ['Mac', 'huawei'], 'host1': ['Mac', 'huawei'], 'host2': ['Mac', 'huawei']}

5.2 d.copy()对字典浅复制，返回一个和d有相同键值对的新字典

5.3 字典的嵌套

1 dic = {'city':{'beijing':'chaoyang','shanghai':'pudong'},
2        'fruit':['banana','apple'],'country':'chinese'}
3 print(dic['city']['beijing'])
4 执行结果：
5 chaoyang

5.4 字典的遍历

 1 dic={'name':'xiaoliu','age':27,'sex':'male'}
 2 for i in dic:
 3     print(i,dic[i])
 4 执行结果：
 5 name xiaoliu
 6 sex male
 7 age 27
 8 
 9 dic={'name':'xiaoliu','age':27,'sex':'male'}
10 for item in dic.items():
11     print(item)
12 执行结果：
13 ('name', 'xiaoliu')
14 ('age', 27)
15 ('sex', 'male')
16 
17 dic={'name':'xiaoliu','age':27,'sex':'male'}
18 for key,values in dic.items():
19     print(key,values)
20 执行结果：
21 age 27
22 sex male
23 name xiaoliu

 5.5 sorted(dic) 将字典的key有序的排列成一个字典

1 dic={5:'555',2:'222',4:'444'}
2 print(sorted(dic))
3 >>>
4 [2,4,5]

 7.集合

集合是无序的不重复元素的集，是python的基本数据类型。集合的主要作用是去重和关系测试。

集合用大括号“{}”表示，但是空集合不能用“{}”表示，只能用set()，前者会创建一个空字典。

1 se1 = {}
2 se2 = set()
3 print(type(se1))
4 print(type(se2))
5 >>>:
6 <class 'dict'>
7 <class 'set'>

1. 集合中的元素必须是可哈希的

1 se = {[1,2],3,4}
2 print(se)
3 >>>:
4 TypeError: unhashable type: 'list'

2. 去重

1 se = {1,3,4,1,5,'a','a','c','c','b',5}
2 print(se)
3 >>>:
4 {1, 'c', 3, 4, 5, 'a', 'b'}

1 se = 'aabbccddee'
2 se1 = set(se)
3 print(se1)
4 >>>:
5 {'c', 'd', 'b', 'e', 'a'}

3. 关系测试

 1 a = set([1,2,3,4,5])
 2 b = set([3,4,5,6,7])
 3 
 4 #父集
 5 print(a > b) #>>>:False  a不在b中
 6 print(a in b) #>>>:False  a不在b中
 7 print(b > a) #>>>:False  b不在a中
 8 print(b in a) #>>>:False  b不在a中
 9 
10 #差集
11 print(a.difference(b)) #>>>:{1, 2}  在a不在b
12 print(a - b) #{1, 2}
13 
14 print(b.difference(a)) #>>>:{6, 7}  在b不在a
15 print(b - a) #{6, 7}
16 
17 print(a.symmetric_difference(b)) #>>>:{1, 2, 6, 7}  对称差集，反向交集
18 print(a ^ b) #>>>:{1, 2, 6, 7}
19 
20 #并集
21 print(a.union(b)) #>>>:{1, 2, 3, 4, 5, 6, 7}
22 print(a | b) #>>>:{1, 2, 3, 4, 5, 6, 7}
23 
24 #交集
25 print(a.intersection(b)) #>>>:{3, 4, 5}
26 print(a & b) #>>>:{3, 4, 5}