Python入门篇_鈥榒^

前言

python入门篇，是博主结合暑期实训的学习，对python常用操作的汇总整理，偏向于个人的学习笔记，同时也加入了很多实例以便于理解❤

python入门学习网站推荐：

• 菜鸟教程（简单易懂，很适合零基础入门）
  

• 廖雪峰-python教程（清晰明了，部分知识点比菜鸟教程难些，也很适合python入门学习）
  

• CSDN平台内的python入门博客（有很多写得通俗易懂而系统便于学习的博客教程，可多看看选择最适合自己的）

1 Python简介

python下载及安装

下载地址：python官网

点击Downloads，选择自己喜好的版本即可

建议使用executable installer和安装非当前最新版本，因为最新版本往往有着不太稳定和部分报错难以搜索解决的缺点。

测试是否安装成功

• windows键（窗口形状，由四个方块组成）+R
• 在弹出窗口输入’cmd’
  
• 再输入python，显示如下即安装成功（最后输入exit()退出）
  

Pycharm的安装

Python本身是一种交互式操作，类似于一问一答，很适合学习/验证python语法或者局部代码，但也存在着代码不能保存、无法运行太大程序的缺点。故需要安装python的集成开发环境——pycharm，以便于更复杂多样的代码书写需求。

下载地址：pycharm官网

使用Pycharm编写第一个Python程序

1. 运行Pycharm,选择Create New Project,创建一个新的Python工程。
   
2. 选择’Pure Python’创建一个新的纯Python工程项目，Location表示该项目的保存路径，Interpreter 用来指定Python计时器的版本。
   
3. 右击项目(project)，选择New，再选择Python File
4. 在弹出的对话框中输入的文件名mycode，点击OK，表示创建一个Python程序的文本文件，文本文件后缀名默认.py
   
5. 在新建的mycode.py文件里，输入以下代码，并在空白处右键选择Run运行，表示输出一段hello world字符串。
6. 运行成功后，Pycharm Console窗口将显示我们的输出结果。(↙)
   

为便于使用，建议可先建立新目录，再在子目录下进行小模块代码的书写与保存

• 皮肤设置(File - settings - Appearance&Behavior - Appearance)
  
• 字体设置(File - settings - Editor - Font)
  
  国内常用的pip下载源列表:

• 阿里云 http://mirrors.aliyun.com/pypi/simple/ 中国科技大学
• https://pypi.mirrors.ustc.edu.cn/simple/ 豆瓣(douban)
• http://pypi.douban.com/simple/ 清华大学
• https://pypi.tuna.tsinghua.edu.cn/simple/ 中国科学技术大学
• http://pypi.mirrors.ustc.edu.cn/simple/

一些实用的快捷键

1. ctrl+d 快速复制一行或选中区域的几行
2. ctrl+shift+F10 (py.file执行快捷键)
3. ctrl+? 快速注释选中区域
4. 光标选中函数后点击ctrl，即可调出函数的详细说明

Debug操作

该操作使我们能观察到代码每步运行后的情况，以便于查找错误和调试代码

1. 点击待调试代码的前端，出现小红点表示选中
   
2. 点击pycharm↗小蜘蛛，或右键——Debug
   
3. 使用F8快捷键，或点击如图折现按钮，即可进行调试
   

关于注释

单行注释

#单行注释，不执行
1

多行注释：以’’‘开始，并以’’'结束

'''
                               _ooOoo_
                              o8888888o
                              88" . "88
                              (| -_- |)
                              O\  =  /O
                           ____/`---'\____
                         .'  \\|     |//  `.
                        /  \\|||  :  |||//  \
                       /  _||||| -:- |||||-  \
                       |   | \\\  -  /// |   |
                       | \_|  ''\---/''  |   |
                       \  .-\__  `-`  ___/-. /
                     ___`. .'  /--.--\  `. . __
                  ."" '<  `.___\_<|>_/___.'  >'"".
                 | | :  `- \`.;`\ _ /`;.`/ - ` : | |
                 \  \ `-.   \_ __\ /__ _/   .-` /  /
            ======`-.____`-.___\_____/___.-`____.-'======
                               `=---='
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                       佛祖保佑        永无BUG
              佛曰:
                     写字楼里写字间，写字间里程序员；
                     程序人员写程序，又拿程序换酒钱。
                     酒醒只在网上坐，酒醉还来网下眠；
                     酒醉酒醒日复日，网上网下年复年。
                     但愿老死电脑间，不愿鞠躬老板前；
                     奔驰宝马贵者趣，公交自行程序员。
                     别人笑我忒疯癫，我笑自己命太贱；
                     不见满街漂亮妹，哪个归得程序员？
'''
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

2 变量及类型

变量及类型

# 变量 = 值； 将右侧的值放入左侧的容器中
bing = 'elephant'

#两边不对等(注意*的作用)
b1, b2, *b3 = 'a', 'b', 'c', 'd', 'e'
print(b1, b2, b3)

b1, *b2, b3 = 'a', 'b', 'c', 'd', 'e'
print(b1, b2, b3)
1
2
3
4
5
6
7
8
9

运行结果

a b ['c', 'd', 'e']
a ['b', 'c', 'd'] e
1
2

变量没有类型，数据才有类型

'''
数值类型      example
    整型      age = 18
    浮点型    salary = 17.32
字符串        book = 'little prince'
布尔类型      True & False 首字母大写
列表          classroom = [21, 7, 'hello', True, [212,323]]
元组          weather = ('Wuhan', 30)
字典          content = {'name':'xiaoming', 'height':'172cm', 'hobby':'running'}
'''
1
2
3
4
5
6
7
8
9
10

变量的取名

命名规则：

1. 标识符由字母、下划线和数字组成，且数字不能开头。
2. 严格区分大小写。
3. 不能使用关键字。（pycharm中蓝色高亮部分）

关键字的概念 一些具有特殊功能的标识符，这就是所谓的关键字。 关键字，已经被python官方使用了，所以不允许开发者自己定义和关键字相同名字的标识符。

驼峰命名法：

• 小驼峰式命名法（lower camel case）： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog
• 大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：FirstName、LastName.

输出

print('hello world') #一般输出
user = 'ZhangSan'
print('hello %s' % user) #格式化输出
age = 17
print('%s is %d years old' % (user, age))
1
2
3
4
5

运行结果：

hello world
hello ZhangSan
ZhangSan is 17 years old
1
2
3

常用格式符号

换行输出

print('=======我的名片=======')
print('姓名：%s\nQQ: %d\n手机号: %d\n公司地址: %s' % (name, QQ, tel, address))
print('======================')
1
2
3

结果输出：

=======我的名片=======
姓名：chris
QQ: 2736368065
手机号: 159654538769
公司地址: Wuhan
======================
1
2
3
4
5
6

边框简化写法（效果与上同）：

print('='*7 + '我的名片' + '='*7)
print('姓名：%s\nQQ: %d\n手机号: %d\n公司地址: %s' % (name, QQ, tel, address))
print('='*20)
1
2
3

输入

password = input("请输入密码:") #接收用户输入
print('您刚刚输入的密码是:%s' % password)
1
2

输出结果：

注意，这里不管我们输入什么类型的数据，最终的结果都是字符串(%s)

print(type(password))
<class 'str'>
1
2

类型转换

常见类型转换

实例：

num1 = '545'
print(type(num1))

num2 = 345
print(type(num2))

# print(num1 + num2)   TypeError: can only concatenate str (not "int") to str
print(int(num1) + num2)
print(num1 + str(num2))
1
2
3
4
5
6
7
8
9

输出结果：

<class 'str'>
<class 'int'>
890
545345
1
2
3
4

关于布尔值

#为假的情况
#整形的 0
#浮点型的 0.0
#空白字符串''转成假    ‘ ’代表空格与空白是两个意思
#空列表 []
#空元组 ()
#空字典 {}
#空集合 set()
1
2
3
4
5
6
7
8

以上情况为假，其余为真

示例

print(bool(set()))
print(bool(0.0))
1
2

结果

False
False
1
2

其他类型转换

3 运算符

算术运算符

示例：

num1 = int(input('the 1st number:')) #input最终的数据类型是字符串
num2 = int(input('the 2nd number')) #因此需要转成整型
#加
print(num1 + num2)
#商
print(num1/num2)
#取余
print(num1 % num2)
#整除
print(num1//num2)
#指数
print(num1**num2)
1
2
3
4
5
6
7
8
9
10
11
12

结果：

the 1st number:3
the 2nd number7
10
0.42857142857142855
3
0
2187
1
2
3
4
5
6
7

比较运算符

比较运算符返回结果一定是布尔类型
一个等号是赋值，’=='表判断是否相等

示例1

print(3==4)
print(3!=4)
print(3<=4)
print(3>=4)
1
2
3
4

输出结果：

False
True
True
False
1
2
3
4

示例2
当布尔参与运算时， False转0 True转1

a = 100
b = False # False转0
print(a*b - 1)
1
2
3

输出结果：

-1
1

示例3

time = 15678
hour = time // 3600 #整除
min = time % 3600 // 60
second = time % 60 #取余

print('%d时%d分%d秒' % (hour, min, second))
print(f'{hour}时{min}分{second}秒') #f-字符串格式化
1
2
3
4
5
6
7

输出结果

4时21分18秒
4时21分18秒
1
2

逻辑运算符

• and（并） 均满足时，结果才是True
• or（或） 只要有一个满足，结果为True
• not（取反）

逻辑运算符返回结果不一定是bool类型

短路运算：从左往右运算

and 左边开始，只要是真，继续往后走。若遇假，立即停止，后面不管

print('adw' and 3223 and 0 and 3>4)
0
1
2

or 左边开始，只要是假，继续往右走。若遇真，立即停止，后面不管

print(0 or 0.0 or [] or 18 or ())
18
1
2

4 流程控制语句

4.1 条件判断语句

if…else语句

age = 18

if age > 18:
    print('成年人的世界没有容易二字，但年轻人不至于躺平')
else:
    print('人总要学会长大')
1
2
3
4
5
6

人总要学会长大
1

elif语句的使用

score = float(input('请输入成绩：'))
if score < 60:
    print('未及格')
elif score < 80:
    print('合格')
elif score < 90:
    print('良好')
else:
    print('优秀')
1
2
3
4
5
6
7
8
9

请输入成绩：85
良好
1
2

if语句嵌套

ticket = 1 # 1买票 0未买票
knife_length = 9 #cm
tep = 36

if ticket == 1:
    print('请排队安检')
    if knife_length <= 9:
        print('通过安检')
        if tep <= 36.5:
            print('体温正常')
        else:
            print('就地等候，需进一步检查身体状况')
    else:
        print('刀具过长，强制没收')
else:
    print('请购票进站')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

请排队安检
通过安检
体温正常
1
2
3

应用：猜拳游戏

分析：
游戏双方 电脑*用户 两者随机出下面三种中的一个
剪刀0 石头1 布2
用户赢得情况(左侧) 0-2 1-0 2-1（也就是说如果电脑出2，用户出0即赢得游戏）

代码实现

#用户赢得情况(左侧) 0-2  1-0 2-1

import  random
computer = random.randint(0,2) #随机出[0,2]中的一个整数
print(computer)

user = int(input('请输入你的选择:(0-剪刀，1-石头， 2-布):'))


if (user==0 and computer==2) or (user==1 and computer==0) or (user==2 and computer==1):
    print('恭喜获胜')
elif user == computer:
    print('难分伯仲，决战到天亮')
else:
    print('失败是成功他爸，加油')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行结果：

4.2 循环语句

while语句

while语法：

while 判断条件: （直至条件不满足，跳出循环）
    代码块
1
2

示例：求1~100所有偶数的和

res = 0 #求和容器
i = 0
while i <= 100:
    if i % 2 == 0:
        res = res + i
    i += 1
print(res)
1
2
3
4
5
6
7

2550
1

这里也可以使用range，注意range左闭右开

res = 0
for x in range(1,101):
    if x % 2 == 0:
        res = res + x
print(res)
1
2
3
4
5

2550
1

break和continue的使用

#不断的询问用户，"我爱你，你爱我吗?"，只有用户回答"爱"时，结束循环。
print('I love you, you too?')
answer = input('please put your answer:(yes) or (no)')
while 'start': 
    if answer == 'yes':
        print('❤'); break #结束整个循环
    else:
        print('┭┮﹏┭┮'); continue #结束本次循环，继续后面的循环
1
2
3
4
5
6
7
8

嵌套循环

1.生成矩形

i = 0
while i < 10: #控行
    i += 1
    j = 0
    while j < 8: #控列
        j += 1
        print('*',end = ' ') 
    print() 
1
2
3
4
5
6
7
8

最终效果：

* * * * * * * * 
* * * * * * * * 
* * * * * * * * 
* * * * * * * * 
* * * * * * * * 
* * * * * * * * 
* * * * * * * * 
* * * * * * * * 
* * * * * * * * 
* * * * * * * * 
1
2
3
4
5
6
7
8
9
10

2.倒置的九九乘法表

i = 10
while 1 <= i <= 10:
    i -= 1
    j = 0
    while j < i:
        j += 1
        print(i,'x',j,'=',i*j,end='')
    print()
1
2
3
4
5
6
7
8

最终效果：

9 x 1 = 99 x 2 = 189 x 3 = 279 x 4 = 369 x 5 = 459 x 6 = 549 x 7 = 639 x 8 = 729 x 9 = 81
8 x 1 = 88 x 2 = 168 x 3 = 248 x 4 = 328 x 5 = 408 x 6 = 488 x 7 = 568 x 8 = 64
7 x 1 = 77 x 2 = 147 x 3 = 217 x 4 = 287 x 5 = 357 x 6 = 427 x 7 = 49
6 x 1 = 66 x 2 = 126 x 3 = 186 x 4 = 246 x 5 = 306 x 6 = 36
5 x 1 = 55 x 2 = 105 x 3 = 155 x 4 = 205 x 5 = 25
4 x 1 = 44 x 2 = 84 x 3 = 124 x 4 = 16
3 x 1 = 33 x 2 = 63 x 3 = 9
2 x 1 = 22 x 2 = 4
1 x 1 = 1
1
2
3
4
5
6
7
8
9

3.寻找水仙花数

for i in range(100,1000):
    a = i // 100
    b = (i - 100*a) // 10
    c = i - 100*a - 10*b
    if (a**3 + b**3 + c**3 == i): #注意：这里用**，而不是^
        print('%d是水仙花数' % i)
1
2
3
4
5
6

最终结果：

153是水仙花数
370是水仙花数
371是水仙花数
407是水仙花数
1
2
3
4

4.折叠次数的求解
一张纸的厚度是0.08mm，请问折叠几次达高度 8848.13m

x = 0.08*10**(-3)
i = 0
while True:
    x *=2
    i += 1
    if x > 8848.13:
        break
print(i)

1
2
3
4
5
6
7
8
9

最终结果：

27
1

4.百马马百担问题

for b in range(1,100//3 + 1):
    for m in range(1, 100//2 + 1):
        for s in range(2,100,2):
            if b+m+s == 100 and b*3+m*2+s//2 == 100:
                print('大马：%d； 中马：%d；小马：%d' % (b,m,s))
1
2
3
4
5

输出结果：

大马：2； 中马：30；小马：68
大马：5； 中马：25；小马：70
大马：8； 中马：20；小马：72
大马：11； 中马：15；小马：74
大马：14； 中马：10；小马：76
大马：17； 中马：5；小马：78
1
2
3
4
5
6

for循环

语句：
for 临时变量 in 可迭代对象：
满足条件时执行的代码

可迭代对象：
字符串、列表、字典、元组、集合
‘’’

for i in 'happy':
    print(i)
1
2

h
a
p
p
y
1
2
3
4
5

5 字符串、元组、列表、字典、集合

切片

切片的语法：[起始:结束:步长]，也可以简化使用 [起始:结束]

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。

#切片
str = '敢问路在何方，路在脚下'
print(str[7]) #python从0开始
print(str[2:7]) #有头没尾
print(str[2:7:2])
print(str[2:7:-1]) #步长为-1，表示从右往左取，而2：7是从左到右，故取不到值
print(str[7:2:-1])
print(str[-3:-1])
1
2
3
4
5
6
7
8

路
路在何方，
路何，

路，方何在
在脚
1
2
3
4
5
6

列表的切片操作与字符串类似

5.1 字符串常见操作

• 获取长度:len
• 查找内容:find,index,rfind,rindex
  find——查找指定内容在字符串中是否存在，如果存在就返回该内容在字符串中第一次出现的开始位置索引值，如果不存在，则返回-1
• 判断:startswith,endswith,isalpha,isdigit,isalnum,isspace

mystr = '1234' #判断字符是否为纯数字
print(mystr.isdigit()) # True 
1
2

• 计算出现次数:count
• 替换内容:replace
• 切割字符串:split,rsplit,splitlines,partition,rpartition

str1 = 'a,b,c,d,e'
print(str1.split(','))
print(str1.split(',',2)) #切两次
print(str1.partition('b')) #把str1以b分割成三部分,b前，b和b后，三部分组成一个元组
1
2
3
4

['a', 'b', 'c', 'd', 'e']
['a', 'b', 'c,d,e']
('a,', 'b', ',c,d,e')
1
2
3

• 修改大小写:capitalize,title,upper,lower

mystr = 'hello world'
print(mystr.title()) # Hello World 每个单词首字母大写
1
2

• 空格处理:ljust,rjust,center,lstrip,rstrip,strip

str = 'hello'
print(str.ljust(10))  # 保留左侧内容，在右边补了五个空格
print(str.rjust(10))  #返回指定长度的字符串
print(str.center(10))  # 两端加空格，让内容居中

str = '    he   llo      '
print(str.lstrip())  #只去掉了左边的空格
print(str.rstrip())  #        右
print(str.strip())  #删除两端空格
1
2
3
4
5
6
7
8
9

hello     
     hello
  hello   

he   llo      
    he   llo
he   llo
1
2
3
4
5
6
7

• 字符串拼接:join

mystr = 'a'
print(mystr.join('hxmdq'))  #haxamadaq  把hxmd一个个取出，并在后面添加字符a. 最后的 q 保留，没有加 a
print(mystr.join(['hi','hello','good']))  #hiahelloagood
1
2
3

haxamadaq
hiahelloagood
1
2

注意：在Python中，字符串是不可变的！所有的字符串相关方法，都不会改变原有的字符串，都是返回一个结果，在这个新的返回值里，保留了执行后的结果！

5.2 列表的常见操作

增

animals.append('cat') #末尾添加
print(animals)
animals.insert(3,'duck') #指定位置前添加元素
print(animals)

a = ['a','b','c']
b = ['d','e','f']
a.extend(b) #通过extend可以将另一个集合中的元素逐一添加到列表中
print(a)  # ['a', 'b', 'c', 'd', 'e', 'f'] 将 b 添加到 a 里
print(b) # ['d','e','f'] b的内容不变
1
2
3
4
5
6
7
8
9
10

['panda', 'chicken', 'horse', 'dog', 'cat']
['panda', 'chicken', 'horse', 'duck', 'dog', 'cat']
['a', 'b', 'c', 'd', 'e', 'f']
['d', 'e', 'f']
1
2
3
4

删
列表元素的常用删除方法有：

• del：根据下标进行删除
• pop：删除最后一个元素
• remove：根据元素的值进行删除

#del
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------%s' % movieName)
del movieName[2]
print('------删除之后------%s' % movieName)

#pop
movieName.pop()
print('------删除之后------%s' % movieName)

#remove
movieName.remove('指环王')
print('------删除之后------%s' % movieName)
1
2
3
4
5
6
7
8
9
10
11
12
13

------删除之前------['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']
------删除之后------['加勒比海盗', '骇客帝国', '指环王', '霍比特人', '速度与激情']
------删除之后------['加勒比海盗', '骇客帝国', '指环王', '霍比特人']
------删除之后------['加勒比海盗', '骇客帝国', '霍比特人']
1
2
3
4

改

# 定义变量A，默认有3个元素
A = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
A[1] = 'xiaoLu' #修改第二个元素
print(A)
1
2
3
4

['xiaoWang', 'xiaoLu', 'xiaoHua']
1

查

• in 和 not in （存不存在）
• index（查找位置，无则报错） 和 count（对元素出现的次数计数）

a = ['a', 'b', 'c', 'a', 'b']
a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
1
2
3
4
5
6
7
8
9
10
11

遍历循环

使用while：

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
length = len(namesList)  # 获取列表长度
i = 0
while i<length:
    print(namesList[i])
    i+=1
1
2
3
4
5
6

xiaoWang
xiaoZhang
xiaoHua
1
2
3

使用for:

res = []
for x in range(5):
    res.append([0]*3)
print(res)
1
2
3
4

[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
1

嵌套操作

schoolNames = [
[1, 2, 3],
[11, 22, 33],
[111, 222, 333]
 ]
schoolNames[1][2]  # 获取数字 33
33
schoolNames[1][2] = 'abc'  # 把 33 修改为 'abc'
schoolNames
[[1, 2, 3], [11, 22, 'abc'], [111, 222, 333]]
schoolNames[1][2][2]  # 获取 'abc' 里的字符c
'c'
1
2
3
4
5
6
7
8
9
10
11
12

列表生成式

res = [x for x  in range(1,101) if x%2==0]  #列表生成式
print(res)
# 通过列表生成式能使代码更加简洁

res = [x+y for x in 'abc' for y in '123']
print(res)  #['a1', 'a2', 'a3', 'b1', 'b2', 'b3', 'c1', 'c2', 'c3']
1
2
3
4
5
6

两种列表元素去重的方法

names = ['z','l','d','z']
res = list(set(names)) #利用集合不重复的性质
print(res)

res = []
for x in names:
    if x not in res:
        res.append(x)
print(res)
1
2
3
4
5
6
7
8
9

['d', 'l', 'z']
['z', 'l', 'd']
1
2

5.3 元组

元组是不可变类型，跟字符串一样，原来结果永不变。所以该数据类型非常适用于固定数据或想避免改变原数据的情况。

python可变类型：列表 字典 集合
不可变类型：整型 字符串 元组 bool

w1 = ('hahaha')
print(type(w1))
w2 = ('hahaha',) #声明元组，不得缺失','
print(type(w2))
1
2
3
4

<class 'str'>
<class 'tuple'>
1
2

元组的不可变性

nums = (12,3,23,5,43,54,88,98)
res = sorted(nums) #原元组永不改变，结果放至新容器中
print(res)
print(nums)
1
2
3
4

[3, 5, 12, 23, 43, 54, 88, 98]
(12, 3, 23, 5, 43, 54, 88, 98)
1
2

5.4 字典的常见操作

• 字典的键必须是不可变类型（一般为字符串），而value可以是任意类型
• 字典的键不要重复，否则后边的会把前面的覆盖掉

info = {'name':'如花', 'id':666, 'sex':'f', 'address':'地球亚洲中国上海'}

# 查看元素
print(info['address'])  # 字典使用键来获取对应的值

# 修改元素
info['id'] = 200  # 为已存在的键赋值就是修改
print('修改之后的id为 %s:' % info)

#添加元素
info['age'] = 18  # 为不存在的键赋值就是添加元素，也可使用update合并字典
print('添加之后的字典为:%s' % info)

# 删除元素
del info['id']  # del 可以通过键删除字典里的指定元素
print('删除后,%s' % info)

info2 = {'name':'monitor', 'id':100}
del info2  # del 也可以直接删除变量


info.clear() #clear清空整个字典
print('清空后,%s'%info)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

结果：

地球亚洲中国上海
修改之后的id为 {'name': '如花', 'id': 200, 'sex': 'f', 'address': '地球亚洲中国上海'}:
添加之后的字典为:{'name': '如花', 'id': 200, 'sex': 'f', 'address': '地球亚洲中国上海', 'age': 18}
删除后,{'name': '如花', 'sex': 'f', 'address': '地球亚洲中国上海', 'age': 18}
清空后,{}
1
2
3
4
5

字典的遍历

遍历键：（遍历值的操作与之类似）

person = {
    'name': 'zhangsan',
    'sex' : 'male',
    'hobby': 'running'
}
for x in person.keys():
    print(x,':',person[x])
1
2
3
4
5
6
7

name : zhangsan
sex : male
hobby : running
1
2
3

遍历字典的键值对(.items)：

for key,value in person.items():
    print(key,value)
1
2

name : zhangsan
sex : male
hobby : running
1
2
3

enumerate()
该函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

chars = ['a', 'b', 'c', 'd']
for i, chr in enumerate(chars):
    print("%d %s"%(i, chr))
1
2
3

0 a
1 b
2 c
3 d
1
2
3
4

5.5 集合

集合（set）是一个无序的不重复元素序列，可以使用大括号 { } 或者 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

因为集合无序，所以同一代码的输出结果或并不相同

并、添、移、删

p1 = {'qsw','sas','swqsq'}
p2 = {'sas','sw','sq'}

#合并
res = p1.union(p2)
print(res)

#添加元素
res.add('akui')
print(res)

#移除元素
res.remove('swqsq')
print(res)

#随机删除
res.pop()
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

{'sq', 'sas', 'qsw', 'sw', 'swqsq'}
{'sq', 'sas', 'qsw', 'akui', 'sw', 'swqsq'}
{'sq', 'sas', 'qsw', 'akui', 'sw'}
{'sas', 'qsw', 'akui', 'sw'}
1
2
3
4

集合运算:

first = {'李白','杜甫','李商隐','白居易','苏轼'}
second={'李白','杜甫','王维','孟浩然'}

#print(first+second) # 集合不支持+
print(first-second) # 差集
print(first & second) # 交集
print(first | second) # 并集
print(first ^ second)# 异部分，即集合独特之处}
1
2
3
4
5
6
7
8

{'苏轼', '白居易', '李商隐'}
{'杜甫', '李白'}
{'白居易', '苏轼', '王维', '杜甫', '李商隐', '孟浩然', '李白'}
{'白居易', '苏轼', '王维', '李商隐', '孟浩然'}
1
2
3
4

6 函数

6.1 函数基础

函数是对语句的封装（类似于ppt中的模板，当我们想达成某一效果时，只需选用相应的模板填入内容即可。）

定义：

def 函数名():
    代码
1
2

函数写好后，需要调用才能实现功能

def tell_story():
    print('once upon a time...')

age = int(input('please tell me your kid\'s age:'))
if 0 <= age <= 3:
    for i in range(3):
        tell_story()
elif age <= 5:
    for i in range(2):
        tell_story()
else:
    tell_story()
1
2
3
4
5
6
7
8
9
10
11
12

带参数的函数

def ad(a,b):
    c = a + b
    print(c)

ad(5,1) #结果为6
1
2
3
4
5

函数返回值

def ad(a,b):
    return a + b 
    print('see') #函数遇return，后边的代码就不执行了

print(ad(12,8)) #最后用print来打印返回结果
1
2
3
4
5

20
1

函数调用函数

求n的阶乘

# n的阶乘
def factorial(n:int):
    '''
    求阶乘
    :param n: int 一个数字
    :return: 结果
    '''
    x = 1
    for i in range(1,n+1):
        x *= i
    return x
print(factorial(5))
1
2
3
4
5
6
7
8
9
10
11
12

120
1

求m阶乘的和

def qsf(m:int):
    s = 0
    for i in range(1,m+1):
        s += factorial(i)
    return s

print(qsf(6))
1
2
3
4
5
6
7

873
1

6.2 函数进阶

返回多个值的情况

def tech(num1:int, num2:int):
    x = num1 // num2
    y = num1 % num2
    return x,y #返回元组
    #return  [x,y] #返回列表
1
2
3
4
5

可变参数

可变位置参数

def add(*args): #*args 可变位置参数
    res = sum(args)
    return res

print(add(5,7,8))
1
2
3
4
5

20
1

关键字参数以字典形式保存，且永远放在参数列表的末尾

def test(**kwargs): #关键字参数会以字典形式保存到kwargs中
    res = {key:value for key,value in kwargs.items()}
    return res
print(test(name='景天',love='雪见',said='抬头能看到的不是云，是天'))
1
2
3
4

{'name': '景天', 'love': '雪见', 'said': '抬头能看到的不是云，是天'}
1

6.3 匿名函数

为更好理解，我们先来看如下例子：

def calculate(a,b,fn):
    """
    :param a: 第一个数字
    :param b: 第二个数字
    :param fn: 函数
    :return: 返回结果c
    """
    c = fn(a,b)
    return c

def add(x,y):
    return x + y

def minus(x,y):
    return x - y

res1 = calculate(10,20,add) #这里不要传()
print(res1) #因为这里由calculate执行add，如果传入()，则代表add自己执行了

res2 = calculate(20,10,minus)
print(res2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

30
10
1
2

用lambda关键词能创建小型匿名函数。(这种函数得名于省略了用def声明函数的标准步骤) 从而可以实现与上面相同的功能。

lambda 参数列表: 运算表达式

print(calculate(10,20,lambda x,y:x+y))
print(calculate(20,10,lambda x,y:x-y))
1
2

30
10
1
2

匿名函数的应用：

1 按年龄排序

students = [
    {'name':'Shelly','age':20,'height':163},
    {'name':'Linda','age':22,'height':160},
    {'name':'Mike','age':21,'height':183},
    {'name':'June','age':22,'height':175}
]
students.sort(key = lambda s:s['age'], reverse = True)
print(students)

1
2
3
4
5
6
7
8
9

[{'name': 'Linda', 'age': 22, 'height': 160}, {'name': 'June', 'age': 22, 'height': 175}, {'name': 'Mike', 'age': 21, 'height': 183}, {'name': 'Shelly', 'age': 20, 'height': 163}]
1

2 寻找大于18的年龄

ages = [12,23,45,7,18,19,20]
# filter()返回的是一个对象，需要转成list
res = list(filter(lambda s:s>18,ages))
print(res)
1
2
3
4

[23, 45, 19, 20]
1

3 统一涨薪

salaries = [10000,11000,15000,21000,9000]
res = list(map(lambda s:s+2000, salaries))
print(res)
1
2
3

[12000, 13000, 17000, 23000, 11000]
1

7 面向对象

面向对象与面向过程

• 面向过程：根据业务逻辑从上到下写代码。
• 面向对象：将变量与函数绑定到一起，分类进行封装，每个程序只要负责分配给自己的分类，这样能够更快速的开发程序，减少了重复代码。

面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程的思路是将数据与函数按照执行的逻辑顺序组织在一起，数据与函数分开考虑，面向过程基本是由函数组成的。

01.面向过程编程

面向过程编程的关注点在于怎么做

• 把完成某一个需求的 所有步骤 从头到尾 逐步实现
• 根据开发需求，将某些 功能独立 的代码 封装 成一个又一个 函数
• 最后完成的代码，就是顺序地调用 不同的函数

特点:

• 注重步骤与过程，不注重职责分工
• 如果需求复杂，代码会变得很复杂
• 开发复杂项目，没有固定的套路，开发难度很大！
  

02.面向对象基本概念

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）和面相对象，是两种不同的编程方式。

面向对象编程的关注点在于谁来做

相比较函数，面向对象是更大的封装，根据职责在 一个对象中封装多个方法

• 在完成某一个需求前，首先确定职责 —— 要做的事情（方法）
• 根据 职责 确定不同的 对象，在对象内部封装不同的方法（多个）
• 最后完成的代码，就是顺序地调用不同对象的相应方法。

特点:

• 注重 对象和职责，不同的对象承担不同的职责。
• 更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路。
• 需要在面向过程基础上，再学习一些面向对象的语法。

面向对象编程的核心概念——类和对象

类：

对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用

• 特征其实就是一个变量，在类里我们称之为属性。
• 行为其实就是一个函数，在类里我们称之为方法。
• 类其实就是由 属性 和 方法 组成的一个抽象概念。

类就相当于制造飞机时的图纸，是一个模板。这个模板只规定了飞机的某些特征(例如大小，颜色，型号等等)和行为(例如起飞，降落，飞行等等)，它并不是一个具体的飞机，而是对飞机的一个抽象概念。它出现的目的，是为了让我们的创建飞机对象。

对象:

对象是由类创建出来的一个具体存在，可以直接使用。由哪一个类创建出来的 对象，就拥有在哪一个类中定义的属性和方法。

对象就相当于用图纸制造的飞机。在开发中，应该先有类，在类里定义好属性和行为，再根据类来创建对象。

类和对象的关系

1. 类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象。
2. 使用同一个类，能够创建出很多对象。
3. 类中定义了什么属性和方法，对象中就有什么属性和方法。
4. 不同对象对应的属性值也会不同。

面向对象基本语法

class Cat:
    """这是个猫类"""

    def eat(self):
        print("小猫在吃东西")

    def drink(self):
        print("小猫在喝水")

tom = Cat()  # 创建了一个Cat对象
tom.eat()
tom.drink()

hello_kitty = Cat()  # 又创建了一个新的Cat对象
hello_kitty.eat()
hello_kitty.drink()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

魔法方法

Python 里有一种方法，叫做魔法方法。Python 的类里提供的，两个下划线开始，两个下划线结束的方法，就是魔法方法，魔法方法在恰当的时候就会被激活，自动执行。 魔法方法的两个特点：

• 两侧各有两个下划线；
• "咒语"名字已经由 Python 官方定义好，我们不能乱写。

'''
class 类名(object)
object 是所有类的父亲
'''
#python3版本(object)可写可不写，两者效果一样
#python2 版本 写不写差别很大

    #静态的 叫属性;  如果有多个对象，每个对象的属性是各自保存的，都有各自独立的地址。
    #动态的 叫方法;  方法是所有对象共享的，只占用一份内存空间，方法被调用时会通过self来判断是哪个对象调用了实例方法。

class Person(object): #类名一般遵循‘大驼峰’命名
    def __init__(self,name,age,height):   #__init__()方法，在创建一个对象时默认被调用，不需要手动调用
        self.name = name       # 哪个对象调用了方法，方法里的self指的就是谁。
        self.age = age         # 通过self.属性名 可以访问到这个对象的属性；通过 self.方法名() 可以调用这个对象的方法。
        self.height = height

    def eat(self):
        print(f'{self.name}吃饭') #方法中可调用属性

    def sleep(self):
        print(f'{self.name}睡觉')

    def bin(self):
        print(f'{self.name}打豆豆')

    #对象格式化输出，__str__方法返回对象的描述信息
    def __str__(self): #不加str，打印对象为#<__main__.Person object at 0x00000255ED39A3C8>
        return f'姓名{self.name},年龄{self.age},身高{self.height}'

xiaoming = Person('小明',20,'180cm')
xiaoming.eat()
xiaoming.sleep()
xiaoming.bin()
print(xiaoming)
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

小明吃饭
小明睡觉
小明打豆豆
姓名小明,年龄20,身高180cm
1
2
3
4

面向对象继承

class Animal(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def sleep(self):
        print(self.name+'正在睡觉')

class Dog(Animal):
    def bark(self):
        print(self.name+'正在狂吠')

d1 = Dog('金毛',7)
d1.bark()
d1.sleep()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

重写父类的属性和方法

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def action(self):
        print(self.name + '立即行动')

    def study(self):
        print(self.name + '正在学习')

class Student(Person):
    def __init__(self,name,age,school):
        super(Student,self).__init__(name, age)
        self.school = school

    def study(self):
        print(f'孙中山对{self.school}的{self.name}说：革命尚未成功，同志仍需努力')
s1 = Student('小华',18,'奋斗大学')
s1.study()
s1.action()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

8 模块和包

几种安装包的方法

方法一（菜单操作）：
File - settings - Project - Project Interpreter - “+” - 搜索包名下载即可

方法二（pip）：

先打开Terminal（pycharm左下），通过以下命令可完成相应需求

1 使用pip list查看已下载包

(venv) C:\Users\JSJSYS\PycharmProjects\untitled>pip list
Package    Version
---------- ---------
certifi    2021.5.30
chardet    4.0.0
idna       2.10
numpy      1.21.0
pip        10.0.1
requests   2.25.1
setuptools 39.1.0
urllib3    1.26.6

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

2 pip install '包名’
这种方法很直接，但直接在官网下载经常会因各种原因卡顿、甚至下载失败。此时，我们可以去国内镜像网站下载相应包。

国内常用的pip下载源列表:

• 阿里云 http://mirrors.aliyun.com/pypi/simple/
• 中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
• 豆瓣(douban) http://pypi.douban.com/simple/
• 清华大学 https://pypi.tuna.tsinghua.edu.cn/simple/
• 中国科学技术大学 http://pypi.mirrors.ustc.edu.cn/simple/

3 pip install 包名 -i 国内源地址

pip install flask -i https://pypi.mirrors.ustc.edu.cn/simple/ 
# 从中国科技大学(ustc)的服务器上下载flask(基于python的第三方web框架)
1
2

实用操作

>pip freeze > requirements.txt
>#生成已安装包及其型号的文档
1
2

在External Libraries可查看已下载包

常见系统模块

为了方便程序员开发代码，Python提供了很多内置的模块给程序员用来提高编码效率。常见的内置模块有:

• os模块: OS全称OperationSystem,即操作系统模块，这个模块可以用来操作系统的功能，并且实现跨平台操作。

import os
os.getcwd()  # 获取当前的工作目录，即当前python脚本工作的目录
os.chdir('test') # 改变当前脚本工作目录，相当于shell下的cd命令
os.rename('毕业论文.txt','毕业论文-最终版.txt') # 文件重命名
os.remove('毕业论文.txt') # 删除文件
os.rmdir('demo')  # 删除空文件夹,文件夹非空则无法删除
os.removedirs('demo') # 删除空文件夹
os.mkdir('demo')  # 创建一个文件夹
os.chdir('C:\\') # 切换工作目录
os.listdir('C:\\') # 列出指定目录里的所有文件和文件夹
os.name # nt->widonws posix->Linux/Unix或者MacOS
os.environ # 获取到环境配置
os.environ.get('PATH') # 获取指定的环境配置

os.path.abspath(path) # 获取Path规范会的绝对路径
os.path.exists(path)  # 如果Path存在，则返回True
os.path.isdir(path)  # 如果path是一个存在的目录，返回True。否则返回False
os.path.isfile(path) # 如果path是一个存在的文件，返回True。否则返回False
os.path.splitext(path)  # 用来将指定路径进行分隔，可以获取到文件的后缀名

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

• sys模块

import sys
sys.path # 模块的查找路径
sys.argv # 传递给Python脚本的命令行参数列表
sys.exit(code) # 让程序以指定的退出码结束

sys.stdin # 标准输入。可以通过它来获取用户的输入
sys.stdout # 标准输出。可以通过修改它来百变默认输出
sys.stderr # 错误输出。可以通过修改它来改变错误删除

1
2
3
4
5
6
7
8
9

• math模块

import math
print(math.fabs(-100)) # 取绝对值
print(math.ceil(34.01))  #向上取整
print(math.factorial(5)) # 计算阶乘
print(math.floor(34.98))  # 向下取整
print(math.pi)   # π的值，约等于 3.141592653589793
print(math.pow(2, 10)) # 2的10次方
print(math.sin(math.pi / 6))  # 正弦值
print(math.cos(math.pi / 3))  # 余弦值
print(math.tan(math.pi / 2))  # 正切值

1
2
3
4
5
6
7
8
9
10
11

• random模块

print(random.random())  # 生成 [0,1)的随机浮点数
print(random.uniform(20, 30))  # 生成[20,30]的随机浮点数
print(random.randint(10, 30))  # 生成[10,30]的随机整数
print(random.randrange(20, 30))  # 生成[20,30)的随机整数
print(random.choice('abcdefg'))  # 从列表里随机取出一个元素
print(random.sample('abcdefghij', 3)) # 从列表里随机取出指定个数的元素

1
2
3
4
5
6
7

• datetime模块

import datetime
print(datetime.date(2020, 1, 1))  # 创建一个日期
print(datetime.time(18, 23, 45)) # 创建一个时间
print(datetime.datetime.now())  # 获取当前的日期时间
print(datetime.datetime.now() + datetime.timedelta(3))  # 计算三天以后的日期时间

1
2
3
4
5
6

• time模块: datetime模块主要用来显示日期时间，这里主要涉及 date类，用来显示日期；time类，用来显示时间；dateteime类，用来显示日期时间;timedelta类用来计算时间。

print(time.time())  # 获取从1970-01-01 00:00:00 UTC 到现在时间的秒数
print(time.strftime("%Y-%m-%d %H:%M:%S")) # 按照指定格式输出时间
print(time.asctime()) #Mon Apr 15 20:03:23 2019
print(time.ctime()) # Mon Apr 15 20:03:23 2019

print('hello')
print(time.sleep(10)) # 让线程暂停10秒钟
print('world')

1
2
3
4
5
6
7
8
9

• calendar模块

calendar.setfirstweekday(calendar.SUNDAY) # 设置每周起始日期码。周一到周日分别对应 0 ~ 6
calendar.firstweekday()# 返回当前每周起始日期的设置。默认情况下，首次载入calendar模块时返回0，即星期一。
c = calendar.calendar(2019)  # 生成2019年的日历，并且以周日为其实日期码
print(c)  #打印2019年日历
print(calendar.isleap(2000)) # True.闰年返回True,否则返回False
count = calendar.leapdays(1996,2010) # 获取1996年到2010年一共有多少个闰年
print(calendar.month(2019, 3))  # 打印2019年3月的日历

1
2
3
4
5
6
7
8

• hashlib模块: 一个提供字符加密功能的模块，包含MD5和SHA的加密算法，具体支持md5,sha1, sha224, sha256, sha384, sha512等算法。 该模块在用户登录认证方面应用广泛，对文本加密也很常见。

import hashlib

# 待加密信息
str = '这是一个测试'

# 创建md5对象
hl = hashlib.md5('hello'.encode(encoding='utf8'))
print('MD5加密后为 ：' + hl.hexdigest())

h1 = hashlib.sha1('123456'.encode())
print(h1.hexdigest())
h2 = hashlib.sha224('123456'.encode())
print(h2.hexdigest())
h3 = hashlib.sha256('123456'.encode())
print(h3.hexdigest())
h4 = hashlib.sha384('123456'.encode())
print(h4.hexdigest())

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

• hmac模块: HMAC算法也是一种一种单项加密算法，并且它是基于上面各种哈希算法/散列算法的，只是它可以在运算过程中使用一个密钥来增增强安全性。hmac模块实现了HAMC算法，提供了相应的函数和方法，且与hashlib提供的api基本一致。

h = hmac.new('h'.encode(),'你好'.encode())
result = h.hexdigest()
print(result)  # 获取加密后的结果

1
2
3
4

• copy模块

import copy

nums = [1, 5, 3, 8, [100, 200, 300, 400], 6, 7]
nums1 = copy.copy(nums)  # 对nums列表进行浅复制
nums2 = copy.deepcopy(nums)  # 对nums列表进行深复制

1
2
3
4
5
6

• uuid模块: UUID是128位的全局唯一标识符，通常由32字节的字母串表示，它可以保证时间和空间的唯一性，也称为GUID。通过MAC地址、时间戳、命名空间、随机数、伪随机数来保证生产的ID的唯一性。随机生成字符串，可以当成token使用，当成用户账号使用，当成订单号使用。

import uuid

print(uuid.uuid1())  # 根据时间戳和机器码生成uuid,可以保证全球唯一
print(uuid.uuid4())  # 随机生成uuid,可能会有重复

# 使用命名空间和字符串生成uuid.
# 注意一下两点:
# 1. 命名空间不是随意输入的字符串，它也是一个uuid类型的数据
# 2. 相同的命名空间和想到的字符串，生成的uuid是一样的
print(uuid.uuid3(uuid.NAMESPACE_DNS, 'hello'))
print(uuid.uuid5(uuid.NAMESPACE_OID, 'hello'))

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

9 文件操作

相对路径与绝对路径

文件的路径分为相对路径和绝对路径两种。

绝对路径：指的是绝对位置，完整地描述了目标的所在地，所有目录层级关系是一目了然的。

例如：C:/Users/chris/AppData/Local/Programs/Python/Python37/python.exe，从电脑的盘符开始，表示的就是一个绝对路径。
1

相对路径：是从当前文件所在的文件夹开始的路径。

• test.txt，是在当前文件夹查找 test.txt 文件
• ./test.txt，也是在当前文件夹里查找test.txt文件， ./ 表示的是当前文件夹。
• …/test.txt，从当前文件夹的上一级文件夹里查找 test.txt 文件。 …/ 表示的是上一级文件夹
• demo/test.txt，在当前文件夹里查找 demo这个文件夹，并在这个文件夹里查找 test.txt文件。

访问模式

文件的读取与输入(简易)

1 文件的输入

f = open('test.txt', 'w')
f.write('hello world, i am here!\n' * 5)
f.close()
1
2
3

使用write命令一定要记得close掉。使用’with open’更便捷，无需在末尾手动close。

with open('anjie.txt', 'w', encoding='utf-8') as fp:
    fp.write('you are beautiful')
1
2

2 文件的读取

with open('anjie.txt','r',encoding='utf-8') as fp:
    while True:
        content = fp.readline() #按行读取
        print(content)
        if content == '':
            break
1
2
3
4
5
6

CSV文件的读写

读

import csv
#读取csv
with open('stock.csv','r') as fp:
    reader = csv.reader(fp)
    title = next(reader) #获取表头
    #print(type(reader))
    for x in reader:
        print(x) #返回为列表，使用csv.DictWriter即可返回字典
1
2
3
4
5
6
7
8

['0', '000001.XSHE', '1', '平安银行', 'XSHE', '2017/12/1', '13.38', '13.4', '13.48', '12.96', '13', '178493315']
['1', '000002.XSHE', '2', '万科A', 'XSHE', '2017/12/1', '31.22', '30.5', '32.03', '30.5', '30.73', '55743855']
['2', '000004.XSHE', '4', '国农科技', 'XSHE', '2017/12/1', '25.56', '25.41', '26.4', '25.18', '26.2', '2211059']
#后续输出略
1
2
3
4

使用csv.DictWriter返回字典

import csv
#读取csv
with open('stock.csv','r') as fp:
    reader = csv.DictReader(fp)
    title = next(reader) #获取表头
    #print(type(reader))
    for x in reader:
        value = {'name':x['secShortName'], 'Vol':x['turnoverVol']}
        print(value)
1
2
3
4
5
6
7
8
9

{'name': '万科A', 'Vol': '55743855'}
{'name': '国农科技', 'Vol': '2211059'}
{'name': '世纪星源', 'Vol': '2365348'}
{'name': '深振业A', 'Vol': '0'}
#后续输出略
1
2
3
4
5

写

import csv
def write_csv_demo1():
    headers = ['username', 'age', 'height']
    values = [
        ('小明', 18, '175cm'),
        ('王珏', 20, '165cm'),
        ('张三', 22, '170cm'),
    ]
    with open('class_list.csv', 'w', encoding='utf8', newline='') as fp:
        writer = csv.writer(fp)
        writer.writerow(headers)
        writer.writerows(values)

if __name__=='__main__':
    #下面的代码只在当前文件写入.py中运行
    # 别的文件除非导入 之后调用 否则不运行
    write_csv_demo1()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

序列化与反序列化

通过文件操作，我们可以将字符串写入到一个本地文件。但是，如果是一个对象(例如列表、字典、元组等)，就无法直接写入到一个文件里，需要对这个对象进行序列化，然后才能写入到文件里。

设计一套协议，按照某种规则，把内存中的数据转换为字节序列，保存到文件，这就是序列化，反之，从文件的字节序列恢复到内存中，就是反序列化。

Python中提供了JSON和pickle两个模块用来实现数据的序列化和反序列化。

Json模块（JSON的本质是字符串！）

# json本质上是字符串
import json #文件只能写入字符串或二进制
# json 键和值全部是双引号
person = {
    'username': '董大',
    'age': 20,
    'height': '182'
}
with open('扛把子.txt', 'w', encoding = "utf-8") as fp:
    fp.write(json.dumps(person))

#JSON提供了dump和dumps方法，将一个对象进行序列化。
# 可以调用 json的dumps方法，传入一个对象参数
data = json.dumps(person, ensure_ascii = False) #dumps方法的作用是把对象转换成为字符串，它本身不具备将数据写入到文件的功能。
# dumps 方法得到的结果是一个字符串
print(type(data)) # <class 'str'>

#使用loads和load方法，可以将一个JSON字符串反序列化成为一个Python对象。
# 调用loads方法，传入一个字符串，可以将这个字符串加载成为Python对象
res = json.loads(data, encoding='utf-8')
print(type(res)) #<class 'dict'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<class 'str'>
<class 'dict'>
1
2

补充：利用json选出所需网页数据：

import json

data = '{"reason":"查询成功!","result":{"city":"武汉","realtime":{"temperature":"33","humidity":"64","info":"多云","wid":"01","direct":"南风","power":"4级","aqi":"33"},"future":[{"date":"2021-07-10","temperature":"28\/34℃","weather":"多云","wid":{"day":"01","night":"01"},"direct":"南风"},{"date":"2021-07-11","temperature":"28\/34℃","weather":"多云","wid":{"day":"01","night":"01"},"direct":"南风"},{"date":"2021-07-12","temperature":"27\/34℃","weather":"多云转阴","wid":{"day":"01","night":"02"},"direct":"南风"},{"date":"2021-07-13","temperature":"26\/34℃","weather":"小雨转阴","wid":{"day":"07","night":"02"},"direct":"南风"},{"date":"2021-07-14","temperature":"28\/35℃","weather":"阴转多云","wid":{"day":"02","night":"01"},"direct":"南风转东南风"}]},"error_code":0}'

res = json.loads(data)
print(res['result']['city'])

weathers = res['result']['future']
#print(weather)列表
for index, weather in enumerate(weathers):
    date = weather['date']
    temperature = weather['temperature']
    weather1 = weather['weather']
    direct = weather['direct']
    print(date,temperature,weather1,direct)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

武汉
2021-07-10 28/34℃ 多云 南风
2021-07-11 28/34℃ 多云 南风
2021-07-12 27/34℃ 多云转阴 南风
2021-07-13 26/34℃ 小雨转阴 南风
2021-07-14 28/35℃ 阴转多云 南风转东南风
1
2
3
4
5
6

正则表达式（略）

正则表达式是一个特殊的字符序列，计算机科学的一个概念。通常被用来检索、替换那些符合某个模式(规则)的文本。

许多程序设计语言都支持利用正则表达式进行字符串操作。在Python中需要通过正则表达式对字符串进行匹配的时候，可以使用re模块。re 模块使 Python 语言拥有全部的正则表达式功能。

特点：

• 灵活性、逻辑性和功能性非常强；
• 可以迅速地用极简单的方式达到字符串的复杂控制。
• 对于刚接触的人来说，比较晦涩难懂。