关于作者

周李杰，最后一批90后，现居湖北武汉

孤独患者，懒癌中期，无脑幻想者。但却人畜无害，无需远离。

兴趣众多，然无一精通。正努力成为一个有趣的人。

1 2	> print("👆以上是不完整的我") //请我吃大餐将会了解更多 >

子网划分

半吊子水准，大神请赐教，小白请阅

​ —写在前面的话

不扯犊子，直接开始

首先，我们要懂得IP地址的类别

IP地址：

• IP地址是可以局部表示唯一的主机
• IP地址是由4个字节，每个字节有8位bit，共32位bit组成
• IP地址分为网络部分和主机部分
• IP地址分为A、B、C、D、E类地址，其中D、E类地址用于科研，我们平常使用的也只有A、B、C三类地址，所以在此我也只列出A、B、C三类地址

A类地址：

前1个字节（前8位bit）为网络位，后3个字节（后24位bit）为主机位

地址范围：1.0.0.0–126.255.255.255
(00000001.00000000.00000000.00000000–01111110.111111111.11111111.11111111）

A类私有地址:10.0.0.0–10.255.255.255

1
2

(00000001.00000000.00000000.00000000--01111110.111111111.11111111.11111111）
# 此处不懂没关系，后面会讲到

B类地址：

前2个字节（前16位bit）为网络位，后2个字节（后16位bit）为主机位

地址范围：128.0.0.0–191.255.255.255
（10000000.00000000.00000000.00000000–10111111.11111111.11111111.11111111）

B类私有地址：172.16.0.0–172.31.255.255

C类地址：

前3个字节（前24位bit）为网络位，后1个字节（后8位bit）为主机位

地址范围：192.0.0.0–223.255.255.255
（11000000.00000000.00000000.00000000–11011111.11111111.11111111.11111111）

C类私有地址：192.168.0.0–192.168.255.255

环回地址：

地址范围：127.0.0.0–127.255.255.255
（01111111.00000000.00000000.00000000–01111111.11111111.11111111.11111111） #一般用于Windows系统，可检测电脑网卡是否正常

然后，我们来理解一下十进制与二进制之间的转换

十进制与二进制之间的转换：

十进制转二进制：

例如：11001100

我们从右往左数，

第一位为0 第二位为0 第三位为1

第四位为1 第五位为0 第六位为0

第七位为1 第八位为1

我们可以把0看作没有，1看作有，然后我们对照着表中，把有的数字相加在一起，

所以就等于4+8+64+128=204

例如：11111111

从右往左数，都为1，所以我们对照表中，

依次相加就等于1+2+4+8+16+32+64+128=255

二进制转十进制：

例如：172

同等于消消乐，从左往右，只要剩余的数字能减这一位的数字则为1，不能减则为0，跳过去减下一位，直到减到没有，

第八位128 能减，则为1，172-128=44.

第七位64 不能减，则为0.

第六位32 能减，则为1，44-32=12.

第五位16 不能减，则为0.

第四位8 能减，则为1，12-8=4.

第三位4 能减，则为1，4-4=0.

第二位2 不能减，则为0.

第一位1 不能减，则为0.

那么即可得出：10101100

例如：192

第八位128 能减，则为1，192-128=64.

第七位64 能减，则为1，64-64=0.

第六位32 不能减，则为0.

第五位16 不能减，则为0.

第四位8 不能减，则为0.

第三位4 不能减，则为0.

第二位2 不能减，则为0.

第一位1 不能减，则为0.

那么即可得出：11000000

为什么要分类：合理的利用网络地址资源 # 网上一大片一大片的文章，其意思就是要合理的利用地址资源，避免浪费，可能他们的更官方，更实用

子网掩码

• 子网掩码是用来区分网络部分和主机部分

如何区分？网络部分为1，主机部分为0

例如：10.1.1.1

首先我们看出这个地址是一个A类地址【前1个字节（前8位bit）为网络位，后3个字节（后24位bit）为主机位】

IP地址：00001010.00000001.00000001.00000001

子网掩码：11111111.00000000.00000000.00000000 (255.0.0.0或者在IP地址后接/8)

/8表示前8位为网络位

例如：172.16.1.1

首先我们看出这个地址是一个B类地址【前2个字节（前16位bit）为网络位，后2个字节（后16位bit）为主机位】

IP地址：10101100.00010000.00000001.00000001

子网掩码：11111111.11111111.00000000.00000000 (255.255.0.0或者在IP地址后接/16)

/16表示前16位为网络位

例如：192.168.10.1

首先我们看出这是一个C类地址【前3个字节（前24位bit）为网络位，后1个字节（后8位bit）为主机位】

IP地址：11000000.10101000.00001010.00000001

子网掩码：11111111.11111111.11111111.00000000 (255.255.255.0或者在IP地址后接/24)

/24表示前24位为网络位

网络地址与广播地址

1. 网络地址：网络位any（任意数），主机位为0
2. 广播地址：网络位any（任意数），主机位为1

例如：10.1.1.1

首先我们看出这是一个A类地址【前1个字节（前8位bit）为网络位，后3个字节（后24位bit）为主机位】

网络地址：00001010.00000001.00000001.00000001 (10.0.0.0)

广播地址：00001010.11111111.11111111.11111111 (10.255.255.255)

网络地址相当于一个范围，不能用于主机。网络地址就是限制IP在本网络范围中

例如：192.168.1.1的网络地址为192.168.1.0/24（/24代表前24位为网络位）

可用主机地址：1–254（主机为255，此为广播风暴，所以255不能用）

子网划分五步骤

1. 确定划分多少个网络，根据划分网络的数量来确定子网掩码

   ​ 2的n次方(n代表借的主机位）

   ​ 2的n次方大于或等于(要划分多少个子网)

2. 确定每个子网容纳的IP地址数量

   ​ 2的n次方（n代表剩余的主机位）

3. 确定可用的主机数量

   ​ 2的n次方减2（n代表剩余的主机位）

4. 确定IP地址范围

5. 确定网络地址与广播地址

例如：192.168.1.0/24 这个网络要划分出4个子网，请写出4个子网的网络地址、子网掩码以及广播地址以及可容纳主机数。

192.168.1.00000000/24

第一步：借两位 2的2次方大于或等于4

答：四个子网，需借走主机位两位来充当网络位，子网掩码为255.255.255.192

第二步： 8-2(借走了两位)=6 2的6次方 =64

答：每个子网容纳的IP地址数量为64

第三部： 2的6次方-2=64-2=62 （减去一个网络地址，减去一个广播地址）

答：可用的主机数量为：62台主机

第四步：

IP地址范围：

• 192.168.1.00000000/26–192.168.1.00111111/26 [192.168.1.0/26–192.168.1.63/26]
• 192.168.1.01000000/26–192.168.1.01111111/26 [192.168.1.64/26–192.168.1.127/26]
• 192.168.1.10000000/26–192.168.1.10111111/26 [192.168.1.128/26–192.168.1.191/26]
• 192.168.1.11000000/26–192.168.1.11111111/26 [192.168.1.192/26–192.168.1.255/26]

第五步：

网络地址：192.168.1.0/26 192.168.1.64/26 192.168.1.128/26 192.168.1.192/26

广播地址：192.168.1.63/26 192.168.1.127/26 192.168.1.191/26 192.168.1.255/26

例如：192.168.1.0/24 这个网络要划分出4个子网，第一个子网要求能容纳100台电脑，第二个子网要求容纳50台电脑，第三个子网要求容纳25台电脑，第四个子网要求容纳20台电脑。请列出四个子网、子网掩码、网络地址、广播地址以及主机地址范围

• 192.168.1.00000000/24–192.168.1.01111111/24 [192.168.1.0/24–192.168.1.127/24]

网络地址：192.168.1.0/24 子网掩码：255.255.255.0

广播地址：192.168.1.127/25 主机地址范围：1—126

• 192.168.1.10000000/25–192.168.1.10111111/25 [192.168.1.128/25–192.168.1.191/25]

网络地址：192.168.1.128/25 子网掩码：255.255.255.128

广播地址：192.168.1.191/25 主机地址范围：129–190

• 192.168.1.11000000/26–192.168.1.11011111/26 [192.168.1.192/26–192.168.1.223/26]

网络地址：192.168.1.192/26 子网掩码：255.255.255.192

广播地址：192.168.1.223/26 主机地址范围：193–222

• 192.168.1.11100000/27–192.168.1. 11111111/27 [192.168.1.224/27–192.168.1.225/27]

网络地址：192.168.1.224 子网掩码：255.255.255.224

广播地址：192.168.1.255 主机地址范围：225–254

总结

有句俗话叫做师傅领进门，修行靠个人。说到底还得自己去学，只有不断地去做，孰能生巧，自然而然的你就会了子网划分，本篇博文2K左右，例题就占比一大部分，记录下一来是为了正在学习子网划分的小白一种参考，有可能写的不是很好。二来是为了我自生的巩固，只有当你把他写出来了，能讲出来，才证明你已经会了。

关于作者

周李杰，最后一批90后，现居湖北武汉

孤独患者，懒癌中期，无脑幻想者。但却人畜无害，无需远离。

兴趣众多，然无一精通。正努力成为一个有趣的人。

1 2	> print("👆以上是不完整的我") //请我吃大餐将会了解更多 >

[TOC]

• 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

class Book:
    def __init__(self,name,author,comment,state=0):
        self.name = name
        self.author = author
        self.comment = comment
        self.state = state

    def __str__(self):
        status = '未借出'
        if self.state == 1:
            status = '已借出'
        return'名称:《%s》\t作者：%s\n推荐语：%s\n状态:%s'%(self.name,self.author,self.comment,status)

class BookManager:
    books = []

    def __init__(self):
        book1 = Book('小王子','安托万·德·圣埃克絮佩里','所述的飞行员坠机于撒哈拉沙漠的情节明显取材于圣埃克苏佩里的亲身经历。')
        book2 = Book('悲惨世界','维克多·雨果','描绘19世纪初20年间几个法国人物的生活背景，涵盖拿破仑战争和1832年巴黎共和党人起义等政治现象叙述。')
        book3 = Book('霍乱时期的爱情','加西亚·马尔克斯','讲述了一段跨越半个多世纪的爱情故事：男女主人公在二十岁的时候没能结婚，因为他们太年轻了；经过各种人生曲折之后，到了八十岁，他们还是没能结婚，因为他们太老了。')
        self.books.append(book1)
        self.books.append(book2)
        self.books.append(book3)

    def menu(self):
        print('欢迎使用贝多芬图书管理系统，周恩来说过：“书籍是人类进步的阶梯！”。\n') 
        while True: 
            print('1.查询所有书籍\n2.添加书籍\n3.借阅书籍\n4.归还书籍\n5.退出系统\n')
            choice = int(input('请输入数字选择对应功能：'))
            if choice == 1:
                self.show_all_book()
            elif choice == 2:
                self.add_book()
            elif choice == 3:
                self.lend_book()
            elif choice == 4:
                self.return_book()
            elif choice == 5:
                print('欢迎下次使用，谢谢，祝您阅读愉快！')
                break

    def show_all_book(self):
        for book in self.books:
            print(book)
            print('')

    def add_book(self):
        new_name = input('请输入书籍名称：')
        new_author = input('请输入作者：')
        new_comment = input('请输入推荐语：')
        new_book = Book(new_name,new_author,new_comment)

        self.books.append(new_book)
        print('恭喜！书籍录入成功！\n')

    def check_book(self, name):
        for book in self.books:
            if book.name == name:
                return book
        else:
            return None

    def lend_book(self):
        name = input('请输入想要借阅书的书名：')
        res = self.check_book(name)

        if res != None:
            if res.state == 1:
                print('你来晚了一步，这本书被借走了哟！')
            else:
                print('借阅成功，为期一个月，请按时还书哟！')
                res.state = 1
        else:
            print('非常抱歉，本图书馆暂时还未收纳本书！')

    def return_book(self):
        name = input('请输入归还书籍的名称：')
        rem = self.check_book(name)

        if rem != None:
            if rem.state == 1:
                print('归还成功，欢迎下次借阅！')
            else:
                print('不需归还，请核实信息')
        else:
            print('这本书暂时没用在系统中！')
manager = BookManager()
manager.menu()

实践功能

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

欢迎使用贝多芬图书管理系统，周恩来说过：“书籍是人类进步的阶梯！”

1.查询所有书籍
2.添加书籍
3.借阅书籍
4.归还书籍
5.退出系统

请输入数字选择对应功能：1
名称:《小王子》 作者：安托万·德·圣埃克絮佩里
推荐语：所述的飞行员坠机于撒哈拉沙漠的情节明显取材于圣埃克苏佩里的亲身经历。
状态:未借出

名称:《悲惨世界》       作者：维克多·雨果
推荐语：描绘19世纪初20年间几个法国人物的生活背景，涵盖拿破仑战争和1832年巴黎共和党人起义等政治现象叙述。
状态:未借出

名称:《霍乱时期的爱情》 作者：加西亚·马尔克斯
推荐语：讲述了一段跨越半个多世纪的爱情故事：男女主人公在二十岁的时候没能结婚，因为他们太年轻了；经过各种人生曲折之后，到了八十岁，他们还是没能结婚，
因为他们太老了。
状态:未借出

1.查询所有书籍
2.添加书籍
3.借阅书籍
4.归还书籍
5.退出系统

请输入数字选择对应功能：2
请输入书籍名称：围城
请输入作者：钱钟书
请输入推荐语：是中国现代文学史上一部风格独特的讽刺小说。被誉为“新儒林外史”。
恭喜！书籍录入成功！

1.查询所有书籍
2.添加书籍
3.借阅书籍
4.归还书籍
5.退出系统

请输入数字选择对应功能：1
名称:《小王子》 作者：安托万·德·圣埃克絮佩里
推荐语：所述的飞行员坠机于撒哈拉沙漠的情节明显取材于圣埃克苏佩里的亲身经历。
状态:未借出

名称:《悲惨世界》       作者：维克多·雨果
推荐语：描绘19世纪初20年间几个法国人物的生活背景，涵盖拿破仑战争和1832年巴黎共和党人起义等政治现象叙述。
状态:未借出

名称:《霍乱时期的爱情》 作者：加西亚·马尔克斯
推荐语：讲述了一段跨越半个多世纪的爱情故事：男女主人公在二十岁的时候没能结婚，因为他们太年轻了；经过各种人生曲折之后，到了八十岁，他们还是没能结婚，
因为他们太老了。
状态:未借出

名称:《围城》   作者：钱钟书
推荐语：是中国现代文学史上一部风格独特的讽刺小说。被誉为“新儒林外史”。
状态:未借出

1.查询所有书籍
2.添加书籍
3.借阅书籍
4.归还书籍
5.退出系统

请输入数字选择对应功能：3
请输入想要借阅书的书名：小王子
借阅成功，为期一个月，请按时还书哟！
1.查询所有书籍
2.添加书籍
3.借阅书籍
4.归还书籍
5.退出系统

请输入数字选择对应功能：4
请输入归还书籍的名称：shdfash
这本书暂时没用在系统中！
1.查询所有书籍
2.添加书籍
3.借阅书籍
4.归还书籍
5.退出系统

请输入数字选择对应功能：1
名称:《小王子》 作者：安托万·德·圣埃克絮佩里
推荐语：所述的飞行员坠机于撒哈拉沙漠的情节明显取材于圣埃克苏佩里的亲身经历。
状态:已借出

名称:《悲惨世界》       作者：维克多·雨果
推荐语：描绘19世纪初20年间几个法国人物的生活背景，涵盖拿破仑战争和1832年巴黎共和党人起义等政治现象叙述。
状态:未借出

名称:《霍乱时期的爱情》 作者：加西亚·马尔克斯
推荐语：讲述了一段跨越半个多世纪的爱情故事：男女主人公在二十岁的时候没能结婚，因为他们太年轻了；经过各种人生曲折之后，到了八十岁，他们还是没能结婚，
因为他们太老了。
状态:未借出

名称:《围城》   作者：钱钟书
推荐语：是中国现代文学史上一部风格独特的讽刺小说。被誉为“新儒林外史”。
状态:未借出

1.查询所有书籍
2.添加书籍
3.借阅书籍
4.归还书籍
5.退出系统

请输入数字选择对应功能：4
请输入归还书籍的名称：小王子
归还成功，欢迎下次借阅！
1.查询所有书籍
2.添加书籍
3.借阅书籍
4.归还书籍
5.退出系统

请输入数字选择对应功能：5
欢迎下次使用，谢谢，祝您阅读愉快！

关于作者

周李杰，最后一批90后，现居湖北武汉

孤独患者，懒癌中期，无脑幻想者。但却人畜无害，无需远离。

兴趣众多，然无一精通。正努力成为一个有趣的人。

1 2	> print("👆以上是不完整的我") //请我吃大餐将会了解更多 >

[TOC]

数学运算函数：

abs() 返回数字的绝对值
divmod() 计算两个数的商和余数，用元组返回
pow() 返回 xy（x的y次方） 的值
sum() 求和计算
bin() 返回一个整数 int 或者长整数 long int 的二进制表示
oct() 将一个整数转换成8进制字符串
round() 返回浮点数x的四舍五入值
long() 将数字或字符串转换为一个长整型
hex() 将10进制整数转换成16进制整数

类型转换函数：

str() 函数将对象转化为String的形式
int() 函数用于将一个字符串会数字转换为整型
tuple() 将列表转换为元组
bool() 参数转换为布尔类型，如果没有参数，返回False
float() 将整数和字符串转换成浮点数
list() 将元组转换为列表

序列操作函数：

min() 返回给定参数的最小值，参数可以为序列
sorte() 对所有可迭代的对象进行排序操作
len() 返回对象（字符、列表、元组等）长度或项目个数
filter() 用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表
set() 创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
zip() 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元组解压为列表。
reversed() 用于反向排序列表中元素
enumerate() 将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中

输入输出函数：

input() 用来获取控制台输入，输入的值必须是一个合法的python表达式
print() 用于打印输出
open() 打开一个文件，创建一个file对象
file() 用于创建一个file对象，它有一个别名叫open()
raw_input() 接收控制台输入的内容，可接收所有的类型

创建函数：

iter() 用来生成迭代器
range() 创建一个整数列表，一般用在for循环中。
dict() 用于创建一个字典
exec() 执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码
bytearray() 返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围:0<=x<256
complex() 创建一个值为real+imag*j的复数或者转化一个字符串或数为复数,如果第一个参数为字符串，则不需要指定第二个参数
xrange() 用法与range完全相同，所不同的是生成的不是一个数组，而是一个生成器。

获取函数：

id() 用于获取对象的内存地址
getattr() 返回一个对象属性值
help() 用于查看函数或模块用途的详细说明
next() 返回迭代器的下一个项目
memoryview() 返回给定参数的内存查看对象(Momory view)
hash() 用于获取取一个对象（字符串或者数值等）的哈希值
vars() 返回对象object的属性和属性值的字典对象
globals() 以字典类型返回当前位置的全部全局变量
max() 返回给定参数的最大值，参数可以为序列
property() 在新式类中返回属性值
ord() 返回一个字符对应的ASCII或者Unicode值
staticmethod() 返回函数的静态方法
frozenset() 返回一个不可变的集合，不能再添加或删除任何元素
locals() 以字典类型返回当前位置的全部局部变量
unichr() 返回unicode字符
map() 根据提供的函数对指定序列做映射。 第一个参数function以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的新列表
dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息

判断函数：

issubclass() 判断参数class是否是类型参数classinfo的子类
hasattr() 用于判断对象是否包含对应的属性。
isinstance() 判断一个对象是否是一个已知的类型，类似type()
any() 用于判断给定的可迭代参数iterable是否全部为空对象，如果都为空、0、false，则返回 False，如果不都为空、0、false，则返回True
all() 函数用于判断给定的可迭代参数iterable中的所有元素是否不为 0、’’、False 或者iterable为空，如果是返回 True，否则返回 False
callable() 检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功
cmp() 用于比较2个对象，如果x < y返回-1, 如果x == y返回 0, 如果x > y返回 1

操作函数：

delattr() 用于删除属性。
setattr() 对应函数getatt()，用于设置属性值，该属性必须存在。
slice() 切片分割对象，用在切片操作函数里的参数传递。
repr() 将对象转化为供解释器读取的形式。
compile() 将一个字符串编译为字节代码。
eval() 执行一个字符串表达式，并返回表达式的值
execfile() 用来执行一个文件。
super() 调用下一个父类(超类)并返回该父类实例的方法
reload() 重新载入之前载入的模块
type() 如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
format() 格式化字符串的函数str.format()，它增强了字符串格式化的功能。
basestring() 是str和unicode的超类（父类），也是抽象类，因此不能被调用和实例化，但可以被用来判断一个对象是否为str或者unicode的实例
classmethod() classmethod修饰符对应的函数不需要实例化，不需要self参数，但第一个参数需要是表示自身类的cls参数，可以来调用类的属性，类的方法，实例化对象等。
chr() 用一个范围在range (256)内的就是(0～255)整数作参数，返回一个对应的字符
__import__() 动态加载类和函数。 如果一个模块经常变化就可以使用 __import__() 来动态载入。
reduce() 对参数序列中元素进行累积。 函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

函数的详细介绍:

函数名：abs()

1
2
3
4
5
6
7

语法：
abs(x)
参数：数值表达式
返回值：函数返回x（数字）的绝对值。
代码示例：
print ("abs(-45) : ", abs(-45))
print ("abs(100.12) : ", abs(100.12))

函数名：divmod()

1
2
3
4
5
6

语法：
divmod(a, b)
参数：a,b均为数值
返回值：一个包含商和余数的元组 例如（3，1），其中3是商，1是余数
代码示例：
divmod(7, 2)

函数名：pow()

1
2
3
4
5
6

语法：
pow(x, y)
参数：x,y均为数值
返回值：返回结果值，为数值类型
代码示例：
pow(7, 2)

函数名：sum()

1
2
3
4
5
6

语法：
sum(a,b)
参数：a为元素为数值的可迭代的对象， b为一个数值类型的参数，b可不写，不写时默认为0
返回值：返回值为迭代对象相加的和加上第二个参数，为数值类型
代码示例：
a = sum((2, 3, 4),1)

函数名：bin()

1
2
3
4
5
6

语法：
bin(x)
参数：x为数值类型
返回值：返回值为二进制的表示，是字符串类型
代码示例：
bin(12)

函数名：oct()

1
2
3
4
5
6

语法：
oct(x)
参数：x为数值类型
返回值：返回值为八进制表示，是字符串类型
代码示例：
oct(11)

函数名：round()

1
2
3
4
5
6

语法：
round(m,n)
参数：m为要四舍五入的值，为数值类型，n是保留的位数，为int类型
返回值：返回值为数值类型
代码示例：
round(10.265 ,2)

函数名：long()

1
2
3
4
5
6

语法：
long(x, y)
参数：x为字符串或数值类型，b为进制数，默认10
返回值：结果为数值类型
代码示例：
long(1)

函数名：hex()

1
2
3
4
5
6

语法：
hex(x)
参数：x为十进制数值
返回值：十六进制的字符串
代码示例：
hex(11)

函数名：str()

1
2
3
4
5
6

语法：
str(x)
参数：x为对象
返回值：返回字符串
代码示例：
str(object)

函数名：int()

1
2
3
4
5
6

语法：
int(x,y)
参数：x为字符串类型
返回值：数值类型
代码示例：
int("111111")

函数名：tuple()

1
2
3
4
5
6

语法：
tuple( seq )
参数：seq为列表
返回值：返回元组
代码示例：
tuple([1,2,3,4])

函数名：bool()

1
2
3
4
5
6
7

语法：
bool(x)
参数：x为要转换的参数，可以是数值或者string
返回值：返回值为boolean类型，当参数为0或者空或者""的时候，返回false
代码示例：
bool("")
bool(0)

函数名：float()

1
2
3
4
5
6

语法：
float(x)
参数：x为数值或者String
返回值：返回值为浮点数
代码示例：
float("1")

函数名：list()

1
2
3
4
5
6

语法：
list( seq )
参数：seq为元组
返回值：返回数组
代码示例：
list(("12","456","789"))

函数名：min()

1
2
3
4
5
6

语法：
min( x, y, z, .... )
参数：参数为序列或者集合
返回值：返回最小值
代码示例：
min(("12","456","789"))

函数名：sorted()

1
2
3
4
5
6
7
8
9
10
11

语法：
sorted(iterable, cmp, key, reverse)
参数：iterable为要排序的序列，cmp为比较函数，key为用来进行比较的元素，reverse为升序或者降序，默认为false降序
返回值：返回排好序的序列
代码示例：
#对元组进行排序
sorted((12,123,56),reverse = True)
#利用cmp函数排序
sorted([('b',2),('a',1),('c',3),('d',4)], cmp=lambda x,y:cmp(x[1],y[1]))
#利用key排序
sorted([('b',2),('a',1),('c',3),('d',4)], key=lambda x:x[1])

函数名：len()

1
2
3
4
5
6

语法：
len( s )
参数：s为字符、列表元组等
返回值：返回数值类型
代码示例：
len("xtyz")

函数名：filter()

1
2
3
4
5
6
7
8
9
10
11

语法：
filter(function, iterable)
参数：第一个参数为函数，函数返回布尔类型， 第二个参数为可迭代对象
返回值：返回过滤后的集合
代码示例：
def  tt (parm):
    return parm < 7

a = filter(tt, [9,8,7,6,5,4,3])
 
print(list(a))

函数名：set()

1
2
3
4
5
6
7
8
9
10
11
12
13
14

语法：
set(x)
参数：x为可迭代对象
返回值：返回一个不重复的元素集合
代码示例：
a = set("9876554321")
print(a)
#可以用来计算交集，并集，差集等
x = set("987654")
y = set("654321")

print(x&y)#交集
print(x|y)#并集
print(x-y)#差集

函数名：zip()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

语法：
zip(a,b,c,d.....)
参数：参数为多个可迭代对象
返回值：返回打包好的元组集合,元素合数与长度最短的迭代对象相同
代码示例：
x = "987654"
y = "654321"
print(list(zip(x,y)))

x = [1,2.3]
y = [4,5,6]
print(list(zip(x,y)))

#解压
z = zip(x,y)
print(zip(*z))

函数名：reverse()

1
2
3
4
5
6
7
8

语法：
list.reverse()
参数：没有参数
返回值：没有返回值
代码示例：
x = (9,8,7,2,5,4,3)
x.reverse()
print(x)#注意，是反向排列，不是按照大小排序

函数名：enumerate()

1
2
3
4
5
6
7

语法：
enumerate(sequence)
参数：参数为可迭代对象
返回值：返回 enumerate(枚举) 对象
代码示例：
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))

函数名：input()

1
2
3
4
5
6
7

语法：
input()
参数：参数无
返回值：返回输入值的类型（3 .x里 input() 默认接收到的是str 类型）
代码示例：
a = input("输入")
print(a)

函数名：print()

1
2
3
4
5
6

语法：
print(*objects, sep=' ', end='\n', file=sys.stdout)
参数：objects 为输出对象，可为多个，用，分隔； sep为间隔符，默认为" "; end为结尾的符号。默认是换行符"\n";file为要写入的文件对象
返回值：无
代码示例：
print("111","222","333",sep ="===",end = "////////")

函数名：open()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

语法：
open(name, mode, buffering)
参数：name为要访问的文件或者创建的文件的字符串，可以包含路径，model为打开文件的模式，buffering : 缓冲区大小，设为0不会有寄存，设为1表示寄存行，大于1的整数，表示寄存去缓冲区的大小，

设置为负数，则为系统默认大小,文件打开模式如下
r    #以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb   #以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+   #打开一个文件用于读写。文件指针将会放在文件的开头。
rb+  #以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w    #打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb   #以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+   #打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+  #以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a    #打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab   #以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+   #打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+  #以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

返回值：file对象

代码示例：
f = open('test.txt')

函数名：file()

1
2
3
4
5

语法：同open()
参数：同open()
返回值：同open()
代码示例：
file('test.txt')

函数名：raw_input()

1
2
3
4
5
6

语法：
raw_input(x)
参数：x为String，可不写，会在控制台输出x内容
返回值：返回输入的内容
代码示例：
raw_input_A = raw_input("raw_input:")

函数名：iter()

1
2
3
4
5
6
7
8

语法：
iter(x)
参数：x为支持迭代的集合对象
返回值：迭代器对象
代码示例：
lst = [1, 2, 3]
for i in iter(lst):
     print(i)

函数名：range()

1
2
3
4
5
6
7
8

语法：
range(start, stop, step)
参数：start为计数开始点，默认为0；stop为计数结束点，但不包括stop；step，步长，默认为1
返回值：列表对象
代码示例：
range(10)
range(1,5)
range(1,10,2)

函数名：dict()

1
2
3
4
5
6
7
8
9
10
11
12

语法：
参数：
返回值：字典对象
代码示例：
a = dict()                        # 创建空字典
print(a)
a =  dict(a='a', b='b', t='t')     # 传入关键字
print(a)
a =  dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
print(a)
a =  dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
print(a)

函数名：exec()

1
2
3
4
5
6

语法：
exec x
参数：x为可执行的字符串代码
返回值：无
代码示例：
exec "print 'runoob.com'"

函数名：bytearray()

1
2
3
4
5
6

语法：
bytearray(source, encoding, errors)
参数：source 可以是整数、字符串、可迭代对象
返回值：字节数数组
代码示例：
bytearray([1,2,3])

函数名：complex()

1
2
3
4
5
6

语法：
complex(real, imag)
参数：real 可以是 int, long, float或字符串，image可以是 int，long，float
返回值：返回一个复数
代码示例：
complex(1, 2)

函数名：xrange()

1
2
3
4
5
6

语法：
xrange(start, stop, step)
参数：start开始数，stop结束数，step步长
返回值：返回生成器
代码示例：
xrange(8)

函数名：id()

1
2
3
4
5
6
7

语法：
id(object)
参数：object为对象
返回值：对象的内存地址
代码示例：
a = 'test'
print(id(a))

函数名：getattr()

1
2
3
4
5
6

语法：
getattr(object, name, default)
参数：object为对象，那么为属性名，default为默认值，如果属性不存在，返回默认值
返回值：属性值
代码示例：
getattr(a, 'bar2', 3)

函数名：help()

1
2
3
4
5
6

语法：
help(x)
参数：x为对象
返回值：返回对象的帮助信息
代码示例：
help('sys')             # 查看 sys 模块的帮助

函数名：next()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

语法：
next(a, default)
参数：a为可迭代对象，default为没有下一个元素时返回的值
返回值：可迭代对象的内容
代码示例：
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

函数名：memoryview()

1
2
3
4
5
6
7

语法：
memoryview(obj)
参数：obj为对象
返回值：返回元组列表
代码示例：
a = memoryview(b'babcefg')
print(a[1])

函数名：hash()

1
2
3
4
5
6
7

语法：
hash(x)
参数：x 为对象
返回值: 返回对象的hash值
代码示例：
a = hash('test')
print(a)

函数名：vars()

1
2
3
4
5
6
7
8

语法：
vars(obj)
参数：obj为对象，如果没有的话，返回当前调用位置的属性和属性值
返回值：返回对象属性和属性值的字典对象
class Runoob:
     a = 1
print(vars(Runoob))
代码示例：

函数名：globals()

1
2
3
4
5
6

语法：
globals()
参数：无
返回值：当前位置的全局变量
代码示例：
print(globals())

函数名：max()

1
2
3
4
5
6

语法
max(a,b,x.....)
参数：数值表达式
返回值：返回参数最大值
代码示例：
print(max(80, 100, 1000))

函数名：property()

1
2
3
4
5
6
7
8
9

语法：
class property(fget, fset, fdel, doc)
参数：
fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述信息
返回值：返回类属性
代码示例：

函数名：ord()

1
2
3
4
5
6

语法：
ord(c)
参数：c为字符
返回值：对应的十进制数
代码示例：
ord('a')

函数名：abs()

1
2
3
4
5
6

语法：
abs( x )
参数：x为数值表达式
返回值：x的绝对值
代码示例：
abs( -8 )

函数名：staticmethod()

1
2
3
4
5
6
7
8
9
10
11
12
13

语法：
staticmethod(function)
参数：无
返回值：无
代码示例：
class C(object):
    @staticmethod
    def f():
        print('runoob');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用

函数名：frozenset()

1
2
3
4
5
6

语法：
frozenset([iterable])
参数：可迭代对象
返回值：一个冻结的集合，不能修改或者删除
代码示例：
frozenset(range(10))

函数名：locals()

1
2
3
4
5
6

语法：
locals()
参数：无
返回值：返回当前位置的所有局部变量
代码示例：
locals()

函数名：unichr()

1
2
3
4
5
6

语法：
unichr(i)
参数：十进制或者十六进制的数字
返回值：unicode 的字符。
代码示例：
unichr(97)

函数名：map()

1
2
3
4
5
6
7
8
9
10

语法：
map(function, iterable, ...)
参数：
function -- 函数，有两个参数
iterable -- 一个或多个序列
返回值：返回列表
代码示例：
def square(x) :            # 计算平方数
     return x ** 2
a = map(square, [1,2,3,4,5])

函数名：dir()

1
2
3
4
5

语法：
dir([object])
参数：对象
返回值：返回属性列表
代码示例：

函数名：issubclass()

1
2
3
4
5
6
7
8
9
10
11

语法：
issubclass(class, classinfo)
参数：
class--class类， classinfo---classifo类
返回值：如果 class 是 classinfo 的子类返回 True，否则返回 False。
代码示例：
class A:
    pass
class B(A):
    pass  
print(issubclass(B,A))    # 返回 True

函数名：hasattr()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

语法：
hasattr(object, name)
参数：object为对象，那么为属性名
返回值：如果对象内有这个属性，返回true，否则false、
代码示例：
class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))  # 没有该属性

函数名：isinstance()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

语法：
isinstance(object, classinfo)
参数：
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者有它们
返回值：如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。
代码示例：
class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

函数名：any()

1
2
3
4
5
6

语法：
any(iterable)
参数：元组或者列表
返回值：如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
代码示例：
any(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0

函数名：all()

1
2
3
4
5
6

语法：
all(iterable)
参数：元组或列表
返回值：如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；
代码示例：
all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0

函数名：callable()

1
2
3
4
5

语法：
callable(object)
参数：对象
返回值：可调用返回 True，否则返回 False。
代码示例：callable(0)

函数名：cmp()

1
2
3
4
5
6

语法：
cmp( x, y )
参数：都是数值表达式
返回值：如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
代码示例：
cmp(80, 100)

函数名：delattr()

1
2
3
4

语法：
参数：
返回值：
代码示例：

函数名：setattr()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

语法：
setattr(object, name, value)
参数：
object -- 对象。
name -- 字符串，对象属性。
value -- 属性值。
返回值：无
代码示例：
class A(object):
     bar = 1
     
a = A()
getattr(a, 'bar')          # 获取属性 bar 值

setattr(a, 'bar', 5)       # 设置属性 bar 值
a.bar

函数名：slice()

1
2
3
4
5
6
7
8
9

语法：
slice(start, stop, step)
参数：
start -- 起始位置
stop -- 结束位置
step -- 间距
返回值：一个切片对象
代码示例：
slice(5)

函数名：repr()

1
2
3
4
5
6
7

语法：
repr(object)
参数：对象
返回值：对象的String格式
代码示例：
s = 'RUNOOB'
repr(s)

函数名：compile()

1
2
3
4
5
6
7
8
9
10

语法：
compile(source, filename, mode, flags, dont_inherit)
参数：
source -- 字符串或者AST（Abstract Syntax Trees）对象。。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志
返回值：
代码示例：

函数名：eval()

1
2
3
4
5
6
7
8
9

语法：
eval(expression, globals, locals)
参数：
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值：表达式执行结果
代码示例：
eval( '3 * x' )

函数名：execfile()

1
2
3
4
5
6
7
8
9

语法：
execfile(filename, globals, locals)
参数：
filename -- 文件名。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值：执行结果
代码示例：
execfile('hello.py') #需要有hello.py

函数名：super()

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

语法：
super(type[, object-or-type])
参数：
type -- 类。
object-or-type -- 类，一般是 self
返回值：无
代码示例：
class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)
 
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')

函数名：reload()

1
2
3
4
5
6

语法：
reload(module)
参数：模块对象
返回值：返回模块对象
代码示例：
reload(sys)

函数名：type()

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

语法：
type(name, bases, dict)
参数：
name -- 类的名称。
bases -- 基类的元组。
dict -- 字典，类内定义的命名空间变量。
返回值：一个参数返回对象类型, 三个参数，返回新的类型对象。
代码示例：

type(1)

type('runoob')

type([2])

type({0:'zero'})

x = 1          
type( x ) == int    # 判断类型是否相等
print(x)
# 三个参数
class X(object):
      a = 1
X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
print(X)

函数名：format()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

语法：String.format()
参数：
返回值：格式化之后的字符串
代码示例：
"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
"{0} {1}".format("hello", "world")  # 设置指定位置
"{1} {0} {1}".format("hello", "world")  # 设置指定位置
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))

my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是可选的

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的

函数名：basestring()

1
2
3
4
5
6

语法：
basestring()
参数：无
返回值：无
代码示例：
isinstance("Hello world", basestring)#判断一个对象是否为 str 或者 unicode 的实例

函数名：classmethod()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

语法：
classmethod
参数：无
返回值：返回函数的类方法
代码示例：
class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

函数名：chr()

1
2
3
4
5
6

语法：
chr(i)
参数：十进制或者十六进制的数字,0-255之间
返回值：对应的ASCLL字符
代码示例：
chr(123)

函数名：import()

1
2
3
4
5
6
7

语法：
__import__(name)
参数：模块名
返回值：元组数组
代码示例：
import sys  
__import__('a')        # 导入 a.py 模块

函数名：reduce()

python 语法： reduce(function, iterable, initializer) 参数： function -- 函数，有两个参数 iterable -- 可迭代对象 initializer -- 可选，初始参数 返回值：返回计算结果 代码示例： def add(x, y) : # 两数相加 return x + y reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5 reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数python

关于作者

周李杰，最后一批90后，现居湖北武汉

孤独患者，懒癌中期，无脑幻想者。但却人畜无害，无需远离。

兴趣众多，然无一精通。正努力成为一个有趣的人。

1 2	> print("👆以上是不完整的我") //请我吃大餐将会了解更多 >

[TOC]

python文件处理

python对文件处理分为两种，一种是本地处理，而另外一种就是通过网络数据处理（也就是爬虫相关），而本地的数据处理，主要是通过文件的都和写完成

我们先想一想平时对文件处理一般遇到过哪些问题:

• 如何读取一个文件的内容，然后处理，最后写到一个新的文件
• 如何更改一个文件夹下面的某一些文件名

python的文件处理简单来说分为以下几点：

• 文件的读写和关闭
• 文件的模式
• 文件的读取位置

文件的读取和关闭

python中想要获取文件里的内容，先要打开文件，然后才能都和写，而且写完之后一定要记得关闭

python中对文件的打开是通过open函数来获取一个句柄

• 获取读的句柄，可以用f.read()进行读入
• 获取写的句柄f之后，就可以f.weite()进行写入
• 当你文件处理完毕之后，要关闭文件

应该会有人和博主思考的问题一样：为什么要关闭文件？

因为如果不正常关闭文件，缓冲在内存中的数据就不能真正地写入到文件中，可能造成数据丢失的现象

文件的打开

1
2
3
4

file_obj=open(filename,mode='r',buffering=-1)
# 这里一共有3个参数，第一个是强制参数，后面两个是可选的
# mode可以是读，也可以是写，或者是追加，一般默认的是读文件
# buffering主要是设置缓冲区，一般我们都是用-1表示系统默认的缓冲区，若写100，则表示缓冲区为100

文件的读取

1
2
3

f=open(r'somefile.txt')
f.readline() # 表示读文件的一行
f.readlines() # 表示把文件从头到位都读出来，并保存为一个列表

例如我们现在在D盘的python目录里面新建

123321.txt

123321.py

打开123321.txt输入：

1 2 3 4

> 123456789 > ABCDEFGHI > IHGFEDCBA >

打开123321.py，写入代码如下：

1
2
3

f=open(r'123321.txt')
print(f.readline())
print(f.readlines())

运行结果如下：

1
2
3

123456789

['ABCDEFGHI\n', 'IHGFEDCBA']

文件的写入

1
2
3
4

f=open(r'somefile.txt,'w')
f.write() # 表示把字符串写入
f.writelines() # 表示把一个列表写入
f.close() # 表示关闭文件

例如我们现在在D盘的python目录里面新建

ABCCBA.txt

ABCCBA.py

打开ABCCBA.py，写入代码如下：

1
2
3
4

f=open(r'ABCCBA.txt','w')
f.write('123321')
f.writelines(['\nABCDEFGHI\n', 'IHGFEDCBA'])
f.close()

此处在后面如果没写入f.close(),那么在最后你打开ABCCBA.txt文件后是看不到你写入的内容的

运行结果：

打开D盘的python目录下的ABCCBA.txt文件

1
2
3

123321
ABCDEFGHI
IHGFEDCBA

文件的关闭

此处我介绍两种关闭方法

1）

1
2
3

f=open(r'somefile.txt')
.............
f.close()

2）

1
2

with open(r'somefile.txt') as f:
    f.readlines()

with用法是python极力推荐的一种使用方法，因为它能够自动帮你关掉文件，你只需要专注对文件的处理就可以了

文件的模式

在上面我仅仅只列举了python的读和写，那么其他的模式该怎么办呢？

其实python只需要改变一下open里面的模式参数就可以了

​ open函数中的模式参数

文件的读取位置

有时候我们就只想读取文件中的某一部分，或者我们需要从文章的某一部分开始读取

那么这就要用到seek()函数

1
2

file_obj.seek(offset,whence=0)
# seek 主要是在文件中移动指针，从`whence`(0表示文件的开头，1表示当前位置，2表示文件的末尾)偏移offset个字符

例如在D盘python目录下的123321.txt文件

1 2 3 4

> 123456789 > ABCDEFGHI > IHGFEDCBA >

从头读取3个字符

在当前目录下创建seek1.py文件，写入代码如下：

1
2
3
4

f=open(r'123321.txt')
f.seek(0,0)
print(f.read(3))
f.close()

运行结果：

1

123

从尾部读取3个字符

在当前目录下创建seek2.py文件，写入代码如下：

1
2
3
4

f=open(b'123321.txt')
f.seek(-3,2)
print(f.read(3))
f.close()

运行结果：

1
2

实战1

在D盘python目录里面创建2019.txt文件，写入：

1 2 3 4 5

> hahaha > hary > natasha > mary >

请把2019.txt文件里面的内容都出来，写到一个新的文件，文件名：9102.txt，格式按照下面这种：

1 2 3 4 5

> 1:hahaha > 2:hary > 3:natasha > 4:mary >

在当前目录下创建test.py，代码如下：

1
2
3
4
5
6
7
8
9
10

f=open('2019.txt') # 打开文件
count=f.readlines() # 从文件中把内容都读出来，保存到列表中
for i in range(0,len(count)): # 关闭文件
    count[i]=str(i+1)+'：'+count[i] # 遍历列表，将每一行都加上下标
print(count)
f.close() # 关闭文件

f=open('9102.txt','w') # 打开文件
f.writelines(count) # 把新的内容写入文件
f.close()

优化重构代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def read_File():    # 把读文件抽成一个函数
    with open(r'2019.txt','r')as f:
        read_lines_from_file=f.readlines()
        return read_lines_from_file

def write_File(count=[]):   # 把写文件抽成一个函数
    with open(r'9102.txt','w')as f:
        f.writelines(count)

new_lines=[]
# 遍历列表，将每一行都加上下标
for index,line in enumerate(read_File()):
    new_lines.append(str(index+1)+'：'+line)

write_File(new_lines)

运行结果：

1

['1：hahaha\n', '2：hary\n', '3：natasha\n', '4：mary']

打开9102.txt文件

1
2
3
4

1：hahaha
2：hary
3：natasha
4：mary

实战2

在D盘python目录下创建hahaha文件夹，网上下载几张图片放进去，用代码将全部照片重命名为1.jpg，2.jpg，3.jpg,…….以此类推

在D盘python目录下创建test2.py，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import os
import re
import sys
def renameall():
    fileList = os.listdir(r"D:\python\hahaha")  #待修改文件夹
    print("修改前："+str(fileList))  #输出文件夹中包含的文件
    currentpath = os.getcwd()  #得到进程当前工作目录
    os.chdir(r"D:\python\hahaha")  #将当前工作目录修改为待修改文件夹的位置
    num=1  #名称变量
    for fileName in fileList:  #遍历文件夹中所有文件
        pat=".+\.(jpg|png|gif)"  #匹配文件名正则表达式
        pattern = re.findall(pat,fileName)  #进行匹配
        os.rename(fileName,(str(num)+'.'+pattern[0]))  #文件重新命名
        num = num+1  #改变编号，继续下一项
    print("---------------------------------------------------")
    os.chdir(currentpath)  #改回程序运行前的工作目录
    sys.stdin.flush()  #刷新
    print("修改后："+str(os.listdir(r"D:\python\hahaha")))  #输出修改后文件夹中包含的文件
renameall()

运行结果：

1
2
3

修改前：['ACG.GY_01.jpg', 'ACG.GY_02.jpg', 'ACG.GY_03.jpg', 'ACG.GY_04.jpg', 'ACG.GY_05.jpg', 'ACG.GY_06.jpg', 'ACG.GY_07.jpg', 'ACG.GY_08.jpg', 'ACG.GY_09.jpg', 'ACG.GY_10.jpg', 'ACG.GY_11.jpg', 'ACG.GY_12.jpg', 'ACG.GY_13.jpg', 'ACG.GY_14.jpg', 'ACG.GY_15.jpg', 'ACG.GY_16.jpg', 'ACG.GY_17.jpg', 'ACG.GY_18.jpg', 'ACG.GY_19.jpg', 'ACG.GY_20.jpg', 'ACG.GY_21.jpg', 'ACG.GY_22.jpg', 'ACG.GY_23.jpg', 'ACG.GY_24.jpg']
---------------------------------------------------
修改后：['1.jpg', '2.jpg', '3.jpg', '4.jpg', '5.jpg', '6.jpg', '7.jpg', '8.jpg', '9.jpg', '10.jpg', '11.jpg', '12.jpg', '13.jpg', '14.jpg', '15.jpg', '16.jpg', '17.jpg', '18.jpg', '19.jpg', '20.jpg', '21.jpg', '22.jpg', '23.jpg', '24.jpg']

关于作者

周李杰，最后一批90后，现居湖北武汉

孤独患者，懒癌中期，无脑幻想者。但却人畜无害，无需远离。

兴趣众多，然无一精通。正努力成为一个有趣的人。

1 2	> print("👆以上是不完整的我") //请我吃大餐将会了解更多 >

[TOC]

分类

Python的变量类型非常简单，主要分为：

• numbers：分为整数int和浮点数float

整数：比如1，200，400，-1000，0，通常也有用十六进制表示的，比如0xff00等

浮点数：比如1.11，12.13，-10.02，也有比较大的浮点数，比如2.12x10^9

• string：单引号，双引号，三引号

python的字符串以''或者”“或者"""括起来的随意文本都是字符串

例如：

'abcd' "hello world" """This is an apple.”""

有一点需要注意：若字符串里面包含特殊字符，可以用转义符\进行转义

1
2
3
4

# 特殊字符转义
# hahaha = 'xiao ming said "I'am full"'
hahaha = 'xiao ming said \"I\'am full\"'
print(hahaha)

运行结果：

1

xiao ming said "I'am full"

说到字符串，这里需要讲一下python的字符串format格式，一般分为两种

1）%操作符

1 2 3 4 5

> # %操作符 > name = "natasha" > age = 18 > print("your name is %s,age is %d."%(name,age)) >

运行结果：

1 2	> your name is natasha,age is 18. >

2) format

1 2 3 4 5

> # format > name = 'harry' > age = 18 > print("your name is {0},age is {1}.".format(name,age)) >

运行结果：

1 2	> your name is harry,age is 18. >

• 布尔值

python中的布尔值，只有True和False两种（切记一定要注意大小写）

布尔值的运算可以用and，or和not

1
2
3

a and b # 表示a和b都为True，最后的运算结果才是True，否则为False
a or b # 表示a或者b其中有一个为True,最后的运算结果才是True，否则为False
not # 是非运算，它是一个单目的运算，就是把True变成False，把False变成True

• 空值

python的值是用None表示，None不是0，也不是空字符串，也不是False，它是一个特殊的空值，我们可以用python的内置函数type来看一下，然后分别用0，空字符，False来比较一下，看看它到底是为何物

1
2
3
4
5
6
7
8
9

# type
print(type(None))
# 0
print(None == 0)
# 空字符
print(None == '')
# False
print(None == False)
print(None == None)

运行结果：

1
2
3
4
5

<class 'NoneType'>
False
False
False
True

Python的变量命名

python的变量名必须是大小写的英文字母，数字和下划线_的组合，切记不能使用数字开头

1
2
3
4
5
6
7

# 变量命名
a = 10
print(a)
n_1 = 100
print(n_1)
a = 'sdfdsff'
print(a)

运行结果：

1
2
3

10
100
sdfdsff

python是动态语言，它不像java是强制类型语言，是静态语言，也就是说你在定义变量的时候就要指定类型，而python是动态语言，是边编译边执行，这样正如蛇的含义所在–灵活。

关于作者

周李杰，最后一批90后，现居湖北武汉

孤独患者，懒癌中期，无脑幻想者。但却人畜无害，无需远离。

兴趣众多，然无一精通。正努力成为一个有趣的人。

1 2	> print("👆以上是不完整的我") //请我吃大餐将会了解更多 >

计算机数据存储与进制

[TOC]

python软件安装

链接：https://pan.baidu.com/s/1WrbMwSLbyeXLyDWzhaFnLA
提取码：wzvn

内涵：pycharm专业版、python3.6以及安装介绍

数据存储

在前面 我们首先思考一下，

1.为什么要使用计算机？

当然是为了存储数据、处理数据

2.数据存在哪里？

数据存储在内存当中

3.那么内存是如何存储数据的呢？

首先得先要弄清楚怎么存储数字

内存

内存是计算机存储数据的一个介质

抽象内存：一个开关，有两种状态，一种为开，一种为关，我们把开对应为1，把关对应为0。把8个开关丢入到一个房间里，那么就可以称这个房间为一个字节。一个开关代表的是一位数，每个房间都有门牌号，可以看作成地址。把无数个房间罗列起来组成一个摩天大厦，把摩天大厦看做成内存。

单位：

​ 1bit

​ 8bit == 1字节

​ 1024字节 == 1K

​ 1024K == 1M

​ 1024M == 1G

​ 1024G == 1T

进制

二进制

​ 逢二进一

​ 0 1

​ 1 + 1 = 10

八进制

​ 逢八进一

​ 0 1 2 3 4 5 6 7

​ 1 + 7 = 10

十进制

​ 逢十进一

​ 0 1 2 3 4 5 6 7 8 9

​ 1 + 9 = 10

十六进制

​ 逢十六进一

​ 0 1 2 3 4 5 6 7 8 9 a b c d e f

​ 1 + f = 10

进制转换

十进制转二进制

​ 公式：倒除法，余数逆序

1
2
3
4
5
6
7

例如55 
55除以2得27   余数1
27除以2得13   余数1
13除以2得6	 余数1
6除以2得3	 余数0
3除以2得1	 余数1
那么逆序可得110111

二进制转十进制

​ 公式：当前的数字(0、1)乘以2的位数次方，然后相加

1
2
3
4

例如110111
1 x 2^5 + 1 x 2^4 + 0 x 2^3 + 1 x 2^2 + 1 x 2^2 + 1 x 2^1 + 1 x 2^0
= 32 + 16 + 0 + 4 + 2 + 1 
= 55

八进制转二进制

​ 公式: [一转三位] 八进制的一位相当于二进制的三位，计算时按十进制转换，不足三位高位补0

1
2
3
4

例如65
6 _ _ _  计算：6除以2得3，余数0，3除以2得1，余数1. 那么6可以化为 1 1 0
5 _ _ _  计算：5除以2得2，余数1，2除以2得1，余数0. 那么5可以化为 1 0 1
总结可得65为110101

二进制转八进制

​ 公式: [三位一取] 从低位开始，每三位得到一个八进制数字，最后高位不足则补0

1
2
3
4

例如110101
0110 _ 计算：0x2^3+1x2^2+1x2^1+0x2^0 得出0+4+2+0=6
0101 _ 计算：0x2^3+1x2^2+0x2^1+1x2^0 得出0+4+0+1=5
综上述可得110101为65

十六进制转二进制

公式: [一转四位] 十六进制的一位相当于二进制的四位，计算时按十进制转换，不足四位高位补0

1
2
3
4

例如75
7 _ _ _ _ 计算：7除以2得3，余数1，3除以2得1，余数1. 那么7可以化为 0 1 1 1
5 _ _ _ _ 计算：5除以2得2，余数1，2除以2得1，余数0. 那么5可以化为 0 1 0 1
总结可得75为01110101

二进制转十六进制

公式: [四位一取] 从低位开始，每四位得到一个十六进制数字，最后高位不足则补0

1
2
3
4

例如01110101
0111 _ 计算：0x2^3+1x2^2+1x2^1+1x2^0 得出0+4+2+1=7
0101 _ 计算：0x2^3+1x2^2+0x2^1+1x2^0 得出0+4+0+1=5
综上述可得01110101为75

其实我们可使用一个简便得方法

叫做8 4 2 1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

> 例如 01100101 > 0 1 1 0 0 1 0 1 > --------------- > 8 4 2 1 8 4 2 1 > > 可得出4+2=6 4+1=5 > 得出65 > > 例如 01110101 > 0 1 1 1 0 1 0 1 > --------------- > 8 4 2 1 8 4 2 1 > > 可得出4+2+1=7 4+1=5 > 得出75 >

进制对应表

存储数据的方式

内存中存储的是数据的二进制形式
存储数据：
1、计算机先开辟空间，在存储数据，计算机开辟空间的最小单位是字节
2、在数据存储时，用最高位标识符号位，0表示正数，1表示复数

原码

原码：规定了字节数，写明了符号位，得到了数据的原码
思考：内存是以数据原码的形式存储的吗？

1
2
3
4

     0000 0000  0000 0000  0000 0000  0000 0001
+    1000 0000  0000 0000  0000 0000  0000 0001
---------------------------------------------------
     1000 0000  0000 0000  0000 0000  0000 0010   -2

结论：不以原码的形式存储数据

反码

反码：正数的反码就是其原码，负数的反码事其原码的符号位不变其他位取反
思考：内存是以数据反码的形式存储的吗？

1
2
3
4

    0000 0000  0000 0000  0000 0000  0000 0001
+   1111 1111  1111 1111  1111 1111  1111 1110
--------------------------------------------------- 
    1111 1111  1111 1111  1111 1111  1111 1111

结论：不以反码的形式存储数据

补码

补码：正数的补码是其原码(正数三码合一)，负数的补码是反码加1

1
2
3
4
5

    0000 0000  0000 0000  0000 0000  0000 0001
+   1111 1111  1111 1111  1111 1111  1111 1111
---------------------------------------------------  
  1 0000 0000  0000 0000  0000 0000  0000 0000
# 加法最后得到的1溢出了，没有存储到内存中

结论：以补码的形式存储数据

关于作者

周李杰，最后一批90后，现居湖北武汉

孤独患者，懒癌中期，无脑幻想者。但却人畜无害，无需远离。

兴趣众多，然无一精通。正努力成为一个有趣的人。

1 2	> print("👆以上是不完整的我") //请我吃大餐将会了解更多 >

[TOC]

前言

一种面向对象的解释型计算机程序设计语言

• 解释类：解释器
  • 通过解释器来翻译，类似于同声传译人员
  • 优点：更灵活
  • 缺点：效率相对低一些
  • python属于解释型
• 编译类：编译器
  • 先通过高级语言把程序写出来通过编译器解释成计算机能够看读懂的语言
  • 类似于笔译人员
  • 优点：效率更高
  • 缺点：内容有修改时需重新写，过程比较漫长

python 历史

• 作者：Guido van Rossum(龟叔)
• 语言诞生：Python是“蟒蛇”的意思。在1989年圣诞节期间，Guido身处阿姆斯特
  丹。这个都市的美丽和繁华没能填满Guido空虚的内心，周边的喧闹使他内心的寂 寞无处安放（夜的黑已不再纯粹，哈哈）。为了打发这种无趣，Guido决心为他之前孕育的ABC语言开发一个插件，这个插件就是大名鼎鼎的Python（男人因为孤独而优秀啊！）。一个新的脚本解释程序就此诞生。在给这个孩子起名字的时候，Guido取其所爱的一个叫Monty Python的喜剧团体的“Python”。
• 版本：Python2.0版本将会在2020年停止维护，Python3.0版本将是学习和开发的主流。

设计哲学与定位

• 优雅
• 简单
• 明确

python 特点

• 1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
• 2.易于阅读：Python代码定义的更清晰。
• 3.易于维护：Python的成功在于它的源代码是相当容易维护的。
• 4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
• 5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
• 6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
• 7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
• 8.数据库：Python提供所有主要的商业数据库的接口。
• 9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。
• 10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得”脚本化”的能力。

Python应用场景

• 数据分析
• 人工智能
• 网络爬虫
• 自动化运维
• GUI（桌面编程）
• WEB编程（网站后台开发 PHP、JSP、.net）
• 数据库编程
• 数学及科学计算（大数据领域）

编程特性

• 面向过程
• 面向对象
• 函数式编程

数据结构

数据结构就是通过某种方式（例如对元素进行编号）组织在一起的数据元素的集合。这些数据元素可以是数字或者字符，甚至可以是其它类型的嵌套的数据结构

python的最基本数据结构是序列

序列中的每个元素被分配一个序号——即元素的位置，也称为索引。索引从0开始编号

python包含6种内建的数据序列：

​ 列表

​ 元组

​ 字符串

​ Unicode字符串

​ buffer对象

​ xrange对象

基本的几种数据类型

1Intergral类型：

​ 整型：不可变类型（-257，201624583371143）

​ 布尔型：True、False

2 浮点类型：

​ 浮点数（3.1415926）

​ 复数（3+6j）

​ 十进制数字

3.字符串：不可变类型

​ ‘GNU is Not Unix’,”hello”,’’’world’’’

程序执行过程

编写与执行python代码

可以通过两种方式来执行python代码：

• 交互式解释器

• python程序文件

  交互式解释器与python程序文件的利弊：

​ 交互式模式下的程序执行完后难以再次运行，但是执行的代码可以立马看到效果；

​ 将编写的程序保存至文件（.py）中可以方便多次运行，但无法立马看到执行效果。

python的程序文件分类：

​ 包含一系列预编写好的语句的程序文件称作“模块”；

​ 能够直接运行的模块文件通常称作脚本（即程序的顶层文件）

逻辑操作符

and 与

or 或

not 非

控制流语句

if、for、while、try

算术操作符

+、-、、/、+=、-=、=、/=

语句和语法

​ 注释：

​ #：可以从一行的任何地方开始

​ 续行：

​ \：只能在行尾

​ ‘’’：闭合操作符，单一语句跨多行。实现多行注释、内置文档等功能

​ 代码组：

​ 缩进相同的一组语句构成的一个代码块

​ 首行以关键字开始，如if、while等，以冒号结束

​ python使用缩进来分隔代码组，同一代码组的代码行必须严格左对齐，否则会造成语法错误

​ 同一行放置多个语句：

​ ;：以分号作为分隔符

​ 模块：

​ 每个python脚本文件都可以被当成是一个模块

​ 模块里的代码可以是一段直接执行的脚本，也可以是一些类似库函数的代码从而可由别的模块执行导入（import）

​ 每一个模块被导入时会被直接执行（仅第一次），因此纯模块文件中通常不会定义函数以外的代码，否则在import时就会被执行

标识符

​ 标识符是计算机语言中允许作为名字的有效字符串集合：

​ 其中有一部分是关键字，它们是语言的标识符，因此是保留字，不能用于其它用途

​ python3的关键字有以下这些：

1
2
3
4
5

False class finally is return None continue	for	lambda try

True def from nonlocal while and del global	not	with as

elif if	or yield assert	else import	pass break except in raise

​ python还有称为”内建”的标识符集合，虽不是保留字，仍不推荐使用这些特别的名字

​ python标识符：

​ 第一个字符只能使用字母或下划线；

​ 余下的字符可以使用字母、数字或下划线；

​ 区分字符大小写

基本编程风格

​ 注释：既不能缺少注释，亦要避免过度注释

​ 文档：python允许通过doc动态获得文档字串

​ 缩进：统一缩进4个字串

​ 标识符名称：见名知义

python的变量取名

• 变量名应该做到见名知义

• 变量名区分大小写

• 变量名中有多个单词时有两种方式表示

  • 单词间使用下划线分隔（官方推荐）
  • 首单词小写，后面单词的首字母大写

• 变量名只能是由下划线、数字、字母组成，不能是空格或者特殊字符（#？<.,$!&*^~）

• 不能以中文做变量名

• 不能是保留字

  • 1	as assert break class continue def del elif else except exec finally for from global if import in is lamda not or pass print raise return try while with yield

• 所有字母都是大写表示常量

python的变量赋值

​ name = ‘tom’

​ Name2 = name

• 把变量名理解为门牌号，而把其值理解为某一个房间内存回收机制
• 变量引用值为0时自动进行内存回收
• 如何·使用变量引用值变为0
• del 变量名
• 重新给变量赋值新值

最后，给大家来一个简单的python游戏–猜数字.py

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

> #!/usr/bin/python > print("-------这是一个猜数字的小游戏-----------") > guess= int(input("猜数字:")) > i=0 > while(guess!=8 and i<3): > i=i+1 > print(i) > if guess>8: > print('大了') > if i==3: > i=i+1 > else: > guess=int(input('请重新输入：')) > else: > print('小了') > if i==3: > i=i+1 > else: > guess=int(input('请重新输入:')) > if guess==8: > print('猜对了，结束此游戏') > else: > print('你的次数已到') >

注：

以上文本部分选自 廖雪峰老师的博客

廖雪峰：十年软件开发经验，业余产品经理，精通Java/Python/Ruby/Scheme/Objective C等，对开源框架有深入研究，著有《Spring 2.0核心技术与最佳实践》一书，多个业余开源项目托管在GitHub

关于作者

周李杰，最后一批90后，现居湖北武汉

孤独患者，懒癌中期，无脑幻想者。但却人畜无害，无需远离。

兴趣众多，然无一精通。正努力成为一个有趣的人。

1 2	> print("👆以上是不完整的我") //请我吃大餐将会了解更多 >