python基础复习-面向过程
- 一. 注释
- 二. 变量
- 三. 关键字
- 四. 终端输入输出
- 五. 运算符
- 六. 数据类型
- 七. 基础语句
- 1. if 语句
- 2. while 语句
- 3. for 语句
- 4. while/for与else
- 八. 可存入多个元素数据类型
- 九. 函数
- 参数
- 返回值
- 拆包
- lambda匿名函数
- 三元运算符
一. 注释
单行注释 #, 多行注释 """ """
二. 变量
使用数字.字母.下划线_组成的字符变量, 定义变量时要注意不能数字开头, 不能和关键字相同
三. 关键字
在python中已经定义好的变量名
四. 终端输入输出
print("输出内容")
input("输入内容")五. 运算符
类型 | Value |
加法 | + |
减法 | - |
乘法 | * |
除法 | / |
取余 | % |
取整 | // |
… | … |
六. 数据类型
类型 | Value | 例子 |
整形 | int |
|
字符串 | str |
|
浮点数 | float |
|
… | … |
七. 基础语句
1. if 语句
if 判断条件: # 任意一条成功后结束判断
判断成功执行的事件
elif:
此条件判断成功执行的事情
else:
判断失败执行的事件2. while 语句
while 循环条件:
要循环的内容
break # 跳出这个循环
continue # 结束本次循环, 直接执行下次循环
# 后续代码不会执行3. for 语句
for 有明确数量的数据类型:
循环内容
break # 跳出这个循环
continue # 结束本次循环, 直接执行下次循环
# 后续代码不会执行4. while/for与else
while / for 循环条件:
循环内容
if 判断条件:
break / continue
else:
如果循环未执行到`break, continue`则执行八. 可存入多个元素数据类型
1.列表
# 列表的创建
a = [] / a = list()
# 列表的基础用法
# 下标操作
a[0] = 1 # 插入第一个元素１
# 增删改
a.append(1) # 从列表的最后添加一个元素1
a.extent([1, 2]) # 合并两个列表
a.remove(1) # 从列表中删除1
a.pop(1) # 删除第二个元素, 并将第二个元素作为返回值, 默认选择最后一个元素
a.insert(下标, 1) # 在所提供的下标处插入元素, 插入下标超过最后一位, 按追加处理
# 排序
a.sort(key=函数引用, reverse=False) # 可以传入key来按照自己的方式排序, 也可以使用reverse=True来进行逆序
a.reverse() # 直接进行逆序
# 清空
a.clear() # 清空不会删除容器, 只是会清空容器
# 关于运算符
a * 3 # 将a列表复制三份组合起来
a + [1, 2] # 将两个列表进行组合, 同extent
# 关于del
del a # 删除a的指向
del a[0: 2] # 删除列表的前两个元素
# 获取一个元素出现的个数
a.count(1) # 找出a出现的个数
# 获取一个元素的下标
a.index(1) # 找出元素1的下标, 没有这个元素会报错
# 获取一个列表的长度
len(a) # len函数会获取长度并返回
# 列表推导式 用来快速的创建一个简单列表
list1 = [x for x in range(5)] # 创建一个从0到4的列表
list1 = [x for x in range(5) if x % 2 == 0] # 取出0到4之间可以整除2的数2.元组
# 创建元组
a = () / a = tuple()
# 元组的基础用法
del a # 删除a
# 获取一个元素出现的个数
a.count(1) # 找出a出现的个数
# 获取一个元素的下标
a.index(1) # 找出元素1的下标, 没有这个元素会报错
# 获取一个元组的长度
len(a) # len函数会获取长度并返回
# 元组不可变, 不可随意改变值, 但可以通过制作新元组的方式来获得想要的效果
a[0, 2] # 取出前两个值, 组合一个新列表返回3.字典
# 创建字典
a = {} / a = dict()
# 关于字典的基础操作
# 增删改查
a["2"] = 2 # 向字典内插入一个键值对 {"2": 2}, 有键为"2"的数据则修改值
a.update({1: 2, 2: 3}) # 组个字典
a.get(1) # 获取键是1的值, 没有返回None
a.pop(1) # 输入一个键, 来删除并返回值, 必须有第一个参数
a.keys() # 获取所有键并组成一个列表返回
a.values() # 获取所有值并组成一个列表返回
a.items() # 返回一个dict_items 数据,
# 清空
a.clear() # 清空不会删除容器, 只是会清空容器
# 字典是无序的, 无法使用下标进行操作
# 字典推导式
dict1 = {x:x%2==0 for x in range(5)} # 得到一个数字是否是双数的字典
{0: True, 1: False, 2: True, 3: False, 4: True}
# 关于for循环字典, 同时取出键和值
for x, y in dict1.items():
print(x)
0 True
1 False
2 True
3 False
4 True4.集合
# 集合的创建
a = set() / a = {1, 2} # 不可以进行 a = {} 初始化, 因为这样会创建一个空字典
# 集合的操作
# 增删改
a.add(1) # 追加元素1, 如果已经拥有则不会发生变化
a.update({3, 4}) # 组合集合, 一样不会出现两个值相同的变量
a.pop(1) # 删除值为1的元素并返回, 没有会报错
a.remove(1) # 删除值为1的元素, 没有会报错
a.discard(1) # 删除值为1的元素, 没有不会报错
# 交集, 并集, 差集
a = {1, 2, 3}
b = {2, 3, 4}
# 交集
a.intersection(b) # {2, 3} # 取出两个集合的相同元素并返回一个新集合 也可以写作 a & b
a.intersection_update(b) # 取出两个集合相同的元素并更新自己
# 并集
a.union(b) # {1, 2, 3, 4} # 取出两个集合中所有数据并去重 a | b
# 差集
a.difference(b) # {1} 取出a中相较于b, 不一样的元素, 同 a - b
a.difference_update(b) # 取出a中相较于b, 不一样的元素, 并更新自己
# 关于不变集合
f = frozenset() # 类似于元组不可变, 也可以通过创建新集合来达到想要的效果关于字符串的操作
a = "zi fu cHuan"
# 字符串常用操作
# 大小写
a.upper() # 'ZI FU CHUAN' 全部字母大写
a.lower() # "zi fu chuan" 全部字母小写
a.capitalize() # "Zi fu chuan" 这一行首字母大写
a.title() # "Zi Fu Chuan" 所有首字母大写
a.swapcase() # 'ZI FU ChUAN' 大变小, 小变大
a.istitle() # 判断是否首字母大写
a.isupper() # 判断是否全部大写
a.islower() # 判断是否全部小写
# 修改
a.replace("u", "U", 2) # 'zi fU cHUan' replace(要替换的元素, 替换后的元素, 要替换的个数) 替换元素
# 查找
a.find("u") # 4 寻找元素a的下标
a.rfind("u") # 8 从右向左找
a.index("u") # 4 寻找元素a的下标, 没有会报错
a.rindex("u") # 8
# 切分
b = a.split(" ") # ['zi', 'fu', 'cHuan'] 按照' '进行拆分成列表
"-".join(b) # 'zi-fu-cHuan' 按照'-'将列表连接成字符串
# 计数
a.count("u") # 2 计算"u"在a中出现的次数
len(a) # 11 获取到字符串的长度
# format 打印
f"我是:{a}" # '我是:zi fu cHuan'
# 空格
a.strip() # 去除两边的空格
a.rstrip() # 去除右边
a.lstrip() # 去除左边九. 函数
使用def将一部分代码进行封装, 用来多次实现一个功能 , 使用函数名()的方式来调用
例:
def printHW():
print("HELLO WORLD")
printHW() # 通过函数名加()来调用, 无法在定义函数前使用参数
1.参数传递
对于不可变参数, 就是将参数的复制传入函数内, 对原参数没有什么影响, 对于可变参数, 就是向参数的引用传入函数, 函数内修改后, 原参数也会发生改变
例:
a = 1
b = [2]
def change(arg1, arg2):
arg1 = 2
arg2[0] = 2
change(a, b)
print(a)
print(b)
# 结果
1
[2]向对于变量原来的结果, 可变类型发生了改变, 而不可类型不变
2.可变参数
对于一个函数有时会有不知道要定义多少个参数的情况, 这时候就可以使用可变参数来接收未知个数的参数
例:
def printf(*args, **kwargs): # 参数名字不固定, 但一般常用args和kwargs, 同 self, cls
print(args)
print(kwargs)
printf(1, 2, "3", [4], a = 5, b = 6)
结果
(1, 2, '3', [4]) # 缺省参数会用元组存放在args里
{'a': 5, 'b': 6} # 命名参数会用字典存放在kwargs里返回值
在一个函数执行到 return 的时候就会将return后的值进行返回, 每个函数都有自己的return, 即便没写出来也会有默认的return None, 返回值可以写多个, 用逗号,隔开, 返回值可以是多个变量与之对应既拆包 也可以只用一个变量来接收, 默认使用元组来存放, 当函数执行到return的时候, 函数直接结束, 类似于正在执行的循环遇到了break, return后的代码不执行, 返回值类型可以是对象, 类
拆包
拆包就是将一个可迭代对象拆为多个对象, 但被拆包的对象的元素数量要于接收这些元素的变量数量一致, 除非使用*_变量来接收
多余的元素, *返回类型为列表
例:
# 数量对应一致
a = (1, 2, 3, 4, 5)
b, c, d, e, f = a
print(b, c, d, e, f)
结果
1 2 3 4 5
# *在结尾
a = (1, 2, 3, 4, 5)
b, c, *args = a
print(b, c, args)
结果
1 2 [3, 4, 5]
# *在开头
a = (1, 2, 3, 4, 5)
*args, b, c = a
print(b, c, args)
结果
4 5 [1, 2, 3]
# 字符串
a = "hello"
b, c, *args = a
print(b, c, args)
结果
h e ['l', 'l', 'o']
# 列表
a = [1, 2, 3, 4, 5]
b, c, *args = a
print(b, c, args)
结果
1 2 [3, 4, 5]
# 元组
a = (1, 2, 3, 4, 5)
b, c, *args = a
print(b, c, args)
结果
1 2 [3, 4, 5]
# 字典
a= {1: 2, 3: 4, 5: 6}
b, c, *args = a
print(b, c, args)
结果
1 3 [5]
# 集合
a = {1, 2, 3, 4, 5}
b, c, *args = a
print(b, c, args)
结果
1 2 [3, 4, 5]lambda匿名函数
lambda表达式可以看为, 将一个需要使用多行的函数进行简化, 使代码更为简洁美观, 可读性更高
例子
def add(num1, num2):
return num1 + num2
# 使用lambda表达式可写为
add = lambda num1, num2 : num1 + num2写法规范为> lambda 参数1, … : 返回值<
常与map, filter, reduce几个函数连用
例子
# 将两个列表两两相加
a = map(lambda x, y : x + y, [1, 2, 3], [4, 5, 6])
print(list(a))
结果
[5, 7, 9]
# 过滤掉一个列表的单数
a = filter(lambda x : x if x % 2 == 0 else None, [1, 2, 3, 4, 5])
print(list(a))
结果
[2, 4]
# 计算一个列表的和
from functools import reduce
a = reduce(lambda x, y : x + y, [1, 2, 3, 4, 5])
print(a)三元运算符
类似于lambda不过不是简化函数, 而是简化if语句, 增加代码的美观性
写法规范为>判断成功执行的结果 if 判断条件 else 判断失败执行的结果<
例:
# 判断是否为双数
a = 1
if a % 2 == 0:
print("a为双数")
else:
print("a为单数")
# 使用三元运算符
"a为双数" if a % 2 == 0 else "a为单数"
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
