Python基础笔记
pycharm的使用
Debug
- step into：Debug时会进入函数内部
- step over：Debug时直接执行完函数，不会进入函数内部
注释
- 注释的分类
- 单⾏： # 注释内容 ，快捷键ctrl+/
- 多⾏： “”" 注释内容 “”" 或 ‘’’ 注释内容 ‘’’
变量
-
定义变量
- 变量 = 值
-
标识符
-
由数字、字⺟、下划线组成
-
不能数字开头
-
不能使⽤内置关键字
-
严格区分⼤⼩写
-
-
BUG
-
Debugger：显示变量和变量的细节
-
Console：输出内容
-
-
数据类型
- 整型：int
- 浮点型：float
- 字符串：str
- 布尔型：bool
- 元组：tuple
- 集合：set
- 字典：dict
输出
-
格式化输出
- %s：字符串
- %d：有符号的⼗进制整数
- %f：浮点数
-
注：
- %06d，表示输出的整数显示位数，不⾜以0补全，超出当前位数则原样输出
- %.2f，表示⼩数点后显示的⼩数位数。
-
f’{表达式}'的用法
print(f'我的名字是{name}, 我今年{age}岁.') -
转义字符
- \n ：换⾏。
- \t ：制表符，⼀个tab键（4个空格）的距离.
-
结束符
-
在Python中，print()， 默认⾃带 end=“\n” 这个换⾏结束符，所以导致每两个 print 直接会换⾏展示，⽤户可以按需求更改结束符
-
# 默认以换行结束 print('Hello', end='\n') # 以制表符结束 print('World', end='\t') # 自定义结束 print('Hi', end='...') print('python')
-
输入
-
语法
input("提示信息") -
特点
- 当程序执⾏到 input ，等待⽤户输⼊，输⼊完成之后才继续向下执⾏。
- 在Python中， input 接收⽤户输⼊后，⼀般存储到变量，⽅便使⽤。
- 在Python中， input 会把接收到的任意⽤户输⼊的数据都当做字符串处理。
转换数据类型
-
转换数据类型的函数
函数 说明 int(x [,base]) 将x转换为⼀个整数 float(x) 将x转换为⼀个浮点数 str(x) 将对象 x 转换为字符串 eval(str) ⽤来计算在字符串中的有效Python表达式,并返回⼀个对象(转换成原本类型) tuple(s) 将序列 s 转换为⼀个元组 list(s) 将序列 s 转换为⼀个列表 -
代码示例
# 转换成浮点型 num1 = 10 print(float(num1)) # 转换成字符串类型 num2 = 110 print(type(str(num2))) # 转换成元组类型 list1 = [10, 9, 8] print(tuple(list1)) print(type(tuple(list1))) # 将字符串转换成原本形式 print('.............') str1 = '10' str2 = '[1, 2, 3]' str3 = '(1000, 2000, 3000)' print(type(eval(str1))) print(type(eval(str2))) print(type(eval(str3)))
运算符
-
算数运算符
-
+，-，*，/，//(整除)，%，**(指数)，()
-
注：混合运算优先级顺序： () ⾼于 ** ⾼于 * / // % ⾼于 + -
-
-
赋值运算符
运算符 描述 赋值实例 = 赋值 将=右侧的结果赋值给等号左侧的变量 - 单个变量赋值：num = 1
- 多个变量赋值：num1, num2, str1 = 10, 10.10, ‘hello’
- 多个变量赋相同值：num1 = num2 = 10
-
复合赋值运算符
运算符 描述 += 加法赋值运算符 -= 减法赋值运算符 *= 乘法赋值运算符 /= 除法赋值运算符 //= 整除赋值运算符 %= 取余赋值运算符 **= 幂赋值运算符 -
注：先算赋值运算符右边的表达式，再算赋值运算符
d = 10 d *= 1 + 2 # 结果为30
-
-
比较运算符
运 算 符 描述 == 判断相等。如果两个操作数的结果相等，则条件结 果为真(True)，否则条件结果为假(False) != 不等于 。如果两个操作数的结果不相等，则条件为 真(True)，否则条件结果为假(False) > 运算符左侧操作数结果是否⼤于右侧操作数结果， 如果⼤于，则条件为真，否则为假 < 运算符左侧操作数结果是否⼩于右侧操作数结果， 如果⼩于，则条件为真，否则为假 >= 运算符左侧操作数结果是否⼤于等于右侧操作数结 果，如果⼤于，则条件为真，否则为假 <= 运算符左侧操作数结果是否⼩于等于右侧操作数结 果，如果⼩于，则条件为真，否则为假 -
逻辑运算符
运 算 符 描述 and x and y 布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。 or x or y 布尔"或"：如果 x 是 True，它返回 True，否则 它返回 y 的值。 not not x 布尔"⾮"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 -
代码示例
a = 1 b = 2 c = 3 print((a < b) and (b < c)) # True print((a > b) and (b < c)) # False print((a > b) or (b < c)) # True print(not (a > b)) # True -
数字之间的逻辑运算
a = 0 b = 1 c = 2 # and运算符，只要有⼀个值为0，则结果为0，否则结果为最后⼀个⾮0数字 print(a and b) # 0 print(b and a) # 0 print(a and c) # 0 print(c and a) # 0 print(b and c) # 2 print(c and b) # 1 # or运算符，只有所有值为0结果才为0，否则结果为第⼀个⾮0数字 print(a or b) # 1 print(a or c) # 2 print(b or c) # 1
-
条件语句
-
if 语法
if 条件: 条件成⽴执⾏的代码1 条件成⽴执⾏的代码2 ......-
代码示例
if True: print('条件成⽴执⾏的代码') # 下⽅的代码没有缩进到if语句块，所以和if条件⽆关 print('我是⽆论条件是否成⽴都要执⾏的代码')
-
-
if…else…
# 注意input接收的数据类型是字符串类型需要转换 age = int(input('请输入你的年龄：')) if age >= 18: print(f'您的年龄为{age}，已成年') else: print('你还未成年，滚去学习吧！')- 注：如果执行了条件成⽴相关的代码，那么其他情况的代码解释器不会执⾏。
-
多重判断
-
语法
if 条件1: 条件1成⽴执⾏的代码1 条件1成⽴执⾏的代码2 ...... elif 条件2： 条件2成⽴执⾏的代码1 条件2成⽴执⾏的代码2 ...... ...... else: 以上条件都不成⽴执⾏执⾏的代码注：多重判断也可以和else配合使⽤。⼀般else放到整个if语句的最后，表示以上条件都不成⽴的时候执⾏的代码
-
代码示例
# 输入年龄 age = int(input('请输入你的年龄：')) # 进行判断 if age < 18: print(f'你的年龄为{age},未成年。') # (age >= 18) and (age < 60): elif 18 <= age < 60: print((f'你的年龄为{age},已成年还未退休。')) else: print(f'你的年龄为{age},已退休。')- 拓展： age >= 18 and age <= 60 可以化简为 18 <= age <= 60 。
-
-
if嵌套
-
语法
if 条件1： 条件1成⽴执⾏的代码 条件1成⽴执⾏的代码 if 条件2： 条件2成⽴执⾏的代码 条件2成⽴执⾏的代码 -
应用
import random ''' 猜拳小游戏 0-石头 1-剪刀 2-布 ''' # 电脑随机出拳 pc = random.randint(0, 2) print(pc) # 玩家出拳 player = int(input('请出拳：0-⽯头，1-剪⼑，2-布：')) # 玩家胜利 if((player == 0) and (pc == 1)) or ((player == 1) and (pc == 2)) or ((player == 2) and (pc == 0) ): print('玩家获胜') elif player == pc: print('平局') else: print('电脑获胜')- 注：random模块中的随机整数功能：random.randint(开始,结束)
- 三目运算符
- 语法：条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式
-
循环
-
while循环
-
语法
while 条件: 条件成⽴重复执⾏的代码1 条件成⽴重复执⾏的代码2 ...... -
应用
- 计数器：计数一般从0开始，例如计数100，从0-99，判断条件为<100。
-
break和continue
- break：终⽌此循环
- continue：退出当前⼀次循环继⽽执⾏下⼀次循环代码
-
-
while循环嵌套
-
语法
while 条件1: 条件1成⽴执⾏的代码 ...... while 条件2: 条件2成⽴执⾏的代码 ......总结：所谓while循环嵌套，就是⼀个while⾥⾯嵌套⼀个while的写法，每个while和之前的基础 语法是相同的。
-
应用：打印99乘法表
# 重复打印9⾏表达式 j = 1 while j <= 9: # 打印⼀⾏⾥⾯的表达式 a * b = a*b i = 1 while i <= j: print(f'{i}*{j}={j*i}', end='\t') i += 1 print() j += 1
-
-
for循环
-
语法
for 临时变量 in 序列: 重复执⾏的代码1 重复执⾏的代码2 ......
-
-
else
- 循环可以和else配合使⽤，else下⽅缩进的代码指的是当循环正常结束之后要执⾏的代码。
-
while…else
while 条件: 条件成⽴重复执⾏的代码 else: 循环正常结束之后要执⾏的代码-
退出循环的方式
-
break
- 如果是break终⽌循环的情况，else下⽅缩进的代码将不执⾏
-
continue
- 因为continue是退出当前⼀次循环，继续下⼀次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执⾏了else缩进的代码。
-
-
-
for…else
for 临时变量 in 序列: 重复执⾏的代码 ... else: 循环正常结束之后要执⾏的代码- break终⽌循环不会执⾏else下⽅缩进的代码
- continue退出循环的⽅式执⾏else下⽅缩进的代码
字符串
-
字符串特征
- ⼀对引号字符串：单引号、双引号。
- 三引号字符串
- 注意：三引号形式的字符串⽀持换⾏。
# 单引号 name1 = 'Tom' print(name1) # 双引号 name2 = "Bob" print(name2) # 三引号 str1 = '''Hello World!''' print(str1) ''' 输出： Hello Python! ''' str2 = """Hello Python!""" print(str2) # 输出：Hello Pop! str3 = 'Hello ' \ 'Pop!' print(str3) str4 = 'I\'m Bob' #使用'\'转义 print(str4) -
字符串输出：%s
-
字符串输入：input
-
下标
- 字符串默认带有一个下标，下标从0开始。可通过下标访问字符串中的某个字符，如：str1[0] (访问字符串str1中的第0个字符)
-
切片
-
概念：切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作。
-
语法
序列[开始位置下标:结束位置下标:步⻓] # 结束位置不会选取[开始位置下标,结束位置下标) -
注
- 不包含结束位置下标对应的数据， 正负整数均可；
- 步⻓是选取间隔，正负整数均可，默认步⻓为1。
- 如果不写开始，默认从0开始选取
- 如果不写结束，表示选取到最后
- 如果不写开始和结束，表示选取所有
- 如果步长为负数，则表示倒序选取
- 如果选取方向(下标开始到结束的方向)和步长的方向冲突，则无法选取数据。
-
-
常用操作方法
-
查找
-
find()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1。
字符串序列.find(⼦串, 开始位置下标, 结束位置下标)注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
-
index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。
字符串序列.index(⼦串, 开始位置下标, 结束位置下标)注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
3. rfind()： 和find()功能相同，但查找⽅向为右侧开始。 4. rindex()：和index()功能相同，但查找⽅向为右侧开始。 5. count()：返回某个⼦串在字符串中出现的次数字符串序列.count(⼦串, 开始位置下标, 结束位置下标)注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
-
-
-
修改
-
replace()：替换
字符串序列.replace(旧⼦串, 新⼦串, 替换次数)注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候 不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。
-
split()：按照指定字符分割字符串。返回一个列表。
字符串序列.split(分割字符, num)注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。
注意：如果分割字符是原有字符串中的⼦串，分割后则丢失该⼦串。
-
join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。
字符或⼦串.join(多字符串组成的序列) -
代码示例
str1 = 'hello and python and world' # replace my_str = str1.replace('and', '') print(my_str) # hello python world # split 分割，返回一个列表，丢失分割字符 my_list = str1.split('and', 1) print(my_list) # ['hello ', ' python and world'] # join 合并列表里面的字符串数据为一个大字符串 list1 = ['aa', 'bb', 'cc'] str3 = '...'.join(list1) print(str3) # aa...bb...cc -
capitalize()：将字符串第⼀个字符转换成⼤写。
-
title()：将字符串每个单词⾸字⺟转换成⼤写。
-
lower()：将字符串中⼤写转⼩写。
-
upper()：将字符串中⼩写转⼤写。
-
rstrip()：删除字符串右侧空⽩字符。
-
lstrip()：删除字符串左侧空⽩字符。
-
strip()：删除字符串两侧空⽩字符
-
ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度的新字符串。
-
rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和 ljust()相同。
-
center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语 法和ljust()相同。
字符串序列.ljust(⻓度, 填充字符) # 表示在该长度内左对齐
-
-
判断
-
startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标) -
endswith()：：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标) -
isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。(都是字母)
-
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。(都是数字)
-
isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回 False。(数字或字母或组合)
-
isspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False。(都是空白)
-
-
列表
-
列表
[数据1, 数据2, 数据3, 数据4......]注：列表可以⼀次性存储多个数据，且可以为不同数据类型。
-
列表的常用操作
-
查找
-
下标
-
函数
-
index()：返回指定数据所在位置的下标 。
列表序列.index(数据, 开始位置下标, 结束位置下标) -
count()：统计指定数据在当前列表中出现的次数。
-
len()：访问列表⻓度，即列表中数据的个数。
-
-
判断
-
in：判断指定数据在某个列表序列，如果在返回True，否则返回False
-
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False。
数据 in|not in 列表
-
-
-
增加
-
append()：列表结尾追加数据。
-
语法
列表序列.extend(数据)列表追加数据的时候，直接在原列表⾥⾯追加了指定数据，即修改了原列表，故列表为可变类型
数据。注意：如果append()追加的数据是⼀个序列，则追加整个序列到列表
-
代码示例
name_list = ['Tom', 'Bob', 'Jay'] # 列表为可变类型 name_list.append('liming') # 结果：['Tom', 'Bob', 'Jay', 'liming'] print(name_list) name_list.append([11, 110]) # 结果：['Tom', 'Bob', 'Jay', 'liming', [11, 110]] print(name_list)
-
-
extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。
-
语法
列表序列.extend(数据) -
代码示例
name_list = ['Tom', 'Bob', 'Jay'] name_list.extend('Liming') # 结果：['Tom', 'Bob', 'Jay', 'L', 'i', 'm', 'i', 'n', 'g'] print(name_list) name_list.extend([10, 20]) # 结果：['Tom', 'Bob', 'Jay', 'L', 'i', 'm', 'i', 'n', 'g', 10, 20] print(name_list)
-
-
insert()：指定位置新增数据。
-
语法
列表序列.insert(位置下标, 数据) # 位置下标从零开始 -
代码示例
name_list = ['Tom', 'Bob', 'Jay'] name_list.insert(2, 'Liming') # 结果：['Tom', 'Bob', 'Liming', 'Jay'] print(name_list)
-
-
-
删除
-
del
- 删除列表：del 列表名
- 删除指定数据：del 列表名[下标]
-
pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。
列表序列.pop(下标) -
remove()：移除列表中某个数据的第⼀个匹配项。
-
clear()：清空列表
name_list = ['Tom', 'Bob', 'Jay'] del name_list # name 'name_list' is not defined print(name_list) del name_list[2] # ['Tom', 'Bob'] print(name_list) # pop pop_name = name_list.pop() # ['Tom', 'Bob'] print(name_list) pop_name = name_list.pop(1) # ['Tom', 'Jay'] print(name_list) # remove name_list.remove('Bob') # ['Tom', 'Jay'] print(name_list) # clear name_list.clear() # [] print(name_list) -
-
修改
-
修改指定下标数据
列表[i] = x -
逆置：reverse()
-
排序：sort()
列表序列.sort( key=None, reverse=False)注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）
-
-
复制：copy()
-
-
列表的循环遍历
- while
- for
name_list = ['Tom', 'Bob', 'Jay'] # while循环实现 i = 0 while i < len(name_list): print(name_list[i]) i += 1 print() # for循环实现 for i in name_list: print(i) -
列表嵌套
-
列表中嵌套列表
name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']] print(name_list) # ['⼩明', '⼩红', '⼩绿'] print(name_list[0]) # ⼩红 print(name_list[0][1])
-
元组
- ⼀个元组可以存储多个数据，元组内的数据是不能修改的。而列表中的数据可更改。
-
定义元组
- 元组特点：定义元组使⽤⼩括号，且逗号隔开各个数据，数据可以是不同的数据类型。
- 注意：如果定义的元组只有⼀个数据，那么这个数据后⾯必须添加逗号，否则该数据类型为唯⼀的这个数据的数据类型
# 多个数据元组 t1 = (1, 2, 3) print(type(t1)) # <class 'tuple'> # 单个数据元组 t2 = (1,) print(type(t2)) # <class 'tuple'> # 单个数据元组，不加逗号 t3 = (1) print(type(t3)) # <class 'int'> t4 = ('abc') print(type(t4)) # <class 'str'> -
元组常见的操作
元组数据不⽀持修改，只⽀持查找。
- 按下标查找数据
- index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index ⽅法相同。
- count()：统计某个数据在当前元组出现的次数。
- len()：统计元组中数据的个数。
tuple1 = ('aa', 'bb', 'cc', 'bb', [10, 22]) # 按下标查找 print(tuple1[3]) # bb # index print(tuple1.index('cc')) # 2 # print(tuple1.index('ccc')) # ValueError: tuple.index(x): x not in tuple # count print(tuple1.count('bb')) # 2 print(tuple1.count('bbb')) # 0 # len print(len(tuple1)) # 4 tuple1[4][1] = 'a' print(tuple1) # ('aa', 'bb', 'cc', 'bb', [10, 'a'])注意：元组内的直接数据如果修改则⽴即报错，但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的。
字典
字典⾥⾯的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不⽀持下标， 后期⽆论数据如何变化，只需要按照对应的键的名字查找数据即可。
-
创建字典
- 字典的特点
- 符号为⼤括号
- 数据为键值对形式出现
- 各个键值对之间⽤逗号隔开
注意：⼀般称冒号前⾯的为键(key)，简称k；冒号后⾯的为值(value)，简称v。
- 字典的特点
-
字典常见操作
-
增
- 写法：字典序列[key] =
注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
注意：字典为可变类型。
-
删
- del() / del：删除字典或删除字典中指定键值对。
- clear()：清空字典
-
改
写法：字典序列[key] = 值
注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} # 增 dict1['id'] = '10' print(dict1) # 覆盖原有值 dict1['name'] = 'Liming' print(dict1) # 删除字典 del(dict1) print(dict1) # NameError: name 'dict1' is not defined # 删除键值对 del dict1['gender'] # {'name': 'Tom', 'age': 20} print(dict1) del dict1['id'] # KeyError: 'id' print(dict1) # 清除字典 dict1.clear() print(dict1) # {} # 改 dict1['name'] = 'Lay' dict1['id'] = 10 print(dict1) # {'name': 'Lay', 'age': 20, 'gender': '男', 'id': 10}-
查
-
key值查找：如果当前查找的key存在，则返回对应的值；否则则报错。
-
get()
字典序列.get(key, 默认值)注意：如果当前查找的key不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回None。
-
keys()：查找字典中所有的key,返回可迭代对象
-
values()：查找字典中所有的value,返回可迭代对象
-
items()：查找字典中所有的键值对，返回可迭代对象，里面的数据为元组，元组数据1是字典的key,元组数据2是字典key对应的值。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} # 键值对 print(dict1['name']) # Tom # print(dict1['names']) # KeyError: 'names' # get() print(dict1.get('name')) # Tom print(dict1.get('names')) # None print(dict1.get('names', 'Lili')) # Lili # keys() print(dict1.keys()) # dict_keys(['name', 'age', 'gender']) # values() print(dict1.values()) # dict_values(['Tom', 20, '男']) # items() print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')]) -
-
字典update
-
字典不存在键值update
-
字典不存在键值，使用update会添加键值对到字典中
account = "optics" decrypt_passwd = "12345abc" accountDict = {} accountDict.update({account:decrypt_passwd}) print(accountDict) # {‘optics’: ‘12345abc’}
-
-
字典已经存在键值update
-
字典已经存在键值update会更新键的值
account = "optics" decrypt_passwd = "abcdef" accountDict = {'optics': '12345abc'} accountDict.update({account:decrypt_passwd}) print(accountDict) # {‘optics’: ‘abcdef’}
-
-
-
-
字典的循环遍历
- 遍历字典的key
- 遍历字典的value
- 遍历字典的元素
- 遍历字典的键值对
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'} # key遍历 for key in dict1.keys(): print(key) # value遍历 for value in dict1.values(): print(value) # 键值对遍历 for item in dict1.items(): print(item) # 遍历字典的键值对(c) for key, value in dict1.items(): print(f'{key} = {value}')
集合
-
创建集合
- 创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。
# 创建有数据的集合 s1 = {10, 20, 30, 40} print(s1) # {40, 10, 20, 30} s2 = {10, 10, 20, 30, 20} print(s2) # {10, 20, 30} s3 = set('12abc') print(s3) # {'2', '1', 'a', 'b', 'c'} # 创建空集合 s4 = set() print(s4) # set() print(type(s4)) # <class 'set'> s5 = {} print(type(s5)) # <class 'dict'> -
集合常见操作方法
-
增加数据
-
add()
因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进⾏任何操作。
-
update(), 追加的数据是序列。
s1 = {10, 20} # 增加数据 s1.add(100) s1.add(10) print(s1) # {100, 10, 20} # 增加数据序列 # s1.update(100) # TypeError: 'int' object is not iterable s1.update([10, 30, 50]) print(s1) # {100, 10, 50, 20, 30} -
-
删除数据
- remove()，删除集合中的指定数据，如果数据不存在则报错。
- discard()，删除集合中的指定数据，如果数据不存在也不会报错。
- pop()，随机删除集合中的某个数据，并返回这个数据。
s1 = {10, 20, 30, 40, 50} # remove s1.remove(10) print(s1) # {40, 50, 20, 30} s1.remove(60) print(s1) # KeyError: 60 # discard s1.discard(20) print(s1) # {40, 50, 30} s1.discard(70) print(s1) # {40, 50, 30} # pop del_num = s1.pop() print(del_num) # 40 print(s1) # {50, 30} -
查找数据
- in：判断数据在集合序列
- not in：判断数据不在集合序列
s1 = {10, 20, 30, 40, 50} print(10 in s1) # True print(10 not in s1) # False
-
公共操作
运算符
| 运算符 | 描述 | 支持容器类型 |
|---|---|---|
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| in | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 元素是否不存在 | 字符串、列表、元组、字典 |
-
# 1. 字符串 str1 = 'aa' str2 = 'bb' # 2. 列表 list1 = [1, 2] list2 = [10, 20] # 3. 元组 t1 = (1, 2) t2 = (10, 20) print(str1 + str2) # aabb print(list1 + list2) # [1, 2, 10, 20] print(t1 + t2) # (1, 2, 10, 20) # 4. 字典 dict1 = {'name': 'lili'} dict2 = {'age': '18'} print(dict1 + dict2) # TypeError: unsupported operand type(s) for +: 'dict' and 'dict' -
# 1. 字符串 print('-' * 10) # ---------- # 2. 列表 list1 = ['hello'] print(list1 * 4) # ['hello', 'hello', 'hello', 'hello'] # 3. 元组 t1 = ('world',) print(t1 * 4) # ('world', 'world', 'world', 'world') -
in & not in
# 1. 字符串 str1 = 'aa' print('a' in str1) # True print('a' not in str1) # False print() # 2. 列表 list1 = [1, 2] print(1 in list1) # True print(1 not in list1) # False print() # 3. 元组 t1 = (1, 2) print(2 in t1) # True print(2 not in t1) # False print() # 4. 字典 dict1 = {'name': 'Lili', 'age': '11'} print('name' in dict1) # True print('name' not in dict1) # False print('name' in dict1.values()) # False print('name' in dict1.keys()) # True print('name' in dict1.items()) # False print(('name', 'Lili') in dict1.items()) # True
公共方法
| 函数 | 描述 |
|---|---|
| len() | 计算容器中元素个数 |
| del 或 del() | 删除 |
| max() | 返回容器中元素最⼤值 |
| min() | 返回容器中元素最⼩值 |
| range(start, end, step) | ⽣成从start到end的数字，步⻓为 step，供for循环使⽤ |
| enumerate() | 函数⽤于将⼀个可遍历的数据对象(如列表、元组或字符串)组合为⼀个索引序 列，同时列出数据和数据下标，⼀般⽤在 for 循环当中。 |
-
range代码示例
# 1 2 3 4 5 6 7 8 9 for i in range(1, 10, 1): print(i) # 1 3 5 7 9 for i in range(1, 10, 2): print(i) # 0 1 2 3 4 5 6 7 8 9 for i in range(10): print(i)注意：range()⽣成的序列不包含end数字。
-
enumerate()
- 语法：
enumerate(可遍历对象, start=0) # 返回结果是元组，元组的第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据。注意：start参数⽤来设置遍历数据的下标的起始值，默认为0。
- 代码示例
list1 = ['a', 'b', 'c', 'd', 'e'] ''' (0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e') ''' for i in enumerate(list1): print(i) ''' (1, 'a') (2, 'b') (3, 'c') (4, 'd') (5, 'e') ''' for i in enumerate(list1, start=1): print(i)
容器转换类型
-
tuple()：将某个序列转换成元组
-
list()：将某个序列转换成列表
-
set()：将某个序列转换成集合
- 注意：
- 集合可以快速完成列表去重
- 集合不⽀持下标
- 注意：
-
代码示例
t1 = ('a', 'b', 'c', 'd', 'e') list1 = [10, 20, 30, 40, 50, 20] s1 = {100, 200, 300, 400, 500} # 转换成元组 print(tuple(list1)) print(tuple(s1)) y # 转换成列表 print(list(t1)) print(list(s1)) # 转换成集合(列表中重复的数据不会打印) print(set(list1)) print(set(s1))
推导式
列表推导式
作⽤：⽤⼀个表达式创建⼀个有规律的列表或控制⼀个有规律列表
-
带if的列表推导式
需求：创建0-10的偶数列表
list1 = [i for i in range(0, 10, 2)] print(list1) # for循环实现 i = 0 list2 = [] for i in range(10): if i % 2 == 0: list2.append(i) print(list2) # 带if的推导式 list3 = [i for i in range(10) if i % 2 == 0] print(list3) # [0, 2, 4, 6, 8] -
多个for循环实现列表推导式
需求：创建列表如下：
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
注：多个for的列表推导式等同于for循环嵌套
list1 = [] for i in range(1, 3): for j in range(3): list1.append((i, j)) print(list1) # 用列表推导式实现 list2 = [(i, j) for i in range(1, 3) for j in range(3)] print(list2)
字典推导式
字典推导式作⽤：快速合并列表为字典或提取字典中⽬标数据。
# 创建⼀个字典：字典key是1-5数字，value是这个数字的2次⽅。
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16}
-
将两个列表合并为一个字典
list1 = ['name', 'age', 'gender'] list2 = ['Tom', 20, 'man'] dict1 = {list1[i]: list2[i] for i in range(len(list1))} print(dict1) # {'name': 'Tom', 'age': 20, 'gender': 'man'} # 注意： # 1. 如果两个列表中的数据个数相同，则使用len统计任何一个列表都可以 # 2. 如果两个列表中的数据个数不同，则使用len统计数据多的列表数据个数会报错，统计数据少的列表数据个数不会报错 -
提取字典中的目标数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99} print(counts.items()) # 返回键值对 dict3 = {key: value for key, value in counts.items() if value >= 200} print(dict3) # {'MBP': 268, 'DELL': 201}
集合推导式
# 需求：创建⼀个集合，数据为下⽅列表的2次⽅。
list1 = [1, 1, 2]
set1 = {i**2 for i in list1}
print(set1) # {1, 4} 注：集合去重
函数一
函数的作用
函数就是将⼀段具有独⽴功能的代码块 整合到⼀个整体并命名，在需要的位置调⽤这个名称即可完成对 应的需求。
函数在开发过程中，可以更⾼效的实现代码重⽤。
函数的使用步骤
-
定义函数
def 函数名(参数): 代码1 代码2 ...... -
调用函数
函数名(参数) -
注意
- 不同的需求，参数可有可⽆。
- 在Python中，函数必须先定义后使⽤。
函数的参数作用
- 分类：
- 形参：函数定义时书写的参数(⾮真实数据)
- 实参：函数调⽤时书写的参数(真实数据)
# 定义函数时同时定义了接收⽤户数据的参数a和b，a和b是形参
def add_num2(a, b):
result = a + b
print(result)
# 调⽤函数时传⼊了真实的数据10 和 20，真实数据为实参
add_num2(10, 20)
函数的返回值作用
- 作用：
- 负责函数返回值
- 退出当前函数，导致return下方的所有代码(函数体内部)不执行。
函数的说明文档
-
定义函数的说明文档
def 函数名(参数): """ 说明⽂档的位置 """ 代码 ...... -
查看函数的说明文档：help(函数名)
# 加法
def add(a, b):
"""求和函数"""
return a + b
help(add)
# 函数说明文档的高级使用
def add2(a, b):
"""
求和函数
:param a: 参数1
:param b: 参数2
:return: 返回值
"""
return a + b
help(add2)
函数嵌套调用
函数嵌套调⽤指的是⼀个函数⾥⾯⼜调⽤了另外⼀个函数。
函数二
变量作用域
变量作⽤域指的是变量⽣效的范围，主要分为两类：局部变量和全局变量。
-
局部变量
- 局部变量是定义在函数体内部的变量，即只在函数体内部⽣效。
- 局部变量的作⽤：在函数体内部，临时保存数据，即当函数调⽤完成后，则销毁局部变量。
-
全局变量
- 所谓全局变量，指的是在函数体内、外都能⽣效的变量。
- 利用global关键字声明全局变量
# 声明全局变量 a = '全局变量' def A(): # 声明局部变量 b = '局部变量' print(b) print(a) def B(): # a = '修改后的变量' # 仍然是局部变量 # print(a) # 修改后的变量 global a # 将a定义为全局变量 a = '修改为全局变量' A() B() print(a) # 修改为全局变量
多函数程序执行流程
-
共用全局变量
# 声明全局变量 global_num = 0 def A(): '''修改全局变量''' global global_num global_num = 10 print(global_num) def B(): '''打印全局变量''' print(global_num) B() # 0 A() # 10 B() # 10 print(global_num) # 10 -
返回值作为参数传递
def A(): return 50 def B(num): print(num) B(A()) # 50
函数的返回值
def test():
# return 1, 2 # 以元组形式返回
# return (10, 20) # 返回元组
# return ['你好', 10] # 返回列表
# return {'name': 'Lili'} # 返回字典
return [10, 20], {10, 15} # ([10, 20], {10, 15})
num = test()
print(num)
注意：
- return a, b 写法，返回多个数据的时候，默认是元组类型。
- return后⾯可以连接列表、元组或字典，以返回多个值。
函数的参数
-
位置参数
-
位置参数：调⽤函数时根据函数定义的参数位置来传递参数。
注意：传递和定义参数的顺序及个数必须⼀致。
-
-
关键字参数
-
函数调⽤，通过“键=值”形式加以指定。可以让函数更加清晰、容易使⽤，同时也清除了参数的顺序需求。
注意：函数调⽤时，如果有位置参数时，位置参数必须在关键字参数的前⾯，但关键字参数之间不存在 先后顺序。
-
-
缺省参数
-
缺省参数也叫默认参数，⽤于定义函数，为参数提供默认值，调⽤函数时可不传该默认参数的值（注 意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤）。
注意：函数调⽤时，如果为缺省参数传值则修改默认参数值；否则使⽤这个默认值。
def user_info(name, age, gender = '男'): print(f'您的姓名是{name}，年龄为{age}，性别是{gender}') # 位置参数 user_info('Lili', 20, '女') user_info(20, 'Lili', '女') # 无意义 # test('Lili', 20) # TypeError: test() missing 1 required positional argument: 'gender' Test()缺少1个必需的位置参数:'gender' # 关键字参数 user_info(gender='女', age='15', name='Lili') # 关键字参数不分先后顺序 user_info('Lili', gender='女', age='15') # 位置参数必须写在关键字参数前面 # user_info(gender='女', age='15', 'Lili') # positional argument follows keyword argument # 缺省参数 user_info('liming', 20) # 没有为缺省参数传值，使用默认值 user_info('Lihao', 18, '女') # 为缺省参数传值，使用该值代替默认值 -
-
不定长参数
-
不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)的场景。此时，可⽤包裹(packing)位置参数，或者包裹关键字参数，来进⾏参数传递，会显得⾮常⽅便。
-
包裹位置传递
# 接收所有位置参数，返回一个元组 def user_info(*args): print(args) user_info('Lili') # ('Lili',) user_info('Lili', 20) # ('Lili', 20) user_info('Lili', 20, '男') # ('Lili', 20, '男') user_info() # ()注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为⼀个元组(tuple)， args是元组类型，这就是包裹位置传递。
-
包裹关键字传递
# 包裹关键字传递 # 收集所有关键字参数，返回一个字典 def user_info1(**kwargs): print(kwargs) user_info1() # {} user_info1(name='Tom') # {'name': 'Tom'} user_info1(name='Tom', age=20) # {'name': 'Tom', 'age': 20}
综上：⽆论是包裹位置传递还是包裹关键字传递，都是⼀个组包的过程。
-
拆包和交换两个变量的值
-
拆包
-
拆包：元组
def num(): return 100, 200 num1, num2 = num() print(num1) print(num2) -
拆包：字典
dict1 = {'name': 'TOM', 'age': 18} a, b = dict1 # 对字典进⾏拆包，取出来的是字典的key print(a) # name print(b) # age print(dict1[a]) # TOM print(dict1[b]) # 18
-
-
交换变量值
需求：有变量 a = 10 和 b = 20 ，交换两个变量的值。
# 方法一：借助中间变量 a = 10 b = 20 c = a a = b b = c print(a) print(b) # 方法二：简便方法 c = 30 d = 40 c, d = d, c print(c) # 40 print(d) # 30
引用
-
了解引用
在python中，值是靠引⽤来传递来的。 可以⽤id() 来判断两个变量是否为同⼀个值的引⽤。可以将id值理解为那块内存的地址标 识。
a = 1 b = a print(id(a)) # 140717864313680 print(id(b)) # 140717864313680 a = 10 print(id(a)) # 140717864313968 print(id(b)) # 140717864313680 整型为不可变类型 aa = [10, 20, 30] bb = aa print(id(aa)) # 3014536290952 print(id(bb)) # 3014536290952 aa.append(40) print(id(aa)) # 3014536290952 print(id(bb)) # 3014536290952 列表为可变类型 -
引用当作实参
def test1(a): print(a) # b:140717864314288 c:1850972988040 print(id(a)) a += a # b:140717864314288 c:1850972988040 print(id(a)) # int:计算前后的id值不同 b = 10 test1(b) # 列表:计算前后的id值相同 c = [10, 20] test1(c)
可变和不可变类型
所谓可变类型与不可变类型是指：数据能够直接进⾏修改，如果能直接修改那么就是可变，否则是不可变。
- 可变类型
- 列表
- 字典
- 集合
- 不可变类型
- 整型
- 浮点型
- 字符串
- 元组
函数加强
应用：学生信息管理系统
# 显示菜单
def print_info():
print('-' * 20)
print('欢迎登录学员管理系统')
print('1: 添加学员')
print('2: 删除学员')
print('3: 修改学员信息')
print('4: 查询学员信息')
print('5: 显示所有学员信息')
print('6: 退出系统')
print('-' * 20)
# 用列表存储所有学员的信息
info = []
# 添加学员信息
def add_info():
"""添加学员函数"""
# 用户输入学生信息
new_id = input('请输入学号：')
new_name = input('请输入姓名：')
new_tel = input('请输入手机号：')
# 判断是否已经添加学生信息
global info
# 学生姓名重复，则报错
for i in info:
if new_name == i['name']:
print('该用户已经存在')
# 退出当前函数，使得增加函数不执行
return
# 不存在，新增数据
info_dict = {}
info_dict['id'] = new_id
info_dict['name'] = new_name
info_dict['tel'] = new_tel
info.append(info_dict)
print(info)
# 删除学员
def del_info():
"""删除学员"""
del_name = input('请输入要删除的学员的姓名：')
# 判断删除的学员是否存在，存在则删除，否则提示不存在
for i in info:
if i['name'] == del_name:
info.remove(i)
break
else:
print('该学员不存在')
print(info)
# 修改学员函数
def modify_info():
"""修改学员信息"""
modify_name = input('请输入要修改的学员的姓名：')
# 判断学员是否存在
for i in info:
if i['name'] == modify_name:
i['tel'] = input('请输入新的手机号：')
break
else:
print('该学员不存在')
print(info)
# 查询学员信息
def search_info():
"""查询学员信息"""
search_name = input('请输入要查询的学员的姓名：')
global info
for i in info:
if search_name == i['name']:
print(f"该学员的姓名为{i['name']}，id为{i['id']}，手机号为{i['tel']}")
break
else:
# 循环正常结束，查找失败
print('该学员不存在')
# 显示所有学员的信息
def print_all():
"""显示所有学员的信息"""
print("学号\t姓名\t手机号")
# 打印所有学员
for i in info:
print(f"{i['id']}\t{i['name']}\t{i['tel']}")
while True:
# 1. 显示功能界⾯
print_info()
# 2. ⽤户选择功能
user_num = input('请选择您需要的功能序号：')
# 3. 根据⽤户选择，执⾏不同的功能
if user_num == '1':
# print('添加学员')
add_info()
elif user_num == '2':
# print('删除学员')
del_info()
elif user_num == '3':
# print('修改学员信息')
modify_info()
elif user_num == '4':
# print('查询学员信息')
search_info()
elif user_num == '5':
# print('显示所有学员信息')
print_all()
elif user_num == '6':
# print('退出系统')
exit_flag = input('确定要退出？yes or no')
if exit_flag == 'yes':
break
else:
print('输⼊错误，请重新输⼊!!!')
递归
-
特点：
- 函数内部⾃⼰调⽤⾃⼰
- 必须有出⼝
-
应⽤：3以内数字累加和
def sum_numbers(num):
# 递归出口
if num == 1:
return 1
return num + sum_numbers(num - 1)
print(sum_numbers(3))
lambda表达式
应用场景
如果⼀个函数有⼀个返回值，并且只有⼀句代码，可以使⽤ lambda简化。
lambda语法
lambda 参数列表 ： 表达式
注意：
- lambda表达式的参数可有可⽆，函数的参数在lambda表达式中完全适⽤。
- lambda函数能接收任何数量的参数但只能返回⼀个表达式的值
# 函数实现
def fn1():
return 10
print(fn1()) # 10
# lambda 表达式实现匿名函数
fn2 = lambda : 100
print(fn2) # lambda内存地址 <function <lambda> at 0x0000014D2E943B70>
print(fn2()) # 100
print((lambda a, b: a + b)(1, 2)) # 3
注意：直接打印lambda表达式，输出的是此lambda的内存地址
lambda参数
# 无参数
fn1 = lambda : 100
print(fn1())
# 一个参数
fn2 = lambda a: a
print(fn2('Hello Python!'))
# 默认参数
fn3 = lambda a, b, c = 100: a + b + c
print(fn3(10, 20))
print(fn3(10, 20, 30))
# 可变参数
fn4 = lambda *args: args
print(fn4(10, 20, 30)) # (10, 20, 30)
print(fn4(10)) # (10,)
# 可变参数 **kwargs
fn5 = lambda **kwargs: kwargs
print(fn5(name='Lili', age=11)) # {'name': 'Lili', 'age': 11}
lambda应用
带判断的lambda
fn1 = lambda a, b: a if a > b else b
print(fn1(1000, 500)) # 1000
列表数据按字典key的值排序
students = [
{'name': 'TOM', 'age': 20},
{'name': 'ROSE', 'age': 19},
{'name': 'Jack', 'age': 22}
]
# 按name值升序排列
students.sort(key=lambda x: x['name']) # 元组中的每一个字典作为x传入，得到其name, 再a
print(students)
# 按name值降序排列
students.sort(key=lambda x: x['name'], reverse=True)
print(students)
# 按age值升序排列
students.sort(key=lambda x: x['age'])
print(students)
高阶函数
高阶函数举例
# 将函数作为参数传入，化简代码
def add1(a, b, f):
return f(a) + f(b)
# 绝对值求和
print(add1(-1, -5, abs)) # 6
# 四舍五入求和
print(add1(1.2, 3.6, round)) # 5
内置高阶函数
-
map()
map(func, lst)，将传⼊的函数变量func作⽤到lst变量的每个元素中，并将结果组成新的列表(Python2)/ 迭代器(Python3)返回。
# 需求：计算 list1 序列中各个数字的2次⽅。 list1 = [1, 2, 3, 4, 5] def func(x): return x**2 result = map(func, list1) print(result) # <map object at 0x0000022794B83358> print(list(result)) # [1, 4, 9, 16, 25] -
reduce()
reduce(func(x,y)，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累 积计算。
# 需求：计算 list1 序列中各个数字的累加和。 import functools list1 = [1, 2, 3, 4, 5] def func(a, b): return a + b result = functools.reduce(func, list1) print(result)注意：reduce()传⼊的参数func必须接受2个参数。
-
filter()
filter(func, lst)函数⽤于过滤序列, 过滤掉不符合条件的元素, 返回⼀个 filter 对象,。如果要转换为列表, 可以使⽤ list() 来转换。
# 需求：过滤列表中的偶数 list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] def func(x): return x % 2 == 0 # 满足func()函数的数据全都过滤掉 result = filter(func, list1) print(result) # <filter object at 0x0000015B4E403320> print(list(result)) # [2, 4, 6, 8, 10]
文件操作
文件操作的作用
⽂件操作的作⽤就是把⼀些内容(数据)存储存放起来，可以让程序下⼀次执⾏的时候直接使⽤，⽽不必重新制作⼀份，省时省⼒。
文件的基本操作
文件操作步骤
-
打开
在python，使⽤open函数，可以打开⼀个已经存在的⽂件，或者创建⼀个新⽂件，语法如下：
open(name, mode)name：是要打开的⽬标⽂件名的字符串(可以包含⽂件所在的具体路径)。
mode：设置打开⽂件的模式(访问模式)：只读、写⼊、追加等。
-
打开文件模式(+号代表可读可写，b代表二进制格式访问)
模式 描述 r 以只读⽅式打开⽂件。⽂件的指针将会放在⽂件的开头。这是默认模式。 rb 以⼆进制格式打开⼀个⽂件⽤于只读。⽂件指针将会放在⽂件的开头。这是默认模式。 r+ 打开⼀个⽂件⽤于读写。⽂件指针将会放在⽂件的开头。 rb+ 以⼆进制格式打开⼀个⽂件⽤于读写。⽂件指针将会放在⽂件的开头。 w 打开⼀个⽂件只⽤于写⼊。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内 容会被删除。如果该⽂件不存在，创建新⽂件。 wb 以⼆进制格式打开⼀个⽂件只⽤于写⼊。如果该⽂件已存在则打开⽂件，并从开头开始编 辑，即原有内容会被删除。如果该⽂件不存在，创建新⽂件。 w+ 打开⼀个⽂件⽤于读写。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内容 会被删除。如果该⽂件不存在，创建新⽂件。 wb+ 以⼆进制格式打开⼀个⽂件⽤于读写。如果该⽂件已存在则打开⽂件，并从开头开始编 辑，即原有内容会被删除。如果该⽂件不存在，创建新⽂件。 a 打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。也就是说， 新的内容将会被写⼊到已有内容之后。如果该⽂件不存在，创建新⽂件进⾏写⼊。 ab 以⼆进制格式打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结 尾。也就是说，新的内容将会被写⼊到已有内容之后。如果该⽂件不存在，创建新⽂件进 ⾏写⼊。 a+ 打开⼀个⽂件⽤于读写。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。⽂件打开时 会是追加模式。如果该⽂件不存在，创建新⽂件⽤于读写。 ab+ 以⼆进制格式打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结 尾。如果该⽂件不存在，创建新⽂件⽤于读写。 -
主访问模式
# r: 若文件不存在，则报错，且不支持写入操作，表示只读 f = open('text1.txt', 'r') # No such file or directory: 'text1.txt' f = open('text.txt', 'r') f.write('abc') f.close() # w: 只写，若文件不存在，则新建文件，执行写入，并且会覆盖原有内容 f = open('t1.txt', 'w') f.write('aaa') # 原文件内容会被覆盖 f.close() # a: 追加，若文件不存在，新建文件，并在原有内容上追加新的内容 f = open('t2.txt', 'a') f.write('bbb') # 追加至原文件内容后面 f.close() # 访问模式参数可以省略，若省略则表示访问模式为r f = open('t1.txt') f = open('t3.txt') # No such file or directory: 't3.txt' f.close() -
次访问模式
# # r+特点: r没有该文件则报错，文件指针在开头，故能读取出来数据 # f = open('text.txt', 'r+') # # f = open('text1.txt', 'r+') # [Errno 2] No such file or directory: 'text1.txt' # w+: 没有该文件会新建文件，w特点：文件指针在开头，用新内容覆盖原内容 # f = open('text.txt', 'w+') # a+：没有该文件会新建文件，文件指针在结尾，无法读取数据(文件指针后无数据) f = open('text.txt', 'a+') contend = f.read() print(contend)
-
-
-
文件对象方法
-
写
文件对象.write('内容')# 1. 打开⽂件 f = open('test.txt', 'w') # 2.⽂件写⼊ f.write('hello world') # 3. 关闭⽂件 f.close()注意：
- w 和 a 模式：如果⽂件不存在则创建该⽂件；如果⽂件存在， w 模式先清空再写⼊， a 模式直接末尾追加。
-
- r 模式：如果⽂件不存在则报错。
-
读
-
read()
⽂件对象.read(num)num表示要从⽂件中读取的数据的⻓度（单位是字节），如果没有传⼊num，那么就表示读取⽂ 件中所有的数据。
f = open('text.txt', 'r') # 读取文件内容 # 不写参数 print(f.read()) # 写参数，若文件内容换行，则默认包含换行符\n，读取时会算作一个字符。 print(f.read(10)) f.close() -
readlines()
- readlines可以按照⾏的⽅式把整个⽂件中的内容进⾏⼀次性读取，并且返回的是⼀个列表，其中每⼀⾏的数据为⼀个元素。
-
readline()
- readline()⼀次读取⼀⾏内容。
f = open('text.txt', 'r') content = f.readlines() print(content) # ['aaaaa\n', 'bbbbb\n', 'ccccc\n', 'ddddd\n', 'eeeee'] content = f.readline() print(content) # aaaaa f.close()
-
-
seek()函数
-
作⽤：⽤来移动⽂件指针。
-
语法：
⽂件对象.seek(偏移量, 起始位置)起始位置： 0：⽂件开头； 1：当前位置； 2：⽂件结尾
-
-
关闭文件
⽂件对象.close()
-
文件备份
# 需求：⽤户输⼊当前⽬录下任意⽂件名，程序完成对该⽂件的备份功能(备份⽂件名为xx[备份]后缀，例
# 如：test[备份].txt)。
# 用户输入目标文件
old_name = input('请输入您要备份的文件名：')
# 提取备份文件名字
index = old_name.rfind('.') # 找到文件后缀
# 有效文件才备份
if index > 0:
postfix = old_name[index:]
# 组织新名字
print(old_name[:index]) # 名字
print(old_name[index:]) # 后缀
new_name = old_name[:index] + '[备份]' + postfix
print(new_name)
# 给备份文件写入数据
# 打开源文件和备份文件
old_f = open(old_name, 'rb')
new_f = open(new_name, 'wb')
# 循环写入，以防止读取数据过大
while True:
con = old_f.read(1024)
# 数据读取出来为空，则终止循环
if(len(con) == 0):
break
new_f.write(con)
# 关闭文件
old_f.close()
new_f.close()
文件和文件夹的操作
在Python中⽂件和⽂件夹的操作要借助os模块⾥⾯的相关功能，具体步骤如下：
- 导⼊os模块
import os
-
使⽤ os 模块相关功能
os.函数名() -
文件重命名
os.rename(⽬标⽂件名, 新⽂件名) -
删除文件
os.remove(⽬标⽂件名) -
创建文件夹
os.mkdir(⽂件夹名字) -
删除文件夹
os.rmdir(⽂件夹名字) -
获取当前目录
os.getcwd() -
改变默认目录
os.chdir(⽬录) -
获取目录列表
os.listdir(⽬录)
import os
# 重命名
# os.rename('t1.txt', 't3.txt')
# 删除文件
# os.remove('t3.txt')
# 创建文件夹
# os.mkdir('aaa') # 当前目录下创建
# 删除文件夹
# os.rmdir('aaa')
# 获取当前文件所在路径
print(os.getcwd())
# 切换目录路径
# os.chdir('aaa')
# 在aaa文件加中创建新文件夹
# os.mkdir('bbb')
# 获取某个文件夹下的所有文件，并以列表的形式返回
# print(os.listdir()) # 没有参数则获取根目录下的所有文件信息
# print(os.listdir('aaa'))
# 重命名文件夹
# os.chdir('aaa') # 切换到aaa文件夹下
# os.rename('bbb', 'bb') # 将aaa文件夹下的bbb重命名
应用案例
# 需求：批量修改⽂件名，既可添加指定字符串，⼜能删除指定字符串。
import os
# 设置重命名标识：如果为1则添加指定字符，flag取值为2则删除指定字符
flag = 1
# 获取指定⽬录
dir_name = './'
# 获取指定⽬录的⽂件列表
file_list = os.listdir(dir_name)
# print(file_list)
# 遍历⽂件列表内的⽂件
for name in file_list:
# 添加指定字符
if flag == 1:
new_name = 'Python-' + name
# 删除指定字符
elif flag == 2:
num = len('Python-')
new_name = name[num:]
# 打印新⽂件名，测试程序正确性
print(new_name)
# 重命名
os.rename(dir_name + name, dir_name + new_name)
面向对象
⾯向对象就是将编程当成是⼀个事物，对外界来说，事物是直接使⽤的，不⽤去管他内部 的情况。⽽编程就是设置事物能够做什么事。
一. 类和对象
类和对象的关系：⽤类去创建(实例化)⼀个对象。
理解类和对象
- 类
类是对⼀系列具有相同特征和⾏为的事物的统称，是⼀个抽象的概念，不是真实存在的事物。
-
特征即是属性
-
⾏为即是⽅法添加和获取对象属性
- 对象
对象是类创建出来的真实存在的事物。
注：先有类才能创建对象。
面向对象实现方法
-
定义类
Python2中类分为：经典类 和 新式类
-
语法
class 类名(): 代码 ......注意：类名要满⾜标识符命名规则，同时遵循⼤驼峰命名习惯。
-
拓展：经典类
不由任意内置类型派⽣出的类，称之为经典类
class 类名: 代码 ......
-
-
创建对象
对象⼜名实例。
-
语法
对象名 = 类名() -
实例
class Washer(): def wash(self): print('洗衣服') # 创建对象 haier = Washer() print(haier) # <__main__.Washer object at 0x00000206FDE43358> # 实例方法/对象方法 -- 对象名.wash() haier.wash() # 洗衣服注意：创建对象的过程也叫实例化对象。
-
-
self
self指的是调⽤该函数的对象。
-
实例
# 1. 定义类 class Washer(): def wash(self): print('我会洗⾐服') # <__main__.Washer object at 0x0000024BA2B34240> print(self) # 2. 创建对象 haier1 = Washer() # <__main__.Washer object at 0x0000018B7B224240> print(haier1) # haier1对象调⽤实例⽅法 haier1.wash() haier2 = Washer() # <__main__.Washer object at 0x0000022005857EF0> print(haier2)注意：打印对象和self得到的结果是⼀致的，都是当前对象的内存中存储地址。
-
二. 添加和获取对象属性
属性即是特征，⽐如：洗⾐机的宽度、⾼度、重量…
对象属性既可以在类外⾯添加和获取，也能在类⾥⾯添加和获取。
-
类外⾯添加对象属性
-
语法
对象名.属性名 = 值
-
-
类外⾯获取对象属性
-
语法
对象名.属性名
-
-
实例
# 类外⾯添加对象属性 haier1.width = 500 haier1.height = 800 # 类外⾯获取对象属性 print(f'haier1洗⾐机的宽度是{haier1.width}') print(f'haier1洗⾐机的⾼度是{haier1.height}') -
类⾥⾯获取对象属性
-
语法
self.属性名 -
示例
# 定义类 class Washer(): def print_info(self): # 类⾥⾯获取实例属性 print(f'haier1洗⾐机的宽度是{self.width}') print(f'haier1洗⾐机的⾼度是{self.height}') # 创建对象 haier1 = Washer() # 添加实例属性 haier1.width = 500 haier1.height = 800 haier1.print_info()
-
三. 魔法方法
在Python中，__xx__()的函数叫做魔法⽅法，指的是具有特殊功能的函数。
3.1 __init__
-
体验__init__()-
__init__()⽅法的作⽤：初始化对象。class Washer(): # 定义初始化功能的函 def __init__(self): # 添加实例属性 self.width = 500 self.height = 800 def print_info(self): # 类⾥⾯调⽤实例属性 print(f'洗⾐机的宽度是{self.width}, ⾼度是{self.height}') haier1 = Washer() haier1.print_info()注意：
-
__init__()⽅法，在创建⼀个对象时默认被调⽤，不需要⼿动调⽤ -
__init__(self)中的self参数，不需要开发者传递，python解释器会⾃动把当前的对象引 ⽤传递过去。
-
-
-
带参数的
__init__()对初始化函数传递参数可以对不同的对象设置不同的初始化属性
class Washer(): def __init__(self, width, height): self.width = width self.height = height def print_info(self): print(f'洗⾐机的宽度是{self.width}') print(f'洗⾐机的⾼度是{self.height}') haier1 = Washer(10, 20) haier1.print_info() haier2 = Washer(30, 40) haier2.print_info()
3.2__str__()
当使⽤print输出对象的时候，默认打印对象的内存地址。如果类定义了 str ⽅法，那么就会打印从 在这个⽅法中 return 的数据。
class Washer():
def __init__(self, wigth, height, name):
self.wigth = wigth
self.height = height
self.name = name
def info(self):
print(f'{self.name}的宽度为{self.wigth}')
print(f'{self.name}的高度为{self.height}')
def __str__(self):
return f'这个洗衣机的名称是{self.name}'
haier1 = Washer(100, 200, 'haier1')
haier1.info() # haier1的宽度为100
haier2 = Washer(400, 500,'haier2')
haier2.info() # haier2的宽度为400
print(haier2) # 这个洗衣机的名称是haier2
3.3 __del__()
当删除对象时，python解释器也会默认调⽤__del__()⽅法。
class Washer():
def __init__(self, wigth, height, name):
self.wigth = wigth
self.height = height
self.name = name
def info(self):
print(f'{self.name}的宽度为{self.wigth}')
print(f'{self.name}的高度为{self.height}')
def __str__(self):
return f'这个洗衣机的名称是{self.name}'
def __del__(self):
print(f'{self.name}已经删除成功！')
del haier2 # haier2已经删除成功！
# haier1已经删除成功！
若不使用del手动删除对象，则当代码执行完毕后会自动调用
__del__()方法删除对象。`
3.4 __call__()
__call__可以把类实例当做函数调用。
import time
# 类中的__call__魔法方法，只要类对象中实现了__call__方法，
# 创建实例对象test = Test() 后，实力对象后面加括号会自动调用__call__里的方法。
class Test():
def __init__(self):
print('一旦创建实例对象，自动调用__inni__()')
def __del__(self):
print('一旦销毁实例对象或者函数程序停止运行，自动调用__del__()')
def __call__(self):
print('实力对象后面加(),自动调用__call__()')
test = Test()
# del test # 删除对象
test()
time.sleep(5)
# 运行结果
# 一旦创建对象，自动调用__inni__()
# 实例对象后面加(),自动调用__call__
# 。。。。。（5s后）。。。。。。
# 一旦销毁实力对象或者函数程序停止运行，自动调用__del__()
实现了
__call__方法的类的实例化对象可以像函数一样去调用它。
3.5 __getitem__()
__getitem__ 可以让对象实现迭代功能，这样就可以使用for...in... 来迭代该对象了。调用对象的属性可以像字典取值一样使用中括号[‘key’]
class Animal:
def __init__(self, animal_list):
self.animals_name = animal_list
def __getitem__(self, index):
return self.animals_name[index]
animals = Animal(["dog","cat","fish"])
for animal in animals:
print(animal)
# 输出结果
'''
dog
cat
fish
'''
当一个类.中定义了getitem方法，那么它的实例对象便拥有了通过下标来索引的能力。即实例对象（假设为P）可以P[key]这样取值。当实例对象做P[key]运算时，就会调用类中的__getitem__()方法。
class A(object): def __getitem__(self, item): return item a = A() print(a[5], a[12]) # 5 12
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
