文章目录
- 1. 数据类型
- 2. 输出
- 3. 输入
- 4. 数据类型转换
- 5. 运算符
- 6. 条件语句
- 7. 循环语句
- 8. 函数
- 9. 文件操作
- 10. 文件和文件夹的操作
- 11. 面向对象
1. 数据类型
- 数值
- int（整型）
- float（浮点型）
- 布尔型
- True（真）
- False（假）
- str（字符串）
- list（列表）
list = (a, b, c) - tuple（元组）
tuple = [a, b, c] - set（集合）
set = {a, b, c} - dict（字典）
dict = {key1:value1, key2:value2, key3:value3}
检测数据类型：type(数据)
1.1 字符串
1.1.1 字符串特征
- 一对引号字符串
name1 = 'Tom'
name2 = "Rose"
- 三引号字符串
name3 = ''' Tom '''
name4 = """ Rose """
a = '''i am Tom,
nice to meet you !'''
b = """i am rose,
nice to meet you !"""
1.1.2 字符串输出
print('hello')
name = 'Tom'
print('我的名字是%s' % name)
print(f'我的名字是{name}')
1.1.3 字符串输入
使用input()接收用户输入
- 代码
name = input('请输入名字：')
print(f'名字是{name}')
print(type(name))
1.1.4 下标
又叫“索引”，就是编号
从左往右，从0开始
str = 'abcde'
print(str[0])
1.1.5 切片
是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作
- 语法
序列[开始位置下标:结束位置下标:步长]
- 不包含结束位置下标对应的数据，正负整数均可【即“左闭右开”】
- 步长是选取间隔，正负整数均可，默认步长为1
- 示例
str = 'abcdefg'
print(str[2:5:1]) #cde
print(str[2:5]) #cde
print(str[:5]) #abcde 不写开始，默认从0位置开始
print(str[1:]) #bcdefg 不写结束，默认取到最后
print(str[:]) #abcdefg 开始和结束都不写，取所有
print(str[::-1]) #gfedcba 倒叙取，步长是1
1.1.6 常用操作方法
字符串的常用操作方法有查找、修改和判断三大类
1.1.6.1 查找
查找子串在字符串中的位置或出现的次数
-
find()：检测字串是否包含在字符串中，如果在返回字串开始的位置下标，否则则返回-1
-
语法
开始和结束位置下标可以忽略，表示在整个字符串系列中查找
字符串序列.find(子串, 开始位置下标, 结束位置下标) -
示例
mystr = "hello world and itcast and itheima and Python" print(mystr.find('and')) #12 print(mystr.find('and', 15, 30)) #23 print(mystr.find('ands')) #-1
-
-
index()：检测子串是否包含在字符串中，如果在，返回字串开始的位置下标，否则则报异常
-
语法
开始和结束位置下标可以忽略，表示在整个字符串系列中查找
字符串序列.index(子串, 开始位置下标, 结束位置下标) -
示例
mystr = "hello world and itcast and itheima and Python" print(mystr.index('and')) #12 print(mystr.index('and', 15, 30)) #23 print(mystr.index('ands')) #报错
-
-
count()：返回子串在字符串中出现的次数
-
语法
字符串序列.count(子串) -
示例
mystr = "hello world and itcast and itheima and Python" print(mystr.count('and')) #3 print(mystr.count('ands')) #0
-
-
rfind()：和find()功能相同，但查找方向是从右侧开始
-
rindex()：和index()功能相同，但查找方向是从右侧开始
1.1.6.2 修改
通过函数的形式修改字符串中的数据
-
replace()：替换
-
语法
- 替换次数不指定，则全部替换
- 未改变原字符串，而是生成一个新的字符串
字符串序列.replace(旧字符串, 新字符串, 替换次数) -
示例
mystr = "hello world and itcast and itheima and Python" print(mystr.replace('and', 'he')) #hello world he itcast he itheima he Python print(mystr.replace('and', 'he', '10')) #hello world he itcast he itheima he Python
-
-
split()：按照指定字符分割字符串
-
语法
num表示的是分割字符出现的次数，即将来返回数据个数为num+1个
字符串序列.split(分割字符, num) -
示例
mystr = "hello world and itcast and itheima and Python" print(mystr.split('and')) #['hello world ', ' itcast ', ' itheima ', ' Python'] print(mystr.split('and', 2)) #['hello world ', ' itcast ', ' itheima and Python']
-
-
join()：合并列表里的字符串数据为一个大字符串
-
语法
字符或字串.join(多字符串组成的序列) -
示例
mylist = ['aa', 'bb', 'cc'] new_str = '...'.join(mylist) print(new_str) # aa...bb...cc
-
-
capitalize()：将字符串第一个字符转换成大写，却其余字符全部小写
-
示例
mystr = "hello world and itcast and itheima and Python" print(mystr.capitalize()) # Hello world and itcast and itheima and python
-
-
title()：将字符串每个单词的首字母都变成大写
-
示例
mystr = "hello world and itcast and itheima and Python" print(mystr.title()) # Hello World And Itcast And Itheima And Python
-
-
lower()：将字符串中大写转小写
-
示例
mystr = "hello world and itcast and itheima and Python" print(mystr.lower()) # hello world and itcast and itheima and python
-
-
upper()：将字符串中小写转大写
-
示例
mystr = "hello world and itcast and itheima and Python" print(mystr.upper()) # HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON
-
-
lstrip()：删除字符串左侧空白字符
-
rstrip()：删除字符串右侧空白字符
-
strip()：删除字符串两侧空白字符
-
ljust()：返回一个原字符串左对齐，并使用指定字符（默认空格）填充至对应长度的新字符串
-
语法
字符串序列.ljust(长度, 填充字符)
-
-
rjust()：返回一个原字符串右对齐，并使用指定字符（默认空格）填充至对应长度的新字符串
-
语法
字符串序列.rjust(长度, 填充字符)
-
-
center()：返回一个原字符串中间对齐，并使用指定字符（默认空格）填充至对应长度的新字符串
-
语法
字符串序列.center(长度, 填充字符)
-
1.1.6.3 判断
判断真假，返回的结果是布尔类型：True 或 False
-
startswith()：检查字符串是否是以指定字串开头，是则返回True，否则返回False。如果设置开始和结束位置下标，则在指定范围内检查
-
语法
字符串序列.startswith(字串, 开始下标, 结束下标) -
示例
mystr = "hello world and itcast and itheima and Python" print(mystr.startswith('hello')) #True
-
-
endswith()：检查字符串是否是以指定字串结尾，是则返回True，否则返回False。如果设置开始和结束位置下标，则在指定范围内检查。用法与startswith()相同
-
isalpha()：如果字符串至少有一个字符且所有字符都是字母则返回True，否则返回False
-
示例
str1 = 'hello' str2 = 'hello123' print(str1.isalpha()) #True print(str2.isalpha()) #False
-
-
isdigit()：如果字符串只包含数字则返回True，否则返回False
-
示例
str1 = 'hello' str2 = 'hello123' str3 = '123456' print(str1.isdigit()) #False print(str2.isdigit()) #False print(str3.isdigit()) #True
-
-
isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False
-
isspace()：如果字符串中只包含空白，则返回True，否则返回False
1.2 列表
1.2.1 语法
可以一次性存储多个数据，且可以为不同类型的数据
[数据1, 数据2, 数据3...]
1.2.2 常用操作
常用操作有：增、删、改、查
1.2.2.1 查找
- 下标
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) #Tom
print(name_list[1]) #Lily
print(name_list[2]) #Rose
- 函数
-
index()：返回指定数据所在位置的下标
如果查找的数据不存在，则报错
-
语法
列表序列.index(数据, 开始位置下标, 结束位置下标) -
示例
name_list = ['Tom', 'Lily', 'Rose'] print(name_list.index('Lily', 0, 2)) #1
-
-
count()：统计指定数据在当前列表中出现的次数
-
示例
name_list = ['Tom', 'Lily', 'Rose'] print(name_list.count('Lily')) #1
-
-
len()：访问列表长度，即列表中数据的个数
-
示例
name_list = ['Tom', 'Lily', 'Rose'] print(len(name_list)) #3
-
- 判断是否存在
-
in：判断指定数据在某个列表序列，如果在则返回True，否则返回False
name_list = ['Tom', 'Lily', 'Rose'] print('Lily' in name_list) #True print('Lilys' in name_list) #False -
not in：判断指定数据不在某个列表序列，如果不在则返回True，否则返回False
name_list = ['Tom', 'Lily', 'Rose']
print('Lily' not in name_list) #False
print('Lilys' not in name_list) #True
1.2.2.2 增加
-
append()：列表结尾追加数据
直接在原列表中追加数据，故会修改原列表
-
语法
列表序列.append(数据) -
示例
name_list = ['Tom', 'Lily', 'Rose'] name_list.append('xiaoming') print(name_list) #['Tom', 'Lily', 'Rose', 'xiaoming']
-
-
extend()：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据注意添加到列表
-
语法
列表序列.extend(数据) -
示例
- 单个数据
name_list = ['Tom', 'Lily', 'Rose'] name_list.extend('xiaoming') print(name_list) #['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']- 序列数
name_list = ['Tom', 'Lily', 'Rose'] name_list.extend(['xiaoming', 'xiaogang']) print(name_list) #['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaogang']
-
-
insert()：指定位置新增数据
-
语法
列表序列.insert(位置下标, 数据) -
示例
name_list = ['Tom', 'Lily', 'Rose'] name_list.insert(1, 'xiaoming') print(name_list) #['Tom', 'xiaoming', 'Lily', 'Rose']
-
1.2.2.3 删除
-
del
-
语法
del 目标 -
示例
-
删除列表
name_list = ['Tom', 'Lily', 'Rose'] del name_list print(name_list) #报错：name 'name_list' is not defined -
删除指定数据
name_list = ['Tom', 'Lily', 'Rose'] del name_list[0] print(name_list) #['Lily', 'Rose']
-
-
-
pop()：删除指定下标的数据（默认为最后一个），并返回该数据
-
语法
列表序列.pop(下标) -
示例
name_list = ['Tom', 'Lily', 'Rose'] del_name = name_list.pop(1) print(name_list) #['Tom', 'Rose'] print(del_name) #Lily
-
-
remove()：移除列表中某个数据的第一个匹配项
-
语法
列表序列.remove(数据) -
示例
name_list = ['Tom', 'Lily', 'Rose'] name_list.remove('Rose') print(name_list) #['Tom', 'Lily']
-
-
clear()：清空列表
-
语法
列表序列.clear() -
示例
name_list = ['Tom', 'Lily', 'Rose'] name_list.clear() print(name_list) #[]
-
1.2.2.4 修改
-
直接修改
name_list = ['Tom', 'Lily', 'Rose'] name_list[0] = 'aaa' print(name_list) #['aaa', 'Lily', 'Rose'] -
reverse()：逆置
-
示例
num_list = [1, 5, 2, 3, 6, 8] num_list.reverse() print(num_list) #[8, 6, 3, 2, 5, 1]
-
-
sort()：排序
-
语法
reverse表示排序规则，reverse=True 降序，reverse=False 升序（默认）
列表序列.sort(key=None, reverse=False) -
示例
-
升序
num_list = [1, 5, 2, 3, 6, 8] num_list.sort() # 升序 print(num_list) #[1, 2, 3, 5, 6, 8] -
降序
num_list = [1, 5, 2, 3, 6, 8] num_list.sort(reverse=True) # 将序 print(num_list) #[8, 6, 5, 3, 2, 1]
-
-
1.2.2.5 复制
-
copy()
-
示例
num_list = [1, 5, 2, 3, 6, 8] num_list2 = num_list.copy() print(num_list2) #[[1, 5, 2, 3, 6, 8]
-
1.2.3 循环遍历
1.2.3.1 while
num_list = [1, 5, 2, 3, 6, 8]
i = 0
while i < len(num_list):
print(num_list[i])
i += 1
1.2.3.2 for
num_list = [1, 5, 2, 3, 6, 8]
for i in num_list:
print(i)
1.2.4 列表嵌套
指的是一个列表里面包含了其他的子列表
name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]
print(name_list[2]) #['张三', '李四', '王五']
print(name_list[2][1]) #李四
1.2.5 应用案例
需求：8位老师，3个办公室，将8位老师随机分配到3个办公室，最后验证
import random
teachers = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
offices = [[], [], []]
for name in teachers:
num = random.randint(0,2)
offices[num].append(name)
i = 1
for office in offices:
print(f'办公室{i}的人数是{len(office)}，老师分别是：')
for name in office:
print(name)
i += 1
1.3 元组
一个元组可以存储多个数据，元组内的数据不能修改
1.3.1 语法
定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型
如果定义元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型
# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)
1.3.2 常见操作
元组数据不支持修改，只支持查找
-
按下标查找数据
t1 = ('aa', 'bb', 'cc', 'bb') print(t1[0]) #aa -
index()：查找某个数据，如果数据存在则返回对应的下标，否则报错
t1 = ('aa', 'bb', 'cc', 'bb') print(t1.index('aa')) #0 -
count()：统计某个数据在当前元组出现的次数
t1 = ('aa', 'bb', 'cc', 'bb') print(t1.count('aa')) #1
元组中的数据不支持修改，如果修改，会报错；如果元组中有列表，那么列表中的数据是支持修改的
t1 = ('aa', 'bb', ['a', 'b'], 'bb')
t1[2][0] = 'c'
print(t1)
1.4 字典
字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标
1.4.1 语法
字典特点：
- 符合为大括号
- 数据为键值对形式出现
- 各个键值对之间用逗号隔开
# 有数据字典
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()
1.4.2 常见操作
字典为可变类型
1.4.2.1 增
-
语法
如果key存在，则修改这个key的值；如果不存在则新增此键值对
字典序列[key] = 值
1.4.2.2 删
-
del() / del：删除字典或删除字典中指定键值对
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'} del dict1['gender'] print(dict1) #{'name': 'Tom', 'age': '20'} -
clear()：清空字典
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'} dict1.clear() print(dict1) #{}
1.4.2.3 改
-
语法
如果key存在，则修改这个key的值；如果不存在则新增此键值对
字典序列[key] = 值
1.4.2.4 查
-
key值查找
如果当前查找的key存在，则返回对应的值；否则直接报错
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'} print(dict1['name']) #Tom -
get()
-
语法
如果当前查找的key不存在则返回第二个参数（默认值），如果省略第二个参数，则返回None
字典序列.get(key, 默认值) -
示例
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'} print(dict1.get('name')) #Tom print(dict1.get('id', 10)) #10 print(dict1.get('id')) #None
-
-
keys()：列出所有key
-
示例
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'} print(dict1.keys()) #dict_keys(['name', 'age', 'gender'])
-
-
values()：列出所有values
-
示例
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'} print(dict1.values()) #dict_values(['Tom', '20', '男'])
-
-
items()：
-
示例
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'} print(dict1.items()) #dict_items([('name', 'Tom'), ('age', '20'), ('gender', '男')])
-
1.4.3 循环遍历
- 遍历字典的key
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'}
for key in dict1.keys():
print(key)
- 遍历字典的value
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'}
for value in dict1.values():
print(value)
- 遍历字典的元素
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'}
for item in dict1.items():
print(item)
- 遍历字典的键值对
dict1 = {'name': 'Tom', 'age': '20', 'gender': '男'}
for key,value in dict1.items():
print(f'{key}={value}')
1.5 集合
1.5.1 语法
创建集合使用{}或set()，但是创建空集合只能用set()，因为{}用来创建空字典
s1 = {10, 20, 30, 40}
s2 = {'abcdefg'}
s3 = set()
1.5.2 常见操作
1.5.2.1 增
-
add()
集合有去重功能，当向集合追加的数据是当前集合已有的数据，则不进行任何操作
s1 = {10, 20} s1.add(30) print(s1) # {10, 20, 30} -
update()：追加的数据是序列
s1 = {10, 20} s1.update([30, 40]) print(s1) # {40, 10, 20, 30}
1.5.2.2 删
-
remove()：删除集合中的指定数据，如果数据不存在则报错
s1 = {10, 20} s1.remove(10) print(s1) #{20} -
discard()：删除集合中的指定数据，如果数据不存在也不会报错
s1 = {10, 20} s1.discard(10) print(s1) #{20} -
pop()：随机删除某个数据，并返回这个数据
s1 = {10, 20} del_num = s1.pop() print(del_num) #10 print(s1) #{20}
1.5.2.3 查
- in：判断数据是否在集合
- not in：判断数据是否不在集合
s1 = {10, 20}
print(10 in s1) #True
print(10 not in s1) #False
print(30 not in s1) #True
1.6 公共操作
1.6.1 运算符
| 运算符 | 描述 | 支持的容器类型 |
|---|---|---|
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| in | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 元素是否不存在 | 字符串、列表、元组、字典 |
1.6.2 公共方法
| 函数 | 描述 |
|---|---|
| len() | 计算容器中元素个数 |
| del 或 del() | 删除 |
| max() | 返回容器中元素最大值 |
| min() | 返回容器中元素最小值 |
| range(start, end, step) | 生成从start到end的数字，步长为step，共for循环使用【左闭右开】 |
| enumerate() | 函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中 |
-
enumerate()
-
语法
start 参数用来设置遍历数据的下标的起始位置，默认为0
enumerate(可遍历对象, start=0) -
示例
list1 = ['a', 'b', 'c'] for i in enumerate(list1): print(i) for index, char in enumerate(list1): print(f'下标是{index}，对应的字符是{char}')
-
1.6.3 容器类型转换
| 函数 | 描述 |
|---|---|
| tuple() | 将某个序列转换成元组 |
| list() | 将某个序列转换成列表 |
| set() | 将某个序列转换成集合 |
1.7 推导式
- 列表推导式
- 字典推导式
- 集合推导式
1.7.1 列表推导式
作用：用一个表达式创建一个有规律的列表或控制一个有规律的列表
列表推导式又叫列表生成式
-
示例：创建0-10的列表【普通列表推导式】
-
列表推导式
list1 = [i for i in range(10)] print(list1)
-
-
示例：创建0-10的偶数列表【if 列表推导式】
-
rang() 步长实现
list1 = [i for i in range(0, 10, 2)] print(list1) -
if 实现
list1 = [i for i in range(10) if i % 2 == 0] print(list1)
-
-
示例：创建列表[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)] 【多个for 列表推导式】
-
多个for
list1 = [(i, j) for i in range(1, 3) for j in range(3)] print(list1)
-
1.7.2 字典推导式
作用：快速合并列表为字典或提取字典中目标数据
-
创建一个字典：字典key是1-5数字，value是这个数字的2次方
dict1 = {i: i**2 for i in range(1, 5)} print(dict1) -
将两个列表合并为一个字典
len统计长列表会报错，统计短列表不会报错
list1 = ['name', 'age', 'gender'] list2 = ['Tom', 20, 'man'] dict1 = {list1[i]: list2[i] for i in range(len(list1))} print(dict1) -
提取字典中目标数据
counts = { 'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99 } # 需求：提取上述电脑数量大于等于200的字典数据 count1 = { k:v for k, v in counts.items() if v >= 200 } print(count1) #{'MBP': 268, 'DELL': 201}
1.7.3 集合推导式
-
创建一个集合，数据为下方列表中数据的2次方
集合有去重功能
list1 = [1 ,2, 2] set1 = { i ** 2 for i in list1} print(set1) #{1, 4}
2. 输出
2.1 格式化输出
- %
- %s：字符串
- %d：有符号十进制
- %f：浮点型
print('名字是%s,年龄是%2d,体重是%.2f' % (name, age, weight))
- f (python3.6版本后新增的功能)
语法：f'{表达式}'
print(f'名字是{name},年龄是{age},体重是{weight}')
2.2 转义字符
- \n：换行
- \t：制表符，（4个空格的距离）
2.3 结束符
print('输出的内容', end="\n")
3. 输入
3.1 输入语法
input("提示信息")
3.2 输入的特点
- 当程序执行到input，等待用户输入，输入完成之后才继续向下执行
- input接收用户输入后，一般存储到变量，方便使用
- input会把接收到的任意用户输入的数据都当作字符串处理
4. 数据类型转换
4.1 转换为整型：使用int函数
-
浮点型转换为整型
PS：保留小数点前面的数，去掉小数点和小数点后面的数
a = 3.14
b = int(a)
print(b)
- 字符串转换为整型
a = '123'
b = int(a)
print(b)
4.2 转换为字符串：使用str函数
- 整型转换为字符串
- 浮点型转换为字符转
4.3 转换为浮点类型：使用float函数
- 整型转换为浮点型
- 字符串转换为浮点型
4.4 eval函数
将字符串中的数据转换为它原本的数据类型
str1 = '1'
str2 = '1.1'
str3 = '(100, 200, 300)'
str4 = '[100, 200, 300]'
prind(type(str1))
prind(type(str2))
prind(type(str3))
prind(type(str4))
4.5 转换为元组：使用tuple函数
4.6 转换为列表：使用list函数
5. 运算符
- 算数运算符
- 赋值运算符
- 复合赋值运算符
- 比较运算符
- 逻辑运算符
5.1 算数运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
| + | 加 | 1 +1 输出结果为 2 |
| - | 减 | 1 - 1 输出结果为 0 |
| * | 乘 | 2 * 2 输出结果为 4 |
| / | 除 | 10 / 2 输出结果为 5 |
| // | 整除 | 9 // 4 输出结果为 2 |
| % | 取余 | 9 % 4 输出结果为 1 |
| ** | 指数 | 2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2 |
| （） | 小括号 | 小括号用来提高运算优先级，即 (1 + 2) * 3 输出结果为 9 |
- 混合运算优先级：() 高于 ** 高于 * / // % 好于 + -
5.2 赋值运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
| = | 赋值 | 将 = 右侧的结果赋值给 = 左边的变量 |
- 单个变量赋值
num = 1
- 多个变量赋值
num1, float1, str1 = 10, 0.5, 'hello'
- 多个变量赋相同值
a = b = 10
5.3 复合赋值运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
| += | 加法赋值运算符 | c += a 等价于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等价于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等价于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等价于 c = c / a |
| //= | 整除赋值运算符 | c //= a 等价于 c = c // a |
| %= | 取余赋值运算符 | c %= a 等价于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等价于 c = c ** a |
5.4 比较运算符
也叫关系运算符，通常用来判断
| 运算符 | 描述 | 示例 |
|---|---|---|
| == | 判断相等。如果两个操作数的结果相等，则结果为真(True)，否则为假(False) | a=3,b=3,则(a==b)为True |
| != | 不等于。如果两个操作数的结果不相等，则结果为真(True)，否则为假(False) | a=1,b=3,则(a!=b)为True |
| > | 运算符左侧操作数结果是否大于右侧操作数结果，如果大于，则为真，否则为假 | a=7,b=3,则(a>b)为True |
| < | 运算符左侧操作数结果是否小于右侧操作数结果，如果小于，则为真，否则为假 | a=3,b=7,则(a<b)为True |
| >= | 运算符左侧操作数结果是否大于或等于右侧操作数结果，如果大于或等于，则为真，否则为假 | a=7,b=3,则(a>b)为True |
| <= | 运算符左侧操作数结果是否小于或等于右侧操作数结果，如果小于或等于，则为真，否则为假 | a=3,b=7,则(a<b)为True |
5.5 逻辑运算符
| 运算符 | 逻辑表达式 | 描述 | 示例 |
|---|---|---|---|
| and | x and y | 布尔“与”：如果 x 为 False，x and y 返回 False，否则返回 y 的值 | True and False，返回 False |
| or | x or y | 布尔“或”：如果 x 为 True，它返回 True，否则返回 y 的值 | False or True，返回 True |
| not | not x | 布尔“非”：如果 x 为 True，返回 False；如果 x 为 False，返回 True | not True 返回 False； not 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 False) # True
数字之间的逻辑运算
- and 运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
- or 运算符，只有所有值为0结果才为0，否则结果为第一个非0数字
a = 0
b = 1
c = 2
# and 运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
print(a and b) # 0
print(b and c) # 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
6. 条件语句
6.1 if
6.1.1 语法
if 条件:
条件成立执行的代码1
条件成立执行的代码2
......
6.1.2 示例
if True:
print('条件成立执行的代码1')
print('条件成立执行的代码2')
6.1.3 实例：上网
需求分析：如果用户年龄大于等于18随，即成年，输入“已经成年，可以上网”
age = int(input('请输入你的年龄：'))
if age >= 18:
print(f'你的年龄是{age},已经成年，可以上网')
print('未成年，退出')
6.2 if…else…
6.2.1 语法
if 条件:
条件成立执行的代码1
条件成立执行的代码2
......
else:
条件不成立执行的代码1
条件不成立执行的代码2
......
6.3 多重判断
6.3.1 语法
if 条件1:
条件1成立执行的代码1
条件1成立执行的代码2
......
elif 条件2:
条件2成立执行的代码1
条件2成立执行的代码2
......
else:
以上条件都不成立执行的代码
6.4 if 嵌套
6.4.1 语法
if 条件1:
条件1成立执行的代码1
条件1成立执行的代码2
......
if 条件2:
条件2成立执行的代码
条件2成立执行的代码
6.5 三目运算符
也叫三元运算符或三元表达式
6.5.1 语法
条件成立执行的表达式 if 条件 else 条件不成立执行的表达式
6.5.2 示例
a = 1
b = 2
c = a if a > b else b
print(c)
7. 循环语句
分类
- while
- for
7.1 while循环
7.1.1 语法
while 条件:
条件成立重复执行的代码1
条件成立重复执行的代码2
......
7.1.1 应用
- 计算1-100累加和
i = 1
resoult = 0
while i <= 100:
resoult += i
i += 1
print(resoult) #5050
- 计算1-100偶数累加和
# 方法1：条件判断
i = 1
resoult = 0
while i <= 100:
if i % 2 == 0:
resoult += i
i += 1
print(resoult) #2550
# 方法2：计数器控制增量为2
i = 0
resoult = 0
while i <= 100:
resoult += i
i += 2
print(resoult) #2550
7.2 break和continue
break和continue是循环中满足一定条件退出循环的两种不同方式
- break 终止此循环
- continue 退出当前一次循环，继续下一轮循环
7.3 while 循环嵌套
while 条件1:
条件1成立执行的代码1
条件1成立执行的代码2
while 条件:
条件2成立执行的代码1
条件2成立执行的代码2
7.3.1 应用：九九乘法表
i = 1
while i <= 9:
j = 1
while j <= i:
print(f'{i}*{j}={i*j} ', end='\t')
j += 1
print()
i += 1
7.4 for 循环
语法
for 临时变量 in 序列:
重复执行的代码1
重复执行的代码1
......
for 循环中也可以使用break和continue
7.5 else
循环可以和else配合使用，else下方缩进的代码指的是当前循环正常结束之后要执行的代码
7.5.1 while…else
语法
while 条件:
条件成立重复执行的代码
else:
循环正常结束之后要执行的代码
7.5.1.1 退出循环的方式
- break
break终止循环（相当于非正常退出循环），else下面缩进的语句不执行
while 条件:
if 条件：
break
条件成立重复执行的代码
else:
循环正常结束之后要执行的代码
- continue
continue是退出当前一次循环，继续下一次循环，所以该循环再continue控制下是可以正常结束的，当循环结束后，则执行了else缩进的代码
while 条件:
if 条件：
continue
条件成立重复执行的代码
else:
循环正常结束之后要执行的代码
7.5.2 for…else
语法
for 临时变量 in 序列:
重复执行的代码
......
else:
循环正常结束之后要执行的代码
7.5.2.1 退出循环的方式
- break：break终止循环（相当于非正常退出循环），else下面缩进的语句不执行
- continue：continue是退出当前一次循环，继续下一次循环，所以该循环再continue控制下是可以正常结束的，当循环结束后，则执行了else缩进的代码
8. 函数
函数就是将一段具有独立功能的代码整合到一个整体并名命，再需要的位置调用这个名称即可完成对应的需求
8.1 函数的使用步骤
-
定义函数
def 函数名(参数): 代码1 代码2 ... -
调用函数
- 不同的需求，参数可有可无
- 函数必须先定义后使用
函数名(参数)
8.2 函数的参数
# 定义函数时同时定义了接收用户数据的参数a和b，a和b是形参
def add_num(a, b):
result = a + b
print(result)
# 调用函数时传入了真实的数据10和20，真实数据为实参
add_num(10, 20) #30
8.3 函数的返回值
使用变量保存函数的返回值
- 一个返回值
def buy():
return '烟'
goods = buy() #使用变量保存函数的返回值
print(goods) #烟
-
多个返回值
return a, b写法，返回多个数据时，默认是元组类型- return后面可以连接列表、元组或字典，以返回多个值
def return_num():
return 1, 2
result = return_num()
print(result) #(1, 2)
8.4 函数的说明文档
也叫函数的文档说明
8.4.1 语法
-
定义函数的说明文档
def 函数名(参数): """ 说明文档的位置 """ 代码 ... -
查看函数的说明文档
help(函数名) -
示例
def sum_num(a, b): """ 求和函数 sum_num :param a: 参数1 :param b: 参数2 :return: 返回值 """ return a + b print(sum_num(10, 20)) help(sum_num)
8.5 函数的嵌套调用
指的是一个函数里面又调用了另外一个函数
def testA():
print('这是函数A')
def testB():
print('---testB start---')
testA()
print('---testB end---')
testB()
####返回如下
---testB start---
这是函数A
---testB end---
8.6 变量作用域
- 局部变量
- 全局变量
8.6.1 局部变量
是指定义在函数体内部的变量，即只在函数体内部生效
def testA():
a = 100
print(a)
testA() #a
print(a) #报错
8.6.2 全局变量
是指在函数体内、外都能访问的变量
a = 100
def testA():
print(a)
def testB():
print(a)
testA() #100
testB() #100
print(a) #100
-
修改全局变量
-
在函数体内修改全局变量
a = 100 def testA(): print(a) def testB(): global a # global关键字声明a是全局变量 a = 200 print(a) print(a) #200
-
8.7 函数的参数
8.7.1 位置参数
传递和定义参数的顺序和个数必须一致
def user_info(name, age, gender):
print(f'您的名字是{name}，年龄是{age}，性别是{gender}')
user_info('Tom', 20, '男') #您的名字是Tom，年龄是20，性别是男
8.7.2 关键字参数
函数调用，通过“键=值”形式加以指定
函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
def user_info(name, age, gender):
print(f'您的名字是{name}，年龄是{age}，性别是{gender}')
user_info('小明', gender='男', age=16) #您的名字是小明，年龄是16，性别是男
8.7.3 缺省参数
也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值
所有位置参数必须出现在默认参数前，包括函数定义和调用
def user_info(name, age, gender='男'):
print(f'您的名字是{name}，年龄是{age}，性别是{gender}')
user_info('Tom', 20) #您的名字是Tom，年龄是20，性别是男
user_info('小明', 18, '女') #您的名字是小明，年龄是18，性别是女
8.7.4 不定长参数
也叫可变参数。用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。此时，可用包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递
-
包裹位置传递
传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组类型
def user_info(*args): print(args) user_info('Tom') #('Tom',) user_info('Tom', 18) #('Tom', 18) -
包裹关键字传递
def user_info(**kwargs): print(kwargs) user_info(name='Tom', age=18, id=110) #{'name': 'Tom', 'age': 18, 'id': 110}
def user_info(*args):
print(args)
user_info('Tom') #('Tom',)
user_info('Tom', 18) #('Tom', 18)
8.8 拆包和交换变量值
8.8.1 拆包
-
拆包：元组
def return_num(): return 100, 200 num1, num2 = return_num() print(num1) #100 print(num2) #200 -
拆包：字典
dict1 = {'name': 'Tom', 'age': 18} a, b = dict1 print(a) #name print(b) #age print(dict1[a]) #Tom print(dict1[b]) #18
8.8.2 交换变量值
需求：有变量a=10和b=20，交换两个变量的值
-
方法1：借助第三变量存储数据
a = 10 b = 20 c = 0 c = a a = b b = c print(a) #20 print(b) #10 -
方法2
a, b = 10, 20 a, b = b, a print(a) #20 print(b) #10
8.9 引用
在python中，值是靠引用来传递的
我们可以用id()来判断两个变量是否为同一个值的引用。我们可以将id值理解为那块内存的地址标识
- 整型：int–不可变类型
a = 1
b = a
print(b) #1
print(id(a)) #140711000721848
print(id(b)) #140711000721848
a = 2
print(b) #1，说明int类型为不可变类型
print(id(a)) #140711000721880
print(id(b)) #140711000721848
- 列表：list–可变类型
aa = [10, 20]
bb = aa
print(id(aa)) #2138763153664
print(id(bb)) #2138763153664
aa.append(30)
print(bb) #[10, 20, 30]，列表为可变类型
print(id(aa)) #2138763153664
print(id(bb)) #2138763153664
8.9.1 引用当作实参
def test1(a):
print(a)
print(id(a))
a += a
print(a)
print(id(a))
# int：计算前后id值不同
b = 100
test1(b)
# 列表：计算前后id值相同
c = [11, 22]
test1(c)
8.10 可变和不可变类型
指数据是否能够直接修改。如果能直接修改就是可变，否则就是不可变
- 可变类型
- 列表
- 字典
- 集合
- 不可变
- 整型
- 浮点型
- 字符串
- 元组
8.11 递归
8.11.1 应用场景
- 遍历文件夹下所有文件
- 快速排序
8.11.2 特点
- 函数内部自己调用自己
- 必须有出口
8.11.3 示例
-
计算3以内数字累加和
def sum_number(num): # 2. 出口 if num == 1: return 1 # 1. 当前数字 + 当前数字-1的累加和 return num + sum_number(num-1) result = sum_number(3) print(result) #6
8.12 lambda 表达式
如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化
8.12.1 语法
- lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
- lambda表达式能接收任何数量的参数，但只能返回一个表达式的值
lambda 参数列表 : 表达式
8.12.2 参数形式
-
无参数
fn1 = lambda: 100 print(fn1()) -
一个参数
fn1 = lambda a: a print(fn1('hello')) -
默认参数
fn1 = lambda a, b, c=100:a + b + c print(fn1(10, 20)) -
可变参数：*args
可变参数传入到lambda之后，返回值为元组
fn1 = lambda *args: args print(fn1(10, 20, 30)) -
可变参数：**kwargs
fn1 = lambda **kwargs: kwargs print(fn1(name='python', age=20))
8.12.3 带判断的lambda
fn1 = lambda a, b: a if a > b else b
print(fn1(1000, 500))
8.12.4 列表数据按字典key的值排序
student = [
{'name': 'Tom', 'age': 20},
{'name': 'Rose', 'age': 19},
{'name': 'Jack', 'age': 23}
]
# 按name值升序排列
student.sort(key=lambda x: x['name'])
print(student)
# 按name值降序排列
student.sort(key=lambda x: x['name'], reverse=True)
print(student)
# 按age值升序排列
student.sort(key=lambda x: x['age'])
print(student)
8.13 高阶函数
把函数作为参数传入，这样的函数称为高阶函数
- abs()：计算绝对值
- round()：对数字进行四舍五入计算
8.13.1 内置高阶函数
-
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 0x000002EB13BFB6D0> print(list(result)) #[1, 4, 9, 16, 25] -
reduce()
reduce(func, lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算
reduce()传入的参数func必须接收2个参数
示例：计算list1序列中各个数字的累加和
import functools list1 = [1, 2, 3, 4, 5] def func(a, b): return a + b result = functools.reduce(func, list1) print(result) #15 -
filter()
filter(func, lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list()来转换
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] def func(x): return x % 2 == 0 result = filter(func, list1) print(result) #<filter object at 0x0000023A3AE0B700> print(list(result)) #[2, 4, 6, 8, 10]
9. 文件操作
9.1 文件操作基本步骤
- 打开文件
- 读写等操作
- 关闭文件
可以只打开和关闭文件，不进行任何读写操作
9.1.1 打开
使用open函数打开一个已经存在的文件，或者创建一个新文件
open(name, mode)
- name：是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
- mode：设置打开文件的模式（访问模式）：只读、写入、追加等
9.1.1.1 打开模式
加粗模式为主访问模式
| 模式 | 描述 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头 |
| rb+ | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。 |
| w | 打开一个文件只用于写入。如果该文件已经存在则打开文件，并从头开始编辑，即原有内容会被删除。如果原文件不存在，则创建新文件 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已经存在则打开文件，并从头开始编辑，即原有内容会被删除。如果原文件不存在，则创建新文件 |
| w+ | 打开一个文件用于读写。果该文件已经存在则打开文件，并从头开始编辑，即原有内容会被删除。如果原文件不存在，则创建新文件 |
| wb+ | 以二进制格式打开一个文件用于读写。果该文件已经存在则打开文件，并从头开始编辑，即原有内容会被删除。如果原文件不存在，则创建新文件 |
| a | 打开一个文件用于追加。如果文件存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，则创建新文件进行写入 |
| ab | 以二进制格式打开一个文件用于追加。如果文件存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，则创建新文件进行写入 |
| a+ | 打开一个文件用于读写。如果该文件存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，则创建新文件进行写入 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，则创建新文件进行写入 |
示例
此时的 f 是 open 函数的文件对象
f = open('test.txt', 'w')
9.1.2 文件对象方法
9.1.2.1 写
文件对象.write('内容')
9.1.2.2 读
-
read()
num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
文件对象.read(num)
-
readlines()
readline可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
读取的内容包含 \n 这个换行符
f = open('test.txt')
content = f.readlines()
print(content)
f.close()
-
readline()
一次读取一行内容
读取内容不包含 \n 这个换行符
-
tell()
返回一个整数，表示当前文件指针的位置（到文件开头的比特数）
-
seek()
用来移动文件指针
起始位置：
- 0：文件开头
- 1：当前位置
- 2：文件结尾
文件对象.seek(偏移量, 起始位置)
9.1.3 关闭
文件对象.close()
9.2 文件备份
示例：用户输入当前目录下任意文件名，程序完成对该文件的备份功能（备份文件名为xx[备份].txt后缀，例如：test[备份].txt）
-
步骤
- 接收用户输入的文件名
- 规划备份文件名称
- 备份文件写入数据
-
实现
old_name = input('请输入您要备份的文件名：') index = old_name.rfind('.') if index > 0: postfix = old_name[index:] new_name = old_name[:index] + '[备份]' + postfix old_file = open(old_name, 'rb') new_file = open(new_name, 'wb') while True: content = old_file.read(1024) if len(content) == 0: break new_file.write(content) old_file.close() new_file.close()
10. 文件和文件夹的操作
文件和文件夹的操作需要借助os模块里面的相关功能，具体步骤如下：
-
导入 os 模块
import os -
使用 os 模块相关功能
os.函数名()
10.1 文件操作
10.1.1 文件重命名
os.rename(目标文件名, 新文件名)
10.1.2 删除文件
os.remove(目标文件名)
10.2 文件夹操作
10.2.1 创建文件夹
os.mkdir(文件夹名字)
10.2.2 删除文件夹
os.rmdir(文件夹名字)
10.2.3 获取当前目录
os.getcwd()
10.2.4 改变默认目录
os.chdir(目录)
10.2.5 获取目录列表
获取某个文件夹下的所有文件，返回的是一个列表
os.listdir(目录) #目录省略代表获取当前目录下所有文件
10.2.6 重命名文件夹
os.rename(目标文件夹名, 新文件夹名)
10.3 应用
需求：批量修改文件名，既可以添加指定字符串，又能删除指定字符串
-
步骤
- 设置添加删除字符串的标识
- 获取指定目录的所有文件
- 将原有文件名添加/删除指定字符串，构造新名字
- os.rename()重命名
-
实现
import os # 1：添加，2：删除 flag = 1 file_list = os.listdir() for i in file_list: if flag == 1: new_name = 'Python_' + i elif flag == 2: num = len('Pyrhon_') new_name = i[num:] os.rename(i, new_name)
11. 面向对象
用类创建对象，也叫实例
11.1 面向对象实现方法
11.1.1 定义类
-
语法
类名要满足标识符名命规则，同时要遵守大驼峰名命习惯
class 类名(): 代码 ...
11.1.2 创建对象
对象又叫实例
-
语法
对象名 = 类名() -
示例
class Washer(): def wash(self): print('能洗衣服') haier = Washer() haier.wash() #能洗衣服
11.1.3 self
self指的是调用该函数的对象
11.2 添加和获取对象属性
属性即是特征
对象属性既可以在类外面添加和获取，也能在类里面添加和获取
11.2.1 类外面添加对象属性
-
语法
对象名.属性名 = 值
11.2.2 类外面获取对象属性
-
语法
对象名.属性名
11.2.3 类里面获取对象属性
-
语法
self.属性名
11.3 魔法方法
在python中，__xx__()的函数叫魔法方法，指的是具有特殊功能的函数
11.3.1 __init__()
用来初始化对象
class Washer():
def __init__(self):
self.width = 500
self.height = 800
def wash(self):
print(f'洗衣机的宽度是{self.width}，高度是{self.height}')
haier = Washer()
haier.wash() #洗衣机的宽度是500，高度是800
-
带参数的
__init__()class Washer(): def __init__(self, width, height): self.width = width self.height = height def wash(self): print(f'洗衣机的宽度是{self.width}，高度是{self.height}') haier1 = Washer(500, 800) haier1.wash() #洗衣机的宽度是500，高度是800 haier2 = Washer(600, 900) haier2.wash() #洗衣机的宽度是600，高度是900
11.3.2 __str__()
当使用print输出对象的时候，默认打印对象的内存地址。如果定义了__str__()方法，那么就会打印从这个方法中 return 的数据
class Washer():
def __init__(self, width, height):
self.width = width
self.height = height
def __str__(self):
return '这是海尔洗衣机的说明书'
haier1 = Washer(500, 800)
print(haier1) #这是海尔洗衣机的说明书
11.3.3 __del__()
当删除对象时，python解释器也会默认调用__del__()方法
class Washer():
def __init__(self):
self.width = 300
self.height = 500
def __del__(self):
print(f'{self}对象已经被删除')
haier1 = Washer()
11.4 继承
在python中，所有类默认继承object类。object类是顶级类（也叫基类）；其他子类叫派生类
# 父类A
class A(object):
def __init__(self):
self.num = 1
def info_print(self):
print(self.num)
# 子类B
class B(A):
pass
result = B()
result.info_print() #1
11.4.1 单继承
一个父类继承给一个子类
# 1. 师傅类
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
# 2. 徒弟类
class Prentice(Master):
pass
# 3. 创建对象
daqiu = Prentice()
# 4. 对象访问实例属性
print(daqiu.kongfu) #[古法煎饼果子配方]
11.4.2 多继承
一个类同时继承多个父类
当一个类有多个父类时，默认使用第一个父类的同名属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
def __init__(self):
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
pass
daqiu = Prentice()
print(daqiu.kongfu) #[学校煎饼果子配方]
daqiu.make_cake() #运用[学校煎饼果子配方]制作煎饼果子
11.4.3 子类重写父类同名方法和属性
子类和父类具有同名属性和方法，默认使用子类的同名属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
def __init__(self):
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
def __init__(self):
self.kongfu = '[独创煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
daqiu = Prentice()
print(daqiu.kongfu) #[独创煎饼果子配方]
daqiu.make_cake() #运用[独创煎饼果子配方]制作煎饼果子
11.4.4 查看父类以及层级关系
子类名.__mro__
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
def __init__(self):
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
def __init__(self):
self.kongfu = '[独创煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
print(Prentice.__mro__) #(<class '__main__.Prentice'>, <class '__main__.School'>, <class '__main__.Master'>, <class 'object'>)
11.4.4 子类调用父类的同名属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
def __init__(self):
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
def __init__(self):
self.kongfu = '[独创煎饼果子配方]'
def make_cake(self):
# 如果先调用了父类的属性和方法，父类属性会覆盖子类属性，故在调用属性前，先调用自己子类的初始化
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
# 调用父类方法，但是为了保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化
def make_master_cake(self):
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
daqiu = Prentice()
print(daqiu.kongfu) #[独创煎饼果子配方]
daqiu.make_cake() #运用[独创煎饼果子配方]制作煎饼果子
daqiu.make_master_cake() #运用[古法煎饼果子配方]制作煎饼果子
daqiu.make_school_cake() #运用[学校煎饼果子配方]制作煎饼果子
11.4.5 多层继承
两层继承关系以上的称为多层继承
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
def __init__(self):
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class Prentice(School, Master):
def __init__(self):
self.kongfu = '[独创煎饼果子配方]'
def make_cake(self):
# 如果先调用了父类的属性和方法，父类属性会覆盖子类属性，故在调用属性前，先调用自己子类的初始化
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
# 调用父类方法，但是为了保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化
def make_master_cake(self):
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
class Tusun(Prentice):
pass
xiaoqiu = Tusun()
print(xiaoqiu.kongfu) #[独创煎饼果子配方]
xiaoqiu.make_cake() #运用[独创煎饼果子配方]制作煎饼果子
xiaoqiu.make_master_cake() #运用[古法煎饼果子配方]制作煎饼果子
xiaoqiu.make_school_cake() #运用[学校煎饼果子配方]制作煎饼果子
11.4.6 super()调用父类方法
只能调用相邻父类方法，即在多继承时，需要在每个父类中都执行一次
-
方法1：带参数
-
语法
缺点：当前类名发生改变时需要在代码修改为对应类名
super(当前类名, self).__init__() super(当前类名, self).make_cake() -
-
方法2：不带参数
super().__init__() super().make_cake()
11.4.7 私有权限
11.4.7.1 定义私有属性和方法
在python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类
设置私有权限的方法：在属性名或方法名前面加上两个下划线 __
私有属性或私有方法只能在类里面访问和修改
11.4.7.2 获取和修改私有属性
在python中，一般定义函数名get_xx用来获取私有属性，定义set_xx用来修改私有属性
#在类里面定义
# 获取私有属性
def get_money(self):
return self.__money
# 修改私有属性
def set_money(self):
self.__money = 500
11.5 面向对象三大特征
- 封装
- 将属性和方法书写到类的里面的操作即为封装
- 封装可以为属性和方法添加私有权限
- 继承
- 子类默认继承父类的所有属性和方法
- 子类可以重写父类的属性和方法
- 多态
- 传入不同的对象，产生不同的结果
11.5.1 多态
class Dog(object):
def work(self): # 父类提供统一的方法，哪怕是空方法
print('指哪打哪...')
class ArmyDog(Dog): #继承Dog类
def work(self): # 子类重写父类同名方法
print('追击敌人...')
class DrugDog(Dog):
def work(self):
print('追查毒品...')
class Person(object):
def work_with_dog(self, dog): # 传入不同的对象，执行不同的代码，即不同的work函数
dog.work()
ad = ArmyDog()
dd = DrugDog()
daqiu = Person()
daqiu.work_with_dog(ad) #追击敌人...
daqiu.work_with_dog(dd) #追查毒品...
11.5.2 类属性和实例属性
11.5.2.1 类属性
11.5.2.1.1 设置和访问类属性
- 类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有
- 类属性可以使用类对象或实例对象访问
class Dog(object):
tooth = 10
wangcai = Dog()
xiaohei = Dog()
print(Dog.tooth) #10
print(wangcai.tooth) #10
print(xiaohei.tooth) #10
11.5.2.1.2 修改类属性
类属性只能通过类对象修改，不能通过实例对象修改。如果通过实例对象修改类属性，表示的是创建了一个实例属性
class Dog(object):
tooth = 10
wangcai = Dog()
xiaohei = Dog()
# 修改类属性
Dog.tooth = 12
print(Dog.tooth) #12
print(wangcai.tooth) #12
print(xiaohei.tooth) #12
# 不能通过对象修改属性，如果这样操作，实则是创建了一个实例属性
wangcai.tooth = 20
print(Dog.tooth) #12
print(wangcai.tooth) #20
print(xiaohei.tooth) #12
1325
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
