变量命名规则：
1.变量由字母、数字、下划线组成
2.变量不能以数字开头
3.禁止使用python中关键字
4.不能使用中文和拼音
5.变量名要区分大小写
6.变量名要有意义
7.推荐写法：
1.驼峰体
1.大驼峰 AgeOfOldboy = 56
2.小驼峰 ageofoldboy = 56
2.下划线
age_of_oldboy = 56加粗样式
python2.7和3.x的区别
2.7：代码重复 语言不统一 不支持中文 input() 输入数字 获取数字
输入字符串必须自己手动写引号
raw_input 和p3中的 input 一样
print可以加括号 也可以不加括号
p2 中除法获取到的是整型
3.x: 代码不重复
语言统一
支持中文
input()
print() 必须加括号
p3 中除法获取到的是浮点型(有小数点)
2. 注释
# 当行注释 # “”" “”" 多行注释
“”" alex wusir tiabai “”"
msg = “”" alex wusir tiabai “”"
3. 整型 int num = int(‘8’) # 通过int()把字符串8转成数字8 转换的内容必须是数字 用于比较和计算的
-
-
- /
-
- 字符串
str s = str(8) #通过str()把数字8转换成字符串8 + # 相加的时候双方必须都是字符串 * # 只能是数字和字符串相乘 - 布尔值
True 真
False 假
6.程序交互
input() 括号内的内容必须是字符串,也称为提示语句
input获取的内容都是字符串
type() # 查看数据类型 将要被查看的数据放到括号里
7.格式化输出
%s – 字符串 注意: s必须小写
%d – 整型
%i – 整型
# 注意点 : 必须按照相对应的数量来填充 使用位置来填充参数 name = ‘骚年’ f’你好{name}’ # 把变量名写到里边,不能加引号 了解*
8.if条件语句
8.1 if 条件:
代码块
8.2 if 条件:
代码块
else:
代码块
8.3 if 条件:
代码块
elif 条件:
代码块
elif 条件:
代码块
8.4 if 条件:
代码块
elif 条件:
代码块
elif 条件:
代码块
else:
代码块
8.5 if 条件:
if 条件:
代码块
1.while 循环
while -- 关键字
while 条件:
缩进循环体(代码块)
死循环 ### 条件一直为真 就形成了一个环(死循环)
# break 是跳出循环
# continue 是跳出本次循环继续下次循环(临时见底 当做代码块中最后一行)
2. 运算符
5 种
算数运算符
print(a + b) # 加
print(b - a) # 减
print(b * a) # 乘
print(b / a) # 除(有小数点)
print(b % a) # 取膜
print(b ** a) # 幂 (几次方)
print(b // a) # 整除(没有小数点)
比较运算符
a = 10
b = 20
print(b > a) # 大于
print(b < a) # 小于
print(b >= a) # 大于等于
print(b <= a) # 小于等于
print(b == a) # 等于
print(b != a) # 不等于
赋值运算符
a = 10 # a就是10
# a += 10 # a = a + 10 就是在自己的身上在就上一个自己
# print(a)
# a -= 10
# print(a) # a = a - 10
# a *= 10 # a = a * 10
# print(a)
# a /= 10 # a = a / 10
# print(a)
# a **= 10 # a = a ** 10
# print(a)
# a //= 10 # a = a // 10
# print(a)
# a %= 10 # a = a % 10
# print(a)
逻辑运算符
与 或 非
and or not
成员运算符
in 存在
not in 不存在
3. 初识编码
0 - 255
新 0001000
开 0002000
了 0003000
一 0004000
个 0005000
x 0006000
j 0007000
你 01
好 02
0001000200030004000500060007
ascii码 不支持中文
python2 默认编码是 ascii码
unicode 万国码 中文4个字节 英文2个
GBK 中文两个字节 英文一个
utf-8 最少使用8位(1字节) 欧洲 16位(2字节) 亚洲 24位(3字节)
1.整型 int()
python2 long 长整型
python3 全都是整型
2.布尔值 bool()
2.1 布尔值转换数字
True --- int()
int(True)
int --- False
bool(int)
注意点: 只有0是False
2.2 布尔值转字符串
a = ''
s = bool(a)
print(s)
a = False
print(type(a))
s = str(a)
print(s)
print(type(s))
注意点: 字符串转布尔值的时候,只要不为空就是True
3. 字符串详解
只要有特殊字符隔开才能分别认为是多个单词(中文也是特殊字符)
name = ‘Alex’
s = name.title() # 标题 每个单词首字母大写
print(s)
name = ‘alex黑哥wusir’
s = name.capitalize() #首字大写
print(s)
name = ‘ALEX黑哥wusir’
s= name.upper() # 全部大写
print(s)
s1 = name.lower() # 全部小写
print(s1)
s2 = name.count(‘w’) # 计数 统计
print(s2)
应用场景
yzm = ‘o98K’ #定义验证码
y_zm = input(“输入验证码(o98K)”) # 输入验证码
if yzm.upper() == y_zm.upper():
if O98K == O98K
print(‘验证码正确’)
else:
print(“验证码错误”)
‘’’
name = ‘alex’
将 name 变量对应的值变大写,并输出结果
将 name 变量对应的值变小写,并输出结果
将name变量对应的值首字母"a"大写,并输出结果
‘’’
name = ‘allex’
s = name.find(‘m’) # 查找索引位置 查找不存在的就返回-1
print(s)
s1 = name.index(‘m’) #索引 查找不存在的就报错(让你滚)
print(s1)
‘meet’ (下标) 索引
0123 # 从左往右
-4-3-2-1 # 从右往左
name = ‘meet’
切片
tee
print(name[0:3]) # [起始位置:终止位置] (终止的不包含)
顾头不顾腚 从左到右
print(name[-1:-4:-1]) # [起始位置:终止位置:步长] (方向)
自己不写的时候默认是1
name = ‘我在上边这么动,你在下面没反应’
元素
print(name[:-8:-1])
print(name[-1:-16:-1])
print(name[::-1])
获取s字符串中前3个内容 # Pyt
print(s[:3])
获取s字符串中第3个内容 # t
print(s[2])
获取s字符串中后3个内容 # 最NB
print(s[6:])
获取s字符串中第3个到第8个 # thon最N
print(s[2:8:1])
获取s字符串中第2个到最后一个 # ython最NB
print(s[1:])
获取s字符串中第1,3,5个内容 # Pto
print(s[0:6:2])
获取s字符串中第2,4,6个内容 # yhn
print(s[1:7:2])
获取s字符串中所有内容 # Python最NB
s = ‘Python最NB’
s1 = s[:] # 拷贝 复制
print(s1)
print(s)
获取s字符串中第4个到最后一个,每2个取一个 # hnN
print(s[3::2])
获取s字符串中倒数第5个到最开始,每3个取一个
print(s[-5::-3]) # oy
总结: 下标(索引)
从左往右 0开始 从右往左 -1 开始
切片
从左往右 [起始位置:终止位置] 如果[-1:-4] 这样可以取到内容吗? 是不可以的
步长(扯蛋) [起始位置:终止位置:步长] (方向) 默认使用是1 也就是从左往右
想要从右往左 步长写为 -1
可以一次性跨多个(例如我们写的步长为2,3,4,5)
#################################################################
‘’’
s = name.title() # 标题 每个单词首字母大写 特殊符号来隔开
print(s)
s1 = name.capitalize() # 首字母大写
print(s1)
s2 = name.upper() # 全部大写
print(s2)
s3 = name.lower() # 全部小写
print(s3)
s4 = name.count(“e”) # 计数 统计
print(s4)
s5 = name.find(“m”) # 查找索引 查找不到返回-1
print(s5)
s6 = name.index(‘m’) # 查找索引 查找不到就报错
print(s6)
‘’’
print(name)
s = name.center(100,"-")
print(s)
s7 = name.center(20,"*") # 居中 第一个放数字,第二个放要填充的内容
print(s7)
name = ‘al ex’
s8 = name.split(“e”) # 分割 ############## 非常非常重要
print(s8)
默认使用的是空格
可以将字符串转换成列表
面试题 通过代码一行把字符串转换成列表
print(s8)
ms = input(“输入账号和密码 用|分割:”)
lst = ms.split("|")
print(lst)
name = ‘alex 阿 斯 顿发 生 地方alex’
s = name.strip(“alex”) # 脱 默认脱的是头尾俩边的空格
#我们指定要脱的时候 只能脱头尾的内容
#默认脱空格和换行符 \n == 键盘上的回车
print(s)
应用场景:
user = input(“请输入用户名:”).strip()
pwd = input(“请输入密码:”).strip()
if user == ‘alex’ and pwd == ‘alex3714’:
print(‘可以取钱了’)
else:
print(‘不能取钱’)
s = name.join(’_’) #错误的示范
print(name)
lst = [‘1’,‘2’,‘3’]
s = ‘_’.join(lst) # 指定字符拼接
print(s)
自己写算法 搞定
用代码一行把列表转换成字符串
name = ’ a l e x n b ’
s = name.replace(’ ‘,’’) #替换 # 第一个是要被替换的内容,第二是要什么替换（牛逼之处）
print(s)
name = ‘wusir’
s = name.startswith(‘w’) # 以什么开始 获取的结果是布尔值
print(s)
s1 = name.endswith(‘i’) # 以什么结尾 获取的结果是布尔值
print(s1)
name = ‘武藤兰{}小{}{}’
s = name.format(‘是个’,‘心’,‘肝’) # 按照占位的顺序来填充
name = ‘武藤兰{0}小{2}{1}’
s = name.format(‘是个’,‘心’,‘肝’) # 按照索引来对应填充
name = ‘武藤兰{a}小{b}{c}’
s1 = name.format(a=‘是个’,b=‘演’,c=‘员’) # 按照关键字对应填充
格式化
print(s1)
is 系列
name = ‘12341234’
s = name.isalnum() # 判断是不是数字和字母
print(s)
s1 = name.isalpha() # 判断是不是纯字母
print(s1)
s2 = name.isdigit() # 判断是不是纯数字 ######
print(s2)
num = input(“请输入数字:”)
if num.isdigit():
num = int(num)
print(type(num))
else:
print(“你傻啊,都告诉你是数字了”)
总结:
split 分割 默认是空格 ********
strip 脱 默认脱头尾的空格 ********
replace 替换 ********
join 插入 拼接 ********
format % f ******
upper 全部大写 ******
lower 全部小写 ******
find 查找 不存在返回 -1 ******
index 查找 不存在报错 ******
isdigit 判断是不是纯数字 ******
isalpha 判断是不是纯字母 ******
count 统计 *****
title 每个单词首字母大写 *****
-
for 循环
for 关键字
i 变量(此处可以更改 更改规则参考变量命名规则)
in 关键字
可迭代对象 (想要循环谁就放谁,注意:数字除外 因为数字不可迭代)for 循环内可以进行任意操作,可以写代码块:
例如:
name = ‘alex’
for i in name:
l = input(">>>")
print(l)注意: for循环是有限循环 限制范围取决与我们的迭代对象的长度
列表
list 列表 [] 可变的
增
lst.append(8) #追加
print(lst)lst.insert(2,True) # 插入
第一个参数是插入的位置(索引)
要插入的内容
print(lst)
lst = [1,2,3,4]
lst.extend(‘alex’) # 扩展 迭代添加
print(lst)lst = [1,2,3,4]
lst1 = [5,6,7,8]print(lst + lst1) # 把来个列表合并了
lst = [1,2,3,4,5]
lst1 = [6,7,8,9]print(lst * 8)
删
lst = [‘alex’,1,2,‘alex’,3,4,True,‘alex’]
lst.remove(‘alex’) # 移除 删除指定的元素,元素放在括号里 只能指定一个删除
print(lst)
s = lst.pop() # 弹出 默认删除最后一个
print(s) # pop有返回值,返回的就是被删除的元素
print(lst)
lst.pop(3) # 弹出 可以通过元素的下标指定删除的元素
print(lst)
lst.clear() # 清空
print(lst)
del lst # 删除整个列表
print(lst)
del lst[-2] #通过下标删除对应的元素
print(lst)
改
lst = [‘alex’,1,2,‘alex’,3,4,True,‘alex’]
lst[3] = ‘wusirabs’ # 下标
print(lst)
lst[0:5] = ‘wusir’,‘alex’,‘taibai’,‘nvsheng’ 范围修改
print(lst)
lst[0:5] = ‘wusirabs’,‘alex’ # 注意点
print(lst)
查
print(lst[2]) # 查询
for 循环:
for i in lst:
print(i)
其他操作
s = lst.count(3) #统计
print(s)
s = lst.index(5) # 索引
print(s)
lst = [1,2,3,4,5,6,7,89,54,2,4,53,34,4,3]
lst.reverse() # 反转
print(lst)
lst.sort() # 排序 默认是不是升序(从小到大) 没有赋值 None
lst.reverse()
print(lst)
lst.sort(reverse=True) # 降序 (从大到小)
print(lst)
lst1 = [‘abex’,‘baobao’,‘dj’,‘ck’,‘gg’,‘hg’,‘alex’,‘baobao’]
lst1.sort()
print(lst1)
列表嵌套
lst = [1,2,3,‘alex’,‘wusir’,True,False,
[5,6,7,‘黑哥’,[18,‘山谷’,‘爱好’,[‘大保健’]]]]
lst1 = lst[7]
[5,6,7,‘黑哥’,[18,‘山谷’,‘爱好’,[‘大保健’]]]
lst2 = lst1[-1]
[18,‘山谷’,‘爱好’,[‘大保健’]]
lst3 = lst2[-1]
[‘大保健’]
lst4 = lst3[0]
print(lst[7][-1][-1][0])
[‘大保健’] == lst[7][-1][-1]
[5,6,7,‘黑哥’,[18,‘山谷’,‘爱好’,[‘大保健’]]]
s1 = ‘好一把’+s
s = s1
lst = [1,‘太白’,‘wusir’,[‘麻花疼’,[‘可口可乐’],‘王健林’]]
lst[-1][-2].append(‘雪碧’)
print(lst)
‘’’
将列表lis中的"tt"变成大写（用两种方式）。
将列表中的数字3变成字符串"100"（用两种方式）。
将列表中的字符串"1"变成数字101（用两种方式）。
‘’’
lis[3][2][1][0] = lis[3][2][1][0].upper() # 找到tt了
lis[3][2][1][0] = ‘TT’
print(lis)
lis = [2, 4, “k”, [“qwe”, 20, [“k1”, [“tt”, 3, “1”]], 89], “ab”, “adv”]
lis[3][2][1][1] = ‘100’
lis[3][2][1][1] = str(lis[3][2][1][1] + 97)
print(lis)
lis[3][2][1][-1] = int(lis[3][2][1][-1]) + 100
print(lis)
lis[3][2][1][-1] = 101
print(lis)
tuple # 元组 ()
tu = (1,) # 括号里如果只有一个类型就是此类型
print(type(tu)) #面试题
lst = [1]
print(type(lst)) #只要是用[]都是列表
tu = (1,2,3)
tu1 = (5,) + tu # 合并
print(tu1)
tu = (1,2,3,4,5,4,3,4,)
print(tu.index(3))
print(tu.count(4))
lst = [1,2,3,5]
print(lst[0:3])
print(tu[:4])
for i in tu:
print(i)
元组嵌套
tu = (1,2,3,‘a’,False,[4,5,6],(8,7,9))
print(id(tu[-2]))
tu[-2].append(7)
print(id(tu[-2]))
print(tu)
tu[3] = ‘b’
print(tu)
字符串和数字是不可变的数据类型
a = ‘alex’
print(id(a))
a = ‘b’
id() # 查看内存地址
print(id(a))
range # 范围
print(range(5))
print(list(range(10,0,-1)))
[起始位置:终止位置:步长]
range(起始位置,终止位置,步长) #顾头不顾尾
- 使用for循环和range打印50 - 0
for i in range(6): # range获取的这个区间是可迭代的
print(i)
for i in range(100,-1,-2):
print(i)
字典
{‘key’:1}
不可变:(可哈希)
数字 字符串 元组 布尔值
可变: (不可哈希)
列表 字典
字典里的键必须保证唯一(不能重复)
python36 有顺序打印
python35及以下无序打印
增
dic[‘3’] = ‘小奶狗的芭比’
print(dic)
增 如果这个键不在字典中就是添加,存在就是修改
dic.setdefault(‘周阳’,‘国家一级大厨’) #存在就不进行添加,不存在就添加
setdefault中第一个参数是键 第二参数是值 如果不写值就默认为None
print(dic)
dic.setdefault(‘艺术哥’,‘就上了’) #存在就不进行添加,不存在就添加
setdefault中第一个参数是键 第二参数是值 如果不写值就默认为None
print(dic)
删
字典是没有remove
s = dic.pop(‘3’) # pop返回的是被删除的值 pop一定要给人家参数 参数是要删除的键
print(s)
print(dic)
s1 = dic.popitem() # 随机删除 在python36中删除最后一个 python35及以下随机删除
print(s1) popitem返回的是被删除的键值对以元组的形式显示
元组中第一个是字典中的键 第二个是字典中的值
print(dic)
del dic # 删除整个字典
print(dic)
del dic[‘3’] #通过dic[‘键’]删除
print(dic)
dic.clear() #清空
改
dic = {1:2,‘3’:8,False:True,(1,2,3):[‘132’,‘qw’],‘周公’:‘移山’}
dic1 = {‘周公’:‘放我的孩子们’,4:89}
dic[1] = 78 # 如果这个键在字典中就是修改,不存在就是添加
print(dic)
dic1.update(dic)
print(dic1)
查
dic = {1:2,‘3’:8,False:True,(1,2,3):[‘132’,‘qw’],‘周公’:‘移山’}
s = dic.get(4) #不报错,默认返回None 可以自己定义返回值
print(dic[4]) #报错
print(s)
其他操作
dic = {1:2,‘3’:8,False:True,(1,2,3):[‘132’,‘qw’],‘周公’:‘移山’}
print(dic.keys()) #高仿列表A货
print(dic.values()) #高仿列表A货
print(dic.items()) #以元组形式将键值对放在一个高仿列表里
for k,v in dic.items():
print(k,v)
for i in dic.values():
print(i)
for i in dic:
print(i) # 获取到的是键
if 1 in dic:
print(666)
for i in dic:
# print(dic[i])
print(dic.get(i)) #使用get
for i in dic:
print(i,dic[i])
解构:
a,b = 1,2
print(a)
print(b)
a = 10
b = 20
a,b = b,a
c,d = (1,2)
print©
print(d)
a,b = [1,2]
print(a)
print(b)
a,c = 12 ,8
print(a)
print©
字典的嵌套:
dic = {‘name’:‘汪峰’,
‘age’:48,
‘job’:‘输出’,
‘wife’:[{‘name’:‘葛慧杰’,‘age’:20,‘job’:‘输入’,‘baby’:‘小苹果’},
{‘name’:‘国际章’,‘age’:23,‘job’:‘国际输入’,‘baby’:[‘胸大’,‘熊二’]}],
}
print(dic[‘wife’][0][‘name’])
print(dic[‘wife’][0][‘baby’])
print(dic[‘wife’][1][‘baby’][0])
id、is、==
id() #查看内存地址
name = ‘alex’
name1 = ‘alex’
print(id(name)) #31302632
print(id(name1)) #31302632
is #查看是不是一个 通过内存地址
print(name == name1)
== 查看等号两边的值
def func():
# pass #代码块1
name = ‘alex’
print(id(name))
def func1():
# pass #代码块2
name = ‘alex’
print(id(name))
func()
func1()
多个代码块中是可以使用小数池
代码块中 有个问题 就是重复使用
a = 100
b = 100
print(a is b)
数字
-5 ~ 256
字符串 乘法总数长度不能超过20个,0和1除外
不能有特殊字符
a = ‘@’*2
b = ‘@’*2
print(a is b)
a = ‘asfasdfas@aasdfasdf’
b = ‘asfasdfas@aasdfasdf’
print(a is b)
二次编码
ascii # 不支持中文
unicode 万国码 中文4个字节 英文 2个
utf-8 最少使用1个字节 欧洲 2 亚洲 3
gbk 中文 2 英 1
windows 默认编码GBK
a = ‘你好黑’
a1 = ‘alex’
a2 = a.encode(‘utf-8’) #编码
print(a)
print(a2)
a3 = a2.decode(‘utf-8’) #解码
print(a3)
bytes字节 用于传输和存储
a = ‘你好黑’
a1 = ‘alex’
a2 = a.encode(‘gbk’) #编码
a3 = a.encode(‘utf-8’) # 最长用
print(a2)
print(a3)
a4 = a2.decode(‘gbk’) #解码
a5 = a3.decode(‘utf-8’)
print(a4,a5)
深浅拷贝
lst = [1,2,3,[4,5,6],7]
lst1 = lst #赋值
lst2 = lst[:] # 切片
lst.append(7)
print(lst)
print(lst2)
import copy
lst4 = copy.deepcopy(lst) # 深拷贝
lst[-2].append(7)
print(lst) #[1, 2, 3, [4, 5, 6,7], 7]
print(lst4) #[1, 2, 3, [4, 5, 6], 7]
浅拷贝:
拷贝的是第一层元素
深拷贝:
拷贝所有元素开辟新的空间存放,完全没有关系
lst = [1,2,3]
lst1 = [1,2,3]
print(id(lst))
print(id(lst1))
面试题
a = [1, 2]
a[1] = a # [1,[1,2]]
print(a[1])
答案:
[1, […]]
lst = [1,3,[5,7],9]
lst1 = lst
lst2 = lst[:]
print(id(lst))
print(id(lst1))
print(id(lst2))
lst.append(9)
print(lst)
print(lst1)
print(lst2)
是不是一个东西 长的一不一样
基础补充
lst = [1,2,3,4,5]
for i in lst:
lst.remove(i)
print(lst)
删除不行
lst = [1,2,3,4,5]
for i in lst:
lst.pop()
print(lst)
不行
lst = [1,2,3,4,5]
for i in lst:
lst.clear()
print(lst)
行,作弊
lst = [1,2,3,4,5]
for i in lst:
del lst[0]
print(lst)
不行
lst = [1,2,3,4,5]
for i in range(len(lst)):
lst.pop(0)
print(lst)
这个行
lst = [1,2,3,4,5]
for i in range(len(lst)):
lst.pop()
print(lst)
这个行
lst = [1,2,3,4,5]
for i in lst:
if type(i) == int:
lst[i-1] = ’ ’
print(lst)
print(list(set(lst)))
lst = [1,2,3,4,5]
lst1 = []
for i in lst:
lst1.append(i)
for k in lst1:
lst.remove(k)
print(lst)
这个方式也可以
for i in dic:
dic[‘c’] = 3
print(dic)
for i in dic:
dic.pop(i)
print(dic)
lst = {}
dic ={‘a’:1,‘b’:2}
for i in dic:
lst[i]= dic[i]
print(lst)
for i in lst:
dic.pop(i)
print(dic)
################################深坑###################################
dic = dict.fromkeys([‘alex’,‘wusir’,‘wenzhou’,‘nvshen’,‘kaige’],[‘太白’,‘姗姗’])
fromkeys 第一是键 第二是值
print(dic)
dic[‘alex’].append(‘老村长’)
print(dic)
######坑########
lst = [1,2,3,4,5,[3,4,6,8],5]
lst1 = lst
lst1 = lst[:] # 浅拷贝只拷贝第一层元素
print(id(lst))
print(id(lst1))
lst.append(6)
print(lst)
print(lst1)
lst[-2].append(9)
print(lst)
print(lst1)
dic = {‘a’:1,‘b’:1}
dic1 = dic
print(id(dic1))
print(id(dic))
import copy
lst = [1,2,3,4,5,[3,4,6,8],5]
lst1 = copy.deepcopy(lst)
print(lst)
print(lst1)
lst[-2].append(10)
print(lst)
print(lst1)
数据类型转换
1.set() — list()
s = {12,4,3,4}
print(list(s)) # [3, 12, 4]
lst = [3, 12, 4]
print(set(lst)) # {3, 12, 4}
tu = (1,2,3,4)
print(list(tu)) #[1, 2, 3, 4]
print(set(tu)) #{1, 2, 3, 4}
s = {1,2,3}
print(tuple(s)) #(1, 2, 3)
tu = (1,2,3,4)
print(str(tu))
lst = [1,2,3,4,[5,6,7,[8,9,10]]]
print(str(lst))
print #面向用户的
s = str(lst)
print(repr(s))
na = ‘alex’
lst = list(na)
print(lst)
dic = {‘name’:‘黑哥’,‘age’:18}
lst = list(dic) # 字典的键
print(lst)
s = set(dic)
print(s)
str
int
bool
list
tuple
dict
set
print(bool(’ ‘)) True
print(bool(’’)) False
print(bool(0)) False
print(bool(56)) True
print(bool(True)) True
print(bool(False)) False
print(bool([1,2,3])) True
print(bool([])) # False
print(bool((1,2,3))) #True
print(bool(())) #False
print(bool())
0 ‘’ None [ ] ( ) { } { } False
print(bool(None))
for i in ‘alex’:
if i:
print(44)
文件操作
r 读
w 写
a 追加写
f = open(‘s.txt’,mode=‘r’,encoding=‘utf-8’)
ff = f.readline() #读取时一行一行的时候末尾会跟着\n
print(ff)
ff = f.readline()
print(ff)
ff = f.readline()
print(ff)
ff = f.read(3)
ff1 = f.read()
print(ff)
print(ff1)
f.close()
f = open(‘s.txt’,mode=‘rb’) # 使用b的时候不能加编码集 b是操作字节的
ff = f.read()
print(ff) # \r是回车 \n是换行
f = open(‘s.txt’,mode=‘r’,encoding=‘utf-8’)
ff = f.read()
print(ff)
for i in f:
print(i)
ff = f.read()
print(ff)
f = open(‘s.txt’,mode=‘rb’)
ff = f.read(3)
print(ff)
总结:
只读 r 正常文本
只读 rb 字节
read() 默认全读完 可以指定读几个
readline 一行一行读
f = open(‘s.txt’,mode=‘w’,encoding=‘utf-8’)
打开 mode 是对文件操作的模式
w模式会自动创建文件 w会覆盖 先清空后写入
f.write(‘黑哥真黑,黑哥都自己黑感冒了’)
f.close()
f1 = open(‘s.txt’,mode=‘w’,encoding=‘utf-8’)
f1.write(‘艺术哥,爱吃六味地黄丸’)
f1.close()
总结:
w只能覆盖的写
w模式会自动创建文件
w模式下写的时候首先清空文件的内容,然后在写
f = open(‘s.txt’,mode=‘a’,encoding=‘utf-8’)
追加写
f.write(‘赵湿熊’)
f.write(‘金阳’)
f.write(‘宝宝’)
总结:
a 追加 在文件文本末尾添加内容
路径
f = open(’…/day6/01 今日内容’,mode=‘r’,encoding=‘utf-8’)
… 返回上一级
转义 ‘E:\s17\day07\文件夹\s.txt’ r’E:\s17\day07\文件夹\s.txt’ 绝对路径
‘…/day6/01 今日内容’ 相对路径 相对于当前文件
推荐使用相对路径 以后工作全都是相对路径
print(f.read())
f = open(‘文件夹/s.txt’,mode=‘r+’,encoding=‘utf-8’) #r+ 读写
ff = f.read()
print(ff)
f.write(‘你好黑’)
f.write(‘你好黑’) # r模式 光标在最开头
ff = f.read()
print(ff)
########坑########## r+ 是咱们最常用的
f = open(‘文件夹/s.txt’,mode=‘w+’,encoding=‘utf-8’) # w+ 写读
f.write(‘你好黑’)
f.flush() # 刷新
f.seek(3) # 调整光标位置到文件最开头
seek(0) 调整到开头
seek(3) 单个参数是字节数 0除外 0就是表示调整光标到开头
seek(0,1) 两个参数的时候就是表示光标调整到当前位置
seek(0,0) 两个参数的时候就是表示光标调整到开始位置
seek(0,2) 两个参数的时候就是表示光标调整到末尾位置
ff = f.read()
print(ff)
f.close()
f = open(‘文件夹/s.txt’,mode=‘a+’,encoding=‘utf-8’) # a+ 追加(写) 读
f.seek(0)
ff = f.read()
print(ff)
f.seek(0)
f.write(‘hahahaha0’)
不管你把光标怎么调,都是在文件的最后写入
f.write(‘哇哈哈哈哈’)
f.seek(0)
ff = f.read()
print(ff)
r
w
a
rb
wb
ab
r+
w+
a+
f = open(‘文件夹/s.txt’,mode=‘w’,encoding=‘utf-8’)
ss = f.tell() # 按字节算 #查看光标位置
print(ss)
f = open(‘文件夹/s.txt’,mode=‘w’,encoding=‘utf-8’)
f.write(’’‘扁担宽板凳长
扁担宽板凳长扁担想绑在板凳上板凳不让扁担绑在板凳上扁担偏要绑在板
凳上板凳偏偏不让扁担绑在那板凳上到底扁担宽还是板凳长。’’’)
f.seek(9)
print(f.tell())
f.truncate() #截断就是将光标后边的内容删除
with open(‘文件夹/s.txt’,mode=‘w’,encoding=‘utf-8’)as f:
f.write(‘asfasf’)
with open(‘文件夹/s1’,mode=‘r’,encoding=‘utf-8’)as f,
open(‘文件夹/s.txt’,mode=‘w’,encoding=‘utf-8’)as f1:
ff = f.read() #s1
ff2 = ff.replace(‘我’,‘都’) # 修改
f1.write(ff2) # s.txt 修改后的内容
for i in f:
ret = i.replace(‘都’,‘大家’)
f1.write(ret)
import os
os.remove(‘文件夹/s1’)
os.rename(‘文件夹/s.txt’,‘文件夹/s1’) # 第一个参数是要被改的名字,第二个参数是改的名字
with open(‘文件夹/s1’,mode=’’)
2095
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
