Python学习笔记
第一章 计算机基础
1.1 硬件
计算机基本的硬件由：CPU / 内存 / 主板 / 硬盘 / 网卡 / 显卡 等组成，只有硬件但硬件之间无法进行交流和通信。
1.2 操作系统
作用：操作系统用于协同或控制硬件之间进行工作
常见的操作系统
- windows，丰富的图形化界面、收费、大量工具、适用于个人办公
- XP
- win7
- win10
- window server
- linux，性能好、占用资源少、适用于做服务器
- centos：公司线上一般用
- ubuntu
- redhat
- mac，人性化交互好、好看好用、适用于个人使用
1.3 解释器或编译器
编程语言的开发者写的一个工具，将用户写的代码转换成010101交给操作系统去执行。
1.3.1 编译型语言和解释性语言
- 编译型语言：代码写完后，编译器将其变成成另外一个文件，然后交给计算机执行
- 常见的编译型语言：C，C++，Java，C#，Go等
- 解释型语言：写完代码交给解释器，解释器会从上到下一行行代码执行：边解释边执行(实时翻译)
- 常见的解释型语言：Python，PHP，ruby等
1.4 软件(应用程序)
软件又称为应用程序，就是我们在电脑上使用的工具，类似于：记事本 / 图片查看 / 游戏
1.5 进制
对于计算机而言无论是文件存储 / 网络传输输入本质上都是：二进制（010101010101），如：电脑上存储视频/图片/文件都是二进制； QQ/微信聊天发送的表情/文字/语言/视频 也全部都是二进制。
进制：
- 2进制，计算机内部。
- 8进制
- 10进制，人来进行使用一般情况下计算机可以获取10进制，然后再内部会自动转换成二进制并操作。
- 16进制，一般用于表示二进制（用更短的内容表示更多的数据），一版是：x 开头。
| 二进制 | 八进制 | 十进制 | 十六进制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 10 | 2 | 2 | 2 |
| 11 | 3 | 3 | 3 |
| 100 | 4 | 4 | 4 |
| 101 | 5 | 5 | 5 |
| 110 | 6 | 6 | 6 |
| 111 | 7 | 7 | 7 |
| 1000 | 10 | 8 | 8 |
| 1001 | 11 | 9 | 9 |
| 1010 | 12 | 10 | a |
| 1011 | 13 | 11 | b |
| 1100 | 14 | 12 | c |
| 1101 | 15 | 13 | d |
| 1110 | 16 | 14 | e |
| 1111 | 17 | 15 | f |
| 10000 | 20 | 16 | 10 |
第二章 Python入门
2.1 环境的安装
解释器
设置环境变量（注意设置系统的环境变量）
- 多环境共存
- python2.7
- python3.6
- 开发工具：pycharm
- pycharm变更解释器
2.2 编码
2.2.1 编码基础
- ascii
- 1字节，8位
- 只包含英文和符号
- 占用内存少
- unicode(万国码)
- 4字节，32位
- 包含所有的语言
- 占用内存大
- 种类：
- ecs2
- ecs4
- 注：现在通常是用ecs4
- utf-8(对unicode的压缩)
- 1-4字节，8的倍数位(8、16、24、32位)
- 包含所有的语言
- 优化了unicode占用内存太大的问题
- 中文用3个字节表示
- utf-16
- 注：电脑上用unicode保存，其实是用的utf-16保存的
- gbk
- 已全包含中文
- 中文用2个字节表示
- gb2312(gbk的升级版)
- 已全包含中文
- 中文用2个字节表示
2.2.2 python编码相关
- python解释器默认编码（python2与python3的区别一）
- python2 解释器默认编码：ascii
- python3 解释器默认编码：utf-8
- 指定python解释器使用utf-8
- 在文件头添加：#-- coding:utf-8 - -,则完成指定
- 注：建议无论使用python2或python3执行，均添加
# -*- coding:utf-8 -*- 注意：对于操作文件时，要按照：以什么编写写入，就要用什么编码去打开。
- 单位转化
- 常用单位:位(bit),字节(byte),KB,兆(MB),GB.TB等
- 常见转化：
- 8 bit = 1 byte
- 1024 byte = 1 KB
- 1024 KB = 1 MB
- 1024 MB = 1 GB
- 1024 GB = 1 TB
2.3 输入和输出
输入
input("请输入你的姓名：")
input输入得到的内容永远是字符串
- python版本的区别（python2与python3的区别三）
- python2：name=raw_input('请输入姓名')
- python3：name=input('请输入你的姓名')
输出
- print(你想要输出的东西)
- python版本的区别（python2与python3的区别二）
- python2：print "你好"
- python3：print("你好")
- 注：python2.7以上两种均可以
2.4 变量
- 要求
- 变量名只能包含字母，数字和下划线
- 变量名不能用数字开头
- 变量名不能是python的关键字
- 建议
- 见名知意：name='alex' 或者age=18
- 名字太长用下划线：lily_dad='tom'
- 补充：LilyDad="tom" (驼峰式命名)
问：为什么要有变量？
答：为某个值创建一个“外号”，以后在使用时候通过此外号就可以直接调用。
2.5 注释
单行注释
- 行头加#
- 例：# 用户 密码
多行注释
使用三引号
例："""
用户
密码
"""
2.6 条件语句
2.6.1 基本格式
初级条件语句（if语句）
#基本格式： if 条件: print('结论一') else: print('结论二')elif语句
#基本格式： if 条件一: print('结论一') elif 条件二: #elif的数量不限制 print('结论二') elif 条件三: print('结论三') else: print('结论四')最简单（只有一个if）
#基本格式： if 条件: print('结论')if条件语句嵌套
#10086示例 message = """欢迎致电10086 1.话费查询； 2.流量服务； 3.业务办理； 4.人工服务""" print(message) index = input('请输入你要选择的服务:') index = int(index) if index==1: print('话费查询') elif index == 2: print('流量服务') elif index == 3: content = """业务办理 1. 修改密码； 2. 更改套餐； 3. 停机；""" print(content) value = input('请输入要办理的业务：') value = int(value) if value == 1: print('修改密码') elif value == 2: print('更改套餐') elif value == 3: print('停机') else: print('错误') elif index == 4: print('人工服务') else: print('输入错误')
2.6.2 三元运算(三目运算)
- 用途：用于简单的if条件语句
- 基本结构
v = 前面 if 条件 else 后面
#如果条件为真，v = 前面，否则，v = 后面
"""
相当于
if 条件:
v = 前面
else:
v = 后面
"""# 让用户输入值，如果值是整数，则转换成整数，否则赋值为None
data = input('>>>') value = int(data) if data.isdecimal() else None - 注意：现阶段先不要直接使用三元运算，先做出来，再思考如何简化
2.7 循环语句
2.7.1 while循环
- 基本循环结构
while True:
print('你想要循环的东西')- while后面加条件
while 1>0 and 1<2:
print('你好')- 关键词
pass：通过
count = 1 while count <=10: if count == 7： pass #跳过，不打印 else: print(count) count = count + 1break:终止(当前循环)
while True: print('666') while True: print('888') break #终止第二个while循环 break #终止第一个while循环continue：继续
count = 1 while count <=10: if count == 7： count = count + 1 continue #不再继续往下走，而是回到while条件的位置 print(count) count = count + 1
- while-else结构
count = 1
while count <=10:
print(count)
count = count + 1
else: #不再满足while后的条件时，或者条件=False时，触发
print(666)2.7.2 for循环
- 使用方式
name = 'alex'
for item in name:
print(item)- 注意
- 用循环打印字符串的每个元素：for > while
- 死循环：while > for
- for和while的应用场景：有穷尽优先用for，无穷尽用while
- for循环 + range
#示例：打印1 - 10
# range(0,10)：[1,2,3,4,5,6,7,8,9]
for i in range(0,11):
print(i)- range
- range(0,10,1) #[0,1,2,3,4,5,6,7,8,9]
- range(9,-1,-1) #[9,8,7,6,5,4,3,2,1,0]
- range(0,10,2) #[0,2,4,6,8]
- 前面的两个数0,10按切片理解
- 后面的一个数2代表隔一个数取一个数
- 后面的那个数正数代表从左到右取，负数代表从右到左取，不写就是默认为1
2.8 运算符
算数运算
#示例：打印1-100之间的奇数 count = 1 while count <= 100: val = count % 2 if val == 1: print(count) count = count + 1赋值运算
count += 1等价于count = count + 1
逻辑运算(and,or,not)
一般情况，用于判断(布尔类型)
二般情况，用于取值
or value = x or y
如果x转化为布尔类型为False,则value = y
如果x转化为布尔类型为True,则value = x
如果有多个or条件，则从左到右依次进行上述流程
and value = x and y
如果x转化为布尔类型为False,则value = x
如果x转化为布尔类型为True,则value = y
如果有多个and条件，则从左到右依次进行上述流程
同时有and和or条件，有括号的先算括号，没有就先算and再算or
优先级:( ) > not > and > or
补充
- in 在里面
- not in 不在里面
- 优先级补充(>优先于not)
第三章 数据类型
3.1 整型(int)
数字表示
python2
64位机器，范围-2^63~2^63-1
超出上述范围，python自动转化为long(长整型)
注：long(长整型)数字末尾有一个L
python3
- 所有整型都是int，没有long(长整型)
整型除法
- python2:只能保留整数位
- python3:可以保留所有内容
3.2 布尔(bool)
- 布尔值就是用于表示真假
- 布尔值：True和False
- 其他类型转换成布尔值：
- 整型转换为布尔值
- 0转换后是False
- 其他转换为True
- 字符串转换为布尔值
- ""转换后是False
- 其他转换为True
- 列表转换为布尔值
- []转换后是False
- 其他转换为True
- 元组转换为布尔值
- ()转换后是False
- 其他转换为True
- 字典转换为布尔值
- {}转换后是False
- 其他转换为True
- 集合转换为布尔值
- set()转换后是False
- 其他转换为True
- None转换为布尔值：False
- 整型转换为布尔值
3.3 字符串(str)
字符串是写代码中最常见的，python内存中的字符串是按照：unicode编码存储
字符串是不可变类型
字符串自己的方法：
upper/lower：字母大小写转换
- upper：字母小写转换为大写
- lower：字母大写转换为小写
v1 = 'alex'
v2 = v1.upper()
print(v2) #'ALEX'
v3 = v2.lower()
print(v3) #'alex'- isdigit：判断字符串是否为数字
v1 = 'alex'
date1 = v1.isdigit()
print(date1) #False
v2 = '666'
date2 = v2.isdigit()
print(date2) #True- strip/rstrip/lstrip：去除空格
- strip：去除左右两边的空格
- rstrip：去除右边的空格
- lstrip：去除左边的空格
v = ' alex '
date1 = v1.strip()
print(date1) #'alex'
date2 = v.rstrip()
print(date2) #' alex'
date3 = v.lstrip()
print(date3) #'alex '- replace：替换
v = '今天我要吃炒饭炒饭炒饭'
date1 = v.replace('炒饭','烤鸭') #替换所有炒饭
print(date1) #'今天我要吃烤鸭烤鸭烤鸭'
date2 = v.replace('炒饭','烤鸭'，1) #只替换第1个炒饭
print(date2) #'今天我要吃烤鸭炒饭炒饭'- split/rsplit：切割
- split：从左到右切割
- rsplit：从右到左切割
v = '今天我要吃炒饭、烧鸡、烤鸭'
date1 = v.split('、') #从左到右，切割所有的顿号
print(date1) #['今天我要吃炒饭','烧鸡','烤鸭']
date2 = v.split('、',1) #从左到右，切割第一个顿号
print(date2) #['今天我要吃炒饭','烧鸡、烤鸭']
date2 = v.rsplit('、',1) #从右到左，切割第一个顿号
print(date2) #['今天我要吃炒饭、烧鸡','烤鸭']- startswith/endswith：判断是否已什么开头/结尾
- startswith：判断是否已什么开头
- endswith：判断是否已什么结尾
v = 'alex'
date1 = v.startswith('al')
print(date1) #True
date2 = v.endswith('ex')
print(date2) #True- format：字符串格式化
date = '他叫{0}，今年{1}'.format('张三',22)
print(date) #'他叫张三，今年22'- encode：将unicode存储转换为其他编码存储
name = '张三' #解释器读取到内存后，用unicode存储
date1 = name.encode('utf-8') #将unicode存储转换为utf-8存储
date2 = name.encode('gbk') #将unicode存储转换为gbk存储- join：循环每个元素，并在元素和元素之间加入加入连接符
v = 'alex'
date = "_".join(v) #循环每个元素，并在元素和元素之间加入"_"
print(date) #'a_l_e_x'3.4 列表(list)
想要表示多个事物，可以用列表
列表是可变类型
列表自己的方法：
- append：追加
v = ['张三','李四','王五']
v.append(666)
print(v) #['张三','李四','王五'，666]- insert：插入
v = ['张三','李四','王五']
v.insert(1，666)
print(v) #['张三',666,'李四','王五']- remove：删除(指定元素)
v = ['张三','李四','王五']
v.remove('李四')
print(v) #['张三','王五']- pop：删除(索引位置的元素)
v = ['张三','李四','王五']
v.pop(o)
print(v) #['李四','王五']- clear：删除全部内容
v = ['张三','李四','王五']
v.clear(o)
print(v) #[]- extend：循环加入
v = ['张三','李四','王五']
v1 = [1,2,3]
v.extend(v1) #把v1中的元素循环追加到v中
print(v) #['张三','李四','王五',1,2,3]- reverse：反转
v = [1,3,6,4,2,5]
v.reverse()
print(v) #[5,2,4,6,3,1]- sort：排序
v = [1,3,6,4,2,5]
v.sort(reverse = False) #从小到大排序[默认：.sort()]
print(v) #[1,2,3,4,5,6]
v.sort(reverse = True) #从大到小排序
print(v) #[6,5,4,3,2,1]3.5 元组(tuple)
元组是不可变类型
没有自己的方法
3.6 字典(dict)
用于帮助用户去表示一个事物的信息(事物是有多高属性的)
字典是可变类型
字典自己的方法：
- keys：获取字典中所有的键
info = {'name':'张三','age':22,'gender':'男'}
for i in info.keys():
print(i)
"""
'name'
'age'
'gender'
"""- values：获取字典中所有的值
info = {'name':'张三','age':22,'gender':'男'}
for i in info.values():
print(i)
"""
'张三'
22
'男'
"""- items：获取字典中所有的键值对
info = {'name':'张三','age':22,'gender':'男'}
for a,b in info.items():
print(a,b)
"""
'name','张三'
'age',22
'gender','男'
"""- get：索引取值
info = {'name':'张三','age':22,'gender':'男'}
v1 = info.get('name')
print(v1) #'张三'，相当于v1 = info['name']
v2 = info.get('hobby')
print(v2) #None
v3 = info.get('hobby',666) #如果'hobby'这个键不存在就输出666
print(v3) #666- pop：删除(索引位置的元素)
info = {'name':'张三','age':22,'gender':'男'}
v = info.pop('name') #删除'name':'张三'这个键值对，并把'张三'赋值给v1
print(v) #'张三'
print(info) #{'age':22,'gender':'男'}- update：批量添加(修改)
- 不存在则添加，存在则修改
info = {'name':'张三'}
info.update({'age':22,'gender':'男','name':'李四'}) #添加'age'和'gender'，修改了'name'对应的值
print(info) # {'name':'李四','age':22,'gender':'男'}3.7 集合(set)
特性：无序性，可变性，互异性
空集合表示方式：v = set()
集合自己的方法：
- add：添加(已有的不再添加)
v = {1,2,3}
v.add(4) #添加4
v.add(3) #3是已有的，不再添加
print(v) #{1,2,3,4} - discard：删除
v = {1,2,3}
v.discard(2) #删除2
print(v) #{1,3}- update：批量添加
v = {1,2,3}
v.update({4,5,6}) #添加4,5,6
print(v) #{1,2,3,4,5,6}- intersection：交集
v = {1,2,3}
date = v.intersection({1,3,4}) #取v和{1,3,4}的交集
print(date) #{1,3}- union：并集
v = {1,2,3}
date = v.union({1,3,4}) #取v和{1,3,4}的并集
print(date) #{1,2,3,4}- difference：差集
v1 = {1,2,3}
v2 = {1,3,4}
date1 = v1.difference(v2) #取v1和v2的差集，v1中有v2中没有的
print(date1) #{2}
date2 = v2.difference(v1) #取v2和v1的差集，v2中有v1中没有的
print(date2) #{4}- symmetric_difference：对称差集
v = {1,2,3}
date = v.symmetric_difference({1,3,4}) #取v和{1,3,4}的对称差集
print(date) #{2,4}3.8 公共功能
长度：len
索引
切片
步长
#笔试题：请将字符串反转 name = 'alex' val = name[::-1] print(val) #xelafor循环
删除：del
- remove,pop和del的区别
- remove #根据值删除，不存在则报错
- deleted = li.pop(2) #删除列表中指定的一个，另将被删除的数据赋值给deleted
- del li[2] #仅仅是删除
- del li[2:4] #del还可以删除列表中指定的一段
- remove,pop和del的区别
修改
3.9 总结
- 列表(list)/字典(dict)/集合(set)
- 不能放在集合中
- 不能作为字典的键(key)
- hash(哈希)是怎么回事？
- 因为在内部会将值进行哈希算法，并得到一个数值(对应内存地址)，以后用于快速查找
- 注意：
#第1点：
info = {0,1,2,False,'你好',None,(1,2,3)}
print(info) #{0,1,2,'你好',None,(1,2,3)}
#因为False相当于0，所以False不输出
#第2点：
info = {
1:'alex', #因为True相当于1，所以把1对应的值修改了
True:'oldboy'
}
print(info) #{1:'oldboy'}3.10 嵌套
列表嵌套
#示例： users = ['alex',0,True,[11,22,33,'老男孩']] users[3] #[11,22,33,'老男孩'] users[3][-1] #'老男孩' users[3][-1][2] #'男'列表和元组嵌套
#例1 v2 = [11,22,33,(11,22,33)] v2[-1][1] = 99 #错误 v2[-1] = 99 #正确 #例2 v3 = (11,[1,2,3],22,33) v3[1] = 99 #错误 v3[1][2] = 99 #正确 #总结：列表中元素可以被修改和删除，元组中元素不可被修改和删除
3.11 数据类型的相互转换
- 整型(int)
- int('字符串')/int(布尔值)
- 布尔类型(bool)
- bool(整型)/bool('字符串')/bool(列表)/bool(元组)
- 注：只有0，""，[]，()转换成布尔是False，其余的都是True
- 字符串(str)
- str(整型)/str(布尔值)
- 要将列表/元组转换成字符串，可以用join
- 注意："".join([元素必须是字符串，元素必须是字符串])
users = ['张三','李四']
val = "".join(users)
print(val) #'张三李四'- 列表(list)
- list(元组)
- list((11,22,33)) #[11,22,33]
- list(元组)
- 元组(tuple)
- tuple(列表)
- tuple([11,22,33]) #(11,22,33)
- 总结(常见数据类型转换)：
- 字符串转数字
- 数字转字符串
- 列表转元组
- 元组转列表
- 其他转布尔
- 只有None，0，""，[]，()，{}，set()转换成布尔是False，其余的都是True
3.12 数据类型表示空
- 补充数据类型：None
- None就是python中的空
- None转化为布尔为False
- None无任何功能，专门用于提供空值
- 数据类型表示空
- None
- int：v1 = int() #0
- bool：v2 = bool() #False
- str：v3 = "" 或 v3 = str()
- list：v4 = [] 或 v4 = list()
- tuple：v5 = () 或 v5 = tuple()
- dict：v6 = {} 或 v6 = dict()
- set：v7 = set()
3.13 判断是否有敏感字符
- 字符串(str)
v = 'python全栈21期'
if '全栈' in v:
print('包含敏感字符')- 列表(list)/元组(tuple)
v = ['alex','oldboy','张三','李四']
if '李四' in v:
print('包含敏感字符')
#元组(tuple)同理- 字典(dict)
v = {'k1':'v1','k2':'v2','k3':'v3'}
#默认按照键判断，即判断x是否是字典中的键
if 'x' in v:
pass
#问题1：判断k1是否在v中？
v = {'k1':'v1','k2':'v2','k3':'v3'}
if 'k1' in v:
pass
#问题2：判断v2是否在v中？
#方法1：循环判断
v = {'k1':'v1','k2':'v2','k3':'v3'}
flag = '不存在'
for v in v.values():
if v == 'v2':
flag = '存在'
print(flag)
#方法2：
#强制转换成列表[v1,v2,v3]
if 'v2' in list(v.values()):
print('存在')
#问题3：判断k2:v2是否在v中？
value = v.get('k2')
if value == 'v2':
print('存在')
else:
print('不存在')
示例：判断用户输入内容是否有敏感字符
char_list = ['张三','李四','王五'] #敏感字符
content = input('请输入内容：')
flag = True
for i in char_list:
if i in content:
flag = False
break
if flag:
print(content)
else:
print('包含敏感字符')3.14 内存相关
列表(list)/字典(dict)/集合(set)
情况一：
v1 = [1,2,3] v2 = v1 v1.append(4) #增加 print(v2) #[1,2,3,4] #在v1里面修改(增加/删除)，v2也跟着改变- 修改内存中的元素，所有指向那个内存的值都会改变
情况二：
v1 = [1,2,3] v2 = v1 v1 = [3,4,5] #重新赋值 print(v2) #[1,2,3] #重新赋值v1，v2不改变- 重新赋值不修改内存中的元素，只改变值的指向
字符串(str)/元组(tuple)
- 只有情况二，只能重新赋值，不能修改
总结
在python中，为了提高性能，值若是以下情况(python小数据池)，就不重新开辟内存
- 常用数字：-5~256
- 简单字符串：如'alex'，除去 'alex' * 3(数字大于1) 这种情况
== 比较的是值是否相等，is 比较的是内存地址是否相等
#例1： v1 = [1,2] v2 = [1,2] v1 == v2 #True v1 is v2 #False #例2： v1 = [1,2] v2 = v1 v1 == v2 #True v1 is v2 #True- 注：python小数据池除外
3.15 深浅拷贝
基本格式
v1 = [1,2,3] import copy v2 = copy.copy(v1) #浅拷贝 v3 = copy.deepcopy(v1) #深拷贝整型int/布尔bool/字符串str(不可变类型)
- 深拷贝和浅拷贝的结果都是一样的
- 无法重新开辟一个内存地址，就使用同一个地址
列表list/字典dict/集合set(不可变类型)
- 对于其中的元素都是不可变类型时，深拷贝和浅拷贝的结果都是一样的，都是只拷贝第一层
- 对于其中元素存在可变类型时，浅拷贝只拷贝第一层，深拷贝要拷贝所有的可变类型
特殊类型：元组tuple
- 如果元组中不含有可变类型，同理字符串的深浅拷贝
- 如果元组中含有可变类型，同理列表的深浅拷贝
总结
浅拷贝：只拷贝第一层
深拷贝：拷贝嵌套层次中的所有可变类型
深拷贝之所以不拷贝不可变类型，是由于python小数据池的缘故
注意：
- 拷贝只针对可变类型：再创造一份
- 不可变类型：不会拷贝(不再创造一份出来，都是用同一个地址)
第四章 文件操作
4.1 文件基本操作
# 打开文件
f = open('要打开的文件路径',mode='r/w/a',encoding='文件原来写入时定义的编码')
# 操作
# f.write()
# f.read()
data = f.read() # 读取文件的内容到内存（全部）
f.write('要写入的内容')
# 关闭文件
f.close()# 示例一 ： 一般用于文字写入。
f = open('a.txt',mode='w',encoding='utf-8')
# a. 将 “你好” 根据encoding指定的编码转换成：
# “你好” --> 10001000 10001000 10001000 10001000 10001000 10001000
# b. 将二进制写入到文件中。
f.write('你好') # w打开文件，则write传入字符串
f.close()
# 示例二：一般用于图片/音频/视频/未知编码
f = open('a.txt',mode='wb')
# 1. 把要写入的字符串转换成二进制
data = "我好困"
content = data.encode('utf-8') # 将字符串按照utf-8编码转换成二进制
# 2. 再将二进制写到文件中
f.write(content) # wb打开文件，则write传入的是 二进制
f.close()4.2 打开模式
r / w / a：只读只写字符串
r+ / w+ / a+：可读可写字符串
rb / wb / ab：只读只写二进制
字符串转换成二进制
v = 字符串 date = v.encode('utf-8')二进制转换成字符串
v = 二进制 date = v.decode('utf-8')
r+b / w+b / a+b ：可读可写二进制
4.3 操作
read() , 全部读到内存
read(1)
1表示一个字符
obj = open('a.txt',mode='r',encoding='utf-8') data = obj.read(1) # 1个字符 obj.close() print(data)1表示一个字节
obj = open('a.txt',mode='rb') data = obj.read(3) # 1个字节 obj.close()
write(字符串)
obj = open('a.txt',mode='w',encoding='utf-8') obj.write('中午你') obj.close()write(二进制)
obj = open('a.txt',mode='wb') # obj.write('中午你'.encode('utf-8')) v = '中午你'.encode('utf-8') obj.write(v) obj.close()seek(光标字节位置)，无论模式是否带b，都是按照字节进行处理。
obj = open('a.txt',mode='r',encoding='utf-8') obj.seek(3) # 跳转到指定字节位置 data = obj.read() obj.close() print(data) obj = open('a.txt',mode='rb') obj.seek(3) # 跳转到指定字节位置 data = obj.read() obj.close() print(data)tell(), 获取光标当前所在的字节位置
obj = open('a.txt',mode='rb') # obj.seek(3) # 跳转到指定字节位置 obj.read() data = obj.tell() print(data) obj.close()flush，强制将内存中的数据写入到硬盘
v = open('a.txt',mode='a',encoding='utf-8') while True: val = input('请输入：') v.write(val) v.flush() v.close()
4.4 关闭文件
- 基本方式
v = open('a.txt',mode='a',encoding='utf-8')
v.close()- 便捷方式
with open('a.txt',mode='a',encoding='utf-8') as v:
data = v.read()
# 缩进中的代码执行完毕后，自动关闭文件4.5 文件内容的修改
- 小文件修改
with open('a.txt',mode='r',encoding='utf-8') as f1:
data = f1.read()
new_data = data.replace('飞洒','666')
with open('a.txt',mode='w',encoding='utf-8') as f1:
data = f1.write(new_data)- 大文件修改
f1 = open('a.txt',mode='r',encoding='utf-8')
f2 = open('b.txt',mode='w',encoding='utf-8')
for line in f1:
new_line = line.replace('阿斯','死啊')
f2.write(new_line)
f1.close()
f2.close()with open('a.txt',mode='r',encoding='utf-8') as f1, open('c.txt',mode='w',encoding='utf-8') as f2:
for line in f1:
new_line = line.replace('阿斯', '死啊')
f2.write(new_line)第五章 函数
5.1 函数的本质及应用场景
截至目前：面向过程编程(可读性差/可重用性差)
对于函数编程：
本质：将N行代码拿到别处并给他起一个名字，以后通过名字就可以找到这段代码并执行
- 应用场景：
- 代码重复执行
- 代码特别多超过一屏，可以选择通过函数进行代码的分割
# 面向过程编程
user_input = input('请输入角色：')
if user_input == '管理员':
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText('管理员，我想演男一号，你想怎么着都行。', 'plain', 'utf-8')
msg['From'] = formataddr(["李邵奇", '15776556369@163.com'])
msg['To'] = formataddr(["管理员", '344522251@qq.com'])
msg['Subject'] = "亲爱的管理员"
server = smtplib.SMTP("smtp.163.com", 25)
server.login("15776556369@163.com", "qq1105400511")
server.sendmail('15776556369@163.com', ['管理员', ], msg.as_string())
server.quit()
elif user_input == '业务员':
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText('业务员，我想演男一号，你想怎么着都行。', 'plain', 'utf-8')
msg['From'] = formataddr(["李邵奇", '15776556369@163.com'])
msg['To'] = formataddr(["业务员", '业务员'])
msg['Subject'] = "亲爱的业务员"
server = smtplib.SMTP("smtp.163.com", 25)
server.login("15776556369@163.com", "qq1105400511")
server.sendmail('15776556369@163.com', ['业务员', ], msg.as_string())
server.quit()
elif user_input == '老板':
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText('老板，我想演男一号，你想怎么着都行。', 'plain', 'utf-8')
msg['From'] = formataddr(["李邵奇", '15776556369@163.com'])
msg['To'] = formataddr(["老板", '老板邮箱'])
msg['Subject'] = "亲爱的老板"
server = smtplib.SMTP("smtp.163.com", 25)
server.login("15776556369@163.com", "qq1105400511")
server.sendmail('15776556369@163.com', ['老板邮箱', ], msg.as_string())
server.quit()#函数式编程
#先不考虑是否能执行，单纯为了比较函数式编程与面向过程编程的区别
def send_email():
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
msg = MIMEText('老板，我想演男一号，你想怎么着都行。', 'plain', 'utf-8')
msg['From'] = formataddr(["李邵奇", '15776556369@163.com'])
msg['To'] = formataddr(["老板", '老板邮箱'])
msg['Subject'] = "情爱的老板"
server = smtplib.SMTP("smtp.163.com", 25)
server.login("15776556369@163.com", "qq1105400511")
server.sendmail('15776556369@163.com', ['老板邮箱', ], msg.as_string())
server.quit()
user_input = input('请输入角色：')
if user_input == '管理员':
send_email()
elif user_input == '业务员':
send_email()
elif user_input == '老板':
send_email()5.2 函数定义
- 基本定义函数
def 函数名(): #函数的定义
代码 #函数内容
函数名() #函数的执行
"""
注意：1.函数如果不被调用，则内部代码永远不会被执行
2.len(计算长度)是python内部写好的一个函数
"""- 参数(个数不限制)
def get_list_date(aaa): #aaa：形式参数(形参)
v = [11,22,33,44]
print(v[aaa])
get_list_date(1) #1：实际参数(实参)发送邮件问题
# 假如：管理员/业务员/老板用的是同一个邮箱。 """ def send_email(to): import smtplib from email.mime.text import MIMEText from email.utils import formataddr msg = MIMEText('导演，我想演男一号，你想怎么着都行。', 'plain', 'utf-8') msg['From'] = formataddr(["李邵奇", '15776556369@163.com']) msg['To'] = formataddr(["导演", to]) msg['Subject'] = "情爱的导演" server = smtplib.SMTP("smtp.163.com", 25) server.login("15776556369@163.com", "qq1105400511") server.sendmail('15776556369@163.com', [to, ], msg.as_string()) server.quit() """ def send_email(to): template = "要给%s发送邮件" %(to,) print(template) user_input = input('请输入角色：') if user_input == '管理员': send_email('xxxx@qq.com') elif user_input == '业务员': send_email('xxxxo@qq.com') elif user_input == '老板': send_email('xoxox@qq.com')练习题
# 1. 请写一个函数，函数计算列表 info = [11,22,33,44,55] 中所有元素的和。 def get_sum(): info = [11,22,33,44,55] data = 0 for item in info: data += item print(data) get_sum() # 2. 请写一个函数，函数计算列表中所有元素的和。 def get_list_sum(a1): data = 0 for item in a1: data += item print(data) get_list_sum([11,22,33]) get_list_sum([99,77,66]) v1 = [8712,123,123] get_list_sum(v1) # 3. 请写一个函数，函数将两个列表拼接起来。 def join_list(a1,a2): result = [] result.extend(a1) result.extend(a2) print(result) join_list([11,22,33],[55,66,77] # 4. 计算一个列表的长度 def my_len(arg): count = 0 for item in arg: count += 1 print(count) v = [11,22,33] my_len(v) len(v) # 5. 发邮件的示例 def send_email(role,to): template = "要给%s%s发送邮件" %(role,to,) print(template) user_input = input('请输入角色：') if user_input == '管理员': send_email('管理员','xxxx@qq.com') elif user_input == '业务员': send_email('业务员','xxxxo@qq.com') elif user_input == '老板': send_email('老板','xoxox@qq.com')
- 返回值(return)
def func(arg):
代码 #函数内容
return 9 #返回值为9，默认：return None
val = func('ads') #设置一个变量接收返回值练习题
# 1. 写函数，计算一个列表中有多少个数字，打印： 列表中有%s个数字。 # 提示：type('x') == int 判断是否是数字。 # 方式一： def get_list_counter1(data_list): count = 0 for item in data_list: if type(item) == int: count += 1 msg = "列表中有%s个数字" %(count,) print(msg) get_list_counter1([1,22,3,'alex',8]) # 方式二： def get_list_counter2(data_list): count = 0 for item in data_list: if type(item) == int: count += 1 return count v = get_list_counter1([1,22,3,'alex',8]) msg = "列表中有%s个数字" %(v,) print(msg) # 2. 写函数，计算一个列表中偶数索引位置的数据构造成另外一个列表，并返回。 # 方式一： def get_data_list1(arg): v = arg[::2] return v data = get_data_list1([11,22,33,44,55,66]) # 方式二： def get_data_list2(arg): v = [] for i in range(0,len(arg)): if i % 2 == 0: v.append(arg[i]) return v data = get_data_list2([11,22,33,44,55,66]) # 3. 读取文件，将文件的内容构造成指定格式的数据，并返回。 """ a.log文件 alex|123|18 eric|uiuf|19 ... 目标结构： a. ["alex|123|18","eric|uiuf|19"] 并返回。 b. [['alex','123','18'],['eric','uiuf','19']] c. [ {'name':'alex','pwd':'123','age':'18'}, {'name':'eric','pwd':'uiuf','age':'19'}, ] """ def a(): info = [] with open('a.log',mode='r',encoding='utf-8') as f: for line in f: line = line.strip() info.append(line) return info def b(): info = [] with open('a.log',mode='r',encoding='utf-8') as f: for line in f: line = line.strip() v = line.split('|') info.append(v) return info def c(): info = [] with open('a.log',mode='r',encoding='utf-8') as f: for line in f: line = line.strip() list = line.split('|') v = {} v['name'] = list[0] v['pwd'] = list[1] v['age'] = list[2] info.append(v) return info date1 = a() date2 = b() date3 = c() print(date1,date2,date3)
- 总结
#函数的基本结构：
#情况一
def f1():
函数内容
f1()
#情况二
def f2(a):
函数内容
f2(1)
#情况三
def f3():
函数内容
return 1
v1 = f3()
#情况四
def f4(a1,a2):
函数内容
return a1+a2
v2 = f4(1,7)第六章 模块
第七章 面向对象
第八章 网络编程
第九章 并发编程
第十章 数据库
第十一章 前端开发
第十二章 Django框架
附录 常见错误和单词
单词
| 单词 | 含义 | 补充 |
|---|---|---|
| 输出 | ||
| input | 输入 | |
| True | 正确 | 布尔值 |
| False | 错误 | 布尔值 |
| pass | 跳过，通过 | |
| break | 终止 | |
| continue | 继续 | |
| if / elif | 如果 | 条件语句 |
| else | 其他 | |
| while | 当......的时候 | while循环 |
| for | for循环 | |
| upper | 小写变为大写 | 字符串方法 |
| lower | 大写变为小写 | 字符串方法 |
| isdecimal | 判断是否为数字 | 字符串方法：isdigit类似 |
| strip / rstrip / lstrip | 去空格/去换行符/去制表符/去除指定的字符串 | 字符串方法 |
| replace | 替换 | 字符串方法 |
| split / rsplit | 切割 | 字符串方法 |
| len | 计算长度 | 公共功能 |
| startswith / endswith | 判断是否已......开头/结尾 | 字符串方法 |
| format | 字符串格式化 | 字符串方法 |
| encode | 将unicode转换成其他编码存储 | 字符串方法 |
| join | 循环每个元素，并在元素和元素之间加入连接符 | 字符串方法 |
| range | 用于for循环 | |
| append | 追加 | 列表方法 |
| insert | 插入 | 列表方法 |
| remove | 删除(指定元素) | 列表方法 |
| pop | 删除(索引位置的元素) | 列表方法，字典方法 |
| clear | 删除全部 | 列表方法 |
| del | 删除 | 公共功能 |
| extend | 循环加入 | 列表方法 |
| keys | 获取字典中的所有键 | 字典方法 |
| values | 获取字典中的所有值 | 字典方法 |
| items | 获取字典中的所有键值对 | 字典方法 |
| reverse | 反转 | 列表方法 |
| sort | 排序 | 列表方法 |
| get | 相当于索引取值 | 字典方法 |
| update | 批量添加(修改)：不存在则添加，存在则修改 | 字典方法，集合方法 |
| add | 添加 | 集合方法 |
| discard | 删除 | 集合方法 |
| intersection | 交集 | 集合方法 |
| union | 并集 | 集合方法 |
| different | 差集 | 集合方法 |
| symmetric_different | 对称差集 | 集合方法 |
| def | 函数 | |
| return | 返回值 | 函数中使用 |
错误记录
缩进错误
键错误
内容来源于网络如有侵权请私信删除
- 还没有人评论，欢迎说说您的想法！
客服
