|
python基础知识总结，人生苦短，我用python |
|
旁观者
L21
• 2021-06-21 • 回复 2 • 只看楼主
• 举报
|
目录
前言
Python 是一种易于学习又功能强大的编程语言。它提供了高效的高级数据结构，还能简单有效地面向对象编程。Python 优雅的语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的理想语言。
Python 解释器及丰富的标准库，提供了适用于各个主要系统平台的源码或机器码，这些可以到 Python 官网 https://www.python.org/ 免费获取，并可自由地分发。许多免费的第三方 Python 模块、程序、工具和它们的文档，也能在这个网站上找到对应内容或链接。
Python 解释器易于扩展，可以使用 C 或 C++（或者其他可以通过 C 调用的语言）扩展新的功能和数据类型。Python 也可用于可定制化软件中的扩展程序语言。
注释
注释 注释能够让阅读代码的人更加清晰的知道代码的作用， 注释可以增强代码的阅读性
单行注释, 多行注释,
在Python里面 # 号就代表单行注释
多行注释
"""
这是多汗注释, 按住shift+"(连按三次")就可以出现多行注释
"""
数据类型
- int 数字整数
- Float 浮点类型(小数点)
- Bool 布尔类型(True(真, 1), False(假, 0))
- String 字符串 (带引号的都是字符串)
- List 列表
- Tuple 元祖
- Dictionary 字典
Python3 的数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
变量名
变量名：字母、数字、下划线组成，数字不能开头，变量命名要和实际数据相关联（见名知意）
不能使用关键字命名
两种命名法：
1.大驼峰法命名：每一个单词的首字母大写 My_Name=
2.小驼峰法命名：除了第一个单词的字母以外，其他单词的首字母都要大写 my_Name_Is=
数值类型
整数
# 整型:整数
num_i_1 = 88 # i为int的缩写 int(整型)
num_i_2 = 66
print(num_i_1)
print('能给我发个%d的红包么？' % num_i_1) # %为占位符 %d为十进制
print('能给我发个%o的红包么？' % num_i_1) # %o为八进制
print('能给我发个%x的红包么？' % num_i_1) # %x为十六进制
print('能给我发个%d的红包么或者%d的红包' % (num_i_1, num_i_2))
浮点数
# float浮点数
num_f_1 = 1.68888888
print(num_f_1)
print('能给我发个%f的红包么？' % num_f_1) # 格式化输出浮点数型 默认保留小数点后6位
print('能给我发个%.3f的红包么？' % num_f_1) # 小数点加数字 表示保留小数点后三位数字
布尔型
True=1
type(True)
输出：class'bool'
False=0
type(False)
输出：class'bool'
复数 a+bi
complex_1 = complex(1, 2) # 1为a 2为b
字符串
# 字符串
str_1 = 'good morning'
str_2 = 'good afternoon'
str_3 = 'good night'
print('%s，你吃了么' % str_1)
print('{}，你吃了么' .format(str_2))
print(f'{str_3}，你吃了么')
print('{},{},你吃了么'.format(str_1, str_2))
替换 replace
str_4 = 'play football'
print(str_4)
print(str_4.replace('football', 'basketball')) # 前面是被替换的字符 后面是替换的新字符
strip去掉
# 两端去空白（做爬虫 做自动化处理Excel) strip(去掉 \t横向制表符 \n换行)
str_5 = '\tplay football\n'
print(str_5)
print(str_5.strip())
切割split
# 切割 （做爬虫 做自动化处理Excel) split
str_6 = 'go to school'
list_7 = str_6.split('o')
print(list_7)
print(type(list_7))
拼接 join
print('-'.join(str_6))
print('o'.join(list_7))
字符串大小写转化
# 字符串大小写转化 upper转化成大写 lower转化成小写
str_8 = 'day day up'
print(str_8.upper())
print(str_8.lower())
查找与统计
print(len(str_8)) # len（）统计括号内输入的数据长度
print(len('@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@'))
count 统计
# count 统计字符出现的次数
print(str_8.count('a'))
print(str_8.count('d'))
find 查找
# find 查找字符是否在字符串中 返回第一次找到字母的下标
print(str_8.find('u')) # 可以分区域查找(不给定区域就是查找整个字符串)，如果不在返回-1
print(str_8.index('y', 3, 8)) # 可以分区域查找 index:类似find如果不在就会报错
# rfind:和find一样，不过是从右边开始查找
print(str_8.rfind('u'))
print(str_8.rindex('y', 3, 8))
判断与检测
# 判断
str_9 = '166529822545'
str_10 = 'adwfvhgcgajfkg'
print(str_9.isdigit()) # isdigit()判断括号内数据全为数字
print(str_10.isalpha()) # isalpha()判断括号内数据全为字母
# 检测 type()
num_1 = 141651
print(type(num_1))
str_11 = '168'
print(type(str_11))
list_1 = [1, 6, 8]
print(type(list_1))
tuple_1 = (1, 6, 8)
print(type(tuple_1))
dict_1 = {'1': 1, '6': 6, '8': 8}
print(type(dict_1))
set_1 = {1, 6, 8}
print(type(set_1))
强制转型
num_f_1 = float(num_1)
print(num_1)
print(num_f_1)
str_12 = str(num_1)
print(num_1)
print(type(num_1))
print(str_12)
print(type(str_12))
运算符
# 运算符
# 算数运算符
加号 +
减号 -
乘号 *
除法 /
取整数 //
取余数 %
幂次方 **
# 比较(关系)运算符
== 检查两个参数是否相等 , 条件成立返回True
!= 检查两个参数是否不相等 , 条件成立返回True
> 大于号 左边数大于右边数就返回True
< 小于号
>= 大于等于
<= 小于等于
num_1 = int(input('请输入一个数字:'))
num_2 = int(input('请输入一个数字:'))
print(num_1 >= num_2)
# 逻辑运算符
and 与 x and y x和y都满足才返回True, 如果其中一个不满足就返回False
or 或者 x or y x和y有一个满足就满足, 如果都不满足才返回False
not 不 如果x为True就返回False, 如果x为False就返回True
# 赋值运算符
在Python中,使用=号可以给变量赋值
+= c = c + b 可简写为 c += b
-= c = c - b 可简写为 c -=b
*= c = c + b 可简写为 c *= b
/= c = c + b 可简写为 c /= b
//= c = c + b 可简写为 c //= b
%= c = c + b 可简写为 c %= b
**= c = c + b 可简写为 c **= b
c = 0
a = 1
b = 2
a = a + b
a += b
# 运算符的优先级
** 最高优先级
* / % //
+ -
<= < > >=
== !=
= %= /= //= -= += *= **=
not or and 最低优先级
# 常用的数据类型转换
a = int(input('输入一个数字:'))
a = hex(a)
print(a)
c = 2
c = str(c)
c = float(c)
c = int(c)
print(c)
判断语句 if
# 判断语句, 给定一个条件, 如果在程序执行过程中判断该条件是否成立,根据判断结果执行不同的操作, 从而改变代码的执行顺序
if 今天发工资:
先还信用卡
if 有剩余:
还花呗
else:
没钱了, 什么也干不了
else:
等待发工资
按住tab键也可以缩进, 一个缩进等于4个空格, tab和空格不要混合使用
if (要判断的条件):
条件成立,就执行
age = int(input('请输入你的年龄:'))
判断年龄是否大于等于18岁
if age >= 18:
print('可以进网吧嗨皮')
else:
print('没有成年,不能进网吧上网')
else 处理条件不满足时的情况
if的嵌套使用
# if的嵌套使用
# if嵌套的应用场景, 在之前条件满足的前提下, 再增加额外的判断
if 条件1:
条件1满足执行的代码
if 在条件1的满足的基础上加条件2:
条件2满足时,执行的代码
else:
条件2不满足执行的代码
else:
条件1不满足时执行的代码
if 语句的进阶
# if 语句的进阶 elif, 条件不同, 需要执行的代码也不同, 就要用到elif,多层条件判断
if 条件1:
条件1满足时执行的代码
elif 条件2:
条件2满足时执行的代码
elif 条件3:
条件3满足时执行的代码
else:
以上条件都不满足时执行的代码
elif的实例
holiday_name = input('今天是什么节日:')
if holiday_name == '情人节':
print('买玫瑰花')
print('看电影')
udyima = int(input('输入0代表False, 输入1代表True:'))
if udyima == 0:
print('这几天不方便,不能去儒家')
elif udyima == 1:
print('哈哈....可以去儒家啦!!! 好开心')
else:
print('唉...女人的心思真难懂!!!!!!')
elif holiday_name == '圣诞节':
print('吃圣诞大餐')
print('送礼物')
print('看电影')
print('去儒家')
elif holiday_name == '生日':
print('送生日蛋糕')
print('送礼物')
print('看电影')
print('去儒家')
else:
print('啊!!!今天终于不过节啦! 不用去儒家啦! 好累啊!! 要补补啦!!!')
while循环
# 定义一个计数器
i = 1
while i <= 100: # 当条件满足时, while里面的代码才会执行
print('I Love You') # 需要重复执行的代码
i += 1 # 一定要有计数器, 没有计数器很可能会造成死循环
# 程序的三大流程
# 在程序开发中,一共有三种流程
# 1. 顺序-- 从上往下, 按照顺序执行代码
# 2. 分支-- 根据条件判断, 决定执行代码的分支
# 3. 循环-- 让特定的代码重复执行
# 死循环, 由于程序员的原因, 忘记在循环内部修改循环的判断条件, 导致循环持续执行,程序无法终止
# Python中的计数(程序): 从0开始计数
# 自然计数是从1开始计数的
# 计算0-100之间所有的数字累计求和
# 0+1+2+3+4+5+6+7+8+9.....+100
# 计算0-100之间所有偶数的求和
# 定义一个计数器
i = 0 # i是计数器
s = 0 # s 是存储结果的容器
while i <= 100: # 当条件满足时, while里面的代码才会执行
# print('I Love You') # 需要重复执行的代码
if i % 2 != 0:
s += i
i += 1 # 一定要有计数器, 没有计数器很可能会造成死循环
print(i)
print(s)
# break , continue是专门在循环中使用的关键字, 只在当前所在的循环有效
# break满足条件时, 退出循环, 不再执行后面重复的代码
# continue满足条件时, 跳过当前循环进入下次循环
i = 0
while i < 10:
if i == 7:
i += 1
continue
print(i)
i += 1
# while嵌套就是while里面嵌套while
# 外部的while影响内部while循环的运行, 直至内部循环不满足条件时才会继续执行外部循环
for 循环
# for 循环
# 在Python中for循环可以遍历任何序列的项目， 比如一个列表或者以个字符等
# for循环的格式
# for 临时变量 in 列表或者字符等：
# 循环满足条件的时候需要执行的代码
# else:
# 执行不满足条件的代码
str_1 = '123456789'
for i in str_1:
if i == '8':
continue
print(i)
else:
print('当字符串里面的所有内容被遍历完之后，条件就不满足了， 就会执行else')
# range 是范围的意思
for i in range(1, 3):
for j in range(1, 3):
for s in range(1, 3):
print(i, j, s)
列表
# 列表 ：中括号
a = 'xiaoming'
list_1 = []
list_2 = list()
list_3 = ['xiaohong', 'lisi']
# 增：往列表里面添加数据
# append 往末尾添加
list_3.append('zhangfei')
print(list_3)
# insert
list_3.insert(0, 'machao')
print(list_3)
b = ['liubei', 'zhaoyun']
list_3.extend(b)
print(list_3)
a = [1, 2, 3, 4, 5, 6, 7, 8]
b = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
for i in a:
b.insert(i, a[i-1])
print(b)
# 根据下标取列表中得元素(注意点：下标是从0开始得)
print(b[2])
print(b[3])
print(b[4])
# 左闭右开，依次取值
print(b[2:4])
print(b[2:6])
print(b[2:8])
['c', 'd', 'e', 'f', 'g', 'h']
# 根据步长依次递增选取
# 下标0， 2， 4， 6， 8
print(b[2:8:2])
# 下标0， 3， 6， 9
print(b[2:8:3])
# 下标0， 4， 8， 12
print(b[2:8:4])
b = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
print(b[-4:])
print(b[:-4])
# 删除remove
b = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
print(b.remove(b[0]))
b.remove(b[0])
print(b)
del b[0]
print(b)
# 删除最后一个值
a = b.pop()
print(a)
b[3][0] = 'zhangfei'
print(b)
a = b.pop(3)
print(a)
# 修改，根据=赋值
b = [['xiaoming', 18, '男'], ['xiao红', 18, '女'], ['李四', 18, '男'], ['张飞', 18, '男']]
c = b[2][0].replace('李四', 'lisi')
print(b)
b = 888
c = 889-1
print(id(b))
print(id(c))
# is == 区别
# 查 index， in， not in
print(len(b))
if '3' in b:
num = b.index('3')
print(num)
for i in b:
print(i)
a = 'qwertyuiasdfgasfsafafsafasfafsafafhjkzxcvbnm'
num = len(a)
print(num)
for j in b:
print(b.index(j))
print(j)
str_1 = b[j]
print(str_1)
b = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', '3']
i = 0
# 长度为9，有9个数据
print(len(b))
while i < len(b):
print(b[i])
i = i + 1
元组
# 元组：不可变得数据类型 小括号
# 当元组里面只有一个值得时候，需要在后面加一个，
a = tuple()
b = (2,)
print(type(a))
print(type(b))
a = (1, 2, 3, 4, 5)
b = list(a)
b[0] = 'g'
c = tuple(b)
print(c)
a = ('a', 'b', 'c', 'd', 'd', 'e', 'e')
print(a.index('b'))
print(a.count('d'))
字典
# 字典:外面是大括号
# 键值对的形式存在
# 什么是键值对 key：value
# c = {'key': 'value'}
a = {'name': 'xiaoming'}
b = dict()
# 添加
a['age'] = 20
print(a)
a = {'name': 'xiaoming', 'age': 20}
a['age'] = 18
print(a)
# 结论：往字典里面添加数据，key值存在，则修改，不存在就创建
c = str_1.split('; ')
print(c)
# 字典推导式
result = {i.split('=')[0]: i.split('=')[1] for i in str_1.split('; ')}
print(result)
a = {}
for i in str_1.split('; '):
i.split('=')
a = 'xiaoming 20 男'
b = a.split(' ')
print(b)
print(str_1.split('; '))
# 字典的删除操作
del a['name']
print(a)
a.clear()
print(a)
for i in a.values():
print(i)
print('*********************************')
for j in a.keys():
print(j)
print(a.items())
for i in a.items():
for j in i:
print(j)
for i in a.keys():
print(i)
a['name'] = 'name' + '1'
print(a)
a = {'name': 'xiaoming', 'age': 20, 'sex': '男', 'number': 0}
in
not in
a = {'name': 'xiaoming', 'age': 20, 'sex': '男', 'number': 0}
for i in a.keys():
if 'name' in i:
print(6666666666)
if 'name' not in i:
print(8888888888)
集合
# 集合, 最外面是大括号
# 特征：去重，集合是无序的，不支持下标(索引)的操作
a = set()
b = {1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 5, 5, 5, 1, 1, 1, 1}
print(b)
# 应用场景：爬虫的url(网址，链接)地址去重
# 添加元素
a.add('xiaoming')
a.add('18')
print(a)
b.remove(6)
print(b)
# 嵌套
a = [[{'name': 'x', 'age': 18, 'sex': '男'}], [{'name': 'y', 'age': 18, 'sex': '男'}], [{'name': 'z', 'age': 18, 'sex': '男'}]]
print(type(a[0]))
# 非常注意的地方集合和字典不能同时存在
a = {{'name': 'xiaoming'}}
print(a)
a = [[{'name': 'x', 'age': 20, 'sex': '男'}, {'name': 'a', 'age': 21, 'sex': '男'}],
[{'name': 'y', 'age': 19, 'sex': '男'}, {'name': 'b', 'age': 22, 'sex': '男'}],
[{'name': 'z', 'age': 18, 'sex': '男'}, {'name': 'c', 'age': 23, 'sex': '男'}]]
print(a[1])
print(a[1][0])
print(a[1][0]['name'])
print(a[2][1]['age'])
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
j = 0
for i in a:
j += i
print(j)
print(sum(a))
运算符公共方法
"""运算符公共方法"""
# + 支持：字符串，列表，元组,不同数据类型不支持相加
a = 'zhang'
b = 'fei'
c = b + a
print(c)
aa = '1'
bb = '2'
cc = aa + bb
print(cc)
#对于数字是加, 对于字符是拼接
a = (1, 2, 3, 4, 5, 6)
b = ['a', 'b', 'c']
print(a + b)
a = {'name': 'xiaoming'}
b = {'age': 18}
print(a + b)
# * 支持：字符串, 列表，元组
a = 2
print(a ** 3)
a = 'qwertyuio'
print(a * 2)
b = [1, 2, 3]
print(b * 2)
c = {1, 2, 3}
print(c * 2)
# in 支持：字符串，元组，列表，字典，集合
a = [1, 2, 3, 4, 5, 8]
if 1 in a:
print(666)
a = {'name': 'xiaoming', 'age': 18}
in 对字典操作
'''注意：in 对字典操作时，默认判断的是字典的key值'''
if {'name': 'xiaoming'} in a:
print(666)
else:
print(888)
a = (1, 2, 3, ('a', 'b', 'c'))
b = ('a', 'b', 'c')
if b in a:
print(666)
else:
print(888)
# 字典和集合不能共存
a = {'key': ({'name': 'xiaoming'}, {'name': 'xiaoming'}), 'keys': {'age': 18}}
b = 'name'
# 并不是判断a字典所有key
if b in a.keys():
print(666)
else:
print(888)
# not in 支持：字符串，元组，列表，字典，集合
a = {1, 2, 3}
b = 3
if b in a:
print(666)
else:
print(888)
a = {{'name': 'xiaoming'}}
print(a)
python内置函数
"""python内置函数"""
# len 统计元素(数据)个数
a = (1, 2, 3, 4, 2)
print(len(a))
# max 返回容器中最大值
a = ['b', 'f', 'e', '2']
b = max(a)
print(b)
# min 返回容器中最小值
a = ['b', 'f', 'e', '2']
b = min(a)
print(b)
# del 删除
# sum 求和
a = [1, 2, 3, 4, 5, 7]
b = sum(a)
print(b)
可变类型与不可变类型
"""引用：可变类型与不可变类型"""
# 改变数据结构，内存地址是否会发生变化
# is 和 == 的区别？
a = 999
b = 1000 - 1
if a is b:
print(666)
if a == b:
print(888)
# is 是判断二者的内存空间知否相同
# == 是判断二者的值是否相等
# 往列表, 字典里面添加数据，是不改变内存空间的，即是可变数据类型
list_1 = [1, 2, 3, 4, 5]
print(id(list_1))
list_1.append('f')
print(id(list_1))
a = {'name': 'xiaoming'}
print(id(a))
a['age'] = 18
print(id(a))
# 不可变类型：字符串，元组:改变其结构，会产生一个新的数据
a = 'xiao'
print(id(a))
print(id(a + 'sdsad'))
b = (1, 2, 3)
c = (1, 2, 3)
print(id(b))
print(id(c))
a = ['xiaomin', '女']
# 不可变数据类型：存储帐号信息，银行卡信息，密码信息，密钥等等
# 可变数据类型：个人信息
三目运算符：三元表达式
"""三目运算符：三元表达式"""
# 返回True执行 if 表达式 else 返回False执行
print('我在你心里' if 3 > 4 else '你不在我心里')
print(i for i in range(10) if i % 2 != 0 )
list_1 = []
for i in range(10):
if i % 2 != 0:
list_1.append(i)
else:
list_1.append('s')
print(list_1)
x = 3
y = 5
# 执行顺序：从左往右执行
print('我比你大' if x > y else '今天天气真好' if x == y else '今天下雨了')
if x>y:
print('我比你大')
else:
if x == y:
print('今天天气真好')
else:
print('今天下雨了')
# 求证的问题：嵌套三目运算符执行顺序
# 从左到右 1 输出我比你大
# 从右到左 2 输出今天下雨
a = 1
b = 2
print('你真棒'if a > b else '很尴尬' if a == b else '哭了' if a < b else '赢了')
if a > b:
print('你真棒')
else:
if a == b:
print('很尴尬')
else:
if a < b:
print('哭了')
else:
print('赢了')
函数
函数的使用
#函数的使用
# 1)函数的定义
# def 函数名(): #函数名命名：字母_数字_下划线且数字不能开头(见名知义)，大_小驼峰法
# 实现独立功能的代码块1
# ...
# 实现独立功能的代码块2
#定义好之后，不调用不会去运行
# 2)函数的调用：直接使用函数名() #方法的调用：通过变量点方法，list_2.append((x, y))
# FoZu() #代码运行跳转到函数定义
函数的返回值
#函数的返回值
def sum_1():
a = 1
b = 2
c = a+b
return c #停止函数运行，return返回函数运行结果(多种数据类型)
# print(sum_1()) #直接打印为None,需要sum_1 = 3
函数的参数
#函数的参数:在定义函数实现功能代码中需要使用的变量
# def 函数名(参数1,参数2,...,参数n):
# 实现独立功能的代码块1
# 使用参数1
# ...
# 使用参数2
# 实现独立功能的代码块2
def sum_2(a, b):
return a+b
print(sum_2(123456787654321,123456787654321))
#参数的性质：形参和实参
def sum_3(a, b): #形参(形式参数)：函数定义时使用的参数叫形参(占位符)
return a+b
print(sum_2(63,12345321)) #实参(实际参数)：调用函数时实际传入的参数
#参数的类型：
#必须(位置)参数：在调用函数时必须使用的参数，与代码块定义的功能(参数位置出错，结果截然不同，甚至报错)
def division(a, b): #division:除法
return a/b
print(division(1,3))
print(division(1, 2))
print(division(2, 1))
print(division(1,0))
print(division(0,2))
#默认参数：在函数定义时给定参数默认值，在调用函数时传入 新参数 就 更新 参数，不传入则使用定义时的默认值(遵循顺序引用参数)
def sum_4(a=1, b=2):
return a+b
# num_1 = 67
num_1 = 23
print(sum_4(4, 5))
print(division())
print(sum_4()) #不传参可直接使用
#只输入单个
print(sum_4(66))
#必须参数和默认参数混用遵循顺序，定义和调用时默认参数在前。
def sun_6(a,b=1):
pass
#关键字参数：在定义时和默认参数类似，以键值对的形式传入，不用去在意参数位置(顺序)
def sum_5(a=1, b=2):
return a+b
print(sum_5(a=3, b=7))
print(sum_5(b=7, a=3)) #关键字参数使用时，带上关键字
#不定长参数：在定义的时候不确定传入参数的个数
def Func(*args, **kwargs): #*代表个数不确定，*args使用元组接收参数，**kwargs:使用字典接收参数
print(args)
print(kwargs)
Func(1, 2, 3, a=4, b=5, c=6) #设计两种接收方式，为了解决多种参数传入
# 函数的类型：根据函数有无参数和返回值判断
# 有参数 有返回值 A
# 无参数 有返回值 B
# 有参数 无返回值 C
# 无参数 无返回值 D
函数的嵌套
#函数的嵌套：函数定义时调用其他函数
def sum_7():
return 2+3
# print(sum_7())
def sum_8(d):
return sum_7()*d
print(sum_8(5))
变量
#变量的作用域:在哪一部分程序可以访问哪个特定的变量
#全局变量：在代码文件中直接定义任何地方都可以引用的变量
# 局部变量:在某个特定的区域才能访问(明前学到：在函数内/在函数外)，定义在函数内的变量只能在函数内访问
def sum_1():
num_1 = 99
print(num_1)
sum_1()
print(num_1)
#全局变量和局部变量重名:重名的局部变量不回去覆盖全局变量，优先使用局部变量(强龙不压地头蛇)
num_2 = 98
def sum_2():
num_2 = 19
print(num_2)
sum_2()
print(num_2)
#global:将局部变量修改为全局变量（蛇想要化龙）
def sum_3(a,b):
global num_2 # 已修改
num_2 = a+b
print(num_2)
sum_3(2,3)
print(num_2)
递归(算法)函数
#递归(算法)函数：函数调用本身函数。(想要理解递归你就先要理解递归)
#一个问题?不断拆解成小问题?解决一个小问题?将整个问题解决
#从前有座山，山里有座庙，庙里有个老和尚在讲故事，讲的故事是什么？
# while True:
# print('从前有座山，山里有座庙，庙里有个老和尚在讲故事，讲的故事是什么？')
#递归函数要求：
#1、必须有明确的结束条件(出口)不然就是一个死循环
#2、每进入一层递归时，问题规模都要比上一次小
#定义计算阶乘的函数 5！ = 5 x 4 x 3 x 2 x 1
def factorial(num):
i = 1
result = 1
while i < num:
i += 1
result *= i
return result
# print(factorial(20))
#定义阶乘的递归函数
def factorial_2 (num):
if num >= 1:
result = num*factorial_2(num-1)
else:
result = 1
return result
# print(factorial_2(5))
# 问题拆解：5！ = 5 x 4 x 3 x 2 x 1
# 结果返回：return result = 1 x 2 x 3 x 4 x 5
#调用函数，num=5，符合num>=1的条件执行下面代码块
#调用阶乘函数，此时参数num = 5-1=4,符合num>=1的条件执行下面代码块
#再次调用阶乘函数，此时参数num = 4-1=3,符合num>=1的条件执行下面代码块
#再次调用阶乘函数，此时参数num = 3-1=2,符合num>=1的条件执行下面代码块
#再次调用阶乘函数，此时参数num = 2-1=1,符合num>=1的条件执行下面代码块
#再次调用阶乘函数，此时参数num = 1-1=0,不合符num>=1的条件执行else下的代码
'''五次函数调用处于同时运行状态'''
#执行return,else将result重置为1，将返回结果给上一层
匿名函数
#匿名函数:在定义函数时不在使用def关键字的形式去定义
def sum_99(a, b):
return a+b
# print(sum_99(4,5))
# print(type(sum_99(2,3)))
#匿名函数名 = lambda 参数1，参数2:功能代码
sum_99_1 = lambda x, y : x+y
# print(sum_99_1(4, 5))
#匿名函数的嵌套
sum_99_99 = lambda num_1:(lambda num_2:num_1+num_2)
#嵌套匿名函数调用
number_1 = sum_99_99(4) #第一层调用
print(type(number_1)) #此时第一次调用的对象也变成了函数，number_1 = lambda 4,num_2:num_1+num_2
print(number_1(5))
def sum_num_1(num1):
def sum_num_2(num2): #函数嵌套的另一种方法，函数体内定义子函数
return num1+num2
return sum_num_2(5)
# print(sum_num_1(4))
sum_99_99 = lambda num_1:(lambda num_2:num_1+num_2)
python的设计思想之一：全面调用计算机功能
#python的设计思想之一：全面调用计算机功能
#文件操作:打开，读取，写入，关闭(为了减少内存资源的浪费)
#打开文件：open(),引号内输入路径
file = open('test.txt','w',encoding='utf8')
#读取：read()
file_str = file.read()
print(file.read())
file = open('test.txt','r',encoding='utf8')
#读取一行：readline
print(file.readline())
#以行的形式读取整个文件并返回列表:realines
print(file.readlines())
#写入：write()
file.write('aaa') #直接写入会覆盖原来的内容
#关闭：close()
file.close()
#open('文件名','访问模式参数','编码格式'):访问模式的权限参数
# r 只读
# w 只写，如果文件不存在就会创建新文件，直接写入会覆盖原文件内容
# a 追加，如果文件不存在就会创建新文件，在文件末尾写入文件?文件指针
# rb/wb/ab(binary system):以二进制的方式对文件进行读取,写入，追加
# r+/w+/a+/rb+/wb+/ab+：将文件指针移动到开头
#文件指针：记录读取和输入的位置
#第一次打开文件，通常文件指针都会指向文件开始的位置
#执行read方法后，文件会移动到读取内容的末尾
file = open('test.txt','r+',encoding='utf8')
print(file.read())
print(file.tell()) #检测当前文件指针所在位置
print('*'*50)
file.seek(10) #更改文件指针位置，0代表最开始
print(file.read())
#文件复制
file = open('test.txt','r',encoding='utf8')
file_str = file.read()
file_1 = open('test1.txt','w',encoding='utf8')
file_1.write(file_str)
file.close()
file_1.close()
异常处理
# 异常处理:python中专门用来处理程序中出现的错误和异常的功能，可以用于程序调试
# 异常：在程序运行是，python解释器遇到错误，停止运行并提示错误信息
# 语法错误：不符合规范
# 运行错误：程序复杂可能出现的错误
# 语义错误：在编程时，将需求转化为代码逻辑出错。运行结果与预料结果不一致
#属性错误(AttributeError)：特性引用和赋值失败时会引发的错误
tuple_1 = (1,2,3)
tuple_1.append('7')
#名称错误(NameError)：试图访问不存在变量
print(a)
#IOError:文件不存在
#关键字错误(KeyError)：使用了映射中不存在的关键字(键名)
dict_1 = {'a':1,'b':2}
print(dict_1['c'])
#值错误(ValueError)：传给对象的参数类型不正确
int('asdfgh')
#索引错误(IndexError)：使用的索引不存在
list_1 = [1,2,3]
print(list_1[99])
#类型错误(TypeError)：函数应用与错误的类型
age = 18
print('我的年龄是' + 18)
# 捕获异常:能够保证程序的稳定性和健壮性(鲁棒性:一个程序的负荷能力)
#单个异常捕捉
# try-except
try:
可能会出现异常的代码
except:
写入自定义提示信息
try:
age = 18
print('我的年龄是' + 18)
except TypeError:
print('此处出现类型错误，在116-117')
print('aaa')
#在编程过程中，无法预判所有的异常
#多种异常捕捉
try:
int('asdfghj')
age = 18
print('我的年龄是' + 18)
except Exception as Error: #给对象重命名,自定义名字(见名知义)
print('这里出现异常，行号位125-127')
try:
int('asdfghj')
age = 18
print('我的年龄是' + 18)
except:
print('这里出现异常，行号位125-127')
# try-except-else-finally
try:
int('asdfghj')
age = 18
print('我的年龄是' + 18)
except Exception as Error: #给对象重命名(见名知义)
print('这里出现异常，行号位125-127')
else:
print('没有异常我才打印')
finally:
print('不管上面有没有异常我都运行')
#异常的传递性：当函数/方法执行时出现异常，会将该异常传递给调用的一方
def sum_1():
return 3/0
def sum_2():
return 5*sum_1()
sum_2()
#自定义异常抛出：raise
#要求用户输入密码，密码规则：长度必须大于六位(长度小于六位就抛出异常)
def u_i_p():
pwd = input('请输入不小于六位数的密码：')
if len(pwd) >=6:
return '密码输入符合规范'
ex = Exception('密码长度不够六位') #自定义异常
raise ex #自定义异常抛出
try:
print(u_i_p())
except Exception as Error:
print('发现错误：%s' % Error)
u_pwd = u_i_p()
#with open：保证代码是否有调用关闭代码它都会调用.close()
#try-finally：很繁琐
try:
f = open('test1.txt','r')
print(f.read())
finally:
print(1)
f.close()
f.read()
with open('test1.txt','r') as f:
print(f.read())
print(f.read())
面向对象编程
#面向对象编程
#面向过程编程：在解决问题时，先分析出解决问题的步骤，再使用函数一步一步把步骤实现，最后依次调用函数
#面向过程有两个特点：过程化和模块化
#将需求分为两步
def print_1():
print('面向过程第一步')
def print_2():
print('面向过程第二步')
print_1()
print_2()
#面向对象编程：就是把面向过程编程进行一个封装(将函数封装成类)
#面向对象编程思维再解决问题时，会将问题拆分成一个一个对象，根据对象的职责来定义方法
#面向对象的三大特点时封装、继承、多态
class Print:
def print_1(self):
print('面向对象的方法一')
def print_2(self):
print('面向过程的方法二')
print_ = Print() #创建对象
print_.print_1() #调用方法
a = ['asdfg'] #创建对象
a.sort() #调用方法
#要想学好面向对象编程：
# 了解类和对象的概念
#类：类是一群具有相同特征或者行为的事物的统称，是抽象的，无法直接使用 ?制造小车的图纸(有各种数据和制造方法)
#对象：由类创建出来的实物，由对象创建的类拥有类的特征和行为 ?小车
#特征：属性
#行为：方法
#定义类：
#1、类名：大驼峰命名法
#2、类的具体属性
#3、类的具体方法
# class 类名:
#
# def 函数名(self):
# pass #具体功能代码
class Car: #定义类
car_brand = 'Benz' #定义属性
def move(self): #方法
print('一脚油门飙到两百码')
def toot(self): #方法
print('车在鸣笛')
# 创建对象
benz = Car()
benz.move()
#函数和方法的区别：
#定义：定义的函数属于整个文件(顶格)，在类中定义的函数叫方法属于这个类
#调用：函数调用直接使用函数名()，方法的调用对象名.方法名()
#__init__和self:
#__方法名__ 属于内置方法
#__init__ 初始化对象，对象被创建时胡自动调用
#self指实例对象本身，这个参数不需要输入(区分函数和方法的标识之一)
class Car_: #定义类
color = 'pink' #定义类属性
def __init__(self, brand):
self.car_brand = brand #定义实例属性
def move(self): #方法
# car_brand = 'Ferrari' 定义变量
print('我的{}一脚油门飙到两百码'.format(self.car_brand))
def toot(self): #方法
print('车在鸣笛')
ferrari = Car_()
banz = Car_('Banz')
banz.move() #调用方法
#访问属性
print('我的奔驰颜色是{}'.format(banz.color))
#修改属性
banz.color = 'red'
print(banz.color)
#添加属性
banz.wheelnum = 4
print(banz.wheelnum)
#python的模块、包、库
#模块：.py文件
#包：包含__init__.py文件的文件夹
#库：具有相关功能模块的集合，
class ob:
def o(self):
print('过年前找到对象')
属性与方法相关概念
#属性与方法相关概念
#类属性和实例属性
#属于类的属性(类变量)，在类中直接创建
#实例属性：属于实例对象本身，通过self.属性名创建
class Car_: #定义类
color = 'pink' #定义类属性
def __init__(self, brand):
self.car_brand = brand #定义实例属性
def move(self): #方法
# car_brand = 'Ferrari' 定义变量
print('我的{}一脚油门飙到两百码'.format(self.car_brand))
def toot(self): #方法
print('车在鸣笛')
ferrari = Car_("Ferrar911")
print(Car_.color) #通过类名去访问类属性
print(Car_.car_brand) #通过类名无法去访问实例属性，实例属性属于实例对象本身 X
print(ferrari.car_brand) #通过对象名去访问实例属性
print(ferrari.color) #通过对象名去访问类属性
#私有属性和私有方法：
#私有属性是为了保护属性的安全性 ? tuple
#属性修改：直接修改与间接修改
class Person_:
age = 18
def person_info(self, name, age, gender):
print('姓名：{}\n年龄：{}岁\n性别：{}\n'.format(name, age, gender))
qingshan = Person_()
print(qingshan.age)
qingshan.age = 17 #直接修改
print(qingshan.age)
qingshan.person_info('青山', '18', '男') #间接修改
qingshan.person_info('青山', '28', '男')
print(qingshan.age)
#如果类中属性不想让外部修改，可以将属性定义为私有
#定义私有：在标识符前加入__
class Person_girlfriend:
def __init__(self, age, weight):
self.__age = age #私有属性定义
self.__girlfriend_weight = weight #私有属性定义
age_True = 28
def __weight(self): #定义私有方法
print('体重：{}'.format(self.__girlfriend_weight))
def girlfriend(self): #定义公有方法去访问私有属性和方法
self.__weight()
print(self.__age) #访问私有属性
xiaofang = Person_girlfriend(18, 79)
print(xiaofang.__age) #私有属性无法访问
xiaofang.__weight() #私有方法无法调用
xiaofang.girlfriend() #定义公有方法去访问私有属性和方法
#魔法方法:__方法名__ 属于内置方法(一些特定的方法：进行特定操作且自动调用)
#__init__方法 每创建一个实例对象之后就将实例对象初始化，不是类的构造函数
class Car: #定义类
def __init__(self, brand,color): #给实例对象进行初始化
self.car_brand = brand #
self.color = color
banz = Car_('Banz')
#__del__方法 在内存中销毁实例对象,会自动调用
class Person_del:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
def person_info(self):
print('姓名：{}\n年龄：{}岁\n性别：{}\n'.format(self.name, self.age, self.gender))
def __del__(self):
print('对象已销毁。。。。')
qingshan = Person_del('青山', 18, '男')
qingshan.person_info()
qingshan
import gc #真正释放内存
a = 1
del a
gc.collect()
#__str__方法 返回对象的描述信息，需要print()函数进行输出，需要写入return
class Person_str:
def __init__(self, name):
self.name = name
def __str__(self):
return '我是Person_str类的实例对象，我的名字叫{}'.format(self.name)
qingshan = Person_str('青山')
print(qingshan)
#__new__方法 类的构造函数，创建对象是会被自动调用，__init__的调用在__new__,一般情况不重写它
#必须要传递一个参数cls
#self:实例对象本身
#cls:类的本身
#创建对象的流程：
# 1、先调用__new__得到一个对象
# 2、再调用__init__方法给对象添加实例属性
# 3、将这个对象赋值给变量名
#单例设计模式：只有一个实例对象(一个全局使用的类频繁的创建与销毁)
#什么时候去用：控制实例数目，节省系统资源
class Person_new():
count_1 = None
def __new__(cls, *args, **kwargs):
if cls.count_1 is None:
cls.count_1 = super().__new__(cls)
return cls.count_1
def __init__(self):
self.age = 18
qingshan = Person_new()
xiaofang = Person_new()
print(id(qingshan))
print(id(xiaofang))
# 面向对象：面向过程
# 封装：类，对象，属性，方法
# 继承：单继承，多继承
# 作业：创建一个汽车类：属性：轮胎个数，颜色，重量，油箱最大容量
# 方法：加油，加速
# 创建法拉利的类：继承自汽车，对于方法需要重写：加油有最大油量，加速
class Auto(object):
# 上天，下水
def __init__(self, color, weight, fuel_capacity=0, tire=4):
self.color = color
self.weight = weight
self.fuel_capacity = fuel_capacity
self.tire = tire
def add_fule(self, value):
self.fuel_capacity += value
if self.fuel_capacity >=200:
self.fuel_capacity = 200
print('已经加满了')
def add_speed(self, values):
print(f'普通车辆百公里加速{values}秒')
class Ferrari(Auto):
#不建议重写__init__方法，可以通过实例对象再添加实例属性
def __init__(self):
super(Ferrari, self).__init__(color='pink', weight=200, fuel_capacity=50, tire=4)
def add_fule(self, value):
self.fuel_capacity += value
if self.fuel_capacity < 120:
print('emmm,没喝饱')
elif self.fuel_capacity == 120:
print('嗝~~！刚刚好')
else:
self.fuel_capacity = 120
print('人家喝饱了Σ(っ °Д °;)っ')
def add_speed(self):
print('我加速百公里只需要5秒')
# LSP原则 面向对象的基本设计原则：继承只注重于步骤重写
ferrari911 = Ferrari()
s.add_fule(30) #fule=50,80
s.add_fule(40) #120
# 多态
# 面向对象编程三大特性
# 封装：更具职责讲属性和方法封装到一个抽象类之中
# 继承：实现代码复用，不需要去重复编写且能够拓展
# 多态：不同的子类对象调用相同的父类方法，产生不同的执行结果(能够增加代码灵活度，多态依赖于继承)
# 多态的特点：只关心对象的实例方法是否同名，多态是调用技巧，不会影响类的内部设计
# 人 类，自己
class Person(object):
def __init__(self, age):
self.age = age
def eat(self):
print('是个人就得干饭')
def sleep(self):
print('是个人也得睡觉休息')
class Son:
def eat(self):
print('作为子女，老老实实按时吃饭')
def sleep(self):
print('老老实实早睡早起')
class Soul_Mate:
def eat(self):
print('和异性伴侣吃饭，比较浪漫')
def sleep(self):
print('美滋滋的去儒家')
class Friend:
def eat(self):
print('和朋友去干饭，得拿盆')
def sleep(self):
print('睡什么睡，起来嗨，我石头你亚索')
def sleep(obj):
obj.sleep()
role_1 = Son()
sleep(role_1)
role_2 = Soul_Mate()
sleep(role_2)
role_3 = Friend()
sleep(role_3)
# 类也是个对象
# 类方法和静态方法
# 类方法：对类本身进行操作的方法，需要用到装饰器，类方法的第一个参数是cls
# 假设有个方法，这个方法再逻辑上采用类本身作为对象来调用更加合理
class Class_Method():
def __init__(self):
pass
@classmethod
def info(cls):
print('正在调用类方法')
def info_(self):
pass
Class_Method.info()
s = Class_Method()
s.info()
# 静态方法(可以当成一个函数来理解)：不需要访问实例属性和调用实例方法，也不用访问类属性和调用类方法(和__str__用处相似)
# 静态方法用来存放逻辑性代码，再逻辑上属于类，实际上和类本身没有关系
#
class Static_Method(object):
@staticmethod
def info():
print('正在调用静态方法')
Static_Method.info()
s = Static_Method()
s.info()
# try-with open
def readFile(filename):
try:
with open(filename, 'r', encoding='utf8') as f:
print(f.readlines())
except:
print('你有问题')
readFile('test.txt')
祝大家学习python顺利！！
原文：https://blog.csdn.net/weixin_54733110/article/details/118057219
声明：本文系转载文章，仅供学习交流使用，侵权请联系删除
